NAMD
Classes | Macros | Functions | Variables
ComputePme.C File Reference
#include <sfftw.h>
#include <srfftw.h>
#include <vector>
#include <algorithm>
#include <deque>
#include "InfoStream.h"
#include "Node.h"
#include "PatchMap.h"
#include "PatchMap.inl"
#include "AtomMap.h"
#include "ComputePme.h"
#include "ComputePmeMgr.decl.h"
#include "PmeBase.inl"
#include "PmeRealSpace.h"
#include "PmeKSpace.h"
#include "ComputeNonbondedUtil.h"
#include "PatchMgr.h"
#include "Molecule.h"
#include "ReductionMgr.h"
#include "ComputeMgr.h"
#include "ComputeMgr.decl.h"
#include "Debug.h"
#include "SimParameters.h"
#include "WorkDistrib.h"
#include "varsizemsg.h"
#include "Random.h"
#include "ckhashtable.h"
#include "Priorities.h"
#include "ComputeMoa.h"
#include "ComputeMoaMgr.decl.h"
#include "DeviceCUDA.h"
#include <cuda_runtime.h>
#include <cuda.h>
#include "ComputePmeCUDAKernel.h"
#include "ComputePmeMgr.def.h"

Go to the source code of this file.

Classes

class  PmeAckMsg
 
class  PmeGridMsg
 
class  PmeTransMsg
 
class  PmeSharedTransMsg
 
class  PmeUntransMsg
 
class  PmeSharedUntransMsg
 
class  PmeEvirMsg
 
class  PmePencilMap
 
struct  PmePencilInitMsgData
 
class  PmePencilInitMsg
 
struct  LocalPmeInfo
 
struct  NodePmeInfo
 
struct  sortop_bit_reversed
 
struct  ijpair
 
struct  ijpair_sortop_bit_reversed
 
class  ComputePmeMgr
 
struct  ComputePmeMgr::cuda_submit_charges_args
 
class  NodePmeMgr
 
class  PmePencil< T >
 
class  PmeZPencil
 
class  PmeYPencil
 
class  PmeXPencil
 

Macros

#define fftwf_malloc   fftw_malloc
 
#define fftwf_free   fftw_free
 
#define MIN_DEBUG_LEVEL   3
 
#define NUM_STREAMS   1
 
#define CUDA_STREAM_CREATE(X)   cudaStreamCreate(X)
 
#define CUDA_EVENT_ID_PME_CHARGES   80
 
#define CUDA_EVENT_ID_PME_FORCES   81
 
#define CUDA_EVENT_ID_PME_TICK   82
 
#define CUDA_EVENT_ID_PME_COPY   83
 
#define CUDA_EVENT_ID_PME_KERNEL   84
 
#define count_limit   1000000
 
#define CUDA_POLL(FN, ARG)   CcdCallFnAfter(FN,ARG,0.1)
 
#define EVENT_STRIDE   10
 
#define XCOPY(X)   masterPmeMgr->X = X;
 
#define XCOPY(X)   X = masterPmeMgr->X;
 
#define DEBUG_NODE_PAR_RECV   0
 

Functions

void cuda_errcheck (const char *msg)
 
static int findRecipEvirPe ()
 
void generatePmePeList2 (int *gridPeMap, int numGridPes, int *transPeMap, int numTransPes)
 
int compare_bit_reversed (int a, int b)
 
bool less_than_bit_reversed (int a, int b)
 
ResizeArray< ComputePme * > & getComputes (ComputePmeMgr *mgr)
 
int isPmeProcessor (int p)
 
void Pme_init ()
 
static void PmeSlabSendTrans (int first, int last, void *result, int paraNum, void *param)
 
static void PmeSlabSendUntrans (int first, int last, void *result, int paraNum, void *param)
 
static void PmeSlabSendUngrid (int first, int last, void *result, int paraNum, void *param)
 
void CcdCallBacksReset (void *ignored, double curWallTime)
 
