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 
16 namespace 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  {
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
312  SharedPointer( const SharedPointer& other )
313  {
314  assign( other );
315  }
316 
317  // destructor clearing pointer
319  {
320  removeObject();
321  }
322 
323  void getObject()
324  {
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  {
347  }
348 
349  // reset pointer
350  ptr_ = nullptr;
351  }
352 
353  void invalidate()
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
ALUGrid::ALUMemoryProvider::ObjectType
Object ObjectType
Definition: memory.hh:206
ALUGrid::ALUGridFiniteStack
Definition: memory.hh:20
ALUGrid::ALUMemoryProvider::getEntityObject
ObjectType * getEntityObject(const FactoryType &factory, int level, EntityImp *fakePtr)
i.e. return pointer to Entity
Definition: memory.hh:229
ALUGrid::ALUMemoryProvider::freeObject
void freeObject(ObjectType *obj)
free, move element to stack, returns NULL
Definition: memory.hh:238
ALUGrid::SharedPointer::invalidate
void invalidate()
Definition: memory.hh:353
ALUGrid::SharedPointer::memoryPool
static MemoryPoolType & memoryPool()
Definition: memory.hh:289
ALUGrid::ALUMemoryProviderSingleThread::ObjectType
Object ObjectType
Definition: memory.hh:39
ALUGrid::ReferenceCountedObject::operator++
void operator++()
increase reference count
Definition: memory.hh:266
ALUGrid::ReferenceCountedObject::object
const ObjectType & object() const
Definition: memory.hh:277
ALUGrid::SharedPointer::MemoryPoolType
ALUMemoryProvider< ReferenceCountedObjectType > MemoryPoolType
Definition: memory.hh:287
alugrid_assert.hh
ALUGrid::SharedPointer::ObjectType
ObjectImp ObjectType
Definition: memory.hh:285
ALUGrid::ALUMemoryProviderSingleThread::getEmptyObject
ObjectType * getEmptyObject()
return object, if created default constructor is used
Definition: memory.hh:140
ALUGrid::ALUMemoryProviderSingleThread::getObject
ObjectType * getObject(const FactoryType &factory, int level)
i.e. return pointer to Entity
Definition: memory.hh:126
ALUGrid::ReferenceCountedObject::operator--
void operator--()
decrease reference count
Definition: memory.hh:269
ALUGrid::ALUMemoryProviderSingleThread::setThreadNumber
void setThreadNumber(const int thread)
set thread number this memory provider works for
Definition: memory.hh:76
ALUGrid::SharedPointer::operator=
SharedPointer & operator=(const SharedPointer &other)
Definition: memory.hh:369
ALUGrid::ALUMemoryProviderSingleThread
organize the memory management for entitys used by the NeighborIterator
Definition: memory.hh:24
ALUGrid::ReferenceCountedObject::refCount
unsigned int & refCount()
Definition: memory.hh:251
ALUGrid::ReferenceCountedObject::ObjectType
ObjectImp ObjectType
Definition: memory.hh:246
ALUGrid::ALUMemoryProviderSingleThread::getEntityObject
ObjectType * getEntityObject(const FactoryType &factory, int level, EntityImp *)
i.e. return pointer to Entity
Definition: memory.hh:87
ALUGrid::ALUMemoryProviderSingleThread::ALUMemoryProviderSingleThread
ALUMemoryProviderSingleThread()
default constructor
Definition: memory.hh:66
ALUGrid::ReferenceCountedObject::refCount
const unsigned int & refCount() const
Definition: memory.hh:252
ALUGrid::SharedPointer::assign
void assign(const SharedPointer &other)
Definition: memory.hh:329
ALUGrid::SharedPointer::operator*
ObjectType & operator*()
Definition: memory.hh:386
ALUGrid::ALUMemoryProvider::maxThreads
static int maxThreads()
Definition: memory.hh:203
ALUGrid::SharedPointer::~SharedPointer
~SharedPointer()
Definition: memory.hh:318
ALUGrid::SharedPointer::unique
bool unique() const
Definition: memory.hh:383
ALUGrid::ReferenceCountedObject
Definition: memory.hh:242
ALUGrid::SharedPointer::ptr
const ReferenceCountedObjectType & ptr() const
Definition: memory.hh:391
ALUGrid::SharedPointer::operator==
bool operator==(const SharedPointer &other) const
Definition: memory.hh:381
ALUGrid::SharedPointer::removeObject
void removeObject()
Definition: memory.hh:338
ALUGrid::ALUMemoryProviderSingleThread::thread
static int thread()
Definition: memory.hh:42
alugrid_assert
#define alugrid_assert(EX)
Definition: alugrid_assert.hh:20
ALUGrid::SharedPointer::ptr_
ReferenceCountedObjectType * ptr_
Definition: memory.hh:393
ALUGrid::ALUMemoryProviderSingleThread::ALUMemoryProviderSingleThread
ALUMemoryProviderSingleThread(const ALUMemoryProviderSingleThread &org)
copy constructor
Definition: memory.hh:71
ALUGrid::ALUMemoryProviderSingleThread::freeObject
void freeObject(ObjectType *obj)
free, move element to stack, returns NULL
Definition: memory.hh:164
ALUGrid::ReferenceCountedObject::unique
bool unique() const
return true if there exists more then on reference
Definition: memory.hh:275
ALUGrid::ALUMemoryProvider::ALUMemoryProvider
ALUMemoryProvider(const ALUMemoryProvider &org)
copy constructor (don't copy memory providers)
Definition: memory.hh:215
ALUGrid::SharedPointer::SharedPointer
SharedPointer(const SharedPointer &other)
Definition: memory.hh:312
ALUGrid::ALUMemoryProvider::getObject
ObjectType * getObject(const FactoryType &factory, int level)
i.e. return pointer to Entity
Definition: memory.hh:222
ALUGrid::ReferenceCountedObject::operator!
bool operator!() const
return true if object has no references anymore
Definition: memory.hh:272
ALUGrid
Definition: alu3dinclude.hh:49
ALUGrid::ALUMemoryProviderSingleThread::stackObject
ObjectType * stackObject()
Definition: memory.hh:106
ALUGrid::ALUMemoryProvider
organize the memory management for entitys used by the NeighborIterator
Definition: memory.hh:177
ALUGrid::SharedPointer::getObject
void getObject()
Definition: memory.hh:323
ALUGrid::ALUMemoryProvider::thread
static int thread()
Definition: memory.hh:200
ALUGrid::ReferenceCountedObject::object_
ObjectType object_
Definition: memory.hh:249
ALUGrid::SharedPointer::ReferenceCountedObjectType
ReferenceCountedObject< ObjectType > ReferenceCountedObjectType
Definition: memory.hh:286
ALUGrid::ALUMemoryProviderSingleThread::~ALUMemoryProviderSingleThread
~ALUMemoryProviderSingleThread()
call deleteEntity
Definition: memory.hh:153
ALUGrid::SharedPointer::SharedPointer
SharedPointer()
Definition: memory.hh:297
ALUGrid::SharedPointer::ptr
ReferenceCountedObjectType & ptr()
Definition: memory.hh:390
ALUGrid::ALUMemoryProviderSingleThread::maxThreads
static int maxThreads()
Definition: memory.hh:54
ALUGrid::SharedPointer
Definition: memory.hh:282
ALUGrid::ALUMemoryProvider::getEmptyObject
ObjectType * getEmptyObject()
return object, if created default constructor is used
Definition: memory.hh:235
ALUGrid::ReferenceCountedObject::reset
void reset()
reset status and reference count
Definition: memory.hh:256
ALUGrid::ALUMemoryProvider::ALUMemoryProvider
ALUMemoryProvider()
default constructor
Definition: memory.hh:209
ALUGrid::ReferenceCountedObject::object
ObjectType & object()
Definition: memory.hh:278