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