VTK  9.0.20200924
vtkExodusIICache.h
Go to the documentation of this file.
1 #ifndef vtkExodusIICache_h
2 #define vtkExodusIICache_h
3 
4 // ============================================================================
5 // The following classes define an LRU cache for data arrays
6 // loaded by the Exodus reader. Here's how they work:
7 //
8 // The actual cache consists of two STL containers: a set of
9 // cache entries (vtkExodusIICacheEntry) and a list of
10 // cache references (vtkExodusIICacheRef). The entries in
11 // these containers are sorted for fast retrieval:
12 // 1. The cache entries are indexed by the timestep, the
13 // object type (edge block, face set, ...), and the
14 // object ID (if one exists). When you call Find() to
15 // retrieve a cache entry, you provide a key containing
16 // this information and the array is returned if it exists.
17 // 2. The list of cache references are stored in "least-recently-used"
18 // order. The least recently referenced array is the first in
19 // the list. Whenever you request an entry with Find(), it is
20 // moved to the back of the list if it exists.
21 // This makes retrieving arrays O(n log n) and popping LRU
22 // entries O(1). Each cache entry stores an iterator into
23 // the list of references so that it can be located quickly for
24 // removal.
25 
26 #include "vtkIOExodusModule.h" // For export macro
27 #include "vtkObject.h"
28 
29 #include <list> // use for LRU ordering
30 #include <map> // used for cache storage
31 
32 class VTKIOEXODUS_EXPORT vtkExodusIICacheKey
33 {
34 public:
35  int Time;
37  int ObjectId;
38  int ArrayId;
40  {
41  Time = -1;
42  ObjectType = -1;
43  ObjectId = -1;
44  ArrayId = -1;
45  }
46  vtkExodusIICacheKey(int time, int objType, int objId, int arrId)
47  {
48  Time = time;
49  ObjectType = objType;
50  ObjectId = objId;
51  ArrayId = arrId;
52  }
54  {
55  Time = src.Time;
56  ObjectType = src.ObjectType;
57  ObjectId = src.ObjectId;
58  ArrayId = src.ArrayId;
59  }
60  vtkExodusIICacheKey& operator=(const vtkExodusIICacheKey& src) = default;
61  bool match(const vtkExodusIICacheKey& other, const vtkExodusIICacheKey& pattern) const
62  {
63  if (pattern.Time && this->Time != other.Time)
64  return false;
65  if (pattern.ObjectType && this->ObjectType != other.ObjectType)
66  return false;
67  if (pattern.ObjectId && this->ObjectId != other.ObjectId)
68  return false;
69  if (pattern.ArrayId && this->ArrayId != other.ArrayId)
70  return false;
71  return true;
72  }
73  bool operator<(const vtkExodusIICacheKey& other) const
74  {
75  if (this->Time < other.Time)
76  return true;
77  else if (this->Time > other.Time)
78  return false;
79  if (this->ObjectType < other.ObjectType)
80  return true;
81  else if (this->ObjectType > other.ObjectType)
82  return false;
83  if (this->ObjectId < other.ObjectId)
84  return true;
85  else if (this->ObjectId > other.ObjectId)
86  return false;
87  if (this->ArrayId < other.ArrayId)
88  return true;
89  return false;
90  }
91 };
92 
94 class vtkExodusIICache;
96 
97 typedef std::map<vtkExodusIICacheKey, vtkExodusIICacheEntry*> vtkExodusIICacheSet;
98 typedef std::map<vtkExodusIICacheKey, vtkExodusIICacheEntry*>::iterator vtkExodusIICacheRef;
99 typedef std::list<vtkExodusIICacheRef> vtkExodusIICacheLRU;
100 typedef std::list<vtkExodusIICacheRef>::iterator vtkExodusIICacheLRURef;
101 
102 class VTKIOEXODUS_EXPORT vtkExodusIICacheEntry
103 {
104 public:
108 
110 
111  vtkDataArray* GetValue() { return this->Value; }
112 
113 protected:
116 
117  friend class vtkExodusIICache;
118 };
119 
120 class VTKIOEXODUS_EXPORT vtkExodusIICache : public vtkObject
121 {
122 public:
123  static vtkExodusIICache* New();
124  vtkTypeMacro(vtkExodusIICache, vtkObject);
125  void PrintSelf(ostream& os, vtkIndent indent) override;
126 
128  void Clear();
129 
132  void SetCacheCapacity(double sizeInMiB);
133 
138  double GetSpaceLeft() { return this->Capacity - this->Size; }
139 
143  int ReduceToSize(double newSize);
144 
146  void Insert(vtkExodusIICacheKey& key, vtkDataArray* value);
147 
151  vtkDataArray*& Find(const vtkExodusIICacheKey&);
152 
157  int Invalidate(const vtkExodusIICacheKey& key);
158 
168  int Invalidate(const vtkExodusIICacheKey& key, const vtkExodusIICacheKey& pattern);
169 
170 protected:
173 
175  ~vtkExodusIICache() override;
176 
178  void RecomputeSize();
179 
181  double Capacity;
182 
185  double Size;
186 
194 
197 
198 private:
199  vtkExodusIICache(const vtkExodusIICache&) = delete;
200  void operator=(const vtkExodusIICache&) = delete;
201 };
202 #endif // vtkExodusIICache_h
vtkExodusIICacheEntry::Value
vtkDataArray * Value
Definition: vtkExodusIICache.h:114
vtkExodusIICacheKey::operator<
bool operator<(const vtkExodusIICacheKey &other) const
Definition: vtkExodusIICache.h:73
vtkExodusIICacheEntry::LRUEntry
vtkExodusIICacheLRURef LRUEntry
Definition: vtkExodusIICache.h:115
vtkX3D::value
Definition: vtkX3D.h:226
vtkExodusIICacheKey::ObjectId
int ObjectId
Definition: vtkExodusIICache.h:37
vtkObject::New
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on.
vtkX3D::key
Definition: vtkX3D.h:263
vtkExodusIICacheKey::Time
int Time
Definition: vtkExodusIICache.h:35
vtkExodusIICacheKey::ArrayId
int ArrayId
Definition: vtkExodusIICache.h:38
vtkExodusIICacheKey::match
bool match(const vtkExodusIICacheKey &other, const vtkExodusIICacheKey &pattern) const
Definition: vtkExodusIICache.h:61
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:62
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
vtkExodusIICacheRef
std::map< vtkExodusIICacheKey, vtkExodusIICacheEntry * >::iterator vtkExodusIICacheRef
Definition: vtkExodusIICache.h:98
vtkX3D::time
Definition: vtkX3D.h:503
vtkExodusIICacheKey::vtkExodusIICacheKey
vtkExodusIICacheKey(const vtkExodusIICacheKey &src)
Definition: vtkExodusIICache.h:53
vtkExodusIICacheKey::vtkExodusIICacheKey
vtkExodusIICacheKey()
Definition: vtkExodusIICache.h:39
vtkExodusIICacheKey
Definition: vtkExodusIICache.h:32
vtkExodusIICacheLRU
std::list< vtkExodusIICacheRef > vtkExodusIICacheLRU
Definition: vtkExodusIICache.h:99
vtkExodusIICacheLRURef
std::list< vtkExodusIICacheRef >::iterator vtkExodusIICacheLRURef
Definition: vtkExodusIICache.h:100
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkExodusIICacheSet
std::map< vtkExodusIICacheKey, vtkExodusIICacheEntry * > vtkExodusIICacheSet
Definition: vtkExodusIICache.h:95
vtkObject::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkExodusIICacheKey::vtkExodusIICacheKey
vtkExodusIICacheKey(int time, int objType, int objId, int arrId)
Definition: vtkExodusIICache.h:46
vtkExodusIICacheEntry::GetValue
vtkDataArray * GetValue()
Definition: vtkExodusIICache.h:111
vtkObject.h
vtkExodusIICache::GetSpaceLeft
double GetSpaceLeft()
See how much cache space is left.
Definition: vtkExodusIICache.h:138
vtkExodusIICache::Capacity
double Capacity
The capacity of the cache (i.e., the maximum size of all arrays it contains) in MiB.
Definition: vtkExodusIICache.h:181
vtkExodusIICache::Cache
vtkExodusIICacheSet Cache
A least-recently-used (LRU) cache to hold arrays.
Definition: vtkExodusIICache.h:193
vtkExodusIICache::Size
double Size
The current size of the cache (i.e., the size of the all the arrays it currently contains) in MiB.
Definition: vtkExodusIICache.h:185
vtkExodusIICacheEntry
Definition: vtkExodusIICache.h:102
vtkExodusIICacheKey::ObjectType
int ObjectType
Definition: vtkExodusIICache.h:36
vtkExodusIICache::LRU
vtkExodusIICacheLRU LRU
The actual LRU list (indices into the cache ordered least to most recently used).
Definition: vtkExodusIICache.h:196
vtkExodusIICache
Definition: vtkExodusIICache.h:120