《CUDA编程》3.简单CUDA程序的基本框架

最新推荐文章于 2024-09-27 11:26:03 发布
最新推荐文章于 2024-09-27 11:26:03 发布
阅读量1k 收藏 11
点赞数 28
分类专栏： CUDA学习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53115174/article/details/142523061
版权

本章将学习CUDA程序的基本框架，编写更加有用的CUDA程序

0 C++例子：数组相加

C++代码如下：

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h> // 包含 time.h 头文件以使用 clock()

const double EPS = 1.0e-15;
const double a = 1.23;
const double b = 2.34;
const double c = 3.57;

void add(const double* x, const double* y, double* z, const int N) {
    for (int n = 0; n < N; ++n) {
        z[n] = x[n] + y[n];
    }
}

void check(const double* z, const int N) {
    bool has_error = false;
    for (int n = 0; n < N; ++n) {
        if (fabs(z[n] - c) > EPS) {//判断浮点数是否相等时，不能用==，而应该做差，判断差值是否小于某个值
            has_error = true;
        }
    }
    printf("Has error: %d\n", has_error);
}

int main(void) {
    const int N = 100000000;
    const int M = sizeof(double) *N;

    double* x = (double*)malloc(M);
    double* y = (double*)malloc(M);
    double* z = (double*)malloc(M);

    // 记录程序开始时间
    clock_t start = clock();

    for (int n = 0; n < N; ++n) {
        x[n] = a;
        y[n] = b;
    }

    add(x, y, z, N);
    check(z, N);

    // 记录程序结束时间
    clock_t end = clock();

    // 计算并打印程序运行时间
    double cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("Time used: %f seconds\n", cpu_time_used);

    free(z);
    free(x);
    free(y);

    return 0;
}

输出结果为
在这里插入图片描述
其中

    const int N = 100000000; //定义数组的长度为10的8次方
    const int M = sizeof(double) *N; // 每个数组所需的字节数

    double* x = (double*)malloc(M); // 分配内存
    double* y = (double*)malloc(M); // 分配内存
    double* z = (double*)malloc(M); // 分配内存

会创建3个长度为10的8次方的一维数组，每个数组大约占用 800 MB 的内存，总共需要约 2.4 GB 的主机内存来存储这三个数组，同样的后面的CUDA程序也需要2.4GB的GPU内存，如果不足，请自行调整

1 CUDA的基本框架

一个典型的基本框架如下图所示：
请添加图片描述
现在我们根据上述框架，将刚刚的C++程序编写为CUDA程序：

#include <cuda.h>
#include <cuda_runtime.h>
#include <math.h>
#include <stdio.h>
#include <time.h> // 包含 time.h 头文件以使用 clock()

const double EPS = 1.0e-15;
const double a = 1.23;
const double b = 2.34;
const double c = 3.57;

// 希望 add 函数在 GPU 上执行
__global__ void add(const double *x, const double *y, double *z);
void check(const double* z, const int N);

int main(void) {
    const int N = 100000000; // 定义数组的长度为 10 的 8 次方
    const int M = sizeof(double) * N; // 每个数组所需的字节数

    // 分配host内存
    double* h_x = (double*)malloc(M); 
    double* h_y = (double*)malloc(M); 
    double* h_z = (double*)malloc(M); 

    // 记录程序开始时间
    clock_t start = clock();

    for (int n = 0; n < N; ++n) {
        h_x[n] = a;
        h_y[n] = b;
    }
	
	//分配device内存
    double* d_x, * d_y, * d_z;
    cudaMalloc((void**)&d_x, M);
    cudaMalloc((void**)&d_y, M);
    cudaMalloc((void**)&d_z, M);

    // 将数据从主机复制到设备上
    cudaMemcpy(d_x, h_x, M, cudaMemcpyHostToDevice);
    cudaMemcpy(d_y, h_y, M, cudaMemcpyHostToDevice);

    const int block_size = 128;
    // 计算网格尺寸，确保所有元素都能被处理
    const int grid_size = (N + block_size - 1) / block_size; 

    // 调用内核函数在设备中进行计算
    add <<<grid_size, block_size>> > (d_x, d_y, d_z);

    // 将计算结果从设备复制回主机
    cudaMemcpy(h_z, d_z, M, cudaMemcpyDeviceToHost);
    check(h_z, N);

    // 记录程序结束时间
    clock_t end = clock();

    // 计算并打印程序运行时间
    double cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("Time used: %f seconds\n", cpu_time_used);
	
	// 释放内存
    free(h_x);
    free(h_y);
    free(h_z);
    cudaFree(d_x);
    cudaFree(d_y);
    cudaFree(d_z);
    return 0;
}

