reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2025-01-21 02:45:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Tests: Run clang-format on CUDA code

Browse Source
This commit is contained in:
Brad King 2017-02-14 10:16:32 -05:00
parent fa5188d0ed
commit 33a65941fa
16 changed files with 91 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
Tests/Cuda/Complex/dynamic.cu
View File

@ -1,7 +1,7 @@
#include <string>
#include <cuda.h>
#include <iostream>
#include <string>
#ifdef _WIN32
#define EXPORT __declspec(dllexport)
@ -16,9 +16,7 @@ EXPORT int __host__ cuda_dynamic_host_func(int x)
return dynamic_base_func(x);
}
static
__global__
void DetermineIfValidCudaDevice()
static __global__ void DetermineIfValidCudaDevice()
{
}
@ -26,35 +24,28 @@ EXPORT int choose_cuda_device()
{
int nDevices = 0;
cudaError_t err = cudaGetDeviceCount(&nDevices);
if (err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "Failed to retrieve the number of CUDA enabled devices"
<< std::endl;
return 1;
}
for (int i = 0; i < nDevices; ++i)
{
}
for (int i = 0; i < nDevices; ++i) {
cudaDeviceProp prop;
cudaError_t err = cudaGetDeviceProperties(&prop, i);
if (err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "Could not retrieve properties from CUDA device " << i
<< std::endl;
return 1;
}
if (prop.major >= 4)
{
err = cudaSetDevice(i);
if (err != cudaSuccess)
{
std::cout << "Could not select CUDA device " << i << std::endl;
}
else
{
return 0;
}
}
if (prop.major >= 4) {
err = cudaSetDevice(i);
if (err != cudaSuccess) {
std::cout << "Could not select CUDA device " << i << std::endl;
} else {
return 0;
}
}
}
std::cout << "Could not find a CUDA enabled card supporting compute >=3.0"
<< std::endl;
@ -64,17 +55,15 @@ EXPORT int choose_cuda_device()
EXPORT void cuda_dynamic_lib_func()
{
DetermineIfValidCudaDevice <<<1,1>>> ();
DetermineIfValidCudaDevice<<<1, 1>>>();
cudaError_t err = cudaGetLastError();
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "DetermineIfValidCudaDevice [SYNC] failed: "
<< cudaGetErrorString(err) << std::endl;
}
}
err = cudaDeviceSynchronize();
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "DetermineIfValidCudaDevice [ASYNC] failed: "
<< cudaGetErrorString(cudaGetLastError()) << std::endl;
}
}
}

2
Tests/Cuda/Complex/file1.cu
View File

@ -5,6 +5,6 @@ result_type __device__ file1_func(int x)
{
result_type r;
r.input = x;
r.sum = x*x;
r.sum = x * x;
return r;
}

14
Tests/Cuda/Complex/file2.cu
View File

@ -5,16 +5,12 @@ result_type __device__ file1_func(int x);
result_type_dynamic __device__ file2_func(int x)
{
if(x!=42)
{
if (x != 42) {
const result_type r = file1_func(x);
const result_type_dynamic rd { r.input, r.sum, true };
const result_type_dynamic rd{ r.input, r.sum, true };
return rd;
}
else
{
const result_type_dynamic rd { x, x*x*x, false };
} else {
const result_type_dynamic rd{ x, x * x * x, false };
return rd;
}
}
}

30
Tests/Cuda/Complex/file3.cu
View File

@ -7,9 +7,7 @@
result_type __device__ file1_func(int x);
result_type_dynamic __device__ file2_func(int x);
static
__global__
void file3_kernel(result_type* r, int x)
static __global__ void file3_kernel(result_type* r, int x)
{
*r = file1_func(x);
result_type_dynamic rd = file2_func(x);
@ -19,36 +17,32 @@ int file3_launch_kernel(int x)
{
result_type* r;
cudaError_t err = cudaMallocManaged(&r, sizeof(result_type));
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "file3_launch_kernel: cudaMallocManaged failed: "
<< cudaGetErrorString(err) << std::endl;
return x;
}
}
file3_kernel <<<1,1>>> (r,x);
file3_kernel<<<1, 1>>>(r, x);
err = cudaGetLastError();
if(err != cudaSuccess)
{
std::cerr << "file3_kernel [SYNC] failed: "
<< cudaGetErrorString(err) << std::endl;
if (err != cudaSuccess) {
std::cerr << "file3_kernel [SYNC] failed: " << cudaGetErrorString(err)
<< std::endl;
return x;
}
}
err = cudaDeviceSynchronize();
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "file3_kernel [ASYNC] failed: "
<< cudaGetErrorString(cudaGetLastError()) << std::endl;
return x;
}
}
int result = r->sum;
err = cudaFree(r);
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "file3_launch_kernel: cudaFree failed: "
<< cudaGetErrorString(err) << std::endl;
return x;
}
}
return result;
}

