ubuntu如何编译cuda？

一. 利用Makefile

• 安装cuda toolkit之后，会有samples文件夹，存储了cuda的一些demo，便于学习与理解。
• 编译步骤

1. 在单个sample文件夹内，有 .cu 文件和Makefile，终端定位到文件夹，输入sudo make就可以编译了

   2.运行，如./asyncAPI ，就可以看到输出的信息

[./asyncAPI] - Starting...
GPU Device 0: "Pascal" with compute capability 6.1

CUDA device [GeForce GTX 1080 Ti]
time spent executing by the GPU: 168.72
time spent by CPU in CUDA calls: 0.02
CPU executed 668184 iterations while waiting for GPU to finish
           

注意：

Makefile project only supported on Mac OS X and Linux Platforms)

如果在windows里面使用，配合VS则会很方便

二.利用CMakeList

使用这种方法可以在Clion中编译cuda，也是爽歪歪！可以在CLion中新建一个cuda project

这里给出一个简单的demo

1. CMakeList.txt

   其中include路径由安装时决定

cmake_minimum_required(VERSION 3.16)
project(untitled_cuda CUDA)

set(CMAKE_CUDA_STANDARD 14)

#include_directories(includes/math)
include_directories(/usr/local/cuda-10.2)   
include_directories(/usr/local/cuda-10.2/samples/common/inc)

add_executable(untitled_cuda main.cu)

set_target_properties(
        untitled_cuda
        PROPERTIES
        CUDA_SEPARABLE_COMPILATION ON
)
           

1. main.cu

#include <iostream>
#include <cmath>

#include <cuda_runtime.h>

// includes, project
#include <helper_cuda.h>
#include <helper_functions.h> // helper utility functions

using namespace std;

// 加法kernel
// cuda kernel 里面无法使用cout!
__global__ void increment_kernel(int *g_data, int inc_value)
{
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    g_data[idx] = g_data[idx] + inc_value;
}

// cpu线程校验计算结果
bool correct_output(int *data, const int n, const int x)
{
    for (int i = 0; i < n; i++)
        if (data[i] != x)
        {
            printf("Error! data[%d] = %d, ref = %d\n", i, data[i], x);
            return false;
        }

    return true;
}


int main(int argc, char *argv[]) {
    std::cout << "Hello, World!" << std::endl;

    int devID;
    cudaDeviceProp deviceProps;

    printf("[%s] - Starting...\n", argv[0]);

    // This will pick the best possible CUDA capable device
    devID = findCudaDevice(argc, (const char **)argv);

    // get device name
    checkCudaErrors(cudaGetDeviceProperties(&deviceProps, devID));
    printf("CUDA device [%s]\n", deviceProps.name);

    int n = 16 * 1024 * 1024;
    int nbytes = n * sizeof(int);
    int value = 26;

    // allocate host memory
    int *a = 0;  // cpu host内存上的变量
    checkCudaErrors(cudaMallocHost((void **)&a, nbytes));
    memset(a, 0, nbytes);

    // allocate device memory
    int *d_a=0;  // gpu设备显存上的变量
    checkCudaErrors(cudaMalloc((void **)&d_a, nbytes));
    checkCudaErrors(cudaMemset(d_a, 255, nbytes));

    // set kernel launch configuration
    dim3 threads = dim3(512, 1);
    dim3 blocks  = dim3(n / threads.x, 1);

    // create cuda event handles
    cudaEvent_t start, stop;
    checkCudaErrors(cudaEventCreate(&start));
    checkCudaErrors(cudaEventCreate(&stop));

    StopWatchInterface *timer = NULL;
    sdkCreateTimer(&timer);
    sdkResetTimer(&timer);

    checkCudaErrors(cudaDeviceSynchronize());
    float gpu_time = 0.0f;

    // asynchronously issue work to the GPU (all to stream 0)
    sdkStartTimer(&timer);
    cudaEventRecord(start, 0);
    cudaMemcpyAsync(d_a, a, nbytes, cudaMemcpyHostToDevice, 0);
    increment_kernel<<<blocks, threads, 0, 0>>>(d_a, value);
    cudaMemcpyAsync(a, d_a, nbytes, cudaMemcpyDeviceToHost, 0);
    cudaEventRecord(stop, 0);
    sdkStopTimer(&timer);

    // have CPU do some work while waiting for stage 1 to finish
    unsigned long int counter=0;

    while (cudaEventQuery(stop) == cudaErrorNotReady)
    {
        counter++;
    }

    checkCudaErrors(cudaEventElapsedTime(&gpu_time, start, stop));

    // print the cpu and gpu times
    printf("time spent executing by the GPU: %.2f\n", gpu_time);
    printf("time spent by CPU in CUDA calls: %.2f\n", sdkGetTimerValue(&timer));
    printf("CPU executed %lu iterations while waiting for GPU to finish\n", counter);

    // check the output for correctness
    bool bFinalResults = correct_output(a, n, value);

    // release resources
    checkCudaErrors(cudaEventDestroy(start));
    checkCudaErrors(cudaEventDestroy(stop));
    checkCudaErrors(cudaFreeHost(a));
    checkCudaErrors(cudaFree(d_a));

    exit(bFinalResults ? EXIT_SUCCESS : EXIT_FAILURE);
}