「ムロ」方言

運営

mhlo.abs (mhlo::AbsOp)

腹筋手術

構文：

operation ::= `mhlo.abs` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operandテンソルに対して要素ごとの abs 演算を実行し、 resultテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

例：

%result = mhlo.abs %operand : tensor<3xi32>

特性: AlwaysSpeculatableImplTrait 、 Elementwise 、 SameOperandsAndResultShape

インターフェイス: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.add (mhlo::AddOp)

追加操作

構文：

operation ::= `mhlo.add` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

2 つのテンソルlhsとrhsの要素ごとの加算を実行し、 resultテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

例：

%result = mhlo.add %lhs, %rhs : tensor<2x2xi32>

特性: AlwaysSpeculatableImplTrait 、 Commutative 、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

インターフェイス: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.add_dependency (mhlo::AddDependencyOp)

AddDependency 操作

構文：

operation ::= `mhlo.add_dependency` operands attr-dict `:` functional-type(operands, results)

この操作は XLA コンパイラーにプライベートなものであるため、まだ仕様がありません。

非公式には、この操作にはデータ オペランドとトークンの 2 つのオペランドがあります。演算の出力はデータ オペランドです。 AfterAll とともに使用すると、この操作により、副作用のない操作 (トークン値を生成しない操作) の順序付けが可能になります。

例：

%1 = mhlo.add_dependency %arg0, %0 : (tensor<3x4xf32>, !mhlo.token) -> tensor<3x4xf32>

特性: AlwaysSpeculatableImplTrait

インターフェイス: ConditionallySpeculatable 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.after_all (mhlo::AfterAllOp)

アフターオール操作

構文：

operation ::= `mhlo.after_all` $inputs attr-dict
              `:` custom<VariadicSameOperandsAndResultType>(ref($inputs), type($inputs), type($result))

inputs生成する操作が、 resultに依存する操作の前に実行されるようにします。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

例：

%result = mhlo.after_all %input0, %input1 : !mhlo.token

特性: AlwaysSpeculatableImplTrait

インターフェイス: ConditionallySpeculatable 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.all_gather (mhlo::AllGatherOp)

オールギャザー操作

プロセス グリッド内の各プロセス グループ内で、各プロセスからのオペランド テンソルの値をall_gather_dimに沿って連結し、結果テンソルを生成します。 computation operandsのオペランドごとに個別に適用され、オペランドごとに 1 つの結果が生成されます。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

例：

%result = "mhlo.all_gather"(%operand) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>,
  // use_global_device_ids = false
} : (tensor<2x2xf32>) -> tensor<2x4xf32>

特性: SameOperandsAndResultElementType

属性:

オペランド:

結果：

mhlo.all_reduce (mhlo::AllReduceOp)

AllReduce 操作

プロセス グリッド内の各プロセス グループ内で、各プロセスからのオペランド テンソルの値にリダクション関数のcomputationを適用し、結果テンソルを生成します。 computation operandsのオペランドごとに個別に適用され、オペランドごとに 1 つの結果が生成されます。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

例：

%result = "mhlo.all_reduce"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
    %0 = mhlo.add %arg1, %arg2 : tensor<f32>
    mhlo.return %0 : tensor<f32>
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xf32>) -> tensor<4xf32>

特性: InferTensorType 、 SingleBlockImplicitTerminator<ReturnOp> 、 SingleBlock

インターフェイス: InferShapedTypeOpInterface 、 InferTypeOpInterface

属性:

オペランド:

結果：

mhlo.all_to_all (mhlo::AllToAllOp)

AllToAll 操作

プロセス グリッドの各プロセス グループ内で、 split_dimensionに沿ってoperandテンソルの値を部分に分割し、分割した部分をプロセス間で分散させ、分散した部分をconcat_dimensionに沿って連結して、 resultテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

例：

%result = "mhlo.all_to_all"(%operand) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<2x4xf32>) -> tensor<4x2xf32>

特性: AlwaysSpeculatableImplTrait 、 InferTensorType 、 SameOperandsElementType 、 SameOperandsShape 、 SameVariadicOperandSize

インターフェイス: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

属性:

オペランド:

結果：

mhlo.and (mhlo::AndOp)

そして操作

構文：

operation ::= `mhlo.and` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