__global__ void add(const double* x, const double* y, double* z) {
    const int n = blockIdx.x * blockDim.x + threadIdx.x;
    z[n] = x[n] + y[n];
}

void check(const double* z, const int N) {
    bool has_error = false;
    for (int n = 0; n < N; ++n) {
        if (fabs(z[n] - c) > EPS) {
            has_error = true;
        }
    }
    printf("Has error: %d\n", has_error);
}

输出结果如下：
请添加图片描述

1.1 解释grid_size的计算

const int block_size = 128;
// 计算网格尺寸，确保所有元素都能被处理
const int grid_size = (N + block_size - 1) / block_size;

其中

  • N：要处理的元素总数
  • block_size：每个block中的线程数，这里是128，可以根据任务进行调整，最大是1024

公式(N + block_size - 1) / block_size是确保N不能被block_size 整除，即确保有足够的线程块来处理元素，下面举例说明：

  1. 整除情况：例如N=1024，block_size=128，则1024/128=8，所以需要8个线程块，则grid_size设置为8
  2. 不能整除：例如N=1025，block_size=128，则1025/128=8余1，所以还需要多一个线程块来处理，但是grid_size是int类型，所以此时也是取8。
    为了避免这种情况，通过加 block_size - 1 来确保 N 在除以 block_size 时总是向上取整。

1.2 隐形的device初始化

在CUAD的runtime的API中，没有明显的初始化设备的函数，因为在第一次调用一个设和设备的管理及版本查询功能无关的runtime的API时，device将自动初始化

1.3 device内存的分配与释放

在代码中，我们在hsot和device中分别定义了3个数组，也分别分配了内存和显存
在这里插入图片描述
大家发现第一个指针是一个双重指针，是因为cudaMalloc()的函数原型是
在这里插入图片描述

  • 第一个参数address是待分配设备内存的指针，但内存本身就是一个指针，所以该参数其实是指针的指针，所以使用双重指针
  • size是待分配内存的字节数
  • 返回值是一个错误代号。如果调用成功，返回cudaSuccess，否则返回一个错误代码。

看下面这段代码
在这里插入图片描述
虽然double类型占用是8字节，但是为了程序的健壮性和可移植性（有的设备可能不是），所以这里还是使用sizeof(double)

1.4 host和device之间数据的传递

这里使用的是cudaMemcpy()函数，原型是：
在这里插入图片描述

  • dst：目标地址

  • src： 源地址

  • count：复制数据的字节数

  • kind：标志，取以下几个值
    –cudaMemcpyHostToHost，表示从主机复制到主机
    –cudaMemcpyHostToDevice，表示从主机复制到设备
    –cudaMemcpyDeviceToHost，表示从设备复制到主机
    –cudaMemcpyDeviceToDevice，表示从设备复制到设备
    –cudaMemcpyDefault，表示根据dst和src所指的地址自动判断，要求系统有统一寻址功能（unified virtual addressing）

  • 返回值是一个错误代号，如果调用成功，返回cudaSuccess

  • 该函数将一定字节数的数据从源地址所指的缓冲区复制到目标地址所指的缓冲区

所以下列代码的意义是：

cudaMemcpy(d_x, h_x, M, cudaMemcpyHostToDevice);
//将h_x指向的主机内存中的数据，复制到d_x指向的设备内存中去

1.5 核函数中数据与线程的对应

观察下列代码
在这里插入图片描述
使用了一个一维线程块，一共有【10的8次方/128】个线程块，每个线程块有128个线程

再观察下列函数：

这个是C++中写的函数
在这里插入图片描述
这个是CUDA程序中写在device中的函数
在这里插入图片描述
可以发现，将主机函数修改为设备中的核函数，只需要去掉循环即可。

因为在主机函数中，需要依次对数组的元素进行操作，所以会写一个循环。
但是在核函数中，我们使用“单指令— —多线程”的方式进行编写，即每个元素的操作都由单独的一个线程来计算，所以不需要循环，会进行并行执行

注意： 也可以使用循环，只需要设置为<<<1, 1>>>，就可以用一个线程去调用核函数计算

2 核函数的要求

