`mhlo` Dialekt

Operacje

mhlo.abs (mhlo::AbsOp)

Operacja brzucha

Składnia:

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

Wykonuje operację abs na tensorze operand elementarnego i generuje tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand

Opis

operand

tensor rangowany 2/4/8/16/32/64-bitowych liczb całkowitych bez znaku lub 4/6/8/16/32/64-bitowych liczb zmiennoprzecinkowych lub typu zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub 2/4/8/16/32-bitowymi jednorodnymi skwantyzowanymi liczbami całkowitymi ze znakiem lub 2/4/8/16/32-bitowymi jednorodnymi skwantyzowanymi liczbami całkowitymi bez znaku lub 2/4/8/16/32-bitowymi jednorodnymi skwantyzowanymi wartościami liczb całkowitych bez znaku na oś

Wyniki:

Wynik

Opis

result

tensor rangowany 2/4/8/16/32/64-bitowych liczb całkowitych bez znaku lub 4/6/8/16/32/64-bitowych liczb zmiennoprzecinkowych lub 2/4/8/16/32-bitowych jednorodnych skwantyzowanych liczb całkowitych ze znakiem lub 2/4/8/16/32-bitowych jednorodnych skwantyzowanych liczb całkowitych ze znakiem na oś lub 2/4/8/16/32-bitowych jednorodnych skwantyzowanych liczb całkowitych bez znaku lub 2/4/8/16/32-bitowych jednorodnych skwantyzowanych liczb całkowitych bez znaku na oś

mhlo.acos (mhlo::AcosOp)

Operacja Acos

Składnia:

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

Wykonuje operację acos na tensorze operand elementarnego i zwraca tensor result .

Przykład:

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

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Operand	Opis
operand	tensor typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

Wyniki:

Wynik	Opis
result	tensor typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

mhlo.acosh (mhlo::AcoshOp)

Operacja Acosh

Składnia:

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

Wykonuje operację acosh elementarną na tensorze operand i generuje tensor result .

Przykład:

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

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Operand	Opis
operand	tensor typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

Wyniki:

Wynik	Opis
result	tensor typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

mhlo.add (mhlo::AddOp)

Dodaj operację

Składnia:

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

Wykonuje dodawanie elementarne dwóch tensorów lhs i rhs i generuje tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
lhs	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś
rhs	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
result	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.add_dependency (mhlo::AddDependencyOp)

Operacja AddDependency

Składnia:

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

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie, ta operacja ma dwa operandy: operand danych i token. Wynikiem operacji jest operand danych. W połączeniu z funkcją AfterAll, operacja ta umożliwia uporządkowanie operacji niepowodujących efektów ubocznych (czyli tych, które nie generują wartości tokenów).

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub tensor rangowany wartościami całkowitymi na oś lub token lub token stablehlo
token	token lub token stablehlo

Wyniki:

Wynik	Opis
output	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub tensor rangowany wartościami całkowitymi na oś lub token lub token stablehlo

mhlo.after_all (mhlo::AfterAllOp)

Operacja AfterAll

Składnia:

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

Zapewnia, że ​​operacje generujące dane inputs są wykonywane przed operacjami zależnymi od result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
inputs	wariadyczny tokena

Wyniki:

Wynik	Opis
result	znak

mhlo.all_gather (mhlo::AllGatherOp)

Operacja AllGather

W obrębie każdej grupy procesów w siatce procesów, funkcja łączy wartości tensora operandu z każdego procesu wzdłuż all_gather_dim i generuje tensor wynikowy. computation są przeprowadzane oddzielnie dla każdego operandu w operands , generując jeden wynik na operand.

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

Przykład:

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

Cechy: SameOperandsAndResultElementType

Atrybuty:

Atrybut	Typ MLIR	Opis
all_gather_dim	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest nieujemna
replica_groups	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
channel_handle	::mlir::mhlo::ChannelHandleAttr	dwie 64-bitowe liczby całkowite „uchwyt” i „typ”
use_global_device_ids	::mlir::UnitAttr	atrybut jednostki

Operandy:

Operand	Opis
operands	zmienna tensora rangowanego o 4/6/8/16/32/64-bitowym floatie lub bool lub 2/4/8/16/32/64-bitowym interze lub typie zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	zmienna tensora rangowanego o 4/6/8/16/32/64-bitowym floatie lub bool lub 2/4/8/16/32/64-bitowym interze lub typie zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub na oś

mhlo.all_reduce (mhlo::AllReduceOp)

Operacja AllReduce

W każdej grupie procesów w siatce procesów stosuje computation funkcji redukcji do wartości tensora operandu z każdego procesu i generuje tensor wynikowy. computation jest przeprowadzane oddzielnie dla każdego operandu w operands , generując jeden wynik na operand.

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

Przykład:

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

Cechy: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Atrybuty:

Atrybut	Typ MLIR	Opis
replica_groups	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
channel_handle	::mlir::mhlo::ChannelHandleAttr	dwie 64-bitowe liczby całkowite „uchwyt” i „typ”
use_global_device_ids	::mlir::UnitAttr	atrybut jednostki

Operandy:

Operand	Opis
operands	zmienna tensora rangowanego o 4/6/8/16/32/64-bitowym floatie lub bool lub 2/4/8/16/32/64-bitowym interze lub typie zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	zmienna tensora rangowanego o 4/6/8/16/32/64-bitowym floatie lub bool lub 2/4/8/16/32/64-bitowym interze lub typie zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub na oś

mhlo.all_to_all (mhlo::AllToAllOp)

Operacja AllToAll

W obrębie każdej grupy procesów w siatce procesów dzieli wartości tensora operand wzdłuż split_dimension na części, rozprasza podzielone części pomiędzy procesami, łączy rozproszone części wzdłuż concat_dimension i generuje tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
split_dimension	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest nieujemna
concat_dimension	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest nieujemna
split_count	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia
replica_groups	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
channel_handle	::mlir::mhlo::ChannelHandleAttr	dwie 64-bitowe liczby całkowite „uchwyt” i „typ”

Operandy:

Operand	Opis
operand	zmienna tensora rangowanego o 4/6/8/16/32/64-bitowym floatie lub bool lub 2/4/8/16/32/64-bitowym interze lub typie zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	zmienna tensora rangowanego o 4/6/8/16/32/64-bitowym floatie lub bool lub 2/4/8/16/32/64-bitowym interze lub typie zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub na oś

mhlo.and (mhlo::AndOp)

I operacja

Składnia:

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

Wykonuje elementarne AND dwóch tensorów lhs i rhs i generuje tensor result

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
lhs	tensor rangowany wartości boolowskich lub całkowitych 2/4/8/16/32/64-bitowych
rhs	tensor rangowany wartości boolowskich lub całkowitych 2/4/8/16/32/64-bitowych

Wyniki:

Wynik	Opis
result	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.asin (mhlo::AsinOp)

Operacja Asin

Składnia:

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

Wykonuje operację asin na tensorze operand elementarnego i generuje tensor result .

Przykład:

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

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Operand	Opis
operand	tensor typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

Wyniki:

Wynik	Opis
result	tensor typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

mhlo.async_done (mhlo::AsyncDoneOp)

Operacja AsyncDone

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie, operacja ta blokuje się do końca obliczeń asynchronicznych. Zwraca ona wynik końcowy obliczeń asynchronicznych.

Więcej informacji znajdziesz w dokumentacji AsyncStart.

Interfejsy: InferTypeOpInterface

Operandy:

Operand	Opis
bundle	async_bundle z dowolną kombinacją tensora rankingowego 4/6/8/16/32/64-bitowego typu float lub bool lub 2/4/8/16/32/64-bitowego typu integer lub typu zespolonego z 32/64-bitowymi elementami float lub wartościami kwantyzowanymi na tensor lub na oś lub wartościami tokenów lub tokenów stablehlo

Wyniki:

Wynik

Opis

"anonimowy"

zmiennoprzecinkowy tensor o 4/6/8/16/32/64-bitowym floatie lub wartości logicznej lub 2/4/8/16/32/64-bitowym typie całkowitym lub zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub skwantyzowanymi wartościami całkowitymi na oś lub tokenem lub tokenem stablehlo lub zagnieżdżoną krotką z dowolną kombinacją tensorów o 4/6/8/16/32/64-bitowym floatie lub wartościach logicznych lub 2/4/8/16/32/64-bitowym integerze lub zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub memref o 4/6/8/16/32/64-bitowym floatie lub wartościach logicznych lub 2/4/8/16/32/64-bitowym integerze lub zespolonym z 32/64-bitowymi elementy zmiennoprzecinkowe lub skwantyzowane wartości całkowite na tensor lub tensor rangowany skwantyzowanych wartości całkowitych na oś lub wartości tokenów

mhlo.async_start (mhlo::AsyncStartOp)

Operacja AsyncStart

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie operacja ta rozpoczyna obliczenia asynchroniczne.

Używa się tego, gdy istnieją funkcje zawierające zarówno asynchroniczne oczekiwania (takie jak DMA), jak i obliczenia w wątku. Na przykład funkcja może składać się z obliczenia, DMA, kolejnego obliczenia, drugiego DMA i ostatecznego obliczenia. Byłoby to reprezentowane jako async_start, po którym następują async_update i async_done. Async_start wykonałby pierwsze obliczenie w wątku, a następnie uruchomiłby DMA. Async_update czekałby na zakończenie DMA, jeśli jeszcze nie zostało zakończone, a następnie wykonałby drugie obliczenie w funkcji i uruchomiłby drugie DMA. Na koniec async_done czekałby na to ostatnie DMA, a następnie uruchomiłby ostatnie obliczenie, które musi zostać wykonane w wątku i zwróciłby wynik tego ostatecznego obliczenia.

