forked from OSchip/llvm-project
1225 lines
40 KiB
MLIR
1225 lines
40 KiB
MLIR
// RUN: mlir-opt -verify-diagnostics -buffer-deallocation -split-input-file %s | FileCheck %s
|
|
|
|
// This file checks the behaviour of BufferDeallocation pass for moving and
|
|
// inserting missing DeallocOps in their correct positions. Furthermore,
|
|
// copies and their corresponding AllocOps are inserted.
|
|
|
|
// Test Case:
|
|
// bb0
|
|
// / \
|
|
// bb1 bb2 <- Initial position of AllocOp
|
|
// \ /
|
|
// bb3
|
|
// BufferDeallocation expected behavior: bb2 contains an AllocOp which is
|
|
// passed to bb3. In the latter block, there should be an deallocation.
|
|
// Since bb1 does not contain an adequate alloc and the alloc in bb2 is not
|
|
// moved to bb0, we need to insert allocs and copies.
|
|
|
|
// CHECK-LABEL: func @condBranch
|
|
func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
|
|
cond_br %arg0, ^bb1, ^bb2
|
|
^bb1:
|
|
br ^bb3(%arg1 : memref<2xf32>)
|
|
^bb2:
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
|
|
br ^bb3(%0 : memref<2xf32>)
|
|
^bb3(%1: memref<2xf32>):
|
|
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: cond_br
|
|
// CHECK: %[[ALLOC0:.*]] = memref.clone
|
|
// CHECK-NEXT: br ^bb3(%[[ALLOC0]]
|
|
// CHECK: %[[ALLOC1:.*]] = memref.alloc
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK-NEXT: %[[ALLOC2:.*]] = memref.clone %[[ALLOC1]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
|
|
// CHECK-NEXT: br ^bb3(%[[ALLOC2]]
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case:
|
|
// bb0
|
|
// / \
|
|
// bb1 bb2 <- Initial position of AllocOp
|
|
// \ /
|
|
// bb3
|
|
// BufferDeallocation expected behavior: The existing AllocOp has a dynamic
|
|
// dependency to block argument %0 in bb2. Since the dynamic type is passed
|
|
// to bb3 via the block argument %2, it is currently required to allocate a
|
|
// temporary buffer for %2 that gets copies of %arg0 and %1 with their
|
|
// appropriate shape dimensions. The copy buffer deallocation will be applied
|
|
// to %2 in block bb3.
|
|
|
|
// CHECK-LABEL: func @condBranchDynamicType
|
|
func @condBranchDynamicType(
|
|
%arg0: i1,
|
|
%arg1: memref<?xf32>,
|
|
%arg2: memref<?xf32>,
|
|
%arg3: index) {
|
|
cond_br %arg0, ^bb1, ^bb2(%arg3: index)
|
|
^bb1:
|
|
br ^bb3(%arg1 : memref<?xf32>)
|
|
^bb2(%0: index):
|
|
%1 = memref.alloc(%0) : memref<?xf32>
|
|
test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
|
|
br ^bb3(%1 : memref<?xf32>)
|
|
^bb3(%2: memref<?xf32>):
|
|
test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: cond_br
|
|
// CHECK: %[[ALLOC0:.*]] = memref.clone
|
|
// CHECK-NEXT: br ^bb3(%[[ALLOC0]]
|
|
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]])
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK-NEXT: %[[ALLOC2:.*]] = memref.clone
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
|
|
// CHECK-NEXT: br ^bb3
|
|
// CHECK-NEXT: ^bb3(%[[ALLOC3:.*]]:{{.*}})
|
|
// CHECK: test.copy(%[[ALLOC3]],
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC3]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test case: See above.
|
|
|
|
// CHECK-LABEL: func @condBranchUnrankedType
|
|
func @condBranchUnrankedType(
|
|
%arg0: i1,
|
|
%arg1: memref<*xf32>,
|
|
%arg2: memref<*xf32>,
|
|
%arg3: index) {
|
|
cond_br %arg0, ^bb1, ^bb2(%arg3: index)
|
|
^bb1:
|
|
br ^bb3(%arg1 : memref<*xf32>)
|
|
^bb2(%0: index):
|
|
%1 = memref.alloc(%0) : memref<?xf32>
|
|
%2 = memref.cast %1 : memref<?xf32> to memref<*xf32>
|
|
test.buffer_based in(%arg1: memref<*xf32>) out(%2: memref<*xf32>)
|
|
br ^bb3(%2 : memref<*xf32>)
|
|
^bb3(%3: memref<*xf32>):
|
|
test.copy(%3, %arg2) : (memref<*xf32>, memref<*xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: cond_br
|
|
// CHECK: %[[ALLOC0:.*]] = memref.clone
|
|
// CHECK-NEXT: br ^bb3(%[[ALLOC0]]
|
|
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]])
|
|
// CHECK: test.buffer_based
|
|
// CHECK-NEXT: %[[ALLOC2:.*]] = memref.clone
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
|
|
// CHECK-NEXT: br ^bb3
|
|
// CHECK-NEXT: ^bb3(%[[ALLOC3:.*]]:{{.*}})
|
|
// CHECK: test.copy(%[[ALLOC3]],
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC3]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case:
|
|
// bb0
|
|
// / \
|
|
// bb1 bb2 <- Initial position of AllocOp
|
|
// | / \
|
|
// | bb3 bb4
|
|
// | \ /
|
|
// \ bb5
|
|
// \ /
|
|
// bb6
|
|
// |
|
|
// bb7
|
|
// BufferDeallocation expected behavior: The existing AllocOp has a dynamic
|
|
// dependency to block argument %0 in bb2. Since the dynamic type is passed to
|
|
// bb5 via the block argument %2 and to bb6 via block argument %3, it is
|
|
// currently required to allocate temporary buffers for %2 and %3 that gets
|
|
// copies of %1 and %arg0 1 with their appropriate shape dimensions. The copy
|
|
// buffer deallocations will be applied to %2 in block bb5 and to %3 in block
|
|
// bb6. Furthermore, there should be no copy inserted for %4.
|
|
|
|
// CHECK-LABEL: func @condBranchDynamicTypeNested
|
|
func @condBranchDynamicTypeNested(
|
|
%arg0: i1,
|
|
%arg1: memref<?xf32>,
|
|
%arg2: memref<?xf32>,
|
|
%arg3: index) {
|
|
cond_br %arg0, ^bb1, ^bb2(%arg3: index)
|
|
^bb1:
|
|
br ^bb6(%arg1 : memref<?xf32>)
|
|
^bb2(%0: index):
|
|
%1 = memref.alloc(%0) : memref<?xf32>
|
|
test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
|
|
cond_br %arg0, ^bb3, ^bb4
|
|
^bb3:
|
|
br ^bb5(%1 : memref<?xf32>)
|
|
^bb4:
|
|
br ^bb5(%1 : memref<?xf32>)
|
|
^bb5(%2: memref<?xf32>):
|
|
br ^bb6(%2 : memref<?xf32>)
|
|
^bb6(%3: memref<?xf32>):
|
|
br ^bb7(%3 : memref<?xf32>)
|
|
^bb7(%4: memref<?xf32>):
|
|
test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: cond_br{{.*}}
|
|
// CHECK-NEXT: ^bb1
|
|
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.clone
|
|
// CHECK-NEXT: br ^bb6(%[[ALLOC0]]
|
|
// CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]])
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: cond_br
|
|
// CHECK: ^bb3:
|
|
// CHECK-NEXT: br ^bb5(%[[ALLOC1]]{{.*}})
|
|
// CHECK: ^bb4:
|
|
// CHECK-NEXT: br ^bb5(%[[ALLOC1]]{{.*}})
|
|
// CHECK-NEXT: ^bb5(%[[ALLOC2:.*]]:{{.*}})
|
|
// CHECK-NEXT: %[[ALLOC3:.*]] = memref.clone %[[ALLOC2]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
|
|
// CHECK-NEXT: br ^bb6(%[[ALLOC3]]{{.*}})
|
|
// CHECK-NEXT: ^bb6(%[[ALLOC4:.*]]:{{.*}})
|
|
// CHECK-NEXT: br ^bb7(%[[ALLOC4]]{{.*}})
|
|
// CHECK-NEXT: ^bb7(%[[ALLOC5:.*]]:{{.*}})
|
|
// CHECK: test.copy(%[[ALLOC5]],
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC4]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case: Existing AllocOp with no users.
|
|
// BufferDeallocation expected behavior: It should insert a DeallocOp right
|
|
// before ReturnOp.
|
|
|
|
// CHECK-LABEL: func @emptyUsesValue
|
|
func @emptyUsesValue(%arg0: memref<4xf32>) {
|
|
%0 = memref.alloc() : memref<4xf32>
|
|
return
|
|
}
|
|
// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case:
|
|
// bb0
|
|
// / \
|
|
// | bb1 <- Initial position of AllocOp
|
|
// \ /
|
|
// bb2
|
|
// BufferDeallocation expected behavior: It should insert a DeallocOp at the
|
|
// exit block after CopyOp since %1 is an alias for %0 and %arg1. Furthermore,
|
|
// we have to insert a copy and an alloc in the beginning of the function.
|
|
|
|
// CHECK-LABEL: func @criticalEdge
|
|
func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
|
|
cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
|
|
^bb1:
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
|
|
br ^bb2(%0 : memref<2xf32>)
|
|
^bb2(%1: memref<2xf32>):
|
|
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.clone
|
|
// CHECK-NEXT: cond_br
|
|
// CHECK: %[[ALLOC1:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK-NEXT: %[[ALLOC2:.*]] = memref.clone %[[ALLOC1]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case:
|
|
// bb0 <- Initial position of AllocOp
|
|
// / \
|
|
// | bb1
|
|
// \ /
|
|
// bb2
|
|
// BufferDeallocation expected behavior: It only inserts a DeallocOp at the
|
|
// exit block after CopyOp since %1 is an alias for %0 and %arg1.
|
|
|
|
// CHECK-LABEL: func @invCriticalEdge
|
|
func @invCriticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
|
|
cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
|
|
^bb1:
|
|
br ^bb2(%0 : memref<2xf32>)
|
|
^bb2(%1: memref<2xf32>):
|
|
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK: dealloc
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case:
|
|
// bb0 <- Initial position of the first AllocOp
|
|
// / \
|
|
// bb1 bb2
|
|
// \ /
|
|
// bb3 <- Initial position of the second AllocOp
|
|
// BufferDeallocation expected behavior: It only inserts two missing
|
|
// DeallocOps in the exit block. %5 is an alias for %0. Therefore, the
|
|
// DeallocOp for %0 should occur after the last BufferBasedOp. The Dealloc for
|
|
// %7 should happen after CopyOp.
|
|
|
|
// CHECK-LABEL: func @ifElse
|
|
func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: 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 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>)
|
|
test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: %[[SECOND_ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: memref.dealloc %[[FIRST_ALLOC]]
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[SECOND_ALLOC]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case: No users for buffer in if-else CFG
|
|
// bb0 <- Initial position of AllocOp
|
|
// / \
|
|
// bb1 bb2
|
|
// \ /
|
|
// bb3
|
|
// BufferDeallocation expected behavior: It only inserts a missing DeallocOp
|
|
// in the exit block since %5 or %6 are the latest aliases of %0.
|
|
|
|
// CHECK-LABEL: func @ifElseNoUsers
|
|
func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: 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>):
|
|
test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[FIRST_ALLOC]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case:
|
|
// bb0 <- Initial position of the first AllocOp
|
|
// / \
|
|
// bb1 bb2
|
|
// | / \
|
|
// | bb3 bb4
|
|
// \ \ /
|
|
// \ /
|
|
// bb5 <- Initial position of the second AllocOp
|
|
// BufferDeallocation expected behavior: Two missing DeallocOps should be
|
|
// inserted in the exit block.
|
|
|
|
// CHECK-LABEL: func @ifElseNested
|
|
func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: 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 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
|
|
test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: %[[SECOND_ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: memref.dealloc %[[FIRST_ALLOC]]
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[SECOND_ALLOC]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case: Dead operations in a single block.
|
|
// BufferDeallocation expected behavior: It only inserts the two missing
|
|
// DeallocOps after the last BufferBasedOp.
|
|
|
|
// CHECK-LABEL: func @redundantOperations
|
|
func @redundantOperations(%arg0: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
|
|
%1 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%0: memref<2xf32>) out(%1: memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK: (%[[ARG0:.*]]: {{.*}})
|
|
// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based in(%[[ARG0]]{{.*}}out(%[[FIRST_ALLOC]]
|
|
// CHECK: %[[SECOND_ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based in(%[[FIRST_ALLOC]]{{.*}}out(%[[SECOND_ALLOC]]
|
|
// CHECK: dealloc
|
|
// CHECK-NEXT: dealloc
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case:
|
|
// bb0
|
|
// / \
|
|
// Initial pos of the 1st AllocOp -> bb1 bb2 <- Initial pos of the 2nd AllocOp
|
|
// \ /
|
|
// bb3
|
|
// BufferDeallocation expected behavior: We need to introduce a copy for each
|
|
// buffer since the buffers are passed to bb3. The both missing DeallocOps are
|
|
// inserted in the respective block of the allocs. The copy is freed in the exit
|
|
// block.
|
|
|
|
// CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc
|
|
func @moving_alloc_and_inserting_missing_dealloc(
|
|
%cond: i1,
|
|
%arg0: memref<2xf32>,
|
|
%arg1: memref<2xf32>) {
|
|
cond_br %cond, ^bb1, ^bb2
|
|
^bb1:
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
|
|
br ^exit(%0 : memref<2xf32>)
|
|
^bb2:
|
|
%1 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
|
|
br ^exit(%1 : memref<2xf32>)
|
|
^exit(%arg2: memref<2xf32>):
|
|
test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: cond_br{{.*}}
|
|
// CHECK-NEXT: ^bb1
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.clone %[[ALLOC0]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
|
|
// CHECK-NEXT: br ^bb3(%[[ALLOC1]]
|
|
// CHECK-NEXT: ^bb2
|
|
// CHECK-NEXT: %[[ALLOC2:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK-NEXT: %[[ALLOC3:.*]] = memref.clone %[[ALLOC2]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC2]]
|
|
// CHECK-NEXT: br ^bb3(%[[ALLOC3]]
|
|
// CHECK-NEXT: ^bb3(%[[ALLOC4:.*]]:{{.*}})
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC4]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case: Invalid position of the DeallocOp. There is a user after
|
|
// deallocation.
|
|
// bb0
|
|
// / \
|
|
// bb1 bb2 <- Initial position of AllocOp
|
|
// \ /
|
|
// bb3
|
|
// BufferDeallocation expected behavior: The existing DeallocOp should be
|
|
// moved to exit block.
|
|
|
|
// CHECK-LABEL: func @moving_invalid_dealloc_op_complex
|
|
func @moving_invalid_dealloc_op_complex(
|
|
%cond: i1,
|
|
%arg0: memref<2xf32>,
|
|
%arg1: memref<2xf32>) {
|
|
%1 = memref.alloc() : memref<2xf32>
|
|
cond_br %cond, ^bb1, ^bb2
|
|
^bb1:
|
|
br ^exit(%arg0 : memref<2xf32>)
|
|
^bb2:
|
|
test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
|
|
memref.dealloc %1 : memref<2xf32>
|
|
br ^exit(%1 : memref<2xf32>)
|
|
^exit(%arg2: memref<2xf32>):
|
|
test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK-NEXT: cond_br
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case: Inserting missing DeallocOp in a single block.
|
|
|
|
// CHECK-LABEL: func @inserting_missing_dealloc_simple
|
|
func @inserting_missing_dealloc_simple(
|
|
%arg0 : memref<2xf32>,
|
|
%arg1: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
|
|
test.copy(%0, %arg1) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
|
|
|
|
// -----
|
|
|
|
// Test Case: Moving invalid DeallocOp (there is a user after deallocation) in a
|
|
// single block.
|
|
|
|
// CHECK-LABEL: func @moving_invalid_dealloc_op
|
|
func @moving_invalid_dealloc_op(%arg0 : memref<2xf32>, %arg1: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
|
|
memref.dealloc %0 : memref<2xf32>
|
|
test.copy(%0, %arg1) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
|
|
|
|
// -----
|
|
|
|
// Test Case: Nested regions - This test defines a BufferBasedOp inside the
|
|
// region of a RegionBufferBasedOp.
|
|
// BufferDeallocation expected behavior: The AllocOp for the BufferBasedOp
|
|
// should remain inside the region of the RegionBufferBasedOp and it should insert
|
|
// the missing DeallocOp in the same region. The missing DeallocOp should be
|
|
// inserted after CopyOp.
|
|
|
|
// CHECK-LABEL: func @nested_regions_and_cond_branch
|
|
func @nested_regions_and_cond_branch(
|
|
%arg0: i1,
|
|
%arg1: memref<2xf32>,
|
|
%arg2: memref<2xf32>) {
|
|
cond_br %arg0, ^bb1, ^bb2
|
|
^bb1:
|
|
br ^bb3(%arg1 : memref<2xf32>)
|
|
^bb2:
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
|
|
^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
|
|
%1 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
|
|
%tmp1 = math.exp %gen1_arg0 : f32
|
|
test.region_yield %tmp1 : f32
|
|
}
|
|
br ^bb3(%0 : memref<2xf32>)
|
|
^bb3(%1: memref<2xf32>):
|
|
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
// CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}})
|
|
// CHECK-NEXT: cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]]
|
|
// CHECK: %[[ALLOC0:.*]] = memref.clone %[[ARG1]]
|
|
// CHECK: ^[[BB2]]:
|
|
// CHECK: %[[ALLOC1:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.region_buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC1]]
|
|
// CHECK: %[[ALLOC2:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC2]]
|
|
// CHECK: memref.dealloc %[[ALLOC2]]
|
|
// CHECK-NEXT: %{{.*}} = math.exp
|
|
// CHECK: %[[ALLOC3:.*]] = memref.clone %[[ALLOC1]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
|
|
// CHECK: ^[[BB3:.*]]({{.*}}):
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc
|
|
|
|
// -----
|
|
|
|
// Test Case: buffer deallocation escaping
|
|
// BufferDeallocation expected behavior: It must not dealloc %arg1 and %x
|
|
// since they are operands of return operation and should escape from
|
|
// deallocating. It should dealloc %y after CopyOp.
|
|
|
|
// CHECK-LABEL: func @memref_in_function_results
|
|
func @memref_in_function_results(
|
|
%arg0: memref<5xf32>,
|
|
%arg1: memref<10xf32>,
|
|
%arg2: memref<5xf32>) -> (memref<10xf32>, memref<15xf32>) {
|
|
%x = memref.alloc() : memref<15xf32>
|
|
%y = memref.alloc() : memref<5xf32>
|
|
test.buffer_based in(%arg0: memref<5xf32>) out(%y: memref<5xf32>)
|
|
test.copy(%y, %arg2) : (memref<5xf32>, memref<5xf32>)
|
|
return %arg1, %x : memref<10xf32>, memref<15xf32>
|
|
}
|
|
// CHECK: (%[[ARG0:.*]]: memref<5xf32>, %[[ARG1:.*]]: memref<10xf32>,
|
|
// CHECK-SAME: %[[RESULT:.*]]: memref<5xf32>)
|
|
// CHECK: %[[X:.*]] = memref.alloc()
|
|
// CHECK: %[[Y:.*]] = memref.alloc()
|
|
// CHECK: test.copy
|
|
// CHECK: memref.dealloc %[[Y]]
|
|
// CHECK: return %[[ARG1]], %[[X]]
|
|
|
|
// -----
|
|
|
|
// Test Case: nested region control flow
|
|
// The alloc %1 flows through both if branches until it is finally returned.
|
|
// Hence, it does not require a specific dealloc operation. However, %3
|
|
// requires a dealloc.
|
|
|
|
// CHECK-LABEL: func @nested_region_control_flow
|
|
func @nested_region_control_flow(
|
|
%arg0 : index,
|
|
%arg1 : index) -> memref<?x?xf32> {
|
|
%0 = cmpi eq, %arg0, %arg1 : index
|
|
%1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
|
|
%2 = scf.if %0 -> (memref<?x?xf32>) {
|
|
scf.yield %1 : memref<?x?xf32>
|
|
} else {
|
|
%3 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
|
|
scf.yield %1 : memref<?x?xf32>
|
|
}
|
|
return %2 : memref<?x?xf32>
|
|
}
|
|
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = scf.if
|
|
// CHECK: scf.yield %[[ALLOC0]]
|
|
// CHECK: %[[ALLOC2:.*]] = memref.alloc(%arg0, %arg1)
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC2]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC0]]
|
|
// CHECK: return %[[ALLOC1]]
|
|
|
|
// -----
|
|
|
|
// Test Case: nested region control flow with a nested buffer allocation in a
|
|
// divergent branch.
|
|
// Buffer deallocation places a copy for both %1 and %3, since they are
|
|
// returned in the end.
|
|
|
|
// CHECK-LABEL: func @nested_region_control_flow_div
|
|
func @nested_region_control_flow_div(
|
|
%arg0 : index,
|
|
%arg1 : index) -> memref<?x?xf32> {
|
|
%0 = cmpi eq, %arg0, %arg1 : index
|
|
%1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
|
|
%2 = scf.if %0 -> (memref<?x?xf32>) {
|
|
scf.yield %1 : memref<?x?xf32>
|
|
} else {
|
|
%3 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
|
|
scf.yield %3 : memref<?x?xf32>
|
|
}
|
|
return %2 : memref<?x?xf32>
|
|
}
|
|
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = scf.if
|
|
// CHECK-NEXT: %[[ALLOC2:.*]] = memref.clone %[[ALLOC0]]
|
|
// CHECK: scf.yield %[[ALLOC2]]
|
|
// CHECK: %[[ALLOC3:.*]] = memref.alloc(%arg0, %arg1)
|
|
// CHECK-NEXT: %[[ALLOC4:.*]] = memref.clone %[[ALLOC3]]
|
|
// CHECK: memref.dealloc %[[ALLOC3]]
|
|
// CHECK: scf.yield %[[ALLOC4]]
|
|
// CHECK: memref.dealloc %[[ALLOC0]]
|
|
// CHECK-NEXT: return %[[ALLOC1]]
|
|
|
|
// -----
|
|
|
|
// Test Case: nested region control flow within a region interface.
|
|
// No copies are required in this case since the allocation finally escapes
|
|
// the method.
|
|
|
|
// CHECK-LABEL: func @inner_region_control_flow
|
|
func @inner_region_control_flow(%arg0 : index) -> memref<?x?xf32> {
|
|
%0 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
|
|
%1 = test.region_if %0 : memref<?x?xf32> -> (memref<?x?xf32>) then {
|
|
^bb0(%arg1 : memref<?x?xf32>):
|
|
test.region_if_yield %arg1 : memref<?x?xf32>
|
|
} else {
|
|
^bb0(%arg1 : memref<?x?xf32>):
|
|
test.region_if_yield %arg1 : memref<?x?xf32>
|
|
} join {
|
|
^bb0(%arg1 : memref<?x?xf32>):
|
|
test.region_if_yield %arg1 : memref<?x?xf32>
|
|
}
|
|
return %1 : memref<?x?xf32>
|
|
}
|
|
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = test.region_if
|
|
// CHECK-NEXT: ^bb0(%[[ALLOC2:.*]]:{{.*}}):
|
|
// CHECK-NEXT: test.region_if_yield %[[ALLOC2]]
|
|
// CHECK: ^bb0(%[[ALLOC3:.*]]:{{.*}}):
|
|
// CHECK-NEXT: test.region_if_yield %[[ALLOC3]]
|
|
// CHECK: ^bb0(%[[ALLOC4:.*]]:{{.*}}):
|
|
// CHECK-NEXT: test.region_if_yield %[[ALLOC4]]
|
|
// CHECK: return %[[ALLOC1]]
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: func @subview
|
|
func @subview(%arg0 : index, %arg1 : index, %arg2 : memref<?x?xf32>) {
|
|
%0 = memref.alloc() : memref<64x4xf32, offset: 0, strides: [4, 1]>
|
|
%1 = memref.subview %0[%arg0, %arg1][%arg0, %arg1][%arg0, %arg1] :
|
|
memref<64x4xf32, offset: 0, strides: [4, 1]>
|
|
to memref<?x?xf32, offset: ?, strides: [?, ?]>
|
|
test.copy(%1, %arg2) :
|
|
(memref<?x?xf32, offset: ?, strides: [?, ?]>, memref<?x?xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: memref.subview
|
|
// CHECK-NEXT: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case: In the presence of AllocaOps only the AllocOps has top be freed.
|
|
// Therefore, all allocas are not handled.
|
|
|
|
// 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 = memref.alloca() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
|
|
br ^bb3(%0 : memref<2xf32>)
|
|
^bb3(%1: memref<2xf32>):
|
|
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: cond_br
|
|
// CHECK: %[[ALLOCA:.*]] = memref.alloca()
|
|
// CHECK: br ^bb3(%[[ALLOCA:.*]])
|
|
// CHECK-NEXT: ^bb3
|
|
// CHECK-NEXT: test.copy
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// Test Case: In the presence of AllocaOps only the AllocOps has top be freed.
|
|
// Therefore, all allocas are not handled. In this case, only alloc %0 has a
|
|
// dealloc.
|
|
|
|
// CHECK-LABEL: func @ifElseAlloca
|
|
func @ifElseAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: 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 = memref.alloca() : memref<2xf32>
|
|
test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>)
|
|
test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: %[[ALLOCA:.*]] = memref.alloca()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: memref.dealloc %[[ALLOC]]
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: func @ifElseNestedAlloca
|
|
func @ifElseNestedAlloca(
|
|
%arg0: i1,
|
|
%arg1: memref<2xf32>,
|
|
%arg2: memref<2xf32>) {
|
|
%0 = memref.alloca() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%0: 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 = memref.alloc() : memref<2xf32>
|
|
test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
|
|
test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: %[[ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.buffer_based
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC]]
|
|
// CHECK-NEXT: return
|
|
|
|
// -----
|
|
|
|
// 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 = memref.alloc() : memref<2xf32>
|
|
test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
|
|
^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
|
|
%1 = memref.alloca() : memref<2xf32>
|
|
test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
|
|
%tmp1 = math.exp %gen1_arg0 : f32
|
|
test.region_yield %tmp1 : f32
|
|
}
|
|
br ^bb3(%0 : memref<2xf32>)
|
|
^bb3(%1: memref<2xf32>):
|
|
test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
// CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}})
|
|
// CHECK-NEXT: cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]]
|
|
// CHECK: ^[[BB1]]:
|
|
// CHECK: %[[ALLOC0:.*]] = memref.clone
|
|
// CHECK: ^[[BB2]]:
|
|
// CHECK: %[[ALLOC1:.*]] = memref.alloc()
|
|
// CHECK-NEXT: test.region_buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC1]]
|
|
// CHECK: %[[ALLOCA:.*]] = memref.alloca()
|
|
// CHECK-NEXT: test.buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOCA]]
|
|
// CHECK: %{{.*}} = math.exp
|
|
// CHECK: %[[ALLOC2:.*]] = memref.clone %[[ALLOC1]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
|
|
// CHECK: ^[[BB3:.*]]({{.*}}):
|
|
// CHECK: test.copy
|
|
// CHECK-NEXT: memref.dealloc
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: func @nestedRegionControlFlowAlloca
|
|
func @nestedRegionControlFlowAlloca(
|
|
%arg0 : index,
|
|
%arg1 : index) -> memref<?x?xf32> {
|
|
%0 = cmpi eq, %arg0, %arg1 : index
|
|
%1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
|
|
%2 = scf.if %0 -> (memref<?x?xf32>) {
|
|
scf.yield %1 : memref<?x?xf32>
|
|
} else {
|
|
%3 = memref.alloca(%arg0, %arg1) : memref<?x?xf32>
|
|
scf.yield %1 : memref<?x?xf32>
|
|
}
|
|
return %2 : memref<?x?xf32>
|
|
}
|
|
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = scf.if
|
|
// CHECK: scf.yield %[[ALLOC0]]
|
|
// CHECK: %[[ALLOCA:.*]] = memref.alloca(%arg0, %arg1)
|
|
// CHECK-NEXT: scf.yield %[[ALLOC0]]
|
|
// CHECK: return %[[ALLOC1]]
|
|
|
|
// -----
|
|
|
|
// Test Case: structured control-flow loop using a nested alloc.
|
|
// The iteration argument %iterBuf has to be freed before yielding %3 to avoid
|
|
// memory leaks.
|
|
|
|
// CHECK-LABEL: func @loop_alloc
|
|
func @loop_alloc(
|
|
%lb: index,
|
|
%ub: index,
|
|
%step: index,
|
|
%buf: memref<2xf32>,
|
|
%res: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
%1 = scf.for %i = %lb to %ub step %step
|
|
iter_args(%iterBuf = %buf) -> memref<2xf32> {
|
|
%2 = cmpi eq, %i, %ub : index
|
|
%3 = memref.alloc() : memref<2xf32>
|
|
scf.yield %3 : memref<2xf32>
|
|
}
|
|
test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.clone %arg3
|
|
// CHECK: %[[ALLOC2:.*]] = scf.for {{.*}} iter_args
|
|
// CHECK-SAME: (%[[IALLOC:.*]] = %[[ALLOC1]]
|
|
// CHECK: cmpi
|
|
// CHECK: memref.dealloc %[[IALLOC]]
|
|
// CHECK: %[[ALLOC3:.*]] = memref.alloc()
|
|
// CHECK: %[[ALLOC4:.*]] = memref.clone %[[ALLOC3]]
|
|
// CHECK: memref.dealloc %[[ALLOC3]]
|
|
// CHECK: scf.yield %[[ALLOC4]]
|
|
// CHECK: }
|
|
// CHECK: test.copy(%[[ALLOC2]], %arg4)
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC2]]
|
|
|
|
// -----
|
|
|
|
// Test Case: structured control-flow loop with a nested if operation.
|
|
// The loop yields buffers that have been defined outside of the loop and the
|
|
// backedges only use the iteration arguments (or one of its aliases).
|
|
// Therefore, we do not have to (and are not allowed to) free any buffers
|
|
// that are passed via the backedges.
|
|
|
|
// CHECK-LABEL: func @loop_nested_if_no_alloc
|
|
func @loop_nested_if_no_alloc(
|
|
%lb: index,
|
|
%ub: index,
|
|
%step: index,
|
|
%buf: memref<2xf32>,
|
|
%res: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
%1 = scf.for %i = %lb to %ub step %step
|
|
iter_args(%iterBuf = %buf) -> memref<2xf32> {
|
|
%2 = cmpi eq, %i, %ub : index
|
|
%3 = scf.if %2 -> (memref<2xf32>) {
|
|
scf.yield %0 : memref<2xf32>
|
|
} else {
|
|
scf.yield %iterBuf : memref<2xf32>
|
|
}
|
|
scf.yield %3 : memref<2xf32>
|
|
}
|
|
test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = scf.for {{.*}} iter_args(%[[IALLOC:.*]] =
|
|
// CHECK: %[[ALLOC2:.*]] = scf.if
|
|
// CHECK: scf.yield %[[ALLOC0]]
|
|
// CHECK: scf.yield %[[IALLOC]]
|
|
// CHECK: scf.yield %[[ALLOC2]]
|
|
// CHECK: test.copy(%[[ALLOC1]], %arg4)
|
|
// CHECK: memref.dealloc %[[ALLOC0]]
|
|
|
|
// -----
|
|
|
|
// Test Case: structured control-flow loop with a nested if operation using
|
|
// a deeply nested buffer allocation.
|
|
// Since the innermost allocation happens in a divergent branch, we have to
|
|
// introduce additional copies for the nested if operation. Since the loop's
|
|
// yield operation "returns" %3, it will return a newly allocated buffer.
|
|
// Therefore, we have to free the iteration argument %iterBuf before
|
|
// "returning" %3.
|
|
|
|
// CHECK-LABEL: func @loop_nested_if_alloc
|
|
func @loop_nested_if_alloc(
|
|
%lb: index,
|
|
%ub: index,
|
|
%step: index,
|
|
%buf: memref<2xf32>) -> memref<2xf32> {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
%1 = scf.for %i = %lb to %ub step %step
|
|
iter_args(%iterBuf = %buf) -> memref<2xf32> {
|
|
%2 = cmpi eq, %i, %ub : index
|
|
%3 = scf.if %2 -> (memref<2xf32>) {
|
|
%4 = memref.alloc() : memref<2xf32>
|
|
scf.yield %4 : memref<2xf32>
|
|
} else {
|
|
scf.yield %0 : memref<2xf32>
|
|
}
|
|
scf.yield %3 : memref<2xf32>
|
|
}
|
|
return %1 : memref<2xf32>
|
|
}
|
|
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.clone %arg3
|
|
// CHECK-NEXT: %[[ALLOC2:.*]] = scf.for {{.*}} iter_args
|
|
// CHECK-SAME: (%[[IALLOC:.*]] = %[[ALLOC1]]
|
|
// CHECK: memref.dealloc %[[IALLOC]]
|
|
// CHECK: %[[ALLOC3:.*]] = scf.if
|
|
|
|
// CHECK: %[[ALLOC4:.*]] = memref.alloc()
|
|
// CHECK-NEXT: %[[ALLOC5:.*]] = memref.clone %[[ALLOC4]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC4]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC5]]
|
|
|
|
// CHECK: %[[ALLOC6:.*]] = memref.clone %[[ALLOC0]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC6]]
|
|
|
|
// CHECK: %[[ALLOC7:.*]] = memref.clone %[[ALLOC3]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC3]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC7]]
|
|
|
|
// CHECK: memref.dealloc %[[ALLOC0]]
|
|
// CHECK-NEXT: return %[[ALLOC2]]
|
|
|
|
// -----
|
|
|
|
// Test Case: several nested structured control-flow loops with a deeply nested
|
|
// buffer allocation inside an if operation.
|
|
// Same behavior is an loop_nested_if_alloc: we have to insert deallocations
|
|
// before each yield in all loops recursively.
|
|
|
|
// CHECK-LABEL: func @loop_nested_alloc
|
|
func @loop_nested_alloc(
|
|
%lb: index,
|
|
%ub: index,
|
|
%step: index,
|
|
%buf: memref<2xf32>,
|
|
%res: memref<2xf32>) {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
%1 = scf.for %i = %lb to %ub step %step
|
|
iter_args(%iterBuf = %buf) -> memref<2xf32> {
|
|
%2 = scf.for %i2 = %lb to %ub step %step
|
|
iter_args(%iterBuf2 = %iterBuf) -> memref<2xf32> {
|
|
%3 = scf.for %i3 = %lb to %ub step %step
|
|
iter_args(%iterBuf3 = %iterBuf2) -> memref<2xf32> {
|
|
%4 = memref.alloc() : memref<2xf32>
|
|
%5 = cmpi eq, %i, %ub : index
|
|
%6 = scf.if %5 -> (memref<2xf32>) {
|
|
%7 = memref.alloc() : memref<2xf32>
|
|
scf.yield %7 : memref<2xf32>
|
|
} else {
|
|
scf.yield %iterBuf3 : memref<2xf32>
|
|
}
|
|
scf.yield %6 : memref<2xf32>
|
|
}
|
|
scf.yield %3 : memref<2xf32>
|
|
}
|
|
scf.yield %2 : memref<2xf32>
|
|
}
|
|
test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
|
|
// CHECK-NEXT: %[[ALLOC1:.*]] = memref.clone %arg3
|
|
// CHECK-NEXT: %[[VAL_7:.*]] = scf.for {{.*}} iter_args
|
|
// CHECK-SAME: (%[[IALLOC0:.*]] = %[[ALLOC1]])
|
|
// CHECK-NEXT: %[[ALLOC2:.*]] = memref.clone %[[IALLOC0]]
|
|
// CHECK-NEXT: memref.dealloc %[[IALLOC0]]
|
|
// CHECK-NEXT: %[[ALLOC3:.*]] = scf.for {{.*}} iter_args
|
|
// CHECK-SAME: (%[[IALLOC1:.*]] = %[[ALLOC2]])
|
|
// CHECK-NEXT: %[[ALLOC5:.*]] = memref.clone %[[IALLOC1]]
|
|
// CHECK-NEXT: memref.dealloc %[[IALLOC1]]
|
|
|
|
// CHECK: %[[ALLOC6:.*]] = scf.for {{.*}} iter_args
|
|
// CHECK-SAME: (%[[IALLOC2:.*]] = %[[ALLOC5]])
|
|
// CHECK: %[[ALLOC8:.*]] = memref.alloc()
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC8]]
|
|
// CHECK: %[[ALLOC9:.*]] = scf.if
|
|
|
|
// CHECK: %[[ALLOC11:.*]] = memref.alloc()
|
|
// CHECK-NEXT: %[[ALLOC12:.*]] = memref.clone %[[ALLOC11]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC11]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC12]]
|
|
|
|
// CHECK: %[[ALLOC13:.*]] = memref.clone %[[IALLOC2]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC13]]
|
|
|
|
// CHECK: memref.dealloc %[[IALLOC2]]
|
|
// CHECK-NEXT: %[[ALLOC10:.*]] = memref.clone %[[ALLOC9]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC9]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC10]]
|
|
|
|
// CHECK: %[[ALLOC7:.*]] = memref.clone %[[ALLOC6]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC6]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC7]]
|
|
|
|
// CHECK: %[[ALLOC4:.*]] = memref.clone %[[ALLOC3]]
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC3]]
|
|
// CHECK-NEXT: scf.yield %[[ALLOC4]]
|
|
|
|
// CHECK: test.copy(%[[VAL_7]], %arg4)
|
|
// CHECK-NEXT: memref.dealloc %[[VAL_7]]
|
|
|
|
// -----
|
|
|
|
// Test Case: explicit control-flow loop with a dynamically allocated buffer.
|
|
// The BufferDeallocation transformation should fail on this explicit
|
|
// control-flow loop since they are not supported.
|
|
|
|
// expected-error@+1 {{Only structured control-flow loops are supported}}
|
|
func @loop_dynalloc(
|
|
%arg0 : i32,
|
|
%arg1 : i32,
|
|
%arg2: memref<?xf32>,
|
|
%arg3: memref<?xf32>) {
|
|
%const0 = constant 0 : i32
|
|
br ^loopHeader(%const0, %arg2 : i32, memref<?xf32>)
|
|
|
|
^loopHeader(%i : i32, %buff : memref<?xf32>):
|
|
%lessThan = cmpi slt, %i, %arg1 : i32
|
|
cond_br %lessThan,
|
|
^loopBody(%i, %buff : i32, memref<?xf32>),
|
|
^exit(%buff : memref<?xf32>)
|
|
|
|
^loopBody(%val : i32, %buff2: memref<?xf32>):
|
|
%const1 = constant 1 : i32
|
|
%inc = addi %val, %const1 : i32
|
|
%size = std.index_cast %inc : i32 to index
|
|
%alloc1 = memref.alloc(%size) : memref<?xf32>
|
|
br ^loopHeader(%inc, %alloc1 : i32, memref<?xf32>)
|
|
|
|
^exit(%buff3 : memref<?xf32>):
|
|
test.copy(%buff3, %arg3) : (memref<?xf32>, memref<?xf32>)
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// Test Case: explicit control-flow loop with a dynamically allocated buffer.
|
|
// The BufferDeallocation transformation should fail on this explicit
|
|
// control-flow loop since they are not supported.
|
|
|
|
// expected-error@+1 {{Only structured control-flow loops are supported}}
|
|
func @do_loop_alloc(
|
|
%arg0 : i32,
|
|
%arg1 : i32,
|
|
%arg2: memref<2xf32>,
|
|
%arg3: memref<2xf32>) {
|
|
%const0 = constant 0 : i32
|
|
br ^loopBody(%const0, %arg2 : i32, memref<2xf32>)
|
|
|
|
^loopBody(%val : i32, %buff2: memref<2xf32>):
|
|
%const1 = constant 1 : i32
|
|
%inc = addi %val, %const1 : i32
|
|
%alloc1 = memref.alloc() : memref<2xf32>
|
|
br ^loopHeader(%inc, %alloc1 : i32, memref<2xf32>)
|
|
|
|
^loopHeader(%i : i32, %buff : memref<2xf32>):
|
|
%lessThan = cmpi slt, %i, %arg1 : i32
|
|
cond_br %lessThan,
|
|
^loopBody(%i, %buff : i32, memref<2xf32>),
|
|
^exit(%buff : memref<2xf32>)
|
|
|
|
^exit(%buff3 : memref<2xf32>):
|
|
test.copy(%buff3, %arg3) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: func @assumingOp(
|
|
func @assumingOp(
|
|
%arg0: !shape.witness,
|
|
%arg2: memref<2xf32>,
|
|
%arg3: memref<2xf32>) {
|
|
// Confirm the alloc will be dealloc'ed in the block.
|
|
%1 = shape.assuming %arg0 -> memref<2xf32> {
|
|
%0 = memref.alloc() : memref<2xf32>
|
|
shape.assuming_yield %arg2 : memref<2xf32>
|
|
}
|
|
// Confirm the alloc will be returned and dealloc'ed after its use.
|
|
%3 = shape.assuming %arg0 -> memref<2xf32> {
|
|
%2 = memref.alloc() : memref<2xf32>
|
|
shape.assuming_yield %2 : memref<2xf32>
|
|
}
|
|
test.copy(%3, %arg3) : (memref<2xf32>, memref<2xf32>)
|
|
return
|
|
}
|
|
|
|
// CHECK-SAME: %[[ARG0:.*]]: !shape.witness,
|
|
// CHECK-SAME: %[[ARG1:.*]]: {{.*}},
|
|
// CHECK-SAME: %[[ARG2:.*]]: {{.*}}
|
|
// CHECK: %[[UNUSED_RESULT:.*]] = shape.assuming %[[ARG0]]
|
|
// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
|
|
// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
|
|
// CHECK-NEXT: shape.assuming_yield %[[ARG1]]
|
|
// CHECK: %[[ASSUMING_RESULT:.*]] = shape.assuming %[[ARG0]]
|
|
// CHECK-NEXT: %[[TMP_ALLOC:.*]] = memref.alloc()
|
|
// CHECK-NEXT: %[[RETURNING_ALLOC:.*]] = memref.clone %[[TMP_ALLOC]]
|
|
// CHECK-NEXT: memref.dealloc %[[TMP_ALLOC]]
|
|
// CHECK-NEXT: shape.assuming_yield %[[RETURNING_ALLOC]]
|
|
// CHECK: test.copy(%[[ASSUMING_RESULT:.*]], %[[ARG2]])
|
|
// CHECK-NEXT: memref.dealloc %[[ASSUMING_RESULT]]
|
|
|
|
// -----
|
|
|
|
// Test Case: The op "test.bar" does not implement the RegionBranchOpInterface.
|
|
// This is not allowed in buffer deallocation.
|
|
|
|
func @noRegionBranchOpInterface() {
|
|
// expected-error@+1 {{All operations with attached regions need to implement the RegionBranchOpInterface.}}
|
|
%0 = "test.bar"() ( {
|
|
// expected-error@+1 {{All operations with attached regions need to implement the RegionBranchOpInterface.}}
|
|
%1 = "test.bar"() ( {
|
|
"test.yield"() : () -> ()
|
|
}) : () -> (i32)
|
|
"test.yield"() : () -> ()
|
|
}) : () -> (i32)
|
|
"test.terminator"() : () -> ()
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: func @dealloc_existing_clones
|
|
// CHECK: (%[[ARG0:.*]]: memref<?x?xf64>, %[[ARG1:.*]]: memref<?x?xf64>)
|
|
// CHECK: %[[RES0:.*]] = memref.clone %[[ARG0]]
|
|
// CHECK: %[[RES1:.*]] = memref.clone %[[ARG1]]
|
|
// CHECK-NOT: memref.dealloc %[[RES0]]
|
|
// CHECK: memref.dealloc %[[RES1]]
|
|
// CHECK: return %[[RES0]]
|
|
func @dealloc_existing_clones(%arg0: memref<?x?xf64>, %arg1: memref<?x?xf64>) -> memref<?x?xf64> {
|
|
%0 = memref.clone %arg0 : memref<?x?xf64> to memref<?x?xf64>
|
|
%1 = memref.clone %arg1 : memref<?x?xf64> to memref<?x?xf64>
|
|
return %0 : memref<?x?xf64>
|
|
}
|