[CA] 实验深入理解core.cpp -1

#我给你代码，你给我在源代码上额外加上中文注释！，如果是函数告诉我它读取了什么结构，通报了什么值，可能或者已经知道它将在哪些函数使用，是体现了pipeline 的哪一步#

1. #include "core.h"
2. #include "common/logging.h" // 日志模块，用于记录调试信息
3. #include "execute/alu.h"    // ALU（算术逻辑单元）的实现
4. #include "utils.h"          // 常用工具函数的实现
5. #include <cinttypes>        // 包含用于固定宽度整数的头文件
7. LOG_CATEGORY("machine.core"); // 定义日志类别，用于标记属于 machine.core 模块的日志信息
9. using namespace machine;
11. /**
12. * @brief 检查不支持的指令标志
13. *
14. * @param xlen 当前处理器的 xlen 配置（32位或64位）
15. * @param isa_word 配置的 ISA 字符（如 'A' 表示原子操作支持，'M' 表示乘法/除法支持）
16. *
17. * 读取内容：
18. * - `xlen`：表示当前的指令长度（32位或64位）。
19. * - `isa_word`：表示当前支持的 ISA 字符集，例如是否支持 'A'（原子操作）或 'M'（乘法操作）。
20. *
21. * 返回值：
22. * - 一个 `InstructionFlags` 对象，表示需要检查的不支持的指令标志。
23. *
24. * 功能说明：
25. * - 该函数用于检查处理器当前是否支持某些指令集的功能。
26. * - 如果处理器是 32 位（`xlen == Xlen::_32`），则不支持 RV64 指令，标记 `IMF_RV64`。
27. * - 如果 `isa_word` 不包含字符 'A'，则不支持原子操作，标记 `IMF_AMO`。
28. * - 如果 `isa_word` 不包含字符 'M'，则不支持乘法和除法操作，标记 `IMF_MUL`。
29. *
30. * 应用场景：
31. * - 该函数在指令解码或指令执行阶段的异常检查中使用，确保处理器只执行它能够支持的指令。
32. * - 属于处理器流水线的解码（Decode）阶段。
33. */
34. static InstructionFlags unsupported_inst_flags_to_check(Xlen xlen, ConfigIsaWord isa_word) {
35.     // 初始化需要检查的标志，默认值为支持的指令集标志
36.     unsigned flags_to_check = IMF_SUPPORTED;
38.     // 如果当前是 32 位模式，则需要检查 RV64 的标志（32 位模式不支持 RV64 指令）
39.     if (xlen == Xlen::_32)
40.         flags_to_check |= IMF_RV64;
42.     // 如果不支持原子操作（'A'），则添加原子操作的标志到检查列表
43.     if (!isa_word.contains('A'))
44.         flags_to_check |= IMF_AMO;
46.     // 如果不支持乘法/除法操作（'M'），则添加乘法操作的标志到检查列表
47.     if (!isa_word.contains('M'))
48.         flags_to_check |= IMF_MUL;
50.     // 返回需要检查的标志
51.     return InstructionFlags(flags_to_check);
52. }

复制代码

原子操作（Atomic Operation） 是指一种不可中断的操作，它在多个线程或进程之间举行共享资源访问时，可以包管操作的完整性和同等性。在硬件层面上，原子操作是一种特殊的指令集功能，能够确保指令的执行不会受到其他操作的干扰。
在 RISC-V 中，原子操作是由 A 扩展（Atomic Extension）支持的，常见的原子操作指令包罗：
RISC-V 中的原子操作类型

• AMO 指令（Atomic Memory Operations，原子内存操作）：
  
  
  
  • RISC-V 的原子操作重要通过 AMO 指令实现。
    
  • 这些指令会在一次指令中完成以下操作：
    
    
    • 从内存中加载一个值。
      
    • 对加载的值举行修改（例如加法、逻辑操作）。
      
    • 将修改后的值存储回内存。
      
    
    
  
  
• 常见的原子操作指令：
  
  
  
  • AMOADD.W：对 32 位数举行加法操作并写回。
    
  • AMOXOR.W：对 32 位数举行按位异或操作并写回。
    
  • AMOAND.W：对 32 位数举行按位与操作并写回。
    
  • AMOSWAP.W：交换内存中的值和寄存器的值。
    
  • LR/SC（Load Reserved 和 Store Conditional）：
    
    
    
    • LR.W：读取一个内存地址的值，并保存访问的锁定。
      
    • SC.W：仅本地址仍处于锁定状态时，才气乐成写入值。
      
    
    
  
  

 #我给你代码，你给我在源代码上额外加上中文注释！，如果是函数告诉我它读取了什么结构，通报了什么值，可能或者已经知道它将在哪些函数使用，是体现了pipeline 的哪一步#

