PmeZPencil Class Reference

Inheritance diagram for PmeZPencil:

Public Member Functions
PmeZPencil_SDAG_CODE	PmeZPencil ()
	PmeZPencil (CkMigrateMessage *)
	~PmeZPencil ()
void	fft_init ()
void	recv_grid (const PmeGridMsg *)
void	forward_fft ()
void	send_trans ()
void	send_subset_trans (int fromIdx, int toIdx)
void	recv_untrans (const PmeUntransMsg *)
void	recvNodeAck (PmeAckMsg *)
void	node_process_untrans (PmeUntransMsg *)
void	node_process_grid (PmeGridMsg *)
void	backward_fft ()
void	send_ungrid (PmeGridMsg *)
void	send_all_ungrid ()
void	send_subset_ungrid (int fromIdx, int toIdx)
Public Member Functions inherited from PmePencil< CBase_PmeZPencil >
	PmePencil ()
	~PmePencil ()
void	base_init (PmePencilInitMsg *msg)
void	order_init (int nBlocks)

Additional Inherited Members
Public Types inherited from PmePencil< CBase_PmeZPencil >
typedef int	AtomicInt
Public Attributes inherited from PmePencil< CBase_PmeZPencil >
PmePencilInitMsgData	initdata
Lattice	lattice
PmeReduction	evir
int	sequence
AtomicInt	imsg
AtomicInt	imsgb
int	hasData
int	offload
float *	data
float *	work
int *	send_order
int *	needs_reply

Detailed Description

Definition at line 4648 of file ComputePme.C.

Constructor & Destructor Documentation

PmeZPencil() [1/2]

PmeZPencil_SDAG_CODE PmeZPencil::PmeZPencil ( )

inline

Definition at line 4651 of file ComputePme.C.

{ __sdag_init(); setMigratable(false); }

PmeZPencil() [2/2]

PmeZPencil::PmeZPencil ( CkMigrateMessage *  )

inline

Definition at line 4652 of file ComputePme.C.

References PmePencil< CBase_PmeZPencil >::imsg, and PmePencil< CBase_PmeZPencil >::imsgb.

{ __sdag_init();  setMigratable (false); imsg=imsgb=0;}

~PmeZPencil()

PmeZPencil::~PmeZPencil ( )

inline

Definition at line 4653 of file ComputePme.C.

                      {
        #ifdef NAMD_FFTW
        #ifdef NAMD_FFTW_3
                delete [] forward_plans;
                delete [] backward_plans;
        #endif
        #endif
        }

Member Function Documentation

backward_fft()

void PmeZPencil::backward_fft

(

)

Definition at line 6239 of file ComputePme.C.

References CKLOOP_CTRL_PME_BACKWARDFFT, PmePencil< CBase_PmeZPencil >::data, PmeGrid::dim3, PmePencilInitMsgData::grid, PmePencil< CBase_PmeZPencil >::initdata, PmeGrid::K1, PmeGrid::K2, PmeGrid::K3, Node::Object(), PmeXZPencilFFT(), Node::simParameters, SimParameters::useCkLoop, PmePencil< CBase_PmeZPencil >::work, PmePencilInitMsgData::xBlocks, and PmePencilInitMsgData::yBlocks.

