‘asctile’ Dialect

Tile-level operations

Operations
Attributes
Enums

Operations

`asctile.accumulator` (asctile::AccumulatorOp)

Create a zeros tensor in L0C or initialize with bias

Syntax:

operation ::= `asctile.accumulator` ($bias^)? attr-dict `:` qualified(type($result)) (`,` type($bias)^)?

Operands:

Operand	Description
`bias`	local tensor of bfloat16 type or 16-bit float or 32-bit float values of ranks 1

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.adds` (asctile::AddSOp)

Compute element-wise addition of tensor and scalar

Syntax:

operation ::= `asctile.adds` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.assert` (asctile::AssertOp)

Declare an assertion

Syntax:

operation ::= `asctile.assert` $cond `,` $msg attr-dict `:` type($cond)

Attributes:

Attribute	MLIR Type	Description
`msg`	::mlir::StringAttr	string attribute

Operands:

Operand	Description
`cond`	1-bit signless integer

`asctile.atomic_rmw` (asctile::AtomicRMWOp)

Atomic accumulation the tensor data into a tensor

Syntax:

operation ::= `asctile.atomic_rmw` `<` $kind `>` $value `,` $base `[` $offsets `]` attr-dict `:` qualified(type($value)) `,` qualified(type($base))

Interfaces: MemoryEffectsOpInterface

Attributes:

Attribute	MLIR Type	Description
`kind`	::mlir::asctile::AtomicKindAttr	kind of atomic {{% markdown %}}Kind of atomic operation{{% /markdown %}}

Operands:

Operand	Description
`value`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`base`	global tensor
`offsets`	variadic of 32-bit signless integer

`asctile.bitwise_mask` (asctile::BitwiseMaskOp)

Apply mask (bit mode) to nested operations

Syntax:

operation ::= `asctile.bitwise_mask` $highBits `,` $lowBits (`,` $other^ `:` type($other))? $region attr-dict

Traits: SingleBlockImplicitTerminator<YieldOp>, SingleBlock

Operands:

Operand	Description
`highBits`	64-bit signless integer
`lowBits`	64-bit signless integer
`other`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

`asctile.bitwise_not` (asctile::BitwiseNotOp)

Compute the bitwise NOT of a tensor

Syntax:

operation ::= `asctile.bitwise_not` $operand attr-dict `:` type($operand)

Traits: AlwaysSpeculatableImplTrait, Elementwise

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	local tensor of 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`result`	local tensor of 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.broadcast` (asctile::BroadcastOp)

Broadcast tensor to the provided shape

Syntax:

operation ::= `asctile.broadcast` $operand attr-dict `:` qualified(type($operand)) `to` qualified(type($result))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.cast` (asctile::CastOp)

Cast tensor elements to other data type

Syntax:

operation ::= `asctile.cast` $roundMode $in attr-dict `:` qualified(type($in)) `to` qualified(type($out))

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape

Interfaces: CastOpInterface, ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`roundMode`	::mlir::asctile::RoundModeAttr	cast rounding mode {{% markdown %}}Cast rounding mode{{% /markdown %}}

Operands:

Operand	Description
`in`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`out`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.cmps` (asctile::CmpSOp)

Compute element-wise comparison of tensor and scalar

Syntax:

operation ::= `asctile.cmps` $cmpMode $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`cmpMode`	::mlir::asctile::CompareModeAttr	comparsion type {{% markdown %}}Comparsion mode{{% /markdown %}}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 1-bit signless integer values

`asctile.copy` (asctile::CopyOp)

Copy from a tensor into a new sub-tensor

Syntax:

operation ::= `asctile.copy` $base `[` $offsets `]` attr-dict `:` qualified(type($base)) `,` qualified(type($result))

Attributes:

Attribute	MLIR Type	Description
`split`	::mlir::asctile::SplitModeAttr	split mode {{% markdown %}}Split strategy when copying from L0C to UB{{% /markdown %}}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`offsets`	variadic of 32-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.copy_fixpipe` (asctile::CopyFixpipeOp)

Store a tensor into a sub-tensor via FixPipe

Syntax:

operation ::= `asctile.copy_fixpipe` $base `[` $offsets `]` attr-dict `:` qualified(type($base)) `,` qualified(type($result))

Attributes:

