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 0;
}

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 = 0;
 clock_t start = clock();
for (int i = 0; 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 = 0; i < size; ++i) {
  data[i] = rand() % 10;
 }
}

int squaresum()
{
// init CUDA device
if (!InitCUDA()) {
return 0;
 }
 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<<<1, 1, 0>>>(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 = 0;
 clock_t start = clock();
for (int i = 0; i < DATA_SIZE; ++i) {
  result += data[i] * data[i];
 }
 time_used = clock() - start;
 printf("(CPU) sum:%d time:%ld\n", result, time_used);

return 0;
}

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[0], prop.maxThreadsDim[1], prop.maxThreadsDim[2]);
 printf("maxGridSize[0 - 2] : %d %d %d.\n", prop.maxGridSize[0], prop.maxGridSize[1], prop.maxGridSize[2]);
 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 == 0) {
  fprintf(stderr, "There is no device.\n");
return false;
 }

// find the device >= 1.X
int i;
for (i = 0; i < count; ++i) {
  cudaDeviceProp prop;
if (cudaGetDeviceProperties(&prop, i) == cudaSuccess) {
if (prop.major >= 1) {
    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();
//}