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