Node Class Reference

#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 301 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 366 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 1469 of file Node.C.

References NAMD_die().

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

enableEarlyExit()

void Node::enableEarlyExit

(

void

)

Definition at line 1461 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 1439 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 1211 of file Node.C.

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

exitScheduler()

void Node::exitScheduler

(

void

)

Definition at line 1447 of file Node.C.

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

getScript()

ScriptTcl * Node::getScript

(

void

)

Definition at line 1656 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 403 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 415 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 1164 of file Node.C.

References run().

Referenced by startup().

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

messageStartUp()

void Node::messageStartUp ( )

static

Definition at line 430 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().

{ return CkMyPe(); }

numNodes()

int Node::numNodes ( )

inline

Definition at line 192 of file Node.h.

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

{ return CkNumPes(); }

Object()

static Node* Node::Object ( )

inlinestatic

Definition at line 86 of file Node.h.

Referenced by HomePatch::addForceToMomentum(), HomePatch::addForceToMomentum3(), Sequencer::addMovDragToPosition(), Sequencer::addRotDragToPosition(), HomePatch::addVelocityToPosition(), after_backend_init(), Controller::algorithm(), CollectionMaster::CollectVectorInstanceDcdSelection::append(), WorkDistrib::assignNodeToPatch(), BackEnd::awaken(), PmeZPencil::backward_fft(), PmeYPencil::backward_fft(), PmeXPencil::backward_fft(), LdbCoordinator::barrier(), HomePatch::boxClosed(), HomePatch::buildRattleList(), HomePatch::buildRattleList_SOA(), ComputeQMMgr::calcMOPAC(), ComputeQMMgr::calcORCA(), Controller::calcPressure(), colvarproxy_namd::calculate(), ComputeQMMgr::calcUSR(), ComputePmeMgr::chargeGridSubmitted(), colvarproxy_namd::check_atom_id(), colvarproxy_namd::check_volmap_by_id(), ComputeGridForce::checkGridForceRatio(), CudaPmeOneDevice::checkPatchLevelLatticeCompatibilityAndComputeOffsets(), SimParameters::close_dcdfile(), SimParameters::close_veldcdfile(), colvarproxy_namd::colvarproxy_namd(), Controller::compareChecksums(), CudaPmeOneDevice::compute(), colvarproxy_namd::compute_volmap(), ComputeCylindricalBC::ComputeCylindricalBC(), ComputeEwald::ComputeEwald(), OneFourNbTholeElem::computeForce(), AngleElem::computeForce(), ImproperElem::computeForce(), CrosstermElem::computeForce(), DihedralElem::computeForce(), TholeElem::computeForce(), AnisoElem::computeForce(), BondElem::computeForce(), ExclElem::computeForce(), GromacsPairElem::computeForce(), ComputeFullDirect::ComputeFullDirect(), ComputeGlobal::ComputeGlobal(), ComputeHomeTuples< TholeElem, Thole, TholeValue >::ComputeHomeTuples(), ComputeLCPO::ComputeLCPO(), LjPmeCompute::computeLJpotential(), ComputeMsm::ComputeMsm(), LjPmeCompute::computeNonbonded(), ComputeNonbondedPair::ComputeNonbondedPair(), ComputeNonbondedSelf::ComputeNonbondedSelf(), ComputePme::ComputePme(), ComputeRestraints::ComputeRestraints(), ComputeSphericalBC::ComputeSphericalBC(), ComputeStir::ComputeStir(), ComputeTclBC::ComputeTclBC(), Controller::Controller(), Output::coordinate(), Output::coordinateNeeded(), ComputeMgr::createComputes(), ComputeCUDAMgr::createCudaComputeNonbonded(), ComputeCUDAMgr::createCudaGlobalMaster(), ComputeCUDAMgr::createCudaPmeOneDevice(), ComputeGridForce::createGridForcedIdxList(), ParallelIOMgr::createHomePatches(), LdbCoordinator::createLoadBalancer(), CudaComputeNonbonded::CudaComputeNonbonded(), CudaPmeOneDevice::CudaPmeOneDevice(), HomePatch::depositMigration(), CollectionMaster::disposeForces(), CollectionMaster::disposePositions(), CollectionMaster::disposeVelocities(), ComputeConsForce::doForce(), ComputeEField::doForce(), ComputeConsTorque::doForce(), ComputeStir::doForce(), ComputeNonbondedPair::doForce(), ComputeNonbondedSelf::doForce(), ComputeGridForce::doForce(), ComputeRestraints::doForce(), HomePatch::doGroupSizeCheck(), HomePatch::doGroupSizeCheck_SOA(), HomePatch::doMarginCheck(), HomePatch::doMarginCheck_SOA(), HomePatch::doPairlistCheck(), ComputePme::doQMWork(), ComputeTclBC::doWork(), ComputeGBISser::doWork(), ComputeGlobal::doWork(), CudaComputeNonbonded::doWork(), ComputeHomeTuples< TholeElem, Thole, TholeValue >::doWork(), dumpbench(), HomePatch::exchangeAtoms(), HomePatch::exchangeCheckpoint(), CudaPmeOneDevice::finishReduction(), Output::force(), Patch::forceBoxClosed(), Output::forceNeeded(), PmeZPencil::forward_fft(), PmeYPencil::forward_fft(), PmeXPencil::forward_fft(), ComputePmeCUDADevice::gatherForce(), ComputePmeCUDADevice::gatherForceDone(), HomePatch::gbisComputeAfterP1(), HomePatch::gbisComputeAfterP2(), GlobalMasterIMD::get_vmd_forces(), GlobalMaster::getCurrentReduction(), CudaComputeNonbonded::getCurrentReduction(), ComputeLjPmeSerialMgr::getLJparameters(), Controller::getTotalPotentialEnergy(), GlobalMaster::GlobalMaster(), GlobalMasterEasy::GlobalMasterEasy(), GlobalMasterFreeEnergy::GlobalMasterFreeEnergy(), GlobalMasterIMD::GlobalMasterIMD(), GlobalMasterServer::GlobalMasterServer(), GlobalMasterSymmetry::GlobalMasterSymmetry(), GlobalMasterTMD::GlobalMasterTMD(), ComputePmeMgr::gridCalc2R(), Sequencer::hardWallDrude(), HomePatch::hardWallDrude(), colvarproxy_namd::init_atom_group(), colvarproxy_namd::init_atoms_map(), colvarproxy_namd::init_tcl_pointers(), colvarproxy_namd::init_volmap_by_name(), ComputeCUDAMgr::initialize(), ComputePmeCUDA::initialize(), LjPmeCompute::initialize(), LdbCoordinator::initialize(), ComputeQM::initialize(), CudaComputeNonbonded::initialize(), ComputeMsmMgr::initialize(), ComputePmeMgr::initialize(), ComputePmeCUDADevice::initialize(), ComputePmeMgr::initialize_computes(), ComputePmeMgr::initialize_pencils(), Controller::integrate(), Sequencer::integrate(), Sequencer::integrate_SOA(), isPmeProcessor(), Sequencer::langevinPiston(), Sequencer::langevinVelocities(), Sequencer::langevinVelocitiesBBK1(), Sequencer::langevinVelocitiesBBK2(), CudaComputeNonbonded::launchWork(), LJTable::LJTable(), ComputeHomeTuples< TholeElem, Thole, TholeValue >::loadTuples(), HomePatch::loweAndersenVelocities(), WorkDistrib::mapComputes(), Sequencer::maximumMove(), Sequencer::maximumMove_SOA(), ScriptTcl::measure(), ComputePmeCUDADevice::mergeForcesOnPatch(), Sequencer::minimize(), HomePatch::minimize_rattle2(), HomePatch::mollyAverage(), HomePatch::mollyMollify(), Controller::monteCarloPressure_accept(), Controller::multigatorCalcEnthalpy(), NAMD_bug(), NAMD_die(), NAMD_err(), NAMD_quit(), NamdHybridLB::NamdHybridLB(), CudaComputeNonbonded::openBoxesOnPe(), PmePencil< CBase_PmeZPencil >::order_init(), Patch::Patch(), PatchDataSOA_set_buffer(), PatchDataSOA_set_size(), WorkDistrib::patchMapInit(), Compute::patchReady(), PmeXPencil::pme_kspace(), Patch::positionsReady(), HomePatch::positionsReady(), HomePatch::positionsReady_SOA(), Controller::printEnergies(), Controller::printMinimizeEnergies(), HomePatch::qmSwapAtoms(), Sequencer::rattle1(), HomePatch::rattle1(), Sequencer::rattle1_SOA(), HomePatch::rattle1_SOA(), HomePatch::rattle1old(), HomePatch::rattle2(), ParallelIOMgr::readInfoForParOutDcdSelection(), LdbCoordinator::rebalance(), Controller::rebalanceLoad(), ProxyPatch::receiveAll(), ProxyPatch::receiveData(), CollectionMaster::receiveDataStream(), CollectionMaster::receiveForces(), CollectionMaster::receivePositions(), CollectionMaster::receivePositionsDcdSelection(), Controller::receivePressure(), CollectionMaster::receiveVelocities(), recursive_bisect_with_curve(), ComputePmeCUDADevice::recvAtoms(), ParallelIOMgr::recvAtomsCntPerPatch(), ComputePmeCUDADevice::recvAtomsFromNeighbor(), recvCheckpointCAck_handler(), recvCheckpointCReq_handler(), HomePatch::recvCheckpointLoad(), ComputeMgr::recvComputeConsForceMsg(), ComputeMsmSerialMgr::recvCoord(), ComputeExtMgr::recvCoord(), ComputeLjPmeSerialMgr::recvCoord(), ComputeFmmSerialMgr::recvCoord(), ComputeGBISserMgr::recvCoord(), ComputeMgr::recvCudaGlobalMasterCreateMsg(), ComputeMgr::recvCudaGlobalMasterRemoveMsg(), ComputeMgr::recvCudaGlobalMasterUpdateMsg(), ParallelIOMgr::recvDcdParams(), HomePatch::recvExchangeMsg(), ComputeQMMgr::recvPartQM(), ComputeQMMgr::recvPntChrg(), recvReplicaDcdData(), recvReplicaDcdInit(), ComputeGlobal::recvResults(), Sequencer::reloadCharges(), Controller::rescaleaccelMD(), Sequencer::rescaleSoluteCharges(), CudaComputeNonbonded::reSortTileLists(), HomePatch::revert(), ScriptTcl::run(), ComputeQM::saveResults(), ComputeGlobal::saveTotalForces(), ComputePmeUtil::select(), ComputeNonbondedUtil::select(), PmeZPencil::send_all_ungrid(), GlobalMasterIMD::send_energies(), GlobalMasterIMD::send_fcoords(), PmeZPencil::send_trans(), PmeYPencil::send_trans(), PmeYPencil::send_untrans(), PmeXPencil::send_untrans(), ComputePmeCUDADevice::sendAtomsToNeighbor(), ComputeMgr::sendComputeGlobalData(), ComputeMgr::sendComputeGlobalResults(), ParallelIOMgr::sendDcdParams(), ComputePmeCUDADevice::sendForcesToNeighbors(), ComputePmeMgr::sendTrans(), ComputePmeMgr::sendUngrid(), ComputePmeMgr::sendUntrans(), HomePatch::setGBISIntrinsicRadii(), PatchMgr::setLattice(), HomePatch::setLcpoType(), ComputeLjPmeSerialMgr::setLJparameters(), ComputePmeCUDAMgr::setupPencils(), SimpleBroadcastObject< Tensor >::SimpleBroadcastObject(), NamdHybridLB::splitComputes(), ComputePmeCUDADevice::spreadCharge(), CollectionMaster::startNextRoundOutputForce(), CollectionMaster::startNextRoundOutputPos(), CollectionMaster::startNextRoundOutputVel(), NamdCentLB::Strategy(), CollectionMgr::submitForces(), CollectionMgr::submitPositions(), PmePencilXYZ::submitReductions(), PmePencilZ::submitReductions(), ComputePmeMgr::submitReductions(), CollectionMgr::submitVelocities(), Tcl_centerOfMass(), Tcl_centerOfNumber(), Tcl_loadCoords(), Tcl_radiusOfGyration(), Sequencer::tcoupleVelocities(), ComputePme::ungridForces(), colvarproxy_namd::update_atom_properties(), colvarproxy_namd::update_atoms_map(), colvarproxy_namd::update_group_properties(), ComputeLonepairsCUDA::updateAtoms(), ComputeMgr::updateLocalComputes4(), Output::velocity(), Output::velocityNeeded(), ReductionMgr::willRequire(), ReductionMgr::willSubmit(), wrap_coor_int(), wrap_coor_int_dcd_selection(), and CollectionMaster::wrapCoorFinished().