1. Core::Core(
2.     Registers *regs,                 // 指向寄存器类的指针，用于读写寄存器值
3.     BranchPredictor *predictor,      // 指向分支预测器的指针，用于预测分支目标
4.     FrontendMemory *mem_program,     // 指向程序存储器的指针，用于获取指令
5.     FrontendMemory *mem_data,        // 指向数据存储器的指针，用于加载和存储数据
6.     CSR::ControlState *control_state,// 控制和状态寄存器 (CSR) 的状态指针，用于管理CSR操作
7.     Xlen xlen,                       // 当前处理器的字长，可能是32位或64位
8.     ConfigIsaWord isa_word)          // 处理器支持的指令集架构特性（如支持扩展M、A等）
9.     : pc_if(state.pipeline.pc.final)                // 取指阶段的最终程序计数器 (PC)
10.     , if_id(state.pipeline.fetch.final)             // 取指与解码阶段的流水线寄存器
11.     , id_ex(state.pipeline.decode.final)            // 解码与执行阶段的流水线寄存器
12.     , ex_mem(state.pipeline.execute.final)          // 执行与访存阶段的流水线寄存器
13.     , mem_wb(state.pipeline.memory.final)           // 访存与写回阶段的流水线寄存器
14.     , xlen(xlen)                                    // 设置处理器的字长
15.     , check_inst_flags_val(IMF_SUPPORTED)           // 指令标志位，用于检查支持的指令类型
16.     , check_inst_flags_mask(unsupported_inst_flags_to_check(xlen, isa_word)) // 获取不支持的指令掩码
17.     , regs(regs)                                    // 初始化寄存器的引用
18.     , control_state(control_state)                  // 初始化CSR状态
19.     , predictor(predictor)                          // 初始化分支预测器
20.     , mem_data(mem_data)                            // 初始化数据存储器引用
21.     , mem_program(mem_program)                      // 初始化程序存储器引用
22.     , ex_handlers()                                 // 异常处理器集合初始化为空
23.     , ex_default_handler(new StopExceptionHandler()) { // 设置默认的异常处理器
24.     stop_on_exception.fill(true);                   // 默认情况下，当发生异常时暂停
25.     step_over_exception.fill(true);                 // 默认情况下，异常步骤会被跳过
26.     step_over_exception[EXCAUSE_INT] = false;       // 对中断异常，不跳过步骤
27. }

复制代码

 

1. void Core::step(bool skip_break) {
2.     emit step_started();  // 发出 "step_started" 信号，通知外部开始一个执行周期
3.     state.cycle_count++;  // 增加当前的周期计数
4.     do_step(skip_break);  // 调用私有函数执行一个完整的流水线周期
5.     emit step_done(state); // 发出 "step_done" 信号，通知外部一个周期已完成，同时传递当前状态
6. }
8. /*
9. * 作用：
10. *  - 执行一个流水线周期，可能会跳过断点检查（由 skip_break 决定）。
11. * 读取的结构：
12. *  - `state.cycle_count`：当前周期计数。
13. * 传递的值：
14. *  - `state`：表示处理器当前的状态，包括流水线寄存器、周期计数等信息。
15. * 使用的流水线阶段：
16. *  - 涉及整个流水线的运行，具体由 `do_step()` 实现。
17. */
19. void Core::reset() {
20.     state.cycle_count = 0; // 重置周期计数器
21.     state.stall_count = 0; // 重置停顿计数器
22.     do_reset();            // 调用私有函数完成核心状态的完全复位
23. }
25. /*
26. * 作用：
27. *  - 重置处理器的状态，将周期计数器和停顿计数器清零，并通过 `do_reset()` 重置核心状态。
28. * 读取的结构：
29. *  - `state`：存储处理器的状态信息，包括流水线寄存器、周期计数等。
30. * 传递的值：
31. *  - 无直接传递，但通过 `do_reset()` 重置所有核心状态。
32. * 使用的流水线阶段：
33. *  - 主要影响整个流水线的初始化。
34. */
36. unsigned Core::get_cycle_count() const {
37.     return state.cycle_count;  // 返回当前的周期计数器值
38. }
40. /*
41. * 作用：
42. *  - 提供当前处理器执行的总周期数，用于性能分析。
43. * 读取的结构：
44. *  - `state.cycle_count`：当前的周期计数。
45. * 传递的值：
46. *  - 返回周期计数。
47. * 使用的流水线阶段：
48. *  - 与流水线无直接关系，属于辅助性能指标。
49. */
51. unsigned Core::get_stall_count() const {
52.     return state.stall_count;  // 返回当前的停顿计数器值
53. }
55. /*
56. * 作用：
57. *  - 提供当前处理器流水线停顿的总次数，用于性能分析。
58. * 读取的结构：
59. *  - `state.stall_count`：当前的停顿计数。
60. * 传递的值：
61. *  - 返回停顿计数。
62. * 使用的流水线阶段：
63. *  - 与流水线无直接关系，属于辅助性能指标。
64. */

