CUDA中的原子操作

已于 2023-12-26 19:40:06 修改
阅读量1.1k 收藏 21
点赞数 14
CC 4.0 BY-SA版权
文章标签： c++
于 2023-12-26 19:37:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43915090/article/details/135229505

CUDA中的原子操作

原子函数对驻留在全局或共享内存中的一个 32 位或 64 位字执行读-修改-写原子操作。 例如，atomicAdd() 在全局或共享内存中的某个地址读取一个字，向其中加一个数字，然后将结果写回同一地址。 该操作是原子的，因为它保证在不受其他线程干扰的情况下执行。 换句话说，在操作完成之前，没有其他线程可以访问该地址。 原子函数不充当内存栅栏，也不意味着内存操作的同步或排序约束（有关内存栅栏的更多详细信息，请参阅内存栅栏函数）。 原子函数只能在设备函数中使用。

原子函数仅相对于特定集合的线程执行的其他操作是原子的：

  • 系统范围的原子：当前程序中所有线程的原子操作，包括系统中的其他 CPU 和 GPU。 这些以 _system 为后缀，例如 atomicAdd_system。
  • 设备范围的原子：当前程序中所有 CUDA 线程的原子操作，在与当前线程相同的计算设备中执行。 这些没有后缀，只是以操作命名，例如 atomicAdd。
  • Block-wide atomics：当前程序中所有 CUDA 线程的原子操作，在与当前线程相同的线程块中执行。 这些以 _block 为后缀，例如 atomicAdd_block。

在以下示例中，CPU 和 GPU 都以原子方式更新地址 addr 处的整数值

__global__ void mykernel(int *addr) {
  atomicAdd_system(addr, 10);       // only available on devices with compute capability 6.x
}

void foo() {
  int *addr;
  cudaMallocManaged(&addr, 4);
  *addr = 0;

   mykernel<<<...>>>(addr);
   __sync_fetch_and_add(addr, 10);  // CPU atomic operation
}

请注意，任何原子操作都可以基于 atomicCAS()（Compare And Swap）来实现。 例如，用于双精度浮点数的 atomicAdd() 在计算能力低于 6.0 的设备上不可用，但可以按如下方式实现：

#if __CUDA_ARCH__ < 600
__device__ double atomicAdd(double* address, double val)
{
    unsigned long long int* address_as_ull =
                              (unsigned long long int*)address;
    unsigned long long int old = *address_as_ull, assumed;

    do {
        assumed = old;
        old = atomicCAS(address_as_ull, assumed,
                        __double_as_longlong(val +
                               __longlong_as_double(assumed)));

    // Note: uses integer comparison to avoid hang in case of NaN (since NaN != NaN)
    } while (assumed != old);

    return __longlong_as_double(old);
}
#endif

以下设备范围的原子 API 有系统范围和块范围的变体，但以下情况除外：

  • 计算能力低于 6.0 的设备只支持设备范围的原子操作，
  • 计算能力低于 7.2 的 Tegra 设备不支持系统范围的原子操作。

1. Arithmetic Functions

1.1. atomicAdd()

int atomicAdd(int* address, int val);
unsigned int atomicAdd(unsigned int* address,
                       unsigned int val);
unsigned long long int atomicAdd(unsigned long long int* address,
                                 unsigned long long int val);
float atomicAdd(float* address, float val);
double atomicAdd(double* address, double val);
__half2 atomicAdd(__half2 *address, __half2 val);
__half atomicAdd(__half *address, __half val);
__nv_bfloat162 atomicAdd(__nv_bfloat162 *address, __nv_bfloat162 val);
__nv_bfloat16 atomicAdd(__nv_bfloat16 *address, __nv_bfloat16 val);

