ComputePmeMgr Class Reference

Inheritance diagram for ComputePmeMgr:

List of all members.

Public Member Functions
	ComputePmeMgr ()
	~ComputePmeMgr ()
void	initialize (CkQdMsg *)
void	initialize_pencils (CkQdMsg *)
void	activate_pencils (CkQdMsg *)
void	recvArrays (CProxy_PmeXPencil, CProxy_PmeYPencil, CProxy_PmeZPencil)
void	sendGrid (void)
void	recvGrid (PmeGridMsg *)
void	gridCalc1 (void)
void	sendTransBarrier (void)
void	sendTrans (void)
void	fwdSharedTrans (PmeTransMsg *)
void	recvSharedTrans (PmeSharedTransMsg *)
void	recvTrans (PmeTransMsg *)
void	procTrans (PmeTransMsg *)
void	gridCalc2 (void)
void	gridCalc2R (void)
void	fwdSharedUntrans (PmeUntransMsg *)
void	recvSharedUntrans (PmeSharedUntransMsg *)
void	sendUntrans (void)
void	recvUntrans (PmeUntransMsg *)
void	procUntrans (PmeUntransMsg *)
void	gridCalc3 (void)
void	sendUngrid (void)
void	recvUngrid (PmeGridMsg *)
void	recvAck (PmeAckMsg *)
void	ungridCalc (void)
void	setCompute (ComputePme *c)
int	isPmeProcessor (int p)
Static Public Attributes
CmiNodeLock	fftw_plan_lock
Friends
class	ComputePme
class	NodePmeMgr

---

Constructor & Destructor Documentation

ComputePmeMgr::ComputePmeMgr (   )

