-chlo-legalize-to-stablehlo
将 CHLO 运算流从 StableHLO 和 Shape 运算合法化
-shape-legalize-to-stablehlo
将与形状相关的操作合法化为 StableHLO。
这是一个实验性传递，用于将与形状相关的操作合法化为 StableHLO 操作。
通过可选的传递将形状和数据计算结合起来，StableHLO 生态系统有望利用使用 StableHLO 运算来对动态性进行建模的编译流水线。
-stablehlo-aggressive-folder
对 StableHLO 运算进行折叠
选项
-fold-float : Allow for potentially lossy computations using float type.
-stablehlo-aggressive-simplification
规范化 StableHLO 操作
-stablehlo-canonicalize-dynamism
将动态 StableHLO 运算规范化为静态运算。
如果这些操作的所有动态元素实际上都是常量，则将动态 StableHLO 操作（例如 DynamicReshapeOp）替换为相应的静态操作（例如将 DynamicReshapeOp 替换为 ReshapeOp 或将 DynamicBroadcastInDim 替换为 BroadcastInDim）。
%c = stablehlo.constant dense<16> : tensor<1xi32>
%0 = stablehlo.dynamic_broadcast_in_dim %cst, %c, dims = [] : (tensor<f32>, tensor<1xi32>) -> tensor<16xf32>
==>
%0 = stablehlo.broadcast_in_dim %cst, dims = [] : (tensor<f32>) -> tensor<16xf32>
-stablehlo-compatibility-expander
适用于 StableHLO 运算的兼容性展开器。
最新版本中会更新 StableHLO 运算或引入新运算。 此可选传递会将较新的 StableHLO 运算分解为这些旧版本支持的等效运算，从而扩大与旧版 StableHLO 版本的向后兼容性。
为什么这项卡券是可选的？
有时，StableHLO 运算增强功能可用于极大地简化 OpenXLA 生态系统中某些常见模式的处理。这包括 TanOp（具有很高的框架和编译器支持）以及汇聚/分散批处理维度（可使用 slice 表示，但会使分片变得更加困难）。对于这类新功能，我们不提供自动降级，因为这可能会丢弃在后续优化中使用的重要信息。此传递可用于根据目标版本扩展这些操作，以最大限度地提高兼容性，但编译可能不太理想。
func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
%1 = stablehlo.tan %arg0 : tensor<4xf64>
func.return %1 : tensor<4xf64>
}
==>
func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
%0 = stablehlo.sine %arg0 : tensor<4xf64>
%1 = stablehlo.cosine %arg0 : tensor<4xf64>
%2 = stablehlo.divide %0, %1 : tensor<4xf64>
return %2 : tensor<4xf64>
}
选项
-target : The target version. Must be a version of the form #.#.#.
-stablehlo-convert-to-signless
通过转换 IR 为无符号整数。
-stablehlo-legalize-composite-to-call
将复合运算替换为对其分解的调用。
将复合运算替换为对其分解的调用，例如以下代码：
stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
decomposition = @bar,
version = 1,
composite_attributes = {
"my_attribute": "my_value"
}
}
将变为：
func.call @bar(%arg0, %arg1)
您可以使用“except”标志将部分复合体从此转换中排除，例如：
stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'
选项
-except : Names of composites that should not be replaced with calls.
-stablehlo-legalize-deprecated-ops
将已废弃的操作合法化为受良好支持的操作。
StableHLO v1.0 Opset 废弃 RFC (#2283) 提议移除多个冗余操作。此传递有助于将这些操作合法化为长期受支持的操作，从而评估这些操作移除对各种编译流水线的影响。
选项
-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.
-stablehlo-legalize-qdq-to-quantized-op
将“融合”（去量化、浮点运算和量化）模式融合到 StableHLO 量化运算中
将“融合（反量化、浮点运算和量化）”模式合并到 StableHLO 量化运算 注意：此传递不会删除任何现有操作。例如，以下程序
func.func @add(%arg0: tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16xf32>
%1 = stablehlo.abs %0 : tensor<16x16xf32>
%2 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
func.return %2 : tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
}
将变为：
func.func @add(%arg0: tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16xf32>
%1 = stablehlo.abs %0 : tensor<16x16xf32>
%2 = stablehlo.abs %arg0 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
%3 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
return %2 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
}
-stablehlo-legalize-quant-to-math
从 StableHLO 量化运算转换为 StableHLO 基元数学运算。
将使用 UniformQuantized 类型的 StableHLO 程序转换为语义等效的整数数学运算。
func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>> {
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}
将变为：
func.func @add(%arg0: tensor<i8>, %arg1: tensor<i8>) -> tensor<i8> {
%0 = stablehlo.convert %arg0 : (tensor<i8>) -> tensor<f32>
%cst = stablehlo.constant dense<0.333333343> : tensor<f32>
%1 = chlo.broadcast_multiply %0, %cst : (tensor<f32>, tensor<f32>) -> tensor<f32>
%cst_0 = stablehlo.constant dense<2.000000e+00> : tensor<f32>
%2 = chlo.broadcast_add %1, %cst_0 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%3 = stablehlo.round_nearest_even %2 : tensor<f32>
%4 = stablehlo.convert %3 : (tensor<f32>) -> tensor<i32>
%5 = stablehlo.convert %arg1 : (tensor<i8>) -> tensor<f32>
%cst_1 = stablehlo.constant dense<0.666666686> : tensor<f32>
%6 = chlo.broadcast_multiply %5, %cst_1 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%cst_2 = stablehlo.constant dense<1.33333337> : tensor<f32>
%7 = chlo.broadcast_add %6, %cst_2 : (tensor<f32>, tensor<f32>) -> tensor<f32>
%8 = stablehlo.round_nearest_even %7 : tensor<f32>
%9 = stablehlo.convert %8 : (tensor<f32>) -> tensor<i32>
%c = stablehlo.constant dense<2> : tensor<i32>
%10 = chlo.broadcast_add %4, %9 : (tensor<i32>, tensor<i32>) -> tensor<i32>
%11 = chlo.broadcast_subtract %10, %c : (tensor<i32>, tensor<i32>) -> tensor<i32>
%c_3 = stablehlo.constant dense<-128> : tensor<i32>
%c_4 = stablehlo.constant dense<127> : tensor<i32>
%12 = stablehlo.clamp %c_3, %11, %c_4 : tensor<i32>
%13 = stablehlo.convert %12 : (tensor<i32>) -> tensor<i8>
return %13 : tensor<i8>
}
-stablehlo-legalize-quantized-op-to-qdq
将量化 StableHLO 运算分解为（反量化、浮点运算和量化）模式。
使用统一的量化/反量化操作对 StableHLO 量化程序进行分解。例如，以下程序
func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>> {
%0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}
将变为：
func.func @add(%arg0: tensor<!quant.uniform<i8:f32, 1.000000e+00>>, %arg1: tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>> {
%0 = stablehlo.uniform_dequantize %arg0 : (tensor<!quant.uniform<i8:f32, 1.000000e+00>>) -> tensor<f32>
%1 = stablehlo.uniform_dequantize %arg1 : (tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<f32>
%2 = stablehlo.add %0, %1 : tensor<f32>
%3 = stablehlo.uniform_quantize %2 : (tensor<f32>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
return %3 : tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
}
-stablehlo-legalize-to-vhlo
将 StableHLO 合法化为 VHLO。
-stablehlo-refine-arguments
优化主函数的参数形状。
使用输入类型签名修改主函数的参数。将参数封装在 custom_call @stablehlo.shape_refinement_operand_wrapper 中，以便在运行形状优化之前使 IR 保持有效。
func.func public @main(%arg0: tensor<?xf32>) -> tensor<?xf32> {
...
}
==>
func.func public @main(%arg0: tensor<16xf32>) -> tensor<?xf32> {
%c = stablehlo.constant dense<16> : tensor<1xi64>
%0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
: (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
...
refinedTypesOption 可用于指定经过优化的类型列表。您可以在 MLIR 中使用 --types='tensor<...>,tensor<...>' 指定此值，也可以将其传递给 pass create 方法。精炼类型列表必须指定要精炼的 main 方法的每个参数的类型。
选项
-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'
-stablehlo-refine-shapes
优化 StableHLO 程序中的形状。
介绍一个 StableHLO 程序，该程序会优化操作中的形状。
此传递的主要用例是将动态形状的程序专门用于静态形状。如果动态形状的 StableHLO 程序具有正确的结构，则将其参数类型从动态形状更新为静态形状并运行此传递将会在整个程序中传播静态形状。
此传递会通过直接将结果用运算数替换来移除 custom_call @shape_refinement_operand_wrapper，并将静态形状传播到整个程序。
%c = stablehlo.constant dense<16> : tensor<1xi64>
%0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
: (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
%1 = stablehlo.add %0, %0 : tensor<?xf32>
==>
%1 = stablehlo.add %arg0, %arg0 : tensor<16xf32>
适用于形状优化的模块必须具有以下属性：
- 所有动态形状仅依赖于输入形状（没有形状依赖于输入数组内容）。我们将仅依赖于输入形状（例如由
stablehlo.get_dimension_size给出）或全局常量（例如符号整数的解析值，即张量：A = 5）的传递依赖操作称为 dimension操作。所有维度值都可以通过跨过程常量折叠解析为常量。 - 中间函数可以在参数列表开头接受多个令牌参数（类型为 !stablehlo.token），后跟一些全局常量参数，这些参数是常量整数标量，例如符号化整数的解析值（即张量
：A = 5）。 - 某些中间函数可能会返回对全局常量（即对 symint 值的
floordiv）的计算结果。这些函数的特点是，在经过优化后只会返回常量值。这些函数会内嵌。 - 对单个函数的所有调用都会解析为相同的参数形状，并且不会进行递归 / 协同递归函数调用。###
-vhlo-legalize-to-stablehlo
将 VHLO 合法化为 StableHLO。
-vhlo-to-version
在不同版本的 VHLO 之间转换。
选项
-target : The target version. Must be a version of the form #.#.# .