Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

PmeZPencil Class Reference

Inheritance diagram for PmeZPencil:

PmePencil< CBase_PmeZPencil > CBase_PmeZPencil List of all members.

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 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, int specialIdx)

Constructor & Destructor Documentation

PmeZPencil_SDAG_CODE PmeZPencil::PmeZPencil (   )  [inline]
 

Definition at line 3335 of file ComputePme.C.

03335 { __sdag_init(); setMigratable(false); }

PmeZPencil::PmeZPencil (  CkMigrateMessage *   )  [inline]
 

Definition at line 3336 of file ComputePme.C.

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

PmeZPencil::~PmeZPencil (   )  [inline]
 

Definition at line 3337 of file ComputePme.C.

03337                       {
03338         #ifdef NAMD_FFTW
03339         #ifdef NAMD_FFTW_3
03340                 delete [] forward_plans;
03341                 delete [] backward_plans;
03342         #endif
03343         #endif
03344         }

Member Function Documentation

void PmeZPencil::backward_fft (   ) 
 

Definition at line 4997 of file ComputePme.C.

References PmeGrid::dim3, PmePencilInitMsgData::grid, j, PmeGrid::K1, PmeGrid::K2, PmeGrid::K3, Node::Object(), PmeXZPencilFFT(), Node::simParameters, and SimParameters::useNodeHelper.

Referenced by node_process_untrans().

04997                               {
04998 #ifdef NAMD_FFTW
04999 #ifdef MANUAL_DEBUG_FFTW3
05000   dumpMatrixFloat3("bw_z_b", data, nx, ny, initdata.grid.dim3, thisIndex.x, thisIndex.y, thisIndex.z);
05001 #endif
05002 #ifdef NAMD_FFTW_3
05003 #if     USE_NODEHELPER
05004   int useNodeHelper = Node::Object()->simParameters->useNodeHelper;
05005   if(useNodeHelper>=NDH_CTRL_PME_BACKWARDFFT) {
05006           //for(int i=0; i<numPlans; i++) fftwf_execute(backward_plans[i]);
05007           //transform the above loop
05008           CProxy_FuncNodeHelper nodeHelper = CkpvAccess(BOCclass_group).nodeHelper;
05009           NodeHelper_Parallelize(nodeHelper, PmeXZPencilFFT, 1, (void *)backward_plans, CkMyNodeSize(), 0, numPlans-1); //sync
05010           return;
05011   }
05012 #endif
05013   fftwf_execute(backward_plan);
05014 #else
05015   rfftwnd_complex_to_real(backward_plan, nx*ny,
05016             (fftw_complex *) data, 1, initdata.grid.dim3/2, work, 1, 0);
05017 #endif
05018 #ifdef MANUAL_DEBUG_FFTW3
05019   dumpMatrixFloat3("bw_z_a", data, nx, ny, initdata.grid.dim3, thisIndex.x, thisIndex.y, thisIndex.z);
05020 #endif
05021 
05022 #endif
05023   
05024 #if CMK_BLUEGENEL
05025   CmiNetworkProgress();
05026 #endif
05027 
05028 #ifdef FFTCHECK
05029   int dim3 = initdata.grid.dim3;
05030   int K1 = initdata.grid.K1;
05031   int K2 = initdata.grid.K2;
05032   int K3 = initdata.grid.K3;
05033   float scale = 1. / (1. * K1 * K2 * K3);
05034   float maxerr = 0.;
05035   float maxstd = 0.;
05036   int mi, mj, mk;  mi = mj = mk = -1;
05037   float std_base = 100. * (thisIndex.x+1.) + 10. * (thisIndex.y+1.);
05038   const float *d = data;
05039   for ( int i=0; i<nx; ++i ) {
05040    for ( int j=0; j<ny; ++j, d += dim3 ) {
05041     for ( int k=0; k<K3; ++k ) {
05042       float std = 10. * (10. * (10. * std_base + i) + j) + k;
05043       float err = scale * d[k] - std;
05044       if ( fabsf(err) > fabsf(maxerr) ) {
05045         maxerr = err;
05046         maxstd = std;
05047         mi = i;  mj = j;  mk = k;
05048       }
05049     }
05050    }
05051   }
05052   CkPrintf("pencil %d %d max error %f at %d %d %d (should be %f)\n",
05053                 thisIndex.x, thisIndex.y, maxerr, mi, mj, mk, maxstd);
05054 #endif
05055 
05056 }

