#include <Node.h>

Inheritance diagram for Node:

Public Member Functions
	Node (GroupInitMsg *msg)

	~Node (void)

void	run ()

void	enableScriptBarrier ()

void	scriptBarrier (void)

void	scriptParam (ScriptParamMsg *)

void	reloadCharges (const char *filename)

void	reloadCharges (float charge[], int n)

void	reloadGridforceGrid (const char *key)

void	reloadGridforceGrid (int gridnum)

void	updateGridScale (const char *key, Vector scale)

void	updateGridScale (int gridnum, float sx, float sy, float sz)

void	reloadStructure (const char , const char )

void	resendMolecule ()

void	resendMolecule2 ()

void	sendCheckpointReq (int remote, const char *key, int task, Lattice &lat, ControllerState &cs)

void	recvCheckpointReq (CheckpointMsg *)

void	recvCheckpointAck (CheckpointMsg *)

void	sendEnableExitScheduler (void)

void	recvEnableExitScheduler (void)

void	enableExitScheduler (void)

void	exitScheduler (void)

void	sendEnableEarlyExit (void)

void	recvEnableEarlyExit (void)

void	enableEarlyExit (void)

void	earlyExit (void)

void	startup ()

void	mallocTest (int)

void	mallocTestQd (void)

float	measureMemory ()

void	BOCCheckIn ()

void	awaitBOCCheckIn ()

void	saveMolDataPointers (NamdState *)

void	startHPM ()

void	stopHPM ()

void	traceBarrier (int turnOnTrace, int step)

void	resumeAfterTraceBarrier (CkReductionMsg *msg)

void	papiMeasureBarrier (int turnOnMeasure, int step)

void	resumeAfterPapiMeasureBarrier (CkReductionMsg *msg)

void	outputPatchComputeMaps (const char *filename, int tag)

int	myid ()

int	numNodes ()

void	setScript (ScriptTcl *s)

ScriptTcl *	getScript (void)

Static Public Member Functions
static Node *	Object ()

static void	messageRun ()

static void	messageStartUp ()

static void	messageBOCCheckIn ()

Public Attributes
int	mallocTest_size

float	initVM

float	initRSS

int	curTimeStep

int	curMFlopStep

bool	specialTracing

WorkDistrib *	workDistrib

ComputeMgr *	computeMgr

Random *	rand

Molecule *	molecule

Parameters *	parameters

SimParameters *	simParameters

ConfigList *	configList

PDB *	pdb

NamdState *	state

Output *	output

IMDOutput *	imd

colvarmodule *	colvars

Vector *	coords

Protected Attributes
AtomMap *	atomMap

PatchMap *	patchMap

ComputeMap *	computeMap

LdbCoordinator *	ldbCoordinator

Detailed Description

Definition at line 78 of file Node.h.

Constructor & Destructor Documentation

Node::Node ( GroupInitMsg * msg )

Definition at line 291 of file Node.C.

References atomMap, colvars, configList, DebugM, GroupInitMsg::group, imd, PatchMap::Instance(), AtomMap::Instance(), ComputeMap::Instance(), molecule, NAMD_bug(), output, parameters, patchMap, pdb, recvCheckpointCAck_handler(), recvCheckpointCReq_handler(), simParameters, specialTracing, state, x, y, and z.

 {    
   DebugM(4,"Creating Node\n");
 #if(CMK_CCS_AVAILABLE && CMK_WEB_MODE)
   CApplicationInit();
 #endif
   if (CkpvAccess(Node_instance) == 0) {
     CkpvAccess(Node_instance) = this;
     eventEndOfTimeStep = traceRegisterUserEvent("EndOfTimeStep", 135);
   } else {
     NAMD_bug("Node::Node() - another instance of Node exists!");
   }
 
   CkpvAccess(BOCclass_group) = msg->group;
   delete msg;
 
   CkpvAccess(BOCclass_group).node = thisgroup;
 
   recvCheckpointCReq_index = CmiRegisterHandler((CmiHandler)recvCheckpointCReq_handler);
   recvCheckpointCAck_index = CmiRegisterHandler((CmiHandler)recvCheckpointCAck_handler);
 
   startupPhase = 0;
 
   molecule = NULL;
   parameters = NULL;
   simParameters = NULL;
   configList = NULL;
   pdb = NULL;
   state = NULL;
   output = NULL;
   imd = new IMDOutput;
   colvars = 0;
 
 #if USE_HPM
   // assumes that this will be done only on BG/P
   TopoManager *tmgr = new TopoManager();
   int x, y, z;
   tmgr->rankToCoordinates(CkMyPe(), x, y, z, localRankOnNode);
   delete tmgr;
 #endif
 
   specialTracing = traceAvailable() && (traceIsOn()==0);
 
   DebugM(4,"Creating PatchMap, AtomMap, ComputeMap\n");
   patchMap = PatchMap::Instance();
   atomMap = AtomMap::Instance();
   if ( CkMyRank() == 0 ) ComputeMap::Instance();
 
   //Note: Binding BOC vars such as workDistrib has been moved
   //to the 1st phase of startup because the in-order message delivery
   //is not always guaranteed --Chao Mei
 #if defined(CMK_BALANCED_INJECTION_API) && CMK_BALANCED_INJECTION_API != 0
   if(CkMyRank() == 0){
     balancedInjectionLevel=ck_get_GNI_BIConfig();
     // CkPrintf("[%d] get retrieved BI=%d\n",CkMyPe(),balancedInjectionLevel);
     ck_set_GNI_BIConfig(20);
     // CkPrintf("[%d] set retrieved BI=%d\n",CkMyPe(),ck_get_GNI_BIConfig());
   }
 #endif
 
 }

Node::~Node ( void )

Definition at line 356 of file Node.C.

References atomMap, computeMap, output, patchMap, and rand.

 {
   delete output;
   delete computeMap;
   delete atomMap;
   delete patchMap;
   delete CkpvAccess(comm);
   // BEGIN LA
   delete rand;
   // END LA
 #ifdef MEASURE_NAMD_WITH_PAPI
   delete CkpvAccess(papiEvents);
 #endif
 }

Member Function Documentation

void Node::awaitBOCCheckIn ( )

void Node::BOCCheckIn ( )

void Node::earlyExit ( void )

Definition at line 1373 of file Node.C.

References NAMD_die().

                          {
   NAMD_die("Exiting prematurely; see error messages above.");
 }

void Node::enableEarlyExit ( void )

Definition at line 1365 of file Node.C.

References sendEnableEarlyExit().

Referenced by Sequencer::hardWallDrude(), Sequencer::maximumMove(), Sequencer::rattle1(), and recvEnableEarlyExit().

                                {
   if ( CkMyPe() ) {
     sendEnableEarlyExit();
   } else {
     CkStartQD(CkIndex_Node::earlyExit(),&thishandle);
   }
 }

void Node::enableExitScheduler ( void )

Definition at line 1343 of file Node.C.

References sendEnableExitScheduler().

Referenced by BackEnd::awaken(), and recvEnableExitScheduler().

                                    {
   if ( CkMyPe() ) {
     sendEnableExitScheduler();
   } else {
     CkStartQD(CkIndex_Node::exitScheduler(), &thishandle);
   }
 }

