2060算力入门指南：从零构建高性能计算环境

1次阅读

没有评论

共计 3639 个字符，预计需要花费 10 分钟才能阅读完成。

RTX 2060 作为 NVIDIA Turing 架构的中端显卡，拥有 1920 个 CUDA 核心和 6GB GDDR6 显存，支持最新的 CUDA 10.1 计算能力 7.5。它的算力特点主要体现在：

性价比突出：相比专业计算卡更亲民的价格
通用计算支持：完整支持 CUDA/OpenCL 生态
能效比优秀：120W TDP 下可提供 5 TFLOPS 单精度性能

适用场景包括：

深度学习模型训练（小规模）
科学计算加速
实时渲染开发

卸载旧驱动（如有）：
```
sudo apt-get purge nvidia*
```

添加官方仓库：

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update

安装推荐驱动（以 470 版本为例）：
```
sudo apt install nvidia-driver-470
```

安装完成后验证：

nvidia-smi

应看到类似输出：

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 470.57.02    Driver Version: 470.57.02    CUDA Version: 11.4     |
|-------------------------------+----------------------+----------------------+

从 NVIDIA 官网下载对应版本（建议 11.3）
执行安装（以 Ubuntu 为例）：
```
sudo sh cuda_11.3.0_465.19.01_linux.run
```

配置环境变量：

echo 'export PATH=/usr/local/cuda/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

验证安装：

nvcc --version

下面是一个简单的矩阵乘法示例，展示 CPU 与 GPU 的性能差异：

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

#define N 1024

// CPU 矩阵乘法
void cpu_matrix_mult(float *a, float *b, float *c) {for (int i = 0; i < N; i++) {for (int j = 0; j < N; j++) {
            float sum = 0.0f;
            for (int k = 0; k < N; k++) {sum += a[i * N + k] * b[k * N + j];
            }
            c[i * N + j] = sum;
        }
    }
}

// GPU 核函数
__global__ void gpu_matrix_mult(float *a, float *b, float *c) {
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;

    if (row < N && col < N) {
        float sum = 0.0f;
        for (int k = 0; k < N; k++) {sum += a[row * N + k] * b[k * N + col];
        }
        c[row * N + col] = sum;
    }
}

int main() {
    // 分配主机内存
    float *a = (float*)malloc(N * N * sizeof(float));
    float *b = (float*)malloc(N * N * sizeof(float));
    float *c_cpu = (float*)malloc(N * N * sizeof(float));
    float *c_gpu = (float*)malloc(N * N * sizeof(float));

    // 初始化矩阵
    for (int i = 0; i < N * N; i++) {a[i] = rand() / (float)RAND_MAX;
        b[i] = rand() / (float)RAND_MAX;
    }

    // CPU 计算
    clock_t start = clock();
    cpu_matrix_mult(a, b, c_cpu);
    clock_t end = clock();
    printf("CPU time: %.2f ms\n", (end - start) * 1000.0 / CLOCKS_PER_SEC);

    // GPU 计算
    float *d_a, *d_b, *d_c;
    cudaMalloc(&d_a, N * N * sizeof(float));
    cudaMalloc(&d_b, N * N * sizeof(float));
    cudaMalloc(&d_c, N * N * sizeof(float));

    cudaMemcpy(d_a, a, N * N * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, b, N * N * sizeof(float), cudaMemcpyHostToDevice);

    dim3 threadsPerBlock(16, 16);
    dim3 blocksPerGrid((N + threadsPerBlock.x - 1) / threadsPerBlock.x, 
                       (N + threadsPerBlock.y - 1) / threadsPerBlock.y);

    cudaEvent_t start_gpu, end_gpu;
    cudaEventCreate(&start_gpu);
    cudaEventCreate(&end_gpu);

    cudaEventRecord(start_gpu);
    gpu_matrix_mult<<<blocksPerGrid, threadsPerBlock>>>(d_a, d_b, d_c);
    cudaEventRecord(end_gpu);
    cudaEventSynchronize(end_gpu);

    float milliseconds = 0;
    cudaEventElapsedTime(&milliseconds, start_gpu, end_gpu);
    printf("GPU time: %.2f ms\n", milliseconds);

    cudaMemcpy(c_gpu, d_c, N * N * sizeof(float), cudaMemcpyDeviceToHost);

    // 验证结果
    float max_diff = 0.0f;
    for (int i = 0; i < N * N; i++) {max_diff = fmax(max_diff, fabs(c_cpu[i] - c_gpu[i]));
    }
    printf("Max difference: %f\n", max_diff);

    // 释放资源
    free(a); free(b); free(c_cpu); free(c_gpu);
    cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);

    return 0;
}

编译运行：

nvcc -o matmul matmul.cu
./matmul

典型输出（RTX 2060）：

CPU time: 3562.45 ms
GPU time: 23.78 ms
Max difference: 0.000015

nvprof ./matmul

输出示例：

==1234== Profiling application: ./matmul
==1234== Profiling result:
Time(%)      Time     Calls       Avg       Min       Max  Name
 50.12%  11.928ms         1  11.928ms  11.928ms  11.928ms  gpu_matrix_mult
 49.88%  11.872ms         2  5.9360ms  5.8880ms  5.9840ms  [CUDA memcpy HtoD]