#include <cuda.h>
#include <cuda_runtime.h>
#include <cuda_runtime_api.h>
#include <iostream>

Classes
struct	compile_time_device_info

Functions
template<typename Kernel , typename Input , typename Output >
void	run_on_cpu (const Kernel &ker, int n, const Input &in, Output &out)

template<typename Kernel , typename Input , typename Output >
__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void	run_on_gpu_meta_kernel (const Kernel ker, int n, const Input in, Output out)

template<typename Kernel , typename Input , typename Output >
void	run_on_gpu (const Kernel &ker, int n, const Input &in, Output &out)

template<typename Kernel , typename Input , typename Output >
void	run_and_compare_to_gpu (const Kernel &ker, int n, const Input &in, Output &out)

void	ei_test_init_gpu ()

Variables
dim3	threadIdx

dim3	blockDim

dim3	blockIdx

Function Documentation

◆ ei_test_init_gpu()

void ei_test_init_gpu ( )

                         {
   int device = 0;
   gpuDeviceProp_t deviceProp;
   gpuGetDeviceProperties(&deviceProp, device);
  
   ArrayXi dummy(1), info(10);
   info = -1;
   run_on_gpu(compile_time_device_info(), 10, dummy, info);
  
   std::cout << "GPU compile-time info:\n";
  
 #ifdef EIGEN_CUDACC
   std::cout << "  EIGEN_CUDACC:                 " << int(EIGEN_CUDACC) << "\n";
 #endif
  
 #ifdef EIGEN_CUDA_SDK_VER
   std::cout << "  EIGEN_CUDA_SDK_VER:             " << int(EIGEN_CUDA_SDK_VER) << "\n";
 #endif
  
 #if EIGEN_COMP_NVCC
   std::cout << "  EIGEN_COMP_NVCC:             " << int(EIGEN_COMP_NVCC) << "\n";
 #endif
  
 #ifdef EIGEN_HIPCC
   std::cout << "  EIGEN_HIPCC:                 " << int(EIGEN_HIPCC) << "\n";
 #endif
  
   std::cout << "  EIGEN_CUDA_ARCH:             " << info[0] << "\n";
   std::cout << "  EIGEN_HIP_DEVICE_COMPILE:    " << info[1] << "\n";
  
   std::cout << "GPU device info:\n";
   std::cout << "  name:                        " << deviceProp.name << "\n";
   std::cout << "  capability:                  " << deviceProp.major << "." << deviceProp.minor << "\n";
   std::cout << "  multiProcessorCount:         " << deviceProp.multiProcessorCount << "\n";
   std::cout << "  maxThreadsPerMultiProcessor: " << deviceProp.maxThreadsPerMultiProcessor << "\n";
   std::cout << "  warpSize:                    " << deviceProp.warpSize << "\n";
   std::cout << "  regsPerBlock:                " << deviceProp.regsPerBlock << "\n";
   std::cout << "  concurrentKernels:           " << deviceProp.concurrentKernels << "\n";
   std::cout << "  clockRate:                   " << deviceProp.clockRate << "\n";
   std::cout << "  canMapHostMemory:            " << deviceProp.canMapHostMemory << "\n";
   std::cout << "  computeMode:                 " << deviceProp.computeMode << "\n";
 }

References EIGEN_COMP_NVCC, EIGEN_CUDA_SDK_VER, info, int(), and run_on_gpu().

◆ run_and_compare_to_gpu()

template<typename Kernel , typename Input , typename Output >

void run_and_compare_to_gpu	(	const Kernel &	ker,
		int	n,
		const Input &	in,
		Output &	out
	)

                                                                                     {
   Input in_ref, in_gpu;
   Output out_ref, out_gpu;
 #if !defined(EIGEN_GPU_COMPILE_PHASE)
   in_ref = in_gpu = in;
   out_ref = out_gpu = out;
 #else
   EIGEN_UNUSED_VARIABLE(in);
   EIGEN_UNUSED_VARIABLE(out);
 #endif
   run_on_cpu(ker, n, in_ref, out_ref);
   run_on_gpu(ker, n, in_gpu, out_gpu);
 #if !defined(EIGEN_GPU_COMPILE_PHASE)
   VERIFY_IS_APPROX(in_ref, in_gpu);
   VERIFY_IS_APPROX(out_ref, out_gpu);
 #endif
 }

