dune-alugrid 3.0.0
memory.hh
Go to the documentation of this file.
1#ifndef DUNE_ALU3DGRIDMEMORY_HH
2#define DUNE_ALU3DGRIDMEMORY_HH
3
5#include <cstdlib>
6#include <vector>
7
8#ifdef _OPENMP
9#include <omp.h>
10#endif
11
12#if HAVE_DUNE_FEM
13#include <dune/fem/misc/threads/threadmanager.hh>
14#endif
15
16namespace ALUGrid
17{
18
19 template< class T, int length >
21
23 template <class Object>
25 {
26 enum { maxStackObjects = 256 };
27 typedef ::ALUGrid::ALUGridFiniteStack< Object *, maxStackObjects > StackType;
28
29 // stack to store object pointers
30 StackType objStack_;
31
32 // thread number
33 int thread_;
34
35 // return reference to object stack
36 StackType &objStack () { return objStack_; }
37 public:
38 // type of object to be stored
39 typedef Object ObjectType;
40
41 // return thread number
42 static inline int thread()
43 {
44#ifdef _OPENMP
45 return omp_get_thread_num();
46#elif HAVE_DUNE_FEM
47 return Dune::Fem :: ThreadManager :: thread() ;
48#else
49 return 0;
50#endif
51 }
52
53 // return maximal possible number of threads
54 static inline int maxThreads()
55 {
56#ifdef _OPENMP
57 return omp_get_max_threads();
58#elif HAVE_DUNE_FEM
59 return Dune::Fem :: ThreadManager :: maxThreads() ;
60#else
61 return 1;
62#endif
63 }
64
67 : objStack_(), thread_( -1 )
68 {}
69
72 : objStack_(), thread_( org.thread_ )
73 {}
74
76 void setThreadNumber( const int thread ) { thread_ = thread; }
77
80
82 template <class FactoryType>
83 ObjectType * getObject(const FactoryType &factory, int level);
84
86 template <class FactoryType, class EntityImp>
87 inline ObjectType * getEntityObject(const FactoryType& factory, int level, EntityImp* )
88 {
89 if( objStack().empty() )
90 {
91 return new ObjectType( EntityImp(factory,level) );
92 }
93 else
94 {
95 return stackObject();
96 }
97 }
98
101
103 void freeObject (ObjectType * obj);
104
105 protected:
107 {
108 // make sure we operate on the correct thread
109 alugrid_assert ( thread_ == thread() );
110 // make sure stack is not empty
111 alugrid_assert ( ! objStack().empty() );
112 // finite stack does also return object on pop
113 return objStack().pop();
114 }
115 };
116
117
118 //************************************************************************
119 //
120 // ALUMemoryProviderSingleThread implementation
121 //
122 //************************************************************************
123 template <class Object> template <class FactoryType>
126 getObject( const FactoryType &factory, int level )
127 {
128 if( objStack().empty() )
129 {
130 return ( new Object (factory, level) );
131 }
132 else
133 {
134 return stackObject();
135 }
136 }
137
138 template <class Object>
141 {
142 if( objStack().empty() )
143 {
144 return new Object () ;
145 }
146 else
147 {
148 return stackObject();
149 }
150 }
151
152 template <class Object>
154 {
155 StackType& objStk = objStack();
156 while ( ! objStk.empty() )
157 {
158 ObjectType * obj = objStk.pop();
159 delete obj;
160 }
161 }
162
163 template <class Object>
165 {
166 // make sure we operate on the correct thread
167 alugrid_assert ( thread_ == thread() );
168 StackType& stk = objStack();
169 if( stk.full() )
170 delete obj;
171 else
172 stk.push( obj );
173 }
174
176 template <class Object>
178 {
179 typedef ALUMemoryProviderSingleThread < Object > MemoryProvider ;
180
181 std::vector< MemoryProvider > memProviders_;
182
183 MemoryProvider& memProvider( const unsigned int thread )
184 {
185 alugrid_assert( thread < memProviders_.size() );
186 return memProviders_[ thread ];
187 }
188
189 void init ()
190 {
191 const int threads = maxThreads();
192 for( int thread = 0; thread < threads; ++ thread )
193 {
194 memProviders_[ thread ].setThreadNumber( thread );
195 }
196 }
197
198 public:
199 // return thread number
200 static inline int thread() { return MemoryProvider :: thread(); }
201
202 // return maximal possible number of threads
203 static inline int maxThreads() { return MemoryProvider :: maxThreads(); }
204
205 // type of stored object
206 typedef Object ObjectType;
207
209 ALUMemoryProvider() : memProviders_( maxThreads() )
210 {
211 init();
212 }
213
215 ALUMemoryProvider( const ALUMemoryProvider& org ) : memProviders_( maxThreads() )
216 {
217 init();
218 }
219
221 template <class FactoryType>
222 ObjectType * getObject(const FactoryType &factory, int level)
223 {
224 return memProvider( thread() ).getObject( factory, level );
225 }
226
228 template <class FactoryType, class EntityImp>
229 inline ObjectType * getEntityObject(const FactoryType& factory, int level , EntityImp * fakePtr )
230 {
231 return memProvider( thread() ).getEntityObject( factory, level, fakePtr );
232 }
233
235 ObjectType * getEmptyObject () { return memProvider( thread() ).getEmptyObject(); }
236
238 void freeObject (ObjectType * obj) { memProvider( thread() ).freeObject( obj ); }
239 };
240
241 template <class ObjectImp>
243 {
244 protected:
245 // type of object to be reference counted
246 typedef ObjectImp ObjectType;
247
248 // object (e.g. geometry impl or intersection impl)
250
251 unsigned int& refCount() { return object_.refCount_; }
252 const unsigned int& refCount() const { return object_.refCount_; }
253
254 public:
256 void reset()
257 {
258 // reset reference counter
259 refCount() = 1;
260
261 // reset status of object
262 object_.invalidate();
263 }
264
266 void operator ++ () { ++ refCount(); }
267
269 void operator -- () { alugrid_assert ( refCount() > 0 ); --refCount(); }
270
272 bool operator ! () const { return refCount() == 0; }
273
275 bool unique () const { return refCount() == 1 ; }
276
277 const ObjectType& object() const { return object_; }
278 ObjectType& object() { return object_; }
279 };
280
281 template <class ObjectImp>
283 {
284 protected:
285 typedef ObjectImp ObjectType;
288
290 {
291 static MemoryPoolType pool;
292 return pool;
293 }
294
295 public:
296 // default constructor
298 {
299 /*
300 static bool first = true ;
301 if( first )
302 {
303 std::cout << "Memory object = " << sizeof( ObjectType ) << " "
304 << sizeof( ReferenceCountedObjectType ) << std::endl;
305 first = false;
306 }
307 */
308 getObject();
309 }
310
311 // copy contructor making shallow copy
313 {
314 assign( other );
315 }
316
317 // destructor clearing pointer
319 {
320 removeObject();
321 }
322
324 {
325 ptr_ = memoryPool().getEmptyObject();
326 ptr().reset();
327 }
328
329 void assign( const SharedPointer& other )
330 {
331 // copy pointer
332 ptr_ = other.ptr_;
333
334 // increase reference counter
335 ++ ptr();
336 }
337
339 {
340 // decrease reference counter
341 -- ptr();
342
343 // if reference count is zero free the object
344 if( ! ptr() )
345 {
346 memoryPool().freeObject( ptr_ );
347 }
348
349 // reset pointer
350 ptr_ = nullptr;
351 }
352
354 {
355 // if pointer is unique, invalidate status
356 if( ptr().unique() )
357 {
358 ptr().object().invalidate();
359 }
360 else
361 {
362 // if pointer is used elsewhere remove the pointer
363 // and get new object
364 removeObject();
365 getObject();
366 }
367 }
368
370 {
371 if( ptr_ != other.ptr_ )
372 {
373 removeObject();
374 assign( other );
375 }
376 return *this;
377 }
378
379 operator bool () const { return bool( ptr_ ); }
380
381 bool operator == (const SharedPointer& other ) const { return ptr_ == other.ptr_; }
382
383 bool unique () const { return ptr().unique(); }
384
385 // dereferencing
386 ObjectType& operator* () { return ptr().object(); }
387 const ObjectType& operator* () const { return ptr().object(); }
388
389 protected:
391 const ReferenceCountedObjectType& ptr() const { alugrid_assert( ptr_ ); return *ptr_; }
392
394 };
395
396} // namespace ALUGrid
397
398#endif // #ifndef DUNE_ALU3DGRIDMEMORY_HH
#define alugrid_assert(EX)
Definition alugrid_assert.hh:20
Definition alu3dinclude.hh:50
Definition memory.hh:20
organize the memory management for entitys used by the NeighborIterator
Definition memory.hh:25
static int maxThreads()
Definition memory.hh:54
void setThreadNumber(const int thread)
set thread number this memory provider works for
Definition memory.hh:76
ALUMemoryProviderSingleThread(const ALUMemoryProviderSingleThread &org)
copy constructor
Definition memory.hh:71
Object ObjectType
Definition memory.hh:39
void freeObject(ObjectType *obj)
free, move element to stack, returns NULL
Definition memory.hh:164
ObjectType * getEmptyObject()
return object, if created default constructor is used
Definition memory.hh:140
ALUMemoryProviderSingleThread()
default constructor
Definition memory.hh:66
~ALUMemoryProviderSingleThread()
call deleteEntity
Definition memory.hh:153
ObjectType * stackObject()
Definition memory.hh:106
ObjectType * getObject(const FactoryType &factory, int level)
i.e. return pointer to Entity
Definition memory.hh:126
static int thread()
Definition memory.hh:42
ObjectType * getEntityObject(const FactoryType &factory, int level, EntityImp *)
i.e. return pointer to Entity
Definition memory.hh:87
organize the memory management for entitys used by the NeighborIterator
Definition memory.hh:178
static int maxThreads()
Definition memory.hh:203
ObjectType * getEmptyObject()
return object, if created default constructor is used
Definition memory.hh:235
ALUMemoryProvider(const ALUMemoryProvider &org)
copy constructor (don't copy memory providers)
Definition memory.hh:215
void freeObject(ObjectType *obj)
free, move element to stack, returns NULL
Definition memory.hh:238
ObjectType * getEntityObject(const FactoryType &factory, int level, EntityImp *fakePtr)
i.e. return pointer to Entity
Definition memory.hh:229
ObjectType * getObject(const FactoryType &factory, int level)
i.e. return pointer to Entity
Definition memory.hh:222
Object ObjectType
Definition memory.hh:206
ALUMemoryProvider()
default constructor
Definition memory.hh:209
static int thread()
Definition memory.hh:200
Definition memory.hh:243
void operator++()
increase reference count
Definition memory.hh:266
unsigned int & refCount()
Definition memory.hh:251
ObjectImp ObjectType
Definition memory.hh:246
ObjectType & object()
Definition memory.hh:278
bool operator!() const
return true if object has no references anymore
Definition memory.hh:272
void reset()
reset status and reference count
Definition memory.hh:256
const ObjectType & object() const
Definition memory.hh:277
ObjectType object_
Definition memory.hh:249
bool unique() const
return true if there exists more then on reference
Definition memory.hh:275
const unsigned int & refCount() const
Definition memory.hh:252
void operator--()
decrease reference count
Definition memory.hh:269
Definition memory.hh:283
void removeObject()
Definition memory.hh:338
void assign(const SharedPointer &other)
Definition memory.hh:329
ReferenceCountedObjectType * ptr_
Definition memory.hh:393
SharedPointer(const SharedPointer &other)
Definition memory.hh:312
SharedPointer & operator=(const SharedPointer &other)
Definition memory.hh:369
void getObject()
Definition memory.hh:323
void invalidate()
Definition memory.hh:353
SharedPointer()
Definition memory.hh:297
static MemoryPoolType & memoryPool()
Definition memory.hh:289
ObjectImp ObjectType
Definition memory.hh:285
ObjectType & operator*()
Definition memory.hh:386
ReferenceCountedObjectType & ptr()
Definition memory.hh:390
~SharedPointer()
Definition memory.hh:318
ReferenceCountedObject< ObjectType > ReferenceCountedObjectType
Definition memory.hh:286
bool unique() const
Definition memory.hh:383
const ReferenceCountedObjectType & ptr() const
Definition memory.hh:391
ALUMemoryProvider< ReferenceCountedObjectType > MemoryPoolType
Definition memory.hh:287
bool operator==(const SharedPointer &other) const
Definition memory.hh:381