From 6a898dc9b3cf2038ae0e13ae00ae8246752d17c1 Mon Sep 17 00:00:00 2001 From: Jakub Kuderski Date: Mon, 11 Nov 2024 15:18:26 -0500 Subject: [PATCH] [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. Signed-off-by: Giacomo Serafini <179146510+giacs-epic@users.noreply.github.com> --- .../c/iree/compiler/dialects/iree_gpu.h | 42 ++++++-- .../python/IREECompilerDialectsModule.cpp | 96 +++++++++++++------ .../bindings/python/test/ir/dialects_test.py | 45 +++++++++ .../API/Internal/IREEGPUDialectCAPI.cpp | 94 ++++++++++++++---- compiler/src/iree/compiler/API/api_exports.c | 16 ++++ .../src/iree/compiler/API/api_exports.def | 8 ++ compiler/src/iree/compiler/API/api_exports.ld | 8 ++ .../iree/compiler/API/api_exports.macos.lst | 8 ++ .../Dialect/GPU/IR/IREEGPUInterfaces.td | 2 +- 9 files changed, 262 insertions(+), 57 deletions(-) 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.