ExtPreAlloc.hpp

/* ExtPreAlloc.hpp
 *
 *  Created on: Apr 3, 2015
 *      Author: Pietro Incardona
 */
 
#ifndef EXTPREALLOC_HPP_
#define EXTPREALLOC_HPP_
 
#include <stddef.h>
#include "memory.hpp"
#include <iostream>
 
template<typename Mem>
class ExtPreAlloc : public memory
{
    size_t a_seq ;
 
    size_t l_size;
 
    Mem * mem;
 
    long int ref_cnt;
 
public:
 
    virtual ~ExtPreAlloc()
    {
        if (ref_cnt != 0)
            std::cerr << "Error: " << __FILE__ << " " << __LINE__ << " destroying a live object" << "\n";
    }
 
    ExtPreAlloc()
    :a_seq(0),l_size(0),mem(NULL),ref_cnt(0)
    {
    }
 
    ExtPreAlloc(size_t size, Mem & mem)
    :a_seq(0),l_size(0),mem(&mem),ref_cnt(0)
    {
        // Allocate the total size of memory
        mem.resize(size);
    }
 
    void setMemory(size_t size, Mem & mem)
    {
        this->mem = &mem;
        mem.resize(size);
    }
 
    Mem * getMemory()
    {
        return this->mem;
    }
 
    bool copyDeviceToDevice(const ExtPreAlloc<Mem> & m)
    {
        return mem->copyDeviceToDevice(*m.mem);
    }
 
    void deviceToDevice(void * ptr, size_t start, size_t stop, size_t offset)
    {
        mem->deviceToDevice(ptr,start,stop,offset);
    }
 
    constexpr static bool isDeviceHostSame()
    {
        return Mem::isDeviceHostSame();
    }
 
    virtual void incRef()
    {ref_cnt++;}
 
    virtual void decRef()
    {ref_cnt--;}
 
    virtual long int ref()
    {
        return ref_cnt;
    }
 
    virtual bool flush() {return mem->flush();};
 
    virtual void fill(unsigned char c)
    {
        mem->fill(c);
    }
 
    virtual bool allocate(size_t sz)
    {
        // Zero sized allocation are ignored
        if (sz == 0)
            return true;
 
        a_seq = l_size;
        l_size += sz;
 
        // Check we do not overflow the allocated memory
#ifdef SE_CLASS1
 
        if (l_size > mem->size())
            std::cerr << __FILE__ << ":" << __LINE__ << " Error requesting more memory than the allocated one" << std::endl;
 
#endif
 
        return true;
    }
 
    bool allocate_nocheck(size_t sz)
    {
        // Zero sized allocation are ignored
        if (sz == 0)
            return true;
 
        a_seq = l_size;
        l_size += sz;
 
        return true;
    }
 
    void * getPointerEnd()
    {
        return (char *)mem->getPointer() + l_size;
    }
 
    void * getDevicePointerEnd()
    {
        return (char *)mem->getDevicePointer() + l_size;
    }
 
    void * getPointerBase()
    {
        return mem->getPointer();
    }
 
    virtual void * getDevicePointer()
    {
        if (mem != NULL)
        {return (((unsigned char *)mem->getDevicePointer()) + a_seq );}
        else {return NULL;}
    }
 
    virtual void hostToDevice()
    {
        mem->hostToDevice();
    }
 
    virtual void hostToDevice(size_t start, size_t stop)
    {
        mem->hostToDevice(start,stop);
    }
 
    virtual void deviceToHost()
    {
        mem->deviceToHost();
    };
 
    virtual void deviceToHost(size_t start, size_t stop)
    {
        mem->deviceToHost(start,stop);
    };
 
    virtual void * getPointer()
    {
        return (((unsigned char *)mem->getPointer()) + a_seq );
    }
 
    virtual const void * getPointer() const
    {
        return (((unsigned char *)mem->getPointer()) + a_seq);
    }
 
    void * getPointerOffset(size_t offset)
    {
        return (((unsigned char *)mem->getPointer()) + offset);
    }
 
    virtual bool resize(size_t sz)
    {
        return allocate(sz);
    }
 
    virtual size_t size() const
    {
        return l_size;
    }
 
    void destroy()
    {
        mem->destroy();
    }
 
    virtual bool copy(const memory & m)
    {
        return mem->copy(m);
    }
 
    bool isInitialized()
    {
        return false;
    }
 
    static size_t calculateMem(std::vector<size_t> & mm)
    {
        size_t s = 0;
 
        for (size_t i = 0 ; i < mm.size() ; i++)
            s += mm[i];
 
        return s;
    }
 
    void shift_backward(size_t sz)
    {
        a_seq -= sz;
        l_size = a_seq;
    }
 
    void shift_forward(size_t sz)
    {
        a_seq += sz;
        l_size = a_seq;
    }
 
    size_t getOffset()
    {
        return a_seq;
    }
 
    size_t getOffsetEnd()
    {
        return l_size;
    }
 
    void reset()
    {
        a_seq = 0;
        l_size = 0;
    }
};
 
#endif /* PREALLOCHEAPMEMORY_HPP_ */