#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)

ScriptTcl *	getScript ()

int	myid ()

int	numNodes ()

void	setScript (ScriptTcl *s)

Static Public Member Functions
static Node *	Object ()

static Node *	ObjectOnPe (int pe)

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::Node ( GroupInitMsg * msg )

Definition at line 298 of file Node.C.

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

 {    
   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::~Node ( void )

Definition at line 363 of file Node.C.

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

 {
   delete imd;
   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

◆ awaitBOCCheckIn()

void Node::awaitBOCCheckIn ( )

◆ BOCCheckIn()

void Node::BOCCheckIn ( )

◆ earlyExit()

void Node::earlyExit ( void )

Definition at line 1412 of file Node.C.

References NAMD_die().

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

◆ enableEarlyExit()

void Node::enableEarlyExit ( void )

Definition at line 1404 of file Node.C.

References sendEnableEarlyExit().

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

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

◆ enableExitScheduler()

void Node::enableExitScheduler ( void )

Definition at line 1382 of file Node.C.

References sendEnableExitScheduler().

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

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

◆ enableScriptBarrier()

void Node::enableScriptBarrier ( )

Definition at line 1154 of file Node.C.

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

◆ exitScheduler()

void Node::exitScheduler ( void )

Definition at line 1390 of file Node.C.

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

◆ getScript()

ScriptTcl * Node::getScript ( void )

Definition at line 1599 of file Node.C.

References PatchData::script.

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

                                { 
 #ifndef NODEGROUP_FORCE_REGISTER
   return script; 
 #else
   if(script == NULL){
     CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
     PatchData* patchData = cpdata.ckLocalBranch();
     return patchData->script;
   }else{
     return script;
   }
 #endif
 } 

◆ mallocTest()

void Node::mallocTest ( int step )

Definition at line 400 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));
 }

◆ mallocTestQd()

void Node::mallocTestQd ( void )

Definition at line 412 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);
 }

◆ measureMemory()

float Node::measureMemory ( )

◆ messageBOCCheckIn()

static void Node::messageBOCCheckIn ( )

static

◆ messageRun()

void Node::messageRun ( )

static

Definition at line 1107 of file Node.C.

References run().

Referenced by startup().

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

◆ messageStartUp()

void Node::messageStartUp ( )

static

Definition at line 427 of file Node.C.

References startup().

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

◆ myid()

int Node::myid ( )

inline

Definition at line 191 of file Node.h.

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

191 { return CkMyPe(); }

◆ numNodes()

int Node::numNodes ( )

inline

Definition at line 192 of file Node.h.

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

192 { return CkNumPes(); }

◆ Object()

static Node* Node::Object ( )

inlinestatic

Definition at line 86 of file Node.h.

86 {return CkpvAccess(Node_instance);}

◆ ObjectOnPe()

static Node* Node::ObjectOnPe ( int pe )

inlinestatic

Definition at line 87 of file Node.h.

87 {return CkpvAccessOther(Node_instance, CmiRankOf(pe));}

◆ outputPatchComputeMaps()

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

Definition at line 1560 of file Node.C.

References Patch::getNumAtoms(), gNAMDBinaryName, PatchMap::gridsize_a(), PatchMap::gridsize_b(), PatchMap::gridsize_c(), NAMD_die(), ComputeMap::node(), PatchMap::node(), ComputeMap::numComputes(), PatchMap::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));             
         }
 }

◆ papiMeasureBarrier()

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

Definition at line 1465 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
 }

◆ recvCheckpointAck()

void Node::recvCheckpointAck ( CheckpointMsg * msg )

Definition at line 1365 of file Node.C.

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

Referenced by recvCheckpointCAck_handler().

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

◆ recvCheckpointReq()

void Node::recvCheckpointReq ( CheckpointMsg * msg )

Definition at line 1343 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
 }

◆ recvEnableEarlyExit()

void Node::recvEnableEarlyExit ( void )

Definition at line 1400 of file Node.C.

References enableEarlyExit().

                                {
   enableEarlyExit();
 }

◆ recvEnableExitScheduler()

void Node::recvEnableExitScheduler ( void )

Definition at line 1377 of file Node.C.

References enableExitScheduler().

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

◆ reloadCharges() [1/2]

void Node::reloadCharges ( const char * filename )