读取位于全局或共享内存中地址 address 的 16 位、32 位或 64 位字 old，计算 (old + val)，并将结果存储回同一地址的内存中。这三个操作在一个原子事务中执行。该函数返回old。
atomicAdd() 的 32 位浮点版本仅受计算能力 2.x 及更高版本的设备支持。
atomicAdd() 的 64 位浮点版本仅受计算能力 6.x 及更高版本的设备支持。
atomicAdd() 的 32 位 __half2 浮点版本仅受计算能力 6.x 及更高版本的设备支持。 __half2 或 __nv_bfloat162 加法操作的原子性分别保证两个 __half 或 __nv_bfloat16 元素中的每一个；不保证整个 __half2 或 __nv_bfloat162 作为单个 32 位访问是原子的。
atomicAdd() 的 16 位 __half 浮点版本仅受计算能力 7.x 及更高版本的设备支持。
atomicAdd() 的 16 位 __nv_bfloat16 浮点版本仅受计算能力 8.x 及更高版本的设备支持

1.2. atomicSub()

int atomicSub(int* address, int val);
unsigned int atomicSub(unsigned int* address,
                       unsigned int val);

读取位于全局或共享内存中地址address的 32 位字 old，计算 (old - val)，并将结果存储回同一地址的内存中。 这三个操作在一个原子事务中执行。 该函数返回old。

1.3. atomicExch()

int atomicExch(int* address, int val);
unsigned int atomicExch(unsigned int* address,
                        unsigned int val);
unsigned long long int atomicExch(unsigned long long int* address,
                                  unsigned long long int val);
float atomicExch(float* address, float val);

读取位于全局或共享内存中地址address的 32 位或 64 位字 old 并将 val 存储回同一地址的内存中。 这两个操作在一个原子事务中执行。 该函数返回old。

1.4. atomicMin()

int atomicMin(int* address, int val);
unsigned int atomicMin(unsigned int* address,
                       unsigned int val);
unsigned long long int atomicMin(unsigned long long int* address,
                                 unsigned long long int val);
long long int atomicMin(long long int* address,
                                long long int val);

读取位于全局或共享内存中地址address的 32 位或 64 位字 old，计算 old 和 val 的最小值，并将结果存储回同一地址的内存中。 这三个操作在一个原子事务中执行。 该函数返回old。
atomicMin() 的 64 位版本仅受计算能力 3.5 及更高版本的设备支持

1.5. atomicMax()

int atomicMax(int* address, int val);
unsigned int atomicMax(unsigned int* address,
                       unsigned int val);
unsigned long long int atomicMax(unsigned long long int* address,
                                 unsigned long long int val);
long long int atomicMax(long long int* address,
                                 long long int val);

1.7. atomicDec()

unsigned int atomicDec(unsigned int* address,
                       unsigned int val);

读取位于全局或共享内存中地址address的 32 位字 old，计算 (((old == 0) || (old > val)) ? val : (old-1) )，并将结果存储回同一个地址的内存。 这三个操作在一个原子事务中执行。 该函数返回old。

1.8. atomicCAS()

int atomicCAS(int* address, int compare, int val);
unsigned int atomicCAS(unsigned int* address,
                       unsigned int compare,
                       unsigned int val);
unsigned long long int atomicCAS(unsigned long long int* address,
                                 unsigned long long int compare,
                                 unsigned long long int val);
unsigned short int atomicCAS(unsigned short int *address, 
                             unsigned short int compare, 
                             unsigned short int val);

2. Bitwise Functions

2.1. atomicAnd()

int atomicAnd(int* address, int val);
unsigned int atomicAnd(unsigned int* address,
                       unsigned int val);
unsigned long long int atomicAnd(unsigned long long int* address,
                                 unsigned long long int val);

读取位于全局或共享内存中地址address的 32 位或 64 位字 old，计算 (old & val)，并将结果存储回同一地址的内存中。 这三个操作在一个原子事务中执行。 该函数返回old。

2.2. atomicOr()

int atomicOr(int* address, int val);
unsigned int atomicOr(unsigned int* address,
                      unsigned int val);
unsigned long long int atomicOr(unsigned long long int* address,
                                unsigned long long int val);

读取位于全局或共享内存中地址address的 32 位或 64 位字 old，计算 (old | val)，并将结果存储回同一地址的内存中。 这三个操作在一个原子事务中执行。 该函数返回old。

