MsmC1HermiteBlock Class Reference

Inheritance diagram for MsmC1HermiteBlock:

Public Member Functions
	MsmC1HermiteBlock (int level)
	MsmC1HermiteBlock (CkMigrateMessage *m)
void	setupSections ()
void	sumReducedPotential (CkReductionMsg *msg)
void	addCharge (GridMsg *)
void	restriction ()
void	sendUpCharge ()
void	gridCutoff ()
void	addPotential (GridMsg *)
void	prolongation ()
void	sendDownPotential ()
void	sendPatch ()
Public Member Functions inherited from MsmBlockKernel< C1Vector, C1Matrix >
	MsmBlockKernel (const msm::BlockIndex &)
	MsmBlockKernel (CkMigrateMessage *m)
void	init ()
void	setupStencils (const msm::Grid< C1Matrix > *res, const msm::Grid< C1Matrix > *pro)
void	restrictionKernel ()
void	prolongationKernel ()

Public Attributes
CProxySection_MsmC1HermiteGridCutoff	msmGridCutoffBroadcast
CProxySection_MsmC1HermiteGridCutoff	msmGridCutoffReduction
Public Attributes inherited from MsmBlockKernel< C1Vector, C1Matrix >
CProxy_ComputeMsmMgr	mgrProxy
ComputeMsmMgr *	mgrLocal
msm::Map *	map
msm::BlockDiagram *	bd
msm::Grid< C1Vector >	qh
msm::Grid< C1Vector >	eh
const msm::Grid< C1Matrix > *	resStencil
const msm::Grid< C1Matrix > *	proStencil
msm::Grid< C1Vector >	qhRestricted
msm::Grid< C1Vector >	ehProlongated
int	cntRecvsCharge
int	cntRecvsPotential
msm::BlockIndex	blockIndex
msm::Grid< C1Vector >	subgrid
int	sequence

Detailed Description

Definition at line 3458 of file ComputeMsm.C.

Constructor & Destructor Documentation

MsmC1HermiteBlock::MsmC1HermiteBlock ( int  level )

inline

Definition at line 3466 of file ComputeMsm.C.

References msm::Map::gc_c1hermite, msm::Map::gpro_c1hermite, msm::Map::gres_c1hermite, msm::Map::gridrange, and ComputeMsmMgr::map.

                                 :
      MsmBlockKernel<C1Vector,C1Matrix>(
          msm::BlockIndex(level,
            msm::Ivec(thisIndex.x, thisIndex.y, thisIndex.z))
          )
    {
      int isfirstlevel = (level == 0);
      int istoplevel = (level == map->gridrange.len()-1);
      const msm::Grid<C1Matrix> *res =
        (istoplevel ? NULL : &(map->gres_c1hermite[level]));
      const msm::Grid<C1Matrix> *pro =
        (isfirstlevel ? NULL : &(map->gpro_c1hermite[level-1]));
#ifndef MSM_GRID_CUTOFF_DECOMP
      const msm::Grid<C1Matrix> *gc = &(map->gc_c1hermite[level]);
      setupStencils(res, pro, gc);
#else
      setupStencils(res, pro);
#endif
    }

MsmC1HermiteBlock::MsmC1HermiteBlock ( CkMigrateMessage *  m )

inline

Definition at line 3485 of file ComputeMsm.C.

                                           :
      MsmBlockKernel<C1Vector,C1Matrix>(m) { }

Member Function Documentation

void MsmC1HermiteBlock::addCharge

(

GridMsg *

gm

)

Definition at line 3597 of file ComputeMsm.C.

References MsmTimer::COMM, GridMsg::get(), ComputeMsmMgr::nlevels, restriction(), and ComputeMsmMgr::subgrid.

{
#ifdef MSM_TIMING
  double startTime, stopTime;
  startTime = CkWallTimer();
#endif
  int pid;
  gm->get(subgrid, pid, sequence);
  delete gm;
  qh += subgrid;
#ifdef MSM_TIMING
  stopTime = CkWallTimer();
  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
#endif
  if (++cntRecvsCharge == bd->numRecvsCharge) {
    int nlevels = mgrLocal->numLevels();
    if (blockIndex.level < nlevels-1) {
      restriction();
    }
    gridCutoff();
  }
} // MsmC1HermiteBlock::addCharge()

void MsmC1HermiteBlock::addPotential

(

GridMsg *

gm

)

Definition at line 3748 of file ComputeMsm.C.

References MsmTimer::COMM, GridMsg::get(), prolongation(), and ComputeMsmMgr::subgrid.

