PmeYPencil Class Reference

Inheritance diagram for PmeYPencil:

Public Member Functions
PmeYPencil_SDAG_CODE	PmeYPencil ()
	PmeYPencil (CkMigrateMessage *)
void	fft_init ()
void	recv_trans (const PmeTransMsg *)
void	forward_fft ()
void	forward_subset_fft (int fromIdx, int toIdx)
void	send_trans ()
void	send_subset_trans (int fromIdx, int toIdx)
void	recv_untrans (const PmeUntransMsg *)
void	node_process_trans (PmeTransMsg *)
void	recvNodeAck (PmeAckMsg *)
void	node_process_untrans (PmeUntransMsg *)
void	backward_fft ()
void	backward_subset_fft (int fromIdx, int toIdx)
void	send_untrans ()
void	send_subset_untrans (int fromIdx, int toIdx)
Public Member Functions inherited from PmePencil< CBase_PmeYPencil >
	PmePencil ()
	~PmePencil ()
void	base_init (PmePencilInitMsg *msg)
void	order_init (int nBlocks)

Additional Inherited Members
Public Types inherited from PmePencil< CBase_PmeYPencil >
typedef int	AtomicInt
Public Attributes inherited from PmePencil< CBase_PmeYPencil >
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 4666 of file ComputePme.C.

Constructor & Destructor Documentation

PmeYPencil() [1/2]

PmeYPencil_SDAG_CODE PmeYPencil::PmeYPencil ( )

inline

Definition at line 4669 of file ComputePme.C.

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

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

PmeYPencil() [2/2]

PmeYPencil::PmeYPencil ( CkMigrateMessage *  )

inline

Definition at line 4670 of file ComputePme.C.

{ __sdag_init(); }

Member Function Documentation

backward_fft()

void PmeYPencil::backward_fft

(

)

Definition at line 5963 of file ComputePme.C.

References CKLOOP_CTRL_PME_BACKWARDFFT, PmePencil< CBase_PmeYPencil >::data, PmePencilInitMsgData::grid, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K2, Node::Object(), PmeYPencilBackwardFFT(), Node::simParameters, SimParameters::useCkLoop, PmePencil< CBase_PmeYPencil >::work, PmePencilInitMsgData::xBlocks, and PmePencilInitMsgData::zBlocks.

Referenced by node_process_untrans().

                              {
#ifdef NAMD_FFTW
#ifdef MANUAL_DEBUG_FFTW3
  dumpMatrixFloat3("bw_y_b", data, nx, initdata.grid.K2, nz, 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.zBlocks) {
          CkLoop_Parallelize(PmeYPencilBackwardFFT, 1, (void *)this, CkMyNodeSize(), 0, nx-1); //sync
          return;
  }
#endif
  //the above is a transformation of the following loop using CkLoop
  for ( int i=0; i<nx; ++i ) {
#if CMK_BLUEGENEL
        CmiNetworkProgress();
#endif
    fftwf_execute_dft(backward_plan,    
                                          ((fftwf_complex *) data) + i * nz * initdata.grid.K2,
                                          ((fftwf_complex *) data) + i * nz * initdata.grid.K2);
  }
#else
        for ( int i=0; i<nx; ++i ) {
#if CMK_BLUEGENEL
          CmiNetworkProgress();
#endif
                fftw(backward_plan, nz,
                ((fftw_complex *) data) + i * nz * initdata.grid.K2,
                nz, 1, (fftw_complex *) work, 1, 0);
        }
#endif

#ifdef MANUAL_DEBUG_FFTW3
  dumpMatrixFloat3("bw_y_a", data, nx, initdata.grid.K2, nz, thisIndex.x, thisIndex.y, thisIndex.z);
#endif

#endif
}

backward_subset_fft()

void PmeYPencil::backward_subset_fft	(	int	fromIdx,
		int	toIdx
	)

Definition at line 5951 of file ComputePme.C.

References PmePencil< CBase_PmeYPencil >::data, PmePencilInitMsgData::grid, PmePencil< CBase_PmeYPencil >::initdata, and PmeGrid::K2.

Referenced by PmeYPencilBackwardFFT().

                                                           {
#ifdef NAMD_FFTW
#ifdef NAMD_FFTW_3
        for(int i=fromIdx; i<=toIdx; i++){
                fftwf_execute_dft(backward_plan,        
                                                  ((fftwf_complex *) data) + i * nz * initdata.grid.K2,         
                                                  ((fftwf_complex *) data) + i * nz * initdata.grid.K2);
        }
#endif
#endif
}