void PmeZPencil::fft_init (   ) 
 

Definition at line 3512 of file ComputePme.C.

References PmeGrid::block1, PmeGrid::block2, PmeGrid::dim3, SimParameters::FFTWEstimate, fftwf_malloc, SimParameters::FFTWPatient, PmePencilInitMsgData::grid, PmeGrid::K1, PmeGrid::K2, PmeGrid::K3, NAMD_die(), PmePencil< CBase_PmeZPencil >::order_init(), PmePencilInitMsgData::pmeNodeProxy, Node::simParameters, simParams, SimParameters::useNodeHelper, and PmePencilInitMsgData::zBlocks.

03512                           {
03513   CProxy_Node nd(CkpvAccess(BOCclass_group).node);
03514   Node *node = nd.ckLocalBranch();
03515   SimParameters *simParams = node->simParameters;
03516 
03517 #if USE_NODE_PAR_RECEIVE
03518   ((NodePmeMgr *)CkLocalNodeBranch(initdata.pmeNodeProxy))->registerZPencil(thisIndex,this);
03519 #endif
03520 
03521   int K1 = initdata.grid.K1;
03522   int K2 = initdata.grid.K2;
03523   int K3 = initdata.grid.K3;
03524   int dim3 = initdata.grid.dim3;
03525   int block1 = initdata.grid.block1;
03526   int block2 = initdata.grid.block2;
03527 
03528   nx = block1;
03529   if ( (thisIndex.x + 1) * block1 > K1 ) nx = K1 - thisIndex.x * block1;
03530   ny = block2;
03531   if ( (thisIndex.y + 1) * block2 > K2 ) ny = K2 - thisIndex.y * block2;
03532 
03533   data = (float *) fftwf_malloc( sizeof(float) *nx*ny*dim3);
03534   work = new float[dim3];
03535 
03536   order_init(initdata.zBlocks);
03537 
03538 #ifdef NAMD_FFTW
03539   CmiLock(ComputePmeMgr::fftw_plan_lock);
03540 #ifdef NAMD_FFTW_3
03541   /* need array of sizes for the how many */
03542 
03543   int fftwFlags = simParams->FFTWPatient ? FFTW_PATIENT  : simParams->FFTWEstimate ? FFTW_ESTIMATE  : FFTW_MEASURE ;
03544   int sizeLines=nx*ny;
03545   int planLineSizes[1];
03546   planLineSizes[0]=K3;
03547   int ndim=initdata.grid.dim3; // storage space is initdata.grid.dim3
03548   int ndimHalf=ndim/2;
03549   forward_plan = fftwf_plan_many_dft_r2c(1, planLineSizes, sizeLines,
03550                                          (float *) data, NULL, 1, 
03551                                          ndim,
03552                                          (fftwf_complex *) data, NULL, 1,
03553                                          ndimHalf,
03554                                          fftwFlags);
03555 
03556   backward_plan = fftwf_plan_many_dft_c2r(1, planLineSizes, sizeLines,
03557                                           (fftwf_complex *) data, NULL, 1, 
03558                                           ndimHalf,
03559                                           (float *) data, NULL, 1, 
03560                                           ndim,
03561                                           fftwFlags);
03562 #if     USE_NODEHELPER
03563   if(simParams->useNodeHelper) {
03564           //How many FFT plans to be created? The grain-size issue!!.
03565           //Currently, I am choosing the min(nx, ny) to be coarse-grain
03566           numPlans = (nx<=ny?nx:ny);
03567           int howmany = sizeLines/numPlans;
03568           forward_plans = new fftwf_plan[numPlans];
03569           backward_plans = new fftwf_plan[numPlans];
03570           for(int i=0; i<numPlans; i++) {
03571                   int dimStride = i*ndim*howmany;
03572                   int dimHalfStride = i*ndimHalf*howmany;
03573                   forward_plans[i] = fftwf_plan_many_dft_r2c(1, planLineSizes, howmany,
03574                                                                                                          ((float *)data)+dimStride, NULL, 1,
03575                                                                                                          ndim,
03576                                                                                                          ((fftwf_complex *)data)+dimHalfStride, NULL, 1,
03577                                                                                                          ndimHalf,
03578                                                                                                          fftwFlags);
03579 
03580                   backward_plans[i] = fftwf_plan_many_dft_c2r(1, planLineSizes, howmany,
03581                                                                                                          ((fftwf_complex *)data)+dimHalfStride, NULL, 1,
03582                                                                                                          ndimHalf,
03583                                                                                                          ((float *)data)+dimStride, NULL, 1,
03584                                                                                                          ndim,
03585                                                                                                          fftwFlags);
03586           }
03587   }else 
03588 #endif 
03589   {
03590           forward_plans = NULL;
03591           backward_plans = NULL;
03592   }
03593 #else
03594   forward_plan = rfftwnd_create_plan_specific(1, &K3, FFTW_REAL_TO_COMPLEX,
03595         ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
03596         | FFTW_IN_PLACE | FFTW_USE_WISDOM, data, 1, work, 1);
03597   backward_plan = rfftwnd_create_plan_specific(1, &K3, FFTW_COMPLEX_TO_REAL,
03598         ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
03599         | FFTW_IN_PLACE | FFTW_USE_WISDOM, data, 1, work, 1);
03600 #endif
03601   CmiUnlock(ComputePmeMgr::fftw_plan_lock);
03602 #else
03603   NAMD_die("Sorry, FFTW must be compiled in to use PME.");
03604 #endif
03605 
03606 #if USE_NODE_PAR_RECEIVE
03607     evir = 0.;
03608     memset(data, 0, sizeof(float) * nx*ny*dim3);
03609 #endif
03610 }

