LdbCoordinator Class Reference

#include <LdbCoordinator.h>

List of all members.

Public Member Functions

 LdbCoordinator ()
 ~LdbCoordinator (void)
void initialize (PatchMap *pmap, ComputeMap *cmap, int reinit=0)
void createLoadBalancer ()
void patchLoad (PatchID id, int nAtoms, int timestep)
void startWork (const LDObjHandle &handle)
void pauseWork (const LDObjHandle &handle)
void skipWork (const LDObjHandle &handle)
void endWork (const LDObjHandle &handle)
void rebalance (Sequencer *seq, PatchID id)
void rebalance (Controller *seq)
void nodeDone (CkReductionMsg *)
void updateComputesReady ()
void barrier (void)
void resume (void)
void resumeReady (CkQdMsg *msg)
void resume2 (void)
int getNumStepsToRun (void)
void AtSyncBarrierReached (void)
void Migrate (LDObjHandle handle, int dest)
void RecvMigrate (LdbMigrateMsg *)
void ExpectMigrate (LdbMigrateMsg *)
void ResumeFromSync (void)
void ExecuteMigrations (void)
void awakenSequencers (void)
int requiredProxies (PatchID id, int[])
void printRequiredProxies (PatchID id, FILE *fp)
void printLocalLdbReport (void)
void sendCollectLoads (CollectLoadsMsg *)
void collectLoads (CollectLoadsMsg *)

Static Public Member Functions

static LdbCoordinatorObject ()
static void staticMigrateFn (LDObjHandle handle, int dest)
static void staticStatsFn (LDOMHandle h, int state)
static void staticQueryEstLoadFn (LDOMHandle h)
static void staticReceiveAtSync (void *data)
static void staticResumeFromSync (void *data)

Public Attributes

int stepsPerLdbCycle
int nLocalComputes
int nLocalPatches
int nPatchesReported
int nPatchesExpected
int nComputesReported
int nComputesExpected
int controllerReported
int controllerExpected
int nStatsMessagesReceived
int nStatsMessagesExpected
ComputeMapcomputeMap
PatchMappatchMap
int * patchNAtoms
int nPatches
ControllercontrollerThread
Sequencer ** sequencerThreads
int ldbCycleNum
int numStepsToRun
int firstLdbStep
int totalStepsDone
int takingLdbData
FILE * ldbStatsFP
computeInfocomputeArray
patchInfopatchArray
processorInfoprocessorArray
LdbInfratheLbdb
LDBarrierClient ldBarrierHandle
LDOMid myOMid
LDOMHandle myHandle
LdbMigrateMsgmigrateMsgs
int numComputes
int nRegisteredObjs
int reg_all_objs
LDObjHandle * patchHandles

Detailed Description

Definition at line 88 of file LdbCoordinator.h.


Constructor & Destructor Documentation

LdbCoordinator::LdbCoordinator (  ) 

Definition at line 118 of file LdbCoordinator.C.

References AtSyncBarrierReached(), computeArray, ldBarrierHandle, ldbCycleNum, ldbStatsFP, migrateMsgs, myHandle, myOMid, NAMD_bug(), nLocalComputes, nLocalPatches, numComputes, Object(), patchArray, patchNAtoms, processorArray, reg_all_objs, ResumeFromSync(), sequencerThreads, staticMigrateFn(), staticQueryEstLoadFn(), staticReceiveAtSync(), staticResumeFromSync(), staticStatsFn(), takingLdbData, theLbdb, and totalStepsDone.

00119 {
00120   if (CkpvAccess(LdbCoordinator_instance) == NULL) {
00121     CkpvAccess(LdbCoordinator_instance) = this;
00122   } else {
00123     NAMD_bug("LdbCoordinator instanced twice on same node!");
00124   }
00125   
00126   collPes = 0;
00127   ldbCycleNum = 1;
00128   takingLdbData = 1;
00129   totalStepsDone = 0;
00130   nLocalComputes = nLocalPatches = 0;
00131   patchNAtoms = (int *) NULL;
00132   sequencerThreads = (Sequencer **) NULL;
00133   ldbStatsFP = NULL;
00134   computeArray = NULL;
00135   patchArray = NULL;
00136   processorArray = NULL;
00137 
00138   // Register self as an object manager for new charm++ balancer framework
00139   theLbdb = LdbInfra::Object();
00140 
00141   // Set the load balancing period (in seconds).  Without this the
00142   // load balancing framework will hang until 1 second has passed
00143   // since the last load balancing, causing hiccups in very fast runs.
00144   // Unfortunately, the clock is already set for the first load
00145   // balancing, but only +LBPeriod 1.0e-5 can fix that in older charm.
00146   // For newer versions this is handled in initproc above.
00147 
00148 #ifndef LB_MANAGER_VERSION
00149   theLbdb->SetLBPeriod(1.0e-5);
00150 #endif
00151 
00152   myOMid.id.idx = 1;
00153   LDCallbacks cb = { (LDMigrateFn)staticMigrateFn,
00154                      (LDStatsFn)staticStatsFn,
00155                      (LDQueryEstLoadFn)staticQueryEstLoadFn
00156                    };
00157   myHandle = theLbdb->RegisterOM(myOMid,nullptr,cb);
00158 
00159 #ifdef LB_MANAGER_VERSION
00160   // Add myself as a local barrier receiver, so I know when I might
00161   // be registering objects.
00162   theLbdb->AddLocalBarrierReceiver(this, &LdbCoordinator::AtSyncBarrierReached);
00163 
00164   // Also, add a local barrier client, to trigger load balancing
00165   ldBarrierHandle = theLbdb->
00166     AddLocalBarrierClient(this, &LdbCoordinator::ResumeFromSync);
00167 #else
00168   // Add myself as a local barrier receiver, so I know when I might
00169   // be registering objects.
00170   theLbdb->AddLocalBarrierReceiver((LDBarrierFn)staticReceiveAtSync,
00171                                    (void*)this);;
00172 
00173   // Also, add a local barrier client, to trigger load balancing
00174   ldBarrierHandle = theLbdb->
00175     AddLocalBarrierClient((LDResumeFn)staticResumeFromSync,
00176                           (void*)this);
00177 #endif
00178   migrateMsgs = 0; // linked list
00179   numComputes = 0;
00180   reg_all_objs = 1;
00181 }

LdbCoordinator::~LdbCoordinator ( void   ) 

Definition at line 183 of file LdbCoordinator.C.

References computeArray, ldbStatsFP, patchArray, patchNAtoms, processorArray, and sequencerThreads.