Referenced by node_process_untrans().

                              {
#ifdef NAMD_FFTW
#ifdef MANUAL_DEBUG_FFTW3
  dumpMatrixFloat3("bw_z_b", data, nx, ny, initdata.grid.dim3, thisIndex.x, thisIndex.y, thisIndex.z);
#endif
#ifdef NAMD_FFTW_3
#if     CMK_SMP && USE_CKLOOP
  int useCkLoop = Node::Object()->simParameters->useCkLoop;
  if(useCkLoop>=CKLOOP_CTRL_PME_BACKWARDFFT
     && CkNumPes() >= 2 * initdata.xBlocks * initdata.yBlocks) {
          //for(int i=0; i<numPlans; i++) fftwf_execute(backward_plans[i]);
          //transform the above loop
          CkLoop_Parallelize(PmeXZPencilFFT, 1, (void *)backward_plans, CkMyNodeSize(), 0, numPlans-1); //sync
          return;
  }
#endif
  fftwf_execute(backward_plan);
#else
  rfftwnd_complex_to_real(backward_plan, nx*ny,
            (fftw_complex *) data, 1, initdata.grid.dim3/2, work, 1, 0);
#endif
#ifdef MANUAL_DEBUG_FFTW3
  dumpMatrixFloat3("bw_z_a", data, nx, ny, initdata.grid.dim3, thisIndex.x, thisIndex.y, thisIndex.z);
#endif

#endif
  
#if CMK_BLUEGENEL
  CmiNetworkProgress();
#endif

#ifdef FFTCHECK
  int dim3 = initdata.grid.dim3;
  int K1 = initdata.grid.K1;
  int K2 = initdata.grid.K2;
  int K3 = initdata.grid.K3;
  float scale = 1. / (1. * K1 * K2 * K3);
  float maxerr = 0.;
  float maxstd = 0.;
  int mi, mj, mk;  mi = mj = mk = -1;
  float std_base = 100. * (thisIndex.x+1.) + 10. * (thisIndex.y+1.);
  const float *d = data;
  for ( int i=0; i<nx; ++i ) {
   for ( int j=0; j<ny; ++j, d += dim3 ) {
    for ( int k=0; k<K3; ++k ) {
      float std = 10. * (10. * (10. * std_base + i) + j) + k;
      float err = scale * d[k] - std;
      if ( fabsf(err) > fabsf(maxerr) ) {
        maxerr = err;
        maxstd = std;
        mi = i;  mj = j;  mk = k;
      }
    }
   }
  }
  CkPrintf("pencil %d %d max error %f at %d %d %d (should be %f)\n",
                thisIndex.x, thisIndex.y, maxerr, mi, mj, mk, maxstd);
#endif

}

fft_init()

void PmeZPencil::fft_init

(

)

Definition at line 4851 of file ComputePme.C.

