This is an archive of the discontinued LLVM Phabricator instance.

Differential D85017

[mlir] Extended Buffer Assignment to support AllocaOps.
ClosedPublic

Authored by dfki-jugr on Jul 31 2020, 3:42 AM.

Details

Reviewers
herhut
pifon2a
Commits
rG6d47431d7eee: [mlir] Extended Buffer Assignment to support AllocaOps.
Summary

Added support for AllocaOps in Buffer Assignment.

Diff Detail

Event Timeline

dfki-jugr created this revision.Jul 31 2020, 3:42 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 31 2020, 3:42 AM
Herald added subscribers: msifontes, jurahul, Kayjukh and 12 others. · View Herald Transcript
dfki-jugr requested review of this revision.Jul 31 2020, 3:42 AM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald TranscriptJul 31 2020, 3:42 AM
dfki-jugr added reviewers: herhut, pifon2a.Jul 31 2020, 3:44 AM
Harbormaster completed remote builds in B66531: Diff 282177.Jul 31 2020, 3:57 AM
dfki-jugr updated this revision to Diff 282190.Jul 31 2020, 4:33 AM

Changed check to exclude automatic allocation scope resources.

Harbormaster completed remote builds in B66540: Diff 282190.Jul 31 2020, 4:47 AM
herhut accepted this revision.Jul 31 2020, 5:45 AM
This revision is now accepted and ready to land.Jul 31 2020, 5:45 AM
Closed by commit rG6d47431d7eee: [mlir] Extended Buffer Assignment to support AllocaOps. (authored by dfki-jugr). · Explain WhyAug 3 2020, 2:23 AM
This revision was automatically updated to reflect the committed changes.
dfki-jugr added a commit: rG6d47431d7eee: [mlir] Extended Buffer Assignment to support AllocaOps..

Revision Contents

PathSize
mlir/
lib/
Transforms/
4 lines
test/
Transforms/
192 lines

Diff 282177

mlir/lib/Transforms/BufferPlacement.cpp