Attribute	MLIR Type	Description
`relu`	::mlir::UnitAttr	unit attribute
`quantize`	::mlir::UnitAttr	unit attribute
`split`	::mlir::asctile::SplitModeAttr	split mode {{% markdown %}}Split strategy when copying from L0C to UB{{% /markdown %}}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`offsets`	variadic of 32-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.count_mask` (asctile::CountMaskOp)

Apply mask (count mode) to nested operations

Syntax:

operation ::= `asctile.count_mask` $count (`,` $other^ `:` type($other))? $region attr-dict

Traits: SingleBlockImplicitTerminator<YieldOp>, SingleBlock

Operands:

Operand	Description
`count`	64-bit signless integer
`other`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

`asctile.cube_group` (asctile::CubeGroupOp)

Group operations targeting the AI Cube compute unit (L0A/L0B/L0C/L1/FIX/BT)

Syntax:

operation ::= `asctile.cube_group` (`(` $operands^ `:` type($operands) `)`)? $region (`:` type($results)^)? attr-dict

Traits: SingleBlockImplicitTerminator<YieldOp>, SingleBlock

Operands:

Operand	Description
`operands`	variadic of any type

Results:

Result	Description
`results`	variadic of any type

`asctile.cv_strategy` (asctile::CVStrategyOp)

Declare CV ratio-based strategy for wrapped operations

Syntax:

operation ::= `asctile.cv_strategy` $split (`->` type($results)^)? $region attr-dict

Traits: SingleBlockImplicitTerminator<YieldOp>, SingleBlock

Attributes:

Attribute	MLIR Type	Description
`split`	::mlir::asctile::SplitModeAttr	split mode {{% markdown %}}Split strategy when copying from L0C to UB{{% /markdown %}}

Results:

Result	Description
`results`	variadic of any type

`asctile.dim` (asctile::DimOp)

Obtain dimension of given tensor

Syntax:

operation ::= `asctile.dim` $base `,` $index attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`index`	::mlir::IntegerAttr	32-bit signless integer attribute

Operands:

Operand	Description
`base`	global tensor

Results:

Result	Description
`result`	32-bit signless integer

`asctile.divs` (asctile::DivSOp)

Compute element-wise division of tensor and scalar

Syntax:

operation ::= `asctile.divs` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.dump_tensor` (asctile::DumpTensorOp)

Print all the information of the tensor

Syntax:

operation ::= `asctile.dump_tensor` $tensor attr-dict `:` type($tensor)

Operands:

Operand	Description
`tensor`	global tensor or local tensor

`asctile.gather` (asctile::GatherOp)

Load elements from a global tensor by index

Syntax:

operation ::= `asctile.gather` $src `[` $offsets `]` `,` $index (`,` $numIndices^ )? `,` $dim (`,` $padValue^ )? attr-dict `:` type($src) `,`
              type($index) `,` type($result)

Traits: AttrSizedOperandSegments

Interfaces: MemoryEffectsOpInterface

Attributes:

Attribute	MLIR Type	Description
`dim`	::mlir::IntegerAttr	32-bit signless integer attribute
`checkBounds`	::mlir::UnitAttr	unit attribute

Operands:

Operand	Description
`src`	global tensor
`offsets`	variadic of 32-bit signless integer
`index`	local tensor of 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values of ranks 1
`numIndices`	32-bit signless integer
`padValue`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.get_value` (asctile::GetValueOp)

Load value from a global tensor

Syntax:

operation ::= `asctile.get_value` $base `[` $offsets `]` attr-dict `:` qualified(type($base))

Interfaces: MemoryEffectsOpInterface

Operands:

Operand	Description
`base`	global tensor
`offsets`	variadic of 32-bit signless integer

Results:

Result	Description
`result`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

`asctile.inline_vf` (asctile::InlineVFOp)

Declare vector function provided as C++ code

Syntax:

operation ::= `asctile.inline_vf` `(` $inputs `)` $code attr-dict `:` functional-type($inputs, results)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`code`	::mlir::StringAttr	string attribute

Operands:

Operand	Description
`inputs`	variadic of local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.layer_norm` (asctile::LayerNormOp)

Compute LayerNorm function over a tensor

Syntax:

operation ::= `asctile.layer_norm` $input `,` $gamma `,` $beta `,` $epsilon attr-dict `:` type($input) `,` type($gamma) `,` type($beta) `,` type($mean)
              `,` type($outputVarRstd)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`outputRstd`	::mlir::UnitAttr	unit attribute

