cuda编程实例

最新推荐文章于 2023-05-18 19:08:43 发布
最新推荐文章于 2023-05-18 19:08:43 发布
阅读量1.9k 收藏 12
点赞数 2
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/learnererer/article/details/125255941
版权

矢量求和

include "error.cuh"
#include <stdio.h>
#include <cuda_runtime.h>

#define N   100

__global__ void add( int *a, int *b, int *c ) {
    int tid = blockIdx.x;    // this thread handles the data at its thread id
    if (tid < N)
        c[tid] = a[tid] + b[tid];
}

int main( void ) {
    int a[N], b[N], c[N];
    int *dev_a, *dev_b, *dev_c;

    // allocate the memory on the GPU
    CHECK( cudaMalloc( (void**)&dev_a, N * sizeof(int) ) );
    CHECK( cudaMalloc( (void**)&dev_b, N * sizeof(int) ) );
    CHECK( cudaMalloc( (void**)&dev_c, N * sizeof(int) ) );

    // fill the arrays 'a' and 'b' on the CPU
    for (int i=0; i<N; i++) {
        a[i] = -i;
        b[i] = i * i;
    }

    // copy the arrays 'a' and 'b' to the GPU
    CHECK( cudaMemcpy( dev_a, a, N * sizeof(int),
                              cudaMemcpyHostToDevice ) );
    CHECK( cudaMemcpy( dev_b, b, N * sizeof(int),
                              cudaMemcpyHostToDevice ) );

    add<<<N,1>>>( dev_a, dev_b, dev_c );

    // copy the array 'c' back from the GPU to the CPU
    CHECK( cudaMemcpy( c, dev_c, N * sizeof(int),
                              cudaMemcpyDeviceToHost ) );

    // display the results
    for (int i=0; i<N; i++) {
        printf( "%d + %d = %d\n", a[i], b[i], c[i] );
    }

    // free the memory allocated on the GPU
    CHECK( cudaFree( dev_a ) );
    CHECK( cudaFree( dev_b ) );
    CHECK( cudaFree( dev_c ) );

    return 0;
}

julia集

在这里插入图片描述

在这里插入代码片

任意长度矢量求和

在这里插入图片描述

#include "error.cuh"
#include <stdio.h>
#include <cuda_runtime.h>
#define N   (33 * 1024)

__global__ void add( int *a, int *b, int *c ) {

//获取线程id，网格大小1D,线程块大小1D,gridDim.x=128，blockDim.x=128
//数据量：33792，线程数：16384

        int tid = threadIdx.x + blockIdx.x * blockDim.x;

//方法1：
        for(int i=0;i<N;i++){
                if(tid==i%blockDim.x*gridDim.x){
                        c[i] = a[i] + b[i];

                }
        }
/*

//方法2：
        while (tid < N) {
                c[tid] = a[tid] + b[tid];
                tid += blockDim.x * gridDim.x;
        }
*/
}
int main( void ) {
    //定义主机指针和设备指针
    int *a, *b, *c;
    int *dev_a, *dev_b, *dev_c;

    //CPU上动态分配内存
    a = (int*)malloc( N * sizeof(int) );
    b = (int*)malloc( N * sizeof(int) );
    c = (int*)malloc( N * sizeof(int) );

    //GPU上动态分配内存
    CHECK( cudaMalloc( (void**)&dev_a, N * sizeof(int) ) );
    CHECK( cudaMalloc( (void**)&dev_b, N * sizeof(int) ) );
    CHECK( cudaMalloc( (void**)&dev_c, N * sizeof(int) ) );

    //CPU上为a和b赋值
    for (int i=0; i<N; i++) {
        a[i] = i;
        b[i] = 2 * i;
    }

    //将a和b的数据从主机拷贝到设备
    CHECK( cudaMemcpy( dev_a, a, N * sizeof(int),
                              cudaMemcpyHostToDevice ) );
    CHECK( cudaMemcpy( dev_b, b, N * sizeof(int),
                              cudaMemcpyHostToDevice ) );
    //调用核函数，设置线程，网格大小1D，线程块大小1D,32
    add<<<128,128>>>( dev_a, dev_b, dev_c );

    //将数据从设备传递到主机上
    CHECK( cudaMemcpy( c, dev_c, N * sizeof(int),
                              cudaMemcpyDeviceToHost ) );

    //结果校验
    bool success = true;
    for (int i=0; i<N; i++) {
        if ((a[i] + b[i]) != c[i]) {
            success = false;
        }
    }
    if (success)
        printf( "We did it!\n" );
    else
        printf("Not Pass!Error!!!\n");

    //释放GPU内存空间
    CHECK( cudaFree( dev_a ) );
    CHECK( cudaFree( dev_b ) );
    CHECK( cudaFree( dev_c ) );

    //释放CPU内存空间
    free( a );
    free( b );
    free( c );

    return 0;
}

