This is an archive of the discontinued LLVM Phabricator instance.

Differential D89209

[mlir] Move Linalg tensors-to-buffers tests to Linalg tests.
ClosedPublic

Authored by pifon2a on Oct 11 2020, 11:09 AM.

Details

Reviewers
nicolasvasilache
Commits
rGb98e5e0f7e99: [mlir] Move Linalg tensors-to-buffers tests to Linalg tests.
Summary

The buffer placement preparation tests in
test/Transforms/buffer-placement-preparation* are using Linalg as a test
dialect which leads to confusion and "copy-pasta", i.e. Linalg is being
extended now and when TensorsToBuffers.cpp is changed, TestBufferPlacement is
sometimes kept in-sync, which should not be the case.

This has led to the unnoticed bug, because the tests were in a different directory and the patterns were slightly off.

Diff Detail

Event Timeline

pifon2a created this revision.Oct 11 2020, 11:09 AM
Herald added a project: Restricted Project. · View Herald TranscriptOct 11 2020, 11:09 AM
Herald added subscribers: tatianashp, msifontes, jurahul and 12 others. · View Herald Transcript
pifon2a requested review of this revision.Oct 11 2020, 11:09 AM
Herald added subscribers: limo1996, stephenneuendorffer. · View Herald TranscriptOct 11 2020, 11:09 AM
Harbormaster completed remote builds in B74735: Diff 297476.Oct 11 2020, 11:24 AM
nicolasvasilache accepted this revision.Oct 12 2020, 12:35 AM

Thanks!

This revision is now accepted and ready to land.Oct 12 2020, 12:35 AM
Herald added a subscriber: rdzhabarov. · View Herald TranscriptOct 12 2020, 12:35 AM
Closed by commit rGb98e5e0f7e99: [mlir] Move Linalg tensors-to-buffers tests to Linalg tests. (authored by pifon2a). · Explain WhyOct 12 2020, 1:19 AM
This revision was automatically updated to reflect the committed changes.
pifon2a added a commit: rGb98e5e0f7e99: [mlir] Move Linalg tensors-to-buffers tests to Linalg tests..

Revision Contents

PathSize
mlir/
lib/
Dialect/
Linalg/
Transforms/
8 lines
test/
Dialect/
Linalg/
139 lines
Transforms/
138 lines

Diff 297510

mlir/lib/Dialect/Linalg/Transforms/TensorsToBuffers.cpp

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Lines auto newLinalgOp = rewriter.create<linalg::GenericOp>(
linalgOp.library_callAttr(), linalgOp.symbol_sourceAttr()); linalgOp.library_callAttr(), linalgOp.symbol_sourceAttr());
// Create a new block in the region of the new Generic Op. // Create a new block in the region of the new Generic Op.
Block *oldBlock = linalgOp.getBody(); Block *oldBlock = linalgOp.getBody();
Region &newRegion = newLinalgOp.region(); Region &newRegion = newLinalgOp.region();
Block *newBlock = rewriter.createBlock(&newRegion, newRegion.begin(), Block *newBlock = rewriter.createBlock(&newRegion, newRegion.begin(),
oldBlock->getArgumentTypes()); oldBlock->getArgumentTypes());
// Add the result arguments to the new block. // Add the result arguments that do not come from init_tensors to the new
for (Value v : newOutputBuffers) // block.
// TODO: update this assumption because the reality is more complex under
// linalg on tensor based transformations.
for (Value v :
ValueRange(newOutputBuffers).drop_front(adaptor.init_tensors().size()))
newBlock->addArgument(v.getType().cast<MemRefType>().getElementType()); newBlock->addArgument(v.getType().cast<MemRefType>().getElementType());
// Clone the body of the old block to the new block. // Clone the body of the old block to the new block.
BlockAndValueMapping mapping; BlockAndValueMapping mapping;
mapping.map(oldBlock->getArguments(), newBlock->getArguments()); mapping.map(oldBlock->getArguments(), newBlock->getArguments());
OpBuilder::InsertionGuard guard(rewriter); OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPointToEnd(newBlock); rewriter.setInsertionPointToEnd(newBlock);
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

mlir/test/Dialect/Linalg/tensors-to-buffers.mlir