00184 {
00185   delete [] patchNAtoms;
00186   delete [] sequencerThreads;
00187   if (CkMyPe() == 0)
00188   {
00189     delete [] computeArray;
00190     delete [] patchArray;
00191     delete [] processorArray;
00192   }
00193   if (ldbStatsFP)
00194     fclose(ldbStatsFP);
00195 
00196 }


Member Function Documentation

void LdbCoordinator::AtSyncBarrierReached ( void   ) 

Definition at line 101 of file LdbCoordinator.C.

References myHandle, and theLbdb.

Referenced by LdbCoordinator().

00102 {
00103   theLbdb->RegisteringObjects(myHandle);
00104 }

void LdbCoordinator::awakenSequencers ( void   ) 

Definition at line 746 of file LdbCoordinator.C.

References Sequencer::awaken(), Controller::awaken(), controllerThread, PatchMap::numPatches(), patchMap, and sequencerThreads.

Referenced by resume2().

00747 {
00748   if (controllerThread)
00749   {
00750     controllerThread->awaken();
00751     controllerThread = NULL;
00752   }
00753   for(int i=0; i < patchMap->numPatches(); i++)
00754   {
00755     if (sequencerThreads[i])
00756     {
00757       sequencerThreads[i]->awaken();
00758     }
00759     sequencerThreads[i]= NULL;
00760   }
00761 }

void LdbCoordinator::barrier ( void   ) 

Definition at line 647 of file LdbCoordinator.C.

References controllerExpected, controllerReported, ldBarrierHandle, NAMD_bug(), nComputesExpected, nComputesReported, nPatchesExpected, nPatchesReported, and theLbdb.

00648 {
00649   if ( (nPatchesReported != nPatchesExpected) 
00650        || (nComputesReported != nComputesExpected)
00651        || (controllerReported != controllerExpected) )
00652   {
00653     NAMD_bug("Load balancer received wrong number of events.\n");
00654   }
00655   theLbdb->AtLocalBarrier(ldBarrierHandle);
00656 }

void LdbCoordinator::collectLoads ( CollectLoadsMsg msg  ) 

Definition at line 839 of file LdbCoordinator.C.

References COLL_AVG, COLL_MAX, COLL_SUM, endi(), CollectLoadsMsg::finalTime, CollectLoadsMsg::firstPe, CollectLoadsMsg::initTime, iout, CollectLoadsMsg::lastPe, and CollectLoadsMsg::strategyName.

00839                                                       {
00840   // CkPrintf("LdbCoordinator::collectLoads recv %d-%d\n", msg->firstPe, msg->lastPe);
00841   if ( collPes == 0 ) {
00842     reverted = 0;
00843     initTotalProxies = 0;
00844     finalTotalProxies = 0;
00845     initMaxPeProxies = 0;
00846     finalMaxPeProxies = 0;
00847     initMaxPatchProxies = 0;
00848     finalMaxPatchProxies = 0;
00849     initTime = 0;
00850     finalTime = 0;
00851     initMemory = 0;
00852     finalMemory = 0;
00853     initAvgPeLoad = 0;
00854     finalAvgPeLoad = 0;
00855     initMaxPeLoad = 0;
00856     finalMaxPeLoad = 0;
00857   }
00858   int numPes = msg->lastPe - msg->firstPe + 1;
00859   collPes += numPes;
00860 #define COLL_MAX(F) if ( msg->F > F ) F = msg->F;
00861 #define COLL_AVG(F) F += msg->F * (double) numPes / (double) CkNumPes();
00862 #define COLL_SUM(F) F += msg->F;
00863   COLL_SUM(reverted)
00864   COLL_SUM(initTotalProxies)
00865   COLL_SUM(finalTotalProxies)
00866   COLL_MAX(initMaxPeProxies)
00867   COLL_MAX(finalMaxPeProxies)
00868   COLL_MAX(initMaxPatchProxies)
00869   COLL_MAX(finalMaxPatchProxies)
00870   if ( (msg->finalTime - msg->initTime) > (finalTime - initTime) ) {
00871     initTime = msg->initTime;
00872     finalTime = msg->finalTime;
00873   }
00874   COLL_MAX(initMemory)
00875   COLL_MAX(finalMemory)
00876   COLL_AVG(initAvgPeLoad)
00877   COLL_AVG(finalAvgPeLoad)
00878   COLL_MAX(initMaxPeLoad)
00879   COLL_MAX(finalMaxPeLoad)
00880 
00881   if ( collPes == CkNumPes() ) {
00882     collPes = 0;
00883     iout << "LDB: TIME " << initTime << " LOAD: AVG " << initAvgPeLoad
00884       << " MAX " << initMaxPeLoad << "  PROXIES: TOTAL " << initTotalProxies << " MAXPE " <<
00885       initMaxPeProxies << " MAXPATCH " << initMaxPatchProxies << " " << "None"
00886       << " MEM: " << initMemory << " MB\n";
00887     if ( reverted ) iout << "LDB: Reverting to original mapping on " << reverted << " balancers\n";
00888     iout << "LDB: TIME " << finalTime << " LOAD: AVG " << finalAvgPeLoad
00889       << " MAX " << finalMaxPeLoad << "  PROXIES: TOTAL " << finalTotalProxies << " MAXPE " <<
00890       finalMaxPeProxies << " MAXPATCH " << finalMaxPatchProxies << " " << msg->strategyName
00891       << " MEM: " << finalMemory << " MB\n";
00892     iout << endi;
00893     fflush(stdout);
00894   }
00895 
00896   delete msg;
00897 }

void LdbCoordinator::createLoadBalancer (  ) 

Definition at line 198 of file LdbCoordinator.C.

References CreateNamdCentLB(), CreateNamdHybridLB(), LDBAL_CENTRALIZED, LDBAL_HYBRID, SimParameters::ldBalancer, Object(), and simParams.

00199 {
00200   const SimParameters *simParams = Node::Object()->simParameters;
00201 
00202   // Create hierarchical or centralized load balancers
00203   // Currently centralized is the default
00204   if (simParams->ldBalancer == LDBAL_CENTRALIZED) {
00205     CkPrintf("LDB: Central LB being created...\n");
00206     CreateNamdCentLB();
00207   } else if (simParams->ldBalancer == LDBAL_HYBRID) {
00208     CkPrintf("LDB: Hybrid LB being created...\n");
00209     CreateNamdHybridLB();
00210   }
00211 }

void LdbCoordinator::endWork ( const LDObjHandle &  handle  )  [inline]

Definition at line 110 of file LdbCoordinator.h.

