Homec4science
Diffusion lammps (efficient_neuronet) Browse

lammps/src/USER-CUDA/cuda_neigh_list.cpp
4a975dd8cf07efficient_neuronet

Last Change
Raw File

cuda_neigh_list.cpp
View Options

/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
Original Version:
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
See the README file in the top-level LAMMPS directory.
-----------------------------------------------------------------------
USER-CUDA Package and associated modifications:
https://sourceforge.net/projects/lammpscuda/
Christian Trott, christian.trott@tu-ilmenau.de
Lars Winterfeld, lars.winterfeld@tu-ilmenau.de
Theoretical Physics II, University of Technology Ilmenau, Germany
See the README file in the USER-CUDA directory.
This software is distributed under the GNU General Public License.
------------------------------------------------------------------------- */
#include "cuda_neigh_list.h"
#include "neigh_list.h"
#include <cstring>
#include <vector>
#include <map>
#include <algorithm>
#include "user_cuda.h"
#include "atom.h"
#include "error.h"
using namespace LAMMPS_NS;
CudaNeighList::CudaNeighList(LAMMPS *lmp, class NeighList* neigh_list) : Pointers(lmp)
{
cuda = lmp->cuda;
if(cuda == NULL)
error->all(FLERR,"You cannot use a /cuda class, without activating 'cuda' acceleration. Provide '-c on' as command-line argument to LAMMPS..");
MYDBG(printf("# CUDA: CudaNeighList::cudaNeighList() ... start\n");)
this->neigh_list = neigh_list;
neigh_list->cuda_list=this;
sneighlist.maxlocal = neigh_list->get_maxlocal();
sneighlist.maxneighbors = 32;
sneighlist.maxcut = 0.0;
sneighlist.cutneighsq = NULL;
cu_neighbors = NULL;
cu_neighbors_border = NULL;
cu_neighbors_inner = NULL;
cu_numneigh_border = NULL;
cu_numneigh_inner = NULL;
cu_numneigh = NULL;
cu_ilist = NULL;
cu_ilist_border = NULL;
cu_inum_border = NULL;
inum_border = 0;
neighbors = NULL;
neighbors_inner = NULL;
neighbors_border = NULL;
numneigh_border = NULL;
numneigh_inner = NULL;
ilist_border = NULL;
build_cuda = false;
sneighlist.binned_id=NULL;
sneighlist.bin_dim=new int[3];
sneighlist.bin_dim[0]=0;
sneighlist.bin_dim[1]=0;
sneighlist.bin_dim[2]=0;
cu_ex_type = NULL;
cu_ex1_bit = NULL;
cu_ex2_bit = NULL;
cu_ex_mol_bit = NULL;
sneighlist.nex_type=0;
sneighlist.nex_group=0;
sneighlist.nex_mol=0;
sneighlist.bin_nmax=0;
sneighlist.bin_extraspace=0.05;
MYDBG(printf("# CUDA: CudaNeighList::cudaNeighList() ... end\n");)
}
CudaNeighList::~CudaNeighList()
{
dev_free();
}
void CudaNeighList::dev_alloc()
{
MYDBG( printf("# CUDA: CudaNeighList::dev_alloc() ... start\n"); )
cu_ilist = new cCudaData<int , int , x> (neigh_list->ilist , & sneighlist.ilist , sneighlist.maxlocal );
cu_numneigh = new cCudaData<int , int , x> (neigh_list->numneigh, & sneighlist.numneigh , sneighlist.maxlocal );
neighbors = new int[atom->nmax*sneighlist.maxneighbors];
cu_neighbors= new cCudaData<int, int, x> (neighbors , & sneighlist.neighbors, atom->nmax*sneighlist.maxneighbors );
if(cuda->shared_data.overlap_comm)
{
ilist_border = new int[sneighlist.maxlocal];
numneigh_border = new int[sneighlist.maxlocal];
numneigh_inner = new int[sneighlist.maxlocal];
cu_inum_border = new cCudaData<int , int , x> (&inum_border , & sneighlist.inum_border , 1 );
cu_ilist_border = new cCudaData<int , int , x> (ilist_border , & sneighlist.ilist_border , sneighlist.maxlocal );
cu_numneigh_border = new cCudaData<int , int , x> (numneigh_border , & sneighlist.numneigh_border , sneighlist.maxlocal );
cu_numneigh_inner = new cCudaData<int , int , x> (numneigh_inner , & sneighlist.numneigh_inner , sneighlist.maxlocal );
neighbors_border = new int[sneighlist.maxlocal*sneighlist.maxneighbors];
cu_neighbors_border= new cCudaData<int, int, x> (neighbors_border , & sneighlist.neighbors_border, sneighlist.maxlocal*sneighlist.maxneighbors );
neighbors_inner = new int[sneighlist.maxlocal*sneighlist.maxneighbors];
cu_neighbors_inner = new cCudaData<int, int, x> (neighbors_inner , & sneighlist.neighbors_inner , sneighlist.maxlocal*sneighlist.maxneighbors );
}
cuda->shared_data.atom.update_neigh=2;
MYDBG( printf("# CUDA: CudaNeighList::dev_alloc() ... end\n"); )
}
void CudaNeighList::dev_free()
{
MYDBG( printf("# CUDA: CudaNeighList::dev_free() ... start\n"); )
delete cu_numneigh;
delete cu_ilist;
delete [] neighbors;
delete cu_neighbors;
if(cuda->shared_data.overlap_comm)
{
delete [] ilist_border;
delete [] numneigh_border;
delete [] numneigh_inner;
delete [] neighbors_border;
delete [] neighbors_inner;
delete cu_inum_border;
delete cu_neighbors_border;
delete cu_neighbors_inner;
delete cu_numneigh_border;
delete cu_numneigh_inner;
delete cu_ilist_border;
}
MYDBG( printf("# CUDA: CudaNeighList::dev_free() ... end\n"); )
}
void CudaNeighList::grow_device()
{
MYDBG(printf("# CUDA: CudaNeighList::grow_device() ... start\n");)
// if host has allocated more memory for atom arrays than device has, then allocate more memory on device
int new_maxlocal = neigh_list->get_maxlocal();
if(sneighlist.maxlocal < new_maxlocal)
{
sneighlist.maxlocal = new_maxlocal;
dev_free();
dev_alloc();
}
if(!cu_ilist || !cu_numneigh) dev_alloc();
// check, if hosts data has been allocated somewhere else
if(cu_ilist ->get_host_data() != neigh_list->ilist) cu_ilist ->set_host_data(neigh_list->ilist);
if(cu_numneigh->get_host_data() != neigh_list->numneigh) cu_numneigh->set_host_data(neigh_list->numneigh);
MYDBG(printf("# CUDA: CudaNeighList::grow_device() ... end\n");)
}
void CudaNeighList::nl_upload(bool will_be_changed)
{
//return;
MYDBG(printf("# CUDA: CudaNeighList::nl_upload() ... start\n");)
if(cu_ilist)
cu_ilist->upload();
if(cu_numneigh)
cu_numneigh->upload();
MYDBG(printf("# CUDA: CudaNeighList::nl_upload() ... end\n");)
}
void CudaNeighList::nl_download(bool will_be_changed)
{
MYDBG(printf("# CUDA: CudaNeighList::nl_download() ... start\n");)
if(cu_ilist)
cu_ilist->download();
if(cu_numneigh)
cu_numneigh->download();
MYDBG(printf("# CUDA: CudaNeighList::nl_download() ... end\n");)
}
c4science · Help