lib-src/memory/mempool.cc

   1 //////////////////////////////////////////////////////////////////////////////
   2 // NOTICE:
   3 //
   4 // ADLib, Prop and their related set of tools and documentation are in the
   5 // public domain.   The author(s) of this software reserve no copyrights on
   6 // the source code and any code generated using the tools.  You are encouraged
   7 // to use ADLib and Prop to develop software, in both academic and commercial
   8 // settings, and are free to incorporate any part of ADLib and Prop into
   9 // your programs.
  10 //
  11 // Although you are under no obligation to do so, we strongly recommend that
  12 // you give away all software developed using our tools.
  13 //
  14 // We also ask that credit be given to us when ADLib and/or Prop are used in
  15 // your programs, and that this notice be preserved intact in all the source
  16 // code.
  17 //
  18 // This software is still under development and we welcome any suggestions
  19 // and help from the users.
  20 //
  21 // Allen Leung
  22 // 1994
  23 //////////////////////////////////////////////////////////////////////////////
  24
  25 #include <string.h>
  26 #include <AD/memory/mempool.h>
  27
  28 //////////////////////////////////////////////////////////////////////////////
  29 //  Constructor
  30 //////////////////////////////////////////////////////////////////////////////
  31 MemPool::MemPool(long pageSize) : Mem("MemPool"),
  32    defaultPageSize(pageSize), pages(0), next(0), limit(0) {}
  33 MemPool::MemPool(Mem& m, long pageSize) : Mem(m,"MemPool"),
  34    defaultPageSize(pageSize), pages(0), next(0), limit(0) {}
  35
  36 //////////////////////////////////////////////////////////////////////////////
  37 //  Destructor
  38 //////////////////////////////////////////////////////////////////////////////
  39 MemPool::~MemPool() { clear(); }
  40
  41 //////////////////////////////////////////////////////////////////////////////
  42 // Returns the total number of bytes used
  43 //////////////////////////////////////////////////////////////////////////////
  44 size_t MemPool::bytes_used() const
  45 {  Page * P; size_t bytes;
  46    for (bytes = 0, P = pages; P; P = P->lastPage)
  47       bytes += defaultPageSize;
  48    return bytes;
  49 }
  50
  51 //////////////////////////////////////////////////////////////////////////////
  52 //  Method to increase the memory manager size
  53 //////////////////////////////////////////////////////////////////////////////
  54 void MemPool::grow(long size)
  55 {  if (defaultPageSize > size) size = defaultPageSize;
  56    long elements = (size + sizeof(Align) - 1) / sizeof(Align);
  57    long my_size  = sizeof(Page) + (elements-1) * sizeof(Align);
  58    Page * newPage = (Page*)manager_mem->m_alloc(my_size);
  59    newPage->lastPage = pages;
  60    pages = newPage;
  61    next = pages->data;
  62    limit = pages->data + elements;
  63 }
  64
  65 //////////////////////////////////////////////////////////////////////////////
  66 // Allocate some memory
  67 //////////////////////////////////////////////////////////////////////////////
  68 void * MemPool::c_alloc(size_t n)
  69 {  void * core = (*this)[n];
  70    memset(core,0,n);
  71    return core;
  72 }
  73
  74 //////////////////////////////////////////////////////////////////////////////
  75 // Get a memory pool mark
  76 //////////////////////////////////////////////////////////////////////////////
  77 MemPoolMark MemPool::getMark() const
  78 {  MemPoolMark M;
  79    M.pages  = pages;
  80    M.next   = next;
  81    M.limit  = limit;
  82    return M;
  83 }
  84
  85 //////////////////////////////////////////////////////////////////////////////
  86 // Reset memory manager to previous mark
  87 //////////////////////////////////////////////////////////////////////////////
  88 void MemPool::setMark(const MemPoolMark& mark)
  89 {
  90    while (mark.pages != pages) {
  91       if (pages == NULL) return;
  92       Page * last = pages->lastPage;
  93       manager_mem->free(pages);
  94       pages = last;
  95    }
  96    next = mark.next;
  97    limit = mark.limit;
  98 }
  99
 100 //////////////////////////////////////////////////////////////////////////////
 101 //  Merge mempool M
 102 //////////////////////////////////////////////////////////////////////////////
 103 void MemPool::merge(MemPool& M)
 104 {
 105    while (M.pages) {
 106       Page * last = M.pages->lastPage;
 107       if (pages) { M.pages->lastPage = pages;
 108                    pages = M.pages; }
 109       else { pages = M.pages; M.pages = NULL; break; }
 110       M.pages = last;
 111    }
 112
 113    M.next = M.limit = next = limit = NULL;
 114 }
 115
 116 //////////////////////////////////////////////////////////////////////////////
 117 // Mem protocol methods
 118 //////////////////////////////////////////////////////////////////////////////
 119 void MemPool::free(void *) { }
 120
 121 //////////////////////////////////////////////////////////////////////////////
 122 // Clear the memory manager
 123 //////////////////////////////////////////////////////////////////////////////
 124 void MemPool::clear()
 125 {  Page * P = pages;
 126    while (P) {
 127       Page * last = P->lastPage;
 128       manager_mem->free(P); P = last;
 129    }
 130    pages = 0; next = 0; limit = 0;
 131 }