ace1d0ad3d
While working on an integration, I found a lot of inconsistencies on IR printing and verification. It turns out that we were: * Only doing "soft fail" verification on IR printing of Operation, not of a Module. * Failed verification was interacting badly with binary=True IR printing (causing a TypeError trying to pass an `str` to a `bytes` based handle). * For systematic integrations, it is often desirable to control verification yourself so that you can explicitly handle errors. This patch: * Trues up the "soft fail" semantics by having `Module.__str__` delegate to `Operation.__str__` vs having a shortcut implementation. * Fixes soft fail in the presence of binary=True (and adds an additional happy path test case to make sure the binary functionality works). * Adds an `assume_verified` boolean flag to the `print`/`get_asm` methods which disables internal verification, presupposing that the caller has taken care of it. It turns out that we had a number of tests which were generating illegal IR but it wasn't being caught because they were doing a print on the `Module` vs operation. All except two were trivially fixed: * linalg/ops.py : Had two tests for direct constructing a Matmul incorrectly. Fixing them made them just like the next two tests so just deleted (no need to test the verifier only at this level). * linalg/opdsl/emit_structured_generic.py : Hand coded conv and pooling tests appear to be using illegal shaped inputs/outputs, causing a verification failure. I just used the `assume_verified=` flag to restore the original behavior and left a TODO. Will get someone who owns that to fix it properly in a followup (would also be nice to break this file up into multiple test modules as it is hard to tell exactly what is failing). Notes to downstreams: * If, like some of our tests, you get verification failures after this patch, it is likely that your IR was always invalid and you will need to fix the root cause. To temporarily revert to prior (broken) behavior, replace calls like `print(module)` with `print(module.operation.get_asm(assume_verified=True))`. Differential Revision: https://reviews.llvm.org/D114680
140 lines
3.7 KiB
Python
140 lines
3.7 KiB
Python
# RUN: %PYTHON %s | FileCheck %s
|
|
|
|
import gc
|
|
from mlir.ir import *
|
|
|
|
def run(f):
|
|
print("\nTEST:", f.__name__)
|
|
f()
|
|
gc.collect()
|
|
assert Context._get_live_count() == 0
|
|
return f
|
|
|
|
|
|
# Verify successful parse.
|
|
# CHECK-LABEL: TEST: testParseSuccess
|
|
# CHECK: module @successfulParse
|
|
@run
|
|
def testParseSuccess():
|
|
ctx = Context()
|
|
module = Module.parse(r"""module @successfulParse {}""", ctx)
|
|
assert module.context is ctx
|
|
print("CLEAR CONTEXT")
|
|
ctx = None # Ensure that module captures the context.
|
|
gc.collect()
|
|
module.dump() # Just outputs to stderr. Verifies that it functions.
|
|
print(str(module))
|
|
|
|
|
|
# Verify parse error.
|
|
# CHECK-LABEL: TEST: testParseError
|
|
# CHECK: testParseError: Unable to parse module assembly (see diagnostics)
|
|
@run
|
|
def testParseError():
|
|
ctx = Context()
|
|
try:
|
|
module = Module.parse(r"""}SYNTAX ERROR{""", ctx)
|
|
except ValueError as e:
|
|
print("testParseError:", e)
|
|
else:
|
|
print("Exception not produced")
|
|
|
|
|
|
# Verify successful parse.
|
|
# CHECK-LABEL: TEST: testCreateEmpty
|
|
# CHECK: module {
|
|
@run
|
|
def testCreateEmpty():
|
|
ctx = Context()
|
|
loc = Location.unknown(ctx)
|
|
module = Module.create(loc)
|
|
print("CLEAR CONTEXT")
|
|
ctx = None # Ensure that module captures the context.
|
|
gc.collect()
|
|
print(str(module))
|
|
|
|
|
|
# Verify round-trip of ASM that contains unicode.
|
|
# Note that this does not test that the print path converts unicode properly
|
|
# because MLIR asm always normalizes it to the hex encoding.
|
|
# CHECK-LABEL: TEST: testRoundtripUnicode
|
|
# CHECK: func private @roundtripUnicode()
|
|
# CHECK: foo = "\F0\9F\98\8A"
|
|
@run
|
|
def testRoundtripUnicode():
|
|
ctx = Context()
|
|
module = Module.parse(r"""
|
|
func private @roundtripUnicode() attributes { foo = "😊" }
|
|
""", ctx)
|
|
print(str(module))
|
|
|
|
|
|
# Verify round-trip of ASM that contains unicode.
|
|
# Note that this does not test that the print path converts unicode properly
|
|
# because MLIR asm always normalizes it to the hex encoding.
|
|
# CHECK-LABEL: TEST: testRoundtripBinary
|
|
# CHECK: func private @roundtripUnicode()
|
|
# CHECK: foo = "\F0\9F\98\8A"
|
|
@run
|
|
def testRoundtripBinary():
|
|
with Context():
|
|
module = Module.parse(r"""
|
|
func private @roundtripUnicode() attributes { foo = "😊" }
|
|
""")
|
|
binary_asm = module.operation.get_asm(binary=True)
|
|
assert isinstance(binary_asm, bytes)
|
|
module = Module.parse(binary_asm)
|
|
print(module)
|
|
|
|
|
|
# Tests that module.operation works and correctly interns instances.
|
|
# CHECK-LABEL: TEST: testModuleOperation
|
|
@run
|
|
def testModuleOperation():
|
|
ctx = Context()
|
|
module = Module.parse(r"""module @successfulParse {}""", ctx)
|
|
assert ctx._get_live_module_count() == 1
|
|
op1 = module.operation
|
|
assert ctx._get_live_operation_count() == 1
|
|
# CHECK: module @successfulParse
|
|
print(op1)
|
|
|
|
# Ensure that operations are the same on multiple calls.
|
|
op2 = module.operation
|
|
assert ctx._get_live_operation_count() == 1
|
|
assert op1 is op2
|
|
|
|
# Ensure that if module is de-referenced, the operations are still valid.
|
|
module = None
|
|
gc.collect()
|
|
print(op1)
|
|
|
|
# Collect and verify lifetime.
|
|
op1 = None
|
|
op2 = None
|
|
gc.collect()
|
|
print("LIVE OPERATIONS:", ctx._get_live_operation_count())
|
|
assert ctx._get_live_operation_count() == 0
|
|
assert ctx._get_live_module_count() == 0
|
|
|
|
|
|
# CHECK-LABEL: TEST: testModuleCapsule
|
|
@run
|
|
def testModuleCapsule():
|
|
ctx = Context()
|
|
module = Module.parse(r"""module @successfulParse {}""", ctx)
|
|
assert ctx._get_live_module_count() == 1
|
|
# CHECK: "mlir.ir.Module._CAPIPtr"
|
|
module_capsule = module._CAPIPtr
|
|
print(module_capsule)
|
|
module_dup = Module._CAPICreate(module_capsule)
|
|
assert module is module_dup
|
|
assert module_dup.context is ctx
|
|
# Gc and verify destructed.
|
|
module = None
|
|
module_capsule = None
|
|
module_dup = None
|
|
gc.collect()
|
|
assert ctx._get_live_module_count() == 0
|
|
|