References nComputesReported, and theLbdb.

Referenced by ComputePatchPair::doWork(), ComputePatch::doWork(), ComputeLCPO::doWork(), and ComputeHomeTuples< TholeElem, Thole, TholeValue >::doWork().

00110                                           {  // both
00111     theLbdb->ObjectStop(handle);
00112     nComputesReported++;
00113   }

void LdbCoordinator::ExecuteMigrations ( void   ) 

Definition at line 670 of file LdbCoordinator.C.

References computeMgr, ComputeMgr::updateComputes(), and updateComputesReady().

Referenced by nodeDone().

00671 {
00672  // computeMgr->updateComputes() call only on Node(0) i.e. right here
00673   // This will barrier for all Nodes - (i.e. Computes must be
00674   // here and with proxies before anyone can start up
00675 
00676   CProxy_ComputeMgr cm(CkpvAccess(BOCclass_group).computeMgr);
00677   ComputeMgr *computeMgr = cm.ckLocalBranch();
00678   computeMgr->updateComputes(CkIndex_LdbCoordinator::
00679                              updateComputesReady(),thisgroup);
00680 }

void LdbCoordinator::ExpectMigrate ( LdbMigrateMsg m  ) 

Definition at line 697 of file LdbCoordinator.C.

References LdbMigrateMsg::from, LdbMigrateMsg::handle, migrateMsgs, myHandle, LdbMigrateMsg::next, and theLbdb.

Referenced by Migrate(), and RecvMigrate().

00698 {
00699   if ( m->from != CkMyPe() ) {
00700     m->handle = theLbdb->RegisterObj(myHandle,m->handle.id,0,1);
00701     theLbdb->Migrated(m->handle);
00702   }
00703 
00704   m->next = migrateMsgs;
00705   migrateMsgs = m;
00706 }

int LdbCoordinator::getNumStepsToRun ( void   )  [inline]

Definition at line 123 of file LdbCoordinator.h.

References numStepsToRun.

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

00123 { return numStepsToRun; }

void LdbCoordinator::initialize ( PatchMap pmap,
ComputeMap cmap,
int  reinit = 0 
)

Definition at line 213 of file LdbCoordinator.C.

References BONDED_TYPE, SimParameters::bondedCUDA, ComputeMap::compute(), computeAnglesType, computeAnisoType, computeArray, computeBondsType, computeCrosstermsType, computeDihedralsType, computeExclsType, computeGromacsPairType, computeImpropersType, computeLCPOType, computeMap, computeNonbondedPairType, computeNonbondedSelfType, computeSelfAnglesType, computeSelfAnisoType, computeSelfBondsType, computeSelfCrosstermsType, computeSelfDihedralsType, computeSelfExclsType, computeSelfGromacsPairType, computeSelfImpropersType, computeSelfTholeType, computeTholeType, controllerExpected, controllerReported, controllerThread, SimParameters::firstLdbStep, firstLdbStep, LdbMigrateMsg::handle, PatchMap::homePatch(), SimParameters::lastLdbStep, ldbCycleNum, LdbIdField(), SimParameters::ldbPeriod, Compute::ldObjHandle, HomePatch::ldObjHandle, migrateMsgs, SimParameters::multigratorOn, SimParameters::multigratorPressureFreq, myHandle, NAMD_bug(), NAMD_die(), nComputesExpected, nComputesReported, LdbMigrateMsg::next, nLocalComputes, nLocalPatches, ComputeMap::node(), PatchMap::node(), NONBONDED_OR_SELF_TYPE, nPatches, nPatchesExpected, nPatchesReported, nStatsMessagesExpected, nStatsMessagesReceived, ComputeMap::numComputes(), numComputes, PatchMap::numHomePatches(), PatchMap::numPatches(), ComputeMap::numPids(), numStepsToRun, Object(), PATCH_TYPE, patchArray, patchHandles, patchMap, patchNAtoms, ComputeMap::pid(), processorArray, reg_all_objs, sequencerThreads, simParams, SimParameters::stepsPerCycle, stepsPerLdbCycle, takingLdbData, theLbdb, totalStepsDone, and ComputeMap::type().

Referenced by resume().

