main.cu

#define VCLUSTER_PERF_REPORT
#define SYNC_BEFORE_TAKE_TIME
#define ENABLE_GRID_DIST_ID_PERF_STATS
#include "Decomposition/Distribution/BoxDistribution.hpp"
#include "util/cuda_launch.hpp"
#include "Grid/grid_dist_id.hpp"
#include "data_type/aggregate.hpp"
#include "timer.hpp"
 
#ifdef __NVCC__
 
constexpr int U = 0;
constexpr int V = 1;
 
constexpr int U_next = 2;
constexpr int V_next = 3;
 
constexpr int x = 0;
constexpr int y = 1;
constexpr int z = 2;
 
typedef CartDecomposition<3,float, CudaMemory, memory_traits_inte, BoxDistribution<3,float> > Dec;
 
typedef sgrid_dist_id_gpu<3,float,aggregate<float>,CudaMemory, Dec> SparseGridType;
 
void init(SparseGridType & grid, Box<3,float> & domain)
{
 
    typedef typename GetAddBlockType<SparseGridType>::type InsertBlockT;
 
    for (int i = 0 ; i < 10 ; i++)
    {
        timer t;
        t.start();
 
        grid.addPoints([] __device__ (int i, int j, int k)
                    {
                        return true;
                    },
                    [] __device__ (InsertBlockT & data, int i, int j, int k)
                    {
                        data.template get<U>() = 1.0;
                    }
                    );
 
 
        grid.template flush<smax_<U>>(flush_type::FLUSH_ON_DEVICE);
 
        t.stop();
 
        std::cout << "Time populate: " << t.getwct()  << std::endl;
 
            timer t2;
        cudaDeviceSynchronize();
            t2.start();
 
            grid.addPoints([] __device__ (int i, int j, int k)
                                {
                                                return true;
                                },
                                [] __device__ (InsertBlockT & data, int i, int j, int k)
                                {
                                        data.template get<U>() = 5.0;
                                }
                                );
 
 
            grid.template flush<sRight_<U>>(flush_type::FLUSH_ON_DEVICE);
 
        t2.stop();
 
        std::cout << "Time populate: " << t2.getwct()  << std::endl;
    }
}
 
 
int main(int argc, char* argv[])
{
    openfpm_init(&argc,&argv);
 
    // domain
    Box<3,float> domain({0.0,0.0,0.0},{2.5,2.5,2.5});
    
    // grid size
        size_t sz[3] = {512,512,512};
 
    // Define periodicity of the grid
    periodicity<3> bc = {PERIODIC,PERIODIC,PERIODIC};
    
    // Ghost in grid unit
    Ghost<3,long int> g(1);
    
    // deltaT
    float deltaT = 0.25;
 
    // Diffusion constant for specie U
    float du = 2*1e-5;
 
    // Diffusion constant for specie V
    float dv = 1*1e-5;
 
    // Number of timesteps
#ifdef TEST_RUN
    size_t timeSteps = 300;
#else
        size_t timeSteps = 15000;
#endif
 
    // K and F (Physical constant in the equation)
    float K = 0.053;
    float F = 0.014;
 
    SparseGridType grid(sz,domain,g,bc);
 
    // spacing of the grid on x and y
    float spacing[3] = {grid.spacing(0),grid.spacing(1),grid.spacing(2)};
 
    init(grid,domain);
 
    // sync the ghost
    grid.deviceToHost<U>();
    grid.write("final");
    grid.print_stats();
 
 
 
    openfpm_finalize();
 
 
}
 
#else
 
int main(int argc, char* argv[])
{
        return 0;
}
 
#endif