fft_init()

void PmeYPencil::fft_init

(

)

Definition at line 4896 of file ComputePme.C.

References PmeGrid::block1, PmeGrid::block3, PmePencil< CBase_PmeYPencil >::data, PmeGrid::dim2, PmeGrid::dim3, PmePencil< CBase_PmeYPencil >::evir, ComputePmeMgr::fftw_plan_lock, fftwf_malloc, PmePencilInitMsgData::grid, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K1, PmeGrid::K2, NAMD_die(), PmePencil< CBase_PmeYPencil >::order_init(), PmePencilInitMsgData::pmeNodeProxy, Node::simParameters, simParams, PmePencil< CBase_PmeYPencil >::work, and PmePencilInitMsgData::yBlocks.

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

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

  int K1 = initdata.grid.K1;
  int K2 = initdata.grid.K2;
  int dim2 = initdata.grid.dim2;
  int dim3 = initdata.grid.dim3;
  int block1 = initdata.grid.block1;
  int block3 = initdata.grid.block3;

  nx = block1;
  if ( (thisIndex.x + 1) * block1 > K1 ) nx = K1 - thisIndex.x * block1;
  nz = block3;
  if ( (thisIndex.z+1)*block3 > dim3/2 ) nz = dim3/2 - thisIndex.z*block3;

#ifdef NAMD_FFTW
  CmiLock(ComputePmeMgr::fftw_plan_lock);

  data = (float *) fftwf_malloc( sizeof(float) * nx*dim2*nz*2);
  work = new float[2*K2];

  order_init(initdata.yBlocks);

#ifdef NAMD_FFTW_3
  /* need array of sizes for the dimensions */
  /* ideally this should be implementable as a single multidimensional
   *  plan, but that has proven tricky to implement, so we maintain the
   *  loop of 1d plan executions. */
  int sizeLines=nz;
  int planLineSizes[1];
  planLineSizes[0]=K2;
  int fftwFlags = simParams->FFTWPatient ? FFTW_PATIENT  : simParams->FFTWEstimate ? FFTW_ESTIMATE  : FFTW_MEASURE ;
  forward_plan = fftwf_plan_many_dft(1, planLineSizes, sizeLines, 
                                     (fftwf_complex *) data, NULL, sizeLines, 1,
                                     (fftwf_complex *) data, NULL, sizeLines, 1,
                                     FFTW_FORWARD, 
                                     fftwFlags);
  backward_plan = fftwf_plan_many_dft(1, planLineSizes, sizeLines, 
                                     (fftwf_complex *) data, NULL, sizeLines, 1,
                                     (fftwf_complex *) data, NULL, sizeLines, 1,
                                     FFTW_BACKWARD, 
                                      fftwFlags);
  CkAssert(forward_plan != NULL);
  CkAssert(backward_plan != NULL);
#else
  forward_plan = fftw_create_plan_specific(K2, FFTW_FORWARD,
        ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
        | FFTW_IN_PLACE | FFTW_USE_WISDOM, (fftw_complex *) data,
        nz, (fftw_complex *) work, 1);
  backward_plan = fftw_create_plan_specific(K2, FFTW_BACKWARD,
        ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
        | FFTW_IN_PLACE | FFTW_USE_WISDOM, (fftw_complex *) data,
        nz, (fftw_complex *) 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;
  CmiMemoryWriteFence();
#endif
}

forward_fft()

void PmeYPencil::forward_fft

(

)

Definition at line 5453 of file ComputePme.C.

References CKLOOP_CTRL_PME_FORWARDFFT, PmePencil< CBase_PmeYPencil >::data, PmeGrid::dim2, PmePencil< CBase_PmeYPencil >::evir, PmePencilInitMsgData::grid, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K2, Node::Object(), PmeYPencilForwardFFT(), Node::simParameters, SimParameters::useCkLoop, PmePencil< CBase_PmeYPencil >::work, PmePencilInitMsgData::xBlocks, and PmePencilInitMsgData::zBlocks.

