ComputeMap Class Reference

#include <ComputeMap.h>

Classes
struct	ComputeData
struct	PatchRec

Public Types
enum	{ numPidsAllocated =8 }

Public Member Functions
void	checkMap ()
	~ComputeMap (void)
void	registerCompute (ComputeID cid, Compute *c)
int	numComputes (void)
int	node (ComputeID cid)
void	setNode (ComputeID cid, NodeID node)
NodeID	newNode (ComputeID cid)
void	setNewNode (ComputeID cid, NodeID node)
int	numPids (ComputeID cid)
int	pid (ComputeID cid, int i)
int	trans (ComputeID cid, int i)
ComputeType	type (ComputeID cid)
int	partition (ComputeID cid)
int	numPartitions (ComputeID cid)
void	setNumPartitions (ComputeID cid, char numPartitions)
char	newNumPartitions (ComputeID cid)
void	setNewNumPartitions (ComputeID cid, char numPartitions)
int	allocateCids ()
ComputeID	storeCompute (int node, int maxPids, ComputeType type, int partition=-1, int numPartitions=0)
void	newPid (ComputeID cid, int pid, int trans=13)
ComputeID	cloneCompute (ComputeID src, int partition)
void	printComputeMap (void)
void	saveComputeMap (const char *fname)
void	loadComputeMap (const char *fname)
Compute *	compute (ComputeID cid)

Static Public Member Functions
static ComputeMap *	Instance ()
static ComputeMap *	Object ()

Protected Member Functions
void	pack (MOStream *msg)
void	unpack (MIStream *msg)
void	initPtrs ()
void	extendPtrs ()
	ComputeMap (void)

Friends
class	ComputeMgr
class	WorkDistrib

Detailed Description

Definition at line 85 of file ComputeMap.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
numPidsAllocated

Definition at line 183 of file ComputeMap.h.

{ numPidsAllocated=8 };

Constructor & Destructor Documentation

~ComputeMap()

ComputeMap::~ComputeMap

(

void

)

Definition at line 40 of file ComputeMap.C.

{
  delete [] computePtrs;
}

ComputeMap()

ComputeMap::ComputeMap ( void  )

protected

Definition at line 33 of file ComputeMap.C.

Referenced by Instance().

{
  nComputes=0;
  computePtrs=0;
}

Member Function Documentation

allocateCids()

int ComputeMap::allocateCids

(

)

Definition at line 141 of file ComputeMap.C.

Referenced by WorkDistrib::mapComputes().

{
  nComputes = 0;
  computeData.resize(500);
  computeData.resize(0);

  return 0;
}

checkMap()

void ComputeMap::checkMap

(

void

)

Definition at line 46 of file ComputeMap.C.

References DebugM.

Referenced by ComputeMgr::updateLocalComputes5().

{
  int computeCount = nComputes;
  for (int i=0; i<nComputes; i++) {
    if (computePtrs[i]) {
      computeCount++;
      if (! (computePtrs[i]->cid == i)) {
        DebugM(4, "ComputeID("<<computePtrs[i]->cid<<") != ComputeID("
          << i <<")\n");
      }
    }
  }
  DebugM(4, "Compute Count = " << computeCount << "\n");
}

cloneCompute()

ComputeID ComputeMap::cloneCompute	(	ComputeID	src,
		int	partition
	)

Definition at line 183 of file ComputeMap.C.

References partition().

Referenced by ComputeMgr::splitComputes().

{
  const int cid = computeData.size();
  computeData.resize(cid+1);

  computeData[cid] = computeData[src];
  computeData[cid].partition = partition;
  computeData[cid].node = -1;

  return cid;
}

compute()

Compute* ComputeMap::compute ( ComputeID  cid )

inline

Definition at line 171 of file ComputeMap.h.

Referenced by LdbCoordinator::initialize(), and ComputeMgr::updateLocalComputes().

{ return computePtrs[cid]; };

extendPtrs()

void ComputeMap::extendPtrs ( )

protected

Definition at line 87 of file ComputeMap.C.

References NAMD_bug().

Referenced by ComputeMgr::splitComputes().

                            {
  if ( ! computePtrs ) NAMD_bug("ComputeMap::extendPtrs() 1");
  int oldN = nComputes;
  nComputes = computeData.size();
  if ( nComputes > oldN ) {
    Compute **oldPtrs = computePtrs;
    computePtrs = new Compute*[nComputes];
    memcpy(computePtrs, oldPtrs, oldN*sizeof(Compute*));
    memset(computePtrs+oldN, 0, (nComputes-oldN)*sizeof(Compute*));
    delete [] oldPtrs;
  }
}

