maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/mlir/test/Dialect/Linalg/fusion-tensor.mlir

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

561 lines
23 KiB
MLIR
Raw Normal View History

Change filecheck default to dump input on failure Having the input dumped on failure seems like a better default: I debugged FileCheck tests for a while without knowing about this option, which really helps to understand failures. Remove `-dump-input-on-failure` and the environment variable FILECHECK_DUMP_INPUT_ON_FAILURE which are now obsolete. Differential Revision: https://reviews.llvm.org/D81422
2020-03-28 07:58:06 +08:00
// RUN: mlir-opt %s -linalg-fusion-for-tensor-ops -split-input-file | FileCheck %s
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: [[$MAP0:#[a-zA-Z0-9_]*]] = affine_map<(d0, d1) -> (d0, d1)>
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
#map0 = affine_map<(d0, d1) -> (d0, d1)>
// CHECK-LABEL: @add_mul_fusion
func @add_mul_fusion(%arg0: tensor<?x?xf32>, %arg1 : tensor<?x?xf32>, %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32>
{
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%0 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel", "parallel"]}
ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?x?xf32>) {
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = addf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xf32>
// CHECK: linalg.generic {
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = {{\[}}[[$MAP0]], [[$MAP0]], [[$MAP0]], [[$MAP0]]{{\]}}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%2 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel", "parallel"]}
ins(%0, %arg2 : tensor<?x?xf32>, tensor<?x?xf32>) {
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
// CHECK: ^{{[a-zA-Z0-9_]*}}
// CHECK-SAME: [[ARG0:%[a-zA-Z0-9_]*]]
// CHECK-SAME: [[ARG1:%[a-zA-Z0-9_]*]]
// CHECK-SAME: [[ARG2:%[a-zA-Z0-9_]*]]
^bb0(%arg5: f32, %arg6: f32): // no predecessors
// CHECK: [[T1:%[a-zA-Z0-9_]*]] = addf [[ARG0]], [[ARG1]]
// CHECK-NOT: linalg.yield
// CHECK: mulf [[T1]], [[ARG2]]
// CHECK: linalg.yield
%3 = mulf %arg5, %arg6 : f32
linalg.yield %3 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xf32>
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
return %2 : tensor<?x?xf32>
}
// -----
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: [[$MAP0:#[a-zA-Z0-9_]*]] = affine_map<(d0, d1) -> (d0, d1)>
// CHECK-DAG: [[$MAP1:#[a-zA-Z0-9_]*]] = affine_map<(d0, d1) -> (d1, d0)>
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
#map0 = affine_map<(d0, d1) -> (d0, d1)>
#map1 = affine_map<(d0, d1) -> (d1, d0)>
// CHECK-LABEL: @transpose_add_mul_fusion
func @transpose_add_mul_fusion(%arg0: tensor<?x?xf32>, %arg1 : tensor<?x?xf32>, %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32>
{
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%0 = linalg.generic {indexing_maps = [#map0, #map1, #map0], iterator_types = ["parallel", "parallel"]}
ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?x?xf32>) {
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = addf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xf32>
// CHECK: linalg.generic {
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = {{\[}}[[$MAP0]], [[$MAP1]], [[$MAP0]], [[$MAP0]]{{\]}}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%2 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel", "parallel"]}
ins(%0, %arg2 : tensor<?x?xf32>, tensor<?x?xf32>) {
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
^bb0(%arg5: f32, %arg6: f32): // no predecessors
%3 = mulf %arg5, %arg6 : f32
linalg.yield %3 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xf32>
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
return %2 : tensor<?x?xf32>
}
// -----
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: [[$MAP0:#[a-zA-Z0-9_]*]] = affine_map<(d0, d1) -> (d0, d1)>
// CHECK-DAG: [[$MAP1:#[a-zA-Z0-9_]*]] = affine_map<(d0, d1) -> (d1, d0)>
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
#map0 = affine_map<(d0, d1) -> (d0, d1)>
#map1 = affine_map<(d0, d1) -> (d1, d0)>
// CHECK-LABEL: @add_transpose_mul_fusion
func @add_transpose_mul_fusion(%arg0: tensor<?x?xf32>, %arg1 : tensor<?x?xf32>, %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32>
{
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%0 = linalg.generic {indexing_maps = [#map0, #map1, #map0], iterator_types = ["parallel", "parallel"]}
ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?x?xf32>) {
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = addf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xf32>
// CHECK: linalg.generic {
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = {{\[}}[[$MAP1]], [[$MAP0]], [[$MAP0]], [[$MAP0]]{{\]}}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%2 = linalg.generic {indexing_maps = [#map1, #map0, #map0], iterator_types = ["parallel", "parallel"]}
ins(%0, %arg2 : tensor<?x?xf32>, tensor<?x?xf32>) {
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
^bb0(%arg5: f32, %arg6: f32): // no predecessors
%3 = mulf %arg5, %arg6 : f32
linalg.yield %3 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xf32>
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
return %2 : tensor<?x?xf32>
}
// -----
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: [[$MAP0:#[a-zA-Z0-9_]*]] = affine_map<(d0, d1) -> (d0, d1)>
// CHECK-DAG: [[$MAP1:#[a-zA-Z0-9_]*]] = affine_map<(d0, d1) -> (d0)>
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
#map0 = affine_map<(d0, d1) -> (d0, d1)>
#map1 = affine_map<(d0, d1) -> (d0)>
#map2 = affine_map<(d0) -> (d0)>
// CHECK-LABEL: @add_broadcast_mul_fusion
func @add_broadcast_mul_fusion(%arg0: tensor<?xf32>, %arg1 : tensor<?xf32>, %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32>
{
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%0 = linalg.generic {indexing_maps = [#map2, #map2, #map2], iterator_types = ["parallel"]}
ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>) {
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = addf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?xf32>
// CHECK: linalg.generic {
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = {{\[}}[[$MAP1]], [[$MAP1]], [[$MAP0]], [[$MAP0]]
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%2 = linalg.generic {indexing_maps = [#map1, #map0, #map0], iterator_types = ["parallel", "parallel"]}
ins(%0, %arg2 : tensor<?xf32>, tensor<?x?xf32>) {
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
^bb0(%arg5: f32, %arg6: f32): // no predecessors
%3 = mulf %arg5, %arg6 : f32
linalg.yield %3 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xf32>
[mlir][Linalg] Implement fusion of linalg.generic operation on tensors. The initial implementation of the fusion operation exposes a method to fuse a consumer with its producer, when - both the producer and consumer operate on tensors - the producer has only a single result value - the producer has only "parallel" iterator types A new interface method hasTensorSemantics is added to verify that an operation has all operands and results of type RankedTensorType. Differential Revision: https://reviews.llvm.org/D74172
2020-02-08 02:28:20 +08:00
return %2 : tensor<?x?xf32>
}
[mlir][LLVMIR] Fix fusion for rank-0 tensors Summary: This diff fixes fusion craching for ops with rank-0 tensors Reviewers: mravishankar, nicolasvasilache, rriddle! Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, liufengdb, Joonsoo, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D76479
2020-03-20 14:55:25 +08:00
// -----
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK: #[[$MAP0:.*]] = affine_map<() -> ()>
[mlir][LLVMIR] Fix fusion for rank-0 tensors Summary: This diff fixes fusion craching for ops with rank-0 tensors Reviewers: mravishankar, nicolasvasilache, rriddle! Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, liufengdb, Joonsoo, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D76479
2020-03-20 14:55:25 +08:00
#map0 = affine_map<() -> ()>
// CHECK-LABEL: @add_mul_scalar_fusion
func @add_mul_scalar_fusion(%arg0: tensor<f32>, %arg1: tensor<f32>, %arg2: tensor<f32>) -> tensor<f32>
{
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%0 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = []}
ins(%arg0, %arg1 : tensor<f32>, tensor<f32>) {
[mlir][LLVMIR] Fix fusion for rank-0 tensors Summary: This diff fixes fusion craching for ops with rank-0 tensors Reviewers: mravishankar, nicolasvasilache, rriddle! Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, liufengdb, Joonsoo, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D76479
2020-03-20 14:55:25 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = addf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<f32>
// CHECK: linalg.generic {
[mlir][LLVMIR] Fix fusion for rank-0 tensors Summary: This diff fixes fusion craching for ops with rank-0 tensors Reviewers: mravishankar, nicolasvasilache, rriddle! Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, liufengdb, Joonsoo, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D76479
2020-03-20 14:55:25 +08:00
// CHECK: addf
// CHECK: mulf
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%1 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = []}
ins(%0, %arg2 : tensor<f32>, tensor<f32>) {
[mlir][LLVMIR] Fix fusion for rank-0 tensors Summary: This diff fixes fusion craching for ops with rank-0 tensors Reviewers: mravishankar, nicolasvasilache, rriddle! Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, liufengdb, Joonsoo, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D76479
2020-03-20 14:55:25 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = mulf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<f32>
[mlir][LLVMIR] Fix fusion for rank-0 tensors Summary: This diff fixes fusion craching for ops with rank-0 tensors Reviewers: mravishankar, nicolasvasilache, rriddle! Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, liufengdb, Joonsoo, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D76479
2020-03-20 14:55:25 +08:00
return %1 : tensor<f32>
}
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
// -----
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1 * 4 + d2, d3)>
// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
#map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
func @generic_op_reshape_producer_fusion(%arg0 : tensor<?x?x?xf32>,
%arg1 : tensor<?x?x4x?xf32>) ->
tensor<?x?x4x?xf32>
{
%0 = linalg.tensor_reshape %arg0 [affine_map<(i, j, k, l) -> (i)>,
affine_map<(i, j, k, l) -> (j, k)>,
affine_map<(i, j, k, l) -> (l)>] :
tensor<?x?x?xf32> into tensor<?x?x4x?xf32>
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%1 = linalg.generic {
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
indexing_maps = [#map0, #map0, #map0],
iterator_types = ["parallel", "parallel", "parallel", "parallel"]}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
ins(%0, %arg1 : tensor<?x?x4x?xf32>, tensor<?x?x4x?xf32>) {
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = mulf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?x4x?xf32>
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
return %1 : tensor<?x?x4x?xf32>
}
// CHECK-LABEL: func @generic_op_reshape_producer_fusion
// CHECK: linalg.generic
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP1]]]
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
// CHECK-NOT: linalg.generic
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
// -----
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1 * 20 + d2 * 5 + d3)>
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
#map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
func @generic_op_reshape_consumer_fusion(%arg0 : tensor<?x?x4x5xf32>,
%arg1 : tensor<?x?x4x5xf32>) ->
tensor<?x?xf32>
{
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%0 = linalg.generic {
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
indexing_maps = [#map0, #map0, #map0],
iterator_types = ["parallel", "parallel", "parallel", "parallel"]}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
ins(%arg0, %arg1 : tensor<?x?x4x5xf32>, tensor<?x?x4x5xf32>) {
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = mulf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?x4x5xf32>
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
%1 = linalg.tensor_reshape %0 [affine_map<(i, j, k, l) -> (i)>,
affine_map<(i, j, k, l) -> (j, k, l)>] :
tensor<?x?x4x5xf32> into tensor<?x?xf32>
return %1 : tensor<?x?xf32>
}
// CHECK-LABEL: func @generic_op_reshape_consumer_fusion
// CHECK: linalg.generic
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP0]], #[[$MAP1]]]
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
// CHECK-NOT: linalg.generic
// -----
#map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
func @generic_op_reshape_consumer_nofusion(%arg0 : tensor<?x?x?x5xf32>,
%arg1 : tensor<?x?x?x5xf32>) ->
tensor<?x?xf32>
{
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%0 = linalg.generic {
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
indexing_maps = [#map0, #map0, #map0],
iterator_types = ["parallel", "parallel", "parallel", "parallel"]}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
ins(%arg0, %arg1 : tensor<?x?x?x5xf32>, tensor<?x?x?x5xf32>) {
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
^bb0(%arg3: f32, %arg4: f32): // no predecessors
%1 = mulf %arg3, %arg4 : f32
linalg.yield %1 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?x?x5xf32>
[mlir][Linalg] Add support for fusing linalg.tensor_reshape with linalg.generic operations. Differential Revision: https://reviews.llvm.org/D78464
2020-04-24 04:41:02 +08:00
%1 = linalg.tensor_reshape %0 [affine_map<(i, j, k, l) -> (i)>,
affine_map<(i, j, k, l) -> (j, k, l)>] :
tensor<?x?x?x5xf32> into tensor<?x?xf32>
return %1 : tensor<?x?xf32>
}
// CHECK-LABEL: func @generic_op_reshape_consumer_nofusion
// CHECK: linalg.tensor_reshape
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
// -----
[mlir][Linalg] Enhance Linalg fusion on generic op and tensor_reshape op. The tensor_reshape op was only fusible only if it is a collapsing case. Now we propagate the op to all the operands so there is a further chance to fuse it with generic op. The pre-conditions are: 1) The producer is not an indexed_generic op. 2) All the shapes of the operands are the same. 3) All the indexing maps are identity. 4) All the loops are parallel loops. 5) The producer has a single user. It is possible to fuse the ops if the producer is an indexed_generic op. We still can compute the original indices. E.g., if the reshape op collapses the d0 and d1, we can use DimOp to get the width of d1, and calculate the index `d0 * width + d1`. Then replace all the uses with it. However, this pattern is not implemented in the patch. Reviewed By: mravishankar Differential Revision: https://reviews.llvm.org/D86314
2020-08-28 16:53:59 +08:00
#map0 = affine_map<(d0, d1) -> (d0, d1)>
#map1 = affine_map<(d0, d1, d2) -> (d0, d1)>
#map2 = affine_map<(d0, d1, d2) -> (d2)>
func @generic_op_reshape_consumer_expanding(%arg0: tensor<264x4xf32>)
-> tensor<8x33x4xf32> {
%cst = constant dense<2.000000e+00> : tensor<264x4xf32>
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%0 = linalg.generic {
[mlir][Linalg] Enhance Linalg fusion on generic op and tensor_reshape op. The tensor_reshape op was only fusible only if it is a collapsing case. Now we propagate the op to all the operands so there is a further chance to fuse it with generic op. The pre-conditions are: 1) The producer is not an indexed_generic op. 2) All the shapes of the operands are the same. 3) All the indexing maps are identity. 4) All the loops are parallel loops. 5) The producer has a single user. It is possible to fuse the ops if the producer is an indexed_generic op. We still can compute the original indices. E.g., if the reshape op collapses the d0 and d1, we can use DimOp to get the width of d1, and calculate the index `d0 * width + d1`. Then replace all the uses with it. However, this pattern is not implemented in the patch. Reviewed By: mravishankar Differential Revision: https://reviews.llvm.org/D86314
2020-08-28 16:53:59 +08:00
indexing_maps = [#map0, #map0, #map0],
iterator_types = ["parallel", "parallel"]}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
ins(%arg0, %cst : tensor<264x4xf32>, tensor<264x4xf32>) {
[mlir][Linalg] Enhance Linalg fusion on generic op and tensor_reshape op. The tensor_reshape op was only fusible only if it is a collapsing case. Now we propagate the op to all the operands so there is a further chance to fuse it with generic op. The pre-conditions are: 1) The producer is not an indexed_generic op. 2) All the shapes of the operands are the same. 3) All the indexing maps are identity. 4) All the loops are parallel loops. 5) The producer has a single user. It is possible to fuse the ops if the producer is an indexed_generic op. We still can compute the original indices. E.g., if the reshape op collapses the d0 and d1, we can use DimOp to get the width of d1, and calculate the index `d0 * width + d1`. Then replace all the uses with it. However, this pattern is not implemented in the patch. Reviewed By: mravishankar Differential Revision: https://reviews.llvm.org/D86314
2020-08-28 16:53:59 +08:00
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%2 = mulf %arg1, %arg2 : f32
linalg.yield %2 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<264x4xf32>
[mlir][Linalg] Enhance Linalg fusion on generic op and tensor_reshape op. The tensor_reshape op was only fusible only if it is a collapsing case. Now we propagate the op to all the operands so there is a further chance to fuse it with generic op. The pre-conditions are: 1) The producer is not an indexed_generic op. 2) All the shapes of the operands are the same. 3) All the indexing maps are identity. 4) All the loops are parallel loops. 5) The producer has a single user. It is possible to fuse the ops if the producer is an indexed_generic op. We still can compute the original indices. E.g., if the reshape op collapses the d0 and d1, we can use DimOp to get the width of d1, and calculate the index `d0 * width + d1`. Then replace all the uses with it. However, this pattern is not implemented in the patch. Reviewed By: mravishankar Differential Revision: https://reviews.llvm.org/D86314
2020-08-28 16:53:59 +08:00
%1 = linalg.tensor_reshape %0 [#map1, #map2] :
tensor<264x4xf32> into tensor<8x33x4xf32>
return %1 : tensor<8x33x4xf32>
}
// The reshape op in `%arg0` is folded into the indexing map of generic op.
// CHECK-DAG: #[[MAP0:.+]] = affine_map<(d0, d1, d2) -> (d0 * 33 + d1, d2)>
// CHECK-DAG: #[[MAP1:.+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
// CHECK: func @generic_op_reshape_consumer_expanding
// CHECK-NOT: linalg.tensor_reshape
// CHECK: %[[CST:.*]] = constant {{.*}} : f32
// CHECK: linalg.generic
// CHECK-SAME: indexing_maps = [#[[MAP0]], #[[MAP1]]]
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
// CHECK-SAME: tensor<264x4xf32>
// CHECK: -> tensor<8x33x4xf32>
[mlir][Linalg] Enhance Linalg fusion on generic op and tensor_reshape op. The tensor_reshape op was only fusible only if it is a collapsing case. Now we propagate the op to all the operands so there is a further chance to fuse it with generic op. The pre-conditions are: 1) The producer is not an indexed_generic op. 2) All the shapes of the operands are the same. 3) All the indexing maps are identity. 4) All the loops are parallel loops. 5) The producer has a single user. It is possible to fuse the ops if the producer is an indexed_generic op. We still can compute the original indices. E.g., if the reshape op collapses the d0 and d1, we can use DimOp to get the width of d1, and calculate the index `d0 * width + d1`. Then replace all the uses with it. However, this pattern is not implemented in the patch. Reviewed By: mravishankar Differential Revision: https://reviews.llvm.org/D86314
2020-08-28 16:53:59 +08:00
// CHECK-NOT: linalg.tensor_reshape
// -----
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
#map0 = affine_map<(d0, d1, d2) -> (d0)>
#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
func @generic_op_constant_fusion(%arg0 : tensor<5x?x?xf32>) -> tensor<5x?x?xf32>
{
%0 = constant dense<42.0> : tensor<5xf32>
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%1 = linalg.generic {
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
indexing_maps = [#map0, #map1, #map1],
iterator_types = ["parallel", "parallel", "parallel"]}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
ins(%0, %arg0 : tensor<5xf32>, tensor<5x?x?xf32>) {
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
^bb0(%arg1: f32, %arg2: f32):
%2 = mulf %arg1, %arg2 : f32
linalg.yield %2 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<5x?x?xf32>
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
return %1 : tensor<5x?x?xf32>
}
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
// CHECK-LABEL: func @generic_op_constant_fusion
// CHECK: %[[CST:.*]] = constant {{.*}} : f32
// CHECK: linalg.generic
// CHECK: ^{{.*}}(%[[ARG1:.*]]: f32)
// CHECK: mulf %[[CST]], %[[ARG1]]
// -----
[mlir][Linalg] Enable fusion of std.constant (producer) with linalg.indexed_generic (consumer) with tensor arguments. The implementation of fusing std.constant producer with a linalg.indexed_generic consumer was already in place. It is exposed with this change. Also cleaning up some of the patterns that implement the fusion to not be templated, thereby avoiding lot of conditional checks for calling the right instantiation. Differential Revision: https://reviews.llvm.org/D84566
2020-07-28 00:48:36 +08:00
#map0 = affine_map<(d0, d1, d2) -> (d0)>
#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
func @indexed_generic_op_constant_fusion(%arg0 : tensor<5x?x?xf32>)
-> tensor<5x?x?xf32>
{
%0 = constant dense<42.0> : tensor<5xf32>
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%1 = linalg.indexed_generic {
[mlir][Linalg] Enable fusion of std.constant (producer) with linalg.indexed_generic (consumer) with tensor arguments. The implementation of fusing std.constant producer with a linalg.indexed_generic consumer was already in place. It is exposed with this change. Also cleaning up some of the patterns that implement the fusion to not be templated, thereby avoiding lot of conditional checks for calling the right instantiation. Differential Revision: https://reviews.llvm.org/D84566
2020-07-28 00:48:36 +08:00
indexing_maps = [#map0, #map1, #map1],
iterator_types = ["parallel", "parallel", "parallel"]}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
ins(%0, %arg0 : tensor<5xf32>, tensor<5x?x?xf32>) {
[mlir][Linalg] Enable fusion of std.constant (producer) with linalg.indexed_generic (consumer) with tensor arguments. The implementation of fusing std.constant producer with a linalg.indexed_generic consumer was already in place. It is exposed with this change. Also cleaning up some of the patterns that implement the fusion to not be templated, thereby avoiding lot of conditional checks for calling the right instantiation. Differential Revision: https://reviews.llvm.org/D84566
2020-07-28 00:48:36 +08:00
^bb0(%arg1: index, %arg2: index, %arg3: index, %arg4: f32, %arg5 : f32):
%2 = mulf %arg4, %arg5 : f32
linalg.yield %2 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<5x?x?xf32>
[mlir][Linalg] Enable fusion of std.constant (producer) with linalg.indexed_generic (consumer) with tensor arguments. The implementation of fusing std.constant producer with a linalg.indexed_generic consumer was already in place. It is exposed with this change. Also cleaning up some of the patterns that implement the fusion to not be templated, thereby avoiding lot of conditional checks for calling the right instantiation. Differential Revision: https://reviews.llvm.org/D84566
2020-07-28 00:48:36 +08:00
return %1 : tensor<5x?x?xf32>
}
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
// CHECK-LABEL: func @indexed_generic_op_constant_fusion
// CHECK: %[[CST:.*]] = constant {{.*}} : f32
// CHECK: linalg.indexed_generic
// CHECK: ^{{[a-zA-Z0-9_]*}}
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: index
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: index
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: index
// CHECK-SAME: %[[ARG4:.*]]: f32)
// CHECK: mulf %[[CST]], %[[ARG4]]
// -----
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
#map0 = affine_map<(d0, d1, d2) -> ()>
#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
func @generic_op_zero_dim_constant_fusion(%arg0 : tensor<5x?x?xf32>)
-> tensor<5x?x?xf32>
{
%0 = constant dense<42.0> : tensor<f32>
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%1 = linalg.generic {
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
indexing_maps = [#map0, #map1, #map1],
iterator_types = ["parallel", "parallel", "parallel"]}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
ins(%0, %arg0 : tensor<f32>, tensor<5x?x?xf32>) {
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
^bb0(%arg1: f32, %arg2: f32):
%2 = mulf %arg1, %arg2 : f32
linalg.yield %2 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<5x?x?xf32>
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
return %1 : tensor<5x?x?xf32>
}
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
[mlir][Linalg] Add producer-consumer fusion when producer is a ConstantOp and Consumer is a GenericOp. Differential Revision: https://reviews.llvm.org/D79838
2020-05-20 23:57:32 +08:00
// CHECK-LABEL: func @generic_op_zero_dim_constant_fusion
// CHECK: %[[CST:.*]] = constant {{.*}} : f32
// CHECK: linalg.generic
// CHECK: ^{{.*}}(%[[ARG1:.*]]: f32)
// CHECK: mulf %[[CST]], %[[ARG1]]
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
// -----
[mlir][Linalg] Enable fusion of std.constant (producer) with linalg.indexed_generic (consumer) with tensor arguments. The implementation of fusing std.constant producer with a linalg.indexed_generic consumer was already in place. It is exposed with this change. Also cleaning up some of the patterns that implement the fusion to not be templated, thereby avoiding lot of conditional checks for calling the right instantiation. Differential Revision: https://reviews.llvm.org/D84566
2020-07-28 00:48:36 +08:00
#map0 = affine_map<(d0, d1, d2) -> ()>
#map1 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
func @indexed_generic_op_zero_dim_constant_fusion
(%arg0 : tensor<5x?x?xf32>) -> tensor<5x?x?xf32>
{
%0 = constant dense<42.0> : tensor<f32>
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
%1 = linalg.indexed_generic {
[mlir][Linalg] Enable fusion of std.constant (producer) with linalg.indexed_generic (consumer) with tensor arguments. The implementation of fusing std.constant producer with a linalg.indexed_generic consumer was already in place. It is exposed with this change. Also cleaning up some of the patterns that implement the fusion to not be templated, thereby avoiding lot of conditional checks for calling the right instantiation. Differential Revision: https://reviews.llvm.org/D84566
2020-07-28 00:48:36 +08:00
indexing_maps = [#map0, #map1, #map1],
iterator_types = ["parallel", "parallel", "parallel"]}
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
ins(%0, %arg0 : tensor<f32>, tensor<5x?x?xf32>) {
[mlir][Linalg] Enable fusion of std.constant (producer) with linalg.indexed_generic (consumer) with tensor arguments. The implementation of fusing std.constant producer with a linalg.indexed_generic consumer was already in place. It is exposed with this change. Also cleaning up some of the patterns that implement the fusion to not be templated, thereby avoiding lot of conditional checks for calling the right instantiation. Differential Revision: https://reviews.llvm.org/D84566
2020-07-28 00:48:36 +08:00
^bb0(%arg1 : index, %arg2 : index, %arg3 : index, %arg4: f32, %arg5: f32):
%2 = mulf %arg4, %arg5 : f32
linalg.yield %2 : f32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<5x?x?xf32>
[mlir][Linalg] Enable fusion of std.constant (producer) with linalg.indexed_generic (consumer) with tensor arguments. The implementation of fusing std.constant producer with a linalg.indexed_generic consumer was already in place. It is exposed with this change. Also cleaning up some of the patterns that implement the fusion to not be templated, thereby avoiding lot of conditional checks for calling the right instantiation. Differential Revision: https://reviews.llvm.org/D84566
2020-07-28 00:48:36 +08:00
return %1 : tensor<5x?x?xf32>
}
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
// CHECK-LABEL: func @indexed_generic_op_zero_dim_constant_fusion
// CHECK: %[[CST:.*]] = constant {{.*}} : f32
// CHECK: linalg.indexed_generic
// CHECK: ^{{[a-zA-Z0-9_]*}}
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: index
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: index
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: index
// CHECK-SAME: %[[ARG4:.*]]: f32)
// CHECK: mulf %[[CST]], %[[ARG4]]
// -----
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
#map0 = affine_map<(d0, d1) -> (d0, d1)>
func @generic_op_indexed_generic_op_fusion(%arg0: tensor<?x?xi32>,
%arg1: tensor<?x?xi32>) {
%0 = linalg.generic {
indexing_maps = [#map0, #map0, #map0],
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
iterator_types = ["parallel", "parallel"] }
ins(%arg0, %arg1 : tensor<?x?xi32>, tensor<?x?xi32>) {
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
^bb0(%arg2: i32, %arg3: i32): // no predecessors
%10 = addi %arg2, %arg3 : i32
linalg.yield %10 : i32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xi32>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
%1 = linalg.indexed_generic {
indexing_maps = [#map0, #map0],
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
iterator_types = ["parallel", "parallel"] }
ins(%0 : tensor<?x?xi32>) {
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
^bb0(%arg2: index, %arg3: index, %arg4: i32): // no predecessors
%2 = index_cast %arg2 : index to i32
%3 = index_cast %arg3 : index to i32
%4 = addi %arg4, %2 : i32
%5 = subi %4, %3 : i32
linalg.yield %5 : i32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xi32>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
return
}
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d0, d1)>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
// CHECK-LABEL: func @generic_op_indexed_generic_op_fusion
// CHECK-NOT: linalg.generic
// CHECK: linalg.indexed_generic
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP0]], #[[$MAP0]]]
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
// CHECK: ^{{[a-zA-Z0-9_]*}}
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: index
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: index
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9_]*]]: i32
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9_]*]]: i32
// CHECK: %[[VAL1:.+]] = addi %[[ARG2]], %[[ARG3]] : i32
// CHECK: %[[ADD_OPERAND:.+]] = index_cast %[[ARG0]] : index to i32
// CHECK: %[[SUB_OPERAND:.+]] = index_cast %[[ARG1]] : index to i32
// CHECK: %[[VAL2:.+]] = addi %[[VAL1]], %[[ADD_OPERAND]] : i32
// CHECK: %[[VAL3:.+]] = subi %[[VAL2]], %[[SUB_OPERAND]] : i32
// CHECK: linalg.yield %[[VAL3]] : i32
// -----
#map0 = affine_map<(d0, d1) -> (d0, d1)>
func @indexed_generic_op_generic_op_fusion(%arg0: tensor<?x?xi32>,
%arg1: tensor<?x?xi32>) {
%0 = linalg.indexed_generic {
indexing_maps = [#map0, #map0],
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
iterator_types = ["parallel", "parallel"] }
ins(%arg0 : tensor<?x?xi32>) {
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
^bb0(%arg2: index, %arg3: index, %arg4: i32): // no predecessors
%2 = index_cast %arg2 : index to i32
%3 = index_cast %arg3 : index to i32
%4 = addi %arg4, %2 : i32
%5 = subi %4, %3 : i32
linalg.yield %5 : i32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xi32>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
%1 = linalg.generic {
indexing_maps = [#map0, #map0, #map0],
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
iterator_types = ["parallel", "parallel"] }
ins(%0, %arg1 : tensor<?x?xi32>, tensor<?x?xi32>) {
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
^bb0(%arg2: i32, %arg3: i32): // no predecessors
%10 = addi %arg2, %arg3 : i32
linalg.yield %10 : i32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xi32>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
return
}
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d0, d1)>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
// CHECK-LABEL: func @indexed_generic_op_generic_op_fusion
// CHECK: linalg.indexed_generic
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP0]], #[[$MAP0]]]
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
// CHECK: ^{{[a-zA-Z0-9_]*}}
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: index
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: index
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9_]*]]: i32
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9_]*]]: i32
// CHECK: %[[ADD_OPERAND:.+]] = index_cast %[[ARG0]] : index to i32
// CHECK: %[[SUB_OPERAND:.+]] = index_cast %[[ARG1]] : index to i32
// CHECK: %[[VAL1:.+]] = addi %[[ARG2]], %[[ADD_OPERAND]] : i32
// CHECK: %[[VAL2:.+]] = subi %[[VAL1]], %[[SUB_OPERAND]] : i32
// CHECK: %[[VAL3:.+]] = addi %[[VAL2]], %[[ARG3]] : i32
// CHECK: linalg.yield %[[VAL3]] : i32
// CHECK-NOT: linalg.generic
// -----
// The indices of the first indexed_generic op are swapped after fusion.
#map0 = affine_map<(d0, d1) -> (d1, d0)>
#map1 = affine_map<(d0, d1) -> (d0, d1)>
func @indexed_generic_op_fusion(%arg0: tensor<?x?xi32>) {
%0 = linalg.indexed_generic {
indexing_maps = [#map0, #map0],
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
iterator_types = ["parallel", "parallel"] }
ins(%arg0 : tensor<?x?xi32>) {
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
^bb0(%arg2: index, %arg3: index, %arg4: i32): // no predecessors
%2 = index_cast %arg2 : index to i32
%3 = index_cast %arg3 : index to i32
%4 = addi %arg4, %2 : i32
%5 = subi %4, %3 : i32
linalg.yield %5 : i32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xi32>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
%1 = linalg.indexed_generic {
indexing_maps = [#map1, #map1],
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
iterator_types = ["parallel", "parallel"] }
ins(%0 : tensor<?x?xi32>) {
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
^bb0(%arg2: index, %arg3: index, %arg4: i32): // no predecessors
%2 = index_cast %arg2 : index to i32
%3 = index_cast %arg3 : index to i32
%4 = addi %arg4, %2 : i32
%5 = subi %4, %3 : i32
linalg.yield %5 : i32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?xi32>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
return
}
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d0, d1)>
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
// CHECK-LABEL: func @indexed_generic_op_fusion
// CHECK: linalg.indexed_generic
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP0]]]
[mlir][Linalg] Add support for fusion between indexed_generic ops and generic ops on tensors. Summary: Different from the fusion between generic ops, indices are involved. In this context, we need to re-map the indices for producer since the fused op is built on consumer's perspective. This patch supports all combination of the fusion between indexed_generic ops and generic ops, which includes tests case: 1) generic op as producer and indexed_generic op as consumer. 2) indexed_generic op as producer and generic op as consumer. 3) indexed_generic op as producer and indexed_generic op as consumer. Differential Revision: https://reviews.llvm.org/D80347
2020-06-04 05:58:19 +08:00
// CHECK: ^{{[a-zA-Z0-9_]*}}
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]*]]: index
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]*]]: index
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9_]*]]: i32
// CHECK: %[[ADD_OPERAND1:.+]] = index_cast %[[ARG1]] : index to i32
// CHECK: %[[SUB_OPERAND1:.+]] = index_cast %[[ARG0]] : index to i32
// CHECK: %[[VAL1:.+]] = addi %[[ARG2]], %[[ADD_OPERAND1]] : i32
// CHECK: %[[VAL2:.+]] = subi %[[VAL1]], %[[SUB_OPERAND1]] : i32
// CHECK: %[[ADD_OPERAND2:.+]] = index_cast %[[ARG0]] : index to i32
// CHECK: %[[SUB_OPERAND2:.+]] = index_cast %[[ARG1]] : index to i32
// CHECK: %[[VAL3:.+]] = addi %[[VAL2]], %[[ADD_OPERAND2]] : i32
// CHECK: %[[VAL4:.+]] = subi %[[VAL3]], %[[SUB_OPERAND2]] : i32
// CHECK: linalg.yield %[[VAL4]] : i32
// CHECK-NOT: linalg.indexed_generic
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
// -----
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1 * 4 + d2, d3)>
// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
#map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
func @indexed_generic_op_reshape_producer_fusion(%arg0 : tensor<?x?x?xi32>)
-> tensor<?x?x4x?xi32> {
%0 = linalg.tensor_reshape %arg0 [affine_map<(i, j, k, l) -> (i)>,
affine_map<(i, j, k, l) -> (j, k)>,
affine_map<(i, j, k, l) -> (l)>] :
tensor<?x?x?xi32> into tensor<?x?x4x?xi32>
%1 = linalg.indexed_generic {
indexing_maps = [#map0, #map0],
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
iterator_types = ["parallel", "parallel", "parallel", "parallel"] }
ins(%0 : tensor<?x?x4x?xi32>) {
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
^bb0(%arg2: index, %arg3: index, %arg4: index, %arg5: index, %arg6: i32): // no predecessors
%2 = index_cast %arg2 : index to i32
%3 = addi %arg6, %2 : i32
linalg.yield %3 : i32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?x4x?xi32>
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
return %1 : tensor<?x?x4x?xi32>
}
// CHECK-LABEL: func @indexed_generic_op_reshape_producer_fusion
// CHECK-NOT: linalg.tensor_reshape
// CHECK: linalg.indexed_generic
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP1]]]
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
// CHECK-NOT: linalg.tensor_reshape
// -----
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1 * 20 + d2 * 5 + d3)>
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
#map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
func @indexed_generic_op_reshape_consumer_fusion(%arg0 : tensor<?x?x4x5xi32>)
-> tensor<?x?xi32> {
%0 = linalg.indexed_generic {
indexing_maps = [#map0, #map0],
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
iterator_types = ["parallel", "parallel", "parallel", "parallel"] }
ins(%arg0 : tensor<?x?x4x5xi32>) {
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
^bb0(%arg2: index, %arg3: index, %arg4: index, %arg5: index, %arg6: i32): // no predecessors
%2 = index_cast %arg2 : index to i32
%3 = addi %arg6, %2 : i32
linalg.yield %3 : i32
[mlir][Linalg] Uniformize linalg.generic with named ops. This revision allows representing a reduction at the level of linalg on tensors for generic ops by uniformizing with the named ops approach.
2020-09-22 03:30:42 +08:00
} -> tensor<?x?x4x5xi32>
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
%1 = linalg.tensor_reshape %0 [affine_map<(i, j, k, l) -> (i)>,
affine_map<(i, j, k, l) -> (j, k, l)>] :
tensor<?x?x4x5xi32> into tensor<?x?xi32>
return %1 : tensor<?x?xi32>
}
// CHECK-LABEL: func @indexed_generic_op_reshape_consumer_fusion
// CHECK-NOT: linalg.tensor_reshape
// CHECK: linalg.indexed_generic
Enable FileCheck -enable-var-scope by default in MLIR test This option avoids to accidentally reuse variable across -LABEL match, it can be explicitly opted-in by prefixing the variable name with $ Differential Revision: https://reviews.llvm.org/D81531
2020-06-12 08:34:35 +08:00
// CHECK-SAME: indexing_maps = [#[[$MAP0]], #[[$MAP1]]]
[mlir][Linalg] Add support for fusion between indexed_generic ops and tensor_reshape ops Summary: The fusion for tensor_reshape is embedding the information to indexing maps, thus the exising pattenr also works for indexed_generic ops. Depends On D80347 Differential Revision: https://reviews.llvm.org/D80348
2020-06-04 05:55:10 +08:00
// CHECK-NOT: linalg.tensor_reshape