VecScope 内存 Hazard 自动插入 MEM_BAR Pass 实现计划

[TelGome]

目标仓库：PTOAS
Pass 名称：PTOInsertVecScopeMemBar
Pass 参数名：pto-insert-vecscope-mem-bar

1. 设计结论

本 Pass 在 pto.vecscope / pto.strict_vecscope 内分析 pto.vlds 和
pto.vsts 的 UB 访存 hazard，自动插入方向相关的 pto.mem_bar。

采用以下明确方案：

1. 新建独立的 VecScopeMemBar 目录；
2. Pass 内部严格分成 Analyze -> Plan -> Apply；
3. 支持 vecscope 内最多两层规范 scf.for；
4. 同时分析同迭代、内层 loop-carried、外层 loop-carried hazard；
5. 地址无法证明 NoAlias 时保守按 MayAlias 处理；
6. 分析阶段绝不修改 IR，所有屏障由 codegen 阶段统一插入。

本 Pass 只处理 Vector pipeline 内部的 UB 访问顺序，不替代现有跨 pipeline 的
set_flag/wait_flag、get_buf/rls_buf 或 pto.barrier 同步。

2. 支持范围

2.1 精确支持

• pto.vecscope；
• pto.strict_vecscope；
• pto.vlds；
• pto.vsts；
• pto.vgather2、pto.vgatherb、pto.vgather2_bc，按 load 分类；
• pto.vscatter，按 store 分类；
• vecscope body 内零层、一层或两层规范 scf.for；
• 常量 scf.for lower bound、upper bound 和 step 的精确循环分析；
• 动态 loop bound 的保守分析；
• offset 中最多包含两个 induction variable 的线性表达式；
• arith.constant、arith.addi、arith.subi；
• 一侧为常量的 arith.muli；
• 整数/index cast；
• 可线性展开的简单 affine.apply；
• pto.castptr、pto.addptr 和稳定 symbolic root；
• 同迭代 RAW/WAW/WAR；
• 内层相邻迭代 RAW/WAW/WAR；
• 外层相邻迭代 RAW/WAW/WAR；
• 已有 pto.mem_bar；
• Pass 幂等执行。

2.2 保守支持

下列情况不做精确 footprint，但不能漏掉 hazard：

• 动态 offset；
• 无法线性化的 offset；
• 动态 loop bound；
• 无法恢复 provenance 的 pointer；
• post-update pointer；
• masked vsts；
• gather/scatter 访问；
• 未知地址区间。

处理原则是：只有能够证明 NoAlias 才跳过，否则返回 MayAlias。

Gather/scatter 使用更严格的固定规则：不解析离散地址集合。只要一个访问对中任一
访问是 gather/scatter，且两边属于相同 memory space，该访问对的 alias 结果固定为
MayAlias。随后按访问方向生成 RAW/WAW/WAR hazard，并必须规划对应的
VST_VLD、VST_VST 或 VLD_VST。RAR 仍不需要屏障。

2.3 VecScope 访存类别与 MEM_BAR 范围

pto.vecscope / pto.strict_vecscope 内不会产生 scalar ld/st，因此本 Pass 只分析
vector load/store 类访问。Gather 仍属于 vector load，scatter 仍属于 vector store，
不会引入新的 MEM_BAR kind。

PTO ISA 的 MemBarKind 共定义 16 种，按 VV、VS、SV、SS 四个 family
划分，每个 family 各 4 种。本 Pass 不处理含 scalar ld/st 的 VS、SV、SS
family，只需要识别和处理以下 4 种 VV MEM_BAR：

用途	MEM_BAR kind	本 Pass 行为
RAW：vector store -> vector load	VST_VLD	根据 hazard 主动生成
WAR：vector load -> vector store	VLD_VST	根据 hazard 主动生成
WAW：vector store -> vector store	VST_VST	根据 hazard 主动生成
全 VV 屏障	VV_ALL	识别已有屏障，或用于明确的保守回退

因此，本 Pass 主动分析并生成的定向 hazard 屏障是 3 种；连同 VV_ALL，需要识别、
覆盖判断和幂等处理的 VV MEM_BAR kind 共 4 种。两个 vector load 之间是 RAR，
包括 gather -> gather，不需要屏障。

2.4 限制与诊断

