00001
00007 #include "BackEnd.h"
00008 #include "ProcessorPrivate.h"
00009 #include "common.h"
00010 #include "Node.h"
00011 #include "memusage.h"
00012
00013 #include <new>
00014 #if defined(WIN32) && !defined(__CYGWIN__)
00015 #include <new.h>
00016 #endif
00017
00018 #ifdef USE_COMM_LIB
00019 #include "ComlibManager.h"
00020 #endif
00021
00022 #include "Lattice.h"
00023 #include "main.decl.h"
00024 #include "main.h"
00025 #include "BOCgroup.h"
00026 #include "WorkDistrib.decl.h"
00027 #include "ProxyMgr.decl.h"
00028 #include "PatchMgr.decl.h"
00029 #include "ComputeMgr.decl.h"
00030 #include "ReductionMgr.decl.h"
00031 #include "CollectionMgr.decl.h"
00032 #include "CollectionMaster.decl.h"
00033 #include "CollectionMgr.h"
00034 #include "CollectionMaster.h"
00035 #include "BroadcastMgr.decl.h"
00036 #include "LdbCoordinator.decl.h"
00037 #include "Sync.decl.h"
00038
00039 extern void _initCharm(int, char**);
00040
00041 float cpuTime_start;
00042 float wallTime_start;
00043
00044 CkpvStaticDeclare(int,exitSchedHndlr);
00045
00046 extern "C" void exit_sched(void* msg)
00047 {
00048
00049 CsdExitScheduler();
00050 }
00051
00052 static void register_exit_sched(void)
00053 {
00054 CkpvInitialize(int,exitSchedHndlr);
00055 CkpvAccess(exitSchedHndlr) = CmiRegisterHandler((CmiHandler)exit_sched);
00056 }
00057
00058 void BackEnd::ExitSchedOn(int pe)
00059 {
00060 void* msg = CmiAlloc(CmiMsgHeaderSizeBytes);
00061 CmiSetHandler(msg,CkpvAccess(exitSchedHndlr));
00062 CmiSyncSendAndFree(pe,CmiMsgHeaderSizeBytes,(char *)msg);
00063 }
00064
00065 #if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW_H)
00066 int NAMD_new_handler(size_t) {
00067 #else
00068 void NAMD_new_handler() {
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 }
00077
00078 void cuda_getargs(char**);
00079 void cuda_initialize();
00080
00081
00082 void all_init(int argc, char **argv)
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");
00093 cuda_getargs(argv);
00094 argc = CmiGetArgc(argv);
00095 #endif
00096
00097 _initCharm(argc, argv);
00098
00099 #ifdef NAMD_CUDA
00100 cuda_initialize();
00101 #endif
00102 }
00103
00104 extern void after_backend_init(int argc, char **argv);
00105 void master_init(int argc, char **argv);
00106
00107
00108 void slave_init(int argc, char **argv)
00109 {
00110 #if CMK_SMP
00111
00112
00113
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())
00125 CsdScheduler(-1);
00126 }
00127
00128 void master_init(int argc, char **argv){
00129 cpuTime_start = CmiCpuTimer();
00130 wallTime_start = CmiWallTimer();
00131 if ( CmiMyPe() ) {
00132 all_init(argc, argv);
00133 CsdScheduler(-1);
00134 ConverseExit();
00135 }
00136
00137 all_init(argc, argv);
00138
00139
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
00153
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
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 }
00179
00180
00181 void BackEnd::init(int argc, char **argv) {
00182
00183 #ifdef NAMD_CUDA
00184
00185 int idlepoll = 0;
00186 for ( int i = 0; i < argc; ++i ) {
00187 if ( 0==strcmp(argv[i],"+idlepoll") ) {
00188 idlepoll = 1;
00189 break;
00190 }
00191 }
00192 #endif
00193
00194 ConverseInit(argc, argv, slave_init, 1, 1);
00195
00196 #if defined(NAMD_CUDA) && CMK_NET_VERSION
00197 if ( ! idlepoll ) {
00198 NAMD_die("Please add +idlepoll to command line for proper performance.");
00199 }
00200 #endif
00201
00202 master_init(argc, argv);
00203 }
00204
00205
00206 void BackEnd::exit(void) {
00207 float cpuTime = CmiCpuTimer() - cpuTime_start;
00208 float wallTime = CmiWallTimer() - wallTime_start;
00209 CmiPrintf("====================================================\n\n"
00210 "WallClock: %f CPUTime: %f Memory: %f MB\n",
00211 wallTime, cpuTime, memusage_MB());
00212 int i;
00213 for(i=1; i < CmiNumPes(); i++)
00214 ExitSchedOn(i);
00215 ConverseExit();
00216 }
00217
00218
00219 void BackEnd::suspend(void) {
00220 CsdScheduler(-1);
00221 }
00222
00223
00224 void BackEnd::awaken(void) {
00225 Node::Object()->enableExitScheduler();
00226 }
00227
00228
00229 void BackEnd::barrier(void) {
00230 awaken();
00231 suspend();
00232 }
00233