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;

// If debugging mode include memory leak check
#ifdef SE_CLASS2
#include "Memleak_check.hpp"
#endif

bool HeapMemory::allocate(size_t sz)
{
    if (dm == NULL)
        dmOrig = new byte[sz+alignement+extra_pad];
    else
        std::cerr << __FILE__ << ":" << __LINE__ << " error memory already allocated\n";

    dm = dmOrig;

#ifdef SE_CLASS2
    check_new(dmOrig,sz+alignement,HEAPMEMORY_EVENT,0);
#endif

    // 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()
{
#ifdef SE_CLASS2
    check_delete(dmOrig);
#endif

    if (dmOrig != NULL)
        delete [] dmOrig;

    sz = 0;
    dm = NULL;
    dmOrig = NULL;
}


bool HeapMemory::copyFromPointer(const void * ptr,size_t sz)
{
    // memory copy

#ifdef SE_CLASS2
    check_valid(dm,sz);
    check_valid(ptr,sz);
#endif
    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;
    }

#ifdef SE_CLASS2
    check_valid(dm,sz);
    check_valid(m.dm,sz);
#endif
    // 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 SE_CLASS2
    check_new(tdmOrig,sz+alignement,HEAPMEMORY_EVENT,0);
#endif
    tdm = tdmOrig;

    size_t sz_a = sz+alignement;

    align(alignement,1,(void *&)tdm,sz_a);


#ifdef SE_CLASS2
    check_valid(tdm,HeapMemory::size());
    check_valid(dm,HeapMemory::size());
#endif
    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;
}