operands są przekazywane bezpośrednio do obliczeń. called_computation to funkcja, która zostanie uruchomiona asynchronicznie. execution_thread to nazwa wątku, w którym zostanie uruchomiona. Wątek główny nazywany jest „main”. Wszystkie wątki mają nazwy.

Zwraca cały stan potrzebny między operacjami asynchronicznymi. Po przypisaniu bufora, wartości zwracane reprezentują przestrzeń potrzebną do przechowywania danych wejściowych, wyników oraz wszelkich plików roboczych potrzebnych lub edytowanych przez operację asynchroniczną.

Atrybuty:

Atrybut	Typ MLIR	Opis
called_computation	::mlir::FlatSymbolRefAttr	atrybut odniesienia symbolu płaskiego
execution_thread	::mlir::StringAttr	atrybut ciągu

Operandy:

Operand

Opis

inputs

zmiennoprzecinkowy tensor o 4/6/8/16/32/64-bitowym floatie lub wartości logicznej lub 2/4/8/16/32/64-bitowym typie całkowitym lub zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub skwantyzowanymi wartościami całkowitymi na oś lub tokenem lub tokenem stablehlo lub zagnieżdżoną krotką z dowolną kombinacją tensorów o 4/6/8/16/32/64-bitowym floatie lub wartościach logicznych lub 2/4/8/16/32/64-bitowym integerze lub zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub memref o 4/6/8/16/32/64-bitowym floatie lub wartościach logicznych lub 2/4/8/16/32/64-bitowym integerze lub zespolonym z 32/64-bitowymi elementy zmiennoprzecinkowe lub skwantyzowane wartości całkowite na tensor lub tensor rangowany skwantyzowanych wartości całkowitych na oś lub wartości tokenów

Wyniki:

Wynik	Opis
"anonimowy"	async_bundle z dowolną kombinacją tensora rankingowego 4/6/8/16/32/64-bitowego typu float lub bool lub 2/4/8/16/32/64-bitowego typu integer lub typu zespolonego z 32/64-bitowymi elementami float lub wartościami kwantyzowanymi na tensor lub na oś lub wartościami tokenów lub tokenów stablehlo

mhlo.async_update (mhlo::AsyncUpdateOp)

Operacja AsyncUpdate

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie, ta operacja blokuje obliczenia asynchroniczne do momentu wystąpienia bariery synchronizacji. Po wykonaniu operacji zwracana jest wartość bundle .

Więcej informacji znajdziesz w dokumentacji AsyncStart.

Interfejsy: InferTypeOpInterface

Operandy:

Operand	Opis
bundle	async_bundle z dowolną kombinacją tensora rankingowego 4/6/8/16/32/64-bitowego typu float lub bool lub 2/4/8/16/32/64-bitowego typu integer lub typu zespolonego z 32/64-bitowymi elementami float lub wartościami kwantyzowanymi na tensor lub na oś lub wartościami tokenów lub tokenów stablehlo

Wyniki:

Wynik	Opis
"anonimowy"	async_bundle z dowolną kombinacją tensora rankingowego 4/6/8/16/32/64-bitowego typu float lub bool lub 2/4/8/16/32/64-bitowego typu integer lub typu zespolonego z 32/64-bitowymi elementami float lub wartościami kwantyzowanymi na tensor lub na oś lub wartościami tokenów lub tokenów stablehlo

mhlo.atan2 (mhlo::Atan2Op)

Operacja Atan2

Składnia:

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

Wykonuje operację atan2 na elementach tensora lhs i rhs i generuje tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
lhs	tensor rangowany typu float 4/6/8/16/32/64-bitowego lub typu zespolonego z elementami float 32/64-bitowymi lub skwantyzowanymi wartościami całkowitymi na tensor
rhs	tensor rangowany typu float 4/6/8/16/32/64-bitowego lub typu zespolonego z elementami float 32/64-bitowymi lub skwantyzowanymi wartościami całkowitymi na tensor

Wyniki:

Wynik	Opis
result	tensor rangowany typu float 4/6/8/16/32/64-bitowego lub typu zespolonego z elementami float 32/64-bitowymi lub skwantyzowanymi wartościami całkowitymi na tensor

mhlo.atanh (mhlo::AtanhOp)

Operacja Atanh

Składnia:

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

Wykonuje operację atanh elementarną na tensorze operand i generuje tensor result .

Przykład:

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

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Operand	Opis
operand	tensor typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

Wyniki:

Wynik	Opis
result	tensor typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Operacja BatchNormGrad

Oblicza gradienty kilku wejść BatchNormTrainingOp, propagując wstecz od grad_output , i generuje tensory grad_operand , grad_scale i grad_offset .

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

Przykład:

%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>)

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
epsilon	::mlir::FloatAttr	32-bitowy atrybut float
feature_index	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest nieujemna

Operandy:

Operand	Opis
operand	tensor rankingowy wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
scale	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
mean	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
variance	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
grad_output	tensor rankingowy wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych

Wyniki:

Wynik	Opis
grad_operand	tensor rankingowy wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
grad_scale	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
grad_offset	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Operacja BatchNormInference

Normalizuje tensor operand we wszystkich wymiarach, z wyjątkiem wymiaru feature_index , i generuje tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
epsilon	::mlir::FloatAttr	32-bitowy atrybut float
feature_index	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest nieujemna

Operandy:

Operand	Opis
operand	tensor rankingowy wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
scale	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
offset	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
mean	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
variance	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych

Wyniki:

Wynik	Opis
result	tensor rankingowy wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operacja BatchNormTraining

Oblicza średnią i wariancję w wymiarach wsadowych i przestrzennych oraz normalizuje tensor operand dla każdej cechy w wymiarze feature_index i generuje output , tensory batch_mean i batch_var .

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

Przykład:

%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>)

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
epsilon	::mlir::FloatAttr	32-bitowy atrybut float
feature_index	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest nieujemna

Operandy:

Operand	Opis
operand	tensor rankingowy wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
scale	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
offset	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych

Wyniki:

Wynik	Opis
output	tensor rankingowy wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
batch_mean	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych
batch_var	1D tensor wartości zmiennoprzecinkowych 4/6/8/16/32/64-bitowych

mhlo.bitcast (mhlo::BitcastOp)

Operacja bitcastowa

Składnia:

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

Operacja ta jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie operacja ta zmienia kształt danych wejściowych w taki sposób, że fizyczny układ elementów pozostaje niezmieniony.

Operacja ta wymaga informacji o układzie, aby zrozumieć „fizyczne rozmieszczenie elementów”, a obsługa układu w MHLO jest obecnie w toku.

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Operacja BitcastConvert

Składnia:

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

Wykonuje operację bitcast na tensorze operand i generuje tensor result , w którym bity całego tensora operand są reinterpretowane przy użyciu typu tensora result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.broadcast (mhlo::BroadcastOp)

Operacja nadawania

Ta operacja jest już poza systemem StableHLO, dlatego nie jest uwzględniona w specyfikacji: https://github.com/openxla/stablehlo/issues/3

Nieformalnie ta operacja wykonuje to samo, co Broadcast XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
broadcast_sizes	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku

Operandy:

Operand	Opis
operand	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Operacja BroadcastInDim

Rozszerza wymiary i/lub rangę tensora wejściowego poprzez duplikację danych w tensorze operand i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
broadcast_dimensions	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku

Operandy:

Operand	Opis
operand	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	statycznie ukształtowany lub jednowymiarowy tensor o ograniczonym wymiarze 4/6/8/16/32/64-bitowy typu float lub bool lub 2/4/8/16/32/64-bitowy typu całkowitego lub zespolonego z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.case (mhlo::CaseOp)

Operacja przypadku

Tworzy dane wyjściowe z wykonania dokładnie jednej function z branches w zależności od wartości index .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

Przykład:

%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>)

Cechy: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfejsy: InferTypeOpInterface

Operandy:

Operand	Opis
index	tensor 32-bitowych wartości całkowitych bez znaku

Wyniki:

Wynik	Opis
"anonimowy"	zmiennoprzecinkowy tensor o 4/6/8/16/32/64-bitowym floatie lub bool lub 2/4/8/16/32/64-bitowym interze lub typie zespolonym z 32/64-bitowymi elementami float lub skwantyzowanymi wartościami całkowitymi na tensor lub tensor o kwantyzowanych wartościach całkowitych na oś lub token

mhlo.cbrt (mhlo::CbrtOp)

Operacja CBRT

Składnia:

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

Wykonuje operację pierwiastka sześciennego na tensorze operand i zwraca tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	Wymagana dokładność dla operacji unarnych.

Operandy:

Operand	Opis
operand	tensor rangowany typu float 4/6/8/16/32/64-bitowego lub typu zespolonego z elementami float 32/64-bitowymi lub skwantyzowanymi wartościami całkowitymi na tensor

Wyniki:

Wynik	Opis
result	tensor rangowany typu float 4/6/8/16/32/64-bitowego lub typu zespolonego z elementami float 32/64-bitowymi lub skwantyzowanymi wartościami całkowitymi na tensor

mhlo.ceil (mhlo::CeilOp)

Operacja sufitowa

Składnia:

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

Wykonuje elementarną funkcję tensora operand i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	tensor rangowany 4/6/8/16/32/64-bitowych wartości zmiennoprzecinkowych lub całkowitych na tensor skwantyzowanych

Wyniki:

Wynik	Opis
result	tensor rangowany 4/6/8/16/32/64-bitowych wartości zmiennoprzecinkowych lub całkowitych na tensor skwantyzowanych

mhlo.cholesky (mhlo::ColeskyOp)

Operacja Choleskiego

Oblicza rozkład Choleskiego dla zestawu macierzy.

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
lower	::mlir::BoolAttr	atrybut bool

Operandy:

Operand	Opis
a	tensor rankingowy typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

Wyniki:

Wynik	Opis
"anonimowy"	tensor rankingowy typu float 4/6/8/16/32/64-bitowego lub typu złożonego z wartościami elementów float 32/64-bitowymi

