grid_gpu.hpp

/*
 * grid_gpu.hpp
 *
 *  Created on: Oct 31, 2015
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_GRID_GRID_GPU_HPP_
#define OPENFPM_DATA_SRC_GRID_GRID_GPU_HPP_

template<unsigned int dim, typename T, typename S=CudaMemory , typename Mem = typename memory_traits_inte< typename T::type >::type >
class grid_gpu
{
    // Indicate if set memory has been called
    bool is_mem_init = false;

    typedef grid_key_dx<dim> access_key;

    grid_sm<dim,void> g1;

    Mem data_;

public:

    typedef int yes_i_am_grid;

    typedef typename memory_traits_inte<typename T::type>::type memory_int;

    typedef Mem memory_conf;

    // you can access all the properties of T
    typedef encapg<dim,T,Mem> container;

    // The object type the grid is storing
    typedef T type;

    grid_gpu() THROW
    {
    }

    void setDimensions(std::vector<size_t> & sz)
    {
        g1.setDimension(sz);
    }

    grid_gpu(std::vector<size_t> & sz) THROW
    :g1(sz)
    {
    }

    const grid_sm<dim,void> & getGrid() const
    {
        return g1;
    }

    void setMemory()
    {
        allocate<S> all(g1.size());

        boost::fusion::for_each(data_,all);

        is_mem_init = true;
    }

    template <unsigned int p>inline typename type_gpu_prop<p,memory_int>::type::reference get(grid_key_d<dim,p> & v1)
    {
        return boost::fusion::at_c<p>(data_).mem_r->operator[](g1.LinId(v1));
    }

    template <unsigned int p>inline typename type_gpu_prop<p,memory_int>::type::reference get(grid_key_dx<dim> & v1)
    {
        return boost::fusion::at_c<p>(data_).mem_r->operator[](g1.LinId(v1));
    }

    inline encapg<dim,T,Mem> get_o(grid_key_dx<dim> & v1)
    {
        return encapg<dim,T,Mem>(data_,g1.LinId(v1));
    }

    inline const encapg<dim,T,Mem> get_o(grid_key_dx<dim> & v1) const
    {
        return encapg<dim,T,Mem>(data_,g1.LinId(v1));
    }

    inline size_t size()
    {
        return g1.size();
    }

    void set_memory(memory & mem)
    {
        data_.mem.set_memory(mem);
    }

    inline grid_key_dx_iterator<dim> getIterator()
    {
        return grid_key_dx_iterator<dim>(g1);
    }


    inline grid_key_dx_iterator_sub<dim> getSubIterator(grid_key_dx<dim> & start, grid_key_dx<dim> & stop)
    {
        return grid_key_dx_iterator_sub<dim>(g1,start,stop);
    }

    void swap(grid_gpu<dim,T,S,Mem> & obj)
    {
        g1.swap(obj.g1);
        data_.swap(obj.data_);
    }
};

template<unsigned int dim, typename T>
struct device_g
{
    typedef grid_cpu<dim,T> cpu;
    typedef grid_gpu<dim,T> gpu;
};


#endif /* OPENFPM_DATA_SRC_GRID_GRID_GPU_HPP_ */