'mhlo' Dialetto

Operazioni

mhlo.abs (mhlo::AbsOp)

Funzionamento dell'ABS

Sintassi:

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

Esegue un'operazione abs elemento per elemento sul tensore operand e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando

Descrizione

operand

tensore classificato di numeri interi senza segno a 2/4/8/16/32/64 bit o di tipo float a 4/6/8/16/32/64 bit o di tipo complesso con elementi float a 32/64 bit o numeri interi con segno quantizzati uniformemente a 2/4/8/16/32 bit o numeri interi con segno quantizzati uniformemente per asse a 2/4/8/16/32 bit o numeri interi senza segno quantizzati uniformemente per asse a 2/4/8/16/32 bit o valori interi senza segno quantizzati uniformemente per asse a 2/4/8/16/32 bit

Risultati:

Risultato

Descrizione

result

tensore classificato di numeri interi senza segno a 2/4/8/16/32/64 bit o numeri in virgola mobile a 4/6/8/16/32/64 bit o numeri interi con segno quantizzati uniformemente a 2/4/8/16/32 bit o numeri interi con segno quantizzati uniformemente per asse a 2/4/8/16/32 bit o numeri interi senza segno quantizzati uniformemente per asse a 2/4/8/16/32 bit o valori interi senza segno quantizzati uniformemente per asse a 2/4/8/16/32 bit

mhlo.acos (mhlo::AcosOp)

Operazione Acos

Sintassi:

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

Esegue un'operazione acos elemento per elemento sul tensore operand e produce un tensore result .

Esempio:

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

Tratti: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Operandi:

Operando	Descrizione
operand	tensore di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

Risultati:

Risultato	Descrizione
result	tensore di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

mhlo.acosh (mhlo::AcoshOp)

Operazione Acosh

Sintassi:

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

Esegue un'operazione acosh elemento per elemento sul tensore operand e produce un tensore result .

Esempio:

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

Tratti: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Operandi:

Operando	Descrizione
operand	tensore di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

Risultati:

Risultato	Descrizione
result	tensore di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

mhlo.add (mhlo::AddOp)

Aggiungi operazione

Sintassi:

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

Esegue l'addizione elemento per elemento di due tensori lhs e rhs e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse
rhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.add_dependency (mhlo::AddDependencyOp)

Operazione AddDependency

Sintassi:

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

Questa operazione è riservata al compilatore XLA, quindi non ha ancora una specifica.

Informalmente, questa operazione utilizza due operandi: un operando dati e un token. L'output dell'operazione è l'operando dati. Se utilizzata con AfterAll, questa operazione consente di ordinare le operazioni non collaterali (quelle che non producono valori token).

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o tensore classificato di valori interi quantizzati per asse o token o token stablehlo
token	token o token stablehlo

Risultati:

Risultato	Descrizione
output	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o tensore classificato di valori interi quantizzati per asse o token o token stablehlo

mhlo.after_all (mhlo::AfterAllOp)

Operazione AfterAll

Sintassi:

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

Assicura che le operazioni che producono gli inputs vengano eseguite prima di qualsiasi operazione che dipende dal result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
inputs	variadico del token

Risultati:

Risultato	Descrizione
result	gettone

mhlo.all_gather (mhlo::AllGatherOp)

Operazione AllGather

All'interno di ciascun gruppo di processi nella griglia dei processi, concatena i valori del tensore operando di ciascun processo lungo all_gather_dim e produce un tensore risultato. Il computation viene applicato separatamente per ciascun operando in operands , producendo un risultato per operando.

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

Esempio:

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

Caratteristiche: SameOperandsAndResultElementType

Attributi:

Attributo	Tipo MLIR	Descrizione
all_gather_dim	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è non negativo
replica_groups	::mlir::DenseIntElementsAttr	Attributo di elementi interi senza segno a 64 bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	due interi a 64 bit 'handle' e 'type'
use_global_device_ids	::mlir::UnitAttr	attributo unità

Operandi:

Operando	Descrizione
operands	variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.all_reduce (mhlo::AllReduceOp)

Operazione AllReduce

All'interno di ciascun gruppo di processi nella griglia dei processi, applica un computation della funzione di riduzione ai valori di un tensore operando di ciascun processo e produce un tensore risultato. Il computation viene applicato separatamente per ciascun operando in operands , producendo un risultato per operando.

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

Esempio:

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

Caratteristiche: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Attributi:

Attributo	Tipo MLIR	Descrizione
replica_groups	::mlir::DenseIntElementsAttr	Attributo di elementi interi senza segno a 64 bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	due interi a 64 bit 'handle' e 'type'
use_global_device_ids	::mlir::UnitAttr	attributo unità

Operandi:

Operando	Descrizione
operands	variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.all_to_all (mhlo::AllToAllOp)

Operazione AllToAll

All'interno di ciascun gruppo di processi nella griglia dei processi, suddivide i valori del tensore operand lungo split_dimension in parti, distribuisce le parti suddivise tra i processi, concatena le parti sparse lungo concat_dimension e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
split_dimension	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è non negativo
concat_dimension	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è non negativo
split_count	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è positivo
replica_groups	::mlir::DenseIntElementsAttr	Attributo di elementi interi senza segno a 64 bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	due interi a 64 bit 'handle' e 'type'

Operandi:

Operando	Descrizione
operand	variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.and (mhlo::AndOp)

E operazione

Sintassi:

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

Esegue l'AND elemento per elemento di due tensori lhs e rhs e produce un tensore result

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
lhs	tensore classificato di valori booleani o interi a 2/4/8/16/32/64 bit
rhs	tensore classificato di valori booleani o interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.asin (mhlo::AsinOp)

Operazione Asin

Sintassi:

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

Esegue un'operazione asin elemento per elemento sul tensore operand e produce un tensore result .

Esempio:

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

Tratti: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Operandi:

Operando	Descrizione
operand	tensore di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

Risultati:

Risultato	Descrizione
result	tensore di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

