92233062c1
This PR implements python enum bindings for *all* the enums - this includes `I*Attrs` (including positional/bit) and `Dialect/EnumAttr`.
There are a few parts to this:
1. CMake: a small addition to `declare_mlir_dialect_python_bindings` and `declare_mlir_dialect_extension_python_bindings` to generate the enum, a boolean arg `GEN_ENUM_BINDINGS` to make it opt-in (even though it works for basically all of the dialects), and an optional `GEN_ENUM_BINDINGS_TD_FILE` for handling corner cases.
2. EnumPythonBindingGen.cpp: there are two weedy aspects here that took investigation:
1. If an enum attribute is not a `Dialect/EnumAttr` then the `EnumAttrInfo` record is canonical, as far as both the cases of the enum **and the `AttrDefName`**. On the otherhand, if an enum is a `Dialect/EnumAttr` then the `EnumAttr` record has the correct `AttrDefName` ("load bearing", i.e., populates `ods.ir.AttributeBuilder('<NAME>')`) but its `enum` field contains the cases, which is an instance of `EnumAttrInfo`. The solution is to generate an one enum class for both `Dialect/EnumAttr` and "independent" `EnumAttrInfo` but to make that class interopable with two builder registrations that both do the right thing (see next sub-bullet).
2. Because we don't have a good connection to cpp `EnumAttr`, i.e., only the `enum class` getters are exposed (like `DimensionAttr::get(Dimension value)`), we have to resort to parsing e.g., `Attribute.parse(f'#gpu<dim {x}>')`. This means that the set of supported `assemblyFormat`s (for the enum) is fixed at compile of MLIR (currently 2, the only 2 I saw). There might be some things that could be done here but they would require quite a bit more C API work to support generically (e.g., casting ints to enum cases and binding all the getters or going generically through the `symbolize*` methods, like `symbolizeDimension(uint32_t)` or `symbolizeDimension(StringRef)`).
A few small changes:
1. In addition, since this patch registers default builders for attributes where people might've had their own builders already written, I added a `replace` param to `AttributeBuilder.insert` (`False` by default).
2. `makePythonEnumCaseName` can't handle all the different ways in which people write their enum cases, e.g., `llvm.CConv.Intel_OCL_BI`, which gets turned into `INTEL_O_C_L_B_I` (because `llvm::convertToSnakeFromCamelCase` doesn't look for runs of caps). So I dropped it. On the otherhand regularization does need to done because some enums have `None` as a case (and others might have other python keywords).
3. I turned on `llvm` dialect generation here in order to test `nvvm.WGMMAScaleIn`, which is an enum with [[ d7e26b5620/mlir/include/mlir/IR/EnumAttr.td (L22-L25) | no explicit discriminator ]] for the `neg` case.
Note, dialects that didn't get a `GEN_ENUM_BINDINGS` don't have any enums to generate.
Let me know if I should add more tests (the three trivial ones I added exercise both the supported `assemblyFormat`s and `replace=True`).
Reviewed By: stellaraccident
Differential Revision: https://reviews.llvm.org/D157934
85 lines
2.7 KiB
Python
85 lines
2.7 KiB
Python
# RUN: %PYTHON %s | FileCheck %s
|
|
|
|
from mlir.ir import *
|
|
import mlir.dialects.builtin as builtin
|
|
import mlir.dialects.func as func
|
|
import mlir.dialects.vector as vector
|
|
|
|
|
|
def run(f):
|
|
print("\nTEST:", f.__name__)
|
|
with Context(), Location.unknown():
|
|
f()
|
|
return f
|
|
|
|
|
|
# CHECK-LABEL: TEST: testPrintOp
|
|
@run
|
|
def testPrintOp():
|
|
module = Module.create()
|
|
with InsertionPoint(module.body):
|
|
|
|
@func.FuncOp.from_py_func(VectorType.get((12, 5), F32Type.get()))
|
|
def print_vector(arg):
|
|
return vector.PrintOp(source=arg)
|
|
|
|
# CHECK-LABEL: func @print_vector(
|
|
# CHECK-SAME: %[[ARG:.*]]: vector<12x5xf32>) {
|
|
# CHECK: vector.print %[[ARG]] : vector<12x5xf32>
|
|
# CHECK: return
|
|
# CHECK: }
|
|
print(module)
|
|
|
|
|
|
# CHECK-LABEL: TEST: testTransferReadOp
|
|
@run
|
|
def testTransferReadOp():
|
|
module = Module.create()
|
|
with InsertionPoint(module.body):
|
|
vector_type = VectorType.get([2, 3], F32Type.get())
|
|
memref_type = MemRefType.get(
|
|
[ShapedType.get_dynamic_size(), ShapedType.get_dynamic_size()],
|
|
F32Type.get(),
|
|
)
|
|
index_type = IndexType.get()
|
|
mask_type = VectorType.get(vector_type.shape, IntegerType.get_signless(1))
|
|
identity_map = AffineMap.get_identity(vector_type.rank)
|
|
identity_map_attr = AffineMapAttr.get(identity_map)
|
|
f = func.FuncOp(
|
|
"transfer_read", ([memref_type, index_type, F32Type.get(), mask_type], [])
|
|
)
|
|
with InsertionPoint(f.add_entry_block()):
|
|
A, zero, padding, mask = f.arguments
|
|
vector.TransferReadOp(
|
|
vector_type, A, [zero, zero], identity_map_attr, padding, mask=mask
|
|
)
|
|
vector.TransferReadOp(
|
|
vector_type, A, [zero, zero], identity_map_attr, padding
|
|
)
|
|
func.ReturnOp([])
|
|
|
|
# CHECK: @transfer_read(%[[MEM:.*]]: memref<?x?xf32>, %[[IDX:.*]]: index,
|
|
# CHECK: %[[PAD:.*]]: f32, %[[MASK:.*]]: vector<2x3xi1>)
|
|
# CHECK: vector.transfer_read %[[MEM]][%[[IDX]], %[[IDX]]], %[[PAD]], %[[MASK]]
|
|
# CHECK: vector.transfer_read %[[MEM]][%[[IDX]], %[[IDX]]], %[[PAD]]
|
|
# CHECK-NOT: %[[MASK]]
|
|
print(module)
|
|
|
|
|
|
# CHECK-LABEL: TEST: testBitEnumCombiningKind
|
|
@run
|
|
def testBitEnumCombiningKind():
|
|
module = Module.create()
|
|
with InsertionPoint(module.body):
|
|
f32 = F32Type.get()
|
|
vector_type = VectorType.get([16], f32)
|
|
|
|
@func.FuncOp.from_py_func(vector_type)
|
|
def reduction(arg):
|
|
v = vector.ReductionOp(f32, vector.CombiningKind.ADD, arg)
|
|
return v
|
|
|
|
# CHECK: func.func @reduction(%[[VEC:.*]]: vector<16xf32>) -> f32 {
|
|
# CHECK: %0 = vector.reduction <add>, %[[VEC]] : vector<16xf32> into f32
|
|
print(module)
|