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 computeArray, ldBarrierHandle, ldbCycleNum, ldbStatsFP, migrateMsgs, myHandle, myOMid, NAMD_bug(), nLocalComputes, nLocalPatches, numComputes, Object(), patchArray, patchNAtoms, processorArray, reg_all_objs, 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   theLbdb->AddClients(this, true, true);
00161 #else
00162   // Add myself as a local barrier receiver, so I know when I might
00163   // be registering objects.
00164   theLbdb->AddLocalBarrierReceiver((LDBarrierFn)staticReceiveAtSync,
00165                                    (void*)this);;
00166 
00167   // Also, add a local barrier client, to trigger load balancing
00168   ldBarrierHandle = theLbdb->
00169     AddLocalBarrierClient((LDResumeFn)staticResumeFromSync,
00170                           (void*)this);
00171 #endif
00172   migrateMsgs = 0; // linked list
00173   numComputes = 0;
00174   reg_all_objs = 1;
00175 }

LdbCoordinator::~LdbCoordinator ( void   ) 

Definition at line 177 of file LdbCoordinator.C.

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

00178 {
00179   delete [] patchNAtoms;
00180   delete [] sequencerThreads;
00181   if (CkMyPe() == 0)
00182   {
00183     delete [] computeArray;
00184     delete [] patchArray;
00185     delete [] processorArray;
00186   }
00187   if (ldbStatsFP)
00188     fclose(ldbStatsFP);
00189 
00190 }


Member Function Documentation

void LdbCoordinator::AtSyncBarrierReached ( void   ) 

Definition at line 101 of file LdbCoordinator.C.

References myHandle, and theLbdb.

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

void LdbCoordinator::awakenSequencers ( void   ) 

Definition at line 744 of file LdbCoordinator.C.

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

Referenced by resume2().

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

void LdbCoordinator::barrier ( void   ) 

Definition at line 641 of file LdbCoordinator.C.

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

00642 {
00643   if ( (nPatchesReported != nPatchesExpected) 
00644        || (nComputesReported != nComputesExpected)
00645        || (controllerReported != controllerExpected) )
00646   {
00647     NAMD_bug("Load balancer received wrong number of events.\n");
00648   }
00649 #ifdef LB_MANAGER_VERSION
00650   theLbdb->AtLocalBarrier(this);
00651 #else
00652   theLbdb->AtLocalBarrier(ldBarrierHandle);
00653 #endif
00654 }

void LdbCoordinator::collectLoads ( CollectLoadsMsg msg  ) 

Definition at line 837 of file LdbCoordinator.C.

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

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

void LdbCoordinator::createLoadBalancer (  ) 

Definition at line 192 of file LdbCoordinator.C.

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

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

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 668 of file LdbCoordinator.C.

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

Referenced by nodeDone().

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

void LdbCoordinator::ExpectMigrate ( LdbMigrateMsg m  ) 

Definition at line 695 of file LdbCoordinator.C.

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

Referenced by Migrate(), and RecvMigrate().

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

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

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

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 656 of file LdbCoordinator.C.

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

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

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

Definition at line 606 of file LdbCoordinator.C.

References DebugM, nPatches, nPatchesReported, and patchNAtoms.

Referenced by HomePatch::submitLoadStats().

00607 {
00608   CmiAssert( id >=0 && id < nPatches);
00609   if (patchNAtoms[id] != -1) {
00610     patchNAtoms[id] = nAtoms;
00611     nPatchesReported++;
00612   } else {
00613     DebugM(10, "::patchLoad() Unexpected patch reporting in\n");
00614   }
00615 }

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 789 of file LdbCoordinator.C.

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

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

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

Definition at line 819 of file LdbCoordinator.C.

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

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

void LdbCoordinator::rebalance ( Controller seq  ) 

Definition at line 626 of file LdbCoordinator.C.

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

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

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

Definition at line 617 of file LdbCoordinator.C.

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

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

00618 {
00619   if (Node::Object()->simParameters->ldBalancer == LDBAL_NONE)
00620     return;
00621 
00622   sequencerThreads[pid] = seq;
00623   seq->suspend();
00624 }

void LdbCoordinator::RecvMigrate ( LdbMigrateMsg m  ) 

Definition at line 680 of file LdbCoordinator.C.

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

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

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

Definition at line 765 of file LdbCoordinator.C.

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

Referenced by printRequiredProxies().

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

void LdbCoordinator::resume ( void   ) 

Definition at line 713 of file LdbCoordinator.C.

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

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

void LdbCoordinator::resume2 ( void   ) 

Definition at line 733 of file LdbCoordinator.C.

References awakenSequencers(), and DebugM.

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

void LdbCoordinator::ResumeFromSync ( void   ) 

Definition at line 111 of file LdbCoordinator.C.

References myHandle, and theLbdb.

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 724 of file LdbCoordinator.C.

References DebugM, endi(), and iout.

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

void LdbCoordinator::sendCollectLoads ( CollectLoadsMsg msg  ) 

Definition at line 833 of file LdbCoordinator.C.

Referenced by Rebalancer::~Rebalancer().

00833                                                           {
00834   CProxy_LdbCoordinator(thisgroup)[0].collectLoads(msg);
00835 }

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 706 of file LdbCoordinator.C.

References DebugM.

Referenced by ExecuteMigrations(), and nodeDone().

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


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 175 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 179 of file LdbCoordinator.h.

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

Definition at line 177 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 181 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 180 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 183 of file LdbCoordinator.h.

Referenced by initialize().

Definition at line 171 of file LdbCoordinator.h.

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

Definition at line 182 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 6 Dec 2019 for NAMD by  doxygen 1.6.1