diff --git a/compiler/bindings/c/iree/compiler/dialects/iree_gpu.h b/compiler/bindings/c/iree/compiler/dialects/iree_gpu.h index e9115b13dcff6..7a596fef70684 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 @@ ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr(MlirAttribute attr); 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 @@ ireeGPUPipelineOptionsAttrGetReorderWorkgroupsStrategy(MlirAttribute attr); 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 0e463fd75c19f..d24075a8e9e5b 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 #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 @@ PYBIND11_MODULE(_ireeCompilerDialects, m) { // GPUReorderWorkgroupsStrategyAttr //===-------------------------------------------------------------------===// - auto strategyEnum = - py::enum_( - 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 @@ PYBIND11_MODULE(_ireeCompilerDialects, m) { 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 a69a0357fbb1c..e1b4121be8fcb 100644 --- a/compiler/bindings/python/test/ir/dialects_test.py +++ b/compiler/bindings/python/test/ir/dialects_test.py @@ -18,6 +18,8 @@ def gpu_pipeline_options_attr(): 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 @@ def gpu_pipeline_options_attr(): # 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" + ) + + 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 821845e73e8c3..15f517e7a0f78 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 +#include #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 @@ MlirTypeID ireeGPUPipelineOptionsAttrGetTypeID() { mlir::iree_compiler::IREE::GPU::GPUPipelineOptionsAttr::getTypeID()); } -static_assert( - static_cast(ireeGPUReorderWorkgroupsStrategyEnumNone) == - static_cast(mlir::iree_compiler::IREE::GPU:: - ReorderWorkgroupsStrategy::None) && - static_cast(ireeGPUReorderWorkgroupsStrategyEnumTranspose) == - static_cast(mlir::iree_compiler::IREE::GPU:: - ReorderWorkgroupsStrategy::Transpose) && - static_cast(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 @@ MlirTypeID ireeGPUReorderWorkgroupsStrategyAttrGetTypeID() { 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 @@ MlirAttribute ireeGPUReorderWorkgroupsStrategyAttrGet( value))); } -ireeGPUReorderWorkgroupsStrategyEnum -ireeGPUReorderWorkgroupsStrategyAttrGetValue(MlirAttribute attr) { +uint32_t ireeGPUReorderWorkgroupsStrategyAttrGetValue(MlirAttribute attr) { assert(ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr(attr) && "attr is not a GPUReorderWorkgroupsStrategyAttr"); - return static_cast( + return static_cast( llvm::cast( unwrap(attr)) .getValue()); } + +bool ireeAttributeIsAGPUMMAIntrinsicAttr(MlirAttribute attr) { + return llvm::isa( + unwrap(attr)); +} + +MlirTypeID ireeGPUMMAIntrinsicAttrGetTypeID() { + return wrap(mlir::iree_compiler::IREE::GPU::MMAIntrinsicAttr::getTypeID()); +} + +static_assert( + std::is_same_v>, + "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(value))); +} + +uint32_t ireeGPUMMAIntrinsicAttrGetValue(MlirAttribute attr) { + assert(ireeAttributeIsAGPUMMAIntrinsicAttr(attr) && + "attr is not a GPUMMAIntrinsicAttr"); + return static_cast( + llvm::cast(unwrap(attr)) + .getValue()); +} + +bool ireeAttributeIsAGPUMMAAttr(MlirAttribute attr) { + return llvm::isa(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(value))); +} + +ireeGPUMMAInfo ireeGPUMMAAttrGetInfo(MlirAttribute attr) { + assert(ireeAttributeIsAGPUMMAAttr(attr) && "attr is not a MMAAttr"); + auto mma = llvm::cast(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 dcb315c3ce73d..664bab403a68f 100644 --- a/compiler/src/iree/compiler/API/api_exports.c +++ b/compiler/src/iree/compiler/API/api_exports.c @@ -10,6 +10,8 @@ #include +extern void ireeAttributeIsAGPUMMAAttr(); +extern void ireeAttributeIsAGPUMMAIntrinsicAttr(); extern void ireeAttributeIsAGPUPipelineOptionsAttr(); extern void ireeAttributeIsAGPUReorderWorkgroupsStrategyAttr(); extern void ireeCompilerEnumeratePlugins(); @@ -63,6 +65,12 @@ extern void ireeCompilerSourceDestroy(); 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 @@ extern void mlirVectorTypeIsScalable(); 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 @@ uintptr_t __iree_compiler_hidden_force_extern() { 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 13ad7abc26116..4d2fb0d306e42 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 @@ EXPORTS 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 4ff25663c3771..cd3f967d5c828 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 @@ VER_0 { 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 871ca80576715..1ac458854058d 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 @@ _ireeCompilerSourceDestroy _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 2c9f828bc4125..639737a570158 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 @@ def IREEGPU_MmaInterfaceAttr : AttrInterface<"MmaInterfaceAttr"> { 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.