[python][tuner] Add bindings for MMAIntrinsic (#19095) Expose MMA intrinsics to python. This includes both the `MMAIntrinsic` attribute and the enum values. In addition, expose element/vector types and shapes from the MMA interface (but not the interface itself). This is so that the tuner can use the compiler as the SoT for all the intrinsics and use them to parse target properties and generate constraints. The enum values are kept opaque so that we do not have to duplicate the definitions in TD and C API headers.
diff --git a/compiler/bindings/c/iree/compiler/dialects/iree_gpu.h b/compiler/bindings/c/iree/compiler/dialects/iree_gpu.h index e9115b1..7a596fe 100644 --- a/compiler/bindings/c/iree/compiler/dialects/iree_gpu.h +++ b/compiler/bindings/c/iree/compiler/dialects/iree_gpu.h
@@ -14,10 +14,8 @@ extern "C" { #endif -enum ireeGPUReorderWorkgroupsStrategyEnum { - ireeGPUReorderWorkgroupsStrategyEnumNone = 0, - ireeGPUReorderWorkgroupsStrategyEnumTranspose = 1, -}; +// The following C API is **NOT STABLE** and likely to change in the future. +// It mirrors the IREE GPU Dialect which is not stable itself. MLIR_CAPI_EXPORTED bool ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr(MlirAttribute attr); @@ -25,10 +23,10 @@ MLIR_CAPI_EXPORTED MlirTypeID ireeGPUReorderWorkgroupsStrategyAttrGetTypeID(void); -MLIR_CAPI_EXPORTED MlirAttribute ireeGPUReorderWorkgroupsStrategyAttrGet( - MlirContext mlirCtx, ireeGPUReorderWorkgroupsStrategyEnum value); +MLIR_CAPI_EXPORTED MlirAttribute +ireeGPUReorderWorkgroupsStrategyAttrGet(MlirContext mlirCtx, uint32_t value); -MLIR_CAPI_EXPORTED ireeGPUReorderWorkgroupsStrategyEnum +MLIR_CAPI_EXPORTED uint32_t ireeGPUReorderWorkgroupsStrategyAttrGetValue(MlirAttribute attr); MLIR_CAPI_EXPORTED @@ -54,6 +52,36 @@ MLIR_CAPI_EXPORTED MlirTypeID ireeGPUPipelineOptionsAttrGetTypeID(void); +MLIR_CAPI_EXPORTED bool ireeAttributeIsAGPUMMAIntrinsicAttr(MlirAttribute attr); + +MLIR_CAPI_EXPORTED MlirTypeID ireeGPUMMAIntrinsicAttrGetTypeID(void); + +MLIR_CAPI_EXPORTED MlirAttribute ireeGPUMMAIntrinsicAttrGet(MlirContext mlirCtx, + uint32_t value); + +MLIR_CAPI_EXPORTED uint32_t ireeGPUMMAIntrinsicAttrGetValue(MlirAttribute attr); + +MLIR_CAPI_EXPORTED bool ireeAttributeIsAGPUMMAAttr(MlirAttribute attr); + +MLIR_CAPI_EXPORTED MlirTypeID ireeGPUMMAAttrGetTypeID(void); + +MLIR_CAPI_EXPORTED MlirAttribute ireeGPUMMAAttrGet(MlirContext mlirCtx, + uint32_t value); + +struct ireeGPUMMAInfo { + MlirType aElementType; + MlirType bElementType; + MlirType cElementType; + MlirType aVectorType; + MlirType bVectorType; + MlirType cVectorType; + int64_t mElements; + int64_t nElements; + int64_t kElements; +}; + +MLIR_CAPI_EXPORTED ireeGPUMMAInfo ireeGPUMMAAttrGetInfo(MlirAttribute attr); + #ifdef __cplusplus } #endif
diff --git a/compiler/bindings/python/IREECompilerDialectsModule.cpp b/compiler/bindings/python/IREECompilerDialectsModule.cpp index 0e463fd..d24075a 100644 --- a/compiler/bindings/python/IREECompilerDialectsModule.cpp +++ b/compiler/bindings/python/IREECompilerDialectsModule.cpp
@@ -4,11 +4,15 @@ // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include <cstdint> #include "iree/compiler/dialects/iree_gpu.h" #include "mlir-c/BuiltinAttributes.h" #include "mlir-c/IR.h" #include "mlir/Bindings/Python/PybindAdaptors.h" +static const char *kGpuModuleImportPath = + MAKE_MLIR_PYTHON_QUALNAME("dialects.iree_gpu"); + namespace py = pybind11; using namespace mlir::python::adaptors; @@ -22,45 +26,23 @@ // GPUReorderWorkgroupsStrategyAttr //===-------------------------------------------------------------------===// - auto strategyEnum = - py::enum_<ireeGPUReorderWorkgroupsStrategyEnum>( - iree_gpu_module, "ReorderWorkgroupsStrategy", py::module_local()) - .value("None_", ireeGPUReorderWorkgroupsStrategyEnumNone) - .value("Transpose", ireeGPUReorderWorkgroupsStrategyEnumTranspose) - .def( - "__str__", - [](ireeGPUReorderWorkgroupsStrategyEnum &self) { - switch (self) { - case ireeGPUReorderWorkgroupsStrategyEnumNone: - return "None"; - case ireeGPUReorderWorkgroupsStrategyEnumTranspose: - return "Transpose"; - default: - llvm::report_fatal_error( - "unknown ReorderWorkgroupsStrategy variant"); - } - }, - // pybind overloads are tried in the order they were registered. - // As a result, enums used the default __str__ method instead of - // the custom one. Adding py::prepend() fixes this issue. - py::prepend()); - mlir_attribute_subclass(iree_gpu_module, "ReorderWorkgroupsStrategyAttr", ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr, ireeGPUReorderWorkgroupsStrategyAttrGetTypeID) .def_classmethod( "get", - [](const py::object &, ireeGPUReorderWorkgroupsStrategyEnum value, - MlirContext ctx) { + [](const py::object &, uint32_t value, MlirContext ctx) { return ireeGPUReorderWorkgroupsStrategyAttrGet(ctx, value); }, "cls"_a, "value"_a, "ctx"_a = py::none(), "Gets a gpu.reorder_workgroups_strategy from parameters.") - .def_property_readonly( - "value", - [](MlirAttribute self) -> ireeGPUReorderWorkgroupsStrategyEnum { - return ireeGPUReorderWorkgroupsStrategyAttrGetValue(self); - }); + .def_property_readonly("raw_value", + ireeGPUReorderWorkgroupsStrategyAttrGetValue) + .def_property_readonly("value", [](MlirAttribute self) -> py::object { + uint32_t rawValue = ireeGPUReorderWorkgroupsStrategyAttrGetValue(self); + return py::module_::import(kGpuModuleImportPath) + .attr("ReorderWorkgroupsStrategy")(rawValue); + }); //===-------------------------------------------------------------------===// // GPUPipelineOptionsAttr @@ -129,4 +111,58 @@ return attr; return std::nullopt; }); + + //===-------------------------------------------------------------------===// + // GPUMMAIntrinsicAttr + //===-------------------------------------------------------------------===// + mlir_attribute_subclass(iree_gpu_module, "MMAIntrinsicAttr", + ireeAttributeIsAGPUMMAIntrinsicAttr, + ireeGPUMMAIntrinsicAttrGetTypeID) + .def_classmethod( + "get", + [](const py::object &, uint32_t value, MlirContext ctx) { + return ireeGPUMMAIntrinsicAttrGet(ctx, value); + }, + "cls"_a, "value"_a, "ctx"_a = py::none(), + "Gets a gpu.mma_intrinsic from parameters.") + .def_property_readonly("raw_value", ireeGPUMMAIntrinsicAttrGetValue) + .def_property_readonly("value", + [](MlirAttribute self) -> py::object { + uint32_t rawValue = + ireeGPUMMAIntrinsicAttrGetValue(self); + return py::module_::import(kGpuModuleImportPath) + .attr("MMAIntrinsic")(rawValue); + }) + .def_property_readonly("mma", [](MlirAttribute self) -> MlirAttribute { + uint32_t value = ireeGPUMMAIntrinsicAttrGetValue(self); + return ireeGPUMMAAttrGet(mlirAttributeGetContext(self), value); + }); + + mlir_attribute_subclass(iree_gpu_module, "MMAAttr", + ireeAttributeIsAGPUMMAAttr, ireeGPUMMAAttrGetTypeID) + .def_classmethod( + "get", + [](const py::object &, uint32_t value, MlirContext ctx) { + return ireeGPUMMAAttrGet(ctx, value); + }, + "cls"_a, "value"_a, "ctx"_a = py::none(), + "Gets a gpu.mma from parameters.") + .def_property_readonly( + "abc_element_types", + [](MlirAttribute self) -> py::tuple { + ireeGPUMMAInfo info = ireeGPUMMAAttrGetInfo(self); + return py::make_tuple(info.aElementType, info.bElementType, + info.cElementType); + }) + .def_property_readonly( + "abc_vector_types", + [](MlirAttribute self) -> py::tuple { + ireeGPUMMAInfo info = ireeGPUMMAAttrGetInfo(self); + return py::make_tuple(info.aVectorType, info.bVectorType, + info.cVectorType); + }) + .def_property_readonly("mnk_shape", [](MlirAttribute self) -> py::tuple { + ireeGPUMMAInfo info = ireeGPUMMAAttrGetInfo(self); + return py::make_tuple(info.mElements, info.nElements, info.kElements); + }); }
diff --git a/compiler/bindings/python/test/ir/dialects_test.py b/compiler/bindings/python/test/ir/dialects_test.py index a69a035..e1b4121 100644 --- a/compiler/bindings/python/test/ir/dialects_test.py +++ b/compiler/bindings/python/test/ir/dialects_test.py
@@ -18,6 +18,8 @@ reorder_attr = iree_gpu.ReorderWorkgroupsStrategyAttr.get( iree_gpu.ReorderWorkgroupsStrategy.Transpose, ctx ) + assert reorder_attr.value == iree_gpu.ReorderWorkgroupsStrategy.Transpose + gpu_attr = iree_gpu.PipelineOptionsAttr.get( True, False, @@ -86,3 +88,46 @@ # unfortunately not `is` == iree_gpu.ReorderWorkgroupsStrategy.Transpose ) + + +@lambda _: _() +def mma_intrinsic_attr(): + with ir.Context() as ctx, ir.Location.unknown(): + module = ir.Module.create() + with ir.InsertionPoint(module.body): + mma_intrinsic_attr = iree_gpu.MMAIntrinsicAttr.get( + iree_gpu.MMAIntrinsic.MFMA_F32_32x32x8_F16, ctx + ) + assert mma_intrinsic_attr is not None + assert ( + str(mma_intrinsic_attr) + == "#iree_gpu<mma_intrinsic MFMA_F32_32x32x8_F16>" + ) + + raw_value = mma_intrinsic_attr.raw_value + assert raw_value == iree_gpu.MMAIntrinsic.MFMA_F32_32x32x8_F16 + value = mma_intrinsic_attr.value + assert str(value) == "MFMA_F32_32x32x8_F16" + assert int(value) == raw_value + + mma_attr = iree_gpu.MMAAttr.get(raw_value, ctx) + assert mma_attr is not None + + f16 = ir.F16Type.get() + f32 = ir.F32Type.get() + a_type, b_type, c_type = mma_attr.abc_element_types + assert a_type == f16 + assert b_type == f16 + assert c_type == f32 + + vec_4xf16 = ir.VectorType.get((4,), f16) + a_vec_type, b_vec_type, _c_vec_type = mma_attr.abc_vector_types + assert a_vec_type == vec_4xf16 + assert b_vec_type == vec_4xf16 + + M, N, K = mma_attr.mnk_shape + assert M == 32 + assert N == 32 + assert K == 8 + + assert mma_intrinsic_attr.mma == mma_attr
diff --git a/compiler/src/iree/compiler/API/Internal/IREEGPUDialectCAPI.cpp b/compiler/src/iree/compiler/API/Internal/IREEGPUDialectCAPI.cpp index 821845e..15f517e 100644 --- a/compiler/src/iree/compiler/API/Internal/IREEGPUDialectCAPI.cpp +++ b/compiler/src/iree/compiler/API/Internal/IREEGPUDialectCAPI.cpp
@@ -4,7 +4,10 @@ // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include <cstdint> +#include <type_traits> #include "iree/compiler/Codegen/Dialect/GPU/IR/IREEGPUAttrs.h" +#include "iree/compiler/Codegen/Dialect/GPU/IR/IREEGPUEnums.h" #include "iree/compiler/dialects/iree_gpu.h" #include "mlir-c/IR.h" #include "mlir/CAPI/IR.h" @@ -84,20 +87,6 @@ mlir::iree_compiler::IREE::GPU::GPUPipelineOptionsAttr::getTypeID()); } -static_assert( - static_cast<uint32_t>(ireeGPUReorderWorkgroupsStrategyEnumNone) == - static_cast<uint32_t>(mlir::iree_compiler::IREE::GPU:: - ReorderWorkgroupsStrategy::None) && - static_cast<uint32_t>(ireeGPUReorderWorkgroupsStrategyEnumTranspose) == - static_cast<uint32_t>(mlir::iree_compiler::IREE::GPU:: - ReorderWorkgroupsStrategy::Transpose) && - static_cast<uint32_t>(ireeGPUReorderWorkgroupsStrategyEnumTranspose) == - mlir::iree_compiler::IREE::GPU:: - getMaxEnumValForReorderWorkgroupsStrategy(), - "ireeGPUReorderWorkgroupsStrategyEnum and " - "mlir::iree_compiler::IREE::GPU::ReorderWorkgroupsStrategy definitions " - "have diverged"); - bool ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr(MlirAttribute attr) { return llvm::isa< mlir::iree_compiler::IREE::GPU::ReorderWorkgroupsStrategyAttr>( @@ -109,8 +98,15 @@ getTypeID()); } -MlirAttribute ireeGPUReorderWorkgroupsStrategyAttrGet( - MlirContext mlirCtx, ireeGPUReorderWorkgroupsStrategyEnum value) { +static_assert( + std::is_same_v< + uint32_t, + std::underlying_type_t< + mlir::iree_compiler::IREE::GPU::ReorderWorkgroupsStrategy>>, + "Enum type changed"); + +MlirAttribute ireeGPUReorderWorkgroupsStrategyAttrGet(MlirContext mlirCtx, + uint32_t value) { mlir::MLIRContext *ctx = unwrap(mlirCtx); return wrap( mlir::iree_compiler::IREE::GPU::ReorderWorkgroupsStrategyAttr::get( @@ -119,12 +115,72 @@ value))); } -ireeGPUReorderWorkgroupsStrategyEnum -ireeGPUReorderWorkgroupsStrategyAttrGetValue(MlirAttribute attr) { +uint32_t ireeGPUReorderWorkgroupsStrategyAttrGetValue(MlirAttribute attr) { assert(ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr(attr) && "attr is not a GPUReorderWorkgroupsStrategyAttr"); - return static_cast<ireeGPUReorderWorkgroupsStrategyEnum>( + return static_cast<uint32_t>( llvm::cast<mlir::iree_compiler::IREE::GPU::ReorderWorkgroupsStrategyAttr>( unwrap(attr)) .getValue()); } + +bool ireeAttributeIsAGPUMMAIntrinsicAttr(MlirAttribute attr) { + return llvm::isa<mlir::iree_compiler::IREE::GPU::MMAIntrinsicAttr>( + unwrap(attr)); +} + +MlirTypeID ireeGPUMMAIntrinsicAttrGetTypeID() { + return wrap(mlir::iree_compiler::IREE::GPU::MMAIntrinsicAttr::getTypeID()); +} + +static_assert( + std::is_same_v<uint32_t, std::underlying_type_t< + mlir::iree_compiler::IREE::GPU::MMAIntrinsic>>, + "Enum type changed"); + +MlirAttribute ireeGPUMMAIntrinsicAttrGet(MlirContext mlirCtx, uint32_t value) { + mlir::MLIRContext *ctx = unwrap(mlirCtx); + return wrap(mlir::iree_compiler::IREE::GPU::MMAIntrinsicAttr::get( + ctx, static_cast<mlir::iree_compiler::IREE::GPU::MMAIntrinsic>(value))); +} + +uint32_t ireeGPUMMAIntrinsicAttrGetValue(MlirAttribute attr) { + assert(ireeAttributeIsAGPUMMAIntrinsicAttr(attr) && + "attr is not a GPUMMAIntrinsicAttr"); + return static_cast<uint32_t>( + llvm::cast<mlir::iree_compiler::IREE::GPU::MMAIntrinsicAttr>(unwrap(attr)) + .getValue()); +} + +bool ireeAttributeIsAGPUMMAAttr(MlirAttribute attr) { + return llvm::isa<mlir::iree_compiler::IREE::GPU::MMAAttr>(unwrap(attr)); +} + +MlirTypeID ireeGPUMMAAttrGetTypeID() { + return wrap(mlir::iree_compiler::IREE::GPU::MMAAttr::getTypeID()); +} + +MlirAttribute ireeGPUMMAAttrGet(MlirContext mlirCtx, uint32_t value) { + mlir::MLIRContext *ctx = unwrap(mlirCtx); + return wrap(mlir::iree_compiler::IREE::GPU::MMAAttr::get( + ctx, static_cast<mlir::iree_compiler::IREE::GPU::MMAIntrinsic>(value))); +} + +ireeGPUMMAInfo ireeGPUMMAAttrGetInfo(MlirAttribute attr) { + assert(ireeAttributeIsAGPUMMAAttr(attr) && "attr is not a MMAAttr"); + auto mma = llvm::cast<mlir::iree_compiler::IREE::GPU::MMAAttr>(unwrap(attr)); + + ireeGPUMMAInfo info = {}; + auto [aType, bType, cType] = mma.getABCElementTypes(); + info.aElementType = wrap(aType); + info.bElementType = wrap(bType); + info.cElementType = wrap(cType); + + auto [aVecType, bVecType, cVecType] = mma.getABCVectorTypes(); + info.aVectorType = wrap(aVecType); + info.bVectorType = wrap(bVecType); + info.cVectorType = wrap(cVecType); + + std::tie(info.mElements, info.nElements, info.kElements) = mma.getMNKShape(); + return info; +}
diff --git a/compiler/src/iree/compiler/API/api_exports.c b/compiler/src/iree/compiler/API/api_exports.c index dcb315c..664bab4 100644 --- a/compiler/src/iree/compiler/API/api_exports.c +++ b/compiler/src/iree/compiler/API/api_exports.c
@@ -10,6 +10,8 @@ #include <stdint.h> +extern void ireeAttributeIsAGPUMMAAttr(); +extern void ireeAttributeIsAGPUMMAIntrinsicAttr(); extern void ireeAttributeIsAGPUPipelineOptionsAttr(); extern void ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr(); extern void ireeCompilerEnumeratePlugins(); @@ -63,6 +65,12 @@ extern void ireeCompilerSourceOpenFile(); extern void ireeCompilerSourceSplit(); extern void ireeCompilerSourceWrapBuffer(); +extern void ireeGPUMMAAttrGet(); +extern void ireeGPUMMAAttrGetInfo(); +extern void ireeGPUMMAAttrGetTypeID(); +extern void ireeGPUMMAIntrinsicAttrGet(); +extern void ireeGPUMMAIntrinsicAttrGetTypeID(); +extern void ireeGPUMMAIntrinsicAttrGetValue(); extern void ireeGPUPipelineOptionsAttrGet(); extern void ireeGPUPipelineOptionsAttrGetNoReduceSharedMemoryBankConflicts(); extern void ireeGPUPipelineOptionsAttrGetPrefetchSharedMemory(); @@ -848,6 +856,8 @@ uintptr_t __iree_compiler_hidden_force_extern() { uintptr_t x = 0; + x += (uintptr_t)&ireeAttributeIsAGPUMMAAttr; + x += (uintptr_t)&ireeAttributeIsAGPUMMAIntrinsicAttr; x += (uintptr_t)&ireeAttributeIsAGPUPipelineOptionsAttr; x += (uintptr_t)&ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr; x += (uintptr_t)&ireeCompilerEnumeratePlugins; @@ -901,6 +911,12 @@ x += (uintptr_t)&ireeCompilerSourceOpenFile; x += (uintptr_t)&ireeCompilerSourceSplit; x += (uintptr_t)&ireeCompilerSourceWrapBuffer; + x += (uintptr_t)&ireeGPUMMAAttrGet; + x += (uintptr_t)&ireeGPUMMAAttrGetInfo; + x += (uintptr_t)&ireeGPUMMAAttrGetTypeID; + x += (uintptr_t)&ireeGPUMMAIntrinsicAttrGet; + x += (uintptr_t)&ireeGPUMMAIntrinsicAttrGetTypeID; + x += (uintptr_t)&ireeGPUMMAIntrinsicAttrGetValue; x += (uintptr_t)&ireeGPUPipelineOptionsAttrGet; x += (uintptr_t)&ireeGPUPipelineOptionsAttrGetNoReduceSharedMemoryBankConflicts; x += (uintptr_t)&ireeGPUPipelineOptionsAttrGetPrefetchSharedMemory;
diff --git a/compiler/src/iree/compiler/API/api_exports.def b/compiler/src/iree/compiler/API/api_exports.def index 13ad7ab..4d2fb0d 100644 --- a/compiler/src/iree/compiler/API/api_exports.def +++ b/compiler/src/iree/compiler/API/api_exports.def
@@ -1,5 +1,7 @@ ; Generated by generate_exports.py: Do not edit. EXPORTS + ireeAttributeIsAGPUMMAAttr + ireeAttributeIsAGPUMMAIntrinsicAttr ireeAttributeIsAGPUPipelineOptionsAttr ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr ireeCompilerEnumeratePlugins @@ -53,6 +55,12 @@ ireeCompilerSourceOpenFile ireeCompilerSourceSplit ireeCompilerSourceWrapBuffer + ireeGPUMMAAttrGet + ireeGPUMMAAttrGetInfo + ireeGPUMMAAttrGetTypeID + ireeGPUMMAIntrinsicAttrGet + ireeGPUMMAIntrinsicAttrGetTypeID + ireeGPUMMAIntrinsicAttrGetValue ireeGPUPipelineOptionsAttrGet ireeGPUPipelineOptionsAttrGetNoReduceSharedMemoryBankConflicts ireeGPUPipelineOptionsAttrGetPrefetchSharedMemory
diff --git a/compiler/src/iree/compiler/API/api_exports.ld b/compiler/src/iree/compiler/API/api_exports.ld index 4ff2566..cd3f967 100644 --- a/compiler/src/iree/compiler/API/api_exports.ld +++ b/compiler/src/iree/compiler/API/api_exports.ld
@@ -1,6 +1,8 @@ # Generated by generate_exports.py: Do not edit. VER_0 { global: + ireeAttributeIsAGPUMMAAttr; + ireeAttributeIsAGPUMMAIntrinsicAttr; ireeAttributeIsAGPUPipelineOptionsAttr; ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr; ireeCompilerEnumeratePlugins; @@ -54,6 +56,12 @@ ireeCompilerSourceOpenFile; ireeCompilerSourceSplit; ireeCompilerSourceWrapBuffer; + ireeGPUMMAAttrGet; + ireeGPUMMAAttrGetInfo; + ireeGPUMMAAttrGetTypeID; + ireeGPUMMAIntrinsicAttrGet; + ireeGPUMMAIntrinsicAttrGetTypeID; + ireeGPUMMAIntrinsicAttrGetValue; ireeGPUPipelineOptionsAttrGet; ireeGPUPipelineOptionsAttrGetNoReduceSharedMemoryBankConflicts; ireeGPUPipelineOptionsAttrGetPrefetchSharedMemory;
diff --git a/compiler/src/iree/compiler/API/api_exports.macos.lst b/compiler/src/iree/compiler/API/api_exports.macos.lst index 871ca80..1ac4588 100644 --- a/compiler/src/iree/compiler/API/api_exports.macos.lst +++ b/compiler/src/iree/compiler/API/api_exports.macos.lst
@@ -1,4 +1,6 @@ # Generated by generate_exports.py: Do not edit. +_ireeAttributeIsAGPUMMAAttr +_ireeAttributeIsAGPUMMAIntrinsicAttr _ireeAttributeIsAGPUPipelineOptionsAttr _ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr _ireeCompilerEnumeratePlugins @@ -52,6 +54,12 @@ _ireeCompilerSourceOpenFile _ireeCompilerSourceSplit _ireeCompilerSourceWrapBuffer +_ireeGPUMMAAttrGet +_ireeGPUMMAAttrGetInfo +_ireeGPUMMAAttrGetTypeID +_ireeGPUMMAIntrinsicAttrGet +_ireeGPUMMAIntrinsicAttrGetTypeID +_ireeGPUMMAIntrinsicAttrGetValue _ireeGPUPipelineOptionsAttrGet _ireeGPUPipelineOptionsAttrGetNoReduceSharedMemoryBankConflicts _ireeGPUPipelineOptionsAttrGetPrefetchSharedMemory
diff --git a/compiler/src/iree/compiler/Codegen/Dialect/GPU/IR/IREEGPUInterfaces.td b/compiler/src/iree/compiler/Codegen/Dialect/GPU/IR/IREEGPUInterfaces.td index 2c9f828..639737a 100644 --- a/compiler/src/iree/compiler/Codegen/Dialect/GPU/IR/IREEGPUInterfaces.td +++ b/compiler/src/iree/compiler/Codegen/Dialect/GPU/IR/IREEGPUInterfaces.td
@@ -16,7 +16,7 @@ let description = [{ Interface used to query information needed to generate code targeting a - specific Matrix Multiply–Accumulate (MMA) machine intrinsic instruction. + specific Matrix Multiply-Accumulate (MMA) machine intrinsic instruction. Layout information can be explicit or opaque, however all such attributes must specify the static shape of the operation and the required element types.