基本原理说明
在 x86 和 ARM 架构上，原子操作通常利用硬件提供的原子指令来实现，比如 LOCK 前缀（x86）或 LDREX/STREX（ARM）。以下是一些关键的原子操作（例如原子递增和比较交换）的汇编实现。
1. x86 架构的原子操作
（1）原子递增
x86 的 LOCK 前缀可以用来保证指令在多核处理器上的原子性。例如原子递增操作：
实现原子递增
global atomic_increment
section .text
atomic_increment:
mov eax, 1 ; 设置递增值为 1
lock xadd [rdi], eax ; 对地址 rdi 所指向的变量执行原子加操作
add rax, 1 ; xadd 返回的是原值，rax = 原值 + 1
ret
解释：
LOCK XADD [rdi], eax：对rdi指向的地址执行原子加操作，将原值存入eax，并把eax加上后写回rdi。- 使用
LOCK前缀可以保证多核环境下的原子性。
（2）比较并交换（CAS）
x86 提供了 CMPXCHG 指令，可以用来实现原子的比较并交换（CAS）。
实现原子 CAS
global atomic_compare_exchange
section .text
atomic_compare_exchange:
mov rax, rsi ; 将期望值放入 rax
lock cmpxchg [rdi], rdx ; 如果 [rdi] 的值等于 rax（期望值），将 rdx 写入 [rdi]
ret
参数说明：
rdi：目标地址。rsi：期望值。rdx：需要交换的值。
解释：
LOCK CMPXCHG [rdi], rdx：- 如果
[rdi]的值等于RAX，则将rdx写入[rdi]。 - 否则将
[rdi]的当前值写入RAX。
- 如果
- 返回值：
RAX中存储的是rdi的旧值，调用者可以根据是否等于rsi判断交换是否成功。
2. ARM 架构的原子操作
ARM 使用 LDREX/STREX 指令对原子操作进行支持。这是一种 负载-存储排他模型，可以保证在加载到存储之间没有其他线程或进程修改目标变量。
（1）原子递增
在 ARM 架构下，使用 LDREX/STREX 实现原子递增：
实现原子递增
.global atomic_increment
atomic_increment:
mov r1, #1 ; 将 1 存入 r1（递增值）
1:
ldrex r0, [r0] ; 使用 LDREX 加载 [r0] 的值到 r0
add r0, r0, r1 ; r0 = r0 + 1
strex r2, r0, [r0] ; 尝试将 r0 写回 [r0]，如果成功 r2 = 0
cmp r2, #0 ; 检查写入是否成功
bne 1b ; 如果不成功，重试
dmb ; 数据内存屏障，确保操作完成
bx lr
解释：
LDREX：加载目标地址的值，同时标记为“独占”访问。STREX：尝试存储值到目标地址，如果目标地址在此期间被其他核修改，存储操作会失败，返回非 0。- 使用循环保证操作成功。
（2）比较并交换（CAS）
实现原子 CAS
.global atomic_compare_exchange
atomic_compare_exchange:
ldrex r0, [r1] ; 从地址 r1 加载值到 r0（旧值）
cmp r0, r2 ; 比较 r0 和 r2（期望值）
bne 1f ; 如果不相等，跳转到 1f，返回旧值
strex r3, r3, [r1] ; 尝试将 r3 写入 [r1]，如果成功 r3 = 0
cmp r3, #0 ; 检查是否存储成功
bne atomic_compare_exchange ; 如果失败，重新尝试
1:
dmb ; 数据内存屏障，保证一致性
bx lr
参数说明：
r1：目标地址。r2：期望值。r3：要交换的值。
解释：
- 如果
LDREX加载的值与期望值（r2）相等，则尝试存储r3。 - 如果存储失败，则重复尝试。
- 成功后返回原值。
3. 汇编操作的注意事项
- x86 的强内存模型：
- x86 硬件有一个相对强的内存序，很多情况下
LOCK前缀可以满足原子操作需求。
- x86 硬件有一个相对强的内存序，很多情况下
- ARM 的弱内存模型：
- ARM 是弱内存模型，使用
LDREX/STREX操作时，通常需要内存屏障（如DMB）来确保指令顺序和数据同步。
- ARM 是弱内存模型，使用
- 重试机制：
- 对于 ARM 的
LDREX/STREX模式，如果存储失败需要通过循环重试。
- 对于 ARM 的
- 指令可用性：
- 需要确保目标平台支持这些指令。比如
CMPXCHG在早期的 x86 处理器（如 80386）上不可用。
- 需要确保目标平台支持这些指令。比如
4. 比较总结
| 操作 | x86 | ARM |
|---|---|---|
| 原子递增 | LOCK XADD | LDREX + ADD + STREX |
| 原子比较交换 | LOCK CMPXCHG | LDREX + CMP + STREX |
| 内存屏障 | MFENCE（可选） | DMB |
x86 汇编通常较为简单，因为其强内存序模型降低了编程复杂性；ARM 则需要更明确的同步和屏障操作。
代码实现
my_atomic.h
#include <stdint.h>
#include <stdio.h>
// 平台区分
#if defined(__x86_64__)
#define ATOMIC_X86
#elif defined(__aarch64__)
#define ATOMIC_ARM
#else
#error "Unsupported platform"
#endif
// ===================== x86 实现 =====================
#ifdef ATOMIC_X86
// 原子递增
static inline int atomic_increment(int *addr) {
int result;
__asm__ __volatile__(
"lock xaddl %0, %1"
: "=r"(result), "+m"(*addr)
: "0"(1)
: "memory"
);
return result + 1; // 返回递增后的值
}
// 原子递减
static inline int atomic_decrement(int *addr) {
int result;
__asm__ __volatile__(
"lock xaddl %0, %1"
: "=r"(result), "+m"(*addr)
: "0"(-1) // 减 1
: "memory"
);
return result - 1; // 返回递减后的值
}
// 原子比较交换
static inline int atomic_compare_exchange(int *addr, int expected, int desired) {
int old;
__asm__ __volatile__(
"lock cmpxchgl %2, %1"
: "=a"(old), "+m"(*addr)
: "r"(desired), "0"(expected)
: "memory"
);
return old; // 返回旧值
}
// 原子读取
static inline int atomic_load(int *addr) {
int value;
__asm__ __volatile__(
"movl %1, %0"
: "=r"(value)
: "m"(*addr)
: "memory"
);
return value; // 返回读取值
}
#endif // ATOMIC_X86
// ===================== ARM 实现 =====================
#ifdef ATOMIC_ARM
// 原子递增
static inline int atomic_increment(int *addr) {
int old, tmp;
do {
__asm__ __volatile__(
"ldrex %0, [%2] \n" // 读取旧值到 old
"add %1, %0, #1 \n" // tmp = old + 1
"strex %0, %1, [%2] \n" // 尝试写回
: "=&r"(old), "=&r"(tmp)
: "r"(addr)
: "memory", "cc"
);
} while (old != 0); // 如果写失败，重试
return tmp; // 返回递增后的值
}
// 原子递减
static inline int atomic_decrement(int *addr) {
int old, tmp;
do {
__asm__ __volatile__(
"ldrex %0, [%2] \n" // 读取旧值到 old
"sub %1, %0, #1 \n" // tmp = old - 1
"strex %0, %1, [%2] \n" // 尝试写回
: "=&r"(old), "=&r"(tmp)
: "r"(addr)
: "memory", "cc"
);
} while (old != 0); // 如果写失败，重试
return tmp; // 返回递减后的值
}
// 原子比较交换
static inline int atomic_compare_exchange(int *addr, int expected, int desired) {
int old, status;
do {
__asm__ __volatile__(
"ldrex %0, [%2] \n" // 加载到 old
"cmp %0, %3 \n" // 比较 old 和 expected
"bne 1f \n" // 如果不相等，跳转到 1
"strex %1, %4, [%2] \n" // 尝试写回 desired
"1:"
: "=&r"(old), "=&r"(status)
: "r"(addr), "r"(expected), "r"(desired)
: "memory", "cc"
);
} while (status != 0); // 如果写失败，重试
return old; // 返回旧值
}
// 原子读取
static inline int atomic_load(int *addr) {
int value;
__asm__ __volatile__(
"ldrex %0, [%1] \n" // 加载值到 value
: "=&r"(value)
: "r"(addr)
: "memory"
);
return value; // 返回读取值
}
#endif // ATOMIC_ARM
my_atomic_test.c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include "my_atomic.h"
#define NUM_THREADS 4
#define ITERATIONS 1000
volatile int shared_counter = 0; // 全局共享计数器
// 线程函数：执行递增操作
void* thread_increment(void* arg) {
for (int i = 0; i < ITERATIONS; i++) {
atomic_increment((int*)&shared_counter);
}
return NULL;
}
// 线程函数：执行递减操作
void* thread_decrement(void* arg) {
for (int i = 0; i < ITERATIONS; i++) {
atomic_decrement((int*)&shared_counter);
}
return NULL;
}
int main() {
pthread_t threads[NUM_THREADS];
// 创建增量线程
for (int i = 0; i < NUM_THREADS / 2; i++) {
if (pthread_create(&threads[i], NULL, thread_increment, NULL) != 0) {
perror("pthread_create");
exit(EXIT_FAILURE);
}
}
// 创建减量线程
for (int i = NUM_THREADS / 2; i < NUM_THREADS; i++) {
if (pthread_create(&threads[i], NULL, thread_decrement, NULL) != 0) {
perror("pthread_create");
exit(EXIT_FAILURE);
}
}
// 等待所有线程完成
for (int i = 0; i < NUM_THREADS; i++) {
pthread_join(threads[i], NULL);
}
// 最终结果
int final_value = atomic_load((int*)&shared_counter);
printf("最终计数器值: %d\n", final_value);
return 0;
}
ubuntu x86编译运行
$ gcc -pthread -o a.out my_atomic_test.c
$ ./a.out
最终计数器值: 0gitlab.0voice.com