{return CkpvAccess(Node_instance);}

ObjectOnPe()

static Node* Node::ObjectOnPe ( int  pe )

inlinestatic

Definition at line 87 of file Node.h.

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

outputPatchComputeMaps()

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

Definition at line 1617 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 1522 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 1422 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 1400 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 1457 of file Node.C.

References enableEarlyExit().

                               {
  enableEarlyExit();
}

recvEnableExitScheduler()

void Node::recvEnableExitScheduler

(

void

)

Definition at line 1434 of file Node.C.

References enableExitScheduler().

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

reloadCharges() [1/2]

void Node::reloadCharges

(

const char *

filename

)

Definition at line 1224 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 1248 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 1254 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 1335 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 1068 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 1081 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 1114 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 1574 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 1516 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 1173 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 1477 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 1215 of file Node.C.

                         {
  //script->awaken();
}

scriptParam()

void Node::scriptParam

(

ScriptParamMsg *

msg

)

Definition at line 1219 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 1376 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 1452 of file Node.C.

Referenced by enableEarlyExit().

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

sendEnableExitScheduler()

void Node::sendEnableExitScheduler

(

void

)

Definition at line 1428 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().

{ script = s; }

startHPM()

void Node::startHPM

(

)

Definition at line 1488 of file Node.C.

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

