cms::cudatest Namespace Reference

Classes
class	Thing

Functions
__device__ void	add_vectors_d (const double *__restrict__ in1, const double *__restrict__ in2, double *__restrict__ out, size_t size)
__device__ void	add_vectors_f (const float *__restrict__ in1, const float *__restrict__ in2, float *__restrict__ out, size_t size)
__global__ void	kernel_add_vectors_d (const double *__restrict__ in1, const double *__restrict__ in2, double *__restrict__ out, size_t size)
__global__ void	kernel_add_vectors_f (const float *__restrict__ in1, const float *__restrict__ in2, float *__restrict__ out, size_t size)
void	opaque_add_vectors_d (const double *in1, const double *in2, double *out, size_t size)
void	opaque_add_vectors_f (const float *in1, const float *in2, float *out, size_t size)
void	requireDevices ()
	Print message and exit if there are no CUDA devices. More...
bool	testDevices ()
	In presence of CUDA devices, return true; otherwise print message and return false. More...
void	wrapper_add_vectors_d (const double *__restrict__ in1, const double *__restrict__ in2, double *__restrict__ out, size_t size)
void	wrapper_add_vectors_f (const float *__restrict__ in1, const float *__restrict__ in2, float *__restrict__ out, size_t size)

Function Documentation

add_vectors_d()

__device__ void cms::cudatest::add_vectors_d	(	const double *__restrict__	in1,
		const double *__restrict__	in2,
		double *__restrict__	out,
		size_t	size
	)

Definition at line 22 of file DeviceAddition.hip.cc.

References cms::cudacompat::blockDim, cms::cudacompat::blockIdx, cms::cudacompat::gridDim, mps_fire::i, MillePedeFileConverter_cfg::out, riemannFit::stride, and cms::cudacompat::threadIdx.

Referenced by cms::rocmtest::kernel_add_vectors_d().

                                             {
    uint32_t thread = threadIdx.x + blockIdx.x * blockDim.x;
    uint32_t stride = blockDim.x * gridDim.x;

    for (size_t i = thread; i < size; i += stride) {
      out[i] = in1[i] + in2[i];
    }
  }

add_vectors_f()

__device__ void cms::cudatest::add_vectors_f	(	const float *__restrict__	in1,
		const float *__restrict__	in2,
		float *__restrict__	out,
		size_t	size
	)

Definition at line 10 of file DeviceAddition.hip.cc.

References cms::cudacompat::blockDim, cms::cudacompat::blockIdx, cms::cudacompat::gridDim, mps_fire::i, MillePedeFileConverter_cfg::out, riemannFit::stride, and cms::cudacompat::threadIdx.

Referenced by cms::rocmtest::kernel_add_vectors_f(), and HeterogeneousCoreROCmTestDevicePlugins::kernel_add_vectors_f().

                                             {
    uint32_t thread = threadIdx.x + blockIdx.x * blockDim.x;
    uint32_t stride = blockDim.x * gridDim.x;

    for (size_t i = thread; i < size; i += stride) {
      out[i] = in1[i] + in2[i];
    }
  }

kernel_add_vectors_d()

__global__ void cms::cudatest::kernel_add_vectors_d	(	const double *__restrict__	in1,
		const double *__restrict__	in2,
		double *__restrict__	out,
		size_t	size
	)

Definition at line 17 of file DeviceAdditionKernel.hip.cc.

References cms::rocmtest::add_vectors_d(), and MillePedeFileConverter_cfg::out.

                                                    {
    add_vectors_d(in1, in2, out, size);
  }

kernel_add_vectors_f()

__global__ void cms::cudatest::kernel_add_vectors_f	(	const float *__restrict__	in1,
		const float *__restrict__	in2,
		float *__restrict__	out,
		size_t	size
	)

Definition at line 12 of file ROCmTestDeviceAdditionAlgo.hip.cc.

References cms::rocmtest::add_vectors_f(), and MillePedeFileConverter_cfg::out.

                                                    {
    cms::rocmtest::add_vectors_f(in1, in2, out, size);
  }

opaque_add_vectors_d()

void cms::cudatest::opaque_add_vectors_d	(	const double *	in1,
		const double *	in2,
		double *	out,
		size_t	size
	)

Definition at line 42 of file DeviceAdditionOpaque.cc.