void cudaDie (const char *msg, cudaError_t err=cudaSuccess)
 
void cuda_check_pme_forces (void *arg, double walltime)
 
void cuda_check_pme_charges (void *arg, double walltime)
 
static void PmeXZPencilFFT (int first, int last, void *result, int paraNum, void *param)
 
static void PmeZPencilSendTrans (int first, int last, void *result, int paraNum, void *param)
 
static void PmeYPencilForwardFFT (int first, int last, void *result, int paraNum, void *param)
 
static void PmeYPencilSendTrans (int first, int last, void *result, int paraNum, void *param)
 
static void PmeXPencilSendUntrans (int first, int last, void *result, int paraNum, void *param)
 
static void PmeYPencilBackwardFFT (int first, int last, void *result, int paraNum, void *param)
 
static void PmeYPencilSendUntrans (int first, int last, void *result, int paraNum, void *param)
 
static void PmeZPencilSendUngrid (int first, int last, void *result, int paraNum, void *param)
 

Variables

__thread DeviceCUDAdeviceCUDA
 
char * pencilPMEProcessors
 

Macro Definition Documentation

#define count_limit   1000000

Definition at line 2475 of file ComputePme.C.

Referenced by cuda_check_pme_charges(), and cuda_check_pme_forces().

#define CUDA_EVENT_ID_PME_CHARGES   80
#define CUDA_EVENT_ID_PME_COPY   83
#define CUDA_EVENT_ID_PME_FORCES   81
#define CUDA_EVENT_ID_PME_KERNEL   84
#define CUDA_EVENT_ID_PME_TICK   82
#define CUDA_POLL (   FN,
  ARG 
)    CcdCallFnAfter(FN,ARG,0.1)
#define CUDA_STREAM_CREATE (   X)    cudaStreamCreate(X)
#define DEBUG_NODE_PAR_RECV   0

Definition at line 4985 of file ComputePme.C.

#define EVENT_STRIDE   10

Definition at line 2477 of file ComputePme.C.

Referenced by cuda_check_pme_forces(), and ComputePmeMgr::ungridCalc().

#define fftwf_free   fftw_free

Definition at line 14 of file ComputePme.C.

Referenced by PmePencil< CBase_PmeZPencil >::~PmePencil().

#define fftwf_malloc   fftw_malloc

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 13 of file ComputePme.C.

Referenced by PmeZPencil::fft_init(), PmeYPencil::fft_init(), and PmeXPencil::fft_init().

#define MIN_DEBUG_LEVEL   3

Definition at line 47 of file ComputePme.C.

#define NUM_STREAMS   1

Definition at line 520 of file ComputePme.C.

Referenced by ComputePmeMgr::ComputePmeMgr().

#define XCOPY (   X)    masterPmeMgr->X = X;
#define XCOPY (   X)    X = masterPmeMgr->X;

Function Documentation

void CcdCallBacksReset ( void ignored,
double  curWallTime 
)
int compare_bit_reversed ( int  a,
int  b 
)

Definition at line 324 of file ComputePme.C.

Referenced by pe_sortop_bit_reversed::operator()().

324  {
325  int d = a ^ b;
326  int c = 1;
327  if ( d ) while ( ! (d & c) ) {
328  c = c << 1;
329  }
330  return (a & c) - (b & c);
331 }
void cuda_check_pme_charges ( void arg,
double  walltime 
)

Definition at line 3463 of file ComputePme.C.

References CcdCallBacksReset(), ComputePmeMgr::charges_time, ComputePmeMgr::check_charges_count, count_limit, CUDA_EVENT_ID_PME_CHARGES, CUDA_POLL, cudaDie(), ComputePmeMgr::end_charges, ComputePmeMgr::saved_sequence, and ComputePmeMgr::sendChargeGridReady().

Referenced by ComputePmeMgr::pollChargeGridReady().