mhlo.clamp (mhlo::ClampOp)

Operacja zacisku

Składnia:

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

Zaciska każdy element tensora operand pomiędzy wartością minimalną i maksymalną i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
min	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś
operand	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś
max	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
result	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Operacja CollectiveBroadcast

W obrębie każdej grupy procesów w siatce procesów wyślij wartość tensora operand z procesu źródłowego do procesów docelowych i wygeneruj tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

Przykład:

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

Cechy: CompatibleOperandsAndResultType

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Atrybuty:

Atrybut	Typ MLIR	Opis
replica_groups	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
channel_handle	::mlir::mhlo::ChannelHandleAttr	dwie 64-bitowe liczby całkowite „uchwyt” i „typ”

Operandy:

Operand	Opis
operand	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Operacja CollectivePermute

W obrębie każdej grupy procesów w siatce procesów wysyła wartość tensora operand z procesu źródłowego do procesu docelowego i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
source_target_pairs	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
channel_handle	::mlir::mhlo::ChannelHandleAttr	dwie 64-bitowe liczby całkowite „uchwyt” i „typ”

Operandy:

Operand	Opis
operand	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

mhlo.compare (mhlo::CompareOp)

Porównaj operację

Składnia:

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

Wykonuje porównanie elementarne tensorów lhs i rhs zgodnie z comparison_direction i compare_type i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
comparison_direction	::mlir::mhlo::AttrKierunkuPorównania	Którą operację porównania wykonać.
compare_type	::mlir::mhlo::ComparisonTypeAttr	Jakiego typu porównania użyć.

Operandy:

Operand	Opis
lhs	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś
rhs	tensor rangowany 4/6/8/16/32/64-bitowy float lub bool lub 2/4/8/16/32/64-bitowy integer lub typ zespolony z 32/64-bitowymi elementami float lub wartościami całkowitymi skwantyzowanymi na tensor lub na oś

Wyniki:

Wynik	Opis
"anonimowy"	tensor rangowany wartości boolowskich

mhlo.complex (mhlo::ComplexOp)

Złożona operacja

Składnia:

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

Wykonuje konwersję elementarną na wartość zespoloną z pary wartości rzeczywistych i urojonych, lhs i rhs , i generuje tensor result .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
lhs	tensor rankingowy 32/64-bitowych wartości zmiennoprzecinkowych
rhs	tensor rankingowy 32/64-bitowych wartości zmiennoprzecinkowych

Wyniki:

Wynik	Opis
result	tensor rangowany typu złożonego z wartościami elementów zmiennoprzecinkowych 32/64-bitowych

mhlo.composite (mhlo::CompositeOp)

Operacja kompozytowa

Składnia:

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

Hermetyzuje operację złożoną (złożoną) z innych operacji StableHLO, pobierającą inputs i composite_attributes oraz generującą results . Semantyka operacji jest implementowana przez atrybut decomposition . Operację composite można zastąpić jej rozkładem bez zmiany semantyki programu. W przypadkach, gdy wstawienie dekompozycji nie zapewnia tej samej op semantyki, lepiej użyć custom_call .

Pole version (domyślnie 0 ) służy do wskazania, kiedy zmienia się semantyka kompozytu.

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#composite

Przykład:

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

Interfejsy: SymbolUserOpInterface

Atrybuty:

Atrybut	Typ MLIR	Opis
name	::mlir::StringAttr	atrybut ciągu
composite_attributes	::mlir::DictionaryAttr	słownik nazwanych wartości atrybutów
decomposition	::mlir::FlatSymbolRefAttr	atrybut odniesienia do symbolu płaskiego
version	::mlir::IntegerAttr	32-bitowy atrybut liczby całkowitej bez znaku

Operandy:

Operand

Opis

inputs

variadic uszeregowanego tensora o 4/6/8/16/32/64-bitowym zmiennoprzecinkowym lub boolowym lub 2/4/8/16/32/64-bitowym typie całkowitym lub zespolonym z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbami całkowitymi na tensor, skwantowanymi lub wartościami całkowitymi skwantowanymi na osi lub tokenem lub zagnieżdżoną krotką z dowolną kombinacją uszeregowanego tensora 4/6/8/16/32/64-bitowy typ zmiennoprzecinkowy lub bool lub 2/4/8/16/32/64-bitowy typ całkowity lub złożony z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi wartościami całkowitymi na tensor lub memref 4/6/8/16/32/64-bitowy zmiennoprzecinkowy lub bool lub 2/4/8/16/32/64-bitowa liczba całkowita lub zespolona typ z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowane wartości całkowite na tensor lub tensor rankingowy skwantowanych wartości całkowitych na oś lub wartości tokenów

Wyniki:

Wynik

Opis

"anonimowy"

variadic uszeregowanego tensora o 4/6/8/16/32/64-bitowym zmiennoprzecinkowym lub boolowym lub 2/4/8/16/32/64-bitowym typie całkowitym lub zespolonym z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbami całkowitymi na tensor, skwantowanymi lub wartościami całkowitymi skwantowanymi na osi lub tokenem lub zagnieżdżoną krotką z dowolną kombinacją uszeregowanego tensora 4/6/8/16/32/64-bitowy typ zmiennoprzecinkowy lub bool lub 2/4/8/16/32/64-bitowy typ całkowity lub złożony z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi wartościami całkowitymi na tensor lub memref 4/6/8/16/32/64-bitowy zmiennoprzecinkowy lub bool lub 2/4/8/16/32/64-bitowa liczba całkowita lub zespolona typ z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowane wartości całkowite na tensor lub tensor rankingowy skwantowanych wartości całkowitych na oś lub wartości tokenów

mhlo.concatenate (mhlo::ConcatenateOp)

Połącz operację

Łączy zmienną liczbę tensorów w inputs wzdłuż dimension w tej samej kolejności, w jakiej podane są argumenty, i tworzy tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
dimension	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest nieujemna

Operandy:

Operand	Opis
val	variadic tensora rankingowego o 4/6/8/16/32/64-bitowym zmiennoprzecinkowym lub boolowym lub 2/4/8/16/32/64-bitowym typie całkowitym lub zespolonym z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowanymi liczbami całkowitymi na tensor lub wartościami całkowitymi skwantowanymi na oś

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.constant (mhlo::ConstantOp)

Ciągła praca

Tworzy tensor output na podstawie stałej value .

Zobacz: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , ConstantLike

Interfejsy: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
value	::mlir::ElementsAttr	stały atrybut wektora/tensora

Wyniki:

Wynik	Opis
output	statycznie ukształtowany tensor typu zmiennoprzecinkowego 4/6/8/16/32/64-bitowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbami całkowitymi na tensor, skwantowanymi lub wartościami całkowitymi na osi

mhlo.convert (mhlo::ConvertOp)

Operacja konwersji

Składnia:

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

Wykonuje konwersję elementową z jednego typu elementu na inny na tensorze operand i tworzy tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfejsy: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

Wyniki:

Wynik	Opis
result	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.convolution (mhlo::ConvolutionOp)

Operacja splotu

Składnia:

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)

Oblicza iloczyny skalarne pomiędzy oknami lhs i wycinkami rhs i daje result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
window_strides	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
padding	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
lhs_dilation	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
rhs_dilation	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
window_reversal	::mlir::DenseElementsAttr	stały atrybut wektora logicznego/tensora
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Struktura informacji o wymiarach dla operacji konw
feature_group_count	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia
batch_group_count	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia
precision_config	::mlir::ArrayAttr	Atrybut konfiguracji precyzyjnej

Operandy:

Operand	Opis
lhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
rhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.copy (mhlo::CopyOp)

Operacja kopiowania

Składnia:

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

Ta operacja jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie ta operacja jest kopią operand . W zależności od metadanych dołączonych do operacji może ona zachowywać się zupełnie inaczej niż w przypadku braku operacji.

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
cross_program_prefetch_index	::mlir::IntegerAttr	32-bitowy atrybut liczby całkowitej bez znaku

Operandy:

Operand

Opis

operand

uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor skwantowaną lub wartością całkowitą na osi skwantowaną lub tokenem lub zagnieżdżoną krotką z dowolną kombinacją uszeregowanego tensora 4/6/8/16/32/64-bitowy typ zmiennoprzecinkowy lub bool lub 2/4/8/16/32/64-bitowy typ całkowity lub złożony z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi wartościami całkowitymi na tensor lub memref 4/6/8/16/32/64-bitowy zmiennoprzecinkowy lub bool lub 2/4/8/16/32/64-bitowa liczba całkowita lub zespolona typ z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor wartości skwantowane lub tensor rankingowy skwantowanych wartości całkowitych na oś lub wartości symboliczne

Wyniki:

Wynik

Opis

result

uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor skwantowaną lub wartością całkowitą na osi skwantowaną lub tokenem lub zagnieżdżoną krotką z dowolną kombinacją uszeregowanego tensora 4/6/8/16/32/64-bitowy typ zmiennoprzecinkowy lub bool lub 2/4/8/16/32/64-bitowy typ całkowity lub złożony z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi wartościami całkowitymi na tensor lub memref 4/6/8/16/32/64-bitowy zmiennoprzecinkowy lub bool lub 2/4/8/16/32/64-bitowa liczba całkowita lub zespolona typ z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor wartości skwantowane lub tensor rankingowy skwantowanych wartości całkowitych na oś lub wartości symboliczne

mhlo.cosh (mhlo::CoshOp)

Operacja Cosh

Składnia:

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

Wykonuje elementarną operację cosh na tensorze operand i generuje tensor result .

Przykład:

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

Cechy: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfejsy: InferShapedTypeOpInterface , InferTypeOpInterface

Operandy:

Operand	Opis
operand	tensor typu zmiennoprzecinkowego 4/6/8/16/32/64-bitowego lub złożonego z 32/64-bitowymi wartościami elementów zmiennoprzecinkowych