References PmeGrid::block1, PmeGrid::block2, PmePencil< CBase_PmeZPencil >::data, PmeGrid::dim3, PmePencil< CBase_PmeZPencil >::evir, ComputePmeMgr::fftw_plan_lock, fftwf_malloc, PmePencilInitMsgData::grid, PmePencil< CBase_PmeZPencil >::initdata, PmeGrid::K1, PmeGrid::K2, PmeGrid::K3, NAMD_die(), PmePencil< CBase_PmeZPencil >::order_init(), PmePencilInitMsgData::pmeNodeProxy, Node::simParameters, simParams, PmePencil< CBase_PmeZPencil >::work, and PmePencilInitMsgData::zBlocks.

                          {
  CProxy_Node nd(CkpvAccess(BOCclass_group).node);
  Node *node = nd.ckLocalBranch();
  SimParameters *simParams = node->simParameters;

#if USE_NODE_PAR_RECEIVE
  ((NodePmeMgr *)CkLocalNodeBranch(initdata.pmeNodeProxy))->registerZPencil(thisIndex,this);
#endif

  int K1 = initdata.grid.K1;
  int K2 = initdata.grid.K2;
  int K3 = initdata.grid.K3;
  int dim3 = initdata.grid.dim3;
  int block1 = initdata.grid.block1;
  int block2 = initdata.grid.block2;

  nx = block1;
  if ( (thisIndex.x + 1) * block1 > K1 ) nx = K1 - thisIndex.x * block1;
  ny = block2;
  if ( (thisIndex.y + 1) * block2 > K2 ) ny = K2 - thisIndex.y * block2;

#ifdef NAMD_FFTW
  CmiLock(ComputePmeMgr::fftw_plan_lock);

  data = (float *) fftwf_malloc( sizeof(float) *nx*ny*dim3);
  work = new float[dim3];

  order_init(initdata.zBlocks);

#ifdef NAMD_FFTW_3
  /* need array of sizes for the how many */

  int fftwFlags = simParams->FFTWPatient ? FFTW_PATIENT  : simParams->FFTWEstimate ? FFTW_ESTIMATE  : FFTW_MEASURE ;
  int sizeLines=nx*ny;
  int planLineSizes[1];
  planLineSizes[0]=K3;
  int ndim=initdata.grid.dim3; // storage space is initdata.grid.dim3
  int ndimHalf=ndim/2;
  forward_plan = fftwf_plan_many_dft_r2c(1, planLineSizes, sizeLines,
                                         (float *) data, NULL, 1, 
                                         ndim,
                                         (fftwf_complex *) data, NULL, 1,
                                         ndimHalf,
                                         fftwFlags);

  backward_plan = fftwf_plan_many_dft_c2r(1, planLineSizes, sizeLines,
                                          (fftwf_complex *) data, NULL, 1, 
                                          ndimHalf,
                                          (float *) data, NULL, 1, 
                                          ndim,
                                          fftwFlags);
#if     CMK_SMP && USE_CKLOOP
  if(simParams->useCkLoop) {
          //How many FFT plans to be created? The grain-size issue!!.
          //Currently, I am choosing the min(nx, ny) to be coarse-grain
          numPlans = (nx<=ny?nx:ny);
          if ( numPlans < CkMyNodeSize() ) numPlans = (nx>=ny?nx:ny);
          if ( numPlans < CkMyNodeSize() ) numPlans = sizeLines;
          int howmany = sizeLines/numPlans;
          forward_plans = new fftwf_plan[numPlans];
          backward_plans = new fftwf_plan[numPlans];
          for(int i=0; i<numPlans; i++) {
                  int dimStride = i*ndim*howmany;
                  int dimHalfStride = i*ndimHalf*howmany;
                  forward_plans[i] = fftwf_plan_many_dft_r2c(1, planLineSizes, howmany,
                                                                                                         ((float *)data)+dimStride, NULL, 1,
                                                                                                         ndim,
                                                                                                         ((fftwf_complex *)data)+dimHalfStride, NULL, 1,
                                                                                                         ndimHalf,
                                                                                                         fftwFlags);

                  backward_plans[i] = fftwf_plan_many_dft_c2r(1, planLineSizes, howmany,
                                                                                                         ((fftwf_complex *)data)+dimHalfStride, NULL, 1,
                                                                                                         ndimHalf,
                                                                                                         ((float *)data)+dimStride, NULL, 1,
                                                                                                         ndim,
                                                                                                         fftwFlags);
          }
  }else 
#endif 
  {
          forward_plans = NULL;
          backward_plans = NULL;
  }
#else
  forward_plan = rfftwnd_create_plan_specific(1, &K3, FFTW_REAL_TO_COMPLEX,
        ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
        | FFTW_IN_PLACE | FFTW_USE_WISDOM, data, 1, work, 1);
  backward_plan = rfftwnd_create_plan_specific(1, &K3, FFTW_COMPLEX_TO_REAL,
        ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
        | FFTW_IN_PLACE | FFTW_USE_WISDOM, data, 1, work, 1);
#endif
  CmiUnlock(ComputePmeMgr::fftw_plan_lock);
#else
  NAMD_die("Sorry, FFTW must be compiled in to use PME.");
#endif

#if USE_NODE_PAR_RECEIVE
    evir = 0.;
    memset(data, 0, sizeof(float) * nx*ny*dim3);
#endif
}

forward_fft()

void PmeZPencil::forward_fft

(

)

Definition at line 5275 of file ComputePme.C.

References CKLOOP_CTRL_PME_FORWARDFFT, PmePencil< CBase_PmeZPencil >::data, PmeGrid::dim3, PmePencil< CBase_PmeZPencil >::evir, PmePencilInitMsgData::grid, PmePencil< CBase_PmeZPencil >::initdata, PmeGrid::K3, Node::Object(), PmeXZPencilFFT(), Node::simParameters, SimParameters::useCkLoop, PmePencil< CBase_PmeZPencil >::work, PmePencilInitMsgData::xBlocks, and PmePencilInitMsgData::yBlocks.