3463  {
3464  ComputePmeMgr *argp = (ComputePmeMgr *) arg;
3465 
3466  cudaError_t err = cudaEventQuery(argp->end_charges);
3467  if ( err == cudaSuccess ) {
3468  traceUserBracketEvent(CUDA_EVENT_ID_PME_CHARGES,argp->charges_time,walltime);
3469  argp->charges_time = walltime - argp->charges_time;
3470  argp->sendChargeGridReady();
3471  argp->check_charges_count = 0;
3472  } else if ( err != cudaErrorNotReady ) {
3473  char errmsg[256];
3474  sprintf(errmsg,"in cuda_check_pme_charges after polling %d times over %f s on seq %d",
3475  argp->check_charges_count, walltime - argp->charges_time,
3476  argp->saved_sequence);
3477  cudaDie(errmsg,err);
3478  } else if ( ++(argp->check_charges_count) >= count_limit ) {
3479  char errmsg[256];
3480  sprintf(errmsg,"cuda_check_pme_charges polled %d times over %f s on seq %d",
3481  argp->check_charges_count, walltime - argp->charges_time,
3482  argp->saved_sequence);
3483  cudaDie(errmsg,err);
3484  } else {
3485  CcdCallBacksReset(0,walltime); // fix Charm++
3487  }
3488 }
#define CUDA_POLL(FN, ARG)
Definition: ComputePme.C:2476
cudaEvent_t end_charges
Definition: ComputePme.C:432
void sendChargeGridReady()
Definition: ComputePme.C:3527
void CcdCallBacksReset(void *ignored, double curWallTime)
int check_charges_count
Definition: ComputePme.C:438
void cuda_check_pme_charges(void *arg, double walltime)
Definition: ComputePme.C:3463
void cudaDie(const char *msg, cudaError_t err=cudaSuccess)
Definition: CudaUtils.C:9
#define count_limit
Definition: ComputePme.C:2475
int saved_sequence
Definition: ComputePme.C:454
double charges_time
Definition: ComputePme.C:436
#define CUDA_EVENT_ID_PME_CHARGES
void cuda_check_pme_forces ( void arg,
double  walltime 
)

Definition at line 2483 of file ComputePme.C.

References CcdCallBacksReset(), ComputePmeMgr::check_forces_count, count_limit, CUDA_EVENT_ID_PME_FORCES, CUDA_POLL, cudaDie(), ComputePmeMgr::end_forces, EVENT_STRIDE, ComputePmeMgr::forces_count, ComputePmeMgr::forces_done_count, ComputePmeMgr::forces_time, WorkDistrib::messageEnqueueWork(), ComputePmeMgr::pmeComputes, and ComputePmeMgr::saved_sequence.

Referenced by ComputePmeMgr::pollForcesReady().