Definition at line 1167 of file Node.C.

References 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);
 #ifdef NODEGROUP_FORCE_REGISTER
   if(CkMyPe()==0)
     {
       CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
       cpdata.setDeviceKernelUpdateCounter();
     }
 #endif
   delete [] charge;
 }

◆ reloadCharges() [2/2]

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

Definition at line 1191 of file Node.C.

References molecule, and Molecule::reloadCharges().

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

◆ reloadGridforceGrid() [1/2]

void Node::reloadGridforceGrid ( const char * key )

Definition at line 1197 of file Node.C.

References DebugM, endi(), 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);
 #ifdef NODEGROUP_FORCE_REGISTER
   if(CkMyPe()==0)
     {
       CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
       cpdata.setDeviceKernelUpdateCounter();
     }
 #endif
     DebugM(4, "reloadGridforceGrid(const char*) finished\n" << endi);
 }

◆ reloadGridforceGrid() [2/2]

void Node::reloadGridforceGrid ( int gridnum )

Definition at line 1278 of file Node.C.

References ALLBUTME, BUFSIZE, DebugM, MOStream::end(), endi(), 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;
     }
 #ifdef NODEGROUP_FORCE_REGISTER
   if(CkMyPe()==0)
     {
       CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
       cpdata.setDeviceKernelUpdateCounter();
     }
 #endif
     DebugM(4, "reloadGridforceGrid(int) finished\n" << endi);
 }

◆ reloadStructure()

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

Definition at line 1011 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();
 }

◆ resendMolecule()

void Node::resendMolecule ( )

Definition at line 1024 of file Node.C.

References ALLBUTME, BUFSIZE, molecule, MOLECULETAG, node_molecule, node_parameters, SimParameters::nonbonded_select(), Molecule::numAtoms, parameters, SimParameters::pme_select(), SimParameters::PMEOn, Molecule::receive_Molecule(), Parameters::receive_Parameters(), Molecule::send_Molecule(), Parameters::send_Parameters(), 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();
   CProxy_Node nodeProxy(thisgroup);
   for ( int i=0; i<CmiMyNodeSize(); ++i ) {
     nodeProxy[CmiMyPe()+i].resendMolecule2();
   }
 }

◆ resendMolecule2()

void Node::resendMolecule2 ( )

Definition at line 1057 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);
 }

◆ resumeAfterPapiMeasureBarrier()

void Node::resumeAfterPapiMeasureBarrier ( CkReductionMsg * msg )

Definition at line 1517 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
 }

◆ resumeAfterTraceBarrier()

void Node::resumeAfterTraceBarrier ( CkReductionMsg * msg )

Definition at line 1459 of file Node.C.

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

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

◆ run()

void Node::run ( void )

Definition at line 1116 of file Node.C.

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

Referenced by messageRun().

 {
 //  NAMD_EVENT_START(1, NamdProfileEvent::NODE_RUN);
 
   // 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);
   }
   
 //  NAMD_EVENT_STOP(1, NamdProfileEvent::NODE_RUN);
 }

◆ saveMolDataPointers()

void Node::saveMolDataPointers ( NamdState * state )

Definition at line 1420 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;
 }

◆ scriptBarrier()

void Node::scriptBarrier ( void )

Definition at line 1158 of file Node.C.

                          {
   //script->awaken();
 }

◆ scriptParam()

void Node::scriptParam ( ScriptParamMsg * msg )

Definition at line 1162 of file Node.C.

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

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

◆ sendCheckpointReq()

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

Definition at line 1319 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
 }

◆ sendEnableEarlyExit()

void Node::sendEnableEarlyExit ( void )

Definition at line 1395 of file Node.C.

Referenced by enableEarlyExit().

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

◆ sendEnableExitScheduler()

void Node::sendEnableExitScheduler ( void )

Definition at line 1371 of file Node.C.

Referenced by enableExitScheduler().

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

◆ setScript()

void Node::setScript ( ScriptTcl * s )

inline

Definition at line 194 of file Node.h.

Referenced by after_backend_init().

194 { script = s; }

◆ startHPM()

void Node::startHPM ( )

Definition at line 1431 of file Node.C.

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

◆ startup()

void Node::startup ( )

Definition at line 437 of file Node.C.