Wyniki:

Wynik	Opis
result	tensor typu zmiennoprzecinkowego 4/6/8/16/32/64-bitowego lub złożonego z 32/64-bitowymi wartościami elementów zmiennoprzecinkowych

mhlo.cosine (mhlo::CosineOp)

Operacja cosinusowa

Składnia:

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

Wykonuje elementarną operację cosinus na tensorze operand i generuje tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	Żądana dokładność dla operacji jednoargumentowych.

Operandy:

Operand	Opis
operand	uszeregowany tensor typu zmiennoprzecinkowego 4/6/8/16/32/64-bitowego lub złożonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowanymi wartościami całkowitymi na tensor

Wyniki:

Wynik	Opis
result	uszeregowany tensor typu zmiennoprzecinkowego 4/6/8/16/32/64-bitowego lub złożonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowanymi wartościami całkowitymi na tensor

mhlo.count_leading_zeros (mhlo::ClzOp)

Operacja Clz

Składnia:

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

Wykonuje elementarne zliczenie liczby wiodących bitów zerowych w tensorze operand i generuje tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	uszeregowany tensor 2/4/8/16/32/64-bitowych wartości całkowitych

Wyniki:

Wynik	Opis
result	uszeregowany tensor 2/4/8/16/32/64-bitowych wartości całkowitych

mhlo.create_token (mhlo::CreateTokenOp)

Operacja CreateToken

Składnia:

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

Ta operacja jest już wycofywana ze StableHLO, więc nie jest uwzględniona w specyfikacji: https://github.com/openxla/stablehlo/issues/3

Nieformalnie ta operacja robi to samo, co AfterAllOp z 0 wejściami: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Przykład:

%output = mhlo.create_token : !mhlo.token

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Wyniki:

Wynik	Opis
output	znak

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

Operacja CrossReplicaSum

Ta operacja jest już wycofywana ze StableHLO, więc nie jest uwzględniona w specyfikacji: https://github.com/openxla/stablehlo/issues/3

Nieformalnie ta operacja robi to samo, co AllReduceOp z channel_id = 0 , use_global_device_ids = false i dodatkiem implementującym computation : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
replica_groups	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.custom_call (mhlo::CustomCallOp)

Operacja CustomCall

Składnia:

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

Hermetyzuje zdefiniowaną w implementacji operację call_target_name która pobiera inputs i called_computations a następnie generuje results .

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

Przykład:

%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.

Interfejsy: MemoryEffectOpInterface

Atrybuty:

Atrybut	Typ MLIR	Opis
call_target_name	::mlir::StringAttr	atrybut ciągu
has_side_effect	::mlir::BoolAttr	atrybut boolowy
backend_config	::mlir::Atrybut	atrybut łańcuchowy lub słownik nazwanych wartości atrybutów
api_version	::mlir::mhlo::CustomCallApiVersionAttr	Wersja interfejsu API wywołań niestandardowych
called_computations	::mlir::ArrayAttr	atrybut tablicowy symbolu płaskiego ref
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	Określa żądany harmonogram połączenia niestandardowego.
operand_layouts	::mlir::ArrayAttr	Tablica atrybutów układu (tensor 1D typu indeksu).
result_layouts	::mlir::ArrayAttr	Tablica atrybutów układu (tensor 1D typu indeksu).
output_operand_aliases	::mlir::ArrayAttr	Atrybut aliasingu dla wyjść i operandów CustomCall

Operandy:

Operand

Opis

inputs

variadic tensora typu zmiennoprzecinkowego 4/6/8/16/32/64-bitowego lub typu bool 2/4/8/16/32/64-bitowego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbami całkowitymi na tensor, skwantowanymi lub wartościami całkowitymi skwantowanymi na osi lub memrefami 4/6/8/16/32/64-bitowymi zmiennoprzecinkowymi lub bool lub 2/4/8/16/32/64-bitowa liczba całkowita lub typ zespolony z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowanymi wartościami całkowitymi na tensor lub token lub zagnieżdżona krotka z dowolną kombinacją tensora 4/6/8/16/32/64-bitowego zmiennoprzecinkowego lub bool lub 2/4/8/16/32/64-bitowa liczba całkowita lub typ zespolony z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczba całkowita na tensor skwantowana lub liczba całkowita na osi, skwantowane wartości lub memref 4/6/8/16/32/64-bitowej liczby zmiennoprzecinkowej lub bool lub 2/4/8/16/32/64-bitowej liczby całkowitej lub typu zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub wartościami całkowitymi na tensor lub wartościami tokenowymi

Wyniki:

Wynik

Opis

"anonimowy"

variadic tensora typu zmiennoprzecinkowego 4/6/8/16/32/64-bitowego lub typu bool 2/4/8/16/32/64-bitowego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbami całkowitymi na tensor, skwantowanymi lub wartościami całkowitymi skwantowanymi na osi lub memrefami 4/6/8/16/32/64-bitowymi zmiennoprzecinkowymi lub bool lub 2/4/8/16/32/64-bitowa liczba całkowita lub typ zespolony z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowanymi wartościami całkowitymi na tensor lub token lub zagnieżdżona krotka z dowolną kombinacją tensora 4/6/8/16/32/64-bitowego zmiennoprzecinkowego lub bool lub 2/4/8/16/32/64-bitowa liczba całkowita lub typ zespolony z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczba całkowita na tensor skwantowana lub liczba całkowita na osi, skwantowane wartości lub memref 4/6/8/16/32/64-bitowej liczby zmiennoprzecinkowej lub bool lub 2/4/8/16/32/64-bitowej liczby całkowitej lub typu zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub wartościami całkowitymi na tensor lub wartościami tokenowymi

mhlo.divide (mhlo::DivOp)

Operacja div

Składnia:

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

Wykonuje elementarny podział tensora dzielnej lhs i dzielnika rhs i tworzy tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
lhs	uszeregowany tensor 2/4/8/16/32/64-bitowej liczby całkowitej lub 4/6/8/16/32/64-bitowej liczby zmiennoprzecinkowej lub typu złożonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi liczbami całkowitymi na tensor lub wartościami całkowitymi skwantowanymi na oś
rhs	uszeregowany tensor 2/4/8/16/32/64-bitowej liczby całkowitej lub 4/6/8/16/32/64-bitowej liczby zmiennoprzecinkowej lub typu złożonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi liczbami całkowitymi na tensor lub wartościami całkowitymi skwantowanymi na oś

Wyniki:

Wynik	Opis
result	uszeregowany tensor 2/4/8/16/32/64-bitowej liczby całkowitej lub 4/6/8/16/32/64-bitowej liczby zmiennoprzecinkowej lub typu złożonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi liczbami całkowitymi na tensor lub wartościami całkowitymi skwantowanymi na oś

mhlo.domain (mhlo::DomainOp)

Działanie domeny

Ta operacja jest prywatna dla kompilatora XLA, więc nie ma jeszcze specyfikacji.

Nieformalnie te operacje służą do grupowania instrukcji z tą samą właściwością DomainMetadata. ShardingMetadata to obecnie główny przypadek użycia do grupowania instrukcji na tym samym urządzeniu. Instrukcje domeny zapewniają dwie główne korzyści:

• Zapobiegaj niezamierzonej optymalizacji instrukcji w różnych domenach.
• Automatycznie przypisuj metadane instrukcji utworzonych w domenie. Bez instrukcji dotyczących domeny każdy przebieg optymalizacji HLO musiałby sprawdzać i propagować metadane, co łatwo byłoby przeoczyć, a także zwiększałoby złożoność kompilatora. Ponieważ instrukcje domeny łączą dwie różne domeny, każda instrukcja domeny jest powiązana z dwoma DomainMetadata — jednym po stronie argumentu i jednym po stronie użytkownika domeny.

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
kind	::mlir::mhlo::DomainKindAttr	Rodzaj metadanych domeny dołączonych do domeny HLO.
entry_metadata	::mlir::StringAttr	atrybut ciągu
exit_metadata	::mlir::StringAttr	atrybut ciągu

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowanymi wartościami całkowitymi na tensor lub tensorem rankingowym skwantowanych wartości całkowitych na oś lub tokenem

Wyniki:

Wynik	Opis
result	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub skwantowanymi wartościami całkowitymi na tensor lub tensorem rankingowym skwantowanych wartości całkowitych na oś lub tokenem

mhlo.dot (mhlo::DotOp)

Operacja kropkowa

Ta operacja jest już wycofywana ze StableHLO, więc nie jest uwzględniona w specyfikacji: https://github.com/openxla/stablehlo/issues/3

Nieformalnie ta operacja robi to samo, co Dot XLA: https://www.tensorflow.org/xla/operacja_semantics#dot

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
precision_config	::mlir::ArrayAttr	Atrybut konfiguracji precyzyjnej

Operandy:

Operand	Opis
lhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
rhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.dot_general (mhlo::DotGeneralOp)

KropkaOgólne działanie

Oblicza iloczyny skalarne pomiędzy wycinkami lhs i rhs i generuje tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	Atrybut modelujący informacje o wymiarze kropki.
precision_config	::mlir::ArrayAttr	Atrybut konfiguracji precyzyjnej
algorithm	::mlir::mhlo::DotAlgorithmAttr	Atrybut modelujący ograniczenia algorytmu używane do obliczania kropki.

Operandy:

Operand	Opis
lhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
rhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

Operacja DynamicBroadcastInDim

Ta operacja jest funkcjonalnie identyczna z operacją broad_in_dim , ale kształt wyniku jest określany dynamicznie poprzez output_dimensions .

