2019-02-15 | 使用 Nsight 進行CUDA-C/C++開發簡易教程

0. 寫在前面

有一位朋友請教我這個軟件如何使用，正趕上我吃飯，這位朋友說過段時間再說也行，於是我就準備程序完成了這篇簡易教程。筆者使用 XUbuntu 18.04 操作系統，安裝的CUDA 9.1，設備爲 GTX-850M。

• 教程內容包括：

  1. 新建CUDA C/C++ 項目
  2. 添加代碼（計算矩陣相乘）
  3. 編譯、鏈接、執行
  4. 分析程序性能

• 教程概覽

  1. Nsight Eclipse Edition 簡介
  2. 使用方法（教程內容）
  3. 附錄 - 程序完整源碼

• 特別聲明
  此教程所用測試代碼取自網絡，原文作者鏈接如下，如若侵犯作者版權，請聯繫刪帖。
  作者：MingChaoSun
  原文：https://blog.csdn.net/sunmc1204953974/article/details/51098028

1. Nsight Eclipse Edition 簡介

NVIDIA®Nsight™Eclipse Edition是一個功能全面的IDE，由Eclipse平臺提供支持，提供一體化的集成環境，用於編輯，構建，調試和分析CUDA-C應用程序。Nsight Eclipse Edition支持豐富的商業和免費插件。
點擊跳轉到 Nsight Eclipse Edition 介紹頁。

2. 使用方法

2.1 打開 Nsight Eclipse Edition

Nsight Eclipse Edition 可以通過兩種方式打開：

$ nsight # 通過終端命令打開

或者新建桌面圖標，通過單擊相應圖標啓動程序。下圖爲 Nsight Eclipse Edition主界面。

• 左側區域爲管理區，在這裏可以管理整個項目屬性；
• 中間區域爲工作區，比如編寫代碼、查看程序分析結果等；
• 右側區域爲大綱區，可以查看項目的頭文件、宏定義、函數名等內容。
  ps: 上面三個區域是我自己想出來的名字，如果讀者覺得不恰當，可以留言討論，謝謝。

2.2 新建 CUDA-C/C++ 項目

• 方法：菜單欄 -> File -> New -> CUDA C/C++ Project
  最後，我們將見到如下圖所示的窗口。在這裏可以設置 Project name（項目名稱）、Location（項目路徑）、Project type（項目類型）等內容
  

2.3 添加代碼

• 方法：在 Nsight Eclipse Edition 主界面管理區單擊鼠標右鍵，然後選擇右鍵菜單中的New，再選擇在出現在下級菜單中的Source File，如下圖所示。

完成上述操作後，出現下面窗口。

• 在這裏，可以設置Source folder（源代碼文件文件夾） Source file（源代碼文件文件名，不帶擴展名） Template（使用模板）。
• 本教程中，源代碼文件文件名爲main，未使用模板。

2.4 編寫代碼

在中間的工作區編寫相關代碼。

2.5 編譯、鏈接、執行

• 通過工具欄，方法：點擊工具欄按鈕（下圖中左起第一個），即可進行。
  
• 通過菜單欄進行，方法：菜單欄 -> Project -> Build All 或 Build Project

2.6 分析程序

• 通過工具欄，方法：點擊工具欄按鈕（下圖中左起第二個），即可進行。

比如此教程所用程序的性能分析如下圖所示。

3. 附錄 - 程序完整源碼

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//CUDA RunTime API
#include <cuda_runtime.h>

#define THREAD_NUM 256

#define MATRIX_SIZE 1000

const int blocks_num = MATRIX_SIZE * (MATRIX_SIZE + THREAD_NUM - 1) / THREAD_NUM;

//打印設備信息
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);
}

//CUDA 初始化
bool InitCUDA() {
    int count;

    //取得支持Cuda的裝置的數目
    cudaGetDeviceCount(&count);

    if (count == 0) {
        fprintf(stderr, "There is no device.\n");

        return false;
    }

    int i;

    for (i = 0; i < count; i++) {

        cudaDeviceProp prop;
        cudaGetDeviceProperties(&prop, i);
        //打印設備信息
        printDeviceProp(prop);

        if (cudaGetDeviceProperties(&prop, i) == cudaSuccess) {
            if (prop.major >= 1) {
                break;
            }
        }
    }

    if (i == count) {
        fprintf(stderr, "There is no device supporting CUDA 1.x.\n");
        return false;
    }

    cudaSetDevice(i);

    return true;

}

//生成隨機矩陣
void matgen(float* a, int n) {
    int i, j;

    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {

            a[i * n + j] = (float) rand() / RAND_MAX
                    + (float) rand() / (RAND_MAX * RAND_MAX);

        }
    }
}

