This is an archive of the discontinued LLVM Phabricator instance.

Differential D126251

[mlir][bufferize] Remove hoisting functionality from One-Shot Bufferize
ClosedPublic

Authored by springerm on May 23 2022, 3:58 PM.

Details

Reviewers
nicolasvasilache
pifon2a
aartbik
Commits
rG0ee1c0388ca3: [mlir][bufferize] Remove hoisting functionality from One-Shot Bufferize
Summary

The same functionality is already provided by -buffer-hoisting and -buffer-loop-hoisting.

The purpose of this change is to remove finalizeBuffers, which made it difficult to extend the bufferization to custom buffer types.

Diff Detail

Revision Contents

PathSize
mlir/
include/
mlir/
Dialect/
Bufferization/
IR/
12 lines
16 lines
Transforms/
5 lines
lib/
Dialect/
Bufferization/
IR/
57 lines
Transforms/
4 lines
2 lines
Shape/
Transforms/
5 lines
test/
Dialect/
Bufferization/
Transforms/
Transforms/
Dialect/
Linalg/
2 lines
SCF/
60 lines
Transforms/

Diff 432046

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h

Show First 20 Lines • Show All 274 Lines • ▼ Show 20 Linesstruct BufferizationOptions {
/// ///
/// If set to `false`, BufferizableOpInterface implementations can try to be /// If set to `false`, BufferizableOpInterface implementations can try to be
/// smart and choose to alias with "in" operands or other operands. E.g., the /// smart and choose to alias with "in" operands or other operands. E.g., the
/// result of a `linalg.generic` op could bufferize in-place with an "in" /// result of a `linalg.generic` op could bufferize in-place with an "in"
/// OpOperand if the corresponding "out" operand is not used within the /// OpOperand if the corresponding "out" operand is not used within the
/// computation. Whether this pays off or not can be very input IR-specific. /// computation. Whether this pays off or not can be very input IR-specific.
bool alwaysAliasingWithDest = true; bool alwaysAliasingWithDest = true;
/// If set to `true`, try to hoist allocations out of blocks as much as
/// possible. An allocation is not hoisted across allocation hoisting barriers
/// as indicated by `BufferizableOpInterface::isAllocationHoistingBarrier`.
///
/// Examples of allocation hoisting barriers are parallel loops or ops where
/// SSA values cannot be captured from the outside.
bool hoistAllocations = true;
/// Buffer alignment for new memory allocations. /// Buffer alignment for new memory allocations.
unsigned int bufferAlignment = 128; unsigned int bufferAlignment = 128;
/// A list of op filters that determine whether an op should be processed or /// A list of op filters that determine whether an op should be processed or
/// ignored by the bufferization. If the filter has an ALLOW rule, only ops /// ignored by the bufferization. If the filter has an ALLOW rule, only ops
/// that are allowed and not denied are bufferized. If the filter does not /// that are allowed and not denied are bufferized. If the filter does not
/// have an ALLOW rule, only ops that are not denied are bufferized. /// have an ALLOW rule, only ops that are not denied are bufferized.
SmallVector<OpFilterEntry> opFilter; SmallVector<OpFilterEntry> opFilter;
▲ Show 20 Lines • Show All 314 Lines • ▼ Show 20 LinesBaseMemRefType getMemRefTypeWithFullyDynamicLayout(TensorType tensorType,
Attribute memorySpace = {}); Attribute memorySpace = {});
/// Return a MemRef type with a static identity layout (i.e., no layout map). If /// Return a MemRef type with a static identity layout (i.e., no layout map). If
/// the given tensor type is unranked, return an unranked MemRef type. /// the given tensor type is unranked, return an unranked MemRef type.
BaseMemRefType BaseMemRefType
getMemRefTypeWithStaticIdentityLayout(TensorType tensorType, getMemRefTypeWithStaticIdentityLayout(TensorType tensorType,
Attribute memorySpace = {}); Attribute memorySpace = {});
/// Try to hoist all new buffer allocations until the next hoisting barrier.
LogicalResult hoistBufferAllocations(Operation *op,
const BufferizationOptions &options);
/// Create alloc/dealloc ops as specified in the bufferization options. If /// Create alloc/dealloc ops as specified in the bufferization options. If
/// `onlyLeakingAlloc`, only those buffer allocations are processed for which no /// `onlyLeakingAlloc`, only those buffer allocations are processed for which no
/// buffer deallocation can be created. `changed` is set to `true` if the IR was /// buffer deallocation can be created. `changed` is set to `true` if the IR was
/// modified. /// modified.
LogicalResult createAllocDeallocOps(Operation *op, LogicalResult createAllocDeallocOps(Operation *op,
const BufferizationOptions &options, const BufferizationOptions &options,
bool onlyLeakingAllocs = false, bool onlyLeakingAllocs = false,
bool *changed = nullptr); bool *changed = nullptr);
} // namespace bufferization } // namespace bufferization
} // namespace mlir } // namespace mlir
#include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h.inc" #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h.inc"
#endif // MLIR_DIALECT_BUFFERIZATION_IR_BUFFERIZABLEOPINTERFACE_H_ #endif // MLIR_DIALECT_BUFFERIZATION_IR_BUFFERIZABLEOPINTERFACE_H_

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.td