复制代码

 

1. Registers *Core::get_regs() const {
2.     return regs; // 返回寄存器类的指针
3.     // 作用：获取指向寄存器文件的指针，用于读取或写入寄存器值
4.     // 输入：无
5.     // 输出：返回寄存器类的指针
6.     // 使用场景：其他模块需要操作通用寄存器（例如在指令的译码或写回阶段）。
7.     // 对应流水线阶段：**ID（指令译码阶段）** 和 **WB（写回阶段）**。
8. }
10. CSR::ControlState *Core::get_control_state() const {
11.     return control_state; // 返回 CSR 控制状态的指针
12.     // 作用：获取 CSR（控制和状态寄存器）管理模块，用于操作控制寄存器（例如 MSTATUS、MEPC 等）
13.     // 输入：无
14.     // 输出：返回 CSR 控制状态类的指针
15.     // 使用场景：需要访问或修改 CSR 值的指令（如 ecall 或中断相关操作）
16.     // 对应流水线阶段：**EX（执行阶段）** 或特殊操作时直接使用。
17. }
19. FrontendMemory *Core::get_mem_data() const {
20.     return mem_data; // 返回数据存储器的指针
21.     // 作用：获取用于数据加载和存储的内存接口
22.     // 输入：无
23.     // 输出：返回数据存储器的前端接口指针
24.     // 使用场景：`load/store` 类型指令需要访问数据存储器（DMEM）
25.     // 对应流水线阶段：**MEM（内存访问阶段）**。
26. }
28. FrontendMemory *Core::get_mem_program() const {
29.     return mem_program; // 返回程序存储器的指针
30.     // 作用：获取用于指令加载的内存接口
31.     // 输入：无
32.     // 输出：返回程序存储器的前端接口指针
33.     // 使用场景：`fetch` 阶段需要从程序存储器中加载指令
34.     // 对应流水线阶段：**IF（指令取指阶段）**。
35. }
37. BranchPredictor *Core::get_predictor() const {
38.     return predictor; // 返回分支预测器的指针
39.     // 作用：获取分支预测器模块，用于分支跳转预测
40.     // 输入：无
41.     // 输出：返回分支预测器的指针
42.     // 使用场景：分支指令需要预测下一条指令的地址（如 `beq`, `bne` 等）
43.     // 对应流水线阶段：**EX（执行阶段）**。
44. }
46. const CoreState &Core::get_state() const {
47.     return state; // 返回内核的当前状态（只读）
48.     // 作用：提供对整个内核状态的只读访问接口
49.     // 输入：无
50.     // 输出：返回 `CoreState` 对象的引用
51.     // 使用场景：外部模块需要检查内核当前状态（如当前周期数、流水线寄存器内容等）
52.     // 对应流水线阶段：覆盖所有阶段，反映流水线的整体运行状态。
53. }

复制代码