矩阵处理

在这里插入图片描述
在这里插入图片描述

#define N 1000
#define BLOCK_SIZE 32

__managed__ int input_Matrix[N][N];
__managed__ int output_GPU[N][N];
__managed__ int output_CPU[N][N];
__managed__ int output_GPU[N][N];
__managed__ int output_CPU[N][N];
__global__ void kernel(int input_M[N][N], int output_M[N][N])
{

  int x = blockIdx.x * blockDim.x + threadIdx.x;//<<gradx,blockx>>
  int y = blockIdx.y * blockDim.y + threadIdx.y;//<grady,blocky>>
//x维度变化快相当于内层循环
  if(x<N && y<N)
  {
      if(x%2==0 && y%2==0)
      {
          output_M[y][x] = input_M[y][x]*input_M[y][x];
      }
      else
      {
          output_M[y][x] = input_M[y][x]-1;
      }
  }
}
void cpu_kernel(int intput_M[N][N], int output_CPU[N][N])
{
    for(int i=0; i<N; i++)
     {
        for(int j=0; j<N; j++)
        {
            if(j%2==0 && i%2==0)
            {
                output_CPU[i][j] = intput_M[i][j]*intput_M[i][j];
            }
            else
            {
                output_CPU[i][j] = intput_M[i][j]-1;
            }
        }
    }
}

int main(int argc, char const *argv[])
{

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j)
        {

            input_Matrix[i][j] = rand()%3001;
        }
    }

//CPU
    cudaEvent_t start_cpu,stop_cpu;
    CHECK(cudaEventCreate(&start_cpu));
    CHECK(cudaEventCreate(&start_cpu));
    CHECK(cudaEventCreate(&stop_cpu));
    CHECK(cudaEventRecord(start_cpu));
    printf("\n***********CPU RUN**************\n");
    cpu_kernel(input_Matrix, output_CPU);
    CHECK(cudaEventRecord(stop_cpu));
    CHECK(cudaEventSynchronize(stop_cpu));
    float elapsed_time_cpu;
    CHECK(cudaEventElapsedTime(&elapsed_time_cpu, start_cpu, stop_cpu));
    printf("Time_CPU = %g ms.\n", elapsed_time_cpu);
    CHECK(cudaEventDestroy(start_cpu));
    CHECK(cudaEventDestroy(stop_cpu));

//GPU
    cudaEvent_t start,stop_gpu;
    CHECK(cudaEventCreate(&start));
    CHECK(cudaEventCreate(&stop_gpu));
    CHECK(cudaEventRecord(start));

    unsigned int grid_rows = (N + BLOCK_SIZE - 1) / BLOCK_SIZE;
    unsigned int grid_cols = (N + BLOCK_SIZE - 1) / BLOCK_SIZE;

    dim3 dimGrid(grid_cols, grid_rows);//网格大小，保证gridDim.x/y*blockDim.y,可以被32整除，且大于数组（x,y）的
