CudaPmePencilZ Class Reference

#include <CudaPmeSolver.h>

Inheritance diagram for CudaPmePencilZ:

Public Member Functions
CudaPmePencilZ_SDAG_CODE	CudaPmePencilZ ()
	CudaPmePencilZ (CkMigrateMessage *m)
	~CudaPmePencilZ ()
void	initialize (CudaPmeXInitMsg *msg)
void	initialize (CudaPmeXYInitMsg *msg)
void	initializeDevice (InitDeviceMsg2 *msg)
void	energyAndVirialDone (unsigned int iGrid)

Detailed Description

Definition at line 190 of file CudaPmeSolver.h.

Constructor & Destructor Documentation

CudaPmePencilZ() [1/2]

CudaPmePencilZ_SDAG_CODE CudaPmePencilZ::CudaPmePencilZ ( )

inline

Definition at line 193 of file CudaPmeSolver.h.

: numGetDeviceBufferY(0), numGetDeviceBufferXY(0), eventCreated(false) {}

CudaPmePencilZ() [2/2]

CudaPmePencilZ::CudaPmePencilZ ( CkMigrateMessage *  m )

inline

Definition at line 194 of file CudaPmeSolver.h.

: numGetDeviceBufferY(0), numGetDeviceBufferXY(0), eventCreated(false) {}

~CudaPmePencilZ()

CudaPmePencilZ::~CudaPmePencilZ

(

)

Definition at line 858 of file CudaPmeSolver.C.

References cudaCheck.

                                {
  if (eventCreated) cudaCheck(cudaEventDestroy(event));
}

Member Function Documentation

energyAndVirialDone()

void CudaPmePencilZ::energyAndVirialDone

(

unsigned int

iGrid

)

Definition at line 1092 of file CudaPmeSolver.C.

                                                           {
  submitReductions(iGrid);
}

initialize() [1/2]

void CudaPmePencilZ::initialize

(

CudaPmeXInitMsg *

msg

)

Definition at line 836 of file CudaPmeSolver.C.

References CudaPmeXInitMsg::pmeGrid, CudaPmeXInitMsg::pmePencilY, and CudaPmeXInitMsg::yMap.

                                                    {
  useXYslab = false;
  pmeGrid = msg->pmeGrid;
  pmePencilY = msg->pmePencilY;
  yMap = msg->yMap;

  delete msg;

  initBlockSizes();
}

initialize() [2/2]

void CudaPmePencilZ::initialize

(

CudaPmeXYInitMsg *

msg

)

Definition at line 847 of file CudaPmeSolver.C.

References CudaPmeXYInitMsg::pmeGrid, CudaPmeXYInitMsg::pmePencilXY, and CudaPmeXYInitMsg::xyMap.

                                                     {
  useXYslab = true;
  pmeGrid = msg->pmeGrid;
  pmePencilXY = msg->pmePencilXY;
  xyMap = msg->xyMap;

  delete msg;

  initBlockSizes();
}

initializeDevice()

void CudaPmePencilZ::initializeDevice

(

InitDeviceMsg2 *

msg

)

Definition at line 865 of file CudaPmeSolver.C.

References cudaCheck, InitDeviceMsg2::deviceID, InitDeviceMsg2::deviceProxy, ComputeNonbondedUtil::ewaldcof, InitDeviceMsg2::mgrProxy, NUM_GRID_MAX, Perm_Z_cX_Y, and InitDeviceMsg2::stream.

                                                         {
  // Get device proxy
  CProxy_ComputePmeCUDADevice deviceProxy = msg->deviceProxy;
  deviceID = msg->deviceID;
  stream = msg->stream;
  CProxy_ComputePmeCUDAMgr mgrProxy = msg->mgrProxy;
  delete msg;
  // deviceID = deviceProxy.ckLocalBranch()->getDeviceID();
  // cudaStream_t stream = deviceProxy.ckLocalBranch()->getStream();
  // CProxy_ComputePmeCUDAMgr mgrProxy = deviceProxy.ckLocalBranch()->getMgrProxy();
  // Setup fftCompute and pmeKSpaceCompute
  for (unsigned int iGrid = 0; iGrid < NUM_GRID_MAX; ++iGrid) {
    if (deviceProxy.ckLocalBranch()->isGridEnabled(iGrid) == true) {
      fftComputes[iGrid] = new CudaFFTCompute(deviceID, stream);
      pmeTransposes[iGrid] = new CudaPmeTranspose(pmeGrid, Perm_Z_cX_Y, thisIndex.x, thisIndex.y, deviceID, stream);
      pmeKSpaceComputes[iGrid] = new CudaPmeKSpaceCompute(pmeGrid, Perm_Z_cX_Y, thisIndex.x, thisIndex.y, ComputeNonbondedUtil::ewaldcof, deviceID, stream, iGrid);
      energyReady[iGrid] = 0;
    } else {
      fftComputes[iGrid] = NULL;
      pmeTransposes[iGrid] = NULL;
      pmeKSpaceComputes[iGrid] = NULL;
      energyReady[iGrid] = -1;
    }
  }

  // Create event. NOTE: Events are tied to devices, hence the cudaSetDevice() here
  cudaCheck(cudaSetDevice(deviceID));
  cudaCheck(cudaEventCreateWithFlags(&event, cudaEventDisableTiming));
  eventCreated = true;

  deviceBuffers.resize(pmeGrid.zBlocks, DeviceBuffer(-1, false));
  numDeviceBuffers = 0;

  if (useXYslab) {
    for (int z=0;z < pmeGrid.zBlocks;z++) {
      int pe = xyMap.ckLocalBranch()->procNum(0, CkArrayIndex3D(0,0,z));
      if (CkNodeOf(pe) == CkMyNode()) {
        int deviceID0 = mgrProxy.ckLocalBranch()->getDeviceIDPencilX(0, z);
        // Check for Peer-to-Peer access
        int canAccessPeer = 0;
        if (deviceID != deviceID0) {
          cudaCheck(cudaSetDevice(deviceID));
          cudaCheck(cudaDeviceCanAccessPeer(&canAccessPeer, deviceID, deviceID0));
        }
#ifdef DISABLE_P2P
        canAccessPeer = 0;
#endif
        numDeviceBuffers++;
        deviceBuffers[z] = DeviceBuffer(deviceID0, canAccessPeer);
        pmePencilXY(0,0,z).getDeviceBuffer(thisIndex.x, (deviceID0 == deviceID) || canAccessPeer, thisProxy);
      }
    }
  } else {
    for (int z=0;z < pmeGrid.zBlocks;z++) {
      int pe = yMap.ckLocalBranch()->procNum(0, CkArrayIndex3D(thisIndex.x,0,z));
      if (CkNodeOf(pe) == CkMyNode()) {
        int deviceID0 = mgrProxy.ckLocalBranch()->getDeviceIDPencilY(thisIndex.x, z);
        numDeviceBuffers++;
        deviceBuffers[z] = DeviceBuffer(deviceID0, false);
        pmePencilY(thisIndex.x,0,z).getDeviceBuffer(thisIndex.y, (deviceID0 == deviceID), thisProxy);
      }
    }
  }

}

---

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

• CudaPmeSolver.h
• CudaPmeSolver.C