void PmeZPencil::forward_fft (   ) 
 

Definition at line 3910 of file ComputePme.C.

References PmeGrid::dim3, PmePencilInitMsgData::grid, j, PmeGrid::K3, Node::Object(), PmeXZPencilFFT(), Node::simParameters, and SimParameters::useNodeHelper.

Referenced by node_process_grid().

03910                              {
03911   evir = 0.;
03912 #ifdef FFTCHECK
03913   int dim3 = initdata.grid.dim3;
03914   int K3 = initdata.grid.K3;
03915   float std_base = 100. * (thisIndex.x+1.) + 10. * (thisIndex.y+1.);
03916   float *d = data;
03917   for ( int i=0; i<nx; ++i ) {
03918    for ( int j=0; j<ny; ++j, d += dim3 ) {
03919     for ( int k=0; k<dim3; ++k ) {
03920       d[k] = 10. * (10. * (10. * std_base + i) + j) + k;
03921     }
03922    }
03923   }
03924 #endif
03925 #ifdef NAMD_FFTW
03926 #ifdef MANUAL_DEBUG_FFTW3
03927   dumpMatrixFloat3("fw_z_b", data, nx, ny, initdata.grid.dim3, thisIndex.x, thisIndex.y, thisIndex.z);
03928 #endif
03929 #ifdef NAMD_FFTW_3
03930 #if     USE_NODEHELPER
03931   int useNodeHelper = Node::Object()->simParameters->useNodeHelper;
03932   if(useNodeHelper>=NDH_CTRL_PME_FORWARDFFT) {
03933           //for(int i=0; i<numPlans; i++) fftwf_execute(forward_plans[i]);
03934           //transform the above loop
03935           CProxy_FuncNodeHelper nodeHelper = CkpvAccess(BOCclass_group).nodeHelper;
03936           NodeHelper_Parallelize(nodeHelper, PmeXZPencilFFT, 1, (void *)forward_plans, CkMyNodeSize(), 0, numPlans-1); //sync
03937           return;
03938   }
03939 #endif
03940   fftwf_execute(forward_plan);
03941 #else
03942   rfftwnd_real_to_complex(forward_plan, nx*ny,
03943         data, 1, initdata.grid.dim3, (fftw_complex *) work, 1, 0);
03944 #endif
03945 #ifdef MANUAL_DEBUG_FFTW3
03946   dumpMatrixFloat3("fw_z_a", data, nx, ny, initdata.grid.dim3, thisIndex.x, thisIndex.y, thisIndex.z);
03947 #endif
03948 
03949 #endif
03950 #ifdef ZEROCHECK
03951   int dim3 = initdata.grid.dim3;
03952   int K3 = initdata.grid.K3;
03953   float *d = data;
03954   for ( int i=0; i<nx; ++i ) {
03955    for ( int j=0; j<ny; ++j, d += dim3 ) {
03956     for ( int k=0; k<dim3; ++k ) {
03957       if ( d[k] == 0. ) CkPrintf("0 in Z at %d %d %d %d %d %d %d %d %d\n",
03958         thisIndex.x, thisIndex.y, i, j, k, nx, ny, dim3);
03959     }
03960    }
03961   }
03962 #endif
03963 }

