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/transform-patterns.mlir

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

398 lines
22 KiB
MLIR
Raw Normal View History

[mlir][Linalg] Mostly NFC - Refactor Linalg patterns and transformations. Linalg transformations are currently exposed as DRRs. Unfortunately RewriterGen does not play well with the line of work on named linalg ops which require variadic operands and results. Additionally, DRR is arguably not the right abstraction to expose compositions of such patterns that don't rely on SSA use-def semantics. This revision abandons DRRs and exposes manually written C++ patterns. Refactorings and cleanups are performed to uniformize APIs. This refactoring will allow replacing the currently manually specified Linalg named ops. A collateral victim of this refactoring is the `tileAndFuse` DRR, and the one associated test, which will be revived at a later time. Lastly, the following 2 tests do not add value and are altered: - a dot_perm tile + interchange test does not test anything new and is removed - a dot tile + lower to loops does not need 2-D tiling and is trimmed.
2020-05-02 13:03:37 +08:00
// RUN: mlir-opt %s -test-linalg-transform-patterns=test-patterns | FileCheck %s
Add basic support for declarative Linalg transformations Linalg ops provide a good anchor for pattern matching/rewriting transformations. This CL adds a simple example of how multi-level tiling may be specified by attaching a simple StringAttr to ops as they are transformed so we can easily specify partial lowering to control transformation application. This is a first stab at taking advantage of higher-level information contained in Linalg ops and will evolve in the future. PiperOrigin-RevId: 277497958
2019-10-30 22:12:07 +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: #[[$STRIDED_1D:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// Map corresponding to a 2D memory access where the stride along the last dim is known to be 1.
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: #[[$STRIDED_2D_u_1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// Map corresponding to a 2D memory access where the stride along all dims are unknown.
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: #[[$STRIDED_2D:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
// CHECK-DAG: #[[$mk:.*]] = affine_map<(d0, d1, d2) -> (d0, d2)>
// CHECK-DAG: #[[$kn:.*]] = affine_map<(d0, d1, d2) -> (d2, d1)>
// CHECK-DAG: #[[$mn:.*]] = affine_map<(d0, d1, d2) -> (d0, d1)>
// CHECK-DAG: #[[$nm:.*]] = affine_map<(d0, d1, d2) -> (d1, d0)>
// CHECK-DAG: #[[$km:.*]] = affine_map<(d0, d1, d2) -> (d2, d0)>
Add basic support for declarative Linalg transformations Linalg ops provide a good anchor for pattern matching/rewriting transformations. This CL adds a simple example of how multi-level tiling may be specified by attaching a simple StringAttr to ops as they are transformed so we can easily specify partial lowering to control transformation application. This is a first stab at taking advantage of higher-level information contained in Linalg ops and will evolve in the future. PiperOrigin-RevId: 277497958
2019-10-30 22:12:07 +08:00
func @dot(%x: memref<?xf32, offset: ?, strides: [1]>,
%y: memref<?xf32, offset: ?, strides: [1]>,
%v: memref<f32>) {
[mlir][Linalg] NFC - Make markers use Identifier instead of StringRef Summary: This removes string ownership worries by putting everything into the context and allows more constructing identifiers programmatically. Reviewers: ftynse Subscribers: mehdi_amini, rriddle, jpienaar, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, aartbik, liufengdb, stephenneuendorffer, Joonsoo, grosul1, frgossen, Kayjukh, jurahul Tags: #mlir Differential Revision: https://reviews.llvm.org/D81027
2020-06-03 03:14:32 +08:00
linalg.dot(%x, %y, %v) { __internal_linalg_transform__ = "MEM" } :
memref<?xf32, offset: ?, strides: [1]>,
memref<?xf32, offset: ?, strides: [1]>,
memref<f32>
Add basic support for declarative Linalg transformations Linalg ops provide a good anchor for pattern matching/rewriting transformations. This CL adds a simple example of how multi-level tiling may be specified by attaching a simple StringAttr to ops as they are transformed so we can easily specify partial lowering to control transformation application. This is a first stab at taking advantage of higher-level information contained in Linalg ops and will evolve in the future. PiperOrigin-RevId: 277497958
2019-10-30 22:12:07 +08:00
return
}
// CHECK-LABEL: func @dot
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-DAG: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c1:.*]] = constant 1 : index
// CHECK-DAG: %[[c8000:.*]] = constant 8000 : index
[mlir] Change dialect namespace loop->scf All ops of the SCF dialect now use the `scf.` prefix instead of `loop.`. This is a part of dialect renaming. Differential Revision: https://reviews.llvm.org/D79844
2020-05-13 18:12:30 +08:00
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c8000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c1]] {
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK: load
// CHECK: load
// CHECK: mulf
// CHECK: load
// CHECK: addf
// CHECK: store
Add basic support for declarative Linalg transformations Linalg ops provide a good anchor for pattern matching/rewriting transformations. This CL adds a simple example of how multi-level tiling may be specified by attaching a simple StringAttr to ops as they are transformed so we can easily specify partial lowering to control transformation application. This is a first stab at taking advantage of higher-level information contained in Linalg ops and will evolve in the future. PiperOrigin-RevId: 277497958
2019-10-30 22:12:07 +08:00
func @matvec(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%x: memref<?xf32, offset: ?, strides: [1]>,
%y: memref<?xf32, offset: ?, strides: [1]>) {
[mlir][Linalg] NFC - Make markers use Identifier instead of StringRef Summary: This removes string ownership worries by putting everything into the context and allows more constructing identifiers programmatically. Reviewers: ftynse Subscribers: mehdi_amini, rriddle, jpienaar, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, aartbik, liufengdb, stephenneuendorffer, Joonsoo, grosul1, frgossen, Kayjukh, jurahul Tags: #mlir Differential Revision: https://reviews.llvm.org/D81027
2020-06-03 03:14:32 +08:00
linalg.matvec(%A, %x, %y) :
memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?xf32, offset: ?, strides: [1]>,
memref<?xf32, offset: ?, strides: [1]>
Add basic support for declarative Linalg transformations Linalg ops provide a good anchor for pattern matching/rewriting transformations. This CL adds a simple example of how multi-level tiling may be specified by attaching a simple StringAttr to ops as they are transformed so we can easily specify partial lowering to control transformation application. This is a first stab at taking advantage of higher-level information contained in Linalg ops and will evolve in the future. PiperOrigin-RevId: 277497958
2019-10-30 22:12:07 +08:00
return
}
// CHECK-LABEL: func @matvec
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-DAG: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c5:.*]] = constant 5 : index
// CHECK-DAG: %[[c6:.*]] = constant 6 : index
[mlir][Linalg] Avoid using scf.parallel for non-parallel loops in Linalg ops. Modifying the loop nest builder for generating scf.parallel loops to not generate scf.parallel loops for non-parallel iterator types in Linalg operations. The existing implementation incorrectly generated scf.parallel for all tiled loops. It is rectified by refactoring logic used while lowering to loops that accounted for this. Differential Revision: https://reviews.llvm.org/D80188
2020-05-27 07:35:20 +08:00
// CHECK: scf.parallel {{.*}} step (%[[c5]])
// CHECK: scf.for {{.*}} step %[[c6]]
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: linalg.matvec({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[$STRIDED_2D]]>, memref<?xf32, #[[$STRIDED_1D]]>, memref<?xf32, #[[$STRIDED_1D]]>
Add basic support for declarative Linalg transformations Linalg ops provide a good anchor for pattern matching/rewriting transformations. This CL adds a simple example of how multi-level tiling may be specified by attaching a simple StringAttr to ops as they are transformed so we can easily specify partial lowering to control transformation application. This is a first stab at taking advantage of higher-level information contained in Linalg ops and will evolve in the future. PiperOrigin-RevId: 277497958
2019-10-30 22:12:07 +08:00
func @matmul(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%B: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%C: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
linalg.matmul(%A, %B, %C) { __internal_linalg_transform__ = "MEM" } :
memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>
Add basic support for declarative Linalg transformations Linalg ops provide a good anchor for pattern matching/rewriting transformations. This CL adds a simple example of how multi-level tiling may be specified by attaching a simple StringAttr to ops as they are transformed so we can easily specify partial lowering to control transformation application. This is a first stab at taking advantage of higher-level information contained in Linalg ops and will evolve in the future. PiperOrigin-RevId: 277497958
2019-10-30 22:12:07 +08:00
return
}
// CHECK-LABEL: func @matmul
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-DAG: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c2:.*]] = constant 2 : index
// CHECK-DAG: %[[c3:.*]] = constant 3 : index
// CHECK-DAG: %[[c4:.*]] = constant 4 : index
// CHECK-DAG: %[[c20:.*]] = constant 20 : index
// CHECK-DAG: %[[c30:.*]] = constant 30 : index
// CHECK-DAG: %[[c40:.*]] = constant 40 : index
// CHECK-DAG: %[[c200:.*]] = constant 200 : index
// CHECK-DAG: %[[c300:.*]] = constant 300 : index
// CHECK-DAG: %[[c400:.*]] = constant 400 : index
// CHECK-DAG: %[[c2000:.*]] = constant 2000 : index
// CHECK-DAG: %[[c3000:.*]] = constant 3000 : index
// CHECK-DAG: %[[c4000:.*]] = constant 4000 : index
[mlir] Change dialect namespace loop->scf All ops of the SCF dialect now use the `scf.` prefix instead of `loop.`. This is a part of dialect renaming. Differential Revision: https://reviews.llvm.org/D79844
2020-05-13 18:12:30 +08:00
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c200]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c300]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c400]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c20]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c30]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c40]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c2]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c3]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c4]] {
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
// CHECK: linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[$STRIDED_2D]]>, memref<?x?xf32, #[[$STRIDED_2D]]>, memref<?x?xf32, #[[$STRIDED_2D]]>
Add Linalg pattern for producer-consumer fusion This CL adds a simple pattern for specifying producer-consumer fusion on Linalg operations. Implementing such an extension reveals some interesting properties. Since Linalg operates on a buffer abstraction, the output buffers are specified as in/out parameters to the ops. As a consequence, there are no SSA use-def chains and one cannot specify complex dag input patterns with the current infrastructure. Instead this CL uses constraints based on the existing linalg dependence analysis to focus the pattern and refine patterns based on the type of op that last wrote in a buffer. This is a very local property and is less powerful than the generic dag specification based on SSA use-def chains. This will be generalized in the future. PiperOrigin-RevId: 277931503
2019-11-01 23:29:42 +08:00
[StructuredOps][Linalg] Add a primitive pattern to rewrite the linalg.generic form of matmul to vector form. This CL uses the newly expanded matcher support to easily detect when a linalg.generic has a multiply-accumulate body. A linalg.generic with such a body is rewritten as a vector contraction. This CL additionally limits the rewrite to the case of matrix multiplication on contiguous and statically shaped memrefs for now. Before expanding further, we should harden the infrastructure for expressing custom ops with the structured ops abstraction. PiperOrigin-RevId: 284566659
2019-12-10 01:14:05 +08:00
#matmul_trait = {
Continue refactoring StructuredOps utilities This CL adds more common information to StructuredOpsUtils.h The n_view attribute is retired in favor of args_in + args_out but the CL is otherwise NFC. PiperOrigin-RevId: 285000621
2019-12-12 01:26:51 +08:00
args_in = 2,
args_out = 1,
[StructuredOps][Linalg] Add a primitive pattern to rewrite the linalg.generic form of matmul to vector form. This CL uses the newly expanded matcher support to easily detect when a linalg.generic has a multiply-accumulate body. A linalg.generic with such a body is rewritten as a vector contraction. This CL additionally limits the rewrite to the case of matrix multiplication on contiguous and statically shaped memrefs for now. Before expanding further, we should harden the infrastructure for expressing custom ops with the structured ops abstraction. PiperOrigin-RevId: 284566659
2019-12-10 01:14:05 +08:00
indexing_maps = [
[mlir] Change the syntax of AffineMapAttr and IntegerSetAttr to avoid conflicts with function types. Summary: The current syntax for AffineMapAttr and IntegerSetAttr conflict with function types, making it currently impossible to round-trip function types(and e.g. FuncOp) in the IR. This revision changes the syntax for the attributes by wrapping them in a keyword. AffineMapAttr is wrapped with `affine_map<>` and IntegerSetAttr is wrapped with `affine_set<>`. Reviewed By: nicolasvasilache, ftynse Differential Revision: https://reviews.llvm.org/D72429
2020-01-14 05:12:37 +08:00
affine_map<(m, n, k) -> (m, k)>,
affine_map<(m, n, k) -> (k, n)>,
affine_map<(m, n, k) -> (m, n)>
[StructuredOps][Linalg] Add a primitive pattern to rewrite the linalg.generic form of matmul to vector form. This CL uses the newly expanded matcher support to easily detect when a linalg.generic has a multiply-accumulate body. A linalg.generic with such a body is rewritten as a vector contraction. This CL additionally limits the rewrite to the case of matrix multiplication on contiguous and statically shaped memrefs for now. Before expanding further, we should harden the infrastructure for expressing custom ops with the structured ops abstraction. PiperOrigin-RevId: 284566659
2019-12-10 01:14:05 +08:00
],
iterator_types = ["parallel", "parallel", "reduction"],
[mlir][Linalg] Extend linalg vectorization to MatmulOp Summary: This is a simple extension to allow vectorization to work not only on GenericLinalgOp but more generally across named ops too. For now, this still only vectorizes matmul-like ops but is a step towards more generic vectorization of Linalg ops. Reviewers: ftynse Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, aartbik, liufengdb, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D72942
2020-01-18 03:26:50 +08:00
__internal_linalg_transform__ = "VECTORIZE"
[StructuredOps][Linalg] Add a primitive pattern to rewrite the linalg.generic form of matmul to vector form. This CL uses the newly expanded matcher support to easily detect when a linalg.generic has a multiply-accumulate body. A linalg.generic with such a body is rewritten as a vector contraction. This CL additionally limits the rewrite to the case of matrix multiplication on contiguous and statically shaped memrefs for now. Before expanding further, we should harden the infrastructure for expressing custom ops with the structured ops abstraction. PiperOrigin-RevId: 284566659
2019-12-10 01:14:05 +08:00
}
func @vectorization_test(%A: memref<8x16xf32>, %B: memref<16x32xf32>,
%C: memref<8x32xf32>) {
linalg.generic #matmul_trait %A, %B, %C {
^bb(%a: f32, %b: f32, %c: f32) :
%d = mulf %a, %b: f32
%e = addf %c, %d: f32
linalg.yield %e : f32
} : memref<8x16xf32>, memref<16x32xf32>, memref<8x32xf32>
return
}
// CHECK-LABEL: func @vectorization_test
[mlir][Linalg] Make contraction vectorization use vector transfers This revision replaces the load + vector.type_cast by appropriate vector transfer operations. These play more nicely with other vector abstractions and canonicalization patterns and lower to load/store with or without masks when appropriate. Differential Revision: https://reviews.llvm.org/D80809
2020-05-30 01:09:55 +08:00
// CHECK: vector.transfer_read %{{.*}} : memref<8x16xf32>, vector<8x16xf32>
// CHECK: vector.transfer_read %{{.*}} : memref<16x32xf32>, vector<16x32xf32>
// CHECK: vector.transfer_read %{{.*}} : memref<8x32xf32>, vector<8x32xf32>
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: vector.contract {indexing_maps = [#[[$mk]], #[[$kn]], #[[$mn]]], iterator_types = ["parallel", "parallel", "reduction"]} %{{.*}}, %{{.*}}, %{{.*}} : vector<8x16xf32>, vector<16x32xf32> into vector<8x32xf32>
[mlir][Linalg] Make contraction vectorization use vector transfers This revision replaces the load + vector.type_cast by appropriate vector transfer operations. These play more nicely with other vector abstractions and canonicalization patterns and lower to load/store with or without masks when appropriate. Differential Revision: https://reviews.llvm.org/D80809
2020-05-30 01:09:55 +08:00
// CHECK: vector.transfer_write %{{.*}}, %{{.*}} : vector<8x32xf32>, memref<8x32xf32>
[mlir][Linalg] Extend linalg vectorization to MatmulOp Summary: This is a simple extension to allow vectorization to work not only on GenericLinalgOp but more generally across named ops too. For now, this still only vectorizes matmul-like ops but is a step towards more generic vectorization of Linalg ops. Reviewers: ftynse Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, aartbik, liufengdb, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D72942
2020-01-18 03:26:50 +08:00
func @vectorization_test_2(%A: memref<8x16xf32>, %B: memref<16x32xf32>,
%C: memref<8x32xf32>) {
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
linalg.matmul(%A, %B, %C) { __internal_linalg_transform__ = "VECTORIZE"} :
memref<8x16xf32>, memref<16x32xf32>, memref<8x32xf32>
[mlir][Linalg] Extend linalg vectorization to MatmulOp Summary: This is a simple extension to allow vectorization to work not only on GenericLinalgOp but more generally across named ops too. For now, this still only vectorizes matmul-like ops but is a step towards more generic vectorization of Linalg ops. Reviewers: ftynse Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, aartbik, liufengdb, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D72942
2020-01-18 03:26:50 +08:00
return
}
// CHECK-LABEL: func @vectorization_test_2
// CHECK: vector.contract {{.*}} :
// vector<8x16xf32>, vector<16x32xf32> into vector<8x32xf32>
[mlir] Add primitive transform pattern to rewrite linalg.fill into vector.broadcast form. Summary: This diff adds a transformation patter to rewrite linalg.fill as broadcasting a scaler into a vector. It uses the same preconditioning as matmul (memory is contiguous). Reviewers: nicolasvasilache Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, aartbik, liufengdb, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D73391
2020-01-25 08:23:16 +08:00
func @test_vectorize_fill(%A : memref<8x16xf32>, %arg0 : f32) {
linalg.fill(%A, %arg0) { __internal_linalg_transform__ = "VECTORIZE"} : memref<8x16xf32>, f32
return
}
// CHECK-LABEL: func @test_vectorize_fill
// CHECK: vector.broadcast {{.*}} : f32 to vector<8x16xf32>
[Linalg] Add a Linalg iterator permutation transformation This patch closes issue tensorflow/mlir#272 We add a standalone iterator permutation transformation to Linalg. This transformation composes a permutation map with the maps in the "indexing_maps" attribute. It also permutes "iterator_types" accordingly. Change-Id: I7c1e693b8203aeecc595a7c012e738ca1100c857 Closes tensorflow/mlir#307 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/307 from tetuante:issue272 f7908d58792f4111119721885e247045104f1131 PiperOrigin-RevId: 284824102
2019-12-11 04:25:10 +08:00
#matmul_accesses = [
[mlir][Linalg] Drop function attribute from generic ops. The function attribute in generic ops is not paying for itself. A region is the more standardized way of specifying a custom computation. If needed this region can call a function directly. This is deemed more natural than managing a dedicated function attribute. This also simplifies named ops generation by trimming unnecessary complexity. Differential Revision: https://reviews.llvm.org/D78266
2020-04-16 21:46:00 +08:00
affine_map<(m, n, k) -> (m, k)>,
affine_map<(m, n, k) -> (k, n)>,
affine_map<(m, n, k) -> (m, n)>
[Linalg] Add a Linalg iterator permutation transformation This patch closes issue tensorflow/mlir#272 We add a standalone iterator permutation transformation to Linalg. This transformation composes a permutation map with the maps in the "indexing_maps" attribute. It also permutes "iterator_types" accordingly. Change-Id: I7c1e693b8203aeecc595a7c012e738ca1100c857 Closes tensorflow/mlir#307 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/307 from tetuante:issue272 f7908d58792f4111119721885e247045104f1131 PiperOrigin-RevId: 284824102
2019-12-11 04:25:10 +08:00
]
#generic_matmul_trait = {
[mlir][Linalg] Drop function attribute from generic ops. The function attribute in generic ops is not paying for itself. A region is the more standardized way of specifying a custom computation. If needed this region can call a function directly. This is deemed more natural than managing a dedicated function attribute. This also simplifies named ops generation by trimming unnecessary complexity. Differential Revision: https://reviews.llvm.org/D78266
2020-04-16 21:46:00 +08:00
args_in = 2,
args_out = 1,
indexing_maps = #matmul_accesses,
library_call = "linalg_matmul",
iterator_types = ["parallel", "parallel", "reduction"]
}
[Linalg] Add a Linalg iterator permutation transformation This patch closes issue tensorflow/mlir#272 We add a standalone iterator permutation transformation to Linalg. This transformation composes a permutation map with the maps in the "indexing_maps" attribute. It also permutes "iterator_types" accordingly. Change-Id: I7c1e693b8203aeecc595a7c012e738ca1100c857 Closes tensorflow/mlir#307 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/307 from tetuante:issue272 f7908d58792f4111119721885e247045104f1131 PiperOrigin-RevId: 284824102
2019-12-11 04:25:10 +08:00
func @permute_generic(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%B: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%C: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
[mlir][Linalg] Drop function attribute from generic ops. The function attribute in generic ops is not paying for itself. A region is the more standardized way of specifying a custom computation. If needed this region can call a function directly. This is deemed more natural than managing a dedicated function attribute. This also simplifies named ops generation by trimming unnecessary complexity. Differential Revision: https://reviews.llvm.org/D78266
2020-04-16 21:46:00 +08:00
linalg.generic #generic_matmul_trait %A, %B, %C {
^bb(%a: f32, %b: f32, %c: f32):
%d = mulf %a, %b: f32
%e = addf %c, %d: f32
linalg.yield %e: f32
}: memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>
[Linalg] Add a Linalg iterator permutation transformation This patch closes issue tensorflow/mlir#272 We add a standalone iterator permutation transformation to Linalg. This transformation composes a permutation map with the maps in the "indexing_maps" attribute. It also permutes "iterator_types" accordingly. Change-Id: I7c1e693b8203aeecc595a7c012e738ca1100c857 Closes tensorflow/mlir#307 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/307 from tetuante:issue272 f7908d58792f4111119721885e247045104f1131 PiperOrigin-RevId: 284824102
2019-12-11 04:25:10 +08:00
return
}
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-LABEL: func @permute_generic
// CHECK: linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
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 = [#[[$kn]], #[[$nm]], #[[$km]]],
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-SAME: iterator_types = ["parallel", "reduction", "parallel"],
// CHECK-SAME: library_call = "linalg_matmul"} %{{.*}}, %{{.*}}, %{{.*}}
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: memref<?x?xf32, #[[$STRIDED_2D_u_1]]>,
// CHECK-SAME: memref<?x?xf32, #[[$STRIDED_2D_u_1]]>,
// CHECK-SAME: memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
[Linalg] Add a Linalg iterator permutation transformation This patch closes issue tensorflow/mlir#272 We add a standalone iterator permutation transformation to Linalg. This transformation composes a permutation map with the maps in the "indexing_maps" attribute. It also permutes "iterator_types" accordingly. Change-Id: I7c1e693b8203aeecc595a7c012e738ca1100c857 Closes tensorflow/mlir#307 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/307 from tetuante:issue272 f7908d58792f4111119721885e247045104f1131 PiperOrigin-RevId: 284824102
2019-12-11 04:25:10 +08:00
#indexed_matmul_trait = {
[mlir][Linalg] Drop function attribute from generic ops. The function attribute in generic ops is not paying for itself. A region is the more standardized way of specifying a custom computation. If needed this region can call a function directly. This is deemed more natural than managing a dedicated function attribute. This also simplifies named ops generation by trimming unnecessary complexity. Differential Revision: https://reviews.llvm.org/D78266
2020-04-16 21:46:00 +08:00
args_in = 2,
args_out = 1,
indexing_maps = #matmul_accesses,
library_call = "linalg_matmul_indexed",
iterator_types = ["parallel", "parallel", "reduction"]
[Linalg] Add a Linalg iterator permutation transformation This patch closes issue tensorflow/mlir#272 We add a standalone iterator permutation transformation to Linalg. This transformation composes a permutation map with the maps in the "indexing_maps" attribute. It also permutes "iterator_types" accordingly. Change-Id: I7c1e693b8203aeecc595a7c012e738ca1100c857 Closes tensorflow/mlir#307 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/307 from tetuante:issue272 f7908d58792f4111119721885e247045104f1131 PiperOrigin-RevId: 284824102
2019-12-11 04:25:10 +08:00
}
[mlir][Linalg] Drop function attribute from generic ops. The function attribute in generic ops is not paying for itself. A region is the more standardized way of specifying a custom computation. If needed this region can call a function directly. This is deemed more natural than managing a dedicated function attribute. This also simplifies named ops generation by trimming unnecessary complexity. Differential Revision: https://reviews.llvm.org/D78266
2020-04-16 21:46:00 +08:00
func @permute_generic_indexed(
%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%B: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%C: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
linalg.indexed_generic #indexed_matmul_trait %A, %B, %C {
^bb(%i: index, %j: index, %k: index, %a: f32, %b: f32, %c: f32):
%d = mulf %a, %b: f32
%e = addf %c, %d: f32
linalg.yield %e: f32
} : memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>
[Linalg] Add a Linalg iterator permutation transformation This patch closes issue tensorflow/mlir#272 We add a standalone iterator permutation transformation to Linalg. This transformation composes a permutation map with the maps in the "indexing_maps" attribute. It also permutes "iterator_types" accordingly. Change-Id: I7c1e693b8203aeecc595a7c012e738ca1100c857 Closes tensorflow/mlir#307 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/307 from tetuante:issue272 f7908d58792f4111119721885e247045104f1131 PiperOrigin-RevId: 284824102
2019-12-11 04:25:10 +08:00
return
}
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-LABEL: func @permute_generic_indexed
// CHECK: linalg.indexed_generic {args_in = 2 : i64, args_out = 1 : i64,
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 = [#[[$kn]], #[[$nm]], #[[$km]]],
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-SAME: iterator_types = ["parallel", "reduction", "parallel"],
// CHECK-SAME: library_call = "linalg_matmul_indexed"} %{{.*}}, %{{.*}}, %{{.*}}
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: memref<?x?xf32, #[[$STRIDED_2D_u_1]]>,
// CHECK-SAME: memref<?x?xf32, #[[$STRIDED_2D_u_1]]>,
// CHECK-SAME: memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
Fold TestLinalgTilePermutePatterns into TestLinalgTransformPatterns - NFC Centralize all patterns that test Linalg transforms in a single pass. PiperOrigin-RevId: 284835938
2019-12-11 05:25:41 +08:00
func @matvec_perm(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%x: memref<?xf32, offset: ?, strides: [1]>,
%y: memref<?xf32, offset: ?, strides: [1]>) {
linalg.matvec(%A, %x, %y) {__internal_linalg_transform__ = "__with_perm__"} :
memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?xf32, offset: ?, strides: [1]>,
memref<?xf32, offset: ?, strides: [1]>
return
}
// CHECK-LABEL: func @matvec_perm
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-DAG: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c5:.*]] = constant 5 : index
// CHECK-DAG: %[[c6:.*]] = constant 6 : index
[mlir] Change dialect namespace loop->scf All ops of the SCF dialect now use the `scf.` prefix instead of `loop.`. This is a part of dialect renaming. Differential Revision: https://reviews.llvm.org/D79844
2020-05-13 18:12:30 +08:00
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c6]]
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c5]]
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: linalg.matvec({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[$STRIDED_2D]]>, memref<?xf32, #[[$STRIDED_1D]]>, memref<?xf32, #[[$STRIDED_1D]]>
Fold TestLinalgTilePermutePatterns into TestLinalgTransformPatterns - NFC Centralize all patterns that test Linalg transforms in a single pass. PiperOrigin-RevId: 284835938
2019-12-11 05:25:41 +08:00
func @matmul_perm(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%B: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%C: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
linalg.matmul(%A, %B, %C) {__internal_linalg_transform__ = "__with_perm__"} :
memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>,
memref<?x?xf32, offset: ?, strides: [?, 1]>
Fold TestLinalgTilePermutePatterns into TestLinalgTransformPatterns - NFC Centralize all patterns that test Linalg transforms in a single pass. PiperOrigin-RevId: 284835938
2019-12-11 05:25:41 +08:00
return
}
// CHECK-LABEL: func @matmul_perm
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK-DAG: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c20:.*]] = constant 20 : index
// CHECK-DAG: %[[c30:.*]] = constant 30 : index
// CHECK-DAG: %[[c40:.*]] = constant 40 : index
// CHECK-DAG: %[[c200:.*]] = constant 200 : index
// CHECK-DAG: %[[c300:.*]] = constant 300 : index
// CHECK-DAG: %[[c400:.*]] = constant 400 : index
// CHECK-DAG: %[[c2000:.*]] = constant 2000 : index
// CHECK-DAG: %[[c3000:.*]] = constant 3000 : index
// CHECK-DAG: %[[c4000:.*]] = constant 4000 : index
[mlir] Change dialect namespace loop->scf All ops of the SCF dialect now use the `scf.` prefix instead of `loop.`. This is a part of dialect renaming. Differential Revision: https://reviews.llvm.org/D79844
2020-05-13 18:12:30 +08:00
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c300]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c200]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c400]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c20]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c30]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c40]] {
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
// CHECK: linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[$STRIDED_2D]]>, memref<?x?xf32, #[[$STRIDED_2D]]>, memref<?x?xf32, #[[$STRIDED_2D]]>
[Linalg] Expose subview promotion as a declarative pattern This PR targest issue tensorflow/mlir#295. It exposes the already existing subiew promotion pass as a declarative pattern Change-Id: If901ebef9fb53fcd0b12ecc536f6b174ce320b92 Closes tensorflow/mlir#315 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/315 from tetuante:issue295 8e5f268b6d85f31015c33505329dbd7a4db97ac5 PiperOrigin-RevId: 285801463
2019-12-17 02:36:06 +08:00
func @promote_subview_matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%arg2: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
%c2000 = constant 2000 : index
%c3000 = constant 3000 : index
%c4000 = constant 4000 : index
%c0 = constant 0 : index
%c1 = constant 1 : index
[MLIR][Standard] Make the `dim` operation index an operand. Allow for dynamic indices in the `dim` operation. Rather than an attribute, the index is now an operand of type `index`. This allows to apply the operation to dynamically ranked tensors. The correct lowering of dynamic indices remains to be implemented. Differential Revision: https://reviews.llvm.org/D81551
2020-06-10 21:52:43 +08:00
%0 = dim %arg0, %c0 : memref<?x?xf32, offset: ?, strides: [?, 1]>
%1 = dim %arg0, %c1 : memref<?x?xf32, offset: ?, strides: [?, 1]>
%2 = dim %arg1, %c1 : memref<?x?xf32, offset: ?, strides: [?, 1]>
[mlir] Change dialect namespace loop->scf All ops of the SCF dialect now use the `scf.` prefix instead of `loop.`. This is a part of dialect renaming. Differential Revision: https://reviews.llvm.org/D79844
2020-05-13 18:12:30 +08:00
scf.for %arg3 = %c0 to %0 step %c2000 {
scf.for %arg4 = %c0 to %2 step %c3000 {
scf.for %arg5 = %c0 to %1 step %c4000 {
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
%3 = subview %arg0[%arg3, %arg5][%c2000, %c4000][%c1, %c1] :
[Linalg] Expose subview promotion as a declarative pattern This PR targest issue tensorflow/mlir#295. It exposes the already existing subiew promotion pass as a declarative pattern Change-Id: If901ebef9fb53fcd0b12ecc536f6b174ce320b92 Closes tensorflow/mlir#315 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/315 from tetuante:issue295 8e5f268b6d85f31015c33505329dbd7a4db97ac5 PiperOrigin-RevId: 285801463
2019-12-17 02:36:06 +08:00
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
%4 = subview %arg1[%arg5, %arg4][%c4000, %c3000][%c1, %c1] :
[Linalg] Expose subview promotion as a declarative pattern This PR targest issue tensorflow/mlir#295. It exposes the already existing subiew promotion pass as a declarative pattern Change-Id: If901ebef9fb53fcd0b12ecc536f6b174ce320b92 Closes tensorflow/mlir#315 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/315 from tetuante:issue295 8e5f268b6d85f31015c33505329dbd7a4db97ac5 PiperOrigin-RevId: 285801463
2019-12-17 02:36:06 +08:00
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
%5 = subview %arg2[%arg3, %arg4][%c2000, %c3000][%c1, %c1] :
[Linalg] Expose subview promotion as a declarative pattern This PR targest issue tensorflow/mlir#295. It exposes the already existing subiew promotion pass as a declarative pattern Change-Id: If901ebef9fb53fcd0b12ecc536f6b174ce320b92 Closes tensorflow/mlir#315 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/315 from tetuante:issue295 8e5f268b6d85f31015c33505329dbd7a4db97ac5 PiperOrigin-RevId: 285801463
2019-12-17 02:36:06 +08:00
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
linalg.matmul(%3, %4, %5) {__internal_linalg_transform__ = "_promote_views_"} :
memref<?x?xf32, offset: ?, strides: [?, ?]>,
memref<?x?xf32, offset: ?, strides: [?, ?]>,
memref<?x?xf32, offset: ?, strides: [?, ?]>
[Linalg] Expose subview promotion as a declarative pattern This PR targest issue tensorflow/mlir#295. It exposes the already existing subiew promotion pass as a declarative pattern Change-Id: If901ebef9fb53fcd0b12ecc536f6b174ce320b92 Closes tensorflow/mlir#315 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/315 from tetuante:issue295 8e5f268b6d85f31015c33505329dbd7a4db97ac5 PiperOrigin-RevId: 285801463
2019-12-17 02:36:06 +08:00
}
}
}
return
}
// CHECK-LABEL: func @promote_subview_matmul
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: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c2000:.*]] = constant 2000 : index
// CHECK-DAG: %[[c3000:.*]] = constant 3000 : index
// CHECK-DAG: %[[c4000:.*]] = constant 4000 : index
[mlir] Change dialect namespace loop->scf All ops of the SCF dialect now use the `scf.` prefix instead of `loop.`. This is a part of dialect renaming. Differential Revision: https://reviews.llvm.org/D79844
2020-05-13 18:12:30 +08:00
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK: %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[s1:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[s2:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[a0:.*]] = alloc({{%.*}}) : memref<?xi8>
[mlir] Simplify and better document std.view semantics This [discussion](https://llvm.discourse.group/t/viewop-isnt-expressive-enough/991/2) raised some concerns with ViewOp. In particular, the handling of offsets is incorrect and does not match the op description. Note that with an elemental type change, offsets cannot be part of the type in general because sizeof(srcType) != sizeof(dstType). Howerver, offset is a poorly chosen term for this purpose and is renamed to byte_shift. Additionally, for all intended purposes, trying to support non-identity layouts for this op does not bring expressive power but rather increases code complexity. This revision simplifies the existing semantics and implementation. This simplification effort is voluntarily restrictive and acts as a stepping stone towards supporting richer semantics: treat the non-common cases as YAGNI for now and reevaluate based on concrete use cases once a round of simplification occurred. Differential revision: https://reviews.llvm.org/D79541
2020-05-12 00:09:18 +08:00
// CHECK: %[[v0:.*]] = std.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?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: %[[l0:.*]] = subview %[[v0]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D]]>
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK: %[[a1:.*]] = alloc({{%.*}}) : memref<?xi8>
[mlir] Simplify and better document std.view semantics This [discussion](https://llvm.discourse.group/t/viewop-isnt-expressive-enough/991/2) raised some concerns with ViewOp. In particular, the handling of offsets is incorrect and does not match the op description. Note that with an elemental type change, offsets cannot be part of the type in general because sizeof(srcType) != sizeof(dstType). Howerver, offset is a poorly chosen term for this purpose and is renamed to byte_shift. Additionally, for all intended purposes, trying to support non-identity layouts for this op does not bring expressive power but rather increases code complexity. This revision simplifies the existing semantics and implementation. This simplification effort is voluntarily restrictive and acts as a stepping stone towards supporting richer semantics: treat the non-common cases as YAGNI for now and reevaluate based on concrete use cases once a round of simplification occurred. Differential revision: https://reviews.llvm.org/D79541
2020-05-12 00:09:18 +08:00
// CHECK: %[[v1:.*]] = std.view %[[a1]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?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: %[[l1:.*]] = subview %[[v1]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D]]>
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK: %[[a2:.*]] = alloc({{%.*}}) : memref<?xi8>
[mlir] Simplify and better document std.view semantics This [discussion](https://llvm.discourse.group/t/viewop-isnt-expressive-enough/991/2) raised some concerns with ViewOp. In particular, the handling of offsets is incorrect and does not match the op description. Note that with an elemental type change, offsets cannot be part of the type in general because sizeof(srcType) != sizeof(dstType). Howerver, offset is a poorly chosen term for this purpose and is renamed to byte_shift. Additionally, for all intended purposes, trying to support non-identity layouts for this op does not bring expressive power but rather increases code complexity. This revision simplifies the existing semantics and implementation. This simplification effort is voluntarily restrictive and acts as a stepping stone towards supporting richer semantics: treat the non-common cases as YAGNI for now and reevaluate based on concrete use cases once a round of simplification occurred. Differential revision: https://reviews.llvm.org/D79541
2020-05-12 00:09:18 +08:00
// CHECK: %[[v2:.*]] = std.view %[[a2]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?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: %[[l2:.*]] = subview %[[v2]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D]]>
[mlir] [linalg] Fix transform-patterns test. Unfortunately FileCheck ignores directives with whitespace between the directive and the colon (`CHECK :` for example), thus most of the directives of this test were ignored. Differential Revision: https://reviews.llvm.org/D78548
2020-04-21 18:51:35 +08:00
// CHECK: linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
// CHECK: linalg.copy(%[[s1]], %[[l1]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
// CHECK: linalg.copy(%[[s2]], %[[l2]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
// CHECK: linalg.matmul(%[[v0]], %[[v1]], %[[v2]]) : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>
[mlir] [linalg] Only promote selected buffers. The promotion transformation is promoting all input and output buffers of the transformed op. The user might want to only promote some of these buffers. Differential Revision: https://reviews.llvm.org/D78498
2020-04-21 17:43:28 +08:00
func @promote_first_subview_matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>,
%arg2: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
%c2000 = constant 2000 : index
%c3000 = constant 3000 : index
%c4000 = constant 4000 : index
%c0 = constant 0 : index
%c1 = constant 1 : index
[MLIR][Standard] Make the `dim` operation index an operand. Allow for dynamic indices in the `dim` operation. Rather than an attribute, the index is now an operand of type `index`. This allows to apply the operation to dynamically ranked tensors. The correct lowering of dynamic indices remains to be implemented. Differential Revision: https://reviews.llvm.org/D81551
2020-06-10 21:52:43 +08:00
%0 = dim %arg0, %c0 : memref<?x?xf32, offset: ?, strides: [?, 1]>
%1 = dim %arg0, %c1 : memref<?x?xf32, offset: ?, strides: [?, 1]>
%2 = dim %arg1, %c1 : memref<?x?xf32, offset: ?, strides: [?, 1]>
[mlir] Change dialect namespace loop->scf All ops of the SCF dialect now use the `scf.` prefix instead of `loop.`. This is a part of dialect renaming. Differential Revision: https://reviews.llvm.org/D79844
2020-05-13 18:12:30 +08:00
scf.for %arg3 = %c0 to %0 step %c2000 {
scf.for %arg4 = %c0 to %2 step %c3000 {
scf.for %arg5 = %c0 to %1 step %c4000 {
[mlir] [linalg] Only promote selected buffers. The promotion transformation is promoting all input and output buffers of the transformed op. The user might want to only promote some of these buffers. Differential Revision: https://reviews.llvm.org/D78498
2020-04-21 17:43:28 +08:00
%3 = std.subview %arg0[%arg3, %arg5][%c2000, %c4000][%c1, %c1] :
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
%4 = std.subview %arg1[%arg5, %arg4][%c4000, %c3000][%c1, %c1] :
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
%5 = std.subview %arg2[%arg3, %arg4][%c2000, %c3000][%c1, %c1] :
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
linalg.matmul(%3, %4, %5) {__internal_linalg_transform__ = "_promote_first_view_"} :
memref<?x?xf32, offset: ?, strides: [?, ?]>,
memref<?x?xf32, offset: ?, strides: [?, ?]>,
memref<?x?xf32, offset: ?, strides: [?, ?]>
[mlir] [linalg] Only promote selected buffers. The promotion transformation is promoting all input and output buffers of the transformed op. The user might want to only promote some of these buffers. Differential Revision: https://reviews.llvm.org/D78498
2020-04-21 17:43:28 +08:00
}
}
}
return
}
// CHECK-LABEL: func @promote_first_subview_matmul
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: %[[c0:.*]] = constant 0 : index
// CHECK-DAG: %[[c2000:.*]] = constant 2000 : index
// CHECK-DAG: %[[c3000:.*]] = constant 3000 : index
// CHECK-DAG: %[[c4000:.*]] = constant 4000 : index
[mlir] Change dialect namespace loop->scf All ops of the SCF dialect now use the `scf.` prefix instead of `loop.`. This is a part of dialect renaming. Differential Revision: https://reviews.llvm.org/D79844
2020-05-13 18:12:30 +08:00
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
// CHECK: scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
[mlir] [linalg] Only promote selected buffers. The promotion transformation is promoting all input and output buffers of the transformed op. The user might want to only promote some of these buffers. Differential Revision: https://reviews.llvm.org/D78498
2020-04-21 17:43:28 +08:00
// CHECK: %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[s1:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[s2:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[a0:.*]] = alloc({{%.*}}) : memref<?xi8>
[mlir] Simplify and better document std.view semantics This [discussion](https://llvm.discourse.group/t/viewop-isnt-expressive-enough/991/2) raised some concerns with ViewOp. In particular, the handling of offsets is incorrect and does not match the op description. Note that with an elemental type change, offsets cannot be part of the type in general because sizeof(srcType) != sizeof(dstType). Howerver, offset is a poorly chosen term for this purpose and is renamed to byte_shift. Additionally, for all intended purposes, trying to support non-identity layouts for this op does not bring expressive power but rather increases code complexity. This revision simplifies the existing semantics and implementation. This simplification effort is voluntarily restrictive and acts as a stepping stone towards supporting richer semantics: treat the non-common cases as YAGNI for now and reevaluate based on concrete use cases once a round of simplification occurred. Differential revision: https://reviews.llvm.org/D79541
2020-05-12 00:09:18 +08:00
// CHECK: %[[v0:.*]] = std.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?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: %[[l0:.*]] = subview %[[v0]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D]]>
[mlir] [linalg] Only promote selected buffers. The promotion transformation is promoting all input and output buffers of the transformed op. The user might want to only promote some of these buffers. Differential Revision: https://reviews.llvm.org/D78498
2020-04-21 17:43:28 +08:00
// CHECK-NOT: %[[a1:.*]] = alloc({{%.*}}) : memref<?xi8>
[mlir] Simplify and better document std.view semantics This [discussion](https://llvm.discourse.group/t/viewop-isnt-expressive-enough/991/2) raised some concerns with ViewOp. In particular, the handling of offsets is incorrect and does not match the op description. Note that with an elemental type change, offsets cannot be part of the type in general because sizeof(srcType) != sizeof(dstType). Howerver, offset is a poorly chosen term for this purpose and is renamed to byte_shift. Additionally, for all intended purposes, trying to support non-identity layouts for this op does not bring expressive power but rather increases code complexity. This revision simplifies the existing semantics and implementation. This simplification effort is voluntarily restrictive and acts as a stepping stone towards supporting richer semantics: treat the non-common cases as YAGNI for now and reevaluate based on concrete use cases once a round of simplification occurred. Differential revision: https://reviews.llvm.org/D79541
2020-05-12 00:09:18 +08:00
// CHECK-NOT: %[[v1:.*]] = std.view %[[a1]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?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-NOT: %[[l0:.*]] = subview %[[v1]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D]]>
[mlir] [linalg] Only promote selected buffers. The promotion transformation is promoting all input and output buffers of the transformed op. The user might want to only promote some of these buffers. Differential Revision: https://reviews.llvm.org/D78498
2020-04-21 17:43:28 +08:00
// CHECK-NOT: %[[a2:.*]] = alloc({{%.*}}) : memref<?xi8>
[mlir] Simplify and better document std.view semantics This [discussion](https://llvm.discourse.group/t/viewop-isnt-expressive-enough/991/2) raised some concerns with ViewOp. In particular, the handling of offsets is incorrect and does not match the op description. Note that with an elemental type change, offsets cannot be part of the type in general because sizeof(srcType) != sizeof(dstType). Howerver, offset is a poorly chosen term for this purpose and is renamed to byte_shift. Additionally, for all intended purposes, trying to support non-identity layouts for this op does not bring expressive power but rather increases code complexity. This revision simplifies the existing semantics and implementation. This simplification effort is voluntarily restrictive and acts as a stepping stone towards supporting richer semantics: treat the non-common cases as YAGNI for now and reevaluate based on concrete use cases once a round of simplification occurred. Differential revision: https://reviews.llvm.org/D79541
2020-05-12 00:09:18 +08:00
// CHECK-NOT: %[[v2:.*]] = std.view %[[a2]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?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-NOT: %[[l0:.*]] = subview %[[v2]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D]]>
[mlir] [linalg] Only promote selected buffers. The promotion transformation is promoting all input and output buffers of the transformed op. The user might want to only promote some of these buffers. Differential Revision: https://reviews.llvm.org/D78498
2020-04-21 17:43:28 +08:00
// CHECK: linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
// CHECK-NOT: linalg.copy(%[[s1]], %[[l1]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
// CHECK-NOT: linalg.copy(%[[s2]], %[[l2]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>^
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
// CHECK: linalg.matmul(%[[v0]], %[[s1]], %[[s2]]) : memref<?x?xf32>, memref<?x?xf32, #[[$STRIDED_2D]]>, memref<?x?xf32, #[[$STRIDED_2D]]>
[mlir] [linalg] Specify alignment during promotion. The buffer allocated by a promotion can be subject to other transformations afterward. For example it could be vectorized, in which case it is needed to ensure that this buffer is memory-aligned. Differential Revision: https://reviews.llvm.org/D78556
2020-04-22 00:12:11 +08:00
func @aligned_promote_fill(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
%c2000 = constant 2000 : index
%c4000 = constant 4000 : index
%c0 = constant 0 : index
%c1 = constant 1 : index
%cf = constant 1.0 : f32
%3 = std.subview %arg0[%c0, %c0][%c2000, %c4000][%c1, %c1] :
memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
linalg.fill(%3, %cf) { __internal_linalg_transform__ = "_promote_views_aligned_"}
: memref<?x?xf32, offset: ?, strides: [?, ?]>, f32
return
}
// CHECK-LABEL: func @aligned_promote_fill
// CHECK: %[[cf:.*]] = constant {{.*}} : f32
// CHECK: %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
// CHECK: %[[a0:.*]] = alloc({{%.*}}) {alignment = 32 : i64} : memref<?xi8>
[mlir] Simplify and better document std.view semantics This [discussion](https://llvm.discourse.group/t/viewop-isnt-expressive-enough/991/2) raised some concerns with ViewOp. In particular, the handling of offsets is incorrect and does not match the op description. Note that with an elemental type change, offsets cannot be part of the type in general because sizeof(srcType) != sizeof(dstType). Howerver, offset is a poorly chosen term for this purpose and is renamed to byte_shift. Additionally, for all intended purposes, trying to support non-identity layouts for this op does not bring expressive power but rather increases code complexity. This revision simplifies the existing semantics and implementation. This simplification effort is voluntarily restrictive and acts as a stepping stone towards supporting richer semantics: treat the non-common cases as YAGNI for now and reevaluate based on concrete use cases once a round of simplification occurred. Differential revision: https://reviews.llvm.org/D79541
2020-05-12 00:09:18 +08:00
// CHECK: %[[v0:.*]] = std.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?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: %[[l0:.*]] = subview %[[v0]][{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D]]>
[mlir] [linalg] Specify alignment during promotion. The buffer allocated by a promotion can be subject to other transformations afterward. For example it could be vectorized, in which case it is needed to ensure that this buffer is memory-aligned. Differential Revision: https://reviews.llvm.org/D78556
2020-04-22 00:12:11 +08:00
// CHECK: linalg.fill(%[[v0]], {{%.*}}) : memref<?x?xf32>, f32
// CHECK: linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
// CHECK: linalg.fill(%[[v0]], %[[cf]]) : memref<?x?xf32>, f32
[mlir][Linalg] Avoid using scf.parallel for non-parallel loops in Linalg ops. Modifying the loop nest builder for generating scf.parallel loops to not generate scf.parallel loops for non-parallel iterator types in Linalg operations. The existing implementation incorrectly generated scf.parallel for all tiled loops. It is rectified by refactoring logic used while lowering to loops that accounted for this. Differential Revision: https://reviews.llvm.org/D80188
2020-05-27 07:35:20 +08:00
func @tile_permute_parallel_loop(%arg0: memref<?x?xf32>,
%arg1: memref<?x?xf32>,
%arg2: memref<?x?xf32>) {
Revert "[mlir][Linalg] Retire C++ MatmulOp in favor of a linalg-ods-gen'd op." This reverts commit 8c6c49f293fc85e14d811d772bdc9a68464d67b4. As discussed offline, this patch breaks internal builds and tests so I'm reverting it for now.
2020-06-16 17:02:28 +08:00
linalg.matmul(%arg0, %arg1, %arg2) {__internal_linalg_transform__ = "par__with_perm__"}
: memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>
[mlir][Linalg] Avoid using scf.parallel for non-parallel loops in Linalg ops. Modifying the loop nest builder for generating scf.parallel loops to not generate scf.parallel loops for non-parallel iterator types in Linalg operations. The existing implementation incorrectly generated scf.parallel for all tiled loops. It is rectified by refactoring logic used while lowering to loops that accounted for this. Differential Revision: https://reviews.llvm.org/D80188
2020-05-27 07:35:20 +08:00
return
}
// CHECK-LABEL: func @tile_permute_parallel_loop
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9_]+]]: memref<?x?xf32>
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9_]+]]: memref<?x?xf32>
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9_]+]]: memref<?x?xf32>
// CHECK-DAG: %[[C16:.*]] = constant 16 : index
// CHECK-DAG: %[[C8:.*]] = constant 8 : index
// CHECK-DAG: %[[C4:.*]] = constant 4 : index
// CHECK-DAG: %[[C0:.*]] = constant 0 : index
[MLIR][Standard] Make the `dim` operation index an operand. Allow for dynamic indices in the `dim` operation. Rather than an attribute, the index is now an operand of type `index`. This allows to apply the operation to dynamically ranked tensors. The correct lowering of dynamic indices remains to be implemented. Differential Revision: https://reviews.llvm.org/D81551
2020-06-10 21:52:43 +08:00
// CHECK-DAG: %[[D0:.*]] = dim %[[ARG0]], %c0
// CHECK-DAG: %[[D1:.*]] = dim %[[ARG0]], %c1
// CHECK-DAG: %[[D2:.*]] = dim %[[ARG1]], %c1
[mlir][Linalg] Avoid using scf.parallel for non-parallel loops in Linalg ops. Modifying the loop nest builder for generating scf.parallel loops to not generate scf.parallel loops for non-parallel iterator types in Linalg operations. The existing implementation incorrectly generated scf.parallel for all tiled loops. It is rectified by refactoring logic used while lowering to loops that accounted for this. Differential Revision: https://reviews.llvm.org/D80188
2020-05-27 07:35:20 +08:00
// CHECK: scf.parallel (%{{.*}}) = (%[[C0]]) to (%[[D2]]) step (%[[C8]])
// CHECK: scf.for %{{.*}} = %[[C0]] to %[[D1]] step %[[C4]]
// CHECK: scf.parallel (%{{.*}}) = (%[[C0]]) to (%[[D0]]) step (%[[C16]])