// __global__ 函數 並行計算矩陣乘法
__global__ static void matMultCUDA(const float* a, const float* b, float* c,
        int n, clock_t* time) {

    //表示目前的 thread 是第幾個 thread（由 0 開始計算）
    const int tid = threadIdx.x;

    //表示目前的 thread 屬於第幾個 block（由 0 開始計算）
    const int bid = blockIdx.x;

    //從 bid 和 tid 計算出這個 thread 應該計算的 row 和 column
    const int idx = bid * THREAD_NUM + tid;
    const int row = idx / n;
    const int column = idx % n;

    int i;

    //記錄運算開始的時間
    clock_t start;

    //只在 thread 0（即 threadIdx.x = 0 的時候）進行記錄，每個 block 都會記錄開始時間及結束時間
    if (tid == 0)
        time[bid] = clock();

    //計算矩陣乘法
    if (row < n && column < n) {
        float t = 0;

        for (i = 0; i < n; i++) {
            t += a[row * n + i] * b[i * n + column];
        }
        c[row * n + column] = t;
    }

    //計算時間,記錄結果，只在 thread 0（即 threadIdx.x = 0 的時候）進行，每個 block 都會記錄開始時間及結束時間
    if (tid == 0) {
        time[bid + blocks_num] = clock();
    }
}

int main() {

    //CUDA 初始化
    if (!InitCUDA())
        return 0;

    //定義矩陣
    float *a, *b, *c, *d;

    int n = MATRIX_SIZE;

    //分配內存
    a = (float*) malloc(sizeof(float) * n * n);
    b = (float*) malloc(sizeof(float) * n * n);
    c = (float*) malloc(sizeof(float) * n * n);
    d = (float*) malloc(sizeof(float) * n * n);

    //設置隨機數種子
    srand(0);

    //隨機生成矩陣
    matgen(a, n);
    matgen(b, n);

    /*把數據複製到顯卡內存中*/
    float *cuda_a, *cuda_b, *cuda_c;

    clock_t* time;

    //cudaMalloc 取得一塊顯卡內存
    cudaMalloc((void**) &cuda_a, sizeof(float) * n * n);
    cudaMalloc((void**) &cuda_b, sizeof(float) * n * n);
    cudaMalloc((void**) &cuda_c, sizeof(float) * n * n);
    cudaMalloc((void**) &time, sizeof(clock_t) * blocks_num * 2);

    //cudaMemcpy 將產生的矩陣複製到顯卡內存中
    //cudaMemcpyHostToDevice - 從內存複製到顯卡內存
    //cudaMemcpyDeviceToHost - 從顯卡內存複製到內存
    cudaMemcpy(cuda_a, a, sizeof(float) * n * n, cudaMemcpyHostToDevice);
    cudaMemcpy(cuda_b, b, sizeof(float) * n * n, cudaMemcpyHostToDevice);

    // 在CUDA 中執行函數 語法：函數名稱<<<block 數目, thread 數目, shared memory 大小>>>(參數...);
    matMultCUDA<<<blocks_num, THREAD_NUM, 0>>>(cuda_a, cuda_b, cuda_c, n, time);

    /*把結果從顯示芯片複製回主內存*/

    clock_t time_use[blocks_num * 2];

    //cudaMemcpy 將結果從顯存中複製回內存
    cudaMemcpy(c, cuda_c, sizeof(float) * n * n, cudaMemcpyDeviceToHost);
    cudaMemcpy(&time_use, time, sizeof(clock_t) * blocks_num * 2,
            cudaMemcpyDeviceToHost);

    //Free
    cudaFree(cuda_a);
    cudaFree(cuda_b);
    cudaFree(cuda_c);
    cudaFree(time);

    //把每個 block 最早的開始時間，和最晚的結束時間相減，取得總運行時間
    clock_t min_start, max_end;

    min_start = time_use[0];

    max_end = time_use[blocks_num];

    for (int i = 1; i < blocks_num; i++) {
        if (min_start > time_use[i])
            min_start = time_use[i];

        if (max_end < time_use[i + blocks_num])
            max_end = time_use[i + blocks_num];
    }

    //核函數運行時間
    clock_t final_time = max_end - min_start;

    //CPU矩陣乘法，存入矩陣d
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            double t = 0;

            for (int k = 0; k < n; k++) {

                t += a[i * n + k] * b[k * n + j];

            }

            d[i * n + j] = t;

        }
    }

    //驗證正確性與精確性

    float max_err = 0;

    float average_err = 0;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (d[i * n + j] != 0) {
                //fabs求浮點數x的絕對值
                float err = fabs((c[i * n + j] - d[i * n + j]) / d[i * n + j]);

                if (max_err < err)
                    max_err = err;

                average_err += err;
            }
        }
    }

    printf("Max error: %g Average error: %g\n", max_err, average_err / (n * n));

    printf("gputime: %d\n", final_time);

    return 0;

}