CudaFFTCompute Class Reference

#include <CudaPmeSolverUtil.h>

Inheritance diagram for CudaFFTCompute:

Public Member Functions
	CudaFFTCompute (int deviceID, cudaStream_t stream)
	~CudaFFTCompute ()
void	forward ()
void	backward ()
Public Member Functions inherited from FFTCompute
	FFTCompute ()
void	init (float *dataSrc_in, int dataSrcSize_in, float *dataDst_in, int dataDstSize_in, int permutation, PmeGrid pmeGrid, int pmePencilType, int jblock, int kblock, int flags)
virtual	~FFTCompute ()
float *	getDataSrc ()
float *	getDataDst ()

Additional Inherited Members
Protected Attributes inherited from FFTCompute
int	jblock
int	kblock
int	isize
int	jsize
int	ksize
float *	dataSrc
float *	dataDst
int	dataSrcSize
int	dataDstSize
bool	dataSrcAllocated
bool	dataDstAllocated

Detailed Description

Definition at line 41 of file CudaPmeSolverUtil.h.

Constructor & Destructor Documentation

CudaFFTCompute()

CudaFFTCompute::CudaFFTCompute	(	int	deviceID,
		cudaStream_t	stream
	)

Definition at line 61 of file CudaPmeSolverUtil.C.

    : deviceID(deviceID), stream(stream) {
    }

~CudaFFTCompute()

CudaFFTCompute::~CudaFFTCompute

(

)

Definition at line 116 of file CudaPmeSolverUtil.C.

References cudaCheck, cufftCheck, FFTCompute::dataDst, FFTCompute::dataDstAllocated, FFTCompute::dataSrc, and FFTCompute::dataSrcAllocated.

                                {
  cudaCheck(cudaSetDevice(deviceID));
        cufftCheck(cufftDestroy(forwardPlan));
        cufftCheck(cufftDestroy(backwardPlan));
  if (dataSrcAllocated) deallocate_device<float>(&dataSrc);
  if (dataDstAllocated) deallocate_device<float>(&dataDst);
}

Member Function Documentation

backward()

void CudaFFTCompute::backward ( )

virtual

Implements FFTCompute.

Definition at line 182 of file CudaPmeSolverUtil.C.

References cudaCheck, cudaNAMD_bug(), cufftCheck, FFTCompute::dataDst, FFTCompute::dataSrc, and FFTCompute::dataSrcSize.

                              {
  cudaCheck(cudaSetDevice(deviceID));
  if (backwardType == CUFFT_C2R) {
    // if (ncall == 1) {
    //   if (plantype == 1)
    //     writeComplexToDisk((float2 *)data, 33*64*64, "data_fx_by_bz.txt");
    //   else
    //     writeComplexToDisk((float2 *)data, 33*64*64, "data_fx_fy_fz_2.txt");
    // }
    cufftCheck(cufftExecC2R(backwardPlan, (cufftComplex *)dataDst, (cufftReal *)dataSrc));
#ifdef TESTPID
  if (1) {
    cudaCheck(cudaStreamSynchronize(stream));
    fprintf(stderr, "AP BACKWARD FFT\n");
    fprintf(stderr, "COPY DEVICE ARRAYS BACK TO HOST\n");
    float *grid;
    int gridsize = dataSrcSize;
    allocate_host<float>(&grid, gridsize);
    copy_DtoH<float>((float*)dataSrc, grid, gridsize, stream);
    cudaCheck(cudaStreamSynchronize(stream));
    TestArray_write<float>("potential_grid_good.bin",
        "potential grid good", grid, gridsize);
    deallocate_host<float>(&grid);
  }
#endif

    // if (ncall == 1)
    //   if (plantype == 1)
    //     writeRealToDisk(data, 64*64*64, "data_bx_by_bz_1D.txt");
    //   else
    //     writeRealToDisk(data, 64*64*64, "data_bx_by_bz_3D.txt");
  } else if (backwardType == CUFFT_C2C) {
    // nc2cb++;
    // if (ncall == 1 && nc2cb == 1)
    //   writeComplexToDisk((float2 *)data, 33*64*64, "data_fz_fx_fy_2.txt");
    // else if (ncall == 1 && nc2cb == 2)
    //   writeComplexToDisk((float2 *)data, 33*64*64, "data_fy_bz_fx.txt");
    cufftCheck(cufftExecC2C(backwardPlan, (cufftComplex *)dataDst, (cufftComplex *)dataSrc, CUFFT_INVERSE));
    // if (ncall == 1 && nc2cb == 1)
    //   writeComplexToDisk((float2 *)data, 33*64*64, "data_bz_fx_fy.txt");
    // else if (ncall == 1 && nc2cb == 2)
    //   writeComplexToDisk((float2 *)data, 33*64*64, "data_by_bz_fx.txt");
  } else {
    cudaNAMD_bug("CudaFFTCompute::backward(), unsupported FFT type");
  }
}

