ARM多核同步原语：LDREX/STREX原理与实践

1. ARM同步原语概述

在嵌入式系统和多核处理器设计中，同步原语是确保共享资源安全访问的基础设施。ARM架构从v6版本开始引入了一套硬件级同步机制，这套机制的核心在于LDREX（Load-Exclusive）和STREX（Store-Exclusive）指令对，它们共同构成了现代ARM处理器上原子操作的基础。

关键提示：从ARMv6架构开始，传统的SWP/SWPB指令已被标记为废弃（deprecated），新设计应完全转向基于独占访问的同步方案。

1.1 同步的必要性

当多个执行单元（处理器核心、线程或进程）需要访问同一共享资源时，会出现三类典型问题：

1. 竞态条件：多个执行单元同时修改数据导致结果不可预测
2. 数据可见性：一个核心的修改可能不会立即被其他核心观察到
3. 执行顺序：处理器和编译器优化可能导致内存访问顺序与代码顺序不一致

在单核系统中，通过禁用中断可以临时解决部分同步问题。但在多核场景下，这种方法完全失效，因为：

• 中断禁用只能影响当前核心
• 长时间禁用中断会导致实时性下降
• 无法解决缓存一致性问题

1.2 ARM同步方案演进

ARM架构的同步支持经历了三个阶段：

2. 独占访问原理与实现

2.1 LDREX/STREX工作机制

这对指令将原子操作分解为两个阶段：

1. LDREX：执行带标记的加载操作

   • 从指定地址加载数据到寄存器
   • 在独占监控器中标记该内存区域
   • 示例：LDREX R1, [R0] 将R0指向的内存值加载到R1

2. STREX：执行条件存储

   • 仅在监控器标记仍存在时执行存储
   • 通过返回值指示成功(0)或失败(1)
   • 示例：STREX R2, R1, [R0] 尝试将R1值存入R0指向地址，结果存入R2

典型使用模式如下：

assembly复制retry:
    LDREX R1, [R0]    ; 加载并标记独占
    ADD R1, R1, #1    ; 修改值
    STREX R2, R1, [R0] ; 尝试存储
    CMP R2, #0        ; 检查是否成功
    BNE retry         ; 失败则重试

2.2 独占监控器体系

ARM架构定义了两种独占监控器：

1. 本地监控器（Local Monitor）

   • 每个核心独立拥有
   • 处理非共享(Non-shareable)内存的独占访问
   • 实现为有限状态机（开放/独占状态）

2. 全局监控器（Global Monitor）

   • 系统级组件，通常位于互连总线上
   • 处理共享(Shareable)内存的独占访问
   • 需要记录处理器ID和地址标签

监控器状态转换规则：

• LDREX使监控器进入独占状态
• 任何其他核心对该地址的存储会使监控器返回开放状态
• 上下文切换必须通过CLREX指令重置监控器

2.3 内存类型与缓存影响

独占访问对内存类型有严格要求：

实践建议：频繁访问的同步变量应放置在Normal内存区域，并确保缓存一致性管理已启用，这可以大幅提升性能。

3. 多核同步实践

3.1 互斥锁实现

以下是完整的互斥锁实现示例，包含低功耗优化：

c复制// 汇编部分
lock_mutex:
    LDR r1, =locked
loop:
    LDREX r2, [r0]      // 加载当前锁状态
    CMP r2, r1          // 检查是否已锁定
    BEQ wait            // 已锁定则等待
    STREX r2, r1, [r0]  // 尝试获取锁
    CMP r2, #0          // 检查是否成功
    BNE loop            // 失败则重试
    DMB                 // 获取锁后的内存屏障
    BX lr
wait:
    WFE                 // 进入低功耗等待
    B loop

unlock_mutex:
    LDR r1, =unlocked
    DMB                 // 释放锁前的内存屏障
    STR r1, [r0]        // 解锁
    SEV                 // 唤醒等待核心
    BX lr

// C接口封装
typedef volatile uint32_t arm_mutex_t;
#define ARM_MUTEX_INIT 0

void arm_lock(arm_mutex_t *mutex) {
    asm volatile(
        "1: LDREX r1, [%0]\n"
        "CMP r1, #1\n"
        "BEQ 2f\n"
        "STREX r1, r1, [%0]\n"
        "CMP r1, #0\n"
        "BNE 1b\n"
        "DMB\n"
        "BX lr\n"
        "2: WFE\n"
        "B 1b" 
        :: "r"(mutex) : "r1", "memory");
}

void arm_unlock(arm_mutex_t *mutex) {
    asm volatile(
        "DMB\n"
        "MOV r1, #0\n"
        "STR r1, [%0]\n"
        "SEV" 
        :: "r"(mutex) : "r1", "memory");
}

关键实现细节：

1. 采用WFE/SEV实现低功耗等待
2. 严格的内存屏障保证操作顺序
3. 双重检查避免不必要的唤醒
4. 内联汇编确保指令顺序不被优化

