ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use only copymode in Kokkos pair_styles

Browse Source
This commit is contained in:
Stan Gerald Moore
2021-05-14 09:36:13 -06:00
parent 2695495552
commit 7b4fdb92df
60 changed files with 172 additions and 699 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/KOKKOS/pair_buck_coul_cut_kokkos.cpp
View File

@ -49,10 +49,6 @@ PairBuckCoulCutKokkos<DeviceType>::PairBuckCoulCutKokkos(LAMMPS *lmp):PairBuckCo
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -60,23 +56,15 @@ PairBuckCoulCutKokkos<DeviceType>::PairBuckCoulCutKokkos(LAMMPS *lmp):PairBuckCo
template<class DeviceType>
PairBuckCoulCutKokkos<DeviceType>::~PairBuckCoulCutKokkos()
{
if (copymode) return;
if (!copymode) {
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
k_cut_ljsq = DAT::tdual_ffloat_2d();
k_cut_coulsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
memory->sfree(cut_ljsq);
memory->sfree(cut_coulsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = nullptr;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq,cut_ljsq);
memoryKK->destroy_kokkos(k_cut_coulsq,cut_coulsq);
}
}
/* ---------------------------------------------------------------------- */

2
src/KOKKOS/pair_buck_coul_cut_kokkos.h
View File

@ -53,8 +53,6 @@ class PairBuckCoulCutKokkos : public PairBuckCoulCut {
};
protected:
void cleanup_copy() {}
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,

47
src/KOKKOS/pair_buck_coul_long_kokkos.cpp
View File