mhlo.async_done (mhlo::AsyncDoneOp)

Operazione AsyncDone

Questa operazione è riservata al compilatore XLA, quindi non ha ancora una specifica.

In termini informali, questa operazione si blocca fino alla fine di un calcolo asincrono, restituendo il risultato finale del calcolo asincrono.

Per ulteriori informazioni, consultare la documentazione di AsyncStart.

Interfacce: InferTypeOpInterface

Operandi:

Operando	Descrizione
bundle	async_bundle con qualsiasi combinazione di tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse o valori token o token stablehlo

Risultati:

Risultato

Descrizione

«senza nome»

variadic di tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o di tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse o token o token stablehlo o tupla annidata con qualsiasi combinazione di tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o di tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o memref di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o di tipo complesso con elementi float a 32/64 bit o per tensore valori quantizzati interi o tensore classificato di valori quantizzati interi per asse o valori token

mhlo.async_start (mhlo::AsyncStartOp)

Operazione AsyncStart

Questa operazione è riservata al compilatore XLA, quindi non ha ancora una specifica.

In termini informali, questa operazione avvia un calcolo asincrono.

Questa funzione viene utilizzata quando sono presenti funzioni che contengono sia attese asincrone (come i DMA) sia calcoli on-thread. Ad esempio, una funzione potrebbe essere composta da un calcolo, un DMA, un altro calcolo, un secondo DMA e un calcolo finale. Questo sarebbe rappresentato da un async_start seguito da un async_update e da un async_done. L'async_start eseguirebbe il primo calcolo on-thread e poi avvierebbe il DMA. L'async_update attenderebbe il completamento del DMA, se non è ancora stato completato, quindi eseguirebbe il secondo calcolo nella funzione e avvierebbe il secondo DMA. Infine, l'async_done attenderebbe quest'ultimo DMA, quindi eseguirebbe l'ultimo calcolo che deve essere eseguito on-thread e restituirebbe il risultato di quel calcolo finale.

operands vengono passati direttamente al calcolo. called_computation è la funzione che verrà eseguita in modo asincrono. execution_thread è il nome del thread in cui verrà eseguita. Il thread principale è chiamato "main". Tutti i thread hanno un nome.

Restituisce tutti gli stati necessari tra le operazioni asincrone. Dopo l'assegnazione del buffer, i valori restituiti rappresentano lo spazio necessario per contenere l'input, i risultati e gli eventuali blocchi note necessari o modificati dall'operazione asincrona.

Attributi:

Attributo	Tipo MLIR	Descrizione
called_computation	::mlir::FlatSymbolRefAttr	attributo di riferimento del simbolo piatto
execution_thread	::mlir::StringAttr	attributo stringa

Operandi:

Operando

Descrizione

inputs

variadic di tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o di tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse o token o token stablehlo o tupla annidata con qualsiasi combinazione di tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o di tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o memref di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o di tipo complesso con elementi float a 32/64 bit o per tensore valori quantizzati interi o tensore classificato di valori quantizzati interi per asse o valori token

Risultati:

Risultato	Descrizione
«senza nome»	async_bundle con qualsiasi combinazione di tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse o valori token o token stablehlo

mhlo.async_update (mhlo::AsyncUpdateOp)

Operazione AsyncUpdate

Questa operazione è riservata al compilatore XLA, quindi non ha ancora una specifica.

In modo informale, questa operazione blocca un calcolo asincrono fino a una barriera di sincronizzazione. Dopo aver eseguito l'operazione, il bundle viene restituito.

Per ulteriori informazioni, consultare la documentazione di AsyncStart.

Interfacce: InferTypeOpInterface

Operandi:

Operando	Descrizione
bundle	async_bundle con qualsiasi combinazione di tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse o valori token o token stablehlo

Risultati:

Risultato	Descrizione
«senza nome»	async_bundle con qualsiasi combinazione di tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse o valori token o token stablehlo

mhlo.atan2 (mhlo::Atan2Op)

Operazione Atan2

Sintassi:

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

Esegue l'operazione atan2 elemento per elemento sui tensori lhs e rhs e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo float o complesso a 4/6/8/16/32/64 bit con elementi float a 32/64 bit o valori interi quantizzati per tensore
rhs	tensore classificato di tipo float o complesso a 4/6/8/16/32/64 bit con elementi float a 32/64 bit o valori interi quantizzati per tensore

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o complesso a 4/6/8/16/32/64 bit con elementi float a 32/64 bit o valori interi quantizzati per tensore

mhlo.atanh (mhlo::AtanhOp)

Operazione Atanh

Sintassi:

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

Esegue un'operazione atanh elemento per elemento sul tensore operand e produce un tensore result .

Esempio:

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

Tratti: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Operandi:

Operando	Descrizione
operand	tensore di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

Risultati:

Risultato	Descrizione
result	tensore di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

Operazione BatchNormGrad

Calcola i gradienti di diversi input di BatchNormTrainingOp tramite retropropagazione da grad_output e produce i tensori grad_operand , grad_scale e grad_offset .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
epsilon	::mlir::FloatAttr	Attributo float a 32 bit
feature_index	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è non negativo

Operandi:

Operando	Descrizione
operand	tensore classificato di valori float a 4/6/8/16/32/64 bit
scale	Tensore 1D di valori float a 4/6/8/16/32/64 bit
mean	Tensore 1D di valori float a 4/6/8/16/32/64 bit
variance	Tensore 1D di valori float a 4/6/8/16/32/64 bit
grad_output	tensore classificato di valori float a 4/6/8/16/32/64 bit

Risultati:

Risultato	Descrizione
grad_operand	tensore classificato di valori float a 4/6/8/16/32/64 bit
grad_scale	Tensore 1D di valori float a 4/6/8/16/32/64 bit
grad_offset	Tensore 1D di valori float a 4/6/8/16/32/64 bit

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

Operazione BatchNormInference

