‘asctile’ Dialect

Tile-level operations

Operations
Types
- TensorType
- TileType
Enums

Operations

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

Compute element-wise addition of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Atomic accumulation the tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`base`
`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 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

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

Broadcast tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Cast tile elements to other data type

Syntax:

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

Traits: AlwaysSpeculatableImplTrait, SameOperandsAndResultShape

Interfaces: CastOpInterface, ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`in`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`out`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

`asctile.cmp` (asctile::CmpOp)

Compute element-wise comparison of two tiles

Syntax:

operation ::= `asctile.cmp` $cmpMode $lhs `,` $rhs attr-dict `:` qualified(type($lhs))

Traits: AlwaysSpeculatableImplTrait, SameTypeOperands

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
`lhs`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`rhs`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	tile of 1-bit signless integer values

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

Compute element-wise comparison of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 1-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 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

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

Results:

Result	Description
`result`	32-bit signless integer

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

Compute element-wise division of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Load value from tensor

Syntax:

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

Interfaces: MemoryEffectsOpInterface

Operands:

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

Results:

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

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

Load from the tensor into a new tile

Syntax:

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

Traits: AttrSizedOperandSegments

Interfaces: MemoryEffectsOpInterface

Operands:

Operand	Description
`base`
`offsets`	variadic of 32-bit signless integer
`padValue`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Compute matrix multiplication on 2D tiles

Syntax:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`matrixA`	tile of 16-bit float or 32-bit float values of ranks 2
`matrixB`	tile of 16-bit float or 32-bit float values of ranks 2

Results:

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

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

Compute element-wise maximum value of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Compute element-wise minimum value of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Compute element-wise multiplication of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

`asctile.reduce_max` (asctile::ReduceMaxOp)

Reduce tile to the provided shape

Syntax:

operation ::= `asctile.reduce_max` $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

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

`asctile.reduce_max_as_1d` (asctile::ReduceMaxAs1dOp)

Reduce tile to 1-element tile or a scalar value

Syntax:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values of length 1

`asctile.reduce_min` (asctile::ReduceMinOp)

Reduce tile to the provided shape

Syntax:

operation ::= `asctile.reduce_min` $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

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

`asctile.reduce_min_as_1d` (asctile::ReduceMinAs1dOp)

Reduce tile to 1-element tile or a scalar value

Syntax:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values of length 1

`asctile.reduce_prod` (asctile::ReduceProdOp)

Reduce tile to the provided shape

Syntax:

operation ::= `asctile.reduce_prod` $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

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

`asctile.reduce_sum` (asctile::ReduceSumOp)

Reduce tile to the provided shape

Syntax:

operation ::= `asctile.reduce_sum` $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

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

`asctile.reduce_sum_as_1d` (asctile::ReduceSumAs1dOp)

Reduce tile to 1-element tile or a scalar value

Syntax:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values of length 1

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

Compute element-wise ReLU value of tile

Syntax:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Create tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`out`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

`asctile.select` (asctile::SelectOp)

Select elements from two tiles depending on a mask

Syntax:

operation ::= `asctile.select` $selMask `,` $src0 `,` $src1 attr-dict `:` qualified(type($result))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`selMask`	tile of 1-bit signless integer values
`src0`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`src1`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Store value into a tensor

Syntax:

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

Interfaces: MemoryEffectsOpInterface

Operands:

Operand	Description
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer
`base`
`offsets`	variadic of 32-bit signless integer

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

Compute element-wise bitwise left shift of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Compute element-wise bitwise right shift of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

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

Syntax:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`operand`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values of ranks 1/2

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values of ranks 1/2

`asctile.splat` (asctile::SplatOp)

Create a tile filled with splat value

Syntax:

operation ::= `asctile.splat` $value attr-dict `:` qualified(type($result))

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

Operand	Description
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values

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

Store a tile into a tensor

Syntax:

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

Interfaces: MemoryEffectsOpInterface

Operands:

Operand	Description
`value`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`base`
`offsets`	variadic of 32-bit signless integer

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

Compute element-wise subtraction of tile 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`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer values
`value`	16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer

Results:

Result	Description
`result`	tile of 16-bit float or 32-bit float or 8-bit signless integer or 16-bit signless integer or 32-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`

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

Terminator for operations with region

Syntax:

operation ::= `asctile.yield` attr-dict

Traits: Terminator

Types

TensorType

Syntax:

!asctile.tensor<
  ::llvm::ArrayRef<int64_t>,   # shape
  Type   # elementType
>

Parameters:

Parameter	C++ type	Description
shape	`::llvm::ArrayRef<int64_t>`
elementType	`Type`

TileType

Syntax:

!asctile.tile<
  ::llvm::ArrayRef<int64_t>,   # shape
  Type,   # elementType
  TileLocationAttr   # locAttr
>

Parameters:

Parameter	C++ type	Description
shape	`::llvm::ArrayRef<int64_t>`
elementType	`Type`
locAttr	`TileLocationAttr`

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

TileLocation

tile location

Cases:

Symbol	Value	String
L0A	`23`	L0A
L0B	`24`	L0B
L0C	`25`	L0C
UB	`26`	UB
L1	`27`	L1
FIX	`28`	FIX

‘asctile’ Dialect

Operations

asctile.adds (asctile::AddSOp)

Operands:

Results:

asctile.atomic_rmw (asctile::AtomicRMWOp)

Attributes:

Operands:

asctile.bitwise_mask (asctile::BitwiseMaskOp)

Operands:

asctile.broadcast (asctile::BroadcastOp)

Operands:

Results:

asctile.cast (asctile::CastOp)

Operands:

Results:

asctile.cmp (asctile::CmpOp)

Attributes:

Operands:

Results:

asctile.cmps (asctile::CmpSOp)

Attributes:

Operands:

Results:

asctile.count_mask (asctile::CountMaskOp)

Operands:

asctile.dim (asctile::DimOp)

Attributes:

Operands:

Results:

asctile.divs (asctile::DivSOp)

Operands:

Results:

asctile.get_value (asctile::GetValueOp)

Operands:

Results:

asctile.load (asctile::LoadOp)

Operands:

Results:

asctile.matmul (asctile::MatmulOp)

Operands:

Results:

asctile.maxs (asctile::MaxSOp)

Operands:

Results:

asctile.mins (asctile::MinSOp)

Operands:

Results:

asctile.muls (asctile::MulSOp)

Operands:

Results:

asctile.reduce_max (asctile::ReduceMaxOp)

Attributes:

Operands:

Results:

asctile.reduce_max_as_1d (asctile::ReduceMaxAs1dOp)

Operands:

Results:

asctile.reduce_min (asctile::ReduceMinOp)

Attributes:

Operands:

Results:

asctile.reduce_min_as_1d (asctile::ReduceMinAs1dOp)

Operands:

Results:

asctile.reduce_prod (asctile::ReduceProdOp)

Attributes:

Operands:

Results:

asctile.reduce_sum (asctile::ReduceSumOp)

Attributes:

Operands:

Results:

asctile.reduce_sum_as_1d (asctile::ReduceSumAs1dOp)

Operands:

Results:

asctile.relu (asctile::ReluOp)

Operands:

Results:

asctile.reshape (asctile::ReshapeOp)

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

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

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

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

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

`asctile.cmp` (asctile::CmpOp)

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

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

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

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

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

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

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

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

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

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

`asctile.reduce_max` (asctile::ReduceMaxOp)

`asctile.reduce_max_as_1d` (asctile::ReduceMaxAs1dOp)

`asctile.reduce_min` (asctile::ReduceMinOp)

`asctile.reduce_min_as_1d` (asctile::ReduceMinAs1dOp)

`asctile.reduce_prod` (asctile::ReduceProdOp)

`asctile.reduce_sum` (asctile::ReduceSumOp)

`asctile.reduce_sum_as_1d` (asctile::ReduceSumAs1dOp)

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

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

`asctile.select` (asctile::SelectOp)

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

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

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

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

`asctile.splat` (asctile::SplatOp)

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

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

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

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