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>

/*! Preallocated memory sequence
 *
 * External pre-allocated memory, is a class that preallocate memory and than it answer
 * to a particular allocation pattern
 *
 * \warning zero sized allocation are removed from the request pattern
 *
 * \tparam Base memory allocation class [Example] HeapMemory or CudaMemory
 *
 *
 */

template<typename Mem>
class ExtPreAlloc : public memory
{
	//! Actual allocation pointer
	size_t a_seq ;

	//! Last allocation size
	size_t l_size;

	//! Main class for memory allocation
	Mem * mem;

	//! Reference counter
	long int ref_cnt;

public:

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

	//! Default constructor
	ExtPreAlloc()
	:a_seq(0),l_size(0),mem(NULL),ref_cnt(0)
	{
	}

	/*! \brief Preallocated memory sequence
	 *
	 * \param size number of bytes
	 * \param mem external memory, used if you want to keep the memory
	 *
	 */
	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);
	}

	/*! \brief Set the internal memory if you did not do it in the constructor
     *
	 * \param size number of bytes
	 * \param mem external memory, used if you want to keep the memory
     *
	 */
	void setMemory(size_t size, Mem & mem)
	{
		this->mem = &mem;
		mem.resize(size);
	}

	/*! \brief Get the internal memory if you did not do it in the constructor
     *
	 * \return the internal memory
     *
	 */
	Mem * getMemory()
	{
		return this->mem;
	}

	/*! \brief Copy the memory from device to device
	 *
	 * \param m memory from where to copy
	 *
	 */
	bool copyDeviceToDevice(const ExtPreAlloc<Mem> & m)
	{
		return mem->copyDeviceToDevice(*m.mem);
	}

	/*! \brief special function to move memory from a raw device pointer
	 *
	 * \param start byte
	 * \param stop byte
	 *
	 * \param offset destination byte
	 *
	 */
	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();
	}

	//! Increment the reference counter
	virtual void incRef()
	{ref_cnt++;}

	//! Decrement the reference counter
	virtual void decRef()
	{ref_cnt--;}

	//! Return the reference counter
	virtual long int ref()
	{
		return ref_cnt;
	}

	//! flush the memory
	virtual bool flush() {return mem->flush();};

	/*! \brief fill host and device memory with the selected byte
	 *
	 *
	 */
	virtual void fill(unsigned char c)
	{
		mem->fill(c);
	}

	/*! \brief Allocate a chunk of memory
	 *
	 * Allocate a chunk of memory
	 *
	 * \param sz size of the chunk of memory to allocate in byte
	 *
	 */
	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;
	}

	/*! \brief Allocate a chunk of memory
	 *
	 * Allocate a chunk of memory
	 *
	 * \param sz size of the chunk of memory to allocate in byte
	 *
	 */
	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;
	}

	/*! \brief Return the end pointer of the previous allocated memory
	 *
	 * \return the pointer
	 *
	 */
	void * getPointerEnd()
	{
		return (char *)mem->getPointer() + l_size;
	}

	/*! \brief Return the device end pointer of the previous allocated memory
	 *
	 * \return the pointer
	 *
	 */
	void * getDevicePointerEnd()
	{
		return (char *)mem->getDevicePointer() + l_size;
	}

	/*! \brief The the base pointer of the preallocate memory
	 *
	 * \return the base pointer
	 *
	 */
	void * getPointerBase()
	{
		return mem->getPointer();
	}

	/*! \brief Return the pointer of the last allocation
	 *
	 * NULL if memory has not been allocated
	 * 
	 * \return the pointer
	 *
	 */
	virtual void * getDevicePointer()
	{
		if (mem != NULL)
		{return (((unsigned char *)mem->getDevicePointer()) + a_seq );}
		else {return NULL;}
	}

	/*! \brief Return the pointer of the last allocation
	 *
	 * \return the pointer
	 *
	 */
	virtual void hostToDevice()
	{
		mem->hostToDevice();
	}

	/*! \brief Return the pointer of the last allocation
	 *
	 * \return the pointer
	 *
	 */
	virtual void hostToDevice(size_t start, size_t stop)
	{
		mem->hostToDevice(start,stop);
	}

	//! Do nothing
	virtual void deviceToHost()
	{
		mem->deviceToHost();
	};

	//! Do nothing
	virtual void deviceToHost(size_t start, size_t stop)
	{
		mem->deviceToHost(start,stop);
	};

	/*! \brief Return the pointer of the last allocation
	 *
	 * \return the pointer
	 *
	 */
	virtual void * getPointer()
	{
		return (((unsigned char *)mem->getPointer()) + a_seq );
	}

	/*! \brief Return the pointer of the last allocation
	 *
	 * \return the pointer
	 *
	 */
	virtual const void * getPointer() const
	{
		return (((unsigned char *)mem->getPointer()) + a_seq);
	}

	/*! \brief Get the base memory pointer increased with an offset
	 *
	 * \param offset memory offset
	 *
	 */
	void * getPointerOffset(size_t offset)
	{
		return (((unsigned char *)mem->getPointer()) + offset);
	}

	/*! \brief Allocate or resize the allocated memory
	 *
	 * Resize the allocated memory, if request is smaller than the allocated, memory
	 * is not resized
	 *
	 * \param sz size
	 * \return true if the resize operation complete correctly
	 *
	 */

	virtual bool resize(size_t sz)
	{
		return allocate(sz);
	}

	/*! \brief Get the size of the LAST allocated memory
	 *
	 * Get the size of the allocated memory
	 *
	 * \return the size of the allocated memory
	 *
	 */

	virtual size_t size() const
	{
		return l_size;
	}

	/*! \brief Destroy memory
	 *
	 */

	void destroy()
	{
		mem->destroy();
	}

	/*! \brief Copy memory
	 *
	 */

	virtual bool copy(const memory & m)
	{
		return mem->copy(m);
	}

	/*! \brief Allocated Memory is never initialized
	 *
	 * \return false
	 *
	 */
	bool isInitialized()
	{
		return false;
	}

	/*! \brief Calculate the total memory required to pack the message
	 *
	 * \return the total required memory
	 *
	 */
	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;
	}

	/*! \brief shift the pointer backward
	 *
	 * \warning when you shift backward the pointer, the last allocation is lost
	 * 			this mean that you have to do again an allocation.
	 *
	 * This function is useful to go ahead in memory and fill the memory later on
	 *
	 * \code

	  mem.allocate(16); <------ Here we allocate 16 byte but we do not fill it because
	  	  	  	  	  	  	    subsequently we do another allocation without using mem
	  unsigned char * start = (unsigned char *)mem.getPointer()
	  mem.allocate(100)

	  // ...
	  // ...
	  // Code that fill mem in some way and do other mem.allocate(...)
	  // ...
	  // ...

	  unsigned char * final = (unsigned char *)mem.getPointer()
	  mem.shift_backward(final - start);
	  mem.allocate(16);  <------ Here I am getting the same memory that I request for the
	  	  	  	  	  	  	  	 first allocate

	  // we now fill the memory

	  \endcode
	 *
	 *
	 *
	 * \param how many byte to shift
	 *
	 */
	void shift_backward(size_t sz)
	{
		a_seq -= sz;
		l_size = a_seq;
	}

	/*! \brief shift the pointer forward
	 *
	 * The same as shift backward, but in this case it move the pointer forward
	 *
	 * In general you use this function after the you went back with shift_backward
	 * and you have to move forward again
	 *
	 * \warning when you shift forward the pointer, the last allocation is lost
	 * 			this mean that you have to do again an allocation.
	 *
	 */
	void shift_forward(size_t sz)
	{
		a_seq += sz;
		l_size = a_seq;
	}

	/*! \brief Get offset
	 *
	 * \return the offset
	 *
	 */
	size_t getOffset()
	{
		return a_seq;
	}

	/*! \brief Get offset
	 *
	 * \return the offset
	 *
	 */
	size_t getOffsetEnd()
	{
		return l_size;
	}

	/*! \brief Reset the internal counters
	 *
	 *
	 */
	void reset()
	{
		a_seq = 0;
		l_size = 0;
	}
};

#endif /* PREALLOCHEAPMEMORY_HPP_ */