NamdHybridLB Class Reference

#include <NamdHybridLB.h>

Inheritance diagram for NamdHybridLB:

Public Member Functions
	NamdHybridLB (const CkLBOptions &opt)
	Default constructor. More...
	NamdHybridLB (CkMigrateMessage *m)
void	UpdateLocalLBInfo (LocalLBInfoMsg *msg)
void	splitComputes (SplitComputesMsg *)

Detailed Description

Definition at line 56 of file NamdHybridLB.h.

Constructor & Destructor Documentation

NamdHybridLB() [1/2]

NamdHybridLB::NamdHybridLB

(

const CkLBOptions &

opt

)

Default constructor.

Definition at line 65 of file NamdHybridLB.C.

References AllocateNamdCentLB(), AllocateNamdDummyLB(), Node::Object(), Node::simParameters, and simParams.

                                                : HybridBaseLB(opt)
{
  // setting the name
  lbname = (char *)"NamdHybridLB";

  delete tree;        // delete the tree built from the base class
  const SimParameters* simParams = Node::Object()->simParameters;
  if (CkNumPes() <= simParams->hybridGroupSize)  {
    tree = new TwoLevelTree;   // similar to centralized load balancing
  }
  else {
    tree = new ThreeLevelTree(simParams->hybridGroupSize);
    initTree();
    // can only do shrink strategy on levels > 1
    statsStrategy = SHRINK_NULL;
  }

  // initializing thisProxy
  thisProxy = CProxy_NamdHybridLB(thisgroup);
  
  // initializing the central LB
  centralLB = AllocateNamdCentLB();

  // initializing the dummy LB
  dummyLB = AllocateNamdDummyLB();

  // assigning initial values to variables
  from_procs = NULL;
  computeArray = NULL;
  patchArray = NULL;
  processorArray = NULL;
  updateCount = 0;
  splitCount = 0;
  splitComputesMsgs = 0;
  updateFlag = false;
  collectFlag = false;

}

NamdHybridLB() [2/2]

NamdHybridLB::NamdHybridLB ( CkMigrateMessage *  m )

inline

Definition at line 60 of file NamdHybridLB.h.

:HybridBaseLB(m) {}

Member Function Documentation

splitComputes()

void NamdHybridLB::splitComputes

(

SplitComputesMsg *

msg

)

Definition at line 219 of file NamdHybridLB.C.