Definition at line 527 of file ComputePme.C. References fftw_plan_lock. : pmeProxy(thisgroup), pmeProxyDir(thisgroup), pmeCompute(0) { CkpvAccess(BOCclass_group).computePmeMgr = thisgroup; pmeNodeProxy = CkpvAccess(BOCclass_group).nodePmeMgr; pmeNodeProxy.ckLocalBranch()->initialize(); #ifdef NAMD_FFTW if ( CmiMyRank() == 0 ) { fftw_plan_lock = CmiCreateLock(); } #endif myKSpace = 0; kgrid = 0; work = 0; grid_count = 0; trans_count = 0; untrans_count = 0; ungrid_count = 0; gridmsg_reuse= new PmeGridMsg*[CkNumPes()]; useBarrier = 0; sendTransBarrier_received = 0; usePencils = 0; }

ComputePmeMgr::~ComputePmeMgr (   )

Definition at line 1506 of file ComputePme.C. References fftw_plan_lock. { #ifdef NAMD_FFTW if ( CmiMyRank() == 0 ) { CmiDestroyLock(fftw_plan_lock); } #endif delete myKSpace; delete [] localInfo; delete [] gridNodeInfo; delete [] transNodeInfo; delete [] gridPeMap; delete [] transPeMap; delete [] recipPeDest; delete [] gridPeOrder; delete [] gridNodeOrder; delete [] transNodeOrder; delete [] isPmeFlag; delete [] qgrid; if ( kgrid != qgrid ) delete [] kgrid; delete [] work; delete [] gridmsg_reuse; }

---

Member Function Documentation

void ComputePmeMgr::activate_pencils (  CkQdMsg *   )

Definition at line 1500 of file ComputePme.C. { if ( ! usePencils ) return; if ( CkMyPe() == 0 ) zPencil.dummyRecvGrid(CkMyPe(),1); }

void ComputePmeMgr::fwdSharedTrans (  PmeTransMsg *   )

Definition at line 1704 of file ComputePme.C. References PmeSharedTransMsg::count, PmeSharedTransMsg::lock, PmeSharedTransMsg::msg, NodePmeInfo::npe, NodePmeInfo::pe_start, PME_TRANS_PRIORITY, PmeTransMsg::sequence, and SET_PRIORITY. Referenced by NodePmeMgr::recvTrans(), and sendTrans(). { // CkPrintf("fwdSharedTrans on Pe(%d)\n",CkMyPe()); int pe = transNodeInfo[myTransNode].pe_start; int npe = transNodeInfo[myTransNode].npe; CmiNodeLock lock = CmiCreateLock(); int *count = new int; *count = npe; for (int i=0; i<npe; ++i, ++pe) { PmeSharedTransMsg *shmsg = new (PRIORITY_SIZE) PmeSharedTransMsg; SET_PRIORITY(shmsg,msg->sequence,PME_TRANS_PRIORITY) shmsg->msg = msg; shmsg->count = count; shmsg->lock = lock; pmeProxy[transPeMap[pe]].recvSharedTrans(shmsg); } }

void ComputePmeMgr::fwdSharedUntrans (  PmeUntransMsg *   )

Definition at line 1928 of file ComputePme.C. References PmeSharedUntransMsg::count, PmeSharedUntransMsg::lock, PmeSharedUntransMsg::msg, NodePmeInfo::npe, and NodePmeInfo::pe_start. Referenced by NodePmeMgr::recvUntrans(), and sendUntrans(). { int pe = gridNodeInfo[myGridNode].pe_start; int npe = gridNodeInfo[myGridNode].npe; CmiNodeLock lock = CmiCreateLock(); int *count = new int; *count = npe; for (int i=0; i<npe; ++i, ++pe) { PmeSharedUntransMsg *shmsg = new PmeSharedUntransMsg; shmsg->msg = msg; shmsg->count = count; shmsg->lock = lock; pmeProxy[gridPeMap[pe]].recvSharedUntrans(shmsg); } }

void ComputePmeMgr::gridCalc1 (  void   )

Definition at line 1614 of file ComputePme.C. References PmeGrid::dim2, and PmeGrid::dim3. { // CkPrintf("gridCalc1 on Pe(%d)\n",CkMyPe()); #ifdef NAMD_FFTW for ( int g=0; g<numGrids; ++g ) { #ifdef NAMD_FFTW_3 fftwf_execute(forward_plan_yz[g]); #else rfftwnd_real_to_complex(forward_plan_yz, localInfo[myGridPe].nx, qgrid + qgrid_size * g, 1, myGrid.dim2 * myGrid.dim3, 0, 0, 0); #endif } #endif if ( ! useBarrier ) pmeProxyDir[CkMyPe()].sendTrans(); }

void ComputePmeMgr::gridCalc2 (  void   )

Definition at line 1772 of file ComputePme.C. References PmeGrid::dim3, gridCalc2R(), LocalPmeInfo::ny_after_transpose, and simParams. { // CkPrintf("gridCalc2 on Pe(%d)\n",CkMyPe()); #if CMK_BLUEGENEL CmiNetworkProgressAfter (0); #endif int zdim = myGrid.dim3; // int y_start = localInfo[myTransPe].y_start_after_transpose; int ny = localInfo[myTransPe].ny_after_transpose; for ( int g=0; g<numGrids; ++g ) { // finish forward FFT (x dimension) #ifdef NAMD_FFTW #ifdef NAMD_FFTW_3 fftwf_execute(forward_plan_x[g]); #else fftw(forward_plan_x, ny * zdim / 2, (fftw_complex *)(kgrid+qgrid_size*g), ny * zdim / 2, 1, work, 1, 0); #endif #endif } #ifdef OPENATOM_VERSION if ( ! simParams -> openatomOn ) { #endif // OPENATOM_VERSION gridCalc2R(); #ifdef OPENATOM_VERSION } else { gridCalc2Moa(); } #endif // OPENATOM_VERSION }

void ComputePmeMgr::gridCalc2R (  void   )

Definition at line 1832 of file ComputePme.C. References BigReal, PmeKSpace::compute_energy(), PmeGrid::dim3, and LocalPmeInfo::ny_after_transpose. Referenced by gridCalc2(). { int zdim = myGrid.dim3; // int y_start = localInfo[myTransPe].y_start_after_transpose; int ny = localInfo[myTransPe].ny_after_transpose; for ( int g=0; g<numGrids; ++g ) { // reciprocal space portion of PME BigReal ewaldcof = ComputeNonbondedUtil::ewaldcof; recip_evir2[g][0] = myKSpace->compute_energy(kgrid+qgrid_size*g, lattice, ewaldcof, &(recip_evir2[g][1])); // CkPrintf("Ewald reciprocal energy = %f\n", recip_evir2[g][0]); // start backward FFT (x dimension) #ifdef NAMD_FFTW #ifdef NAMD_FFTW_3 fftwf_execute(backward_plan_x[g]); #else fftw(backward_plan_x, ny * zdim / 2, (fftw_complex *)(kgrid+qgrid_size*g), ny * zdim / 2, 1, work, 1, 0); #endif #endif } pmeProxyDir[CkMyPe()].sendUntrans(); }

void ComputePmeMgr::gridCalc3 (  void   )

Definition at line 2010 of file ComputePme.C. References PmeGrid::dim2, and PmeGrid::dim3. { // CkPrintf("gridCalc3 on Pe(%d)\n",CkMyPe()); // finish backward FFT #ifdef NAMD_FFTW for ( int g=0; g<numGrids; ++g ) { #ifdef NAMD_FFTW_3 fftwf_execute(backward_plan_yz[g]); #else rfftwnd_complex_to_real(backward_plan_yz, localInfo[myGridPe].nx, (fftw_complex *) (qgrid + qgrid_size * g), 1, myGrid.dim2 * myGrid.dim3 / 2, 0, 0, 0); #endif } #endif pmeProxyDir[CkMyPe()].sendUngrid(); }

void ComputePmeMgr::initialize (  CkQdMsg *   )

Definition at line 617 of file ComputePme.C. References Lattice::a(), Lattice::a_r(), ResizeArray< Elem >::add(), SimParameters::alchDecouple, SimParameters::alchElecLambdaStart, SimParameters::alchFepOn, SimParameters::alchThermIntOn, ResizeArray< Elem >::begin(), BigReal, PmeGrid::block1, PmeGrid::block2, PmeGrid::block3, SimParameters::cutoff, PmeGrid::dim2, PmeGrid::dim3, fftw_plan_lock, SimParameters::FFTWEstimate, SimParameters::FFTWPatient, generatePmePeList2(), PmePencilInitMsgData::grid, iINFO(), ResizeArray< Elem >::insert(), iout, j, PmeGrid::K1, PmeGrid::K2, PmeGrid::K3, SimParameters::lattice, SimParameters::lesFactor, SimParameters::lesOn, PatchMap::max_a(), PatchMap::min_a(), NAMD_bug(), NAMD_die(), PatchMap::node(), NodePmeInfo::npe, PatchMap::numNodesWithPatches(), PatchMap::numPatches(), PatchMap::numPatchesOnNode(), LocalPmeInfo::nx, LocalPmeInfo::ny_after_transpose, PatchMap::Object(), Node::Object(), PmeGrid::order, SimParameters::pairInteractionOn, SimParameters::pairInteractionSelf, SimParameters::patchDimension, NodePmeInfo::pe_start, pencilPMEProcessors, SimParameters::PMEBarrier, SimParameters::PMEGridSizeX, SimParameters::PMEGridSizeY, SimParameters::PMEGridSizeZ, SimParameters::PMEInterpOrder, SimParameters::PMEMinPoints, SimParameters::PMEMinSlices, PmePencilInitMsgData::pmeNodeProxy, SimParameters::PMEPencils, SimParameters::PMEProcessors, PmePencilInitMsgData::pmeProxy, NodePmeInfo::real_node, Random::reorder(), ResizeArray< Elem >::resize(), Node::simParameters, simParams, ResizeArray< Elem >::size(), SortableResizeArray< Elem >::sort(), Vector::unit(), LocalPmeInfo::x_start, PmePencilInitMsgData::xBlocks, PmePencilInitMsgData::xm, PmePencilInitMsgData::xPencil, LocalPmeInfo::y_start_after_transpose, PmePencilInitMsgData::yBlocks, PmePencilInitMsgData::ym, PmePencilInitMsgData::yPencil, PmePencilInitMsgData::zBlocks, PmePencilInitMsgData::zm, and PmePencilInitMsgData::zPencil. { delete msg; localInfo = new LocalPmeInfo[CkNumPes()]; gridNodeInfo = new NodePmeInfo[CkNumNodes()]; transNodeInfo = new NodePmeInfo[CkNumNodes()]; gridPeMap = new int[CkNumPes()]; transPeMap = new int[CkNumPes()]; recipPeDest = new int[CkNumPes()]; gridPeOrder = new int[CkNumPes()]; gridNodeOrder = new int[CkNumNodes()]; transNodeOrder = new int[CkNumNodes()]; isPmeFlag = new char[CkNumPes()]; SimParameters *simParams = Node::Object()->simParameters; PatchMap *patchMap = PatchMap::Object(); alchFepOn = simParams->alchFepOn; alchThermIntOn = simParams->alchThermIntOn; alchDecouple = (alchFepOn || alchThermIntOn) && (simParams->alchDecouple); alchElecLambdaStart = (alchFepOn || alchThermIntOn) ? simParams->alchElecLambdaStart : 0; if (alchFepOn || alchThermIntOn) { numGrids = 2; if (alchDecouple) numGrids += 2; if (alchElecLambdaStart || alchThermIntOn) numGrids ++; } else numGrids = 1; lesOn = simParams->lesOn; useBarrier = simParams->PMEBarrier; if ( lesOn ) { lesFactor = simParams->lesFactor; numGrids = lesFactor; } selfOn = 0; pairOn = simParams->pairInteractionOn; if ( pairOn ) { selfOn = simParams->pairInteractionSelf; if ( selfOn ) pairOn = 0; // make pairOn and selfOn exclusive numGrids = selfOn ? 1 : 3; } if ( numGrids != 1 || simParams->PMEPencils == 0 ) usePencils = 0; else if ( simParams->PMEPencils > 0 ) usePencils = 1; else { int nrps = simParams->PMEProcessors; if ( nrps <= 0 ) nrps = CkNumPes(); if ( nrps > CkNumPes() ) nrps = CkNumPes(); int dimx = simParams->PMEGridSizeX; int dimy = simParams->PMEGridSizeY; int maxslabs = 1 + (dimx - 1) / simParams->PMEMinSlices; if ( maxslabs > nrps ) maxslabs = nrps; int maxpencils = ( simParams->PMEGridSizeX * simParams->PMEGridSizeY * simParams->PMEGridSizeZ ) / simParams->PMEMinPoints; if ( maxpencils > nrps ) maxpencils = nrps; if ( maxpencils > 3 * maxslabs ) usePencils = 1; else usePencils = 0; } if ( usePencils ) { int nrps = simParams->PMEProcessors; if ( nrps <= 0 ) nrps = CkNumPes(); if ( nrps > CkNumPes() ) nrps = CkNumPes(); if ( simParams->PMEPencils > 1 && simParams->PMEPencils * simParams->PMEPencils <= nrps ) { xBlocks = yBlocks = zBlocks = simParams->PMEPencils; } else { int nb2 = ( simParams->PMEGridSizeX * simParams->PMEGridSizeY * simParams->PMEGridSizeZ ) / simParams->PMEMinPoints; if ( nb2 > nrps ) nb2 = nrps; int nb = (int) sqrt((float)nb2); xBlocks = zBlocks = nb; yBlocks = nb2 / nb; } int dimx = simParams->PMEGridSizeX; int bx = 1 + ( dimx - 1 ) / xBlocks; xBlocks = 1 + ( dimx - 1 ) / bx; int dimy = simParams->PMEGridSizeY; int by = 1 + ( dimy - 1 ) / yBlocks; yBlocks = 1 + ( dimy - 1 ) / by; int dimz = simParams->PMEGridSizeZ / 2 + 1; // complex int bz = 1 + ( dimz - 1 ) / zBlocks; zBlocks = 1 + ( dimz - 1 ) / bz; if ( ! CkMyPe() ) { iout << iINFO << "PME using " << xBlocks << " x " << yBlocks << " x " << zBlocks << " pencil grid for FFT and reciprocal sum.\n" << endi; } } else { // usePencils { // decide how many pes to use for reciprocal sum // rules based on work available int minslices = simParams->PMEMinSlices; int dimx = simParams->PMEGridSizeX; int nrpx = ( dimx + minslices - 1 ) / minslices; int dimy = simParams->PMEGridSizeY; int nrpy = ( dimy + minslices - 1 ) / minslices; // rules based on processors available int nrpp = CkNumPes(); // if ( nrpp > 32 ) nrpp = 32; // cap to limit messages if ( nrpp < nrpx ) nrpx = nrpp; if ( nrpp < nrpy ) nrpy = nrpp; // user override int nrps = simParams->PMEProcessors; if ( nrps > CkNumPes() ) nrps = CkNumPes(); if ( nrps > 0 ) nrpx = nrps; if ( nrps > 0 ) nrpy = nrps; // make sure there aren't any totally empty processors int bx = ( dimx + nrpx - 1 ) / nrpx; nrpx = ( dimx + bx - 1 ) / bx; int by = ( dimy + nrpy - 1 ) / nrpy; nrpy = ( dimy + by - 1 ) / by; if ( bx != ( dimx + nrpx - 1 ) / nrpx ) NAMD_bug("Error in selecting number of PME processors."); if ( by != ( dimy + nrpy - 1 ) / nrpy ) NAMD_bug("Error in selecting number of PME processors."); numGridPes = nrpx; numTransPes = nrpy; } if ( ! CkMyPe() ) { iout << iINFO << "PME using " << numGridPes << " and " << numTransPes << " processors for FFT and reciprocal sum.\n" << endi; } int sum_npes = numTransPes + numGridPes; int max_npes = (numTransPes > numGridPes)?numTransPes:numGridPes; #if 0 // USE_TOPOMAP /* This code is being disabled permanently for slab PME on Blue Gene machines */ PatchMap * pmap = PatchMap::Object(); int patch_pes = pmap->numNodesWithPatches(); TopoManager tmgr; if(tmgr.hasMultipleProcsPerNode()) patch_pes *= 2; bool done = false; if(CkNumPes() > 2*sum_npes + patch_pes) { done = generateBGLORBPmePeList(transPeMap, numTransPes); done &= generateBGLORBPmePeList(gridPeMap, numGridPes, transPeMap, numTransPes); } else if(CkNumPes() > 2 *max_npes + patch_pes) { done = generateBGLORBPmePeList(transPeMap, max_npes); gridPeMap = transPeMap; } if (!done) #endif { //generatePmePeList(transPeMap, max_npes); //gridPeMap = transPeMap; generatePmePeList2(gridPeMap, numGridPes, transPeMap, numTransPes); } myGridPe = -1; myGridNode = -1; int i = 0; for ( i=0; i<CkNumPes(); ++i ) isPmeFlag[i] = 0; int node = -1; int real_node = -1; for ( i=0; i<numGridPes; ++i ) { if ( gridPeMap[i] == CkMyPe() ) myGridPe = i; isPmeFlag[gridPeMap[i]] |= 1; int real_node_i = CkNodeOf(gridPeMap[i]); if ( real_node_i == real_node ) { gridNodeInfo[node].npe += 1; } else { real_node = real_node_i; ++node; gridNodeInfo[node].real_node = real_node; gridNodeInfo[node].pe_start = i; gridNodeInfo[node].npe = 1; } if ( CkMyNode() == real_node_i ) myGridNode = node; } numGridNodes = node + 1; myTransPe = -1; myTransNode = -1; node = -1; real_node = -1; for ( i=0; i<numTransPes; ++i ) { if ( transPeMap[i] == CkMyPe() ) myTransPe = i; isPmeFlag[transPeMap[i]] |= 2; int real_node_i = CkNodeOf(transPeMap[i]); if ( real_node_i == real_node ) { transNodeInfo[node].npe += 1; } else { real_node = real_node_i; ++node; transNodeInfo[node].real_node = real_node; transNodeInfo[node].pe_start = i; transNodeInfo[node].npe = 1; } if ( CkMyNode() == real_node_i ) myTransNode = node; } numTransNodes = node + 1; if ( ! CkMyPe() ) { iout << iINFO << "PME USING " << numGridNodes << " GRID NODES AND " << numTransNodes << " TRANS NODES\n" << endi; iout << iINFO << "PME GRID LOCATIONS:"; int i; for ( i=0; i<numGridPes && i<10; ++i ) { iout << " " << gridPeMap[i]; } if ( i < numGridPes ) iout << " ..."; iout << "\n" << endi; iout << iINFO << "PME TRANS LOCATIONS:"; for ( i=0; i<numTransPes && i<10; ++i ) { iout << " " << transPeMap[i]; } if ( i < numTransPes ) iout << " ..."; iout << "\n" << endi; } { // generate random orderings for grid and trans messages int i; for ( i = 0; i < numGridPes; ++i ) { gridPeOrder[i] = i; } Random rand(CkMyPe()); if ( myGridPe < 0 ) { rand.reorder(gridPeOrder,numGridPes); } else { // self last gridPeOrder[myGridPe] = numGridPes-1; gridPeOrder[numGridPes-1] = myGridPe; rand.reorder(gridPeOrder,numGridPes-1); } for ( i = 0; i < numGridNodes; ++i ) { gridNodeOrder[i] = i; } if ( myGridNode < 0 ) { rand.reorder(gridNodeOrder,numGridNodes); } else { // self last gridNodeOrder[myGridNode] = numGridNodes-1; gridNodeOrder[numGridNodes-1] = myGridNode; rand.reorder(gridNodeOrder,numGridNodes-1); } for ( i = 0; i < numTransNodes; ++i ) { transNodeOrder[i] = i; } if ( myTransNode < 0 ) { rand.reorder(transNodeOrder,numTransNodes); } else { // self last transNodeOrder[myTransNode] = numTransNodes-1; transNodeOrder[numTransNodes-1] = myTransNode; rand.reorder(transNodeOrder,numTransNodes-1); } } } // ! usePencils myGrid.K1 = simParams->PMEGridSizeX; myGrid.K2 = simParams->PMEGridSizeY; myGrid.K3 = simParams->PMEGridSizeZ; myGrid.order = simParams->PMEInterpOrder; myGrid.dim2 = myGrid.K2; myGrid.dim3 = 2 * (myGrid.K3/2 + 1); if ( ! usePencils ) { myGrid.block1 = ( myGrid.K1 + numGridPes - 1 ) / numGridPes; myGrid.block2 = ( myGrid.K2 + numTransPes - 1 ) / numTransPes; myGrid.block3 = myGrid.dim3 / 2; // complex } if ( usePencils ) { myGrid.block1 = ( myGrid.K1 + xBlocks - 1 ) / xBlocks; myGrid.block2 = ( myGrid.K2 + yBlocks - 1 ) / yBlocks; myGrid.block3 = ( myGrid.K3/2 + 1 + zBlocks - 1 ) / zBlocks; // complex int pe = 0; int x,y,z; SortableResizeArray<int> zprocs(xBlocks*yBlocks); SortableResizeArray<int> yprocs(xBlocks*zBlocks); SortableResizeArray<int> xprocs(yBlocks*zBlocks); { int basepe = 0; int npe = CkNumPes(); if ( npe > xBlocks*yBlocks && npe > xBlocks*zBlocks && npe > yBlocks*zBlocks ) { // avoid node 0 ++basepe; --npe; } // decide which pes to use by bit reversal and patch use int i; int ncpus = CkNumPes(); // find next highest power of two int npow2 = 1; int nbits = 0; while ( npow2 < ncpus ) { npow2 *= 2; nbits += 1; } // build bit reversal sequence SortableResizeArray<int> patches, nopatches, pmeprocs; PatchMap *pmap = PatchMap::Object(); i = 0; for ( int icpu=0; icpu<ncpus; ++icpu ) { int ri; for ( ri = ncpus; ri >= ncpus; ++i ) { ri = 0; int pow2 = 1; int rpow2 = npow2 / 2; for ( int j=0; j<nbits; ++j ) { ri += rpow2 * ( ( i / pow2 ) % 2 ); pow2 *= 2; rpow2 /= 2; } } // seq[icpu] = ri; if ( ri ) { // keep 0 for special case if ( pmap->numPatchesOnNode(ri) ) patches.add(ri); else nopatches.add(ri); } } #if USE_RANDOM_TOPO Random rand(CkMyPe()); int *tmp = new int[patches.size()]; int nn = patches.size(); for (i=0;i<nn;i++) tmp[i] = patches[i]; rand.reorder(tmp, nn); patches.resize(0); for (i=0;i<nn;i++) patches.add(tmp[i]); delete [] tmp; tmp = new int[nopatches.size()]; nn = nopatches.size(); for (i=0;i<nn;i++) tmp[i] = nopatches[i]; rand.reorder(tmp, nn); nopatches.resize(0); for (i=0;i<nn;i++) nopatches.add(tmp[i]); delete [] tmp; #endif // only use zero if it eliminates overloading or has patches int useZero = 0; int npens = xBlocks*yBlocks; if ( npens % ncpus == 0 ) useZero = 1; if ( npens == nopatches.size() + 1 ) useZero = 1; npens += xBlocks*zBlocks; if ( npens % ncpus == 0 ) useZero = 1; if ( npens == nopatches.size() + 1 ) useZero = 1; npens += yBlocks*zBlocks; if ( npens % ncpus == 0 ) useZero = 1; if ( npens == nopatches.size() + 1 ) useZero = 1; // add nopatches then patches in reversed order for ( i=nopatches.size()-1; i>=0; --i ) pmeprocs.add(nopatches[i]); if ( useZero && ! pmap->numPatchesOnNode(0) ) pmeprocs.add(0); for ( i=patches.size()-1; i>=0; --i ) pmeprocs.add(patches[i]); if ( pmap->numPatchesOnNode(0) ) pmeprocs.add(0); int npes = pmeprocs.size(); for ( i=0; i<xBlocks*yBlocks; ++i, ++pe ) zprocs[i] = pmeprocs[pe%npes]; if ( i>1 && zprocs[0] == zprocs[i-1] ) zprocs[0] = 0; #if !USE_RANDOM_TOPO zprocs.sort(); #endif for ( i=0; i<xBlocks*zBlocks; ++i, ++pe ) yprocs[i] = pmeprocs[pe%npes]; if ( i>1 && yprocs[0] == yprocs[i-1] ) yprocs[0] = 0; #if !USE_RANDOM_TOPO yprocs.sort(); #endif for ( i=0; i<yBlocks*zBlocks; ++i, ++pe ) xprocs[i] = pmeprocs[pe%npes]; if ( i>1 && xprocs[0] == xprocs[i-1] ) xprocs[0] = 0; #if !USE_RANDOM_TOPO xprocs.sort(); #endif #if USE_TOPO_SFC CmiLock(tmgr_lock); //{ TopoManager tmgr; int xdim = tmgr.getDimNX(); int ydim = tmgr.getDimNY(); int zdim = tmgr.getDimNZ(); int xdim1 = find_level_grid(xdim); int ydim1 = find_level_grid(ydim); int zdim1 = find_level_grid(zdim); if(CkMyPe() == 0) printf("xdim: %d %d %d, %d %d %d\n", xdim, ydim, zdim, xdim1, ydim1, zdim1); vector<Coord> result; SFC_grid(xdim, ydim, zdim, xdim1, ydim1, zdim1, result); sort_sfc(xprocs, tmgr, result); sort_sfc(yprocs, tmgr, result); sort_sfc(zprocs, tmgr, result); //} CmiUnlock(tmgr_lock); #endif pencilPMEProcessors = new char [CkNumPes()]; memset (pencilPMEProcessors, 0, sizeof(char) * CkNumPes()); if(CkMyPe() == 0){ iout << iINFO << "PME Z PENCIL LOCATIONS:"; for ( i=0; i<zprocs.size() && i<10; ++i ) { #if USE_TOPO_SFC int x,y,z,t; tmgr.rankToCoordinates(zprocs[i], x,y, z, t); iout << " " << zprocs[i] << "(" << x << " " << y << " " << z << ")"; #else iout << " " << zprocs[i]; #endif } if ( i < zprocs.size() ) iout << " ..."; iout << "\n" << endi; } for (pe=0, x = 0; x < xBlocks; ++x) for (y = 0; y < yBlocks; ++y, ++pe ) { pencilPMEProcessors[zprocs[pe]] = 1; } if(CkMyPe() == 0){ iout << iINFO << "PME Y PENCIL LOCATIONS:"; for ( i=0; i<yprocs.size() && i<10; ++i ) { #if USE_TOPO_SFC int x,y,z,t; tmgr.rankToCoordinates(yprocs[i], x,y, z, t); iout << " " << yprocs[i] << "(" << x << " " << y << " " << z << ")"; #else iout << " " << yprocs[i]; #endif } if ( i < yprocs.size() ) iout << " ..."; iout << "\n" << endi; } for (pe=0, z = 0; z < zBlocks; ++z ) for (x = 0; x < xBlocks; ++x, ++pe ) { pencilPMEProcessors[yprocs[pe]] = 1; } if(CkMyPe() == 0){ iout << iINFO << "PME X PENCIL LOCATIONS:"; for ( i=0; i<xprocs.size() && i<10; ++i ) { #if USE_TOPO_SFC int x,y,z,t; tmgr.rankToCoordinates(xprocs[i], x,y, z, t); iout << " " << xprocs[i] << "(" << x << " " << y << " " << z << ")"; #else iout << " " << xprocs[i]; #endif } if ( i < xprocs.size() ) iout << " ..."; iout << "\n" << endi; } for (pe=0, y = 0; y < yBlocks; ++y ) for (z = 0; z < zBlocks; ++z, ++pe ) { pencilPMEProcessors[xprocs[pe]] = 1; } } // creating the pencil arrays if ( CkMyPe() == 0 ){ #if 1 CProxy_PmePencilMap zm = CProxy_PmePencilMap::ckNew(0,1,yBlocks,xBlocks*yBlocks,zprocs.begin()); CProxy_PmePencilMap ym = CProxy_PmePencilMap::ckNew(2,0,xBlocks,zBlocks*xBlocks,yprocs.begin()); CProxy_PmePencilMap xm = CProxy_PmePencilMap::ckNew(1,2,zBlocks,yBlocks*zBlocks,xprocs.begin()); pmeNodeProxy.recvPencilMapProxies(xm,ym,zm); CkArrayOptions zo(xBlocks,yBlocks,1); zo.setMap(zm); CkArrayOptions yo(xBlocks,1,zBlocks); yo.setMap(ym); CkArrayOptions xo(1,yBlocks,zBlocks); xo.setMap(xm); #if CHARM_VERSION > 60301 zo.setAnytimeMigration(false); zo.setStaticInsertion(true); yo.setAnytimeMigration(false); yo.setStaticInsertion(true); xo.setAnytimeMigration(false); xo.setStaticInsertion(true); #endif zPencil = CProxy_PmeZPencil::ckNew(zo); // (xBlocks,yBlocks,1); yPencil = CProxy_PmeYPencil::ckNew(yo); // (xBlocks,1,zBlocks); xPencil = CProxy_PmeXPencil::ckNew(xo); // (1,yBlocks,zBlocks); #else zPencil = CProxy_PmeZPencil::ckNew(); // (xBlocks,yBlocks,1); yPencil = CProxy_PmeYPencil::ckNew(); // (xBlocks,1,zBlocks); xPencil = CProxy_PmeXPencil::ckNew(); // (1,yBlocks,zBlocks); for (pe=0, x = 0; x < xBlocks; ++x) for (y = 0; y < yBlocks; ++y, ++pe ) { zPencil(x,y,0).insert(zprocs[pe]); } zPencil.doneInserting(); for (pe=0, z = 0; z < zBlocks; ++z ) for (x = 0; x < xBlocks; ++x, ++pe ) { yPencil(x,0,z).insert(yprocs[pe]); } yPencil.doneInserting(); for (pe=0, y = 0; y < yBlocks; ++y ) for (z = 0; z < zBlocks; ++z, ++pe ) { xPencil(0,y,z).insert(xprocs[pe]); } xPencil.doneInserting(); #endif pmeProxy.recvArrays(xPencil,yPencil,zPencil); PmePencilInitMsgData msgdata; msgdata.grid = myGrid; msgdata.xBlocks = xBlocks; msgdata.yBlocks = yBlocks; msgdata.zBlocks = zBlocks; msgdata.xPencil = xPencil; msgdata.yPencil = yPencil; msgdata.zPencil = zPencil; msgdata.pmeProxy = pmeProxyDir; msgdata.pmeNodeProxy = pmeNodeProxy; msgdata.xm = xm; msgdata.ym = ym; msgdata.zm = zm; xPencil.init(new PmePencilInitMsg(msgdata)); yPencil.init(new PmePencilInitMsg(msgdata)); zPencil.init(new PmePencilInitMsg(msgdata)); } return; // continue in initialize_pencils() at next startup stage } int pe; int nx = 0; for ( pe = 0; pe < numGridPes; ++pe ) { localInfo[pe].x_start = nx; nx += myGrid.block1; if ( nx > myGrid.K1 ) nx = myGrid.K1; localInfo[pe].nx = nx - localInfo[pe].x_start; } int ny = 0; for ( pe = 0; pe < numTransPes; ++pe ) { localInfo[pe].y_start_after_transpose = ny; ny += myGrid.block2; if ( ny > myGrid.K2 ) ny = myGrid.K2; localInfo[pe].ny_after_transpose = ny - localInfo[pe].y_start_after_transpose; } { // decide how many pes this node exchanges charges with PatchMap *patchMap = PatchMap::Object(); Lattice lattice = simParams->lattice; BigReal sysdima = lattice.a_r().unit() * lattice.a(); BigReal cutoff = simParams->cutoff; BigReal patchdim = simParams->patchDimension; int numPatches = patchMap->numPatches(); int numNodes = CkNumPes(); int *source_flags = new int[numNodes]; int node; for ( node=0; node<numNodes; ++node ) { source_flags[node] = 0; recipPeDest[node] = 0; } // // make sure that we don't get ahead of ourselves on this node // if ( CkMyPe() < numPatches && myRecipPe >= 0 ) { // source_flags[CkMyPe()] = 1; // recipPeDest[myRecipPe] = 1; // } for ( int pid=0; pid < numPatches; ++pid ) { int pnode = patchMap->node(pid); BigReal minx = patchMap->min_a(pid); BigReal maxx = patchMap->max_a(pid); BigReal margina = 0.5 * ( patchdim - cutoff ) / sysdima; // min1 (max1) is smallest (largest) grid line for this patch int min1 = ((int) floor(myGrid.K1 * (minx - margina))) - myGrid.order + 1; int max1 = ((int) floor(myGrid.K1 * (maxx + margina))); for ( int i=min1; i<=max1; ++i ) { int ix = i; while ( ix >= myGrid.K1 ) ix -= myGrid.K1; while ( ix < 0 ) ix += myGrid.K1; // set source_flags[pnode] if this patch sends to our node if ( myGridPe >= 0 && ix >= localInfo[myGridPe].x_start && ix < localInfo[myGridPe].x_start + localInfo[myGridPe].nx ) { source_flags[pnode] = 1; } // set dest_flags[] for node that our patch sends to if ( pnode == CkMyPe() ) { recipPeDest[ix / myGrid.block1] = 1; } } } numSources = 0; numDestRecipPes = 0; for ( node=0; node<numNodes; ++node ) { if ( source_flags[node] ) ++numSources; if ( recipPeDest[node] ) ++numDestRecipPes; } #if 0 if ( numSources ) { iout << iINFO << "PME " << CkMyPe() << " sources:"; for ( node=0; node<numNodes; ++node ) { if ( source_flags[node] ) iout << " " << node; } iout << "\n" << endi; } #endif delete [] source_flags; // CkPrintf("PME on node %d has %d sources and %d destinations\n", // CkMyPe(), numSources, numDestRecipPes); } // decide how many pes this node exchanges charges with (end) ungrid_count = numDestRecipPes; sendTransBarrier_received = 0; if ( myGridPe < 0 && myTransPe < 0 ) return; // the following only for nodes doing reciprocal sum if ( myTransPe >= 0 ) { int k2_start = localInfo[myTransPe].y_start_after_transpose; int k2_end = k2_start + localInfo[myTransPe].ny_after_transpose; #ifdef OPENATOM_VERSION if ( simParams->openatomOn ) { CProxy_ComputeMoaMgr moaProxy(CkpvAccess(BOCclass_group).computeMoaMgr); myKSpace = new PmeKSpace(myGrid, k2_start, k2_end, 0, myGrid.dim3/2, moaProxy); } else { myKSpace = new PmeKSpace(myGrid, k2_start, k2_end, 0, myGrid.dim3/2); } #else // OPENATOM_VERSION myKSpace = new PmeKSpace(myGrid, k2_start, k2_end, 0, myGrid.dim3/2); #endif // OPENATOM_VERSION } int local_size = myGrid.block1 * myGrid.K2 * myGrid.dim3; int local_size_2 = myGrid.block2 * myGrid.K1 * myGrid.dim3; if ( local_size < local_size_2 ) local_size = local_size_2; qgrid = new float[local_size*numGrids]; if ( numGridPes > 1 || numTransPes > 1 ) { kgrid = new float[local_size*numGrids]; } else { kgrid = qgrid; } qgrid_size = local_size; if ( myGridPe >= 0 ) { qgrid_start = localInfo[myGridPe].x_start * myGrid.K2 * myGrid.dim3; qgrid_len = localInfo[myGridPe].nx * myGrid.K2 * myGrid.dim3; fgrid_start = localInfo[myGridPe].x_start * myGrid.K2; fgrid_len = localInfo[myGridPe].nx * myGrid.K2; } int n[3]; n[0] = myGrid.K1; n[1] = myGrid.K2; n[2] = myGrid.K3; #ifdef NAMD_FFTW CmiLock(fftw_plan_lock); #ifdef NAMD_FFTW_3 work = new fftwf_complex[n[0]]; int fftwFlags = simParams->FFTWPatient ? FFTW_PATIENT : simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE ; if ( myGridPe >= 0 ) { forward_plan_yz=new fftwf_plan[numGrids]; backward_plan_yz=new fftwf_plan[numGrids]; } if ( myTransPe >= 0 ) { forward_plan_x=new fftwf_plan[numGrids]; backward_plan_x=new fftwf_plan[numGrids]; } /* need one plan per grid */ if ( ! CkMyPe() ) iout << iINFO << "Optimizing 4 FFT steps. 1..." << endi; if ( myGridPe >= 0 ) { for( int g=0; g<numGrids; g++) { forward_plan_yz[g] = fftwf_plan_many_dft_r2c(2, n+1, localInfo[myGridPe].nx, qgrid + qgrid_size * g, NULL, 1, myGrid.dim2 * myGrid.dim3, (fftwf_complex *) qgrid + qgrid_size * g, NULL, 1, myGrid.dim2 * (myGrid.dim3/2), fftwFlags); } } int zdim = myGrid.dim3; int xStride=localInfo[myTransPe].ny_after_transpose *( myGrid.dim3 / 2); if ( ! CkMyPe() ) iout << " 2..." << endi; if ( myTransPe >= 0 ) { for( int g=0; g<numGrids; g++) { forward_plan_x[g] = fftwf_plan_many_dft(1, n, xStride, (fftwf_complex *) (kgrid+qgrid_size*g), NULL, xStride, 1, (fftwf_complex *) (kgrid+qgrid_size*g), NULL, xStride, 1, FFTW_FORWARD,fftwFlags); } } if ( ! CkMyPe() ) iout << " 3..." << endi; if ( myTransPe >= 0 ) { for( int g=0; g<numGrids; g++) { backward_plan_x[g] = fftwf_plan_many_dft(1, n, xStride, (fftwf_complex *) (kgrid+qgrid_size*g), NULL, xStride, 1, (fftwf_complex *) (kgrid+qgrid_size*g), NULL, xStride, 1, FFTW_BACKWARD, fftwFlags); } } if ( ! CkMyPe() ) iout << " 4..." << endi; if ( myGridPe >= 0 ) { for( int g=0; g<numGrids; g++) { backward_plan_yz[g] = fftwf_plan_many_dft_c2r(2, n+1, localInfo[myGridPe].nx, (fftwf_complex *) qgrid + qgrid_size * g, NULL, 1, myGrid.dim2*(myGrid.dim3/2), qgrid + qgrid_size * g, NULL, 1, myGrid.dim2 * myGrid.dim3, fftwFlags); } } if ( ! CkMyPe() ) iout << " Done.\n" << endi; #else work = new fftw_complex[n[0]]; if ( ! CkMyPe() ) iout << iINFO << "Optimizing 4 FFT steps. 1..." << endi; if ( myGridPe >= 0 ) { forward_plan_yz = rfftwnd_create_plan_specific(2, n+1, FFTW_REAL_TO_COMPLEX, ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE ) | FFTW_IN_PLACE | FFTW_USE_WISDOM, qgrid, 1, 0, 0); } if ( ! CkMyPe() ) iout << " 2..." << endi; if ( myTransPe >= 0 ) { forward_plan_x = fftw_create_plan_specific(n[0], FFTW_FORWARD, ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE ) | FFTW_IN_PLACE | FFTW_USE_WISDOM, (fftw_complex *) kgrid, localInfo[myTransPe].ny_after_transpose * myGrid.dim3 / 2, work, 1); } if ( ! CkMyPe() ) iout << " 3..." << endi; if ( myTransPe >= 0 ) { backward_plan_x = fftw_create_plan_specific(n[0], FFTW_BACKWARD, ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE ) | FFTW_IN_PLACE | FFTW_USE_WISDOM, (fftw_complex *) kgrid, localInfo[myTransPe].ny_after_transpose * myGrid.dim3 / 2, work, 1); } if ( ! CkMyPe() ) iout << " 4..." << endi; if ( myGridPe >= 0 ) { backward_plan_yz = rfftwnd_create_plan_specific(2, n+1, FFTW_COMPLEX_TO_REAL, ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE ) | FFTW_IN_PLACE | FFTW_USE_WISDOM, qgrid, 1, 0, 0); } if ( ! CkMyPe() ) iout << " Done.\n" << endi; #endif CmiUnlock(fftw_plan_lock); #else NAMD_die("Sorry, FFTW must be compiled in to use PME."); #endif if ( myGridPe >= 0 && numSources == 0 ) NAMD_bug("PME grid elements exist without sources."); grid_count = numSources; memset( (void*) qgrid, 0, qgrid_size * numGrids * sizeof(float) ); trans_count = numGridPes; }

void ComputePmeMgr::initialize_pencils (  CkQdMsg *   )

Definition at line 1420 of file ComputePme.C. References Lattice::a(), Lattice::a_r(), Lattice::b(), Lattice::b_r(), BigReal, PmeGrid::block1, PmeGrid::block2, SimParameters::cutoff, j, PmeGrid::K1, PmeGrid::K2, SimParameters::lattice, PatchMap::max_a(), PatchMap::max_b(), PatchMap::min_a(), PatchMap::min_b(), PatchMap::node(), PatchMap::numPatches(), PatchMap::Object(), Node::Object(), PmeGrid::order, SimParameters::patchDimension, Random::reorder(), Node::simParameters, simParams, and Vector::unit(). { delete msg; if ( ! usePencils ) return; SimParameters *simParams = Node::Object()->simParameters; PatchMap *patchMap = PatchMap::Object(); Lattice lattice = simParams->lattice; BigReal sysdima = lattice.a_r().unit() * lattice.a(); BigReal sysdimb = lattice.b_r().unit() * lattice.b(); BigReal cutoff = simParams->cutoff; BigReal patchdim = simParams->patchDimension; int numPatches = patchMap->numPatches(); pencilActive = new char[xBlocks*yBlocks]; for ( int i=0; i<xBlocks; ++i ) { for ( int j=0; j<yBlocks; ++j ) { pencilActive[i*yBlocks+j] = 0; } } for ( int pid=0; pid < numPatches; ++pid ) { int pnode = patchMap->node(pid); if ( pnode != CkMyPe() ) continue; BigReal minx = patchMap->min_a(pid); BigReal maxx = patchMap->max_a(pid); BigReal margina = 0.5 * ( patchdim - cutoff ) / sysdima; // min1 (max1) is smallest (largest) grid line for this patch int min1 = ((int) floor(myGrid.K1 * (minx - margina))) - myGrid.order + 1; int max1 = ((int) floor(myGrid.K1 * (maxx + margina))); BigReal miny = patchMap->min_b(pid); BigReal maxy = patchMap->max_b(pid); BigReal marginb = 0.5 * ( patchdim - cutoff ) / sysdimb; // min2 (max2) is smallest (largest) grid line for this patch int min2 = ((int) floor(myGrid.K2 * (miny - marginb))) - myGrid.order + 1; int max2 = ((int) floor(myGrid.K2 * (maxy + marginb))); for ( int i=min1; i<=max1; ++i ) { int ix = i; while ( ix >= myGrid.K1 ) ix -= myGrid.K1; while ( ix < 0 ) ix += myGrid.K1; for ( int j=min2; j<=max2; ++j ) { int jy = j; while ( jy >= myGrid.K2 ) jy -= myGrid.K2; while ( jy < 0 ) jy += myGrid.K2; pencilActive[(ix / myGrid.block1)*yBlocks + (jy / myGrid.block2)] = 1; } } } numPencilsActive = 0; for ( int i=0; i<xBlocks; ++i ) { for ( int j=0; j<yBlocks; ++j ) { if ( pencilActive[i*yBlocks+j] ) { ++numPencilsActive; zPencil(i,j,0).dummyRecvGrid(CkMyPe(),0); } } } activePencils = new ijpair[numPencilsActive]; numPencilsActive = 0; for ( int i=0; i<xBlocks; ++i ) { for ( int j=0; j<yBlocks; ++j ) { if ( pencilActive[i*yBlocks+j] ) { activePencils[numPencilsActive++] = ijpair(i,j); } } } Random rand(CkMyPe()); rand.reorder(activePencils,numPencilsActive); //if ( numPencilsActive ) { // CkPrintf("node %d sending to %d pencils\n", CkMyPe(), numPencilsActive); //} ungrid_count = numPencilsActive; }

int ComputePmeMgr::isPmeProcessor (  int  p  )

Definition at line 443 of file ComputePme.C. References pencilPMEProcessors. { return ( usePencils ? pencilPMEProcessors[p] : isPmeFlag[p] ); }

void ComputePmeMgr::procTrans (  PmeTransMsg *   )

Definition at line 1738 of file ComputePme.C. References PmeGrid::dim3, PmeTransMsg::lattice, NodePmeInfo::npe, PmeTransMsg::nx, LocalPmeInfo::ny_after_transpose, NodePmeInfo::pe_start, PmeTransMsg::qgrid, PmeTransMsg::sequence, PmeTransMsg::x_start, and LocalPmeInfo::y_start_after_transpose. Referenced by recvSharedTrans(), and recvTrans(). { // CkPrintf("procTrans on Pe(%d)\n",CkMyPe()); if ( trans_count == numGridPes ) { lattice = msg->lattice; sequence = msg->sequence; } if ( msg->nx ) { int zdim = myGrid.dim3; NodePmeInfo &nodeInfo(transNodeInfo[myTransNode]); int first_pe = nodeInfo.pe_start; int last_pe = first_pe+nodeInfo.npe-1; int y_skip = localInfo[myTransPe].y_start_after_transpose - localInfo[first_pe].y_start_after_transpose; int ny_msg = localInfo[last_pe].y_start_after_transpose + localInfo[last_pe].ny_after_transpose - localInfo[first_pe].y_start_after_transpose; int ny = localInfo[myTransPe].ny_after_transpose; int x_start = msg->x_start; int nx = msg->nx; for ( int g=0; g<numGrids; ++g ) { CmiMemcpy((void*)(kgrid + qgrid_size * g + x_start*ny*zdim), (void*)(msg->qgrid + nx*(ny_msg*g+y_skip)*zdim), nx*ny*zdim*sizeof(float)); } } --trans_count; if ( trans_count == 0 ) { pmeProxyDir[CkMyPe()].gridCalc2(); } }

void ComputePmeMgr::procUntrans (  PmeUntransMsg *   )

Definition at line 1960 of file ComputePme.C. References PmeGrid::dim3, PmeUntransMsg::evir, PmeGrid::K2, NodePmeInfo::npe, LocalPmeInfo::nx, PmeUntransMsg::ny, NodePmeInfo::pe_start, PmeUntransMsg::qgrid, LocalPmeInfo::x_start, and PmeUntransMsg::y_start. Referenced by recvSharedUntrans(), and recvUntrans(). { // CkPrintf("recvUntrans on Pe(%d)\n",CkMyPe()); if ( untrans_count == numTransPes ) { for ( int g=0; g<numGrids; ++g ) { recip_evir[g] = 0.; } } #if CMK_BLUEGENEL CmiNetworkProgressAfter (0); #endif NodePmeInfo &nodeInfo(gridNodeInfo[myGridNode]); int first_pe = nodeInfo.pe_start; int g; if ( myGridPe == first_pe ) for ( g=0; g<numGrids; ++g ) { recip_evir[g] += msg->evir[g]; } if ( msg->ny ) { int zdim = myGrid.dim3; int last_pe = first_pe+nodeInfo.npe-1; int x_skip = localInfo[myGridPe].x_start - localInfo[first_pe].x_start; int nx_msg = localInfo[last_pe].x_start + localInfo[last_pe].nx - localInfo[first_pe].x_start; int nx = localInfo[myGridPe].nx; int y_start = msg->y_start; int ny = msg->ny; int slicelen = myGrid.K2 * zdim; int cpylen = ny * zdim; for ( g=0; g<numGrids; ++g ) { float *q = qgrid + qgrid_size * g + y_start * zdim; float *qmsg = msg->qgrid + (nx_msg*g+x_skip) * cpylen; for ( int x = 0; x < nx; ++x ) { CmiMemcpy((void*)q, (void*)qmsg, cpylen*sizeof(float)); q += slicelen; qmsg += cpylen; } } } --untrans_count; if ( untrans_count == 0 ) { pmeProxyDir[CkMyPe()].gridCalc3(); } }

void ComputePmeMgr::recvAck (  PmeAckMsg *   )

Definition at line 2087 of file ComputePme.C. Referenced by recvUngrid(). { if ( msg ) delete msg; --ungrid_count; if ( ungrid_count == 0 ) { pmeProxyDir[CkMyPe()].ungridCalc(); } }

void ComputePmeMgr::recvArrays (  CProxy_PmeXPencil  , CProxy_PmeYPencil  , CProxy_PmeZPencil  )

Definition at line 555 of file ComputePme.C. { xPencil = x; yPencil = y; zPencil = z; if(CmiMyRank()==0) { pmeNodeProxy.ckLocalBranch()->xPencil=x; pmeNodeProxy.ckLocalBranch()->yPencil=y; pmeNodeProxy.ckLocalBranch()->zPencil=z; } }

void ComputePmeMgr::recvGrid (  PmeGridMsg *   )

Definition at line 1535 of file ComputePme.C. References PmeGrid::dim3, PmeGridMsg::fgrid, PmeGridMsg::lattice, NAMD_bug(), PmeGridMsg::qgrid, PmeGridMsg::sequence, PmeGridMsg::zlist, and PmeGridMsg::zlistlen. Referenced by ComputePme::sendPencils(). { // CkPrintf("recvGrid from %d on Pe(%d)\n",msg->sourceNode,CkMyPe()); if ( grid_count == 0 ) { NAMD_bug("Message order failure in ComputePmeMgr::recvGrid\n"); } if ( grid_count == numSources ) { lattice = msg->lattice; sequence = msg->sequence; } int zdim = myGrid.dim3; int zlistlen = msg->zlistlen; int *zlist = msg->zlist; float *qmsg = msg->qgrid; for ( int g=0; g<numGrids; ++g ) { char *f = msg->fgrid + fgrid_len * g; float *q = qgrid + qgrid_size * g; for ( int i=0; i<fgrid_len; ++i ) { if ( f[i] ) { for ( int k=0; k<zlistlen; ++k ) { q[zlist[k]] += *(qmsg++); } } q += zdim; } } gridmsg_reuse[numSources-grid_count] = msg; --grid_count; if ( grid_count == 0 ) { pmeProxyDir[CkMyPe()].gridCalc1(); if ( useBarrier ) pmeProxyDir[0].sendTransBarrier(); } }

void ComputePmeMgr::recvSharedTrans (  PmeSharedTransMsg *   )

Definition at line 1720 of file ComputePme.C. References PmeSharedTransMsg::count, PmeSharedTransMsg::lock, PmeSharedTransMsg::msg, and procTrans(). { procTrans(msg->msg); CmiLock(msg->lock); int count = --(*msg->count); CmiUnlock(msg->lock); if ( count == 0 ) { CmiDestroyLock(msg->lock); delete msg->count; delete msg->msg; } delete msg; }

void ComputePmeMgr::recvSharedUntrans (  PmeSharedUntransMsg *   )

Definition at line 1942 of file ComputePme.C. References PmeSharedUntransMsg::count, PmeSharedUntransMsg::lock, PmeSharedUntransMsg::msg, and procUntrans(). { procUntrans(msg->msg); CmiLock(msg->lock); int count = --(*msg->count); CmiUnlock(msg->lock); if ( count == 0 ) { CmiDestroyLock(msg->lock); delete msg->count; delete msg->msg; } delete msg; }

void ComputePmeMgr::recvTrans (  PmeTransMsg *   )

Definition at line 1733 of file ComputePme.C. References procTrans(). { procTrans(msg); delete msg; }

void ComputePmeMgr::recvUngrid (  PmeGridMsg *   )

Definition at line 2075 of file ComputePme.C. References ComputePme::copyPencils(), ComputePme::copyResults(), NAMD_bug(), and recvAck(). { // CkPrintf("recvUngrid on Pe(%d)\n",CkMyPe()); if ( ungrid_count == 0 ) { NAMD_bug("Message order failure in ComputePmeMgr::recvUngrid\n"); } if ( usePencils ) pmeCompute->copyPencils(msg); else pmeCompute->copyResults(msg); delete msg; recvAck(0); }

void ComputePmeMgr::recvUntrans (  PmeUntransMsg *   )

Definition at line 1955 of file ComputePme.C. References procUntrans(). { procUntrans(msg); delete msg; }

void ComputePmeMgr::sendGrid (  void   )

Definition at line 1531 of file ComputePme.C. References ComputePme::sendData(). { pmeCompute->sendData(numGridPes,gridPeOrder,recipPeDest,gridPeMap); }

void ComputePmeMgr::sendTrans (  void   )

Definition at line 1642 of file ComputePme.C. References PmeGrid::dim3, fwdSharedTrans(), j, PmeGrid::K2, kgrid, PmeTransMsg::lattice, NodePmeInfo::npe, PmeTransMsg::nx, LocalPmeInfo::nx, LocalPmeInfo::ny_after_transpose, NodePmeInfo::pe_start, PME_TRANS_PRIORITY, PmeTransMsg::qgrid, qgrid_size, NodePmeInfo::real_node, PmeTransMsg::sequence, SET_PRIORITY, PmeTransMsg::sourceNode, PmeTransMsg::x_start, LocalPmeInfo::x_start, and LocalPmeInfo::y_start_after_transpose. { // CkPrintf("sendTrans on Pe(%d)\n",CkMyPe()); // send data for transpose int zdim = myGrid.dim3; int nx = localInfo[myGridPe].nx; int x_start = localInfo[myGridPe].x_start; int slicelen = myGrid.K2 * zdim; ComputePmeMgr **mgrObjects = pmeNodeProxy.ckLocalBranch()->mgrObjects; #if CMK_BLUEGENEL CmiNetworkProgressAfter (0); #endif for (int j=0; j<numTransNodes; j++) { int node = transNodeOrder[j]; // different order on each node int pe = transNodeInfo[node].pe_start; int npe = transNodeInfo[node].npe; int totlen = 0; if ( node != myTransNode ) for (int i=0; i<npe; ++i, ++pe) { LocalPmeInfo &li = localInfo[pe]; int cpylen = li.ny_after_transpose * zdim; totlen += cpylen; } PmeTransMsg *newmsg = new (nx * totlen * numGrids, PRIORITY_SIZE) PmeTransMsg; newmsg->sourceNode = myGridPe; newmsg->lattice = lattice; newmsg->x_start = x_start; newmsg->nx = nx; for ( int g=0; g<numGrids; ++g ) { float *qmsg = newmsg->qgrid + nx * totlen * g; pe = transNodeInfo[node].pe_start; for (int i=0; i<npe; ++i, ++pe) { LocalPmeInfo &li = localInfo[pe]; int cpylen = li.ny_after_transpose * zdim; if ( node == myTransNode ) { ComputePmeMgr *m = mgrObjects[CkRankOf(transPeMap[pe])]; qmsg = m->kgrid + m->qgrid_size * g + x_start*cpylen; } float *q = qgrid + qgrid_size * g + li.y_start_after_transpose * zdim; for ( int x = 0; x < nx; ++x ) { CmiMemcpy((void*)qmsg, (void*)q, cpylen*sizeof(float)); q += slicelen; qmsg += cpylen; } } } newmsg->sequence = sequence; SET_PRIORITY(newmsg,sequence,PME_TRANS_PRIORITY) if ( node == myTransNode ) newmsg->nx = 0; if ( npe > 1 ) { if ( node == myTransNode ) fwdSharedTrans(newmsg); else pmeNodeProxy[transNodeInfo[node].real_node].recvTrans(newmsg); } else pmeProxy[transPeMap[transNodeInfo[node].pe_start]].recvTrans(newmsg); } untrans_count = numTransPes; }

void ComputePmeMgr::sendTransBarrier (  void   )

Definition at line 1632 of file ComputePme.C. { sendTransBarrier_received += 1; // CkPrintf("sendTransBarrier on %d %d\n",myGridPe,numGridPes-sendTransBarrier_received); if ( sendTransBarrier_received < numGridPes ) return; sendTransBarrier_received = 0; for ( int i=0; i<numGridPes; ++i ) { pmeProxyDir[gridPeMap[i]].sendTrans(); } }

void ComputePmeMgr::sendUngrid (  void   )

Definition at line 2031 of file ComputePme.C. References PmeGrid::dim3, PmeGridMsg::evir, PmeGridMsg::fgrid, j, PmeGridMsg::len, PME_UNGRID_PRIORITY, PmeGridMsg::qgrid, SET_PRIORITY, PmeGridMsg::sourceNode, PmeGridMsg::start, PmeGridMsg::zlist, and PmeGridMsg::zlistlen. { for ( int j=0; j<numSources; ++j ) { // int msglen = qgrid_len; PmeGridMsg *newmsg = gridmsg_reuse[j]; int pe = newmsg->sourceNode; if ( j == 0 ) { // only need these once for ( int g=0; g<numGrids; ++g ) { newmsg->evir[g] = recip_evir[g]; } } else { for ( int g=0; g<numGrids; ++g ) { newmsg->evir[g] = 0.; } } int zdim = myGrid.dim3; int flen = newmsg->len; int fstart = newmsg->start; int zlistlen = newmsg->zlistlen; int *zlist = newmsg->zlist; float *qmsg = newmsg->qgrid; for ( int g=0; g<numGrids; ++g ) { char *f = newmsg->fgrid + fgrid_len * g; float *q = qgrid + qgrid_size * g + (fstart-fgrid_start) * zdim; for ( int i=0; i<flen; ++i ) { if ( f[i] ) { for ( int k=0; k<zlistlen; ++k ) { *(qmsg++) = q[zlist[k]]; } } q += zdim; } } newmsg->sourceNode = myGridPe; SET_PRIORITY(newmsg,sequence,PME_UNGRID_PRIORITY) CmiEnableUrgentSend(1); pmeProxyDir[pe].recvUngrid(newmsg); CmiEnableUrgentSend(0); } grid_count = numSources; memset( (void*) qgrid, 0, qgrid_size * numGrids * sizeof(float) ); }

void ComputePmeMgr::sendUntrans (  void   )

Definition at line 1860 of file ComputePme.C. References PmeGrid::dim3, PmeUntransMsg::evir, fwdSharedUntrans(), j, PmeGrid::K2, NodePmeInfo::npe, LocalPmeInfo::nx, PmeUntransMsg::ny, LocalPmeInfo::ny_after_transpose, NodePmeInfo::pe_start, PME_UNTRANS_PRIORITY, qgrid, PmeUntransMsg::qgrid, qgrid_size, NodePmeInfo::real_node, SET_PRIORITY, PmeUntransMsg::sourceNode, LocalPmeInfo::x_start, PmeUntransMsg::y_start, and LocalPmeInfo::y_start_after_transpose. { int zdim = myGrid.dim3; int y_start = localInfo[myTransPe].y_start_after_transpose; int ny = localInfo[myTransPe].ny_after_transpose; int slicelen = myGrid.K2 * zdim; ComputePmeMgr **mgrObjects = pmeNodeProxy.ckLocalBranch()->mgrObjects; #if CMK_BLUEGENEL CmiNetworkProgressAfter (0); #endif // send data for reverse transpose for (int j=0; j<numGridNodes; j++) { int node = gridNodeOrder[j]; // different order on each node int pe = gridNodeInfo[node].pe_start; int npe = gridNodeInfo[node].npe; int totlen = 0; if ( node != myGridNode ) for (int i=0; i<npe; ++i, ++pe) { LocalPmeInfo &li = localInfo[pe]; int cpylen = li.nx * zdim; totlen += cpylen; } PmeUntransMsg *newmsg = new (ny * totlen * numGrids,numGrids, PRIORITY_SIZE) PmeUntransMsg; newmsg->sourceNode = myTransPe; newmsg->y_start = y_start; newmsg->ny = ny; for ( int g=0; g<numGrids; ++g ) { if ( j == 0 ) { // only need these once newmsg->evir[g] = recip_evir2[g]; } else { newmsg->evir[g] = 0.; } float *qmsg = newmsg->qgrid + ny * totlen * g; pe = gridNodeInfo[node].pe_start; for (int i=0; i<npe; ++i, ++pe) { LocalPmeInfo &li = localInfo[pe]; if ( node == myGridNode ) { ComputePmeMgr *m = mgrObjects[CkRankOf(gridPeMap[pe])]; qmsg = m->qgrid + m->qgrid_size * g + y_start * zdim; float *q = kgrid + qgrid_size*g + li.x_start*ny*zdim; int cpylen = ny * zdim; for ( int x = 0; x < li.nx; ++x ) { CmiMemcpy((void*)qmsg, (void*)q, cpylen*sizeof(float)); q += cpylen; qmsg += slicelen; } } else { CmiMemcpy((void*)qmsg, (void*)(kgrid + qgrid_size*g + li.x_start*ny*zdim), li.nx*ny*zdim*sizeof(float)); qmsg += li.nx*ny*zdim; } } } SET_PRIORITY(newmsg,sequence,PME_UNTRANS_PRIORITY) if ( node == myGridNode ) newmsg->ny = 0; if ( npe > 1 ) { if ( node == myGridNode ) fwdSharedUntrans(newmsg); else pmeNodeProxy[gridNodeInfo[node].real_node].recvUntrans(newmsg); } else pmeProxy[gridPeMap[gridNodeInfo[node].pe_start]].recvUntrans(newmsg); } trans_count = numGridPes; }

void ComputePmeMgr::setCompute (  ComputePme *  c  )  [inline]

Definition at line 347 of file ComputePme.C. References ComputePme::setMgr(). { pmeCompute = c; c->setMgr(this); }

void ComputePmeMgr::ungridCalc (  void   )

Definition at line 2096 of file ComputePme.C. References ComputePme::ungridForces(). { // CkPrintf("ungridCalc on Pe(%d)\n",CkMyPe()); pmeCompute->ungridForces(); ungrid_count = (usePencils ? numPencilsActive : numDestRecipPes ); }

---

Friends And Related Function Documentation

friend class ComputePme [friend]

Definition at line 312 of file ComputePme.C.

friend class NodePmeMgr [friend]

Definition at line 313 of file ComputePme.C.

---

Member Data Documentation

CmiNodeLock ComputePmeMgr::fftw_plan_lock [static]

Definition at line 436 of file ComputePme.C. Referenced by ComputePmeMgr(), initialize(), and ~ComputePmeMgr().

---

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

• ComputePme.C

---