References cudaCheck, and wrapper_add_vectors_d().

                                                                                                  {
    // allocate input and output buffers on the device
    double* in1_d;
    double* in2_d;
    double* out_d;
    cudaCheck(cudaMalloc(&in1_d, size * sizeof(double)));
    cudaCheck(cudaMalloc(&in2_d, size * sizeof(double)));
    cudaCheck(cudaMalloc(&out_d, size * sizeof(double)));

    // copy the input data to the device
    cudaCheck(cudaMemcpy(in1_d, in1_h, size * sizeof(double), cudaMemcpyHostToDevice));
    cudaCheck(cudaMemcpy(in2_d, in2_h, size * sizeof(double), cudaMemcpyHostToDevice));

    // fill the output buffer with zeros
    cudaCheck(cudaMemset(out_d, 0, size * sizeof(double)));

    // launch the 1-dimensional kernel for vector addition
    wrapper_add_vectors_d(in1_d, in2_d, out_d, size);

    // copy the results from the device to the host
    cudaCheck(cudaMemcpy(out_h, out_d, size * sizeof(double), cudaMemcpyDeviceToHost));

    // wait for all the operations to complete
    cudaCheck(cudaDeviceSynchronize());

    // free the input and output buffers on the device
    cudaCheck(cudaFree(in1_d));
    cudaCheck(cudaFree(in2_d));
    cudaCheck(cudaFree(out_d));
  }

opaque_add_vectors_f()

void cms::cudatest::opaque_add_vectors_f	(	const float *	in1,
		const float *	in2,
		float *	out,
		size_t	size
	)

Definition at line 11 of file DeviceAdditionOpaque.cc.

References cudaCheck, and wrapper_add_vectors_f().

Referenced by CUDATestOpaqueAdditionModule::analyze().

                                                                                               {
    // allocate input and output buffers on the device
    float* in1_d;
    float* in2_d;
    float* out_d;
    cudaCheck(cudaMalloc(&in1_d, size * sizeof(float)));
    cudaCheck(cudaMalloc(&in2_d, size * sizeof(float)));
    cudaCheck(cudaMalloc(&out_d, size * sizeof(float)));

    // copy the input data to the device
    cudaCheck(cudaMemcpy(in1_d, in1_h, size * sizeof(float), cudaMemcpyHostToDevice));
    cudaCheck(cudaMemcpy(in2_d, in2_h, size * sizeof(float), cudaMemcpyHostToDevice));

    // fill the output buffer with zeros
    cudaCheck(cudaMemset(out_d, 0, size * sizeof(float)));

    // launch the 1-dimensional kernel for vector addition
    wrapper_add_vectors_f(in1_d, in2_d, out_d, size);

    // copy the results from the device to the host
    cudaCheck(cudaMemcpy(out_h, out_d, size * sizeof(float), cudaMemcpyDeviceToHost));

    // wait for all the operations to complete
    cudaCheck(cudaDeviceSynchronize());

    // free the input and output buffers on the device
    cudaCheck(cudaFree(in1_d));
    cudaCheck(cudaFree(in2_d));
    cudaCheck(cudaFree(out_d));
  }

requireDevices()

void cms::cudatest::requireDevices

(

)

Print message and exit if there are no CUDA devices.

Definition at line 25 of file requireDevices.cc.

References beamvalidation::exit(), and testDevices().

                        {
    if (not testDevices()) {
      exit(EXIT_SUCCESS);
    }
  }

testDevices()

bool cms::cudatest::testDevices

(

)

In presence of CUDA devices, return true; otherwise print message and return false.

Definition at line 9 of file requireDevices.cc.

References DMR_cfg::cerr, cms::alpakatools::devices(), and mps_update::status.

Referenced by requireDevices().

                     {
    int devices = 0;
    auto status = cudaGetDeviceCount(&devices);
    if (status != cudaSuccess) {
      std::cerr << "Failed to initialise the CUDA runtime, the test will be skipped."
                << "\n";
      return false;
    }
    if (devices == 0) {
      std::cerr << "No CUDA devices available, the test will be skipped."
                << "\n";
      return false;
    }
    return true;
  }

wrapper_add_vectors_d()

void cms::cudatest::wrapper_add_vectors_d	(	const double *__restrict__	in1,
		const double *__restrict__	in2,
		double *__restrict__	out,
		size_t	size
	)

Definition at line 20 of file DeviceAdditionWrapper.hip.cc.

References hipCheck, and MillePedeFileConverter_cfg::out.

Referenced by opaque_add_vectors_d(), and cms::rocmtest::opqaue_add_vectors_d().

                                          {
    // launch the 1-dimensional kernel for vector addition
    kernel_add_vectors_d<<<32, 32>>>(in1, in2, out, size);
    hipCheck(hipGetLastError());
  }

wrapper_add_vectors_f()

void cms::cudatest::wrapper_add_vectors_f	(	const float *__restrict__	in1,
		const float *__restrict__	in2,
		float *__restrict__	out,
		size_t	size
	)

Definition at line 19 of file ROCmTestDeviceAdditionAlgo.hip.cc.

References hipCheck, and MillePedeFileConverter_cfg::out.

Referenced by CUDATestWrapperAdditionModule::analyze(), ROCmTestWrapperAdditionModule::analyze(), ROCmTestKernelAdditionModule::analyze(), ROCmTestDeviceAdditionModule::analyze(), opaque_add_vectors_f(), and cms::rocmtest::opqaue_add_vectors_f().

                                          {
    kernel_add_vectors_f<<<32, 32>>>(in1, in2, out, size);
    hipCheck(hipGetLastError());
  }