NAMD
Functions | Variables
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 "ComputeMoa.h"
#include "ComputeMsmMsa.h"
#include "main.decl.h"
#include "main.h"
#include "BOCgroup.h"
#include "WorkDistrib.decl.h"
#include "ProxyMgr.decl.h"
#include "PatchMgr.decl.h"
#include "DataExchanger.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"
#include "PatchData.decl.h"
#include <tcl.h>

Go to the source code of this file.

Functions

void _initCharm (int, char **)
 
 CkpvStaticDeclare (int, exitSchedHndlr)
 
void exit_sched (void *msg)
 
static void register_exit_sched (void)
 
void NAMD_new_handler ()
 
void topo_getargs (char **)
 
void cuda_getargs (char **)
 
void cuda_affinity_initialize ()
 
void mic_getargs (char **)
 
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
 
char * gNAMDBinaryName = NULL
 

Function Documentation

◆ _initCharm()

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

◆ after_backend_init()

void after_backend_init ( int  argc,
char **  argv 
)

Definition at line 55 of file mainfunc.C.

References CHDIR, CWDSIZE, endi(), ScriptTcl::eval(), BackEnd::exit(), GETCWD, iINFO(), iout, ScriptTcl::load(), NAMD_die(), NAMD_err(), Node::Object(), PATHSEP, PATHSEPSTR, ScriptTcl::run(), PatchData::script, Node::setScript(), and ScriptTcl::tclmain().

Referenced by main(), and slave_init().

55  {
56 #define CWDSIZE 1024
57  char origcwd_buf[CWDSIZE];
58  char currentdir_buf[CWDSIZE];
59 
60  ScriptTcl *script = new ScriptTcl;
61  Node::Object()->setScript(script);
62  // Node is a group that contains common pointers across many PEs,
63  // since script is not shared among nodes, into the nodegroup it goes
64 
65 #ifdef NODEGROUP_FORCE_REGISTER
66  CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
67  PatchData* patchData = cpdata.ckLocalBranch();
68  patchData->script =script;
69 #endif
70 
71  for(argc = 0; argv[argc]; ++argc);
72  if ( argc < 2 ) {
73 #if defined(WIN32) && !defined(__CYGWIN__)
74  CkPrintf("\nFATAL ERROR: No simulation config file specified on command line.\n");
75  CkPrintf("\nNOTE: NAMD has no graphical interface and must be run from a command line.\n");
76  int nsleep = 10;
77  CkPrintf("\nSleeping %d seconds before exiting...\n", nsleep);
78  fflush(stdout);
79  sleep(nsleep);
80  CkPrintf("\n");
81 #endif
82  NAMD_die("No simulation config file specified on command line.");
83  }
84  char *origcwd = GETCWD(origcwd_buf,CWDSIZE);
85  if ( ! origcwd ) NAMD_err("getcwd");
86 #ifdef NAMD_TCL
87  for(int i = 1; i < argc; ++i) {
88  if ( strstr(argv[i],"--") == argv[i] ) {
89  char buf[1024];
90  if ( i + 1 == argc ) {
91  sprintf(buf, "missing argument for command line option %s", argv[i]);
92  NAMD_die(buf);
93  }
94  if ( ! strcmp(argv[i],"--tclmain") ) {
95  // pass all remaining arguments to script
96  iout << iINFO << "Command-line argument is";
97  for ( int j=i; j<argc; ++j ) { iout << " " << argv[j]; }
98  iout << "\n" << endi;
99  script->tclmain(argc-i-1,argv+i+1);
100  BackEnd::exit();
101  return;
102  }
103  sprintf(buf, "%s %s", argv[i]+2, argv[i+1]);
104  iout << iINFO << "Command-line argument is --" << buf << "\n" << endi;
105  script->eval(buf);
106  ++i;
107  continue;
108  }
109  char *confFile = argv[i];
110 #else
111  char *confFile = argv[argc-1];
112 #endif
113  iout << iINFO << "Configuration file is " << confFile << "\n" << endi;
114 
115  char *currentdir=confFile;
116  char *tmp;
117  char tmpcurdir[3];
118  for(tmp=confFile;*tmp;++tmp); // find final null
119  for( ; tmp != confFile && *tmp != PATHSEP; --tmp); // find last '/'
120 #if defined(WIN32) && !defined(__CYGWIN__)
121  if (tmp == confFile) {
122  // in case this is under cygwin, search for '/' as well
123  for(tmp=confFile;*tmp;++tmp); // find final null
124  for( ; tmp != confFile && *tmp != '/'; --tmp); // find last '/'
125  }
126 #endif
127  if ( CHDIR(origcwd) ) NAMD_err(origcwd);
128  if ( tmp != confFile )
129  {
130  *tmp = 0; confFile = tmp + 1;
131  if ( CHDIR(currentdir) ) NAMD_err(currentdir);
132  struct stat statBuf;
133  if (stat(confFile, &statBuf)) {
134  char buf[1024];
135  sprintf(buf,"Unable to access config file %s%c%s",currentdir,PATHSEP,confFile);
136  NAMD_die(buf);
137  }
138  iout << iINFO << "Changed directory to " << currentdir << "\n" << endi;
139  currentdir = GETCWD(currentdir_buf,CWDSIZE);
140  if ( ! currentdir ) NAMD_err("getcwd after chdir");
141  }
142  else{
143  if ( *tmp == PATHSEP ){ // config file in / is odd, but it might happen
145  struct stat statBuf;
146  if (stat(confFile, &statBuf)) {
147  char buf[1024];
148  sprintf(buf,"Unable to access config file %s",confFile);
149  NAMD_die(buf);
150  }
151  }else{ // just a config file name, so the path is the current working path
152  struct stat statBuf;
153  if (stat(confFile, &statBuf)) {
154  char buf[1024];
155  if ( confFile[0] == '-' || confFile[0] == '+' ) {
156  sprintf(buf,"Unknown command-line option %s",confFile);
157  } else {
158  sprintf(buf,"Unable to access config file %s",confFile);
159  }
160  NAMD_die(buf);
161  }
162  tmpcurdir[0] = '.';
163  tmpcurdir[1] = PATHSEP;
164  tmpcurdir[2] = 0;
165  currentdir = tmpcurdir;
166  iout << iINFO << "Working in the current directory " << origcwd << "\n" << endi;
167  }
168  }
169 
170 #ifdef MEM_OPT_VERSION
171  int dirlen = strlen(currentdir);
172  gWorkDir = new char[dirlen+1];
173  gWorkDir[dirlen]=0;
174  memcpy(gWorkDir, currentdir, dirlen);
175 #endif
176 
177  currentdir = NULL;
178 
179 #ifdef NAMD_TCL
180  script->load(confFile);
181 #else
182  script->run(confFile);
183 #endif
184 
185 #ifdef NAMD_TCL
186 }
187  script->run();
188 #endif
189 
190  BackEnd::exit();
191 }
static Node * Object()
Definition: Node.h:86
std::ostream & iINFO(std::ostream &s)
Definition: InfoStream.C:81
void NAMD_err(const char *err_msg)
Definition: common.C:170
void load(char *scriptFile)
Definition: ScriptTcl.C:2419
static void exit(int status=0)
Definition: BackEnd.C:277
std::ostream & endi(std::ostream &s)
Definition: InfoStream.C:54
#define iout
Definition: InfoStream.h:51
#define CHDIR
Definition: mainfunc.C:24
#define PATHSEP
Definition: mainfunc.C:26
void run()
Definition: ScriptTcl.C:2436
void setScript(ScriptTcl *s)
Definition: Node.h:194
#define CWDSIZE
ScriptTcl * script
Definition: PatchData.h:154
void NAMD_die(const char *err_msg)
Definition: common.C:147
void tclmain(int, char **)
Definition: ScriptTcl.C:2402
void eval(char *script)
Definition: ScriptTcl.C:2362
#define PATHSEPSTR
Definition: mainfunc.C:27
#define GETCWD
Definition: mainfunc.C:25

◆ all_init()

void all_init ( int  argc,
char **  argv 
)

