NAMD
Classes | Macros | Functions | Variables
ComputeMgr.C File Reference
#include "InfoStream.h"
#include "ProcessorPrivate.h"
#include "Debug.h"
#include "BOCgroup.h"
#include "ComputeMgr.decl.h"
#include "ComputeMgr.h"
#include "ProxyMgr.decl.h"
#include "ProxyMgr.h"
#include "Node.h"
#include "ComputeMap.h"
#include "PatchMap.h"
#include "PatchMap.inl"
#include "Compute.h"
#include "ComputeNonbondedUtil.h"
#include "ComputeNonbondedSelf.h"
#include "ComputeNonbondedPair.h"
#include "ComputeNonbondedCUDA.h"
#include "ComputeNonbondedMIC.h"
#include "ComputeAngles.h"
#include "ComputeDihedrals.h"
#include "ComputeImpropers.h"
#include "ComputeThole.h"
#include "ComputeAniso.h"
#include "ComputeCrossterms.h"
#include "ComputeGromacsPair.h"
#include "ComputeBonds.h"
#include "ComputeNonbondedCUDAExcl.h"
#include "ComputeFullDirect.h"
#include "ComputeGlobal.h"
#include "ComputeGlobalMsgs.h"
#include "ComputeExt.h"
#include "ComputeQM.h"
#include "ComputeGBISser.h"
#include "ComputeLCPO.h"
#include "ComputeFmmSerial.h"
#include "ComputeMsmSerial.h"
#include "ComputeMsmMsa.h"
#include "ComputeMsm.h"
#include "ComputeDPMTA.h"
#include "ComputeDPME.h"
#include "ComputeDPMEMsgs.h"
#include "ComputePme.h"
#include "ComputePmeCUDA.h"
#include "ComputeCUDAMgr.h"
#include "CudaComputeNonbonded.h"
#include "ComputePmeCUDAMgr.h"
#include "ComputeEwald.h"
#include "ComputeEField.h"
#include "ComputeGridForce.h"
#include "ComputeStir.h"
#include "ComputeSphericalBC.h"
#include "ComputeCylindricalBC.h"
#include "ComputeTclBC.h"
#include "ComputeRestraints.h"
#include "ComputeConsForce.h"
#include "ComputeConsForceMsgs.h"
#include "WorkDistrib.h"
#include "LdbCoordinator.h"
#include "FreeEnergyEnums.h"
#include "FreeEnergyAssert.h"
#include "FreeEnergyGroup.h"
#include "FreeEnergyVector.h"
#include "FreeEnergyRestrain.h"
#include "FreeEnergyRMgr.h"
#include "FreeEnergyLambda.h"
#include "FreeEnergyLambdMgr.h"
#include "GlobalMasterTest.h"
#include "GlobalMasterIMD.h"
#include "GlobalMasterTcl.h"
#include "GlobalMasterSMD.h"
#include "GlobalMasterTMD.h"
#include "GlobalMasterSymmetry.h"
#include "GlobalMasterEasy.h"
#include "GlobalMasterMisc.h"
#include "GlobalMasterFreeEnergy.h"
#include "GlobalMasterColvars.h"
#include "ComputeNonbondedMICKernel.h"
#include "DeviceCUDA.h"
#include "ComputeMgr.def.h"

Go to the source code of this file.

Classes

class  NonbondedCUDASlaveMsg
 
class  NonbondedCUDASkipMsg
 
class  NonbondedMICSlaveMsg
 
class  CudaComputeNonbondedMsg
 
class  NonbondedMICSkipMsg
 

Macros

#define MIN_DEBUG_LEVEL   1
 

Functions

CudaComputeNonbonded * getCudaComputeNonbonded ()
 
CudaComputeNonbonded * createCudaComputeNonbonded (ComputeID c)
 
void registerUserEventsForAllComputeObjs ()
 
void build_cuda_exclusions ()
 
void build_cuda_force_table ()
 
int isMICProcessor (int pe)
 

Variables

__thread DeviceCUDA * deviceCUDA
 

Macro Definition Documentation

#define MIN_DEBUG_LEVEL   1

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 11 of file ComputeMgr.C.

Function Documentation

void build_cuda_exclusions ( )

Definition at line 252 of file ComputeNonbondedCUDA.C.

References ComputeNonbondedCUDA::build_exclusions(), deviceCUDA, and DeviceCUDA::getMasterPe().

Referenced by ComputeMgr::recvBuildCudaExclusions().