startup()

void Node::startup

(

)

Definition at line 462 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(), SimParameters::CUDASOAintegrate, SimParameters::dcdSelectionOn, DebugM, WorkDistrib::distributeHomePatches(), endi(), BackEnd::exit(), PDB::get_extremes(), ProxyMgr::getRecvSpanning(), ProxyMgr::getSendSpanning(), iINFO(), SynchronousCollectives::initAllScope(), LdbCoordinator::initialize(), initializeGPUResident(), 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(), SynchronousCollectives::Object(), ComputeMap::Object(), LdbCoordinator::Object(), ProxyMgr::Object(), Sync::openSync(), output, outputPatchComputeMaps(), parameters, WorkDistrib::patchMapInit(), pdb, SimParameters::pme_select(), SimParameters::PMEOn, PRIORITY_SIZE, proxyRecvSpanning, proxySendSpanning, SimParameters::proxyTreeBranchFactor, rand, SimParameters::randomSeed, registerUserEventsForAllComputeObjs(), WorkDistrib::sendComputeMap(), WorkDistrib::sendPatchMap(), SEQ_STK_SZ, 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();
    if(simParameters->dcdSelectionOn)
      if(!CkMyPe())
        ioMgr->sendDcdParams();
    #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:
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
    // Initialize the collective synchronization object before the sequencers are created
    if (simParameters->CUDASOAintegrate) {
      SynchronousCollectives* syncColl = SynchronousCollectives::Object();
      syncColl->initAllScope();
      // Sync between all PEs so that expectedBarrierAll and currentBarrierAll are set
    }