void PmeZPencil::node_process_grid (  PmeGridMsg *   ) 
 

Definition at line 5163 of file ComputePme.C.

References forward_fft(), PmeGridMsg::hasData, recv_grid(), send_trans(), and ResizeArray< Elem >::size().

Referenced by NodePmeMgr::recvZGrid().

05164 {
05165 #if USE_NODE_PAR_RECEIVE
05166   CmiLock(ComputePmeMgr::fftw_plan_lock);
05167   CmiMemoryReadFence();
05168 #endif
05169   recv_grid(msg);
05170   if(msg->hasData) hasData=msg->hasData;
05171   int limsg;
05172   CmiMemoryAtomicFetchAndInc(imsg,limsg);
05173   grid_msgs[limsg] = msg;
05174   //  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);      
05175   if(limsg+1 == grid_msgs.size())
05176     {
05177 
05178       if (hasData)
05179         {
05180           forward_fft();
05181         }
05182       send_trans();
05183       imsg=0;
05184       CmiMemoryWriteFence();
05185       //      CkPrintf("[%d] PmeZPencil grid node_zero imsg for %d %d %d\n",CkMyPe(),thisIndex.x,thisIndex.y,thisIndex.z);
05186     }
05187 #if USE_NODE_PAR_RECEIVE
05188   CmiUnlock(ComputePmeMgr::fftw_plan_lock);
05189   CmiMemoryWriteFence();
05190 #endif
05191 }

void PmeZPencil::node_process_untrans (  PmeUntransMsg *   ) 
 

Definition at line 5193 of file ComputePme.C.

References backward_fft(), PmeGrid::dim3, PmePencilInitMsgData::grid, recv_untrans(), send_all_ungrid(), and PmePencilInitMsgData::zBlocks.

Referenced by NodePmeMgr::recvZUntrans().

05194 {
05195 #if USE_NODE_PAR_RECEIVE
05196   CmiLock(ComputePmeMgr::fftw_plan_lock);
05197   CmiMemoryReadFence();
05198 #endif    
05199   recv_untrans(msg);
05200   int limsg;
05201   CmiMemoryAtomicFetchAndInc(imsgb,limsg);
05202   if(limsg+1 == initdata.zBlocks)
05203     {
05204       if(hasData) // maybe this should be an assert
05205         {
05206           backward_fft();
05207         }
05208         
05209         send_all_ungrid();
05210     /*  int send_evir = 1;
05211       // TODO: this part should use Chao's output parallelization
05212       for ( limsg=0; limsg < grid_msgs.size(); ++limsg ) {
05213         PmeGridMsg *omsg = grid_msgs[limsg];
05214         if ( omsg->hasData ) {
05215           if ( send_evir ) {
05216             omsg->evir[0] = evir;
05217             send_evir = 0;
05218           } else {
05219             omsg->evir[0] = 0.;
05220           }
05221         }
05222         send_ungrid(omsg);
05223       } */
05224       imsgb=0;
05225       evir = 0;
05226       memset(data, 0, sizeof(float) * nx*ny* initdata.grid.dim3); 
05227       CmiMemoryWriteFence();
05228       //      CkPrintf("[%d] PmeZPencil untrans node_zero imsg for %d %d %d\n",CkMyPe(),thisIndex.x,thisIndex.y,thisIndex.z);
05229     }
05230 #if USE_NODE_PAR_RECEIVE
05231   CmiUnlock(ComputePmeMgr::fftw_plan_lock);
05232   CmiMemoryWriteFence();
05233 #endif
05234 }

