Merge pull request #53 from stanmoore1/new-neighbor (b34be30b) · Commits · 郑智淋 / lammps

src/KOKKOS/Install.sh

+6 −1

Original line number	Diff line number	Diff line
		@@ -105,11 +105,16 @@ action modify_kokkos.cpp
		action modify_kokkos.h
		action neigh_bond_kokkos.cpp
		action neigh_bond_kokkos.h
		action neigh_full_kokkos.h
		action neigh_list_kokkos.cpp
		action neigh_list_kokkos.h
		action neighbor_kokkos.cpp
		action neighbor_kokkos.h
		action npair_copy_kokkos.cpp
		action npair_copy_kokkos.h
		action npair_kokkos.cpp
		action npair_kokkos.h
		action nbin_kokkos.cpp
		action nbin_kokkos.h
		action math_special_kokkos.cpp
		action math_special_kokkos.h
		action pair_buck_coul_cut_kokkos.cpp

src/KOKKOS/fix_qeq_reax_kokkos.cpp

+0 −2

Original line number	Diff line number	Diff line
		@@ -125,12 +125,10 @@ void FixQEqReaxKokkos<DeviceType>::init()
		neighbor->requests[irequest]->pair = 0;
		neighbor->requests[irequest]->full = 1;
		neighbor->requests[irequest]->half = 0;
		neighbor->requests[irequest]->full_cluster = 0;
		} else { //if (neighflag == HALF \|\| neighflag == HALFTHREAD)
		neighbor->requests[irequest]->fix = 1;
		neighbor->requests[irequest]->full = 0;
		neighbor->requests[irequest]->half = 1;
		neighbor->requests[irequest]->full_cluster = 0;
		neighbor->requests[irequest]->ghost = 1;
		}
		}

src/KOKKOS/kokkos.cpp

+18 −31

