Add data duplication to pair_eam_kokkos variants (ebc0abbb) · Commits · 郑智淋 / lammps

src/KOKKOS/pair_eam_alloy_kokkos.cpp

+57 −29

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ using namespace LAMMPS_NS;

		// Cannot use virtual inheritance on the GPU, so must duplicate code


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

		template<class DeviceType>
		@@ -122,6 +123,19 @@ void PairEAMAlloyKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
		d_ilist = k_list->d_ilist;
		int inum = list->inum;

		need_dup = lmp->kokkos->need_dup<DeviceType>();
		if (need_dup) {
		dup_rho = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated>(d_rho);
		dup_f = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated>(f);
		dup_eatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated>(d_eatom);
		dup_vatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated>(d_vatom);
		} else {
		ndup_rho = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated>(d_rho);
		ndup_f = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated>(f);
		ndup_eatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated>(d_eatom);
		ndup_vatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated>(d_vatom);
		}

		copymode = 1;

		// zero out density
		@@ -233,6 +247,9 @@ void PairEAMAlloyKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
		}
		}

		if (need_dup)
		Kokkos::Experimental::contribute(f, dup_f);

		if (eflag_global) eng_vdwl += ev.evdwl;
		if (vflag_global) {
		virial[0] += ev.v[0];
		@@ -244,11 +261,15 @@ void PairEAMAlloyKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
		}

		if (eflag_atom) {
		if (need_dup)
		Kokkos::Experimental::contribute(d_eatom, dup_eatom);
		k_eatom.template modify<DeviceType>();
		k_eatom.template sync<LMPHostType>();
		}

		if (vflag_atom) {
		if (need_dup)
		Kokkos::Experimental::contribute(d_vatom, dup_vatom);
		k_vatom.template modify<DeviceType>();
		k_vatom.template sync<LMPHostType>();
		}
		@@ -503,8 +524,10 @@ void PairEAMAlloyKokkos<DeviceType>::operator()(TagPairEAMAlloyKernelA<NEIGHFLAG
		// rho = density at each atom
		// loop over neighbors of my atoms

		// The rho array is atomic for Half/Thread neighbor style
		Kokkos::View<F_FLOAT*, typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > rho = v_rho;
		// The rho array is duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_rho = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_rho),decltype(ndup_rho)>::get(dup_rho,ndup_rho);
		auto a_rho = v_rho.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		const int i = d_ilist[ii];
		const X_FLOAT xtmp = x(i,0);
		@@ -672,8 +695,10 @@ template<int NEIGHFLAG, int NEWTON_PAIR, int EVFLAG>
		KOKKOS_INLINE_FUNCTION
		void PairEAMAlloyKokkos<DeviceType>::operator()(TagPairEAMAlloyKernelC<NEIGHFLAG,NEWTON_PAIR,EVFLAG>, const int &ii, EV_FLOAT& ev) const {

		// The f array is atomic for Half/Thread neighbor style
		Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
		// The f array is duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_f = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_f),decltype(ndup_f)>::get(dup_f,ndup_f);
		auto a_f = v_f.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		const int i = d_ilist[ii];
		const X_FLOAT xtmp = x(i,0);
		@@ -780,18 +805,22 @@ void PairEAMAlloyKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const
		const int EFLAG = eflag;
		const int VFLAG = vflag_either;

		// The eatom and vatom arrays are atomic for Half/Thread neighbor style
		Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
		Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
		// The eatom and vatom arrays are duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_eatom = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_eatom),decltype(ndup_eatom)>::get(dup_eatom,ndup_eatom);
		auto a_eatom = v_eatom.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		auto v_vatom = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_vatom),decltype(ndup_vatom)>::get(dup_vatom,ndup_vatom);
		auto a_vatom = v_vatom.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		if (EFLAG) {
		if (eflag_atom) {
		const E_FLOAT epairhalf = 0.5 * epair;
		if (NEIGHFLAG!=FULL) {
		if (NEWTON_PAIR \|\| i < nlocal) v_eatom[i] += epairhalf;
		if (NEWTON_PAIR \|\| j < nlocal) v_eatom[j] += epairhalf;
		if (NEWTON_PAIR \|\| i < nlocal) a_eatom[i] += epairhalf;
		if (NEWTON_PAIR \|\| j < nlocal) a_eatom[j] += epairhalf;
		} else {
		v_eatom[i] += epairhalf;
		a_eatom[i] += epairhalf;
		}
		}
		}
		@@ -835,28 +864,28 @@ void PairEAMAlloyKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const
		if (vflag_atom) {
		if (NEIGHFLAG!=FULL) {
		if (NEWTON_PAIR \|\| i < nlocal) {
		v_vatom(i,0) += 0.5*v0;
		v_vatom(i,1) += 0.5*v1;
		v_vatom(i,2) += 0.5*v2;
		v_vatom(i,3) += 0.5*v3;
		v_vatom(i,4) += 0.5*v4;
		v_vatom(i,5) += 0.5*v5;
		a_vatom(i,0) += 0.5*v0;
		a_vatom(i,1) += 0.5*v1;
		a_vatom(i,2) += 0.5*v2;
		a_vatom(i,3) += 0.5*v3;
		a_vatom(i,4) += 0.5*v4;
		a_vatom(i,5) += 0.5*v5;
		}
		if (NEWTON_PAIR \|\| j < nlocal) {
		v_vatom(j,0) += 0.5*v0;
		v_vatom(j,1) += 0.5*v1;
		v_vatom(j,2) += 0.5*v2;
		v_vatom(j,3) += 0.5*v3;
		v_vatom(j,4) += 0.5*v4;
		v_vatom(j,5) += 0.5*v5;
		a_vatom(j,0) += 0.5*v0;
		a_vatom(j,1) += 0.5*v1;
		a_vatom(j,2) += 0.5*v2;
		a_vatom(j,3) += 0.5*v3;
		a_vatom(j,4) += 0.5*v4;
		a_vatom(j,5) += 0.5*v5;
		}
		} else {
		v_vatom(i,0) += 0.5*v0;
		v_vatom(i,1) += 0.5*v1;
		v_vatom(i,2) += 0.5*v2;
		v_vatom(i,3) += 0.5*v3;
		v_vatom(i,4) += 0.5*v4;
		v_vatom(i,5) += 0.5*v5;
		a_vatom(i,0) += 0.5*v0;
		a_vatom(i,1) += 0.5*v1;
		a_vatom(i,2) += 0.5*v2;
		a_vatom(i,3) += 0.5*v3;
		a_vatom(i,4) += 0.5*v4;
		a_vatom(i,5) += 0.5*v5;
		}
		}
		}
		@@ -1165,4 +1194,3 @@ template class PairEAMAlloyKokkos<LMPDeviceType>;
		template class PairEAMAlloyKokkos<LMPHostType>;
		#endif
		}