Akceptuje także opcjonalne atrybuty wyrażające statyczną wiedzę na temat rozszerzającego się zachowania wymiarów. Jeśli nie określono, przyjmuje się, że wszystkie wymiary mogą się rozszerzać. Zbiory wymiarów, o których wiadomo, że się rozszerzają, i zbiory wymiarów, o których wiadomo, że się nie rozszerzają, muszą być rozłączne i muszą stanowić podzbiór wymiarów operandu.

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
broadcast_dimensions	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
known_expanding_dimensions	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
output_dimensions	Tensor 1D indeksu lub 2/4/8/16/32/64-bitowe wartości całkowite

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.dynamic_conv (mhlo::DynamicConvOp)

Operacja DynamicConv

Ta operacja jest w toku, więc nie jest jeszcze uwzględniona w specyfikacji: https://github.com/openxla/stablehlo/issues/8

Nieformalnie ta operacja robi to samo, co ConvolutionOp, z tą różnicą, że padding jest określane dynamicznie poprzez d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
window_strides	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
padding	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
lhs_dilation	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
rhs_dilation	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku
window_reversal	::mlir::DenseElementsAttr	stały atrybut wektora logicznego/tensora
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Struktura informacji o wymiarach dla operacji konw
feature_group_count	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia
batch_group_count	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest dodatnia
precision_config	::mlir::ArrayAttr	Atrybut konfiguracji precyzyjnej

Operandy:

Operand	Opis
lhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
rhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
d_padding	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

Operacja DynamicGather

Ta operacja jest w toku, więc nie jest jeszcze uwzględniona w specyfikacji: https://github.com/openxla/stablehlo/issues/8

Nieformalnie ta operacja robi to samo, co GatherOp, z tą różnicą, że slice_sizes są określane dynamicznie: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Atrybut modelujący informacje o wymiarach dla zbierania
indices_are_sorted	::mlir::BoolAttr	atrybut boolowy

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
start_indices	uszeregowany tensor 2/4/8/16/32/64-bitowych wartości całkowitych
slice_sizes	statycznie ukształtowany 1-wymiarowy tensor liczb całkowitych o 2/4/8/16/32/64-bitowych wartościach całkowitych

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

Operacja DynamicIota

Ta operacja jest funkcjonalnie identyczna z operacją iota , ale kształt wyniku jest określany dynamicznie poprzez output_shape .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
iota_dimension	::mlir::IntegerAttr	64-bitowy atrybut liczby całkowitej bez znaku, którego wartość jest nieujemna

Operandy:

Operand	Opis
output_shape	Tensor 1D indeksu lub 2/4/8/16/32/64-bitowe wartości całkowite

Wyniki:

Wynik	Opis
result	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.dynamic_pad (mhlo::DynamicPadOp)

Obsługa DynamicPada

Składnia:

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

Dynamicznie dopełnia operand , a ilość dopełnienia dodana na najniższym/wysokim poziomie/wewnętrznym jest przekazywana przez tensory wejściowe.

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
padding_value	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
edge_padding_low	Tensor 1D indeksu lub 2/4/8/16/32/64-bitowe wartości całkowite
edge_padding_high	Tensor 1D indeksu lub 2/4/8/16/32/64-bitowe wartości całkowite
interior_padding	Tensor 1D indeksu lub 2/4/8/16/32/64-bitowe wartości całkowite

Wyniki:

Wynik	Opis
result	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

Operacja DynamicReshape

Składnia:

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

Ta operacja jest funkcjonalnie identyczna z operacją reshape , ale kształt wyniku jest określany dynamicznie poprzez output_shape .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi liczbami całkowitymi na tensor lub wartościami całkowitymi skwantowanymi na oś
output_shape	Tensor 1D indeksu lub 2/4/8/16/32/64-bitowe wartości całkowite

Wyniki:

Wynik	Opis
result	tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub kwantyzowanymi liczbami całkowitymi na tensor lub wartościami całkowitymi skwantowanymi na oś

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

Operacja DynamicSlice

Wyodrębnia wycinek z operand przy użyciu dynamicznie obliczanych indeksów początkowych i tworzy tensor result .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
slice_sizes	::mlir::DenseIntElementsAttr	Atrybut 64-bitowych elementów całkowitych bez znaku

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
start_indices	variadic tensora 0D o 2/4/8/16/32/64-bitowych wartościach całkowitych

Wyniki:

Wynik	Opis
result	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

Operacja DynamicUpdateSlice

Składnia:

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

Tworzy tensor result równy tensorowi operand , z tą różnicą, że wycinek rozpoczynający się od start_indices jest aktualizowany wartościami w update .

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

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , InferTensorType

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
update	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
start_indices	variadic tensora 0D o 2/4/8/16/32/64-bitowych wartościach całkowitych

Wyniki:

Wynik	Opis
result	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.einsum (mhlo::EinsumOp)

Operacja Einsum

Ta operacja jest już wycofywana ze StableHLO, więc nie jest uwzględniona w specyfikacji: https://github.com/openxla/stablehlo/issues/3

Nieformalnie ta operacja robi to samo, co einsum TF: https://www.tensorflow.org/api_docs/python/tf/einsum

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait

Interfejsy: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Efekty: MemoryEffects::Effect{}

Atrybuty:

Atrybut	Typ MLIR	Opis
einsum_config	::mlir::StringAttr	atrybut ciągu

Operandy:

Operand	Opis
lhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś
rhs	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

Wyniki:

Wynik	Opis
"anonimowy"	uszeregowany tensor 4/6/8/16/32/64-bitowego typu zmiennoprzecinkowego lub boolowego lub 2/4/8/16/32/64-bitowego typu całkowitego lub zespolonego z 32/64-bitowymi elementami zmiennoprzecinkowymi lub liczbą całkowitą na tensor, skwantowaną lub wartością całkowitą skwantowaną na oś

mhlo.erf (mhlo::ErfOp)

Operacja Erfa

Składnia:

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

Wykonuje elementarną operację erf na tensorze operand i generuje tensor result .

Przykład:

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

Cechy: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Efekty: MemoryEffects::Effect{}

Operandy:

Operand	Opis
operand	uszeregowany tensor 4/6/8/16/32/64-bitowych wartości zmiennoprzecinkowych

Wyniki:

Wynik	Opis
result	uszeregowany tensor 4/6/8/16/32/64-bitowych wartości zmiennoprzecinkowych

mhlo.exponential (mhlo::ExpOp)

Operacja eksp

Składnia:

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

Wykonuje elementarną operację wykładniczą na tensorze operand i generuje tensor result .

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

Składnia:

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

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

Przykład:

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

Atrybut	MLIR Type	Opis
fft_type	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
fft_length	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.floor (mhlo::FloorOp)

Floor operation

Składnia:

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

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:

Atrybut	MLIR Type	Opis
fusion_kind	::mlir::mhlo::FusionKindAttr	fusion kind
output_operand_aliases	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

Operands:

Operand	Opis
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

Wyniki:

Wynik

Opis

results

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

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

Przykład:

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

Atrybut	MLIR Type	Opis
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
slice_sizes	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
indices_are_sorted	::mlir::BoolAttr	bool attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	ranked tensor of 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

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

Przykład:

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

Atrybut	MLIR Type	Opis
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	tensor of 32-bit signless integer values

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Składnia:

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

Przykład:

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

Atrybut	MLIR Type	Opis
index	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Operand

Opis

operand

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

Wyniki:

Wynik

Opis

"anonimowy"

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

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:

Operand	Opis
pred	ranked tensor of bool values

Wyniki:

Wynik	Opis
"anonimowy"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.imag (mhlo::ImagOp)

Imag operation

Składnia:

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float values

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

Przykład:

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

Attributes:

Atrybut	MLIR Type	Opis
infeed_config	::mlir::StringAttr	string attribute
layout	::mlir::ArrayAttr	array attribute

Operands:

Operand	Opis
token	znak

Wyniki:

Wynik

Opis

"anonimowy"

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
iota_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Wyniki:

Wynik	Opis
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

Składnia:

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
x	ranked tensor of 4/6/8/16/32/64-bit float values

Wyniki:

Wynik	Opis
y	ranked tensor of bool values

mhlo.log (mhlo::LogOp)

Log operation

Składnia:

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.log_plus_one (mhlo::Log1pOp)

Log1p operation

Składnia:

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

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

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

Przykład:

%result = mhlo.log_plus_one %operand : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.logistic (mhlo::LogisticOp)

Logistic operation

Składnia:

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

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

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.map (mhlo::MapOp)

Map operation

Applies a map function computation to inputs along the dimensions and produces a result tensor.

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

Przykład:

%result = "mhlo.map"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.multiply %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  dimensions = dense<[0, 1]> : tensor<2xi64>
} : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.maximum (mhlo::MaxOp)

Max operation

Składnia:

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

Performs element-wise max operation on tensors lhs and rhs and produces a result tensor.

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum (mhlo::MinOp)

Min operation

Składnia:

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

Performs element-wise min operation on tensors lhs and rhs and produces a result tensor.

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.minimum_broadcast_shapes (mhlo::MinimumBroadcastShapesOp)

Minimizes the rank of two or more shapes to be broadcasted

Składnia:

operation ::= `mhlo.minimum_broadcast_shapes` $shapes attr-dict `:` type($shapes) `->` type($results)

Given two or more 1D tensors representing shapes, returns one 1D tensor for each operand, where operand i corresponds to output i .

The returned tensors have the property that they specify a shape which is a reshape of the corresponding input shape, and the broadcasted output shape (using shape::BroadcastOp) of the returned shapes is a reshape of the broadcasted output shape of the input shapes. Among all possibilities with this property, the one is chosen which minimizes the rank of each returned shape.

The general idea of this op is that it can be used for ops which have a broadcasting semantic to operate on shapes with a possibly smaller rank while preserving equivalence of the computed values. After computing the result of the op using reshaped operands, the result can be reshaped to the result that would have been originally computed.

Here is an example with two input shapes:

mhlo.minimum_broadcast_shapes [1, 2, 3, 1, 2, 1],
                                 [1, 1, 1, 2, 3] -> [6, 2, 1], [2, 3]

