CUDA 学习（CUDA实战 第四章）

最新推荐文章于 2024-04-20 10:14:21 发布
最新推荐文章于 2024-04-20 10:14:21 发布
阅读量255 收藏 2
点赞数
分类专栏： CUDA实战 文章标签： 学习 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ygf666/article/details/124831396
版权

1.矢量求和

1.1 CPU


#include <stdio.h>

#define N   10

void add( int *a, int *b, int *c ) {
    int tid = 0;    // this is CPU zero, so we start at zero
    while (tid < N) {
        c[tid] = a[tid] + b[tid];
        tid += 1;   // we have one CPU, so we increment by one
    }
}

int main( void ) {
    int a[N], b[N], c[N];

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

    add( a, b, c );

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

    return 0;
}

输出：
在这里插入图片描述

1.2 GPU


#include <stdio.h>

#define N   10

__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
    cudaMalloc( (void**)&dev_a, N * sizeof(int) ) ;
    cudaMalloc( (void**)&dev_b, N * sizeof(int) ) ;
    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
    cudaMemcpy( dev_a, a, N * sizeof(int),
                              cudaMemcpyHostToDevice  );
    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
    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
    cudaFree( dev_a ) ;
    cudaFree( dev_b ) ;
    cudaFree( dev_c ) ;

    return 0;
}

在这里插入图片描述

1.3 GPU （数据大）


#include <stdio.h>

#define N   (32 * 1024)

__global__ void add( int *a, int *b, int *c ) {
    int tid = blockIdx.x;
    while (tid < N) {
        c[tid] = a[tid] + b[tid];
        tid += gridDim.x;
    }
}

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

    // allocate the memory on the CPU
    a = (int*)malloc( N * sizeof(int) );
    b = (int*)malloc( N * sizeof(int) );
    c = (int*)malloc( N * sizeof(int) );

    // allocate the memory on the GPU
    cudaMalloc( (void**)&dev_a, N * sizeof(int) ) ;
    cudaMalloc( (void**)&dev_b, N * sizeof(int) ) ;
    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] = 2 * i;
    }

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

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

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

    // verify that the GPU did the work we requested
    bool success = true;
    for (int i=0; i<N; i++) {
        if ((a[i] + b[i]) != c[i]) {
            printf( "Error:  %d + %d != %d\n", a[i], b[i], c[i] );
            success = false;
        }
    }
    if (success)    printf( "We did it!\n" );

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

    // free the memory we allocated on the CPU
    free( a );
    free( b );
    free( c );

    return 0;
}

在这里插入图片描述

2. Julia集曲线

2.1 CPU


#include <GL/glut.h>

#define DIM 1000
struct CPUBitmap {
    unsigned char    *pixels;
    int     x, y;
    void    *dataBlock;
    void (*bitmapExit)(void*);

    CPUBitmap( int width, int height, void *d = NULL ) {
        pixels = new unsigned char[width * height * 4];
        x = width;
        y = height;
        dataBlock = d;
    }

    ~CPUBitmap() {
        delete [] pixels;
    }

    unsigned char* get_ptr( void ) const   { return pixels; }
    long image_size( void ) const { return x * y * 4; }

    void display_and_exit( void(*e)(void*) = NULL ) {
        CPUBitmap**   bitmap = get_bitmap_ptr();
        *bitmap = this;
        bitmapExit = e;
        // a bug in the Windows GLUT implementation prevents us from
        // passing zero arguments to glutInit()
        int c=1;
        char* dummy = "";
        glutInit( &c, &dummy );
        glutInitDisplayMode( GLUT_SINGLE | GLUT_RGBA );
        glutInitWindowSize( x, y );
        glutCreateWindow( "bitmap" );
        glutKeyboardFunc(Key);
        glutDisplayFunc(Draw);
        glutMainLoop();
    }

     // static method used for glut callbacks
    static CPUBitmap** get_bitmap_ptr( void ) {
        static CPUBitmap   *gBitmap;
        return &gBitmap;
    }

   // static method used for glut callbacks
    static void Key(unsigned char key, int x, int y) {
        switch (key) {
            case 27:
                CPUBitmap*   bitmap = *(get_bitmap_ptr());
                if (bitmap->dataBlock != NULL && bitmap->bitmapExit != NULL)
                    bitmap->bitmapExit( bitmap->dataBlock );
                exit(0);
        }
    }

    // static method used for glut callbacks
    static void Draw( void ) {
        CPUBitmap*   bitmap = *(get_bitmap_ptr());
        glClearColor( 0.0, 0.0, 0.0, 1.0 );
        glClear( GL_COLOR_BUFFER_BIT );
        glDrawPixels( bitmap->x, bitmap->y, GL_RGBA, GL_UNSIGNED_BYTE, bitmap->pixels );
        glFlush();
    }
};


