This is an archive of the discontinued LLVM Phabricator instance.

Differential D114869

[mlir][linalg] Shorter prefixes in CodegenStrategy test (NFC).
AbandonedPublic

Authored by gysit on Dec 1 2021, 6:00 AM.

Details

Reviewers
nicolasvasilache
Summary

Shorten the test prefixes in the CodegenStrategy test.

Depends On D114868

Diff Detail

Event Timeline

gysit created this revision.Dec 1 2021, 6:00 AM
Herald added subscribers: sdasgup3, wenzhicui, wrengr and 21 others. · View Herald TranscriptDec 1 2021, 6:00 AM
gysit requested review of this revision.Dec 1 2021, 6:00 AM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptDec 1 2021, 6:00 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: limo1996, stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B136899: Diff 390994.Dec 1 2021, 6:26 AM
nicolasvasilache accepted this revision.Dec 6 2021, 2:43 AM
This revision is now accepted and ready to land.Dec 6 2021, 2:43 AM
gysit abandoned this revision.Dec 7 2021, 1:07 AM

As discussed offline, let`s abandon this revision until we have a better solution not relying on markers.

Revision Contents

PathSize
mlir/
test/
Dialect/
Linalg/
94 lines

Diff 390994

mlir/test/Dialect/Linalg/codegen-strategy.mlir

// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=2,4,8 vectorize vectorize-contraction-to=matrixintrinsics unroll-vector-transfers=true" -split-input-file | FileCheck %s --check-prefix=CHECK-INTRINSIC // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=2,4,8 vectorize vectorize-contraction-to=matrixintrinsics unroll-vector-transfers=true" -split-input-file | FileCheck %s --check-prefix=INTRINSIC
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=16,32,64 promote promote-full-tile-pad register-tile-sizes=2,4,8 vectorize vectorize-contraction-to=outerproduct split-transfers=true unroll-vector-transfers=false" -split-input-file | FileCheck %s --check-prefix=CHECK-OUTER // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=16,32,64 promote promote-full-tile-pad register-tile-sizes=2,4,8 vectorize vectorize-contraction-to=outerproduct split-transfers=true unroll-vector-transfers=false" -split-input-file | FileCheck %s --check-prefix=OUTER
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=16,32,64 tile-interchange=1,2,0 generalize iterator-interchange=0,2,1" -split-input-file | FileCheck %s --check-prefix=CHECK-TILE-AND-INTERCHANGE // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=16,32,64 tile-interchange=1,2,0 generalize iterator-interchange=0,2,1" -split-input-file | FileCheck %s --check-prefix=TILE-AND-INTERCHANGE
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=16,32,64 pad pack-paddings=1,1,0 hoist-paddings=3,3,0" -split-input-file | FileCheck %s --check-prefix=CHECK-PAD // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=16,32,64 pad pack-paddings=1,1,0 hoist-paddings=3,3,0" -split-input-file | FileCheck %s --check-prefix=PAD
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=16,32,64 fuse pad vectorize" -split-input-file | FileCheck %s --check-prefix=CHECK-FUSE // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul tile-sizes=16,32,64 fuse pad vectorize" -split-input-file | FileCheck %s --check-prefix=FUSE
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matvec generalize iterator-interchange=1,0" -split-input-file | FileCheck %s --check-prefix=CHECK-GENERALIZE // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matvec generalize iterator-interchange=1,0" -split-input-file | FileCheck %s --check-prefix=GENERALIZE-AND-INTERCHANGE
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matvec iterator-interchange=1,0 vectorize" -split-input-file | FileCheck %s --check-prefix=CHECK-INTERCHANGE-AND-VECTORIZE // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=matvec iterator-interchange=1,0 vectorize" -split-input-file | FileCheck %s --check-prefix=INTERCHANGE-AND-VECTORIZE
// RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=conv decompose generalize" -split-input-file | FileCheck %s --check-prefix=CHECK-DECOMPOSE-AND-GENERALIZE // RUN: mlir-opt %s -test-linalg-codegen-strategy="anchor-func=conv decompose generalize" -split-input-file | FileCheck %s --check-prefix=DECOMPOSE-AND-GENERALIZE
// CHECK-INTRINSIC: func @matmul( // INTRINSIC: func @matmul(
// CHECK-OUTER: func @matmul( // OUTER: func @matmul(
func @matmul(%arg0: memref<72x72xf32>, %arg1: memref<72x72xf32>, %arg2: memref<72x72xf32>) { func @matmul(%arg0: memref<72x72xf32>, %arg1: memref<72x72xf32>, %arg2: memref<72x72xf32>) {
// Check the matrix intrinsic lowering is triggered. // Check the matrix intrinsic lowering is triggered.
// CHECK-INTRINSIC: vector.matrix_multiply // INTRINSIC: vector.matrix_multiply
// CHECK-INTRINSIC-SAME: {lhs_columns = 8 : i32, lhs_rows = 2 : i32, rhs_columns = 4 : i32} // INTRINSIC-SAME: {lhs_columns = 8 : i32, lhs_rows = 2 : i32, rhs_columns = 4 : i32}
// CHECK-INTRINSIC-SAME: (vector<16xf32>, vector<32xf32>) -> vector<8xf32> // INTRINSIC-SAME: (vector<16xf32>, vector<32xf32>) -> vector<8xf32>
// Check the outer product lowering is triggered. // Check the outer product lowering is triggered.
// CHECK-OUTER: vector.outerproduct {{.*}} : vector<2xf32>, vector<4xf32> // OUTER: vector.outerproduct {{.*}} : vector<2xf32>, vector<4xf32>
linalg.matmul ins(%arg0, %arg1: memref<72x72xf32>, memref<72x72xf32>) outs(%arg2: memref<72x72xf32>) linalg.matmul ins(%arg0, %arg1: memref<72x72xf32>, memref<72x72xf32>) outs(%arg2: memref<72x72xf32>)
return return
} }
// ----- // -----
// CHECK-TILE-AND-INTERCHANGE: func @matmul( // TILE-AND-INTERCHANGE: func @matmul(
func @matmul(%arg0: tensor<72x72xf32>, %arg1: tensor<72x72xf32>, %arg2: tensor<72x72xf32>) -> tensor<72x72xf32> { func @matmul(%arg0: tensor<72x72xf32>, %arg1: tensor<72x72xf32>, %arg2: tensor<72x72xf32>) -> tensor<72x72xf32> {
// CHECK-TILE-AND-INTERCHANGE-DAG: %[[C16:.*]] = arith.constant 16 // TILE-AND-INTERCHANGE-DAG: %[[C16:.*]] = arith.constant 16
// CHECK-TILE-AND-INTERCHANGE-DAG: %[[C32:.*]] = arith.constant 32 // TILE-AND-INTERCHANGE-DAG: %[[C32:.*]] = arith.constant 32
// CHECK-TILE-AND-INTERCHANGE-DAG: %[[C64:.*]] = arith.constant 64 // TILE-AND-INTERCHANGE-DAG: %[[C64:.*]] = arith.constant 64
// Check the tile loops are interchanged. // Check the tile loops are interchanged.
// CHECK-TILE-AND-INTERCHANGE: scf.for {{.*}} step %[[C32]] // TILE-AND-INTERCHANGE: scf.for {{.*}} step %[[C32]]
// CHECK-TILE-AND-INTERCHANGE: scf.for {{.*}} step %[[C64]] // TILE-AND-INTERCHANGE: scf.for {{.*}} step %[[C64]]
// CHECK-TILE-AND-INTERCHANGE: scf.for {{.*}} step %[[C16]] // TILE-AND-INTERCHANGE: scf.for {{.*}} step %[[C16]]
// Check the operation has been generalized and interchanged. // Check the operation has been generalized and interchanged.
// CHECK-TILE-AND-INTERCHANGE: linalg.generic // TILE-AND-INTERCHANGE: linalg.generic
// CHECK-TILE-AND-INTERCHANGE-SAME: iterator_types = ["parallel", "reduction", "parallel"] // TILE-AND-INTERCHANGE-SAME: iterator_types = ["parallel", "reduction", "parallel"]
%0 = linalg.matmul ins(%arg0, %arg1: tensor<72x72xf32>, tensor<72x72xf32>) outs(%arg2: tensor<72x72xf32>) -> tensor<72x72xf32> %0 = linalg.matmul ins(%arg0, %arg1: tensor<72x72xf32>, tensor<72x72xf32>) outs(%arg2: tensor<72x72xf32>) -> tensor<72x72xf32>
return %0 : tensor<72x72xf32> return %0 : tensor<72x72xf32>
} }
// ----- // -----
// CHECK-PAD-DAG: #[[MAP0:[0-9a-z]+]] = affine_map<(d0) -> (16, -d0 + 72)> // PAD-DAG: #[[MAP0:[0-9a-z]+]] = affine_map<(d0) -> (16, -d0 + 72)>
// CHECK-PAD: func @matmul( // PAD: func @matmul(
func @matmul(%arg0: tensor<72x72xf32>, %arg1: tensor<72x72xf32>, %arg2: tensor<72x72xf32>) -> tensor<72x72xf32> { func @matmul(%arg0: tensor<72x72xf32>, %arg1: tensor<72x72xf32>, %arg2: tensor<72x72xf32>) -> tensor<72x72xf32> {
// Check the padding of the input operands has been hoisted out of the tile loop nest. // Check the padding of the input operands has been hoisted out of the tile loop nest.
// CHECK-PAD-COUNT=2: linalg.pad_tensor %{{.*}} nofold // PAD-COUNT=2: linalg.pad_tensor %{{.*}} nofold
// CHECK-PAD: scf.for // PAD: scf.for
// Check CSE eliminates the duplicate min operations introduced by tiling. // Check CSE eliminates the duplicate min operations introduced by tiling.
// CHECK-PAD: affine.min #[[MAP0]] // PAD: affine.min #[[MAP0]]
// CHECK-PAD-NOT: affine.min #[[MAP0]] // PAD-NOT: affine.min #[[MAP0]]
// CHECK-PAD-COUNT=2: scf.for // PAD-COUNT=2: scf.for
// CHECK-PAD: linalg.matmul // PAD: linalg.matmul
%0 = linalg.matmul ins(%arg0, %arg1: tensor<72x72xf32>, tensor<72x72xf32>) outs(%arg2: tensor<72x72xf32>) -> tensor<72x72xf32> %0 = linalg.matmul ins(%arg0, %arg1: tensor<72x72xf32>, tensor<72x72xf32>) outs(%arg2: tensor<72x72xf32>) -> tensor<72x72xf32>
return %0 : tensor<72x72xf32> return %0 : tensor<72x72xf32>
} }
// ----- // -----
// CHECK-FUSE: func @matmul( // FUSE: func @matmul(
func @matmul(%arg0: tensor<72x72xf32>, %arg1: tensor<72x72xf32>, %arg2: tensor<72x72xf32>) -> tensor<72x72xf32> { func @matmul(%arg0: tensor<72x72xf32>, %arg1: tensor<72x72xf32>, %arg2: tensor<72x72xf32>) -> tensor<72x72xf32> {
// Check the padding and vectorization applies to the fill operation due to the empty anchor op string. // Check the padding and vectorization applies to the fill operation due to the empty anchor op string.
// CHECK-FUSE: %[[CST:.*]] = arith.constant dense<0.000000e+00> // FUSE: %[[CST:.*]] = arith.constant dense<0.000000e+00>
// CHECK-FUSE: vector.transfer_write %[[CST]] // FUSE: vector.transfer_write %[[CST]]
%cst = arith.constant 0.0 : f32 %cst = arith.constant 0.0 : f32
%0 = linalg.fill(%cst, %arg0) : f32, tensor<72x72xf32> -> tensor<72x72xf32> %0 = linalg.fill(%cst, %arg0) : f32, tensor<72x72xf32> -> tensor<72x72xf32>
// Check the matmul is padded and vectorized despite the empty anchor op string. // Check the matmul is padded and vectorized despite the empty anchor op string.
// CHECK-FUSE: vector.outerproduct // FUSE: vector.outerproduct
%1 = linalg.matmul ins(%arg0, %arg1: tensor<72x72xf32>, tensor<72x72xf32>) outs(%0: tensor<72x72xf32>) -> tensor<72x72xf32> %1 = linalg.matmul ins(%arg0, %arg1: tensor<72x72xf32>, tensor<72x72xf32>) outs(%0: tensor<72x72xf32>) -> tensor<72x72xf32>
return %1 : tensor<72x72xf32> return %1 : tensor<72x72xf32>
} }
// ----- // -----
#map0 = affine_map<(d0, d1) -> (d0, d1)> #map0 = affine_map<(d0, d1) -> (d0, d1)>
#map1 = affine_map<(d0, d1) -> (d0)> #map1 = affine_map<(d0, d1) -> (d0)>
// CHECK-GENERALIZE: func @matvec( // GENERALIZE-AND-INTERCHANGE: func @matvec(
func @matvec(%arg0: tensor<72x72xf32>, %arg1: tensor<72xf32>, %arg2: tensor<72xf32>) -> tensor<72xf32> { func @matvec(%arg0: tensor<72x72xf32>, %arg1: tensor<72xf32>, %arg2: tensor<72xf32>) -> tensor<72xf32> {
// Check both operations are interchanged despite the missing generic generalization pattern. // Check both operations are interchanged despite the missing generic generalization pattern.
// CHECK-GENERALIZE: linalg.generic // GENERALIZE-AND-INTERCHANGE: linalg.generic
// CHECK-GENERALIZE-SAME: iterator_types = ["reduction", "parallel"] // GENERALIZE-AND-INTERCHANGE-SAME: iterator_types = ["reduction", "parallel"]
// CHECK-GENERALIZE: linalg.generic // GENERALIZE-AND-INTERCHANGE: linalg.generic
// CHECK-GENERALIZE-SAME: iterator_types = ["reduction", "parallel"] // GENERALIZE-AND-INTERCHANGE-SAME: iterator_types = ["reduction", "parallel"]
%0 = linalg.generic {indexing_maps = [#map0, #map1], %0 = linalg.generic {indexing_maps = [#map0, #map1],
iterator_types = ["parallel", "reduction"]} iterator_types = ["parallel", "reduction"]}
ins(%arg0 : tensor<72x72xf32>) ins(%arg0 : tensor<72x72xf32>)
outs(%arg1 : tensor<72xf32>) { outs(%arg1 : tensor<72xf32>) {
^bb0(%arg3: f32, %arg5: f32): // no predecessors ^bb0(%arg3: f32, %arg5: f32): // no predecessors
%2 = arith.addf %arg3, %arg5 : f32 %2 = arith.addf %arg3, %arg5 : f32
linalg.yield %2 : f32 linalg.yield %2 : f32
} -> tensor<72xf32> } -> tensor<72xf32>
%1 = linalg.matvec ins(%arg0, %0: tensor<72x72xf32>, tensor<72xf32>) outs(%arg2: tensor<72xf32>) -> tensor<72xf32> %1 = linalg.matvec ins(%arg0, %0: tensor<72x72xf32>, tensor<72xf32>) outs(%arg2: tensor<72xf32>) -> tensor<72xf32>
return %1 : tensor<72xf32> return %1 : tensor<72xf32>
} }
// ----- // -----
#map0 = affine_map<(d0, d1) -> (d0, d1)> #map0 = affine_map<(d0, d1) -> (d0, d1)>
#map1 = affine_map<(d0, d1) -> (d0)> #map1 = affine_map<(d0, d1) -> (d0)>
// CHECK-INTERCHANGE-AND-VECTORIZE: func @matvec( // INTERCHANGE-AND-VECTORIZE: func @matvec(
func @matvec(%arg0: tensor<72x72xf32>, %arg1: tensor<72xf32>, %arg2: tensor<72xf32>) -> tensor<72xf32> { func @matvec(%arg0: tensor<72x72xf32>, %arg1: tensor<72xf32>, %arg2: tensor<72xf32>) -> tensor<72xf32> {
// Check both operations are vectorized despite the missing matvec interchange pattern. // Check both operations are vectorized despite the missing matvec interchange pattern.
// CHECK-INTERCHANGE-AND-VECTORIZE-NOT: linalg.generic // INTERCHANGE-AND-VECTORIZE-NOT: linalg.generic
// CHECK-INTERCHANGE-AND-VECTORIZE-NOT: linalg.matvec // INTERCHANGE-AND-VECTORIZE-NOT: linalg.matvec
%0 = linalg.generic {indexing_maps = [#map0, #map1], %0 = linalg.generic {indexing_maps = [#map0, #map1],
iterator_types = ["parallel", "reduction"]} iterator_types = ["parallel", "reduction"]}
ins(%arg0 : tensor<72x72xf32>) ins(%arg0 : tensor<72x72xf32>)
outs(%arg1 : tensor<72xf32>) { outs(%arg1 : tensor<72xf32>) {
^bb0(%arg3: f32, %arg5: f32): // no predecessors ^bb0(%arg3: f32, %arg5: f32): // no predecessors
%2 = arith.addf %arg3, %arg5 : f32 %2 = arith.addf %arg3, %arg5 : f32
linalg.yield %2 : f32 linalg.yield %2 : f32
} -> tensor<72xf32> } -> tensor<72xf32>
%1 = linalg.matvec ins(%arg0, %0: tensor<72x72xf32>, tensor<72xf32>) outs(%arg2: tensor<72xf32>) -> tensor<72xf32> %1 = linalg.matvec ins(%arg0, %0: tensor<72x72xf32>, tensor<72xf32>) outs(%arg2: tensor<72xf32>) -> tensor<72xf32>
return %1 : tensor<72xf32> return %1 : tensor<72xf32>
} }
// ----- // -----
#map0 = affine_map<(d0, d1) -> (d0, d1)> #map0 = affine_map<(d0, d1) -> (d0, d1)>
#map1 = affine_map<(d0, d1) -> (d0)> #map1 = affine_map<(d0, d1) -> (d0)>
// CHECK-DECOMPOSE-AND-GENERALIZE: func @conv( // DECOMPOSE-AND-GENERALIZE: func @conv(
func @conv(%input: tensor<4x1x6x3xf32>, %filter: tensor<1x2x3x8xf32>, %init: tensor<4x1x2x8xf32>) -> tensor<4x1x2x8xf32> { func @conv(%input: tensor<4x1x6x3xf32>, %filter: tensor<1x2x3x8xf32>, %init: tensor<4x1x2x8xf32>) -> tensor<4x1x2x8xf32> {
%cst = arith.constant 0.0 : f32 %cst = arith.constant 0.0 : f32
// Check both operations are generalized despite the missing fill decompose pattern. // Check both operations are generalized despite the missing fill decompose pattern.
// CHECK-DECOMPOSE-AND-GENERALIZE-NOT: linalg.fill // DECOMPOSE-AND-GENERALIZE-NOT: linalg.fill
// CHECK-DECOMPOSE-AND-GENERALIZE-NOT: linalg.conv_2d_nhwc_hwcf // DECOMPOSE-AND-GENERALIZE-NOT: linalg.conv_2d_nhwc_hwcf
%0 = linalg.fill(%cst, %init) : f32, tensor<4x1x2x8xf32> -> tensor<4x1x2x8xf32> %0 = linalg.fill(%cst, %init) : f32, tensor<4x1x2x8xf32> -> tensor<4x1x2x8xf32>
%1 = linalg.conv_2d_nhwc_hwcf %1 = linalg.conv_2d_nhwc_hwcf
{dilations = dense<[2, 3]> : tensor<2xi64>, strides = dense<[3, 2]> : tensor<2xi64>} {dilations = dense<[2, 3]> : tensor<2xi64>, strides = dense<[3, 2]> : tensor<2xi64>}
ins(%input, %filter : tensor<4x1x6x3xf32>, tensor<1x2x3x8xf32>) ins(%input, %filter : tensor<4x1x6x3xf32>, tensor<1x2x3x8xf32>)
outs(%0 : tensor<4x1x2x8xf32>) -> tensor<4x1x2x8xf32> outs(%0 : tensor<4x1x2x8xf32>) -> tensor<4x1x2x8xf32>
return %1 : tensor<4x1x2x8xf32> return %1 : tensor<4x1x2x8xf32>
} }