{
#ifdef MSM_TIMING
  double startTime, stopTime;
  startTime = CkWallTimer();
#endif
  int pid;
  int pseq;
  gm->get(subgrid, pid, pseq);  // receive sender's level
  delete gm;
  eh += subgrid;
#ifdef MSM_TIMING
  stopTime = CkWallTimer();
  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
#endif
  if (++cntRecvsPotential == bd->numRecvsPotential) {
    if (blockIndex.level > 0) {
      prolongation();
    }
    else {
      sendPatch();
    }
  }
} // MsmC1HermiteBlock::addPotential()

void MsmC1HermiteBlock::gridCutoff

(

)

Definition at line 3656 of file ComputeMsm.C.

References MsmTimer::COMM, MSM_PRIORITY, GridMsg::put(), and SET_PRIORITY.

{
#ifdef DEBUG_MSM_GRID
  printf("MsmC1HermiteBlock level=%d, id=%d %d %d:  grid cutoff\n",
      blockIndex.level, blockIndex.n.i, blockIndex.n.j, blockIndex.n.k);
#endif
#ifndef MSM_GRID_CUTOFF_DECOMP
  gridCutoffKernel();
  sendAcrossPotential();
#else // MSM_GRID_CUTOFF_DECOMP

  // send charge block to MsmGridCutoff compute objects
#ifdef MSM_TIMING
  double startTime, stopTime;
  startTime = CkWallTimer();
#endif
  int priority = mgrLocal->nlevels + 2*(mgrLocal->nlevels - blockIndex.level)-1;
  int msgsz = qh.data().len() * sizeof(C1Vector);
  int len = bd->indexGridCutoff.len();

#if 0
  // send charge message to each MsmGridCutoff compute element in list
  for (int n = 0;  n < len;  n++) {
#ifdef MSM_TIMING
    startTime = CkWallTimer();
#endif
    int index = bd->indexGridCutoff[n];
    GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
    SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
    gm->put(qh, blockIndex.level, sequence);  // send my level
#ifdef MSM_TIMING
    stopTime = CkWallTimer();
    mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
#endif
    mgrLocal->msmGridCutoff[index].compute(gm);
  }
#else

  // broadcast charge message to section
  GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
  SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
  gm->put(qh, blockIndex.level, sequence);  // send my level
  msmGridCutoffBroadcast.compute(gm);
#ifdef MSM_TIMING
  stopTime = CkWallTimer();
  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
#endif

#endif // 0

#endif // MSM_GRID_CUTOFF_DECOMP

} // MsmC1HermiteBlock::gridCutoff()

void MsmC1HermiteBlock::prolongation ( )

inline

Definition at line 3526 of file ComputeMsm.C.

                        {
      prolongationKernel();
      sendDownPotential();
    }

void MsmC1HermiteBlock::restriction ( )

inline

Definition at line 3514 of file ComputeMsm.C.

                       {
      restrictionKernel();
      sendUpCharge();
    }

void MsmC1HermiteBlock::sendDownPotential

(

)

Definition at line 3774 of file ComputeMsm.C.

References ComputeMsmMgr::addPotential(), ASSERT, MsmTimer::COMM, msm::Ivec::i, msm::Grid< T >::init(), msm::Ivec::j, msm::Ivec::k, msm::BlockIndex::level, MSM_PRIORITY, msm::BlockIndex::n, msm::IndexRange::nn(), GridMsg::put(), SET_PRIORITY, ComputeMsmMgr::subgrid, and msm::Grid< T >::updateLower().

{
#ifdef MSM_TIMING
  double startTime, stopTime;
  startTime = CkWallTimer();
#endif
  int lnext = blockIndex.level - 1;
  int priority = mgrLocal->nlevels + 2*(mgrLocal->nlevels - blockIndex.level);
  // buffer portions of grid to send to Blocks on next level
  for (int n = 0;  n < bd->sendDown.len();  n++) {
    // initialize the proper subgrid indexing range
    subgrid.init( bd->sendDown[n].nrange );
    // extract the values from the larger grid into the subgrid
    ehProlongated.extract(subgrid);
    // translate the subgrid indexing range to match the MSM block
    subgrid.updateLower( bd->sendDown[n].nrange_wrap.lower() );
    // add the subgrid charges into the block
    msm::BlockIndex& bindex = bd->sendDown[n].nblock_wrap;
    ASSERT(bindex.level == lnext);
    // place subgrid into message
    int msgsz = subgrid.nn() * sizeof(C1Vector);
    GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
    SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
    gm->put(subgrid, blockIndex.level, sequence);  // send my level
    // lookup in ComputeMsmMgr proxy array by level
    mgrLocal->msmC1HermiteBlock[lnext](
        bindex.n.i, bindex.n.j, bindex.n.k).addPotential(gm);
  } // for
#ifdef MSM_TIMING
  stopTime = CkWallTimer();
  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
  mgrLocal->doneTiming();
#endif
  init();  // reinitialize for next computation
} // MsmC1HermiteBlock::sendDownPotential()