initPtrs()

void ComputeMap::initPtrs ( )

protected

Definition at line 80 of file ComputeMap.C.

Referenced by WorkDistrib::sendComputeMap().

                          {
  if ( ! computePtrs ) {
    computePtrs = new Compute*[nComputes];
    memset(computePtrs, 0, nComputes*sizeof(Compute*));
  }
}

Instance()

ComputeMap * ComputeMap::Instance ( )

static

Definition at line 24 of file ComputeMap.C.

References ComputeMap().

Referenced by Node::Node().

                                 {
  if (instance == 0) {
    instance = new ComputeMap;  // this is never deleted
  }
  return instance;
}

loadComputeMap()

void ComputeMap::loadComputeMap

(

const char *

fname

)

Definition at line 276 of file ComputeMap.C.

References node().

Referenced by WorkDistrib::mapComputes().

{
  FILE *fp = fopen(fname, "r");
  CmiAssert(fp != NULL);
  int n;
  fscanf(fp, "%d\n", &n);
  CmiAssert(n == nComputes);
  for(int i=0; i < nComputes; i++)
  {
    fscanf(fp, "%d\n", &computeData[i].node);
  }
  fclose(fp);
}

newNode()

NodeID ComputeMap::newNode ( ComputeID  cid )

inline

Definition at line 116 of file ComputeMap.h.

Referenced by WorkDistrib::recvComputeMapChanges(), ComputeMgr::splitComputes(), ComputeMgr::updateLocalComputes(), and ComputeMgr::updateLocalComputes3().

                                       {
    return (computeData[cid].moveToNode);
  }

newNumPartitions()

char ComputeMap::newNumPartitions ( ComputeID  cid )

inline

Definition at line 141 of file ComputeMap.h.

Referenced by WorkDistrib::recvComputeMapChanges(), ComputeMgr::splitComputes(), and ComputeMgr::updateLocalComputes().

                                              {
    return (computeData[cid].newNumPartitions);
  }

newPid()

void ComputeMap::newPid	(	ComputeID	cid,
		int	pid,
		int	trans = 13
	)

Definition at line 196 of file ComputeMap.C.

References pid(), and trans().

{
  computeData[cid].pids[computeData[cid].numPids].pid=pid;
  computeData[cid].pids[computeData[cid].numPids].trans=trans;
  computeData[cid].numPids++;
}

node()

int ComputeMap::node ( ComputeID  cid )

inline

Definition at line 106 of file ComputeMap.h.

Referenced by ProxyMgr::createProxies(), LdbCoordinator::initialize(), loadComputeMap(), Node::outputPatchComputeMaps(), printComputeMap(), saveComputeMap(), setNewNode(), setNode(), ComputeMgr::splitComputes(), and ComputeMgr::updateLocalComputes().

                                 {
    return computeData[cid].node;
  }

numComputes()

int ComputeMap::numComputes ( void  )

inline

Definition at line 101 of file ComputeMap.h.

Referenced by ProxyMgr::createProxies(), dumpbench(), LdbCoordinator::initialize(), Node::outputPatchComputeMaps(), WorkDistrib::recvComputeMapChanges(), registerUserEventsForAllComputeObjs(), ComputeMgr::splitComputes(), Node::startup(), NamdCentLB::Strategy(), ComputeMgr::updateLocalComputes(), and ComputeMgr::updateLocalComputes3().

                               {
    return nComputes;
  }

numPartitions()

int ComputeMap::numPartitions

(

ComputeID

cid

)

Definition at line 133 of file ComputeMap.C.

References computeErrorType.

Referenced by setNewNumPartitions(), setNumPartitions(), ComputeMgr::splitComputes(), storeCompute(), and NamdCentLB::Strategy().

{
  if (nComputes)
    return computeData[cid].numPartitions;
  else return computeErrorType;
}

numPids()

int ComputeMap::numPids

(

ComputeID

cid

)

Definition at line 101 of file ComputeMap.C.

Referenced by ProxyMgr::createProxies(), LdbCoordinator::initialize(), printComputeMap(), and ComputeMgr::updateLocalComputes().

{
    return computeData[cid].numPids;
}

Object()

static ComputeMap* ComputeMap::Object ( )

inlinestatic

Definition at line 89 of file ComputeMap.h.