References Lattice::a_p(), AtomMap::allocateMap(), WorkDistrib::assignNodeToPatch(), Lattice::b_p(), 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, NAMD_EVENT_STOP, node_molecule, node_parameters, node_simParameters, SimParameters::nonbonded_select(), Molecule::numAtoms, ComputeMap::numComputes(), 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(), startupTime, SimParameters::useCkLoop, SimParameters::usePMECUDA, and workDistrib.

Referenced by messageStartUp().

                    {
   NAMD_EVENT_START(1, NamdProfileEvent::NAMD_STARTUP);
 
   int gotoRun = false;
   double newTime;
 
   if (!CkMyPe()) {
     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 ( 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 (!gotoRun) {
       CkStartQD(CkCallback(CkIndex_Node::startup(), thisgroup));
     } else {
       Node::messageRun();
     }
   }
 
   NAMD_EVENT_STOP(1, NamdProfileEvent::NAMD_STARTUP);
 }

◆ stopHPM()

void Node::stopHPM ( )

Definition at line 1437 of file Node.C.

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

◆ traceBarrier()

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

Definition at line 1444 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);
         
 }

◆ updateGridScale() [1/2]

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

Definition at line 1231 of file Node.C.

References DebugM, endi(), 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);
 }

◆ updateGridScale() [2/2]

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

Definition at line 1256 of file Node.C.

References MGridforceParamsList::at_index(), DebugM, endi(), 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 );
 #ifdef NODEGROUP_FORCE_REGISTER
   if(CkMyPe()==0)
     {
       CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
       cpdata.setDeviceKernelUpdateCounter();
     }
 #endif
     DebugM(4, "updateGridScale(char*, int, float, float, float) finished\n" << endi);
 }

Member Data Documentation

◆ atomMap

AtomMap* Node::atomMap

protected

Definition at line 202 of file Node.h.

Referenced by Node(), and ~Node().

◆ colvars

colvarmodule* Node::colvars

Definition at line 187 of file Node.h.

Referenced by colvarproxy_namd::colvarproxy_namd(), and Node().

◆ computeMap

ComputeMap* Node::computeMap

protected

Definition at line 204 of file Node.h.

Referenced by startup(), and ~Node().

◆ computeMgr

ComputeMgr* Node::computeMgr

Definition at line 172 of file Node.h.

Referenced by Sequencer::integrate(), Sequencer::integrate_SOA(), Sequencer::minimize(), and startup().

◆ configList

ConfigList* Node::configList

Definition at line 182 of file Node.h.

Referenced by colvarproxy_namd::colvarproxy_namd(), WorkDistrib::createAtomLists(), GlobalMasterSymmetry::GlobalMasterSymmetry(), Node(), ComputeQMMgr::recvPntChrg(), and saveMolDataPointers().

◆ coords

Vector* Node::coords

Definition at line 188 of file Node.h.

Referenced by ScriptTcl::measure(), Tcl_centerOfMass(), Tcl_centerOfNumber(), Tcl_loadCoords(), and Tcl_radiusOfGyration().

◆ curMFlopStep

int Node::curMFlopStep

Definition at line 157 of file Node.h.

Referenced by papiMeasureBarrier(), and resumeAfterPapiMeasureBarrier().

◆ curTimeStep

int Node::curTimeStep

Definition at line 152 of file Node.h.

Referenced by resumeAfterTraceBarrier(), and traceBarrier().

◆ imd

IMDOutput* Node::imd

Definition at line 186 of file Node.h.

Referenced by Output::coordinate(), GlobalMasterIMD::get_vmd_forces(), GlobalMasterIMD::GlobalMasterIMD(), Node(), Controller::printEnergies(), and ~Node().

◆ initRSS

float Node::initRSS

Definition at line 136 of file Node.h.

◆ initVM

float Node::initVM

Definition at line 136 of file Node.h.

◆ ldbCoordinator

LdbCoordinator* Node::ldbCoordinator

protected

Definition at line 205 of file Node.h.

◆ mallocTest_size

int Node::mallocTest_size

Definition at line 130 of file Node.h.

Referenced by mallocTestQd(), and startup().

◆ molecule

Molecule* Node::molecule

Definition at line 179 of file Node.h.

◆ output

Output* Node::output

Definition at line 185 of file Node.h.