2 つのテンソルlhsとrhsの要素ごとの AND を実行し、 resultテンソルを生成します

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

例：

%result = mhlo.and %lhs, %rhs : tensor<2x2xi32>

特性: AlwaysSpeculatableImplTrait 、 Commutative 、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

インターフェイス: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.async_done (mhlo::AsyncDoneOp)

非同期完了操作

この操作は XLA コンパイラーにプライベートなものであるため、まだ仕様がありません。

非公式には、この操作は非同期計算が終了するまでブロックされます。非同期計算の最終結果を返します。

詳細については、AsyncStart のドキュメントを参照してください。

インターフェイス: InferTypeOpInterface

オペランド:

結果：

mhlo.async_start (mhlo::AsyncStartOp)

非同期開始操作

この操作は XLA コンパイラーにプライベートなものであるため、まだ仕様がありません。

非公式には、この操作により非同期計算が開始されます。

これは、非同期待機 (DMA など) とオンスレッド計算の両方を含む関数がある場合に使用されます。たとえば、関数は、計算、DMA、別の計算、2 番目の DMA、および最終計算で構成される場合があります。これは、async_start とそれに続く async_update および async_done として表されます。 async_start はスレッド上で最初の計算を実行し、その後 DMA を開始します。 async_update は、DMA がまだ完了していない場合は完了するまで待機し、関数内の 2 番目の計算を実行して、2 番目の DMA を開始します。最後に、async_done はこの最後の DMA を待機してから、スレッド上で実行する必要がある最後の計算を実行し、その最後の計算の結果を返します。

operands計算に直接渡されますcalled_computation非同期で実行される関数ですexecution_thread実行されるスレッドの名前です。メインスレッドを「メイン」と呼びます。すべてのスレッドには名前があります。

これにより、非同期操作の間に必要なすべての状態が返されます。バッファ割り当て後の戻り値は、入力、結果、および非同期操作によって必要または編集されたスクラッチパッドを保持するために必要なスペースを表します。

属性:

オペランド:

結果：

mhlo.async_update (mhlo::AsyncUpdateOp)

非同期更新操作

この操作は XLA コンパイラーにプライベートなものであるため、まだ仕様がありません。

非公式には、この操作は同期バリアに達するまで非同期計算をブロックします。これにより、操作後にbundleが返されます。

詳細については、AsyncStart のドキュメントを参照してください。

インターフェイス: InferTypeOpInterface

オペランド:

結果：

mhlo.atan2 (mhlo::Atan2Op)

Atan2の動作

構文：

operation ::= `mhlo.atan2` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

lhsおよびrhsテンソルに対して要素ごとの atan2 演算を実行し、 resultテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

例：

%result = mhlo.atan2 %lhs, %rhs : tensor<3xf32>

特性: AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

インターフェイス: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

BatchNormGrad 操作

grad_outputから逆伝播する BatchNormTrainingOp のいくつかの入力の勾配を計算し、 grad_operand 、 grad_scale 、およびgrad_offsetテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

例：

%grad_operand, %grad_scale, %grad_offset =
"mhlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>,
    tensor<2x2x2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

特性: AlwaysSpeculatableImplTrait 、 InferTensorType

インターフェイス: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

属性:

オペランド:

結果：

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

BatchNormInference 操作

feature_index次元を除くすべての次元にわたってoperandテンソルを正規化し、 resultテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

例：

%result = "mhlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>) -> tensor<2x2x2xf32>

特性: AlwaysSpeculatableImplTrait 、 InferTensorType

インターフェイス: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

属性:

オペランド:

結果：

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

BatchNormTraining オペレーション

バッチ次元と空間次元にわたる平均と分散を計算し、 feature_index次元の各特徴についてoperandテンソルを正規化し、 output 、 batch_meanテンソル、 batch_varテンソルを生成します。

参照: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

例：

%output, %batch_mean, %batch_var = "mhlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

特性: AlwaysSpeculatableImplTrait 、 InferTensorType

インターフェイス: ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

エフェクト: MemoryEffects::Effect{}

属性:

オペランド:

結果：

mhlo.bitcast （mhlo :: bitcastop）

ビットキャスト操作

構文：

operation ::= `mhlo.bitcast` operands attr-dict `:` functional-type(operands, results)