00214 {
00215   const SimParameters *simParams = Node::Object()->simParameters;
00216 
00217   //  DebugM(10,"stepsPerLdbCycle initialized\n");
00218   stepsPerLdbCycle = simParams->ldbPeriod;
00219   firstLdbStep = simParams->firstLdbStep;
00220   int lastLdbStep = simParams->lastLdbStep;
00221   int stepsPerCycle = simParams->stepsPerCycle;
00222 
00223   computeMap = cMap;
00224   patchMap = pMap;
00225 
00226   // Set the number of received messages correctly for node 0
00227 
00228   nStatsMessagesExpected = Node::Object()->numNodes();
00229   nStatsMessagesReceived = 0;
00230 
00231   if (patchNAtoms) 
00232     delete [] patchNAtoms;  // Depends on delete NULL to do nothing
00233   nPatches = patchMap->numPatches();
00234   patchNAtoms = new int[nPatches];
00235 
00236   typedef Sequencer *seqPtr;
00237 
00238   if ( ! reinit ) {
00239     delete [] sequencerThreads;  // Depends on delete NULL to do nothing
00240     sequencerThreads = new seqPtr[nPatches];
00241   }
00242 
00243   nLocalPatches=0;
00244 
00245   int i;
00246   for(i=0;i<nPatches;i++)
00247   {
00248     if (patchMap->node(i) == Node::Object()->myid())
00249     {
00250       nLocalPatches++;
00251       patchNAtoms[i]=0;
00252     } else {
00253       patchNAtoms[i]=-1;
00254     }
00255     if ( ! reinit ) sequencerThreads[i]=NULL;
00256   }
00257   if ( ! reinit ) controllerThread = NULL;
00258   if (nLocalPatches != patchMap->numHomePatches())
00259     NAMD_die("Disaggreement in patchMap data.\n");
00260  
00261   const int oldNumComputes = numComputes;
00262   nLocalComputes = 0;
00263   numComputes = computeMap->numComputes();
00264 
00265   for(i=0;i<numComputes;i++)  {
00266     if ( (computeMap->node(i) == Node::Object()->myid())
00267          && ( 0
00268               #if (defined(NAMD_CUDA) || defined(NAMD_MIC))
00269                 #if defined(NAMD_MIC)
00270                   || ((computeMap->type(i) == computeNonbondedSelfType) && (computeMap->directToDevice(i) == 0))
00271                   || ((computeMap->type(i) == computeNonbondedPairType) && (computeMap->directToDevice(i) == 0))
00272                 #endif
00273               #else
00274               || (computeMap->type(i) == computeNonbondedSelfType)
00275               || (computeMap->type(i) == computeNonbondedPairType)
00276 #endif
00277 #if defined(NAMD_CUDA) && defined(BONDED_CUDA)
00278         || (computeMap->type(i) == computeSelfBondsType && !(simParams->bondedCUDA & 1))
00279         || (computeMap->type(i) == computeBondsType && !(simParams->bondedCUDA & 1))
00280         || (computeMap->type(i) == computeSelfAnglesType && !(simParams->bondedCUDA & 2))
00281         || (computeMap->type(i) == computeAnglesType && !(simParams->bondedCUDA & 2))
00282         || (computeMap->type(i) == computeSelfDihedralsType && !(simParams->bondedCUDA & 4))
00283         || (computeMap->type(i) == computeDihedralsType && !(simParams->bondedCUDA & 4))
00284         || (computeMap->type(i) == computeSelfImpropersType && !(simParams->bondedCUDA & 8))
00285         || (computeMap->type(i) == computeImpropersType && !(simParams->bondedCUDA & 8))
00286         || (computeMap->type(i) == computeSelfExclsType && !(simParams->bondedCUDA & 16))
00287         || (computeMap->type(i) == computeExclsType && !(simParams->bondedCUDA & 16))
00288         || (computeMap->type(i) == computeSelfCrosstermsType && !(simParams->bondedCUDA & 32))
00289         || (computeMap->type(i) == computeCrosstermsType && !(simParams->bondedCUDA & 32))
00290 #else
00291         || (computeMap->type(i) == computeSelfBondsType)
00292         || (computeMap->type(i) == computeBondsType)
00293         || (computeMap->type(i) == computeSelfAnglesType)
00294         || (computeMap->type(i) == computeAnglesType)
00295         || (computeMap->type(i) == computeSelfDihedralsType)
00296         || (computeMap->type(i) == computeDihedralsType)
00297         || (computeMap->type(i) == computeSelfImpropersType)
00298         || (computeMap->type(i) == computeImpropersType)
00299         || (computeMap->type(i) == computeSelfExclsType)
00300         || (computeMap->type(i) == computeExclsType)
00301         || (computeMap->type(i) == computeSelfCrosstermsType)
00302         || (computeMap->type(i) == computeCrosstermsType)
00303 #endif
00304               || (computeMap->type(i) == computeLCPOType)
00305               || (computeMap->type(i) == computeSelfTholeType)
00306               || (computeMap->type(i) == computeSelfAnisoType)
00307 
00308                  || (computeMap->type(i) == computeTholeType)
00309                  || (computeMap->type(i) == computeAnisoType)
00310               // JLai
00311                  || (computeMap->type(i) == computeGromacsPairType)
00312                  || (computeMap->type(i) == computeSelfGromacsPairType)
00313         ) ) {
00314       nLocalComputes++;
00315     }
00316   }
00317   
00318   // New LB frameworks registration
00319 
00320   // Allocate data structure to save incoming migrations.  Processor
00321   // zero will get all migrations
00322 
00323   // If this is the first time through, we need it register patches
00324   if (ldbCycleNum == reg_all_objs) {
00325     if ( 1 ) { // ( Node::Object()->simParameters->ldBalancer == LDBAL_CENTRALIZED ) {
00326       reg_all_objs = 3;
00327     }
00328     // Tell the lbdb that I'm registering objects, until I'm done
00329     // registering them.
00330     theLbdb->RegisteringObjects(myHandle);
00331     
00332    if ( ldbCycleNum == 1 ) {
00333     patchHandles = new LDObjHandle[nLocalPatches];
00334     int patch_count=0;
00335     int i;
00336     for(i=0;i<nPatches;i++)
00337       if (patchMap->node(i) == Node::Object()->myid()) {
00338 
00339         LdbId elemID;
00340         LdbIdField(elemID, 0) = i;
00341         LdbIdField(elemID, 1) = PATCH_TYPE;
00342 
00343         if (patch_count >= nLocalPatches) {
00344     NAMD_bug("LdbCoordinator found too many local patches!");
00345         }
00346         HomePatch *p = patchMap->homePatch(i);
00347         p->ldObjHandle = 
00348         patchHandles[patch_count] 
00349           = theLbdb->RegisterObj(myHandle,elemID,0,0);
00350         patch_count++;
00351 
00352       }
00353    }
00354   
00355     if ( numComputes > oldNumComputes ) {
00356       // Register computes
00357       for(i=oldNumComputes; i<numComputes; i++)  {
00358         if ( computeMap->node(i) == Node::Object()->myid())
00359         {
00360           if ( 0
00361                #if (defined(NAMD_CUDA) || defined(NAMD_MIC))
00362                  #if defined(NAMD_MIC)
00363                    || ((computeMap->type(i) == computeNonbondedSelfType) && (computeMap->directToDevice(i) == 0))
00364                    || ((computeMap->type(i) == computeNonbondedPairType) && (computeMap->directToDevice(i) == 0))
00365                  #endif
00366                #else
00367                   || (computeMap->type(i) == computeNonbondedSelfType)
00368                   || (computeMap->type(i) == computeNonbondedPairType)
00369                #endif
00370 #if defined(NAMD_CUDA) && defined(BONDED_CUDA)
00371             || (computeMap->type(i) == computeSelfBondsType && !(simParams->bondedCUDA & 1))
00372             || (computeMap->type(i) == computeSelfAnglesType && !(simParams->bondedCUDA & 2))
00373             || (computeMap->type(i) == computeSelfDihedralsType && !(simParams->bondedCUDA & 4))
00374             || (computeMap->type(i) == computeSelfImpropersType && !(simParams->bondedCUDA & 8))
00375             || (computeMap->type(i) == computeSelfExclsType && !(simParams->bondedCUDA & 16))
00376             || (computeMap->type(i) == computeSelfCrosstermsType && !(simParams->bondedCUDA & 32))
00377 #else
00378             || (computeMap->type(i) == computeSelfBondsType)
00379             || (computeMap->type(i) == computeSelfAnglesType)
00380             || (computeMap->type(i) == computeSelfDihedralsType)
00381             || (computeMap->type(i) == computeSelfImpropersType)
00382             || (computeMap->type(i) == computeSelfExclsType)
00383             || (computeMap->type(i) == computeSelfCrosstermsType)
00384 #endif
00385                   || (computeMap->type(i) == computeLCPOType)
00386                   || (computeMap->type(i) == computeSelfTholeType)
00387                   || (computeMap->type(i) == computeSelfAnisoType)
00388                // JLai
00389                   || (computeMap->type(i) == computeSelfGromacsPairType)
00390                // End of JLai
00391                 )  {
00392           // Register the object with the load balancer
00393           // Store the depended patch IDs in the rest of the element ID
00394           LdbId elemID;
00395           LdbIdField(elemID, 0) = i;
00396 
00397           if (computeMap->numPids(i) > 0)
00398             LdbIdField(elemID, 1) =  computeMap->pid(i,0);
00399           else LdbIdField(elemID, 1) = NONBONDED_OR_SELF_TYPE;
00400 
00401           Compute *c = computeMap->compute(i);
00402           if ( ! c ) NAMD_bug("LdbCoordinator::initialize() null compute pointer");
00403 
00404           c->ldObjHandle = theLbdb->RegisterObj(myHandle,elemID,0,1);
00405           }
00406           else if ( 
00407 #if defined(NAMD_CUDA) && defined(BONDED_CUDA)
00408                     (computeMap->type(i) == computeBondsType && !(simParams->bondedCUDA & 1))
00409                  || (computeMap->type(i) == computeAnglesType && !(simParams->bondedCUDA & 2))
00410                  || (computeMap->type(i) == computeDihedralsType && !(simParams->bondedCUDA & 4))
00411                  || (computeMap->type(i) == computeImpropersType && !(simParams->bondedCUDA & 8))
00412                  || (computeMap->type(i) == computeExclsType && !(simParams->bondedCUDA & 16))
00413                  || (computeMap->type(i) == computeCrosstermsType && !(simParams->bondedCUDA & 32))
00414 #else
00415                     (computeMap->type(i) == computeBondsType)
00416                  || (computeMap->type(i) == computeAnglesType)
00417                  || (computeMap->type(i) == computeDihedralsType)
00418                  || (computeMap->type(i) == computeImpropersType)
00419                  || (computeMap->type(i) == computeExclsType)
00420                  || (computeMap->type(i) == computeCrosstermsType)
00421 #endif
00422                  || (computeMap->type(i) == computeTholeType)
00423                  || (computeMap->type(i) == computeAnisoType)
00424                  // JLai
00425                  || (computeMap->type(i) == computeGromacsPairType)
00426                  // End of JLai
00427                ) {
00428           // Register the object with the load balancer
00429           // Store the depended patch IDs in the rest of the element ID
00430           LdbId elemID;
00431           LdbIdField(elemID, 0) = i;
00432         
00433           LdbIdField(elemID, 1) = BONDED_TYPE;
00434 
00435           Compute *c = computeMap->compute(i);
00436           if ( ! c ) NAMD_bug("LdbCoordinator::initialize() null compute pointer");
00437 
00438           c->ldObjHandle = theLbdb->RegisterObj(myHandle,elemID,0,0);
00439           }
00440         }
00441       }
00442     }
00443     theLbdb->DoneRegisteringObjects(myHandle);
00444   }
00445 
00446   // process saved migration messages, if any
00447   while ( migrateMsgs ) {
00448     LdbMigrateMsg *m = migrateMsgs;
00449     migrateMsgs = m->next;
00450     Compute *c = computeMap->compute(LdbIdField(m->handle.id, 0));
00451     if ( ! c ) NAMD_bug("LdbCoordinator::initialize() null compute pointer 2");
00452     c->ldObjHandle = m->handle;
00453     delete m;
00454   }
00455 
00456   // Fixup to take care of the extra timestep at startup
00457   // This is pretty ugly here, but it makes the count correct
00458   
00459   // iout << "LDB Cycle Num: " << ldbCycleNum << "\n";
00460 
00461  if ( 1 ) { // ( simParams->ldBalancer == LDBAL_CENTRALIZED ) {
00462   if (ldbCycleNum == 1 || ldbCycleNum == 3) {
00463     numStepsToRun = stepsPerCycle;
00464     totalStepsDone += numStepsToRun;
00465     takingLdbData = 0;
00466     theLbdb->CollectStatsOff();
00467   } else if (ldbCycleNum == 2 || ldbCycleNum == 4) {
00468     numStepsToRun = firstLdbStep - stepsPerCycle;
00469     while ( numStepsToRun <= 0 ) numStepsToRun += stepsPerCycle;
00470     totalStepsDone += numStepsToRun;
00471     takingLdbData = 1;
00472     theLbdb->CollectStatsOn();
00473   } else if ( (ldbCycleNum <= 6) || !takingLdbData )
00474   {
00475     totalStepsDone += firstLdbStep;
00476     if(lastLdbStep != -1 && totalStepsDone > lastLdbStep) {
00477       numStepsToRun = -1;
00478       takingLdbData = 0;
00479       theLbdb->CollectStatsOff();
00480     } else {
00481       numStepsToRun = firstLdbStep;
00482       takingLdbData = 1;
00483       theLbdb->CollectStatsOn();
00484     }
00485   }
00486   else 
00487   {
00488     totalStepsDone += stepsPerLdbCycle - firstLdbStep;
00489     if(lastLdbStep != -1 && totalStepsDone > lastLdbStep) {
00490       numStepsToRun = -1;
00491       takingLdbData = 0;
00492       theLbdb->CollectStatsOff();
00493     } else {
00494       numStepsToRun = stepsPerLdbCycle - firstLdbStep;
00495       takingLdbData = 0;
00496       theLbdb->CollectStatsOff();
00497     }
00498   }
00499  } else {
00500   if (ldbCycleNum==1)
00501   {
00502     totalStepsDone += firstLdbStep;
00503     numStepsToRun = firstLdbStep;
00504     takingLdbData = 0;
00505     theLbdb->CollectStatsOff();
00506   }
00507   else if ( (ldbCycleNum <= 4) || !takingLdbData )
00508   {
00509     totalStepsDone += firstLdbStep;
00510     if(lastLdbStep != -1 && totalStepsDone > lastLdbStep) {
00511       numStepsToRun = -1;
00512       takingLdbData = 0;
00513       theLbdb->CollectStatsOff();
00514     } else {
00515       numStepsToRun = firstLdbStep;
00516       takingLdbData = 1;
00517       theLbdb->CollectStatsOn();
00518     }
00519   }
00520   else 
00521   {
00522     totalStepsDone += stepsPerLdbCycle - firstLdbStep;
00523     if(lastLdbStep != -1 && totalStepsDone > lastLdbStep) {
00524       numStepsToRun = -1;
00525       takingLdbData = 0;
00526       theLbdb->CollectStatsOff();
00527     } else {
00528       numStepsToRun = stepsPerLdbCycle - firstLdbStep;
00529       takingLdbData = 0;
00530       theLbdb->CollectStatsOff();
00531     }
00532   }
00533  }
00534 
00535 /*-----------------------------------------------------------------------------*
00536  * --------------------------------------------------------------------------- *
00537  * Comments inserted by Abhinav to clarify relation between ldbCycleNum,       *
00538  * load balancing step numbers (printed by the step() function) and            *
00539  * tracing of the steps                                                        *
00540  * --------------------------------------------------------------------------- *
00541  * If trace is turned off in the beginning, then tracing is turned on          *
00542  * at ldbCycleNum = 4 and turned off at ldbCycleNum = 8. ldbCycleNum can       *
00543  * be adjusted by specifying firstLdbStep and ldbPeriod which are set by       *
00544  * default to 5*stepspercycle and 200*stepspercycle if not specified.          *
00545  *                                                                             *
00546  * If we choose firstLdbStep = 20 and ldbPeriod = 100, we have the             *
00547  * following timeline (for these particular numbers):                          *
00548  *                                                                             *
00549  * Tracing         :  <------ off ------><------------- on -----------><-- off *
00550  * Ldb Step() No   :              1     2     3        4      5       6      7 *
00551  * Iteration Steps : 00====20====40====60====80======160====180=====260====280 *
00552  * ldbCycleNum     :  1     2     3     4     5        6      7       8      9 *
00553  * Instrumention   :          Inst  Inst  Inst           Inst            Inst  *
00554  * LDB Strategy    :              TLB  RLB   RLB            RLB            RLB *
00555  *                                                                             *
00556  * TLB = TorusLB                                                               *
00557  * RLB = RefineTorusLB                                                         *
00558  * Inst = Instrumentation Phase (no real load balancing)                       *
00559  * --------------------------------------------------------------------------- *
00560  *-----------------------------------------------------------------------------*
00561  */
00562 #if 0 //replaced by traceBarrier at Controller and Sequencer
00563   if (traceAvailable()) {
00564     static int specialTracing = 0; // XXX static variables are unsafe for SMP
00565     if (ldbCycleNum == 1 && traceIsOn() == 0)  specialTracing = 1;
00566     if (specialTracing) {
00567       if (ldbCycleNum == 4) traceBegin();
00568       if (ldbCycleNum == 8) traceEnd();
00569     }
00570   }
00571 #endif
00572 
00573   nPatchesReported = 0;
00574   nPatchesExpected = nLocalPatches;
00575   nComputesReported = 0;
00576   nComputesExpected = nLocalComputes * numStepsToRun;
00577   controllerReported = 0;
00578   controllerExpected = ! CkMyPe();
00579 
00580   if (simParams->multigratorOn) {
00581     // Add the number of pressure cycles into nComputesExpected:
00582     // Pressure cycle is done when !(step % simParams->multigratorPressureFreq) = true
00583     // step = Current step
00584     int step = totalStepsDone - numStepsToRun;
00585     int freq = simParams->multigratorPressureFreq;
00586     // dstep = Number of steps we have to take until next pressure cycle
00587     int dstep = 0;
00588     if ((step % freq) != 0) dstep = freq - (step % freq);
00589     step += dstep;
00590     if (step < totalStepsDone) {
00591       int numPressureCycles = 1 + ((totalStepsDone-step-1)/freq);
00592       if (step==0) numPressureCycles--;
00593       // if (CkMyPe()==2) fprintf(stderr, "step %d totalStepsDone %d numPressureCycles %d\n",
00594       //   step, totalStepsDone, numPressureCycles);
00595       nComputesExpected += 2*nLocalComputes*numPressureCycles;
00596     }
00597   }
00598 
00599   if (CkMyPe() == 0)
00600   {
00601     if (computeArray == NULL)
00602       computeArray = new computeInfo[numComputes];
00603     if (patchArray == NULL)
00604       patchArray = new patchInfo[nPatches];
00605     if (processorArray == NULL)
00606       processorArray = new processorInfo[CkNumPes()];
00607   }
00608     
00609   theLbdb->ClearLoads();
00610 }

