内核原子变量_pstl1strm-优快云博客

本文链接：https://blog.youkuaiyun.com/congchp/article/details/146864765

原子变量的作用

原子变量用来实现对整数的互斥访问，通常用来实现计数器。

例如，我们写一行代码把变量a加1，编译器会把代码编译成3条汇编指令。

（1）把变量a从内存加载到寄存器。

（2）把寄存器的值加1。

（3）把寄存器的值写回内存。

在单处理器系统中，如果进程1和进程2都执行把变量a加1的操作，可能出现下面的执行顺序:

预期结果是进程1和进程2执行完以后变量a的值加，但是因为在进程1把变量a的新值写回内存之前，进程调度器调度进程2，进程2从内存读取变量a的旧值，导致进程1和进程2执行完以后变量a的值实际只增加了1。

在多处理器系统中，如果处理器1和处理器2都执行把变量a加1的操作，可能出现下面的执行顺序:

预期结果是处理器1和处理器2执行完以后变量a的值加2，但是因为在处理器1把变量a的新值写回内存之前，处理器2从内存读取变量a的旧值，导致处理器1和处理器2执行完以后变量a的值实际只增加了1。

原子变量可以解决这种问题,使3个操作成为一个原子操作。

原子变量类型及使用方法

原子变量类型

内核定义了3种原子变量。

(1)整数原子变量,数据类型是atomic_t。

typedef struct {
	int counter;
} atomic_t;

(2)长整数原子变量,数据类型是atomic_long_t。

(3)64位整数原子变量,数据类型是atomic64_t。

整数原子变量使用方法

初始化方法

静态初始化：
- 可以使用 ATOMIC_INIT(i) 宏在编译时初始化 atomic_t 变量。
- 其中 i 是初始整数值。
- 例如：atomic_t my_atomic = ATOMIC_INIT(10);
动态初始化：
- 可以使用 atomic_set(v, i) 函数在运行时初始化 atomic_t 变量。
- 其中 v 是指向 atomic_t 变量的指针，i 是初始整数值。
- 例如：

atomic_t my_atomic;
atomic_set(&my_atomic, 20);

常用操作函数

atomic_read(v)：读取原子变量v的值。
atomic_inc(v)：把原子变量v的值加上1。
atomic_dec(v)：把原子变量v的值减去1。
atomic_add(i, v)：把原子变量v的值加上i。
atomic_sub(i, v)：把原子变量v的减去上i。
atomic_cmpxchg(v, old, new)：原子比较并交换。如果原子变量v的值等于old,那么把原子变量v的值设置为new。返回值总是原子变量v的旧值。

注意事项

使用 atomic_t 时，必须使用其提供的原子操作函数，以确保并发访问安全。
原子操作通常比普通操作慢，因此应谨慎使用。

ARM64处理器的原子变量实现

原子变量的实现是基于处理器指令支持的。在ARM64架构中，ldxr（Load Exclusive Register）和stxr（Store Exclusive Register）是一对用于实现原子操作的指令。它们通常一起使用，用于在多核或多线程环境中确保对共享内存的原子访问。

ARM64 `ldxr`和`stxr`指令

ldxr和stxr指令是ARM64架构中实现无锁（lock-free）原子操作的基础。

`ldxr`（Load Exclusive Register）