void Node::enableScriptBarrier ( )

Definition at line 1140 of file Node.C.

                                {
   CkStartQD(CkIndex_Node::scriptBarrier(), &thishandle);
 }

void Node::exitScheduler ( void )

Definition at line 1351 of file Node.C.

                              {
   //CmiPrintf("exitScheduler %d\n",CkMyPe());
   CsdExitScheduler();
 }

ScriptTcl* Node::getScript ( void )

inline

Definition at line 192 of file Node.h.

Referenced by Output::coordinate(), colvarproxy_namd::init_tcl_pointers(), and Controller::printEnergies().

192 { return script; }

void Node::mallocTest ( int step )

Definition at line 392 of file Node.C.

References NAMD_die().

Referenced by mallocTestQd().

                               {
   int MB = 1024*1024;
   int size = 100;
   char* foo = (char*) malloc(size*MB);
   if ( ! foo ) {
     char buf[256];
     sprintf(buf,"Malloc fails on Pe %d at %d MB.\n",CkMyPe(),step*size);
     NAMD_die(buf);
   }
   memset(foo,0,size*MB*sizeof(char));
 }

void Node::mallocTestQd ( void )

Definition at line 404 of file Node.C.

References mallocTest(), and mallocTest_size.

                         {
   if ( mallocTest_size ) {
     CkPrintf("All PEs successfully allocated %d MB.\n", 100*mallocTest_size);
   } else {
     CkPrintf("Starting malloc test on all PEs.\n");
   }
   fflush(stdout);
   ++mallocTest_size;
   CkStartQD(CkIndex_Node::mallocTestQd(), &thishandle);
   (CProxy_Node(CkpvAccess(BOCclass_group).node)).mallocTest(mallocTest_size);
 }

float Node::measureMemory ( )

static void Node::messageBOCCheckIn ( )

static

void Node::messageRun ( )

static

Definition at line 1096 of file Node.C.

References run().

Referenced by startup().

                       {
   (CProxy_Node(CkpvAccess(BOCclass_group).node)).run();
 }

void Node::messageStartUp ( )

static

Definition at line 419 of file Node.C.

References startup().

                           {
   (CProxy_Node(CkpvAccess(BOCclass_group).node)).startup();
 }

int Node::myid ( )

inline

Definition at line 188 of file Node.h.

Referenced by ComputeMgr::createComputes(), WorkDistrib::distributeHomePatches(), and LdbCoordinator::initialize().

188 { return CkMyPe(); }

int Node::numNodes ( )

inline

Definition at line 189 of file Node.h.

Referenced by WorkDistrib::assignNodeToPatch(), and LdbCoordinator::initialize().

189 { return CkNumPes(); }

static Node* Node::Object ( )

inlinestatic

Definition at line 86 of file Node.h.

86 {return CkpvAccess(Node_instance);}

void Node::outputPatchComputeMaps	(	const char *	filename,
		int	tag
	)

Definition at line 1521 of file Node.C.

References Patch::getNumAtoms(), PatchMap::gridsize_a(), PatchMap::gridsize_b(), PatchMap::gridsize_c(), NAMD_die(), ComputeMap::node(), PatchMap::node(), ComputeMap::numComputes(), PatchMap::numPatches(), numPatches, PatchMap::Object(), ComputeMap::Object(), SimParameters::outputMaps, PatchMap::patch(), ComputeMap::pid(), simParameters, SimParameters::simulatedNodeSize, SimParameters::simulatedPEs, SimParameters::simulateInitialMapping, and ComputeMap::type().

Referenced by Controller::rebalanceLoad(), and startup().

                                                               {
         if(!simParameters->outputMaps && !simParameters->simulateInitialMapping) return;
 
         int numpes = CkNumPes();
         int nodesize = CkMyNodeSize();
         if(simParameters->simulateInitialMapping) {
                 numpes = simParameters->simulatedPEs;
                 nodesize = simParameters->simulatedNodeSize;
         }
 
         char fname[128];
         sprintf(fname, "mapdump_%s.%d_%d_%d_%s", filename, numpes, nodesize, tag, gNAMDBinaryName);
 
         FILE *fp = fopen(fname, "w");
         if(fp == NULL) {
                 NAMD_die("Error in outputing PatchMap and ComputeMap info!\n");
                 return;
         }
         PatchMap *pMap = PatchMap::Object();
         ComputeMap *cMap = ComputeMap::Object();
         int numPatches = pMap->numPatches();
         int numComputes = cMap->numComputes();
         fprintf(fp, "%d %d %d %d %d %d %d\n", numpes, nodesize, numPatches, numComputes, 
                         pMap->gridsize_a(), pMap->gridsize_b(), pMap->gridsize_c());
         //output PatchMap info
         for(int i=0; i<numPatches; i++) {
         #ifdef MEM_OPT_VERSION
                 fprintf(fp, "%d %d\n", pMap->numAtoms(i), pMap->node(i));
         #else
                 fprintf(fp, "%d %d\n", pMap->patch(i)->getNumAtoms(), pMap->node(i));
         #endif
         }
 
         //output ComputeMap info
         for(int i=0; i<numComputes; i++) {              
                 fprintf(fp, "%d %d %d %d\n", cMap->node(i), cMap->type(i), cMap->pid(i,0), cMap->pid(i,1));             
         }
 }

void Node::papiMeasureBarrier	(	int	turnOnMeasure,
		int	step
	)

Definition at line 1426 of file Node.C.

References curMFlopStep.

                                                         {
 #ifdef MEASURE_NAMD_WITH_PAPI
         curMFlopStep = step;
         double results[NUM_PAPI_EVENTS+1];
 
         if(turnOnMeasure){              
           CkpvAccess(papiEvents)[NUM_PAPI_EVENTS]=CmiWallTimer();
 
           long long counters[NUM_PAPI_EVENTS+1];
           int ret=PAPI_start_counters(CkpvAccess(papiEvents), NUM_PAPI_EVENTS);
           if(ret==PAPI_OK)
             {
               //              CkPrintf("traceBarrier start counters (%d) at step %d called on proc %d\n", turnOnMeasure, step, CkMyPe());
             }
           else
             {
               CkPrintf("error PAPI_start_counters (%d) at step %d called on proc %d\n",ret , step, CkMyPe());
             }
           if(PAPI_read_counters(counters, NUM_PAPI_EVENTS)!=PAPI_OK)
             {
               CkPrintf("error PAPI_read_counters %d\n",PAPI_read_counters(counters, NUM_PAPI_EVENTS));
             };
         }else{
           long long counters[NUM_PAPI_EVENTS+1];
           for(int i=0;i<NUM_PAPI_EVENTS;i++)  counters[i]=0LL;
           if(PAPI_read_counters(counters, NUM_PAPI_EVENTS)==PAPI_OK)
             {
 #if !MEASURE_PAPI_SPP
               results[0] = (double)counters[0]/1e6;
               results[1] = (double)counters[1]/1e6;
 #else
               for(int i=0;i<NUM_PAPI_EVENTS;i++)  results[i] = counters[i]/1e6;
 #endif
               //              for(int i=0;i<NUM_PAPI_EVENTS;i++) CkPrintf("[%d] counter %d is %ld\n",CkMyPe(),i,counters[i]);
             }
           else
             {
               //              CkPrintf("error PAPI_read_counters %d\n",PAPI_read_counters(counters, NUM_PAPI_EVENTS));
             }
           //      CkPrintf("traceBarrier stop counters (%d) at step %d called on proc %d\n", turnOnMeasure, step, CkMyPe());
                 
           PAPI_stop_counters(counters, NUM_PAPI_EVENTS);        
         }
         if(CkMyPe()==0)
           //        CkPrintf("traceBarrier (%d) at step %d called on proc %d\n", turnOnMeasure, step, CkMyPe());
         results[NUM_PAPI_EVENTS]=CkpvAccess(papiEvents)[NUM_PAPI_EVENTS]; //starttime
         CProxy_Node nd(CkpvAccess(BOCclass_group).node);
         CkCallback cb(CkIndex_Node::resumeAfterPapiMeasureBarrier(NULL), nd[0]);
         contribute(sizeof(double)*(NUM_PAPI_EVENTS+1), &results, CkReduction::sum_double, cb);  
 #endif
 }