Referenced by Compute::Compute(), ProxyMgr::createProxies(), dumpbench(), WorkDistrib::mapComputes(), Node::outputPatchComputeMaps(), WorkDistrib::recvComputeMapChanges(), registerUserEventsForAllComputeObjs(), LdbCoordinator::resume(), WorkDistrib::sendComputeMap(), NamdHybridLB::splitComputes(), ComputeMgr::splitComputes(), Node::startup(), NamdCentLB::Strategy(), ComputeMgr::updateLocalComputes(), ComputeMgr::updateLocalComputes3(), ComputeMgr::updateLocalComputes4(), ComputeMgr::updateLocalComputes5(), and NamdHybridLB::UpdateLocalLBInfo().

{ return instance; }

pack()

void ComputeMap::pack ( MOStream *  msg )

protected

Definition at line 61 of file ComputeMap.C.

References DebugM, and MOStream::put().

Referenced by WorkDistrib::sendComputeMap().

{
  DebugM(4,"Packing ComputeMap\n");
  msg->put(nComputes);
  msg->put(nComputes,computeData.begin());
}

partition()

int ComputeMap::partition

(

ComputeID

cid

)

Definition at line 126 of file ComputeMap.C.

References computeErrorType.

Referenced by cloneCompute(), dumpbench(), and storeCompute().

{
  if (nComputes)
    return computeData[cid].partition;
  else return computeErrorType;
}

pid()

int ComputeMap::pid	(	ComputeID	cid,
		int	i
	)

Definition at line 107 of file ComputeMap.C.

Referenced by ProxyMgr::createProxies(), dumpbench(), LdbCoordinator::initialize(), newPid(), Node::outputPatchComputeMaps(), printComputeMap(), registerUserEventsForAllComputeObjs(), and ComputeMgr::updateLocalComputes().

{
    return computeData[cid].pids[i].pid;
}

printComputeMap()

void ComputeMap::printComputeMap

(

void

)

Definition at line 204 of file ComputeMap.C.

References DebugM, node(), numPids(), pid(), and type().

{
  DebugM(2,"---------------------------------------");
  DebugM(2,"---------------------------------------\n");

  DebugM(2,"nComputes = " << nComputes << '\n');
  DebugM(2,"nAllocated = " << nComputes << '\n');
  for(int i=0; i < nComputes; i++)
  {
    DebugM(2,"Compute " << i << '\n');
    DebugM(2,"  node = " << computeData[i].node << '\n');
    DebugM(2,"  numPids = " << computeData[i].numPids << '\n');
    for(int j=0; j < computeData[i].numPids; j++)
    {
      DebugM(2,computeData[i].pids[j].pid);
      if (!((j+1) % 6))
        DebugM(2,'\n');
    }
    DebugM(2,"\n---------------------------------------");
    DebugM(2,"---------------------------------------\n");

  }

#ifdef MEM_OPT_VERSION
const char *fname = "computeMap.opt";
#else
const char *fname = "computeMap.orig";
#endif

  FILE *ofp = fopen(fname, "w");
  fprintf(ofp,"---------------------------------------");
  fprintf(ofp,"---------------------------------------\n");

  fprintf(ofp,"nComputes = %d\n", nComputes);
  fprintf(ofp,"nAllocated = %d\n", nComputes);
  for(int i=0; i < nComputes; i++)
  {
    fprintf(ofp,"Compute %d\n", i);
    fprintf(ofp,"  node = %d\n",computeData[i].node);
    fprintf(ofp,"  numPids = %d\n",computeData[i].numPids);
        fprintf(ofp,"  type = %d\n",computeData[i].type);
    for(int j=0; j < computeData[i].numPids; j++)
    {
      fprintf(ofp,"%d ",computeData[i].pids[j].pid);
      if (!((j+1) % 6))
        fprintf(ofp,"\n");
    }
    fprintf(ofp,"\n---------------------------------------");
    fprintf(ofp,"---------------------------------------\n");

  }

fclose(ofp);

}

registerCompute()

void ComputeMap::registerCompute ( ComputeID  cid, Compute *  c  )

inline

Definition at line 95 of file ComputeMap.h.

Referenced by ComputeMgr::updateLocalComputes().

                                                  {
    computePtrs[cid] = c;
  }

saveComputeMap()

void ComputeMap::saveComputeMap

(

const char *

fname

)

Definition at line 260 of file ComputeMap.C.

References node().

Referenced by WorkDistrib::mapComputes(), and ComputeMgr::updateLocalComputes4().