2483  {
2484  ComputePmeMgr *argp = (ComputePmeMgr *) arg;
2485 
2486  while ( 1 ) { // process multiple events per call
2487  cudaError_t err = cudaEventQuery(argp->end_forces[argp->forces_done_count/EVENT_STRIDE]);
2488  if ( err == cudaSuccess ) {
2489  argp->check_forces_count = 0;
2490  for ( int i=0; i<EVENT_STRIDE; ++i ) {
2492  if ( ++(argp->forces_done_count) == argp->forces_count ) break;
2493  }
2494  if ( argp->forces_done_count == argp->forces_count ) { // last event
2495  traceUserBracketEvent(CUDA_EVENT_ID_PME_FORCES,argp->forces_time,walltime);
2496  argp->forces_time = walltime - argp->forces_time;
2497  //CkPrintf("cuda_check_pme_forces forces_time == %f\n", argp->forces_time);
2498  return;
2499  } else { // more events
2500  continue; // check next event
2501  }
2502  } else if ( err != cudaErrorNotReady ) {
2503  char errmsg[256];
2504  sprintf(errmsg,"in cuda_check_pme_forces for event %d after polling %d times over %f s on seq %d",
2505  argp->forces_done_count/EVENT_STRIDE,
2506  argp->check_forces_count, walltime - argp->forces_time,
2507  argp->saved_sequence);
2508  cudaDie(errmsg,err);
2509  } else if ( ++(argp->check_forces_count) >= count_limit ) {
2510  char errmsg[256];
2511  sprintf(errmsg,"cuda_check_pme_forces for event %d polled %d times over %f s on seq %d",
2512  argp->forces_done_count/EVENT_STRIDE,
2513  argp->check_forces_count, walltime - argp->forces_time,
2514  argp->saved_sequence);
2515  cudaDie(errmsg,err);
2516  } else {
2517  break; // call again
2518  }
2519  } // while ( 1 )
2520  CcdCallBacksReset(0,walltime); // fix Charm++
2522 }
#define CUDA_POLL(FN, ARG)
Definition: ComputePme.C:2476
double forces_time
Definition: ComputePme.C:437
#define EVENT_STRIDE
Definition: ComputePme.C:2477
static void messageEnqueueWork(Compute *)
Definition: WorkDistrib.C:2727
void CcdCallBacksReset(void *ignored, double curWallTime)
#define CUDA_EVENT_ID_PME_FORCES
void cudaDie(const char *msg, cudaError_t err=cudaSuccess)
Definition: CudaUtils.C:9
void cuda_check_pme_forces(void *arg, double walltime)
Definition: ComputePme.C:2483
#define count_limit
Definition: ComputePme.C:2475
ResizeArray< ComputePme * > pmeComputes
Definition: ComputePme.C:460
cudaEvent_t * end_forces
Definition: ComputePme.C:433
int saved_sequence
Definition: ComputePme.C:454
int forces_done_count
Definition: ComputePme.C:435
int check_forces_count
Definition: ComputePme.C:439
void cuda_errcheck ( const char *  msg)

Definition at line 45 of file ComputeNonbondedCUDA.C.

References NAMD_die().

Referenced by ComputeNonbondedCUDA::ComputeNonbondedCUDA(), ComputePmeMgr::ComputePmeMgr(), cuda_bind_atom_params(), cuda_bind_atoms(), cuda_bind_exclusions(), cuda_bind_force_table(), cuda_bind_forces(), cuda_bind_GBIS_bornRad(), cuda_bind_GBIS_dEdaSum(), cuda_bind_GBIS_dHdrPrefix(), cuda_bind_GBIS_energy(), cuda_bind_GBIS_intRad(), cuda_bind_GBIS_psiSum(), cuda_bind_lj_table(), cuda_bind_patch_pairs(), cuda_bind_vdw_types(), cuda_bind_virials(), cuda_check_local_progress(), cuda_check_remote_progress(), cuda_GBIS_P1(), cuda_GBIS_P2(), cuda_GBIS_P3(), cuda_init(), cuda_nonbonded_forces(), ComputePme::doWork(), ComputeNonbondedCUDA::doWork(), ComputeNonbondedCUDA::finishReductions(), ComputePmeMgr::initialize(), ComputePmeMgr::initialize_computes(), and ComputePmeMgr::ungridCalc().

45  {
46  cudaError_t err;
47  if ((err = cudaGetLastError()) != cudaSuccess) {
48  char host[128];
49  gethostname(host, 128); host[127] = 0;
50  char devstr[128] = "";
51  int devnum;
52  if ( cudaGetDevice(&devnum) == cudaSuccess ) {
53  sprintf(devstr, " device %d", devnum);
54  }
55  cudaDeviceProp deviceProp;
56  if ( cudaGetDeviceProperties(&deviceProp, devnum) == cudaSuccess ) {
57  sprintf(devstr, " device %d pci %x:%x:%x", devnum,
58  deviceProp.pciDomainID, deviceProp.pciBusID, deviceProp.pciDeviceID);
59  }
60  char errmsg[1024];
61  sprintf(errmsg,"CUDA error %s on Pe %d (%s%s): %s", msg, CkMyPe(), host, devstr, cudaGetErrorString(err));
62  NAMD_die(errmsg);
63  }
64 }
void NAMD_die(const char *err_msg)
Definition: common.C:83
void cudaDie ( const char *  msg,
cudaError_t  err = cudaSuccess 
)