void LdbCoordinator::Migrate ( LDObjHandle  handle,
int  dest 
)

Definition at line 67 of file LdbCoordinator.C.

References ExpectMigrate(), LdbMigrateMsg::from, LdbMigrateMsg::handle, and LdbMigrateMsg::to.

Referenced by staticMigrateFn(), and ComputeMgr::updateLocalComputes().

00068 {
00069   LdbMigrateMsg* msg = new LdbMigrateMsg;
00070   msg->handle = handle;
00071   msg->from = CkMyPe();
00072   msg->to = dest;
00073   if ( msg->to != CkMyPe() ) {
00074     CProxy_LdbCoordinator ldbProxy(thisgroup);
00075     ldbProxy[CkMyPe()].RecvMigrate(msg);
00076   } else {
00077     ExpectMigrate(msg);
00078   }
00079 }

void LdbCoordinator::nodeDone ( CkReductionMsg *  msg  ) 

Definition at line 658 of file LdbCoordinator.C.

References endi(), ExecuteMigrations(), iout, takingLdbData, and updateComputesReady().

00659 {
00660   delete msg;
00661 
00662   iout << "LDB: ============== END OF LOAD BALANCING =============== " << CmiWallTimer() << "\n" << endi;
00663   if ( takingLdbData ) {
00664       ExecuteMigrations();
00665   } else {
00666       updateComputesReady();
00667   }
00668 }