Show First 20 Lines • Show All 255 Lines • ▼ Show 20 Lines let methods = [
"const AnalysisState &":$state), "const AnalysisState &":$state),
/*methodBody=*/"", /*methodBody=*/"",
/*defaultImplementation=*/[{ /*defaultImplementation=*/[{
return value.isa<OpResult>(); return value.isa<OpResult>();
}] }]
>, >,
InterfaceMethod< InterfaceMethod<
/*desc=*/[{ /*desc=*/[{
Return `true` if the op is an allocation hoisting barrier. Buffer
allocations will never be beyond such ops. E.g., ops with certain
parallel semantics may be allocation hoisting barriers. The majority
of ops, however, is not a barrier. Therefore, this method returns
`false` by default.
}],
/*retType=*/"bool",
/*methodName=*/"isAllocationHoistingBarrier",
/*args=*/(ins),
/*methodBody=*/"",
/*defaultImplementation=*/[{
return false;
}]
>,
InterfaceMethod<
/*desc=*/[{
Return `true` if the `uRead` and `uWrite` do not constitute a RaW Return `true` if the `uRead` and `uWrite` do not constitute a RaW
conflict. If they are conflicting or if it is unknown whether they are conflict. If they are conflicting or if it is unknown whether they are
conflicting, return `false`. This method will never be called with conflicting, return `false`. This method will never be called with
OpOperands that do not have a tensor type. At least one of the two OpOperands that do not have a tensor type. At least one of the two
given OpOperands belongs to this operation. given OpOperands belongs to this operation.
This method can be implemented to specify custom RaW analysis rules. This method can be implemented to specify custom RaW analysis rules.
If this method returns `true` the given OpOperands are not considered If this method returns `true` the given OpOperands are not considered
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Bufferization/Transforms/Bufferize.h

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
/// Bufferize `op` and its nested ops that implement `BufferizableOpInterface`. /// Bufferize `op` and its nested ops that implement `BufferizableOpInterface`.
/// Reuse an existing `BufferizationState`. /// Reuse an existing `BufferizationState`.
/// ///
/// Note: This function overload is useful for extending the bufferization. /// Note: This function overload is useful for extending the bufferization.
LogicalResult bufferizeOp(Operation *op, LogicalResult bufferizeOp(Operation *op,
BufferizationState &bufferizationState); BufferizationState &bufferizationState);
/// Finalize all buffer allocations. /// Finalize all buffer allocations: Create alloc/dealloc ops as specified by
/// * Hoist buffer allocations as much as possible. /// the bufferization options.
/// * Create alloc/dealloc ops as specified by the bufferization options.
LogicalResult finalizeBuffers(Operation *op, LogicalResult finalizeBuffers(Operation *op,
const BufferizationOptions &options); const BufferizationOptions &options);
} // namespace bufferization } // namespace bufferization
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERIZE_H #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERIZE_H

mlir/lib/Dialect/Bufferization/IR/BufferizableOpInterface.cpp

Show First 20 Lines • Show All 576 Lines • ▼ Show 20 Lines if (failed(options.createDealloc(rewriter, alloc->getLoc(), *alloc)))
return WalkResult::interrupt(); return WalkResult::interrupt();
return WalkResult::advance(); return WalkResult::advance();
}); });
return success(!status.wasInterrupted()); return success(!status.wasInterrupted());
} }
/// Try to hoist all new buffer allocations until the next hoisting barrier.
// TODO: Consolidate this function with the existing buffer hoisting pass.
LogicalResult
bufferization::hoistBufferAllocations(Operation *op,
const BufferizationOptions &options) {
// Nothing to do if allocation hoisting is deactivated.
if (!options.hoistAllocations)
return success();
// Gather all buffer allocations that were created by the bufferization.
SmallVector<Operation *> allocaOps;
op->walk([&](memref::AllocaOp allocaOp) {
if (allocaOp->hasAttr(kBufferAllocationAttr))
allocaOps.push_back(allocaOp);
});
for (Operation *allocaOp : allocaOps) {
// TODO: Hoisting of allocs with dynamic shape not implemented.
if (!allocaOp->getOpOperands().empty())
continue;
Operation *op = allocaOp->getParentOp();
while (op) {
if (auto bufferizableOp = dyn_cast<BufferizableOpInterface>(op)) {
if (bufferizableOp.isAllocationHoistingBarrier()) {
break;
}
} else {
// Op is not bufferizable: It may not be safe to hoist across this op.
break;
}
op = op->getParentOp();
}
// FuncOp is an allocation hoisting barrier, so this should never happen.
assert(op && "allocation hoisting barrier not found");
// Nothing to do if the insertion point is in the same block.
if (op == allocaOp->getParentOp())
continue;
// `op` may have multiple blocks. Make sure that we insert in the right one.
SmallVector<Block *> blocks;
for (Region &r : op->getRegions())
for (Block &b : r.getBlocks())
blocks.push_back(&b);
auto *insertionBlock = llvm::find_if(
blocks, [&](Block *b) { return b->findAncestorOpInBlock(*allocaOp); });
assert(insertionBlock != blocks.end() && "owning block not found");
// Move to the beginning of the block.
allocaOp->moveBefore(&(*insertionBlock)->front());
}
return success();
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Bufferization-specific BlockAndValueMapping support with debugging. // Bufferization-specific BlockAndValueMapping support with debugging.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
bool bufferization::isFunctionArgument(Value value) { bool bufferization::isFunctionArgument(Value value) {
auto bbArg = value.dyn_cast<BlockArgument>(); auto bbArg = value.dyn_cast<BlockArgument>();
if (!bbArg) if (!bbArg)
return false; return false;
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp

Show First 20 Lines • Show All 289 Lines • ▼ Show 20 Linesstatic bool hasTensorSemantics(Operation *op) {
bool hasTensorResult = any_of(op->getResultTypes(), isaTensor); bool hasTensorResult = any_of(op->getResultTypes(), isaTensor);
bool hasTensorOperand = any_of(op->getOperandTypes(), isaTensor); bool hasTensorOperand = any_of(op->getOperandTypes(), isaTensor);
return hasTensorResult || hasTensorOperand; return hasTensorResult || hasTensorOperand;
} }
LogicalResult LogicalResult
bufferization::finalizeBuffers(Operation *op, bufferization::finalizeBuffers(Operation *op,
const BufferizationOptions &options) { const BufferizationOptions &options) {
// Hoist buffers.
if (failed(hoistBufferAllocations(op, options)))
return failure();
// Create allocation ops for "leaking buffers", i.e., buffer allocations that // Create allocation ops for "leaking buffers", i.e., buffer allocations that
// escape block boundaries. If there are no leaking allocs, `hasLeakingAllocs` // escape block boundaries. If there are no leaking allocs, `hasLeakingAllocs`
// is set to `false`. // is set to `false`.
bool hasLeakingAllocs = false; bool hasLeakingAllocs = false;
if (failed(createAllocDeallocOps(op, options, /*onlyLeakingAllocs=*/true, if (failed(createAllocDeallocOps(op, options, /*onlyLeakingAllocs=*/true,
&hasLeakingAllocs))) &hasLeakingAllocs)))
return failure(); return failure();
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp

Show First 20 Lines • Show All 543 Lines • ▼ Show 20 Lines bool isWritable(Operation *op, Value value,
// currently used for testing only. // currently used for testing only.
if (BoolAttr writable = funcOp.getArgAttrOfType<BoolAttr>( if (BoolAttr writable = funcOp.getArgAttrOfType<BoolAttr>(
bbArg.getArgNumber(), BufferizationDialect::kWritableAttrName)) bbArg.getArgNumber(), BufferizationDialect::kWritableAttrName))
return writable.getValue(); return writable.getValue();
// All function arguments are writable by default. // All function arguments are writable by default.
return true; return true;
} }
bool isAllocationHoistingBarrier(Operation *op) const { return true; }
}; };
} // namespace func_ext } // namespace func_ext
} // namespace bufferization } // namespace bufferization
} // namespace mlir } // namespace mlir
void mlir::bufferization::func_ext:: void mlir::bufferization::func_ext::
registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry) { registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry) {
registry.addExtension(+[](MLIRContext *ctx, func::FuncDialect *dialect) { registry.addExtension(+[](MLIRContext *ctx, func::FuncDialect *dialect) {
func::CallOp::attachInterface<func_ext::CallOpInterface>(*ctx); func::CallOp::attachInterface<func_ext::CallOpInterface>(*ctx);
func::FuncOp::attachInterface<func_ext::FuncOpInterface>(*ctx); func::FuncOp::attachInterface<func_ext::FuncOpInterface>(*ctx);
func::ReturnOp::attachInterface<func_ext::ReturnOpInterface>(*ctx); func::ReturnOp::attachInterface<func_ext::ReturnOpInterface>(*ctx);
}); });
} }