Definition at line 9 of file CudaUtils.C.

Referenced by copy3D_PeerDtoD_T(), cuda_check_local_progress(), cuda_check_pme_charges(), cuda_check_pme_forces(), cuda_check_progress(), cuda_check_remote_progress(), DeviceCUDA::initialize(), and read_CUDA_ARCH().

9  {
10  char host[128];
11  gethostname(host, 128); host[127] = 0;
12  char devstr[128] = "";
13  int devnum;
14  if ( cudaGetDevice(&devnum) == cudaSuccess ) {
15  sprintf(devstr, " device %d", devnum);
16  }
17  cudaDeviceProp deviceProp;
18  if ( cudaGetDeviceProperties(&deviceProp, devnum) == cudaSuccess ) {
19  sprintf(devstr, " device %d pci %x:%x:%x", devnum,
20  deviceProp.pciDomainID, deviceProp.pciBusID, deviceProp.pciDeviceID);
21  }
22  char errmsg[1024];
23  if (err == cudaSuccess) {
24  sprintf(errmsg,"CUDA error %s on Pe %d (%s%s)", msg, CkMyPe(), host, devstr);
25  } else {
26  sprintf(errmsg,"CUDA error %s on Pe %d (%s%s): %s", msg, CkMyPe(), host, devstr, cudaGetErrorString(err));
27  }
28  NAMD_die(errmsg);
29 }
void NAMD_die(const char *err_msg)
Definition: common.C:83
static int findRecipEvirPe ( )
static

Definition at line 247 of file ComputePme.C.

References NAMD_bug(), PatchMap::numPatchesOnNode(), and PatchMap::Object().

Referenced by PmeXPencil::evir_init(), and ComputePmeMgr::initialize().

247  {
248  PatchMap *patchMap = PatchMap::Object();
249  {
250  int mype = CkMyPe();
251  if ( patchMap->numPatchesOnNode(mype) ) {
252  return mype;
253  }
254  }
255  {
256  int node = CmiMyNode();
257  int firstpe = CmiNodeFirst(node);
258  int nodeSize = CmiNodeSize(node);
259  int myrank = CkMyRank();
260  for ( int i=0; i<nodeSize; ++i ) {
261  int pe = firstpe + (myrank+i)%nodeSize;
262  if ( patchMap->numPatchesOnNode(pe) ) {
263  return pe;
264  }
265  }
266  }
267  {
268  int *pelist;
269  int nodeSize;
270  CmiGetPesOnPhysicalNode(CmiPhysicalNodeID(CkMyPe()), &pelist, &nodeSize);
271  int myrank;
272  for ( int i=0; i<nodeSize; ++i ) {
273  if ( pelist[i] == CkMyPe() ) myrank = i;
274  }
275  for ( int i=0; i<nodeSize; ++i ) {
276  int pe = pelist[(myrank+i)%nodeSize];
277  if ( patchMap->numPatchesOnNode(pe) ) {
278  return pe;
279  }
280  }
281  }
282  {
283  int mype = CkMyPe();
284  int npes = CkNumPes();
285  for ( int i=0; i<npes; ++i ) {
286  int pe = (mype+i)%npes;
287  if ( patchMap->numPatchesOnNode(pe) ) {
288  return pe;
289  }
290  }
291  }
292  NAMD_bug("findRecipEvirPe() failed!");
293  return -999; // should never happen
294 }
static PatchMap * Object()
Definition: PatchMap.h:27
void NAMD_bug(const char *err_msg)
Definition: common.C:123
int numPatchesOnNode(int node)
Definition: PatchMap.h:60
void generatePmePeList2 ( int *  gridPeMap,
int  numGridPes,
int *  transPeMap,
int  numTransPes 
)

Definition at line 298 of file ComputePme.C.

References WorkDistrib::peDiffuseOrdering, and sort.

Referenced by ComputePmeMgr::initialize().

