「ムロ」方言

業務

mhlo.abs (mhlo::AbsOp)

アブス手術

構文：

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

operandテンソルに対して要素ごとの絶対値演算を実行し、 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.acos (mhlo::AcosOp)

アコス作戦

構文：

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

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

例：

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

特性: CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

オペランド:

結果：

mhlo.acosh (mhlo::AcoshOp)

アコシュ作戦

構文：

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

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

例：

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

特性: CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

オペランド:

結果：

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)

AllGather作戦

プロセスグリッド内の各プロセスグループ内で、各プロセスのオペランドテンソルの値を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操作

プロセスグリッド内の各プロセスグループ内で、 operandテンソルの値をsplit_dimensionに沿って分割し、分割された部分をプロセス間で分散させ、分散された部分を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.asin (mhlo::AsinOp)

ASINオペレーション

構文：

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

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

例：

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

特性: CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

オペランド:

結果：

mhlo.asinh (mhlo::AsinhOp)

アシンオペレーション

構文：

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

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

例：

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

特性: CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

オペランド:

結果：

mhlo.async_done (mhlo::AsyncDoneOp)

AsyncDone操作

この操作はXLAコンパイラ固有のものであるため、現時点では仕様が定められていません。

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

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

インターフェース: InferTypeOpInterface

オペランド:

結果：

mhlo.async_start (mhlo::AsyncStartOp)

AsyncStart操作

この操作は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実行されるスレッドの名前です。メインスレッドは「main」と呼ばれます。すべてのスレッドには名前があります。

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

属性:

オペランド:

結果：

mhlo.async_update (mhlo::AsyncUpdateOp)

AsyncUpdate 操作

この操作は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.atanh (mhlo::AtanhOp)

アタン作戦

構文：

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

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

例：

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

特性: CompatibleOperandsAndResultType 、 Elementwise 、 SameOperandsAndResultShape

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

オペランド:

結果：

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

バッチ正規化演算

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)

バッチ正規化推論操作

operandテンソルをfeature_index次元を除くすべての次元で正規化し、 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)

バッチ正規化トレーニング操作

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 の Broadcast と同じことを行います: https://www.tensorflow.org/xla/operation_semantics#broadcast

例：

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

特性: AlwaysSpeculatableImplTrait 、 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 、 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 、 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 、 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 、 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 、 HLO_BroadcastingElementwise 、 InferTensorType 、 SameOperandsAndResultElementType

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

効果: MemoryEffects::Effect{}

オペランド:

結果：

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

集団放送作戦

プロセスグリッド内の各プロセスグループ内で、 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)

集団順列操作

プロセスグリッド内の各プロセスグループ内で、 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 、 Elementwise 、 SameOperandsAndResultShape 、 SameOperandsElementType

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

Effects: MemoryEffects::Effect{}

Operands:

結果：

mhlo.composite (mhlo::CompositeOp)

Composite operation

構文：

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

Encapsulates an operation made up (composed) of other StableHLO operations, taking inputs and composite_attributes and producing results . The semantics of the op are implemented by the decomposition attribute. The composite op can be replaced with its decomposition without changing program semantics. In cases where inlining the decomposition does not provide the same op semantics, prefer using custom_call .

The version field (defaults to 0 ) is used to denote when a composite's semantics change.

See: 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>

Interfaces: SymbolUserOpInterface

Attributes:

Operands:

結果：

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

Concatenates a variadic number of tensors in inputs along dimension dimension in the same order as the given arguments and produces a result tensor.

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

例：

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

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

結果：

mhlo.constant (mhlo::ConstantOp)

Constant operation

Produces an output tensor from a constant value .

See: 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>

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

結果：

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.cosh (mhlo::CoshOp)

Cosh operation

構文：

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

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

例：

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

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{}

Attributes:

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.

例：

%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{}

Attributes:

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{}

Attributes:

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:

結果：