void Node::recvCheckpointAck ( CheckpointMsg * msg )

Definition at line 1326 of file Node.C.

References CheckpointMsg::checkpoint, Controller::recvCheckpointAck(), and state.

Referenced by recvCheckpointCAck_handler().

                                                {
   state->controller->recvCheckpointAck(msg->checkpoint);
   delete msg;
 }

void Node::recvCheckpointReq ( CheckpointMsg * msg )

Definition at line 1304 of file Node.C.

References CheckpointMsg::checkpoint, CheckpointMsg::key, Controller::recvCheckpointReq(), CheckpointMsg::replica, state, and CheckpointMsg::task.

Referenced by recvCheckpointCReq_handler().

                                                {
   state->controller->recvCheckpointReq(msg->key,msg->task,msg->checkpoint);
 
   int remote = msg->replica;
   msg->replica = CmiMyPartition();
   envelope *env = UsrToEnv(CheckpointMsg::pack(msg));
   CmiSetHandler(env,recvCheckpointCAck_index);
 #if CMK_HAS_PARTITION
   CmiInterSyncSendAndFree(CkMyPe(),remote,env->getTotalsize(),(char*)env);
 #else
   CmiSyncSendAndFree(CkMyPe(),env->getTotalsize(),(char*)env);
 #endif
 }

void Node::recvEnableEarlyExit ( void )

Definition at line 1361 of file Node.C.

References enableEarlyExit().

                                {
   enableEarlyExit();
 }

void Node::recvEnableExitScheduler ( void )

Definition at line 1338 of file Node.C.

References enableExitScheduler().

                                        {
   //CmiPrintf("recvEnableExitScheduler\n");
   enableExitScheduler();
 }

void Node::reloadCharges ( const char * filename )

Definition at line 1153 of file Node.C.

References charge, molecule, NAMD_die(), and Molecule::numAtoms.

                                              {
   FILE *file = fopen(filename,"r");
   if ( ! file ) NAMD_die("node::reloadCharges():Error opening charge file.");
 
   int n = molecule->numAtoms;
   float *charge = new float[n];
 
   for ( int i = 0; i < n; ++i ) {
     if ( ! fscanf(file,"%f",&charge[i]) )
       NAMD_die("Node::reloadCharges():Not enough numbers in charge file.");
   }
 
   fclose(file);
   CProxy_Node(thisgroup).reloadCharges(charge,n);
   delete [] charge;
 }

void Node::reloadCharges	(	float	charge[],
		int	n
	)

Definition at line 1170 of file Node.C.

References molecule, and Molecule::reloadCharges().

                                               {
   molecule->reloadCharges(charge,n);
 }

void Node::reloadGridforceGrid ( const char * key )

Definition at line 1176 of file Node.C.

References DebugM, MGridforceParamsList::find_key(), Molecule::get_gridfrc_grid(), MGridforceParamsList::index_for_key(), SimParameters::mgridforcelist, MGRIDFORCEPARAMS_DEFAULTKEY, molecule, NAMD_bug(), NAMD_die(), GridforceGrid::reinitialize(), and simParameters.

                                                {
     DebugM(4, "reloadGridforceGrid(const char*) called on node " << CkMyPe() << "\n" << endi);
     
     int gridnum;
     MGridforceParams *mgridParams;
     if (key == NULL) {
         gridnum = simParameters->mgridforcelist.index_for_key(MGRIDFORCEPARAMS_DEFAULTKEY);
         mgridParams = simParameters->mgridforcelist.find_key(MGRIDFORCEPARAMS_DEFAULTKEY);
     } else {
         gridnum = simParameters->mgridforcelist.index_for_key(key);
         mgridParams = simParameters->mgridforcelist.find_key(key);
     }
     
     if (gridnum < 0 || mgridParams == NULL) {
         NAMD_die("Node::reloadGridforceGrid(const char*):Could not find grid.");
     }
     
     GridforceGrid *grid = molecule->get_gridfrc_grid(gridnum);
     if (grid == NULL) {
         NAMD_bug("Node::reloadGridforceGrid(const char*):grid not found");
     }
     grid->reinitialize(simParameters, mgridParams);
     
     CProxy_Node(thisgroup).reloadGridforceGrid(gridnum);
     
     DebugM(4, "reloadGridforceGrid(const char*) finished\n" << endi);
 }

void Node::reloadGridforceGrid ( int gridnum )

Definition at line 1245 of file Node.C.

References ALLBUTME, BUFSIZE, DebugM, MOStream::end(), Molecule::get_gridfrc_grid(), GRIDFORCEGRIDTAG, molecule, NAMD_bug(), GridforceGrid::pack_grid(), Molecule::set_gridfrc_grid(), and GridforceGrid::unpack_grid().

                                           {
     if (CmiMyRank()) return;
     DebugM(4, "reloadGridforceGrid(int) called on node " << CkMyPe() << "\n" << endi);
     
     GridforceGrid *grid = molecule->get_gridfrc_grid(gridnum);
     if (grid == NULL) {
         NAMD_bug("Node::reloadGridforceGrid(int):grid not found");
     }
     
     if (CkMyPe()) {
         // not node 0 -> receive grid
         DebugM(4, "Receiving grid\n");
         
         delete grid;
         
         MIStream *msg = CkpvAccess(comm)->newInputStream(0, GRIDFORCEGRIDTAG);
         grid = GridforceGrid::unpack_grid(gridnum, msg);
         molecule->set_gridfrc_grid(gridnum, grid);
         delete msg;
     } else {
         // node 0 -> send grid
         DebugM(4, "Sending grid\n");
         
         MOStream *msg = CkpvAccess(comm)->newOutputStream(ALLBUTME, GRIDFORCEGRIDTAG, BUFSIZE);
         GridforceGrid::pack_grid(grid, msg);
         msg->end();
         delete msg;
     }
     
     DebugM(4, "reloadGridforceGrid(int) finished\n" << endi);
 }

void Node::reloadStructure	(	const char *	fname,
		const char *	pdbname
	)

Definition at line 1007 of file Node.C.