#endif
  break;

  case 14:
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
    if (simParameters->CUDASOAintegrate) {
      gpuResInitThread  = CthCreate((CthVoidFn) &(initializeGPUResident), nullptr, SEQ_STK_SZ);
      gpuResInitThreadPriority = 0;
      CthSetStrategyDefault(gpuResInitThread);
      CthAwakenPrio(gpuResInitThread, CK_QUEUEING_IFIFO, PRIORITY_SIZE, &gpuResInitThreadPriority);
      CthSuspend();
    }
#endif
  break;

  case 15:
    // Make sure that the GPU resident initialization threads have finished
  break;

  case 16:

    // 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 17:
    // 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 18:
    {
        //For debugging
        /*if(!CkMyPe()){
        FILE *dumpFile = fopen("/tmp/NAMD_Bench.dump", "w");
        dumpbench(dumpFile);
        NAMD_die("Normal execution\n");
        }*/
    }
    #ifdef MEM_OPT_VERSION
    if(simParameters->dcdSelectionOn)
      ioMgr->readInfoForParOutDcdSelection();
    //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 1494 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 1501 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 1288 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 1313 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(), Output::force(), GlobalMasterIMD::get_vmd_forces(), GlobalMasterIMD::GlobalMasterIMD(), Node(), Controller::printEnergies(), Output::velocity(), 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.

