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 //  ALUMemoryProvider implementation
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 } // end namespace Dune
00157 
00158 #endif 

Generated on 9 Apr 2008 with Doxygen (ver 1.5.2) [logfile].