Show First 20 Lines • Show All 167 Lines • ▼ Show 20 Lines
} }
// This gets converted to a function operating on memref<*xf32>. // This gets converted to a function operating on memref<*xf32>.
// Note that this is skipping a step and we would need at least some function // Note that this is skipping a step and we would need at least some function
// attribute to declare that this conversion is valid (e.g. when we statically // attribute to declare that this conversion is valid (e.g. when we statically
// know that things will play nicely at the C ABI boundary). // know that things will play nicely at the C ABI boundary).
func @print_memref_f32(%ptr : tensor<*xf32>) func @print_memref_f32(%ptr : tensor<*xf32>)
// CHECK-LABEL: func @print_memref_f32(memref<*xf32>) // CHECK-LABEL: func @print_memref_f32(memref<*xf32>)
// -----
#accesses = [
affine_map<(i, j, k) -> (j, i, k)>,
affine_map<(i, j, k) -> (i, j)>
]
#trait = {
indexing_maps = #accesses,
iterator_types = ["parallel", "parallel", "reduction"]
}
func @generic_with_init_tensor(%arg0: tensor<2x3x4xvector<3x4xi4>>,
%arg1: tensor<3x2xf32>) -> (tensor<3x2xf32>) {
%0 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%arg1 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
return %0 : tensor<3x2xf32>
}
// CHECK-LABEL: func @generic_with_init_tensor
// CHECK-SAME: (%[[ARG0:.*]]: memref<2x3x4xvector<3x4xi4>>, %[[ARG1:.*]]: memref<3x2xf32>, %[[RESULT0:.*]]: memref<3x2xf32>) {
// CHECK-NEXT: linalg.generic
// CHECK: linalg.copy(%[[ARG1]], %[[RESULT0]])
// CHECK-NEXT: return
// CHECK-NOT: %
// -----
#accesses = [
affine_map<(i, j, k) -> (j, i, k)>,
affine_map<(i, j, k) -> (i, j)>
]
#trait = {
indexing_maps = #accesses,
iterator_types = ["parallel", "parallel", "reduction"]
}
func @init_tensor_with_2_uses(%arg0: tensor<2x3x4xvector<3x4xi4>>,
%arg1: tensor<3x2xf32>) -> (tensor<3x2xf32>, tensor<3x2xf32>) {
%0 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%arg1 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
%1 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%arg1 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
return %0, %1 : tensor<3x2xf32>, tensor<3x2xf32>
}
// CHECK-LABEL: func @init_tensor_with_2_uses
// CHECK-SAME: (%[[ARG0:.*]]: memref<2x3x4xvector<3x4xi4>>, %[[ARG1:.*]]: memref<3x2xf32>, %[[RESULT0:.*]]: memref<3x2xf32>, %[[RESULT1:.*]]: memref<3x2xf32>) {
// CHECK-NEXT: %[[ALLOC0:.*]] = alloc
// CHECK-NEXT: linalg.copy(%[[ARG1]], %[[ALLOC0]])
// CHECK-NEXT: linalg.generic
// CHECK-SAME: outs(%[[ALLOC0]]
// CHECK-NEXT: ^bb
// CHECK-NEXT: constant
// CHECK-NEXT: yield
// CHECK-NEXT: }
// CHECK-NEXT: %[[ALLOC1:.*]] = alloc
// CHECK-NEXT: linalg.copy(%[[ARG1]], %[[ALLOC1]])
// CHECK-NEXT: linalg.generic
// CHECK-SAME: outs(%[[ALLOC1]]
// CHECK-NEXT: ^bb
// CHECK-NEXT: constant
// CHECK-NEXT: yield
// CHECK-NEXT: }
// CHECK-NEXT: linalg.copy(%[[ALLOC0]], %[[RESULT0]])
// CHECK-NEXT: dealloc
// CHECK-NEXT: linalg.copy(%[[ALLOC1]], %[[RESULT1]])
// CHECK-NEXT: dealloc
// CHECK-NEXT: return
// CHECK-NOT: %
// -----
#accesses = [
affine_map<(i, j, k) -> (j, i, k)>,
affine_map<(i, j, k) -> (i, j)>
]
#trait = {
indexing_maps = #accesses,
iterator_types = ["parallel", "parallel", "reduction"]
}
func @init_tensor_with_1_use_def_chain(%arg0: tensor<2x3x4xvector<3x4xi4>>,
%arg1: tensor<3x2xf32>) -> (tensor<3x2xf32>) {
%0 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%arg1 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
%1 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%0 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
return %1 : tensor<3x2xf32>
}
// CHECK-LABEL: func @init_tensor_with_1_use_def_chain
// CHECK-SAME: (%[[ARG0:.*]]: memref<2x3x4xvector<3x4xi4>>, %[[ARG1:.*]]: memref<3x2xf32>, %[[RESULT0:.*]]: memref<3x2xf32>) {
// CHECK-NEXT: linalg.generic
// CHECK-NEXT: ^bb
// CHECK-NEXT: constant
// CHECK-NEXT: yield
// CHECK-NEXT: }
// CHECK-NEXT: linalg.generic
// CHECK-NEXT: ^bb
// CHECK-NEXT: constant
// CHECK-NEXT: yield
// CHECK-NEXT: }
// CHECK-NEXT: linalg.copy(%[[ARG1]], %[[RESULT0]])
// CHECK-NEXT: return
// CHECK-NOT: %

