MemoryPool.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Martin Ritter                                            *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <vector>
#include <cstddef>
#include <cstdlib>
 
namespace Belle2 {
  template < class T, int chunkSize = 128 > class MemoryPool {
 
  public:
    explicit MemoryPool(int n = 0): m_entries(0) { reserve(n); }
 
    ~MemoryPool() { release_memory(); }
 
    size_t size() const { return m_entries; }
 
    T* operator[](size_t i) { return m_chunks[i / chunkSize] + i % chunkSize; }
 
    T* at(size_t i) { return (i >= m_entries) ? 0 : (*this)[i]; }
 
    void clear() { m_entries = 0; }
 
    T* add()
    {
      if (m_entries / chunkSize >= m_chunks.size()) {
        m_chunks.push_back(reinterpret_cast<T*>(malloc(chunkSize * sizeof(T))));
      }
      return (*this)[m_entries++];
    }
 
    void reserve(size_t n)
    {
      size_t needed_chunks = n / chunkSize + 1;
      m_chunks.reserve(needed_chunks);
      while (m_chunks.size() < needed_chunks) {
        m_chunks.push_back(reinterpret_cast<T*>(malloc(chunkSize * sizeof(T))));
      }
    }
 
    void release_memory()
    {
      for (T* ptr : m_chunks) {
        free(reinterpret_cast<void*>(ptr));
      }
      m_chunks.clear();
    }
 
  protected:
 
    size_t m_entries; 
    std::vector<T*> m_chunks; 
  };
 
} //end namespace Belle2