#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"

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 DeviceCUDA *	deviceCUDA

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

Referenced by ComputePmeMgr::ComputePmeMgr(), and cuda_check_pme_charges().

#define CUDA_EVENT_ID_PME_COPY 83

Referenced by ComputePmeMgr::chargeGridSubmitted(), ComputePmeMgr::ComputePmeMgr(), ComputePmeMgr::cuda_submit_charges(), and ComputePmeMgr::ungridCalc().

#define CUDA_EVENT_ID_PME_FORCES 81

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

#define CUDA_EVENT_ID_PME_KERNEL 84

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

#define CUDA_EVENT_ID_PME_TICK 82

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

#define CUDA_POLL	(	FN,
		ARG
	)	CcdCallFnAfter(FN,ARG,0.1)

Definition at line 2476 of file ComputePme.C.

Referenced by cuda_check_pme_charges(), cuda_check_pme_forces(), ComputePmeMgr::pollChargeGridReady(), and ComputePmeMgr::pollForcesReady().

#define CUDA_STREAM_CREATE ( X ) cudaStreamCreate(X)

Referenced by ComputePmeMgr::ComputePmeMgr().

#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

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;

Referenced by ComputePmeMgr::initialize_computes().

#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()().

                                        {
   int d = a ^ b;
   int c = 1;
   if ( d ) while ( ! (d & c) ) {
     c = c << 1;
   }
   return (a & c) - (b & c);
 }

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().

                                                         {
   ComputePmeMgr *argp = (ComputePmeMgr *) arg;
 
   cudaError_t err = cudaEventQuery(argp->end_charges);
   if ( err == cudaSuccess ) {
     traceUserBracketEvent(CUDA_EVENT_ID_PME_CHARGES,argp->charges_time,walltime);
     argp->charges_time = walltime - argp->charges_time;
     argp->sendChargeGridReady();
     argp->check_charges_count = 0;
   } else if ( err != cudaErrorNotReady ) {
     char errmsg[256];
     sprintf(errmsg,"in cuda_check_pme_charges after polling %d times over %f s on seq %d",
             argp->check_charges_count, walltime - argp->charges_time,
             argp->saved_sequence);
     cudaDie(errmsg,err);
   } else if ( ++(argp->check_charges_count) >= count_limit ) {
     char errmsg[256];
     sprintf(errmsg,"cuda_check_pme_charges polled %d times over %f s on seq %d",
             argp->check_charges_count, walltime - argp->charges_time,
             argp->saved_sequence);
     cudaDie(errmsg,err);
   } else {
     CcdCallBacksReset(0,walltime);  // fix Charm++
     CUDA_POLL(cuda_check_pme_charges, arg);
   }
 }

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().

                                                        {
   ComputePmeMgr *argp = (ComputePmeMgr *) arg;
 
  while ( 1 ) { // process multiple events per call
   cudaError_t err = cudaEventQuery(argp->end_forces[argp->forces_done_count/EVENT_STRIDE]);
   if ( err == cudaSuccess ) {
     argp->check_forces_count = 0;
     for ( int i=0; i<EVENT_STRIDE; ++i ) {
       WorkDistrib::messageEnqueueWork(argp->pmeComputes[argp->forces_done_count]);
       if ( ++(argp->forces_done_count) == argp->forces_count ) break;
     }
     if ( argp->forces_done_count == argp->forces_count ) { // last event
       traceUserBracketEvent(CUDA_EVENT_ID_PME_FORCES,argp->forces_time,walltime);
       argp->forces_time = walltime - argp->forces_time;
       //CkPrintf("cuda_check_pme_forces forces_time == %f\n", argp->forces_time);
       return;
     } else { // more events
       continue; // check next event
     }
   } else if ( err != cudaErrorNotReady ) {
     char errmsg[256];
     sprintf(errmsg,"in cuda_check_pme_forces for event %d after polling %d times over %f s on seq %d",
             argp->forces_done_count/EVENT_STRIDE,
             argp->check_forces_count, walltime - argp->forces_time,
             argp->saved_sequence);
     cudaDie(errmsg,err);
   } else if ( ++(argp->check_forces_count) >= count_limit ) {
     char errmsg[256];
     sprintf(errmsg,"cuda_check_pme_forces for event %d polled %d times over %f s on seq %d",
             argp->forces_done_count/EVENT_STRIDE,
             argp->check_forces_count, walltime - argp->forces_time,
             argp->saved_sequence);
     cudaDie(errmsg,err);
   } else {
     break; // call again
   }
  } // while ( 1 )
  CcdCallBacksReset(0,walltime);  // fix Charm++
  CUDA_POLL(cuda_check_pme_forces, arg);
 }

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().

                                     {
   cudaError_t err;
   if ((err = cudaGetLastError()) != cudaSuccess) {
     char host[128];
     gethostname(host, 128);  host[127] = 0;
     char devstr[128] = "";
     int devnum;
     if ( cudaGetDevice(&devnum) == cudaSuccess ) {
       sprintf(devstr, " device %d", devnum);
     }
     cudaDeviceProp deviceProp;
     if ( cudaGetDeviceProperties(&deviceProp, devnum) == cudaSuccess ) {
       sprintf(devstr, " device %d pci %x:%x:%x", devnum,
         deviceProp.pciDomainID, deviceProp.pciBusID, deviceProp.pciDeviceID);
     }
     char errmsg[1024];
     sprintf(errmsg,"CUDA error %s on Pe %d (%s%s): %s", msg, CkMyPe(), host, devstr, cudaGetErrorString(err));
     NAMD_die(errmsg);
   }
 }

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().

                                                {
   char host[128];
   gethostname(host, 128);  host[127] = 0;
   char devstr[128] = "";
   int devnum;
   if ( cudaGetDevice(&devnum) == cudaSuccess ) {
     sprintf(devstr, " device %d", devnum);
   }
   cudaDeviceProp deviceProp;
   if ( cudaGetDeviceProperties(&deviceProp, devnum) == cudaSuccess ) {
     sprintf(devstr, " device %d pci %x:%x:%x", devnum,
       deviceProp.pciDomainID, deviceProp.pciBusID, deviceProp.pciDeviceID);
   }
   char errmsg[1024];
   if (err == cudaSuccess) {
     sprintf(errmsg,"CUDA error %s on Pe %d (%s%s)", msg, CkMyPe(), host, devstr);
   } else {
     sprintf(errmsg,"CUDA error %s on Pe %d (%s%s): %s", msg, CkMyPe(), host, devstr, cudaGetErrorString(err));    
   }
   NAMD_die(errmsg);
 }

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().

                              {
     PatchMap *patchMap = PatchMap::Object();
     {
       int mype = CkMyPe();
       if ( patchMap->numPatchesOnNode(mype) ) {
         return mype; 
       }
     }
     {
       int node = CmiMyNode();
       int firstpe = CmiNodeFirst(node);
       int nodeSize = CmiNodeSize(node);
       int myrank = CkMyRank();
       for ( int i=0; i<nodeSize; ++i ) {
         int pe = firstpe + (myrank+i)%nodeSize;
         if ( patchMap->numPatchesOnNode(pe) ) {
           return pe;
         }
       }
     }
     {
       int *pelist;
       int nodeSize;
       CmiGetPesOnPhysicalNode(CmiPhysicalNodeID(CkMyPe()), &pelist, &nodeSize);
       int myrank;
       for ( int i=0; i<nodeSize; ++i ) {
         if ( pelist[i] == CkMyPe() ) myrank = i;
       }
       for ( int i=0; i<nodeSize; ++i ) {
         int pe = pelist[(myrank+i)%nodeSize];
         if ( patchMap->numPatchesOnNode(pe) ) {
           return pe;
         }
       }
     }
     {
       int mype = CkMyPe();
       int npes = CkNumPes();
       for ( int i=0; i<npes; ++i ) {
         int pe = (mype+i)%npes;
         if ( patchMap->numPatchesOnNode(pe) ) {
           return pe;
         }
       }
     }
     NAMD_bug("findRecipEvirPe() failed!");
     return -999;  // should never happen
 }

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().

                                                                                          {
   int ncpus = CkNumPes();
   
   for ( int i=0; i<numGridPes; ++i ) {
     gridPeMap[i] = WorkDistrib::peDiffuseOrdering[ncpus - numGridPes + i];
   }
   std::sort(gridPeMap,gridPeMap+numGridPes);
   int firstTransPe = ncpus - numGridPes - numTransPes;
   if ( firstTransPe < 0 ) {
     firstTransPe = 0;
     // 0 should be first in list, skip if possible
     if ( ncpus > numTransPes ) firstTransPe = 1;
   }
   for ( int i=0; i<numTransPes; ++i ) {
     transPeMap[i] = WorkDistrib::peDiffuseOrdering[firstTransPe + i];
   }
   std::sort(transPeMap,transPeMap+numTransPes);
 }