298  {
299  int ncpus = CkNumPes();
300 
301  for ( int i=0; i<numGridPes; ++i ) {
302  gridPeMap[i] = WorkDistrib::peDiffuseOrdering[ncpus - numGridPes + i];
303  }
304  std::sort(gridPeMap,gridPeMap+numGridPes);
305  int firstTransPe = ncpus - numGridPes - numTransPes;
306  if ( firstTransPe < 0 ) {
307  firstTransPe = 0;
308  // 0 should be first in list, skip if possible
309  if ( ncpus > numTransPes ) firstTransPe = 1;
310  }
311  for ( int i=0; i<numTransPes; ++i ) {
312  transPeMap[i] = WorkDistrib::peDiffuseOrdering[firstTransPe + i];
313  }
314  std::sort(transPeMap,transPeMap+numTransPes);
315 }
static int * peDiffuseOrdering
Definition: WorkDistrib.h:115
BlockRadixSort::TempStorage sort
ResizeArray<ComputePme*>& getComputes ( ComputePmeMgr mgr)

Definition at line 593 of file ComputePme.C.

References ComputePmeMgr::pmeComputes.

Referenced by ComputeQM::saveResults().

593  {
594  return mgr->pmeComputes ;
595 }
ResizeArray< ComputePme * > pmeComputes
Definition: ComputePme.C:460
int isPmeProcessor ( int  p)

Definition at line 604 of file ComputePme.C.

References Node::Object(), pencilPMEProcessors, Node::simParameters, simParams, and SimParameters::usePMECUDA.

604  {
606  if (simParams->usePMECUDA) {
607  return 0;
608  } else {
609  return pencilPMEProcessors[p];
610  }
611 }
static Node * Object()
Definition: Node.h:86
SimParameters * simParameters
Definition: Node.h:178
#define simParams
Definition: Output.C:127
char * pencilPMEProcessors
Definition: ComputePme.C:113
bool less_than_bit_reversed ( int  a,
int  b 
)
inline

Definition at line 333 of file ComputePme.C.

Referenced by sortop_bit_reversed::operator()(), and ijpair_sortop_bit_reversed::operator()().

333  {
334  int d = a ^ b;
335  int c = 1;
336  if ( d ) while ( ! (d & c) ) {
337  c = c << 1;
338  }
339  return d && (b & c);
340 }
void Pme_init ( )

Definition at line 860 of file ComputePme.C.

861 {
862 #if USE_TOPO_SFC
863  if (CkMyRank() == 0)
864  tmgr_lock = CmiCreateLock();
865 #endif
866 }
static void PmeSlabSendTrans ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 1940 of file ComputePme.C.

References ComputePmeMgr::sendTransSubset().

Referenced by ComputePmeMgr::sendTrans().

1940  {
1941  ComputePmeMgr *mgr = (ComputePmeMgr *)param;
1942  mgr->sendTransSubset(first, last);
1943 }
void sendTransSubset(int first, int last)
Definition: ComputePme.C:1961
static void PmeSlabSendUngrid ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 2370 of file ComputePme.C.

References ComputePmeMgr::sendUngridSubset().

Referenced by ComputePmeMgr::sendUngrid().

2370  {
2371  ComputePmeMgr *mgr = (ComputePmeMgr *)param;
2372  mgr->sendUngridSubset(first, last);
2373 }
void sendUngridSubset(int first, int last)
Definition: ComputePme.C:2391
static void PmeSlabSendUntrans ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 2184 of file ComputePme.C.

References ComputePmeMgr::sendUntransSubset().

Referenced by ComputePmeMgr::sendUntrans().

2184  {
2185  ComputePmeMgr *mgr = (ComputePmeMgr *)param;
2186  mgr->sendUntransSubset(first, last);
2187 }
void sendUntransSubset(int first, int last)
Definition: ComputePme.C:2216
static void PmeXPencilSendUntrans ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 5746 of file ComputePme.C.

References PmeXPencil::send_subset_untrans().