ldxr <Wt>, [<Xn|SP>{, #0}]

功能：
- 从内存中加载一个32位的值到寄存器<Wt>，并标记该内存地址为“独占访问”。
- 独占访问标记是硬件级别的，表示当前核心正在独占访问该内存地址。
参数：
- <Wt>：目标寄存器，用于存储从内存中加载的值。Wt表示32位寄存器（如w0、w1等）。
- [<Xn|SP>{, #0}]：内存地址。Xn或SP表示基址寄存器（64位寄存器或栈指针），#0是可选的偏移量（通常为0）。
行为：
- 从内存地址[Xn + #0]加载32位值到寄存器<Wt>。
- 硬件会标记该内存地址为“独占访问”，表示当前核心正在独占访问该地址。
示例：

ldxr w0, [x1]

- <font style="color:rgb(64, 64, 64);">从内存地址</font>`<font style="color:rgb(64, 64, 64);">[x1]</font>`<font style="color:rgb(64, 64, 64);">加载32位值到寄存器</font>`<font style="color:rgb(64, 64, 64);">w0</font>`<font style="color:rgb(64, 64, 64);">，并标记该地址为独占访问。</font>

`stxr`（Store Exclusive Register）

stxr <Ws>, <Wt>, [<Xn|SP>{, #0}]

功能：
- 尝试将寄存器<Wt>中的32位值存储到内存地址[Xn + #0]。
- 如果存储成功（即内存地址仍然被当前核心独占访问），则返回0；否则返回1。
参数：
- <Ws>：状态寄存器，用于存储存储操作的结果（0表示成功，1表示失败）。Ws表示32位寄存器（如w2、w3等）。
- <Wt>：源寄存器，存储要写入内存的值。
- [<Xn|SP>{, #0}]：内存地址。Xn或SP表示基址寄存器（64位寄存器或栈指针），#0是可选的偏移量（通常为0）。
行为：
- 检查内存地址[Xn + #0]是否仍然被当前核心独占访问。
 - 如果是，则将<Wt>的值存储到内存地址，并返回0。
 - 如果不是，则不存储值，并返回1。
- 无论存储是否成功，都会清除该内存地址的独占访问标记。
示例：

stxr w2, w0, [x1]

- <font style="color:rgb(64, 64, 64);">尝试将寄存器</font>`<font style="color:rgb(64, 64, 64);">w0</font>`<font style="color:rgb(64, 64, 64);">的值存储到内存地址</font>`<font style="color:rgb(64, 64, 64);">[x1]</font>`<font style="color:rgb(64, 64, 64);">。</font>
- <font style="color:rgb(64, 64, 64);">如果存储成功，</font>`<font style="color:rgb(64, 64, 64);">w2</font>`<font style="color:rgb(64, 64, 64);">被设置为0；否则</font>`<font style="color:rgb(64, 64, 64);">w2</font>`<font style="color:rgb(64, 64, 64);">被设置为1</font><font style="color:rgb(64, 64, 64);">。</font>

独占访问机制

独占标记：
- 每个CPU核心都有一个本地独占监视器（Local Exclusive Monitor），用于跟踪该核心的独占访问。
- 当执行ldxr时，硬件会标记该内存地址为“独占访问”。
- 当执行stxr时，硬件会检查该内存地址是否仍然被当前核心独占访问。
独占标记的清除：
- 如果其他核心修改了该内存地址，或者执行了ldxr，独占标记会被清除。
- 如果独占标记被清除，stxr会失败，并返回1。

arm64架构`atomic_add(i, v)`实现

ATOMIC_OP是一个宏定义，作用是生成一个通用的原子操作函数，通过传入不同的操作符（如add、sub等）和对应的汇编指令（如add、sub等），可以生成不同的原子操作函数。

#define ATOMIC_OP(op, asm_op)						\
__LL_SC_INLINE void							\
__LL_SC_PREFIX(atomic_##op(int i, atomic_t *v))				\
{									\
	unsigned long tmp;						\
	int result;							\
									\
	asm volatile("// atomic_" #op "\n"				\
"	prfm	pstl1strm, %2\n"					\
"1:	ldxr	%w0, %2\n"						\
"	" #asm_op "	%w0, %w0, %w3\n"				\
"	stxr	%w1, %w0, %2\n"						\
"	cbnz	%w1, 1b"						\
	: "=&r" (result), "=&r" (tmp), "+Q" (v->counter)		\
	: "Ir" (i));							\
}

宏定义解析

**ATOMIC_OP(op, asm_op)**：
- 这是一个宏定义，接受两个参数：op（操作名称，如add）和asm_op（对应的汇编指令，如add）。
- 宏的作用是生成一个原子操作函数。
**__LL_SC_INLINE**：
- 这是一个内联函数声明，表示生成的函数是内联的，以减少函数调用的开销。
**__LL_SC_PREFIX(atomic_##op(int i, atomic_t *v))**：
- 这是函数声明部分，atomic_##op会被替换为具体的函数名，例如atomic_add。
- 函数接受两个参数：一个整数i和一个指向atomic_t类型的指针v。
**asm volatile**：
- 这是内联汇编块，用于执行实际的原子操作。
- volatile关键字告诉编译器不要优化这段汇编代码。
**prfm pstl1strm, %2**：
- 这是一个预取指令，用于将内存数据预取到缓存中，以提高性能。
- %2表示第二个操作数（即v->counter）。
**1: ldxr %w0, %2**：
- ldxr是独占加载指令，将v->counter的值加载到result寄存器（%w0），并标记该内存地址为独占访问。
**#asm_op %w0, %w0, %w3**：
- 这是一个占位符，表示具体的操作指令（如add）。
- %w0是目标寄存器（result），%w3是源操作数（即i）。
**stxr %w1, %w0, %2**：
- stxr是独占存储指令，尝试将result的值存储回v->counter。
- 该指令会检测当前CPU核心对于该地址的独占访问标记是否存在；如果不存在，则该指令执行失败。
- %w1是存储操作的返回值（tmp），%w0是要存储的值，%2是内存地址（即v->counter）。
**cbnz %w1, 1b**：
- cbnz是条件分支指令，如果%w1不为零（即存储失败），则跳转到标签1处重新执行加载和存储操作。
输出和输入操作数：
- : "=&r" (result), "=&r" (tmp), "+Q" (v->counter)：
 - result和tmp是输出操作数，分别表示操作结果和临时变量。
 - v->counter是输入输出操作数，表示原子变量的值。
- : "Ir" (i)：
 - i是输入操作数，表示要操作的整数值。

prfm pstl1strm

`prfm` (Prefetch Memory)

prfm 指令用于预取数据到缓存的特定层级，以减少加载延迟。
它的作用是 提前将内存中的数据取入 CPU 缓存，从而加快后续的访问速度。

`pstl1strm`

pstl1strm 由 pstl1 和 strm 组合而成：

pst（Prefetch for Store）：表示预取用于存储（store）。
l1（Level 1 Cache）：表示预取到 L1 级缓存。
strm（Streaming）：表示以 流式（streaming）模式 进行预取，意味着数据只会短暂存留在缓存，并尽可能避免影响现有缓存行。

展开为`atomic_add`

如果将ATOMIC_OP宏展开为atomic_add，代码如下：

__LL_SC_INLINE void
__LL_SC_PREFIX(atomic_add(int i, atomic_t *v))
{
    unsigned long tmp;
    int result;

    asm volatile("// atomic_add\n"
                 "   prfm    pstl1strm, %2\n"
                 "1: ldxr    %w0, %2\n"
                 "   add     %w0, %w0, %w3\n"
                 "   stxr    %w1, %w0, %2\n"
                 "   cbnz    %w1, 1b"
                 : "=&r" (result), "=&r" (tmp), "+Q" (v->counter)
                 : "Ir" (i));
}
__LL_SC_EXPORT(atomic_add);

函数名：
- atomic_add：表示这是一个原子加法操作。
参数：
- int i：要加的值。
- atomic_t *v：指向原子变量的指针。
汇编代码：
- prfm pstl1strm, %2：预取v->counter到缓存。
- ldxr %w0, %2：独占加载v->counter的值到result寄存器。
- add %w0, %w0, %w3：将result加上i。
- stxr %w1, %w0, %2：尝试将result存储回v->counter。
- cbnz %w1, 1b：如果存储失败（tmp != 0），跳转到标签1重新执行。
输出和输入操作数：
- result：存储add结果。
- tmp：存储stxr的返回值（0表示成功，1表示失败）。
- v->counter：原子变量的值。
- i：要加的值。

使用`stadd`实现的`atomic_add`

在非常大的系统中，处理器很多，竟争很激烈，使用独占加载指令和独占存储指令可能需要重试很多次才能成功，性能很差。ARMV8.1标准实现了大系统扩展(Large System Extensions, LSE)，专门设计了原子指令，提供了原子加法指令stadd:首先从内存加载32位或64位数据到寄存器中，然后把寄存器加上指定值，把结果写回内存。

使用原子加法指令stadd实现的atomic_add(i, v)如下：

static inline void atomic_add(int i, atomic_t *v)
{
    register int w0 asm ("w0") = i;
    register atomic_t *x1 asm ("x1") = v;

    asm volatile(
        "   stadd   %w[i], %[v]\n"  // 使用stadd指令实现原子加法
        : [i] "+r" (w0), [v] "+Q" (v->counter)
        : "r" (x1)
        : __LL_SC_CLOBBERS
    );
}

原子变量和互斥锁比较

特性	原子变量（Atomic Variables）	互斥锁（Mutex）
操作粒度	通常作用于单个变量，适用于简单操作	可以保护较大的代码块或多个变量
阻塞性	无阻塞，除非存储失败需要重试	阻塞，当锁被占用时请求线程会等待
性能	高效，直接利用硬件指令	较低，涉及内核调度和上下文切换
适用场景	简单、频繁的操作，如计数器递增或递减	保护复杂的操作或多个变量的一致性
功能扩展	通常用于简单的读-改-写操作	提供优先级继承等高级功能，适合实时系统

原子变量的使用场景

选择原子变量：当需要对单个变量执行简单、频繁的操作时，原子变量是更高效的选择。例如，计数器的递增或递减操作。
避免滥用原子变量：虽然原子变量高效，但它们只能处理简单的操作。对于复杂的逻辑，使用互斥锁等机制更为合适。

用户空间原子变量

在Linux用户空间中，原子变量和原子操作是实现高效并发控制的重要工具。它们通过硬件指令和标准化的接口，确保了多线程环境下的数据一致性和正确性。

Linux用户空间中的原子变量和原子操作通过硬件指令和标准化的接口实现，提供了高效、无阻塞的并发控制机制。它们适用于简单、频繁的操作，如计数器递增、无锁数据结构等场景。然而，对于复杂的操作或需要保护多个变量的场景，互斥锁或其他同步机制可能是更合适的选择。

通过合理选择和使用原子操作，可以在用户空间中实现高效的并发程序，避免竞态条件和数据不一致的问题，从而提高程序的正确性和性能。

Linux用户空间中的原子操作实现

在Linux用户空间中，实现原子操作的主要方式包括：

硬件提供的原子指令：现代处理器架构（如x86、ARM）提供了原子操作指令。这些指令可以在用户空间中直接使用，以实现原子操作。例如，x86架构中的LOCK前缀指令，ARM架构中的ldxr和stxr指令。
C11标准中的原子类型和操作：C11标准引入了<stdatomic.h>头文件，提供了对原子类型的定义和原子操作的函数。这些函数利用底层硬件的原子指令实现，可以在用户空间中使用。例如：


#include <stdatomic.h>

atomic_int counter = ATOMIC_VAR_INIT(0);

// 原子递增
atomic_fetch_add(&counter, 1);

GCC扩展：GCC编译器提供了一些扩展，如__sync_前缀的函数，用于实现原子操作。这些函数在不同平台上可能有不同的实现，但在用户空间中可以用来实现原子操作。例如：

int counter = 0;

// 原子递增
__sync_fetch_and_add(&counter, 1);

pthread库中的原子操作：在某些情况下，pthread库也提供了原子操作的接口，供用户空间程序使用。

使用C11原子类型和操作

C11标准中的<stdatomic.h>头文件提供了丰富的原子操作接口。这些接口简化了原子操作的使用，使得开发者无需深入了解底层硬件细节即可实现高效的并发控制。

示例代码：

#include <stdatomic.h>
#include <pthread.h>
#include <stdio.h>

atomic_int counter = ATOMIC_VAR_INIT(0);

void* thread_function(void* arg) {
    int i;
    for (i = 0; i < 100000; ++i) {
        atomic_fetch_add(&counter, 1);
    }
    return NULL;
}

int main() {
    pthread_t threads[4];
    for (int j = 0; j < 4; ++j) {
        pthread_create(&threads[j], NULL, thread_function, NULL);
    }
    for (int j = 0; j < 4; ++j) {
        pthread_join(threads[j], NULL);
    }
    printf("Counter value: %d\n", atomic_load(&counter));
    return 0;
}

在这个示例中，四个线程同时对同一个计数器进行递增操作。由于使用了原子操作，计数器的值最终会准确地达到400,000（每个线程递增100,000次，共四个线程）。

`sig_atomic_t`

sig_atomic_t 是C标准库中定义的一种数据类型，专门用于在信号处理程序（signal handler）中安全地访问变量。它的设计目的是确保在信号处理程序和程序的其他部分之间共享的变量能够被原子地访问，从而避免竞争条件（race condition）。

虽然sig_atomic_t 设计的主要目的是在信号处理程序中使用，但也可以在普通函数中使用，而不仅限于信号处理函数。

※ sig_atomic_t 的原子性只适用于于读写和赋值，对于符合操作如++``--，它是没有原子性的。

使用GCC扩展实现原子操作

GCC编译器提供了__sync_前缀的原子操作函数，这些函数在不同平台上会有不同的实现，但在用户空间中可以用来实现原子操作。

示例代码：

#include <stdio.h>
#include <pthread.h>

int counter = 0;

void* thread_function(void* arg) {
    int i;
    for (i = 0; i < 100000; ++i) {
        __sync_fetch_and_add(&counter, 1);
    }
    return NULL;
}

int main() {
    pthread_t threads[4];
    for (int j = 0; j < 4; ++j) {
        pthread_create(&threads[j], NULL, thread_function, NULL);
    }
    for (int j = 0; j < 4; ++j) {
        pthread_join(threads[j], NULL);
    }
    printf("Counter value: %d\n", counter);
    return 0;
}