mlir/test/Transforms/buffer-placement-preparation.mlir

Show First 20 Lines • Show All 376 Lines • ▼ Show 20 Lines
// CHECK-NEXT: %[[SECOND_TUPLE:.*]] = "test.make_tuple"(%[[ARG3]], %[[ARG4]]) // CHECK-NEXT: %[[SECOND_TUPLE:.*]] = "test.make_tuple"(%[[ARG3]], %[[ARG4]])
// CHECK-NEXT: %[[SECOND_TUPLE_FIRST_ELEM:.*]] = "test.get_tuple_element"(%[[SECOND_TUPLE]]) {index = 0 : i32} // CHECK-NEXT: %[[SECOND_TUPLE_FIRST_ELEM:.*]] = "test.get_tuple_element"(%[[SECOND_TUPLE]]) {index = 0 : i32}
// CHECK-NEXT: %[[SECOND_TUPLE_SECOND_ELEM:.*]] = "test.get_tuple_element"(%[[SECOND_TUPLE]]) {index = 1 : i32} // CHECK-NEXT: %[[SECOND_TUPLE_SECOND_ELEM:.*]] = "test.get_tuple_element"(%[[SECOND_TUPLE]]) {index = 1 : i32}
// CHECK-NEXT: %[[FIRST_TUPLE_FIRST_ELEM:.*]] = "test.get_tuple_element"(%[[FIRST_TUPLE]]) {index = 0 : i32} // CHECK-NEXT: %[[FIRST_TUPLE_FIRST_ELEM:.*]] = "test.get_tuple_element"(%[[FIRST_TUPLE]]) {index = 0 : i32}
// CHECK-NEXT: %[[FIRST_TUPLE_SECOND_ELEM:.*]] = "test.get_tuple_element"(%[[FIRST_TUPLE]]) {index = 1 : i32} // CHECK-NEXT: %[[FIRST_TUPLE_SECOND_ELEM:.*]] = "test.get_tuple_element"(%[[FIRST_TUPLE]]) {index = 1 : i32}
// CHECK-NEXT: linalg.copy(%[[SECOND_TUPLE_SECOND_ELEM]], %[[RESULT0]]) // CHECK-NEXT: linalg.copy(%[[SECOND_TUPLE_SECOND_ELEM]], %[[RESULT0]])
// CHECK-NEXT: linalg.copy(%[[ARG2]], %[[RESULT1]]) // CHECK-NEXT: linalg.copy(%[[ARG2]], %[[RESULT1]])
// CHECK-NEXT: return %[[SECOND_TUPLE_FIRST_ELEM]], %[[FIRST_TUPLE_FIRST_ELEM]], %[[FIRST_TUPLE_SECOND_ELEM]] // CHECK-NEXT: return %[[SECOND_TUPLE_FIRST_ELEM]], %[[FIRST_TUPLE_FIRST_ELEM]], %[[FIRST_TUPLE_SECOND_ELEM]]
// -----
#accesses = [
affine_map<(i, j, k) -> (j, i, k)>,
affine_map<(i, j, k) -> (i, j)>
]
#trait = {
indexing_maps = #accesses,
iterator_types = ["parallel", "parallel", "reduction"]
}
func @generic_with_init_tensor(
%arg0: tensor<2x3x4xvector<3x4xi4>>, %arg1: tensor<3x2xf32>) -> (tensor<3x2xf32>) {
%0 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%arg1 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
return %0 : tensor<3x2xf32>
}
// CHECK-LABEL: func @generic_with_init_tensor
// CHECK-SAME: (%[[ARG0:.*]]: memref<2x3x4xvector<3x4xi4>>, %[[ARG1:.*]]: memref<3x2xf32>, %[[RESULT0:.*]]: memref<3x2xf32>) {
// CHECK-NEXT: linalg.generic
// CHECK: linalg.copy(%[[ARG1]], %[[RESULT0]])
// CHECK-NEXT: return
// CHECK-NOT: %
// -----
#accesses = [
affine_map<(i, j, k) -> (j, i, k)>,
affine_map<(i, j, k) -> (i, j)>
]
#trait = {
indexing_maps = #accesses,
iterator_types = ["parallel", "parallel", "reduction"]
}
func @init_tensor_with_2_uses(
%arg0: tensor<2x3x4xvector<3x4xi4>>, %arg1: tensor<3x2xf32>) -> (tensor<3x2xf32>, tensor<3x2xf32>) {
%0 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%arg1 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
%1 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%arg1 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
return %0, %1 : tensor<3x2xf32>, tensor<3x2xf32>
}
// CHECK-LABEL: func @init_tensor_with_2_uses
// CHECK-SAME: (%[[ARG0:.*]]: memref<2x3x4xvector<3x4xi4>>, %[[ARG1:.*]]: memref<3x2xf32>, %[[RESULT0:.*]]: memref<3x2xf32>, %[[RESULT1:.*]]: memref<3x2xf32>) {
// CHECK-NEXT: %[[ALLOC0:.*]] = alloc
// CHECK-NEXT: linalg.copy(%[[ARG1]], %[[ALLOC0]])
// CHECK-NEXT: linalg.generic
// CHECK-SAME: outs(%[[ALLOC0]]
// CHECK-NEXT: ^bb
// CHECK-NEXT: constant
// CHECK-NEXT: yield
// CHECK-NEXT: }
// CHECK-NEXT: %[[ALLOC1:.*]] = alloc
// CHECK-NEXT: linalg.copy(%[[ARG1]], %[[ALLOC1]])
// CHECK-NEXT: linalg.generic
// CHECK-SAME: outs(%[[ALLOC1]]
// CHECK-NEXT: ^bb
// CHECK-NEXT: constant
// CHECK-NEXT: yield
// CHECK-NEXT: }
// CHECK-NEXT: linalg.copy(%[[ALLOC0]], %[[RESULT0]])
// CHECK-NEXT: linalg.copy(%[[ALLOC1]], %[[RESULT1]])
// CHECK-NEXT: return
// CHECK-NOT: %
// -----
#accesses = [
affine_map<(i, j, k) -> (j, i, k)>,
affine_map<(i, j, k) -> (i, j)>
]
#trait = {
indexing_maps = #accesses,
iterator_types = ["parallel", "parallel", "reduction"]
}
func @init_tensor_with_1_use_def_chain(
%arg0: tensor<2x3x4xvector<3x4xi4>>, %arg1: tensor<3x2xf32>) -> (tensor<3x2xf32>) {
%0 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%arg1 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
%1 = linalg.generic #trait
ins(%arg0 : tensor<2x3x4xvector<3x4xi4>>)
init(%0 : tensor<3x2xf32>) {
^bb(%v0: vector<3x4xi4>, %v1: f32) :
%f0 = constant 0.0 : f32
linalg.yield %f0 : f32
} -> tensor<3x2xf32>
return %1 : tensor<3x2xf32>
}
// CHECK-LABEL: func @init_tensor_with_1_use_def_chain
// CHECK-SAME: (%[[ARG0:.*]]: memref<2x3x4xvector<3x4xi4>>, %[[ARG1:.*]]: memref<3x2xf32>, %[[RESULT0:.*]]: memref<3x2xf32>) {
// CHECK-NEXT: linalg.generic
// CHECK-NEXT: ^bb
// CHECK-NEXT: constant
// CHECK-NEXT: yield
// CHECK-NEXT: }
// CHECK-NEXT: linalg.generic
// CHECK-NEXT: ^bb
// CHECK-NEXT: constant
// CHECK-NEXT: yield
// CHECK-NEXT: }
// CHECK-NEXT: linalg.copy(%[[ARG1]], %[[RESULT0]])
// CHECK-NEXT: return
// CHECK-NOT: %