Referenced by Sequencer::addMovDragToPosition(), Sequencer::addRotDragToPosition(), CollectionMaster::CollectVectorInstanceDcdSelection::append(), WorkDistrib::assignNodeToPatch(), ComputeQMMgr::calcMOPAC(), ComputeQMMgr::calcORCA(), colvarproxy_namd::calculate(), ComputeQMMgr::calcUSR(), colvarproxy_namd::check_atom_id(), colvarproxy_namd::check_volmap_by_id(), ComputeGridForce::checkGridForceRatio(), SimParameters::close_dcdfile(), Controller::compareChecksums(), colvarproxy_namd::compute_volmap(), AngleElem::computeForce(), CrosstermElem::computeForce(), DihedralElem::computeForce(), ImproperElem::computeForce(), TholeElem::computeForce(), AnisoElem::computeForce(), BondElem::computeForce(), LjPmeCompute::computeNonbonded(), Controller::Controller(), Output::coordinate(), Output::coordinateNeeded(), WorkDistrib::createAtomLists(), ComputeMgr::createComputes(), ComputeGridForce::createGridForcedIdxList(), CudaPmeOneDevice::CudaPmeOneDevice(), ComputeConsForce::doForce(), ComputeConsTorque::doForce(), ComputeStir::doForce(), ComputeGridForce::doForce(), ComputeRestraints::doForce(), ComputePme::doQMWork(), dumpbench(), ComputeLjPmeSerialMgr::getLJparameters(), Controller::getTotalPotentialEnergy(), GlobalMasterEasy::GlobalMasterEasy(), GlobalMasterFreeEnergy::GlobalMasterFreeEnergy(), GlobalMasterSymmetry::GlobalMasterSymmetry(), GlobalMasterTMD::GlobalMasterTMD(), HomePatch::hardWallDrude(), colvarproxy_namd::init_atom_group(), colvarproxy_namd::init_atoms_map(), colvarproxy_namd::init_volmap_by_name(), ComputeQM::initialize(), ParallelIOMgr::initialize(), Sequencer::integrate_SOA(), Sequencer::langevinPiston(), Sequencer::langevinVelocities(), Sequencer::langevinVelocitiesBBK1(), Sequencer::langevinVelocitiesBBK2(), LJTable::LJTable(), ComputeHomeTuples< TholeElem, Thole, TholeValue >::loadTuples(), HomePatch::loweAndersenVelocities(), HomePatch::minimize_rattle2(), HomePatch::mollyAverage(), HomePatch::mollyMollify(), Controller::monteCarloPressure_accept(), Controller::multigatorCalcEnthalpy(), Node(), WorkDistrib::patchMapInit(), Controller::printEnergies(), Controller::printMinimizeEnergies(), HomePatch::qmSwapAtoms(), HomePatch::rattle1old(), HomePatch::rattle2(), ParallelIOMgr::readInfoForParOutDcdSelection(), Controller::receivePressure(), ComputeMgr::recvComputeConsForceMsg(), ComputeMsmSerialMgr::recvCoord(), ComputeExtMgr::recvCoord(), ComputeLjPmeSerialMgr::recvCoord(), ComputeFmmSerialMgr::recvCoord(), ComputeGBISserMgr::recvCoord(), ParallelIOMgr::recvDcdParams(), ComputeQMMgr::recvPartQM(), reloadCharges(), Sequencer::reloadCharges(), reloadGridforceGrid(), reloadStructure(), Controller::rescaleaccelMD(), Sequencer::rescaleSoluteCharges(), resendMolecule(), resendMolecule2(), saveMolDataPointers(), ComputeQM::saveResults(), ComputeNonbondedUtil::select(), ParallelIOMgr::sendDcdParams(), HomePatch::setGBISIntrinsicRadii(), HomePatch::setLcpoType(), startup(), Tcl_centerOfMass(), Tcl_centerOfNumber(), Tcl_loadCoords(), Tcl_radiusOfGyration(), Sequencer::tcoupleVelocities(), colvarproxy_namd::update_atom_properties(), colvarproxy_namd::update_atoms_map(), colvarproxy_namd::update_group_properties(), ComputeLonepairsCUDA::updateAtoms(), updateGridScale(), wrap_coor_int(), and wrap_coor_int_dcd_selection().

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.