• scf.if 等分支内的跨路径 hazard；
• scf.while；
• pto.vldsx2 / pto.vstsx2；
• 特殊、非连续 distribution 的精确 footprint；
• mask 的逐 lane 精确集合；
• 不同 vecscope 之间的 hazard。

遇到上述控制流时应报出明确诊断，不允许递归 walk() 后错误线性化。

3. Hazard 定义

设 P 为动态执行中较早的访问，C 为较晚的访问：

P	C	Hazard	MEM_BAR kind
VST	VLD	RAW	VST_VLD
VST	VST	WAW	VST_VST
VLD	VST	WAR	VLD_VST
VLD	VLD	RAR	无

Hazard 成立需要：

1. 两个动态访问实例存在程序执行先后关系；
2. 地址区间为 MustAlias、PartialAlias 或 MayAlias；
3. 访问方向属于 RAW/WAW/WAR。

4. 独立目录与文件结构

新建以下目录：

include/PTO/Transforms/VecScopeMemBar/
  VecScopeMemBarIR.h
  VecScopeMemoryFootprint.h
  VecScopeMemBarAnalysis.h
  VecScopeMemBarPlacement.h
  VecScopeMemBarCodegen.h

lib/PTO/Transforms/VecScopeMemBar/
  VecScopeMemoryFootprint.cpp
  VecScopeMemBarAnalysis.cpp
  VecScopeMemBarPlacement.cpp
  VecScopeMemBarCodegen.cpp
  PTOInsertVecScopeMemBarPass.cpp

同时修改：

include/PTO/Transforms/Passes.td
include/PTO/Transforms/Passes.h
include/PTO/IR/VPTOOps.td
lib/PTO/IR/PTO.cpp
lib/PTO/Transforms/CMakeLists.txt
tools/ptoas/ptoas.cpp
test/lit/pto/

5. 模块职责

5.1 VecScopeMemBarIR

定义 Pass 内部只读分析 IR：

enum class VecScopeNodeKind {
  Sequence,
  Loop,
  Access,
  ExistingBarrier,
};

struct VecScopeLoopInfo {
  unsigned id;
  scf::ForOp op;
  unsigned depth;
  Value inductionVar;
  Value lowerBound;
  Value upperBound;
  Value step;
};

struct VecScopeScheduleNode {
  VecScopeNodeKind kind;
  Operation *op;
  SmallVector<unsigned> children;
  std::optional<unsigned> parentLoop;
};

schedule 只需要表达 sequence 和最多两层 scf.for。

5.2 VecScopeMemoryFootprint

负责：

• pointer root/provenance 解析；
• 元素 offset 转字节 offset；
• vreg 访问宽度计算；
• 线性表达式提取；
• 同迭代和指定 loop transition 下的 alias 比较；
• expression/pointer 解析缓存。

5.3 VecScopeMemBarAnalysis

负责：

• 构造 vecscope schedule；
• 收集 access occurrence；
• 收集已有 mem_bar；
• 枚举同迭代 hazard；
• 枚举内层 loop-carried hazard；
• 枚举外层 loop-carried hazard；
• 标记 carrying loop；
• 输出只读 analysis result。

不负责选择最终屏障，也不修改 IR。

5.4 VecScopeMemBarPlacement

负责：

• 为 hazard 生成合法候选插入点；
• 同迭代 interval stabbing；
• 内层 backedge 屏障合并；
• 外层 backedge 屏障合并；
• 识别已有屏障覆盖；
• 基于 happens-before 传递性消除冗余；
• 输出稳定、确定性的 plan。

5.5 VecScopeMemBarCodegen

负责：

• 校验 plan 中的插入 anchor 仍有效；
• 对相同位置/kind 去重；
• 按固定顺序创建 pto.mem_bar；
• 统一修改 IR；
• 不做任何新的 alias 或 hazard 推导。

5.6 Pass Driver

PTOInsertVecScopeMemBarPass.cpp 只负责串联三个阶段：