References NamdState::loadStructure(), molecule, pdb, and state.

                                                                  {
   delete molecule;
   molecule = state->molecule = 0;
   delete pdb;
   pdb = state->pdb = 0;
   state->loadStructure(fname,pdbname,1);
   this->molecule = state->molecule;
   this->pdb = state->pdb;
   CProxy_Node nodeProxy(thisgroup);
   nodeProxy.resendMolecule();
 }

void Node::resendMolecule ( )

Definition at line 1020 of file Node.C.

References ALLBUTME, BUFSIZE, computeMgr, molecule, MOLECULETAG, SimParameters::nonbonded_select(), Molecule::numAtoms, parameters, SimParameters::pme_select(), SimParameters::PMEOn, Molecule::receive_Molecule(), Parameters::receive_Parameters(), Molecule::send_Molecule(), Parameters::send_Parameters(), ComputeMgr::sendBuildCudaExclusions(), simParameters, and STATICPARAMSTAG.

                           {
   if ( CmiMyRank() ) {
     return;
   }
   if ( CmiMyPe() == 0 ) {
     int bufSize = BUFSIZE;
     MOStream *conv_msg;
     conv_msg = CkpvAccess(comm)->newOutputStream(ALLBUTME, STATICPARAMSTAG, bufSize);
     parameters->send_Parameters(conv_msg);
     if(molecule->numAtoms>=1000000) bufSize = 16*BUFSIZE;
     conv_msg = CkpvAccess(comm)->newOutputStream(ALLBUTME, MOLECULETAG, bufSize);
     molecule->send_Molecule(conv_msg);
   } else {
     MIStream *conv_msg;
     delete parameters;
     parameters = new Parameters;
     conv_msg = CkpvAccess(comm)->newInputStream(0, STATICPARAMSTAG);
     parameters->receive_Parameters(conv_msg);
     delete molecule;
     molecule = new Molecule(simParameters,parameters);
     conv_msg = CkpvAccess(comm)->newInputStream(0, MOLECULETAG);
     molecule->receive_Molecule(conv_msg);
   }
   node_parameters = parameters;
   node_molecule = molecule;
   SimParameters::nonbonded_select();
   if ( simParameters->PMEOn ) SimParameters::pme_select();
   computeMgr->sendBuildCudaExclusions();
   CProxy_Node nodeProxy(thisgroup);
   for ( int i=0; i<CmiMyNodeSize(); ++i ) {
     nodeProxy[CmiMyPe()+i].resendMolecule2();
   }
 }

void Node::resendMolecule2 ( )

Definition at line 1054 of file Node.C.

References AtomMap::allocateMap(), molecule, node_molecule, node_parameters, Molecule::numAtoms, AtomMap::Object(), and parameters.

                            {
   parameters = node_parameters;
   molecule = node_molecule;
   AtomMap::Object()->allocateMap(molecule->numAtoms);
 }

void Node::resumeAfterPapiMeasureBarrier ( CkReductionMsg * msg )

Definition at line 1478 of file Node.C.

References curMFlopStep, simParameters, and state.

                                                            {
 #ifdef MEASURE_NAMD_WITH_PAPI
   
         if(simParameters->papiMeasureStartStep != curMFlopStep) {
                 double *results = (double *)msg->getData();
                 double endtime=CmiWallTimer();
                 int bstep = simParameters->papiMeasureStartStep;
                 int estep = bstep + simParameters->numPapiMeasureSteps;
 #if MEASURE_PAPI_SPP
                 CkPrintf("SPP INFO: PAPI_FP_OPS timestep %d to %d is %lf(1e6)\n", bstep,estep,results[0]);
                 CkPrintf("SPP INFO: PAPI_TOT_INS timestep %d to %d is %lf(1e6)\n", bstep,estep,results[1]);
                 CkPrintf("SPP INFO: perf::PERF_COUNT_HW_CACHE_LL:MISS timestep %d to %d is %lf(1e6)\n", bstep,estep,results[2]);
                 CkPrintf("SPP INFO: DATA_PREFETCHER:ALL timestep %d to %d is %lf(1e6)\n", bstep,estep,results[3]);
                 CkPrintf("SPP INFO: PAPI_L1_DCA timestep %d to %d is %lf(1e6)\n", bstep,estep,results[4]);
                 CkPrintf("SPP INFO: PAPI_TOT_CYC timestep %d to % is %lf(1e6)\n", bstep,estep,results[5]);
                 //              CkPrintf("SPP INFO: INSTRUCTION_FETCH_STALL timestep %d to %d is %lf(1e6)\n", bstep,estep,results[6]);
                 //              CkPrintf("SPP INFO: WALLtime timestep %d to %d is %lf\n", bstep,estep,endtime-results[NUM_PAPI_EVENTS]/CkNumPes());
                 CkPrintf("SPP INFO: WALLtime timestep %d to %d is %lf\n", bstep,estep,endtime-results[NUM_PAPI_EVENTS]);
                 CkPrintf("SPP INFO: endtime %lf avgtime %lf tottime %lf\n", endtime,results[NUM_PAPI_EVENTS]/CkNumPes(),results[NUM_PAPI_EVENTS] );
 #else
                 if(CkpvAccess(papiEvents)[0] == PAPI_FP_INS){
                         double totalFPIns = results[0];
                         if(CkpvAccess(papiEvents)[1] == PAPI_FMA_INS) totalFPIns += (results[1]*2);
                         CkPrintf("FLOPS INFO: from timestep %d to %d, the total FP instruction of NAMD is %lf(x1e6) per processor\n", 
                                          bstep, estep, totalFPIns/CkNumPes());
                 }else{
                         char nameBuf[PAPI_MAX_STR_LEN];
                         CkPrintf("PAPI COUNTERS INFO: from timestep %d to %d, ", 
                                          bstep, estep);
                         for(int i=0; i<NUM_PAPI_EVENTS; i++) {
                                 PAPI_event_code_to_name(CkpvAccess(papiEvents)[i], nameBuf);
                                 CkPrintf("%s is %lf(x1e6), ", nameBuf, results[i]/CkNumPes());
                         }
                         CkPrintf("per processor\n");
                 }               
 #endif
         }
         delete msg;     
         state->controller->resumeAfterPapiMeasureBarrier(curMFlopStep);
 #endif
 }

void Node::resumeAfterTraceBarrier ( CkReductionMsg * msg )

Definition at line 1420 of file Node.C.

References curTimeStep, Controller::resumeAfterTraceBarrier(), and state.

                                                      {
         CmiAssert(CmiMyPe()==0);
         delete msg;     
         state->controller->resumeAfterTraceBarrier(curTimeStep);
 }

void Node::run ( void )

Definition at line 1105 of file Node.C.

References ResizeArrayIter< Type >::begin(), DebugM, ResizeArrayIter< Type >::end(), endi(), PatchMap::homePatchList(), iINFO(), iout, memusage_MB(), PatchMap::Object(), NamdState::runController(), HomePatch::runSequencer(), and state.