Referenced by node_process_trans().

                             {
    evir = 0.;
#ifdef NAMD_FFTW
#ifdef MANUAL_DEBUG_FFTW3
  dumpMatrixFloat3("fw_y_b", data, nx, initdata.grid.K2, nz, 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.zBlocks) {
          CkLoop_Parallelize(PmeYPencilForwardFFT, 1, (void *)this, CkMyNodeSize(), 0, nx-1); //sync
          return;
  }
#endif
  //the above is a transformation of the following loop using CkLoop
  for ( int i=0; i<nx; ++i ) {
    fftwf_execute_dft(forward_plan, ((fftwf_complex *) data) + i 
                      * nz * initdata.grid.K2,  
                      ((fftwf_complex *) data) + i * nz * initdata.grid.K2);
  }
#else
  for ( int i=0; i<nx; ++i ) {
    fftw(forward_plan, nz,
        ((fftw_complex *) data) + i * nz * initdata.grid.K2,
        nz, 1, (fftw_complex *) work, 1, 0);
  }
#endif
#ifdef MANUAL_DEBUG_FFTW3
  dumpMatrixFloat3("fw_y_a", data, nx, initdata.grid.dim2, nz, thisIndex.x, thisIndex.y, thisIndex.z);
#endif

#endif
}

forward_subset_fft()

void PmeYPencil::forward_subset_fft	(	int	fromIdx,
		int	toIdx
	)

Definition at line 5441 of file ComputePme.C.

References PmePencil< CBase_PmeYPencil >::data, PmePencilInitMsgData::grid, PmePencil< CBase_PmeYPencil >::initdata, and PmeGrid::K2.

Referenced by PmeYPencilForwardFFT().

                                                          {
#ifdef NAMD_FFTW
#ifdef NAMD_FFTW_3
        for(int i=fromIdx; i<=toIdx; i++){
                fftwf_execute_dft(forward_plan, ((fftwf_complex *) data) + i 
                      * nz * initdata.grid.K2,  
                      ((fftwf_complex *) data) + i * nz * initdata.grid.K2);
        }
#endif
#endif
}

node_process_trans()

void PmeYPencil::node_process_trans

(

PmeTransMsg *

msg

)

Definition at line 4967 of file ComputePme.C.

References forward_fft(), PmeTransMsg::hasData, PmePencil< CBase_PmeYPencil >::hasData, PmePencil< CBase_PmeYPencil >::imsg, PmePencil< CBase_PmeYPencil >::initdata, PmePencil< CBase_PmeYPencil >::needs_reply, recv_trans(), send_trans(), PmeTransMsg::sourceNode, and PmePencilInitMsgData::yBlocks.

Referenced by NodePmeMgr::recvYTrans().

{
  if ( msg->hasData ) hasData = 1;
  needs_reply[msg->sourceNode] = msg->hasData;
  recv_trans(msg);
  int limsg;
  CmiMemoryAtomicFetchAndInc(imsg,limsg);
  if(limsg+1 == initdata.yBlocks)
    {
      if ( hasData ) {
        forward_fft();
      }
      send_trans();
      imsg=0;
      CmiMemoryWriteFence();
    }
}

node_process_untrans()

void PmeYPencil::node_process_untrans

(

PmeUntransMsg *

msg

)

Definition at line 4990 of file ComputePme.C.

References backward_fft(), PmePencil< CBase_PmeYPencil >::hasData, PmePencil< CBase_PmeYPencil >::imsgb, PmePencil< CBase_PmeYPencil >::initdata, NAMD_bug(), recv_untrans(), send_untrans(), and PmePencilInitMsgData::yBlocks.

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

{
  if ( msg ) {
    if ( ! hasData ) NAMD_bug("PmeYPencil::node_process_untrans non-null msg but not hasData");
    recv_untrans(msg);
  } else if ( hasData ) NAMD_bug("PmeYPencil::node_process_untrans hasData but null msg");
  int limsg;
  CmiMemoryAtomicFetchAndInc(imsgb,limsg);
  if(limsg+1 == initdata.yBlocks)
    {
     if ( hasData ) {
      backward_fft();
     }
      hasData=0;
      imsgb=0;
      CmiMemoryWriteFence();
      send_untrans();
    }
}

recv_trans()

void PmeYPencil::recv_trans

(

const PmeTransMsg *

msg

)

Definition at line 5400 of file ComputePme.C.

References PmeGrid::block2, PmePencil< CBase_PmeYPencil >::data, PmePencilInitMsgData::grid, PmeTransMsg::hasData, PmePencil< CBase_PmeYPencil >::imsg, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K2, PmeTransMsg::lattice, PmePencil< CBase_PmeYPencil >::lattice, PmeTransMsg::nx, PmeTransMsg::qgrid, PmeTransMsg::sequence, PmePencil< CBase_PmeYPencil >::sequence, and PmeTransMsg::sourceNode.