void PTOInsertVecScopeMemBarPass::runOnOperation() {
  func::FuncOp func = getOperation();

  SmallVector<Operation *> scopes;
  func.walk([&](Operation *op) {
    if (isa<pto::VecScopeOp, pto::StrictVecScopeOp>(op))
      scopes.push_back(op);
  });

  for (Operation *scope : scopes) {
    VecScopeMemBarAnalysis analysis(scope);
    FailureOr<VecScopeMemBarAnalysisResult> result = analysis.run();
    if (failed(result)) {
      signalPassFailure();
      return;
    }

    VecScopeMemBarPlacement placement(*result);
    FailureOr<VecScopeMemBarPlan> plan = placement.solve();
    if (failed(plan)) {
      signalPassFailure();
      return;
    }

    VecScopeMemBarCodegen codegen(scope);
    if (failed(codegen.apply(*plan))) {
      signalPassFailure();
      return;
    }
  }
}

6. 访问与地址模型

6.1 线性字节表达式

struct AffineByteExpr {
  int64_t constant = 0;
  SmallVector<std::pair<Value, int64_t>, 2> coefficients;
  bool exact = true;
};

两层循环下的地址表示为：

address(i, j) = root + c + ai * i + aj * j

6.2 Footprint

enum class MemoryRootKind {
  Absolute,
  ProvenAllocation,
  Symbolic,
  Unknown,
};

struct VecScopeMemoryFootprint {
  MemoryRootKind rootKind;
  Value root;
  std::optional<uint64_t> absoluteBase;
  pto::AddressSpace addressSpace;
  AffineByteExpr byteOffset;
  std::optional<uint64_t> byteSize;
  bool forcesMayAlias = false;
};

vlds/vsts 的 offset 是元素单位：

byteOffset = elementOffset * storageElementByteSize

普通连续访问的宽度：

byteSize = vreg.elementCount * storageElementByteSize

masked vsts 按完整 vreg footprint 保守处理。Gather/scatter 设置
forcesMayAlias = true，不尝试用连续区间近似其离散地址集合。

6.3 Access Occurrence

enum class VecScopeAccessKind { Load, Store };

struct AccessOccurrence {
  unsigned id;
  Operation *op;
  VecScopeAccessKind kind;
  VecScopeMemoryFootprint footprint;
  SmallVector<unsigned, 2> loopNest;
  unsigned lexicalOrder;
};

7. Alias 分析

7.1 三值结果

enum class VecScopeAliasResult {
  NoAlias,
  MayAlias,
  MustOrPartialAlias,
};

只有 NoAlias 可以跳过 hazard。

7.2 Root 判定

1. memory space 不同：NoAlias；
2. memory space 相同且任一侧 forcesMayAlias：MayAlias；
3. 两边均为已知绝对地址：比较绝对区间；
4. 两边来自已证明独立 allocation：NoAlias；
5. root 相同：比较相对区间；
6. 不同普通 symbolic root：MayAlias；
7. unknown provenance：MayAlias。

不同 SSA pointer 不等价于不同 allocation，不能据此返回 NoAlias。

7.3 同迭代比较

设：

P(i,j) = bP + cP + aPi*i + aPj*j
C(i,j) = bC + cC + aCi*i + aCj*j

计算：

D(i,j) = C(i,j) - P(i,j)

如果 i/j 系数全部抵消，D 为常量，可直接比较半开区间。

如果系数未抵消：

• 常量 loop bounds 时求 D 在迭代域上的最小/最大值；
• 若整个差值范围都能证明区间不重叠，返回 NoAlias；
• 否则返回 MayAlias。

半开区间比较必须使用 checked arithmetic 或 APInt，避免地址加长度溢出。

8. 两层循环依赖分析

8.1 Hazard 分类

enum class VecScopeHazardScope {
  SameIteration,
  InnerLoopCarried,
  OuterLoopCarried,
};

struct IterationDistance {
  std::optional<int64_t> outer;
  std::optional<int64_t> inner;
};

struct MemoryHazard {
  unsigned id;
  unsigned producer;
  unsigned consumer;
  MemBarKind kind;
  VecScopeHazardScope scope;
  std::optional<unsigned> carryingLoop;
  IterationDistance distance;
};

8.2 同迭代

分析：

P(i,j) -> C(i,j)

要求 producer 的静态执行位置早于 consumer，并进行同迭代 alias 比较。

8.3 内层相邻迭代

分析：

P(i,j) -> C(i,j + stepJ)

consumer 地址替换为：

C(i,j+stepJ)
  = bC + cC + aCi*i + aCj*j + aCj*stepJ