30
Tests/Cuda/Complex/mixed.cu
View File

@ -17,9 +17,7 @@ result_type_dynamic __device__ file2_func(int x);
IMPORT void __host__ cuda_dynamic_lib_func();
static
__global__
void mixed_kernel(result_type* r, int x)
static __global__ void mixed_kernel(result_type* r, int x)
{
*r = file1_func(x);
result_type_dynamic rd = file2_func(x);
@ -31,37 +29,33 @@ EXPORT int mixed_launch_kernel(int x)
result_type* r;
cudaError_t err = cudaMallocManaged(&r, sizeof(result_type));
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "mixed_launch_kernel: cudaMallocManaged failed: "
<< cudaGetErrorString(err) << std::endl;
return x;
}
}
mixed_kernel <<<1,1>>> (r,x);
mixed_kernel<<<1, 1>>>(r, x);
err = cudaGetLastError();
if(err != cudaSuccess)
{
std::cerr << "mixed_kernel [SYNC] failed: "
<< cudaGetErrorString(err) << std::endl;
if (err != cudaSuccess) {
std::cerr << "mixed_kernel [SYNC] failed: " << cudaGetErrorString(err)
<< std::endl;
return x;
}
}
err = cudaDeviceSynchronize();
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "mixed_kernel [ASYNC] failed: "
<< cudaGetErrorString(cudaGetLastError()) << std::endl;
return x;
}
}
int result = r->sum;
err = cudaFree(r);
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "mixed_launch_kernel: cudaFree failed: "
<< cudaGetErrorString(err) << std::endl;
return x;
}
}
return result;
}

8
Tests/Cuda/ConsumeCompileFeatures/main.cu
View File

@ -5,14 +5,16 @@ int static_cxx11_func(int);
void test_functions()
{
auto x = static_cxx11_func( int(42) );
auto x = static_cxx11_func(int(42));
std::cout << x << std::endl;
}
int main(int argc, char **argv)
int main(int argc, char** argv)
{
test_functions();
std::cout << "this executable doesn't use cuda code, just call methods defined" << std::endl;
std::cout
<< "this executable doesn't use cuda code, just call methods defined"
<< std::endl;
std::cout << "in libraries that have cuda code" << std::endl;
return 0;
}

6
Tests/Cuda/ObjectLibrary/static.cu
View File

@ -8,14 +8,14 @@ int __host__ file1_sq_func(int x)
cudaError_t err;
int nDevices = 0;
err = cudaGetDeviceCount(&nDevices);
if(err != cudaSuccess)
{
if (err != cudaSuccess) {
std::cerr << "nDevices: " << nDevices << std::endl;
std::cerr << "err: " << err << std::endl;
return 1;
}
std::cout << "this library uses cuda code" << std::endl;
std::cout << "you have " << nDevices << " devices that support cuda" << std::endl;
std::cout << "you have " << nDevices << " devices that support cuda"
<< std::endl;
return x * x;
}

2
Tests/Cuda/ProperLinkFlags/file1.cu
View File

@ -6,6 +6,6 @@ result_type __device__ file1_func(int x)
__ldg(&x);
result_type r;
r.input = x;
r.sum = x*x;
r.sum = x * x;
return r;
}

6
Tests/CudaOnly/EnableStandard/main.cu
View File