forward()

void CudaFFTCompute::forward ( )

virtual

Implements FFTCompute.

Definition at line 133 of file CudaPmeSolverUtil.C.

References cudaCheck, cudaNAMD_bug(), cufftCheck, FFTCompute::dataDst, FFTCompute::dataDstSize, and FFTCompute::dataSrc.

                             {
  cudaCheck(cudaSetDevice(deviceID));
  // ncall++;
  if (forwardType == CUFFT_R2C) {
    cufftCheck(cufftExecR2C(forwardPlan, (cufftReal *)dataSrc, (cufftComplex *)dataDst));
#ifdef TESTPID
    if (1) {
      cudaCheck(cudaStreamSynchronize(stream));
      fprintf(stderr, "AP FORWARD FFT\n");
      fprintf(stderr, "COPY DEVICE ARRAYS BACK TO HOST\n");
      int m = dataDstSize;
      float *tran = 0;
      allocate_host<float>(&tran, m);
      copy_DtoH<float>(dataDst, tran, m, stream);
      cudaCheck(cudaStreamSynchronize(stream));
      TestArray_write<float>("tran_charge_grid_good.bin",
          "transformed charge grid good", tran, m);
      deallocate_host<float>(&tran);
    }
#endif

    // if (ncall == 1) {
    //   writeComplexToDisk((float2 *)dataSrc, (isize/2+1)*jsize*ksize, "dataSrc.txt", stream);
    // }

    // if (ncall == 1 && plantype == 2) {
    //   writeComplexToDisk((float2 *)data, (isize/2+1)*jsize*ksize, "data_fx_fy_z.txt", stream);
    // }

  } else if (forwardType == CUFFT_C2C) {
    // nc2cf++;
    // if (ncall == 1 && nc2cf == 1)
    //   writeComplexToDisk((float2 *)data, 33*64*64, "data_y_z_fx.txt");
    // else if (ncall == 1 && nc2cf == 2)
    //   writeComplexToDisk((float2 *)data, 33*64*64, "data_z_fx_fy.txt");
    cufftCheck(cufftExecC2C(forwardPlan, (cufftComplex *)dataSrc, (cufftComplex *)dataDst, CUFFT_FORWARD));
    // fprintf(stderr, "ncall %d plantype %d\n", ncall, plantype);
    // if (ncall == 1 && plantype == 1 && isize == 62) {
    //   writeComplexToDisk((float2 *)data, isize*jsize*(ksize/2+1), "data_fy_z_fx.txt", stream);
    // }
    // if (ncall == 1 && nc2cf == 1)
    //   writeComplexToDisk((float2 *)data, 33*64*64, "data_fy_z_fx.txt");
    // else if (ncall == 1 && nc2cf == 2)
    //   writeComplexToDisk((float2 *)data, 33*64*64, "data_fz_fx_fy.txt");
  } else {
    cudaNAMD_bug("CudaFFTCompute::forward(), unsupported FFT type");
  }
}

---

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

• CudaPmeSolverUtil.h
• CudaPmeSolverUtil.C