memory_array.hpp

/*
 * memory_stride.hpp
 *
 *  Created on: Aug 17, 2014
 *      Author: Pietro Incardona
 */
 
#ifndef MEMORY_ARRAY_HPP_
#define MEMORY_ARRAY_HPP_
 
#include "memory/memory.hpp"
 
#include "util/cuda_util.hpp"
 
template<typename T>
class memory_array
{
 
#if defined(__GNUG__) || defined(__clang__)
 
    T __attribute__((aligned(16))) * ptr;
 
#else
 
    T * ptr;
 
#endif
 
    size_t sz;
 
    T get(mem_id i)
    {
        return ptr[i];
    }
 
 
    public:
 
    typedef T value_type;
 
    void initialize(void * ptr, size_t sz, bool init)
    {
        this->ptr = static_cast<T *>(ptr);
 
 
        // Initialize the constructors
 
        if (init == false)
            new (ptr)T[sz];
 
        this->sz = sz;
    }
 
    size_t size()
    {
        return sz;
    }
 
    void set_pointer(void * ptr_)
    {
        ptr = static_cast<T *>(ptr_);
    }
 
    __device__ __host__ void * get_pointer() const
    {
        return ptr;
    }
 
    template<typename Tbind> void bind_ref(const memory_array<Tbind> & ref)
    {
        ptr = static_cast<T *>(ref.get_pointer());
    }
 
    __host__ __device__ T & operator[](mem_id i)
    {
        return ptr[i];
    }
 
    __host__ __device__ const T & operator[](mem_id i) const
    {
        return ptr[i];
    }
 
    void swap(memory_array<T> & obj)
    {
        size_t sz_tmp = sz;
        sz = obj.sz;
        obj.sz = sz_tmp;
 
        T * ptr_tmp = ptr;
        ptr = obj.ptr;
        obj.ptr = ptr_tmp;
    }
 
    void deinit()
    {
        // Call the destructor of every objects
        for (size_t i = 0 ; i < sz ; i++)
        {
            (&ptr[i])->~T();
        }
    }
 
    memory_array()
    :ptr(NULL),sz(0)
    {};
 
    memory_array(void * ptr, size_t sz, bool init)
    {
        initialize(ptr,sz,init);
    }
 
    ~memory_array()
    {
    };
};
 
 
#endif