2.1 编写核函数时要注意：

  • 核函数的返回类型必须是void
  • 必须使用__global__，也可以加上其他C++的限定符，如static，次序任意
  • 函数名无特殊要求，支持重载
  • 不支持可变数量的参数列表，参数的个数必须确定
  • 核函数不能成为一个类的成员，通常是用一个包装函数调用核函数，然后将包装函数定义为类的成员
  • 在计算能力3.5之前的，核函数之间不能相互调用
  • 可以向核函数传递非指针变量（如int N），其内容每个线程可见（可使用可访问）
  • 除非使用统一内存编程机制（将在第12章介绍），否则传给核函数的数组（指针）必须指向设备内存

2.2 核函数中if语句的必要性

在这里插入图片描述
该代码中没有使用if语句，但由于线程数是比元素总数多的，所以应该添加一个if语句，来防止数组越界，并且节约不必要的线程计算，修改代码如下：
在这里插入图片描述
运行结果如下，比不加if语句之前快，因为多余的线程没有执行计算操作
在这里插入图片描述

3 自定义设备函数

核函数可以调用不带执行配置的自定义函数，这样的自定义函数称为设备函数（device function），它是在设备中执行，并在设备中被调用的。

与之相比，核函数是在设备中执行，但在主机端被调用的。

3.1 标识符

  • 用__global__修饰的函数称为核函数，一般由主机调用，在设备中执行。如果使用动态并行，则也可以在核函数中调用自己或其他核函数。
  • 用__device__修饰的函数叫称为设备函数，只能被核函数或其他设备函数调用，在设备中执行。
  • 用__host__修饰的函数就是主机端的普通C++函数，在主机中被调用，在主机中执行。对于主机端的函数，该修饰符可省略。因为有时可以用__host__和__device__同时修饰一个函数，使得该函数既是一个C++中的普通函数，又是一个设备函数。这样做可以减少冗余代码。编译器将针对主机和设备分别编译该函数
  • 不能同时用__device__和__global__修饰一个函数，即不能将一个函数同时定义为设备函数和核函数。
  • 不能同时用__host__和__global__修饰一个函数，即不能将一个函数同时定义为主机函数和核函数。
  • 编译器决定把设备函数当作内联函数（inline function）或非内联函数，但可以用修饰符__noinline__建议一个设备函数为非内联函数（编译器不一定接受），也可以用修饰符__forceinline__建议一个设备函数为内联函数

3.2 例子： 为数组相加的核函数定义一个设备函数

（1）返回值

#include <cuda.h>
#include <cuda_runtime.h>
#include <math.h>
#include <stdio.h>
#include <time.h> // 包含 time.h 头文件以使用 clock()

const double EPS = 1.0e-15;
const double a = 1.23;
const double b = 2.34;
const double c = 3.57;

// 希望 add 函数在 GPU 上执行
__global__ void add(const double *x, const double *y, double *z,int N);
__device__ double add1_device(const double x, const double y);
void check(const double* z, const int N);

int main(void) {
    const int N = 100000000; // 定义数组的长度为 10 的 8 次方
    const int M = sizeof(double) * N; // 每个数组所需的字节数

    // 在 host 中分配内存
    double* h_x = (double*)malloc(M); // 分配内存
    double* h_y = (double*)malloc(M); // 分配内存
    double* h_z = (double*)malloc(M); // 分配内存

    // 记录程序开始时间
    clock_t start = clock();

    for (int n = 0; n < N; ++n) {
        h_x[n] = a;
        h_y[n] = b;
    }

    double* d_x, * d_y, * d_z;
    cudaMalloc((void**)&d_x, M);
    cudaMalloc((void**)&d_y, M);
    cudaMalloc((void**)&d_z, M);

    // 将主机上的数据复制到设备上
    cudaMemcpy(d_x, h_x, M, cudaMemcpyHostToDevice);
    cudaMemcpy(d_y, h_y, M, cudaMemcpyHostToDevice);

    const int block_size = 128;
    // 计算网格尺寸，确保所有元素都能被处理
    const int grid_size = (N + block_size - 1) / block_size; 

    // 调用内核函数来执行加法
    add <<<grid_size, block_size>> > (d_x, d_y, d_z,N);

    // 将计算结果从设备复制回主机
    cudaMemcpy(h_z, d_z, M, cudaMemcpyDeviceToHost);
    check(h_z, N);

    // 记录程序结束时间
    clock_t end = clock();

    // 计算并打印程序运行时间
    double cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("Time used: %f seconds\n", cpu_time_used);

    free(h_x);
    free(h_y);
    free(h_z);
    cudaFree(d_x);
    cudaFree(d_y);
    cudaFree(d_z);

    return 0;
}