Referenced by SimParameters::close_dcdfile(), SimParameters::close_veldcdfile(), CollectionMaster::disposeForces(), CollectionMaster::disposePositions(), CollectionMaster::disposeVelocities(), Node(), recvReplicaDcdData(), recvReplicaDcdInit(), startup(), and ~Node().

◆ parameters

Parameters* Node::parameters

Definition at line 180 of file Node.h.

Referenced by ComputeNonbondedPair::ComputeNonbondedPair(), ComputeNonbondedSelf::ComputeNonbondedSelf(), ComputeLjPmeSerialMgr::getLJparameters(), LJTable::LJTable(), ComputeHomeTuples< TholeElem, Thole, TholeValue >::loadTuples(), Node(), ComputeLjPmeSerialMgr::recvCoord(), resendMolecule(), resendMolecule2(), saveMolDataPointers(), ComputeNonbondedUtil::select(), and startup().

◆ patchMap

PatchMap* Node::patchMap

protected

Definition at line 203 of file Node.h.

Referenced by Node(), and ~Node().

◆ pdb

PDB* Node::pdb

Definition at line 183 of file Node.h.

Referenced by WorkDistrib::createAtomLists(), Node(), WorkDistrib::patchMapInit(), reloadStructure(), saveMolDataPointers(), and startup().

◆ rand

Random* Node::rand

Definition at line 175 of file Node.h.

Referenced by ComputeNonbondedPair::ComputeNonbondedPair(), ComputeNonbondedSelf::ComputeNonbondedSelf(), startup(), and ~Node().

◆ simParameters

SimParameters* Node::simParameters

Definition at line 181 of file Node.h.

◆ specialTracing

bool Node::specialTracing

Definition at line 166 of file Node.h.

Referenced by Node().

◆ state

NamdState* Node::state

Definition at line 184 of file Node.h.

Referenced by Node(), recvCheckpointAck(), recvCheckpointReq(), reloadStructure(), resumeAfterPapiMeasureBarrier(), resumeAfterTraceBarrier(), run(), saveMolDataPointers(), and colvarproxy_namd::update_accelMD_info().

◆ workDistrib

WorkDistrib* Node::workDistrib

Definition at line 169 of file Node.h.

Referenced by ParallelIOMgr::createHomePatches(), and startup().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Node()

◆ ~Node()

Member Function Documentation

◆ awaitBOCCheckIn()

◆ BOCCheckIn()

◆ earlyExit()

◆ enableEarlyExit()

◆ enableExitScheduler()

◆ enableScriptBarrier()

◆ exitScheduler()

◆ getScript()

◆ mallocTest()

◆ mallocTestQd()

◆ measureMemory()

◆ messageBOCCheckIn()

◆ messageRun()

◆ messageStartUp()

◆ myid()

◆ numNodes()

◆ Object()

◆ ObjectOnPe()

◆ outputPatchComputeMaps()

◆ papiMeasureBarrier()

◆ recvCheckpointAck()

◆ recvCheckpointReq()

◆ recvEnableEarlyExit()

◆ recvEnableExitScheduler()

◆ reloadCharges() [1/2]

◆ reloadCharges() [2/2]

◆ reloadGridforceGrid() [1/2]

◆ reloadGridforceGrid() [2/2]

◆ reloadStructure()

◆ resendMolecule()

◆ resendMolecule2()

◆ resumeAfterPapiMeasureBarrier()

◆ resumeAfterTraceBarrier()

◆ run()

◆ saveMolDataPointers()

◆ scriptBarrier()

◆ scriptParam()

◆ sendCheckpointReq()

◆ sendEnableEarlyExit()

◆ sendEnableExitScheduler()

◆ setScript()

◆ startHPM()

◆ startup()

◆ stopHPM()

◆ traceBarrier()

◆ updateGridScale() [1/2]

◆ updateGridScale() [2/2]

Member Data Documentation

◆ atomMap

◆ colvars

◆ computeMap

◆ computeMgr

◆ configList

◆ coords

◆ curMFlopStep

◆ curTimeStep

◆ imd

◆ initRSS

◆ initVM

◆ ldbCoordinator

◆ mallocTest_size

◆ molecule

◆ output

◆ parameters

◆ patchMap

◆ pdb

◆ rand

◆ simParameters

◆ specialTracing

◆ state

◆ workDistrib