Referenced by messageRun().

 {
   // Start Controller (aka scalar Sequencer) on Pe(0)
 //  printf("\n\n I am in Node.C in run method about to call  state->runController\n\n");
   if ( ! CkMyPe() ) {
     state->runController();
   }
 
   DebugM(4, "Starting Sequencers\n");
   // Run Sequencer on each HomePatch - i.e. start simulation
   HomePatchList *hpl = PatchMap::Object()->homePatchList();
   ResizeArrayIter<HomePatchElem> ai(*hpl);
   for (ai=ai.begin(); ai != ai.end(); ai++) {
     HomePatch *patch = (*ai).patch;
 //CkPrintf("Proc#%d in Node calling Sequencer ",CkMyPe());
     patch->runSequencer();
   }
 
   if (!CkMyPe()) {
     double newTime = CmiWallTimer();
     iout << iINFO << "Startup phase " << startupPhase-1 << " took "
          << newTime - startupTime << " s, "
          << memusage_MB() << " MB of memory in use\n";
     iout << iINFO << "Finished startup at " << newTime << " s, "
          << memusage_MB() << " MB of memory in use\n\n" << endi;
     fflush(stdout);
   }
   
 }

void Node::saveMolDataPointers ( NamdState * state )

Definition at line 1381 of file Node.C.

References configList, molecule, parameters, pdb, simParameters, and state.

 {
   this->molecule = state->molecule;
   this->parameters = state->parameters;
   this->simParameters = state->simParameters;
   this->configList = state->configList;
   this->pdb = state->pdb;
   this->state = state;
 }

void Node::scriptBarrier ( void )

Definition at line 1144 of file Node.C.

                          {
   //script->awaken();
 }

void Node::scriptParam ( ScriptParamMsg * msg )

Definition at line 1148 of file Node.C.

References ScriptParamMsg::param, SimParameters::scriptSet(), simParameters, and ScriptParamMsg::value.

                                           {
   simParameters->scriptSet(msg->param,msg->value);
   delete msg;
 }

void Node::sendCheckpointReq	(	int	remote,
		const char *	key,
		int	task,
		Lattice &	lat,
		ControllerState &	cs
	)

Definition at line 1280 of file Node.C.

References CheckpointMsg::checkpoint, CheckpointMsg::key, Controller::checkpoint::lattice, CheckpointMsg::replica, Controller::checkpoint::state, and CheckpointMsg::task.

Referenced by Controller::algorithm().

                                                                                                      {
   CheckpointMsg *msg = new (1+strlen(key),0) CheckpointMsg;
   msg->replica = CmiMyPartition();
   msg->task = task;
   msg->checkpoint.lattice = lat;
   msg->checkpoint.state = cs;
   strcpy(msg->key,key);
   envelope *env = UsrToEnv(CheckpointMsg::pack(msg));
   CmiSetHandler(env,recvCheckpointCReq_index);
 #if CMK_HAS_PARTITION
   CmiInterSyncSendAndFree(CkMyPe(),remote,env->getTotalsize(),(char*)env);
 #else
   CmiSyncSendAndFree(CkMyPe(),env->getTotalsize(),(char*)env);
 #endif
 }

void Node::sendEnableEarlyExit ( void )

Definition at line 1356 of file Node.C.

Referenced by enableEarlyExit().

                                    {
   CProxy_Node nodeProxy(thisgroup);
   nodeProxy[0].recvEnableEarlyExit();
 }

void Node::sendEnableExitScheduler ( void )

Definition at line 1332 of file Node.C.

Referenced by enableExitScheduler().

                                        {
   //CmiPrintf("sendEnableExitScheduler\n");
   CProxy_Node nodeProxy(thisgroup);
   nodeProxy[0].recvEnableExitScheduler();
 }

void Node::setScript ( ScriptTcl * s )

inline

Definition at line 191 of file Node.h.

Referenced by after_backend_init().

191 { script = s; }

void Node::startHPM ( )

Definition at line 1392 of file Node.C.

                     {
 #if USE_HPM
   HPM_Start("500 steps", localRankOnNode);
 #endif
 }

void Node::startup ( )

Definition at line 429 of file Node.C.

References Lattice::a_p(), AtomMap::allocateMap(), WorkDistrib::assignNodeToPatch(), Lattice::b_p(), SimParameters::bondedCUDA, ProxyMgr::buildProxySpanningTree(), Lattice::c_p(), computeMap, computeMgr, ComputeMgr::createComputes(), WorkDistrib::createHomePatches(), LdbCoordinator::createLoadBalancer(), ProxyMgr::createProxies(), DebugM, WorkDistrib::distributeHomePatches(), endi(), BackEnd::exit(), PDB::get_extremes(), ProxyMgr::getRecvSpanning(), ProxyMgr::getSendSpanning(), iINFO(), LdbCoordinator::initialize(), iout, SimParameters::isRecvSpanningTreeOn(), SimParameters::isSendSpanningTreeOn(), SimParameters::lattice, SimParameters::mallocTest, mallocTest_size, WorkDistrib::mapComputes(), memusage_MB(), messageRun(), molecule, SimParameters::MSMOn, SimParameters::MsmSerialOn, NAMD_bug(), NAMD_EVENT_START_EX, NAMD_EVENT_STOP, NamdProfileEventStr, node_molecule, node_parameters, node_simParameters, SimParameters::nonbonded_select(), Molecule::numAtoms, ComputeMap::numComputes(), numPatches, PatchMap::Object(), AtomMap::Object(), Sync::Object(), ComputeMap::Object(), LdbCoordinator::Object(), ProxyMgr::Object(), Sync::openSync(), output, outputPatchComputeMaps(), parameters, WorkDistrib::patchMapInit(), pdb, SimParameters::pme_select(), SimParameters::PMEOn, proxyRecvSpanning, proxySendSpanning, SimParameters::proxyTreeBranchFactor, rand, SimParameters::randomSeed, registerUserEventsForAllComputeObjs(), WorkDistrib::sendComputeMap(), WorkDistrib::sendPatchMap(), WorkDistrib::setPatchMapArrived(), ProxyMgr::setProxyTreeBranchFactor(), ProxyMgr::setRecvSpanning(), ProxyMgr::setSendSpanning(), simParameters, SimParameters::simulatedNodeSize, SimParameters::simulatedPEs, SimParameters::simulateInitialMapping, MsmInitMsg::smax, MsmInitMsg::smin, Random::split(), SimParameters::useCkLoop, SimParameters::useCUDA2, SimParameters::usePMECUDA, and workDistrib.