static LdbCoordinator* LdbCoordinator::Object (  )  [inline, static]
void LdbCoordinator::patchLoad ( PatchID  id,
int  nAtoms,
int  timestep 
)

Definition at line 612 of file LdbCoordinator.C.

References DebugM, nPatches, nPatchesReported, and patchNAtoms.

Referenced by HomePatch::submitLoadStats().

00613 {
00614   CmiAssert( id >=0 && id < nPatches);
00615   if (patchNAtoms[id] != -1) {
00616     patchNAtoms[id] = nAtoms;
00617     nPatchesReported++;
00618   } else {
00619     DebugM(10, "::patchLoad() Unexpected patch reporting in\n");
00620   }
00621 }

void LdbCoordinator::pauseWork ( const LDObjHandle &  handle  )  [inline]

Definition at line 104 of file LdbCoordinator.h.

References theLbdb.

Referenced by ComputePatchPair::doWork(), ComputePatch::doWork(), SimpleBroadcastObject< Tensor >::get(), Sequencer::suspend(), and Sequencer::terminate().

00104                                             {  // stop timer only
00105     theLbdb->ObjectStop(handle);
00106   }

void LdbCoordinator::printLocalLdbReport ( void   ) 

Definition at line 791 of file LdbCoordinator.C.

References j, PatchMap::numPatches(), patchMap, and patchNAtoms.

00792 {
00793   char outputBuf[255];
00794   char *curLoc;
00795 
00796   CkPrintf("%d:Patch report:\n",CkMyPe());
00797   
00798   curLoc = outputBuf;
00799   int i,j=0;
00800   for(i=0; i<patchMap->numPatches(); i++)
00801   {
00802     if (patchNAtoms[i] != -1)
00803     {
00804       curLoc += sprintf(curLoc,"%5d: %5d ",i,patchNAtoms[i]);
00805       j++;
00806     } 
00807     if (((j % 4) == 0) && j)
00808     {
00809       curLoc = outputBuf;
00810       CkPrintf("[%d]%s\n",CkMyPe(),outputBuf);
00811       j=0;
00812     }
00813   }
00814 
00815   CkPrintf("%d:Compute report:\n",CkMyPe());
00816   
00817   curLoc = outputBuf;
00818   j=0;
00819 }

void LdbCoordinator::printRequiredProxies ( PatchID  id,
FILE *  fp 
)

Definition at line 821 of file LdbCoordinator.C.

References PatchMap::MaxOneAway, PatchMap::MaxTwoAway, and requiredProxies().

00822 {
00823   // Check all two-away neighbors.
00824   // This is really just one-away neighbors, since 
00825   // two-away always returns zero: RKB
00826   int neighborNodes[PatchMap::MaxOneAway + PatchMap::MaxTwoAway];
00827   const int nProxyNodes = requiredProxies(id,neighborNodes);
00828 
00829   fprintf(fp,"%4d ",nProxyNodes);
00830 
00831   for(int i=0;i<nProxyNodes;i++)
00832     fprintf(fp,"%4d ",neighborNodes[i]);
00833 }

void LdbCoordinator::rebalance ( Controller seq  ) 

Definition at line 632 of file LdbCoordinator.C.

References controllerReported, controllerThread, DebugM, endi(), iout, LDBAL_NONE, and Node::Object().

00633 {
00634   if (Node::Object()->simParameters->ldBalancer == LDBAL_NONE)
00635     return;
00636 
00637   iout << "LDB: ============= START OF LOAD BALANCING ============== " << CmiWallTimer() << "\n" << endi;
00638   DebugM(3, "Controller reached load balance barrier.\n");
00639   controllerReported = 1;
00640   controllerThread = c;
00641 
00642   CProxy_LdbCoordinator(thisgroup).barrier();
00643 
00644   CthSuspend();
00645 }

void LdbCoordinator::rebalance ( Sequencer seq,
PatchID  id 
)

Definition at line 623 of file LdbCoordinator.C.

References LDBAL_NONE, Node::Object(), sequencerThreads, and Sequencer::suspend().

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

00624 {
00625   if (Node::Object()->simParameters->ldBalancer == LDBAL_NONE)
00626     return;
00627 
00628   sequencerThreads[pid] = seq;
00629   seq->suspend();
00630 }

void LdbCoordinator::RecvMigrate ( LdbMigrateMsg m  ) 

Definition at line 682 of file LdbCoordinator.C.

References ExpectMigrate(), LdbMigrateMsg::handle, theLbdb, and LdbMigrateMsg::to.

00683 {
00684   // This method receives the migration from the framework,
00685   // unregisters it, and sends it to the destination PE
00686 
00687   if ( m->to != CkMyPe() ) {
00688     theLbdb->UnregisterObj(m->handle);
00689 
00690     CProxy_LdbCoordinator  ldbProxy(thisgroup);
00691     ldbProxy[m->to].ExpectMigrate(m);
00692   } else {
00693     ExpectMigrate(m);
00694   }
00695 }

int LdbCoordinator::requiredProxies ( PatchID  id,
int  neighborNodes[] 
)

Definition at line 767 of file LdbCoordinator.C.

References PatchMap::basenode(), PatchMap::downstreamNeighbors(), j, PatchMap::MaxOneAway, PatchMap::node(), and patchMap.

Referenced by printRequiredProxies().

00768 {
00769   PatchID neighbors[1 + PatchMap::MaxOneAway];
00770   neighbors[0] = id;
00771   int numNeighbors = 1 + patchMap->downstreamNeighbors(id,neighbors+1);
00772 
00773   int nProxyNodes = 0;
00774   int myNode = patchMap->node(id);
00775   for ( int i = 0; i < numNeighbors; ++i ) {
00776     const int proxyNode = patchMap->basenode(neighbors[i]);
00777     if ( proxyNode != myNode ) {
00778       int j;
00779       for ( j = 0; j < nProxyNodes; ++j ) {
00780         if ( neighborNodes[j] == proxyNode ) break;
00781       }
00782       if ( j == nProxyNodes ) {
00783         neighborNodes[nProxyNodes] = proxyNode;
00784         nProxyNodes++;
00785       }
00786     }
00787   }
00788   return nProxyNodes;
00789 }

void LdbCoordinator::resume ( void   ) 

Definition at line 715 of file LdbCoordinator.C.

References DebugM, initialize(), ldbCycleNum, Object(), ComputeMap::Object(), and PatchMap::Object().

00716 {
00717   DebugM(3,"resume()\n");
00718   //  printLocalLdbReport();
00719 
00720   ldbCycleNum++;
00721   initialize(PatchMap::Object(),ComputeMap::Object(),1);
00722 
00723   Sync::Object()->openSync();
00724 }

void LdbCoordinator::resume2 ( void   ) 

Definition at line 735 of file LdbCoordinator.C.

References awakenSequencers(), and DebugM.

00736 {
00737   DebugM(3,"resume2()\n");
00738 
00739 #if CONVERSE_VERSION_ELAN
00740   //  enableBlockingReceives();
00741 #endif
00742 
00743   awakenSequencers();
00744 }

void LdbCoordinator::ResumeFromSync ( void   ) 

Definition at line 111 of file LdbCoordinator.C.

References myHandle, and theLbdb.

Referenced by LdbCoordinator().

00112 {
00113   theLbdb->DoneRegisteringObjects(myHandle);
00114   CkCallback cb(CkIndex_LdbCoordinator::nodeDone(NULL), 0, thisgroup);
00115   contribute(0, NULL, CkReduction::random, cb);
00116 }