再与 P(i,j) 比较。若 alias 且方向为 RAW/WAW/WAR，则 hazard 由内层 loop
携带。

跨迭代 pair 允许 producer 和 consumer 是同一静态访问。

8.4 外层相邻迭代

不能比较：

P(i,j) -> C(i+stepI,j)

因为下一次外层迭代时内层 induction variable 已重置。正确比较是：

P(i, lastJ) -> C(i + stepI, firstJ)

对于规范 scf.for：

firstJ = lowerBoundJ
tripCountJ = ceilDiv(upperBoundJ - lowerBoundJ, stepJ)
lastJ = lowerBoundJ + (tripCountJ - 1) * stepJ

如果内层 loop 可以 zero-trip，则需要分别考虑：

• producer/consumer 位于内层 loop 内时，该动态实例是否存在；
• producer/consumer 位于内层 loop 外时，外层 transition 仍然存在；
• 外层屏障不能依赖内层 loop 尾部屏障执行。

如果 inner bounds 或 trip count 无法精确求解，地址比较降级为 MayAlias。

8.5 Carrying Loop

hazard 的 carrying loop 是 iteration distance 中第一个发生变化的循环维度：

(0, 0) -> SameIteration
(0, 1) -> InnerLoopCarried
(1, *) -> OuterLoopCarried

carryingLoop 是 placement 决定 backedge 插点的核心属性。

8.6 不枚举运行时迭代

编译期不展开实际 iteration。Pass 只操作线性表达式、loop bounds 和 iteration
transition。

动态条件无法证明安全时保守产生 hazard。

9. Analysis 输出

struct ExistingBarrier {
  pto::MemBarOp op;
  MemBarKind kind;
  std::optional<unsigned> backedgeLoop;
  unsigned lexicalOrder;
};

struct VecScopeMemBarAnalysisResult {
  Operation *scope;
  SmallVector<VecScopeScheduleNode> schedule;
  SmallVector<VecScopeLoopInfo> loops;
  SmallVector<AccessOccurrence> accesses;
  SmallVector<MemoryHazard> hazards;
  SmallVector<ExistingBarrier> existingBarriers;
};

Analysis 不负责：

• 创建 MemBarOp；
• 修改 block；
• 合并最终屏障；
• 决定最终屏障顺序。

10. Placement 算法

10.1 Plan 表示

enum class BarrierAnchorKind {
  BeforeOperation,
  BeforeLoopTerminator,
};

struct BarrierPlacement {
  BarrierAnchorKind anchorKind;
  Operation *anchor;
  MemBarKind kind;
  SmallVector<unsigned> resolvedHazards;
};

struct VecScopeMemBarPlan {
  SmallVector<BarrierPlacement> barriers;
};

10.2 同迭代插点

对于同一 sequence block 中的 hazard (P,C)，合法插点是：

(P, C]

同一 kind 使用最右端 interval-stabbing 贪心：遇到尚未覆盖的 hazard，在其 consumer
前插入。相同 anchor 和 kind 合并。

10.3 内层 loop-carried 插点

固定在 carrying inner loop 的 terminator 前：

scf.for %j = ... {
  ...
  pto.mem_bar "KIND"
  scf.yield
}

相同 inner loop、相同 kind 的 hazard 合并。

10.4 外层 loop-carried 插点

固定在 carrying outer loop 的 terminator 前：

scf.for %i = ... {
  scf.for %j = ... {
    ...
  }
  pto.mem_bar "KIND"
  scf.yield
}

相同 outer loop、相同 kind 的 hazard 合并。外层 hazard 不能依赖 inner backedge
屏障，因为 inner loop 可能 zero-trip。

10.5 传递覆盖

Placement 建立访问级 happens-before 图：

• VST_VLD：屏障前 store 到屏障后 load；
• VLD_VST：屏障前 load 到屏障后 store；
• VST_VST：屏障前 store 到屏障后 store；
• VV_ALL：屏障前 load/store 到屏障后 load/store。

通过可达性判断 hazard 是否已被直接或传递覆盖。例如：

S1 --VST_VLD--> L1 --VLD_VST--> S2

已经建立 S1 -> S2，因此不再插 VST_VST。

两层循环下，图边必须携带 scope：same-iteration、inner backedge 或 outer backedge。
只有处于相同动态 transition 上的边才能组成传递链。