void PmeZPencil::recv_grid (  const PmeGridMsg *   ) 
 

Definition at line 3869 of file ComputePme.C.

References PmeGrid::dim3, PmeGridMsg::fgrid, PmePencilInitMsgData::grid, PmeGridMsg::hasData, j, PmeGridMsg::lattice, PmeGridMsg::qgrid, PmeGridMsg::sequence, PmeGridMsg::zlist, and PmeGridMsg::zlistlen.

Referenced by node_process_grid().

03869                                                 {
03870 
03871   int dim3 = initdata.grid.dim3;
03872   if ( imsg == 0 ) {
03873     lattice = msg->lattice;
03874     sequence = msg->sequence;
03875 #if ! USE_NODE_PAR_RECEIVE
03876     memset(data, 0, sizeof(float)*nx*ny*dim3);
03877 #endif
03878   }
03879 
03880   if ( ! msg->hasData ) return;
03881 
03882   int zlistlen = msg->zlistlen;
03883   int *zlist = msg->zlist;
03884   char *fmsg = msg->fgrid;
03885   float *qmsg = msg->qgrid;
03886   float *d = data;
03887   int numGrids = 1;  // pencil FFT doesn't support multiple grids
03888   for ( int g=0; g<numGrids; ++g ) {
03889     for ( int i=0; i<nx; ++i ) {
03890      for ( int j=0; j<ny; ++j, d += dim3 ) {
03891       if( *(fmsg++) ) {
03892         for ( int k=0; k<zlistlen; ++k ) {
03893           d[zlist[k]] += *(qmsg++);
03894         }
03895       }
03896      }
03897     }
03898   }
03899 }

void PmeZPencil::recv_untrans (  const PmeUntransMsg *   ) 
 

Definition at line 4968 of file ComputePme.C.

References PmeGrid::block3, PmeGrid::dim3, PmeUntransMsg::evir, PmePencilInitMsgData::grid, PmeUntransMsg::has_evir, j, PmeUntransMsg::ny, PmeUntransMsg::qgrid, and PmeUntransMsg::sourceNode.

Referenced by node_process_untrans().

04968                                                       {
04969 #if ! USE_NODE_PAR_RECEIVE
04970     if(imsg==0) evir=0.;
04971 #endif
04972 
04973   if ( msg->has_evir ) evir += msg->evir[0];
04974   int block3 = initdata.grid.block3;
04975   int dim3 = initdata.grid.dim3;
04976   int kb = msg->sourceNode;
04977   int nz = msg->ny;
04978   const float *md = msg->qgrid;
04979   float *d = data;
04980   for ( int i=0; i<nx; ++i ) {
04981 #if CMK_BLUEGENEL
04982     CmiNetworkProgress();
04983 #endif   
04984     for ( int j=0; j<ny; ++j, d += dim3 ) {
04985       for ( int k=kb*block3; k<(kb*block3+nz); ++k ) {
04986 #ifdef ZEROCHECK
04987         if ( (*md) == 0. ) CkPrintf("0 in YZ at %d %d %d %d %d %d %d %d %d\n",
04988                                     thisIndex.x, thisIndex.y, kb, i, j, k, nx, ny, nz);
04989 #endif
04990         d[2*k] = *(md++);
04991         d[2*k+1] = *(md++);
04992       }
04993     }
04994   }
04995 }

void PmeZPencil::send_all_ungrid (   ) 
 

Definition at line 5066 of file ComputePme.C.

References Bool, Node::Object(), PmeZPencilSendUngrid(), send_subset_ungrid(), Node::simParameters, ResizeArray< Elem >::size(), and SimParameters::useNodeHelper.

Referenced by node_process_untrans().