@ -12,11 +12,11 @@ IMPORT int shared_cuda11_func(int);
void test_functions()
{
static_cuda11_func( int(42) );
shared_cuda11_func( int(42) );
static_cuda11_func(int(42));
shared_cuda11_func(int(42));
}
int main(int argc, char **argv)
int main(int argc, char** argv)
{
test_functions();
return 0;

2
Tests/CudaOnly/SeparateCompilation/file1.cu
View File

@ -5,6 +5,6 @@ result_type __device__ file1_func(int x)
{
result_type r;
r.input = x;
r.sum = x*x;
r.sum = x * x;
return r;
}

14
Tests/CudaOnly/SeparateCompilation/file2.cu
View File

@ -5,16 +5,12 @@ result_type __device__ file1_func(int x);
result_type_dynamic __device__ file2_func(int x)
{
if(x!=42)
{
if (x != 42) {
const result_type r = file1_func(x);
const result_type_dynamic rd { r.input, r.sum, true };
const result_type_dynamic rd{ r.input, r.sum, true };
return rd;
}
else
{
const result_type_dynamic rd { x, x*x*x, false };
} else {
const result_type_dynamic rd{ x, x * x * x, false };
return rd;
}
}
}

11
Tests/CudaOnly/SeparateCompilation/file3.cu
View File

@ -6,13 +6,10 @@
result_type __device__ file1_func(int x);
result_type_dynamic __device__ file2_func(int x);
static
__global__
void file3_kernel(result_type& r, int x)
static __global__ void file3_kernel(result_type& r, int x)
{
//call static_func which is a method that is defined in the
//static library that is always out of date
// call static_func which is a method that is defined in the
// static library that is always out of date
r = file1_func(x);
result_type_dynamic rd = file2_func(x);
}
@ -20,6 +17,6 @@ void file3_kernel(result_type& r, int x)
result_type file3_launch_kernel(int x)
{
result_type r;
file3_kernel <<<1,1>>> (r,x);
file3_kernel<<<1, 1>>>(r, x);
return r;
}

10
Tests/CudaOnly/SeparateCompilation/file4.cu
View File

@ -7,12 +7,10 @@
result_type __device__ file1_func(int x);
result_type_dynamic __device__ file2_func(int x);
static
__global__
void file4_kernel(result_type& r, int x)
static __global__ void file4_kernel(result_type& r, int x)
{
//call static_func which is a method that is defined in the
//static library that is always out of date
// call static_func which is a method that is defined in the
// static library that is always out of date
r = file1_func(x);
result_type_dynamic rd = file2_func(x);
}
@ -20,6 +18,6 @@ void file4_kernel(result_type& r, int x)
int file4_launch_kernel(int x)
{
result_type r;
file4_kernel <<<1,1>>> (r,x);
file4_kernel<<<1, 1>>>(r, x);
return r.sum;
}

10
Tests/CudaOnly/SeparateCompilation/file5.cu
View File

@ -7,12 +7,10 @@
result_type __device__ file1_func(int x);
result_type_dynamic __device__ file2_func(int x);
static
__global__
void file5_kernel(result_type& r, int x)
static __global__ void file5_kernel(result_type& r, int x)
{
//call static_func which is a method that is defined in the
//static library that is always out of date
// call static_func which is a method that is defined in the
// static library that is always out of date
r = file1_func(x);
result_type_dynamic rd = file2_func(x);
}
@ -20,6 +18,6 @@ void file5_kernel(result_type& r, int x)
int file5_launch_kernel(int x)
{
result_type r;
file5_kernel <<<1,1>>> (r,x);
file5_kernel<<<1, 1>>>(r, x);
return r.sum;
}

2
Tests/CudaOnly/SeparateCompilation/main.cu
View File

@ -7,7 +7,7 @@
int file4_launch_kernel(int x);
int file5_launch_kernel(int x);
int main(int argc, char **argv)
int main(int argc, char** argv)
{
file4_launch_kernel(42);
file5_launch_kernel(42);

28
Tests/CudaOnly/WithDefs/main.notcu
View File

@ -6,14 +6,12 @@
#error "PACKED_DEFINE not defined!"
#endif
static
__global__
void DetermineIfValidCudaDevice()
static __global__ void DetermineIfValidCudaDevice()
{
}
#ifdef _MSC_VER
#pragma pack(push,1)
#pragma pack(push, 1)
#undef PACKED_DEFINE
#define PACKED_DEFINE
#endif
@ -32,28 +30,24 @@ struct PACKED_DEFINE result_type
result_type can_launch_kernel()
{
result_type r;
DetermineIfValidCudaDevice <<<1,1>>> ();
DetermineIfValidCudaDevice<<<1, 1>>>();
r.valid = (cudaSuccess == cudaGetLastError());
if(r.valid)
{
if (r.valid) {
r.value = 1;
}
else
{
} else {
r.value = -1;
}
}
return r;
}
int main(int argc, char **argv)
int main(int argc, char** argv)
{
cudaError_t err;
int nDevices = 0;
err = cudaGetDeviceCount(&nDevices);
if(err != cudaSuccess)
{
std::cerr << cudaGetErrorString(err) << std::endl;
return 1;
}
if (err != cudaSuccess) {
std::cerr << cudaGetErrorString(err) << std::endl;
return 1;
}
return 0;
}