Definition at line 100 of file BackEnd.C.

References _initCharm(), cuda_affinity_initialize(), cuda_getargs(), mic_getargs(), NAMD_new_handler(), ProcessorPrivateInit(), register_exit_sched(), and topo_getargs().

Referenced by master_init(), and slave_init().

101 {
102 #if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW_H)
103  _set_new_handler(NAMD_new_handler);
104 #else
105  std::set_new_handler(NAMD_new_handler);
106 #endif
109  CmiGetArgFlag(argv, "+idlepoll"); // remove +idlepoll if it's still there
110  topo_getargs(argv);
111 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
112  cuda_getargs(argv);
113  argc = CmiGetArgc(argv);
114 #endif
115 #ifdef NAMD_MIC
116  CmiGetArgFlag(argv, "+idlepoll"); // remove +idlepoll if it's still there
117  mic_getargs(argv);
118  argc = CmiGetArgc(argv);
119 #endif
120 #ifdef NAMD_AVXTILES
121  avxTilesCommandLineDisable = CmiGetArgFlag(argv, "+notiles");
122 #endif
123 
124 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
125  // launch CUDA runtime threads before affinity is set by _initCharm
126  // _initCharm contains a node barrier so there is no race here
127  if(CmiMyRank()==0){
129  }
130 #endif
131 
132  _initCharm(argc, argv); // message main Chare
133 
134 //#if 0 // moved to WorkDistrib
135 //#ifdef NAMD_CUDA
136 // if ( CkMyPe() < CkNumPes() ) cuda_initialize();
137 //#endif
138 //#ifdef NAMD_MIC
139 // if ( CkMyPe() < CkNumPes() ) mic_initialize();
140 //#endif
141 //#endif
142 }
void NAMD_new_handler()
Definition: BackEnd.C:78
void cuda_getargs(char **)
Definition: DeviceCUDA.C:67
void ProcessorPrivateInit(void)
void mic_getargs(char **)
void topo_getargs(char **)
Definition: WorkDistrib.C:91
void _initCharm(int, char **)
static void register_exit_sched(void)
Definition: BackEnd.C:62
void cuda_affinity_initialize()
Definition: CudaUtils.C:55

◆ CkpvStaticDeclare()

CkpvStaticDeclare ( int  ,
exitSchedHndlr   
)

◆ cuda_affinity_initialize()

void cuda_affinity_initialize ( )

Definition at line 55 of file CudaUtils.C.

Referenced by all_init().

55  {
56  int devcnt = 0;
57  cudaError_t err = cudaGetDeviceCount(&devcnt);
58  if ( devcnt == 1 ) { // only one device so it must be ours
59  int *dummy;
60  if ( err == cudaSuccess ) err = cudaSetDevice(0);
61  if ( err == cudaSuccess ) err = cudaSetDeviceFlags(cudaDeviceMapHost);
62  if ( err == cudaSuccess ) err = cudaMalloc(&dummy, 4);
63  }
64  if ( err != cudaSuccess ) {
65  char host[128];
66  gethostname(host, 128); host[127] = 0;
67  fprintf(stderr,"CUDA initialization error on %s: %s\n", host, cudaGetErrorString(err));
68  }
69 }

◆ cuda_getargs()

void cuda_getargs ( char **  )

Definition at line 67 of file DeviceCUDA.C.

References cuda_args, cuda_args_t::devicelist, cuda_args_t::devicesperreplica, cuda_args_t::globaldevice, cuda_args_t::ignoresharing, cuda_args_t::mergegrids, NAMD_die(), cuda_args_t::nomergegrids, cuda_args_t::nostreaming, cuda_args_t::pmedevice, cuda_args_t::pmePes, and cuda_args_t::usedevicelist.

Referenced by all_init().

