UniqueIOCachingAlgorithm.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "UniqueIOCachingAlgorithm.h"
 
#include <algorithm>
#include <iostream>
 
#include <QList>
#include <QQueue>
 
#include "IException.h"
#include "IString.h"
#include "RawCubeChunk.h"
 
namespace Isis {
  UniqueIOCachingAlgorithm::UniqueIOCachingAlgorithm(int numUniqueIOs) {
    m_uniqueIOs = NULL;
    m_uniqueIOs = new QQueue < QList <RawCubeChunk *> >;
 
    if (numUniqueIOs <= 0) {
      IString msg = "At least one unique IO must be used when using the unique "
          "IO cube caching algorithm";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    while (m_uniqueIOs->size() < numUniqueIOs)
      m_uniqueIOs->enqueue( QList<RawCubeChunk *>() );
  }
  UniqueIOCachingAlgorithm::UniqueIOCachingAlgorithm(int numUniqueIOs) {…}
 

  UniqueIOCachingAlgorithm::~UniqueIOCachingAlgorithm() {
    if (m_uniqueIOs) {
      delete m_uniqueIOs;
      m_uniqueIOs = NULL;
    }
  }
  UniqueIOCachingAlgorithm::~UniqueIOCachingAlgorithm() {…}
 

  CubeCachingAlgorithm::CacheResult
      UniqueIOCachingAlgorithm::recommendChunksToFree(
      QList <RawCubeChunk *> allocated, QList <RawCubeChunk *> justUsed,
          const Buffer &justRequested) {
    QList <RawCubeChunk *> chunksToToss;
    CacheResult result(chunksToToss);
 
    // This read has different chunks than before...
    if (justUsed.size()) {
      // If any of our unique reads are not yet populated, then populate them
      //   with our current IO.
      bool foundAHome = false;
 
      for (int uniqueIONum = 0;
           !foundAHome && uniqueIONum < m_uniqueIOs->size();
           uniqueIONum++) {
        QList <RawCubeChunk *> &uniqueIO = (*m_uniqueIOs)[uniqueIONum];
 
        if (uniqueIO.empty()) {
          foundAHome = true;
          uniqueIO = justUsed;
        }
        else if (uniqueIO == justUsed) {
          foundAHome = true;
          m_uniqueIOs->enqueue(m_uniqueIOs->takeAt(uniqueIONum));
        }
      }
 
      if (!foundAHome) {
        m_uniqueIOs->enqueue(justUsed);
        m_uniqueIOs->dequeue();
      }
 
      // We don't know if Cube tossed any of the chunks, so we really need to
      //   look in the allocated list for things to toss.
      QListIterator <RawCubeChunk *> allocatedIterator(allocated);
 
      while (allocatedIterator.hasNext()) {
        RawCubeChunk *chunk = allocatedIterator.next();
 
        bool found = false;
 
        foreach (QList <RawCubeChunk *> chunksForIo, *m_uniqueIOs) {
          if (!found)
            found = chunksForIo.indexOf(chunk) != -1;
        }
 
        if (!found) {
          chunksToToss.append(chunk);
        }
      }
 
      result = CacheResult(chunksToToss);
    }
 
    return result;
  }
      UniqueIOCachingAlgorithm::recommendChunksToFree( {…}
}