@ -56,10 +56,6 @@ PairBuckCoulLongKokkos<DeviceType>::PairBuckCoulLongKokkos(LAMMPS *lmp):PairBuck
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = 0.0;
}
/* ---------------------------------------------------------------------- */
@ -67,37 +63,18 @@ PairBuckCoulLongKokkos<DeviceType>::PairBuckCoulLongKokkos(LAMMPS *lmp):PairBuck
template<class DeviceType>
PairBuckCoulLongKokkos<DeviceType>::~PairBuckCoulLongKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
k_cut_ljsq = DAT::tdual_ffloat_2d();
k_cut_coulsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
memory->sfree(cut_ljsq);
//memory->sfree(cut_coulsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
cut_ljsq = nullptr;
//cut_coulsq = nullptr;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq,cut_ljsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairBuckCoulLongKokkos<DeviceType>::cleanup_copy() {
allocated = 0;
cutsq = nullptr;
cut_ljsq = nullptr;
eatom = nullptr;
vatom = nullptr;
ftable = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairBuckCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -124,7 +101,6 @@ void PairBuckCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_ljsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -313,8 +289,8 @@ void PairBuckCoulLongKokkos<DeviceType>::allocate()
memoryKK->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_buck_coul**,Kokkos::LayoutRight,DeviceType>("PairBuckCoulLong::params",n+1,n+1);
params = k_params.template view<DeviceType>();
@ -486,7 +462,6 @@ double PairBuckCoulLongKokkos<DeviceType>::init_one(int i, int j)
{
double cutone = PairBuckCoulLong::init_one(i,j);
double cut_ljsqm = cut_ljsq[i][j];
double cut_coulsqm = cut_coulsq;
k_params.h_view(i,j).a = a[i][j];
k_params.h_view(i,j).c = c[i][j];
@ -495,29 +470,25 @@ double PairBuckCoulLongKokkos<DeviceType>::init_one(int i, int j)
k_params.h_view(i,j).buck2 = buck2[i][j];
k_params.h_view(i,j).offset = offset[i][j];
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsq;
k_params.h_view(j,i) = k_params.h_view(i,j);
if (i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsq;
}
k_cutsq.h_view(i,j) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
k_cut_ljsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;
}
namespace LAMMPS_NS {
template class PairBuckCoulLongKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

3
src/KOKKOS/pair_buck_coul_long_kokkos.h
View File

@ -54,8 +54,6 @@ class PairBuckCoulLongKokkos : public PairBuckCoulLong {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
@ -102,7 +100,6 @@ class PairBuckCoulLongKokkos : public PairBuckCoulLong {
typename AT::t_ffloat_2d d_cutsq;
typename AT::tdual_ffloat_2d k_cut_ljsq;
typename AT::t_ffloat_2d d_cut_ljsq;
typename AT::tdual_ffloat_2d k_cut_coulsq;
typename AT::t_ffloat_2d d_cut_coulsq;
typename AT::t_ffloat_1d_randomread

11
src/KOKKOS/pair_buck_kokkos.cpp
View File

@ -47,7 +47,6 @@ PairBuckKokkos<DeviceType>::PairBuckKokkos(LAMMPS *lmp) : PairBuck(lmp)
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -55,14 +54,12 @@ PairBuckKokkos<DeviceType>::PairBuckKokkos(LAMMPS *lmp) : PairBuck(lmp)
template<class DeviceType>
PairBuckKokkos<DeviceType>::~PairBuckKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}

2
src/KOKKOS/pair_buck_kokkos.h
View File

@ -52,8 +52,6 @@ class PairBuckKokkos : public PairBuck {
};
protected:
void cleanup_copy() {}
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;

17
src/KOKKOS/pair_coul_cut_kokkos.cpp
View File

@ -38,7 +38,6 @@ PairCoulCutKokkos<DeviceType>::PairCoulCutKokkos(LAMMPS *lmp) : PairCoulCut(lmp)
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -46,25 +45,17 @@ PairCoulCutKokkos<DeviceType>::PairCoulCutKokkos(LAMMPS *lmp) : PairCoulCut(lmp)
template<class DeviceType>
PairCoulCutKokkos<DeviceType>::~PairCoulCutKokkos()
{
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq, cutsq);
cleanup_copy();
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairCoulCutKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_coul_cut_kokkos.h
View File

@ -53,8 +53,6 @@ class PairCoulCutKokkos : public PairCoulCut {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& /*rsq*/, const int& /*i*/, const int& /*j*/,

20
src/KOKKOS/pair_coul_debye_kokkos.cpp
View File

@ -47,8 +47,6 @@ PairCoulDebyeKokkos<DeviceType>::PairCoulDebyeKokkos(LAMMPS *lmp):PairCoulDebye(
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -56,25 +54,17 @@ PairCoulDebyeKokkos<DeviceType>::PairCoulDebyeKokkos(LAMMPS *lmp):PairCoulDebye(
template<class DeviceType>
PairCoulDebyeKokkos<DeviceType>::~PairCoulDebyeKokkos()
{
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_cutsq, cutsq);
cleanup_copy();
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairCoulDebyeKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairCoulDebyeKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_coul_debye_kokkos.h
View File

@ -53,8 +53,6 @@ class PairCoulDebyeKokkos : public PairCoulDebye {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& /*rsq*/, const int& /*i*/, const int& /*j*/,

39
src/KOKKOS/pair_coul_long_kokkos.cpp
View File

@ -56,9 +56,6 @@ PairCoulLongKokkos<DeviceType>::PairCoulLongKokkos(LAMMPS *lmp):PairCoulLong(lmp
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_coulsq = 0.0;
}
/* ---------------------------------------------------------------------- */
@ -66,31 +63,17 @@ PairCoulLongKokkos<DeviceType>::PairCoulLongKokkos(LAMMPS *lmp):PairCoulLong(lmp
template<class DeviceType>
PairCoulLongKokkos<DeviceType>::~PairCoulLongKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
k_cut_coulsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairCoulLongKokkos<DeviceType>::cleanup_copy() {
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
ftable = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -116,7 +99,6 @@ void PairCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -271,8 +253,8 @@ void PairCoulLongKokkos<DeviceType>::allocate()
memoryKK->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
d_cutsq = k_cutsq.template view<DeviceType>();
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_coul**,Kokkos::LayoutRight,DeviceType>("PairCoulLong::params",n+1,n+1);
params = k_params.template view<DeviceType>();
@ -443,28 +425,23 @@ template<class DeviceType>
double PairCoulLongKokkos<DeviceType>::init_one(int i, int j)
{
double cutone = PairCoulLong::init_one(i,j);
double cut_coulsqm = cut_coulsq;
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsq;
k_params.h_view(j,i) = k_params.h_view(i,j);
if (i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsq;
}
k_cutsq.h_view(i,j) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;
}
namespace LAMMPS_NS {
template class PairCoulLongKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

4
src/KOKKOS/pair_coul_long_kokkos.h
View File

@ -54,8 +54,6 @@ class PairCoulLongKokkos : public PairCoulLong {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& /*rsq*/, const int& /*i*/, const int& /*j*/,
@ -100,9 +98,7 @@ class PairCoulLongKokkos : public PairCoulLong {
typename AT::tdual_ffloat_2d k_cutsq;
typename AT::t_ffloat_2d d_cutsq;
typename AT::tdual_ffloat_2d k_cut_ljsq;
typename AT::t_ffloat_2d d_cut_ljsq;
typename AT::tdual_ffloat_2d k_cut_coulsq;
typename AT::t_ffloat_2d d_cut_coulsq;
typename AT::t_ffloat_1d_randomread

2
src/KOKKOS/pair_eam_alloy_kokkos.h
View File

@ -116,8 +116,6 @@ class PairEAMAlloyKokkos : public PairEAM, public KokkosBase {
void unpack_reverse_comm(int, int *, double *);
protected:
void cleanup_copy();
typename AT::t_x_array x;
typename AT::t_f_array f;
typename AT::t_int_1d type;

2
src/KOKKOS/pair_eam_fs_kokkos.h
View File

@ -116,8 +116,6 @@ class PairEAMFSKokkos : public PairEAM, public KokkosBase {
void unpack_reverse_comm(int, int *, double *);
protected:
void cleanup_copy();
typename AT::t_x_array x;
typename AT::t_f_array f;
typename AT::t_int_1d type;

2
src/KOKKOS/pair_eam_kokkos.h
View File

@ -113,8 +113,6 @@ class PairEAMKokkos : public PairEAM, public KokkosBase {
void unpack_reverse_comm(int, int *, double *);
protected:
void cleanup_copy();
typename AT::t_x_array x;
typename AT::t_f_array f;
typename AT::t_int_1d type;

4
src/KOKKOS/pair_kokkos.h
View File

@ -94,8 +94,8 @@ struct PairComputeFunctor {
dup_vatom = Kokkos::Experimental::create_scatter_view<Kokkos::Experimental::ScatterSum, typename NeedDup<NEIGHFLAG,device_type>::value >(c.d_vatom);
};
// Call cleanup_copy which sets allocations to null which are destructed by the PairStyle
~PairComputeFunctor() {c.cleanup_copy();list.copymode = 1;};
// Set copymode = 1 so parent allocations aren't destructed by copies of the sstyle
~PairComputeFunctor() {c.copymode = 1; list.copymode = 1;};
KOKKOS_INLINE_FUNCTION int sbmask(const int& j) const {
return j >> SBBITS & 3;

58
src/KOKKOS/pair_lj_charmm_coul_charmm_implicit_kokkos.cpp
View File

@ -55,10 +55,6 @@ PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::PairLJCharmmCoulCharmmImplicit
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = 0.0;
cut_coulsq = 0.0;
}
/* ---------------------------------------------------------------------- */
@ -66,38 +62,17 @@ PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::PairLJCharmmCoulCharmmImplicit
template<class DeviceType>
PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::~PairLJCharmmCoulCharmmImplicitKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
k_cut_ljsq = DAT::tdual_ffloat_2d();
k_cut_coulsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
//memory->sfree(cut_ljsq);
//memory->sfree(cut_coulsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
cut_ljsq = 0.0;
cut_coulsq = 0.0;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = 0.0;
eatom = nullptr;
vatom = nullptr;
ftable = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -123,8 +98,6 @@ void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::compute(int eflag_in, int
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_ljsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -312,12 +285,11 @@ void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::allocate()
memoryKK->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
d_cutsq = k_cutsq.template view<DeviceType>();
//memory->destroy(cut_ljsq);
memoryKK->create_kokkos(k_cut_ljsq,n+1,n+1,"pair:cut_ljsq");
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
d_cut_ljsq = typename AT::t_ffloat_2d("pair:cut_ljsq",n+1,n+1);
Kokkos::deep_copy(d_cut_ljsq,cut_ljsq);
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCharmmCoulCharmmImplicit::params",n+1,n+1);
params = k_params.template view<DeviceType>();
@ -488,31 +460,25 @@ template<class DeviceType>
double PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::init_one(int i, int j)
{
double cutone = PairLJCharmmCoulCharmmImplicit::init_one(i,j);
double cut_ljsqm = cut_ljsq;
double cut_coulsqm = cut_coulsq;
k_params.h_view(i,j).lj1 = lj1[i][j];
k_params.h_view(i,j).lj2 = lj2[i][j];
k_params.h_view(i,j).lj3 = lj3[i][j];
k_params.h_view(i,j).lj4 = lj4[i][j];
//k_params.h_view(i,j).offset = offset[i][j];
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
k_params.h_view(i,j).cut_ljsq = cut_ljsq;
k_params.h_view(i,j).cut_coulsq = cut_coulsq;
k_params.h_view(j,i) = k_params.h_view(i,j);
if (i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsq;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsq;
}
k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_ljsq.h_view(i,j) = k_cut_ljsq.h_view(j,i) = cut_ljsqm;
k_cut_ljsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = k_cut_coulsq.h_view(j,i) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;

2
src/KOKKOS/pair_lj_charmm_coul_charmm_implicit_kokkos.h
View File

@ -47,8 +47,6 @@ class PairLJCharmmCoulCharmmImplicitKokkos : public PairLJCharmmCoulCharmmImplic
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,

58
src/KOKKOS/pair_lj_charmm_coul_charmm_kokkos.cpp
View File

@ -56,10 +56,6 @@ PairLJCharmmCoulCharmmKokkos<DeviceType>::PairLJCharmmCoulCharmmKokkos(LAMMPS *l
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = 0.0;
cut_coulsq = 0.0;
}
/* ---------------------------------------------------------------------- */
@ -67,38 +63,17 @@ PairLJCharmmCoulCharmmKokkos<DeviceType>::PairLJCharmmCoulCharmmKokkos(LAMMPS *l
template<class DeviceType>
PairLJCharmmCoulCharmmKokkos<DeviceType>::~PairLJCharmmCoulCharmmKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
k_cut_ljsq = DAT::tdual_ffloat_2d();
k_cut_coulsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
//memory->sfree(cut_ljsq);
//memory->sfree(cut_coulsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
cut_ljsq = 0.0;
cut_coulsq = 0.0;
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCharmmCoulCharmmKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = 0.0;
eatom = nullptr;
vatom = nullptr;
ftable = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCharmmCoulCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -124,8 +99,6 @@ void PairLJCharmmCoulCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_i
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_ljsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -313,12 +286,11 @@ void PairLJCharmmCoulCharmmKokkos<DeviceType>::allocate()
memoryKK->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
d_cutsq = k_cutsq.template view<DeviceType>();
//memory->destroy(cut_ljsq);
memoryKK->create_kokkos(k_cut_ljsq,n+1,n+1,"pair:cut_ljsq");
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
d_cut_ljsq = typename AT::t_ffloat_2d("pair:cut_ljsq",n+1,n+1);
Kokkos::deep_copy(d_cut_ljsq,cut_ljsq);
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCharmmCoulCharmm::params",n+1,n+1);
params = k_params.template view<DeviceType>();
@ -489,38 +461,30 @@ template<class DeviceType>
double PairLJCharmmCoulCharmmKokkos<DeviceType>::init_one(int i, int j)
{
double cutone = PairLJCharmmCoulCharmm::init_one(i,j);
double cut_ljsqm = cut_ljsq;
double cut_coulsqm = cut_coulsq;
k_params.h_view(i,j).lj1 = lj1[i][j];
k_params.h_view(i,j).lj2 = lj2[i][j];
k_params.h_view(i,j).lj3 = lj3[i][j];
k_params.h_view(i,j).lj4 = lj4[i][j];
//k_params.h_view(i,j).offset = offset[i][j];
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
k_params.h_view(i,j).cut_ljsq = cut_ljsq;
k_params.h_view(i,j).cut_coulsq = cut_coulsq;
k_params.h_view(j,i) = k_params.h_view(i,j);
if (i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsq;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsq;
}
k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_ljsq.h_view(i,j) = k_cut_ljsq.h_view(j,i) = cut_ljsqm;
k_cut_ljsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = k_cut_coulsq.h_view(j,i) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;
}
namespace LAMMPS_NS {
template class PairLJCharmmCoulCharmmKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

4
src/KOKKOS/pair_lj_charmm_coul_charmm_kokkos.h
View File

@ -47,8 +47,6 @@ class PairLJCharmmCoulCharmmKokkos : public PairLJCharmmCoulCharmm {
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
@ -93,9 +91,7 @@ class PairLJCharmmCoulCharmmKokkos : public PairLJCharmmCoulCharmm {
typename AT::tdual_ffloat_2d k_cutsq;
typename AT::t_ffloat_2d d_cutsq;
typename AT::tdual_ffloat_2d k_cut_ljsq;
typename AT::t_ffloat_2d d_cut_ljsq;
typename AT::tdual_ffloat_2d k_cut_coulsq;
typename AT::t_ffloat_2d d_cut_coulsq;
typename AT::t_ffloat_1d_randomread

60
src/KOKKOS/pair_lj_charmm_coul_long_kokkos.cpp
View File

@ -56,10 +56,6 @@ PairLJCharmmCoulLongKokkos<DeviceType>::PairLJCharmmCoulLongKokkos(LAMMPS *lmp):
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = 0.0;
cut_coulsq = 0.0;
}
/* ---------------------------------------------------------------------- */
@ -67,38 +63,17 @@ PairLJCharmmCoulLongKokkos<DeviceType>::PairLJCharmmCoulLongKokkos(LAMMPS *lmp):
template<class DeviceType>
PairLJCharmmCoulLongKokkos<DeviceType>::~PairLJCharmmCoulLongKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
k_cut_ljsq = DAT::tdual_ffloat_2d();
k_cut_coulsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
//memory->sfree(cut_ljsq);
//memory->sfree(cut_coulsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
cut_ljsq = 0.0;
cut_coulsq = 0.0;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCharmmCoulLongKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = 0.0;
eatom = nullptr;
vatom = nullptr;
ftable = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCharmmCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -124,8 +99,6 @@ void PairLJCharmmCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_ljsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -334,12 +307,11 @@ void PairLJCharmmCoulLongKokkos<DeviceType>::allocate()
memoryKK->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
d_cutsq = k_cutsq.template view<DeviceType>();
//memory->destroy(cut_ljsq);
memoryKK->create_kokkos(k_cut_ljsq,n+1,n+1,"pair:cut_ljsq");
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
d_cut_ljsq = typename AT::t_ffloat_2d("pair:cut_ljsq",n+1,n+1);
Kokkos::deep_copy(d_cut_ljsq,cut_ljsq);
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCharmmCoulLong::params",n+1,n+1);
params = k_params.template view<DeviceType>();
@ -497,38 +469,30 @@ template<class DeviceType>
double PairLJCharmmCoulLongKokkos<DeviceType>::init_one(int i, int j)
{
double cutone = PairLJCharmmCoulLong::init_one(i,j);
double cut_ljsqm = cut_ljsq;
double cut_coulsqm = cut_coulsq;
k_params.h_view(i,j).lj1 = lj1[i][j];
k_params.h_view(i,j).lj2 = lj2[i][j];
k_params.h_view(i,j).lj3 = lj3[i][j];
k_params.h_view(i,j).lj4 = lj4[i][j];
//k_params.h_view(i,j).offset = offset[i][j];
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
k_params.h_view(i,j).cut_ljsq = cut_ljsq;
k_params.h_view(i,j).cut_coulsq = cut_coulsq;
k_params.h_view(j,i) = k_params.h_view(i,j);
if (i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsq;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsq;
}
k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_ljsq.h_view(i,j) = k_cut_ljsq.h_view(j,i) = cut_ljsqm;
k_cut_ljsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = k_cut_coulsq.h_view(j,i) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;
}
namespace LAMMPS_NS {
template class PairLJCharmmCoulLongKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

4
src/KOKKOS/pair_lj_charmm_coul_long_kokkos.h
View File

@ -45,8 +45,6 @@ class PairLJCharmmCoulLongKokkos : public PairLJCharmmCoulLong {
double init_one(int, int);
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
@ -91,9 +89,7 @@ class PairLJCharmmCoulLongKokkos : public PairLJCharmmCoulLong {
typename AT::tdual_ffloat_2d k_cutsq;
typename AT::t_ffloat_2d d_cutsq;
typename AT::tdual_ffloat_2d k_cut_ljsq;
typename AT::t_ffloat_2d d_cut_ljsq;
typename AT::tdual_ffloat_2d k_cut_coulsq;
typename AT::t_ffloat_2d d_cut_coulsq;
typename AT::t_ffloat_1d_randomread

29
src/KOKKOS/pair_lj_class2_coul_cut_kokkos.cpp
View File

@ -44,10 +44,6 @@ PairLJClass2CoulCutKokkos<DeviceType>::PairLJClass2CoulCutKokkos(LAMMPS *lmp):Pa
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -55,28 +51,19 @@ PairLJClass2CoulCutKokkos<DeviceType>::PairLJClass2CoulCutKokkos(LAMMPS *lmp):Pa
template<class DeviceType>
PairLJClass2CoulCutKokkos<DeviceType>::~PairLJClass2CoulCutKokkos()
{
if (!copymode) {
memoryKK->destroy_kokkos(k_cutsq, cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq, cut_ljsq);
memoryKK->destroy_kokkos(k_cut_coulsq, cut_coulsq);
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq,cut_ljsq);
memoryKK->destroy_kokkos(k_cut_coulsq,cut_coulsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJClass2CoulCutKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJClass2CoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_lj_class2_coul_cut_kokkos.h
View File

@ -46,8 +46,6 @@ class PairLJClass2CoulCutKokkos : public PairLJClass2CoulCut {
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,

43
src/KOKKOS/pair_lj_class2_coul_long_kokkos.cpp
View File

@ -52,10 +52,6 @@ PairLJClass2CoulLongKokkos<DeviceType>::PairLJClass2CoulLongKokkos(LAMMPS *lmp):
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = 0.0;
}
/* ---------------------------------------------------------------------- */
@ -63,27 +59,18 @@ PairLJClass2CoulLongKokkos<DeviceType>::PairLJClass2CoulLongKokkos(LAMMPS *lmp):
template<class DeviceType>
PairLJClass2CoulLongKokkos<DeviceType>::~PairLJClass2CoulLongKokkos()
{
if (!copymode) {
memoryKK->destroy_kokkos(k_cutsq, cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq, cut_ljsq);
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq,cut_ljsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJClass2CoulLongKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = nullptr;
eatom = nullptr;
vatom = nullptr;
ftable = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJClass2CoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -110,7 +97,6 @@ void PairLJClass2CoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_ljsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -302,15 +288,18 @@ void PairLJClass2CoulLongKokkos<DeviceType>::allocate()
PairLJClass2CoulLong::allocate();
int n = atom->ntypes;
memory->destroy(cutsq);
memoryKK->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
d_cutsq = k_cutsq.template view<DeviceType>();
memory->destroy(cut_ljsq);
memoryKK->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJClass2CoulLong::params",n+1,n+1);
params = k_params.template view<DeviceType>();
}
@ -481,7 +470,6 @@ double PairLJClass2CoulLongKokkos<DeviceType>::init_one(int i, int j)
{
double cutone = PairLJClass2CoulLong::init_one(i,j);
double cut_ljsqm = cut_ljsq[i][j];
double cut_coulsqm = cut_coulsq;
k_params.h_view(i,j).lj1 = lj1[i][j];
k_params.h_view(i,j).lj2 = lj2[i][j];
@ -489,28 +477,25 @@ double PairLJClass2CoulLongKokkos<DeviceType>::init_one(int i, int j)
k_params.h_view(i,j).lj4 = lj4[i][j];
k_params.h_view(i,j).offset = offset[i][j];
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsq;
k_params.h_view(j,i) = k_params.h_view(i,j);
if (i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsq;
}
k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_ljsq.h_view(i,j) = k_cut_ljsq.h_view(j,i) = cut_ljsqm;
k_cut_ljsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = k_cut_coulsq.h_view(j,i) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;
}
namespace LAMMPS_NS {
template class PairLJClass2CoulLongKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

3
src/KOKKOS/pair_lj_class2_coul_long_kokkos.h
View File

@ -46,8 +46,6 @@ class PairLJClass2CoulLongKokkos : public PairLJClass2CoulLong {
double init_one(int, int);
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
@ -94,7 +92,6 @@ class PairLJClass2CoulLongKokkos : public PairLJClass2CoulLong {
typename AT::t_ffloat_2d d_cutsq;
typename AT::tdual_ffloat_2d k_cut_ljsq;
typename AT::t_ffloat_2d d_cut_ljsq;
typename AT::tdual_ffloat_2d k_cut_coulsq;
typename AT::t_ffloat_2d d_cut_coulsq;
typename AT::t_ffloat_1d_randomread

20
src/KOKKOS/pair_lj_class2_kokkos.cpp
View File

@ -47,7 +47,6 @@ PairLJClass2Kokkos<DeviceType>::PairLJClass2Kokkos(LAMMPS *lmp) : PairLJClass2(l
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -55,26 +54,17 @@ PairLJClass2Kokkos<DeviceType>::PairLJClass2Kokkos(LAMMPS *lmp) : PairLJClass2(l
template<class DeviceType>
PairLJClass2Kokkos<DeviceType>::~PairLJClass2Kokkos()
{
if (copymode) return;
if (allocated) {
k_cutsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
cutsq = nullptr;
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJClass2Kokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_lj_class2_kokkos.h
View File

@ -53,8 +53,6 @@ class PairLJClass2Kokkos : public PairLJClass2 {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;

28
src/KOKKOS/pair_lj_cut_coul_cut_kokkos.cpp
View File

@ -43,10 +43,6 @@ PairLJCutCoulCutKokkos<DeviceType>::PairLJCutCoulCutKokkos(LAMMPS *lmp):PairLJCu
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -54,29 +50,19 @@ PairLJCutCoulCutKokkos<DeviceType>::PairLJCutCoulCutKokkos(LAMMPS *lmp):PairLJCu
template<class DeviceType>
PairLJCutCoulCutKokkos<DeviceType>::~PairLJCutCoulCutKokkos()
{
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_cutsq, cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq, cut_ljsq);
memoryKK->destroy_kokkos(k_cut_coulsq, cut_coulsq);
cleanup_copy();
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq,cut_ljsq);
memoryKK->destroy_kokkos(k_cut_coulsq,cut_coulsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutCoulCutKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_lj_cut_coul_cut_kokkos.h
View File

@ -45,8 +45,6 @@ class PairLJCutCoulCutKokkos : public PairLJCutCoulCut {
double init_one(int, int);
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,

30
src/KOKKOS/pair_lj_cut_coul_debye_kokkos.cpp
View File

@ -47,10 +47,6 @@ PairLJCutCoulDebyeKokkos<DeviceType>::PairLJCutCoulDebyeKokkos(LAMMPS *lmp):Pair
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -58,31 +54,19 @@ PairLJCutCoulDebyeKokkos<DeviceType>::PairLJCutCoulDebyeKokkos(LAMMPS *lmp):Pair
template<class DeviceType>
PairLJCutCoulDebyeKokkos<DeviceType>::~PairLJCutCoulDebyeKokkos()
{
if (!copymode) {
memoryKK->destroy_kokkos(k_cutsq, cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq, cut_ljsq);
memoryKK->destroy_kokkos(k_cut_coulsq, cut_coulsq);
}
if (copymode) return;
if (allocated) {
cleanup_copy();
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq,cut_ljsq);
memoryKK->destroy_kokkos(k_cut_coulsq,cut_coulsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutCoulDebyeKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutCoulDebyeKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_lj_cut_coul_debye_kokkos.h
View File

@ -45,8 +45,6 @@ class PairLJCutCoulDebyeKokkos : public PairLJCutCoulDebye {
double init_one(int, int);
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,

44
src/KOKKOS/pair_lj_cut_coul_dsf_kokkos.cpp
View File

@ -57,10 +57,6 @@ PairLJCutCoulDSFKokkos<DeviceType>::PairLJCutCoulDSFKokkos(LAMMPS *lmp):PairLJCu
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = nullptr;
//cut_coulsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -68,27 +64,14 @@ PairLJCutCoulDSFKokkos<DeviceType>::PairLJCutCoulDSFKokkos(LAMMPS *lmp):PairLJCu
template<class DeviceType>
PairLJCutCoulDSFKokkos<DeviceType>::~PairLJCutCoulDSFKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq, cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq, cut_ljsq);
//memoryKK->destroy_kokkos(k_cut_coulsq, cut_coulsq);
}
if (allocated) {
cleanup_copy();
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutCoulDSFKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = nullptr;
//cut_coulsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -119,7 +102,6 @@ void PairLJCutCoulDSFKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_ljsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -279,15 +261,18 @@ void PairLJCutCoulDSFKokkos<DeviceType>::allocate()
PairLJCutCoulDSF::allocate();
int n = atom->ntypes;
memory->destroy(cutsq);
memoryKK->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
d_cutsq = k_cutsq.template view<DeviceType>();
memory->destroy(cut_ljsq);
memoryKK->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
//memory->destroy(cut_coulsq);
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCutCoulDSF::params",n+1,n+1);
params = k_params.template view<DeviceType>();
}
@ -342,7 +327,6 @@ double PairLJCutCoulDSFKokkos<DeviceType>::init_one(int i, int j)
{
double cutone = PairLJCutCoulDSF::init_one(i,j);
double cut_ljsqm = cut_ljsq[i][j];
double cut_coulsqm = cut_coulsq;
k_params.h_view(i,j).lj1 = lj1[i][j];
k_params.h_view(i,j).lj2 = lj2[i][j];
@ -350,22 +334,20 @@ double PairLJCutCoulDSFKokkos<DeviceType>::init_one(int i, int j)
k_params.h_view(i,j).lj4 = lj4[i][j];
k_params.h_view(i,j).offset = offset[i][j];
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsq;
k_params.h_view(j,i) = k_params.h_view(i,j);
if (i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsq;
}
k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_ljsq.h_view(i,j) = k_cut_ljsq.h_view(j,i) = cut_ljsqm;
k_cut_ljsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = k_cut_coulsq.h_view(j,i) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;

4
src/KOKKOS/pair_lj_cut_coul_dsf_kokkos.h
View File

@ -44,8 +44,6 @@ class PairLJCutCoulDSFKokkos : public PairLJCutCoulDSF {
double init_one(int, int);
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
@ -92,10 +90,8 @@ class PairLJCutCoulDSFKokkos : public PairLJCutCoulDSF {
typename AT::t_ffloat_2d d_cutsq;
typename AT::tdual_ffloat_2d k_cut_ljsq;
typename AT::t_ffloat_2d d_cut_ljsq;
typename AT::tdual_ffloat_2d k_cut_coulsq;
typename AT::t_ffloat_2d d_cut_coulsq;
int neighflag;
int nlocal,nall,eflag,vflag;

45
src/KOKKOS/pair_lj_cut_coul_long_kokkos.cpp
View File

@ -54,10 +54,6 @@ PairLJCutCoulLongKokkos<DeviceType>::PairLJCutCoulLongKokkos(LAMMPS *lmp):PairLJ
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = nullptr;
cut_coulsq = 0.0;
}
/* ---------------------------------------------------------------------- */
@ -65,31 +61,18 @@ PairLJCutCoulLongKokkos<DeviceType>::PairLJCutCoulLongKokkos(LAMMPS *lmp):PairLJ
template<class DeviceType>
PairLJCutCoulLongKokkos<DeviceType>::~PairLJCutCoulLongKokkos()
{
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
eatom = nullptr;
vatom = nullptr;
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_cutsq, cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq, cut_ljsq);
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
memoryKK->destroy_kokkos(k_cut_ljsq,cut_ljsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutCoulLongKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = nullptr;
eatom = nullptr;
vatom = nullptr;
ftable = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -117,7 +100,6 @@ void PairLJCutCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_ljsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -303,12 +285,14 @@ void PairLJCutCoulLongKokkos<DeviceType>::allocate()
memory->destroy(cutsq);
memoryKK->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
d_cutsq = k_cutsq.template view<DeviceType>();
memory->destroy(cut_ljsq);
memoryKK->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCutCoulLong::params",n+1,n+1);
params = k_params.template view<DeviceType>();
}
@ -479,7 +463,6 @@ double PairLJCutCoulLongKokkos<DeviceType>::init_one(int i, int j)
{
double cutone = PairLJCutCoulLong::init_one(i,j);
double cut_ljsqm = cut_ljsq[i][j];
double cut_coulsqm = cut_coulsq;
k_params.h_view(i,j).lj1 = lj1[i][j];
k_params.h_view(i,j).lj2 = lj2[i][j];
@ -487,29 +470,25 @@ double PairLJCutCoulLongKokkos<DeviceType>::init_one(int i, int j)
k_params.h_view(i,j).lj4 = lj4[i][j];
k_params.h_view(i,j).offset = offset[i][j];
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
k_params.h_view(i,j).cut_coulsq = cut_coulsq;
k_params.h_view(j,i) = k_params.h_view(i,j);
if (i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsq;
}
k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_ljsq.h_view(i,j) = k_cut_ljsq.h_view(j,i) = cut_ljsqm;
k_cut_ljsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = k_cut_coulsq.h_view(j,i) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;
}
namespace LAMMPS_NS {
template class PairLJCutCoulLongKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

3
src/KOKKOS/pair_lj_cut_coul_long_kokkos.h
View File

@ -46,8 +46,6 @@ class PairLJCutCoulLongKokkos : public PairLJCutCoulLong {
double init_one(int, int);
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
@ -94,7 +92,6 @@ class PairLJCutCoulLongKokkos : public PairLJCutCoulLong {
typename AT::t_ffloat_2d d_cutsq;
typename AT::tdual_ffloat_2d k_cut_ljsq;
typename AT::t_ffloat_2d d_cut_ljsq;
typename AT::tdual_ffloat_2d k_cut_coulsq;
typename AT::t_ffloat_2d d_cut_coulsq;
typename AT::t_ffloat_1d_randomread

22
src/KOKKOS/pair_lj_cut_kokkos.cpp
View File

@ -42,7 +42,6 @@ PairLJCutKokkos<DeviceType>::PairLJCutKokkos(LAMMPS *lmp) : PairLJCut(lmp)
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -50,30 +49,17 @@ PairLJCutKokkos<DeviceType>::PairLJCutKokkos(LAMMPS *lmp) : PairLJCut(lmp)
template<class DeviceType>
PairLJCutKokkos<DeviceType>::~PairLJCutKokkos()
{
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -119,6 +105,8 @@ void PairLJCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
// loop over neighbors of my atoms
copymode = 1;
EV_FLOAT ev = pair_compute<PairLJCutKokkos<DeviceType>,void >(this,(NeighListKokkos<DeviceType>*)list);
if (eflag_global) eng_vdwl += ev.evdwl;

2
src/KOKKOS/pair_lj_cut_kokkos.h
View File

@ -53,8 +53,6 @@ class PairLJCutKokkos : public PairLJCut {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;

23
src/KOKKOS/pair_lj_expand_kokkos.cpp
View File

@ -47,7 +47,6 @@ PairLJExpandKokkos<DeviceType>::PairLJExpandKokkos(LAMMPS *lmp) : PairLJExpand(l
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -55,29 +54,17 @@ PairLJExpandKokkos<DeviceType>::PairLJExpandKokkos(LAMMPS *lmp) : PairLJExpand(l
template<class DeviceType>
PairLJExpandKokkos<DeviceType>::~PairLJExpandKokkos()
{
if (!copymode) {
k_cutsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
cutsq = nullptr;
}
if (copymode) return;
if (allocated) {
cleanup_copy();
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJExpandKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJExpandKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_lj_expand_kokkos.h
View File

@ -53,8 +53,6 @@ class PairLJExpandKokkos : public PairLJExpand {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;

48
src/KOKKOS/pair_lj_gromacs_coul_gromacs_kokkos.cpp
View File

@ -47,10 +47,6 @@ PairLJGromacsCoulGromacsKokkos<DeviceType>::PairLJGromacsCoulGromacsKokkos(LAMMP
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_ljsq = 0.0;
cut_coulsq = 0.0;
}
/* ---------------------------------------------------------------------- */
@ -58,38 +54,17 @@ PairLJGromacsCoulGromacsKokkos<DeviceType>::PairLJGromacsCoulGromacsKokkos(LAMMP
template<class DeviceType>
PairLJGromacsCoulGromacsKokkos<DeviceType>::~PairLJGromacsCoulGromacsKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
k_cut_ljsq = DAT::tdual_ffloat_2d();
k_cut_coulsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
//memory->sfree(cut_ljsq);
//memory->sfree(cut_coulsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
cut_ljsq = 0.0;
cut_coulsq = 0.0;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJGromacsCoulGromacsKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_ljsq = 0.0;
eatom = nullptr;
vatom = nullptr;
ftable = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJGromacsCoulGromacsKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{
@ -115,8 +90,6 @@ void PairLJGromacsCoulGromacsKokkos<DeviceType>::compute(int eflag_in, int vflag
atomKK->sync(execution_space,datamask_read);
k_cutsq.template sync<DeviceType>();
k_cut_ljsq.template sync<DeviceType>();
k_cut_coulsq.template sync<DeviceType>();
k_params.template sync<DeviceType>();
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
else atomKK->modified(execution_space,F_MASK);
@ -298,12 +271,11 @@ void PairLJGromacsCoulGromacsKokkos<DeviceType>::allocate()
memoryKK->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
d_cutsq = k_cutsq.template view<DeviceType>();
//memory->destroy(cut_ljsq);
memoryKK->create_kokkos(k_cut_ljsq,n+1,n+1,"pair:cut_ljsq");
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
d_cut_ljsq = typename AT::t_ffloat_2d("pair:cut_ljsq",n+1,n+1);
Kokkos::deep_copy(d_cut_ljsq,cut_ljsq);
memoryKK->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
d_cut_coulsq = typename AT::t_ffloat_2d("pair:cut_coulsq",n+1,n+1);
Kokkos::deep_copy(d_cut_coulsq,cut_coulsq);
k_params = Kokkos::DualView<params_lj_coul_gromacs**,Kokkos::LayoutRight,DeviceType>("PairLJGromacsCoulGromacs::params",n+1,n+1);
params = k_params.template view<DeviceType>();
@ -499,10 +471,6 @@ double PairLJGromacsCoulGromacsKokkos<DeviceType>::init_one(int i, int j)
k_cutsq.h_view(i,j) = k_cutsq.h_view(j,i) = cutone*cutone;
k_cutsq.template modify<LMPHostType>();
k_cut_ljsq.h_view(i,j) = k_cut_ljsq.h_view(j,i) = cut_ljsqm;
k_cut_ljsq.template modify<LMPHostType>();
k_cut_coulsq.h_view(i,j) = k_cut_coulsq.h_view(j,i) = cut_coulsqm;
k_cut_coulsq.template modify<LMPHostType>();
k_params.template modify<LMPHostType>();
return cutone;

4
src/KOKKOS/pair_lj_gromacs_coul_gromacs_kokkos.h
View File

@ -54,8 +54,6 @@ class PairLJGromacsCoulGromacsKokkos : public PairLJGromacsCoulGromacs {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
@ -100,9 +98,7 @@ class PairLJGromacsCoulGromacsKokkos : public PairLJGromacsCoulGromacs {
typename AT::tdual_ffloat_2d k_cutsq;
typename AT::t_ffloat_2d d_cutsq;
typename AT::tdual_ffloat_2d k_cut_ljsq;
typename AT::t_ffloat_2d d_cut_ljsq;
typename AT::tdual_ffloat_2d k_cut_coulsq;
typename AT::t_ffloat_2d d_cut_coulsq;
typename AT::t_ffloat_1d_randomread

30
src/KOKKOS/pair_lj_gromacs_kokkos.cpp
View File

@ -47,10 +47,6 @@ PairLJGromacsKokkos<DeviceType>::PairLJGromacsKokkos(LAMMPS *lmp):PairLJGromacs(
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
cut_inner = nullptr;
cut_inner_sq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -58,35 +54,17 @@ PairLJGromacsKokkos<DeviceType>::PairLJGromacsKokkos(LAMMPS *lmp):PairLJGromacs(
template<class DeviceType>
PairLJGromacsKokkos<DeviceType>::~PairLJGromacsKokkos()
{
if (!copymode) {
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
k_cut_inner_sq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
cut_inner = nullptr;
cut_inner_sq = nullptr;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJGromacsKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
cut_inner = nullptr;
cut_inner_sq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJGromacsKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_lj_gromacs_kokkos.h
View File

@ -53,8 +53,6 @@ class PairLJGromacsKokkos : public PairLJGromacs {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,

20
src/KOKKOS/pair_lj_sdk_kokkos.cpp
View File

@ -47,7 +47,6 @@ PairLJSDKKokkos<DeviceType>::PairLJSDKKokkos(LAMMPS *lmp) : PairLJSDK(lmp)
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -55,26 +54,17 @@ PairLJSDKKokkos<DeviceType>::PairLJSDKKokkos(LAMMPS *lmp) : PairLJSDK(lmp)
template<class DeviceType>
PairLJSDKKokkos<DeviceType>::~PairLJSDKKokkos()
{
if (copymode) return;
if (allocated) {
k_cutsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
cutsq = nullptr;
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJSDKKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairLJSDKKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_lj_sdk_kokkos.h
View File

@ -54,8 +54,6 @@ class PairLJSDKKokkos : public PairLJSDK {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;

20
src/KOKKOS/pair_morse_kokkos.cpp
View File

@ -49,7 +49,6 @@ PairMorseKokkos<DeviceType>::PairMorseKokkos(LAMMPS *lmp) : PairMorse(lmp)
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -57,30 +56,17 @@ PairMorseKokkos<DeviceType>::PairMorseKokkos(LAMMPS *lmp) : PairMorse(lmp)
template<class DeviceType>
PairMorseKokkos<DeviceType>::~PairMorseKokkos()
{
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairMorseKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairMorseKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
{

2
src/KOKKOS/pair_morse_kokkos.h
View File

@ -52,8 +52,6 @@ class PairMorseKokkos : public PairMorse {
};
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;

1
src/KOKKOS/pair_reaxc_kokkos.h
View File

@ -331,7 +331,6 @@ class PairReaxCKokkos : public PairReaxC {
F_FLOAT *fi, F_FLOAT *fj, F_FLOAT *fk, F_FLOAT *dril, F_FLOAT *drjl, F_FLOAT *drkl) const;
protected:
void cleanup_copy();
void allocate();
void allocate_array();
void setup();

12
src/KOKKOS/pair_table_kokkos.cpp
View File

@ -50,11 +50,11 @@ template<class DeviceType>
PairTableKokkos<DeviceType>::~PairTableKokkos()
{
if (copymode) return;
delete h_table;
h_table = nullptr;
delete d_table;
d_table = nullptr;
copymode = true; //prevents base class destructor from running
}
/* ---------------------------------------------------------------------- */
@ -519,16 +519,6 @@ void PairTableKokkos<DeviceType>::init_style()
}
}
template<class DeviceType>
void PairTableKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
h_table=nullptr; d_table=nullptr;
}
namespace LAMMPS_NS {
template class PairTableKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

1
src/KOKKOS/pair_table_kokkos.h
View File

@ -120,7 +120,6 @@ class PairTableKokkos : public PairTable {
int update_table;
void create_kokkos_tables();
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION

10
src/KOKKOS/pair_table_rx_kokkos.cpp
View File

@ -1280,16 +1280,6 @@ void PairTableRXKokkos<DeviceType>::init_style()
}
}
template<class DeviceType>
void PairTableRXKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
h_table=nullptr; d_table=nullptr;
}
namespace LAMMPS_NS {
template class PairTableRXKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

1
src/KOKKOS/pair_table_rx_kokkos.h
View File

@ -90,7 +90,6 @@ class PairTableRXKokkos : public PairTable {
int update_table;
void create_kokkos_tables();
void cleanup_copy();
friend void pair_virial_fdotr_compute<PairTableRXKokkos>(PairTableRXKokkos*);

2
src/KOKKOS/pair_tersoff_kokkos.h
View File

@ -181,8 +181,6 @@ class PairTersoffKokkos : public PairTersoff {
void setup_params();
protected:
void cleanup_copy();
typedef Kokkos::DualView<int***,DeviceType> tdual_int_3d;
Kokkos::DualView<params_ters***,Kokkos::LayoutRight,DeviceType> k_params;
typename Kokkos::DualView<params_ters***,

2
src/KOKKOS/pair_tersoff_mod_kokkos.h
View File

@ -181,8 +181,6 @@ class PairTersoffMODKokkos : public PairTersoffMOD {
void setup_params();
protected:
void cleanup_copy();
typedef Kokkos::DualView<int***,DeviceType> tdual_int_3d;
Kokkos::DualView<params_ters***,Kokkos::LayoutRight,DeviceType> k_params;
typename Kokkos::DualView<params_ters***,

2
src/KOKKOS/pair_tersoff_zbl_kokkos.h
View File

@ -186,8 +186,6 @@ class PairTersoffZBLKokkos : public PairTersoffZBL {
double fermi_d_k(const int &i, const int &j, const int &k, const F_FLOAT &r) const;
protected:
void cleanup_copy();
typedef Kokkos::DualView<int***,DeviceType> tdual_int_3d;
Kokkos::DualView<params_ters***,Kokkos::LayoutRight,DeviceType> k_params;
typename Kokkos::DualView<params_ters***,

20
src/KOKKOS/pair_yukawa_kokkos.cpp
View File

@ -46,7 +46,6 @@ PairYukawaKokkos<DeviceType>::PairYukawaKokkos(LAMMPS *lmp) : PairYukawa(lmp)
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
cutsq = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -54,28 +53,15 @@ PairYukawaKokkos<DeviceType>::PairYukawaKokkos(LAMMPS *lmp) : PairYukawa(lmp)
template<class DeviceType>
PairYukawaKokkos<DeviceType>::~PairYukawaKokkos()
{
if (copymode) return;
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
k_cutsq = DAT::tdual_ffloat_2d();
memory->sfree(cutsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
memoryKK->destroy_kokkos(k_cutsq,cutsq);
}
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairYukawaKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
/* ----------------------------------------------------------------------
allocate all arrays
------------------------------------------------------------------------- */

2
src/KOKKOS/pair_yukawa_kokkos.h
View File

@ -53,8 +53,6 @@ class PairYukawaKokkos : public PairYukawa {
protected:
void cleanup_copy();
template<bool STACKPARAMS, class Specialisation>
KOKKOS_INLINE_FUNCTION
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,

16
src/KOKKOS/pair_zbl_kokkos.cpp
View File

@ -62,10 +62,6 @@ PairZBLKokkos<DeviceType>::~PairZBLKokkos()
if (allocated) {
memoryKK->destroy_kokkos(k_eatom,eatom);
memoryKK->destroy_kokkos(k_vatom,vatom);
memory->sfree(cutsq);
eatom = nullptr;
vatom = nullptr;
cutsq = nullptr;
}
}
@ -412,18 +408,6 @@ F_FLOAT PairZBLKokkos<DeviceType>::d2zbldr2(F_FLOAT r, int i, int j) const {
return result;
}
/* ---------------------------------------------------------------------- */
template<class DeviceType>
void PairZBLKokkos<DeviceType>::cleanup_copy() {
// WHY needed: this prevents parent copy from deallocating any arrays
allocated = 0;
cutsq = nullptr;
eatom = nullptr;
vatom = nullptr;
}
namespace LAMMPS_NS {
template class PairZBLKokkos<LMPDeviceType>;
#ifdef LMP_KOKKOS_GPU

1
src/KOKKOS/pair_zbl_kokkos.h
View File

@ -86,7 +86,6 @@ class PairZBLKokkos : public PairZBL {
F_FLOAT compute_ecoul(const F_FLOAT& /*rsq*/, const int& /*i*/, const int& /*j*/,
const int& /*itype*/, const int& /*jtype*/) const { return 0; }
void cleanup_copy();
void allocate();
friend struct PairComputeFunctor<PairZBLKokkos,FULL,true>;