1. void Core::insert_hwbreak(Address address) {
2.     // 在指定的地址处插入硬件断点
3.     hw_breaks.insert(address, new hwBreak(address));
4.     // 输入：
5.     //  - address: 要插入断点的地址
6.     // 操作：
7.     //  - 使用地址作为键，将一个新的硬件断点对象（hwBreak）插入到 `hw_breaks` 容器中。
8.     //  - `hw_breaks` 是一个管理断点的映射表。
9.     // 输出：
10.     //  - 无直接返回值，但会更新 `hw_breaks` 容器。
11.     // 使用场景：
12.     //  - 调试过程中，当用户设置断点时调用此方法。
13.     // 对应流水线阶段：
14.     //  - **IF（指令取指阶段）**，在取指阶段会检查是否命中断点。
15. }
17. void Core::remove_hwbreak(Address address) {
18.     // 移除指定地址的硬件断点
19.     hwBreak *hwbrk = hw_breaks.take(address);
20.     // 输入：
21.     //  - address: 要移除断点的地址
22.     // 操作：
23.     //  - 从 `hw_breaks` 容器中移除与该地址关联的硬件断点对象。
24.     //  - `take` 方法会返回被移除的断点对象。
25.     //  - 删除返回的断点对象，释放内存。
26.     delete hwbrk;
27.     // 输出：
28.     //  - 无直接返回值，但会更新 `hw_breaks` 容器并释放相关资源。
29.     // 使用场景：
30.     //  - 调试过程中，当用户取消断点时调用此方法。
31.     // 对应流水线阶段：
32.     //  - 无直接关联，只在调试器控制时使用。
33. }
35. bool Core::is_hwbreak(Address address) const {
36.     // 检查指定地址是否存在硬件断点
37.     hwBreak *hwbrk = hw_breaks.value(address);
38.     // 输入：
39.     //  - address: 要检查的地址
40.     // 操作：
41.     //  - 从 `hw_breaks` 容器中查询该地址是否有对应的断点对象。
42.     // 输出：
43.     //  - 返回值为布尔类型：
44.     //      - `true`：地址处有硬件断点。
45.     //      - `false`：地址处无硬件断点。
46.     return hwbrk != nullptr;
47.     // 使用场景：
48.     //  - 在程序运行过程中（如指令取指阶段），检查当前地址是否命中断点。
49.     // 对应流水线阶段：
50.     //  - **IF（指令取指阶段）**，在加载指令时检查是否需要暂停以触发断点。
51. }

复制代码

1. 功能概述：

• 这组方法用于管理硬件断点，允许用户动态插入、移除或查抄断点。
  
• 硬件断点通常用于调试器中，帮助用户暂停程序运行以查抄状态。
  

2. 关键逻辑：

• insert_hwbreak：
  
  
  
  • 动态添加断点，将地址与断点对象关联。
    
  
  
• remove_hwbreak：
  
  
  
  • 移除断点，删除与地址关联的断点对象。
    
  
  
• is_hwbreak：
  
  
  
  • 查抄某地址是否有断点，用于判定是否必要暂停程序执行。
    
  
  

3. 对应流水线阶段：

• 这些函数重要作用于 IF（指令取指阶段）。
  
  
  
  • 在取指阶段，系统会查抄当前指令地址是否命中断点，如果命中则暂停流水线执行。
    
  
  

 

1. void Core::set_stop_on_exception(enum ExceptionCause excause, bool value) {
2.     // 设置指定异常是否会触发程序停止
3.     stop_on_exception[excause] = value;
4.     // 输入：
5.     //  - excause: 异常原因（枚举类型 `ExceptionCause`）。
6.     //  - value: 布尔值，表示是否在该异常发生时停止程序运行。
7.     // 操作：
8.     //  - 更新 `stop_on_exception` 数组中对应异常的布尔值。
9.     // 输出：
10.     //  - 无直接返回值，但修改了 `stop_on_exception` 的值。
11.     // 使用场景：
12.     //  - 调试器可以通过此方法动态控制是否在特定异常触发时暂停程序。
13.     // 对应流水线阶段：
14.     //  - **EX（执行阶段）** 和 **MEM（访存阶段）**。
15.     //    异常通常发生在指令执行或访存阶段，例如非法指令或内存访问越界。
16. }
18. bool Core::get_stop_on_exception(enum ExceptionCause excause) const {
19.     // 检查指定异常是否会触发程序停止
20.     return stop_on_exception[excause];
21.     // 输入：
22.     //  - excause: 异常原因（枚举类型 `ExceptionCause`）。
23.     // 操作：
24.     //  - 查询 `stop_on_exception` 数组中对应异常的布尔值。
25.     // 输出：
26.     //  - 布尔值：
27.     //      - `true`: 异常发生时程序会停止。
28.     //      - `false`: 异常发生时程序不会停止。
29.     // 使用场景：
30.     //  - 调试器或运行时可以动态检查当前对特定异常的处理配置。
31.     // 对应流水线阶段：
32.     //  - 与异常触发阶段相关，通常是 **EX（执行阶段）** 和 **MEM（访存阶段）**。
33. }
35. void Core::set_step_over_exception(enum ExceptionCause excause, bool value) {
36.     // 设置指定异常是否会被跳过
37.     step_over_exception[excause] = value;
38.     // 输入：
39.     //  - excause: 异常原因（枚举类型 `ExceptionCause`）。
40.     //  - value: 布尔值，表示是否在该异常发生时跳过处理。
41.     // 操作：
42.     //  - 更新 `step_over_exception` 数组中对应异常的布尔值。
43.     // 输出：
44.     //  - 无直接返回值，但修改了 `step_over_exception` 的值。
45.     // 使用场景：
46.     //  - 调试器或运行时可以通过此方法动态设置是否跳过特定异常的处理。
47.     // 对应流水线阶段：
48.     //  - 异常处理阶段，通常与 **EX（执行阶段）** 和 **MEM（访存阶段）** 相关。
49. }
51. bool Core::get_step_over_exception(enum ExceptionCause excause) const {
52.     // 检查指定异常是否会被跳过
53.     return step_over_exception[excause];
54.     // 输入：
55.     //  - excause: 异常原因（枚举类型 `ExceptionCause`）。
56.     // 操作：
57.     //  - 查询 `step_over_exception` 数组中对应异常的布尔值。
58.     // 输出：
59.     //  - 布尔值：
60.     //      - `true`: 异常发生时会被跳过。
61.     //      - `false`: 异常发生时不会被跳过。
62.     // 使用场景：
63.     //  - 调试器或运行时可以动态检查是否需要跳过特定异常。
64.     // 对应流水线阶段：
65.     //  - 与异常触发阶段相关，通常是 **EX（执行阶段）** 和 **MEM（访存阶段）**。
66. }

