#include "BackEnd.h"#include "ProcessorPrivate.h"#include "common.h"#include "Node.h"#include "memusage.h"#include <new>#include "Lattice.h"#include "main.decl.h"#include "main.h"#include "BOCgroup.h"#include "WorkDistrib.decl.h"#include "ProxyMgr.decl.h"#include "PatchMgr.decl.h"#include "ComputeMgr.decl.h"#include "ReductionMgr.decl.h"#include "CollectionMgr.decl.h"#include "CollectionMaster.decl.h"#include "CollectionMgr.h"#include "CollectionMaster.h"#include "BroadcastMgr.decl.h"#include "LdbCoordinator.decl.h"#include "Sync.decl.h"Go to the source code of this file.
Functions | |
| void | _initCharm (int, char **) |
| CkpvStaticDeclare (int, exitSchedHndlr) | |
| void | exit_sched (void *msg) |
| void | register_exit_sched (void) |
| void | NAMD_new_handler () |
| void | cuda_getargs (char **) |
| void | cuda_initialize () |
| void | all_init (int argc, char **argv) |
| void | after_backend_init (int argc, char **argv) |
| void | master_init (int argc, char **argv) |
| void | slave_init (int argc, char **argv) |
Variables | |
| float | cpuTime_start |
| float | wallTime_start |
|
||||||||||||
|
Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved. Referenced by all_init(). |
|
||||||||||||
|
Definition at line 42 of file mainfunc.C. References CHDIR, BackEnd::exit(), GETCWD, iINFO(), iout, ScriptTcl::load(), NAMD_die(), Node::Object(), PATHSEPSTR, ScriptTcl::run(), and Node::setScript(). 00042 {
00043 ScriptTcl *script = new ScriptTcl;
00044 Node::Object()->setScript(script);
00045
00046 for(argc = 0; argv[argc]; ++argc);
00047 if ( argc < 2 ) {
00048 NAMD_die("No simulation config file specified on command line.");
00049 }
00050 #ifdef NAMD_TCL
00051 if (argc>2)
00052 iout << iINFO << "Found " << (argc-1) << " config files.\n" << endi;
00053 for(int i = 1; i < argc; ++i) {
00054 char *confFile = argv[i];
00055 #else
00056 char *confFile = argv[argc-1];
00057 #endif
00058 char *oldcwd = GETCWD(0,0);
00059 char *currentdir=confFile;
00060 char *tmp;
00061 for(tmp=confFile;*tmp;++tmp); // find final null
00062 for( ; tmp != confFile && *tmp != PATHSEP; --tmp); // find last '/'
00063 #if defined(WIN32) && !defined(__CYGWIN__)
00064 if (tmp == confFile) {
00065 // in case this is under cygwin, search for '/' as well
00066 for(tmp=confFile;*tmp;++tmp); // find final null
00067 for( ; tmp != confFile && *tmp != '/'; --tmp); // find last '/'
00068 }
00069 #endif
00070 if ( tmp != confFile )
00071 {
00072 *tmp = 0; confFile = tmp + 1;
00073 if ( CHDIR(currentdir) ) NAMD_die("chdir() failed!");
00074 iout << iINFO << "Changed directory to " << currentdir << "\n" << endi;
00075 }
00076 else if ( *tmp == PATHSEP ) // config file in / is odd, but it might happen
00077 if ( CHDIR(PATHSEPSTR) ) NAMD_die("chdir() failed!");
00078 currentdir = NULL;
00079
00080 iout << iINFO << "Configuration file is " << confFile << "\n" << endi;
00081
00082 struct stat statBuf;
00083 if (stat(confFile, &statBuf)) {
00084 NAMD_die("Simulation config file is not accessible.");
00085 }
00086
00087 #ifdef NAMD_TCL
00088 if ( i == argc - 1 ) script->run(confFile);
00089 else script->load(confFile);
00090 #else
00091 script->run(confFile);
00092 #endif
00093
00094 CHDIR(oldcwd);
00095 // free(oldcwd);
00096
00097 #ifdef NAMD_TCL
00098 }
00099 #endif
00100
00101 BackEnd::exit();
00102 }
|
|
||||||||||||
|
Definition at line 82 of file BackEnd.C. References _initCharm(), cuda_getargs(), cuda_initialize(), NAMD_new_handler(), ProcessorPrivateInit(), and register_exit_sched(). Referenced by master_init(), and slave_init(). 00083 {
00084 #if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW_H)
00085 _set_new_handler(NAMD_new_handler);
00086 #else
00087 std::set_new_handler(NAMD_new_handler);
00088 #endif
00089 ProcessorPrivateInit();
00090 register_exit_sched();
00091 #ifdef NAMD_CUDA
00092 CmiGetArgFlag(argv, "+idlepoll"); // remove +idlepoll if it's still there
00093 cuda_getargs(argv);
00094 argc = CmiGetArgc(argv);
00095 #endif
00096
00097 _initCharm(argc, argv); // message main Chare
00098
00099 #ifdef NAMD_CUDA
00100 cuda_initialize();
00101 #endif
00102 }
|
|
||||||||||||
|
|
|
|
Definition at line 33 of file ComputeNonbondedCUDA.C. References devicelist, ignoresharing, and usedevicelist. Referenced by all_init(). 00033 {
00034 devicelist = 0;
00035 usedevicelist = CmiGetArgStringDesc(argv, "+devices", &devicelist,
00036 "comma-delimited list of CUDA device numbers such as 0,2,1,2");
00037 ignoresharing = CmiGetArgFlag(argv, "+ignoresharing");
00038 }
|
|
|
Definition at line 46 of file ComputeNonbondedCUDA.C. References CmiPhysicalNodeID, cuda_init(), devicelist, first_pe_sharing_gpu, gpu_is_mine, NAMD_die(), next_pe_sharing_gpu, and shared_gpu. Referenced by all_init(). 00046 {
00047
00048 char host[128];
00049 #ifdef NOHOSTNAME
00050 sprintf(host,"unknown");
00051 #else
00052 gethostname(host, 128); host[127] = 0;
00053 #endif
00054
00055 int myPhysicalNodeID = CmiPhysicalNodeID(CkMyPe());
00056 int myRankInPhysicalNode;
00057 int numPesOnPhysicalNode;
00058 int *pesOnPhysicalNode;
00059 CmiGetPesOnPhysicalNode(myPhysicalNodeID,
00060 &pesOnPhysicalNode,&numPesOnPhysicalNode);
00061 {
00062 int i;
00063 for ( i=0; i < numPesOnPhysicalNode; ++i ) {
00064 if ( i && (pesOnPhysicalNode[i] <= pesOnPhysicalNode[i-1]) ) {
00065 i = numPesOnPhysicalNode;
00066 break;
00067 }
00068 if ( pesOnPhysicalNode[i] == CkMyPe() ) break;
00069 }
00070 if ( i == numPesOnPhysicalNode || i != CmiPhysicalRank(CkMyPe()) ) {
00071 CkPrintf("Bad result from CmiGetPesOnPhysicalNode!\n");
00072 for ( i=0; i < numPesOnPhysicalNode; ++i ) {
00073 CkPrintf("pe %d physnode rank %d of %d is %d\n", CkMyPe(),
00074 i, numPesOnPhysicalNode, pesOnPhysicalNode[i]);
00075 }
00076 myRankInPhysicalNode = 0;
00077 numPesOnPhysicalNode = 1;
00078 pesOnPhysicalNode = new int[1];
00079 pesOnPhysicalNode[0] = CkMyPe();
00080 } else {
00081 myRankInPhysicalNode = i;
00082 }
00083 }
00084 // CkPrintf("Pe %d ranks %d in physical node\n",CkMyPe(),myRankInPhysicalNode);
00085
00086 int deviceCount = 0;
00087 cudaGetDeviceCount(&deviceCount);
00088 if ( deviceCount <= 0 ) {
00089 NAMD_die("No CUDA devices found.");
00090 }
00091
00092 int *devices;
00093 int ndevices = 0;
00094 int nexclusive = 0;
00095 if ( usedevicelist ) {
00096 devices = new int[strlen(devicelist)];
00097 int i = 0;
00098 while ( devicelist[i] ) {
00099 ndevices += sscanf(devicelist+i,"%d",devices+ndevices);
00100 while ( devicelist[i] && isdigit(devicelist[i]) ) ++i;
00101 while ( devicelist[i] && ! isdigit(devicelist[i]) ) ++i;
00102 }
00103 } else {
00104 if ( ! CkMyPe() ) {
00105 CkPrintf("Did not find +devices i,j,k,... argument, using all\n");
00106 }
00107 devices = new int[deviceCount];
00108 for ( int i=0; i<deviceCount; ++i ) {
00109 int dev = (i+1) % deviceCount; // avoid 0 if possible
00110 #if CUDA_VERSION >= 2020
00111 cudaDeviceProp deviceProp;
00112 cudaGetDeviceProperties(&deviceProp, dev);
00113 if ( deviceProp.computeMode != cudaComputeModeProhibited ) {
00114 devices[ndevices++] = dev;
00115 }
00116 if ( deviceProp.computeMode == cudaComputeModeExclusive ) {
00117 ++nexclusive;
00118 }
00119 #else
00120 devices[ndevices++] = dev;
00121 #endif
00122 }
00123 }
00124
00125 if ( ! ndevices ) {
00126 NAMD_die("All CUDA devices are in prohibited mode.");
00127 }
00128
00129 shared_gpu = 0;
00130 gpu_is_mine = 1;
00131 first_pe_sharing_gpu = CkMyPe();
00132 next_pe_sharing_gpu = CkMyPe();
00133
00134 if ( (ndevices >= numPesOnPhysicalNode) || (nexclusive == 0) ) {
00135
00136 int dev;
00137 if ( numPesOnPhysicalNode > 1 ) {
00138 dev = devices[myRankInPhysicalNode % ndevices];
00139 if ( ! ignoresharing ) {
00140 for ( int i = (myRankInPhysicalNode + 1) % numPesOnPhysicalNode;
00141 i != myRankInPhysicalNode;
00142 i = (i + 1) % numPesOnPhysicalNode ) {
00143 if (devices[i % ndevices] == dev) {
00144 shared_gpu = 1;
00145 next_pe_sharing_gpu = pesOnPhysicalNode[i];
00146 break;
00147 }
00148 }
00149 }
00150 if ( shared_gpu ) {
00151 for ( int i = 0; i < numPesOnPhysicalNode; ++i ) {
00152 if (devices[i % ndevices] == dev) {
00153 first_pe_sharing_gpu = pesOnPhysicalNode[i];
00154 break;
00155 }
00156 }
00157 CkPrintf("Pe %d sharing CUDA device %d first %d next %d\n",
00158 CkMyPe(), dev, first_pe_sharing_gpu, next_pe_sharing_gpu);
00159 }
00160 } else { // in case phys node code is lying
00161 dev = devices[CkMyPe() % ndevices];
00162 }
00163
00164 gpu_is_mine = ( first_pe_sharing_gpu == CkMyPe() );
00165
00166 if ( dev >= deviceCount ) {
00167 char buf[256];
00168 sprintf(buf,"Pe %d unable to bind to CUDA device %d on %s because only %d devices are present",
00169 CkMyPe(), dev, host, deviceCount);
00170 NAMD_die(buf);
00171 }
00172
00173 cudaDeviceProp deviceProp;
00174 cudaGetDeviceProperties(&deviceProp, dev);
00175 CkPrintf("Pe %d physical rank %d binding to CUDA device %d on %s: '%s' Mem: %dMB Rev: %d.%d\n",
00176 CkMyPe(), myRankInPhysicalNode, dev, host,
00177 deviceProp.name, deviceProp.totalGlobalMem / (1024*1024),
00178 deviceProp.major, deviceProp.minor);
00179
00180 cudaSetDevice(dev);
00181 cudaError_t err;
00182 if ((err = cudaGetLastError()) != cudaSuccess) {
00183 char errmsg[1024];
00184 sprintf(errmsg,"CUDA error binding to device %d on pe %d: %s",
00185 dev, CkMyPe(), cudaGetErrorString(err));
00186 NAMD_die(errmsg);
00187 }
00188
00189 } // just let CUDA pick a device for us
00190
00191 if ( sizeof(patch_pair) & 15 ) NAMD_die("sizeof(patch_pair) % 16 != 0");
00192 if ( sizeof(force_list) & 15 ) NAMD_die("sizeof(force_list) % 16 != 0");
00193 if ( sizeof(atom) & 15 ) NAMD_die("sizeof(atom) % 16 != 0");
00194 if ( sizeof(atom_param) & 15 ) NAMD_die("sizeof(atom_param) % 16 != 0");
00195
00196 cuda_init();
00197
00198 }
|
|
|
Definition at line 46 of file BackEnd.C. Referenced by register_exit_sched(). 00047 {
00048 // CmiPrintf("Exiting scheduler on %d\n",CmiMyPe());
00049 CsdExitScheduler();
00050 }
|
|
||||||||||||
|
Definition at line 128 of file BackEnd.C. References all_init(), BOCgroup::broadcastMgr, BOCgroup::collectionMgr, BOCgroup::computeExtMgr, BOCgroup::computeGridForceMgr, BOCgroup::computeGridForceNodeMgr, BOCgroup::computeMgr, BOCgroup::computePmeMgr, cpuTime_start, GroupInitMsg::group, BOCgroup::ldbCoordinator, SlaveInitMsg::master, BOCgroup::patchMgr, BOCgroup::proxyMgr, BOCgroup::reductionMgr, BOCgroup::sync, wallTime_start, and BOCgroup::workDistrib. Referenced by BackEnd::init(), and slave_init(). 00128 {
00129 cpuTime_start = CmiCpuTimer();
00130 wallTime_start = CmiWallTimer();
00131 if ( CmiMyPe() ) {
00132 all_init(argc, argv);
00133 CsdScheduler(-1);
00134 ConverseExit(); // should never return
00135 }
00136
00137 all_init(argc, argv);
00138
00139 // Create branch-office chares
00140 BOCgroup group;
00141 group.workDistrib = CProxy_WorkDistrib::ckNew();
00142 group.proxyMgr = CProxy_ProxyMgr::ckNew();
00143 group.patchMgr = CProxy_PatchMgr::ckNew();
00144 group.computeMgr = CProxy_ComputeMgr::ckNew();
00145 group.reductionMgr = CProxy_ReductionMgr::ckNew();
00146 group.computePmeMgr = CProxy_ComputePmeMgr::ckNew();
00147 group.computeGridForceNodeMgr = CProxy_ComputeGridForceNodeMgr::ckNew();
00148 group.computeGridForceMgr = CProxy_ComputeGridForceMgr::ckNew();
00149 group.computeExtMgr = CProxy_ComputeExtMgr::ckNew();
00150 group.sync = CProxy_Sync::ckNew();
00151
00152 //group.computePmeMgr = CProxy_OptPmeMgr::ckNew();
00153 //group.computePmeMgr = CProxy_ComputePmeMgr::ckNew();
00154
00155 #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
00156 group.nodeProxyMgr = CProxy_NodeProxyMgr::ckNew();
00157 #endif
00158
00159 #ifdef MEM_OPT_VERSION
00160 MasterHandlerInitMsg *initmsg8 = new MasterHandlerInitMsg;
00161 //initmsg8->master = collectionMaster;
00162 CkChareID collectionMasterHanlder = CProxy_CollectionMasterHandler::ckNew(initmsg8, 0);
00163 #else
00164 CkChareID collectionMaster = CProxy_CollectionMaster::ckNew(0);
00165 #endif
00166
00167 SlaveInitMsg *initmsg7 = new SlaveInitMsg;
00168 #ifndef MEM_OPT_VERSION
00169 initmsg7->master = collectionMaster;
00170 #endif
00171 group.collectionMgr = CProxy_CollectionMgr::ckNew(initmsg7);
00172 group.broadcastMgr = CProxy_BroadcastMgr::ckNew();
00173 group.ldbCoordinator = CProxy_LdbCoordinator::ckNew();
00174 GroupInitMsg *msg = new GroupInitMsg;
00175 msg->group = group;
00176 CProxy_Node::ckNew(msg);
00177
00178 }
|
|
|
Definition at line 68 of file BackEnd.C. References NAMD_die(). Referenced by all_init(). 00068 {
00069 #endif
00070 char tmp[100];
00071 sprintf(tmp,"Memory allocation failed on processor %d.",CmiMyPe());
00072 NAMD_die(tmp);
00073 #if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW_H)
00074 return 0;
00075 #endif
00076 }
|
|
|
Definition at line 52 of file BackEnd.C. References exit_sched(). Referenced by all_init(). 00053 {
00054 CkpvInitialize(int,exitSchedHndlr);
00055 CkpvAccess(exitSchedHndlr) = CmiRegisterHandler((CmiHandler)exit_sched);
00056 }
|
|
||||||||||||
|
Definition at line 108 of file BackEnd.C. References after_backend_init(), all_init(), and master_init(). Referenced by BackEnd::init(). 00109 {
00110 #if CMK_SMP
00111 //the original main thread could now be a comm thread
00112 //and a slave thread could now be the main thread,
00113 //so we have to do the master initialization here
00114 if(CmiMyRank()==0){
00115 master_init(argc, argv);
00116 if(CmiMyPe()==0)
00117 after_backend_init(argc, argv);
00118 return;
00119 }
00120 #endif
00121
00122 all_init(argc, argv);
00123
00124 if (CkMyRank() < CkMyNodeSize()) // skip the communication thread
00125 CsdScheduler(-1);
00126 }
|
|
|
Definition at line 41 of file BackEnd.C. Referenced by master_init(). |
|
|
Definition at line 42 of file BackEnd.C. Referenced by master_init(). |
1.3.9.1