UniqueIOCachingAlgorithm.cpp

Go to the documentation of this file.

#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() {
    if (m_uniqueIOs) {
      delete m_uniqueIOs;
      m_uniqueIOs = NULL;
    }
  }


  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;
  }
}