67  {
69  cuda_args.usedevicelist = CmiGetArgStringDesc(argv, "+devices", &cuda_args.devicelist,
70  "comma-delimited list of CUDA device numbers such as 0,2,1,2");
72  CmiGetArgInt(argv, "+devicesperreplica", &cuda_args.devicesperreplica);
73  if ( cuda_args.devicesperreplica < 0 ) NAMD_die("Devices per replica must be positive\n");
74  cuda_args.ignoresharing = CmiGetArgFlag(argv, "+ignoresharing");
75  cuda_args.mergegrids = CmiGetArgFlag(argv, "+mergegrids");
76  cuda_args.nomergegrids = CmiGetArgFlag(argv, "+nomergegrids");
77  if ( cuda_args.mergegrids && cuda_args.nomergegrids ) NAMD_die("Do not specify both +mergegrids and +nomergegrids");
78  cuda_args.nostreaming = CmiGetArgFlag(argv, "+nostreaming");
79 #ifdef NODEGROUP_FORCE_REGISTER
80  CmiGetArgInt(argv, "+pmedevice", &cuda_args.pmedevice);
81  CmiGetArgInt(argv, "+pmepes", &cuda_args.pmePes);
83  CmiGetArgInt(argv, "+globaldevice", &cuda_args.globaldevice);
84 #endif
85 }
int devicesperreplica
Definition: DeviceCUDA.C:55
int nomergegrids
Definition: DeviceCUDA.C:58
static __thread cuda_args_t cuda_args
Definition: DeviceCUDA.C:65
int globaldevice
Definition: DeviceCUDA.C:62
int usedevicelist
Definition: DeviceCUDA.C:54
int mergegrids
Definition: DeviceCUDA.C:57
int nostreaming
Definition: DeviceCUDA.C:59
int pmedevice
Definition: DeviceCUDA.C:60
void NAMD_die(const char *err_msg)
Definition: common.C:147
int ignoresharing
Definition: DeviceCUDA.C:56
char * devicelist
Definition: DeviceCUDA.C:53

◆ exit_sched()

void exit_sched ( void *  msg)

Definition at line 56 of file BackEnd.C.

Referenced by register_exit_sched().

57 {
58  // CmiPrintf("Exiting scheduler on %d\n",CmiMyPe());
59  CsdExitScheduler();
60 }

◆ master_init()

void master_init ( int  argc,
char **  argv 
)

Definition at line 168 of file BackEnd.C.

References all_init(), BOCgroup::broadcastMgr, BOCgroup::collectionMgr, BOCgroup::computeCUDAMgr, BOCgroup::computeExtMgr, BOCgroup::computeFmmSerialMgr, BOCgroup::computeGBISserMgr, BOCgroup::computeLjPmeSerialMgr, BOCgroup::computeMgr, BOCgroup::computeMsmMgr, BOCgroup::computeMsmMsaMgr, BOCgroup::computeMsmSerialMgr, BOCgroup::computePmeCUDAMgr, BOCgroup::computeQMMgr, cpuTime_start, BOCgroup::dataExchanger, GroupInitMsg::group, BOCgroup::ioMgr, BOCgroup::ldbCoordinator, SlaveInitMsg::master, BOCgroup::multicastMgr, BOCgroup::nodePmeMgr, BOCgroup::patchData, BOCgroup::patchMgr, BOCgroup::proxyMgr, BOCgroup::reductionMgr, BOCgroup::sync, wallTime_start, and BOCgroup::workDistrib.

Referenced by BackEnd::init(), and slave_init().