Operands:

Operand	Description
`input`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values
`gamma`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values
`beta`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values
`epsilon`	32-bit float

Results:

Result	Description
`output`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values
`mean`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values
`outputVarRstd`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values

`asctile.leaky_relu` (asctile::LeakyReluOp)

Compute element-wise leaky ReLU of tensor and scalar

Syntax:

operation ::= `asctile.leaky_relu` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.load` (asctile::LoadOp)

Load from the global tensor into a new local tensor

Syntax:

operation ::= `asctile.load` $base `[` $offsets `]` (`,` $padValue^)? (`,` `(` $realShape^ `)`)? attr-dict `:` qualified(type($base)) `,`
              qualified(type($result))

Traits: AttrSizedOperandSegments

Interfaces: MemoryEffectsOpInterface

Operands:

Operand	Description
`base`	global tensor
`offsets`	variadic of 32-bit signless integer
`padValue`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer
`realShape`	variadic of 32-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.matmul` (asctile::MatmulOp)

Compute matrix multiplication on 2D tiles with optional bias

Syntax:

operation ::= `asctile.matmul` $matrixA `,` $matrixB (`,` $bias^)? attr-dict `:` type($matrixA) `,` type($matrixB) (`,` type($bias)^)? `->`
              type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`hf32`	::mlir::UnitAttr	unit attribute

Operands:

Operand	Description
`matrixA`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values of ranks 2
`matrixB`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values of ranks 2
`bias`	local tensor of bfloat16 type or 16-bit float or 32-bit float values of ranks 1

Results:

Result	Description
`result`	local tensor of 32-bit float values of ranks 2

`asctile.matmul_acc` (asctile::MatmulAccOp)

Compute matrix multiplication with accumulator on 2D tiles

Syntax:

operation ::= `asctile.matmul_acc` $acc `,` $matrixA `,` $matrixB attr-dict `:` type($acc) `,` type($matrixA) `,` type($matrixB)

Interfaces: MemoryEffectsOpInterface

Attributes:

Attribute	MLIR Type	Description
`hf32`	::mlir::UnitAttr	unit attribute

Operands:

Operand	Description
`acc`	local tensor of 32-bit float values of ranks 2
`matrixA`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values of ranks 2
`matrixB`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values of ranks 2

`asctile.maxs` (asctile::MaxSOp)

Compute element-wise maximum value of tensor and scalar

Syntax:

operation ::= `asctile.maxs` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.mins` (asctile::MinSOp)

Compute element-wise minimum value of tensor and scalar

Syntax:

operation ::= `asctile.mins` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.muls` (asctile::MulSOp)

Compute element-wise multiplication of tensor and scalar

Syntax:

operation ::= `asctile.muls` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.power` (asctile::PowerOp)

Compute one tensor to the power of other tensor

Syntax:

operation ::= `asctile.power` $lhs `,` $rhs attr-dict `:` type($result)

Traits: AlwaysSpeculatableImplTrait, Elementwise

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`lhs`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`rhs`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.reduce` (asctile::ReduceOp)

Reduce tensor to the provided shape

Syntax:

operation ::= `asctile.reduce` $kind $operand attr-dict `:` qualified(type($operand)) `,` qualified(type($result))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`dims`	::mlir::ArrayAttr	32-bit integer array attribute
`kind`	::mlir::asctile::ReduceKindAttr	kind of reduce {{% markdown %}}Kind of reduce operation{{% /markdown %}}

Operands:

Operand	Description
`operand`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.reduce_as_1d` (asctile::ReduceAs1dOp)

Reduce tensor to 1-element tensor or a scalar value

Syntax:

operation ::= `asctile.reduce_as_1d` $kind $operand attr-dict `:` qualified(type($operand)) `,` type($result)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`kind`	::mlir::asctile::ReduceKindAttr	kind of reduce {{% markdown %}}Kind of reduce operation{{% /markdown %}}

Operands:

Operand	Description
`operand`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`result`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values of length 1

`asctile.relu` (asctile::ReluOp)

Compute element-wise ReLU value of tensor

Syntax:

operation ::= `asctile.relu` $operand attr-dict `:` qualified(type($result))

Traits: AlwaysSpeculatableImplTrait, Elementwise

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.reshape` (asctile::ReshapeOp)