05066                                  {
05067 /* 
05068 //Original code: the transformation is to first extract the msg 
05069 //idx that will has evir value set. -Chao Mei  
05070         int send_evir = 1;
05071         for (int imsg=0; imsg < grid_msgs.size(); ++imsg ) {
05072                 PmeGridMsg *msg = grid_msgs[imsg];
05073                 if ( msg->hasData ) {
05074                         if ( send_evir ) {
05075                                 msg->evir[0] = evir;
05076                                 send_evir = 0;
05077                         } else {
05078                                 msg->evir[0] = 0.;
05079                         }
05080                 }
05081                 send_ungrid(msg);
05082         }
05083 */
05084         int evirIdx = 0;
05085         for(int imsg=0; imsg<grid_msgs.size(); imsg++) {
05086                 if(grid_msgs[imsg]->hasData) {
05087                         evirIdx = imsg;
05088                         break;
05089                 }
05090         }
05091 
05092 #if     USE_NODEHELPER
05093         Bool useNodeHelper = Node::Object()->simParameters->useNodeHelper;
05094         if(useNodeHelper>=NDH_CTRL_PME_SENDUNTRANS) {
05095                 CProxy_FuncNodeHelper nodeHelper = CkpvAccess(BOCclass_group).nodeHelper;
05096                 //????What's the best value for numChunks?????
05097 #if USE_NODE_PAR_RECEIVE        
05098                 //NodeHelper_Parallelize(nodeHelper, PmeZPencilSendUngrid, evirIdx, (void *)this, CkMyNodeSize(), 0, grid_msgs.size()-1, 1); //has to sync
05099                 NodeHelper_Parallelize(nodeHelper, PmeZPencilSendUngrid, evirIdx, (void *)this, grid_msgs.size(), 0, grid_msgs.size()-1, 1); //has to sync
05100 #else
05101         //NodeHelper_Parallelize(nodeHelper, PmeZPencilSendUngrid, evirIdx, (void *)this, CkMyNodeSize(), 0, grid_msgs.size()-1, 0); //not sync
05102                 NodeHelper_Parallelize(nodeHelper, PmeZPencilSendUngrid, evirIdx, (void *)this, grid_msgs.size(), 0, grid_msgs.size()-1, 0); //not sync
05103 #endif        
05104                 return;
05105         }
05106 #endif
05107         send_subset_ungrid(0, grid_msgs.size()-1, evirIdx);
05108 }

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

Definition at line 3971 of file ComputePme.C.

References PmeGrid::block3, PmeTransMsg::destElem, PmeGrid::dim3, PmePencilInitMsgData::grid, PmeTransMsg::hasData, j, PmeTransMsg::lattice, PmeTransMsg::nx, PME_TRANS_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PmeTransMsg::qgrid, PmeTransMsg::sequence, SET_PRIORITY, PmeTransMsg::sourceNode, PmePencilInitMsgData::ym, PmePencilInitMsgData::yPencil, and PmePencilInitMsgData::zBlocks.

Referenced by PmeZPencilSendTrans().

03971                                                         {
03972         int zBlocks = initdata.zBlocks;
03973         int block3 = initdata.grid.block3;
03974         int dim3 = initdata.grid.dim3;
03975         for ( int isend=fromIdx; isend<=toIdx; ++isend ) {
03976           int kb = send_order[isend];
03977           int nz = block3;
03978           if ( (kb+1)*block3 > dim3/2 ) nz = dim3/2 - kb*block3;
03979           int hd = ( hasData ? 1 : 0 );
03980           PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
03981           msg->lattice = lattice;
03982           msg->sourceNode = thisIndex.y;
03983           msg->hasData = hasData;
03984           msg->nx = ny;
03985          if ( hasData ) {
03986           float *md = msg->qgrid;
03987           const float *d = data;
03988           for ( int i=0; i<nx; ++i ) {
03989            for ( int j=0; j<ny; ++j, d += dim3 ) {
03990                 for ( int k=kb*block3; k<(kb*block3+nz); ++k ) {
03991                   *(md++) = d[2*k];
03992                   *(md++) = d[2*k+1];
03993                 }
03994            }
03995           }
03996          }
03997           msg->sequence = sequence;
03998           SET_PRIORITY(msg,sequence,PME_TRANS_PRIORITY)
03999 
04000     CmiEnableUrgentSend(1);
04001 #if USE_NODE_PAR_RECEIVE
04002       msg->destElem=CkArrayIndex3D(thisIndex.x,0,kb);
04003 #if USE_PERSISTENT 
04004       CmiUsePersistentHandle(&trans_handle[isend], 1);
04005 #endif
04006       initdata.pmeNodeProxy[CmiNodeOf(initdata.ym.ckLocalBranch()->procNum(0,msg->destElem))].recvYTrans(msg);
04007 #if USE_PERSISTENT
04008       CmiUsePersistentHandle(NULL, 0);
04009 #endif    
04010 #else
04011 #if USE_PERSISTENT 
04012       CmiUsePersistentHandle(&trans_handle[isend], 1);
04013 #endif
04014       initdata.yPencil(thisIndex.x,0,kb).recvTrans(msg);
04015 #if USE_PERSISTENT
04016       CmiUsePersistentHandle(NULL, 0);
04017 #endif    
04018 #endif
04019     CmiEnableUrgentSend(0);
04020     }
04021 }

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