3.2 信号量实现

计数信号量的增强实现方案：

c复制struct arm_semaphore {
    volatile int32_t count;
    volatile uint32_t waiters;
};

void sem_down(struct arm_semaphore *sem) {
    int32_t old;
    do {
        LDREX old, [sem->count]
        if (old <= 0) {
            atomic_inc(sem->waiters);
            WFE();
            atomic_dec(sem->waiters);
            continue;
        }
        new = old - 1;
    } while (STREX new, [sem->count] != 0);
    DMB();
}

void sem_up(struct arm_semaphore *sem) {
    int32_t old;
    do {
        LDREX old, [sem->count]
        new = old + 1;
    } while (STREX new, [sem->count] != 0);
    
    DMB();
    if (old < 0 || sem->waiters > 0) {
        SEV();
    }
}

优化点分析：

1. 等待者计数避免无效唤醒
2. 条件发送事件（仅当有必要时）
3. 宽松的内存排序策略（根据场景选择）
4. 双字对齐避免假共享

4. 高级优化技术

4.1 独占保留粒度（ERG）

ERG定义了监控器能跟踪的最小内存区域，典型值为64-128字节。这导致：

1. 假共享问题：同一ERG内的不同变量会相互干扰
2. 优化策略：
   • 关键同步变量间隔至少ERG大小
   • 高频访问锁放入独立缓存行
   • 结构体填充确保对齐

测试ERG大小的示例代码：

c复制#define TEST_SIZE 256
void detect_erg() {
    volatile uint32_t *area = malloc(TEST_SIZE);
    for (int i=0; i<TEST_SIZE/4; i++) {
        area[i] = 0;
        if (LDREX(&area[0]) && STREX(1, &area[i])) {
            printf("ERG boundary at %d\n", i*4);
            break;
        }
    }
    free(area);
}

4.2 低功耗同步模式

针对不同场景的等待策略选择：

混合策略实现示例：

c复制void smart_wait(int *flag) {
    int retries = 0;
    while (*flag == 0) {
        if (retries++ > SPIN_THRESHOLD) {
            __wfe();  // 长时间等待转低功耗
            retries = 0;
        } else {
            __yield(); // 短时间主动让出
        }
    }
}

4.3 内存屏障使用指南

ARMv7内存屏障指令：

典型使用场景：

1. 锁获取后：DMB保证临界区访问看到最新数据
2. 锁释放前：DMB保证临界区修改已提交
3. 外设操作：DSB确保寄存器写入完成
4. 代码修改：ISB保证新指令被获取

错误示例分析：

c复制// 错误：缺少屏障可能导致乱序
void unsafe_write(int *shared) {
    *shared = 1;      // 可能被重排到锁外
    lock(mutex);
    // 实际临界区代码
    unlock(mutex);
}

// 正确版本
void safe_write(int *shared) {
    lock(mutex);
    dmb();
    *shared = 1;
    dmb();
    unlock(mutex);
}

5. 调试与性能分析

5.1 常见问题排查

1. 死锁场景：

   • 监控器状态丢失（缺失CLREX）
   • 中断上下文中的锁获取
   • 锁顺序不一致

2. 性能问题：

   • 缓存抖动（同步变量频繁失效）
   • 错误共享（无关变量同缓存行）
   • 过度唤醒（不必要的SEV）

3. 调试技巧：

   • 使用ETM跟踪独占操作流
   • 监控全局监控器状态寄存器
   • 统计锁争用情况（PMU事件）

5.2 性能优化指标

关键性能计数器：

优化案例：某4核系统通过以下改动将锁吞吐提升3倍：

1. 将锁变量对齐到独立缓存行
2. 实现指数退避的重试策略
3. 根据负载动态切换等待策略

6. 实际应用建议

1. API设计原则：

   • 提供阻塞/非阻塞双版本接口
   • 区分快速路径和慢速路径
   • 隐藏架构差异（如ARMv6与v7差异）

2. RTOS集成要点：

   • 调度器与同步原语协同
   • 优先级继承协议实现
   • 中断上下文安全处理

3. 安全关键系统：

   • 双重检查关键操作
   • 监控锁持有时间
   • 实现死锁检测机制

在实时控制系统中的典型应用框架：

c复制struct sync_object {
    arm_mutex_t lock;
    uint32_t timestamp;
    int32_t count;
};

void critical_operation(struct sync_object *obj) {
    if (arm_trylock(&obj->lock, 100) != 0) {
        // 超时处理
        log_error("Lock timeout");
        return;
    }
    
    // 临界区操作
    obj->count++;
    obj->timestamp = get_system_tick();
    
    arm_unlock(&obj->lock);
    
    // 非临界区后处理
    if (obj->count > THRESHOLD) {
        trigger_alert();
    }
}

通过合理应用ARM同步原语，开发者可以构建出既高效又可靠的多核嵌入式系统。记住：同步问题的复杂性往往超出预期，务必通过压力测试验证所有边界条件。