The broadcasted output shape of the operands is [1, 2, 3, 1, 2, 3], the broadcasted output shape of the outputs is [6, 2, 3]. These two shapes are reshapes of each other, and also each output is a reshape of the corresponding input.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
shapes	variadic of 1D tensor of index values

Wyniki:

Wynik	Opis
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

Składnia:

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

Performs element-wise product of two tensors lhs and rhs and produces a result tensor.

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

Przykład:

%result = mhlo.multiply %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.negate (mhlo::NegOp)

Neg operation

Składnia:

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

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

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

Przykład:

%result = mhlo.negate %operand : tensor<2x3xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.not (mhlo::NotOp)

Not operation

Składnia:

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

Performs element-wise NOT of tensor operand of type integer and produces a result tensor.

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

Przykład:

%result = mhlo.not %operand : tensor<5x3x1xi1>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

Składnia:

operation ::= `mhlo.optimization_barrier` attr-dict ($operand^ `:` custom<PairwiseOpType>(type($operand), type($result))):(`(` `)`)?

Ensures that the operations that produce the operand are executed before any operations that depend on the result and prevents compiler transformations from moving operations across the barrier. Other than that, the operation is an identity, ie result = operand .

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

Przykład:

%result0, %result1 = mhlo.optimization_barrier %operand0, %operand1 : tensor<f32>, tensor<f32>

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

Wyniki:

Wynik	Opis
result	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

mhlo.or (mhlo::OrOp)

Or operation

Składnia:

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

Performs element-wise OR of two tensors lhs and rhs and produces a result tensor.

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

Przykład:

%result = mhlo.or %lhs, %rhs : tensor<2xi1>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.outfeed (mhlo::OutfeedOp)

Outfeed operation

Writes inputs to the outfeed and produces a result token.

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

Przykład:

%result = "mhlo.outfeed"(%input0, %token) {
  outfeed_config = ""
} : (tensor<3x3x3xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
outfeed_config	::mlir::StringAttr	string attribute

Operands:

Operand	Opis
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	znak

Wyniki:

Wynik	Opis
"anonimowy"	znak

mhlo.pad (mhlo::PadOp)

Pad operation

Expands operand by padding around the tensor as well as between the elements of the tensor with the given padding_value .

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

Przykład:

%0 = mhlo.pad %arg0, %arg1, low = [0, 1], high = [2, 1], interior = [1, 2]
  : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
edge_padding_low	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
edge_padding_high	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
interior_padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
padding_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.partition_id (mhlo::PartitionIdOp)

PartitionId operation

Składnia:

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

Produces partition_id of the current process.

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

Przykład:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

Składnia:

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

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

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

Przykład:

%result = mhlo.popcnt %operand : tensor<4xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

Składnia:

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

Performs element-wise exponentiation of lhs tensor by rhs tensor and produces a result tensor.

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

Przykład:

%result = mhlo.power %lhs, %rhs : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.ragged_dot (mhlo::RaggedDotOp)

Ragged matrix multiplication over a single ragged dimension

This operation takes three tensor args---lhs, rhs, and group_sizes---and a "ragged_dot_dimension_numbers" attribute. Like dot_general, the lhs and rhs are allowed arbitrary batch and contracting dimensions. Additionally, the lhs is required to have one ragged dimension, and the rhs may have at most one group dimension. The op has three modes, depending on the kind of the lhs ragged dimension.

In mode 1, the shape-signature is [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] . Here the ragged dimension is an lhs non-contracting dimension ( m ). The dimensions b and k represent batch and contracting dimensions respectively. The rhs is required to have a group dimension ( g ).

In mode 2, the shape-signature is [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] . Here the ragged dimension is an lhs/rhs contracting dimension ( k ).

In mode 3, the shape-signature is [b,m,k], [b,k,n], [g] -> [b,m,n] . Here the ragged dimension is an lhs/rhs batch dimension ( b ).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
ragged_dot_dimension_numbers	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
precision_config	::mlir::ArrayAttr	Precision Config attribute

Operands:

Operand	Opis
lhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
group_sizes	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.real (mhlo::RealOp)

Real operation

Składnia:

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

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

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

Składnia:

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

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 SliceOp except that start_indices , limit_indices and strides are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

Przykład:

%result = mhlo.real_dynamic_slice %operand,
            %start_indices, %limit_indices, %strides
       : (tensor<256x?xf32>, tensor<2xindex>, tensor<2xindex>, tensor<2xindex>) -> tensor<256x?xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
start_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
limit_indices	1D tensor of index or 2/4/8/16/32/64-bit integer values
strides	1D tensor of index or 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.recv (mhlo::RecvOp)

Recv operation

Receives data from a channel with channel_id and produces results .

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

Przykład:

%results:2 = "mhlo.recv"(%token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (!mhlo.token) -> (tensor<3x4xi32>, !mhlo.token)

Attributes:

Atrybut	MLIR Type	Opis
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
token	znak

Wyniki:

Wynik

Opis

"anonimowy"

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

mhlo.reduce (mhlo::ReduceOp)

Reduce operation

Applies a reduction function body to inputs and init_values along the dimensions and produces a result tensor.

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

Przykład:

%result = "mhlo.reduce"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  dimensions = dense<1> : tensor<1xi64>
} : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_precision (mhlo::ReducePrecisionOp)

ReducePrecision operation

Składnia:

operation ::= `mhlo.reduce_precision` $operand `,` `format` `=` custom<ExponentMantissa>($exponent_bits, $mantissa_bits)
              attr-dict `:` custom<SameOperandsAndResultType>(type($operand), type($output))

Performs element-wise conversion of operand to another floating-point type that uses exponent_bits and mantissa_bits and back to the original floating-point type and produces an output tensor.

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

Przykład:

%output = mhlo.reduce_precision %operand, format = e5m2 : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
exponent_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is positive
mantissa_bits	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Wyniki:

Wynik	Opis
output	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.reduce_scatter (mhlo::ReduceScatterOp)

ReduceScatter operation

Within each process group in the process grid, performs reduction, using computations , over the values of the operand tensor from each process, splits the reduction result along scatter_dimension into parts, and scatters the split parts between the processes to produce the result .

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

Przykład:

%result = "mhlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
  %0 = mhlo.add %arg0, %arg1 : tensor<f32>
  mhlo.return %0 : tensor<f32>
}) {
  scatter_dimension = 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<2x4xf32>) -> tensor<2x2xf32>

Attributes:

Atrybut	MLIR Type	Opis
scatter_dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
replica_groups	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
use_global_device_ids	::mlir::UnitAttr	unit attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.reduce_window (mhlo::ReduceWindowOp)

ReduceWindow operation

Applies a reduction function body to windows of inputs and init_values and produces results .

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

Przykład:

%result = "mhlo.reduce_window"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  window_dimensions = dense<[2, 1]> : tensor<2xi64>,
  window_strides = dense<[4, 1]> : tensor<2xi64>,
  base_dilations = dense<[2, 1]> : tensor<2xi64>,
  window_dilations = dense<[3, 1]> : tensor<2xi64>,
  padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi32>, tensor<i32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
base_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_dilations	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_values	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.remainder (mhlo::RemOp)

Rem operation

Składnia:

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

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

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

Przykład:

%result = mhlo.remainder %lhs, %rhs : tensor<4xi64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.replica_id (mhlo::ReplicaIdOp)

ReplicaId operation

Składnia:

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

Produces replica_id of the current process.

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

Przykład:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

Składnia:

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

Performs reshape of operand tensor to a result tensor.

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

Przykład:

%result = mhlo.reshape %operand : (tensor<2xf32>) -> tensor<1x2xf32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	statically shaped or single bounded dimension tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.return (mhlo::ReturnOp)

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

Informally, this operation serves as a terminator for regions defined by
the StableHLO ops. Non-StableHLO ops, e.g. `func.func`, have their own
terminators, e.g. `func.return`.

Example:

    ```mlir
    %result = "mhlo.reduce"(%input, %init_value) ({
      ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
        %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
        "mhlo.return"(%0) : (tensor<i32>) -> ()
    }) {
      dimensions = dense<1> : tensor<1xi64>
    } : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>
    ```_

Syntax:

```

operation ::= mhlo.return $results attr-dict ( : type($results)^)?

Traits: `AlwaysSpeculatableImplTrait`, `Terminator`

Interfaces: `ConditionallySpeculatable`, `NoMemoryEffect (MemoryEffectOpInterface)`

Effects: `MemoryEffects::Effect{}`

#### Operands:

| Operand | Description |
| :-----: | ----------- |
| `results` | variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values |



### `mhlo.reverse` (mhlo::ReverseOp)

_Reverse operation_

Reverses the order of elements in the `operand` along the specified
`dimensions` and produces a `result` tensor.

See:
<a href="https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse">https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse</a>

Example:
```mlir
%result = mhlo.reverse %operand, dims = [1] : tensor<3x2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.rng (mhlo::RngOp)

Rng operation

Generates random numbers using the rng_distribution algorithm and produces a result tensor of a given shape shape .

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

Przykład:

%result = mhlo.rng %a, %b, %shape, distribution = NORMAL : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

Operand	Opis
a	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
b	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
shape	1D tensor of index or 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.rng_bit_generator (mhlo::RngBitGeneratorOp)

RngBitGenerator operation

Returns an output filled with uniform random data and an updated output state output_state given an initial state initial_state using the pseudorandom number generator algorithm rng_algorithm .

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

Przykład:

%output_state, %output = mhlo.rng_bit_generator %initial_state, algorithm = THREE_FRY : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

Operand	Opis
initial_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

Wyniki:

Wynik	Opis
output_state	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
output	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

mhlo.round_nearest_afz (mhlo::RoundOp)

Round operation

Składnia:

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

Performs element-wise rounding towards the nearest integer, breaking ties away from zero, on the operand tensor and produces a result tensor.

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