数据大小
    dim3 dimBlock(BLOCK_SIZE, BLOCK_SIZE);
    printf("\n***********GPU RUN**************\n");
    kernel<<<dimGrid, dimBlock>>>(input_Matrix, output_GPU);

    CHECK(cudaDeviceSynchronize());
    CHECK(cudaEventRecord(stop_gpu));
    CHECK(cudaEventSynchronize(stop_gpu));

    float elapsed_time_gpu;
    CHECK(cudaEventElapsedTime(&elapsed_time_gpu, start, stop_gpu));
    printf("Time_GPU = %g ms.\n", elapsed_time_gpu);
    CHECK(cudaEventDestroy(start));
    CHECK(cudaEventDestroy(stop_gpu));
    //校验
    printf("\n***********Check result**************\n");
    int ok=1;
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            if(fabs(output_GPU[i][j] - output_CPU[i][j])>(1.0e-10))
            {
                ok = 0;
            }

        }
    }


    if(ok)
    {
        printf("Pass!!!\n");
    }
    else
    {
        printf("Error!!!\n");
    }

    // free memory
    return 0;
}

矩阵转置

在这里插入图片描述在这里插入图片描述

点积

在这里插入图片描述
在这里插入图片描述

常量内存

在这里插入图片描述

yeager415
关注
一个成功运行的CUDA小例子
12-24
忙活了很久，终于编译并成功运行了一个自己的CUDA例程，里面有三个小测试程序，包括Hello CUDA！、修改矩阵、矩阵块加
几个cuda源代码示例
09-04
几个cuda源代码示例 1.cuda矩阵例子.cu 2.实现矩阵的乘法.cu 3.... /*****************************************************************************************/ /核心代码部分,实现了矩阵的乘法运算/核心代码部分,实现了矩阵的乘法运算 /*****************************************************************************************/ / // Matrix multiplication kernel –thread specification __global__ void MatrixMulKernel(Matrix M, Matrix N, Matrix P) { // 2D Thread ID int tx = threadIdx.x; int ty = threadIdx.y; // Pvalue is used to store the element of the matrix // that is computed by the thread float Pvalue = 0; // 并行计算体现在次,多个thread并行进行 // 每个thread计算一行与一列的乘积 for (int k = 0; k < M.width; ++k) { float Melement = M.elements[ty * M.pitch + k]; float Nelement = Nd.elements[k * N.pitch + tx]; Pvalue += Melement * Nelement; } // Write the matrix to device memory; // each thread writes one element P.elements[ty * P.pitch + tx] = Pvalue; }
记一次CUDA编程任务
weixin_30689307的博客
02-16 356
　　 　　这个月6号开始，着手解决一个具有实际意义的计算任务。任务数据有9879896条，每条包含30个整数，任务是计算每两条数据之间的斯皮尔相关系数及其P值。原始数据只有500+MB，因此我并不认为这是个多么大的计算任务。随后稍加计算，我还是很惊呆的，要计算(9879896×9879895)÷2≈4.88亿亿组数据，但此时这还只是个数字概念，我也没意识到时间复杂度和空间复杂度的问题。 ...
NVIDIA CUDA 高度并行处理器编程（六）：并行模式：卷积
ikun的博仔的博客
06-12 1818
CUDA卷积。
【CUDA编程】一：从简单的实例入门
qq_43257640的博客
05-31 5139
前提 拥有NVIDIA的显卡- 配置好cuda 有C/C++基础 代码1 //helloworld.cu #include <iostream> #include <stdio.h> /* * __global__ 用于修饰在gpu上运行且由cpu调用的函数 */ __global__ void k_add (int a, int b, int* c ){ *c = a+b; } /* * __host__用于修饰在cpu上运行的函数，一般缺省 */ int main(v
CUDA教程及其实例程序实现
07-29
CUDA教程及其实例程序实现，非常经典的资料，压缩包中有文档和代码实例，非常好的资料
cuda示例程序
07-15
英伟达官方提供的cuda示例程序，显示cuda设备信息，供cuda入门使用，简单了解cuda原理。
cuda编程入门示例15
Gone_HuiLin的博客
11-19 456
#include #include #include #include #define BLOCK_SIZE 16 static void HandleError(cudaError_t err, const char *file, int line) { if (err != cudaSuccess) { printf("%s in %s at line %d\n", cuda
CUDA入门示例代码
11-19
cuda入门示例代码
cuda编程学习——第二个cuda程序（官方案例分析）！干货向（二）
出门吃三碗饭的博客
05-18 1422
最近在做三维重建，尤其是Nerf方面多视角合成工作的时候，意识到了cuda的编程计算可以大大提高其中渲染的计算，最明显的例子是Instant-ngp，Plenoxels等文章，因此后面会学Cuda一段时间，同时也就开了这个新坑。因为笔者也是cuda新手，所以大家有问题的话可以评论区指出，一起学习进步！
cuda小例子
10-14
通过thrust库对n卡在上层并行。请用nvcc 编译，cu代码同c代码。
CUDA by example （中文：GPU高性能编程CUDA实战）代码实例
08-28
CUDA by example代码实例
GPU-4CUDA编程实例
10-30
根据需要使用正确的存储器，减少对GPU片 外的显存的读取，提高计算密集度。编写调试，实现算法功能，验证结果的准 确性。从各个方面进行优化，提高执行单元利用 率，尽可能隐藏访存延时。实现流操作，协调与CPU的操作，编写CPU 调用接口，实现节点内多GPU并行和集群中 多节点并行。
CUDA 入门小例子，简单实用，上手快，了解CUDA程序的框架
03-09
CUDA 入门小例子，简单实用，上手快，了解CUDA程序的框架，迅速入门
CUDA典型例子
11-18
典型cuda编程实例，可以看看，适合cuda编程爱好者
QT CUDA编程 教程 实例.pdf
11-04
适用于VS cuda编程移植至Qtcreator，以及使用qt 编写cuda程序的初学者
cuda程序设计讲解及实例讲解
03-11
本ppt详细介绍了cuda的基本理论以及cuda的编程模型，多线程和硬件结构，并通过几个案例讲解了cuda的基本应用。
cuda 编程--图像边缘检测的实现.docx
12-22
cuda 编程--图像边缘检测的实现
CUDA By Example(三)——CUDA C并行编程
hhhcbw的博客，欢迎各位来访
11-09 1150
CUDA C并行编程，主要通过矢量求和与Julia集的绘制进行说明。以及对编译运行代码过程中遇到的问题及解决方案进行说明
cuda编程 经典教材
最新发布
07-30
《CUDA 编程： GPU 高性能并行计算经典教材》是一本广泛被认可的权威教材，涵盖了 CUDA 编程的重要概念、原理和技术。该书针对使用 NVIDIA GPU 进行并行计算的开发人员和学习者提供了深入的指导和实践经验。 首先，该教材从基础开始，介绍了 CUDA 编程的基本概念和体系结构，包括并行计算模型、线程和块的概念以及内存模型等。这为读者打下了坚实的基础，使他们能够理解并应用 CUDA 的核心原理。 其次，该教材详细介绍了 CUDA 编程的各个环节，包括在 GPU 上设置和管理线程、优化并行性能以及处理复杂数据结构等。通过深入讲解 CUDA 编程中的关键技术和技巧，读者能够更好地理解如何有效地利用 GPU 并行计算的优势。 此外，该教材还提供了丰富的实例和案例，涵盖了广泛的应用领域，如图像处理、机器学习和科学计算等。这些实例不仅有助于读者将理论知识转化为实际应用，还展示了 CUDA 编程在不同领域中的灵活性和高效性。 最后，该教材还介绍了 CUDA 并行计算的最新发展和趋势，如 CUDA C++、GPU 云计算和深度学习等。通过了解这些最新进展，读者能够跟随技术的发展潮流，进一步拓展自己的知识和技能。 综上所述，《CUDA 编程： GPU 高性能并行计算经典教材》作为一本经典教材，全面而详细地介绍了 CUDA 编程的各个方面，既适合初学者入门，也适合有一定经验的开发人员进一步提升技术水平。无论是对于学习 CUDA 编程的人员，还是对于进行 GPU 高性能并行计算的开发者来说，这本教材都是一本不可多得的宝贵资料。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值