Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

BackEnd.C File Reference

#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


Function Documentation

void _initCharm int  ,
char ** 
 

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().

void after_backend_init int  argc,
char **  argv
 

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 }

void all_init int  argc,
char **  argv
 

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 }

CkpvStaticDeclare int  ,
exitSchedHndlr 
 

void cuda_getargs char **   ) 
 

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 }

void cuda_initialize  ) 
 

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 }

void exit_sched void *  msg  ) 
 

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 }

void master_init int  argc,
char **  argv
 

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 }

void NAMD_new_handler  ) 
 

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 }

void register_exit_sched void   )  [static]
 

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 }

void slave_init int  argc,
char **  argv
 

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 }


Variable Documentation

float cpuTime_start
 

Definition at line 41 of file BackEnd.C.

Referenced by master_init().

float wallTime_start
 

Definition at line 42 of file BackEnd.C.

Referenced by master_init().


Generated on Sun Nov 8 04:07:18 2009 for NAMD by  doxygen 1.3.9.1