Normalizza il tensore operand su tutte le dimensioni, ad eccezione della dimensione feature_index , e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
epsilon	::mlir::FloatAttr	Attributo float a 32 bit
feature_index	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è non negativo

Operandi:

Operando	Descrizione
operand	tensore classificato di valori float a 4/6/8/16/32/64 bit
scale	Tensore 1D di valori float a 4/6/8/16/32/64 bit
offset	Tensore 1D di valori float a 4/6/8/16/32/64 bit
mean	Tensore 1D di valori float a 4/6/8/16/32/64 bit
variance	Tensore 1D di valori float a 4/6/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di valori float a 4/6/8/16/32/64 bit

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

Operazione BatchNormTraining

Calcola la media e la varianza tra le dimensioni batch e spaziali e normalizza il tensore operand per ogni caratteristica nella dimensione feature_index e produce i tensori output batch_mean e batch_var .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
epsilon	::mlir::FloatAttr	Attributo float a 32 bit
feature_index	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è non negativo

Operandi:

Operando	Descrizione
operand	tensore classificato di valori float a 4/6/8/16/32/64 bit
scale	Tensore 1D di valori float a 4/6/8/16/32/64 bit
offset	Tensore 1D di valori float a 4/6/8/16/32/64 bit

Risultati:

Risultato	Descrizione
output	tensore classificato di valori float a 4/6/8/16/32/64 bit
batch_mean	Tensore 1D di valori float a 4/6/8/16/32/64 bit
batch_var	Tensore 1D di valori float a 4/6/8/16/32/64 bit

mhlo.bitcast (mhlo::BitcastOp)

Operazione Bitcast

Sintassi:

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

Questa operazione è riservata al compilatore XLA, quindi non ha ancora una specifica.

In termini informali, questa operazione modifica la forma dell'input in modo che la disposizione fisica degli elementi resti invariata.

Questa operazione necessita di informazioni di layout per dare un senso alla "disposizione fisica degli elementi" e il supporto del layout in MHLO è attualmente in fase di sviluppo.

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

Operazione BitcastConvert

Sintassi:

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

Esegue un'operazione bitcast sul tensore operand e produce un tensore result in cui i bit dell'intero tensore operand vengono reinterpretati utilizzando il tipo del tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.broadcast (mhlo::BroadcastOp)

Operazione di trasmissione

Questa operazione sta per uscire da StableHLO, quindi non è inclusa nella specifica: https://github.com/openxla/stablehlo/issues/3

Informalmente, questa operazione fa la stessa cosa di Broadcast di XLA: https://www.tensorflow.org/xla/operation_semantics#broadcast

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
broadcast_sizes	::mlir::DenseIntElementsAttr	Attributo di elementi interi senza segno a 64 bit

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

Operazione BroadcastInDim

Espande le dimensioni e/o il rango di un tensore di input duplicando i dati nel tensore operand e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
broadcast_dimensions	::mlir::DenseIntElementsAttr	Attributo di elementi interi senza segno a 64 bit

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore di dimensione statica o limitata singola di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.case (mhlo::CaseOp)

operazione di caso

Produce l'output dall'esecuzione di una sola function dai branches in base al valore index .

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

Esempio:

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

Caratteristiche: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfacce: InferTypeOpInterface

Operandi:

Operando	Descrizione
index	tensore di valori interi senza segno a 32 bit

Risultati:

Risultato	Descrizione
«senza nome»	variadico del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o tensore classificato di valori interi quantizzati per asse o token

mhlo.cbrt (mhlo::CbrtOp)

operazione Cbrt

Sintassi:

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

Esegue l'operazione di radice cubica elemento per elemento sul tensore operand e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	La precisione richiesta per le operazioni unarie.

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o complesso a 4/6/8/16/32/64 bit con elementi float a 32/64 bit o valori interi quantizzati per tensore

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o complesso a 4/6/8/16/32/64 bit con elementi float a 32/64 bit o valori interi quantizzati per tensore

mhlo.ceil (mhlo::CeilOp)

Operazione a soffitto

Sintassi:

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

Esegue il ceil elemento per elemento del tensore operand e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore classificato di valori float o interi quantizzati per tensore a 4/6/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di valori float o interi quantizzati per tensore a 4/6/8/16/32/64 bit

mhlo.cholesky (mhlo::CholeskyOp)

Operazione Cholesky

Calcola la decomposizione di Cholesky di un lotto di matrici.

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
lower	::mlir::BoolAttr	attributo bool

Operandi:

Operando	Descrizione
a	tensore classificato di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o complesso a 4/6/8/16/32/64 bit con valori di elementi float a 32/64 bit

mhlo.clamp (mhlo::ClampOp)

operazione di serraggio

Sintassi:

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

Blocca ogni elemento del tensore operand tra un valore minimo e uno massimo e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
min	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse
max	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

Operazione di trasmissione collettiva

All'interno di ciascun gruppo di processi nella griglia dei processi, invia il valore del tensore operand dal processo sorgente ai processi di destinazione e produce un tensore result .

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

Esempio:

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

Caratteristiche: CompatibleOperandsAndResultType

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Attributi:

Attributo	Tipo MLIR	Descrizione
replica_groups	::mlir::DenseIntElementsAttr	Attributo di elementi interi senza segno a 64 bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	due interi a 64 bit 'handle' e 'type'

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.collective_permute (mhlo::CollectivePermuteOp)

Operazione CollectivePermute

All'interno di ciascun gruppo di processi nella griglia dei processi, invia il valore del tensore operand dal processo sorgente al processo di destinazione e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
source_target_pairs	::mlir::DenseIntElementsAttr	Attributo di elementi interi senza segno a 64 bit
channel_handle	::mlir::mhlo::ChannelHandleAttr	due interi a 64 bit 'handle' e 'type'

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

mhlo.compare (mhlo::CompareOp)

Confronta operazione

Sintassi:

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