src/KOKKOS/pair_eam_alloy_kokkos.h

+10 −0

Original line number	Diff line number	Diff line
		@@ -129,6 +129,16 @@ class PairEAMAlloyKokkos : public PairEAM, public KokkosBase {
		typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
		typename ArrayTypes<DeviceType>::t_virial_array d_vatom;

		int need_dup;
		Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_rho;
		Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
		Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
		Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
		Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_rho;
		Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
		Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
		Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;

		DAT::tdual_ffloat_1d k_rho;
		DAT::tdual_ffloat_1d k_fp;
		typename AT::t_ffloat_1d d_rho;

src/KOKKOS/pair_eam_fs_kokkos.cpp

+56 −29

Original line number	Diff line number	Diff line
		@@ -122,6 +122,19 @@ void PairEAMFSKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
		d_ilist = k_list->d_ilist;
		int inum = list->inum;

		need_dup = lmp->kokkos->need_dup<DeviceType>();
		if (need_dup) {
		dup_rho = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated>(d_rho);
		dup_f = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated>(f);
		dup_eatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated>(d_eatom);
		dup_vatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterDuplicated>(d_vatom);
		} else {
		ndup_rho = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated>(d_rho);
		ndup_f = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated>(f);
		ndup_eatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated>(d_eatom);
		ndup_vatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, Kokkos::Experimental::ScatterNonDuplicated>(d_vatom);
		}

		copymode = 1;

		// zero out density
		@@ -233,6 +246,9 @@ void PairEAMFSKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
		}
		}

		if (need_dup)
		Kokkos::Experimental::contribute(f, dup_f);

		if (eflag_global) eng_vdwl += ev.evdwl;
		if (vflag_global) {
		virial[0] += ev.v[0];
		@@ -246,11 +262,15 @@ void PairEAMFSKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
		if (vflag_fdotr) pair_virial_fdotr_compute(this);

		if (eflag_atom) {
		if (need_dup)
		Kokkos::Experimental::contribute(d_eatom, dup_eatom);
		k_eatom.template modify<DeviceType>();
		k_eatom.template sync<LMPHostType>();
		}

		if (vflag_atom) {
		if (need_dup)
		Kokkos::Experimental::contribute(d_vatom, dup_vatom);
		k_vatom.template modify<DeviceType>();
		k_vatom.template sync<LMPHostType>();
		}
		@@ -503,8 +523,10 @@ void PairEAMFSKokkos<DeviceType>::operator()(TagPairEAMFSKernelA<NEIGHFLAG,NEWTO
		// rho = density at each atom
		// loop over neighbors of my atoms

		// The rho array is atomic for Half/Thread neighbor style
		Kokkos::View<F_FLOAT*, typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > rho = v_rho;
		// The rho array is duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_rho = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_rho),decltype(ndup_rho)>::get(dup_rho,ndup_rho);
		auto a_rho = v_rho.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		const int i = d_ilist[ii];
		const X_FLOAT xtmp = x(i,0);
		@@ -672,8 +694,10 @@ template<int NEIGHFLAG, int NEWTON_PAIR, int EVFLAG>
		KOKKOS_INLINE_FUNCTION
		void PairEAMFSKokkos<DeviceType>::operator()(TagPairEAMFSKernelC<NEIGHFLAG,NEWTON_PAIR,EVFLAG>, const int &ii, EV_FLOAT& ev) const {

		// The f array is atomic for Half/Thread neighbor style
		Kokkos::View<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > a_f = f;
		// The f array is duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_f = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_f),decltype(ndup_f)>::get(dup_f,ndup_f);
		auto a_f = v_f.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		const int i = d_ilist[ii];
		const X_FLOAT xtmp = x(i,0);
		@@ -780,18 +804,22 @@ void PairEAMFSKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const int
		const int EFLAG = eflag;
		const int VFLAG = vflag_either;

		// The eatom and vatom arrays are atomic for Half/Thread neighbor style
		Kokkos::View<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_eatom = k_eatom.view<DeviceType>();
		Kokkos::View<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::MemoryTraits<AtomicF<NEIGHFLAG>::value> > v_vatom = k_vatom.view<DeviceType>();
		// The eatom and vatom arrays are duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_eatom = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_eatom),decltype(ndup_eatom)>::get(dup_eatom,ndup_eatom);
		auto a_eatom = v_eatom.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		auto v_vatom = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_vatom),decltype(ndup_vatom)>::get(dup_vatom,ndup_vatom);
		auto a_vatom = v_vatom.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		if (EFLAG) {
		if (eflag_atom) {
		const E_FLOAT epairhalf = 0.5 * epair;
		if (NEIGHFLAG!=FULL) {
		if (NEWTON_PAIR \|\| i < nlocal) v_eatom[i] += epairhalf;
		if (NEWTON_PAIR \|\| j < nlocal) v_eatom[j] += epairhalf;
		if (NEWTON_PAIR \|\| i < nlocal) a_eatom[i] += epairhalf;
		if (NEWTON_PAIR \|\| j < nlocal) a_eatom[j] += epairhalf;
		} else {
		v_eatom[i] += epairhalf;
		a_eatom[i] += epairhalf;
		}
		}
		}
		@@ -835,28 +863,28 @@ void PairEAMFSKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const int
		if (vflag_atom) {
		if (NEIGHFLAG!=FULL) {
		if (NEWTON_PAIR \|\| i < nlocal) {
		v_vatom(i,0) += 0.5*v0;
		v_vatom(i,1) += 0.5*v1;
		v_vatom(i,2) += 0.5*v2;
		v_vatom(i,3) += 0.5*v3;
		v_vatom(i,4) += 0.5*v4;
		v_vatom(i,5) += 0.5*v5;
		a_vatom(i,0) += 0.5*v0;
		a_vatom(i,1) += 0.5*v1;
		a_vatom(i,2) += 0.5*v2;
		a_vatom(i,3) += 0.5*v3;
		a_vatom(i,4) += 0.5*v4;
		a_vatom(i,5) += 0.5*v5;
		}
		if (NEWTON_PAIR \|\| j < nlocal) {
		v_vatom(j,0) += 0.5*v0;
		v_vatom(j,1) += 0.5*v1;
		v_vatom(j,2) += 0.5*v2;
		v_vatom(j,3) += 0.5*v3;
		v_vatom(j,4) += 0.5*v4;
		v_vatom(j,5) += 0.5*v5;
		a_vatom(j,0) += 0.5*v0;
		a_vatom(j,1) += 0.5*v1;
		a_vatom(j,2) += 0.5*v2;
		a_vatom(j,3) += 0.5*v3;
		a_vatom(j,4) += 0.5*v4;
		a_vatom(j,5) += 0.5*v5;
		}
		} else {
		v_vatom(i,0) += 0.5*v0;
		v_vatom(i,1) += 0.5*v1;
		v_vatom(i,2) += 0.5*v2;
		v_vatom(i,3) += 0.5*v3;
		v_vatom(i,4) += 0.5*v4;
		v_vatom(i,5) += 0.5*v5;
		a_vatom(i,0) += 0.5*v0;
		a_vatom(i,1) += 0.5*v1;
		a_vatom(i,2) += 0.5*v2;
		a_vatom(i,3) += 0.5*v3;
		a_vatom(i,4) += 0.5*v4;
		a_vatom(i,5) += 0.5*v5;
		}
		}
		}
		@@ -1174,4 +1202,3 @@ template class PairEAMFSKokkos<LMPDeviceType>;
		template class PairEAMFSKokkos<LMPHostType>;
		#endif
		}

