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 <map> // used for cache storage
30 #include <list> // use for LRU ordering
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 )
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();
132  void PrintSelf( ostream& os, vtkIndent indent ) VTK_OVERRIDE;
133 
135  void Clear();
136 
138  void SetCacheCapacity( double sizeInMiB );
139 
144  double GetSpaceLeft()
145  { return this->Capacity - this->Size; }
146 
150  int ReduceToSize( double newSize );
151 
153  void Insert( vtkExodusIICacheKey& key, vtkDataArray* value );
154 
159 
164  int Invalidate( vtkExodusIICacheKey key );
165 
175  int Invalidate( vtkExodusIICacheKey key, vtkExodusIICacheKey pattern );
176 
177 protected:
180 
182  ~vtkExodusIICache() VTK_OVERRIDE;
183 
184 
186  void RecomputeSize();
187 
189  double Capacity;
190 
192  double Size;
193 
201 
204 
205 private:
206  vtkExodusIICache( const vtkExodusIICache& ) VTK_DELETE_FUNCTION;
207  void operator = ( const vtkExodusIICache& ) VTK_DELETE_FUNCTION;
208 };
209 #endif // vtkExodusIICache_h
std::list< vtkExodusIICacheRef >::iterator vtkExodusIICacheLRURef
abstract base class for most VTK objects
Definition: vtkObject.h:53
std::list< vtkExodusIICacheRef > vtkExodusIICacheLRU
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
double GetSpaceLeft()
See how much cache space is left.
vtkExodusIICacheLRURef LRUEntry
VTKCOMMONCORE_EXPORT bool operator<(const vtkUnicodeString &lhs, const vtkUnicodeString &rhs)
std::map< vtkExodusIICacheKey, vtkExodusIICacheEntry * > vtkExodusIICacheSet
vtkExodusIICacheKey(int time, int objType, int objId, int arrId)
a simple class to control print indentation
Definition: vtkIndent.h:33
bool match(const vtkExodusIICacheKey &other, const vtkExodusIICacheKey &pattern) const
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:48
vtkDataArray * GetValue()
vtkExodusIICacheKey(const vtkExodusIICacheKey &src)
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on...
std::map< vtkExodusIICacheKey, vtkExodusIICacheEntry * >::iterator vtkExodusIICacheRef