Esegue un confronto elemento per elemento dei tensori lhs e rhs in base a comparison_direction e compare_type e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
comparison_direction	::mlir::mhlo::ComparisonDirectionAttr	Quale operazione di confronto eseguire.
compare_type	::mlir::mhlo::ComparisonTypeAttr	Quale tipo di confronto utilizzare.

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse
rhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori interi quantizzati per tensore o valori interi quantizzati per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di valori booleani

mhlo.complex (mhlo::ComplexOp)

Operazione complessa

Sintassi:

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

Esegue la conversione elemento per elemento in un valore complesso da una coppia di valori reali e immaginari, lhs e rhs , e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
lhs	tensore classificato di valori float a 32/64 bit
rhs	tensore classificato di valori float a 32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo complesso con valori di elementi float a 32/64 bit

mhlo.composite (mhlo::CompositeOp)

Operazione composita

Sintassi:

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

Incapsula un'operazione costituita (composta) da altre operazioni StableHLO, prendendo inputs e composite_attributes e producendo results . La semantica dell'operazione è implementata dall'attributo decomposition . L'operazione composite può essere sostituita con la sua scomposizione senza modificare la semantica del programma. Nei casi in cui l'incorporamento della scomposizione non fornisce la stessa semantica operativa, è preferibile utilizzare custom_call .

Il campo version (il valore predefinito è 0 ) viene utilizzato per indicare quando la semantica di un composito cambia.

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

Esempio:

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

Interfacce: SymbolUserOpInterface

Attributi:

Attributo	Tipo MLIR	Descrizione
name	::mlir::StringAttr	attributo stringa
composite_attributes	::mlir::DizionarioAttr	dizionario dei valori degli attributi denominati
decomposition	::mlir::FlatSymbolRefAttr	attributo di riferimento del simbolo piatto
version	::mlir::IntegerAttr	Attributo intero senza segno a 32 bit

Operandi:

Operando

Descrizione

inputs

variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o valori quantizzati interi per asse o token o tupla annidata con qualsiasi combinazione di tensore classificato di float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o memref di tipo float o bool a 4/6/8/16/32/64 bit o intero o complesso a 2/4/8/16/32/64 bit tipo con elementi float a 32/64 bit o valori quantizzati interi per tensore o tensore classificato di valori quantizzati interi per asse o valori token

Risultati:

Risultato

Descrizione

«senza nome»

variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o valori quantizzati interi per asse o token o tupla annidata con qualsiasi combinazione di tensore classificato di float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o memref di tipo float o bool a 4/6/8/16/32/64 bit o intero o complesso a 2/4/8/16/32/64 bit tipo con elementi float a 32/64 bit o valori quantizzati interi per tensore o tensore classificato di valori quantizzati interi per asse o valori token

mhlo.concatenate (mhlo::ConcatenateOp)

Operazione di concatenazione

Concatena un numero variadico di tensori negli inputs lungo la dimensione dimension nello stesso ordine degli argomenti forniti e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
dimension	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore non è negativo

Operandi:

Operando	Descrizione
val	variadica del tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.constant (mhlo::CostanteOp)

Operazione costante

Produce un tensore output da un value costante.

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , ConstantLike

Interfacce: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
value	::mlir::ElementsAttr	attributo vettore/tensore costante

Risultati:

Risultato	Descrizione
output	tensore di forma statica di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.convert (mhlo::ConvertOp)

Operazione di conversione

Sintassi:

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

Esegue una conversione per elemento da un tipo di elemento a un altro sul tensore operand e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfacce: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.convolution (mhlo::ConvoluzioneOp)

Operazione di convoluzione

Sintassi:

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)

Calcola i prodotti scalari tra le finestre di lhs e le fette di rhs e produce result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
window_strides	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
padding	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
lhs_dilation	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
rhs_dilation	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
window_reversal	::mlir::DenseElementsAttr	attributo booleano costante del vettore/tensore
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Struttura delle informazioni sulle dimensioni per conv op
feature_group_count	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è positivo
batch_group_count	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è positivo
precision_config	::mlir::ArrayAttr	Attributo Configurazione precisione

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
rhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.copy (mhlo::CopyOp)

Operazione di copia

Sintassi:

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

Questa operazione è privata per il compilatore XLA, quindi non ha ancora una specifica.

Informalmente, questa operazione è una copia operand . A seconda dei metadati allegati all'operazione, questa può comportarsi in modo molto diverso da una no-op.

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
cross_program_prefetch_index	::mlir::IntegerAttr	Attributo intero senza segno a 32 bit

Operandi:

Operando

Descrizione

operand

tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o valori quantizzati interi per asse o token o tupla annidata con qualsiasi combinazione di tensore classificato di 4/6/8/16/32/64 bit float o bool o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o memref di tipo intero o complesso a 4/6/8/16/32/64 bit float o bool o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o tensore classificato di valori quantizzati interi per asse o valori token

Risultati:

Risultato

Descrizione

result

tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o valori quantizzati interi per asse o token o tupla annidata con qualsiasi combinazione di tensore classificato di 4/6/8/16/32/64 bit float o bool o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o memref di tipo intero o complesso a 4/6/8/16/32/64 bit float o bool o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o tensore classificato di valori quantizzati interi per asse o valori token

mhlo.cosh (mhlo::CoshOp)

Operazione Cosh

Sintassi:

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

Esegue un'operazione di cosh per elemento sul tensore operand e produce un tensore result .

Esempio:

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

Caratteristiche: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfacce: InferShapedTypeOpInterface , InferTypeOpInterface

Operandi:

Operando	Descrizione
operand	tensore di tipo float a 4/6/8/16/32/64 bit o complesso con valori di elementi float a 32/64 bit

Risultati:

Risultato	Descrizione
result	tensore di tipo float a 4/6/8/16/32/64 bit o complesso con valori di elementi float a 32/64 bit

mhlo.cosine (mhlo::CosenoOp)

Operazione coseno

Sintassi:

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

Esegue l'operazione coseno per elemento sul tensore operand e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	La precisione richiesta per le operazioni unarie.

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float a 4/6/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float a 4/6/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore

mhlo.count_leading_zeros (mhlo::ClzOp)

Operazione Clz

Sintassi:

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

Esegue il conteggio per elemento del numero di bit zero iniziali nel tensore operand e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore classificato di valori interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di valori interi a 2/4/8/16/32/64 bit

mhlo.create_token (mhlo::CreateTokenOp)

Operazione Crea token

Sintassi:

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

Questa operazione sta per uscire da StableHLO, quindi non è inclusa nelle specifiche: https://github.com/openxla/stablehlo/issues/3

Informalmente, questa operazione fa la stessa cosa di AfterAllOp con 0 input: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

Esempio:

%output = mhlo.create_token : !mhlo.token

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Risultati:

Risultato	Descrizione
output	gettone

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

Operazione CrossReplicaSum

Questa operazione sta per uscire da StableHLO, quindi non è inclusa nelle specifiche: https://github.com/openxla/stablehlo/issues/3

Informalmente, questa operazione fa la stessa cosa di AllReduceOp con channel_id = 0 , use_global_device_ids = false e aggiunta di implementazione del computation : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
replica_groups	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.custom_call (mhlo::CustomCallOp)

Operazione CustomCall

Sintassi:

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

Incapsula un'operazione definita dall'implementazione call_target_name che accetta inputs e called_computations e produce results .

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

Esempio:

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

Interfacce: MemoryEffectOpInterface

Attributi:

Attributo	Tipo MLIR	Descrizione
call_target_name	::mlir::StringAttr	attributo stringa
has_side_effect	::mlir::BoolAttr	attributo bool
backend_config	::mlir::Attributo	attributo stringa o dizionario dei valori degli attributi denominati
api_version	::mlir::mhlo::CustomCallApiVersionAttr	Versione API per chiamate personalizzate
called_computations	::mlir::ArrayAttr	attributo dell'array di riferimento del simbolo piatto
custom_call_schedule	::mlir::mhlo::CustomCallScheduleAttr	Specifica la pianificazione desiderata per la chiamata personalizzata.
operand_layouts	::mlir::ArrayAttr	Matrice di attributi di layout (tensore 1D di tipo indice).
result_layouts	::mlir::ArrayAttr	Matrice di attributi di layout (tensore 1D di tipo indice).
output_operand_aliases	::mlir::ArrayAttr	Attributo di alias per uscite e operandi di CustomCall

Operandi:

Operando

Descrizione

inputs

variadica del tensore di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o valori quantizzati interi per asse o memref di 4/6/8/16/32/64 bit float o bool o Tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o token o tupla annidata con qualsiasi combinazione di tensore di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o intero per tensore quantizzato o intero per asse valori quantizzati o memref di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o valori token

Risultati:

Risultato

Descrizione

«senza nome»

variadica del tensore di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o valori quantizzati interi per asse o memref di 4/6/8/16/32/64 bit float o bool o Tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o token o tupla annidata con qualsiasi combinazione di tensore di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o intero per tensore quantizzato o intero per asse valori quantizzati o memref di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o valori token

mhlo.divide (mhlo::DivOp)

Operazione div

Sintassi:

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

Esegue la divisione per elemento dei tensori del dividendo lhs e del divisore rhs destra e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo intero a 2/4/8/16/32/64 bit o tipo float a 4/6/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
rhs	tensore classificato di tipo intero a 2/4/8/16/32/64 bit o tipo float a 4/6/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo intero a 2/4/8/16/32/64 bit o tipo float a 4/6/8/16/32/64 bit o complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.domain (mhlo::DomainOp)

Operazione di dominio

Questa operazione è privata per il compilatore XLA, quindi non ha ancora una specifica.

Informalmente, queste operazioni vengono utilizzate per raggruppare istruzioni con la stessa proprietà DomainMetadata. ShardingMetadata è oggi il caso d'uso principale per raggruppare le istruzioni sullo stesso dispositivo. Le istruzioni di dominio offrono due vantaggi principali:

• Impedisci l'ottimizzazione involontaria delle istruzioni tra domini.
• Assegna automaticamente i metadati delle istruzioni create nel dominio. Senza le istruzioni del dominio, ogni passaggio di ottimizzazione HLO dovrebbe controllare e propagare i metadati, il che sarebbe facile da perdere e aggiungerebbe complessità al compilatore. Poiché le istruzioni di dominio collegano due domini diversi, ciascuna istruzione di dominio è associata a due DomainMetadata: uno sul lato operando e uno sul lato utente del dominio.

Caratteristiche: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
kind	::mlir::mhlo::DomainKindAttr	Tipo di metadati del dominio collegati a un dominio HLO.
entry_metadata	::mlir::StringAttr	attributo stringa
exit_metadata	::mlir::StringAttr	attributo stringa

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o tensore classificato di valori quantizzati interi per asse o token

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o tensore classificato di valori quantizzati interi per asse o token

mhlo.dot (mhlo::DotOp)

Operazione punto

Questa operazione sta per uscire da StableHLO, quindi non è inclusa nelle specifiche: https://github.com/openxla/stablehlo/issues/3

Informalmente, questa operazione fa la stessa cosa di Dot di XLA: https://www.tensorflow.org/xla/operazione_semantics#dot

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
precision_config	::mlir::ArrayAttr	Attributo Configurazione precisione

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
rhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dot_general (mhlo::DotGeneralOp)

PuntoOperazione generale

Calcola i prodotti scalari tra le fette di lhs e le fette di rhs e produce un tensore result .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
dot_dimension_numbers	::mlir::mhlo::DotDimensionNumbersAttr	Attributo che modella le informazioni sulla dimensione per punto.
precision_config	::mlir::ArrayAttr	Attributo Configurazione precisione
algorithm	::mlir::mhlo::DotAlgorithmAttr	Attributo che modella i vincoli dell'algoritmo da utilizzare per il calcolo del punto.

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
rhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

Operazione DynamicBroadcastInDim

Questa operazione è funzionalmente identica a broadcast_in_dim op, ma la forma del risultato viene specificata dinamicamente tramite output_dimensions .

