vtkExodusIICache.h

Go to the documentation of this file.

#ifndef vtkExodusIICache_h
#define vtkExodusIICache_h
 
// ============================================================================
// The following classes define an LRU cache for data arrays
// loaded by the Exodus reader. Here's how they work:
//
// The actual cache consists of two STL containers: a set of
// cache entries (vtkExodusIICacheEntry) and a list of
// cache references (vtkExodusIICacheRef). The entries in
// these containers are sorted for fast retrieval:
// 1. The cache entries are indexed by the timestep, the
//    object type (edge block, face set, ...), and the
//    object ID (if one exists). When you call Find() to
//    retrieve a cache entry, you provide a key containing
//    this information and the array is returned if it exists.
// 2. The list of cache references are stored in "least-recently-used"
//    order. The least recently referenced array is the first in
//    the list. Whenever you request an entry with Find(), it is
//    moved to the back of the list if it exists.
// This makes retrieving arrays O(n log n) and popping LRU
// entries O(1). Each cache entry stores an iterator into
// the list of references so that it can be located quickly for
// removal.
 
#include "vtkIOExodusModule.h" // For export macro
#include "vtkObject.h"
 
#include <list> // use for LRU ordering
#include <map>  // used for cache storage
 
class VTKIOEXODUS_EXPORT vtkExodusIICacheKey
{
public:
  int Time;
  int ObjectType;
  int ObjectId;
  int ArrayId;
  vtkExodusIICacheKey()
  {
    Time = -1;
    ObjectType = -1;
    ObjectId = -1;
    ArrayId = -1;
  }
  vtkExodusIICacheKey(int time, int objType, int objId, int arrId)
  {
    Time = time;
    ObjectType = objType;
    ObjectId = objId;
    ArrayId = arrId;
  }
  vtkExodusIICacheKey(const vtkExodusIICacheKey& src)
  {
    Time = src.Time;
    ObjectType = src.ObjectType;
    ObjectId = src.ObjectId;
    ArrayId = src.ArrayId;
  }
  vtkExodusIICacheKey& operator=(const vtkExodusIICacheKey& src)
  {
    Time = src.Time;
    ObjectType = src.ObjectType;
    ObjectId = src.ObjectId;
    ArrayId = src.ArrayId;
    return *this;
  }
  bool match(const vtkExodusIICacheKey& other, const vtkExodusIICacheKey& pattern) const
  {
    if (pattern.Time && this->Time != other.Time)
      return false;
    if (pattern.ObjectType && this->ObjectType != other.ObjectType)
      return false;
    if (pattern.ObjectId && this->ObjectId != other.ObjectId)
      return false;
    if (pattern.ArrayId && this->ArrayId != other.ArrayId)
      return false;
    return true;
  }
  bool operator<(const vtkExodusIICacheKey& other) const
  {
    if (this->Time < other.Time)
      return true;
    else if (this->Time > other.Time)
      return false;
    if (this->ObjectType < other.ObjectType)
      return true;
    else if (this->ObjectType > other.ObjectType)
      return false;
    if (this->ObjectId < other.ObjectId)
      return true;
    else if (this->ObjectId > other.ObjectId)
      return false;
    if (this->ArrayId < other.ArrayId)
      return true;
    return false;
  }
};
 
class vtkExodusIICacheEntry;
class vtkExodusIICache;
class vtkDataArray;
 
typedef std::map<vtkExodusIICacheKey, vtkExodusIICacheEntry*> vtkExodusIICacheSet;
typedef std::map<vtkExodusIICacheKey, vtkExodusIICacheEntry*>::iterator vtkExodusIICacheRef;
typedef std::list<vtkExodusIICacheRef> vtkExodusIICacheLRU;
typedef std::list<vtkExodusIICacheRef>::iterator vtkExodusIICacheLRURef;
 
class VTKIOEXODUS_EXPORT vtkExodusIICacheEntry
{
public:
  vtkExodusIICacheEntry();
  vtkExodusIICacheEntry(vtkDataArray* arr);
  vtkExodusIICacheEntry(const vtkExodusIICacheEntry& other);
 
  ~vtkExodusIICacheEntry();
 
  vtkDataArray* GetValue() { return this->Value; }
 
protected:
  vtkDataArray* Value;
  vtkExodusIICacheLRURef LRUEntry;
 
  friend class vtkExodusIICache;
};
 
class VTKIOEXODUS_EXPORT vtkExodusIICache : public vtkObject
{
public:
  static vtkExodusIICache* New();
  vtkTypeMacro(vtkExodusIICache, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Clear();
 
  void SetCacheCapacity(double sizeInMiB);
 
  double GetSpaceLeft() { return this->Capacity - this->Size; }
 
  int ReduceToSize(double newSize);
 
  void Insert(vtkExodusIICacheKey& key, vtkDataArray* value);
 
  vtkDataArray*& Find(const vtkExodusIICacheKey&);
 
  int Invalidate(const vtkExodusIICacheKey& key);
 
  int Invalidate(const vtkExodusIICacheKey& key, const vtkExodusIICacheKey& pattern);
 
protected:
  vtkExodusIICache();
 
  ~vtkExodusIICache() override;
 
  void RecomputeSize();
 
  double Capacity;
 
  double Size;
 
  vtkExodusIICacheSet Cache;
 
  vtkExodusIICacheLRU LRU;
 
private:
  vtkExodusIICache(const vtkExodusIICache&) = delete;
  void operator=(const vtkExodusIICache&) = delete;
};
#endif // vtkExodusIICache_h