void MsmC1HermiteBlock::sendPatch

(

)

Definition at line 3811 of file ComputeMsm.C.

References ASSERT, MsmTimer::COMM, msm::Grid< T >::init(), MSM_PRIORITY, msm::IndexRange::nn(), PatchMap::node(), PatchMap::Object(), GridMsg::put(), SET_PRIORITY, ComputeMsmMgr::subgrid, and msm::Grid< T >::updateLower().

{
#ifdef MSM_TIMING
  double startTime, stopTime;
  startTime = CkWallTimer();
#endif
  int lnext = blockIndex.level;
  int priority = mgrLocal->nlevels + 2*(mgrLocal->nlevels - blockIndex.level);
  ASSERT(lnext == 0);
  // buffer portions of grid to send to Blocks on next level
  for (int n = 0;  n < bd->sendPatch.len();  n++) {
    // initialize the proper subgrid indexing range
    subgrid.init( bd->sendPatch[n].nrange );
    // extract the values from the larger grid into the subgrid
    eh.extract(subgrid);
    // translate the subgrid indexing range to match the MSM block
    subgrid.updateLower( bd->sendPatch[n].nrange_unwrap.lower() );
    // add the subgrid charges into the block, need its patch ID
    int pid = bd->sendPatch[n].patchID;
    // place subgrid into message
    int msgsz = subgrid.nn() * sizeof(C1Vector);
    GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
    SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
    gm->put(subgrid, pid, sequence);  // send patch ID
    // lookup which PE has this patch
    PatchMap *pm = PatchMap::Object();
    int pe = pm->node(pid);
    mgrProxy[pe].addPotential(gm);
  }
#ifdef MSM_TIMING
  stopTime = CkWallTimer();
  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
  mgrLocal->doneTiming();
#endif
  init();  // reinitialize for next computation
} // MsmC1HermiteBlock::sendPatch()

void MsmC1HermiteBlock::sendUpCharge

(

)

Definition at line 3621 of file ComputeMsm.C.

References ASSERT, MsmTimer::COMM, msm::Ivec::i, msm::Grid< T >::init(), msm::Ivec::j, msm::Ivec::k, msm::BlockIndex::level, MSM_PRIORITY, msm::BlockIndex::n, msm::IndexRange::nn(), GridMsg::put(), SET_PRIORITY, ComputeMsmMgr::subgrid, and msm::Grid< T >::updateLower().

{
#ifdef MSM_TIMING
  double startTime, stopTime;
  startTime = CkWallTimer();
#endif
  int lnext = blockIndex.level + 1;
  // buffer portions of grid to send to Blocks on next level
  for (int n = 0;  n < bd->sendUp.len();  n++) {
    // initialize the proper subgrid indexing range
    subgrid.init( bd->sendUp[n].nrange );
    // extract the values from the larger grid into the subgrid
    qhRestricted.extract(subgrid);
    // translate the subgrid indexing range to match the MSM block
    subgrid.updateLower( bd->sendUp[n].nrange_wrap.lower() );
    // add the subgrid charges into the block
    msm::BlockIndex& bindex = bd->sendUp[n].nblock_wrap;
    ASSERT(bindex.level == lnext);
    // place subgrid into message
    // SET MESSAGE PRIORITY
    int msgsz = subgrid.nn() * sizeof(C1Vector);
    GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
    SET_PRIORITY(gm, sequence, MSM_PRIORITY + lnext);
    gm->put(subgrid, blockIndex.level, sequence);  // send my level
    // lookup in ComputeMsmMgr proxy array by level
    mgrLocal->msmC1HermiteBlock[lnext](
        bindex.n.i, bindex.n.j, bindex.n.k).addCharge(gm);
  } // for
#ifdef MSM_TIMING
  stopTime = CkWallTimer();
  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
#endif
} // MsmC1HermiteBlock::sendUpCharge()

void MsmC1HermiteBlock::setupSections

(

)

Definition at line 3535 of file ComputeMsm.C.

References MsmC1HermiteGridCutoffSetupMsg::put().