Create tensor with same data but different shape

Syntax:

operation ::= `asctile.reshape` $in attr-dict `:` qualified(type($in)) `to` qualified(type($out))

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: CastOpInterface, ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`in`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`out`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.rms_norm` (asctile::RmsNormOp)

Compute RmsNorm function over a tensor

Syntax:

operation ::= `asctile.rms_norm` $input `,` $gamma `,` $epsilon attr-dict `:` qualified(type($input)) `,` qualified(type($gamma))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`input`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values
`gamma`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values
`epsilon`	16-bit float or bfloat16 type or 32-bit float or 64-bit float

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float values

`asctile.scatter` (asctile::ScatterOp)

Store elements by index to a global tensor

Syntax:

operation ::= `asctile.scatter` $dst `[` $offsets `]` `,` $index `,` $src ( `,` $numIndices^ )? `,` $dim attr-dict `:` type($dst) `,` type($index)
              `,` type($src)

Traits: AttrSizedOperandSegments

Interfaces: MemoryEffectsOpInterface

Attributes:

Attribute	MLIR Type	Description
`dim`	::mlir::IntegerAttr	32-bit signless integer attribute
`checkBounds`	::mlir::UnitAttr	unit attribute

Operands:

Operand	Description
`src`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`index`	local tensor of 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values of ranks 1
`dst`	global tensor
`offsets`	variadic of 32-bit signless integer
`numIndices`	32-bit signless integer

`asctile.set_value` (asctile::SetValueOp)

Store value into a global tensor

Syntax:

operation ::= `asctile.set_value` $value `,` $base `[` $offsets `]` attr-dict `:` type($value) `,` qualified(type($base))

Interfaces: MemoryEffectsOpInterface

Operands:

Operand	Description
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values of length 1
`base`	global tensor
`offsets`	variadic of 32-bit signless integer

`asctile.shls` (asctile::ShLSOp)

Compute element-wise bitwise left shift of tensor and scalar

Syntax:

operation ::= `asctile.shls` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.shrs` (asctile::ShRSOp)

Compute element-wise bitwise right shift of tensor and scalar

Syntax:

operation ::= `asctile.shrs` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.softmax` (asctile::SoftmaxOp)

Compute row-wise softmax of 1D or 2D tensor

Syntax:

operation ::= `asctile.softmax` $operand attr-dict `:` qualified(type($result))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values of ranks 1/2

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values of ranks 1/2

`asctile.store` (asctile::StoreOp)

Store a local tensor into a global tensor

Syntax:

operation ::= `asctile.store` $value `,` $base `[` $offsets `]` (`,` `(` $realShape^ `)`)? attr-dict `:` qualified(type($value)) `,`
              qualified(type($base))

Traits: AttrSizedOperandSegments

Interfaces: MemoryEffectsOpInterface

Operands:

Operand	Description
`value`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`base`	global tensor
`offsets`	variadic of 32-bit signless integer
`realShape`	variadic of 32-bit signless integer

`asctile.store_fixpipe` (asctile::StoreFixpipeOp)

Store a local tensor into a global tensor via FixPipe

Syntax:

operation ::= `asctile.store_fixpipe` $value `,` $base `[` $offsets `]` (`,` `(` $realShape^ `)`)? attr-dict `:` qualified(type($value)) `,`
              qualified(type($base))

Traits: AttrSizedOperandSegments

Interfaces: MemoryEffectsOpInterface

Attributes:

Attribute	MLIR Type	Description
`relu`	::mlir::UnitAttr	unit attribute
`quantize`	::mlir::UnitAttr	unit attribute

Operands:

Operand	Description
`value`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`base`	global tensor
`offsets`	variadic of 32-bit signless integer
`realShape`	variadic of 32-bit signless integer

`asctile.subs` (asctile::SubSOp)

Compute element-wise subtraction of tensor and scalar

Syntax:

operation ::= `asctile.subs` $base `,` $value attr-dict `:` qualified(type($base))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values
`value`	16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.tensor` (asctile::TensorOp)

Create tensor

Syntax:

operation ::= `asctile.tensor` $base `(` $sizes `)` attr-dict `:` qualified(type($base)) `,` qualified(type($result))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`base`	ranked or unranked memref of any type values
`sizes`	variadic of 32-bit signless integer