atomicOr() 的 64 位版本仅受计算能力 3.5 及更高版本的设备支持

2.3. atomicXor()

int atomicXor(int* address, int val);
unsigned int atomicXor(unsigned int* address,
                       unsigned int val);
unsigned long long int atomicXor(unsigned long long int* address,
                                 unsigned long long int val);

读取位于全局或共享内存中地址address的 32 位或 64 位字 old，计算 (old ^ val)，并将结果存储回同一地址的内存中。 这三个操作在一个原子事务中执行。 该函数返回old。

atomicXor() 的 64 位版本仅受计算能力 3.5 及更高版本的设备支持

cuda代码中使用原子函数处理小数（附最值和求和代码）
puqian13的博客
04-25 656
cuda代码中重载原子函数，实现小数的处理
CUDA atomic原子操作
weixin_30657999的博客
02-09 2289
CUDA的原子操作可以理解为对一个变量进行“读取-修改-写入”这三个操作的一个最小单位的执行过程，这个执行过程不能够再分解为更小的部分，在它执行过程中，不允许其他并行线程对该变量进行读取和写入的操作。基于这个机制，原子操作实现了对在多个线程间共享的变量的互斥保护，确保任何一次对变量的操作的结果的正确性。 原子操作确保了在多个并行线程间共享的内存的读写保护，每次...
cuda编程笔记（5）--原子操作
最新发布
ouliten的博客
06-27 446
CUDA 中的指能在并发线程中的函数。它们避免了竞态条件（race condition），保证操作的，即多个线程对同一个变量的读-改-写过程不会相互干扰。__device__（即修改之前的值）。常用原子操作函数分类。
CUDA原子操作详解及其适用场景
专注于人工智能领域的小何尚
04-24 2975
CUDA原子操作详解及其适用场景 CUDA中的原子操作本质上是让线程在某个内存单元完成读-修改-写的过程中不被其他线程打扰. 官方的编程手册上是这么说的: “原子函数对驻留在全局或共享内存中的一个 32 位或 64 位字执行读-修改-写原子操作” 举个例子来说, 我有很多线程. 每个线程计算出了一个结果, 我需要把所有的结果加在一起, 如下图所示. 执行到这一步时, 有很多线程想读取X的值, 并加上另一个值. 如果你在你的Kernel程序最后面直接写 x=x+a, 那么当执行到这里的时候, 一个线程在读的
cuda原子操作
IChocolateKapa
02-07 2841
C.1  数学函数C.1.1  atomicAdd() int atomicAdd(int* address, int val); unsigned int atomicAdd(unsigned int* address,                            unsigned int val); unsigned long long int atomicAdd(unsig
Cuda By Example - 13 (原子操作）
dairyman的专栏
11-05 906
通过计算直方图, 以atomicAdd为例,介绍CUDA的原子操作
cuda 原子锁&多线程操作&通用原子操作
Limiao_123的博客
12-15 5879
经历了很多奇奇怪怪的bug，整理一下。先描述要做的事情以及怎么做： 在项目中，空间中有200w+的点，需要映射到一个grid_map的600*600的网格中，落入到同一个格子的点需要进行一些计算获得一个值。对于格子与格子之间是并行的，但格子之中的点需要设计为串行。所以在计算某个格子中的点时，需要将格子的值保护起来，只允许一个线程（点）计算并改变。 这里就用到了cuda的通用原子操作。也许有人会问，cuda提供了一些原子操作函数，能不能直接用呢？cuda提供的原子函数适用于简单的单一变量判断加减，而对于需要复
CUDA基础的基础教程：初探原子操作和CUDA流
limn204的专栏
09-24 947
1.原子操作 熟悉操作系统的读者对与原子操作不会陌生，原子操作代表不可被分割的操作，也就是最小的计算机可执行程序的单元。在CUDA中，也有这样的原子操作,我们使用原子操作之后，会锁定空间，防止其他的进程访问。由于CUDA的超多线程并行运算的特性，我们可以利用CUDA中的原子操作来优化我们的程序。 1.1 CUDA原子操作 CUDA可供使用的原子操作有很多，我们只介绍最基本的一个atomicAdd，...
VS2017 CUDA编程学习8：线程同步-原子操作
DU_YULIN的博客
10-21 1047
文章目录前言1. 原子操作的理解2. C++ CUDA实现原子操作3. 执行结果总结学习资料 VS2017 CUDA编程学习1：CUDA编程两变量加法运算 VS2017 CUDA编程学习2：在GPU上执行线程 VS2017 CUDA编程学习3：CUDA获取设备上属性信息 VS2017 CUDA编程学习4：CUDA并行处理初探 - 向量加法实现 VS2017 CUDA编程学习5：CUDA并行执行-线程 VS2017 CUDA编程学习6: GPU存储器架构 VS2017 CUDA编程学习7：线程同步-共享内存
CUDA原子操作
HinGwenWoong的博客
02-13 1928
CUDA原子操作
CUDA的原子操作
maobin_1的博客
12-09 440
CUDA的原子操作是用于在并行计算中保证多个线程对共享数据进行安全访问的一种机制。由于CUDA允许多个线程同时执行，这可能会导致数据竞争和不一致性，原子操作通过确保某个操作在执行过程中不会被其他线程打断，从而解决这些问题。
cuda 原子操作案例
qq_42812089的博客
01-02 426
让10000 去增加同一个数组元素 #include <stdio.h> #define NUM_THREADS 1000000 #define ARRAY_SIZE 100 #define BLOCK_WIDTH 1000 void print_array(int *array, int size) { printf("{ "); for (int i = 0; i < size; i++) { printf("%d ", array[i]); } pr
CUDA学习之原子操作
deep_love1314的博客
07-09 2222
cuda学习
CUDA原子操作【参加CUDA线上训练营】
Mr_8j的博客
02-09 482
CUDA原子操作及求和计算【参加CUDA线上训练营】
关于CUDA操作中的原子问题
zhbxlm的专栏
04-02 2240
好久不写博客了，慢慢的感觉自己懒散好多，废话不说，看看关于原子操作吧      关于CUDA的书一本接着一本，算来看了好多本，在做CT重建中FDK，也算是有个结果了吧，不过后期优化还没有做，想看看关于CUDA的一些simple，那就从第一个开始吧，结果第一个是关于CUDA的动态并行的，也就是递归调用的，项目名字叫cdpSimplePrint，调试结果分析，发现原子操作的结果并不是自己以前认为的。
CUDA原子操作和规约
07-28
CUDA原子操作和规约是在CUDA编程中常用的技术。原子操作是一种特殊的操作，可以确保多个线程同时访问共享内存时的数据一致性。CUDA提供了多种原子操作函数，如原子加法函数，可以在并行计算中实现线程间的同步和数据的安全更新。\[3\] 规约是一种常见的并行计算技术，用于将一个数组中的元素通过某种操作进行合并，得到一个最终的结果。在CUDA中，规约操作可以用于求和、求最大值、求最小值等。CUDA提供了多种规约算法，如交叉配对规约、交错配对规约、处理两个block数据规约、循环展开等。这些算法可以根据具体的需求选择使用。\[1\] 在CUDA编程中，使用原子操作和规约可以提高并行计算的效率和准确性。然而，需要注意的是，在进行规约操作时，必须确保每个步骤的所有线程是同步的，也就是说，所有线程计算完成之后再进入下一步骤的计算，否则会导致结果错误。\[2\]因此，在编写CUDA程序时，需要仔细考虑线程同步的问题，以确保正确的结果。 #### 引用[.reference_title] - *1* [CUDA----规约](https://blog.csdn.net/UCAS_HMM/article/details/126543251)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [CUDA加速——基于规约思想的数组元素求和](https://blog.csdn.net/shandianfengfan/article/details/120407846)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [CUDA学习(十一):原子操作实现向量内积](https://blog.csdn.net/hjxu2016/article/details/109816989)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值