2012-01-25 23:31:54 +08:00
|
|
|
/***************************************************************************
|
|
|
|
eam.cpp
|
|
|
|
-------------------
|
|
|
|
Trung Dac Nguyen, W. Michael Brown (ORNL)
|
|
|
|
|
|
|
|
Class for acceleration of the eam pair style.
|
|
|
|
|
|
|
|
__________________________________________________________________________
|
|
|
|
This file is part of the LAMMPS Accelerator Library (LAMMPS_AL)
|
|
|
|
__________________________________________________________________________
|
|
|
|
|
2016-07-02 07:27:26 +08:00
|
|
|
begin :
|
2012-01-25 23:31:54 +08:00
|
|
|
email : brownw@ornl.gov nguyentd@ornl.gov
|
|
|
|
***************************************************************************/
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-08-21 21:57:32 +08:00
|
|
|
#if defined(USE_OPENCL)
|
2012-01-25 23:31:54 +08:00
|
|
|
#include "eam_cl.h"
|
2012-08-21 21:57:32 +08:00
|
|
|
#elif defined(USE_CUDART)
|
|
|
|
const char *eam=0;
|
2012-01-25 23:31:54 +08:00
|
|
|
#else
|
2012-08-21 21:57:32 +08:00
|
|
|
#include "eam_cubin.h"
|
2012-01-25 23:31:54 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "lal_eam.h"
|
|
|
|
#include <cassert>
|
|
|
|
using namespace LAMMPS_AL;
|
|
|
|
#define EAMT EAM<numtyp, acctyp>
|
|
|
|
|
|
|
|
|
|
|
|
#define MIN(A,B) ((A) < (B) ? (A) : (B))
|
|
|
|
#define MAX(A,B) ((A) > (B) ? (A) : (B))
|
|
|
|
|
|
|
|
extern Device<PRECISION,ACC_PRECISION> device;
|
|
|
|
|
|
|
|
template <class numtyp, class acctyp>
|
2016-07-02 07:27:26 +08:00
|
|
|
EAMT::EAM() : BaseAtomic<numtyp,acctyp>(),
|
2012-01-25 23:31:54 +08:00
|
|
|
_compiled_energy(false), _allocated(false) {
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
EAMT::~EAM() {
|
|
|
|
clear();
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
int EAMT::init(const int ntypes, double host_cutforcesq, int **host_type2rhor,
|
|
|
|
int **host_type2z2r, int *host_type2frho,
|
|
|
|
double ***host_rhor_spline, double ***host_z2r_spline,
|
2016-07-02 07:27:26 +08:00
|
|
|
double ***host_frho_spline, double rdr, double rdrho,
|
2012-09-21 23:57:23 +08:00
|
|
|
double rhomax, int nrhor, int nrho, int nz2r, int nfrho, int nr,
|
|
|
|
const int nlocal, const int nall, const int max_nbors,
|
2016-07-02 07:27:26 +08:00
|
|
|
const int maxspecial, const double cell_size,
|
|
|
|
const double gpu_split, FILE *_screen)
|
2012-01-25 23:31:54 +08:00
|
|
|
{
|
|
|
|
int success;
|
|
|
|
success=this->init_atomic(nlocal,nall,max_nbors,maxspecial,cell_size,
|
2012-08-21 21:57:32 +08:00
|
|
|
gpu_split,_screen,eam,"k_eam");
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (success!=0)
|
|
|
|
return success;
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// allocate fp
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
int ef_nall=nall;
|
|
|
|
if (ef_nall==0)
|
|
|
|
ef_nall=2000;
|
|
|
|
|
|
|
|
_max_fp_size=static_cast<int>(static_cast<double>(ef_nall)*1.10);
|
2013-08-23 22:41:20 +08:00
|
|
|
_fp.alloc(_max_fp_size,*(this->ucl_device),UCL_READ_WRITE,UCL_READ_WRITE);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-08-21 21:57:32 +08:00
|
|
|
k_energy.set_function(*(this->pair_program),"k_energy");
|
|
|
|
k_energy_fast.set_function(*(this->pair_program),"k_energy_fast");
|
2012-01-25 23:31:54 +08:00
|
|
|
fp_tex.get_texture(*(this->pair_program),"fp_tex");
|
2012-08-21 21:57:32 +08:00
|
|
|
fp_tex.bind_float(_fp,1);
|
2012-01-25 23:31:54 +08:00
|
|
|
_compiled_energy = true;
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// Initialize timers for selected GPU
|
|
|
|
time_pair2.init(*(this->ucl_device));
|
|
|
|
time_pair2.zero();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
time_fp1.init(*(this->ucl_device));
|
|
|
|
time_fp1.zero();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
time_fp2.init(*(this->ucl_device));
|
|
|
|
time_fp2.zero();
|
|
|
|
|
|
|
|
// If atom type constants fit in shared memory use fast kernel
|
|
|
|
int lj_types=ntypes;
|
|
|
|
shared_types=false;
|
|
|
|
|
|
|
|
int max_shared_types=this->device->max_shared_types();
|
|
|
|
if (lj_types<=max_shared_types && this->_block_size>=max_shared_types) {
|
|
|
|
lj_types=max_shared_types;
|
|
|
|
shared_types=true;
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
_ntypes=lj_types;
|
|
|
|
_cutforcesq=host_cutforcesq;
|
|
|
|
_rdr=rdr;
|
|
|
|
_rdrho = rdrho;
|
2012-09-21 23:57:23 +08:00
|
|
|
_rhomax=rhomax;
|
2012-01-25 23:31:54 +08:00
|
|
|
_nrhor=nrhor;
|
|
|
|
_nrho=nrho;
|
|
|
|
_nz2r=nz2r;
|
|
|
|
_nfrho=nfrho;
|
|
|
|
_nr=nr;
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
UCL_H_Vec<int2> dview_type(lj_types*lj_types,*(this->ucl_device),
|
2013-08-23 22:41:20 +08:00
|
|
|
UCL_WRITE_ONLY);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
for (int i=0; i<lj_types*lj_types; i++) {
|
|
|
|
dview_type[i].x=0; dview_type[i].y=0;
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// pack type2rhor and type2z2r
|
|
|
|
type2rhor_z2r.alloc(lj_types*lj_types,*(this->ucl_device),UCL_READ_ONLY);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
for (int i=0; i<ntypes; i++) {
|
|
|
|
for (int j=0; j<ntypes; j++) {
|
|
|
|
dview_type[i*lj_types+j].x=host_type2rhor[i][j];
|
|
|
|
dview_type[i*lj_types+j].y=host_type2z2r[i][j];
|
|
|
|
}
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
ucl_copy(type2rhor_z2r,dview_type,false);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// pack type2frho
|
|
|
|
UCL_H_Vec<int> dview_type2frho(lj_types,*(this->ucl_device),
|
2013-08-23 22:41:20 +08:00
|
|
|
UCL_WRITE_ONLY);
|
2012-01-25 23:31:54 +08:00
|
|
|
|
|
|
|
type2frho.alloc(lj_types,*(this->ucl_device),UCL_READ_ONLY);
|
|
|
|
for (int i=0; i<ntypes; i++)
|
|
|
|
dview_type2frho[i]=host_type2frho[i];
|
|
|
|
ucl_copy(type2frho,dview_type2frho,false);
|
|
|
|
|
|
|
|
// pack frho_spline
|
|
|
|
UCL_H_Vec<numtyp4> dview_frho_spline(nfrho*(nrho+1),*(this->ucl_device),
|
2013-08-23 22:41:20 +08:00
|
|
|
UCL_WRITE_ONLY);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
for (int ix=0; ix<nfrho; ix++)
|
|
|
|
for (int iy=0; iy<nrho+1; iy++) {
|
|
|
|
dview_frho_spline[ix*(nrho+1)+iy].x=host_frho_spline[ix][iy][0];
|
|
|
|
dview_frho_spline[ix*(nrho+1)+iy].y=host_frho_spline[ix][iy][1];
|
|
|
|
dview_frho_spline[ix*(nrho+1)+iy].z=host_frho_spline[ix][iy][2];
|
|
|
|
dview_frho_spline[ix*(nrho+1)+iy].w=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
frho_spline1.alloc(nfrho*(nrho+1),*(this->ucl_device),UCL_READ_ONLY);
|
|
|
|
ucl_copy(frho_spline1,dview_frho_spline,false);
|
|
|
|
frho_spline1_tex.get_texture(*(this->pair_program),"frho_sp1_tex");
|
|
|
|
frho_spline1_tex.bind_float(frho_spline1,4);
|
|
|
|
|
|
|
|
for (int ix=0; ix<nfrho; ix++)
|
|
|
|
for (int iy=0; iy<nrho+1; iy++) {
|
|
|
|
dview_frho_spline[ix*(nrho+1)+iy].x=host_frho_spline[ix][iy][3];
|
|
|
|
dview_frho_spline[ix*(nrho+1)+iy].y=host_frho_spline[ix][iy][4];
|
|
|
|
dview_frho_spline[ix*(nrho+1)+iy].z=host_frho_spline[ix][iy][5];
|
|
|
|
dview_frho_spline[ix*(nrho+1)+iy].w=host_frho_spline[ix][iy][6];
|
|
|
|
}
|
|
|
|
|
|
|
|
frho_spline2.alloc(nfrho*(nrho+1),*(this->ucl_device),UCL_READ_ONLY);
|
|
|
|
ucl_copy(frho_spline2,dview_frho_spline,false);
|
|
|
|
frho_spline2_tex.get_texture(*(this->pair_program),"frho_sp2_tex");
|
|
|
|
frho_spline2_tex.bind_float(frho_spline2,4);
|
|
|
|
|
|
|
|
// pack rhor_spline
|
|
|
|
UCL_H_Vec<numtyp4> dview_rhor_spline(nrhor*(nr+1),*(this->ucl_device),
|
2013-08-23 22:41:20 +08:00
|
|
|
UCL_WRITE_ONLY);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
for (int ix=0; ix<nrhor; ix++)
|
|
|
|
for (int iy=0; iy<nr+1; iy++) {
|
|
|
|
dview_rhor_spline[ix*(nr+1)+iy].x=host_rhor_spline[ix][iy][0];
|
|
|
|
dview_rhor_spline[ix*(nr+1)+iy].y=host_rhor_spline[ix][iy][1];
|
|
|
|
dview_rhor_spline[ix*(nr+1)+iy].z=host_rhor_spline[ix][iy][2];
|
|
|
|
dview_rhor_spline[ix*(nr+1)+iy].w=(numtyp)0;
|
|
|
|
}
|
|
|
|
|
|
|
|
rhor_spline1.alloc(nrhor*(nr+1),*(this->ucl_device),UCL_READ_ONLY);
|
|
|
|
ucl_copy(rhor_spline1,dview_rhor_spline,false);
|
|
|
|
rhor_spline1_tex.get_texture(*(this->pair_program),"rhor_sp1_tex");
|
|
|
|
rhor_spline1_tex.bind_float(rhor_spline1,4);
|
|
|
|
|
|
|
|
for (int ix=0; ix<nrhor; ix++)
|
|
|
|
for (int iy=0; iy<nr+1; iy++) {
|
|
|
|
dview_rhor_spline[ix*(nr+1)+iy].x=host_rhor_spline[ix][iy][3];
|
|
|
|
dview_rhor_spline[ix*(nr+1)+iy].y=host_rhor_spline[ix][iy][4];
|
|
|
|
dview_rhor_spline[ix*(nr+1)+iy].z=host_rhor_spline[ix][iy][5];
|
|
|
|
dview_rhor_spline[ix*(nr+1)+iy].w=host_rhor_spline[ix][iy][6];
|
|
|
|
}
|
|
|
|
|
|
|
|
rhor_spline2.alloc(nrhor*(nr+1),*(this->ucl_device),UCL_READ_ONLY);
|
|
|
|
ucl_copy(rhor_spline2,dview_rhor_spline,false);
|
|
|
|
rhor_spline2_tex.get_texture(*(this->pair_program),"rhor_sp2_tex");
|
|
|
|
rhor_spline2_tex.bind_float(rhor_spline2,4);
|
|
|
|
|
|
|
|
// pack z2r_spline
|
|
|
|
UCL_H_Vec<numtyp4> dview_z2r_spline(nz2r*(nr+1),*(this->ucl_device),
|
2013-08-23 22:41:20 +08:00
|
|
|
UCL_WRITE_ONLY);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
for (int ix=0; ix<nz2r; ix++)
|
|
|
|
for (int iy=0; iy<nr+1; iy++) {
|
|
|
|
dview_z2r_spline[ix*(nr+1)+iy].x=host_z2r_spline[ix][iy][0];
|
|
|
|
dview_z2r_spline[ix*(nr+1)+iy].y=host_z2r_spline[ix][iy][1];
|
|
|
|
dview_z2r_spline[ix*(nr+1)+iy].z=host_z2r_spline[ix][iy][2];
|
|
|
|
dview_z2r_spline[ix*(nr+1)+iy].w=(numtyp)0;
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
z2r_spline1.alloc(nz2r*(nr+1),*(this->ucl_device),UCL_READ_ONLY);
|
|
|
|
ucl_copy(z2r_spline1,dview_z2r_spline,false);
|
|
|
|
z2r_spline1_tex.get_texture(*(this->pair_program),"z2r_sp1_tex");
|
|
|
|
z2r_spline1_tex.bind_float(z2r_spline1,4);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
for (int ix=0; ix<nz2r; ix++)
|
|
|
|
for (int iy=0; iy<nr+1; iy++) {
|
|
|
|
dview_z2r_spline[ix*(nr+1)+iy].x=host_z2r_spline[ix][iy][3];
|
|
|
|
dview_z2r_spline[ix*(nr+1)+iy].y=host_z2r_spline[ix][iy][4];
|
|
|
|
dview_z2r_spline[ix*(nr+1)+iy].z=host_z2r_spline[ix][iy][5];
|
|
|
|
dview_z2r_spline[ix*(nr+1)+iy].w=host_z2r_spline[ix][iy][6];
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
z2r_spline2.alloc(nz2r*(nr+1),*(this->ucl_device),UCL_READ_ONLY);
|
|
|
|
ucl_copy(z2r_spline2,dview_z2r_spline,false);
|
|
|
|
z2r_spline2_tex.get_texture(*(this->pair_program),"z2r_sp2_tex");
|
|
|
|
z2r_spline2_tex.bind_float(z2r_spline2,4);
|
|
|
|
|
|
|
|
_allocated=true;
|
|
|
|
this->_max_bytes=type2rhor_z2r.row_bytes()
|
|
|
|
+ type2frho.row_bytes()
|
|
|
|
+ rhor_spline1.row_bytes()
|
|
|
|
+ rhor_spline2.row_bytes()
|
|
|
|
+ frho_spline1.row_bytes()
|
|
|
|
+ frho_spline2.row_bytes()
|
|
|
|
+ z2r_spline1.row_bytes()
|
|
|
|
+ z2r_spline2.row_bytes()
|
2012-08-21 21:57:32 +08:00
|
|
|
+ _fp.device.row_bytes();
|
2012-01-25 23:31:54 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
void EAMT::clear() {
|
|
|
|
if (!_allocated)
|
|
|
|
return;
|
|
|
|
_allocated=false;
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
type2rhor_z2r.clear();
|
|
|
|
type2frho.clear();
|
|
|
|
rhor_spline1.clear();
|
|
|
|
rhor_spline2.clear();
|
|
|
|
frho_spline1.clear();
|
|
|
|
frho_spline2.clear();
|
|
|
|
z2r_spline1.clear();
|
|
|
|
z2r_spline2.clear();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-08-21 21:57:32 +08:00
|
|
|
_fp.clear();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
time_pair2.clear();
|
|
|
|
time_fp1.clear();
|
|
|
|
time_fp2.clear();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (_compiled_energy) {
|
|
|
|
k_energy_fast.clear();
|
|
|
|
k_energy.clear();
|
|
|
|
_compiled_energy=false;
|
|
|
|
}
|
|
|
|
|
|
|
|
this->clear_atomic();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
double EAMT::host_memory_usage() const {
|
|
|
|
return this->host_memory_usage_atomic()+sizeof(EAM<numtyp,acctyp>);
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Copy nbor list from host if necessary and then compute atom energies/forces
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
void EAMT::compute(const int f_ago, const int inum_full, const int nlocal,
|
|
|
|
const int nall, double **host_x, int *host_type,
|
|
|
|
int *ilist, int *numj, int **firstneigh,
|
|
|
|
const bool eflag, const bool vflag,
|
|
|
|
const bool eatom, const bool vatom,
|
|
|
|
int &host_start, const double cpu_time,
|
|
|
|
bool &success, void **fp_ptr) {
|
|
|
|
this->acc_timers();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (this->device->time_device()) {
|
|
|
|
// Put time from the second part to the total time_pair
|
|
|
|
this->time_pair.add_time_to_total(time_pair2.time());
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// Add transfer time from device -> host after part 1
|
|
|
|
this->atom->add_transfer_time(time_fp1.time());
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// Add transfer time from host -> device before part 2
|
|
|
|
this->atom->add_transfer_time(time_fp2.time());
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// ------------------- Resize FP Array for EAM --------------------
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (nall>_max_fp_size) {
|
|
|
|
_max_fp_size=static_cast<int>(static_cast<double>(nall)*1.10);
|
2012-08-21 21:57:32 +08:00
|
|
|
_fp.resize(_max_fp_size);
|
|
|
|
fp_tex.bind_float(_fp,1);
|
2012-01-25 23:31:54 +08:00
|
|
|
}
|
2012-08-21 21:57:32 +08:00
|
|
|
*fp_ptr=_fp.host.begin();
|
2012-01-25 23:31:54 +08:00
|
|
|
|
|
|
|
// ----------------------------------------------------------------
|
|
|
|
|
|
|
|
if (inum_full==0) {
|
|
|
|
host_start=0;
|
|
|
|
// Make sure textures are correct if realloc by a different hybrid style
|
|
|
|
this->resize_atom(0,nall,success);
|
|
|
|
this->zero_timers();
|
|
|
|
return;
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
int ago=this->hd_balancer.ago_first(f_ago);
|
|
|
|
int inum=this->hd_balancer.balance(ago,inum_full,cpu_time);
|
|
|
|
this->ans->inum(inum);
|
|
|
|
host_start=inum;
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------
|
|
|
|
|
|
|
|
if (ago==0) {
|
|
|
|
this->reset_nbors(nall, inum, ilist, numj, firstneigh, success);
|
|
|
|
if (!success)
|
|
|
|
return;
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
this->atom->cast_x_data(host_x,host_type);
|
|
|
|
this->atom->add_x_data(host_x,host_type);
|
|
|
|
|
|
|
|
loop(eflag,vflag);
|
|
|
|
|
|
|
|
// copy fp from device to host for comm
|
|
|
|
_nlocal=nlocal;
|
|
|
|
time_fp1.start();
|
2012-08-21 21:57:32 +08:00
|
|
|
_fp.update_host(nlocal,true);
|
2012-01-25 23:31:54 +08:00
|
|
|
time_fp1.stop();
|
2012-03-02 23:57:05 +08:00
|
|
|
time_fp1.sync_stop();
|
2012-01-25 23:31:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Reneighbor on GPU and then compute per-atom densities
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
int** EAMT::compute(const int ago, const int inum_full, const int nall,
|
2016-07-02 07:27:26 +08:00
|
|
|
double **host_x, int *host_type, double *sublo,
|
2014-01-26 07:53:12 +08:00
|
|
|
double *subhi, tagint *tag, int **nspecial, tagint **special,
|
2012-01-25 23:31:54 +08:00
|
|
|
const bool eflag, const bool vflag, const bool eatom,
|
|
|
|
const bool vatom, int &host_start, int **ilist, int **jnum,
|
2016-07-02 07:27:26 +08:00
|
|
|
const double cpu_time, bool &success, int &inum,
|
2012-01-25 23:31:54 +08:00
|
|
|
void **fp_ptr) {
|
|
|
|
this->acc_timers();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (this->device->time_device()) {
|
|
|
|
// Put time from the second part to the total time_pair
|
|
|
|
this->time_pair.add_time_to_total(time_pair2.time());
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// Add transfer time from device -> host after part 1
|
|
|
|
this->atom->add_transfer_time(time_fp1.time());
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// Add transfer time from host -> device before part 2
|
|
|
|
this->atom->add_transfer_time(time_fp2.time());
|
|
|
|
}
|
|
|
|
|
|
|
|
// ------------------- Resize FP Array for EAM --------------------
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (nall>_max_fp_size) {
|
|
|
|
_max_fp_size=static_cast<int>(static_cast<double>(nall)*1.10);
|
2012-08-21 21:57:32 +08:00
|
|
|
_fp.resize(_max_fp_size);
|
|
|
|
fp_tex.bind_float(_fp,1);
|
2016-07-02 07:27:26 +08:00
|
|
|
}
|
|
|
|
*fp_ptr=_fp.host.begin();
|
2012-01-25 23:31:54 +08:00
|
|
|
|
|
|
|
// -----------------------------------------------------------------
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (inum_full==0) {
|
|
|
|
host_start=0;
|
|
|
|
// Make sure textures are correct if realloc by a different hybrid style
|
|
|
|
this->resize_atom(0,nall,success);
|
|
|
|
this->zero_timers();
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// load balance, returning the atom count on the device (inum)
|
|
|
|
this->hd_balancer.balance(cpu_time);
|
|
|
|
inum=this->hd_balancer.get_gpu_count(ago,inum_full);
|
|
|
|
this->ans->inum(inum);
|
|
|
|
host_start=inum;
|
2016-07-02 07:27:26 +08:00
|
|
|
|
|
|
|
// Build neighbor list on GPU if necessary
|
2012-01-25 23:31:54 +08:00
|
|
|
if (ago==0) {
|
|
|
|
this->build_nbor_list(inum, inum_full-inum, nall, host_x, host_type,
|
|
|
|
sublo, subhi, tag, nspecial, special, success);
|
|
|
|
if (!success)
|
|
|
|
return NULL;
|
|
|
|
} else {
|
|
|
|
this->atom->cast_x_data(host_x,host_type);
|
|
|
|
this->atom->add_x_data(host_x,host_type);
|
|
|
|
}
|
|
|
|
*ilist=this->nbor->host_ilist.begin();
|
|
|
|
*jnum=this->nbor->host_acc.begin();
|
|
|
|
|
|
|
|
loop(eflag,vflag);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
// copy fp from device to host for comm
|
|
|
|
_nlocal=inum_full;
|
|
|
|
time_fp1.start();
|
2012-08-21 21:57:32 +08:00
|
|
|
_fp.update_host(inum_full,true);
|
2012-01-25 23:31:54 +08:00
|
|
|
time_fp1.stop();
|
2012-03-02 23:57:05 +08:00
|
|
|
time_fp1.sync_stop();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
return this->nbor->host_jlist.begin()-host_start;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Copy nbor list from host if necessary and then calculate forces, virials,..
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
void EAMT::compute2(int *ilist, const bool eflag, const bool vflag,
|
|
|
|
const bool eatom, const bool vatom) {
|
2016-07-02 07:27:26 +08:00
|
|
|
if (this->ans->inum()==0)
|
2012-01-25 23:31:54 +08:00
|
|
|
return;
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
this->hd_balancer.start_timer();
|
|
|
|
time_fp2.start();
|
|
|
|
this->add_fp_data();
|
|
|
|
time_fp2.stop();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
loop2(eflag,vflag);
|
|
|
|
if (ilist == NULL)
|
|
|
|
this->ans->copy_answers(eflag,vflag,eatom,vatom);
|
|
|
|
else
|
|
|
|
this->ans->copy_answers(eflag,vflag,eatom,vatom, ilist);
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
this->device->add_ans_object(this->ans);
|
|
|
|
this->hd_balancer.stop_timer();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Calculate per-atom energies and forces
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
void EAMT::loop(const bool _eflag, const bool _vflag) {
|
|
|
|
// Compute the block size and grid size to keep all cores busy
|
|
|
|
const int BX=this->block_size();
|
|
|
|
int eflag, vflag;
|
|
|
|
if (_eflag)
|
|
|
|
eflag=1;
|
|
|
|
else
|
|
|
|
eflag=0;
|
|
|
|
|
|
|
|
if (_vflag)
|
|
|
|
vflag=1;
|
|
|
|
else
|
|
|
|
vflag=0;
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
int GX=static_cast<int>(ceil(static_cast<double>(this->ans->inum())/
|
|
|
|
(BX/this->_threads_per_atom)));
|
|
|
|
|
|
|
|
int ainum=this->ans->inum();
|
|
|
|
int nbor_pitch=this->nbor->nbor_pitch();
|
|
|
|
this->time_pair.start();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (shared_types) {
|
|
|
|
this->k_energy_fast.set_size(GX,BX);
|
2012-08-21 21:57:32 +08:00
|
|
|
this->k_energy_fast.run(&this->atom->x, &type2rhor_z2r, &type2frho,
|
2016-07-02 07:27:26 +08:00
|
|
|
&rhor_spline2, &frho_spline1,&frho_spline2,
|
|
|
|
&this->nbor->dev_nbor, &this->_nbor_data->begin(),
|
2012-08-21 21:57:32 +08:00
|
|
|
&_fp, &this->ans->engv, &eflag, &ainum,
|
2012-01-25 23:31:54 +08:00
|
|
|
&nbor_pitch, &_ntypes, &_cutforcesq, &_rdr, &_rdrho,
|
2012-09-21 23:57:23 +08:00
|
|
|
&_rhomax, &_nrho, &_nr, &this->_threads_per_atom);
|
2012-01-25 23:31:54 +08:00
|
|
|
} else {
|
|
|
|
this->k_energy.set_size(GX,BX);
|
2012-08-21 21:57:32 +08:00
|
|
|
this->k_energy.run(&this->atom->x, &type2rhor_z2r, &type2frho,
|
2016-07-02 07:27:26 +08:00
|
|
|
&rhor_spline2, &frho_spline1, &frho_spline2,
|
|
|
|
&this->nbor->dev_nbor, &this->_nbor_data->begin(), &_fp,
|
2012-08-21 21:57:32 +08:00
|
|
|
&this->ans->engv,&eflag, &ainum, &nbor_pitch,
|
2012-09-21 23:57:23 +08:00
|
|
|
&_ntypes, &_cutforcesq, &_rdr, &_rdrho, &_rhomax, &_nrho,
|
|
|
|
&_nr, &this->_threads_per_atom);
|
2012-01-25 23:31:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
this->time_pair.stop();
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Calculate energies, forces, and torques
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
template <class numtyp, class acctyp>
|
|
|
|
void EAMT::loop2(const bool _eflag, const bool _vflag) {
|
|
|
|
// Compute the block size and grid size to keep all cores busy
|
|
|
|
const int BX=this->block_size();
|
|
|
|
int eflag, vflag;
|
|
|
|
if (_eflag)
|
|
|
|
eflag=1;
|
|
|
|
else
|
|
|
|
eflag=0;
|
|
|
|
|
|
|
|
if (_vflag)
|
|
|
|
vflag=1;
|
|
|
|
else
|
|
|
|
vflag=0;
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
int GX=static_cast<int>(ceil(static_cast<double>(this->ans->inum())/
|
|
|
|
(BX/this->_threads_per_atom)));
|
|
|
|
|
|
|
|
int ainum=this->ans->inum();
|
|
|
|
int nbor_pitch=this->nbor->nbor_pitch();
|
|
|
|
this->time_pair2.start();
|
2016-07-02 07:27:26 +08:00
|
|
|
|
2012-01-25 23:31:54 +08:00
|
|
|
if (shared_types) {
|
|
|
|
this->k_pair_fast.set_size(GX,BX);
|
2012-08-21 21:57:32 +08:00
|
|
|
this->k_pair_fast.run(&this->atom->x, &_fp, &type2rhor_z2r,
|
2016-07-02 07:27:26 +08:00
|
|
|
&rhor_spline1, &z2r_spline1, &z2r_spline2,
|
|
|
|
&this->nbor->dev_nbor, &this->_nbor_data->begin(),
|
2012-08-21 21:57:32 +08:00
|
|
|
&this->ans->force, &this->ans->engv, &eflag,
|
|
|
|
&vflag, &ainum, &nbor_pitch, &_cutforcesq, &_rdr,
|
|
|
|
&_nr, &this->_threads_per_atom);
|
2012-01-25 23:31:54 +08:00
|
|
|
} else {
|
|
|
|
this->k_pair.set_size(GX,BX);
|
2016-07-02 07:27:26 +08:00
|
|
|
this->k_pair.run(&this->atom->x, &_fp, &type2rhor_z2r, &rhor_spline1,
|
2012-08-21 21:57:32 +08:00
|
|
|
&z2r_spline1, &z2r_spline2, &this->nbor->dev_nbor,
|
|
|
|
&this->_nbor_data->begin(), &this->ans->force,
|
|
|
|
&this->ans->engv, &eflag, &vflag, &ainum, &nbor_pitch,
|
|
|
|
&_ntypes, &_cutforcesq, &_rdr, &_nr,
|
|
|
|
&this->_threads_per_atom);
|
2012-01-25 23:31:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
this->time_pair2.stop();
|
|
|
|
}
|
|
|
|
|
|
|
|
template class EAM<PRECISION,ACC_PRECISION>;
|