Referenced by node_process_grid().

                             {
  evir = 0.;
#ifdef FFTCHECK
  int dim3 = initdata.grid.dim3;
  int K3 = initdata.grid.K3;
  float std_base = 100. * (thisIndex.x+1.) + 10. * (thisIndex.y+1.);
  float *d = data;
  for ( int i=0; i<nx; ++i ) {
   for ( int j=0; j<ny; ++j, d += dim3 ) {
    for ( int k=0; k<dim3; ++k ) {
      d[k] = 10. * (10. * (10. * std_base + i) + j) + k;
    }
   }
  }
#endif
#ifdef NAMD_FFTW
#ifdef MANUAL_DEBUG_FFTW3
  dumpMatrixFloat3("fw_z_b", data, nx, ny, initdata.grid.dim3, thisIndex.x, thisIndex.y, thisIndex.z);
#endif
#ifdef NAMD_FFTW_3
#if     CMK_SMP && USE_CKLOOP
  int useCkLoop = Node::Object()->simParameters->useCkLoop;
  if(useCkLoop>=CKLOOP_CTRL_PME_FORWARDFFT
     && CkNumPes() >= 2 * initdata.xBlocks * initdata.yBlocks) {
          //for(int i=0; i<numPlans; i++) fftwf_execute(forward_plans[i]);
          //transform the above loop
          CkLoop_Parallelize(PmeXZPencilFFT, 1, (void *)forward_plans, CkMyNodeSize(), 0, numPlans-1); //sync
          return;
  }
#endif
  fftwf_execute(forward_plan);
#else
  rfftwnd_real_to_complex(forward_plan, nx*ny,
        data, 1, initdata.grid.dim3, (fftw_complex *) work, 1, 0);
#endif
#ifdef MANUAL_DEBUG_FFTW3
  dumpMatrixFloat3("fw_z_a", data, nx, ny, initdata.grid.dim3, thisIndex.x, thisIndex.y, thisIndex.z);
#endif

#endif
#ifdef ZEROCHECK
  int dim3 = initdata.grid.dim3;
  int K3 = initdata.grid.K3;
  float *d = data;
  for ( int i=0; i<nx; ++i ) {
   for ( int j=0; j<ny; ++j, d += dim3 ) {
    for ( int k=0; k<dim3; ++k ) {
      if ( d[k] == 0. ) CkPrintf("0 in Z at %d %d %d %d %d %d %d %d %d\n",
        thisIndex.x, thisIndex.y, i, j, k, nx, ny, dim3);
    }
   }
  }
#endif
}

node_process_grid()

void PmeZPencil::node_process_grid

(

PmeGridMsg *

msg

)

Definition at line 6380 of file ComputePme.C.

References ComputePmeMgr::fftw_plan_lock, forward_fft(), PmeGridMsg::hasData, PmePencil< CBase_PmeZPencil >::hasData, PmePencil< CBase_PmeZPencil >::imsg, recv_grid(), send_trans(), and ResizeArray< Elem >::size().

Referenced by NodePmeMgr::recvZGrid().

{
#if USE_NODE_PAR_RECEIVE
  CmiLock(ComputePmeMgr::fftw_plan_lock);
  CmiMemoryReadFence();
#endif
  recv_grid(msg);
  if(msg->hasData) hasData=msg->hasData;
  int limsg;
  CmiMemoryAtomicFetchAndInc(imsg,limsg);
  grid_msgs[limsg] = msg;
  //  CkPrintf("[%d] PmeZPencil node_process_grid for %d %d %d has %d of %d imsg %d\n",CkMyPe(),thisIndex.x,thisIndex.y,thisIndex.z, limsg, grid_msgs.size(), imsg);      
  if(limsg+1 == grid_msgs.size())
    {

      if (hasData)
        {
          forward_fft();
        }
      send_trans();
      imsg=0;
      CmiMemoryWriteFence();
      //      CkPrintf("[%d] PmeZPencil grid node_zero imsg for %d %d %d\n",CkMyPe(),thisIndex.x,thisIndex.y,thisIndex.z);
    }
#if USE_NODE_PAR_RECEIVE
  CmiUnlock(ComputePmeMgr::fftw_plan_lock);
  CmiMemoryWriteFence();
#endif
}

node_process_untrans()

void PmeZPencil::node_process_untrans

(

PmeUntransMsg *

msg

)

Definition at line 6415 of file ComputePme.C.

References backward_fft(), PmePencil< CBase_PmeZPencil >::data, PmeGrid::dim3, PmePencil< CBase_PmeZPencil >::evir, ComputePmeMgr::fftw_plan_lock, PmePencilInitMsgData::grid, PmePencil< CBase_PmeZPencil >::hasData, PmePencil< CBase_PmeZPencil >::imsgb, PmePencil< CBase_PmeZPencil >::initdata, NAMD_bug(), recv_untrans(), send_all_ungrid(), and PmePencilInitMsgData::zBlocks.

Referenced by recvNodeAck(), and NodePmeMgr::recvZUntrans().