Definition at line 5110 of file ComputePme.C.

References PmeGridMsg::evir, PmeGridMsg::hasData, and send_ungrid().

Referenced by PmeZPencilSendUngrid(), and send_all_ungrid().

05110                                                                          {
05111         for (int imsg=fromIdx; imsg <=toIdx; ++imsg ) {
05112                 PmeGridMsg *msg = grid_msgs[imsg];
05113                 if ( msg->hasData) {
05114                         if (imsg == specialIdx) {
05115                                 msg->evir[0] = evir;                            
05116                         } else {
05117                                 msg->evir[0] = 0.;
05118                         }
05119                 }
05120                 send_ungrid(msg);
05121         }
05122 }

void PmeZPencil::send_trans (   ) 
 

Definition at line 4023 of file ComputePme.C.

References PmeGrid::block3, Bool, PmeTransMsg::destElem, PmeGrid::dim3, PmePencilInitMsgData::grid, PmeTransMsg::hasData, j, PmeTransMsg::lattice, PmeTransMsg::nx, Node::Object(), PME_TRANS_PRIORITY, PmePencilInitMsgData::pmeNodeProxy, PmeZPencilSendTrans(), PmeTransMsg::qgrid, PmeTransMsg::sequence, SET_PRIORITY, Node::simParameters, PmeTransMsg::sourceNode, SimParameters::useNodeHelper, PmePencilInitMsgData::ym, PmePencilInitMsgData::yPencil, and PmePencilInitMsgData::zBlocks.

Referenced by node_process_grid().