Referenced by node_process_trans().

                                                  {
  if ( imsg == 0 ) {
    lattice = msg->lattice;
    sequence = msg->sequence;
  }
  int block2 = initdata.grid.block2;
  int K2 = initdata.grid.K2;
  int jb = msg->sourceNode;
  int ny = msg->nx;
 if ( msg->hasData ) {
  const float *md = msg->qgrid;
  float *d = data;
  for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
   for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
    for ( int k=0; k<nz; ++k ) {
#ifdef ZEROCHECK
      if ( (*md) == 0. ) CkPrintf("0 in ZY at %d %d %d %d %d %d %d %d %d\n",
        thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
#endif
      d[2*(j*nz+k)] = *(md++);
      d[2*(j*nz+k)+1] = *(md++);
    }
   }
  }
 } else {
  float *d = data;
  for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
   for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
    for ( int k=0; k<nz; ++k ) {
      d[2*(j*nz+k)] = 0;
      d[2*(j*nz+k)+1] = 0;
    }
   }
  }
 }
}

recv_untrans()

void PmeYPencil::recv_untrans

(

const PmeUntransMsg *

msg

)

Definition at line 5922 of file ComputePme.C.

References PmeGrid::block2, PmePencil< CBase_PmeYPencil >::data, PmePencilInitMsgData::grid, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K2, PmeUntransMsg::ny, PmeUntransMsg::qgrid, and PmeUntransMsg::sourceNode.

Referenced by node_process_untrans().

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

recvNodeAck()

void PmeYPencil::recvNodeAck

(

PmeAckMsg *

msg

)

Definition at line 4985 of file ComputePme.C.

References node_process_untrans().

                                           {
  delete msg;
  node_process_untrans(0);
}

send_subset_trans()

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

Definition at line 5494 of file ComputePme.C.

References PmeGrid::block2, PmePencil< CBase_PmeYPencil >::data, PmeTransMsg::destElem, PmePencilInitMsgData::grid, PmeTransMsg::hasData, PmePencil< CBase_PmeYPencil >::hasData, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K2, PmeTransMsg::lattice, PmePencil< CBase_PmeYPencil >::lattice, PmeTransMsg::nx, PME_TRANS2_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PRIORITY_SIZE, PmeTransMsg::qgrid, PmePencil< CBase_PmeYPencil >::send_order, PmeTransMsg::sequence, PmePencil< CBase_PmeYPencil >::sequence, SET_PRIORITY, PmeTransMsg::sourceNode, PmePencilInitMsgData::xm, PmePencilInitMsgData::xPencil, and PmePencilInitMsgData::yBlocks.

Referenced by PmeYPencilSendTrans().

                                                        {
        int yBlocks = initdata.yBlocks;
        int block2 = initdata.grid.block2;
        int K2 = initdata.grid.K2;
    for ( int isend=fromIdx; isend<=toIdx; ++isend ) {
          int jb = send_order[isend];
          int ny = block2;
          if ( (jb+1)*block2 > K2 ) ny = K2 - jb*block2;
          int hd = ( hasData ? 1 : 0 );
          PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
          msg->lattice = lattice;
          msg->sourceNode = thisIndex.x;
          msg->hasData = hasData;
          msg->nx = nx;
         if ( hasData ) {
          float *md = msg->qgrid;
          const float *d = data;
          for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
           for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
                for ( int k=0; k<nz; ++k ) {
                  *(md++) = d[2*(j*nz+k)];
                  *(md++) = d[2*(j*nz+k)+1];
  #ifdef ZEROCHECK
                  if ( *(md-2) == 0. ) CkPrintf("send 0 in YX at %d %d %d %d %d %d %d %d %d\n",
          thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
  #endif
                }
           }
          }
          if ( md != msg->qgrid + nx*ny*nz*2 ) CkPrintf("error in YX at %d %d %d\n",
          thisIndex.x, jb, thisIndex.z);
         }
          msg->sequence = sequence;
          SET_PRIORITY(msg,sequence,PME_TRANS2_PRIORITY)
      CmiEnableUrgentSend(1);
#if USE_NODE_PAR_RECEIVE
      msg->destElem=CkArrayIndex3D(0,jb,thisIndex.z);
#if X_PERSIST 
      CmiUsePersistentHandle(&trans_handle[isend], 1);
#endif
      initdata.pmeNodeProxy[CmiNodeOf(initdata.xm.ckLocalBranch()->procNum(0,msg->destElem))].recvXTrans(msg);   
#if X_PERSIST 
      CmiUsePersistentHandle(NULL, 0);
#endif
#else      
#if X_PERSIST 
      CmiUsePersistentHandle(&trans_handle[isend], 1);
#endif
      initdata.xPencil(0,jb,thisIndex.z).recvTrans(msg);
#if X_PERSIST 
      CmiUsePersistentHandle(NULL, 0);
#endif
#endif
      CmiEnableUrgentSend(0);
        }
}