Accetta anche attributi facoltativi per esprimere conoscenza statica sul comportamento di espansione delle dimensioni. Se non specificato, si presuppone che tutte le dimensioni siano in espansione. Gli insiemi di dimensioni noti per essere espandibili e l'insieme di dimensioni noti per non essere espandibili devono essere disgiunti e devono essere un sottoinsieme delle dimensioni dell'operando.

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
broadcast_dimensions	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
known_expanding_dimensions	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
known_nonexpanding_dimensions	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
output_dimensions	Tensore 1D dell'indice o valori interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dynamic_conv (mhlo::DynamicConvOp)

Operazione DynamicConv

Questa operazione è un work in progress, quindi non è ancora inclusa nelle specifiche: https://github.com/openxla/stablehlo/issues/8

Informalmente, questa operazione fa la stessa cosa di ConvolutionOp tranne che il padding viene specificato dinamicamente tramite d_padding : https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
window_strides	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
padding	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
lhs_dilation	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
rhs_dilation	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit
window_reversal	::mlir::DenseElementsAttr	attributo booleano costante del vettore/tensore
dimension_numbers	::mlir::mhlo::ConvDimensionNumbersAttr	Struttura delle informazioni sulle dimensioni per conv op
feature_group_count	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è positivo
batch_group_count	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore è positivo
precision_config	::mlir::ArrayAttr	Attributo Configurazione precisione

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
rhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
d_padding	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

Operazione DynamicGather

Questa operazione è un work in progress, quindi non è ancora inclusa nelle specifiche: https://github.com/openxla/stablehlo/issues/8

Informalmente, questa operazione fa la stessa cosa di GatherOp tranne che slice_sizes è specificato dinamicamente: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
dimension_numbers	::mlir::mhlo::GatherDimensionNumbersAttr	Attributo che modella le informazioni sulla dimensione per la raccolta
indices_are_sorted	::mlir::BoolAttr	attributo bool

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
start_indices	tensore classificato di valori interi a 2/4/8/16/32/64 bit
slice_sizes	tensore intero unidimensionale di forma statica di valori interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

Operazione DynamicIota

Questa operazione è funzionalmente identica a iota op, ma la forma del risultato viene specificata dinamicamente tramite output_shape .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
iota_dimension	::mlir::IntegerAttr	Attributo intero senza segno a 64 bit il cui valore non è negativo

Operandi:

Operando	Descrizione
output_shape	Tensore 1D dell'indice o valori interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dynamic_pad (mhlo::DynamicPadOp)

Funzionamento del DynamicPad

Sintassi:

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

Riempie dinamicamente l' operand , con la quantità di riempimento aggiunta nella fascia bassa/alta/interna che viene passata attraverso i tensori di input.

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
padding_value	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
edge_padding_low	Tensore 1D dell'indice o valori interi a 2/4/8/16/32/64 bit
edge_padding_high	Tensore 1D dell'indice o valori interi a 2/4/8/16/32/64 bit
interior_padding	Tensore 1D dell'indice o valori interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

Operazione DynamicReshape

Sintassi:

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

Questa operazione è funzionalmente identica a reshape op, ma la forma del risultato viene specificata dinamicamente tramite output_shape .

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

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
output_shape	Tensore 1D dell'indice o valori interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore di tipo float o bool a 4/6/8/16/32/64 bit o tipo intero o complesso a 2/4/8/16/32/64 bit con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

Operazione DynamicSlice

Estrae una sezione operand utilizzando indici iniziali calcolati dinamicamente e produce un tensore result .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
slice_sizes	::mlir::DenseIntElementsAttr	Attributo degli elementi interi senza segno a 64 bit

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
start_indices	variadica del tensore 0D di valori interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

Operazione DynamicUpdateSlice

Sintassi:

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

Produce un tensore result che è uguale al tensore operand tranne per il fatto che la sezione che inizia da start_indices viene aggiornata con i valori in update .

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

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , InferTensorType

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

Effetti: MemoryEffects::Effect{}

Operandi:

Operando	Descrizione
operand	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
update	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
start_indices	variadica del tensore 0D di valori interi a 2/4/8/16/32/64 bit

Risultati:

Risultato	Descrizione
result	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.einsum (mhlo::EinsumOp)

Operazione Einsum

Questa operazione sta per uscire da StableHLO, quindi non è inclusa nelle specifiche: https://github.com/openxla/stablehlo/issues/3

Informalmente, questa operazione fa la stessa cosa dell'einsum di TF: https://www.tensorflow.org/api_docs/python/tf/einsum

Esempio:

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

Tratti: AlwaysSpeculatableImplTrait

Interfacce: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effetti: MemoryEffects::Effect{}

Attributi:

Attributo	Tipo MLIR	Descrizione
einsum_config	::mlir::StringAttr	attributo stringa

Operandi:

Operando	Descrizione
lhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse
rhs	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

Risultati:

Risultato	Descrizione
«senza nome»	tensore classificato di tipo float o bool a 4/6/8/16/32/64 bit o intero a 2/4/8/16/32/64 bit o tipo complesso con elementi float a 32/64 bit o valori quantizzati interi per tensore o quantizzati interi per asse

mhlo.erf (mhlo::ErfOp)

Operazione Erf

Sintassi:

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

Esegue l'operazione erf per elemento sul tensore operand e produce un tensore result .

Esempio:

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

Caratteristiche: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

Risultato	Descrizione
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.exponential (mhlo::ExpOp)

Exp operation

Sintassi:

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

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

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Esempio:

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

Attributi:

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

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

Risultato	Descrizione
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.

Attributi:

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

Operands:

Operand	Descrizione
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

Results:

Risultato

Descrizione

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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributi:

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

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	tensor of 32-bit signless integer values

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

Sintassi:

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

Esempio:

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

Attributi:

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

Operands:

Operand

Descrizione

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

Results:

Risultato

Descrizione