struct cuComplex {
    float   r;
    float   i;
    cuComplex( float a, float b ) : r(a), i(b)  {}
    float magnitude2( void ) { return r * r + i * i; }
    cuComplex operator*(const cuComplex& a) {
        return cuComplex(r*a.r - i*a.i, i*a.r + r*a.i);
    }
    cuComplex operator+(const cuComplex& a) {
        return cuComplex(r+a.r, i+a.i);
    }
};

int julia( int x, int y ) { 
    const float scale = 1.5;
    float jx = scale * (float)(DIM/2 - x)/(DIM/2);
    float jy = scale * (float)(DIM/2 - y)/(DIM/2);

    cuComplex c(-0.8, 0.156);
    cuComplex a(jx, jy);

    int i = 0;
    for (i=0; i<200; i++) {
        a = a * a + c;
        if (a.magnitude2() > 1000)
            return 0;
    }

    return 1;
}

void kernel( unsigned char *ptr ){
    for (int y=0; y<DIM; y++) {
        for (int x=0; x<DIM; x++) {
            int offset = x + y * DIM;

            int juliaValue = julia( x, y );
            ptr[offset*4 + 0] = 255 * juliaValue;
            ptr[offset*4 + 1] = 0;
            ptr[offset*4 + 2] = 0;
            ptr[offset*4 + 3] = 255;
        }
    }
 }

int main( void ) {
    CPUBitmap bitmap( DIM, DIM );
    unsigned char *ptr = bitmap.get_ptr();

    kernel( ptr );

    bitmap.display_and_exit();
}

编译，运行：
在这里插入图片描述

2.2 GPU

// nvcc julia_gpu.cu -o julia -lglut -lcuda

#include <GL/glut.h>

#ifndef DIM
#define DIM 1000
#endif
struct CPUBitmap {
    unsigned char    *pixels;
    int     x, y;
    void    *dataBlock;
    void (*bitmapExit)(void*);

    CPUBitmap( int width, int height, void *d = NULL ) {
        pixels = new unsigned char[width * height * 4];
        x = width;
        y = height;
        dataBlock = d;
    }

    ~CPUBitmap() {
        delete [] pixels;
    }

    unsigned char* get_ptr( void ) const   { return pixels; }
    long image_size( void ) const { return x * y * 4; }

    void display_and_exit( void(*e)(void*) = NULL ) {
        CPUBitmap**   bitmap = get_bitmap_ptr();
        *bitmap = this;
        bitmapExit = e;
        // a bug in the Windows GLUT implementation prevents us from
        // passing zero arguments to glutInit()
        int c=1;
        char* dummy = "";
        glutInit( &c, &dummy );
        glutInitDisplayMode( GLUT_SINGLE | GLUT_RGBA );
        glutInitWindowSize( x, y );
        glutCreateWindow( "bitmap" );
        glutKeyboardFunc(Key);
        glutDisplayFunc(Draw);
        glutMainLoop();
    }

     // static method used for glut callbacks
    static CPUBitmap** get_bitmap_ptr( void ) {
        static CPUBitmap   *gBitmap;
        return &gBitmap;
    }

   // static method used for glut callbacks
    static void Key(unsigned char key, int x, int y) {
        switch (key) {
            case 27:
                CPUBitmap*   bitmap = *(get_bitmap_ptr());
                if (bitmap->dataBlock != NULL && bitmap->bitmapExit != NULL)
                    bitmap->bitmapExit( bitmap->dataBlock );
                exit(0);
        }
    }

    // static method used for glut callbacks
    static void Draw( void ) {
        CPUBitmap*   bitmap = *(get_bitmap_ptr());
        glClearColor( 0.0, 0.0, 0.0, 1.0 );
        glClear( GL_COLOR_BUFFER_BIT );
        glDrawPixels( bitmap->x, bitmap->y, GL_RGBA, GL_UNSIGNED_BYTE, bitmap->pixels );
        glFlush();
    }
};

struct cuComplex {
    float   r;
    float   i;
    __device__ cuComplex( float a, float b ) : r(a), i(b)  {}
    __device__ float magnitude2( void ) {
        return r * r + i * i;
    }
    __device__ cuComplex operator*(const cuComplex& a) {
        return cuComplex(r*a.r - i*a.i, i*a.r + r*a.i);
    }
    __device__ cuComplex operator+(const cuComplex& a) {
        return cuComplex(r+a.r, i+a.i);
    }
};

