707 lines · python
1# RUN: %PYTHON %s | FileCheck %s2 3import functools4from typing import Callable5 6from mlir.ir import *7from mlir.dialects import transform8from mlir.dialects import pdl9from mlir.dialects.transform import structured10from mlir.dialects.transform import pdl as transform_pdl11from mlir.dialects.transform.extras import constant_param12 13 14def run(f):15 with Context(), Location.unknown():16 module = Module.create()17 with InsertionPoint(module.body):18 print("\nTEST:", f.__name__)19 f()20 module.operation.verify()21 print(module)22 return f23 24 25def create_sequence(func: Callable) -> Callable:26 @functools.wraps(func)27 def decorated() -> None:28 sequence = transform.SequenceOp(29 transform.FailurePropagationMode.Propagate,30 [],31 transform.AnyOpType.get(),32 )33 with InsertionPoint(sequence.body):34 func(sequence.bodyTarget)35 transform.YieldOp()36 37 return decorated38 39 40@run41@create_sequence42def testBufferizeToAllocationOpCompact(target):43 structured.BufferizeToAllocationOp(target)44 # CHECK-LABEL: TEST: testBufferizeToAllocationOpCompact45 # CHECK: transform.sequence46 # CHECK: transform.structured.bufferize_to_allocation47 48 49@run50@create_sequence51def testBufferizeToAllocationOpArgs(target):52 structured.BufferizeToAllocationOp(53 target,54 memory_space=3,55 memcpy_op="memref.copy",56 alloc_op="memref.alloca",57 bufferize_destination_only=True,58 )59 # CHECK-LABEL: TEST: testBufferizeToAllocationOpArgs60 # CHECK: transform.sequence61 # CHECK: transform.structured.bufferize_to_allocation62 # CHECK-SAME: alloc_op = "memref.alloca"63 # CHECK-SAME: bufferize_destination_only64 # CHECK-SAME: memcpy_op = "memref.copy"65 # CHECK-SAME: memory_space = 366 67 68@run69@create_sequence70def testDecompose(target):71 structured.DecomposeOp(target)72 # CHECK-LABEL: TEST: testDecompose73 # CHECK: transform.sequence74 # CHECK: transform.structured.decompose75 76 77@run78@create_sequence79def testFuseIntoContainingOpTypes(target):80 fused = structured.MatchOp.match_op_names(target, ["test.dummy"])81 containing = structured.MatchOp.match_op_names(target, ["test.dummy"])82 structured.FuseIntoContainingOp(83 transform.OperationType.get("test.dummy"),84 transform.OperationType.get("test.dummy"),85 fused,86 containing,87 )88 # CHECK-LABEL: TEST: testFuseIntoContainingOpTypes89 # CHECK: = transform.structured.fuse_into_containing_op90 # CHECK-SAME: (!transform.any_op, !transform.any_op) -> (!transform.op<"test.dummy">, !transform.op<"test.dummy">)91 92 93@run94@create_sequence95def testFuseIntoContainingOpCompact(target):96 fused = structured.MatchOp.match_op_names(target, ["test.dummy"])97 containing = structured.MatchOp.match_op_names(target, ["test.dummy"])98 structured.FuseIntoContainingOp(fused, containing)99 # CHECK-LABEL: TEST: testFuseIntoContainingOpCompact100 # CHECK: = transform.structured.fuse_into_containing_op101 # CHECK-SAME: (!transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op)102 103 104@run105@create_sequence106def testFuseOpCompact(target):107 structured.FuseOp(108 target, tile_sizes=[4, 8], tile_interchange=[0, 1], apply_cleanup=True109 )110 # CHECK-LABEL: TEST: testFuseOpCompact111 # CHECK: transform.sequence112 # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.fuse %{{.*}} tile_sizes [4, 8]113 # CHECK-SAME: interchange [0, 1] {apply_cleanup}114 # CHECK-SAME: (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op)115 116 117@run118@create_sequence119def testFuseOpCompactForall(target):120 structured.FuseOp(121 target,122 tile_sizes=[4, 8],123 apply_cleanup=True,124 use_forall=True,125 )126 # CHECK-LABEL: TEST: testFuseOpCompact127 # CHECK: transform.sequence128 # CHECK: %{{.+}}, %{{.+}} = transform.structured.fuse %{{.*}} tile_sizes [4, 8]129 # CHECK-SAME: {apply_cleanup, use_forall}130 # CHECK-SAME: (!transform.any_op) -> (!transform.any_op, !transform.any_op)131 132 133@run134@create_sequence135def testFuseOpNoArg(target):136 structured.FuseOp(target)137 # CHECK-LABEL: TEST: testFuseOpNoArg138 # CHECK: transform.sequence139 # CHECK: %{{.+}} = transform.structured.fuse %{{.*}} :140 # CHECK-SAME: (!transform.any_op) -> !transform.any_op141 142 143@run144@create_sequence145def testFuseOpParams(target):146 structured.FuseOp(147 target,148 tile_sizes=[constant_param(4), Attribute.parse("8")],149 tile_interchange=[constant_param(0), Attribute.parse("1")],150 )151 # CHECK-LABEL: TEST: testFuseOpParams152 # CHECK: transform.sequence153 # CHECK-DAG: %[[P:.*]] = transform.param.constant 4154 # CHECK-DAG: %[[I:.*]] = transform.param.constant 0155 # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.fuse156 # CHECK-SAME: tile_sizes [%[[P]], 8]157 # CHECK-SAME: interchange [%[[I]], 1]158 # CHECK-SAME: (!transform.any_op, !transform.param<i64>, !transform.param<i64>) -> (!transform.any_op, !transform.any_op, !transform.any_op)159 160 161@run162@create_sequence163def testFuseOpHandles(target):164 size1 = structured.MatchOp.match_op_names(target, ["arith.constant"])165 ichange1 = structured.MatchOp.match_op_names(target, ["arith.constant"])166 structured.FuseOp(167 target,168 tile_sizes=[size1, 8],169 tile_interchange=[ichange1, 1],170 )171 # CHECK-LABEL: TEST: testFuseOpHandles172 # CHECK: transform.sequence173 # CHECK: %[[H:.*]] = transform.structured.match174 # CHECK: %[[I:.*]] = transform.structured.match175 # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.fuse176 # CHECK-SAME: tile_sizes [%[[H]], 8]177 # CHECK-SAME: interchange [%[[I]], 1]178 # CHECK-SAME: (!transform.any_op, !transform.any_op, !transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op)179 180 181@run182@create_sequence183def testFuseOpAttributes(target):184 attr = DenseI64ArrayAttr.get([4, 8])185 ichange = DenseI64ArrayAttr.get([0, 1])186 structured.FuseOp(target, tile_sizes=attr, tile_interchange=ichange)187 # CHECK-LABEL: TEST: testFuseOpAttributes188 # CHECK: transform.sequence189 # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.fuse %{{.*}} tile_sizes [4, 8]190 # CHECK-SAME: interchange [0, 1]191 # CHECK-SAME: (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op)192 193 194@run195@create_sequence196def testGeneralize(target):197 structured.GeneralizeOp(target)198 # CHECK-LABEL: TEST: testGeneralize199 # CHECK: transform.sequence200 # CHECK: transform.structured.generalize201 202 203@run204@create_sequence205def testInterchange(target):206 structured.InterchangeOp(target, iterator_interchange=[1, 0])207 # CHECK-LABEL: TEST: testInterchange208 # CHECK: transform.sequence209 # CHECK: transform.structured.interchange210 # CHECK: iterator_interchange = [1, 0]211 212 213@run214@create_sequence215def testMapCopyToThreadsOpCompact(target):216 structured.MapCopyToThreadsOp(217 target, total_num_threads=32, desired_bit_alignment=128218 )219 # CHECK-LABEL: TEST: testMapCopyToThreadsOpCompact220 # CHECK: = transform.structured.gpu.map_copy_to_threads221 # CHECK-SAME: total_num_threads = 32222 # CHECK-SAME: desired_bit_alignment = 128223 # CHECK-SAME: (!transform.any_op) -> (!transform.any_op, !transform.any_op)224 225 226@run227@create_sequence228def testMapCopyToThreadsOpTypes(target):229 structured.MapCopyToThreadsOp(230 transform.OperationType.get("test.opA"),231 transform.OperationType.get("test.opB"),232 target,233 total_num_threads=32,234 desired_bit_alignment=128,235 )236 # CHECK-LABEL: TEST: testMapCopyToThreadsOpTypes237 # CHECK: = transform.structured.gpu.map_copy_to_threads238 # CHECK-SAME: total_num_threads = 32239 # CHECK-SAME: desired_bit_alignment = 128240 # CHECK-SAME: (!transform.any_op) -> (!transform.op<"test.opA">, !transform.op<"test.opB">)241 242 243@run244@create_sequence245def testMatchOpNamesString(target):246 structured.MatchOp.match_op_names(target, "test.dummy")247 # CHECK-LABEL: TEST: testMatchOpNamesString248 # CHECK: transform.structured.match ops249 # CHECK-SAME: ["test.dummy"]250 # CHECK-SAME: (!transform.any_op) -> !transform.any_op251 252 253@run254@create_sequence255def testMatchOpNamesList(target):256 structured.MatchOp.match_op_names(target, ["test.dummy"])257 # CHECK-LABEL: TEST: testMatchOpNamesList258 # CHECK: transform.structured.match ops259 # CHECK-SAME: ["test.dummy"]260 # CHECK-SAME: (!transform.any_op) -> !transform.any_op261 262 263@run264@create_sequence265def testVectorizeNoArgs(target):266 structured.VectorizeOp(target)267 # CHECK-LABEL: TEST: testVectorizeNoArgs268 # CHECK: transform.sequence269 # CHECK: transform.structured.vectorize270 # CHECK-NOT: vector_sizes271 272 273@run274@create_sequence275def testVectorizeStatic(target):276 structured.VectorizeOp(target, [16, 4])277 # CHECK-LABEL: TEST: testVectorizeStatic278 # CHECK: transform.sequence279 # CHECK: transform.structured.vectorize280 # CHECK-SAME: vector_sizes [16, 4]281 282 283@run284@create_sequence285def testVectorizeArray(target):286 sizes = Attribute.parse("[16, 4]")287 structured.VectorizeOp(target, sizes)288 # CHECK-LABEL: TEST: testVectorizeArray289 # CHECK: transform.sequence290 # CHECK: transform.structured.vectorize291 # CHECK-SAME: vector_sizes [16, 4]292 293 294@run295@create_sequence296def testVectorizeMixed(target):297 sz1 = structured.MatchOp.match_op_names(target, ["arith.constant"])298 sz2 = Attribute.parse("4")299 structured.VectorizeOp(target, [sz1, sz2])300 # CHECK-LABEL: TEST: testVectorizeMixed301 # CHECK: transform.sequence302 # CHECK: %[[V0:.*]] = transform.structured.match303 # CHECK: transform.structured.vectorize304 # CHECK-SAME: vector_sizes [%[[V0]], 4]305 306 307@run308@create_sequence309def testVectorizeEmpty(target):310 structured.VectorizeOp(target, [])311 # CHECK-LABEL: TEST: testVectorizeEmpty312 # CHECK: transform.sequence313 # CHECK: transform.structured.vectorize314 # CHECK-NOT: vector_sizes315 316 317@run318@create_sequence319def testVectorizeScalable(target):320 sz1 = structured.MatchOp.match_op_names(target, ["arith.constant"])321 sz2 = Attribute.parse("4")322 structured.VectorizeOp(target, [16, [sz1], [sz2], [8]])323 # CHECK-LABEL: TEST: testVectorizeScalable324 # CHECK: transform.sequence325 # CHECK-DAG: %[[V0:.*]] = transform.structured.match326 # CHECK-DAG: transform.structured.vectorize327 # CHECK-SAME: vector_sizes [16, [%[[V0]]], [4], [8]]328 329 330@run331@create_sequence332def testVectorizeArgs(target):333 structured.VectorizeOp(target, [16, 4], vectorize_nd_extract=True)334 # CHECK-LABEL: TEST: testVectorizeArgs335 # CHECK: transform.sequence336 # CHECK: transform.structured.vectorize337 # CHECK-SAME: vectorize_nd_extract338 339 340@run341@create_sequence342def testMatchOpNamesTyped(target):343 structured.MatchOp.match_op_names(344 transform.OperationType.get("test.dummy"),345 target,346 ["test.dummy"],347 )348 # CHECK-LABEL: TEST: testMatchOpNamesTyped349 # CHECK: transform.structured.match ops350 # CHECK-SAME: ["test.dummy"]351 # CHECK-SAME: (!transform.any_op) -> !transform.op<"test.dummy">352 353 354@run355@create_sequence356def testMultitileSizesCompact(target):357 structured.MultiTileSizesOp(358 transform.AnyOpType.get(), target, dimension=1, target_size=42359 )360 # CHECK-LABEL: TEST: testMultitileSizes361 # CHECK: transform.sequence362 # CHECK-NOT: divisor363 # CHECK: transform.structured.multitile_sizes364 # CHECK-NOT: divisor365 # CHECK-DAG: dimension = 1366 # CHECK-NOT: divisor367 # CHECK-DAG: target_size = 42368 # CHECK-NOT: divisor369 370 371@run372@create_sequence373def testMultitileSizesAllArgs(target):374 structured.MultiTileSizesOp(375 transform.AnyOpType.get(),376 target,377 dimension=1,378 target_size=42,379 divisor=2,380 )381 # CHECK-LABEL: TEST: testMultitileSizes382 # CHECK: transform.sequence383 # CHECK: transform.structured.multitile_sizes384 # CHECK-DAG: dimension = 1385 # CHECK-DAG: divisor = 2386 # CHECK-DAG: target_size = 42387 388 389@run390@create_sequence391def testPadOpNoArgs(target):392 structured.PadOp(target)393 # CHECK-LABEL: TEST: testPadOpNoArgs394 # CHECK: transform.sequence395 # CHECK: transform.structured.pad396 # CHECK-NOT: copy_back_op397 # CHECK-NOT: nofold_flags398 # CHECK-NOT: pad_to_multiple_of399 # CHECK-NOT: padding_dimensions400 # CHECK-NOT: padding_values401 # CHECK-NOT: transpose_paddings402 403 404@run405@create_sequence406def testPadOpArgs(target):407 structured.PadOp(408 target,409 pad_to_multiple_of=[128],410 padding_values=[FloatAttr.get_f32(42.0), StringAttr.get("0")],411 padding_dimensions=Attribute.parse("[1]"),412 nofold_flags=[0],413 transpose_paddings=[[1, Attribute.parse("0")], Attribute.parse("[0, 1]")],414 copy_back_op="linalg.copy",415 )416 # CHECK-LABEL: TEST: testPadOpArgs417 # CHECK: transform.sequence418 # CHECK: transform.structured.pad419 # CHECK-DAG: pad_to_multiple_of [128]420 # CHECK-DAG: copy_back_op = "linalg.copy"421 # CHECK-DAG: nofold_flags = [0]422 # CHECK-DAG: padding_dimensions = [1]423 # CHECK-DAG: padding_values = [4.200000e+01 : f32, "0"]424 # CHECK-DAG: transpose_paddings = {{\[}}[1, 0], [0, 1]]425 426 427@run428@create_sequence429def testPadOpArgsParam(target):430 structured.PadOp(431 target,432 pad_to_multiple_of=[constant_param(128), Attribute.parse("2"), 10],433 padding_dimensions=Attribute.parse("[0, 1, 2]"),434 )435 # CHECK-LABEL: TEST: testPadOpArgsParam436 # CHECK: transform.sequence437 # CHECK-DAG: %[[P:.*]] = transform.param.constant 128438 # CHECK: transform.structured.pad439 # CHECK-DAG: pad_to_multiple_of [%[[P]], 2, 10]440 # CHECK-DAG: padding_dimensions = [0, 1, 2]441 442 443@run444@create_sequence445def testScalarize(target):446 structured.ScalarizeOp(target)447 # CHECK-LABEL: TEST: testScalarize448 # CHECK: transform.structured.scalarize449 450 451@run452@create_sequence453def testSplit(target):454 handle = structured.SplitOp(target, dimension=1, chunk_sizes=42)455 split = transform.SplitHandleOp(456 [transform.AnyOpType.get(), transform.AnyOpType.get()], handle457 )458 structured.SplitOp(split.results[0], dimension=3, chunk_sizes=split.results[1])459 # CHECK-LABEL: TEST: testSplit460 # CHECK: %[[G:.+]] = transform.structured.split %{{.*}} after 42 {dimension = 1461 # CHECK: %[[F:.+]]:2 = split_handle %[[G]]462 # CHECK: transform.structured.split %[[F]]#0 after %[[F]]#1 {dimension = 3463 464 465@run466@create_sequence467def testTileCompact(target):468 structured.TileUsingForOp(target, sizes=[4, 8], interchange=[0, 1])469 # CHECK-LABEL: TEST: testTileCompact470 # CHECK: transform.sequence471 # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile_using_for %{{.*}}[4, 8]472 # CHECK: interchange = [0, 1]473 474 475@run476@create_sequence477def testTileAttributes(target):478 attr = DenseI64ArrayAttr.get([4, 8])479 ichange = DenseI64ArrayAttr.get([0, 1])480 structured.TileUsingForOp(target, sizes=attr, interchange=ichange)481 # CHECK-LABEL: TEST: testTileAttributes482 # CHECK: transform.sequence483 # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile_using_for %{{.*}}[4, 8]484 # CHECK: interchange = [0, 1]485 486 487@run488@create_sequence489def testTileZero(target):490 structured.TileUsingForOp(target, sizes=[4, 0, 2, 0], interchange=[0, 1, 2, 3])491 # CHECK-LABEL: TEST: testTileZero492 # CHECK: transform.sequence493 # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile_using_for %{{.*}}[4, 0, 2, 0]494 # CHECK: interchange = [0, 1, 2, 3]495 496 497@run498def testTileDynamic():499 with_pdl = transform_pdl.WithPDLPatternsOp(pdl.OperationType.get())500 with InsertionPoint(with_pdl.body):501 sequence = transform.SequenceOp(502 transform.FailurePropagationMode.Propagate, [], with_pdl.bodyTarget503 )504 with InsertionPoint(sequence.body):505 m1 = transform_pdl.PDLMatchOp(506 pdl.OperationType.get(), sequence.bodyTarget, "first"507 )508 m2 = transform_pdl.PDLMatchOp(509 pdl.OperationType.get(), sequence.bodyTarget, "second"510 )511 structured.TileUsingForOp(sequence.bodyTarget, sizes=[m1, 3, m2, 0])512 transform.YieldOp()513 # CHECK-LABEL: TEST: testTileDynamic514 # CHECK: %[[FIRST:.+]] = pdl_match515 # CHECK: %[[SECOND:.+]] = pdl_match516 # CHECK: %{{.+}}, %{{.+}}:3 = transform.structured.tile_using_for %{{.*}}[%[[FIRST]], 3, %[[SECOND]], 0]517 518 519@run520@create_sequence521def testTileExplicitLoopTypeSingle(target):522 structured.TileUsingForOp(523 transform.OperationType.get("scf.for"), target, sizes=[2, 3, 4]524 )525 # CHECK-LABEL: TEST: testTileExplicitLoopTypeSingle526 # CHECK: = transform.structured.tile_using_for %{{.*}} : (!{{.*}}) ->527 # CHECK-COUNT-3: !transform.op<"scf.for">528 529 530@run531@create_sequence532def testTileExplicitLoopTypeAll(target):533 types = [534 transform.OperationType.get(x)535 for x in ["scf.for", "scf.parallel", "scf.forall"]536 ]537 structured.TileUsingForOp(types, target, sizes=[2, 3, 4])538 # CHECK-LABEL: TEST: testTileExplicitLoopTypeAll539 # CHECK: = transform.structured.tile540 # CHECK-SAME: (!transform.any_op) -> (!transform.any_op, !transform.op<"scf.for">,541 # CHECK-SAME: !transform.op<"scf.parallel">, !transform.op<"scf.forall">542 543 544@run545@create_sequence546def testTileScalable(target):547 structured.TileUsingForOp(548 target,549 sizes=[4, [2]],550 )551 # CHECK-LABEL: TEST: testTileScalable552 # CHECK: transform.sequence553 # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile_using_for %{{.*}}[4, [2]]554 555 556@run557@create_sequence558def testTileToForallCompact(target):559 matmul = transform.CastOp(transform.OperationType.get("linalg.matmul"), target)560 structured.TileUsingForallOp(matmul, num_threads=[2, 3, 4])561 # CHECK-LABEL: TEST: testTileToForallCompact562 # CHECK: = transform.structured.tile_using_forall563 # CHECK-SAME: num_threads [2, 3, 4]564 # CHECK-SAME: (!transform.op<"linalg.matmul">) -> (!transform.any_op, !transform.any_op)565 566 567@run568@create_sequence569def testTileToForallLoopsAndTileOpTypes(target):570 structured.TileUsingForallOp(571 transform.OperationType.get("scf.forall"), # loops_type572 transform.OperationType.get("linalg.matmul"), # tiled_op_type573 target,574 num_threads=[2, 3, 4],575 )576 # CHECK-LABEL: TEST: testTileToForallLoopsAndTileOpTypes577 # CHECK: = transform.structured.tile_using_forall578 # CHECK-SAME: num_threads [2, 3, 4]579 # CHECK-SAME: (!transform.any_op) -> (!transform.op<"scf.forall">, !transform.op<"linalg.matmul">)580 581 582@run583@create_sequence584def testTileToForallTileSizes(target):585 structured.TileUsingForallOp(target, tile_sizes=[2, 3, 4])586 # CHECK-LABEL: TEST: testTileToForallTileSizes587 # CHECK: = transform.structured.tile_using_forall588 # CHECK-SAME: tile_sizes [2, 3, 4]589 590 591@run592@create_sequence593def testTileToForallMixedDynamic(target):594 n = structured.MatchOp.match_op_names(target, ["test.dummy"])595 structured.TileUsingForallOp(target, num_threads=[n, 3, 4])596 # CHECK-LABEL: TEST: testTileToForallMixedDynamic597 # CHECK: = transform.structured.tile_using_forall598 # CHECK-SAME: num_threads [%{{.*}}, 3, 4] : (!transform.any_op, !transform.any_op)599 600 601@run602@create_sequence603def testTileToForallPackedDynamic(target):604 n = structured.MatchOp.match_op_names(target, ["test.dummy"])605 structured.TileUsingForallOp(target, num_threads=n)606 # CHECK-LABEL: TEST: testTileToForallPackedDynamic607 # CHECK: = transform.structured.tile_using_forall608 # CHECK-SAME: num_threads *(%0) : (!transform.any_op, !transform.any_op)609 610 611@run612@create_sequence613def testTileToForallMapping(target):614 mapping = Attribute.parse("[ #gpu.thread<y>, #gpu.thread<x> ]")615 structured.TileUsingForallOp(target, num_threads=[2, 3], mapping=mapping)616 # CHECK-LABEL: TEST: testTileToForallMapping617 # CHECK: = transform.structured.tile_using_forall618 # CHECK-SAME: mapping = [#gpu.thread<y>, #gpu.thread<x>]619 620 621@run622@create_sequence623def testVectorizeChildrenAndApplyPatternsAllAttrs(target):624 structured.VectorizeChildrenAndApplyPatternsOp(625 target,626 disable_multi_reduction_to_contract_patterns=True,627 disable_transfer_permutation_map_lowering_patterns=True,628 vectorize_nd_extract=True,629 vectorize_padding=True,630 flatten_1d_depthwise_conv=True,631 fold_type_extensions_into_contract=True,632 )633 # CHECK-LABEL: TEST: testVectorizeChildrenAndApplyPatternsAllAttrs634 # CHECK: transform.sequence635 # CHECK: = transform.structured.vectorize636 # CHECK-SAME: disable_multi_reduction_to_contract_patterns637 # CHECK-SAME: disable_transfer_permutation_map_lowering_patterns638 # CHECK-SAME: flatten_1d_depthwise_conv639 # CHECK-SAME: fold_type_extensions_into_contract640 # CHECK-SAME: vectorize_nd_extract641 # CHECK-SAME: vectorize_padding642 643 644@run645@create_sequence646def testVectorizeChildrenAndApplyPatternsNoAttrs(target):647 structured.VectorizeChildrenAndApplyPatternsOp(648 target,649 disable_multi_reduction_to_contract_patterns=False,650 disable_transfer_permutation_map_lowering_patterns=False,651 vectorize_nd_extract=False,652 vectorize_padding=False,653 flatten_1d_depthwise_conv=False,654 fold_type_extensions_into_contract=False,655 )656 # CHECK-LABEL: TEST: testVectorizeChildrenAndApplyPatternsNoAttrs657 # CHECK: transform.sequence658 # CHECK: = transform.structured.vectorize659 # CHECK-NOT: disable_multi_reduction_to_contract_patterns660 # CHECK-NOT: disable_transfer_permutation_map_lowering_patterns661 # CHECK-NOT: flatten_1d_depthwise_conv662 # CHECK-NOT: fold_type_extensions_into_contract663 # CHECK-NOT: vectorize_nd_extract664 # CHECK-NOT: vectorize_padding665 666 667@run668@create_sequence669def testMatchInterfaceEnum(target):670 names = ArrayAttr.get([StringAttr.get("test.dummy")])671 result_type = transform.AnyOpType.get()672 fused = structured.MatchOp.__base__(673 result_type,674 target,675 ops=names,676 interface=structured.MatchInterfaceEnum.LinalgOp,677 )678 # CHECK-LABEL: TEST: testMatchInterfaceEnum679 # CHECK: transform.sequence680 # CHECK: = transform.structured.match681 # CHECK: interface{LinalgOp}682 683 684@run685@create_sequence686def testMatchInterfaceEnumReplaceAttributeBuilder(target):687 @register_attribute_builder("MatchInterfaceEnum", replace=True)688 def match_interface_enum(x, context):689 if x == "LinalgOp":690 y = 0691 elif x == "TilingInterface":692 y = 1693 return IntegerAttr.get(IntegerType.get_signless(32, context=context), y)694 695 names = ArrayAttr.get([StringAttr.get("test.dummy")])696 result_type = transform.AnyOpType.get()697 fused = structured.MatchOp.__base__(698 result_type,699 target,700 ops=names,701 interface="TilingInterface",702 )703 # CHECK-LABEL: TEST: testMatchInterfaceEnumReplaceAttributeBuilder704 # CHECK: transform.sequence705 # CHECK: = transform.structured.match706 # CHECK: interface{TilingInterface}707