{
  static int count = 0;
  char f[128];
  sprintf(f, "%s.%d", fname, count++);
  FILE *fp = fopen(f, "w");
  CmiAssert(fp != NULL);
  fprintf(fp, "%d\n", nComputes);
  for(int i=0; i < nComputes; i++)
  {
    fprintf(fp, "%d\n", computeData[i].node);
  }
  fclose(fp);
  CkPrintf("ComputeMap has been stored in %s.\n", f);
}

setNewNode()

void ComputeMap::setNewNode ( ComputeID  cid, NodeID  node  )

inline

Definition at line 120 of file ComputeMap.h.

References node().

Referenced by WorkDistrib::recvComputeMapChanges(), ComputeMgr::splitComputes(), NamdCentLB::Strategy(), ComputeMgr::updateLocalComputes3(), and NamdHybridLB::UpdateLocalLBInfo().

                                                     {
    computeData[cid].moveToNode = node;
  }

setNewNumPartitions()

void ComputeMap::setNewNumPartitions ( ComputeID  cid, char  numPartitions  )

inline

Definition at line 144 of file ComputeMap.h.

References numPartitions().

Referenced by WorkDistrib::recvComputeMapChanges(), NamdHybridLB::splitComputes(), ComputeMgr::splitComputes(), NamdCentLB::Strategy(), and ComputeMgr::updateLocalComputes3().

                                                                     {
    computeData[cid].newNumPartitions = numPartitions;
  }

setNode()

void ComputeMap::setNode ( ComputeID  cid, NodeID  node  )

inline

Definition at line 110 of file ComputeMap.h.

References node().

Referenced by ComputeMgr::updateLocalComputes3().

                                                  {
    computeData[cid].node = node;
  }

setNumPartitions()

void ComputeMap::setNumPartitions ( ComputeID  cid, char  numPartitions  )

inline

Definition at line 138 of file ComputeMap.h.

References numPartitions().

Referenced by ComputeMgr::splitComputes().

                                                                  {
    computeData[cid].numPartitions = numPartitions;
  }

storeCompute()

ComputeID ComputeMap::storeCompute	(	int	node,
		int	maxPids,
		ComputeType	type,
		int	partition = -1,
		int	numPartitions = 0
	)

Definition at line 151 of file ComputeMap.C.

References NAMD_bug(), numPartitions(), numPidsAllocated, partition(), and type().

{
  if (maxPids > numPidsAllocated) {
    NAMD_bug("ComputeMap::storeCompute called with maxPids > numPidsAllocated");
  }

  int cid;

  cid = nComputes;
  nComputes++;
  computeData.resize(nComputes);

  computeData[cid].node=inode;

  computeData[cid].type = type;
  computeData[cid].partition = partition;
  computeData[cid].numPartitions = numPartitions;

  computeData[cid].numPids = 0;

  #if defined(NAMD_MIC)
    // Initially in MIC runs, all computes are mapped to the host.  The host vs
    //   device LDB scheme will change this mapping later.
    computeData[cid].directToDevice = 0;
  #endif

  return cid;
}

trans()

int ComputeMap::trans	(	ComputeID	cid,
		int	i
	)

Definition at line 112 of file ComputeMap.C.

Referenced by dumpbench(), newPid(), and registerUserEventsForAllComputeObjs().

{
    return computeData[cid].pids[i].trans;
}

type()

ComputeType ComputeMap::type

(

ComputeID

cid

)

Definition at line 118 of file ComputeMap.C.

References computeErrorType.

Referenced by Compute::Compute(), ComputeMgr::createComputes(), ProxyMgr::createProxies(), dumpbench(), LdbCoordinator::initialize(), Node::outputPatchComputeMaps(), printComputeMap(), registerUserEventsForAllComputeObjs(), and storeCompute().

{
  if (nComputes)
    return computeData[cid].type;
  else return computeErrorType;
}

unpack()

void ComputeMap::unpack ( MIStream *  msg )

protected

Definition at line 68 of file ComputeMap.C.

References DebugM, MIStream::get(), and NAMD_bug().

Referenced by WorkDistrib::sendComputeMap().

{
  DebugM(4,"Unpacking ComputeMap\n");
  int old = nComputes;
  msg->get(nComputes);
  if ( old && old != nComputes ) {
    NAMD_bug("number of computes in new ComputeMap has changed!\n");
  }
  computeData.resize(nComputes);
  msg->get(nComputes,computeData.begin());
}

Friends And Related Function Documentation

ComputeMgr

friend class ComputeMgr

friend

Definition at line 171 of file ComputeMap.h.

WorkDistrib

friend class WorkDistrib

friend

Definition at line 208 of file ComputeMap.h.

---

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

• ComputeMap.h
• ComputeMap.C