168  {
169  cpuTime_start = CmiCpuTimer();
170  wallTime_start = CmiWallTimer();
171  if ( CmiMyPe() ) {
172  all_init(argc, argv);
173  CsdScheduler(-1);
174  ConverseExit(); // should never return
175  }
176 
177  all_init(argc, argv);
178 
179  // Create branch-office chares
180  BOCgroup group;
181  group.workDistrib = CProxy_WorkDistrib::ckNew();
182  group.proxyMgr = CProxy_ProxyMgr::ckNew();
183  group.patchMgr = CProxy_PatchMgr::ckNew();
184  group.computeMgr = CProxy_ComputeMgr::ckNew();
185  group.reductionMgr = CProxy_ReductionMgr::ckNew();
186  // group.computePmeMgr set in constructor during startup
187  group.nodePmeMgr = CProxy_NodePmeMgr::ckNew();
188 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
189  group.patchData = CProxy_PatchData::ckNew();
190  group.computePmeCUDAMgr = CProxy_ComputePmeCUDAMgr::ckNew();
191  group.computeCUDAMgr = CProxy_ComputeCUDAMgr::ckNew();
192 #endif
193 #ifdef OPENATOM_VERSION
194  group.computeMoaMgr = CProxy_ComputeMoaMgr::ckNew();
195 #endif // OPENATOM_VERSION
196  group.computeExtMgr = CProxy_ComputeExtMgr::ckNew();
197  group.computeQMMgr = CProxy_ComputeQMMgr::ckNew();
198  group.computeGBISserMgr = CProxy_ComputeGBISserMgr::ckNew();
199  group.computeFmmSerialMgr = CProxy_ComputeFmmSerialMgr::ckNew();
200  group.computeMsmSerialMgr = CProxy_ComputeMsmSerialMgr::ckNew();
201  group.computeLjPmeSerialMgr = CProxy_ComputeLjPmeSerialMgr::ckNew();
202 #ifdef CHARM_HAS_MSA
203  group.computeMsmMsaMgr = CProxy_ComputeMsmMsaMgr::ckNew();
204 #endif
205  group.computeMsmMgr = CProxy_ComputeMsmMgr::ckNew();
206  // Charm CkMulticast library module
207  group.multicastMgr = CProxy_CkMulticastMgr::ckNew();
208 #ifdef MEM_OPT_VERSION
209  group.ioMgr=CProxy_ParallelIOMgr::ckNew();
210 #endif
211 
212  group.sync = CProxy_Sync::ckNew();
213 
214  #ifdef USE_NODEPATCHMGR
215  group.nodeProxyMgr = CProxy_NodeProxyMgr::ckNew();
216  #endif
217 
218 #if CMK_SMP && USE_CKLOOP
219  group.ckLoop = CkLoop_Init();
220 #endif
221 
222  CkChareID collectionMaster = CProxy_CollectionMaster::ckNew(0);
223  SlaveInitMsg *initmsg7 = new SlaveInitMsg;
224  initmsg7->master = collectionMaster;
225  group.collectionMgr = CProxy_CollectionMgr::ckNew(initmsg7);
226 
227  group.broadcastMgr = CProxy_BroadcastMgr::ckNew();
228  group.ldbCoordinator = CProxy_LdbCoordinator::ckNew();
229 
230  group.dataExchanger = CProxy_DataExchanger::ckNew();
231 
232  GroupInitMsg *msg = new GroupInitMsg;
233  msg->group = group;
234  CkGroupID node = CProxy_Node::ckNew(msg);
235 
236  CkStartQD(CkCallback(CkIndex_Node::exitScheduler(), CkMyPe(), node));
237  CsdScheduler(-1);
238 }
CkGroupID broadcastMgr
Definition: BOCgroup.h:44
CkChareID master
Definition: CollectionMgr.h:23
BOCgroup group
Definition: Node.h:68
CkGroupID patchMgr
Definition: BOCgroup.h:19
void all_init(int argc, char **argv)
Definition: BackEnd.C:100
CkGroupID computeLjPmeSerialMgr
Definition: BOCgroup.h:38
CkGroupID computeMsmMsaMgr
Definition: BOCgroup.h:39
CkGroupID patchData
Definition: BOCgroup.h:27
CkGroupID workDistrib
Definition: BOCgroup.h:18
float cpuTime_start
Definition: BackEnd.C:51
CkGroupID computeMgr
Definition: BOCgroup.h:21
CkGroupID computeCUDAMgr
Definition: BOCgroup.h:26
CkGroupID computePmeCUDAMgr
Definition: BOCgroup.h:25
CkGroupID computeMsmSerialMgr
Definition: BOCgroup.h:37
float wallTime_start
Definition: BackEnd.C:52
CkGroupID dataExchanger
Definition: BOCgroup.h:57
CkGroupID collectionMgr
Definition: BOCgroup.h:43
CkGroupID computeMsmMgr
Definition: BOCgroup.h:40
CkGroupID computeExtMgr
Definition: BOCgroup.h:33
CkGroupID multicastMgr
Definition: BOCgroup.h:41
CkGroupID proxyMgr
Definition: BOCgroup.h:20
CkGroupID ldbCoordinator
Definition: BOCgroup.h:45
CkGroupID nodePmeMgr
Definition: BOCgroup.h:23
CkGroupID computeGBISserMgr
Definition: BOCgroup.h:35
CkGroupID ioMgr
Definition: BOCgroup.h:48
CkGroupID sync
Definition: BOCgroup.h:46
CkGroupID computeFmmSerialMgr
Definition: BOCgroup.h:36
CkGroupID computeQMMgr
Definition: BOCgroup.h:34
CkGroupID reductionMgr
Definition: BOCgroup.h:42