__device__ int julia( int x, int y ) {
    const float scale = 1.5;
    float jx = scale * (float)(DIM/2 - x)/(DIM/2);
    float jy = scale * (float)(DIM/2 - y)/(DIM/2);

    cuComplex c(-0.8, 0.156);
    cuComplex a(jx, jy);

    int i = 0;
    for (i=0; i<200; i++) {
        a = a * a + c;
        if (a.magnitude2() > 1000)
            return 0;
    }

    return 1;
}

__global__ void kernel( unsigned char *ptr ) {
    // map from blockIdx to pixel position
    int x = blockIdx.x;
    int y = blockIdx.y;
    int offset = x + y * gridDim.x;

    // now calculate the value at that position
    int juliaValue = julia( x, y );
    ptr[offset*4 + 0] = 255 * juliaValue;
    ptr[offset*4 + 1] = 0;
    ptr[offset*4 + 2] = 0;
    ptr[offset*4 + 3] = 255;
}

// globals needed by the update routine
struct DataBlock {
    unsigned char   *dev_bitmap;
};

int main( void ) {
    DataBlock   data;
    CPUBitmap bitmap( DIM, DIM, &data );
    unsigned char    *dev_bitmap;

    cudaMalloc( (void**)&dev_bitmap, bitmap.image_size() );
    data.dev_bitmap = dev_bitmap;

    dim3 grid(DIM,DIM);
    kernel<<<grid,1>>>(dev_bitmap);

    cudaMemcpy(bitmap.get_ptr(), dev_bitmap, bitmap.image_size(), cudaMemcpyDeviceToHost);
                              
    cudaFree(dev_bitmap);
                              
    bitmap.display_and_exit();
}

编译，运行：
在这里插入图片描述