References SplitComputesMsg::averageLoad, averageLoad, SplitComputesMsg::avgCompute, SplitComputesMsg::cid, SplitComputesMsg::load, SplitComputesMsg::maxCompute, SplitComputesMsg::maxComputeId, SplitComputesMsg::maxUnsplit, SplitComputesMsg::n, SplitComputesMsg::nMoveableComputes, SplitComputesMsg::numPesAvailable, Node::Object(), ComputeMap::Object(), ComputeMap::setNewNumPartitions(), Node::simParameters, and simParams.

                                                      {
  const int children = tree->numNodes(1);

  if ( ! splitComputesMsgs ) {
    splitComputesMsgs = new SplitComputesMsg*[children];
  }
  
  splitComputesMsgs[splitCount] = msg;

  if ( ++splitCount == children ) {
    splitCount = 0;

    const SimParameters* simParams = Node::Object()->simParameters;
    ComputeMap *computeMap = ComputeMap::Object();

    double maxUnsplit = 0.;
    double averageLoad = 0.;
    double avgCompute = 0.;
    double maxCompute = 0.;
    int maxComputeId = -1;
    int nMoveableComputes = 0;
    int numPesAvailable = 0;
    int nToSplit = 0;

    for ( int j=0; j < children; ++j ) {
      SplitComputesMsg *msg = splitComputesMsgs[j];
      if ( msg->maxUnsplit > maxUnsplit ) { maxUnsplit = msg->maxUnsplit; }
      if ( msg->maxCompute > maxCompute ) { maxCompute = msg->maxCompute; maxComputeId = msg->maxComputeId; }
      averageLoad += msg->averageLoad * msg->numPesAvailable;
      numPesAvailable += msg->numPesAvailable;
      avgCompute += msg->avgCompute * msg->nMoveableComputes;
      nMoveableComputes += msg->nMoveableComputes;
      nToSplit += msg->n;
    }
    
    averageLoad /= numPesAvailable;
    if ( nMoveableComputes ) avgCompute /= nMoveableComputes; else avgCompute = 0.;

    CkPrintf("LDB: Largest compute %d load %f is %.1f%% of average load %f\n",
            maxComputeId, maxCompute, 100. * maxCompute / averageLoad, averageLoad);
    CkPrintf("LDB: Average compute %f is %.1f%% of average load %f\n",
            avgCompute, 100. * avgCompute / averageLoad, averageLoad);

    if ( ! nToSplit ) {
      for ( int j=0; j < children; ++j ) {
        delete splitComputesMsgs[j];
      }
    } else {
      // partitions are stored as char but mostly limited by
      // high load noise at low outer-loop iteration counts
      int maxParts = 10;
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
//split LCPO compute very small, else CUDA compute is delayed
      if (simParams->LCPOOn) {
        maxParts = 20;
      }
#endif
      int totalAddedParts = 0;
      maxCompute = averageLoad / 10.;
      if ( maxCompute < 2. * avgCompute ) maxCompute = 2. * avgCompute;
      if ( simParams->ldbRelativeGrainsize > 0. ) {
        maxCompute = averageLoad * simParams->ldbRelativeGrainsize;
      }
      CkPrintf("LDB: Partitioning computes with target load %f\n", maxCompute);

      for ( int j=0; j < children; ++j ) {
        SplitComputesMsg *msg = splitComputesMsgs[j];
        for (int i=0; i < msg->n; ++i) {
          int nparts = (int) ceil(msg->load[i] / maxCompute);
          if ( nparts > maxParts ) nparts = maxParts;
          if ( nparts < 1 ) nparts = 1;
          computeMap->setNewNumPartitions(msg->cid[i],nparts);
          totalAddedParts += nparts - 1;
        }
        delete msg;
      }

      CkPrintf("LDB: Increased migratable compute count from %d to %d\n",
              nMoveableComputes,nMoveableComputes+totalAddedParts);
      CkPrintf("LDB: Largest unpartitionable compute is %f\n", maxUnsplit);
    }
  }
}

UpdateLocalLBInfo()

void NamdHybridLB::UpdateLocalLBInfo

(

LocalLBInfoMsg *

msg

)

Updates the compute map with the migration information from its children.

Definition at line 178 of file NamdHybridLB.C.

References LocalLBInfoMsg::cpuloads, cpuloads, LdbIdField(), LocalLBInfoMsg::moves, LocalLBInfoMsg::n_moves, ComputeMap::Object(), ComputeMap::setNewNode(), and LocalLBInfoMsg::startPE.

                                                       {
        int children;
        int i;

        // getting the number of children
        children = tree->numNodes(currentLevel);
        // CkPrintf("[%d] Updating compute map, total %d\n",CkMyPe(),siblings);

        // getting the compute map to insert the changes coming from the children
        ComputeMap *computeMap = ComputeMap::Object();

        // traversing the set of moves in msg
        for(i=0; i<msg->n_moves; i++){
            if (msg->moves[i].to_pe != -1)
                computeMap->setNewNode(LdbIdField(msg->moves[i].obj.id, 0),msg->moves[i].to_pe);
        }

        // CODING
        // updating cpuloads array
        for(i=msg->startPE; i<=msg->endPE; i++){
                cpuloads[i] = msg->cpuloads[i-msg->startPE];
        }

        // checking if all children have sent the update
        updateCount++;
        if(updateCount == children){
                updateCount = 0;
                updateFlag = true;
                 // CkPrintf("[%d] UPDATE READY\n",CkMyPe());           
        }

        // checking if the collect info is ready
        if(updateFlag && collectFlag){
                updateFlag = false;
                collectFlag = false;    
                thisProxy[parent_backup].CollectInfo(loc_backup, n_backup, fromlevel_backup);
        }

        delete msg;
}

---

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

• NamdHybridLB.h
• NamdHybridLB.C