//返回值
__device__ double add1_device(const double x, const double y) {
    return x + y;
}

__global__ void add(const double* x, const double* y, double* z,int N) {
    const int n = blockIdx.x * blockDim.x + threadIdx.x;//会飘红，不影响运行
    // 添加边界检查，确保索引不越界
    if (n < N) {
        z[n] = add1_device(x[n], y[n]);
    }
}

void check(const double* z, const int N) {
    bool has_error = false;
    for (int n = 0; n < N; ++n) {
        if (fabs(z[n] - c) > EPS) {
            has_error = true;
        }
    }
    printf("Has error: %d\n", has_error);
}

（2）指针

#include <cuda.h>
#include <cuda_runtime.h>
#include <math.h>
#include <stdio.h>
#include <time.h> // 包含 time.h 头文件以使用 clock()

const double EPS = 1.0e-15;
const double a = 1.23;
const double b = 2.34;
const double c = 3.57;

// 希望 add 函数在 GPU 上执行
__global__ void add(const double *x, const double *y, double *z,int N);
__device__ void add2_device(const double x, const double y,double *z);
void check(const double* z, const int N);

int main(void) {
    const int N = 100000000; // 定义数组的长度为 10 的 8 次方
    const int M = sizeof(double) * N; // 每个数组所需的字节数

    // 在 host 中分配内存
    double* h_x = (double*)malloc(M); // 分配内存
    double* h_y = (double*)malloc(M); // 分配内存
    double* h_z = (double*)malloc(M); // 分配内存

    // 记录程序开始时间
    clock_t start = clock();

    for (int n = 0; n < N; ++n) {
        h_x[n] = a;
        h_y[n] = b;
    }

    double* d_x, * d_y, * d_z;
    cudaMalloc((void**)&d_x, M);
    cudaMalloc((void**)&d_y, M);
    cudaMalloc((void**)&d_z, M);

    // 将主机上的数据复制到设备上
    cudaMemcpy(d_x, h_x, M, cudaMemcpyHostToDevice);
    cudaMemcpy(d_y, h_y, M, cudaMemcpyHostToDevice);

    const int block_size = 128;
    // 计算网格尺寸，确保所有元素都能被处理
    const int grid_size = (N + block_size - 1) / block_size; 

    // 调用内核函数来执行加法
    add <<<grid_size, block_size>> > (d_x, d_y, d_z,N);

    // 将计算结果从设备复制回主机
    cudaMemcpy(h_z, d_z, M, cudaMemcpyDeviceToHost);
    check(h_z, N);

    // 记录程序结束时间
    clock_t end = clock();

    // 计算并打印程序运行时间
    double cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("Time used: %f seconds\n", cpu_time_used);

    free(h_x);
    free(h_y);
    free(h_z);
    cudaFree(d_x);
    cudaFree(d_y);
    cudaFree(d_z);

    return 0;
}

//指针
__device__ void add2_device(const double x, const double y, double* z) {
    *z=x+y;
}

__global__ void add(const double* x, const double* y, double* z,int N) {
    const int n = blockIdx.x * blockDim.x + threadIdx.x;//会飘红，不影响运行
    // 添加边界检查，确保索引不越界
    if (n < N) {
        add2_device(x[n], y[n], &z[n]);
    }
}

void check(const double* z, const int N) {
    bool has_error = false;
    for (int n = 0; n < N; ++n) {
        if (fabs(z[n] - c) > EPS) {
            has_error = true;
        }
    }
    printf("Has error: %d\n", has_error);
}

（3）引用

#include <cuda.h>
#include <cuda_runtime.h>
#include <math.h>
#include <stdio.h>
#include <time.h> // 包含 time.h 头文件以使用 clock()

const double EPS = 1.0e-15;
const double a = 1.23;
const double b = 2.34;
const double c = 3.57;

// 希望 add 函数在 GPU 上执行
__global__ void add(const double *x, const double *y, double *z,int N);
__device__ void add3_device(const double x, const double y,double &z);
void check(const double* z, const int N);