mlir/lib/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.cpp

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Lines LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
return success(); return success();
} }
BufferRelation bufferRelation(Operation *op, OpResult opResult, BufferRelation bufferRelation(Operation *op, OpResult opResult,
const AnalysisState &state) const { const AnalysisState &state) const {
return BufferRelation::Equivalent; return BufferRelation::Equivalent;
} }
bool isAllocationHoistingBarrier(Operation *op) const {
// Allocations should not be hoisted out of AssumingOps.
return true;
}
}; };
/// Bufferization of shape.assuming_yield. Bufferized as part of their enclosing /// Bufferization of shape.assuming_yield. Bufferized as part of their enclosing
/// ops, so this is for analysis only. /// ops, so this is for analysis only.
struct AssumingYieldOpInterface struct AssumingYieldOpInterface
: public BufferizableOpInterface::ExternalModel<AssumingYieldOpInterface, : public BufferizableOpInterface::ExternalModel<AssumingYieldOpInterface,
shape::AssumingOp> { shape::AssumingOp> {
bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand, bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

mlir/test/Dialect/Bufferization/Transforms/buffer-hoisting.mlir

  • This file was moved from mlir/test/Transforms/buffer-hoisting.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Bufferization/Transforms/buffer-loop-hoisting.mlir

  • This file was moved from mlir/test/Transforms/buffer-loop-hoisting.mlir.
The contents of this file were not changed.

mlir/test/Dialect/Linalg/one-shot-bufferize.mlir

// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs bufferize-function-boundaries" -split-input-file | FileCheck %s // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs bufferize-function-boundaries" -buffer-loop-hoisting -split-input-file | FileCheck %s
// Run fuzzer with different seeds. // Run fuzzer with different seeds.
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=23 bufferize-function-boundaries" -split-input-file -o /dev/null // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=23 bufferize-function-boundaries" -split-input-file -o /dev/null
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=59 bufferize-function-boundaries" -split-input-file -o /dev/null // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=59 bufferize-function-boundaries" -split-input-file -o /dev/null
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=91 bufferize-function-boundaries" -split-input-file -o /dev/null // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs test-analysis-only analysis-fuzzer-seed=91 bufferize-function-boundaries" -split-input-file -o /dev/null
// Test bufferization using memref types that have no layout map. // Test bufferization using memref types that have no layout map.
// RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs unknown-type-conversion=identity-layout-map function-boundary-type-conversion=identity-layout-map bufferize-function-boundaries" -split-input-file | FileCheck %s --check-prefix=CHECK-NO-LAYOUT-MAP // RUN: mlir-opt %s -one-shot-bufferize="allow-return-allocs unknown-type-conversion=identity-layout-map function-boundary-type-conversion=identity-layout-map bufferize-function-boundaries" -split-input-file | FileCheck %s --check-prefix=CHECK-NO-LAYOUT-MAP
▲ Show 20 Lines • Show All 368 Lines • Show Last 20 Lines

mlir/test/Dialect/SCF/one-shot-bufferize.mlir

Show First 20 Lines • Show All 361 Lines • ▼ Show 20 Lines
// CHECK-LABEL: func @scf_while_non_equiv_condition( // CHECK-LABEL: func @scf_while_non_equiv_condition(
// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}> // CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}>
func.func @scf_while_non_equiv_condition(%arg0: tensor<5xi1>, func.func @scf_while_non_equiv_condition(%arg0: tensor<5xi1>,
%arg1: tensor<5xi1>, %arg1: tensor<5xi1>,
%idx: index) %idx: index)
-> (tensor<5xi1>, tensor<5xi1>) -> (tensor<5xi1>, tensor<5xi1>)
{ {
// These allocation used to be inside the scf.while loop, but they were // CHECK: %[[clone1:.*]] = bufferization.clone %[[arg1]]
// hoisted. // CHECK: %[[clone0:.*]] = bufferization.clone %[[arg0]]
// CHECK: %[[a0:.*]] = memref.alloc() {{.*}} : memref<5xi1> // CHECK: %[[loop:.*]]:2 = scf.while (%[[w0:.*]] = %[[clone0]], %[[w1:.*]] = %[[clone1]]) {{.*}} {
// CHECK: %[[a1:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: %[[loop:.*]]:2 = scf.while (%[[w0:.*]] = %[[arg0]], %[[w1:.*]] = %[[arg1]]) {{.*}} {
%r0, %r1 = scf.while (%w0 = %arg0, %w1 = %arg1) %r0, %r1 = scf.while (%w0 = %arg0, %w1 = %arg1)
: (tensor<5xi1>, tensor<5xi1>) -> (tensor<5xi1>, tensor<5xi1>) { : (tensor<5xi1>, tensor<5xi1>) -> (tensor<5xi1>, tensor<5xi1>) {
// CHECK: %[[condition:.*]] = memref.load %[[w0]] // CHECK: %[[condition:.*]] = memref.load %[[w0]]
// CHECK: %[[a1:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: memref.copy %[[w1]], %[[a1]] // CHECK: memref.copy %[[w1]], %[[a1]]
// CHECK: %[[casted1:.*]] = memref.cast %[[a1]] // CHECK: memref.dealloc %[[w1]]
// CHECK: %[[a0:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: memref.copy %[[w0]], %[[a0]] // CHECK: memref.copy %[[w0]], %[[a0]]
// CHECK: memref.dealloc %[[w0]]
// CHECK: %[[casted0:.*]] = memref.cast %[[a0]] // CHECK: %[[casted0:.*]] = memref.cast %[[a0]]
// CHECK: %[[casted1:.*]] = memref.cast %[[a1]]
// CHECK: scf.condition(%[[condition]]) %[[casted1]], %[[casted0]] // CHECK: scf.condition(%[[condition]]) %[[casted1]], %[[casted0]]
%condition = tensor.extract %w0[%idx] : tensor<5xi1> %condition = tensor.extract %w0[%idx] : tensor<5xi1>
scf.condition(%condition) %w1, %w0 : tensor<5xi1>, tensor<5xi1> scf.condition(%condition) %w1, %w0 : tensor<5xi1>, tensor<5xi1>
} do { } do {
^bb0(%b0: tensor<5xi1>, %b1: tensor<5xi1>): ^bb0(%b0: tensor<5xi1>, %b1: tensor<5xi1>):
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[b0:.*]]: memref<5xi1, #{{.*}}>, %[[b1:.*]]: memref<5xi1, #{{.*}}): // CHECK: ^bb0(%[[b0:.*]]: memref<5xi1, #{{.*}}>, %[[b1:.*]]: memref<5xi1, #{{.*}}):
// CHECK: memref.store %{{.*}}, %[[b0]] // CHECK: memref.store %{{.*}}, %[[b0]]
Show All 15 Lines
// CHECK-LABEL: func @scf_while_non_equiv_condition_and_body( // CHECK-LABEL: func @scf_while_non_equiv_condition_and_body(
// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}> // CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}>
func.func @scf_while_non_equiv_condition_and_body(%arg0: tensor<5xi1>, func.func @scf_while_non_equiv_condition_and_body(%arg0: tensor<5xi1>,
%arg1: tensor<5xi1>, %arg1: tensor<5xi1>,
%idx: index) %idx: index)
-> (tensor<5xi1>, tensor<5xi1>) -> (tensor<5xi1>, tensor<5xi1>)
{ {
// These allocation used to be inside the scf.while loop, but they were // CHECK: %[[clone1:.*]] = bufferization.clone %[[arg1]]
// hoisted. // CHECK: %[[clone0:.*]] = bufferization.clone %[[arg0]]
// CHECK: %[[a0:.*]] = memref.alloc() {{.*}} : memref<5xi1> // CHECK: %[[loop:.*]]:2 = scf.while (%[[w0:.*]] = %[[clone0]], %[[w1:.*]] = %[[clone1]]) {{.*}} {
// CHECK: %[[a1:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: %[[a2:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: %[[a3:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: %[[loop:.*]]:2 = scf.while (%[[w0:.*]] = %[[arg0]], %[[w1:.*]] = %[[arg1]]) {{.*}} {
%r0, %r1 = scf.while (%w0 = %arg0, %w1 = %arg1) %r0, %r1 = scf.while (%w0 = %arg0, %w1 = %arg1)
: (tensor<5xi1>, tensor<5xi1>) -> (tensor<5xi1>, tensor<5xi1>) { : (tensor<5xi1>, tensor<5xi1>) -> (tensor<5xi1>, tensor<5xi1>) {
// CHECK: %[[condition:.*]] = memref.load %[[w0]] // CHECK: %[[condition:.*]] = memref.load %[[w0]]
// CHECK: memref.copy %[[w1]], %[[a3]] // CHECK: %[[a1:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: %[[casted3:.*]] = memref.cast %[[a3]] // CHECK: memref.copy %[[w1]], %[[a1]]
// CHECK: memref.copy %[[w0]], %[[a2]] // CHECK: memref.dealloc %[[w1]]
// CHECK: %[[casted2:.*]] = memref.cast %[[a2]] // CHECK: %[[a0:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: scf.condition(%[[condition]]) %[[casted3]], %[[casted2]] // CHECK: memref.copy %[[w0]], %[[a0]]
// CHECK: memref.dealloc %[[w0]]
// CHECK: %[[casted0:.*]] = memref.cast %[[a0]]
// CHECK: %[[casted1:.*]] = memref.cast %[[a1]]
// CHECK: scf.condition(%[[condition]]) %[[casted1]], %[[casted0]]
%condition = tensor.extract %w0[%idx] : tensor<5xi1> %condition = tensor.extract %w0[%idx] : tensor<5xi1>
scf.condition(%condition) %w1, %w0 : tensor<5xi1>, tensor<5xi1> scf.condition(%condition) %w1, %w0 : tensor<5xi1>, tensor<5xi1>
} do { } do {
^bb0(%b0: tensor<5xi1>, %b1: tensor<5xi1>): ^bb0(%b0: tensor<5xi1>, %b1: tensor<5xi1>):
// CHECK: } do { // CHECK: } do {
// CHECK: ^bb0(%[[b0:.*]]: memref<5xi1, #{{.*}}>, %[[b1:.*]]: memref<5xi1, #{{.*}}): // CHECK: ^bb0(%[[b0:.*]]: memref<5xi1, #{{.*}}>, %[[b1:.*]]: memref<5xi1, #{{.*}}):
// CHECK: memref.store %{{.*}}, %[[b0]] // CHECK: memref.store %{{.*}}, %[[b0]]
// CHECK: memref.copy %[[b1]], %[[a1]] // CHECK: %[[a3:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: %[[casted1:.*]] = memref.cast %[[a1]] // CHECK: memref.copy %[[b1]], %[[a3]]
// CHECK: memref.copy %[[b0]], %[[a0]] // CHECK: memref.dealloc %[[b1]]
// CHECK: %[[casted0:.*]] = memref.cast %[[a0]] // CHECK: %[[a2:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: scf.yield %[[casted1]], %[[casted0]] // CHECK: memref.copy %[[b0]], %[[a2]]
// CHECK: %[[casted2:.*]] = memref.cast %[[a2]]
// CHECK: %[[casted3:.*]] = memref.cast %[[a3]]
// CHECK: scf.yield %[[casted3]], %[[casted2]]
// CHECK: } // CHECK: }
%pos = "dummy.some_op"() : () -> (index) %pos = "dummy.some_op"() : () -> (index)
%val = "dummy.another_op"() : () -> (i1) %val = "dummy.another_op"() : () -> (i1)
%1 = tensor.insert %val into %b0[%pos] : tensor<5xi1> %1 = tensor.insert %val into %b0[%pos] : tensor<5xi1>
scf.yield %b1, %1 : tensor<5xi1>, tensor<5xi1> scf.yield %b1, %1 : tensor<5xi1>, tensor<5xi1>
} }
// CHECK-DAG: memref.dealloc %[[a0]]
// CHECK-DAG: memref.dealloc %[[a1]]
// CHECK: return %[[loop]]#0, %[[loop]]#1 // CHECK: return %[[loop]]#0, %[[loop]]#1
return %r0, %r1 : tensor<5xi1>, tensor<5xi1> return %r0, %r1 : tensor<5xi1>, tensor<5xi1>
} }
// ----- // -----
// CHECK-LABEL: func @scf_while_iter_arg_result_mismatch( // CHECK-LABEL: func @scf_while_iter_arg_result_mismatch(
// CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}> // CHECK-SAME: %[[arg0:.*]]: memref<5xi1, #{{.*}}>, %[[arg1:.*]]: memref<5xi1, #{{.*}}>
// CHECK: %[[alloc1:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: %[[alloc2:.*]] = memref.alloc() {{.*}} : memref<5xi1> // CHECK: %[[alloc2:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: scf.while (%[[arg3:.*]] = %[[arg1]]) : (memref<5xi1, #{{.*}}) -> () { // CHECK: %[[clone:.*]] = bufferization.clone %[[arg1]]
// CHECK: scf.while (%[[arg3:.*]] = %[[clone]]) : (memref<5xi1, #{{.*}}) -> () {
// CHECK: memref.dealloc %[[arg3]]
// CHECK: %[[load:.*]] = memref.load %[[arg0]] // CHECK: %[[load:.*]] = memref.load %[[arg0]]
// CHECK: scf.condition(%[[load]]) // CHECK: scf.condition(%[[load]])
// CHECK: } do { // CHECK: } do {
// CHECK: memref.copy %[[arg0]], %[[alloc2]] // CHECK: memref.copy %[[arg0]], %[[alloc2]]
// CHECK: memref.store %{{.*}}, %[[alloc2]] // CHECK: memref.store %{{.*}}, %[[alloc2]]
// CHECK: %[[alloc1:.*]] = memref.alloc() {{.*}} : memref<5xi1>
// CHECK: memref.copy %[[alloc2]], %[[alloc1]] // CHECK: memref.copy %[[alloc2]], %[[alloc1]]
// CHECK: %[[casted:.*]] = memref.cast %[[alloc1]] : memref<5xi1> to memref<5xi1, #{{.*}}> // CHECK: %[[casted:.*]] = memref.cast %[[alloc1]] : memref<5xi1> to memref<5xi1, #{{.*}}>
// CHECK: scf.yield %[[casted]] // CHECK: scf.yield %[[casted]]
// CHECK: } // CHECK: }
// CHECK-DAG: memref.dealloc %[[alloc1]]
// CHECK-DAG: memref.dealloc %[[alloc2]] // CHECK-DAG: memref.dealloc %[[alloc2]]
func.func @scf_while_iter_arg_result_mismatch(%arg0: tensor<5xi1>, func.func @scf_while_iter_arg_result_mismatch(%arg0: tensor<5xi1>,
%arg1: tensor<5xi1>, %arg1: tensor<5xi1>,
%arg2: index) { %arg2: index) {
scf.while (%arg3 = %arg1) : (tensor<5xi1>) -> () { scf.while (%arg3 = %arg1) : (tensor<5xi1>) -> () {
%0 = tensor.extract %arg0[%arg2] : tensor<5xi1> %0 = tensor.extract %arg0[%arg2] : tensor<5xi1>
scf.condition(%0) scf.condition(%0)
} do { } do {
%0 = "dummy.some_op"() : () -> index %0 = "dummy.some_op"() : () -> index
%1 = "dummy.another_op"() : () -> i1 %1 = "dummy.another_op"() : () -> i1
%2 = tensor.insert %1 into %arg0[%0] : tensor<5xi1> %2 = tensor.insert %1 into %arg0[%0] : tensor<5xi1>
scf.yield %2 : tensor<5xi1> scf.yield %2 : tensor<5xi1>
} }
return return
} }

mlir/test/Transforms/buffer-hoisting.mlir

  • This file was moved to mlir/test/Dialect/Bufferization/Transforms/buffer-hoisting.mlir.

mlir/test/Transforms/buffer-loop-hoisting.mlir

  • This file was moved to mlir/test/Dialect/Bufferization/Transforms/buffer-loop-hoisting.mlir.