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/promote.mlir

52 lines
3.9 KiB
MLIR
Raw Normal View History

Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
// RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=2,3,4 -linalg-tile-promote-full-tile-views=true | FileCheck %s -check-prefix=TILE-1D
Unify Linalg types by using strided memrefs This CL finishes the implementation of the Linalg + Affine type unification of the [strided memref RFC](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). As a consequence, the !linalg.view type, linalg::DimOp, linalg::LoadOp and linalg::StoreOp can now disappear and Linalg can use standard types everywhere. PiperOrigin-RevId: 272187165
2019-10-01 20:22:54 +08:00
// TILE-1D-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
// TILE-1D-DAG: #[[strided2DnoOffset:.*]] = (d0, d1)[s0] -> (d0 * s0 + d1)
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
func @matmul(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: index) {
%c0 = constant 0 : index
%c1 = constant 1 : index
%I = linalg.range %c0:%arg1:%c1 : !linalg.range
%J = linalg.range %c0:%arg2:%c1 : !linalg.range
%K = linalg.range %c0:%arg3:%c1 : !linalg.range
Add syntactic sugar for strided memref parsing. This CL implements the last remaining bit of the [strided memref proposal](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). The syntax is a bit more explicit than what was originally proposed and resembles: `memref<?x?xf32, offset: 0 strides: [?, 1]>` Nonnegative strides and offsets are currently supported. Future extensions will include negative strides. This also gives a concrete example of syntactic sugar for the ([RFC] Proposed Changes to MemRef and Tensor MLIR Types)[https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/-wKHANzDNTg]. The underlying implementation still uses AffineMap layout. PiperOrigin-RevId: 272717437
2019-10-04 03:33:47 +08:00
%A = linalg.view %arg0[%I, %K] : !linalg.buffer<?xf32> -> memref<?x?xf32, offset: ?, strides: [?, 1]>
%B = linalg.view %arg0[%K, %J] : !linalg.buffer<?xf32> -> memref<?x?xf32, offset: ?, strides: [?, 1]>
%C = linalg.view %arg0[%I, %J] : !linalg.buffer<?xf32> -> memref<?x?xf32, offset: ?, strides: [?, 1]>
linalg.matmul(%A, %B, %C) : memref<?x?xf32, offset: ?, strides: [?, 1]>, memref<?x?xf32, offset: ?, strides: [?, 1]>, memref<?x?xf32, offset: ?, strides: [?, 1]>
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
return
}
Standardize the value numbering in the AsmPrinter. Change the AsmPrinter to number values breadth-first so that values in adjacent regions can have the same name. This allows for ModuleOp to contain operations that produce results. This also standardizes the special name of region entry arguments to "arg[0-9+]" now that Functions are also operations. PiperOrigin-RevId: 257225069
2019-07-10 01:40:29 +08:00
// TILE-1D-LABEL: func @matmul(%{{.*}}: !linalg.buffer<?xf32>, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
Replace linalg.for by loop.for With the introduction of the Loop dialect, uses of the `linalg.for` operation can now be subsumed 1-to-1 by `loop.for`. This CL performs the replacement and tests are updated accordingly. PiperOrigin-RevId: 258322565
2019-07-16 16:46:23 +08:00
// TILE-1D: loop.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// TILE-1D: loop.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// TILE-1D: loop.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
Unify Linalg types by using strided memrefs This CL finishes the implementation of the Linalg + Affine type unification of the [strided memref RFC](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). As a consequence, the !linalg.view type, linalg::DimOp, linalg::LoadOp and linalg::StoreOp can now disappear and Linalg can use standard types everywhere. PiperOrigin-RevId: 272187165
2019-10-01 20:22:54 +08:00
// TILE-1D: %[[vA:.*]] = linalg.subview {{.*}} : memref<?x?xf32, #[[strided2D]]>
// TILE-1D: %[[vB:.*]] = linalg.subview {{.*}} : memref<?x?xf32, #[[strided2D]]>
// TILE-1D: %[[vC:.*]] = linalg.subview {{.*}} : memref<?x?xf32, #[[strided2D]]>
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
///
// TILE-1D: %[[tmpA:.*]] = linalg.buffer_alloc : !linalg.buffer<8xf32>
Unify Linalg types by using strided memrefs This CL finishes the implementation of the Linalg + Affine type unification of the [strided memref RFC](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). As a consequence, the !linalg.view type, linalg::DimOp, linalg::LoadOp and linalg::StoreOp can now disappear and Linalg can use standard types everywhere. PiperOrigin-RevId: 272187165
2019-10-01 20:22:54 +08:00
// TILE-1D: %[[fullA:.*]] = linalg.view %[[tmpA]][{{.*}}] : !linalg.buffer<8xf32> -> memref<?x?xf32>
// TILE-1D: %[[partialA:.*]] = linalg.slice %[[fullA]][%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, memref<?x?xf32, #[[strided2DnoOffset]]>
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
///
// TILE-1D: %[[tmpB:.*]] = linalg.buffer_alloc : !linalg.buffer<12xf32>
Unify Linalg types by using strided memrefs This CL finishes the implementation of the Linalg + Affine type unification of the [strided memref RFC](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). As a consequence, the !linalg.view type, linalg::DimOp, linalg::LoadOp and linalg::StoreOp can now disappear and Linalg can use standard types everywhere. PiperOrigin-RevId: 272187165
2019-10-01 20:22:54 +08:00
// TILE-1D: %[[fullB:.*]] = linalg.view %[[tmpB]][{{.*}}] : !linalg.buffer<12xf32> -> memref<?x?xf32>
// TILE-1D: %[[partialB:.*]] = linalg.slice %[[fullB]][%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, memref<?x?xf32, #[[strided2DnoOffset]]>
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
///
// TILE-1D: %[[tmpC:.*]] = linalg.buffer_alloc : !linalg.buffer<6xf32>
Unify Linalg types by using strided memrefs This CL finishes the implementation of the Linalg + Affine type unification of the [strided memref RFC](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). As a consequence, the !linalg.view type, linalg::DimOp, linalg::LoadOp and linalg::StoreOp can now disappear and Linalg can use standard types everywhere. PiperOrigin-RevId: 272187165
2019-10-01 20:22:54 +08:00
// TILE-1D: %[[fullC:.*]] = linalg.view %[[tmpC]][{{.*}}] : !linalg.buffer<6xf32> -> memref<?x?xf32>
// TILE-1D: %[[partialC:.*]] = linalg.slice %[[fullC]][%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, memref<?x?xf32, #[[strided2DnoOffset]]>
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
Unify Linalg types by using strided memrefs This CL finishes the implementation of the Linalg + Affine type unification of the [strided memref RFC](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). As a consequence, the !linalg.view type, linalg::DimOp, linalg::LoadOp and linalg::StoreOp can now disappear and Linalg can use standard types everywhere. PiperOrigin-RevId: 272187165
2019-10-01 20:22:54 +08:00
// TILE-1D: linalg.fill(%[[fullA]], {{.*}}) : memref<?x?xf32>, f32
// TILE-1D: linalg.fill(%[[fullB]], {{.*}}) : memref<?x?xf32>, f32
// TILE-1D: linalg.fill(%[[fullC]], {{.*}}) : memref<?x?xf32>, f32
// TILE-1D: linalg.copy(%[[vA]], %[[partialA]]) : memref<?x?xf32, #[[strided2D]]>, memref<?x?xf32, #[[strided2DnoOffset]]>
// TILE-1D: linalg.copy(%[[vB]], %[[partialB]]) : memref<?x?xf32, #[[strided2D]]>, memref<?x?xf32, #[[strided2DnoOffset]]>
// TILE-1D: linalg.copy(%[[vC]], %[[partialC]]) : memref<?x?xf32, #[[strided2D]]>, memref<?x?xf32, #[[strided2DnoOffset]]>
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
//
Unify Linalg types by using strided memrefs This CL finishes the implementation of the Linalg + Affine type unification of the [strided memref RFC](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). As a consequence, the !linalg.view type, linalg::DimOp, linalg::LoadOp and linalg::StoreOp can now disappear and Linalg can use standard types everywhere. PiperOrigin-RevId: 272187165
2019-10-01 20:22:54 +08:00
// TILE-1D: linalg.matmul(%[[fullA]], %[[fullB]], %[[fullC]]) : memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
//
Unify Linalg types by using strided memrefs This CL finishes the implementation of the Linalg + Affine type unification of the [strided memref RFC](https://groups.google.com/a/tensorflow.org/forum/#!topic/mlir/MaL8m2nXuio). As a consequence, the !linalg.view type, linalg::DimOp, linalg::LoadOp and linalg::StoreOp can now disappear and Linalg can use standard types everywhere. PiperOrigin-RevId: 272187165
2019-10-01 20:22:54 +08:00
// TILE-1D: linalg.copy(%[[partialC]], %[[vC]]) : memref<?x?xf32, #[[strided2DnoOffset]]>, memref<?x?xf32, #[[strided2D]]>
Add support for promoting Linalg views into new buffers. This CL uses the generic CopyOp to promote a subview (constructed during tiling) into a new buffer + copy by: 1. Creating a new buffer for the subview. 2. Taking a view into the buffer and copying into it. 3. Adapting the linalg op to operating on the view from point 2. Tiling is extended with a boolean flag to enable promoting views (all or nothing for now). More specifically, the current implementation creates a buffer that is always of the full size of the ranges of the subview. This produces a buffer whose size may be bigger than the actual size of the `subView` at the boundaries and is related to the full/partial tile problem. In practice, we introduce a `buffer`, a `fullLocalView` and a `partialLocalView` such that: * `buffer` is always the size of the subview in the full tile case. * `fullLocalView` is a dense contiguous view into that buffer. * `partialLocalView` is a dense non-contiguous slice of `fullLocalView` that corresponds to the size of `subView` and accounting for boundary effects. The point of the full tile buffer is that constant static tile sizes are folded and result in a buffer type with statically known size and alignment properties. Padding is introduced on the boundary tiles with a `fill` op followed by a partial `copy` op. These behaviors will be refined later, on a per-need basis. PiperOrigin-RevId: 256237319
2019-07-03 05:17:30 +08:00
//
// TILE-1D: linalg.buffer_dealloc %[[tmpA]] : !linalg.buffer<8xf32>
// TILE-1D: linalg.buffer_dealloc %[[tmpB]] : !linalg.buffer<12xf32>
// TILE-1D: linalg.buffer_dealloc %[[tmpC]] : !linalg.buffer<6xf32>