Show First 20 Lines • Show All 262 Lines • ▼ Show 20 Lines operation->walk([&](MemoryEffectOpInterface opInterface) {
SmallVector<MemoryEffects::EffectInstance, 2> effects; SmallVector<MemoryEffects::EffectInstance, 2> effects;
opInterface.getEffects(effects); opInterface.getEffects(effects);
SmallVector<MemoryEffects::EffectInstance, 2> allocateResultEffects; SmallVector<MemoryEffects::EffectInstance, 2> allocateResultEffects;
llvm::copy_if(effects, std::back_inserter(allocateResultEffects), llvm::copy_if(effects, std::back_inserter(allocateResultEffects),
[=](MemoryEffects::EffectInstance &it) { [=](MemoryEffects::EffectInstance &it) {
Value value = it.getValue(); Value value = it.getValue();
return isa<MemoryEffects::Allocate>(it.getEffect()) && return isa<MemoryEffects::Allocate>(it.getEffect()) &&
value && value.isa<OpResult>(); value && value.isa<OpResult>() &&
it.getResource() ==
SideEffects::DefaultResource::get();
}); });
// If there is one result only, we will be able to move the allocation and // If there is one result only, we will be able to move the allocation and
// (possibly existing) deallocation ops. // (possibly existing) deallocation ops.
if (allocateResultEffects.size() != 1) if (allocateResultEffects.size() != 1)
return; return;
// Get allocation result. // Get allocation result.
auto allocResult = allocateResultEffects[0].getValue().cast<OpResult>(); auto allocResult = allocateResultEffects[0].getValue().cast<OpResult>();
// Find the initial allocation block and register this result. // Find the initial allocation block and register this result.
▲ Show 20 Lines • Show All 445 Lines • Show Last 20 Lines

mlir/test/Transforms/buffer-placement.mlir

Show First 20 Lines • Show All 927 Lines • ▼ Show 20 Linesfunc @subview(%arg0 : index, %arg1 : index, %arg2 : memref<?x?xf32>) {
return return
} }
// CHECK-NEXT: %[[ALLOC:.*]] = alloc() // CHECK-NEXT: %[[ALLOC:.*]] = alloc()
// CHECK-NEXT: subview // CHECK-NEXT: subview
// CHECK-NEXT: linalg.copy // CHECK-NEXT: linalg.copy
// CHECK-NEXT: dealloc %[[ALLOC]] // CHECK-NEXT: dealloc %[[ALLOC]]
// CHECK-NEXT: return // CHECK-NEXT: return
// -----
#map0 = affine_map<(d0) -> (d0)>
// CHECK-LABEL: func @condBranchAlloca
func @condBranchAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2
^bb1:
br ^bb3(%arg1 : memref<2xf32>)
^bb2:
%0 = alloca() : memref<2xf32>
linalg.generic {
args_in = 1 : i64,
args_out = 1 : i64,
indexing_maps = [#map0, #map0],
iterator_types = ["parallel"]} %arg1, %0 {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%tmp1 = exp %gen1_arg0 : f32
linalg.yield %tmp1 : f32
}: memref<2xf32>, memref<2xf32>
br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>):
"linalg.copy"(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
return
}
// CHECK-NEXT: cond_br
// CHECK: %[[ALLOCA:.*]] = alloca()
// CHECK: br ^bb3(%[[ALLOCA:.*]])
// CHECK-NEXT: ^bb3
// CHECK-NEXT: linalg.copy
// CHECK-NEXT: return
// -----
#map0 = affine_map<(d0) -> (d0)>
// CHECK-LABEL: func @ifElseAlloca
func @ifElseAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = alloc() : memref<2xf32>
linalg.generic {
args_in = 1 : i64,
args_out = 1 : i64,
indexing_maps = [#map0, #map0],
iterator_types = ["parallel"]} %arg1, %0 {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%tmp1 = exp %gen1_arg0 : f32
linalg.yield %tmp1 : f32
}: memref<2xf32>, memref<2xf32>
cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
%7 = alloca() : memref<2xf32>
linalg.generic {
args_in = 1 : i64,
args_out = 1 : i64,
indexing_maps = [#map0, #map0],
iterator_types = ["parallel"]} %5, %7 {
^bb0(%gen2_arg0: f32, %gen2_arg1: f32):
%tmp2 = exp %gen2_arg0 : f32
linalg.yield %tmp2 : f32
}: memref<2xf32>, memref<2xf32>
"linalg.copy"(%7, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
return
}
// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
// CHECK-NEXT: linalg.generic
// CHECK: %[[ALLOCA:.*]] = alloca()
// CHECK-NEXT: linalg.generic
// CHECK: dealloc %[[ALLOC]]
// CHECK: linalg.copy
// CHECK-NEXT: return
// -----
#map0 = affine_map<(d0) -> (d0)>
// CHECK-LABEL: func @ifElseNestedAlloca
func @ifElseNestedAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
%0 = alloca() : memref<2xf32>
linalg.generic {
args_in = 1 : i64,
args_out = 1 : i64,
indexing_maps = [#map0, #map0],
iterator_types = ["parallel"]} %arg1, %0 {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%tmp1 = exp %gen1_arg0 : f32
linalg.yield %tmp1 : f32
}: memref<2xf32>, memref<2xf32>
cond_br %arg0,
^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
^bb3(%5: memref<2xf32>):
br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
^bb4(%6: memref<2xf32>):
br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
%9 = alloc() : memref<2xf32>
linalg.generic {
args_in = 1 : i64,
args_out = 1 : i64,
indexing_maps = [#map0, #map0],
iterator_types = ["parallel"]} %7, %9 {
^bb0(%gen2_arg0: f32, %gen2_arg1: f32):
%tmp2 = exp %gen2_arg0 : f32
linalg.yield %tmp2 : f32
}: memref<2xf32>, memref<2xf32>
"linalg.copy"(%9, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
return
}
// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
// CHECK-NEXT: linalg.generic
// CHECK: %[[ALLOC:.*]] = alloc()
// CHECK-NEXT: linalg.generic
// CHECK: linalg.copy
// CHECK-NEXT: dealloc %[[ALLOC]]
// CHECK-NEXT: return
// -----
#map0 = affine_map<(d0) -> (d0)>
// CHECK-LABEL: func @nestedRegionsAndCondBranchAlloca
func @nestedRegionsAndCondBranchAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
cond_br %arg0, ^bb1, ^bb2
^bb1:
br ^bb3(%arg1 : memref<2xf32>)
^bb2:
%0 = alloc() : memref<2xf32>
linalg.generic {args_in = 1 : i64, args_out = 1 : i64, indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} %arg1, %0 {
^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
%1 = alloca() : memref<2xf32>
linalg.generic {args_in = 1 : i64, args_out = 1 : i64, indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} %arg1, %1 {
^bb0(%gen2_arg0: f32, %gen2_arg1: f32):
%tmp2 = exp %gen2_arg0 : f32
linalg.yield %tmp2 : f32
}: memref<2xf32>, memref<2xf32>
%tmp1 = exp %gen1_arg0 : f32
linalg.yield %tmp1 : f32
}: memref<2xf32>, memref<2xf32>
br ^bb3(%0 : memref<2xf32>)
^bb3(%1: memref<2xf32>):
"linalg.copy"(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
return
}
// CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}})
// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
// CHECK-NEXT: cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]]
// CHECK: ^[[BB2]]:
// CHECK-NEXT: linalg.generic {{{.*}}} %[[ARG1]], %[[ALLOC]]
// CHECK: %[[ALLOCA:.*]] = alloca()
// CHECK-NEXT: linalg.generic {{{.*}}} %[[ARG1]], %[[ALLOCA]]
// CHECK: %{{.*}} = exp
// CHECK: ^[[BB3:.*]]({{.*}}):
// CHECK: linalg.copy
// CHECK-NEXT: dealloc %[[ALLOC]]
// -----
// CHECK-LABEL: func @nestedRegionControlFlowAlloca
func @nestedRegionControlFlowAlloca(
%arg0 : index,
%arg1 : index) -> memref<?x?xf32> {
%0 = cmpi "eq", %arg0, %arg1 : index
%1 = alloc(%arg0, %arg0) : memref<?x?xf32>
%2 = scf.if %0 -> (memref<?x?xf32>) {
scf.yield %1 : memref<?x?xf32>
} else {
%3 = alloca(%arg0, %arg1) : memref<?x?xf32>
scf.yield %1 : memref<?x?xf32>
}
return %2 : memref<?x?xf32>
}
// CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
// CHECK-NEXT: %[[ALLOC1:.*]] = scf.if
// CHECK: scf.yield %[[ALLOC0]]
// CHECK: %[[ALLOCA:.*]] = alloca(%arg0, %arg1)
// CHECK-NEXT: scf.yield %[[ALLOC0]]
// CHECK: return %[[ALLOC1]]