Referenced by messageStartUp().

                    {
   int gotoRun = false;
   double newTime;
 
   if (!CkMyPe()) {
 #if defined(NAMD_NVTX_ENABLED) || defined(NAMD_CMK_TRACE_ENABLED) || defined(NAMD_ROCTX_ENABLED)
       char buf[32];
       sprintf(buf, "%s: %d", NamdProfileEventStr[NamdProfileEvent::NAMD_STARTUP], startupPhase);
       NAMD_EVENT_START_EX(1, NamdProfileEvent::NAMD_STARTUP, buf);
 #endif
     if (!startupPhase) {
       iout << iINFO << "\n";
       startupTime = CmiWallTimer();
       iout << iINFO << "Entering startup at " << startupTime << " s, ";
     } else {
       newTime = CmiWallTimer();
       iout << iINFO << "Startup phase " << startupPhase-1 << " took "
            << newTime - startupTime << " s, ";
       startupTime = newTime;
     }
     iout << memusage_MB() << " MB of memory in use\n" << endi;
     fflush(stdout);
   }
   switch (startupPhase) {
 
   case 0:
     computeMap = ComputeMap::Object();
     namdOneCommInit(); // Namd1.X style
   break;
 
   case 1:
       bindBocVars();
 
     // send & receive molecule, simparameters... (Namd1.X style)
     if (CkMyPe()) {
       namdOneRecv();
     } else {
       namdOneSend();
     }
   break;
 
   case 2:
     // fix up one-per-node objects (for SMP version)
     simParameters = node_simParameters;
     parameters = node_parameters;
     molecule = node_molecule;
 
     SimParameters::nonbonded_select();
     if ( simParameters->PMEOn ) SimParameters::pme_select();   
  
     #if !CMK_SMP || ! USE_CKLOOP
     //the CkLoop library should be only used in SMP mode
     simParameters->useCkLoop = 0;
     #else
     if ( CkNumPes() < 2 * CkNumNodes() ) simParameters->useCkLoop = 0;
     #endif
 
 
     if ( simParameters->mallocTest ) {
       if (!CkMyPe()) {
         mallocTest_size = 0;
         CkStartQD(CkIndex_Node::mallocTestQd(), &thishandle);
       }
       return;
     }
 
       
         #ifdef MEASURE_NAMD_WITH_PAPI
         if(simParameters->papiMeasure) namdInitPapiCounters();  
         #endif
     
     #ifdef MEM_OPT_VERSION
     //At this point, each Node object has received the simParameters,
     //parameters and the atom signatures info from the master Node
     //(proc 0). It's time to initialize the parallel IO manager and
     //read the binary per-atom file --Chao Mei
 
     //Step 1: initialize the parallel IO manager per Node
     ioMgr->initialize(this);
     #endif
 
   break;
 
   case 3:
 
     #ifdef MEM_OPT_VERSION
     //Step 2: read the binary per-atom files (signater index, coordinates etc.)
     ioMgr->readPerAtomInfo();
     #endif
 
   break;
 
   case 4:
 
     #ifdef MEM_OPT_VERSION
     //Step 3: update counters of tuples and exclusions inside Molecule object
     ioMgr->updateMolInfo();
 
     //Step 4: prepare distributing the atoms to neighboring procs if necessary
     ioMgr->migrateAtomsMGrp();
 
     //step 5: initialize patchMap and send it to every other processors
     //to decide atoms to patch distribution on every input processor
     if(!CkMyPe()) {
         workDistrib->patchMapInit(); // create space division
         workDistrib->sendPatchMap();
     }
     #endif
 
     #if USE_HPM
     HPM_Init(localRankOnNode);
     #endif    
 
     // take care of inital thread setting
     threadInit();
 
     // create blank AtomMap
     AtomMap::Object()->allocateMap(molecule->numAtoms);
 
     if (!CkMyPe()) {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
       if (simParameters->usePMECUDA) {
         // computePmeCUDAMgr was created in BackEnd.C
         // This empty branch is to avoid initializing ComputePmeMgr
       } else
 #endif
       if (simParameters->PMEOn) {
         CkpvAccess(BOCclass_group).computePmeMgr = CProxy_ComputePmeMgr::ckNew();
       }
         #ifdef OPENATOM_VERSION
         if ( simParameters->openatomOn ) { 
           CkpvAccess(BOCclass_group).computeMoaMgr = CProxy_ComputeMoaMgr::ckNew();
         }
         #endif // OPENATOM_VERSION
 
     }
     
     #ifdef OPENATOM_VERSION
     if ( simParameters->openatomOn ) {
       // if ( ! CkMyPe() ) { 
         CkCallback doneMoaStart(CkIndexmain::doneMoaSetup(), thishandle); 
         startOA(simParameters->moaDriverFile, simParameters->moaPhysicsFile, doneMoaStart);
       // }
     }
     #endif // OPENATOM_VERSION
   
     // BEGIN LA
     rand = new Random(simParameters->randomSeed);
     rand->split(CkMyPe(), CkNumPes());
     // END LA
 
   break;
 
   case 5:
     #ifdef MEM_OPT_VERSION
     //Now, every input proc has received all the atoms necessary
     //to decide the patches those atoms belong to
     
     //step 1: integrate the migrated atoms into the atom list that
     //contains the initally distributed atoms, and sort the atoms
     //based on hydrogenList value
     ioMgr->integrateMigratedAtoms();
 
     //step 2: integrate the cluster size of each atom on each output proc
     ioMgr->integrateClusterSize();
 
     //step 3: calculate the number of atoms in each patch on every
     //input procs (atoms belonging to a patch may lie on different
     //procs), and reduce such info on proc 0. Such info is required
     //for determing which node a particular patch is assigned to.
     ioMgr->calcAtomsInEachPatch();
 
     //set to false to re-send PatchMap later
     workDistrib->setPatchMapArrived(false);
     #endif
     break;
   case 6:     
     if(simParameters->isSendSpanningTreeOn()) {                         
                         ProxyMgr::Object()->setSendSpanning();
     }
     if(simParameters->isRecvSpanningTreeOn()) {                         
                         ProxyMgr::Object()->setRecvSpanning();
     }
     if(simParameters->proxyTreeBranchFactor) {
                         ProxyMgr::Object()->setProxyTreeBranchFactor(simParameters->proxyTreeBranchFactor);
     }
     #ifdef PROCTRACE_DEBUG
     DebugFileTrace::Instance("procTrace");
     #endif
 
     if (!CkMyPe()) {
       output = new Output; // create output object just on PE(0)
 
       #ifndef MEM_OPT_VERSION
       workDistrib->patchMapInit(); // create space division
       workDistrib->createHomePatches(); // load atoms into HomePatch(es)
       #endif
       
       workDistrib->assignNodeToPatch();
       workDistrib->mapComputes();         
       //ComputeMap::Object()->printComputeMap();
 
       // For MIC runs, take the additional step after the compute map has been created to
       //   assign the various computes to either the host or the device.  This info will
       //   be distributed across the PEs.
       #if defined(NAMD_MIC)
         mic_initHostDeviceLDB();
       #endif
           
           if(simParameters->simulateInitialMapping) {
           iout << iINFO << "Simulating initial mapping with " << simParameters->simulatedPEs
                           << " PEs with " << simParameters->simulatedNodeSize << " PEs per node\n" << endi;
                   outputPatchComputeMaps("init_mapping", 0);
                   iout << iINFO << "Simulating initial mapping is done, now NAMD exits\n" << endi;
                   BackEnd::exit();
           }
 
       registerUserEventsForAllComputeObjs();
 
       //in MEM_OPT_VERSION, patchMap is resent
       //because they have been updated since creation including
       //#atoms per patch, the proc a patch should stay etc. --Chao Mei
       workDistrib->sendPatchMap();
       #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
       CProxy_NodeProxyMgr npm(CkpvAccess(BOCclass_group).nodeProxyMgr);
       //a node broadcast
       npm.createProxyInfo(PatchMap::Object()->numPatches());
       #endif
     }
     {
         #if defined(NODEAWARE_PROXY_SPANNINGTREE) && defined(USE_NODEPATCHMGR)
         CProxy_NodeProxyMgr npm(CkpvAccess(BOCclass_group).nodeProxyMgr);
         if(CkMyRank()==0) {
             //just need to register once
             npm[CkMyNode()].ckLocalBranch()->registerLocalProxyMgr(CkpvAccess(BOCclass_group).proxyMgr);
         }
         npm[CkMyNode()].ckLocalBranch()->registerLocalPatchMap(CkMyRank(), PatchMap::Object());
         #endif
     }
   break;
 
   case 7:
 #ifdef CHARM_HAS_MSA
     if ( simParameters->MSMOn && ! simParameters->MsmSerialOn ) {
       CProxy_ComputeMsmMsaMgr msm(CkpvAccess(BOCclass_group).computeMsmMsaMgr);
       msm[CkMyPe()].initialize(new CkQdMsg);
     }
 #else
     if ( simParameters->MSMOn && ! simParameters->MsmSerialOn ) {
       CProxy_ComputeMsmMgr msm(CkpvAccess(BOCclass_group).computeMsmMgr);
       MsmInitMsg *msg = new MsmInitMsg;
       Lattice lattice = simParameters->lattice;  // system lattice vectors
       ScaledPosition smin=0, smax=0;
       if (lattice.a_p() && lattice.b_p() && lattice.c_p()) {
         msg->smin = smin;
         msg->smax = smax;
         msm[CkMyPe()].initialize(msg);  // call from my own PE
       }
       else if ( ! CkMyPe() ) {
         pdb->get_extremes(smin, smax);  // only available on PE 0
         msg->smin = smin;
         msg->smax = smax;
         msm.initialize(msg);  // broadcast to chare group
       }
 
       /*
       CProxy_Node nd(CkpvAccess(BOCclass_group).node);
       Node *node = nd.ckLocalBranch();
       ScaledPosition smin, smax;
       node->pdb->get_extremes(smin, smax);
       msg->smin = smin;                       // extreme positions in system
       msg->smax = smax;
       msm[CkMyPe()].initialize(msg);
       */
     }
 #endif
 
     if ( simParameters->PMEOn ) {
       #ifdef OPENATOM_VERSION
       if ( simParameters->openatomOn ) { 
         CProxy_ComputeMoaMgr moa(CkpvAccess(BOCclass_group).computeMoaMgr); 
         moa[CkMyPe()].initialize(new CkQdMsg);
       }
       #endif // OPENATOM_VERSION
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
       if ( simParameters->usePMECUDA ) {
         if(CkMyRank()==0) {
           CProxy_ComputePmeCUDAMgr pme(CkpvAccess(BOCclass_group).computePmeCUDAMgr);
           pme.ckLocalBranch()->initialize(new CkQdMsg);  // must run on pe 0 to call ckNew
         }
       } else 
 #endif
       {
         CProxy_ComputePmeMgr pme(CkpvAccess(BOCclass_group).computePmeMgr);
         pme[CkMyPe()].initialize(new CkQdMsg);          
       }
     }
     break;
 
   case 8:
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     if ( (simParameters->useCUDA2 || simParameters->bondedCUDA) && CkMyRank()==0 ) {
       CProxy_ComputeCUDAMgr nb(CkpvAccess(BOCclass_group).computeCUDAMgr);
       nb.ckLocalBranch()->initialize(new CkQdMsg);
     }
 #endif
     break;
 
   case 9:
     workDistrib->sendComputeMap();
     break;
 
   case 10:
     #ifdef MEM_OPT_VERSION
     //migrate atoms to HomePatch processors
     ioMgr->sendAtomsToHomePatchProcs();
     #endif
     break;
     
   case 11:
     // part 2 of MSM init
     if ( simParameters->MSMOn && ! simParameters->MsmSerialOn ) {
       CProxy_ComputeMsmMgr msm(CkpvAccess(BOCclass_group).computeMsmMgr);
       msm[CkMyPe()].initialize_create();  // call from my own PE
     }
 
     if ( simParameters->PMEOn ) {
       #ifdef OPENATOM_VERSION
       if ( simParameters->openatomOn ) { 
         CProxy_ComputeMoaMgr moa(CkpvAccess(BOCclass_group).computeMoaMgr); 
         moa[CkMyPe()].initWorkers(new CkQdMsg);
       }
       #endif // OPENATOM_VERSION
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
       if ( simParameters->usePMECUDA ) {
         if(CkMyRank()==0) {
           CProxy_ComputePmeCUDAMgr pme(CkpvAccess(BOCclass_group).computePmeCUDAMgr);
           pme[CkMyNode()].initialize_pencils(new CkQdMsg);
         }
       } else
 #endif
       {
         CProxy_ComputePmeMgr pme(CkpvAccess(BOCclass_group).computePmeMgr);
         pme[CkMyPe()].initialize_pencils(new CkQdMsg);          
       }
     }
 #ifdef CHARM_HAS_MSA
     else if ( simParameters->MSMOn && ! simParameters->MsmSerialOn ) {
       CProxy_ComputeMsmMsaMgr msm(CkpvAccess(BOCclass_group).computeMsmMsaMgr);
       msm[CkMyPe()].initWorkers(new CkQdMsg);
     }
 #else
     else if ( simParameters->MSMOn && ! simParameters->MsmSerialOn ) {
       CProxy_ComputeMsmMgr msm(CkpvAccess(BOCclass_group).computeMsmMgr);
       msm[CkMyPe()].update(new CkQdMsg);
     }
 #endif
 
     #ifdef MEM_OPT_VERSION
     //Now every processor has all the atoms it needs to create the HomePatches.
     //The HomePatches are created in parallel on every home patch procs.
     ioMgr->createHomePatches();
     #else
     if (!CkMyPe()) {
       workDistrib->distributeHomePatches();          
     }
     #endif
   break;
 
   case 12:
     if ( simParameters->PMEOn ) {
       #ifdef OPENATOM_VERSION
       if ( simParameters->openatomOn ) { 
         CProxy_ComputeMoaMgr moa(CkpvAccess(BOCclass_group).computeMoaMgr); 
         moa[CkMyPe()].startWorkers(new CkQdMsg);
       }
       #endif // OPENATOM_VERSION
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
       if ( simParameters->usePMECUDA ) {
         if(CkMyRank()==0) {
           CProxy_ComputePmeCUDAMgr pme(CkpvAccess(BOCclass_group).computePmeCUDAMgr);
           pme[CkMyNode()].activate_pencils(new CkQdMsg);
         }
       } else
 #endif
       {
         CProxy_ComputePmeMgr pme(CkpvAccess(BOCclass_group).computePmeMgr);
         pme[CkMyPe()].activate_pencils(new CkQdMsg);          
       }
     }
 #ifdef CHARM_HAS_MSA
     else if ( simParameters->MSMOn && ! simParameters->MsmSerialOn ) {
       CProxy_ComputeMsmMsaMgr msm(CkpvAccess(BOCclass_group).computeMsmMsaMgr);
       msm[CkMyPe()].startWorkers(new CkQdMsg);
     }
 #else
     /*
     else if ( simParameters->MSMOn && ! simParameters->MsmSerialOn ) {
       CProxy_ComputeMsmMgr msm(CkpvAccess(BOCclass_group).computeMsmMgr);
       //msm[CkMyPe()].startWorkers(new CkQdMsg);
     }
     */
 #endif
 
     proxyMgr->createProxies();  // need Home patches before this
     if (!CkMyPe()) LdbCoordinator::Object()->createLoadBalancer();
 
 #ifdef NAMD_TCL
     // TclInitSubsystems() has a race condition so we create one interp per node here
     if (CkMyPe() && CkMyNodeSize() > 1 && ! CkMyRank()) Tcl_DeleteInterp(Tcl_CreateInterp());
 #endif
 
 #ifdef USE_NODEPATCHMGR
         //at this point, PatchMap info has been recved on PEs. It is time to create
         //the home patch spanning tree for receiving proxy list info
         if(proxyMgr->getSendSpanning() || proxyMgr->getRecvSpanning()) {
                 if(CkMyRank()==0) {
                         CProxy_NodeProxyMgr npm(CkpvAccess(BOCclass_group).nodeProxyMgr);
                         npm[CkMyNode()].ckLocalBranch()->createSTForHomePatches(PatchMap::Object());
                 }
         }
 #endif
 
   break;
 
   case 13:
 
     // DMK - DEBUG - If, in MIC runs, the debug option to dump all the compute maps to files
     //   for debugging/verification purposes has been enabled, have each PE do so now.
     #if defined(NAMD_MIC)
       mic_dumpHostDeviceComputeMap();
     #endif
 
     if (!CkMyPe()) {
       iout << iINFO << "CREATING " << ComputeMap::Object()->numComputes()
            << " COMPUTE OBJECTS\n" << endi;
     }
     DebugM(4,"Creating Computes\n");
     computeMgr->createComputes(ComputeMap::Object());
     DebugM(4,"Building Sequencers\n");
     buildSequencers();
     DebugM(4,"Initializing LDB\n");
     LdbCoordinator::Object()->initialize(PatchMap::Object(),ComputeMap::Object());
   break;
 
   case 14:
     // computes may create proxies on the fly so put these in separate phase
     Sync::Object()->openSync();  // decide if to open local Sync 
     if (proxySendSpanning || proxyRecvSpanning ) proxyMgr->buildProxySpanningTree();
 #if defined(CMK_BALANCED_INJECTION_API) && CMK_BALANCED_INJECTION_API != 0
     if(CkMyRank() == 0){
       // CkPrintf("[%d] get retrieved BI=%d\n",CkMyPe(),balancedInjectionLevel);
       ck_set_GNI_BIConfig(balancedInjectionLevel);
       // CkPrintf("[%d] set retrieved BI=%d\n",CkMyPe(),ck_get_GNI_BIConfig());
     }
 #endif
 
   break;
 
   case 15:
     {
         //For debugging
         /*if(!CkMyPe()){
         FILE *dumpFile = fopen("/tmp/NAMD_Bench.dump", "w");
         dumpbench(dumpFile);
         NAMD_die("Normal execution\n");
         }*/
     }
     #ifdef MEM_OPT_VERSION
     //free space in the Molecule object that are not used anymore
     ioMgr->freeMolSpace();
     #endif
     gotoRun = true;
   break;
 
   default:
     NAMD_bug("Startup Phase has a bug - check case statement");
   break;
 
   }
 
   startupPhase++;
   if (!CkMyPe()) {
 #if defined(NAMD_NVTX_ENABLED) || defined(NAMD_CMK_TRACE_ENABLED) || defined(NAMD_ROCTX_ENABLED)
     NAMD_EVENT_STOP(1, NamdProfileEvent::NAMD_STARTUP);
 #endif
     if (!gotoRun) {
       CkStartQD(CkCallback(CkIndex_Node::startup(), thisgroup));
     } else {
       Node::messageRun();
     }
   }
 }