10.6 合法性检查

每个 placement 必须满足：

1. anchor 位于当前 vecscope 内；
2. 同迭代 producer 在 anchor 前、consumer 在 anchor 后；
3. loop-carried anchor 是 carrying loop 的 terminator；
4. backedge 屏障在每个 relevant iteration 上必经；
5. outer hazard 不依赖可能 zero-trip 的 inner barrier；
6. 不跨不支持的控制流路径。

11. Codegen

Codegen 先建立：

DenseMap<Operation *, SmallVector<MemBarKind>> beforeAnchor;

然后：

1. 对相同 anchor/kind 去重；
2. 按固定 kind 顺序排序；
3. 使用 IRRewriter 在 anchor 前创建 pto.mem_bar；
4. 不边分析边修改 IR。

固定顺序建议：

VST_VLD
VLD_VST
VST_VST
VV_ALL

若 ISA 对同点多屏障顺序有额外约束，实现前再确认。

12. MEM_BAR 副作用

PTO_MemBarOp 必须声明 MemoryEffectsOpInterface，否则 resultless barrier 可能被
canonicalizer/CSE 删除。

ODS：

def PTO_MemBarOp : PTO_MicroOp<"mem_bar", [
    DeclareOpInterfaceMethods<MemoryEffectsOpInterface>
  ]> {
  ...
}

C++：

void MemBarOp::getEffects(
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
        &effects) {
  effects.emplace_back(MemoryEffects::Read::get(),
                       SideEffects::DefaultResource::get());
  effects.emplace_back(MemoryEffects::Write::get(),
                       SideEffects::DefaultResource::get());
}

必须验证 canonicalizer、CSE 和 LICM 不删除或跨越该 barrier。

13. Pass 注册

在 include/PTO/Transforms/Passes.td 增加：

def PTOInsertVecScopeMemBar
    : Pass<"pto-insert-vecscope-mem-bar", "func::FuncOp"> {
  let summary = "Insert memory barriers for VPTO vecscope memory hazards";
  let constructor = "mlir::pto::createPTOInsertVecScopeMemBarPass()";
  let dependentDialects = [
    "mlir::pto::PTODialect",
    "mlir::arith::ArithDialect",
    "mlir::affine::AffineDialect",
    "mlir::func::FuncDialect",
    "mlir::scf::SCFDialect"
  ];
}

在 include/PTO/Transforms/Passes.h 增加：

std::unique_ptr<Pass> createPTOInsertVecScopeMemBarPass();

14. Pipeline 接入

修改 tools/ptoas/ptoas.cpp：

static void prepareVPTOForEmission(PassManager &pm)

具体插在 soft post-update 之后、LICM 之前：

kernelModulePM.addNestedPass<func::FuncOp>(
    pto::createPTOInferVPTOVecScopePass());
if (enableSoftPostUpdate)
  kernelModulePM.addPass(pto::createVPTOSoftPostUpdatePass());

kernelModulePM.addNestedPass<func::FuncOp>(
    pto::createPTOInsertVecScopeMemBarPass());

kernelModulePM.addPass(createLoopInvariantCodeMotionPass());

新 Pass 是 func::FuncOp Pass，必须使用 addNestedPass<func::FuncOp>()。

如第一阶段使用 CLI 开关，开关只包围新 Pass，不能把它放进
if (enableSoftPostUpdate)。

15. 复杂度

设：

• N：vecscope 内 vlds/vsts 数量；
• L <= 2：循环深度；
• H：hazard 数量，最坏 O(N^2)。

分析复杂度：

schedule 构建                    O(IR size)
表达式解析与缓存                 O(expression nodes)
同迭代 pair 分析                O(N^2 * L)
内层相邻迭代 pair 分析          O(N^2 * L)
外层相邻迭代 pair 分析          O(N^2 * L)

由于 L <= 2，总分析复杂度为：

O(N^2)

Placement：

同迭代 interval stabbing        O(H) 或 O(H log H)
按 loop/kind 合并               O(H)
happens-before 覆盖验证          O(N^2)

总体时间复杂度：

O(N^2)

空间复杂度：

O(N^2)

16. 测试计划

16.1 同迭代