«unnamed»

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	Descrizione
pred	ranked tensor of bool values

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

Risultato	Descrizione
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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
infeed_config	::mlir::StringAttr	string attribute
layout	::mlir::ArrayAttr	array attribute

Operands:

Operand	Descrizione
token	gettone

Results:

Risultato

Descrizione

«unnamed»

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributi:

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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

Risultato	Descrizione
y	ranked tensor of bool values

mhlo.log (mhlo::LogOp)

Log operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Esempio:

%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

Attributi:

Attributo	MLIR Type	Descrizione
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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	Descrizione
shapes	variadic of 1D tensor of index values

Results:

Risultato	Descrizione
results	variadic of 1D tensor of index values

mhlo.multiply (mhlo::MulOp)

Mul operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

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

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

Sintassi:

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

Esempio:

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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Esempio:

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

Interfaces: InferTypeOpInterface

Attributi:

Attributo	MLIR Type	Descrizione
outfeed_config	::mlir::StringAttr	string attribute

Operands:

Operand	Descrizione
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	gettone

Results:

Risultato	Descrizione
«unnamed»	gettone

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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

Results:

Risultato	Descrizione
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

Risultato	Descrizione
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.power (mhlo::PowOp)

Pow operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

Risultato	Descrizione
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.real_dynamic_slice (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

Sintassi:

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

Esempio:

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

Results:

Risultato	Descrizione
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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
token	gettone

Results:

Risultato

Descrizione

«unnamed»

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

Esempio:

%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

Attributi:

Attributo	MLIR Type	Descrizione
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
operand	ranked tensor of 4/6/8/16/32/64-bit float values

Results:

Risultato	Descrizione
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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Esempio:

%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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Results:

Risultato	Descrizione
«unnamed»	ranked tensor of 32-bit unsigned integer values

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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{}

Attributi:

Attributo	MLIR Type	Descrizione
dimensions	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Esempio:

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

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributi:

Attributo	MLIR Type	Descrizione
rng_distribution	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
rng_algorithm	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

Operands:

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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

Risultato	Descrizione
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.round_nearest_even (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

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

Results:

Risultato	Descrizione
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.rsqrt (mhlo::RsqrtOp)

Rsqrt operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Esempio:

%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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Results:

Risultato	Descrizione
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

Esempio:

%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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Esempio:

%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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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	gettone

Results:

Risultato	Descrizione
«unnamed»	gettone

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

Esempio:

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

Attributi:

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

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_arithmetic (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

Sintassi:

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

Esempio:

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

Results:

Risultato	Descrizione
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.shift_right_logical (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

Sintassi:

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

Esempio:

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

Results:

Risultato	Descrizione
result	ranked tensor of 2/4/8/16/32/64-bit integer values

mhlo.sign (mhlo::SignOp)

Sign operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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.

Esempio:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

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

Results:

Risultato	Descrizione
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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Esempio:

%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

Attributi:

Attributo	MLIR Type	Descrizione
dimension	::mlir::IntegerAttr	64-bit signless integer attribute
is_stable	::mlir::BoolAttr	bool attribute

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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.

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributi:

Attributo	MLIR Type	Descrizione
result_accuracy	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Sintassi:

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

Esempio:

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

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Attributi:

Attributo	MLIR Type	Descrizione
k	::mlir::IntegerAttr	64-bit signless integer attribute
largest	::mlir::BoolAttr	bool attribute

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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.

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
dim	::mlir::IntegerAttr	64-bit signless integer attribute
batch_dims	::mlir::IntegerAttr	64-bit signless integer attribute

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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.

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
tag	::mlir::StringAttr	string attribute

Operands:

Operand	Descrizione
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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
permutation	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Esempio:

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

Attributi:

Attributo	MLIR Type	Descrizione
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	Descrizione
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

Results:

Risultato	Descrizione
«unnamed»	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

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand

Descrizione

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

Results:

Risultato

Descrizione

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

Sintassi:

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

Esempio:

%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	Descrizione
operand	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

Results:

Risultato	Descrizione
result	ranked tensor of 4/6/8/16/32/64-bit float values

mhlo.uniform_quantize (mhlo::UniformQuantizeOp)

UniformQuantize operation

Sintassi:

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

Esempio:

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

Results:

Risultato	Descrizione
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

Esempio:

%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

Descrizione

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

Results:

Risultato

Descrizione

«unnamed»

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

Sintassi:

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

Attributi:

Attributo	MLIR Type	Descrizione
delta	::mlir::IntegerAttr	64-bit signless integer attribute

Results:

Risultato	Descrizione
«unnamed»	statically shaped tensor of 64-bit unsigned integer values

mhlo.xor (mhlo::XorOp)

Xor operation

Sintassi:

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

Esempio:

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

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

Operand	Descrizione
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

Results:

Risultato	Descrizione
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

Attributes

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:

Parametro	C++ type	Descrizione
argTupleIndices	::llvm::ArrayRef<int64_t>	Dimensione
resultIndex	int64_t
resultTupleIndices	::llvm::ArrayRef<int64_t>	Dimensione
isMustAlias	bool

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

Sintassi:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

Parameters:

Parametro	C++ type	Descrizione
maniglia	int64_t
tipo	int64_t

ComparisonDirectionAttr

Which comparison operation to perform.

Sintassi:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::ComparisonDirection	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

Sintassi:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::ComparisonType	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

Parameters:

Parametro	C++ type	Descrizione
inputBatchDimension	int64_t
inputFeatureDimension	int64_t
inputSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensione
kernelInputFeatureDimension	int64_t
kernelOutputFeatureDimension	int64_t
kernelSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensione
outputBatchDimension	int64_t
outputFeatureDimension	int64_t
outputSpatialDimensions	::llvm::ArrayRef<int64_t>	Dimensione

CrossProgramPrefetchAttr

Argument that is prefetched from another program

Sintassi:

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

Per esempio,

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:

Parametro	C++ type	Descrizione
parametro	int64_t
indici	::llvm::ArrayRef<int64_t>	Dimensione
offset	std::optional<int64_t>

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

Sintassi:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::CustomCallSchedule	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

Sintassi:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::DequantizeMode	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

Sintassi:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::DomainKind	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

Sintassi:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

Parameters:

Parametro	C++ type	Descrizione
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:

Parametro	C++ type	Descrizione
lhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Dimensione
rhsBatchingDimensions	::llvm::ArrayRef<int64_t>	Dimensione
lhsContractingDimensions	::llvm::ArrayRef<int64_t>	Dimensione
rhsContractingDimensions	::llvm::ArrayRef<int64_t>	Dimensione

FftTypeAttr

XLA fast fourier transform type.

Sintassi:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::FftType	an enum of type FftType

FusionKindAttr

Fusion kind

Sintassi:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::FusionKind	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

Parameters:

Parametro	C++ type	Descrizione
offsetDims	::llvm::ArrayRef<int64_t>	Dimensione
collapsedSliceDims	::llvm::ArrayRef<int64_t>	Dimensione
operandBatchingDims	::llvm::ArrayRef<int64_t>	Dimensione
startIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Dimensione
startIndexMap	::llvm::ArrayRef<int64_t>	Dimensione
indexVectorDim	int64_t

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

Sintassi:

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

Parametro	C++ type	Descrizione
outputTupleIndices	::llvm::ArrayRef<int64_t>	Dimensione
operandIndex	int64_t
operandTupleIndices	::llvm::ArrayRef<int64_t>	Dimensione

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

Sintassi:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::Precision	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

Parameters:

Parametro	C++ type	Descrizione
dotDimensionNumbers	::mlir::mhlo::DotDimensionNumbersAttr	Attribute that models the dimension information for dot.
lhsRaggedDimensions	::llvm::ArrayRef<int64_t>	Dimensione
rhsGroupDimensions	::llvm::ArrayRef<int64_t>	Dimensione

ResultAccuracyAttr

The requested accuracy for unary ops.

Parameters:

Parametro	C++ type	Descrizione
atol	APFloat
rtol	APFloat
ulps	int64_t
modalità	::mlir::mhlo::ResultAccuracyModeAttr	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

Sintassi:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::ResultAccuracyMode	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

Sintassi:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::RngAlgorithm	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

Sintassi:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::RngDistribution	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

Parameters:

Parametro	C++ type	Descrizione
updateWindowDims	::llvm::ArrayRef<int64_t>	Dimensione
insertedWindowDims	::llvm::ArrayRef<int64_t>	Dimensione
inputBatchingDims	::llvm::ArrayRef<int64_t>	Dimensione
scatterIndicesBatchingDims	::llvm::ArrayRef<int64_t>	Dimensione
scatterDimsToOperandDims	::llvm::ArrayRef<int64_t>	Dimensione
indexVectorDim	int64_t

TransposeAttr

Transpose options

Sintassi:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

Parameters:

Parametro	C++ type	Descrizione
valore	::mlir::mhlo::Transpose	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

Sintassi:

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

Parametro	C++ type	Descrizione
bounds	::llvm::ArrayRef<int64_t>

Tipi

AsyncBundleType

Opaque collection of other types

Sintassi:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

Parameters:

Parametro	C++ type	Descrizione
tipi	::llvm::ArrayRef<Type>

Enums

ComparisonDirection

Which comparison operation to perform.

Cases:

Simbolo	Valore	Corda
EQ	0	EQ
NE	1	NE
GE	2	GE
GT	3	GT
LE	4	LE
TENENTE	5	TENENTE

ComparisonType

Which comparison type to use.

Cases:

Simbolo	Valore	Corda
NOTYPE	0	NOTYPE
GALLEGGIANTE	1	GALLEGGIANTE
TOTALORDER	2	TOTALORDER
FIRMATO	3	FIRMATO
UNSIGNED	4	UNSIGNED

CustomCallApiVersion

Custom call API version

Cases:

Simbolo	Valore	Corda
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.

Cases:

Simbolo	Valore	Corda
NESSUNO	0	NESSUNO
ULTIMO	1	ULTIMO
EARLIEST	2	EARLIEST

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

Cases:

Simbolo	Valore	Corda
MIN_COMBINED	0	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

Cases:

Simbolo	Valore	Corda
sharding	0	sharding

FftType

XLA fast fourier transform type.

Cases:

Simbolo	Valore	Corda
FFT	0	FFT
IFFT	1	IFFT
RFFT	2	RFFT
IRFFT	3	IRFFT

FusionKind

Fusion kind

Cases:

Simbolo	Valore	Corda
kLoop	0	kLoop
kInput	1	kInput
kOutput	2	kOutput
kCustom	3	kCustom

Precisione

XLA precision for an operand. Has backend specific meaning.

Cases:

Simbolo	Valore	Corda
PREDEFINITO	0	PREDEFINITO
ALTO	1	ALTO
PIÙ ALTO	2	PIÙ ALTO

ResultAccuracyMode

XLA result accuracy mode.

Cases:

Simbolo	Valore	Corda
PREDEFINITO	0	PREDEFINITO
PIÙ ALTO	1	PIÙ ALTO
TOLLERANZA	2	TOLLERANZA

RngAlgorithm

XLA PRNG algorithm to be used.

Cases:

Simbolo	Valore	Corda
PREDEFINITO	0	PREDEFINITO
THREE_FRY	1	THREE_FRY
PHILOX	2	PHILOX

RngDistribution

XLA PRNG distribution to be used.

Cases:

Simbolo	Valore	Corda
UNIFORME	1	UNIFORME
NORMALE	2	NORMALE

Trasporre

Transpose options

Cases:

Simbolo	Valore	Corda
TRANSPOSE_INVALID	0	TRANSPOSE_INVALID
NO_TRANSPOSE	1	NO_TRANSPOSE
TRASPORRE	2	TRASPORRE
ADJOINT	3	ADJOINT