HeapMemory.cpp

/*
 * HeapMemory.cpp
 *
 *  Created on: Aug 17, 2014
 *      Author: Pietro Incardona
 */
 
#include "HeapMemory.hpp"
#include <cstddef>
#include <cstring>
#include <iostream>
#include <cstdint>
 
static const int extra_pad = 512;
 
 
void HeapMemory::fill(unsigned char c)
{
    memset(dm,c,size());
}
 
bool HeapMemory::allocate(size_t sz)
{
    if (dm == NULL)
    {
        dmOrig = new byte[sz+alignement+extra_pad];
        #ifdef GARBAGE_INJECTOR
        memset(dmOrig,0xFF,sz+alignement+extra_pad);
        #endif
    }
    else
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error memory already allocated\n";
        return false;
    }
 
    dm = dmOrig;
 
    // align it, we do not know the size of the element we put 1
    // and we ignore the align check
    size_t sz_a = sz+alignement;
    align(alignement,1,(void *&)dm,sz_a);
 
    this->sz = sz;
 
    return true;
}
 
void HeapMemory::setAlignment(size_t align)
{
    this->alignement = align;
}
 
void HeapMemory::destroy()
{
    if (dmOrig != NULL)
        delete [] dmOrig;
 
    sz = 0;
    dm = NULL;
    dmOrig = NULL;
}
 
 
bool HeapMemory::copyFromPointer(const void * ptr,size_t sz)
{
    memcpy(dm,ptr,sz);
 
    return true;
}
 
bool HeapMemory::copyDeviceToDevice(const HeapMemory & m)
{
 
    if (m.sz > sz)
    {
        std::cerr << "Error " << __LINE__ << __FILE__ << ": source buffer is too big to copy";
        return false;
    }
 
    // Copy the memory from m
    memcpy(dm,m.dm,m.sz);
    return true;
}
 
bool HeapMemory::copy(const memory & m)
{
    const HeapMemory * ofpm = dynamic_cast<const HeapMemory *>(&m);
 
 
    if (ofpm == NULL)
    {
        // copy the memory from device to host and from host to device
 
        return copyFromPointer(m.getPointer(),m.size());
    }
    else
    {
        // they are the same memory type, use cuda/thrust buffer copy
 
        return copyDeviceToDevice(*ofpm);
    }
    return false;
}
 
size_t HeapMemory::size() const
{
    return sz;
}
 
bool HeapMemory::resize(size_t sz)
{
    // if the allocated memory is enough, do not resize
    if (sz <= HeapMemory::size())
        return true;
 
 
    if (HeapMemory::size() == 0)
        return HeapMemory::allocate(sz);
 
    byte * tdm;
    byte * tdmOrig;
    tdmOrig = new byte[sz+alignement+extra_pad];
    #ifdef GARBAGE_INJECTOR
    memset(tdmOrig,0xFF,sz+alignement+extra_pad);
    #endif
    tdm = tdmOrig;
 
    size_t sz_a = sz+alignement;
 
    align(alignement,1,(void *&)tdm,sz_a);
 
 
    memcpy(tdm,dm,HeapMemory::size());
 
    this->sz = sz;
 
 
    HeapMemory::destroy();
 
 
    dm = tdm;
    dmOrig = tdmOrig;
    this->sz = sz;
 
    return true;
}
 
void * HeapMemory::getDevicePointer()
{
    return dm;
}
 
void * HeapMemory::getPointer()
{
    return dm;
}
 
const void * HeapMemory::getPointer() const
{
    return dm;
}