send_subset_untrans()

void PmeYPencil::send_subset_untrans	(	int	fromIdx,
		int	toIdx
	)

Definition at line 6010 of file ComputePme.C.

References PmeGrid::block2, PmePencil< CBase_PmeYPencil >::data, PmeUntransMsg::destElem, PmePencilInitMsgData::grid, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K2, PmePencil< CBase_PmeYPencil >::needs_reply, PmeUntransMsg::ny, PME_UNTRANS2_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PRIORITY_SIZE, PmeUntransMsg::qgrid, PmePencil< CBase_PmeYPencil >::send_order, PmePencil< CBase_PmeYPencil >::sequence, SET_PRIORITY, PmeUntransMsg::sourceNode, PmePencilInitMsgData::yBlocks, PmePencilInitMsgData::zm, and PmePencilInitMsgData::zPencil.

Referenced by PmeYPencilSendUntrans().

                                                          {
        int yBlocks = initdata.yBlocks;
        int block2 = initdata.grid.block2;      
        int K2 = initdata.grid.K2;

        for(int isend=fromIdx; isend<=toIdx; isend++) {
                int jb = send_order[isend];
                if ( ! needs_reply[jb] ) {
                        PmeAckMsg *msg = new (PRIORITY_SIZE) PmeAckMsg;
                        CmiEnableUrgentSend(1);
                        SET_PRIORITY(msg,sequence,PME_UNTRANS2_PRIORITY)
#if USE_NODE_PAR_RECEIVE
                        initdata.zPencil(thisIndex.x,jb,0).recvNodeAck(msg);
#else
                        initdata.zPencil(thisIndex.x,jb,0).recvAck(msg);
#endif
                        CmiEnableUrgentSend(0);
                        continue;
                }
                int ny = block2;
                if ( (jb+1)*block2 > K2 ) ny = K2 - jb*block2;
                PmeUntransMsg *msg = new (nx*ny*nz*2,PRIORITY_SIZE) PmeUntransMsg;
                msg->sourceNode = thisIndex.z;
                msg->ny = nz;
                float *md = msg->qgrid;
                const float *d = data;
                for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
                        for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
                                for ( int k=0; k<nz; ++k ) {
                                        *(md++) = d[2*(j*nz+k)];
                                        *(md++) = d[2*(j*nz+k)+1];
                                }
                        }
                }
                SET_PRIORITY(msg,sequence,PME_UNTRANS2_PRIORITY)
            CmiEnableUrgentSend(1);
#if USE_NODE_PAR_RECEIVE
        msg->destElem=CkArrayIndex3D( thisIndex.x, jb, 0);
        //    CkPrintf("[%d] sending to %d %d %d recvZUntrans on node %d\n", CkMyPe(), thisIndex.x, jb, 0, CmiNodeOf(initdata.zm.ckLocalBranch()->procNum(0,msg->destElem)));
#if Z_PERSIST 
        CmiUsePersistentHandle(&untrans_handle[isend], 1);
#endif
        initdata.pmeNodeProxy[CmiNodeOf(initdata.zm.ckLocalBranch()->procNum(0,msg->destElem))].recvZUntrans(msg);
#if Z_PERSIST 
        CmiUsePersistentHandle(NULL, 0);
#endif
#else
#if Z_PERSIST 
        CmiUsePersistentHandle(&untrans_handle[isend], 1);
#endif
        initdata.zPencil(thisIndex.x,jb,0).recvUntrans(msg);
#if Z_PERSIST 
        CmiUsePersistentHandle(NULL, 0);
#endif
#endif
    CmiEnableUrgentSend(0);
        }
}

send_trans()

void PmeYPencil::send_trans

(

)

Definition at line 5551 of file ComputePme.C.