int main(void) {
    const int N = 100000000; // 定义数组的长度为 10 的 8 次方
    const int M = sizeof(double) * N; // 每个数组所需的字节数

    // 在 host 中分配内存
    double* h_x = (double*)malloc(M); // 分配内存
    double* h_y = (double*)malloc(M); // 分配内存
    double* h_z = (double*)malloc(M); // 分配内存

    // 记录程序开始时间
    clock_t start = clock();

    for (int n = 0; n < N; ++n) {
        h_x[n] = a;
        h_y[n] = b;
    }

    double* d_x, * d_y, * d_z;
    cudaMalloc((void**)&d_x, M);
    cudaMalloc((void**)&d_y, M);
    cudaMalloc((void**)&d_z, M);

    // 将主机上的数据复制到设备上
    cudaMemcpy(d_x, h_x, M, cudaMemcpyHostToDevice);
    cudaMemcpy(d_y, h_y, M, cudaMemcpyHostToDevice);

    const int block_size = 128;
    // 计算网格尺寸，确保所有元素都能被处理
    const int grid_size = (N + block_size - 1) / block_size; 

    // 调用内核函数来执行加法
    add <<<grid_size, block_size>> > (d_x, d_y, d_z,N);

    // 将计算结果从设备复制回主机
    cudaMemcpy(h_z, d_z, M, cudaMemcpyDeviceToHost);
    check(h_z, N);

    // 记录程序结束时间
    clock_t end = clock();

    // 计算并打印程序运行时间
    double cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("Time used: %f seconds\n", cpu_time_used);

    free(h_x);
    free(h_y);
    free(h_z);
    cudaFree(d_x);
    cudaFree(d_y);
    cudaFree(d_z);

    return 0;
}

//指针
__device__ void add3_device(const double x, const double y, double& z) {
    z=x+y;
}

__global__ void add(const double* x, const double* y, double* z,int N) {
    const int n = blockIdx.x * blockDim.x + threadIdx.x;//会飘红，不影响运行
    // 添加边界检查，确保索引不越界
    if (n < N) {
        add3_device(x[n], y[n], z[n]);
    }
}