Referenced by HomePatch::addForceToMomentum(), HomePatch::addForceToMomentum3(), HomePatch::addVelocityToPosition(), WorkDistrib::assignNodeToPatch(), PmeZPencil::backward_fft(), PmeYPencil::backward_fft(), PmeXPencil::backward_fft(), LdbCoordinator::barrier(), HomePatch::boxClosed(), HomePatch::buildRattleList(), HomePatch::buildRattleList_SOA(), ComputePmeMgr::chargeGridSubmitted(), CudaPmeOneDevice::checkPatchLevelLatticeCompatibilityAndComputeOffsets(), colvarproxy_namd::colvarproxy_namd(), CudaPmeOneDevice::compute(), ComputeCylindricalBC::ComputeCylindricalBC(), ComputeEwald::ComputeEwald(), OneFourNbTholeElem::computeForce(), AngleElem::computeForce(), ImproperElem::computeForce(), DihedralElem::computeForce(), CrosstermElem::computeForce(), AnisoElem::computeForce(), TholeElem::computeForce(), BondElem::computeForce(), ExclElem::computeForce(), GromacsPairElem::computeForce(), ComputeFullDirect::ComputeFullDirect(), ComputeGlobal::ComputeGlobal(), ComputeHomeTuples< TholeElem, Thole, TholeValue >::ComputeHomeTuples(), ComputeLCPO::ComputeLCPO(), LjPmeCompute::computeLJpotential(), ComputeMsm::ComputeMsm(), ComputeNonbondedPair::ComputeNonbondedPair(), ComputeNonbondedSelf::ComputeNonbondedSelf(), ComputePme::ComputePme(), ComputeRestraints::ComputeRestraints(), ComputeSphericalBC::ComputeSphericalBC(), ComputeStir::ComputeStir(), ComputeTclBC::ComputeTclBC(), Output::coordinate(), Output::coordinateNeeded(), WorkDistrib::createAtomLists(), ComputeMgr::createComputes(), ComputeCUDAMgr::createCudaComputeNonbonded(), ComputeCUDAMgr::createCudaGlobalMaster(), ComputeCUDAMgr::createCudaPmeOneDevice(), LdbCoordinator::createLoadBalancer(), CudaComputeNonbonded::CudaComputeNonbonded(), CudaPmeOneDevice::CudaPmeOneDevice(), HomePatch::depositMigration(), CollectionMaster::disposePositions(), ComputeConsForce::doForce(), ComputeEField::doForce(), ComputeConsTorque::doForce(), ComputeStir::doForce(), ComputeNonbondedPair::doForce(), ComputeNonbondedSelf::doForce(), ComputeGridForce::doForce(), ComputeRestraints::doForce(), HomePatch::doGroupSizeCheck(), HomePatch::doGroupSizeCheck_SOA(), HomePatch::doMarginCheck(), HomePatch::doMarginCheck_SOA(), HomePatch::doPairlistCheck(), ComputeTclBC::doWork(), ComputeGBISser::doWork(), ComputeGlobal::doWork(), CudaComputeNonbonded::doWork(), dumpbench(), HomePatch::exchangeAtoms(), HomePatch::exchangeCheckpoint(), PmeZPencil::fft_init(), PmeYPencil::fft_init(), PmeXPencil::fft_init(), CudaPmeOneDevice::finishReduction(), Output::force(), Output::forceNeeded(), PmeZPencil::forward_fft(), PmeYPencil::forward_fft(), PmeXPencil::forward_fft(), ComputePmeCUDADevice::gatherForce(), ComputePmeCUDADevice::gatherForceDone(), HomePatch::gbisComputeAfterP1(), HomePatch::gbisComputeAfterP2(), GlobalMasterIMD::get_vmd_forces(), GlobalMaster::getCurrentReduction(), CudaComputeNonbonded::getCurrentReduction(), ComputeLjPmeSerialMgr::getLJparameters(), GlobalMaster::GlobalMaster(), GlobalMasterFreeEnergy::GlobalMasterFreeEnergy(), GlobalMasterIMD::GlobalMasterIMD(), GlobalMasterServer::GlobalMasterServer(), GlobalMasterSymmetry::GlobalMasterSymmetry(), GlobalMasterTMD::GlobalMasterTMD(), HomePatch::hardWallDrude(), ComputeCUDAMgr::initialize(), ComputePmeCUDA::initialize(), LjPmeCompute::initialize(), LdbCoordinator::initialize(), ComputeQM::initialize(), CudaComputeNonbonded::initialize(), ParallelIOMgr::initialize(), ComputeMsmMgr::initialize(), ComputePmeMgr::initialize(), ComputePmeCUDADevice::initialize(), ComputePmeMgr::initialize_computes(), ComputePmeMgr::initialize_pencils(), isPmeProcessor(), CudaComputeNonbonded::launchWork(), LJTable::LJTable(), ComputeHomeTuples< TholeElem, Thole, TholeValue >::loadTuples(), HomePatch::loweAndersenVelocities(), WorkDistrib::mapComputes(), ComputePmeCUDADevice::mergeForcesOnPatch(), HomePatch::minimize_rattle2(), HomePatch::mollyAverage(), HomePatch::mollyMollify(), Controller::multigatorCalcEnthalpy(), NamdHybridLB::NamdHybridLB(), Node(), PmePencil< CBase_PmeZPencil >::order_init(), outputPatchComputeMaps(), Patch::Patch(), PatchDataSOA_set_buffer(), PatchDataSOA_set_size(), WorkDistrib::patchMapInit(), Compute::patchReady(), Patch::positionsReady(), HomePatch::positionsReady(), HomePatch::positionsReady_SOA(), HomePatch::qmSwapAtoms(), HomePatch::rattle1(), HomePatch::rattle1_SOA(), HomePatch::rattle1old(), HomePatch::rattle2(), ProxyPatch::receiveAll(), ProxyPatch::receiveData(), CollectionMaster::receiveDataStream(), recursive_bisect_with_curve(), ComputePmeCUDADevice::recvAtoms(), ComputePmeCUDADevice::recvAtomsFromNeighbor(), HomePatch::recvCheckpointLoad(), ComputeExtMgr::recvCoord(), ComputeMsmSerialMgr::recvCoord(), ComputeLjPmeSerialMgr::recvCoord(), ComputeFmmSerialMgr::recvCoord(), ComputeMgr::recvCudaGlobalMasterCreateMsg(), ComputeMgr::recvCudaGlobalMasterRemoveMsg(), ComputeMgr::recvCudaGlobalMasterUpdateMsg(), HomePatch::recvExchangeMsg(), ComputeQMMgr::recvPartQM(), ComputeGlobal::recvResults(), reloadGridforceGrid(), resendMolecule(), CudaComputeNonbonded::reSortTileLists(), resumeAfterPapiMeasureBarrier(), HomePatch::revert(), ScriptTcl::run(), saveMolDataPointers(), WorkDistrib::savePatchMap(), ComputeGlobal::saveTotalForces(), scriptParam(), ComputePmeUtil::select(), ComputeNonbondedUtil::select(), PmeZPencil::send_all_ungrid(), GlobalMasterIMD::send_energies(), GlobalMasterIMD::send_fcoords(), PmeZPencil::send_trans(), PmeYPencil::send_trans(), PmeYPencil::send_untrans(), PmeXPencil::send_untrans(), ComputePmeCUDADevice::sendAtomsToNeighbor(), ComputeMgr::sendComputeGlobalData(), ComputeMgr::sendComputeGlobalResults(), ComputePmeCUDADevice::sendForcesToNeighbors(), WorkDistrib::sendPatchMap(), ComputePmeMgr::sendTrans(), ComputePmeMgr::sendUngrid(), ComputePmeMgr::sendUntrans(), HomePatch::setGBISIntrinsicRadii(), PatchMgr::setLattice(), ComputeLjPmeSerialMgr::setLJparameters(), ComputePmeCUDAMgr::setupPencils(), SimpleBroadcastObject< Tensor >::SimpleBroadcastObject(), NamdHybridLB::splitComputes(), ComputePmeCUDADevice::spreadCharge(), startup(), NamdCentLB::Strategy(), CollectionMgr::submitForces(), CollectionMgr::submitPositions(), PmePencilXYZ::submitReductions(), PmePencilZ::submitReductions(), ComputePmeMgr::submitReductions(), CollectionMgr::submitVelocities(), ComputePme::ungridForces(), updateGridScale(), ComputeMgr::updateLocalComputes4(), Output::velocity(), Output::velocityNeeded(), ReductionMgr::willRequire(), ReductionMgr::willSubmit(), wrap_coor_int(), and wrap_coor_int_dcd_selection().

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 colvarproxy_namd::calculate(), Node(), recvCheckpointAck(), recvCheckpointReq(), reloadStructure(), resumeAfterPapiMeasureBarrier(), resumeAfterTraceBarrier(), run(), and saveMolDataPointers().

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:

• Node.h
• Node.C