References EIGEN_UNUSED_VARIABLE, n, out(), run_on_cpu(), run_on_gpu(), and VERIFY_IS_APPROX.

◆ run_on_cpu()

template<typename Kernel , typename Input , typename Output >

void run_on_cpu	(	const Kernel &	ker,
		int	n,
		const Input &	in,
		Output &	out
	)

                                                                         {
   for (int i = 0; i < n; i++) ker(i, in.data(), out.data());
 }

References i, n, and out().

Referenced by Eigen::run(), run_and_compare_to_gpu(), and Eigen::run_with_hint().

◆ run_on_gpu()

template<typename Kernel , typename Input , typename Output >

void run_on_gpu	(	const Kernel &	ker,
		int	n,
		const Input &	in,
		Output &	out
	)

                                                                         {
   typename Input::Scalar* d_in;
   typename Output::Scalar* d_out;
   std::ptrdiff_t in_bytes = in.size() * sizeof(typename Input::Scalar);
   std::ptrdiff_t out_bytes = out.size() * sizeof(typename Output::Scalar);
  
   gpuMalloc((void**)(&d_in), in_bytes);
   gpuMalloc((void**)(&d_out), out_bytes);
  
   gpuMemcpy(d_in, in.data(), in_bytes, gpuMemcpyHostToDevice);
   gpuMemcpy(d_out, out.data(), out_bytes, gpuMemcpyHostToDevice);
  
   // Simple and non-optimal 1D mapping assuming n is not too large
   // That's only for unit testing!
   dim3 Blocks(128);
   dim3 Grids((n + int(Blocks.x) - 1) / int(Blocks.x));
  
   gpuDeviceSynchronize();
  
 #ifdef EIGEN_USE_HIP
   hipLaunchKernelGGL(HIP_KERNEL_NAME(run_on_gpu_meta_kernel<Kernel, typename std::decay<decltype(*d_in)>::type,
                                                             typename std::decay<decltype(*d_out)>::type>),
                      dim3(Grids), dim3(Blocks), 0, 0, ker, n, d_in, d_out);
 #else
   // Various versions of clang-format incorrectly add spaces to the kernel launch brackets.
   // clang-format off
   run_on_gpu_meta_kernel<<<Grids, Blocks>>>(ker, n, d_in, d_out);
   // clang-format on
 #endif
   // Pre-launch errors.
   gpuError_t err = gpuGetLastError();
   if (err != gpuSuccess) {
     printf("%s: %s\n", gpuGetErrorName(err), gpuGetErrorString(err));
     gpu_assert(false);
   }
  
   // Kernel execution errors.
   err = gpuDeviceSynchronize();
   if (err != gpuSuccess) {
     printf("%s: %s\n", gpuGetErrorName(err), gpuGetErrorString(err));
     gpu_assert(false);
   }
  
   // check inputs have not been modified
   gpuMemcpy(const_cast<typename Input::Scalar*>(in.data()), d_in, in_bytes, gpuMemcpyDeviceToHost);
   gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost);
  
   gpuFree(d_in);
   gpuFree(d_out);
 }

References n, out(), run_on_gpu_meta_kernel(), and compute_granudrum_aor::type.

Referenced by ei_test_init_gpu(), Eigen::run(), and run_and_compare_to_gpu().

◆ run_on_gpu_meta_kernel()

template<typename Kernel , typename Input , typename Output >

__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void run_on_gpu_meta_kernel	(	const Kernel	ker,
		int	n,
		const Input *	in,
		Output *	out
	)

                                                                                  {
   int i = threadIdx.x + blockIdx.x * blockDim.x;
   if (i < n) {
     ker(i, in, out);
   }
 }