{
  if ( msg ) {
    if ( ! hasData ) NAMD_bug("PmeZPencil::node_process_untrans non-null msg but not hasData");
    recv_untrans(msg);
  } else if ( hasData ) NAMD_bug("PmeZPencil::node_process_untrans hasData but null msg");
#if USE_NODE_PAR_RECEIVE
  CmiMemoryWriteFence();
  CmiLock(ComputePmeMgr::fftw_plan_lock);
#endif    
  int limsg;
  CmiMemoryAtomicFetchAndInc(imsgb,limsg);
  if(limsg+1 == initdata.zBlocks)
    {
#if USE_NODE_PAR_RECEIVE
      CmiMemoryReadFence();
#endif    
      if(hasData) {
        backward_fft();
      }
      send_all_ungrid();
      hasData=0;
      imsgb=0;
      evir = 0;
      memset(data, 0, sizeof(float) * nx*ny* initdata.grid.dim3); 
      CmiMemoryWriteFence();
      //      CkPrintf("[%d] PmeZPencil untrans node_zero imsg for %d %d %d\n",CkMyPe(),thisIndex.x,thisIndex.y,thisIndex.z);
    }
#if USE_NODE_PAR_RECEIVE
  CmiUnlock(ComputePmeMgr::fftw_plan_lock);
#endif
}

recv_grid()

void PmeZPencil::recv_grid

(

const PmeGridMsg *

msg

)

Definition at line 5224 of file ComputePme.C.

References ResizeArray< Elem >::begin(), PmePencil< CBase_PmeZPencil >::data, PmeGrid::dim3, PmeGridMsg::fgrid, PmePencilInitMsgData::grid, PmeGridMsg::hasData, PmePencil< CBase_PmeZPencil >::imsg, PmePencil< CBase_PmeZPencil >::initdata, PmeGridMsg::lattice, PmePencil< CBase_PmeZPencil >::lattice, PmeGridMsg::qgrid, PmeGridMsg::sequence, PmePencil< CBase_PmeZPencil >::sequence, PmeGridMsg::zlist, and PmeGridMsg::zlistlen.

Referenced by node_process_grid().

                                                {

  int dim3 = initdata.grid.dim3;
  if ( imsg == 0 ) {
    lattice = msg->lattice;
    sequence = msg->sequence;
#if ! USE_NODE_PAR_RECEIVE
    memset(data, 0, sizeof(float)*nx*ny*dim3);
#endif
  }

  if ( ! msg->hasData ) return;

  int zlistlen = msg->zlistlen;
#ifdef NAMD_KNL
  int * __restrict msg_zlist = msg->zlist;
  int * __restrict zlist = (int*)__builtin_assume_aligned(work_zlist.begin(),
                                                          64);
  for ( int k=0; k<zlistlen; ++k ) {
    zlist[k] = msg_zlist[k];
  }
#else
  int * __restrict zlist = msg->zlist;
#endif
  char * __restrict fmsg = msg->fgrid;
  float * __restrict qmsg = msg->qgrid;
  float * __restrict d = data;
  int numGrids = 1;  // pencil FFT doesn't support multiple grids
  for ( int g=0; g<numGrids; ++g ) {
    for ( int i=0; i<nx; ++i ) {
     for ( int j=0; j<ny; ++j, d += dim3 ) {
      if( *(fmsg++) ) {
        #pragma ivdep
        for ( int k=0; k<zlistlen; ++k ) {
          d[zlist[k]] += *(qmsg++);
        }
      }
     }
    }
  }
}

recv_untrans()

void PmeZPencil::recv_untrans

(

const PmeUntransMsg *

msg

)

Definition at line 6211 of file ComputePme.C.

References PmeGrid::block3, PmePencil< CBase_PmeZPencil >::data, PmeGrid::dim3, PmePencil< CBase_PmeZPencil >::evir, PmePencilInitMsgData::grid, PmePencil< CBase_PmeZPencil >::imsg, PmePencil< CBase_PmeZPencil >::initdata, PmeUntransMsg::ny, PmeUntransMsg::qgrid, and PmeUntransMsg::sourceNode.

