VTK
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  }
61  {
62  Time = src.Time;
63  ObjectType = src.ObjectType;
64  ObjectId = src.ObjectId;
65  ArrayId = src.ArrayId;
66  return *this;
67  }
68  bool match(const vtkExodusIICacheKey& other, const vtkExodusIICacheKey& pattern) const
69  {
70  if (pattern.Time && this->Time != other.Time)
71  return false;
72  if (pattern.ObjectType && this->ObjectType != other.ObjectType)
73  return false;
74  if (pattern.ObjectId && this->ObjectId != other.ObjectId)
75  return false;
76  if (pattern.ArrayId && this->ArrayId != other.ArrayId)
77  return false;
78  return true;
79  }
80  bool operator<(const vtkExodusIICacheKey& other) const
81  {
82  if (this->Time < other.Time)
83  return true;
84  else if (this->Time > other.Time)
85  return false;
86  if (this->ObjectType < other.ObjectType)
87  return true;
88  else if (this->ObjectType > other.ObjectType)
89  return false;
90  if (this->ObjectId < other.ObjectId)
91  return true;
92  else if (this->ObjectId > other.ObjectId)
93  return false;
94  if (this->ArrayId < other.ArrayId)
95  return true;
96  return false;
97  }
98 };
99 
101 class vtkExodusIICache;
103 
104 typedef std::map<vtkExodusIICacheKey, vtkExodusIICacheEntry*> vtkExodusIICacheSet;
105 typedef std::map<vtkExodusIICacheKey, vtkExodusIICacheEntry*>::iterator vtkExodusIICacheRef;
106 typedef std::list<vtkExodusIICacheRef> vtkExodusIICacheLRU;
107 typedef std::list<vtkExodusIICacheRef>::iterator vtkExodusIICacheLRURef;
108 
109 class VTKIOEXODUS_EXPORT vtkExodusIICacheEntry
110 {
111 public:
115 
117 
118  vtkDataArray* GetValue() { return this->Value; }
119 
120 protected:
123 
124  friend class vtkExodusIICache;
125 };
126 
127 class VTKIOEXODUS_EXPORT vtkExodusIICache : public vtkObject
128 {
129 public:
130  static vtkExodusIICache* New();
131  vtkTypeMacro(vtkExodusIICache, vtkObject);
132  void PrintSelf(ostream& os, vtkIndent indent) override;
133 
135  void Clear();
136 
139  void SetCacheCapacity(double sizeInMiB);
140 
145  double GetSpaceLeft() { return this->Capacity - this->Size; }
146 
150  int ReduceToSize(double newSize);
151 
153  void Insert(vtkExodusIICacheKey& key, vtkDataArray* value);
154 
158  vtkDataArray*& Find(const vtkExodusIICacheKey&);
159 
164  int Invalidate(const vtkExodusIICacheKey& key);
165 
175  int Invalidate(const vtkExodusIICacheKey& key, const vtkExodusIICacheKey& pattern);
176 
177 protected:
180 
182  ~vtkExodusIICache() override;
183 
185  void RecomputeSize();
186 
188  double Capacity;
189 
192  double Size;
193 
201 
204 
205 private:
206  vtkExodusIICache(const vtkExodusIICache&) = delete;
207  void operator=(const vtkExodusIICache&) = delete;
208 };
209 #endif // vtkExodusIICache_h
vtkExodusIICacheEntry::Value
vtkDataArray * Value
Definition: vtkExodusIICache.h:121
vtkExodusIICacheKey::operator<
bool operator<(const vtkExodusIICacheKey &other) const
Definition: vtkExodusIICache.h:80
vtkExodusIICacheEntry::LRUEntry
vtkExodusIICacheLRURef LRUEntry
Definition: vtkExodusIICache.h:122
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:68
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:53
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
vtkExodusIICacheRef
std::map< vtkExodusIICacheKey, vtkExodusIICacheEntry * >::iterator vtkExodusIICacheRef
Definition: vtkExodusIICache.h:105
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:106
vtkExodusIICacheLRURef
std::list< vtkExodusIICacheRef >::iterator vtkExodusIICacheLRURef
Definition: vtkExodusIICache.h:107
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkExodusIICacheSet
std::map< vtkExodusIICacheKey, vtkExodusIICacheEntry * > vtkExodusIICacheSet
Definition: vtkExodusIICache.h:102
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:118
vtkObject.h
vtkExodusIICache::GetSpaceLeft
double GetSpaceLeft()
See how much cache space is left.
Definition: vtkExodusIICache.h:145
vtkExodusIICache::Capacity
double Capacity
The capacity of the cache (i.e., the maximum size of all arrays it contains) in MiB.
Definition: vtkExodusIICache.h:188
vtkExodusIICache::Cache
vtkExodusIICacheSet Cache
A least-recently-used (LRU) cache to hold arrays.
Definition: vtkExodusIICache.h:200
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:192
vtkExodusIICacheKey::operator=
vtkExodusIICacheKey & operator=(const vtkExodusIICacheKey &src)
Definition: vtkExodusIICache.h:60
vtkExodusIICacheEntry
Definition: vtkExodusIICache.h:109
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:203
vtkExodusIICache
Definition: vtkExodusIICache.h:127