References PmeGrid::block2, CKLOOP_CTRL_PME_SENDTRANS, PmePencil< CBase_PmeYPencil >::data, PmeTransMsg::destElem, PmePencilInitMsgData::grid, PmeTransMsg::hasData, PmePencil< CBase_PmeYPencil >::hasData, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K2, PmeTransMsg::lattice, PmePencil< CBase_PmeYPencil >::lattice, PmeTransMsg::nx, Node::Object(), PME_TRANS2_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PmeYPencilSendTrans(), PRIORITY_SIZE, PmeTransMsg::qgrid, PmePencil< CBase_PmeYPencil >::send_order, PmeTransMsg::sequence, PmePencil< CBase_PmeYPencil >::sequence, SET_PRIORITY, Node::simParameters, PmeTransMsg::sourceNode, SimParameters::useCkLoop, PmePencilInitMsgData::xBlocks, PmePencilInitMsgData::xm, PmePencilInitMsgData::xPencil, PmePencilInitMsgData::yBlocks, and PmePencilInitMsgData::zBlocks.

Referenced by node_process_trans().

                            {
#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.zBlocks) {
                //send_subset_trans(0, initdata.yBlocks-1);
                CkLoop_Parallelize(PmeYPencilSendTrans, 1, (void *)this, CkMyNodeSize(), 0, initdata.yBlocks-1, 1); //not sync
                return;
        }
#endif
  int yBlocks = initdata.yBlocks;
  int block2 = initdata.grid.block2;
  int K2 = initdata.grid.K2;
  for ( int isend=0; isend<yBlocks; ++isend ) {
    int jb = send_order[isend];
    int ny = block2;
    if ( (jb+1)*block2 > K2 ) ny = K2 - jb*block2;
    int hd = ( hasData ? 1 : 0 );
    PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
    msg->lattice = lattice;
    msg->sourceNode = thisIndex.x;
    msg->hasData = hasData;
    msg->nx = nx;
   if ( hasData ) {
    float *md = msg->qgrid;
    const float *d = data;
    for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
     for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
      for ( int k=0; k<nz; ++k ) {
        *(md++) = d[2*(j*nz+k)];
        *(md++) = d[2*(j*nz+k)+1];
#ifdef ZEROCHECK
        if ( *(md-2) == 0. ) CkPrintf("send 0 in YX at %d %d %d %d %d %d %d %d %d\n",
        thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
#endif
      }
     }
    }
    if ( md != msg->qgrid + nx*ny*nz*2 ) CkPrintf("error in YX at %d %d %d\n",
        thisIndex.x, jb, thisIndex.z);
   }
    msg->sequence = sequence;
    SET_PRIORITY(msg,sequence,PME_TRANS2_PRIORITY)
    CmiEnableUrgentSend(1);
#if USE_NODE_PAR_RECEIVE
    msg->destElem=CkArrayIndex3D(0,jb,thisIndex.z);
#if X_PERSIST 
        CmiUsePersistentHandle(&trans_handle[isend], 1);
#endif
    initdata.pmeNodeProxy[CmiNodeOf(initdata.xm.ckLocalBranch()->procNum(0,msg->destElem))].recvXTrans(msg);   
#if X_PERSIST 
        CmiUsePersistentHandle(NULL, 0);
#endif
#else
#if X_PERSIST 
        CmiUsePersistentHandle(&trans_handle[isend], 1);
#endif
    initdata.xPencil(0,jb,thisIndex.z).recvTrans(msg);
#if X_PERSIST 
        CmiUsePersistentHandle(NULL, 0);
#endif
    
#endif
    CmiEnableUrgentSend(0);
  }
}

send_untrans()

void PmeYPencil::send_untrans

(

)

Definition at line 6069 of file ComputePme.C.

References PmeGrid::block2, CKLOOP_CTRL_PME_SENDUNTRANS, PmePencil< CBase_PmeYPencil >::data, PmeUntransMsg::destElem, PmePencil< CBase_PmeYPencil >::evir, PmePencilInitMsgData::grid, PmePencil< CBase_PmeYPencil >::initdata, PmeGrid::K2, PmePencil< CBase_PmeYPencil >::needs_reply, PmeUntransMsg::ny, Node::Object(), PME_UNTRANS2_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PmeYPencilSendUntrans(), PRIORITY_SIZE, PmeUntransMsg::qgrid, PmePencil< CBase_PmeYPencil >::send_order, PmePencil< CBase_PmeYPencil >::sequence, SET_PRIORITY, Node::simParameters, PmeUntransMsg::sourceNode, SimParameters::useCkLoop, PmePencilInitMsgData::xBlocks, PmePencilInitMsgData::yBlocks, PmePencilInitMsgData::zBlocks, PmePencilInitMsgData::zm, and PmePencilInitMsgData::zPencil.

