MemoryHandler.hpp

Go to the documentation of this file.

#ifndef MEMORY_HANDLER
#define MEMORY_HANDLER
 
#include <iostream>
#include <vector>
#include <string.h> //memset
 
class ChunkMemoryHandler
{  private:
  std::vector<unsigned char*> m_memory;
  std::vector<size_t> m_used;
  // chunk capacity;
  size_t m_capacity;
 
 
  public:
  ChunkMemoryHandler(size_t size = 131072) : m_used(0), m_capacity(size)
  {
    unsigned char* mem = (unsigned char*)malloc(size);
    m_memory.push_back(mem);
    memset(mem, 0, size);
    m_used.push_back(0);
  }
 
 
  virtual ~ChunkMemoryHandler()
  {
    for(size_t i = 0; i < m_memory.size(); ++i)
    {
      free(m_memory[i]);
    }
  }
  template <typename T>
    void* alloc(size_t required, long& offset)
    {
      required = (sizeof(T) * required);
      for(size_t i = 0; i < m_memory.size(); ++i)
      {
        size_t used = m_used[i];
        if((m_capacity - used) >= required)
        {
          m_used[i] += required;
 
          return m_memory[i] + used;
        }
      }
      
 
      ssize_t size = (required > m_capacity) ? required : m_capacity;
      
      unsigned char* mem = (unsigned char*)malloc(size);
      memset(mem, 0, size);
      m_memory.push_back(mem);
      m_used.push_back(required);
      return mem;
    }
 
 
};
 
class BlockMemoryHandler 
{
  public:
    // 1 MiB default
    BlockMemoryHandler(size_t size = 32) : m_size(size), m_used(0), m_capacity(size)
  {
    m_memory = (unsigned char*)malloc(m_size);
    m_address = m_memory;
  }
 
    size_t m_size;
    size_t m_used;
    size_t m_capacity;
    unsigned char* m_memory;
    unsigned char* m_address;
 
    template <typename T>
      void* alloc(size_t required, long& offset)
      {
        required = (sizeof(T) * required);
 
        if((m_capacity - m_used) < required)
        {
          long addSize = (required > m_size) ? required : m_size;
          m_capacity += addSize;
 
          unsigned char* tmp = (unsigned char*)realloc(m_memory, m_capacity);
 
          // check if realloc failed
          if(NULL == tmp)
          {
            return tmp;
          }
 
          m_memory = tmp;
 
          if(m_memory != m_address)
          {
            offset = m_memory - m_address;
            m_address = m_memory;
          }
        }
 
        unsigned char* ptr = &m_memory[m_used];
        memset(ptr, 0, required);
        m_used += required;
        return (void*)ptr;
      }
 
    void shrinkToFit()
    {
      m_memory = (unsigned char*)realloc(m_memory, m_used);
      if(m_memory != m_address)
      {
        std::cout << "FUCK WHY" << std::endl;
      }
    }
 
    virtual ~BlockMemoryHandler()
    {
      free(m_memory);
      m_memory = NULL;
      m_address = NULL;
    }
 
};
 
#endif