この操作はXLAコンパイラのプライベートであるため、まだ仕様がありません。

非公式には、この操作は、要素の物理的な配置が変化しないように入力の形状を変更します。

この操作には、「要素の物理的配置」を理解するためにレイアウト情報が必要であり、MHLOでのレイアウトサポートは現在進行中です。

例：

%0 = mhlo.bitcast %arg0 : (tensor<3x4xf32>) -> tensor<3x4x1xf32>

特性： AlwaysSpeculatableImplTrait

インターフェイス： ConditionallySpeculatable 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

オペランド：

結果：

mhlo.bitcast_convert （mhlo :: bitcastconvertop）

BitCastConvert操作

構文：

operation ::= `mhlo.bitcast_convert` operands attr-dict `:` functional-type(operands, results)

operandテンソルでビットキャスト操作を実行し、 result operandのタイプを使用して再解釈されるresultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

例：

%result = mhlo.bitcast_convert %operand : (tensor<2xf32>) -> tensor<2x4xi8>

特性： AlwaysSpeculatableImplTrait

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

オペランド：

結果：

mhlo.broadcast （mhlo :: broadcastop）

ブロードキャスト操作

この操作はStablehloから出ているので、仕様には含まれていません：https： //github.com/openxla/stablehlo/issues/3

非公式には、この操作はXLAの放送と同じことをします： https：//www.tensorflow.org/xla/operation_semantics#broadcast

例：

%result = mhlo.broadcast %operand, sizes = [1, 2] : (tensor<3xi32>) -> tensor<1x2x3xi32>

特性： AlwaysSpeculatableImplTrait yimpltrait、 InferTensorType 、 SameOperandsAndResultElementType

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

属性：

オペランド：

結果：

mhlo.broadcast_in_dim （mhlo :: broadcastindimop）

broadcastindim操作

operandテンソルのデータを複製することにより、入力テンソルの寸法および/またはランクを拡張し、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

例：

%result = mhlo.broadcast_in_dim %operand, dims = [2, 1] : (tensor<1x3xi32>) -> tensor<2x3x2xi32>

特性： AlwaysSpeculatableImplTrait yimpltrait、 HLO_CompatibleOperandsAndResultElementType

インターフェイス： ConditionallySpeculatable 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

属性：

オペランド：

結果：

mhlo.case （mhlo :: caseop）

ケース操作

indexの値に応じて、 branchesから正確に1つのfunctionを実行することから出力を生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#case

例：

