memory.hh
00001 #ifndef DUNE_ALU3DGRIDMEMORY_HH
00002 #define DUNE_ALU3DGRIDMEMORY_HH
00003
00004 #include <stack>
00005
00006 namespace Dune {
00007
00009 template <class Object>
00010 class ALUFastMemoryProvider
00011 {
00012 static std::stack < Object * > objStack_;
00013 typedef ALUFastMemoryProvider < Object > MyType;
00014 typedef Object ObjectType;
00015
00016 public:
00017 void * operator new (size_t s);
00018 void operator delete (void *obj, size_t s);
00019 };
00020
00021 template <class Object>
00022 std::stack< Object * > ALUFastMemoryProvider< Object > :: objStack_;
00023
00024 template <class Object>
00025 inline void *
00026 ALUFastMemoryProvider<Object> :: operator new (size_t s)
00027 {
00028 assert( s == sizeof(ObjectType) );
00029 if( objStack_.empty() )
00030 {
00031 void * obj = std::malloc( sizeof(ObjectType) );
00032 assert( obj );
00033 return obj;
00034 }
00035 else
00036 {
00037 ObjectType * obj = objStack_.top();
00038 objStack_.pop();
00039 return ((void *) obj);
00040 }
00041 }
00042
00043 template <class Object>
00044 inline void
00045 ALUFastMemoryProvider<Object> :: operator delete (void *ptr, size_t s)
00046 {
00047 assert( s == sizeof(ObjectType) );
00048 objStack_.push( (ObjectType *) ptr );
00049 }
00050
00051
00053 template <class Object>
00054 class ALUMemoryProvider
00055 {
00056 std::stack < Object * > objStack_;
00057
00058 typedef ALUMemoryProvider < Object > MyType;
00059 public:
00060 typedef Object ObjectType;
00061
00063 ALUMemoryProvider() {};
00064
00066 ~ALUMemoryProvider ();
00067
00069 template <class GridType>
00070 ObjectType * getObject(const GridType &grid, int level);
00071
00073 template <class GridType, class EntityImp>
00074 inline ObjectType * getEntityObject(const GridType &grid, int level , EntityImp * fakePtr )
00075 {
00076 if( objStack_.empty() )
00077 {
00078 return ( new ObjectType(EntityImp(grid,level) ));
00079 }
00080 else
00081 {
00082 ObjectType * obj = objStack_.top();
00083 objStack_.pop();
00084 return obj;
00085 }
00086 }
00087
00089 ObjectType * getObjectCopy(const ObjectType & org);
00090
00092 void freeObject (ObjectType * obj);
00093
00094 private:
00096 ALUMemoryProvider(const ALUMemoryProvider<Object> & org) {}
00097 };
00098
00099
00100
00101
00102
00103
00104
00105 template <class Object> template <class GridType>
00106 inline typename ALUMemoryProvider<Object>::ObjectType *
00107 ALUMemoryProvider<Object>::getObject
00108 (const GridType &grid, int level )
00109 {
00110 if( objStack_.empty() )
00111 {
00112 return ( new Object (grid,level) );
00113 }
00114 else
00115 {
00116 ObjectType * obj = objStack_.top();
00117 objStack_.pop();
00118 return obj;
00119 }
00120 }
00121
00122 template <class Object>
00123 inline typename ALUMemoryProvider<Object>::ObjectType *
00124 ALUMemoryProvider<Object>::getObjectCopy
00125 (const ObjectType & org )
00126 {
00127 if( objStack_.empty() )
00128 {
00129 return ( new Object (org) );
00130 }
00131 else
00132 {
00133 ObjectType * obj = objStack_.top();
00134 objStack_.pop();
00135 return obj;
00136 }
00137 }
00138
00139 template <class Object>
00140 inline ALUMemoryProvider<Object>::~ALUMemoryProvider()
00141 {
00142 while ( !objStack_.empty() )
00143 {
00144 ObjectType * obj = objStack_.top();
00145 objStack_.pop();
00146 delete obj;
00147 }
00148 }
00149
00150 template <class Object>
00151 inline void ALUMemoryProvider<Object>::freeObject(Object * obj)
00152 {
00153 objStack_.push( obj );
00154 }
00155
00156 }
00157
00158 #endif