风尘23187
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
GPU高性能编程CUDA实战—book.h CPUBitmap.h等头文件
04-09
GPU高性能编程CUDA实战—book.h CPUBitmap.h等头文件
深度学习-TensorRT模型部署实战视频课程
09-07
第四部分tensorRT高级：以项目驱动，学习大量具体的项目案例（分类器、目标检测、姿态检测、场景分割、道路分割、深度估计、车道线检测、huggingface、insightface、mmdetection、onnxruntime、openvino），学习针对...
【AI实战】CUDA 编程入门及开源项目代码分享
Zack的博客
11-06 2936
CUDA 编程入门及开源项目代码分享
CUDA_cudaFree_释放Stream_cudaError_t 错误类型码解释
最新发布
惊鸿一博
04-20 789
官方网站 ：CUDA Runtime API :: CUDA Toolkit Documentation 是 CUDA 中用于释放由 或 分配的设备内存的函数。它的参数是一个指向设备内存的指针，用于指示要释放的内存块的起始地址。用法说明如下：参数 是一个指向要释放的设备内存块的指针。这个指针必须是由 、 或类似函数返回的指针，指向通过 CUDA 运行时 API 分配的内存。如果 是 ，则 会忽略并返回 。通常情况下， 应该在不再需要设备内存时被调用，以释放之前通过 CUDA 运行时 API 分配的
CUDA实战教程专栏完整目录
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-15 542
CUDA实战教程专栏完整目录
CPUBitmap的定义
wufenxia的专栏
06-14 3912
/*  * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.  *  * NVIDIA Corporation and its licensors retain all intellectual property and  * proprietary rights in and to this software an
CUDA编程基础与Triton模型部署实践
阿里技术
04-13 3616
本文将结合在阿里智能互联云端模型推理部署方面半年以来的工作学习，对相关的GPU编程与云端模型部署的知识与经验进行总结分享。
深度学习-TensorRT模型部署实战2022
04-11
第四部分tensorRT高级：以项目驱动，学习大量具体的项目案例（分类器、目标检测、姿态检测、场景分割、道路分割、深度估计、车道线检测、huggingface、insightface、mmdetection、onnxruntime、openvino），学习针对...
深度学习-TensorRT模型部署实战
06-16
第四部分tensorRT高级：以项目驱动，学习大量具体的项目案例（分类器、目标检测、姿态检测、场景分割、道路分割、深度估计、车道线检测、huggingface、insightface、mmdetection、onnxruntime、openvino），学习针对...
Win10下在VS2019中配置使用CUDA进行加速的C++项目 （配置.h文件，.dll以及.lib文件等）
weixin_43980331的博客
08-23 3757
在Visual Studio 2019的C/C++项目属性页中，常规（General）选项卡下的“附加包含目录”（Additional Include Directories）是用于指定额外的头文件包含目录的设置。通过在“附加包含目录”中添加路径，可以告诉编译器在这些路径中查找头文件。在项目属性中，将二进制输出目录（通常是“bin”目录）和库文件输出目录（通常是“lib”目录）添加到链接器的附加库目录中，是确保在链接过程中能够正确找到库文件的常见做法。
cpu_bitmap结构体解析
武泗海的博客
04-03 1143
#ifndef __CPU_BITMAP_H__ #define __CPU_BITMAP_H__ #include "gl_helper.h" struct CPUBitmap {     unsigned char    *pixels;     int     x, y;     void    *dataBlock;     void (*bitmapExit
【笔记】【BIOS】CPU Bitmap
NEWLIA 在 CSDN 的博客。
08-17 484
由此可看出，Available Bitmap 的 bit 值为 1 时候，代表启用核心。Disable Bitmap，则是 bit 值为 1 时候，禁用对应核心。再举例，如果只想禁用 4 个核心，转换为 16 进制：F。转换为 16 进制：FF9B7757E7DDDD50。
cuda编程示例_约束编程示例
cumo7370的博客
07-11 345
cuda编程示例 解决计算问题的方法有很多种。 您可以通过尽可能多地计算可能性来“蛮力”解决问题，或者可以采用程序方法并仔细建立影响正确答案的已知因素。 在约束编程中 ，问题被视为对可能是有效解决方案的一系列限制。 此范例可用于有效解决一组问题，这些问题可以转换为变量和约束或表示为数学方程式。 这样，它与约束满足问题（ CSP ）有关。 它使用声明式编程风格来描述具有某些属性的通用模型。 与...
bitmap原理+性能优化实践
u011752195的博客
01-09 2908
bitMap比特图源码分析+原理+工作实践+性能优化
在VS中，CUDA学习过程中CPUBitmap的配置
weixin_42330052的博客
03-25 1483
在VS中，CUDA学习过程中CPUBitmap的配置 在学习GPU高性能编程时，很多例子中都出现了CPUBitmap的变量，CPUBitmap不是CUDA的自带的类型，所以需要进行配置，下面按自己的经历写下配置的整个过程。 首先，下载和书本对应的实例文件，下载地址为： https://developer.download.nvidia.cn/books/cuda-by-example/cuda_b...
E1696 无法打开源文件 “cpu_bitmap.h“
wukuruaCL的博客
11-06 799
做CUDA作业,跑一个范例程序，报错: E1696 无法打开源文件 "cpu_bitmap.h" 解决办法： 下载一个cuda_by_example文件 解压后将cuda_by_example中lib文件夹下的glut32.lib文件和glut64.lib文件复制到 F:\Cuda Projects\cuda_by_example\lib\Win32 和 F:\Cuda Projects\cuda_by_example\lib\x64 （看你的CUDA安装路径） 将cuda_by_examp
【模型加速】CUDA-Pointpillars项目解读(3)
04-02 2352
后处理 接上篇【模型加速】CUDA-Pointpillars项目解读(2)，就PointPillars而言神经网络部分的耗时相对较少，时间消耗主要在后处理部分。PointPillars检测头输出3路信息，分别是类别置信度(cls_prds)，带编码的3D框回归值(box_preds)和方向(dir_cls_preds)。这3路输出信息结合设定的anchors生成真实的预测框(box_preds)和类别置信度(cls_preds)，再送入NMS。解码的过程包虽不复杂，但包含一系列细小的操作。
CUDA编程(二):基本项目建立流程
谢小小XH
09-08 8440
一:新建CUDA项目流程(VS2013下)1.新建项目(file->New->Project)2.在项目列表中可以看见NVIDIA的CUDA项目(前提是你安装了CUDA)选择项目,添加一些必要的信息,自己定义就行 3.项目生生成成功 .cu文件就是跑在GPU上面的文件。文件夹里面是自动生成的一些要依赖的库文件你可以不用管 二:第一个程序:HelloWorld我们通过最基本最经典的HelloWo
cuda编程项目实战
08-19
CUDA编程是针对NVIDIA的GPU进行并行计算的编程模型。您可以在以下地方进行CUDA编程： 1. NVIDIA官方网站：NVIDIA官方网站提供了CUDA的下载和安装指南、编程文档、示例代码等资源。您可以访问[NVIDIA官方网站](https://developer.nvidia.com/cuda-zone)来获取相关信息。 2. CUDA Toolkit：CUDA Toolkit是NVIDIA提供的用于开发CUDA应用程序的软件包。您可以从NVIDIA官方网站下载适合您操作系统的CUDA Toolkit，并按照安装指南进行安装。CUDA Toolkit包含了编译器、库文件、示例代码等工具和资源。 3. CUDA编程环境：一般情况下，您需要在支持CUDA的编程环境中进行CUDA编程。常见的编程语言包括C、C++和Python等。您可以使用常见的

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

风尘23187

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

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

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

打赏作者

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

抵扣说明：

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

余额充值