void Node::stopHPM ( )

Definition at line 1398 of file Node.C.

                    {
 #if USE_HPM
   HPM_Stop("500 steps", localRankOnNode);
   HPM_Print(CkMyPe(), localRankOnNode);
 #endif
 }

void Node::traceBarrier	(	int	turnOnTrace,
		int	step
	)

Definition at line 1405 of file Node.C.

References curTimeStep.

                                                 {
         curTimeStep = step;
         if(turnOnTrace) traceBegin();
         else traceEnd();
 
     if(turnOnTrace) CmiTurnOnStats();
     else CmiTurnOffStats();
 
         //CkPrintf("traceBarrier (%d) at step %d called on proc %d\n", turnOnTrace, step, CkMyPe());    
         CProxy_Node nd(CkpvAccess(BOCclass_group).node);
         CkCallback cb(CkIndex_Node::resumeAfterTraceBarrier(NULL), nd[0]);
         contribute(0, NULL, CkReduction::sum_int, cb);
         
 }

void Node::updateGridScale	(	const char *	key,
		Vector	scale
	)

Definition at line 1204 of file Node.C.

References DebugM, MGridforceParamsList::find_key(), Molecule::get_gridfrc_grid(), MGridforceParamsList::index_for_key(), SimParameters::mgridforcelist, MGRIDFORCEPARAMS_DEFAULTKEY, molecule, NAMD_bug(), NAMD_die(), simParameters, Vector::x, Vector::y, and Vector::z.

                                                         {
     DebugM(4, "updateGridScale(char*, Vector) called on node " << CkMyPe() << "\n" << endi);
     
     int gridnum;
     MGridforceParams* mgridParams;
     if (key == NULL) {
         gridnum = simParameters->mgridforcelist.index_for_key(MGRIDFORCEPARAMS_DEFAULTKEY);
         mgridParams = simParameters->mgridforcelist.find_key(MGRIDFORCEPARAMS_DEFAULTKEY);
     } else {
         gridnum = simParameters->mgridforcelist.index_for_key(key);
         mgridParams = simParameters->mgridforcelist.find_key(key);
     }
 
     if (gridnum < 0 || mgridParams == NULL) {
         NAMD_die("Node::updateGridScale(char*, Vector): Could not find grid.");
     }
     
     GridforceGrid* grid = molecule->get_gridfrc_grid(gridnum);
     if (grid == NULL) {
         NAMD_bug("Node::updateGridScale(char*, Vector): grid not found");
     }
     CProxy_Node(thisgroup).updateGridScale(gridnum, scale.x, scale.y, scale.z);
     
     DebugM(4, "updateGridScale(char*, Vector) finished\n" << endi);
 }

void Node::updateGridScale	(	int	gridnum,
		float	sx,
		float	sy,
		float	sz
	)

Definition at line 1229 of file Node.C.

References MGridforceParamsList::at_index(), DebugM, Molecule::get_gridfrc_grid(), MGridforceParams::gridforceScale, SimParameters::mgridforcelist, molecule, NAMD_bug(), GridforceGrid::set_scale(), and simParameters.

                                                                     {
     if (CmiMyRank()) return;
     DebugM(4, "updateGridScale(char*, int, float, float, float) called on node " << CkMyPe() << "\n" << endi);
        
     GridforceGrid *grid = molecule->get_gridfrc_grid(gridnum);
     if (grid == NULL) {
         NAMD_bug("Node::updateGridScale(char*, int, float, float, float):grid not found");
     }
     
     Vector scale(sx,sy,sz);
     simParameters->mgridforcelist.at_index(gridnum)->gridforceScale = scale;
     grid->set_scale( scale );
 
     DebugM(4, "updateGridScale(char*, int, float, float, float) finished\n" << endi);
 }