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);
    }


    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_ */