Referenced by node_process_untrans().

                              {
#if USE_PERSISTENT
  if (untrans_handle == NULL) setup_persistent();
#endif
#if     CMK_SMP && USE_CKLOOP
  int useCkLoop = Node::Object()->simParameters->useCkLoop;
  if(useCkLoop>=CKLOOP_CTRL_PME_SENDUNTRANS
     && CkNumPes() >= 2 * initdata.xBlocks * initdata.zBlocks) {
          int yBlocks = initdata.yBlocks;

#if USE_NODE_PAR_RECEIVE      
          //CkLoop_Parallelize(PmeYPencilSendUntrans, 1, (void *)this, CkMyNodeSize(), 0, yBlocks-1, 1); //sync
          CkLoop_Parallelize(PmeYPencilSendUntrans, 1, (void *)this, yBlocks, 0, yBlocks-1, 1);
#else
      //CkLoop_Parallelize(PmeYPencilSendUntrans, 1, (void *)this, CkMyNodeSize(), 0, yBlocks-1, 0); //not sync
          CkLoop_Parallelize(PmeYPencilSendUntrans, 1, (void *)this, yBlocks, 0, yBlocks-1, 0); //not sync
#endif
          return;
  }
#endif
  int yBlocks = initdata.yBlocks;
  int block2 = initdata.grid.block2;
  int K2 = initdata.grid.K2;
  for ( int isend=0; isend<yBlocks; ++isend ) {
    int jb = send_order[isend];
    if ( ! needs_reply[jb] ) {
      PmeAckMsg *msg = new (PRIORITY_SIZE) PmeAckMsg;
      CmiEnableUrgentSend(1);
      SET_PRIORITY(msg,sequence,PME_UNTRANS2_PRIORITY)
#if USE_NODE_PAR_RECEIVE
      initdata.zPencil(thisIndex.x,jb,0).recvNodeAck(msg);
#else
      initdata.zPencil(thisIndex.x,jb,0).recvAck(msg);
#endif
      CmiEnableUrgentSend(0);
      continue;
    }
    int ny = block2;
    if ( (jb+1)*block2 > K2 ) ny = K2 - jb*block2;
    PmeUntransMsg *msg = new (nx*ny*nz*2,PRIORITY_SIZE) PmeUntransMsg;
    msg->sourceNode = thisIndex.z;
    msg->ny = nz;
    float *md = msg->qgrid;
    const float *d = data;
    for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
     for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
      for ( int k=0; k<nz; ++k ) {
        *(md++) = d[2*(j*nz+k)];
        *(md++) = d[2*(j*nz+k)+1];
      }
     }
    }
    SET_PRIORITY(msg,sequence,PME_UNTRANS2_PRIORITY)

    CmiEnableUrgentSend(1);
#if USE_NODE_PAR_RECEIVE
    msg->destElem=CkArrayIndex3D( thisIndex.x, jb, 0);
    //    CkPrintf("[%d] sending to %d %d %d recvZUntrans on node %d\n", CkMyPe(), thisIndex.x, jb, 0, CmiNodeOf(initdata.zm.ckLocalBranch()->procNum(0,msg->destElem)));
#if Z_PERSIST 
    CmiUsePersistentHandle(&untrans_handle[isend], 1);
#endif
    initdata.pmeNodeProxy[CmiNodeOf(initdata.zm.ckLocalBranch()->procNum(0,msg->destElem))].recvZUntrans(msg);
#if Z_PERSIST
    CmiUsePersistentHandle(NULL, 0);
#endif
#else
#if Z_PERSIST 
    CmiUsePersistentHandle(&untrans_handle[isend], 1);
#endif
    initdata.zPencil(thisIndex.x,jb,0).recvUntrans(msg);
#if Z_PERSIST 
    CmiUsePersistentHandle(NULL, 0);
#endif
#endif    
    CmiEnableUrgentSend(0);
  }
  
#if USE_NODE_PAR_RECEIVE
  evir = 0.;
  CmiMemoryWriteFence();
#endif
}

---

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

• ComputePme.C