Referenced by node_process_untrans().

                                                      {
#if ! USE_NODE_PAR_RECEIVE
    if(imsg==0) evir=0.;
#endif

  int block3 = initdata.grid.block3;
  int dim3 = initdata.grid.dim3;
  int kb = msg->sourceNode;
  int nz = msg->ny;
  const float *md = msg->qgrid;
  float *d = data;
  for ( int i=0; i<nx; ++i ) {
#if CMK_BLUEGENEL
    CmiNetworkProgress();
#endif   
    for ( int j=0; j<ny; ++j, d += dim3 ) {
      for ( int k=kb*block3; k<(kb*block3+nz); ++k ) {
#ifdef ZEROCHECK
        if ( (*md) == 0. ) CkPrintf("0 in YZ at %d %d %d %d %d %d %d %d %d\n",
                                    thisIndex.x, thisIndex.y, kb, i, j, k, nx, ny, nz);
#endif
        d[2*k] = *(md++);
        d[2*k+1] = *(md++);
      }
    }
  }
}

recvNodeAck()

void PmeZPencil::recvNodeAck

(

PmeAckMsg *

msg

)

Definition at line 6410 of file ComputePme.C.

References node_process_untrans().

                                           {
  delete msg;
  node_process_untrans(0);
}

send_all_ungrid()

void PmeZPencil::send_all_ungrid

(

)

Definition at line 6307 of file ComputePme.C.

References CKLOOP_CTRL_PME_SENDUNTRANS, PmePencil< CBase_PmeZPencil >::initdata, Node::Object(), PmeZPencilSendUngrid(), send_subset_ungrid(), Node::simParameters, ResizeArray< Elem >::size(), SimParameters::useCkLoop, PmePencilInitMsgData::xBlocks, and PmePencilInitMsgData::yBlocks.

Referenced by node_process_untrans().

                                 {

#if     CMK_SMP && USE_CKLOOP
        int useCkLoop = Node::Object()->simParameters->useCkLoop;
        if(useCkLoop>=CKLOOP_CTRL_PME_SENDUNTRANS
           && CkNumPes() >= 2 * initdata.xBlocks * initdata.yBlocks) {
                //????What's the best value for numChunks?????
                CkLoop_Parallelize(PmeZPencilSendUngrid, 1, (void *)this, grid_msgs.size(), 0, grid_msgs.size()-1, 1); //has to sync
                return;
        }
#endif
        send_subset_ungrid(0, grid_msgs.size()-1);
}

send_subset_trans()

void PmeZPencil::send_subset_trans	(	int	fromIdx,
		int	toIdx
	)

Definition at line 5336 of file ComputePme.C.

References PmeGrid::block3, PmePencil< CBase_PmeZPencil >::data, PmeTransMsg::destElem, PmeGrid::dim3, PmePencilInitMsgData::grid, PmeTransMsg::hasData, PmePencil< CBase_PmeZPencil >::hasData, PmePencil< CBase_PmeZPencil >::initdata, PmeTransMsg::lattice, PmePencil< CBase_PmeZPencil >::lattice, PmeTransMsg::nx, PME_TRANS_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PRIORITY_SIZE, PmeTransMsg::qgrid, PmePencil< CBase_PmeZPencil >::send_order, PmeTransMsg::sequence, PmePencil< CBase_PmeZPencil >::sequence, SET_PRIORITY, PmeTransMsg::sourceNode, PmePencilInitMsgData::ym, PmePencilInitMsgData::yPencil, and PmePencilInitMsgData::zBlocks.

Referenced by PmeZPencilSendTrans().

                                                        {
        int zBlocks = initdata.zBlocks;
        int block3 = initdata.grid.block3;
        int dim3 = initdata.grid.dim3;
        for ( int isend=fromIdx; isend<=toIdx; ++isend ) {
          int kb = send_order[isend];
          int nz = block3;
          if ( (kb+1)*block3 > dim3/2 ) nz = dim3/2 - kb*block3;
          int hd = ( hasData ? 1 : 0 );
          PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
          msg->lattice = lattice;
          msg->sourceNode = thisIndex.y;
          msg->hasData = hasData;
          msg->nx = ny;
         if ( hasData ) {
          float *md = msg->qgrid;
          const float *d = data;
          for ( int i=0; i<nx; ++i ) {
           for ( int j=0; j<ny; ++j, d += dim3 ) {
                for ( int k=kb*block3; k<(kb*block3+nz); ++k ) {
                  *(md++) = d[2*k];
                  *(md++) = d[2*k+1];
                }
           }
          }
         }
          msg->sequence = sequence;
          SET_PRIORITY(msg,sequence,PME_TRANS_PRIORITY)

    CmiEnableUrgentSend(1);
#if USE_NODE_PAR_RECEIVE
      msg->destElem=CkArrayIndex3D(thisIndex.x,0,kb);
#if Y_PERSIST 
      CmiUsePersistentHandle(&trans_handle[isend], 1);
#endif
      initdata.pmeNodeProxy[CmiNodeOf(initdata.ym.ckLocalBranch()->procNum(0,msg->destElem))].recvYTrans(msg);
#if Y_PERSIST 
      CmiUsePersistentHandle(NULL, 0);
#endif    
#else
#if Y_PERSIST 
      CmiUsePersistentHandle(&trans_handle[isend], 1);
#endif
      initdata.yPencil(thisIndex.x,0,kb).recvTrans(msg);
#if Y_PERSIST 
      CmiUsePersistentHandle(NULL, 0);
#endif    
#endif
    CmiEnableUrgentSend(0);
    }
}

