102 lines
3.3 KiB
C++
102 lines
3.3 KiB
C++
|
|
#ifndef EIGEN_TEST_CUDA_COMMON_H
|
|
#define EIGEN_TEST_CUDA_COMMON_H
|
|
|
|
#include <cuda.h>
|
|
#include <cuda_runtime.h>
|
|
#include <cuda_runtime_api.h>
|
|
#include <iostream>
|
|
|
|
#ifndef __CUDACC__
|
|
dim3 threadIdx, blockDim, blockIdx;
|
|
#endif
|
|
|
|
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());
|
|
}
|
|
|
|
|
|
template<typename Kernel, typename Input, typename Output>
|
|
__global__
|
|
void run_on_cuda_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);
|
|
}
|
|
}
|
|
|
|
|
|
template<typename Kernel, typename Input, typename Output>
|
|
void run_on_cuda(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);
|
|
|
|
cudaMalloc((void**)(&d_in), in_bytes);
|
|
cudaMalloc((void**)(&d_out), out_bytes);
|
|
|
|
cudaMemcpy(d_in, in.data(), in_bytes, cudaMemcpyHostToDevice);
|
|
cudaMemcpy(d_out, out.data(), out_bytes, cudaMemcpyHostToDevice);
|
|
|
|
// 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) );
|
|
|
|
cudaThreadSynchronize();
|
|
run_on_cuda_meta_kernel<<<Grids,Blocks>>>(ker, n, d_in, d_out);
|
|
cudaThreadSynchronize();
|
|
|
|
// check inputs have not been modified
|
|
cudaMemcpy(const_cast<typename Input::Scalar*>(in.data()), d_in, in_bytes, cudaMemcpyDeviceToHost);
|
|
cudaMemcpy(out.data(), d_out, out_bytes, cudaMemcpyDeviceToHost);
|
|
|
|
cudaFree(d_in);
|
|
cudaFree(d_out);
|
|
}
|
|
|
|
|
|
template<typename Kernel, typename Input, typename Output>
|
|
void run_and_compare_to_cuda(const Kernel& ker, int n, const Input& in, Output& out)
|
|
{
|
|
Input in_ref, in_cuda;
|
|
Output out_ref, out_cuda;
|
|
#ifndef __CUDA_ARCH__
|
|
in_ref = in_cuda = in;
|
|
out_ref = out_cuda = out;
|
|
#endif
|
|
run_on_cpu (ker, n, in_ref, out_ref);
|
|
run_on_cuda(ker, n, in_cuda, out_cuda);
|
|
#ifndef __CUDA_ARCH__
|
|
VERIFY_IS_APPROX(in_ref, in_cuda);
|
|
VERIFY_IS_APPROX(out_ref, out_cuda);
|
|
#endif
|
|
}
|
|
|
|
|
|
void ei_test_init_cuda()
|
|
{
|
|
int device = 0;
|
|
cudaDeviceProp deviceProp;
|
|
cudaGetDeviceProperties(&deviceProp, device);
|
|
std::cout << "CUDA 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";
|
|
}
|
|
|
|
#endif // EIGEN_TEST_CUDA_COMMON_H
|