void check(const double* z, const int N) {
    bool has_error = false;
    for (int n = 0; n < N; ++n) {
        if (fabs(z[n] - c) > EPS) {
            has_error = true;
        }
    }
    printf("Has error: %d\n", has_error);
}
青石横刀策马
关注
专栏目录
pytorch的c++/cuda扩展，CUDA编程
xx_xjm的博客
04-25 2596
我们知道C++，C这类的编程语言是为了让计算机执行我们的指令，确切一点是让计算机的cpu执行我们的执行，现在cuda编程则是要让显卡中的计算核心执行我们的指令；所以，cuda编程其实就是编写显卡中计算核心执行指令。为了区别于.cpp，.c这样的文件，我们取.cu后缀来指明当前的代码文件是给显卡用的；我们上面说了，.cu本质上还是写给CPU的，所以核函数其实也是C++函数的一种，只不过有一个特殊的限定词"__global__"，用以指明“这个C++函数，是用来调用显卡的！
QT CUDA编程 教程 实例.pdf
11-04
QT CUDA编程教程主要针对那些想要将CUDA程序从Visual Studio (VS)环境移植到Qt Creator的开发者，特别是初学者。CUDA是NVIDIA推出的一种并行计算平台和编程模型，主要用于GPU加速计算。Qt则是一个跨平台的C++应用...
【CUDA】《CUDA编程：基础与实践》CUDA程序基本框架
qq_30340349的博客
03-12 552
以向量加法为例介绍了CUDA程序得基本结构，使用xmake进行项目组织及编译。
CUDA编程（三）CUDA程序的基本框架
qq_43616651的博客
10-23 172
设备函数：核函数可以调用不带执行配置的自定义函数，这样的自定函数称为设备函数（device function）。他是在设备中执行，并在设备中被调用的。与之相比，核函数时在设备中执行，但在主机端被调用。现在也支持在一个核函数中调用其他和函数，甚至该核函数本身。函数执行空间表示符：__gloabal__:核函数，一般由主机调用，在设备中执行，如果使用动态并行，则也可以在核函数中调用自己或其他核函数。__device__:设备函数，只能被核函数或其他设备函数调用，在设备中执行。
CUDA 编程简介
略懂……略懂……
04-29 1294
本文用尽量通俗的语言为大家讲解 GPU 的工作原理和 CUDA 异构编程。并用向量相加、矩阵相乘为例，演示了如何在 GPU 上用 CUDA 进行异构编程。
03《CUDA编程基础与实践》-简单CUDA程序的基本框架
HZZC_的博客
07-18 185
核函数可以调用不带执行配置的自定义函数，这样的自定义函数称为设备函数(device function)。它是在设备中执行，并在设备中被调用的。与之相比，核函数是在设备中执行，但在主机端被调用的。现在也支持在一个核函数中调用其他核函数，甚至调用该核函数本身，但本书不涉及这方面的内容。设备函数的定义与使用涉及 CUDA 中函数执行空间标识符的概念。我们先对此进行介绍，然后以数组相加的程序为例展示设备函数的定义与调用。3.3.1 函数执行空间标识符。
CUDA 编程上手指南：CUDA C 编程及 GPU 基本知识
极市平台的技术博客
12-21 2370
作者丨科技猛兽 编辑丨极市平台 本文原创首发于极市平台，转载请获得授权并标明出处。 推荐大家关注极市平台公众号，每天都会更新最新的计算机视觉论文解读、综述盘点、调参攻略、面试经验等干货~ 目录 1 CPU 和 GPU 的基础知识 2 CUDA 编程的重要概念 3 并行计算向量相加 4 实践 4.1 向量相加 CUDA 代码 4.2 实践向量相加 5 给大家的一点参考资料 1 CPU 和 GPU 的基础知识 提到处理器结构，有2个指标是经常要考虑的：延迟和吞吐量。所谓延迟，是指从发出指令到最终返回结果中
CUDA 编程简单入门 Advance CUDA 编程基础 (C++ programming)
一个博客
10-10 720
CUDA 编程简单入门 Advance CUDA 编程基础 (C++ programming)
【CUDA编程基础】第三章 CUDA程序的基本框架
阳一子的博客
09-21 691
确定类型：在声明指针时，你必须指定指针的类型（例如，int*、double*、char* 等）。指针的类型对于后续的内存访问和解引用操作至关重要，因为它决定了如何解释存储在指针所指向地址上的数据。请注意，这里分配的内存是用于存储地址的，而不是用于存储指针所指向的数据。2. 类型确定：双重指针的类型指明了它所指向的对象类型，即另一个指针的类型。它们常用于动态内存分配（如二维数组的动态分配）、修改指针本身的值（如在函数内部改变外部指针的指向），以及构建复杂的数据结构（如树、图等）。将某些数据从主机复制到设备。
Linux上C++与CUDA混合编程
白水的博客
10-09 4141
为了更好地说明如何在Linux实现C++与CUDA的混合编程，我接下来将以实现对一个矩阵的每一个元素的取模运算。 1. 头文件和文件形式 要在C++中编写CUDA代码，需要引入头文件： #include "cuda_runtime.h" #include "cublas_v2.h" #include "device_launch_parameters.h" 然后将文件后缀由.cpp改为.cu 2. 搭建程序框架 一个CUDA程序的框架类似于普通C++程序，下面我们来展示其中一种简单的形式： // mod_
OpenCV环境下CUDA编程示例.pdf
02-27
4. 错误检查：在CUDA编程中，错误检查是必要的，以确保程序的稳定性和正确性。 5. 协同编程：结合CPU和GPU的工作，例如在CPU上进行预处理或后处理，GPU进行计算密集型任务。 总之，OpenCV与CUDA的结合为图像处理和...
TensorRT 6.0.1.5.Windows10版本.x86_64平台.cuda-10.0.cudnn7.6
03-17
- CUDA是NVIDIA提供的编程接口，允许开发者利用GPU进行并行计算。CUDA 10.0引入了对Volta架构的支持，优化了内存管理，提供了新的库如NCCL（NVIDIA Collective Communications Library）和cuDNN。 3. **cuDNN 7.6*...
CUDA C编程权威指南.pdf
07-08
- CUDA编程的基本框架和组成部分。 - 主程序(host)和设备程序(device)的概念及其交互方式。 - **2.1.2 内存管理** - 不同类型的内存（如全局内存、共享内存等）及其使用方法。 - 内存拷贝的基本操作。 - **...
TensorRT-7.0.0.11.Ubuntu-18.04.x86_64-gnu.cuda-10.2.cudnn7.6.zip
05-28
3. **安装CUDNN**：同样从NVIDIA官网获取CUDNN的.tgz文件，解压后将头文件（include目录）和库文件（lib64目录）复制到CUDA安装目录下的相应位置。 4. **安装TensorRT**：下载TensorRT的zip文件，解压得到的tar.gz...
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 985
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1004
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
pyqt瀑布流布局
weixin_54217201的博客
09-21 480
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 373
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青石横刀策马

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值