ResizeArray<ComputePme*>& getComputes ( ComputePmeMgr * mgr )

Definition at line 593 of file ComputePme.C.

References ComputePmeMgr::pmeComputes.

Referenced by ComputeQM::saveResults().

                                                           {
     return mgr->pmeComputes ;
 }

int isPmeProcessor ( int p )

Definition at line 604 of file ComputePme.C.

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

                          { 
   SimParameters *simParams = Node::Object()->simParameters;
   if (simParams->usePMECUDA) {
     return 0;
   } else {
     return pencilPMEProcessors[p];
   }
 }

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()().

                                                  {
   int d = a ^ b;
   int c = 1;
   if ( d ) while ( ! (d & c) ) {
     c = c << 1;
   }
   return d && (b & c);
 }

void Pme_init ( )

Definition at line 860 of file ComputePme.C.

 {
 #if USE_TOPO_SFC
   if (CkMyRank() == 0) 
     tmgr_lock = CmiCreateLock();
 #endif
 }

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().

                                                                                                  {
   ComputePmeMgr *mgr = (ComputePmeMgr *)param;
   mgr->sendTransSubset(first, last);
 }

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().

                                                                                                   {
   ComputePmeMgr *mgr = (ComputePmeMgr *)param;
   mgr->sendUngridSubset(first, last);
 }

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().

                                                                                                    {
   ComputePmeMgr *mgr = (ComputePmeMgr *)param;
   mgr->sendUntransSubset(first, last);
 }

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().

                                                                                                      {
         PmeXPencil *xpencil = (PmeXPencil *)param;
         xpencil->send_subset_untrans(first, last);
 }

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().

                                                                                               {
 #ifdef NAMD_FFTW
 #ifdef NAMD_FFTW_3    
     fftwf_plan *plans = (fftwf_plan *)param;
     for(int i=first; i<=last; i++) fftwf_execute(plans[i]);
 #endif
 #endif        
 }

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().

                                                                                                      {
         PmeYPencil *ypencil = (PmeYPencil *)param;
         ypencil->backward_subset_fft(first, last);
 }

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().

                                                                                                     {
         PmeYPencil *ypencil = (PmeYPencil *)param;
         ypencil->forward_subset_fft(first, last);
 }

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().

                                                                                                    {
         PmeYPencil *ypencil = (PmeYPencil *)param;
         ypencil->send_subset_trans(first, last);
 }

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().

                                                                                                      {
         PmeYPencil *ypencil = (PmeYPencil *)param;
         ypencil->send_subset_untrans(first, last);
 }

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().

                                                                                                    {
         PmeZPencil *zpencil = (PmeZPencil *)param;
         zpencil->send_subset_trans(first, last);        
 }

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().

                                                                                                     {
         //to take advantage of the interface which allows 3 user params at most.
         //under such situtation, no new parameter list needs to be created!! -Chao Mei
         PmeZPencil *zpencil = (PmeZPencil *)param;
         zpencil->send_subset_ungrid(first, last);
 }

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().

Classes

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation