PtrMemory.cpp

/*
 * PtrMemory.cpp
 *
 *  Created on: Apr 15, 2015
 *      Author: i-bird
 */
 
#ifndef PTRMEMORY_CPP_
#define PTRMEMORY_CPP_
 
#include "PtrMemory.hpp"
#include <cstddef>
#include <cstring>
#include <iostream>
#include <cstdint>
 
void PtrMemory::fill(unsigned char c)
{
    memset(dm,c,this->size());
}
 
bool PtrMemory::allocate(size_t sz)
{
    if (sz <= spm)
        return true;
 
    std::cerr << "Error: " << __FILE__ << " " << __LINE__ << " allocation failed";
    return false;
}
 
void PtrMemory::destroy()
{
}
 
 
bool PtrMemory::copyFromPointer(const void * ptr,size_t sz)
{
    // memory copy
 
    memcpy(dm,ptr,sz);
 
    return true;
}
 
bool PtrMemory::copyDeviceToDevice(const PtrMemory & m)
{
 
    if (m.spm > spm)
    {
        std::cerr << "Error " << __LINE__ << " " << __FILE__ << ": source buffer is too big to copy";
        return false;
    }
 
    // Copy the memory from m
    memcpy(dm,m.dm,m.spm);
    return true;
}
 
bool PtrMemory::copy(const memory & m)
{
    const PtrMemory * ofpm = dynamic_cast<const PtrMemory *>(&m);
 
 
    if (ofpm == NULL)
    {
        // copy the memory from device to host and from host to device
 
        return copyFromPointer(m.getPointer(),m.size());
    }
    else
    {
        // they are the same memory type, use cuda/thrust buffer copy
 
        return copyDeviceToDevice(*ofpm);
    }
    return false;
}
 
size_t PtrMemory::size() const
{
    return spm;
}
 
bool PtrMemory::resize(size_t sz)
{
    // if the allocated memory is enough, do not resize
    if (sz <= spm)
    {
        this->spm = sz;
        return true;
    }
 
    std::cerr << "Error: " << __FILE__ << " " << __LINE__ << " allocation failed";
    return false;
}
 
void * PtrMemory::getPointer()
{
    return dm;
}
 
void * PtrMemory::getDevicePointer()
{
    return dm;
}
 
 
const void * PtrMemory::getPointer() const
{
    return dm;
}
 
 
#endif /* PTRMEMORY_CPP_ */