Commit 0a5b027b authored by Denis Taniguchi's avatar Denis Taniguchi
Browse files

Porting pair gran/hooke/history to Kokkos.

parent a52ddf87

src/GRANULAR/pair_gran_hooke_history.cpp

+2 −0
Original line number Diff line number Diff line
@@ -63,6 +63,8 @@ PairGranHookeHistory::PairGranHookeHistory(LAMMPS *lmp) : Pair(lmp) 


PairGranHookeHistory::~PairGranHookeHistory()

{

  if (copymode) return;



  delete [] svector;

  if (fix_history) modify->delete_fix("NEIGH_HISTORY");

src/KOKKOS/Install.sh

+6 −0
Original line number Diff line number Diff line
@@ -71,6 +71,8 @@ action atom_vec_kokkos.cpp 
action atom_vec_kokkos.h

action atom_vec_molecular_kokkos.cpp atom_vec_molecular.cpp

action atom_vec_molecular_kokkos.h atom_vec_molecular.h

action atom_vec_sphere_kokkos.cpp atom_vec_sphere.cpp

action atom_vec_sphere_kokkos.h atom_vec_sphere.h

action bond_class2_kokkos.cpp bond_class2.cpp 

action bond_class2_kokkos.h bond_class2.h

action bond_fene_kokkos.cpp bond_fene.cpp
@@ -97,6 +99,8 @@ 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_langevin_kokkos.cpp

action fix_langevin_kokkos.h

action fix_neigh_history_kokkos.cpp

action fix_neigh_history_kokkos.h

action fix_nh_kokkos.cpp

action fix_nh_kokkos.h

action fix_nph_kokkos.cpp
@@ -191,6 +195,8 @@ action pair_eam_fs_kokkos.cpp pair_eam_fs.cpp 
action pair_eam_fs_kokkos.h pair_eam_fs.h

action pair_exp6_rx_kokkos.cpp pair_exp6_rx.cpp

action pair_exp6_rx_kokkos.h pair_exp6_rx.h

action pair_gran_hooke_history_kokkos.h

action pair_gran_hooke_history_kokkos.cpp

action pair_hybrid_kokkos.cpp

action pair_hybrid_kokkos.h

action pair_hybrid_overlay_kokkos.cpp

src/KOKKOS/atom_vec_sphere_kokkos.cpp

0 → 100644
+2155 −0

File added.

Preview size limit exceeded, changes collapsed.

src/KOKKOS/atom_vec_sphere_kokkos.h

0 → 100644
+155 −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 ATOM_CLASS



AtomStyle(sphere/kk,AtomVecSphereKokkos)



#else



#ifndef LMP_ATOM_VEC_SPHERE_KOKKOS_H

#define LMP_ATOM_VEC_SPHERE_KOKKOS_H



#include "atom_vec_kokkos.h"

#include "kokkos_type.h"



namespace LAMMPS_NS {



class AtomVecSphereKokkos : public AtomVecKokkos {

 public:

  AtomVecSphereKokkos(class LAMMPS *);

  ~AtomVecSphereKokkos() {}

  void init();

  void grow(int);

  void grow_reset();

  void copy(int, int, int);

  int pack_comm(int, int *, double *, int, int *);

  int pack_comm_vel(int, int *, double *, int, int *);

  int pack_comm_hybrid(int, int *, double *);

  void unpack_comm(int, int, double *);

  void unpack_comm_vel(int, int, double *);

  int unpack_comm_hybrid(int, int, double *);

  int pack_reverse(int, int, double *);

  int pack_reverse_hybrid(int, int, double *);

  void unpack_reverse(int, int *, double *);

  int unpack_reverse_hybrid(int, int *, double *);

  int pack_border(int, int *, double *, int, int *);

  int pack_border_vel(int, int *, double *, int, int *);

  int pack_border_hybrid(int, int *, double *);

  void unpack_border(int, int, double *);

  void unpack_border_vel(int, int, double *);

  int unpack_border_hybrid(int, int, double *);

  int pack_exchange(int, double *);

  int unpack_exchange(double *);

  int size_restart();

  int pack_restart(int, double *);

  int unpack_restart(double *);

  void create_atom(int, double *);

  void data_atom(double *, imageint, char **);

  int data_atom_hybrid(int, char **);

  void data_vel(int, char **);

  int data_vel_hybrid(int, char **);

  void pack_data(double **);

  int pack_data_hybrid(int, double *);

  void write_data(FILE *, int, double **);

  int write_data_hybrid(FILE *, double *);

  void pack_vel(double **);

  int pack_vel_hybrid(int, double *);

  void write_vel(FILE *, int, double **);

  int write_vel_hybrid(FILE *, double *);

  bigint memory_usage();



  int pack_comm_kokkos(const int &n, const DAT::tdual_int_2d &k_sendlist,

                       const int & iswap,

                       const DAT::tdual_xfloat_2d &buf,

                       const int &pbc_flag, const int pbc[]);

  void unpack_comm_kokkos(const int &n, const int &nfirst,

                          const DAT::tdual_xfloat_2d &buf);

  int pack_comm_self(const int &n, const DAT::tdual_int_2d &list,

                     const int & iswap, const int nfirst,

                     const int &pbc_flag, const int pbc[]);

  int pack_border_kokkos(int n, DAT::tdual_int_2d k_sendlist,

                         DAT::tdual_xfloat_2d buf,int iswap,

                         int pbc_flag, int *pbc, ExecutionSpace space);

  void unpack_border_kokkos(const int &n, const int &nfirst,

                            const DAT::tdual_xfloat_2d &buf,

                            ExecutionSpace space);

  int pack_exchange_kokkos(const int &nsend,DAT::tdual_xfloat_2d &buf,

                           DAT::tdual_int_1d k_sendlist,

                           DAT::tdual_int_1d k_copylist,

                           ExecutionSpace space, int dim,

                           X_FLOAT lo, X_FLOAT hi);

  int unpack_exchange_kokkos(DAT::tdual_xfloat_2d &k_buf, int nrecv,

                             int nlocal, int dim, X_FLOAT lo, X_FLOAT hi,

                             ExecutionSpace space);



  void sync(ExecutionSpace space, unsigned int mask);

  void modified(ExecutionSpace space, unsigned int mask);

  void sync_overlapping_device(ExecutionSpace space, unsigned int mask);



 private:

  tagint *tag;

  int *type,*mask;

  imageint *image;

  double **x,**v,**f;

  double *radius,*rmass;

  double **omega,**torque;

  int radvary;



  DAT::t_tagint_1d d_tag;

  HAT::t_tagint_1d h_tag;

  DAT::t_imageint_1d d_image;

  HAT::t_imageint_1d h_image;

  DAT::t_int_1d d_type, d_mask;

  HAT::t_int_1d h_type, h_mask;



  DAT::t_x_array d_x;

  DAT::t_v_array d_v;

  DAT::t_f_array d_f;

  DAT::t_float_1d d_radius;

  HAT::t_float_1d h_radius;

  DAT::t_float_1d d_rmass;

  HAT::t_float_1d h_rmass;

  DAT::t_v_array d_omega;

  HAT::t_v_array h_omega;

  DAT::t_f_array d_torque;

  HAT::t_f_array h_torque;



  DAT::tdual_int_1d k_count;

};



}



#endif

#endif



/* ERROR/WARNING messages:



E: Per-processor system is too big



The number of owned atoms plus ghost atoms on a single

processor must fit in 32-bit integer.



E: Invalid atom type in Atoms section of data file



Atom types must range from 1 to specified # of types.



E: Invalid radius in Atoms section of data file



Radius must be >= 0.0.



E: Invalid density in Atoms section of data file



Density value cannot be <= 0.0.



*/

src/KOKKOS/fix_neigh_history_kokkos.cpp

0 → 100644
+346 −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_neigh_history_kokkos.h"

#include "atom_kokkos.h"

#include "error.h"

#include "memory_kokkos.h"

#include "neigh_list_kokkos.h"

#include "pair_kokkos.h"

#include "comm.h"



using namespace LAMMPS_NS;



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



template <class DeviceType>

FixNeighHistoryKokkos<DeviceType>::FixNeighHistoryKokkos(LAMMPS *lmp, int narg, char **arg) :

  FixNeighHistory(lmp, narg, arg)

{

  kokkosable = 1;

  atomKK = (AtomKokkos *)atom;

  execution_space = ExecutionSpaceFromDevice<DeviceType>::space;



  memory->destroy(npartner);

  memory->destroy(partner);

  memory->destroy(valuepartner);



  maxpartner = 8;

  grow_arrays(atom->nmax);



  d_resize = typename ArrayTypes<DeviceType>::t_int_scalar("FixNeighHistoryKokkos::resize");

#ifndef KOKKOS_USE_CUDA_UVM

  h_resize = Kokkos::create_mirror_view(d_resize);

#else

  h_resize = d_resize;

#endif

  h_resize() = 1;

}



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



template <class DeviceType>

FixNeighHistoryKokkos<DeviceType>::~FixNeighHistoryKokkos()

{

  if (copymode) return;



  memoryKK->destroy_kokkos(k_npartner, npartner);

  memoryKK->destroy_kokkos(k_partner, partner);

  memoryKK->destroy_kokkos(k_valuepartner, valuepartner);

}



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



template <class DeviceType>

void FixNeighHistoryKokkos<DeviceType>::init()

{

  if (atomKK->tag_enable == 0)

    error->all(FLERR,"Neighbor history requires atoms have IDs");

}



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



template <class DeviceType>

void FixNeighHistoryKokkos<DeviceType>::pre_exchange()

{

  copymode = 1;

  

  h_resize() = 1;

  while (h_resize() > 0) {

    FixNeighHistoryKokkosZeroPartnerCountFunctor<DeviceType> zero(this);

    Kokkos::parallel_for(nlocal_neigh,zero);



    h_resize() = 0;

    deep_copy(d_resize, h_resize);



    FixNeighHistoryKokkosPreExchangeFunctor<DeviceType> f(this);

    Kokkos::parallel_for(nlocal_neigh,f);



    deep_copy(h_resize, d_resize);

    if (h_resize() > 0) {

      maxpartner += 8;

      memoryKK->grow_kokkos(k_partner,partner,atom->nmax,maxpartner,"neighbor_history:partner");

      memoryKK->grow_kokkos(k_valuepartner,valuepartner,atom->nmax,dnum*maxpartner,"neighbor_history:valuepartner");

    }

  }



  copymode = 0;



  comm->maxexchange_fix = MAX(comm->maxexchange_fix,(dnum+1)*maxpartner+1);

}



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



template <class DeviceType>

void FixNeighHistoryKokkos<DeviceType>::zero_partner_count_item(const int &i) const

{

  d_npartner[i] = 0;

}



template <class DeviceType>

void FixNeighHistoryKokkos<DeviceType>::pre_exchange_item(const int &ii) const

{

  const int i = d_ilist[ii];

  const int jnum = d_numneigh[i];



  for (int jj = 0; jj < jnum; jj++) {

    if (d_firstflag(i,jj)) {

      int j = d_neighbors(i,jj);

      j &= NEIGHMASK;

      int m = Kokkos::atomic_fetch_add(&d_npartner[i],1);

      if (m < maxpartner) {

	d_partner(i,m) = tag[j];

	for (int k = 0; k < dnum; k++)

	  d_valuepartner(i,dnum*m+k) = d_firstvalue(i,dnum*jj+k);

      } else {

	d_resize() = 1;

      }

      if (j < nlocal_neigh) {

	m = Kokkos::atomic_fetch_add(&d_npartner[j],1);

	if (m < maxpartner) {

	  d_partner(j,m) = tag[i];

	  for (int k = 0; k < dnum; k++)

	    d_valuepartner(j,dnum*m+k) = d_firstvalue(i,dnum*jj+k);

	} else {

	  d_resize() = 1;

	}

      }

    }

  }

}



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



template <class DeviceType>

void FixNeighHistoryKokkos<DeviceType>::setup_post_neighbor()

{

  post_neighbor();

}



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



template <class DeviceType>

void FixNeighHistoryKokkos<DeviceType>::post_neighbor()

{

  tag = atomKK->k_tag.view<DeviceType>();

  

  int inum = pair->list->inum;

  NeighListKokkos<DeviceType>* k_list = static_cast<NeighListKokkos<DeviceType>*>(pair->list);

  d_numneigh = k_list->d_numneigh;

  d_neighbors = k_list->d_neighbors;

  d_ilist = k_list->d_ilist;



  // store atom counts used for new neighbor list which was just built



  int nlocal = atom->nlocal;

  int nall = nlocal + atom->nghost;

  nlocal_neigh = nlocal;

  nall_neigh = nall;



  // realloc firstflag and firstvalue if needed



  if (maxatom < nlocal || k_list->maxneighs > d_firstflag.extent(1)) {

    maxatom = nall;

    d_firstflag = typename ArrayTypes<DeviceType>::t_int_2d("neighbor_history:firstflag",maxatom,k_list->maxneighs);

    d_firstvalue = typename ArrayTypes<DeviceType>::t_float_2d("neighbor_history:firstvalue",maxatom,k_list->maxneighs*dnum);

  }



  copymode = 1;

  

  FixNeighHistoryKokkosPostNeighborFunctor<DeviceType> f(this);

  Kokkos::parallel_for(inum,f);



  copymode = 0;



#ifdef LMP_KOKKOS_DEBUG

  typename ArrayTypes<LMPHostType>::t_neighbors_2d h_neighbors("neighbor_history:h_neighbor",k_list->d_neighbors.extent(0), k_list->d_neighbors.extent(1));

  deep_copy(h_neighbors, d_neighbors);



  typename ArrayTypes<LMPHostType>::t_int_1d h_numneigh("neighbor_history:h_numneigh",k_list->d_numneigh.extent(0));

  deep_copy(h_numneigh, d_numneigh);

  

  typename ArrayTypes<LMPHostType>::t_int_2d h_firstflag("neighbor_history:h_firstflag",maxatom,k_list->maxneighs);

  deep_copy(h_firstflag, d_firstflag);



  typename ArrayTypes<LMPHostType>::t_float_2d h_firstvalue("neighbor_history:h_firstvalue",maxatom,k_list->maxneighs*dnum);

  deep_copy(h_firstvalue, d_firstvalue);

#endif

}



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



template<class DeviceType>

KOKKOS_INLINE_FUNCTION

void FixNeighHistoryKokkos<DeviceType>::post_neighbor_item(const int &ii) const

{

  const int i = d_ilist[ii];

  const int jnum = d_numneigh[i];

  const int np = d_npartner[i];



  for (int jj = 0; jj < jnum; jj++) {

    int j = d_neighbors(i,jj);

    const int rflag = j >> SBBITS & 3;

    j &= NEIGHMASK;



    int m;

    if (rflag) {

      int jtag = tag(j);

      for (m = 0; m < np; m++)

	if (d_partner(i, m) == jtag) break;

      if (m < np) {

	d_firstflag(i,jj) = 1;

	for (int k = 0; k < dnum; k++) {

	  d_firstvalue(i, dnum*jj+k) = d_valuepartner(i, dnum*m+k);

	}

      } else {

	d_firstflag(i,jj) = 0;

	for (int k = 0; k < dnum; k++) {

	  d_firstvalue(i, dnum*jj+k) = 0;

	}

      }

    } else {

      d_firstflag(i,jj) = 0;

      for (int k = 0; k < dnum; k++) {

	d_firstvalue(i, dnum*jj+k) = 0;

      }

    }

  }

}



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

   memory usage of local atom-based arrays

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



template<class DeviceType>

double FixNeighHistoryKokkos<DeviceType>::memory_usage()

{

  double bytes = d_firstflag.extent(0)*d_firstflag.extent(1)*sizeof(int);

  bytes += d_firstvalue.extent(0)*d_firstvalue.extent(1)*sizeof(double);

  bytes += 2*k_npartner.extent(0)*sizeof(int);

  bytes += 2*k_partner.extent(0)*k_partner.extent(1)*sizeof(int);

  bytes += 2*k_valuepartner.extent(0)*k_valuepartner.extent(1)*sizeof(double);

  return bytes;

}



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

   allocate fictitious charge arrays

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



template<class DeviceType>

void FixNeighHistoryKokkos<DeviceType>::grow_arrays(int nmax)

{

  k_npartner.template sync<LMPHostType>(); // force reallocation on host

  k_partner.template sync<LMPHostType>();

  k_valuepartner.template sync<LMPHostType>();

  

  memoryKK->grow_kokkos(k_npartner,npartner,nmax,"neighbor_history:npartner");

  memoryKK->grow_kokkos(k_partner,partner,nmax,maxpartner,"neighbor_history:partner");

  memoryKK->grow_kokkos(k_valuepartner,valuepartner,nmax,dnum*maxpartner,"neighbor_history:valuepartner");



  d_npartner = k_npartner.template view<DeviceType>();

  d_partner = k_partner.template view<DeviceType>();

  d_valuepartner = k_valuepartner.template view<DeviceType>();



  k_npartner.template modify<LMPHostType>();

  k_partner.template modify<LMPHostType>();

  k_valuepartner.template modify<LMPHostType>();

}



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

   copy values within fictitious charge arrays

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



template<class DeviceType>

void FixNeighHistoryKokkos<DeviceType>::copy_arrays(int i, int j, int delflag)

{

  k_npartner.template sync<LMPHostType>();

  k_partner.template sync<LMPHostType>();

  k_valuepartner.template sync<LMPHostType>();



  npartner[j] = npartner[i];

  for (int m = 0; m < npartner[i]; m++) {

    partner[j][m] = partner[i][m];

    valuepartner[j][m] = valuepartner[i][m];

  }



  k_npartner.template modify<LMPHostType>();

  k_partner.template modify<LMPHostType>();

  k_valuepartner.template modify<LMPHostType>();

}



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

   pack values in local atom-based array for exchange with another proc

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



template<class DeviceType>

int FixNeighHistoryKokkos<DeviceType>::pack_exchange(int i, double *buf)

{

  k_npartner.template sync<LMPHostType>();

  k_partner.template sync<LMPHostType>();

  k_valuepartner.template sync<LMPHostType>();



  int n = 0;

  buf[n++] = npartner[i];

  for (int m = 0; m < npartner[i]; m++) buf[n++] = partner[i][m];

  for (int m = 0; m < dnum*npartner[i]; m++) buf[n++] = valuepartner[i][m];



  return n;

}



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

   unpack values in local atom-based array from exchange with another proc

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



template<class DeviceType>

int FixNeighHistoryKokkos<DeviceType>::unpack_exchange(int nlocal, double *buf)

{

  int n = 0;

  npartner[nlocal] = static_cast<int>(buf[n++]);

  for (int m = 0; m < npartner[nlocal]; m++) partner[nlocal][m] = static_cast<int>(buf[n++]);

  for (int m = 0; m < dnum*npartner[nlocal]; m++) valuepartner[nlocal][m] = buf[n++];



  k_npartner.template modify<LMPHostType>();

  k_partner.template modify<LMPHostType>();

  k_valuepartner.template modify<LMPHostType>();



  return n;

}



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



namespace LAMMPS_NS {

template class FixNeighHistoryKokkos<LMPDeviceType>;

#ifdef KOKKOS_HAVE_CUDA

template class FixNeighHistoryKokkos<LMPHostType>;

#endif

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE