'rocdl' Dialect

Dialect for wrapping LLVM AMDGPU backend intrinsics and attributes

The ROCDL dialect, like the other platform-specific LLVM dialects, serves as the location of wrappers around the AMD-specific intrinsics and attributes in LLVM.

This dialect, like other GPU lowering targets, also contains the infrastructure used by the built-in compilation/offloading framework to compile AMD-specific LLVM IR into binaries.

Dialect inclusion criteria and guidelines

The operations in this dialect are 1:1 wrappers around their corresponding LLVM intrinsics. Operations that do not correspond to intrinsics should not be placed in this dialect.

The definition of a ROCDL op should match its LLVM counterpart. If the argument and result types are fixed, they should be specified as type constraints, including by overriding the default variadic type on LLVM intrinsics by doing a let results in the operation definition.

LLVM attributes do not need to be replicated exactly if it wouldn’t be easy to do so, but pure operations and ones that read/write memory should be annotated as such.

While LLVM intrinsics currently don’t allow constraining the values an any_type can take, it is acceptable (but not required) to impose such constraints if they are known.

When an LLVM intrinsic uses an immarg, this corresponds to an attribute in MLIR.

Human-readable assembly formats (those that, for example, explicitly indicate parameter names) may be used, and are encouraged for intrinsics that have complex argument schemes and don’t have any higher-level wrapper (such as in the amdgpu dialect).

While not all existing operations follow this convention, new operations should generally provide argument and result types except in cases where they are clearly redundant (such as with operations like rocdl.fmed3, which doesn’t need to reiterate the single type at issue multiple times). This convention enhances the readability of low-level IR and prevents programmers from needing to find non-local type information.

Dialect-defined discardable attributes (any attribute starting with rocdl. that has special handling) need to correspond to AMD-specific attributes, metadata, or other entities (such as calling conventions) in LLVM, or be needed for GPU compilation management. Outside of the compilation infrastructure, dialect-specific enums or attributes are extmelely unlikely to be needed and should be avoided.

Operation documentation should specify when the operation was introduced (if relevant) and include usage examples. Operations should have parser/printer tests in mlir/test/Dialect/LLVMIR/rocdl.mlir and lowering tests in mlir/test/Target/LLVMIR/rocdl.mlir.

General documentation (What does this op do?)

While rocdl ops sometimes carry their own documentation, there is no expectation that such documentation will exist (or be kept up to date).

Since ROCDL operations correspond to LLVM intrinsics, the semantics and behavior of these operations can be determined by investigating the documentation for the corresponding intrinsic. This documentation can be found in

• llvm/docs/AMDGPUUsage.rst and
• The comments of llvm/include/llvm/IR/IntrinsicsAMDGPU.td, which is where details of the meaning of certain bitfields or of how an intrinsic corresponds to hardware instructions are most likely to be found.

Since many intrinsics are themselves minimal wrappers around hardware instructions, these documentation sources often do not repeat hardware documentation. If an intrinsic appears undocumented, information about its behavior will often be available in published ISA descriptions or (sometimes known as shader programming guides).

If an operation doesn’t provide usage examples, it is likely that they can be found in mlir/test/Dialect/LLVMIR/rocdl.mlir (op syntax and verification) or mlir/test/Target/LLVMIR/rocdl.mlir (translation to LLVM IR).

Operations ¶

source

rocdl.asyncmark (ROCDL::AsyncmarkOp) ¶

Mark the end of a group of asynchronous operations

Syntax:

operation ::= `rocdl.asyncmark` attr-dict

This operation, in conjunction with rocdl.wait.asyncmark, forms the compiler-provided framework for tracking explicitly asynchronous memory operations, such as copies to LDS that use async intrinsics and gfx1250’s tensor loads.

Details of its behavior can be found in the LLVM documentation on async tracking.

See rocdl.wait.asyncmark’s documentation for a usage example.

Example:

// Mark the end of an async operation group.
rocdl.asyncmark

Available on gfx9 and later.

rocdl.ballot (ROCDL::BallotOp) ¶

Vote across thread group

Syntax:

operation ::= `rocdl.ballot` $pred attr-dict `:` type($res)

Ballot provides a bit mask containing the 1-bit predicate value from each lane. The nth bit of the result contains the 1 bit contributed by the nth warp lane.

Example:

// Ballot across thread group.
%0 = rocdl.ballot %pred : i64

Operands: ¶

Results: ¶

rocdl.barrier (ROCDL::BarrierOp) ¶

Syntax:

operation ::= `rocdl.barrier` attr-dict

An operation with the same expansion as HIP’s __synchthreads();

DEPRECATION NOTICE: Use gpu.barrier, which will expand to these operations, instead.

Example:

// Workgroup barrier with acquire/release fences.
rocdl.barrier

rocdl.cluster.id.x (ROCDL::ClusterIdXOp) ¶

Syntax:

operation ::= `rocdl.cluster.id.x` (`range` $range^)? attr-dict `:` type($res)

Read a hardware register for thread/workgroup/cluster identification. An optional range attribute can constrain the returned value.

Example:

// Read the workitem id in the x dimension.
%0 = rocdl.workitem.id.x : i32

// Read with a known range constraint.
%1 = rocdl.workitem.id.x range <i32, 0, 64> : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

A pair of two integers, mapping to the ConstantRange structure in LLVM IR,
which is allowed to wrap or be empty.
The range represented is [Lower, Upper), and is either signed or unsigned
depending on context.
lower and upper must have the same width.
Syntax:
`<` `i`(width($lower)) $lower `,` $upper `>`

Results: ¶

rocdl.cluster.id.y (ROCDL::ClusterIdYOp) ¶

Syntax:

operation ::= `rocdl.cluster.id.y` (`range` $range^)? attr-dict `:` type($res)

Read a hardware register for thread/workgroup/cluster identification. An optional range attribute can constrain the returned value.

Example:

// Read the workitem id in the x dimension.
%0 = rocdl.workitem.id.x : i32

// Read with a known range constraint.
%1 = rocdl.workitem.id.x range <i32, 0, 64> : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

A pair of two integers, mapping to the ConstantRange structure in LLVM IR,
which is allowed to wrap or be empty.
The range represented is [Lower, Upper), and is either signed or unsigned
depending on context.
lower and upper must have the same width.
Syntax:
`<` `i`(width($lower)) $lower `,` $upper `>`

Results: ¶

rocdl.cluster.id.z (ROCDL::ClusterIdZOp) ¶

Syntax:

operation ::= `rocdl.cluster.id.z` (`range` $range^)? attr-dict `:` type($res)

Read a hardware register for thread/workgroup/cluster identification. An optional range attribute can constrain the returned value.

Example:

// Read the workitem id in the x dimension.
%0 = rocdl.workitem.id.x : i32

// Read with a known range constraint.
%1 = rocdl.workitem.id.x range <i32, 0, 64> : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

A pair of two integers, mapping to the ConstantRange structure in LLVM IR,
which is allowed to wrap or be empty.
The range represented is [Lower, Upper), and is either signed or unsigned
depending on context.
lower and upper must have the same width.
Syntax:
`<` `i`(width($lower)) $lower `,` $upper `>`

Results: ¶

rocdl.cluster.load.async.to.lds.b128 (ROCDL::ClusterLoadAsyncToLDSB128Op) ¶

Syntax:

operation ::= `rocdl.cluster.load.async.to.lds.b128` $globalPtr `,`  $ldsPtr `,` $offset `,` $cpol `,` $mask
              attr-dict `:` qualified(type($globalPtr)) `,` qualified(type($ldsPtr))

Broadcasts memory load of 128 bits of data for a cluster of workgroups.

Available on gfx1250+.

Example:

// Cluster broadcast 128-bit load to LDS.
rocdl.cluster.load.async.to.lds.b128 %src, %dst, 0, 0, %mask : !llvm.ptr<1>, !llvm.ptr<3>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

rocdl.cluster.load.async.to.lds.b32 (ROCDL::ClusterLoadAsyncToLDSB32Op) ¶

Syntax:

operation ::= `rocdl.cluster.load.async.to.lds.b32` $globalPtr `,`  $ldsPtr `,` $offset `,` $cpol `,` $mask
              attr-dict `:` qualified(type($globalPtr)) `,` qualified(type($ldsPtr))

Broadcasts memory load of 32 bits of data for a cluster of workgroups.

Available on gfx1250+.

Example:

// Cluster broadcast 32-bit load to LDS.
rocdl.cluster.load.async.to.lds.b32 %src, %dst, 0, 0, %mask : !llvm.ptr<1>, !llvm.ptr<3>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

rocdl.cluster.load.async.to.lds.b64 (ROCDL::ClusterLoadAsyncToLDSB64Op) ¶

Syntax:

operation ::= `rocdl.cluster.load.async.to.lds.b64` $globalPtr `,`  $ldsPtr `,` $offset `,` $cpol `,` $mask
              attr-dict `:` qualified(type($globalPtr)) `,` qualified(type($ldsPtr))

Broadcasts memory load of 64 bits of data for a cluster of workgroups.

Available on gfx1250+.

Example:

// Cluster broadcast 64-bit load to LDS.
rocdl.cluster.load.async.to.lds.b64 %src, %dst, 0, 0, %mask : !llvm.ptr<1>, !llvm.ptr<3>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

rocdl.cluster.load.async.to.lds.b8 (ROCDL::ClusterLoadAsyncToLDSB8Op) ¶

Syntax:

operation ::= `rocdl.cluster.load.async.to.lds.b8` $globalPtr `,`  $ldsPtr `,` $offset `,` $cpol `,` $mask
              attr-dict `:` qualified(type($globalPtr)) `,` qualified(type($ldsPtr))

Broadcasts memory load of 8 bits of data for a cluster of workgroups.

Available on gfx1250+.

Example:

// Cluster broadcast 8-bit load to LDS.
rocdl.cluster.load.async.to.lds.b8 %src, %dst, 0, 0, %mask : !llvm.ptr<1>, !llvm.ptr<3>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

rocdl.cluster.workgroup.id.x (ROCDL::ClusterWorkgroupIdXOp) ¶

Syntax:

operation ::= `rocdl.cluster.workgroup.id.x` (`range` $range^)? attr-dict `:` type($res)

Read a hardware register for thread/workgroup/cluster identification. An optional range attribute can constrain the returned value.

Example:

// Read the workitem id in the x dimension.
%0 = rocdl.workitem.id.x : i32

// Read with a known range constraint.
%1 = rocdl.workitem.id.x range <i32, 0, 64> : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

A pair of two integers, mapping to the ConstantRange structure in LLVM IR,
which is allowed to wrap or be empty.
The range represented is [Lower, Upper), and is either signed or unsigned
depending on context.
lower and upper must have the same width.
Syntax:
`<` `i`(width($lower)) $lower `,` $upper `>`

Results: ¶

rocdl.cluster.workgroup.id.y (ROCDL::ClusterWorkgroupIdYOp) ¶

Syntax:

operation ::= `rocdl.cluster.workgroup.id.y` (`range` $range^)? attr-dict `:` type($res)

Read a hardware register for thread/workgroup/cluster identification. An optional range attribute can constrain the returned value.

Example:

// Read the workitem id in the x dimension.
%0 = rocdl.workitem.id.x : i32

// Read with a known range constraint.
%1 = rocdl.workitem.id.x range <i32, 0, 64> : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

A pair of two integers, mapping to the ConstantRange structure in LLVM IR,
which is allowed to wrap or be empty.
The range represented is [Lower, Upper), and is either signed or unsigned
depending on context.
lower and upper must have the same width.
Syntax:
`<` `i`(width($lower)) $lower `,` $upper `>`

Results: ¶

rocdl.cluster.workgroup.id.z (ROCDL::ClusterWorkgroupIdZOp) ¶

Syntax:

operation ::= `rocdl.cluster.workgroup.id.z` (`range` $range^)? attr-dict `:` type($res)

Read a hardware register for thread/workgroup/cluster identification. An optional range attribute can constrain the returned value.

Example:

// Read the workitem id in the x dimension.
%0 = rocdl.workitem.id.x : i32

// Read with a known range constraint.
%1 = rocdl.workitem.id.x range <i32, 0, 64> : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

A pair of two integers, mapping to the ConstantRange structure in LLVM IR,
which is allowed to wrap or be empty.
The range represented is [Lower, Upper), and is either signed or unsigned
depending on context.
lower and upper must have the same width.
Syntax:
`<` `i`(width($lower)) $lower `,` $upper `>`

Results: ¶

rocdl.cos (ROCDL::ROCDLCos) ¶

Syntax:

operation ::= `rocdl.cos` $arg qualified(type($arg)) attr-dict `->` qualified(type($res))

Note: In the general case, prefer the conventional arith, math, or llvm ops over this. Use this ROCDL-specific operation only when you fully understand its implication and when it is strictly necessary. This op is usually chosen when a small loss in precision is acceptable in exchange for higher execution speed.

Example:

%0 = rocdl.cos %a f32 -> f32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.f32.bf8 (ROCDL::CvtF32Bf8Op) ¶

Convert bf8 to f32

Syntax:

operation ::= `rocdl.cvt.f32.bf8` attr-dict $srcA `[` $byteSel `]` `:` type($res)

Convert 8-bit bf8 value from the byteSelth bit of srcA to fp32.

Example:

// Convert bf8 byte 0 to f32.
%0 = rocdl.cvt.f32.bf8 %src[0] : f32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.f32.fp8 (ROCDL::CvtF32Fp8Op) ¶

Convert fp8 to f32

Syntax:

operation ::= `rocdl.cvt.f32.fp8` attr-dict $srcA `[` $byteSel `]` `:` type($res)

Convert 8-bit fp8 value from the byteSelth bit of srcA to fp32.

Example:

// Convert fp8 byte 0 to f32.
%0 = rocdl.cvt.f32.fp8 %src[0] : f32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.pk.bf8.f32 (ROCDL::CvtPkBf8F32Op) ¶

Convert two f32’s to bf8

Syntax:

operation ::= `rocdl.cvt.pk.bf8.f32` attr-dict $srcA `,` $srcB `->` $old `[` $wordSel `]` `:` type($res)

Convert srcA and srcB to bf8 and store into the low/high word of old, preserving the other word.

Example:

// Pack two f32 values into bf8 in the low word of old.
%0 = rocdl.cvt.pk.bf8.f32 %a, %b -> %old[false] : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.pk.f32.bf8 (ROCDL::CvtPkF32Bf8Op) ¶

Convert packed bf8 to packed f32

Syntax:

operation ::= `rocdl.cvt.pk.f32.bf8` attr-dict $src `[` $wordSel `]` `:` type($res)

Convert src based on $wordSel to packed fp32.

Example:

// Unpack bf8 word to packed f32.
%0 = rocdl.cvt.pk.f32.bf8 %src[false] : vector<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.pk.f32.fp8 (ROCDL::CvtPkF32Fp8Op) ¶

Convert packed fp8 to packed f32

Syntax:

operation ::= `rocdl.cvt.pk.f32.fp8` attr-dict $src `[` $wordSel `]` `:` type($res)

Convert src based on $wordSel to packed fp32.

Example:

// Unpack fp8 word to packed f32.
%0 = rocdl.cvt.pk.f32.fp8 %src[false] : vector<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.pk.fp8.f32 (ROCDL::CvtPkFp8F32Op) ¶

Convert two f32’s to fp8

Syntax:

operation ::= `rocdl.cvt.pk.fp8.f32` attr-dict $srcA `,` $srcB `->` $old `[` $wordSel `]` `:` type($res)

Convert srcA and srcB to fp8 and store into the low/high word of old, preserving the other word.

Example:

// Pack two f32 values into fp8 in the low word of old.
%0 = rocdl.cvt.pk.fp8.f32 %a, %b -> %old[false] : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.pkrtz (ROCDL::CvtPkRtz) ¶

Convert two f32 input into a vector<2xf16>

Syntax:

operation ::= `rocdl.cvt.pkrtz` attr-dict $srcA `,` $srcB `:` type($res)

Convert two f32 values into a packed vector<2xf16>.

Example:

// Pack two f32 values into a vector<2xf16> with round-to-zero.
%0 = rocdl.cvt.pkrtz %a, %b : vector<2xf16>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk16.bf16.bf6 (ROCDL::CvtPkScalePk16Bf16Bf6Op) ¶

Scales 16 bf6 and converts them to 16 bf16.

Syntax:

operation ::= `rocdl.cvt.scale.pk16.bf16.bf6` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk16.bf16.fp6 (ROCDL::CvtPkScalePk16Bf16Fp6Op) ¶

Scales 16 fp6 and converts them to 16 bf16.

Syntax:

operation ::= `rocdl.cvt.scale.pk16.bf16.fp6` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk16.f16.bf6 (ROCDL::CvtPkScalePk16F16Bf6Op) ¶

Scales 16 bf6 and converts them to 16 f16.

Syntax:

operation ::= `rocdl.cvt.scale.pk16.f16.bf6` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk16.f16.fp6 (ROCDL::CvtPkScalePk16F16Fp6Op) ¶

Scales 16 fp6 and converts them to 16 f16.

Syntax:

operation ::= `rocdl.cvt.scale.pk16.f16.fp6` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk16.f32.bf6 (ROCDL::CvtPkScalePk16F32Bf6Op) ¶

Scales 16 bf6 and converts them to 16 f32.

Syntax:

operation ::= `rocdl.cvt.scale.pk16.f32.bf6` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk16.f32.fp6 (ROCDL::CvtPkScalePk16F32Fp6Op) ¶

Scales 16 fp6 and converts them to 16 f32.

Syntax:

operation ::= `rocdl.cvt.scale.pk16.f32.fp6` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.bf16.bf8 (ROCDL::CvtPkScalePk8Bf16Bf8Op) ¶

Scales 8 bf8 and converts them to 8 bf16.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.bf16.bf8` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.bf16.fp4 (ROCDL::CvtPkScalePk8Bf16Fp4Op) ¶

Scales 8 fp4 and converts them to 8 bf16.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.bf16.fp4` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.bf16.fp8 (ROCDL::CvtPkScalePk8Bf16Fp8Op) ¶

Scales 8 fp8 and converts them to 8 bf16.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.bf16.fp8` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.f16.bf8 (ROCDL::CvtPkScalePk8F16Bf8Op) ¶

Scales 8 bf8 and converts them to 8 f16.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.f16.bf8` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.f16.fp4 (ROCDL::CvtPkScalePk8F16Fp4Op) ¶

Scales 8 fp4 and converts them to 8 f16.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.f16.fp4` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.f16.fp8 (ROCDL::CvtPkScalePk8F16Fp8Op) ¶

Scales 8 fp8 and converts them to 8 f16.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.f16.fp8` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.f32.bf8 (ROCDL::CvtPkScalePk8F32Bf8Op) ¶

Scales 8 bf8 and converts them to 8 f32.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.f32.bf8` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.f32.fp4 (ROCDL::CvtPkScalePk8F32Fp4Op) ¶

Scales 8 fp4 and converts them to 8 f32.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.f32.fp4` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scale.pk8.f32.fp8 (ROCDL::CvtPkScalePk8F32Fp8Op) ¶

Scales 8 fp8 and converts them to 8 f32.

Syntax:

operation ::= `rocdl.cvt.scale.pk8.f32.fp8` attr-dict $src `,` $scale `[` $scaleSel `]` `:` type($res)

Available on gfx1250+.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.2xpk16.bf6.f32 (ROCDL::CvtScaleF322xPk16Bf6F32Op) ¶

Scale and convert two vector<16xf32> to 32 packed bf6

Syntax:

operation ::= `rocdl.cvt.scalef32.2xpk16.bf6.f32` attr-dict $src0 `,` $src1 `,` $scale `:` type($res)

Convert 32 single-precision float values, packed into two length-16 vectors that will be logically concanenated, to packed bf6, dividing by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.2xpk16.fp6.f32 (ROCDL::CvtScaleF322xPk16Fp6F32Op) ¶

Scale and convert two vector<16xf32> to 32 packed fp6

Syntax:

operation ::= `rocdl.cvt.scalef32.2xpk16.fp6.f32` attr-dict $src0 `,` $src1 `,` $scale `:` type($res)

Convert 32 single-precision float values, packed into two length-16 vectors that will be logically concanenated, to packed fp6, dividing by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.f16.bf8 (ROCDL::CvtScaleF32F16Bf8Op) ¶

Scaled convert bf8 from packed vector to f16, updating tied result

Syntax:

operation ::= `rocdl.cvt.scalef32.f16.bf8` attr-dict $src `[` $srcSelIndex `]` `,` $scale `->` $oldVdst `[` $dstLoHiSel `]` `:` type($res)

Convert a bf8 byte from src, selected by srcSelIndex, to f16 while multiplying it by the expontent of scale, and place it into the dstLoHiSelth bit of oldVdst preserving the other element of that vector in the return value.

The bytes are stored as an i32 and not a <4 x i8>.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.f16.fp8 (ROCDL::CvtScaleF32F16Fp8Op) ¶

Scaled convert fp8 from packed vector to f16, updating tied result

Syntax:

operation ::= `rocdl.cvt.scalef32.f16.fp8` attr-dict $src `[` $srcSelIndex `]` `,` $scale `->` $oldVdst `[` $dstLoHiSel `]` `:` type($res)

Convert a fp8 byte from src, selected by srcSelIndex, to f16 while multiplying it by the expontent of scale, and place it into the dstLoHiSelth bit of oldVdst preserving the other element of that vector in the return value.

The bytes are stored as an i32 and not a <4 x i8>.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.f32.bf8 (ROCDL::CvtScaleF32F32Bf8Op) ¶

Scaled convert bf8 from packed vector to f32

Syntax:

operation ::= `rocdl.cvt.scalef32.f32.bf8` attr-dict $src `[` $srcSelIndex `]` `,` $scale `:` type($res)

Convert a bf8 byte from src, selected by srcSelIndex, to f32, multiplying it by the exponent of scale.

The bytes are stored in an i32, not a <4 x i8>.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.f32.fp8 (ROCDL::CvtScaleF32F32Fp8Op) ¶

Scaled convert fp8 from packed vector to f32

Syntax:

operation ::= `rocdl.cvt.scalef32.f32.fp8` attr-dict $src `[` $srcSelIndex `]` `,` $scale `:` type($res)

Convert a fp8 byte from src, selected by srcSelIndex, to f32, multiplying it by the exponent of scale.

The bytes are stored in an i32, not a <4 x i8>.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.bf16.bf8 (ROCDL::CvtScaleF32PkBf16Bf8Op) ¶

Scaled convert two bf8to two bf16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.bf16.bf8` attr-dict $src `[` $srcLoHiSel `]` `,` $scale `:` type($res)

Convert two packed bf8 values in src0 to two bf16 values, multiplying by the exponent in scale. The two values to be converted are selected from the low or high half of src (a packed vector represented as an i32) on the basis of srcLoHiSel.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.bf16.fp4 (ROCDL::CvtScaleF32PkBf16Fp4Op) ¶

Scale and convert two packed fp4 to packed bf16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.bf16.fp4` attr-dict $src `[` $srcSelIndex `]` `,` $scale `:` type($res)

Convert two packed fp4 (f4E2M1) values stored as one byte of a 32-bit integer to packed bf16, multiplying by the exponent part of scale before doing so.

The byte to convert is chosen by srcSelIndex.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.bf16.fp8 (ROCDL::CvtScaleF32PkBf16Fp8Op) ¶

Scaled convert two fp8to two bf16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.bf16.fp8` attr-dict $src `[` $srcLoHiSel `]` `,` $scale `:` type($res)

Convert two packed fp8 values in src0 to two bf16 values, multiplying by the exponent in scale. The two values to be converted are selected from the low or high half of src (a packed vector represented as an i32) on the basis of srcLoHiSel.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.bf8.bf16 (ROCDL::CvtScaleF32PkBf8Bf16Op) ¶

Scaled convert two bf16to two bf8, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.bf8.bf16` attr-dict $src0 `,` $scale `->` $oldVdst `[` $dstLoHiSel `]` `:` type($res)

Convert two bf16 values in src0 to two bf8 bytes, dividing by the exponent in scale. The bytes are packed into a 16-bit value which is inserted into oldVdst at the dstLoHiSel position, with the entire updated vector being returned.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.bf8.f16 (ROCDL::CvtScaleF32PkBf8F16Op) ¶

Scaled convert two f16to two bf8, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.bf8.f16` attr-dict $src0 `,` $scale `->` $oldVdst `[` $dstLoHiSel `]` `:` type($res)

Convert two f16 values in src0 to two bf8 bytes, dividing by the exponent in scale. The bytes are packed into a 16-bit value which is inserted into oldVdst at the dstLoHiSel position, with the entire updated vector being returned.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.bf8.f32 (ROCDL::CvtScaleF32PkBf8F32Op) ¶

Scaled convert two f32 to two bf8, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.bf8.f32` attr-dict  $src0 `,` $src1 `,` $scale `->` $oldVdst `[` $dstLoHiSel `]` `:` type($res)

Convert two f32 values in src0 and src1 to two bf8 bytes, dividing by the exponent in scale. The bytes are packed into a 16-bit value which is inserted into oldVdst at the dstLoHiSel position, with the entire updated vector being returned.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.f16.bf8 (ROCDL::CvtScaleF32PkF16Bf8Op) ¶

Scaled convert two bf8to two f16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.f16.bf8` attr-dict $src `[` $srcLoHiSel `]` `,` $scale `:` type($res)

Convert two packed bf8 values in src0 to two f16 values, multiplying by the exponent in scale. The two values to be converted are selected from the low or high half of src (a packed vector represented as an i32) on the basis of srcLoHiSel.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.f16.fp4 (ROCDL::CvtScaleF32PkF16Fp4Op) ¶

Scale and convert two packed fp4 to packed f16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.f16.fp4` attr-dict $src `[` $srcSelIndex `]` `,` $scale `:` type($res)

Convert two packed fp4 (f4E2M1) values stored as one byte of a 32-bit integer to packed f16, multiplying by the exponent part of scale before doing so.

The byte to convert is chosen by srcSelIndex.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.f16.fp8 (ROCDL::CvtScaleF32PkF16Fp8Op) ¶

Scaled convert two fp8to two f16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.f16.fp8` attr-dict $src `[` $srcLoHiSel `]` `,` $scale `:` type($res)

Convert two packed fp8 values in src0 to two f16 values, multiplying by the exponent in scale. The two values to be converted are selected from the low or high half of src (a packed vector represented as an i32) on the basis of srcLoHiSel.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.f32.bf8 (ROCDL::CvtScaleF32PkF32Bf8Op) ¶

Scaled convert two bf8to two f32

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.f32.bf8` attr-dict $src `[` $srcLoHiSel `]` `,` $scale `:` type($res)

Convert two packed bf8 values in src0 to two f32 values, multiplying by the exponent in scale. The two values to be converted are selected from the low or high half of src (a packed vector represented as an i32) on the basis of srcLoHiSel.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.f32.fp4 (ROCDL::CvtScaleF32PkF32Fp4Op) ¶

Scale and convert two packed fp4 to packed f32

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.f32.fp4` attr-dict $src `[` $srcSelIndex `]` `,` $scale `:` type($res)

Convert two packed fp4 (f4E2M1) values stored as one byte of a 32-bit integer to packed f32, multiplying by the exponent part of scale before doing so.

The byte to convert is chosen by srcSelIndex.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.f32.fp8 (ROCDL::CvtScaleF32PkF32Fp8Op) ¶

Scaled convert two fp8to two f32

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.f32.fp8` attr-dict $src `[` $srcLoHiSel `]` `,` $scale `:` type($res)

Convert two packed fp8 values in src0 to two f32 values, multiplying by the exponent in scale. The two values to be converted are selected from the low or high half of src (a packed vector represented as an i32) on the basis of srcLoHiSel.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.fp4.bf16 (ROCDL::CvtScaleF32PkFp4Bf16Op) ¶

Scale and convert two bf16 to packed fp4, updating tied vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.fp4.bf16` attr-dict $src `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert two packed bf16 values to packed fp4, dividing by the exponent part of scale before doing so.

The two scaled values are packed into a byte. That byte is used to update the dstSelIndexth byte of oldVdst, which is returned in its entirity.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.fp4.f16 (ROCDL::CvtScaleF32PkFp4F16Op) ¶

Scale and convert two f16 to packed fp4, updating tied vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.fp4.f16` attr-dict $src `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert two packed f16 values to packed fp4, dividing by the exponent part of scale before doing so.

The two scaled values are packed into a byte. That byte is used to update the dstSelIndexth byte of oldVdst, which is returned in its entirity.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.fp4.f32 (ROCDL::CvtScaleF32PkFp4F32Op) ¶

Scale and convert two f32 values to two packed fp4, updating tied vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.fp4.f32` attr-dict $src0 `,` $src1 `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert two single-precision float values, passed in src0 and src1 into two fp4 values, dividing them by the expontent part of scale before doing so.

The two scaled values are packed into a byte. That byte is used to update the dstSelIndexth byte of oldVdst, which is returned in its entirity.

Example:

// Scaled convert two f32 values to packed fp4 in byte 0 of old.
%0 = rocdl.cvt.scalef32.pk.fp4.f32 %a, %b, %scale -> %old[0] : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.fp8.bf16 (ROCDL::CvtScaleF32PkFp8Bf16Op) ¶

Scaled convert two bf16to two fp8, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.fp8.bf16` attr-dict $src0 `,` $scale `->` $oldVdst `[` $dstLoHiSel `]` `:` type($res)

Convert two bf16 values in src0 to two fp8 bytes, dividing by the exponent in scale. The bytes are packed into a 16-bit value which is inserted into oldVdst at the dstLoHiSel position, with the entire updated vector being returned.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.fp8.f16 (ROCDL::CvtScaleF32PkFp8F16Op) ¶

Scaled convert two f16to two fp8, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.fp8.f16` attr-dict $src0 `,` $scale `->` $oldVdst `[` $dstLoHiSel `]` `:` type($res)

Convert two f16 values in src0 to two fp8 bytes, dividing by the exponent in scale. The bytes are packed into a 16-bit value which is inserted into oldVdst at the dstLoHiSel position, with the entire updated vector being returned.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk.fp8.f32 (ROCDL::CvtScaleF32PkFp8F32Op) ¶

Scaled convert two f32 to two fp8, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.pk.fp8.f32` attr-dict  $src0 `,` $src1 `,` $scale `->` $oldVdst `[` $dstLoHiSel `]` `:` type($res)

Convert two f32 values in src0 and src1 to two fp8 bytes, dividing by the exponent in scale. The bytes are packed into a 16-bit value which is inserted into oldVdst at the dstLoHiSel position, with the entire updated vector being returned.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk16.bf6.bf16 (ROCDL::CvtScaleF32Pk16Bf6Bf16Op) ¶

Scale and convert packed bf16 to packed bf6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk16.bf6.bf16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed bf6, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk16.bf6.f16 (ROCDL::CvtScaleF32Pk16Bf6F16Op) ¶

Scale and convert packed f16 to packed bf6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk16.bf6.f16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f16 values to packed bf6, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk16.bf6.f32 (ROCDL::CvtScaleF32Pk16Bf6F32Op) ¶

Scale and convert packed f32 to packed bf6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk16.bf6.f32` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f32 values to packed bf6, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk16.fp6.bf16 (ROCDL::CvtScaleF32Pk16Fp6Bf16Op) ¶

Scale and convert packed bf16 to packed fp6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk16.fp6.bf16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed fp6, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk16.fp6.f16 (ROCDL::CvtScaleF32Pk16Fp6F16Op) ¶

Scale and convert packed f16 to packed fp6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk16.fp6.f16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f16 values to packed fp6, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk16.fp6.f32 (ROCDL::CvtScaleF32Pk16Fp6F32Op) ¶

Scale and convert packed f32 to packed fp6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk16.fp6.f32` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f32 values to packed fp6, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.bf16.bf6 (ROCDL::CvtScaleF32Pk32Bf16Bf6Op) ¶

Scale and convert packed bf6 to packed bf16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.bf16.bf6` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed bf6 values to packed bf16, multiplying by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.bf16.fp6 (ROCDL::CvtScaleF32Pk32Bf16Fp6Op) ¶

Scale and convert packed fp6 to packed bf16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.bf16.fp6` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed fp6 values to packed bf16, multiplying by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.bf6.bf16 (ROCDL::CvtScaleF32Pk32Bf6Bf16Op) ¶

Scale and convert packed bf16 to packed bf6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.bf6.bf16` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed bf16 values to packed bf6, dividing by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.bf6.f16 (ROCDL::CvtScaleF32Pk32Bf6F16Op) ¶

Scale and convert packed f16 to packed bf6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.bf6.f16` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed f16 values to packed bf6, dividing by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.f16.bf6 (ROCDL::CvtScaleF32Pk32F16Bf6Op) ¶

Scale and convert packed bf6 to packed f16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.f16.bf6` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed bf6 values to packed f16, multiplying by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.f16.fp6 (ROCDL::CvtScaleF32Pk32F16Fp6Op) ¶

Scale and convert packed fp6 to packed f16

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.f16.fp6` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed fp6 values to packed f16, multiplying by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.f32.bf6 (ROCDL::CvtScaleF32Pk32F32Bf6Op) ¶

Scale and convert packed bf6 to packed f32

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.f32.bf6` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed bf6 values to packed f32, multiplying by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.f32.fp6 (ROCDL::CvtScaleF32Pk32F32Fp6Op) ¶

Scale and convert packed fp6 to packed f32

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.f32.fp6` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed fp6 values to packed f32, multiplying by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.fp6.bf16 (ROCDL::CvtScaleF32Pk32Fp6Bf16Op) ¶

Scale and convert packed bf16 to packed fp6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.fp6.bf16` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed bf16 values to packed fp6, dividing by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk32.fp6.f16 (ROCDL::CvtScaleF32Pk32Fp6F16Op) ¶

Scale and convert packed f16 to packed fp6

Syntax:

operation ::= `rocdl.cvt.scalef32.pk32.fp6.f16` attr-dict $src `,` $scale `:` type($res)

Convert 32 packed f16 values to packed fp6, dividing by the exponent part of scale before doing so.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.bf8.bf16 (ROCDL::CvtScaleF32Pk8Bf8Bf16Op) ¶

Scale and convert packed bf16 to packed bf8

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.bf8.bf16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed bf8, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.bf8.f16 (ROCDL::CvtScaleF32Pk8Bf8F16Op) ¶

Scale and convert packed f16 to packed bf8

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.bf8.f16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f16 values to packed bf8, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.bf8.f32 (ROCDL::CvtScaleF32Pk8Bf8F32Op) ¶

Scale and convert packed f32 to packed bf8

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.bf8.f32` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f32 values to packed bf8, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.fp4.bf16 (ROCDL::CvtScaleF32Pk8Fp4Bf16Op) ¶

Scale and convert packed bf16 to packed fp4

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.fp4.bf16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed fp4, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.fp4.f16 (ROCDL::CvtScaleF32Pk8Fp4F16Op) ¶

Scale and convert packed f16 to packed fp4

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.fp4.f16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f16 values to packed fp4, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.fp4.f32 (ROCDL::CvtScaleF32Pk8Fp4F32Op) ¶

Scale and convert packed f32 to packed fp4

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.fp4.f32` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f32 values to packed fp4, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.fp8.bf16 (ROCDL::CvtScaleF32Pk8Fp8Bf16Op) ¶

Scale and convert packed bf16 to packed fp8

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.fp8.bf16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed fp8, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.fp8.f16 (ROCDL::CvtScaleF32Pk8Fp8F16Op) ¶

Scale and convert packed f16 to packed fp8

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.fp8.f16` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f16 values to packed fp8, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.pk8.fp8.f32 (ROCDL::CvtScaleF32Pk8Fp8F32Op) ¶

Scale and convert packed f32 to packed fp8

Syntax:

operation ::= `rocdl.cvt.scalef32.pk8.fp8.f32` attr-dict $src `,` $scale `:` type($res)

Convert 8 packed f32 values to packed fp8, multiplying by the exponent part of scale before doing so. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.bf8.bf16 (ROCDL::CvtScaleF32SrBf8BF16Op) ¶

Scaled convert bf16to bf8 with stochiastic rounding, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.bf8.bf16` attr-dict $src0 `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert a bf16 value in src0 to a bf8 bytes, dividing by the exponent in scale and using seed for stochiastic rounding. Place the resulting byte in the dstSelIndexth bit of oldVdst and return the entire packed vector, which is stored as an i32.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.bf8.f16 (ROCDL::CvtScaleF32SrBf8F16Op) ¶

Scaled convert f16to bf8 with stochiastic rounding, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.bf8.f16` attr-dict $src0 `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert a f16 value in src0 to a bf8 bytes, dividing by the exponent in scale and using seed for stochiastic rounding. Place the resulting byte in the dstSelIndexth bit of oldVdst and return the entire packed vector, which is stored as an i32.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.bf8.f32 (ROCDL::CvtScaleF32SrBf8F32Op) ¶

Scaled convert f32to bf8 with stochiastic rounding, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.bf8.f32` attr-dict $src0 `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert a f32 value in src0 to a bf8 bytes, dividing by the exponent in scale and using seed for stochiastic rounding. Place the resulting byte in the dstSelIndexth bit of oldVdst and return the entire packed vector, which is stored as an i32.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.fp8.bf16 (ROCDL::CvtScaleF32SrFp8BF16Op) ¶

Scaled convert bf16to fp8 with stochiastic rounding, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.fp8.bf16` attr-dict $src0 `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert a bf16 value in src0 to a fp8 bytes, dividing by the exponent in scale and using seed for stochiastic rounding. Place the resulting byte in the dstSelIndexth bit of oldVdst and return the entire packed vector, which is stored as an i32.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.fp8.f16 (ROCDL::CvtScaleF32SrFp8F16Op) ¶

Scaled convert f16to fp8 with stochiastic rounding, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.fp8.f16` attr-dict $src0 `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert a f16 value in src0 to a fp8 bytes, dividing by the exponent in scale and using seed for stochiastic rounding. Place the resulting byte in the dstSelIndexth bit of oldVdst and return the entire packed vector, which is stored as an i32.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.fp8.f32 (ROCDL::CvtScaleF32SrFp8F32Op) ¶

Scaled convert f32to fp8 with stochiastic rounding, updating packed vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.fp8.f32` attr-dict $src0 `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert a f32 value in src0 to a fp8 bytes, dividing by the exponent in scale and using seed for stochiastic rounding. Place the resulting byte in the dstSelIndexth bit of oldVdst and return the entire packed vector, which is stored as an i32.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk.fp4.bf16 (ROCDL::CvtScaleF32SrPkFp4Bf16Op) ¶

Scale and convert two bf16 to packed fp4 with stochiastic rounding, updating tied vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk.fp4.bf16` attr-dict $src `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert two packed bf16 values to packed fp4, dividing by the exponent part of scale before doing so and using seed as the random seed for stochiastic rounding.

The two scaled values are packed (little-endian) into a byte. That byte is used to update the dstSelIndexth byte of oldVdst, which is returned in its entirity.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk.fp4.f16 (ROCDL::CvtScaleF32SrPkFp4F16Op) ¶

Scale and convert two f16 to packed fp4 with stochiastic rounding, updating tied vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk.fp4.f16` attr-dict $src `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert two packed f16 values to packed fp4, dividing by the exponent part of scale before doing so and using seed as the random seed for stochiastic rounding.

The two scaled values are packed (little-endian) into a byte. That byte is used to update the dstSelIndexth byte of oldVdst, which is returned in its entirity.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk.fp4.f32 (ROCDL::CvtScaleF32SrPkFp4F32Op) ¶

Scale and convert two f32 to packed fp4 with stochiastic rounding, updating tied vector

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk.fp4.f32` attr-dict $src `,` $seed `,` $scale `->` $oldVdst `[` $dstSelIndex `]` `:` type($res)

Convert two packed f32 values to packed fp4, dividing by the exponent part of scale before doing so and using seed as the random seed for stochiastic rounding.

The two scaled values are packed (little-endian) into a byte. That byte is used to update the dstSelIndexth byte of oldVdst, which is returned in its entirity.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk16.bf6.bf16 (ROCDL::CvtScaleF32SrPk16Bf6Bf16Op) ¶

Scale and convert packed bf16 to packed bf6 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk16.bf6.bf16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed bf6, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk16.bf6.f16 (ROCDL::CvtScaleF32SrPk16Bf6F16Op) ¶

Scale and convert packed f16 to packed bf6 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk16.bf6.f16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f16 values to packed bf6, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk16.bf6.f32 (ROCDL::CvtScaleF32SrPk16Bf6F32Op) ¶

Scale and convert packed f32 to packed bf6 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk16.bf6.f32` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f32 values to packed bf6, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk16.fp6.bf16 (ROCDL::CvtScaleF32SrPk16Fp6Bf16Op) ¶

Scale and convert packed bf16 to packed fp6 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk16.fp6.bf16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed fp6, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk16.fp6.f16 (ROCDL::CvtScaleF32SrPk16Fp6F16Op) ¶

Scale and convert packed f16 to packed fp6 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk16.fp6.f16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f16 values to packed fp6, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk16.fp6.f32 (ROCDL::CvtScaleF32SrPk16Fp6F32Op) ¶

Scale and convert packed f32 to packed fp6 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk16.fp6.f32` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f32 values to packed fp6, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk32.bf6.bf16 (ROCDL::CvtScaleF32SrPk32Bf6Bf16Op) ¶

Scale and convert packed bf16 to packed bf6 with stochiastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk32.bf6.bf16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 32 packed bf16 values to packed bf6, dividing by the exponent part of scale before doing so and applying random rounding derived from seed.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk32.bf6.f16 (ROCDL::CvtScaleF32SrPk32Bf6F16Op) ¶

Scale and convert packed f16 to packed bf6 with stochiastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk32.bf6.f16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 32 packed f16 values to packed bf6, dividing by the exponent part of scale before doing so and applying random rounding derived from seed.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk32.bf6.f32 (ROCDL::CvtScaleF32SrPk32Bf6F32Op) ¶

Scale and convert packed f32 to packed bf6 with stochiastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk32.bf6.f32` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 32 packed f32 values to packed bf6, dividing by the exponent part of scale before doing so and applying random rounding derived from seed.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk32.fp6.bf16 (ROCDL::CvtScaleF32SrPk32Fp6Bf16Op) ¶

Scale and convert packed bf16 to packed fp6 with stochiastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk32.fp6.bf16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 32 packed bf16 values to packed fp6, dividing by the exponent part of scale before doing so and applying random rounding derived from seed.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk32.fp6.f16 (ROCDL::CvtScaleF32SrPk32Fp6F16Op) ¶

Scale and convert packed f16 to packed fp6 with stochiastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk32.fp6.f16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 32 packed f16 values to packed fp6, dividing by the exponent part of scale before doing so and applying random rounding derived from seed.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk32.fp6.f32 (ROCDL::CvtScaleF32SrPk32Fp6F32Op) ¶

Scale and convert packed f32 to packed fp6 with stochiastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk32.fp6.f32` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 32 packed f32 values to packed fp6, dividing by the exponent part of scale before doing so and applying random rounding derived from seed.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.bf8.bf16 (ROCDL::CvtScaleF32SrPk8Bf8Bf16Op) ¶

Scale and convert packed bf16 to packed bf8 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.bf8.bf16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed bf8, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.bf8.f16 (ROCDL::CvtScaleF32SrPk8Bf8F16Op) ¶

Scale and convert packed f16 to packed bf8 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.bf8.f16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f16 values to packed bf8, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.bf8.f32 (ROCDL::CvtScaleF32SrPk8Bf8F32Op) ¶

Scale and convert packed f32 to packed bf8 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.bf8.f32` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f32 values to packed bf8, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.fp4.bf16 (ROCDL::CvtScaleF32SrPk8Fp4Bf16Op) ¶

Scale and convert packed bf16 to packed fp4 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.fp4.bf16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed fp4, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.fp4.f16 (ROCDL::CvtScaleF32SrPk8Fp4F16Op) ¶

Scale and convert packed f16 to packed fp4 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.fp4.f16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f16 values to packed fp4, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.fp4.f32 (ROCDL::CvtScaleF32SrPk8Fp4F32Op) ¶

Scale and convert packed f32 to packed fp4 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.fp4.f32` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f32 values to packed fp4, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.fp8.bf16 (ROCDL::CvtScaleF32SrPk8Fp8Bf16Op) ¶

Scale and convert packed bf16 to packed fp8 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.fp8.bf16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed bf16 values to packed fp8, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.fp8.f16 (ROCDL::CvtScaleF32SrPk8Fp8F16Op) ¶

Scale and convert packed f16 to packed fp8 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.fp8.f16` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f16 values to packed fp8, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.scalef32.sr.pk8.fp8.f32 (ROCDL::CvtScaleF32SrPk8Fp8F32Op) ¶

Scale and convert packed f32 to packed fp8 with stochastic rounding

Syntax:

operation ::= `rocdl.cvt.scalef32.sr.pk8.fp8.f32` attr-dict $src `,` $seed `,` $scale `:` type($res)

Convert 8 packed f32 values to packed fp8, multiplying by the exponent part of scale before doing so and apply stochastic rounding. This op is for gfx1250+ arch.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands: ¶

Results: ¶

rocdl.cvt.sr.bf8.f32 (ROCDL::CvtSrBf8F32Op) ¶

Convert f32 to bf8, stochiastic rounding

Syntax:

operation ::= `rocdl.cvt.sr.bf8.f32` attr-dict $srcA `,` $srcB `->` $old `[` $byteSel `]` `:` type($res)

Convert srcA to bf8, adding the rounding factor from srcB, and store into the byteSelth byte of old, preserving the others.

Example:

// Stochastic rounding convert f32 to bf8 in byte 2 of old.
%0 = rocdl.cvt.sr.bf8.f32 %val, %stoch -> %old[2] : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.cvt.sr.fp8.f32 (ROCDL::CvtSrFp8F32Op) ¶

Convert f32 to fp8, stochiastic rounding

Syntax:

operation ::= `rocdl.cvt.sr.fp8.f32` attr-dict $srcA `,` $srcB `->` $old `[` $byteSel `]` `:` type($res)

Convert srcA to fp8, adding the rounding factor from srcB, and store into the byteSelth byte of old, preserving the others.

Example:

// Stochastic rounding convert f32 to fp8 in byte 3 of old.
%0 = rocdl.cvt.sr.fp8.f32 %val, %stoch -> %old[3] : i32

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable, NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.ds.atomic.async.barrier.arrive.b64 (ROCDL::DsAtomicAsyncBarrierArriveOp) ¶

Syntax:

operation ::= `rocdl.ds.atomic.async.barrier.arrive.b64` $barrierPtr attr-dict `:` qualified(type($barrierPtr))

Waits on a given DS barrier and decrements pending count by -1. Stays in order with ASYNC loads to LDS, and uses ASYNCcnt to track its completion. Available on gfx1250+.

Example:

// Async atomic barrier arrive (fire-and-forget).
rocdl.ds.atomic.async.barrier.arrive.b64 %ptr : !llvm.ptr<3>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

rocdl.ds.atomic.barrier.arrive.rtn.b64 (ROCDL::DsAtomicBarrierArriveRtnOp) ¶

Syntax:

operation ::= `rocdl.ds.atomic.barrier.arrive.rtn.b64` $barrierPtr `,` $val attr-dict `:` qualified(type($barrierPtr)) `,` type($val) `->` type($res)

Waits on a given DS barrier and decrements its pending count by a given value. Note, the barrier state is given as a 64-bit structure containing pending count, phase and init count. The op returns the old barrier state. The op is executed as an ordinary LDS operations and it is ordered with other LDS operations. Thus, check DSCNT to determine when this instruction has executed. Available on gfx1250+.

Example:

// Atomic barrier arrive with return of old barrier state.
%res = rocdl.ds.atomic.barrier.arrive.rtn.b64 %ptr, %val : !llvm.ptr<3>, i64 -> i64

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.ds.load.tr16.b128 (ROCDL::DsLoadTr16_B128) ¶

Loads and transposes a matrix from ds memory to registers (available in gfx1250+).

Syntax:

operation ::= `rocdl.ds.load.tr16.b128` $ptr attr-dict `:` qualified(type($ptr)) `->` type($res)

Load a matrix of 16-bit data from the ds memory, transpose data between row-major and column-major order, and store the result into a 128-bit vector register.

Available in gfx1250+.

Example (concrete mnemonics depend on address space and element size):

// 64-bit transpose load from global memory.
%0 = rocdl.global.load.tr4.b64 %ptr : !llvm.ptr<1> -> vector<2xi32>

// 128-bit transpose load from global memory with f16 result.
%1 = rocdl.global.load.tr.b128 %ptr : !llvm.ptr<1> -> vector<8xf16>

// 64-bit transpose load from LDS.
%2 = rocdl.ds.load.tr4.b64 %ptr : !llvm.ptr<3> -> vector<2xi32>

// 128-bit transpose load from LDS with bf16 result.
%3 = rocdl.ds.load.tr16.b128 %ptr : !llvm.ptr<3> -> vector<8xbf16>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.ds.load.tr4.b64 (ROCDL::DsLoadTr4_B64) ¶

Loads and transposes a matrix from ds memory to registers (available in gfx1250+).

Syntax:

operation ::= `rocdl.ds.load.tr4.b64` $ptr attr-dict `:` qualified(type($ptr)) `->` type($res)

Load a matrix of 4-bit data from the ds memory, transpose data between row-major and column-major order, and store the result into a 64-bit vector register.

Available in gfx1250+.

Example (concrete mnemonics depend on address space and element size):

// 64-bit transpose load from global memory.
%0 = rocdl.global.load.tr4.b64 %ptr : !llvm.ptr<1> -> vector<2xi32>

// 128-bit transpose load from global memory with f16 result.
%1 = rocdl.global.load.tr.b128 %ptr : !llvm.ptr<1> -> vector<8xf16>

// 64-bit transpose load from LDS.
%2 = rocdl.ds.load.tr4.b64 %ptr : !llvm.ptr<3> -> vector<2xi32>

// 128-bit transpose load from LDS with bf16 result.
%3 = rocdl.ds.load.tr16.b128 %ptr : !llvm.ptr<3> -> vector<8xbf16>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.ds.load.tr6.b96 (ROCDL::DsLoadTr6_B96) ¶

Loads and transposes a matrix from ds memory to registers (available in gfx1250+).

Syntax:

operation ::= `rocdl.ds.load.tr6.b96` $ptr attr-dict `:` qualified(type($ptr)) `->` type($res)

Load a matrix of 6-bit data from the ds memory, transpose data between row-major and column-major order, and store the result into a 96-bit vector register.

Available in gfx1250+.

Example (concrete mnemonics depend on address space and element size):

// 64-bit transpose load from global memory.
%0 = rocdl.global.load.tr4.b64 %ptr : !llvm.ptr<1> -> vector<2xi32>

// 128-bit transpose load from global memory with f16 result.
%1 = rocdl.global.load.tr.b128 %ptr : !llvm.ptr<1> -> vector<8xf16>

// 64-bit transpose load from LDS.
%2 = rocdl.ds.load.tr4.b64 %ptr : !llvm.ptr<3> -> vector<2xi32>

// 128-bit transpose load from LDS with bf16 result.
%3 = rocdl.ds.load.tr16.b128 %ptr : !llvm.ptr<3> -> vector<8xbf16>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.ds.load.tr8.b64 (ROCDL::DsLoadTr8_B64) ¶

Loads and transposes a matrix from ds memory to registers (available in gfx1250+).

Syntax:

operation ::= `rocdl.ds.load.tr8.b64` $ptr attr-dict `:` qualified(type($ptr)) `->` type($res)

Load a matrix of 8-bit data from the ds memory, transpose data between row-major and column-major order, and store the result into a 64-bit vector register.

Available in gfx1250+.

Example (concrete mnemonics depend on address space and element size):

// 64-bit transpose load from global memory.
%0 = rocdl.global.load.tr4.b64 %ptr : !llvm.ptr<1> -> vector<2xi32>

// 128-bit transpose load from global memory with f16 result.
%1 = rocdl.global.load.tr.b128 %ptr : !llvm.ptr<1> -> vector<8xf16>

// 64-bit transpose load from LDS.
%2 = rocdl.ds.load.tr4.b64 %ptr : !llvm.ptr<3> -> vector<2xi32>

// 128-bit transpose load from LDS with bf16 result.
%3 = rocdl.ds.load.tr16.b128 %ptr : !llvm.ptr<3> -> vector<8xbf16>

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.ds.read.tr16.b64 (ROCDL::ds_read_tr16_b64) ¶

Syntax:

operation ::= `rocdl.ds.read.tr16.b64` $ptr attr-dict `:` type($ptr) `->` type($res)

Interfaces: AliasAnalysisOpInterface

Attributes: ¶

Operands: ¶

Results: ¶

rocdl.ds.read.tr4.b64 (ROCDL::ds_read_tr4_b64) ¶

Syntax:

operation ::= `rocdl.ds.read.tr4.b64` $ptr attr-dict `:` type($ptr) `->` type($res)

Interfaces: AliasAnalysisOpInterface

Attributes: ¶