252  {
253  if ( deviceCUDA->getMasterPe() != CkMyPe() ) return;
254  ComputeNonbondedCUDA::build_exclusions();
255 }
DeviceCUDA::getMasterPe
int getMasterPe()
Definition: DeviceCUDA.h:105
deviceCUDA
__thread DeviceCUDA * deviceCUDA
Definition: DeviceCUDA.C:22
void build_cuda_force_table ( )

Definition at line 81 of file ComputeNonbondedCUDA.C.

References ComputeNonbondedCUDA::build_force_table(), ComputeNonbondedCUDA::build_lj_table(), deviceCUDA, and DeviceCUDA::getMasterPe().

Referenced by ComputeMgr::recvBuildCudaForceTable().

81  {
82  if ( deviceCUDA->getMasterPe() != CkMyPe() ) return;
83  ComputeNonbondedCUDA::build_lj_table();
84  ComputeNonbondedCUDA::build_force_table();
85 }
DeviceCUDA::getMasterPe
int getMasterPe()
Definition: DeviceCUDA.h:105
deviceCUDA
__thread DeviceCUDA * deviceCUDA
Definition: DeviceCUDA.C:22
CudaComputeNonbonded* createCudaComputeNonbonded ( ComputeID  c)

Definition at line 364 of file ComputeMgr.C.

References ComputeCUDAMgr::createCudaComputeNonbonded(), and ComputeCUDAMgr::getComputeCUDAMgr().

364  {
365  return ComputeCUDAMgr::getComputeCUDAMgr()->createCudaComputeNonbonded(c);
366 }
ComputeCUDAMgr::getComputeCUDAMgr
static ComputeCUDAMgr * getComputeCUDAMgr()
Definition: ComputeCUDAMgr.C:83
ComputeCUDAMgr::createCudaComputeNonbonded
CudaComputeNonbonded * createCudaComputeNonbonded(ComputeID c)
Definition: ComputeCUDAMgr.C:95
CudaComputeNonbonded* getCudaComputeNonbonded ( )

Definition at line 360 of file ComputeMgr.C.

References ComputeCUDAMgr::getComputeCUDAMgr(), and ComputeCUDAMgr::getCudaComputeNonbonded().

Referenced by ComputeMgr::createComputes().

360  {
361  return ComputeCUDAMgr::getComputeCUDAMgr()->getCudaComputeNonbonded();
362 }
ComputeCUDAMgr::getComputeCUDAMgr
static ComputeCUDAMgr * getComputeCUDAMgr()
Definition: ComputeCUDAMgr.C:83
ComputeCUDAMgr::getCudaComputeNonbonded
CudaComputeNonbonded * getCudaComputeNonbonded()
Definition: ComputeCUDAMgr.C:109
int isMICProcessor ( int  pe)

Definition at line 1881 of file ComputeMgr.C.

1881  {
1882  return CProxy_ComputeMgr::ckLocalBranch(CkpvAccess(BOCclass_group).computeMgr)->isMICProcessor(pe);
1883 }
computeMgr
static __thread ComputeMgr * computeMgr
Definition: ComputeNonbondedCUDA.C:75
void registerUserEventsForAllComputeObjs ( void  )

Definition at line 830 of file ComputeMgr.C.

References computeAnglesType, computeAnisoType, computeBondsType, computeConsForceType, computeConsTorqueType, computeCrosstermsType, computeCylindricalBCType, computeDihedralsType, computeEFieldType, computeEwaldType, computeExclsType, computeExtType, computeFullDirectType, computeGlobalType, computeGridForceType, computeImpropersType, computeLCPOType, computeNonbondedPairType, computeNonbondedSelfType, computePmeCUDAType, computePmeType, computeQMType, computeRestraintsType, computeSelfAnglesType, computeSelfAnisoType, computeSelfBondsType, computeSelfCrosstermsType, computeSelfDihedralsType, computeSelfExclsType, computeSelfImpropersType, computeSelfTholeType, computeSphericalBCType, computeStirType, computeTclBCType, computeTholeType, PatchMap::gridsize_a(), PatchMap::gridsize_b(), PatchMap::gridsize_c(), PatchMap::index_a(), PatchMap::index_b(), PatchMap::index_c(), NAMD_bug(), ComputeMap::numComputes(), PatchMap::Object(), ComputeMap::Object(), Lattice::offset_a(), Lattice::offset_b(), Lattice::offset_c(), ComputeMap::pid(), TRACE_COMPOBJ_IDOFFSET, ComputeMap::trans(), and ComputeMap::type().