复制代码

1. Xlen Core::get_xlen() const {
2.     // 返回当前核心处理器的 XLEN 值
3.     return xlen;
4.     // 输入：
5.     //  - 无输入参数。
6.     // 操作：
7.     //  - 返回成员变量 `xlen` 的值。
8.     // 输出：
9.     //  - 返回值为 `Xlen` 类型，表示当前处理器的字长（32 位或 64 位）。
10.     // 使用场景：
11.     //  - 需要判断处理器的架构模式时（如 RV32 或 RV64）。
12.     //  - 在指令解码或执行过程中，决定数据操作的宽度。
13.     // 对应流水线阶段：
14.     //  - **ID（指令解码阶段）** 和 **EX（执行阶段）**。
15.     //    在解码指令时，XLEN 会决定寄存器和操作数的宽度（如 RV32 处理 32 位数据，RV64 处理 64 位数据）。
16. }

复制代码

通俗解释与总结

1. 功能概述：

• 此函数返回处理器的字长（XLEN），通常是 32 位（RV32） 或 64 位（RV64）。
  
• 字长决定了指令操作数、寄存器宽度以及数据的位宽。
  

2. 关键逻辑：

• 该函数是一个只读方法（const），它直接返回焦点处理器成员变量 xlen。
  
• xlen 的值在 Core 类初始化时由构造函数设置。
  

3. 对流水线的影响：

• ID（指令解码阶段）：
  
  
  
  • 解码时必要根据 XLEN 判定指令操作数的宽度。例如 RV32 仅支持 32 位寄存器，而 RV64 支持 64 位寄存器。
    
  
  
• EX（执行阶段）：
  
  
  
  • 执行阶段必要根据 XLEN 决定算术和逻辑操作的宽度（如加法或逻辑操作必要处理 32 位还是 64 位数据）。
    
  
  

4. 使用场景：

• 指令解码：
  
  
  
  • 解码时区分 RV32 和 RV64 的指令格式及功能。
    
  
  
• 寄存器访问：
  
  
  
  • RV32 的寄存器为 32 位，而 RV64 的寄存器为 64 位。
    
  
  
• 数据处理：
  
  
  
  • RV32 和 RV64 的数据操作宽度不同，xlen 是区分它们的关键标志。
    
  
  

1. void Core::register_exception_handler(ExceptionCause excause, ExceptionHandler *exhandler) {
2.     if (excause == EXCAUSE_NONE) {
3.         // 如果异常原因为 EXCAUSE_NONE，设置为默认异常处理器
4.         ex_default_handler.reset(exhandler); // 使用新传入的处理器覆盖默认处理器
5.     } else {
6.         // 如果是具体的异常类型，将其插入到异常处理器映射表中
7.         ExceptionHandler *old = ex_handlers.take(excause); // 获取旧的异常处理器
8.         delete old; // 删除旧处理器以释放内存
9.         ex_handlers.insert(excause, exhandler); // 插入新的异常处理器
10.     }
11. }