◆ mic_getargs()

void mic_getargs ( char **  )

Referenced by all_init().

◆ NAMD_new_handler()

void NAMD_new_handler ( )

Definition at line 78 of file BackEnd.C.

References NAMD_die().

Referenced by all_init().

78  {
79 #endif
80  char tmp[100];
81  sprintf(tmp,"Memory allocation failed on processor %d.",CmiMyPe());
82  NAMD_die(tmp);
83 #if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW_H)
84  return 0;
85 #endif
86 }
void NAMD_die(const char *err_msg)
Definition: common.C:147

◆ register_exit_sched()

static void register_exit_sched ( void  )
static

Definition at line 62 of file BackEnd.C.

References exit_sched().

Referenced by all_init().

63 {
64  CkpvInitialize(int,exitSchedHndlr);
65  CkpvAccess(exitSchedHndlr) = CmiRegisterHandler((CmiHandler)exit_sched);
66 }
void exit_sched(void *msg)
Definition: BackEnd.C:56

◆ slave_init()

void slave_init ( int  argc,
char **  argv 
)

Definition at line 148 of file BackEnd.C.

References after_backend_init(), all_init(), and master_init().

Referenced by BackEnd::init().

149 {
150 #if CMK_SMP
151  //the original main thread could now be a comm thread
152  //and a slave thread could now be the main thread,
153  //so we have to do the master initialization here
154  if(CmiMyRank()==0){
155  master_init(argc, argv);
156  if(CmiMyPe()==0)
157  after_backend_init(argc, argv);
158  return;
159  }
160 #endif
161 
162  all_init(argc, argv);
163 
164  if (CkMyRank() < CkMyNodeSize()) // skip the communication thread
165  CsdScheduler(-1);
166 }
void after_backend_init(int argc, char **argv)
Definition: mainfunc.C:55
void all_init(int argc, char **argv)
Definition: BackEnd.C:100
void master_init(int argc, char **argv)
Definition: BackEnd.C:168

◆ topo_getargs()

void topo_getargs ( char **  )

Definition at line 91 of file WorkDistrib.C.

References build_ordering(), and randtopo.

Referenced by all_init().

91  {
92  randtopo = CmiGetArgFlag(argv, "+randtopo");
93  if ( CkMyPe() >= CkNumPes() ) return;
94 #if CCD_COND_FN_EXISTS
95  CcdCallOnCondition(CcdTOPOLOGY_AVAIL, (CcdCondFn)build_ordering, (void*)0);
96 #else
97  CcdCallOnCondition(CcdTOPOLOGY_AVAIL, (CcdVoidFn)build_ordering, (void*)0);
98 #endif
99 }
static int randtopo
Definition: WorkDistrib.C:85
static void build_ordering(void *)
Definition: WorkDistrib.C:87

Variable Documentation

◆ cpuTime_start

float cpuTime_start

Definition at line 51 of file BackEnd.C.

Referenced by BackEnd::exit(), and master_init().

◆ gNAMDBinaryName

char* gNAMDBinaryName = NULL

Definition at line 240 of file BackEnd.C.

Referenced by BackEnd::init(), and Node::outputPatchComputeMaps().

◆ wallTime_start

float wallTime_start

Definition at line 52 of file BackEnd.C.

Referenced by BackEnd::exit(), and master_init().