Original line number	Diff line number	Diff line
		@@ -168,7 +168,6 @@ void KokkosLMP::accelerator(int narg, char **arg)
		else
		neighflag = HALF;
		} else if (strcmp(arg[iarg+1],"n2") == 0) neighflag = N2;
		else if (strcmp(arg[iarg+1],"full/cluster") == 0) neighflag = FULLCLUSTER;
		else error->all(FLERR,"Illegal package kokkos command");
		iarg += 2;
		} else if (strcmp(arg[iarg],"binsize") == 0) {
		@@ -232,20 +231,6 @@ void KokkosLMP::accelerator(int narg, char **arg)
		called by Finish
		------------------------------------------------------------------------- */

		int KokkosLMP::neigh_list_kokkos(int m)
		{
		NeighborKokkos nk = (NeighborKokkos ) neighbor;
		if (nk->lists_host[m] && nk->lists_host[m]->d_numneigh.dimension_0())
		return 1;
		if (nk->lists_device[m] && nk->lists_device[m]->d_numneigh.dimension_0())
		return 1;
		return 0;
		}

		/* ----------------------------------------------------------------------
		called by Finish
		------------------------------------------------------------------------- */

		int KokkosLMP::neigh_count(int m)
		{
		int inum;
		@@ -255,28 +240,30 @@ int KokkosLMP::neigh_count(int m)
		ArrayTypes<LMPHostType>::t_int_1d h_numneigh;

		NeighborKokkos nk = (NeighborKokkos ) neighbor;
		if (nk->lists_host[m]) {
		inum = nk->lists_host[m]->inum;
		if (nk->lists[m]->execution_space == Host) {
		NeighListKokkos<LMPHostType>* nlistKK = (NeighListKokkos<LMPHostType>*) nk->lists[m];
		inum = nlistKK->inum;
		#ifndef KOKKOS_USE_CUDA_UVM
		h_ilist = Kokkos::create_mirror_view(nk->lists_host[m]->d_ilist);
		h_numneigh = Kokkos::create_mirror_view(nk->lists_host[m]->d_numneigh);
		h_ilist = Kokkos::create_mirror_view(nlistKK->d_ilist);
		h_numneigh = Kokkos::create_mirror_view(nlistKK->d_numneigh);
		#else
		h_ilist = nk->lists_host[m]->d_ilist;
		h_numneigh = nk->lists_host[m]->d_numneigh;
		h_ilist = nlistKK->d_ilist;
		h_numneigh = nlistKK->d_numneigh;
		#endif
		Kokkos::deep_copy(h_ilist,nk->lists_host[m]->d_ilist);
		Kokkos::deep_copy(h_numneigh,nk->lists_host[m]->d_numneigh);
		} else if (nk->lists_device[m]) {
		inum = nk->lists_device[m]->inum;
		Kokkos::deep_copy(h_ilist,nlistKK->d_ilist);
		Kokkos::deep_copy(h_numneigh,nlistKK->d_numneigh);
		} else if (nk->lists[m]->execution_space == Device) {
		NeighListKokkos<LMPDeviceType>* nlistKK = (NeighListKokkos<LMPDeviceType>*) nk->lists[m];
		inum = nlistKK->inum;
		#ifndef KOKKOS_USE_CUDA_UVM
		h_ilist = Kokkos::create_mirror_view(nk->lists_device[m]->d_ilist);
		h_numneigh = Kokkos::create_mirror_view(nk->lists_device[m]->d_numneigh);
		h_ilist = Kokkos::create_mirror_view(nlistKK->d_ilist);
		h_numneigh = Kokkos::create_mirror_view(nlistKK->d_numneigh);
		#else
		h_ilist = nk->lists_device[m]->d_ilist;
		h_numneigh = nk->lists_device[m]->d_numneigh;
		h_ilist = nlistKK->d_ilist;
		h_numneigh = nlistKK->d_numneigh;
		#endif
		Kokkos::deep_copy(h_ilist,nk->lists_device[m]->d_ilist);
		Kokkos::deep_copy(h_numneigh,nk->lists_device[m]->d_numneigh);
		Kokkos::deep_copy(h_ilist,nlistKK->d_ilist);
		Kokkos::deep_copy(h_numneigh,nlistKK->d_numneigh);
		}

		for (int i = 0; i < inum; i++) nneigh += h_numneigh[h_ilist[i]];

src/KOKKOS/kokkos.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -34,7 +34,6 @@ class KokkosLMP : protected Pointers {
		KokkosLMP(class LAMMPS , int, char *);
		~KokkosLMP();
		void accelerator(int, char **);
		int neigh_list_kokkos(int);
		int neigh_count(int);
		private:
		static void my_signal_handler(int);

src/KOKKOS/nbin_kokkos.cpp

0 → 100644

+145 −0

Original line number	Diff line number	Diff line
		/* ----------------------------------------------------------------------
		LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
		http://lammps.sandia.gov, Sandia National Laboratories
		Steve Plimpton, sjplimp@sandia.gov

		Copyright (2003) Sandia Corporation. Under the terms of Contract
		DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
		certain rights in this software. This software is distributed under
		the GNU General Public License.

		See the README file in the top-level LAMMPS directory.
		------------------------------------------------------------------------- */

		#include "nbin_kokkos.h"
		#include "neighbor.h"
		#include "atom_kokkos.h"
		#include "group.h"
		#include "domain.h"
		#include "comm.h"
		#include "update.h"
		#include "error.h"
		#include "atom_masks.h"

		using namespace LAMMPS_NS;

		enum{NSQ,BIN,MULTI}; // also in Neighbor

		#define SMALL 1.0e-6
		#define CUT2BIN_RATIO 100

		/* ---------------------------------------------------------------------- */

		template<class DeviceType>
		NBinKokkos<DeviceType>::NBinKokkos(LAMMPS *lmp) : NBinStandard(lmp) {
		atoms_per_bin = 16;

		d_resize = typename AT::t_int_scalar("NeighborKokkosFunctor::resize");
		#ifndef KOKKOS_USE_CUDA_UVM
		h_resize = Kokkos::create_mirror_view(d_resize);
		#else
		h_resize = d_resize;
		#endif
		h_resize() = 1;

		}

		/* ----------------------------------------------------------------------
		setup neighbor binning geometry
		bin numbering in each dimension is global:
		0 = 0.0 to binsize, 1 = binsize to 2*binsize, etc
		nbin-1,nbin,etc = bbox-binsize to bbox, bbox to bbox+binsize, etc
		-1,-2,etc = -binsize to 0.0, -2*binsize to -binsize, etc
		code will work for any binsize
		since next(xyz) and stencil extend as far as necessary
		binsize = 1/2 of cutoff is roughly optimal
		for orthogonal boxes:
		a dim must be filled exactly by integer # of bins
		in periodic, procs on both sides of PBC must see same bin boundary
		in non-periodic, coord2bin() still assumes this by use of nbin xyz
		for triclinic boxes:
		tilted simulation box cannot contain integer # of bins
		stencil & neigh list built differently to account for this
		mbinlo = lowest global bin any of my ghost atoms could fall into
		mbinhi = highest global bin any of my ghost atoms could fall into
		mbin = number of bins I need in a dimension
		------------------------------------------------------------------------- */

		template<class DeviceType>
		void NBinKokkos<DeviceType>::bin_atoms_setup(int nall)
		{
		if (mbins > k_bins.d_view.dimension_0()) {
		k_bins = DAT::tdual_int_2d("Neighbor::d_bins",mbins,atoms_per_bin);
		bins = k_bins.view<DeviceType>();

		k_bincount = DAT::tdual_int_1d("Neighbor::d_bincount",mbins);
		bincount = k_bincount.view<DeviceType>();
		last_bin_memory = update->ntimestep;
		}

		last_bin = update->ntimestep;
		}

		/* ----------------------------------------------------------------------
		bin owned and ghost atoms
		------------------------------------------------------------------------- */

		template<class DeviceType>
		void NBinKokkos<DeviceType>::bin_atoms()
		{
		h_resize() = 1;

		while(h_resize() > 0) {
		h_resize() = 0;
		deep_copy(d_resize, h_resize);

		MemsetZeroFunctor<DeviceType> f_zero;
		f_zero.ptr = (void*) k_bincount.view<DeviceType>().ptr_on_device();
		Kokkos::parallel_for(mbins, f_zero);
		DeviceType::fence();

		atomKK->sync(ExecutionSpaceFromDevice<DeviceType>::space,X_MASK);
		x = atomKK->k_x.view<DeviceType>();

		bboxlo_[0] = bboxlo[0]; bboxlo_[1] = bboxlo[1]; bboxlo_[2] = bboxlo[2];
		bboxhi_[0] = bboxhi[0]; bboxhi_[1] = bboxhi[1]; bboxhi_[2] = bboxhi[2];

		NPairKokkosBinAtomsFunctor<DeviceType> f(*this);

		Kokkos::parallel_for(atom->nlocal+atom->nghost, f);
		DeviceType::fence();

		deep_copy(h_resize, d_resize);
		if(h_resize()) {

		atoms_per_bin += 16;
		k_bins = DAT::tdual_int_2d("bins", mbins, atoms_per_bin);
		bins = k_bins.view<DeviceType>();
		c_bins = bins;
		last_bin_memory = update->ntimestep;
		}
		}
		}

		/* ---------------------------------------------------------------------- */

		template<class DeviceType>
		KOKKOS_INLINE_FUNCTION
		void NBinKokkos<DeviceType>::binatomsItem(const int &i) const
		{
		const int ibin = coord2bin(x(i, 0), x(i, 1), x(i, 2));

		const int ac = Kokkos::atomic_fetch_add(&bincount[ibin], (int)1);
		if(ac < bins.dimension_1()) {
		bins(ibin, ac) = i;
		} else {
		d_resize() = 1;
		}
		}

		namespace LAMMPS_NS {
		template class NBinKokkos<LMPDeviceType>;
		#ifdef KOKKOS_HAVE_CUDA
		template class NBinKokkos<LMPHostType>;
		#endif
		}

Admin message