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;
102 class vtkDataArray;
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:
132  void PrintSelf( ostream& os, vtkIndent indent );
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 
154 
159 
165 
176 
177 protected:
180 
183 
184 
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
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
vtkExodusIICacheEntry(vtkDataArray *arr)
vtkDataArray * GetValue()
vtkExodusIICacheLRURef LRUEntry
vtkExodusIICacheEntry(const vtkExodusIICacheEntry &other)
bool match(const vtkExodusIICacheKey &other, const vtkExodusIICacheKey &pattern) const
vtkExodusIICacheKey(int time, int objType, int objId, int arrId)
vtkExodusIICacheKey(const vtkExodusIICacheKey &src)
void Clear()
Empty the cache.
void SetCacheCapacity(double sizeInMiB)
Set the maximum allowable cache size. This will remove cache entries if the capacity is reduced below...
vtkExodusIICacheLRU LRU
The actual LRU list (indices into the cache ordered least to most recently used).
double Size
The current size of the cache (i.e., the size of the all the arrays it currently contains) in MiB.
vtkExodusIICache()
Default constructor.
double Capacity
The capacity of the cache (i.e., the maximum size of all arrays it contains) in MiB.
~vtkExodusIICache()
Destructor.
int ReduceToSize(double newSize)
Remove cache entries until the size of the cache is at or below the given size.
static vtkExodusIICache * New()
void PrintSelf(ostream &os, vtkIndent indent)
Methods invoked by print to print information about the object including superclasses.
void RecomputeSize()
Avoid (some) FP problems.
double GetSpaceLeft()
See how much cache space is left.
int Invalidate(vtkExodusIICacheKey key, vtkExodusIICacheKey pattern)
Invalidate all cache entries matching a specified pattern, dropping all matches from the cache.
void Insert(vtkExodusIICacheKey &key, vtkDataArray *value)
Insert an entry into the cache (this can remove other cache entries to make space).
int Invalidate(vtkExodusIICacheKey key)
Invalidate a cache entry (drop it from the cache) if the key exists.
vtkExodusIICacheSet Cache
A least-recently-used (LRU) cache to hold arrays.
vtkDataArray *& Find(vtkExodusIICacheKey)
Determine whether a cache entry exists.
a simple class to control print indentation
Definition: vtkIndent.h:40
abstract base class for most VTK objects
Definition: vtkObject.h:60
@ key
Definition: vtkX3D.h:257
@ value
Definition: vtkX3D.h:220
@ time
Definition: vtkX3D.h:497
std::list< vtkExodusIICacheRef > vtkExodusIICacheLRU
std::map< vtkExodusIICacheKey, vtkExodusIICacheEntry * > vtkExodusIICacheSet
std::map< vtkExodusIICacheKey, vtkExodusIICacheEntry * >::iterator vtkExodusIICacheRef
std::list< vtkExodusIICacheRef >::iterator vtkExodusIICacheLRURef
VTKCOMMONCORE_EXPORT bool operator<(const vtkUnicodeString &lhs, const vtkUnicodeString &rhs)