HeapMemory.hpp

/*
 * HeapMempory.hpp
 *
 *  Created on: Aug 17, 2014
 *      Author: Pietro Incardona
 */

#ifndef HEAP_MEMORY_HPP
#define HEAP_MEMORY_HPP

#include "config.h"
#include "memory.hpp"
#include <cstddef>
#include <cstdint>
#include <iostream>

typedef unsigned char byte;

#define MEM_ALIGNMENT 32


class HeapMemory : public memory
{
    size_t alignement;

    size_t sz;

    byte * dm;
    byte * dmOrig;
    long int ref_cnt;

    bool copyFromPointer(const void * ptr, size_t sz);

    void setAlignment(size_t align);

public:

    bool copyDeviceToDevice(const HeapMemory & m);

    virtual bool flush() {return true;};
    virtual bool allocate(size_t sz);
    virtual void destroy();
    virtual bool copy(const memory & m);
    virtual size_t size() const;
    virtual bool resize(size_t sz);
    virtual void * getPointer();

    virtual const void * getPointer() const;

    virtual void * getDevicePointer();

    virtual void fill(unsigned char c);

    virtual void hostToDevice(){};

    virtual void deviceToHost(){};

    virtual void deviceToHost(size_t start, size_t stop) {};

    virtual void hostToDevice(size_t start, size_t stop) {};

    virtual void incRef()
    {ref_cnt++;}

    virtual void decRef()
    {ref_cnt--;}

    virtual long int ref()
    {
        return ref_cnt;
    }

    bool isInitialized()
    {
        return false;
    }

    // Copy the Heap memory
    HeapMemory & operator=(const HeapMemory & mem)
    {
        copy(mem);
        return *this;
    }

    // Copy the Heap memory
    HeapMemory(const HeapMemory & mem)
    :HeapMemory()
    {
        allocate(mem.size());
        copy(mem);
    }

    HeapMemory(HeapMemory && mem) noexcept
    {
        alignement = mem.alignement;
        sz = mem.sz;
        dm = mem.dm;
        dmOrig = mem.dmOrig;
        ref_cnt = mem.ref_cnt;

        mem.alignement = MEM_ALIGNMENT;
        mem.sz = 0;
        mem.dm = NULL;
        mem.dmOrig = NULL;
        mem.ref_cnt = 0;
    }

    HeapMemory():alignement(MEM_ALIGNMENT),sz(0),dm(NULL),dmOrig(NULL),ref_cnt(0) {};

    virtual ~HeapMemory() noexcept
    {
        if(ref_cnt == 0)
            HeapMemory::destroy();
        else
            std::cerr << "Error: " << __FILE__ << " " << __LINE__ << " destroying a live object" << "\n";
    };

    void swap(HeapMemory & mem)
    {
        size_t alignement_tmp;
        size_t sz_tmp;
        byte * dm_tmp;
        byte * dmOrig_tmp;
        long int ref_cnt_tmp;

        alignement_tmp = alignement;
        sz_tmp = sz;
        dm_tmp = dm;
        dmOrig_tmp = dmOrig;
        ref_cnt_tmp = ref_cnt;

        alignement = mem.alignement;
        sz = mem.sz;
        dm = mem.dm;
        dmOrig = mem.dmOrig;
        ref_cnt = mem.ref_cnt;

        mem.alignement = alignement_tmp;
        mem.sz = sz_tmp;
        mem.dm = dm_tmp;
        mem.dmOrig = dmOrig_tmp;
        mem.ref_cnt = ref_cnt_tmp;
    }

    constexpr static bool isDeviceHostSame()
    {
        return true;
    }
};

inline size_t align_number(size_t al, size_t number)
{
    return number + ((number % al) != 0)*(al - number % al);
}

inline void *align( std::size_t alignment, std::size_t size,
                    void *&ptr, std::size_t &space ) {
    std::uintptr_t pn = reinterpret_cast< std::uintptr_t >( ptr );
    std::uintptr_t aligned = ( pn + alignment - 1 ) & - alignment;
    std::size_t padding = aligned - pn;
    if ( space < size + padding ) return nullptr;
    space -= padding;
    return ptr = reinterpret_cast< void * >( aligned );
}

#endif