Referenced by Node::startup().

831 {
832 #ifdef TRACE_COMPUTE_OBJECTS
833  ComputeMap *map = ComputeMap::Object();
834  PatchMap *pmap = PatchMap::Object();
835  char user_des[50];
836  int p1, p2;
837  int adim, bdim, cdim;
838  int t1, t2;
839  int x1, y1, z1, x2, y2, z2;
840  int dx, dy, dz;
841  for (int i=0; i<map->numComputes(); i++)
842  {
843  memset(user_des, 0, 50);
844  switch ( map->type(i) )
845  {
846  case computeNonbondedSelfType:
847  sprintf(user_des, "computeNonBondedSelfType_%d_pid_%d", i, map->pid(i,0));
848  break;
849  case computeLCPOType:
850  sprintf(user_des, "computeLCPOType_%d_pid_%d", i, map->pid(i,0));
851  break;
852  case computeNonbondedPairType:
853  adim = pmap->gridsize_a();
854  bdim = pmap->gridsize_b();
855  cdim = pmap->gridsize_c();
856  p1 = map->pid(i, 0);
857  t1 = map->trans(i, 0);
858  x1 = pmap->index_a(p1) + adim * Lattice::offset_a(t1);
859  y1 = pmap->index_b(p1) + bdim * Lattice::offset_b(t1);
860  z1 = pmap->index_c(p1) + cdim * Lattice::offset_c(t1);
861  p2 = map->pid(i, 1);
862  t2 = map->trans(i, 1);
863  x2 = pmap->index_a(p2) + adim * Lattice::offset_a(t2);
864  y2 = pmap->index_b(p2) + bdim * Lattice::offset_b(t2);
865  z2 = pmap->index_c(p2) + cdim * Lattice::offset_c(t2);
866  dx = abs(x1-x2);
867  dy = abs(y1-y2);
868  dz = abs(z1-z2);
869  sprintf(user_des, "computeNonBondedPairType_%d(%d,%d,%d)", i, dx,dy,dz);
870  break;
871 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
872 #ifdef BONDED_CUDA
873  case computeBondedCUDAType:
874  sprintf(user_des, "computeBondedCUDAType_%d", i);
875  break;
876 #endif
877 #endif
878  case computeExclsType:
879  sprintf(user_des, "computeExclsType_%d", i);
880  break;
881  case computeBondsType:
882  sprintf(user_des, "computeBondsType_%d", i);
883  break;
884  case computeAnglesType:
885  sprintf(user_des, "computeAnglesType_%d", i);
886  break;
887  case computeDihedralsType:
888  sprintf(user_des, "computeDihedralsType_%d", i);
889  break;
890  case computeImpropersType:
891  sprintf(user_des, "computeImpropersType_%d", i);
892  break;
893  case computeTholeType:
894  sprintf(user_des, "computeTholeType_%d", i);
895  break;
896  case computeAnisoType:
897  sprintf(user_des, "computeAnisoType_%d", i);
898  break;
899  case computeCrosstermsType:
900  sprintf(user_des, "computeCrosstermsType_%d", i);
901  break;
902  case computeSelfExclsType:
903  sprintf(user_des, "computeSelfExclsType_%d", i);
904  break;
905  case computeSelfBondsType:
906  sprintf(user_des, "computeSelfBondsType_%d", i);
907  break;
908  case computeSelfAnglesType:
909  sprintf(user_des, "computeSelfAnglesType_%d", i);
910  break;
911  case computeSelfDihedralsType:
912  sprintf(user_des, "computeSelfDihedralsType_%d", i);
913  break;
914  case computeSelfImpropersType:
915  sprintf(user_des, "computeSelfImpropersType_%d", i);
916  break;
917  case computeSelfTholeType:
918  sprintf(user_des, "computeSelfTholeType_%d", i);
919  break;
920  case computeSelfAnisoType:
921  sprintf(user_des, "computeSelfAnisoType_%d", i);
922  break;
923  case computeSelfCrosstermsType:
924  sprintf(user_des, "computeSelfCrosstermsType_%d", i);
925  break;
926 #ifdef DPMTA
927  case computeDPMTAType:
928  sprintf(user_des, "computeDPMTAType_%d", i);
929  break;
930 #endif
931 #ifdef DPME
932  case computeDPMEType:
933  sprintf(user_des, "computeDPMEType_%d", i);
934  break;
935 #endif
936  case computePmeType:
937  sprintf(user_des, "computePMEType_%d", i);
938  break;
939 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
940  case computePmeCUDAType:
941  sprintf(user_des, "computePMECUDAType_%d", i);
942  break;
943 #endif
944  case computeEwaldType:
945  sprintf(user_des, "computeEwaldType_%d", i);
946  break;
947  case computeFullDirectType:
948  sprintf(user_des, "computeFullDirectType_%d", i);
949  break;
950  case computeGlobalType:
951  sprintf(user_des, "computeGlobalType_%d", i);
952  break;
953  case computeStirType:
954  sprintf(user_des, "computeStirType_%d", i);
955  break;
956  case computeExtType:
957  sprintf(user_des, "computeExtType_%d", i);
958  break;
959  case computeQMType:
960  sprintf(user_des, "computeQMType_%d", i);
961  break;
962  case computeEFieldType:
963  sprintf(user_des, "computeEFieldType_%d", i);
964  break;
965  /* BEGIN gf */
966  case computeGridForceType:
967  sprintf(user_des, "computeGridForceType_%d", i);
968  break;
969  /* END gf */
970  case computeSphericalBCType:
971  sprintf(user_des, "computeSphericalBCType_%d", i);
972  break;
973  case computeCylindricalBCType:
974  sprintf(user_des, "computeCylindricalBCType_%d", i);
975  break;
976  case computeTclBCType:
977  sprintf(user_des, "computeTclBCType_%d", i);
978  break;
979  case computeRestraintsType:
980  sprintf(user_des, "computeRestraintsType_%d", i);
981  break;
982  case computeConsForceType:
983  sprintf(user_des, "computeConsForceType_%d", i);
984  break;
985  case computeConsTorqueType:
986  sprintf(user_des, "computeConsTorqueType_%d", i);
987  break;
988  default:
989  NAMD_bug("Unknown compute type in ComputeMgr::registerUserEventForAllComputeObjs().");
990  break;
991  }
992  int user_des_len = strlen(user_des);
993  char *user_des_cst = new char[user_des_len+1];
994  memcpy(user_des_cst, user_des, user_des_len);
995  user_des_cst[user_des_len] = 0;
996  //Since the argument in traceRegisterUserEvent is supposed
997  //to be a const string which will not be copied inside the
998  //function when a new user event is created, user_des_cst
999  //has to be allocated in heap.
1000  int reEvenId = traceRegisterUserEvent(user_des_cst, TRACE_COMPOBJ_IDOFFSET+i);
1001  //printf("Register user event (%s) with id (%d)\n", user_des, reEvenId);
1002  }
1003 #else
1004  return;
1005 #endif
1006 }
Lattice::offset_b
static int offset_b(int i)
Definition: Lattice.h:248
Lattice::offset_c
static int offset_c(int i)
Definition: Lattice.h:249
ComputeMap::numComputes
int numComputes(void)
Definition: ComputeMap.h:101
TRACE_COMPOBJ_IDOFFSET
#define TRACE_COMPOBJ_IDOFFSET
Definition: Compute.h:77
PatchMap::gridsize_c
int gridsize_c(void) const
Definition: PatchMap.h:66
PatchMap::Object
static PatchMap * Object()
Definition: PatchMap.h:27
PatchMap::index_a
int index_a(int pid) const
Definition: PatchMap.h:86
PatchMap::gridsize_a
int gridsize_a(void) const
Definition: PatchMap.h:64
NAMD_bug
void NAMD_bug(const char *err_msg)
Definition: common.C:129
Lattice::offset_a
static int offset_a(int i)
Definition: Lattice.h:247
ComputeMap::type
ComputeType type(ComputeID cid)
Definition: ComputeMap.C:120
PatchMap::index_b
int index_b(int pid) const
Definition: PatchMap.h:87
PatchMap::index_c
int index_c(int pid) const
Definition: PatchMap.h:88
ComputeMap::Object
static ComputeMap * Object()
Definition: ComputeMap.h:89
ComputeMap::pid
int pid(ComputeID cid, int i)
Definition: ComputeMap.C:109
ComputeMap::trans
int trans(ComputeID cid, int i)
Definition: ComputeMap.C:114
PatchMap::gridsize_b
int gridsize_b(void) const
Definition: PatchMap.h:65

Variable Documentation

__thread DeviceCUDA* deviceCUDA

Definition at line 22 of file DeviceCUDA.C.

Generated by   doxygen 1.8.5