linux利用CMakeLists编译cuda程序

时间:2023-03-09 13:38:22
linux利用CMakeLists编译cuda程序

文件目录:

cudaTest

|--utils.cu

|--utils.h

|--squaresum.cu

|--squaresum.h

|--test.cpp

|--CMakeLists.txt

编译命令:

$cd /root/cudaTest

$mkdir build

$cd build

$cmake ..

$make

调佣关系:

utils:提供常用工具,这里提供查询设备信息功能;

squaresum:计算平方和功能,为cuda运行的核心函数实现

test:调用平方和函数

CMakeLists.txt:组织所有文件编译生成可执行文件

注意:调用cu文件中的函数时要在头文件声明成extern “C”

文件内容:

CMakeLists.txt

# CMakeLists.txt to build hellocuda.cu
cmake_minimum_required(VERSION 2.8)
find_package(CUDA QUIET REQUIRED) # Specify binary name and source file to build it from
#add_library(utils utils.cpp)
cuda_add_executable(
squaresum
test.cpp squaresum.cu utils.cu)
#target_link_libraries(squaresum utils)

test.cpp

#include <iostream>
#include "squaresum.h" //extern "C" int squaresum(); int main(){
squaresum();
return ;
}

squaresum.h

#include "utils.h"
#include <cuda_runtime.h> extern "C" {
int squaresum();
}

squaresum.cu

#include <stdio.h>
#include <stdlib.h>
//#include "utils.h"
#include <iostream>
#include "squaresum.h"
// ======== define area ========
#define DATA_SIZE 1048576 // 1M // ======== global area ========
int data[DATA_SIZE]; __global__ static void squaresSum(int *data, int *sum, clock_t *time)
{
int sum_t = ;
clock_t start = clock();
for (int i = ; i < DATA_SIZE; ++i) {
sum_t += data[i] * data[i];
}
*sum = sum_t;
*time = clock() - start;
} // ======== used to generate rand datas ========
void generateData(int *data, int size)
{
for (int i = ; i < size; ++i) {
data[i] = rand() % ;
}
} int squaresum()
{
// init CUDA device
if (!InitCUDA()) {
return ;
}
printf("CUDA initialized.\n"); // generate rand datas
generateData(data, DATA_SIZE); // malloc space for datas in GPU
int *gpuData, *sum;
clock_t *time;
cudaMalloc((void**) &gpuData, sizeof(int) * DATA_SIZE);
cudaMalloc((void**) &sum, sizeof(int));
cudaMalloc((void**) &time, sizeof(clock_t));
cudaMemcpy(gpuData, data, sizeof(int) * DATA_SIZE, cudaMemcpyHostToDevice); // calculate the squares's sum
squaresSum<<<, , >>>(gpuData, sum, time); // copy the result from GPU to HOST
int result;
clock_t time_used;
cudaMemcpy(&result, sum, sizeof(int), cudaMemcpyDeviceToHost);
cudaMemcpy(&time_used, time, sizeof(clock_t), cudaMemcpyDeviceToHost); // free GPU spaces
cudaFree(gpuData);
cudaFree(sum);
cudaFree(time); // print result
printf("(GPU) sum:%d time:%ld\n", result, time_used); // CPU calculate
result = ;
clock_t start = clock();
for (int i = ; i < DATA_SIZE; ++i) {
result += data[i] * data[i];
}
time_used = clock() - start;
printf("(CPU) sum:%d time:%ld\n", result, time_used); return ;
}

utils.h

#include <stdio.h>
#include <cuda_runtime.h> extern "C" {
bool InitCUDA();
}

utils.cu

#include "utils.h"
#include <cuda_runtime.h>
#include <iostream> void printDeviceProp(const cudaDeviceProp &prop)
{
printf("Device Name : %s.\n", prop.name);
printf("totalGlobalMem : %d.\n", prop.totalGlobalMem);
printf("sharedMemPerBlock : %d.\n", prop.sharedMemPerBlock);
printf("regsPerBlock : %d.\n", prop.regsPerBlock);
printf("warpSize : %d.\n", prop.warpSize);
printf("memPitch : %d.\n", prop.memPitch);
printf("maxThreadsPerBlock : %d.\n", prop.maxThreadsPerBlock);
printf("maxThreadsDim[0 - 2] : %d %d %d.\n", prop.maxThreadsDim[], prop.maxThreadsDim[], prop.maxThreadsDim[]);
printf("maxGridSize[0 - 2] : %d %d %d.\n", prop.maxGridSize[], prop.maxGridSize[], prop.maxGridSize[]);
printf("totalConstMem : %d.\n", prop.totalConstMem);
printf("major.minor : %d.%d.\n", prop.major, prop.minor);
printf("clockRate : %d.\n", prop.clockRate);
printf("textureAlignment : %d.\n", prop.textureAlignment);
printf("deviceOverlap : %d.\n", prop.deviceOverlap);
printf("multiProcessorCount : %d.\n", prop.multiProcessorCount);
} bool InitCUDA()
{
//used to count the device numbers
int count; // get the cuda device count
cudaGetDeviceCount(&count);
// print("%d\n", count);
std::cout << count << std::endl;
if (count == ) {
fprintf(stderr, "There is no device.\n");
return false;
} // find the device >= 1.X
int i;
for (i = ; i < count; ++i) {
cudaDeviceProp prop;
if (cudaGetDeviceProperties(&prop, i) == cudaSuccess) {
if (prop.major >= ) {
printDeviceProp(prop);
break;
}
}
} // if can't find the device
if (i == count) {
fprintf(stderr, "There is no device supporting CUDA 1.x.\n");
return false;
} // set cuda device
cudaSetDevice(i); return true;
} //int main(){
// InitCUDA();
//}