void LdbCoordinator::resumeReady ( CkQdMsg *  msg  ) 

Definition at line 726 of file LdbCoordinator.C.

References DebugM, endi(), and iout.

00726                                              {
00727 
00728   iout << "LDB: =============== DONE WITH MIGRATION ================ " << CmiWallTimer() << "\n" << endi;
00729   DebugM(3,"resumeReady()\n");
00730   delete msg;
00731 
00732   CProxy_LdbCoordinator(thisgroup).resume2();
00733 }

void LdbCoordinator::sendCollectLoads ( CollectLoadsMsg msg  ) 

Definition at line 835 of file LdbCoordinator.C.

Referenced by Rebalancer::~Rebalancer().

00835                                                           {
00836   CProxy_LdbCoordinator(thisgroup)[0].collectLoads(msg);
00837 }

void LdbCoordinator::skipWork ( const LDObjHandle &  handle  )  [inline]

Definition at line 107 of file LdbCoordinator.h.

References nComputesReported.

Referenced by ComputeNonbondedSelf::noWork(), ComputeNonbondedPair::noWork(), and ComputeLCPO::noWork().

00107                                            {  // increment counter only
00108     nComputesReported++;
00109   }

void LdbCoordinator::startWork ( const LDObjHandle &  handle  )  [inline]
void LdbCoordinator::staticMigrateFn ( LDObjHandle  handle,
int  dest 
) [static]

Definition at line 62 of file LdbCoordinator.C.

References Migrate(), and Object().

Referenced by LdbCoordinator().

00063 {
00064    LdbCoordinator::Object()->Migrate(handle,dest);
00065 }

void LdbCoordinator::staticQueryEstLoadFn ( LDOMHandle  h  )  [static]

Definition at line 86 of file LdbCoordinator.C.

Referenced by LdbCoordinator().

00087 {
00088   CkPrintf("I'm supposed to query load\n");
00089 }

void LdbCoordinator::staticReceiveAtSync ( void *  data  )  [static]

Definition at line 91 of file LdbCoordinator.C.

Referenced by LdbCoordinator().

00092 {
00093 
00094 #if CONVERSE_VERSION_ELAN
00095     //disableBlockingReceives();
00096 #endif
00097 
00098   ((LdbCoordinator*)data)->AtSyncBarrierReached();
00099 }

void LdbCoordinator::staticResumeFromSync ( void *  data  )  [static]

Definition at line 106 of file LdbCoordinator.C.

Referenced by LdbCoordinator().

00107 {
00108   ((LdbCoordinator*)data)->ResumeFromSync();
00109 }

void LdbCoordinator::staticStatsFn ( LDOMHandle  h,
int  state 
) [static]

Definition at line 81 of file LdbCoordinator.C.

Referenced by LdbCoordinator().

00082 {
00083   CkPrintf("I'm supposed to set stats\n");
00084 }

void LdbCoordinator::updateComputesReady (  ) 

Definition at line 708 of file LdbCoordinator.C.

References DebugM.

Referenced by ExecuteMigrations(), and nodeDone().

00708                                          {
00709   DebugM(3,"updateComputesReady()\n");
00710 
00711   CProxy_LdbCoordinator(thisgroup).resume();
00712   CkStartQD(CkIndex_LdbCoordinator::resumeReady((CkQdMsg*)0),&thishandle);
00713 }


Member Data Documentation

Definition at line 169 of file LdbCoordinator.h.

Referenced by initialize(), LdbCoordinator(), and ~LdbCoordinator().

Definition at line 153 of file LdbCoordinator.h.

Referenced by initialize().

Definition at line 150 of file LdbCoordinator.h.

Referenced by barrier(), and initialize().

Definition at line 149 of file LdbCoordinator.h.

Referenced by barrier(), initialize(), and rebalance().

Definition at line 157 of file LdbCoordinator.h.

Referenced by awakenSequencers(), initialize(), and rebalance().

Definition at line 163 of file LdbCoordinator.h.

Referenced by initialize().

Definition at line 174 of file LdbCoordinator.h.

Referenced by barrier(), and LdbCoordinator().

Definition at line 160 of file LdbCoordinator.h.

Referenced by initialize(), LdbCoordinator(), and resume().

Definition at line 168 of file LdbCoordinator.h.

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

Definition at line 177 of file LdbCoordinator.h.

Referenced by ExpectMigrate(), initialize(), and LdbCoordinator().

Definition at line 175 of file LdbCoordinator.h.

Referenced by LdbCoordinator().

Definition at line 148 of file LdbCoordinator.h.

Referenced by barrier(), and initialize().

Definition at line 147 of file LdbCoordinator.h.

Referenced by barrier(), endWork(), initialize(), and skipWork().

Definition at line 143 of file LdbCoordinator.h.

Referenced by initialize(), and LdbCoordinator().

Definition at line 144 of file LdbCoordinator.h.

Referenced by initialize(), and LdbCoordinator().

Definition at line 156 of file LdbCoordinator.h.

Referenced by initialize(), and patchLoad().

Definition at line 146 of file LdbCoordinator.h.

Referenced by barrier(), and initialize().

Definition at line 145 of file LdbCoordinator.h.

Referenced by barrier(), initialize(), and patchLoad().

Definition at line 179 of file LdbCoordinator.h.

Definition at line 152 of file LdbCoordinator.h.

Referenced by initialize().

Definition at line 151 of file LdbCoordinator.h.

Referenced by initialize().

Definition at line 178 of file LdbCoordinator.h.

Referenced by initialize(), and LdbCoordinator().

Definition at line 161 of file LdbCoordinator.h.

Referenced by getNumStepsToRun(), and initialize().

Definition at line 170 of file LdbCoordinator.h.

Referenced by initialize(), LdbCoordinator(), and ~LdbCoordinator().

Definition at line 181 of file LdbCoordinator.h.

Referenced by initialize().

Definition at line 171 of file LdbCoordinator.h.

Referenced by initialize(), LdbCoordinator(), and ~LdbCoordinator().

Definition at line 180 of file LdbCoordinator.h.

Referenced by initialize(), and LdbCoordinator().

Definition at line 142 of file LdbCoordinator.h.

Referenced by initialize().

Definition at line 166 of file LdbCoordinator.h.

Referenced by initialize(), LdbCoordinator(), and nodeDone().

Definition at line 164 of file LdbCoordinator.h.

Referenced by initialize(), and LdbCoordinator().


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

Generated on 19 Sep 2020 for NAMD by  doxygen 1.6.1