JRAM.hh

Go to the documentation of this file.

#ifndef __JLANG__JRAM__
#define __JLANG__JRAM__
 
#include <vector>
#include <algorithm>
 
#include "JLang/JException.hh"
 
 
/**
 * \file
 * Auxiliary class to speed up new/delete operations of any class.
 * \author mdejong
 */
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
  /**
   * Memory management for small objects.
   * This object allocator is optimised for speed at the cost of some memory overhead.
   */
  class JRAM :
    public std::vector<void*>
  {
  private:
 
    const std::size_t           BLOCK_SIZE;
    const std::size_t           numberOfBlocks;
    std::vector<unsigned char*> memory;
 
 
    /**
     * Add memory.
     */
    void addMemory()
    {
      unsigned char* buffer = new unsigned char[BLOCK_SIZE * numberOfBlocks];
      
      if (buffer == NULL) {
        THROW(JException, "JRAM::allocate(): not enough space in memory.");
      }
      
      memory.push_back(buffer);
 
      const std::size_t size = this->size();
 
      this->resize(size + numberOfBlocks);
      
      iterator q = this->begin();
 
      std::advance(q, size);
 
      for ( ; q != this->end(); buffer += BLOCK_SIZE, ++q) {
        *q = buffer;
      }
    }
 
  public:
    /**
     * Constructor.
     *
     * \param  block_size          number of bytes
     * \param  number_of_blocks    number of blocks
     */
    JRAM(const std::size_t block_size,
         const std::size_t number_of_blocks = 65536) :
      std::vector<void*>(),
      BLOCK_SIZE    (block_size),
      numberOfBlocks(number_of_blocks)
    {
      addMemory();
    }
 
 
    /**
     * Destructor.
     */
    ~JRAM()
    {
      for (std::vector<unsigned char*>::iterator i = memory.begin(); i != memory.end(); ++i) {
        delete [] (*i);
      }
    }
 
 
    /**
     * Get total used RAM.
     *
     * \return                     number of bytes
     */
    long long int getTotalRAM()
    {
      return this->size() * sizeof(void*)  +  memory.size() * BLOCK_SIZE * numberOfBlocks;
    }
 
 
    /**
     * Get total free RAM.
     *
     * \return                     number of bytes
     */
    long long int getFreeRAM()
    {
      return this->size() * BLOCK_SIZE;
    }
 
 
    /**
     * Allocate memory.
     *
     * \return                     pointer to avaible memory
     */
    inline void* allocate()
    {
      if (this->empty()) {
        addMemory();
      }
 
      void* p = this->back();
 
      this->pop_back();
 
      return p;
    }
 
 
    /**
     * Deallocate memory.
     *
     * \param  p                   pointer to memory to be freed
     */
    inline void free(void* p)
    {
      this->push_back(p);
    }
 
 
    /**
     * Run garbage collector.
     */
    void gc()
    {
      using namespace std;
 
      sort(this->begin(), this->end());
 
      vector<unsigned char*>::iterator __end = memory.end();
      
      for (vector<unsigned char*>::iterator i = memory.begin(); i != __end; ) {
 
        iterator p = lower_bound(this->begin(), this->end(), *i);
        iterator q = p  +  numberOfBlocks  -  1;
 
        if (*p == *i                      && 
            distance(q, this->end()) > 0  && 
            ((unsigned char*) (*q) - (unsigned char*) *p) == (int) (BLOCK_SIZE * (numberOfBlocks - 1))) {
 
          iter_swap(i, --__end);
 
          this->erase(p,++q);
 
        } else {
          ++i;
        }
      }
 
      for (std::vector<unsigned char*>::iterator i = __end; i != memory.end(); ++i) {
        delete [] (*i);
      }
 
      memory.erase(__end, memory.end());
    }
 
  private:
    JRAM(const JRAM&);
    JRAM(JRAM&&);
    JRAM& operator=(const JRAM&);
    JRAM& operator=(JRAM&&);
  };
}
 
#endif