send_subset_ungrid()

void PmeZPencil::send_subset_ungrid	(	int	fromIdx,
		int	toIdx
	)

Definition at line 6321 of file ComputePme.C.

References send_ungrid().

Referenced by PmeZPencilSendUngrid(), and send_all_ungrid().

                                                         {
        for (int limsg=fromIdx; limsg <=toIdx; ++limsg ) {
                PmeGridMsg *msg = grid_msgs[limsg];
                send_ungrid(msg);
        }
}

send_trans()

void PmeZPencil::send_trans

(

)

Definition at line 5388 of file ComputePme.C.

References PmeGrid::block3, CKLOOP_CTRL_PME_SENDTRANS, PmePencil< CBase_PmeZPencil >::data, PmeTransMsg::destElem, PmeGrid::dim3, PmePencilInitMsgData::grid, PmeTransMsg::hasData, PmePencil< CBase_PmeZPencil >::hasData, PmePencil< CBase_PmeZPencil >::initdata, PmeTransMsg::lattice, PmePencil< CBase_PmeZPencil >::lattice, PmeTransMsg::nx, Node::Object(), PME_TRANS_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PmeZPencilSendTrans(), PRIORITY_SIZE, PmeTransMsg::qgrid, PmePencil< CBase_PmeZPencil >::send_order, PmeTransMsg::sequence, PmePencil< CBase_PmeZPencil >::sequence, SET_PRIORITY, Node::simParameters, PmeTransMsg::sourceNode, SimParameters::useCkLoop, PmePencilInitMsgData::xBlocks, PmePencilInitMsgData::yBlocks, PmePencilInitMsgData::ym, PmePencilInitMsgData::yPencil, and PmePencilInitMsgData::zBlocks.

Referenced by node_process_grid().

                            {
#if USE_PERSISTENT
    if (trans_handle == NULL) setup_persistent();
#endif
#if     CMK_SMP && USE_CKLOOP
        int useCkLoop = Node::Object()->simParameters->useCkLoop;
        if(useCkLoop>=CKLOOP_CTRL_PME_SENDTRANS
           && CkNumPes() >= 2 * initdata.xBlocks * initdata.yBlocks) {
                //send_subset_trans(0, initdata.zBlocks-1);
                CkLoop_Parallelize(PmeZPencilSendTrans, 1, (void *)this, CkMyNodeSize(), 0, initdata.zBlocks-1, 1); //not sync
                return;
        }
#endif
  int zBlocks = initdata.zBlocks;
  int block3 = initdata.grid.block3;
  int dim3 = initdata.grid.dim3;
  for ( int isend=0; isend<zBlocks; ++isend ) {
    int kb = send_order[isend];
    int nz = block3;
    if ( (kb+1)*block3 > dim3/2 ) nz = dim3/2 - kb*block3;
    int hd = ( hasData ? 1 : 0 );
    PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
    msg->lattice = lattice;
    msg->sourceNode = thisIndex.y;
    msg->hasData = hasData;
    msg->nx = ny;
   if ( hasData ) {
    float *md = msg->qgrid;
    const float *d = data;
    for ( int i=0; i<nx; ++i ) {
     for ( int j=0; j<ny; ++j, d += dim3 ) {
      for ( int k=kb*block3; k<(kb*block3+nz); ++k ) {
        *(md++) = d[2*k];
        *(md++) = d[2*k+1];
      }
     }
    }
   }
    msg->sequence = sequence;
    SET_PRIORITY(msg,sequence,PME_TRANS_PRIORITY)

    CmiEnableUrgentSend(1);
#if USE_NODE_PAR_RECEIVE
    msg->destElem=CkArrayIndex3D(thisIndex.x,0,kb);
#if Y_PERSIST 
    CmiUsePersistentHandle(&trans_handle[isend], 1);
#endif
    initdata.pmeNodeProxy[CmiNodeOf(initdata.ym.ckLocalBranch()->procNum(0,msg->destElem))].recvYTrans(msg);
#if Y_PERSIST 
    CmiUsePersistentHandle(NULL, 0);
#endif    
#else
#if Y_PERSIST 
    CmiUsePersistentHandle(&trans_handle[isend], 1);
#endif
    initdata.yPencil(thisIndex.x,0,kb).recvTrans(msg);
#if Y_PERSIST 
    CmiUsePersistentHandle(NULL, 0);
#endif    
#endif
    CmiEnableUrgentSend(0);
  }
}