Results:

Result	Description
`result`	global tensor

`asctile.transpose` (asctile::TransposeOp)

Transpose a tensor

Syntax:

operation ::= `asctile.transpose` $operand `,` $dims attr-dict `:` qualified(type($operand)) `to` qualified(type($result))

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Attribute	MLIR Type	Description
`dims`	::mlir::ArrayAttr	32-bit integer array attribute

Operands:

Operand	Description
`operand`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

Results:

Result	Description
`result`	local tensor of 16-bit float or bfloat16 type or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values

`asctile.vector_group` (asctile::VectorGroupOp)

Group operations targeting the AI Vector compute unit (UB)

Syntax:

operation ::= `asctile.vector_group` (`(` $operands^ `:` type($operands) `)`)? $region (`:` type($results)^)? attr-dict

Traits: SingleBlockImplicitTerminator<YieldOp>, SingleBlock

Operands:

Operand	Description
`operands`	variadic of any type

Results:

Result	Description
`results`	variadic of any type

`asctile.yield` (asctile::YieldOp)

Terminator for operations with region

Syntax:

operation ::= `asctile.yield` ($operands^ `:` type($operands))? attr-dict

Traits: Terminator

Operands:

Operand	Description
`operands`	variadic of any type

Attributes

GlobalTensorAttr

An encoding for a global tensor

Syntax: #asctile.global

LocalTensorAttr

An encoding for a local tensor

Syntax:

#asctile.local<
  TensorLocation   # loc
>

Parameters:

Parameter	C++ type	Description
loc	`TensorLocation`

ReduceKindAttr

kind of reduce

Syntax:

#asctile.kind<
  ::mlir::asctile::ReduceKind   # value
>

Kind of reduce operation

Parameters:

Parameter	C++ type	Description
value	`::mlir::asctile::ReduceKind`	an enum of type ReduceKind

RoundModeAttr

cast rounding mode

Syntax:

#asctile.round_mode<
  ::mlir::asctile::RoundMode   # value
>

Cast rounding mode

Parameters:

Parameter	C++ type	Description
value	`::mlir::asctile::RoundMode`	an enum of type RoundMode

SplitModeAttr

split mode

Syntax:

#asctile.split_mode<
  ::mlir::asctile::SplitMode   # value
>

Split strategy when copying from L0C to UB

Parameters:

Parameter	C++ type	Description
value	`::mlir::asctile::SplitMode`	an enum of type SplitMode

Enums

AtomicKind

kind of atomic

Cases:

Symbol	Value	String
Add	`0`	Add
Max	`1`	Max
Min	`2`	Min

CompareMode

comparsion type

Cases:

Symbol	Value	String
LT	`0`	LT
GT	`1`	GT
EQ	`2`	EQ
LE	`3`	LE
GE	`4`	GE
NE	`5`	NE

ReduceKind

kind of reduce

Cases:

Symbol	Value	String
Sum	`0`	sum
Max	`1`	max
Min	`2`	min
Prod	`3`	prod
Mean	`4`	mean
All	`5`	all
Any	`6`	any
XorSum	`7`	xor_sum

RoundMode

cast rounding mode

Cases:

Symbol	Value	String
NoRound	`0`	noround
Rint	`1`	rint
Floor	`2`	floor
Ceil	`3`	ceil
Round	`4`	round
Trunc	`5`	trunc
Odd	`6`	odd
Default	`100`	default

SplitMode

split mode

Cases:

Symbol	Value	String
FullVec0	`0`	full_vec0
FullVec1	`1`	full_vec1
SplitByM	`2`	split_by_m
SplitByN	`3`	split_by_n

TensorLocation

tensor location

Cases:

Symbol	Value	String
Auto	`0`	auto
L0A	`23`	L0A
L0B	`24`	L0B
L0C	`25`	L0C
UB	`26`	UB
L1	`27`	L1
FIX	`28`	FIX
BT	`29`	BT

‘asctile’ Dialect

Operations

asctile.accumulator (asctile::AccumulatorOp)

Operands:

Results:

asctile.adds (asctile::AddSOp)

Operands:

Results:

asctile.assert (asctile::AssertOp)

Attributes:

Operands:

asctile.atomic_rmw (asctile::AtomicRMWOp)

Attributes:

Operands:

asctile.bitwise_mask (asctile::BitwiseMaskOp)

Operands:

asctile.bitwise_not (asctile::BitwiseNotOp)

Operands:

Results:

asctile.broadcast (asctile::BroadcastOp)

Operands:

Results:

asctile.cast (asctile::CastOp)

Attributes:

Operands:

Results:

asctile.cmps (asctile::CmpSOp)

Attributes:

Operands:

Results:

asctile.copy (asctile::CopyOp)

Attributes:

Operands:

Results:

asctile.copy_fixpipe (asctile::CopyFixpipeOp)

Attributes:

Operands:

Results:

asctile.count_mask (asctile::CountMaskOp)

Operands:

asctile.cube_group (asctile::CubeGroupOp)

Operands:

Results:

asctile.cv_strategy (asctile::CVStrategyOp)

Attributes:

Results:

asctile.dim (asctile::DimOp)

Attributes:

Operands:

Results:

asctile.divs (asctile::DivSOp)

Operands:

Results:

asctile.dump_tensor (asctile::DumpTensorOp)

Operands:

asctile.gather (asctile::GatherOp)

Attributes:

Operands:

Results:

asctile.get_value (asctile::GetValueOp)

Operands:

Results:

asctile.inline_vf (asctile::InlineVFOp)

Attributes:

Operands:

Results:

asctile.layer_norm (asctile::LayerNormOp)

Attributes:

Operands:

Results:

asctile.leaky_relu (asctile::LeakyReluOp)

Operands:

Results:

asctile.load (asctile::LoadOp)

Operands:

Results:

asctile.matmul (asctile::MatmulOp)

Attributes:

Operands:

Results:

`asctile.accumulator` (asctile::AccumulatorOp)

`asctile.adds` (asctile::AddSOp)

`asctile.assert` (asctile::AssertOp)

`asctile.atomic_rmw` (asctile::AtomicRMWOp)

`asctile.bitwise_mask` (asctile::BitwiseMaskOp)

`asctile.bitwise_not` (asctile::BitwiseNotOp)

`asctile.broadcast` (asctile::BroadcastOp)

`asctile.cast` (asctile::CastOp)

`asctile.cmps` (asctile::CmpSOp)

`asctile.copy` (asctile::CopyOp)

`asctile.copy_fixpipe` (asctile::CopyFixpipeOp)

`asctile.count_mask` (asctile::CountMaskOp)

`asctile.cube_group` (asctile::CubeGroupOp)

`asctile.cv_strategy` (asctile::CVStrategyOp)

`asctile.dim` (asctile::DimOp)

`asctile.divs` (asctile::DivSOp)

`asctile.dump_tensor` (asctile::DumpTensorOp)

`asctile.gather` (asctile::GatherOp)

`asctile.get_value` (asctile::GetValueOp)

`asctile.inline_vf` (asctile::InlineVFOp)

`asctile.layer_norm` (asctile::LayerNormOp)

`asctile.leaky_relu` (asctile::LeakyReluOp)

`asctile.load` (asctile::LoadOp)

`asctile.matmul` (asctile::MatmulOp)

`asctile.matmul_acc` (asctile::MatmulAccOp)

`asctile.maxs` (asctile::MaxSOp)

`asctile.mins` (asctile::MinSOp)

`asctile.muls` (asctile::MulSOp)

`asctile.power` (asctile::PowerOp)

`asctile.reduce` (asctile::ReduceOp)

`asctile.reduce_as_1d` (asctile::ReduceAs1dOp)

`asctile.relu` (asctile::ReluOp)

`asctile.reshape` (asctile::ReshapeOp)

`asctile.rms_norm` (asctile::RmsNormOp)

`asctile.scatter` (asctile::ScatterOp)

`asctile.set_value` (asctile::SetValueOp)

`asctile.shls` (asctile::ShLSOp)

`asctile.shrs` (asctile::ShRSOp)

`asctile.softmax` (asctile::SoftmaxOp)

`asctile.store` (asctile::StoreOp)

`asctile.store_fixpipe` (asctile::StoreFixpipeOp)

`asctile.subs` (asctile::SubSOp)

`asctile.tensor` (asctile::TensorOp)

`asctile.transpose` (asctile::TransposeOp)

`asctile.vector_group` (asctile::VectorGroupOp)

`asctile.yield` (asctile::YieldOp)