04023                             {
04024 #if USE_PERSISTENT
04025     if (trans_handle == NULL) setup_persistent();
04026 #endif
04027 #if     USE_NODEHELPER
04028         Bool useNodeHelper = Node::Object()->simParameters->useNodeHelper;
04029         if(useNodeHelper>=NDH_CTRL_PME_SENDTRANS) {
04036                 //send_subset_trans(0, initdata.zBlocks-1);
04037                 CProxy_FuncNodeHelper nodeHelper = CkpvAccess(BOCclass_group).nodeHelper;               
04038                 NodeHelper_Parallelize(nodeHelper, PmeZPencilSendTrans, 1, (void *)this, CkMyNodeSize(), 0, initdata.zBlocks-1, 1); //not sync
04039                 return;
04040         }
04041 #endif
04042   int zBlocks = initdata.zBlocks;
04043   int block3 = initdata.grid.block3;
04044   int dim3 = initdata.grid.dim3;
04045   for ( int isend=0; isend<zBlocks; ++isend ) {
04046     int kb = send_order[isend];
04047     int nz = block3;
04048     if ( (kb+1)*block3 > dim3/2 ) nz = dim3/2 - kb*block3;
04049     int hd = ( hasData ? 1 : 0 );
04050     PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
04051     msg->lattice = lattice;
04052     msg->sourceNode = thisIndex.y;
04053     msg->hasData = hasData;
04054     msg->nx = ny;
04055    if ( hasData ) {
04056     float *md = msg->qgrid;
04057     const float *d = data;
04058     for ( int i=0; i<nx; ++i ) {
04059      for ( int j=0; j<ny; ++j, d += dim3 ) {
04060       for ( int k=kb*block3; k<(kb*block3+nz); ++k ) {
04061         *(md++) = d[2*k];
04062         *(md++) = d[2*k+1];
04063       }
04064      }
04065     }
04066    }
04067     msg->sequence = sequence;
04068     SET_PRIORITY(msg,sequence,PME_TRANS_PRIORITY)
04069 
04070     CmiEnableUrgentSend(1);
04071 #if USE_NODE_PAR_RECEIVE
04072     msg->destElem=CkArrayIndex3D(thisIndex.x,0,kb);
04073 #if USE_PERSISTENT
04074     CmiUsePersistentHandle(&trans_handle[isend], 1);
04075 #endif
04076     initdata.pmeNodeProxy[CmiNodeOf(initdata.ym.ckLocalBranch()->procNum(0,msg->destElem))].recvYTrans(msg);
04077 #if USE_PERSISTENT
04078     CmiUsePersistentHandle(NULL, 0);
04079 #endif    
04080 #else
04081 #if USE_PERSISTENT
04082     CmiUsePersistentHandle(&trans_handle[isend], 1);
04083 #endif
04084     initdata.yPencil(thisIndex.x,0,kb).recvTrans(msg);
04085 #if USE_PERSISTENT
04086     CmiUsePersistentHandle(NULL, 0);
04087 #endif    
04088 #endif
04089     CmiEnableUrgentSend(0);
04090   }
04091 }

void PmeZPencil::send_ungrid (  PmeGridMsg *   ) 
 

Definition at line 5124 of file ComputePme.C.

References PmeGrid::dim3, PmeGridMsg::fgrid, PmePencilInitMsgData::grid, PmeGridMsg::hasData, j, PME_UNGRID_PRIORITY, PmePencilInitMsgData::pmeProxy, PmeGridMsg::qgrid, SET_PRIORITY, PmeGridMsg::sourceNode, PmePencilInitMsgData::yBlocks, PmeGridMsg::zlist, and PmeGridMsg::zlistlen.

Referenced by send_subset_ungrid().

05124                                             {
05125   int pe = msg->sourceNode;
05126   if ( ! msg->hasData ) {
05127     delete msg;
05128     PmeAckMsg *ackmsg = new (PRIORITY_SIZE) PmeAckMsg;
05129     SET_PRIORITY(ackmsg,sequence,PME_UNGRID_PRIORITY)
05130     CmiEnableUrgentSend(1);
05131     initdata.pmeProxy[pe].recvAck(ackmsg);
05132     CmiEnableUrgentSend(0);
05133     return;
05134   }
05135   msg->sourceNode = thisIndex.x * initdata.yBlocks + thisIndex.y;
05136   int dim3 = initdata.grid.dim3;
05137   int zlistlen = msg->zlistlen;
05138   int *zlist = msg->zlist;
05139   char *fmsg = msg->fgrid;
05140   float *qmsg = msg->qgrid;
05141   float *d = data;
05142   int numGrids = 1;  // pencil FFT doesn't support multiple grids
05143   for ( int g=0; g<numGrids; ++g ) {
05144 #if CMK_BLUEGENEL
05145     CmiNetworkProgress();
05146 #endif    
05147     for ( int i=0; i<nx; ++i ) {
05148       for ( int j=0; j<ny; ++j, d += dim3 ) {
05149         if( *(fmsg++) ) {
05150           for ( int k=0; k<zlistlen; ++k ) {
05151             *(qmsg++) = d[zlist[k]];
05152           }
05153         }
05154       }
05155     }
05156   }
05157   SET_PRIORITY(msg,sequence,PME_UNGRID_PRIORITY)
05158     CmiEnableUrgentSend(1);
05159   initdata.pmeProxy[pe].recvUngrid(msg);
05160     CmiEnableUrgentSend(0);
05161 }

The documentation for this class was generated from the following file:
Generated on Fri May 25 04:07:24 2012 for NAMD by  doxygen 1.3.9.1