Jonathan R. Madsen
7042f85927
* Python implementation of run-ci.sh
* Container workflow update
- retry failed container build to combat network failures
* cpack workflow update
- retry failed base container build to combat network failures
* General CI workflow updates
- retry failed "Install packages" step to combat network failures
* Miscellanous linting fixes
* Formatting workflow update
- improve regex for source formatting
* format user.h
* Add new omnitrace-avail tests
* Make run-ci.py executable
* workflow retry fix
- timeout_seconds -> retry_wait_seconds
* Fix cmake formatting glob
* source formatting
* Handle PRs in run-ci.py
* Specify timeout_minutes in retry steps
* Remove remaining --cmake-args from workflows
* CI warnings about using MPICH headers
* Remove text=True from run-ci.py
- not capturing stdout/sterr so unnecessary
* Fix OpenSUSE step label
* Update omnitrace-avail-write-config tests
- use TWD (Test Working Directory) instead of PWD since PWD might not be build directory
* paths-ignore + workflow_dispatch
[ROCm/rocprofiler-systems commit: e1102a8ba4]
874 строки
26 KiB
C++
874 строки
26 KiB
C++
|
|
#if !defined(USE_MPI)
|
|
# error "You should specify USE_MPI=0 or USE_MPI=1 on the compile line"
|
|
#endif
|
|
|
|
// OpenMP will be compiled in if this flag is set to 1 AND the compiler beging
|
|
// used supports it (i.e. the _OPENMP symbol is defined)
|
|
#define USE_OMP 1
|
|
|
|
#if USE_MPI
|
|
# include <mpi.h>
|
|
|
|
/*
|
|
define one of these three symbols:
|
|
|
|
SEDOV_SYNC_POS_VEL_NONE
|
|
SEDOV_SYNC_POS_VEL_EARLY
|
|
SEDOV_SYNC_POS_VEL_LATE
|
|
*/
|
|
|
|
# define SEDOV_SYNC_POS_VEL_EARLY 1
|
|
#endif
|
|
|
|
#include <Kokkos_Core.hpp>
|
|
#include <Kokkos_StaticCrsGraph.hpp>
|
|
#include <Kokkos_Vector.hpp>
|
|
|
|
#include <math.h>
|
|
#include <vector>
|
|
|
|
//**************************************************
|
|
// Allow flexibility for arithmetic representations
|
|
//**************************************************
|
|
|
|
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
|
|
|
|
// Precision specification
|
|
typedef float real4;
|
|
typedef double real8;
|
|
typedef long double real10; // 10 bytes on x86
|
|
|
|
typedef int Index_t; // array subscript and loop index
|
|
typedef real8 Real_t; // floating point representation
|
|
typedef int Int_t; // integer representation
|
|
|
|
enum
|
|
{
|
|
VolumeError = -1,
|
|
QStopError = -2
|
|
};
|
|
|
|
KOKKOS_INLINE_FUNCTION real4
|
|
SQRT(real4 arg)
|
|
{
|
|
return sqrtf(arg);
|
|
}
|
|
KOKKOS_INLINE_FUNCTION real8
|
|
SQRT(real8 arg)
|
|
{
|
|
return sqrt(arg);
|
|
}
|
|
KOKKOS_INLINE_FUNCTION real10
|
|
SQRT(real10 arg)
|
|
{
|
|
return sqrtl(arg);
|
|
}
|
|
|
|
KOKKOS_INLINE_FUNCTION real4
|
|
CBRT(real4 arg)
|
|
{
|
|
return cbrtf(arg);
|
|
}
|
|
KOKKOS_INLINE_FUNCTION real8
|
|
CBRT(real8 arg)
|
|
{
|
|
return cbrt(arg);
|
|
}
|
|
KOKKOS_INLINE_FUNCTION real10
|
|
CBRT(real10 arg)
|
|
{
|
|
return cbrtl(arg);
|
|
}
|
|
|
|
KOKKOS_INLINE_FUNCTION real4
|
|
FABS(real4 arg)
|
|
{
|
|
return fabsf(arg);
|
|
}
|
|
KOKKOS_INLINE_FUNCTION real8
|
|
FABS(real8 arg)
|
|
{
|
|
return fabs(arg);
|
|
}
|
|
KOKKOS_INLINE_FUNCTION real10
|
|
FABS(real10 arg)
|
|
{
|
|
return fabsl(arg);
|
|
}
|
|
|
|
// Stuff needed for boundary conditions
|
|
// 2 BCs on each of 6 hexahedral faces (12 bits)
|
|
#define XI_M 0x00007
|
|
#define XI_M_SYMM 0x00001
|
|
#define XI_M_FREE 0x00002
|
|
#define XI_M_COMM 0x00004
|
|
|
|
#define XI_P 0x00038
|
|
#define XI_P_SYMM 0x00008
|
|
#define XI_P_FREE 0x00010
|
|
#define XI_P_COMM 0x00020
|
|
|
|
#define ETA_M 0x001c0
|
|
#define ETA_M_SYMM 0x00040
|
|
#define ETA_M_FREE 0x00080
|
|
#define ETA_M_COMM 0x00100
|
|
|
|
#define ETA_P 0x00e00
|
|
#define ETA_P_SYMM 0x00200
|
|
#define ETA_P_FREE 0x00400
|
|
#define ETA_P_COMM 0x00800
|
|
|
|
#define ZETA_M 0x07000
|
|
#define ZETA_M_SYMM 0x01000
|
|
#define ZETA_M_FREE 0x02000
|
|
#define ZETA_M_COMM 0x04000
|
|
|
|
#define ZETA_P 0x38000
|
|
#define ZETA_P_SYMM 0x08000
|
|
#define ZETA_P_FREE 0x10000
|
|
#define ZETA_P_COMM 0x20000
|
|
|
|
// MPI Message Tags
|
|
#define MSG_COMM_SBN 1024
|
|
#define MSG_SYNC_POS_VEL 2048
|
|
#define MSG_MONOQ 3072
|
|
|
|
#define MAX_FIELDS_PER_MPI_COMM 6
|
|
|
|
// Assume 128 byte coherence
|
|
// Assume Real_t is an "integral power of 2" bytes wide
|
|
#define CACHE_COHERENCE_PAD_REAL (128 / sizeof(Real_t))
|
|
|
|
#define CACHE_ALIGN_REAL(n) \
|
|
(((n) + (CACHE_COHERENCE_PAD_REAL - 1)) & ~(CACHE_COHERENCE_PAD_REAL - 1))
|
|
|
|
//////////////////////////////////////////////////////
|
|
// Primary data structure
|
|
//////////////////////////////////////////////////////
|
|
|
|
/*
|
|
* The implementation of the data abstraction used for lulesh
|
|
* resides entirely in the Domain class below. You can change
|
|
* grouping and interleaving of fields here to maximize data layout
|
|
* efficiency for your underlying architecture or compiler.
|
|
*
|
|
* For example, fields can be implemented as STL objects or
|
|
* raw array pointers. As another example, individual fields
|
|
* m_x, m_y, m_z could be budled into
|
|
*
|
|
* struct { Real_t x, y, z ; } *m_coord ;
|
|
*
|
|
* allowing accessor functions such as
|
|
*
|
|
* "Real_t &x(Index_t idx) { return m_coord[idx].x ; }"
|
|
* "Real_t &y(Index_t idx) { return m_coord[idx].y ; }"
|
|
* "Real_t &z(Index_t idx) { return m_coord[idx].z ; }"
|
|
*/
|
|
|
|
class Domain
|
|
{
|
|
public:
|
|
// Constructor
|
|
Domain(Int_t numRanks, Index_t colLoc, Index_t rowLoc, Index_t planeLoc, Index_t nx,
|
|
Int_t tp, Int_t nr, Int_t balance, Int_t cost);
|
|
|
|
// Destructor
|
|
KOKKOS_FUNCTION ~Domain();
|
|
|
|
//
|
|
// ALLOCATION
|
|
//
|
|
|
|
void AllocateNodePersistent(Int_t numNode) // Node-centered
|
|
{
|
|
Kokkos::resize(m_x, numNode); // coordinates
|
|
Kokkos::resize(m_y, numNode);
|
|
Kokkos::resize(m_z, numNode);
|
|
|
|
Kokkos::resize(m_xd, numNode); // velocities
|
|
Kokkos::resize(m_yd, numNode);
|
|
Kokkos::resize(m_zd, numNode);
|
|
|
|
Kokkos::resize(m_xdd, numNode); // accelerations
|
|
Kokkos::resize(m_ydd, numNode);
|
|
Kokkos::resize(m_zdd, numNode);
|
|
|
|
Kokkos::resize(m_fx, numNode); // forces
|
|
Kokkos::resize(m_fy, numNode);
|
|
Kokkos::resize(m_fz, numNode);
|
|
|
|
Kokkos::resize(m_nodalMass, numNode); // mass
|
|
|
|
m_c_x = m_x;
|
|
m_c_y = m_y;
|
|
m_c_z = m_z;
|
|
m_c_xd = m_xd;
|
|
m_c_yd = m_yd;
|
|
m_c_zd = m_zd;
|
|
}
|
|
|
|
void AllocateElemPersistent(Int_t numElem) // Elem-centered
|
|
{
|
|
Kokkos::resize(m_nodelist, numElem);
|
|
|
|
// elem connectivities through face
|
|
Kokkos::resize(m_lxim, numElem);
|
|
Kokkos::resize(m_lxip, numElem);
|
|
Kokkos::resize(m_letam, numElem);
|
|
Kokkos::resize(m_letap, numElem);
|
|
Kokkos::resize(m_lzetam, numElem);
|
|
Kokkos::resize(m_lzetap, numElem);
|
|
|
|
Kokkos::resize(m_elemBC, numElem);
|
|
|
|
Kokkos::resize(m_e, numElem);
|
|
Kokkos::resize(m_p, numElem);
|
|
|
|
Kokkos::resize(m_q, numElem);
|
|
Kokkos::resize(m_ql, numElem);
|
|
Kokkos::resize(m_qq, numElem);
|
|
|
|
Kokkos::resize(m_v, numElem);
|
|
|
|
Kokkos::resize(m_volo, numElem);
|
|
Kokkos::resize(m_delv, numElem);
|
|
Kokkos::resize(m_vdov, numElem);
|
|
|
|
Kokkos::resize(m_arealg, numElem);
|
|
|
|
Kokkos::resize(m_ss, numElem);
|
|
|
|
Kokkos::resize(m_elemMass, numElem);
|
|
|
|
Kokkos::resize(m_vnew, numElem);
|
|
|
|
m_c_e = m_e;
|
|
m_c_p = m_p;
|
|
m_c_q = m_q;
|
|
m_c_ql = m_ql;
|
|
m_c_qq = m_qq;
|
|
m_c_delv = m_delv;
|
|
}
|
|
|
|
void AllocateGradients(Int_t numElem, Int_t allElem)
|
|
{
|
|
// Position gradients
|
|
Kokkos::resize(m_delx_xi, numElem);
|
|
Kokkos::resize(m_delx_eta, numElem);
|
|
Kokkos::resize(m_delx_zeta, numElem);
|
|
|
|
// Velocity gradients
|
|
Kokkos::resize(m_delv_xi, allElem);
|
|
Kokkos::resize(m_delv_eta, allElem);
|
|
Kokkos::resize(m_delv_zeta, allElem);
|
|
}
|
|
|
|
void DeallocateGradients()
|
|
{
|
|
m_delx_zeta = Kokkos::View<Real_t*>();
|
|
m_delx_eta = Kokkos::View<Real_t*>();
|
|
m_delx_xi = Kokkos::View<Real_t*>();
|
|
|
|
m_delv_zeta = Kokkos::View<Real_t*>();
|
|
m_delv_eta = Kokkos::View<Real_t*>();
|
|
m_delv_xi = Kokkos::View<Real_t*>();
|
|
}
|
|
|
|
void AllocateStrains(Int_t numElem)
|
|
{
|
|
Kokkos::resize(m_dxx, numElem);
|
|
Kokkos::resize(m_dyy, numElem);
|
|
Kokkos::resize(m_dzz, numElem);
|
|
}
|
|
|
|
void DeallocateStrains()
|
|
{
|
|
m_dzz = Kokkos::View<Real_t*>();
|
|
m_dyy = Kokkos::View<Real_t*>();
|
|
m_dxx = Kokkos::View<Real_t*>();
|
|
}
|
|
|
|
//
|
|
// ACCESSORS
|
|
//
|
|
KOKKOS_INLINE_FUNCTION
|
|
const Kokkos::View<Real_t*>& e_view() const { return m_e; }
|
|
|
|
// Node-centered
|
|
|
|
// Nodal coordinates
|
|
KOKKOS_INLINE_FUNCTION Real_t& x(const Index_t idx) const { return m_x[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& y(const Index_t idx) const { return m_y[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& z(const Index_t idx) const { return m_z[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_x(const Index_t idx) const { return m_c_x[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_y(const Index_t idx) const { return m_c_y[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_z(const Index_t idx) const { return m_c_z[idx]; }
|
|
|
|
// Nodal velocities
|
|
KOKKOS_INLINE_FUNCTION Real_t& xd(const Index_t idx) const { return m_xd[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& yd(const Index_t idx) const { return m_yd[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& zd(const Index_t idx) const { return m_zd[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_xd(const Index_t idx) const { return m_c_xd[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_yd(const Index_t idx) const { return m_c_yd[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_zd(const Index_t idx) const { return m_c_zd[idx]; }
|
|
|
|
// Nodal accelerations
|
|
KOKKOS_INLINE_FUNCTION Real_t& xdd(const Index_t idx) const { return m_xdd[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& ydd(const Index_t idx) const { return m_ydd[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& zdd(const Index_t idx) const { return m_zdd[idx]; }
|
|
|
|
// Nodal forces
|
|
KOKKOS_INLINE_FUNCTION Real_t& fx(const Index_t idx) const { return m_fx[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& fy(const Index_t idx) const { return m_fy[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& fz(const Index_t idx) const { return m_fz[idx]; }
|
|
|
|
// Nodal mass
|
|
KOKKOS_INLINE_FUNCTION Real_t& nodalMass(const Index_t idx) const
|
|
{
|
|
return m_nodalMass[idx];
|
|
}
|
|
|
|
// Nodes on symmertry planes
|
|
KOKKOS_INLINE_FUNCTION Index_t symmX(const Index_t idx) const { return m_symmX[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Index_t symmY(const Index_t idx) const { return m_symmY[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Index_t symmZ(const Index_t idx) const { return m_symmZ[idx]; }
|
|
KOKKOS_INLINE_FUNCTION bool symmXempty() { return m_symmX.data() == nullptr; }
|
|
KOKKOS_INLINE_FUNCTION bool symmYempty() { return m_symmY.data() == nullptr; }
|
|
KOKKOS_INLINE_FUNCTION bool symmZempty() { return m_symmZ.data() == nullptr; }
|
|
|
|
//
|
|
// Element-centered
|
|
//
|
|
Index_t& regElemSize(Index_t idx) { return m_regElemSize[idx]; }
|
|
Index_t& regNumList(Index_t idx) { return m_regNumList[idx]; }
|
|
Index_t* regNumList() { return &m_regNumList[0]; }
|
|
Index_t* regElemlist(Int_t r) const
|
|
{
|
|
return &m_regElemlist.entries(m_regElemlist.row_map(r));
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Index_t regElemlist(const Int_t r, Index_t idx) const
|
|
{
|
|
return m_regElemlist.entries(m_regElemlist.row_map(r) + idx);
|
|
}
|
|
|
|
KOKKOS_INLINE_FUNCTION Index_t& nodelist(Index_t i, Index_t j) const
|
|
{
|
|
return m_nodelist(i, j);
|
|
}
|
|
|
|
// elem connectivities through face
|
|
KOKKOS_INLINE_FUNCTION Index_t& lxim(const Index_t idx) const { return m_lxim[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Index_t& lxip(const Index_t idx) const { return m_lxip[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Index_t& letam(const Index_t idx) const
|
|
{
|
|
return m_letam[idx];
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Index_t& letap(const Index_t idx) const
|
|
{
|
|
return m_letap[idx];
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Index_t& lzetam(const Index_t idx) const
|
|
{
|
|
return m_lzetam[idx];
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Index_t& lzetap(const Index_t idx) const
|
|
{
|
|
return m_lzetap[idx];
|
|
}
|
|
|
|
// elem face symm/free-surface flag
|
|
KOKKOS_INLINE_FUNCTION Int_t& elemBC(const Index_t idx) const
|
|
{
|
|
return m_elemBC[idx];
|
|
}
|
|
|
|
// Principal strains - temporary
|
|
KOKKOS_INLINE_FUNCTION Real_t& dxx(const Index_t idx) const { return m_dxx[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& dyy(const Index_t idx) const { return m_dyy[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& dzz(const Index_t idx) const { return m_dzz[idx]; }
|
|
|
|
// New relative volume - temporary
|
|
KOKKOS_INLINE_FUNCTION Real_t& vnew(const Index_t idx) const { return m_vnew[idx]; }
|
|
|
|
// Velocity gradient - temporary
|
|
KOKKOS_INLINE_FUNCTION Real_t& delv_xi(const Index_t idx) const
|
|
{
|
|
return m_delv_xi[idx];
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Real_t& delv_eta(const Index_t idx) const
|
|
{
|
|
return m_delv_eta[idx];
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Real_t& delv_zeta(const Index_t idx) const
|
|
{
|
|
return m_delv_zeta[idx];
|
|
}
|
|
|
|
// Position gradient - temporary
|
|
KOKKOS_INLINE_FUNCTION Real_t& delx_xi(const Index_t idx) const
|
|
{
|
|
return m_delx_xi[idx];
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Real_t& delx_eta(const Index_t idx) const
|
|
{
|
|
return m_delx_eta[idx];
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Real_t& delx_zeta(const Index_t idx) const
|
|
{
|
|
return m_delx_zeta[idx];
|
|
}
|
|
// Energy
|
|
KOKKOS_INLINE_FUNCTION Real_t& e(const Index_t idx) const { return m_e[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_e(const Index_t idx) const { return m_c_e[idx]; }
|
|
|
|
// Pressure
|
|
KOKKOS_INLINE_FUNCTION Real_t& p(const Index_t idx) const { return m_p[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_p(const Index_t idx) const { return m_c_p[idx]; }
|
|
|
|
// Artificial viscosity
|
|
KOKKOS_INLINE_FUNCTION Real_t& q(const Index_t idx) const { return m_q[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_q(const Index_t idx) const { return m_c_q[idx]; }
|
|
|
|
// Linear term for q
|
|
KOKKOS_INLINE_FUNCTION Real_t& ql(const Index_t idx) const { return m_ql[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_ql(const Index_t idx) const { return m_c_ql[idx]; }
|
|
// Quadratic term for q
|
|
KOKKOS_INLINE_FUNCTION Real_t& qq(const Index_t idx) const { return m_qq[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_qq(const Index_t idx) const { return m_c_qq[idx]; }
|
|
|
|
// Relative volume
|
|
KOKKOS_INLINE_FUNCTION Real_t& v(const Index_t idx) const { return m_v[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t& delv(const Index_t idx) const { return m_delv[idx]; }
|
|
KOKKOS_INLINE_FUNCTION Real_t c_delv(const Index_t idx) const
|
|
{
|
|
return m_c_delv[idx];
|
|
}
|
|
|
|
// Reference volume
|
|
KOKKOS_INLINE_FUNCTION Real_t& volo(Index_t idx) const { return m_volo[idx]; }
|
|
|
|
// volume derivative over volume
|
|
KOKKOS_INLINE_FUNCTION Real_t& vdov(Index_t idx) const { return m_vdov[idx]; }
|
|
|
|
// Element characteristic length
|
|
KOKKOS_INLINE_FUNCTION Real_t& arealg(Index_t idx) const { return m_arealg[idx]; }
|
|
|
|
// Sound speed
|
|
KOKKOS_INLINE_FUNCTION Real_t& ss(const Index_t idx) const { return m_ss[idx]; }
|
|
|
|
// Element mass
|
|
KOKKOS_INLINE_FUNCTION Real_t& elemMass(const Index_t idx) const
|
|
{
|
|
return m_elemMass[idx];
|
|
}
|
|
|
|
KOKKOS_INLINE_FUNCTION Index_t nodeElemCount(Index_t idx) const
|
|
{
|
|
return m_nodeElemStart[idx + 1] - m_nodeElemStart[idx];
|
|
}
|
|
|
|
KOKKOS_INLINE_FUNCTION Index_t* nodeElemCornerList(Index_t idx) const
|
|
{
|
|
return &m_nodeElemCornerList[m_nodeElemStart[idx]];
|
|
}
|
|
|
|
// Parameters
|
|
|
|
// Cutoffs
|
|
KOKKOS_INLINE_FUNCTION Real_t u_cut() const { return m_u_cut; }
|
|
KOKKOS_INLINE_FUNCTION Real_t e_cut() const { return m_e_cut; }
|
|
KOKKOS_INLINE_FUNCTION Real_t p_cut() const { return m_p_cut; }
|
|
KOKKOS_INLINE_FUNCTION Real_t q_cut() const { return m_q_cut; }
|
|
KOKKOS_INLINE_FUNCTION Real_t v_cut() const { return m_v_cut; }
|
|
|
|
// Other constants (usually are settable via input file in real codes)
|
|
KOKKOS_INLINE_FUNCTION Real_t hgcoef() const { return m_hgcoef; }
|
|
KOKKOS_INLINE_FUNCTION Real_t qstop() const { return m_qstop; }
|
|
KOKKOS_INLINE_FUNCTION Real_t monoq_max_slope() const { return m_monoq_max_slope; }
|
|
KOKKOS_INLINE_FUNCTION Real_t monoq_limiter_mult() const
|
|
{
|
|
return m_monoq_limiter_mult;
|
|
}
|
|
KOKKOS_INLINE_FUNCTION Real_t ss4o3() const { return m_ss4o3; }
|
|
KOKKOS_INLINE_FUNCTION Real_t qlc_monoq() const { return m_qlc_monoq; }
|
|
KOKKOS_INLINE_FUNCTION Real_t qqc_monoq() const { return m_qqc_monoq; }
|
|
KOKKOS_INLINE_FUNCTION Real_t qqc() const { return m_qqc; }
|
|
|
|
KOKKOS_INLINE_FUNCTION Real_t eosvmax() const { return m_eosvmax; }
|
|
KOKKOS_INLINE_FUNCTION Real_t eosvmin() const { return m_eosvmin; }
|
|
KOKKOS_INLINE_FUNCTION Real_t pmin() const { return m_pmin; }
|
|
KOKKOS_INLINE_FUNCTION Real_t emin() const { return m_emin; }
|
|
KOKKOS_INLINE_FUNCTION Real_t dvovmax() const { return m_dvovmax; }
|
|
KOKKOS_INLINE_FUNCTION Real_t refdens() const { return m_refdens; }
|
|
|
|
// Timestep controls, etc...
|
|
Real_t& time() { return m_time; }
|
|
Real_t& deltatime() { return m_deltatime; }
|
|
Real_t& deltatimemultlb() { return m_deltatimemultlb; }
|
|
Real_t& deltatimemultub() { return m_deltatimemultub; }
|
|
Real_t& stoptime() { return m_stoptime; }
|
|
Real_t& dtcourant() { return m_dtcourant; }
|
|
Real_t& dthydro() { return m_dthydro; }
|
|
Real_t& dtmax() { return m_dtmax; }
|
|
Real_t& dtfixed() { return m_dtfixed; }
|
|
|
|
Int_t& cycle() { return m_cycle; }
|
|
Index_t& numRanks() { return m_numRanks; }
|
|
|
|
Index_t& colLoc() { return m_colLoc; }
|
|
Index_t& rowLoc() { return m_rowLoc; }
|
|
Index_t& planeLoc() { return m_planeLoc; }
|
|
Index_t& tp() { return m_tp; }
|
|
|
|
Index_t& sizeX() { return m_sizeX; }
|
|
Index_t& sizeY() { return m_sizeY; }
|
|
Index_t& sizeZ() { return m_sizeZ; }
|
|
Index_t& numReg() { return m_numReg; }
|
|
Int_t& cost() { return m_cost; }
|
|
Index_t& numElem() { return m_numElem; }
|
|
Index_t& numNode() { return m_numNode; }
|
|
|
|
Index_t& maxPlaneSize() { return m_maxPlaneSize; }
|
|
Index_t& maxEdgeSize() { return m_maxEdgeSize; }
|
|
|
|
//
|
|
// MPI-Related additional data
|
|
//
|
|
|
|
#if USE_MPI
|
|
// Communication Work space
|
|
Real_t* commDataSend;
|
|
Real_t* commDataRecv;
|
|
|
|
// Maximum number of block neighbors
|
|
MPI_Request recvRequest[26]; // 6 faces + 12 edges + 8 corners
|
|
MPI_Request sendRequest[26]; // 6 faces + 12 edges + 8 corners
|
|
#endif
|
|
|
|
private:
|
|
void BuildMesh(Int_t nx, Int_t edgeNodes, Int_t edgeElems);
|
|
void SetupThreadSupportStructures();
|
|
void CreateRegionIndexSets(Int_t nreg, Int_t balance);
|
|
void SetupCommBuffers(Int_t edgeNodes);
|
|
void SetupSymmetryPlanes(Int_t edgeNodes);
|
|
void SetupElementConnectivities(Int_t edgeElems);
|
|
void SetupBoundaryConditions(Int_t edgeElems);
|
|
|
|
//
|
|
// IMPLEMENTATION
|
|
//
|
|
|
|
/* Node-centered */
|
|
Kokkos::View<Real_t*> m_x; /* coordinates */
|
|
Kokkos::View<Real_t*> m_y;
|
|
Kokkos::View<Real_t*> m_z;
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_x; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_y; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_z; /* coordinates */
|
|
|
|
Kokkos::View<Real_t*> m_xd; /* velocities */
|
|
Kokkos::View<Real_t*> m_yd;
|
|
Kokkos::View<Real_t*> m_zd;
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_xd; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_yd; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_zd; /* coordinates */
|
|
|
|
Kokkos::View<Real_t*> m_xdd; /* accelerations */
|
|
Kokkos::View<Real_t*> m_ydd;
|
|
Kokkos::View<Real_t*> m_zdd;
|
|
|
|
Kokkos::View<Real_t*> m_fx; /* forces */
|
|
Kokkos::View<Real_t*> m_fy;
|
|
Kokkos::View<Real_t*> m_fz;
|
|
|
|
Kokkos::View<Real_t*> m_nodalMass; /* mass */
|
|
|
|
Kokkos::View<Index_t*> m_symmX; /* symmetry plane nodesets */
|
|
Kokkos::View<Index_t*> m_symmY;
|
|
Kokkos::View<Index_t*> m_symmZ;
|
|
|
|
// Element-centered
|
|
|
|
// Region information
|
|
Int_t m_numReg;
|
|
Int_t m_cost; // imbalance cost
|
|
Index_t* m_regElemSize; // Size of region sets
|
|
Index_t* m_regNumList; // Region number per domain element
|
|
// Index_t **m_regElemlist; // region indexset
|
|
using t_regElemlist =
|
|
Kokkos::StaticCrsGraph<Index_t, Kokkos::LayoutLeft, Kokkos::DefaultExecutionSpace,
|
|
Kokkos::MemoryTraits<0>, Index_t>;
|
|
t_regElemlist m_regElemlist;
|
|
|
|
Kokkos::View<Index_t* [8], Kokkos::LayoutRight>
|
|
m_nodelist; /* elemToNode connectivity */
|
|
|
|
Kokkos::View<Index_t*> m_lxim; /* element connectivity across each face */
|
|
Kokkos::View<Index_t*> m_lxip;
|
|
Kokkos::View<Index_t*> m_letam;
|
|
Kokkos::View<Index_t*> m_letap;
|
|
Kokkos::View<Index_t*> m_lzetam;
|
|
Kokkos::View<Index_t*> m_lzetap;
|
|
|
|
Kokkos::View<Int_t*> m_elemBC; /* symmetry/free-surface flags for each elem face */
|
|
|
|
Kokkos::View<Real_t*> m_dxx; /* principal strains -- temporary */
|
|
Kokkos::View<Real_t*> m_dyy;
|
|
Kokkos::View<Real_t*> m_dzz;
|
|
|
|
Kokkos::View<Real_t*> m_delv_xi; /* velocity gradient -- temporary */
|
|
Kokkos::View<Real_t*> m_delv_eta;
|
|
Kokkos::View<Real_t*> m_delv_zeta;
|
|
|
|
Kokkos::View<Real_t*> m_delx_xi; /* coordinate gradient -- temporary */
|
|
Kokkos::View<Real_t*> m_delx_eta;
|
|
Kokkos::View<Real_t*> m_delx_zeta;
|
|
|
|
Kokkos::View<Real_t*> m_e; /* energy */
|
|
|
|
Kokkos::View<Real_t*> m_p; /* pressure */
|
|
Kokkos::View<Real_t*> m_q; /* q */
|
|
Kokkos::View<Real_t*> m_ql; /* linear term for q */
|
|
Kokkos::View<Real_t*> m_qq; /* quadratic term for q */
|
|
|
|
Kokkos::View<Real_t*> m_v; /* relative volume */
|
|
Kokkos::View<Real_t*> m_volo; /* reference volume */
|
|
Kokkos::View<Real_t*> m_vnew; /* new relative volume -- temporary */
|
|
Kokkos::View<Real_t*> m_delv; /* m_vnew - m_v */
|
|
Kokkos::View<Real_t*> m_vdov; /* volume derivative over volume */
|
|
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_e; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_p; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_q; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_ql; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_qq; /* coordinates */
|
|
Kokkos::View<const Real_t*, Kokkos::MemoryTraits<Kokkos::RandomAccess>>
|
|
m_c_delv; /* coordinates */
|
|
|
|
Kokkos::View<Real_t*> m_arealg; /* characteristic length of an element */
|
|
|
|
Kokkos::View<Real_t*> m_ss; /* "sound speed" */
|
|
|
|
Kokkos::View<Real_t*> m_elemMass; /* mass */
|
|
|
|
// Cutoffs (treat as constants)
|
|
const Real_t m_e_cut; // energy tolerance
|
|
const Real_t m_p_cut; // pressure tolerance
|
|
const Real_t m_q_cut; // q tolerance
|
|
const Real_t m_v_cut; // relative volume tolerance
|
|
const Real_t m_u_cut; // velocity tolerance
|
|
|
|
// Other constants (usually setable, but hardcoded in this proxy app)
|
|
|
|
const Real_t m_hgcoef; // hourglass control
|
|
const Real_t m_ss4o3;
|
|
const Real_t m_qstop; // excessive q indicator
|
|
const Real_t m_monoq_max_slope;
|
|
const Real_t m_monoq_limiter_mult;
|
|
const Real_t m_qlc_monoq; // linear term coef for q
|
|
const Real_t m_qqc_monoq; // quadratic term coef for q
|
|
const Real_t m_qqc;
|
|
const Real_t m_eosvmax;
|
|
const Real_t m_eosvmin;
|
|
const Real_t m_pmin; // pressure floor
|
|
const Real_t m_emin; // energy floor
|
|
const Real_t m_dvovmax; // maximum allowable volume change
|
|
const Real_t m_refdens; // reference density
|
|
|
|
// Variables to keep track of timestep, simulation time, and cycle
|
|
Real_t m_dtcourant; // courant constraint
|
|
Real_t m_dthydro; // volume change constraint
|
|
Int_t m_cycle; // iteration count for simulation
|
|
Real_t m_dtfixed; // fixed time increment
|
|
Real_t m_time; // current time
|
|
Real_t m_deltatime; // variable time increment
|
|
Real_t m_deltatimemultlb;
|
|
Real_t m_deltatimemultub;
|
|
Real_t m_dtmax; // maximum allowable time increment
|
|
Real_t m_stoptime; // end time for simulation
|
|
|
|
Int_t m_numRanks;
|
|
|
|
Index_t m_colLoc;
|
|
Index_t m_rowLoc;
|
|
Index_t m_planeLoc;
|
|
Index_t m_tp;
|
|
|
|
Index_t m_sizeX;
|
|
Index_t m_sizeY;
|
|
Index_t m_sizeZ;
|
|
Index_t m_numElem;
|
|
Index_t m_numNode;
|
|
|
|
Index_t m_maxPlaneSize;
|
|
Index_t m_maxEdgeSize;
|
|
|
|
// OMP hack
|
|
Kokkos::View<Index_t*> m_nodeElemStart;
|
|
Kokkos::View<Index_t*> m_nodeElemCornerList;
|
|
|
|
// Used in setup
|
|
Index_t m_rowMin, m_rowMax;
|
|
Index_t m_colMin, m_colMax;
|
|
Index_t m_planeMin, m_planeMax;
|
|
};
|
|
typedef Real_t& (Domain::*Domain_member)(Index_t) const;
|
|
|
|
struct cmdLineOpts
|
|
{
|
|
Int_t its; // -i
|
|
Int_t nx; // -s
|
|
Int_t numReg; // -r
|
|
Int_t numFiles; // -f
|
|
Int_t showProg; // -p
|
|
Int_t quiet; // -q
|
|
Int_t viz; // -v
|
|
Int_t cost; // -c
|
|
Int_t balance; // -b
|
|
Int_t do_atomic; // -a
|
|
};
|
|
|
|
// Function Prototypes
|
|
|
|
// lulesh-par
|
|
/*Real_t CalcElemVolume( const Real_t x[8],
|
|
const Real_t y[8],
|
|
const Real_t z[8]);*/
|
|
|
|
// lulesh-util
|
|
void
|
|
ParseCommandLineOptions(int argc, char* argv[], Int_t myRank, struct cmdLineOpts* opts);
|
|
void
|
|
VerifyAndWriteFinalOutput(Real_t elapsed_time, Domain& locDom, Int_t nx, Int_t numRanks);
|
|
|
|
// lulesh-viz
|
|
void
|
|
DumpToVisit(Domain& domain, int numFiles, int myRank, int numRanks);
|
|
|
|
// lulesh-comm
|
|
void
|
|
CommRecv(Domain& domain, Int_t msgType, Index_t xferFields, Index_t dx, Index_t dy,
|
|
Index_t dz, bool doRecv, bool planeOnly);
|
|
void
|
|
CommSend(Domain& domain, Int_t msgType, Index_t xferFields, Domain_member* fieldData,
|
|
Index_t dx, Index_t dy, Index_t dz, bool doSend, bool planeOnly);
|
|
void
|
|
CommSBN(Domain& domain, Int_t xferFields, Domain_member* fieldData);
|
|
void
|
|
CommSyncPosVel(Domain& domain);
|
|
void
|
|
CommMonoQ(Domain& domain);
|
|
|
|
// lulesh-init
|
|
void
|
|
InitMeshDecomp(Int_t numRanks, Int_t myRank, Int_t* col, Int_t* row, Int_t* plane,
|
|
Int_t* side);
|
|
|
|
/*********************************/
|
|
/* Data structure implementation */
|
|
/*********************************/
|
|
|
|
/* might want to add access methods so that memory can be */
|
|
/* better managed, as in luleshFT */
|
|
|
|
template <typename T>
|
|
T*
|
|
Allocate(size_t size)
|
|
{
|
|
return static_cast<T*>(
|
|
Kokkos::kokkos_malloc<Kokkos::HostSpace>(sizeof(T) * size + 8));
|
|
}
|
|
|
|
template <typename T>
|
|
void
|
|
Release(T** ptr)
|
|
{
|
|
if(*ptr != NULL)
|
|
{
|
|
Kokkos::kokkos_free<Kokkos::HostSpace>(*ptr);
|
|
*ptr = NULL;
|
|
}
|
|
}
|
|
|
|
struct MinFinder
|
|
{
|
|
Real_t val;
|
|
int i;
|
|
KOKKOS_INLINE_FUNCTION
|
|
|
|
MinFinder()
|
|
: val(100000000000000000000.0000)
|
|
, i(-1)
|
|
{}
|
|
|
|
KOKKOS_INLINE_FUNCTION
|
|
MinFinder(const double& val_, const int& i_)
|
|
: val(val_)
|
|
, i(i_)
|
|
{}
|
|
|
|
KOKKOS_INLINE_FUNCTION
|
|
MinFinder(const MinFinder& src)
|
|
: val(src.val)
|
|
, i(src.i)
|
|
{}
|
|
|
|
// overloading += operator to do the max assignment
|
|
KOKKOS_INLINE_FUNCTION
|
|
void operator+=(MinFinder& src)
|
|
{
|
|
if(src.val < val)
|
|
{
|
|
val = src.val;
|
|
i = src.i;
|
|
}
|
|
}
|
|
KOKKOS_INLINE_FUNCTION
|
|
void operator+=(const volatile MinFinder& src) volatile
|
|
{
|
|
if(src.val < val)
|
|
{
|
|
val = src.val;
|
|
i = src.i;
|
|
}
|
|
}
|
|
};
|
|
|
|
struct reduce_double3
|
|
{
|
|
double x, y, z;
|
|
KOKKOS_INLINE_FUNCTION
|
|
reduce_double3()
|
|
{
|
|
x = 0.0;
|
|
y = 0.0;
|
|
z = 0.0;
|
|
}
|
|
KOKKOS_INLINE_FUNCTION
|
|
void operator+=(const volatile reduce_double3& src) volatile
|
|
{
|
|
x += src.x;
|
|
y += src.y;
|
|
z += src.z;
|
|
}
|
|
KOKKOS_INLINE_FUNCTION
|
|
void operator+=(const reduce_double3& src)
|
|
{
|
|
x += src.x;
|
|
y += src.y;
|
|
z += src.z;
|
|
}
|
|
};
|