src/KOKKOS/pair_eam_fs_kokkos.h

+10 −0

Original line number	Diff line number	Diff line
		@@ -129,6 +129,16 @@ class PairEAMFSKokkos : public PairEAM, public KokkosBase {
		typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
		typename ArrayTypes<DeviceType>::t_virial_array d_vatom;

		int need_dup;
		Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_rho;
		Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_f;
		Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_eatom;
		Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterDuplicated> dup_vatom;
		Kokkos::Experimental::ScatterView<F_FLOAT*, typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_rho;
		Kokkos::Experimental::ScatterView<F_FLOAT*[3], typename DAT::t_f_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_f;
		Kokkos::Experimental::ScatterView<E_FLOAT*, typename DAT::t_efloat_1d::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_eatom;
		Kokkos::Experimental::ScatterView<F_FLOAT*[6], typename DAT::t_virial_array::array_layout,DeviceType,Kokkos::Experimental::ScatterSum,Kokkos::Experimental::ScatterNonDuplicated> ndup_vatom;

		DAT::tdual_ffloat_1d k_rho;
		DAT::tdual_ffloat_1d k_fp;
		typename AT::t_ffloat_1d d_rho;

src/KOKKOS/pair_eam_kokkos.cpp

+4 −1

Original line number	Diff line number	Diff line
		/* ----------------------------------------------------------------------
		/* ----------------------------------------------------------------------
		LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
		http://lammps.sandia.gov, Sandia National Laboratories
		@@ -34,7 +35,6 @@

		using namespace LAMMPS_NS;


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

		template<class DeviceType>
		@@ -524,6 +524,7 @@ void PairEAMKokkos<DeviceType>::operator()(TagPairEAMKernelA<NEIGHFLAG,NEWTON_PA
		// loop over neighbors of my atoms

		// The rho array is duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_rho = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_rho),decltype(ndup_rho)>::get(dup_rho,ndup_rho);
		auto a_rho = v_rho.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		@@ -692,6 +693,7 @@ KOKKOS_INLINE_FUNCTION
		void PairEAMKokkos<DeviceType>::operator()(TagPairEAMKernelC<NEIGHFLAG,NEWTON_PAIR,EVFLAG>, const int &ii, EV_FLOAT& ev) const {

		// The f array is duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_f = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_f),decltype(ndup_f)>::get(dup_f,ndup_f);
		auto a_f = v_f.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

		@@ -801,6 +803,7 @@ void PairEAMKokkos<DeviceType>::ev_tally(EV_FLOAT &ev, const int &i, const int &
		const int VFLAG = vflag_either;

		// The eatom and vatom arrays are duplicated for OpenMP, atomic for CUDA, and neither for Serial

		auto v_eatom = ScatterViewHelper<NeedDup<NEIGHFLAG,DeviceType>::value,decltype(dup_eatom),decltype(ndup_eatom)>::get(dup_eatom,ndup_eatom);
		auto a_eatom = v_eatom.template access<AtomicDup<NEIGHFLAG,DeviceType>::value>();

Admin message