src/SMDS/ObjectPool.hxx

   1 #ifndef _OBJECTPOOL_HXX_
   2 #define _OBJECTPOOL_HXX_
   3
   4 #include <vector>
   5 #include <stack>
   6 #include <iostream>
   7
   8 template<class X> class ObjectPool
   9 {
  10
  11 private:
  12   std::vector<X*> _chunkList;
  13   std::vector<bool> _freeList;
  14   int _nextFree;
  15   int _maxAvail;
  16   int _chunkSize;
  17
  18   int getNextFree()
  19   {
  20     for (int i = _nextFree; i < _maxAvail; i++)
  21       if (_freeList[i] == true)
  22       {
  23         return i;
  24         break;
  25       }
  26     return _maxAvail;
  27   }
  28
  29   void checkDelete(int chunkId)
  30   {
  31     int i0 = _chunkSize * chunkId;
  32     int i1 = _chunkSize * (chunkId + 1);
  33     for (int i = i0; i < i1; i++)
  34       if (_freeList[i] == false)
  35         return;
  36     std::cerr << "a chunk to delete" << std::endl;
  37     // compactage des vecteurs un peu lourd, pas necessaire
  38     //X* chunk = _chunkList[chunkId];
  39     //delete [] chunk;
  40   }
  41
  42 public:
  43   ObjectPool(int nblk)
  44   {
  45     _chunkSize = nblk;
  46     _nextFree = 0;
  47     _maxAvail = 0;
  48     _chunkList.clear();
  49     _freeList.clear();
  50   }
  51
  52   virtual ~ObjectPool()
  53   {
  54     for (int i = 0; i < _chunkList.size(); i++)
  55       delete[] _chunkList[i];
  56   }
  57
  58   X* getNew()
  59   {
  60     X *obj = 0;
  61     _nextFree = getNextFree();
  62     if (_nextFree == _maxAvail)
  63     {
  64       X* newChunk = new X[_chunkSize];
  65       _chunkList.push_back(newChunk);
  66       _freeList.insert(_freeList.end(), _chunkSize, true);
  67       _maxAvail += _chunkSize;
  68       _freeList[_nextFree] = false;
  69       obj = newChunk; // &newChunk[0];
  70     }
  71     else
  72     {
  73       int chunkId = _nextFree / _chunkSize;
  74       int rank = _nextFree - chunkId * _chunkSize;
  75       _freeList[_nextFree] = false;
  76       obj = _chunkList[chunkId] + rank; // &_chunkList[chunkId][rank];
  77     }
  78     //obj->init();
  79     return obj;
  80   }
  81
  82   void destroy(X* obj)
  83   {
  84     long adrobj = (long) (obj);
  85     for (int i = 0; i < _chunkList.size(); i++)
  86     {
  87       X* chunk = _chunkList[i];
  88       long adrmin = (long) (chunk);
  89       if (adrobj < adrmin)
  90         continue;
  91       long adrmax = (long) (chunk + _chunkSize);
  92       if (adrobj >= adrmax)
  93         continue;
  94       int rank = (adrobj - adrmin) / sizeof(X);
  95       int toFree = i * _chunkSize + rank;
  96       _freeList[toFree] = true;
  97       if (toFree < _nextFree)
  98         _nextFree = toFree;
  99       //obj->clean();
 100       //checkDelete(i); compactage non fait
 101       break;
 102     }
 103   }
 104
 105 //  void destroy(int toFree)
 106 //  {
 107 //    // no control 0<= toFree < _freeList.size()
 108 //    _freeList[toFree] = true;
 109 //    if (toFree < _nextFree)
 110 //      _nextFree = toFree;
 111 //  }
 112
 113 };
 114
 115 #endif