send_ungrid()

void PmeZPencil::send_ungrid

(

PmeGridMsg *

msg

)

Definition at line 6328 of file ComputePme.C.

References PmePencil< CBase_PmeZPencil >::data, PmeGrid::dim3, PmeGridMsg::fgrid, PmePencilInitMsgData::grid, PmeGridMsg::hasData, PmePencil< CBase_PmeZPencil >::hasData, PmePencil< CBase_PmeZPencil >::initdata, NAMD_bug(), PmePencil< CBase_PmeZPencil >::offload, PME_OFFLOAD_UNGRID_PRIORITY, PME_UNGRID_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PmePencilInitMsgData::pmeProxy, PRIORITY_SIZE, PmeGridMsg::qgrid, PmePencil< CBase_PmeZPencil >::sequence, SET_PRIORITY, PmeGridMsg::sourceNode, PmePencilInitMsgData::yBlocks, PmeGridMsg::zlist, and PmeGridMsg::zlistlen.

Referenced by send_subset_ungrid().

                                            {

#if defined(NAMD_CUDA) || defined(NAMD_HIP)
  const int UNGRID_PRIORITY = ( offload ? PME_OFFLOAD_UNGRID_PRIORITY : PME_UNGRID_PRIORITY );
#else
  const int UNGRID_PRIORITY = PME_UNGRID_PRIORITY ;
#endif

  int pe = msg->sourceNode;
  if ( ! msg->hasData ) {
    delete msg;
    PmeAckMsg *ackmsg = new (PRIORITY_SIZE) PmeAckMsg;
    SET_PRIORITY(ackmsg,sequence,UNGRID_PRIORITY)
    CmiEnableUrgentSend(1);
    initdata.pmeProxy[pe].recvAck(ackmsg);
    CmiEnableUrgentSend(0);
    return;
  }
  if ( ! hasData ) NAMD_bug("PmeZPencil::send_ungrid msg->hasData but not pencil->hasData");
  msg->sourceNode = thisIndex.x * initdata.yBlocks + thisIndex.y;
  int dim3 = initdata.grid.dim3;
  int zlistlen = msg->zlistlen;
  int *zlist = msg->zlist;
  char *fmsg = msg->fgrid;
  float *qmsg = msg->qgrid;
  float *d = data;
  int numGrids = 1;  // pencil FFT doesn't support multiple grids
  for ( int g=0; g<numGrids; ++g ) {
#if CMK_BLUEGENEL
    CmiNetworkProgress();
#endif    
    for ( int i=0; i<nx; ++i ) {
      for ( int j=0; j<ny; ++j, d += dim3 ) {
        if( *(fmsg++) ) {
          for ( int k=0; k<zlistlen; ++k ) {
            *(qmsg++) = d[zlist[k]];
          }
        }
      }
    }
  }
  SET_PRIORITY(msg,sequence,UNGRID_PRIORITY)
    CmiEnableUrgentSend(1);
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
    if ( offload ) {
      initdata.pmeNodeProxy[CkNodeOf(pe)].recvUngrid(msg);
    } else
#endif
  initdata.pmeProxy[pe].recvUngrid(msg);
    CmiEnableUrgentSend(0);
}

---

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

• ComputePme.C