Porting fix gravity to Kokkos. (a365246e) · Commits · 郑智淋 / lammps

src/KOKKOS/Install.sh

+2 −0

Original line number	Diff line number	Diff line
		@@ -97,6 +97,8 @@ action fix_deform_kokkos.cpp
		action fix_deform_kokkos.h
		action fix_eos_table_rx_kokkos.cpp fix_eos_table_rx.cpp
		action fix_eos_table_rx_kokkos.h fix_eos_table_rx.h
		action fix_gravity_kokkos.cpp
		action fix_gravity_kokkos.h
		action fix_langevin_kokkos.cpp
		action fix_langevin_kokkos.h
		action fix_neigh_history_kokkos.cpp

src/KOKKOS/fix_gravity_kokkos.cpp

0 → 100644

+121 −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 "fix_gravity_kokkos.h"
		#include "atom_masks.h"
		#include "modify.h"
		#include "input.h"
		#include "variable.h"
		#include "update.h"
		#include "atom_kokkos.h"
		#include "atom_vec.h"

		using namespace LAMMPS_NS;

		enum{CONSTANT,EQUAL};

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

		template<class DeviceType>
		FixGravityKokkos<DeviceType>::FixGravityKokkos(LAMMPS lmp, int narg, char *arg) :
		FixGravity(lmp, narg, arg)
		{
		kokkosable = 1;
		atomKK = (AtomKokkos *)atom;
		execution_space = ExecutionSpaceFromDevice<DeviceType>::space;

		datamask_read = X_MASK \| F_MASK \| RMASS_MASK \| MASK_MASK \| TYPE_MASK;
		datamask_modify = F_MASK;
		}

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

		template<class DeviceType>
		void FixGravityKokkos<DeviceType>::post_force(int vflag)
		{
		// update gravity due to variables

		if (varflag != CONSTANT) {
		modify->clearstep_compute();
		if (mstyle == EQUAL) magnitude = input->variable->compute_equal(mvar);
		if (vstyle == EQUAL) vert = input->variable->compute_equal(vvar);
		if (pstyle == EQUAL) phi = input->variable->compute_equal(pvar);
		if (tstyle == EQUAL) theta = input->variable->compute_equal(tvar);
		if (xstyle == EQUAL) xdir = input->variable->compute_equal(xvar);
		if (ystyle == EQUAL) ydir = input->variable->compute_equal(yvar);
		if (zstyle == EQUAL) zdir = input->variable->compute_equal(zvar);
		modify->addstep_compute(update->ntimestep + 1);

		set_acceleration();
		}

		atomKK->sync(execution_space,datamask_read);
		atomKK->modified(execution_space,datamask_modify);

		x = atomKK->k_x.view<DeviceType>();
		f = atomKK->k_f.view<DeviceType>();
		if (atomKK->rmass)
		rmass = atomKK->k_rmass.view<DeviceType>();
		else
		mass = atomKK->k_mass.view<DeviceType>();
		type = atomKK->k_type.view<DeviceType>();
		mask = atomKK->k_mask.view<DeviceType>();
		int nlocal = atomKK->nlocal;
		if (igroup == atomKK->firstgroup) nlocal = atomKK->nfirst;

		copymode = 1;

		eflag = 0;
		egrav = 0.0;

		if (atomKK->rmass) {
		Kokkos::parallel_reduce(Kokkos::RangePolicy<DeviceType, TagFixGravityRMass>(0,nlocal), *this, egrav);
		}
		else {
		Kokkos::parallel_reduce(Kokkos::RangePolicy<DeviceType, TagFixGravityMass>(0,nlocal), *this, egrav);
		}
		copymode = 0;
		}

		template<class DeviceType>
		KOKKOS_INLINE_FUNCTION
		void FixGravityKokkos<DeviceType>::operator()(TagFixGravityRMass, const int i, double &eg) const
		{
		if (mask[i] & groupbit) {
		double massone = rmass[i];
		f(i,0) += massone*xacc;
		f(i,1) += massone*yacc;
		f(i,2) += massone*zacc;
		eg -= massone * (xaccx(i,0) + yaccx(i,1) + zacc*x(i,2));
		}
		}

		template<class DeviceType>
		KOKKOS_INLINE_FUNCTION
		void FixGravityKokkos<DeviceType>::operator()(TagFixGravityMass, const int i, double &eg) const
		{
		if (mask[i] & groupbit) {
		double massone = mass[type[i]];
		f(i,0) += massone*xacc;
		f(i,1) += massone*yacc;
		f(i,2) += massone*zacc;
		eg -= massone * (xaccx(i,0) + yaccx(i,1) + zacc*x(i,2));
		}
		}

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

src/KOKKOS/fix_gravity_kokkos.h

0 → 100644

+57 −0

Original line number	Diff line number	Diff line
		/* -- c++ -- ----------------------------------------------------------
		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.
		------------------------------------------------------------------------- */

		#ifdef FIX_CLASS

		FixStyle(gravity/kk,FixGravityKokkos<LMPDeviceType>)
		FixStyle(gravity/kk/device,FixGravityKokkos<LMPDeviceType>)
		FixStyle(gravity/kk/host,FixGravityKokkos<LMPHostType>)

		#else

		#ifndef LMP_FIX_GRAVITY_KOKKOS_H
		#define LMP_FIX_GRAVITY_KOKKOS_H

		#include "fix_gravity.h"
		#include "kokkos_type.h"

		namespace LAMMPS_NS {

		struct TagFixGravityRMass {};
		struct TagFixGravityMass {};

		template<class DeviceType>
		class FixGravityKokkos : public FixGravity {
		public:
		FixGravityKokkos(class LAMMPS , int, char *);
		virtual ~FixGravityKokkos() {}
		void post_force(int);

		KOKKOS_INLINE_FUNCTION
		void operator()(TagFixGravityRMass, const int, double &) const;
		KOKKOS_INLINE_FUNCTION
		void operator()(TagFixGravityMass, const int, double &) const;

		private:
		typename ArrayTypes<DeviceType>::t_x_array x;
		typename ArrayTypes<DeviceType>::t_f_array f;
		typename ArrayTypes<DeviceType>::t_float_1d_randomread rmass;
		typename ArrayTypes<DeviceType>::t_float_1d_randomread mass;
		typename ArrayTypes<DeviceType>::t_int_1d type;
		typename ArrayTypes<DeviceType>::t_int_1d mask;
		};

		} // namespace LAMMPS_NS

		#endif // LMP_FIX_GRAVITY_KOKKOS_H
		#endif // FIX_CLASS

src/fix_gravity.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -141,6 +141,8 @@ FixGravity::FixGravity(LAMMPS lmp, int narg, char *arg) :

		FixGravity::~FixGravity()
		{
		if (copymode) return;

		delete [] mstr;
		delete [] vstr;
		delete [] pstr;

src/fix_gravity.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@ class FixGravity : public Fix {

		public:
		FixGravity(class LAMMPS , int, char *);
		~FixGravity();
		virtual ~FixGravity();
		int setmask();
		void init();
		void setup(int);

Admin message