%result0, %result1 = "mhlo.case"(%index) ({
  mhlo.return %result_branch0, %result_branch0 : tensor<2xi64>, tensor<2xi64>
}, {
  mhlo.return %result_branch1, %result_branch1 : tensor<2xi64>, tensor<2xi64>
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)

特性： RecursiveMemoryEffects 、 SingleBlockImplicitTerminator<ReturnOp> 、 SingleBlock

インターフェイス： InferTypeOpInterface

オペランド：

結果：

mhlo.cbrt （mhlo :: cbrtop）

CBRT操作

構文：

operation ::= `mhlo.cbrt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operandテンソルで要素ごとのキュービックルート操作を実行し、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

例：

%result = mhlo.cbrt %operand : tensor<4xf32>

特性： AlwaysSpeculatableImplTrait yimpltrait、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

オペランド：

結果：

mhlo.ceil （mhlo :: ceilop）

天井操作

構文：

operation ::= `mhlo.ceil` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operandテンソルの要素ごとの天井を実行し、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

例：

%result = mhlo.ceil %operand : tensor<5xf32>

特性： AlwaysSpeculatableImplTrait yimpltrait、 CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

オペランド：

結果：

mhlo.cholesky （Mhlo :: Choleskyop）

コレスキー操作

マトリックスのバッチの軟骨の分解を計算します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

例：

%result = mhlo.cholesky %a, lower = true : tensor<3x3xf32>

特性： AlwaysSpeculatableImplTrait yimpltrait、 InferTensorType 、 SameOperandsAndResultElementType

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

属性：

オペランド：

結果：

mhlo.clamp （MHLo :: Clampop）

クランプ操作

構文：

operation ::= `mhlo.clamp` $min `,` $operand `,` $max attr-dict
              `:` custom<SameOperandsAndResultType>(type($min), type($operand), type($max), type($result))

operandテンソルのすべての要素を最小値と最大値の間でクランプし、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

例：

%result = mhlo.clamp %min, %operand, %max : tensor<3xi32>

特性： AlwaysSpeculatableImplTrait speculatableimpltrait、 HLO_BroadcastingElementwise 、 InferTensorType 、 SameOperandsAndResultElementType

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

オペランド：

結果：

mhlo.collective_broadcast （mhlo :: collectivebroadcastop）

CollectiveBroadcast Operation

プロセスグリッド内の各プロセスグループ内で、ソースプロセスからoperandテンソルの値をターゲットプロセスに送信し、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

例：

%result = "mhlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<1x2xi64>) -> tensor<1x2xi64>

特性： CompatibleOperandsAndResultType

インターフェイス： InferShapedTypeOpInterface 、 InferTypeOpInterface

属性：

オペランド：

結果：

mhlo.collective_permute （mhlo :: collectivepermuteop）

CollectivePermute操作

プロセスグリッド内の各プロセスグループ内で、ソースプロセスからターゲットプロセスにoperandテンソルの値を送信し、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

例：

%result = "mhlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<4x2xf32>) -> tensor<4x2xf32>

特性： AlwaysSpeculatableImplTrait 、 CompatibleOperandsAndResultType

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

属性：

オペランド：

結果：

mhlo.compare （mhlo :: compareop）

操作を比較します

構文：

operation ::= `mhlo.compare` $comparison_direction `,` $lhs `,` $rhs (`,` $compare_type^)?
              attr-dict `:` functional-type(operands, results)

comparison_directionとcompare_typeに従って、 lhsとrhsテンソルの要素ごとの比較を実行し、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

例：

%result = mhlo.compare LT, %lhs, %rhs, FLOAT : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>

特性： AlwaysSpeculatableImplTrait 、 Elementwise 、 InferTensorType 、 SameOperandsAndResultShape 、 SameOperandsElementType

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

属性：

オペランド：

結果：

mhlo.complex （mhlo :: complexop）

複雑な操作

構文：

operation ::= `mhlo.complex` operands attr-dict
              `:` custom<ComplexOpType>(type($lhs), type($rhs), type($result))

実際の値と架空の値、 lhsおよびrhsペアから複雑な値への要素ごとの変換を実行し、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

例：

%result = mhlo.complex %lhs, %rhs : tensor<2xcomplex<f32>>

特性： AlwaysSpeculatableImplTrait yimpltrait、 Elementwise 、 SameOperandsAndResultShape 、 SameOperandsElementType

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

オペランド：

結果：

mhlo.composite （mhlo :: compositeop）

複合操作

構文：

operation ::= `mhlo.composite` $name $inputs attr-dict `:` functional-type(operands, results)

他の安定した操作で構成された（構成された）操作をカプセル化し、 inputsとcomposite_attributesを取得し、 resultsを生成します。 OPのセマンティクスは、 decomposition属性によって実装されます。 composite OPは、プログラムセマンティクスを変更することなく、分解に置き換えることができます。分解が同じOPセマンティクスを提供しない場合、 custom_callの使用を好みます。

versionフィールド（デフォルトは0 ）を使用して、コンポジットのセマンティクスが変更されるときに示すために使用されます。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#composite

例：

%results = mhlo.composite "my.op" %arg0, %arg1 {
  decomposition = @my_op,
  composite_attributes = { my_attribute = "my_value" },
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

インターフェイス： SymbolUserOpInterface

属性：

オペランド：

結果：

mhlo.concatenate （mhlo :: concatenateop）

連結動作

指定された引数と同じ順序で、 dimension寸法に沿ったinputsの変形数のテンソルを連結し、 resultテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#concatenate

例：

%result = mhlo.concatenate %input0, %input1, dim = 0 : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>

特性： AlwaysSpeculatableImplTrait 、 SameOperandsAndResultElementType

インターフェイス： ConditionallySpeculatable 、 InferShapedTypeOpInterface 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

属性：

オペランド：

結果：

mhlo.constant （mhlo :: constantop）

一定の動作

一定のvalueからoutputテンソルを生成します。

参照：https： //github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

例：

%output = mhlo.constant dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>

特性： AlwaysSpeculatableImplTrait 、 ConstantLike

インターフェイス： ConditionallySpeculatable 、 InferTypeOpInterface 、 NoMemoryEffect (MemoryEffectOpInterface)

効果： MemoryEffects::Effect{}

属性：

結果：

mhlo.convert (mhlo::ConvertOp)

Convert operation

構文：

operation ::= `mhlo.convert` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs an element-wise conversion from one element type to another on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convert

例：

%result = mhlo.convert %operand : (tensor<3xi32>) -> tensor<3xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

構文：

operation ::= `mhlo.convolution` `(`operands`)`
              `dim_numbers` `=` custom<ConvolutionDimensions>($dimension_numbers) `,`
              `window` `=` `{` custom<WindowAttributes>($window_strides, $padding,
              $lhs_dilation, $rhs_dilation,
              $window_reversal) `}`
              attr-dict `:` functional-type(operands, results)

Computes dot products between windows of lhs and slices of rhs and produces result .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

例：

%result = "mhlo.convolution"(%lhs, %rhs) {
  window_strides = dense<4> : tensor<2xi64>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.copy (mhlo::CopyOp)

Copy operation

構文：

operation ::= `mhlo.copy` operands attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation a copy of operand . Depending on the metadata attached to the operation, it can behave quite differently from a no-op.

例：

%0 = mhlo.copy %arg0 : tensor<f32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.cosine (mhlo::CosineOp)

Cosine operation

構文：

operation ::= `mhlo.cosine` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise cosine operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cosine

例：

%result = mhlo.cosine %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

構文：

operation ::= `mhlo.count_leading_zeros` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise count of the number of leading zero bits in the operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#count_leading_zeros

例：

%result = mhlo.count_leading_zeros %operand : tensor<2x2xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

構文：

operation ::= `mhlo.create_token` attr-dict `:` type(results)

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AfterAllOp with 0 inputs: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

例：

%output = mhlo.create_token : !mhlo.token

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

結果：

mhlo.cross-replica-sum (mhlo::CrossReplicaSumOp)

CrossReplicaSum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as AllReduceOp with channel_id = 0 , use_global_device_ids = false and computation implementing addition: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

例：

%result = "mhlo.cross-replica-sum"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<4xf32>) -> tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

構文：

operation ::= `mhlo.custom_call` custom<CustomCallTarget>($call_target_name) `(` $inputs `)`
              attr-dict `:` functional-type(operands, results)

Encapsulates an implementation-defined operation call_target_name that takes inputs and called_computations and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#custom_call

例：

%results = "mhlo.custom_call"(%input0) {
  call_target_name = "foo",
  has_side_effect = false,
  backend_config = "bar",
  api_version = 1 : i32,
  called_computations = [@foo]
} : (tensor<f32>) -> tensor<f32>

A custom call invokes code external to XLA. The `inputs` are passed to the
external code, and the external code is expected to produce a result of the
given type. The exact mechanism is backend-specific. For example, in the CPU
backend, a call instruction is emitted which targets a symbol with the name
`call_target_name`.

If XLA runtime is enabled for a backend, then custom calls use the runtime
custom call calling convention to call into the external functions. This
calling convention defines an ABI for encoding arguments, attributes and
results.

Depending on the API version there are two ways to pass extra bits of static
information to the external function:

1. For `API_VERSION_TYPED_FFI` custom calls `backend_config` must be a
   dictionary attribute, that will be encoded according to the custom call
   calling convention and passed to the external function as the attributes
   argument. External code is expected to use declarative bindings (see
   `xla/runtime/custom_call.h`) to decode them at run time. These custom
   calls are only supported if XLA uses XLA runtime.

2. For previous API versions it is the user responsibility to encode extra
   bits of static information as a string `backend_config` attribute, and
   decode it at run time.

Interfaces: MemoryEffectOpInterface

Attributes:

Operands:

結果：

mhlo.divide (mhlo::DivOp)

Div operation

構文：

operation ::= `mhlo.divide` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise division of dividend lhs and divisor rhs tensors and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#divide

例：

%result = mhlo.divide %lhs, %rhs : tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.domain (mhlo::DomainOp)

Domain operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, these operations are used to group instructions with the same DomainMetadata property. ShardingMetadata is the main use case today to group instructions on the same device. Domain instructions provide two major benefits:

• Prevent unintentionally optimizing instructions across domains.
• Automatically assign the metadata of the instructions created in the domain. Without domain instructions, each HLO optimization pass would have to check and propagate the metadata, which would be easy to miss and also adds complexity to the compiler. Since domain instructions connect two different domains, each domain instruction is associated with two DomainMetadata -- one on the operand side and one on the user side of the domain.

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dot (mhlo::DotOp)

Dot operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as XLA's Dot: https://www.tensorflow.org/xla/operation_semantics#dot

例：

%0 = mhlo.dot %arg0, %arg1 : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<1x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

Computes dot products between slices of lhs and slices of rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dot_general

例：

%result = "mhlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #mhlo.dot<
    lhs_batching_dimensions = [0],
    rhs_batching_dimensions = [0],
    lhs_contracting_dimensions = [2],
    rhs_contracting_dimensions = [1]
  >,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<2x2x2xi32>, tensor<2x2x2xi32>) -> tensor<2x2x2xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

This operation is functionally identical to broadcast_in_dim op, but the result shape is specified dynamically via output_dimensions .

It also accepts optional attributes to express static knowledge about the expanding behavior of dimensions. If not specified, all dimensions are assumed to be possibly expanding. The sets of dimensions that are known to be expanding and the set of dimensions that are known to be non-expanding must be disjoint and they must be a subset of the operand's dimensions.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_broadcast_in_dim

例：

%operand = mhlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = mhlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "mhlo.dynamic_broadcast_in_dim"(%operand, %output_dimensions) {
  broadcast_dimensions = array<i64: 2, 1>,
  known_expanding_dimensions = array<i64: 0>,
  known_nonexpanding_dimensions = array<i64: 1>
} : (tensor<1x3xi64>, tensor<3xi64>) -> tensor<2x3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as ConvolutionOp except that padding is specified dynamically via d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

例：

%result = "mhlo.dynamic_conv"(%lhs, %rhs, %d_padding) {
  window_strides = dense<4> : tensor<2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>, tensor<2x2xi64>) -> tensor<1x2x2x1xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as GatherOp except that slice_sizes are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

例：

%result = "mhlo.dynamic_gather"(%operand, %start_indices, %slice_sizes) {
  dimension_numbers = #mhlo.gather<
    offset_dims = [2, 3],
    collapsed_slice_dims = [0],
    start_index_map = [0, 2],
    index_vector_dim = 2>,
  indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>, tensor<3xi64>) -> tensor<2x3x2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

This operation is functionally identical to iota op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_iota

例：

%0 = mhlo.dynamic_iota %arg0, dim = 0 : (tensor<1xindex>) -> tensor<4xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

構文：

operation ::= `mhlo.dynamic_pad` operands attr-dict `:` functional-type(operands, results)

Dynamically Pads the operand , with amount of padding added at low-end/high-end/interior is passed through input tensors.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

構文：

operation ::= `mhlo.dynamic_reshape` operands attr-dict `:` functional-type(operands, results)

This operation is functionally identical to reshape op, but the result shape is specified dynamically via output_shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_reshape

例：

%output_shape = mhlo.constant dense<[3, 2]> : tensor<2xi64>
%result = mhlo.dynamic_reshape %operand, %output_shape : (tensor<2x3xi64>, tensor<2xi64>) -> tensor<3x2xi64>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

Extracts a slice from the operand using dynamically-computed starting indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_slice

例：

%result = mhlo.dynamic_slice %operand, %start_indices0, %start_indices1, sizes = [2, 2]
  : (tensor<4x4xi32>, tensor<i64>, tensor<i64>) -> tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

構文：

operation ::= `mhlo.dynamic_update_slice` operands attr-dict `:` functional-type(operands, results)

Produces a result tensor which is equal to the operand tensor except that the slice starting at start_indices is updated with the values in update .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_update_slice

例：

%result = mhlo.dynamic_update_slice %operand, %update, %start_indices0, %start_indices1
  : (tensor<4x4xi32>, tensor<2x2xi32>, tensor<i64>, tensor<i64>) -> tensor<4x4xi32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.einsum (mhlo::EinsumOp)

Einsum operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as TF's einsum: https://www.tensorflow.org/api_docs/python/tf/einsum

例：

%result = "mhlo.einsum"(%lhs, %rhs) {
  einsum_config = "ab,bc->ac"
} : (tensor<4x16xf32>, tensor<16x4xf32>) -> tensor<4x4xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.erf (mhlo::ErfOp)

Erf operation

構文：

operation ::= `mhlo.erf` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise erf operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#erf

例：

%result = mhlo.erf %operand : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.exponential (mhlo::ExpOp)

Exp operation

構文：

operation ::= `mhlo.exponential` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential

例：

%result = mhlo.exponential %operand : tensor<2x2xf64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

構文：

operation ::= `mhlo.exponential_minus_one` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise exponential minus one operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential_minus_one

例：

%result = mhlo.exponential_minus_one %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.fft (mhlo::FftOp)

Fft operation

Performs the forward and inverse Fourier transforms for real and complex inputs/outputs.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#fft

例：

%result = mhlo.fft %operand, type = FFT, length = [4] : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.floor (mhlo::FloorOp)

Floor operation

構文：

operation ::= `mhlo.floor` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise floor of operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#floor

例：

%result = mhlo.floor %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.fusion (mhlo::FusionOp)

Fusion operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation consists of a group of basic ops (represented as a region attached to it). It serves as a hint to the backend that it is beneficial to emit the contained ops into a single loop nest or kernel.

Attributes:

Operands:

結果：

mhlo.gather (mhlo::GatherOp)

Gather operation

Gathers slices from operand tensor from offsets specified in start_indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

例：

%result = "mhlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [3, 4],
    collapsed_slice_dims = [1],
    operand_batching_dims = [0],
    start_indices_batching_dims = [1],
    start_index_map = [2, 1],
    index_vector_dim = 3>,
  slice_sizes = dense<[0, 2, 2]> : tensor<3xi64>,
  indices_are_sorted = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>) -> tensor<2x2x3x2x2xi64>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.get_dimension_size (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

Produces the size of the given dimension of the operand .

See https://github.com/openxla/stablehlo/blob/main/docs/spec.md#get_dimension_size

例：

%result = mhlo.get_dimension_size %operand, dim = 1 : (tensor<2x3xf32>) -> tensor<i32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

構文：

operation ::= `mhlo.get_tuple_element` $operand `[` $index `]` attr-dict `:` functional-type(operands, results)

Extracts element at index position of the operand tuple and produces a result .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#get_tuple_element

例：

%result = mhlo.get_tuple_element %operand[0] : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.if (mhlo::IfOp)

If operation

Produces the output from executing exactly one branch from true_branch or false_branch depending on the value of pred .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#if

Example: %result = "mhlo.if"(%pred) ({ "mhlo.return"(%result_true_branch) : (tensor ) -> () }, { "mhlo.return"(%result_false_branch) : (tensor ) -> () }) : (tensor ) -> tensor

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

Operands:

結果：

mhlo.imag (mhlo::ImagOp)

Imag operation

構文：

operation ::= `mhlo.imag` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Extracts the imaginary part, element-wise, from the operand and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#imag

例：

%result = mhlo.imag %operand : (tensor<2xcomplex<f32>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#infeed

例：

%results:2 = "mhlo.infeed"(%token) {
  infeed_config = ""
} : (!mhlo.token) -> (tensor<3x3x3xi32>, !mhlo.token)

Attributes:

Operands:

結果：

mhlo.iota (mhlo::IotaOp)

Iota operation

Fills an output tensor with values in increasing order starting from zero along the iota_dimension dimension.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#iota

例：

%output = mhlo.iota dim = 0 : tensor<4x5xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

結果：

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

構文：

operation ::= `mhlo.is_finite` $x attr-dict `:` functional-type(operands, results)

Performs element-wise check whether the value in x is finite (ie is neither +Inf, -Inf, nor NaN) and produces a y tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#is_finite

例：

%y = mhlo.is_finite %x : (tensor<7xf32>) -> tensor<7xi1>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.log (mhlo::LogOp)

Log operation

構文：

operation ::= `mhlo.log` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise logarithm operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#log

例：

%result = mhlo.log %operand : tensor<2x2xf64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

結果：