Składnia:

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

Performs element-wise rounding towards the nearest integer, breaking ties towards the even integer, on the operand tensor and produces a result tensor.

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

Składnia:

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

Performs element-wise reciprocal square root operation on operand tensor and produces a result tensor, implementing the rSqrt operation from the IEEE-754 specification.

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.scatter (mhlo::ScatterOp)

Scatter operation

Produces results tensors which are equal to inputs tensors except that several slices specified by scatter_indices are updated with the values updates using update_computation .

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

Przykład:

%result = "mhlo.scatter"(%input, %scatter_indices, %update) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  scatter_dimension_numbers = #mhlo.scatter<
    update_window_dims = [3, 4],
    inserted_window_dims = [1],
    input_batching_dims = [0],
    scatter_indices_batching_dims = [1],
    scatter_dims_to_operand_dims = [2, 1],
    index_vector_dim = 3>,
  indices_are_sorted = false,
  unique_indices = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>, tensor<2x2x3x2x2xi64>) -> tensor<2x3x4x2xi64>

Traits: RecursiveMemoryEffects , SameVariadicOperandSize

Interfaces: InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
scatter_dimension_numbers	::mlir::mhlo::ScatterDimensionNumbersAttr	Attribute that models the dimension information for scatter
indices_are_sorted	::mlir::BoolAttr	bool attribute
unique_indices	::mlir::BoolAttr	bool attribute

Operands:

Operand	Opis
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
scatter_indices	ranked tensor of integer or index values
updates	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select (mhlo::SelectOp)

Select operation

Składnia:

operation ::= `mhlo.select` operands attr-dict `:`
              custom<SelectOpType>(type($pred), type($on_true), type($on_false), type($result))

Produces a result tensor where each element is selected from on_true or on_false tensor based on the value of the corresponding element of pred .

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

Przykład:

%result = mhlo.select %pred, %on_true, %on_false : tensor<2x2xi1>, tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
pred	ranked tensor of bool values
on_true	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
on_false	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.select_and_scatter (mhlo::SelectAndScatterOp)

SelectAndScatter operation

Scatters the values from the source tensor using scatter based on the outcome of reduce_window of the input tensor using select and produces a result tensor.

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

Przykład:

%result = "mhlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

Traits: RecursiveMemoryEffects

Interfaces: InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
window_dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
window_strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
padding	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
source	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
init_value	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.send (mhlo::SendOp)

Send operation

Sends inputs to a channel channel_id and produces a result token.

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

Przykład:

%result = "mhlo.send"(%operand, %token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (tensor<3x4xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
channel_handle	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
is_host_transfer	::mlir::BoolAttr	bool attribute
source_target_pairs	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
token	znak

Wyniki:

Wynik	Opis
"anonimowy"	znak

mhlo.set_dimension_size (mhlo::SetDimensionSizeOp)

SetDimensionSize 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 XLA's SetDimensionSize: https://www.tensorflow.org/xla/operation_semantics#setdimensionsize

Przykład:

%0 = mhlo.set_dimension_size %arg0, %arg1, dim = 1 : (tensor<4x2xf32>, tensor<i32>) -> tensor<4x2xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
dimension	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
size	tensor of 32-bit signless integer values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.shift_left (mhlo::ShiftLeftOp)

ShiftLeft operation

Składnia:

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

Performs element-wise left-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Przykład:

%result = mhlo.shift_left %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

Składnia:

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

Performs element-wise arithmetic right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Przykład:

%result = mhlo.shift_right_arithmetic %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

Składnia:

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

Performs element-wise logical right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

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

Przykład:

%result = mhlo.shift_right_logical %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

Składnia:

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

Returns the sign of the operand element-wise and produces a result tensor.

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

Przykład:

%result = mhlo.sign %operand : tensor<7xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sine (mhlo::SineOp)

Sine operation

Składnia:

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

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

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.sinh (mhlo::SinhOp)

Sinh operation

Składnia:

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

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

Przykład:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

Operand	Opis
operand	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Wyniki:

Wynik	Opis
result	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.slice (mhlo::SliceOp)

Slice operation

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

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

Przykład:

%result = "mhlo.slice" (%operand) {
  start_indices = dense<[1, 2]> : tensor<2xi64>,
  limit_indices = dense<[3, 4]> : tensor<2xi64>,
  strides = dense<1> : tensor<2xi64>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
start_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
limit_indices	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
strides	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sort (mhlo::SortOp)

Sort operation

Sorts a variadic number of tensors in inputs together, according to a custom comparator , along the given dimension and produces a variadic number of tensors as results .

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

Przykład:

%result0, %result1 = "mhlo.sort"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>):
    %predicate = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GT>
      } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
  dimension = 0 : i64,
  is_stable = true
} : (tensor<2x3xi32>, tensor<2x3xi32>) -> (tensor<2x3xi32>, tensor<2x3xi32>)

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

Operand	Opis
inputs	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.sqrt (mhlo::SqrtOp)

Sqrt operation

Składnia:

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

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

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.stochastic_convert (mhlo::StochasticConvertOp)

StochasticConvert operation

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

Informally, this operation performs element-wise conversion of values from a bigger type to a smaller one with stochastic rounding using the random number passed in.

Traits: AlwaysSpeculatableImplTrait , Elementwise

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float values
random	ranked tensor of 2/4/8/16/32/64-bit unsigned integer values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.subtract (mhlo::SubtractOp)

Subtract operation

Składnia:

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

Performs element-wise subtraction of two tensors lhs and rhs and produces a result tensor.

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

Przykład:

%result = mhlo.subtract %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
rhs	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.tan (mhlo::TanOp)

Tan operation

Składnia:

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

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

Informally, this operation returns Tan(operand) element-wise.

Przykład:

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.tanh (mhlo::TanhOp)

Tanh operation

Składnia:

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

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

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

Przykład:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.topk (mhlo::TopKOp)

TopK operation

Składnia:

operation ::= `mhlo.topk` `(`$operand `,` `k` `=` $k (`,` `largest` `=` $largest^)? `)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Returns top k values and their indices, along the last dimension of the operand if largest=true or the bottom k values if largest=false .

See: https://www.tensorflow.org/xla/operation_semantics#top-k

Przykład:

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
values	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
indices	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.torch_index_select (mhlo::TorchIndexSelectOp)

TorchIndexSelect 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 PyTorch's index_select, augmented with support for batch dimensions: https://pytorch.org/docs/stable/generated/torch.index_select.html

The batch_dims attribute specifies the number of major batch dimensions (0 or more) that act like a multidimensional loop over both the operand and the index.

Przykład:

%result = "mhlo.torch_index_select"(%operand, %index) {
  dim = 2 : i64,
  batch_dims = 1 : i64
} : (tensor<8x128x3072x64xf32>, tensor<8x16x1024xi32>) -> tensor<8x128x16x1024x64xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
index	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.trace (mhlo::TraceOp)

Trace operation

Składnia:

operation ::= `mhlo.trace` $operand `,` $tag attr-dict `:` type($operand)

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

It is not used by JAX, PyTorch or TensorFlow, so it looks like we should've classified it as "Private to XLA" and not included it in StableHLO in the first place. With that in mind, its semantics will not be documented here.

Przykład:

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

Attributes:

Atrybut	MLIR Type	Opis
tag	::mlir::StringAttr	string attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.transpose (mhlo::TransposeOp)

Transpose operation

Permutes the dimensions of operand tensor using permutation and produces a result tensor.

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

Przykład:

%0 = mhlo.transpose %arg0, dims = [2, 1, 0] : (tensor<1x2x3xi32>) -> tensor<3x2x1xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

mhlo.triangular_solve (mhlo::TriangularSolveOp)

TriangularSolve operation

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

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

Przykład:

%result = "mhlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Atrybut	MLIR Type	Opis
left_side	::mlir::BoolAttr	bool attribute
lower	::mlir::BoolAttr	bool attribute
unit_diagonal	::mlir::BoolAttr	bool attribute
transpose_a	::mlir::mhlo::TransposeAttr	Transpose options

Operands:

Operand	Opis
a	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values
b	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

Wyniki:

Wynik	Opis
"anonimowy"	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

mhlo.tuple (mhlo::TupleOp)

Tuple operation

Składnia:

operation ::= `mhlo.tuple` $val attr-dict `:` custom<TupleOpType>(type($val), type($result))

Produces a result tuple from values val .

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

Przykład:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand

Opis

val

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik

Opis

result

nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

mhlo.uniform_dequantize (mhlo::UniformDequantizeOp)

UniformDequantize operation

Składnia:

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

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

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

Przykład:

%result = mhlo.uniform_dequantize %operand : (tensor<16x16x!quant.uniform<i8:f32, 34.0:16>>) -> tensor<16x16xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

Składnia:

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

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

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

Przykład:

%result = mhlo.uniform_quantize %operand : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
operand	ranked tensor of 4/6/8/16/32/64-bit float or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values

Wyniki:

Wynik	Opis
result	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

mhlo.while (mhlo::WhileOp)

While operation

Produces the output from executing body function 0 or more times while the cond function outputs true .

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

Przykład:

%results0, %results1 = "mhlo.while"(%operand0, %operand1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %constant0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0, %arg1) : (tensor<i32>, tensor<i32>) -> ()
}) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface , OpAsmOpInterface

Operands:

Operand

Opis

operand

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

Wyniki:

Wynik

Opis

"anonimowy"

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

mhlo.xla.rng_get_and_update_state (mhlo::XlaRngGetAndUpdateStateOp)

XlaRngGetAndUpdateState operation

Składnia:

operation ::= `mhlo.xla.rng_get_and_update_state` attr-dict

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

Informally, this operation represents the change of the global random number generator state for rng instructions. The global state is incremented by delta and the old state is returned.

The output is currently defined for a single output type. If this changes in the future to support multiple types, lowering to use of a global memref must ensure that a single memref is still used and updated appropriately.

Interfaces: InferTypeOpInterface

Attributes:

Atrybut	MLIR Type	Opis
delta	::mlir::IntegerAttr	64-bit signless integer attribute

Wyniki:

Wynik	Opis
"anonimowy"	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

Składnia:

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

Performs element-wise XOR of two tensors lhs and rhs and produces a result tensor.

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

Przykład:

%result = mhlo.xor %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Opis
lhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
rhs	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

Wyniki:

Wynik	Opis
result	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

Atrybuty

ArgResultAliasAttr

Attribute that models the alias relationship of entry function argument

This attribute captures the alias relationship of an MHLO main function argument to one of the results, denoted by resultIndex . The argTupleIndices and resultTupleIndices are used to index into nested tuples in operand and result respectively. If isMustAlias is true then the operand-result pair must alias.

This is meant to be used as an attribute on a function argument in MHLO. For example, in the following code it expresses that %arg1 may alias 0-th result.

func @main(%arg0: tensor<2xf32>, %arg1: tensor<3xf32> {mhlo.result_alias =
    mhlo.result_alias<result_index = [2], ...>}
  ) -> tensor<2xf32>, tensor<3xf32> {
  // function body ...
}

Parameters:

Parametr	C++ type	Opis
argTupleIndices	::llvm::ArrayRef<int64_t>	Wymiar
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	Wymiar
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

Składnia:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

Parameters:

Parametr	C++ type	Opis
uchwyt	int64_t
typ	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

Składnia:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

Składnia:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

Parameters:

Parametr	C++ type	Opis
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	Wymiar
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	Wymiar
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	Wymiar

CrossProgramPrefetchAttr

Argument that is prefetched from another program

Składnia:

#mhlo.cross_program_prefetch<
  int64_t,   # parameter
  ::llvm::ArrayRef<int64_t>,   # indices
  std::optional<int64_t>   # offset
>

This attribute captures an argument that is prefetched from another program. For a given CrossProgramPrefetchAttr , parameter tells us which argument of the main function of the module is prefetched, and indices is a shape index telling us what subshape of that argument is prefetched.

A shape has a subshape iff it is a tuple. In that case, the subshape of the tuple by indices is the shape achieved after indexing by each element of indices in turn. For example, the [1,0] subshape of tuple<tuple<token, token>, tuple<tensor<i32>, token>> is tensor<i32> .

An empty value for indices means the whole shape is prefetched.

Na przykład,

module attributes { mhlo.cross_program_prefetch = [ #mhlo.cross_program_prefetch< parameter = 0, indices = [0]> ]} {
  func.func @copy(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %0 = "mhlo.copy"(%arg0) {is_cross_program_prefetch}
    return %0 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
  func.func @main(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %1 = "mhlo.async_start"(%arg0) {called_computation=@copy}
    %2 = "mhlo.async_done"(%1) {called_computation=@copy}
    return %2 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
}

The parameter = 0 tells us that the async copy of the 0 th parameter is a cross_program_prefetch , while the index of [0] tells us that the 0 th element of the tuple is prefetched while the other element of the tuple is not.

Parameters:

Parametr	C++ type	Opis
parametr	int64_t
indeksy	::llvm::ArrayRef<int64_t>	Wymiar
zrównoważyć	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

Składnia:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

Składnia:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

Składnia:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

Składnia:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

Parameters:

Parametr	C++ type	Opis
lhsPrecisionType	Type
rhsPrecisionType	Type
accumulationType	Type
lhsComponentCount	int64_t
rhsComponentCount	int64_t
numPrimitiveOperations	int64_t
allowImpreciseAccumulation	bool

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

Parameters:

Parametr	C++ type	Opis
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Wymiar
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Wymiar
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	Wymiar
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	Wymiar

FftTypeAttr

XLA fast fourier transform type.

Składnia:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

Składnia:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

Parameters:

Parametr	C++ type	Opis
offsetDims	::llvm::ArrayRef<int64_t>	Wymiar
collapsedSliceDims	::llvm::ArrayRef<int64_t>	Wymiar
operandBatchingDims	::llvm::ArrayRef<int64_t>	Wymiar
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Wymiar
startIndexMap	::llvm::ArrayRef<int64_t>	Wymiar
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

Składnia:

#mhlo.output_operand_alias<
  ::llvm::ArrayRef<int64_t>,   # outputTupleIndices
  int64_t,   # operandIndex
  ::llvm::ArrayRef<int64_t>   # operandTupleIndices
>

This attribute captures the alias relationship of the output to one of the operands for a CustomCall op, denoted by operand_index . The output_tuple_indices and operand_tuple_indices are used to index into output and operand types. These indices lists are empty if the corresponding types are not tuple types, and can be arbitrarily long in case of arbitrarily nested tuple types.

See https://www.tensorflow.org/xla/aliasing

Example when used as array with in mhlo.custom-call:

%0 = "mhlo.custom_call"(%arg0, %arg1) {
  // other attributes
  output_operand_alias = [
    #mhlo.output_operand_alias<output_tuple_indices = [0],
                               operand_index = 0,
                               operand_tuple_indices = [1]>
  ]
} : (tuple<tensor<1x1xf32>, tensor<2x3xf32>>, tensor<5x5xf32>) -> tuple<tensor<2x3xf32>>

The output and the 0th operand are both tuples. The aliasing shows the
relationship between the 0th element in output tuple with the 1st element in
the 0th operand. And both of them are of the same type: tensor<2x3xf32>.

Parameters:

Parametr	C++ type	Opis
outputTupleIndices	::llvm::ArrayRef<int64_t>	Wymiar
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	Wymiar

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

Składnia:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

Parameters:

Parametr	C++ type	Opis
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	Wymiar
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	Wymiar

ResultAccuracyAttr

The requested accuracy for unary ops.

Parameters:

Parametr	C++ type	Opis
atol	APFloat
rtol	APFloat
ulps	int64_t
tryb	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

Składnia:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

Składnia:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

Składnia:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

Parameters:

Parametr	C++ type	Opis
updateWindowDims	::llvm::ArrayRef<int64_t>	Wymiar
insertedWindowDims	::llvm::ArrayRef<int64_t>	Wymiar
inputBatchingDims	::llvm::ArrayRef<int64_t>	Wymiar
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Wymiar
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	Wymiar
indexVectorDim	int64_t

TransposeAttr

Transpose options

Składnia:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

Parameters:

Parametr	C++ type	Opis
wartość	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

Składnia:

#mhlo.type_extensions<
  ::llvm::ArrayRef<int64_t>   # bounds
>

This attribute is used to extend MLIR tensor type with MHLO tensor specific properties. These properties aren't modeled in the MLIR type. This attribute is set in the encoding field of the tensor type.

See HLO_BoundedAttrInterface for documentation for bounds .

Parameters:

Parametr	C++ type	Opis
miedza	::llvm::ArrayRef<int64_t>

Typy

AsyncBundleType

Opaque collection of other types

Składnia:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

Parameters:

Parametr	C++ type	Opis
typy	::llvm::ArrayRef<Type>

Wyliczenia

ComparisonDirection

Which comparison operation to perform.

Sprawy:

Symbol	Wartość	Smyczkowy
EQ	0	EQ
NE	1	NE
GE	2	GE
GT	3	GT
LE	4	LE
LT	5	LT

ComparisonType

Which comparison type to use.

Sprawy:

Symbol	Wartość	Smyczkowy
NOTYPE	0	NOTYPE
PLATFORMA	1	PLATFORMA
TOTALORDER	2	TOTALORDER
PODPISANE	3	PODPISANE
UNSIGNED	4	UNSIGNED

CustomCallApiVersion

Custom call API version

Sprawy:

Symbol	Wartość	Smyczkowy
API_VERSION_UNSPECIFIED	0	API_VERSION_UNSPECIFIED
API_VERSION_ORIGINAL	1	API_VERSION_ORIGINAL
API_VERSION_STATUS_RETURNING	2	API_VERSION_STATUS_RETURNING
API_VERSION_STATUS_RETURNING_UNIFIED	3	API_VERSION_STATUS_RETURNING_UNIFIED
API_VERSION_TYPED_FFI	4	API_VERSION_TYPED_FFI

CustomCallSchedule

Specifies the desired schedule for the custom-call.

Sprawy:

Symbol	Wartość	Smyczkowy
NIC	0	NIC
NAJNOWSZY	1	NAJNOWSZY
EARLIEST	2	EARLIEST

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

Sprawy:

Symbol	Wartość	Smyczkowy
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

Sprawy:

Symbol	Wartość	Smyczkowy
sharding	0	sharding

FftType

XLA fast fourier transform type.

Sprawy:

Symbol	Wartość	Smyczkowy
FFT	0	FFT
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

Sprawy:

Symbol	Wartość	Smyczkowy
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

Precyzja

XLA precision for an operand. Has backend specific meaning.

Sprawy:

Symbol	Wartość	Smyczkowy
DOMYŚLNY	0	DOMYŚLNY
WYSOKI	1	WYSOKI
NAJWYŻSZY	2	NAJWYŻSZY

ResultAccuracyMode

XLA result accuracy mode.

Sprawy:

Symbol	Wartość	Smyczkowy
DOMYŚLNY	0	DOMYŚLNY
NAJWYŻSZY	1	NAJWYŻSZY
TOLERANCJA	2	TOLERANCJA

RngAlgorithm

XLA PRNG algorithm to be used.

Sprawy:

Symbol	Wartość	Smyczkowy
DOMYŚLNY	0	DOMYŚLNY
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

Sprawy:

Symbol	Wartość	Smyczkowy
MUNDUR	1	MUNDUR
NORMALNA	2	NORMALNA

Transponować

Transpose options

Sprawy:

Symbol	Wartość	Smyczkowy
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
TRANSPONOWAĆ	2	TRANSPONOWAĆ
ADJOINT	3	ADJOINT