• RAW/WAW/WAR；
• RAR 不插；
• 不重叠不插；
• 一个 barrier 覆盖多个同 kind hazard；
• S1 -> L1 -> S2 只插 VST_VLD + VLD_VST，不插冗余 VST_VST；
• 已有正确/错误 kind；
• Pass 二次运行不变化。

16.2 地址表达式

• 常量 offset；
• f16/f32 等不同元素字节数；
• ai*i + aj*j + c；
• 系数抵消；
• 常量范围可证明不重叠；
• 动态表达式保守 alias；
• masked store 按完整 footprint；
• gather/scatter 与同空间 load/store 配对固定为 MayAlias；
• gather 按 load、scatter 按 store 产生对应方向屏障；
• gather-gather 的 RAR 不插屏障；
• 地址范围溢出保护。

16.3 一层循环

• 同迭代 hazard；
• store 自身 loop-carried WAW；
• 相邻迭代 RAW/WAR/WAW；
• step 不等于 1；
• trip count <= 1 时无 carried hazard；
• 动态 bounds 保守处理；
• barrier 位于 loop terminator 前。

16.4 两层循环

• inner-loop-carried hazard 插 inner backedge；
• outer-loop-carried hazard 插 outer backedge；
• outer transition 使用 lastJ -> firstJ；
• inner zero-trip 时 outer barrier 仍必经；
• inner barrier 不错误覆盖 outer hazard；
• producer/consumer 分别位于 inner loop 内外的组合；
• 两层 affine coefficient 的 alias/no-alias cases。

16.5 限制与保守路径

• scf.if 含目标访存诊断；
• gather/scatter 强制 MayAlias 并插入对应方向屏障；
• 无法解析 pointer 时不漏插；
• scope 外访问不参与分析。

16.6 Pipeline 与副作用

• vecscope inference 后自动插入；
• canonicalizer/CSE 后 barrier 存活；
• LICM 不跨 barrier 移动；
• LLVM/EmitC backend 正确 lowering；
• 开关关闭时保持旧输出。

17. 实现步骤

步骤 1：MEM_BAR 副作用

• 更新 ODS；
• 实现 getEffects()；
• 添加优化存活测试。

步骤 2：独立内部 IR 与 schedule

• 新建 VecScopeMemBar include/lib 目录；
• 实现 sequence + 两层 scf.for schedule；
• 对 branch 添加诊断。

步骤 3：Footprint 与 alias

• pointer root 解析；
• affine byte expression；
• 同迭代区间比较；
• inner/outer transition substitution；
• unknown 保守策略。

步骤 4：Hazard analysis

• 同迭代 hazard；
• inner-loop-carried hazard；
• outer-loop-carried hazard；
• carrying loop 标注；
• existing barrier 收集。

步骤 5：Placement 与冗余消除

• 同迭代 interval stabbing；
• inner/outer backedge 合并；
• happens-before 图；
• 传递覆盖；
• deterministic plan。

步骤 6：Codegen 与 Pass 接入

• 统一应用 plan；
• Passes/CMake 注册；
• pipeline/CLI 接入；
• focused tests。

步骤 7：完整验证

• 新增 lit tests；
• 运行相关 VPTO 测试；
• 运行完整 PTO lit suite；
• 检查编译时间和屏障数量。

18. 验收标准

1. 支持 vecscope 内最多两层 scf.for；
2. 正确区分 same/inner-carried/outer-carried hazard；
3. outer transition 正确使用 inner lastJ -> firstJ；
4. unknown alias 不导致漏同步；
5. loop-carried barrier 插在正确 carrying loop backedge；
6. inner zero-trip 不破坏 outer hazard 同步；
7. 传递性可消除 S1 -> L1 -> S2 的冗余 WAW barrier；
8. Pass 幂等；
9. gather/scatter 与同 memory space 的非 RAR 访问对固定产生对应 hazard；
10. barrier 不被任何优化删除或跨越；
11. 总体分析和 placement 保持 O(N^2)；
12. 新增和现有相关测试全部通过。

19. 待确认决策

1. 动态 loop bounds 是统一保守 MayAlias，还是实现简单范围推导；
2. scf.if 是否直接拒绝；
3. 特殊 dist 是拒绝，还是先按未知 footprint 保守处理；
4. 是否使用 --enable-vecscope-mem-bar 显式开启；
5. 同点多个 kind 的固定生成顺序是否需要 ISA 侧确认。