{
#ifdef DEBUG_MSM_GRID
  CkPrintf("LEVEL %d MSM C1 HERMITE BLOCK (%d,%d,%d):  "
      "creating broadcast section on PE %d\n",
      blockIndex.level, thisIndex.x, thisIndex.y, thisIndex.z, CkMyPe());
#endif
  std::vector<CkArrayIndex1D> elems;
  elems.reserve(bd->indexGridCutoff.len());
  for (int n = 0;  n < bd->indexGridCutoff.len();  n++) {
    elems.emplace_back(bd->indexGridCutoff[n]);
  }
  msmGridCutoffBroadcast = CProxySection_MsmC1HermiteGridCutoff::ckNew(
      mgrLocal->msmC1HermiteGridCutoff, elems.data(), elems.size()
      );
  CProxy_CkMulticastMgr mcastProxy = CkpvAccess(BOCclass_group).multicastMgr;
  CkMulticastMgr *mcastPtr = CProxy_CkMulticastMgr(mcastProxy).ckLocalBranch();
  msmGridCutoffBroadcast.ckSectionDelegate(mcastPtr);
  
#ifdef DEBUG_MSM_GRID
  char s[1024];
  sprintf(s, "LEVEL %d MSM C1 HERMITE BLOCK (%d,%d,%d):  "
      "creating reduction section on PE %d\n",
      blockIndex.level, thisIndex.x, thisIndex.y, thisIndex.z, CkMyPe());
#endif
  std::vector<CkArrayIndex1D> elems2;
  elems2.reserve(bd->recvGridCutoff.len());
#ifdef DEBUG_MSM_GRID
  strcat(s, "receiving from MsmC1HermiteGridCutoff ID:");
#endif
  for (int n = 0;  n < bd->recvGridCutoff.len();  n++) {
#ifdef DEBUG_MSM_GRID
    char t[20];
    sprintf(t, "  %d", bd->recvGridCutoff[n]);
    strcat(s, t);
#endif
    elems2.emplace_back(bd->recvGridCutoff[n]);
  }
#ifdef DEBUG_MSM_GRID
  strcat(s, "\n");
  CkPrintf(s);
#endif
  msmGridCutoffReduction = CProxySection_MsmC1HermiteGridCutoff::ckNew(
      mgrLocal->msmC1HermiteGridCutoff, elems2.data(), elems2.size()
      );
  msmGridCutoffReduction.ckSectionDelegate(mcastPtr);
  MsmC1HermiteGridCutoffSetupMsg *msg = new MsmC1HermiteGridCutoffSetupMsg;
  CProxyElement_MsmC1HermiteBlock thisElementProxy = thisProxy(thisIndex);
  msg->put(&thisElementProxy);

  msmGridCutoffReduction.setupSections(msg);  // broadcast to entire section

  /* XXX alternatively, setup default reduction client
   *
  mcastPtr->setReductionClient(msmGridCutoffReduction,
      new CkCallback(CkIndex_MsmC1HermiteBlock::myReductionEntry(NULL),
        thisElementProxy));
   *
   */
} // MsmC1HermiteBlock::setupSections()

void MsmC1HermiteBlock::sumReducedPotential ( CkReductionMsg *  msg )

inline

Definition at line 3490 of file ComputeMsm.C.

References ComputeMsmMgr::addPotential(), msm::Array< T >::buffer(), MsmTimer::COMM, msm::Grid< T >::data(), msm::Grid< T >::init(), msm::Array< T >::len(), MSM_PRIORITY, GridMsg::put(), and SET_PRIORITY.

                                                  {
#ifdef MSM_TIMING
      double startTime, stopTime;
      startTime = CkWallTimer();
#endif
      msm::Grid<C1Vector> ehfull;
      ehfull.init( msm::IndexRange(eh) );
      memcpy(ehfull.data().buffer(), msg->getData(), msg->getSize());
      delete msg;
      int priority = mgrLocal->nlevels
        + 2*(mgrLocal->nlevels - blockIndex.level)-1;
      int msgsz = ehfull.data().len() * sizeof(C1Vector);
      GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
      SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
      gm->put(ehfull, blockIndex.level, sequence);  // send my level
#ifdef MSM_TIMING
      stopTime = CkWallTimer();
      mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
#endif
      addPotential(gm);
    }

Member Data Documentation

CProxySection_MsmC1HermiteGridCutoff MsmC1HermiteBlock::msmGridCutoffBroadcast

Definition at line 3463 of file ComputeMsm.C.

CProxySection_MsmC1HermiteGridCutoff MsmC1HermiteBlock::msmGridCutoffReduction

Definition at line 3464 of file ComputeMsm.C.

---

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

• ComputeMsm.C