Referenced by PmeXPencil::send_untrans().

5746  {
5747  PmeXPencil *xpencil = (PmeXPencil *)param;
5748  xpencil->send_subset_untrans(first, last);
5749 }
void send_subset_untrans(int fromIdx, int toIdx)
Definition: ComputePme.C:5751
static void PmeXZPencilFFT ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 5183 of file ComputePme.C.

Referenced by PmeZPencil::backward_fft(), PmeXPencil::backward_fft(), PmeZPencil::forward_fft(), and PmeXPencil::forward_fft().

5183  {
5184 #ifdef NAMD_FFTW
5185 #ifdef NAMD_FFTW_3
5186  fftwf_plan *plans = (fftwf_plan *)param;
5187  for(int i=first; i<=last; i++) fftwf_execute(plans[i]);
5188 #endif
5189 #endif
5190 }
static void PmeYPencilBackwardFFT ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 5921 of file ComputePme.C.

References PmeYPencil::backward_subset_fft().

Referenced by PmeYPencil::backward_fft().

5921  {
5922  PmeYPencil *ypencil = (PmeYPencil *)param;
5923  ypencil->backward_subset_fft(first, last);
5924 }
void backward_subset_fft(int fromIdx, int toIdx)
Definition: ComputePme.C:5926
static void PmeYPencilForwardFFT ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 5412 of file ComputePme.C.

References PmeYPencil::forward_subset_fft().

Referenced by PmeYPencil::forward_fft().

5412  {
5413  PmeYPencil *ypencil = (PmeYPencil *)param;
5414  ypencil->forward_subset_fft(first, last);
5415 }
void forward_subset_fft(int fromIdx, int toIdx)
Definition: ComputePme.C:5416
static void PmeYPencilSendTrans ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 5464 of file ComputePme.C.

References PmeYPencil::send_subset_trans().

Referenced by PmeYPencil::send_trans().

5464  {
5465  PmeYPencil *ypencil = (PmeYPencil *)param;
5466  ypencil->send_subset_trans(first, last);
5467 }
void send_subset_trans(int fromIdx, int toIdx)
Definition: ComputePme.C:5469
static void PmeYPencilSendUntrans ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 5980 of file ComputePme.C.

References PmeYPencil::send_subset_untrans().

Referenced by PmeYPencil::send_untrans().

5980  {
5981  PmeYPencil *ypencil = (PmeYPencil *)param;
5982  ypencil->send_subset_untrans(first, last);
5983 }
void send_subset_untrans(int fromIdx, int toIdx)
Definition: ComputePme.C:5985
static void PmeZPencilSendTrans ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 5248 of file ComputePme.C.

References PmeZPencil::send_subset_trans().

Referenced by PmeZPencil::send_trans().

5248  {
5249  PmeZPencil *zpencil = (PmeZPencil *)param;
5250  zpencil->send_subset_trans(first, last);
5251 }
void send_subset_trans(int fromIdx, int toIdx)
Definition: ComputePme.C:5253
static void PmeZPencilSendUngrid ( int  first,
int  last,
void result,
int  paraNum,
void param 
)
inlinestatic

Definition at line 6216 of file ComputePme.C.

References PmeZPencil::send_subset_ungrid().

Referenced by PmeZPencil::send_all_ungrid().

6216  {
6217  //to take advantage of the interface which allows 3 user params at most.
6218  //under such situtation, no new parameter list needs to be created!! -Chao Mei
6219  PmeZPencil *zpencil = (PmeZPencil *)param;
6220  zpencil->send_subset_ungrid(first, last);
6221 }
void send_subset_ungrid(int fromIdx, int toIdx)
Definition: ComputePme.C:6237

Variable Documentation

__thread DeviceCUDA* deviceCUDA

Definition at line 22 of file DeviceCUDA.C.

char* pencilPMEProcessors

Definition at line 113 of file ComputePme.C.

Referenced by ComputePmeMgr::initialize(), and isPmeProcessor().