复制代码

1. static int32_t amo32_operations(enum AccessControl memctl, int32_t a, int32_t b) {
2.     switch(memctl) {
3.     case AC_AMOSWAP32:
4.         return b; // AMOSWAP：直接返回操作数 b 的值，覆盖原始值
5.     case AC_AMOADD32:  
6.         return a + b; // AMOADD：返回 a 和 b 的和
7.     case AC_AMOXOR32:  
8.         return a ^ b; // AMOXOR：返回 a 和 b 的按位异或结果
9.     case AC_AMOAND32:  
10.         return a & b; // AMOAND：返回 a 和 b 的按位与结果
11.     case AC_AMOOR32:   
12.         return a | b; // AMOOR：返回 a 和 b 的按位或结果
13.     case AC_AMOMIN32:  
14.         return a < b ? a : b; // AMOMIN：返回 a 和 b 中较小的值
15.     case AC_AMOMAX32:  
16.         return a < b ? b : a; // AMOMAX：返回 a 和 b 中较大的值
17.     case AC_AMOMINU32:
18.         return (uint32_t)a < (uint32_t)b ? a : b; // AMOMINU：无符号比较，返回较小值
19.     case AC_AMOMAXU32:
20.         return (uint32_t)a < (uint32_t)b ? b : a; // AMOMAXU：无符号比较，返回较大值
21.     default:
22.         break; // 对于不支持的操作，进入默认处理逻辑
23.     }
24.     return 0; // 如果未匹配到任何操作，返回 0
25. }

复制代码

 
通用分析

AMO 支持的操作

AMO 是 RISC-V 指令集中的一部门，用于执行原子操作。上述函数支持以下操作：

• 交换 (AMOSWAP)：
  
  
  
  • 直接将操作数 b 写入目标位置。
    
  
  
• 加法 (AMOADD)：
  
  
  
  • 将两个操作数相加并返回结果。
    
  
  
• 按位操作 (AMOXOR, AMOAND, AMOOR)：
  
  
  
  • 分别执行按位异或、按位与、按位或操作。
    
  
  
• 最小/最大值选择 (AMOMIN, AMOMAX)：
  
  
  
  • 比较操作数并返回较小或较大的值。
    
  • 支持有符号和无符号两种模式（U 表示无符号）。
    
  
  

函数特点

• 位宽区分：
  
  
  
  • 提供了 32 位和 64 位两种实现，分别适配 RV32 和 RV64 架构。
    
  
  
• 灵活性：
  
  
  
  • 支持多种类型的原子操作，可以满足不同场景的需求。
    
  
  
• 可扩展性：
  
  
  
  • 如果必要新增操作类型，可以在 AccessControl 枚举中添加新值，并扩展 switch 语句。
    
  
  

流水线阶段

这些原子操作通常在 EX（执行阶段） 完成：

• 执行逻辑：在 ALU 中完成算术或逻辑运算。
  
• 访存交互：将结果写回内存（通过 MEM 阶段完成）。
  

 
AMO（Atomic Memory Operation）原子操作是RISC-V指令集中用于实现多核处理器系统中的原子读写操作的一组指令。这些指令能够包管在多处理器系统中对共享数据的访问是原子性的，即在执行这些操作时，其他处理器不能介入，从而避免了数据不同等的题目。以下是AMO原子操作的一些关键寄义和特点：

• 原子性：AMO指令执行的是“读-改-写”操作，在整个操作过程中，存储器的特定地址不能被其他线程访问，确保了操作的原子性。
  
• 读改写操作：AMO指令从存储器中读取数据，将读出的数据与寄存器中的值举行计算，然后将计算结果写回存储器，这一过程是连续的，不会被其他操作打断。
  
• 多种操作类型：AMO指令包罗多种操作，如交换（AMOSWAP）、加法（AMOADD）、按位与（AMOAND）、按位或（AMOOR）、按位异或（AMOXOR）等，这些操作都是在原子层面上执行的。
  
• 内存对齐要求：对于32位架构的AMO指令，访问存储器的地址必须与32位对齐，否则会产生地址非对齐非常（AMO Misaligned Address Exception）。
  
• 支持内存次序：RISC-V为每个原子指令预留了aq/rl两个比特位，从而可以在原子指令上施加额外的内存次序限制，这有助于在多核系统中实现同步。
  

 
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。