[flang-commits] [flang] [flang][OpenMP] fix lastprivate for allocatables (PR #99686)
Tom Eccles via flang-commits
flang-commits at lists.llvm.org
Sat Jul 20 06:37:09 PDT 2024
https://github.com/tblah updated https://github.com/llvm/llvm-project/pull/99686
>From c62761e8595838a2b0588cce270081f8d22187cc Mon Sep 17 00:00:00 2001
From: Tom Eccles <tom.eccles at arm.com>
Date: Fri, 19 Jul 2024 18:22:34 +0000
Subject: [PATCH 1/3] [flang][OpenMP] fix lastprivate for allocatables
1) Do not deallocate allocatable private variables if they are
lastprivate at the end of the openmp region because their address
will have been transferred to the host variable when the variable
is copied.
2) Don't use copyHostAssociateVar for allocatable variables. It isn't
clear to me whether or not this should be addressed in
copyHostAssociateVar instead of inside OpenMP. I opted for OpenMP
to minimise how many things I effected. copyHostAssociateVar will
not update the destination variable if the destination variable
was unallocated. This is incorrect because assignment inside of the
openmp block can cause the allocation status of the variable to
change. Furthermore, copyHostAssociateVar seems to only copy the
variable address not other metadata like the size of the allocation.
Reallocation by assignment could cause this to change.
---
.../lib/Lower/OpenMP/DataSharingProcessor.cpp | 50 +++++++++++++++++--
.../Lower/OpenMP/lastprivate-allocatable.f90 | 44 ++++++++++++++++
2 files changed, 91 insertions(+), 3 deletions(-)
create mode 100644 flang/test/Lower/OpenMP/lastprivate-allocatable.f90
diff --git a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
index c1d4c089df3b2..597d62f469d75 100644
--- a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
@@ -79,7 +79,8 @@ void DataSharingProcessor::processStep2(mlir::Operation *op, bool isLoop) {
void DataSharingProcessor::insertDeallocs() {
for (const semantics::Symbol *sym : allPrivatizedSymbols)
- if (semantics::IsAllocatable(sym->GetUltimate())) {
+ if (semantics::IsAllocatable(sym->GetUltimate()) &&
+ !sym->test(semantics::Symbol::Flag::OmpLastPrivate)) {
if (!useDelayedPrivatization) {
converter.createHostAssociateVarCloneDealloc(*sym);
continue;
@@ -127,8 +128,51 @@ void DataSharingProcessor::copyFirstPrivateSymbol(
void DataSharingProcessor::copyLastPrivateSymbol(
const semantics::Symbol *sym,
[[maybe_unused]] mlir::OpBuilder::InsertPoint *lastPrivIP) {
- if (sym->test(semantics::Symbol::Flag::OmpLastPrivate))
- converter.copyHostAssociateVar(*sym, lastPrivIP);
+ if (sym->test(semantics::Symbol::Flag::OmpLastPrivate)) {
+ bool allocatable = semantics::IsAllocatable(sym->GetUltimate());
+ if (!allocatable) {
+ converter.copyHostAssociateVar(*sym, lastPrivIP);
+ return;
+ }
+
+ // copyHostAssociateVar doesn't work properly if the privatised copy was
+ // reallocated (e.g. by assignment): it will only copy if the ultimate
+ // symbol was already allocated, and it only copies data so any reallocated
+ // lengths etc are lost
+
+ // 1) Fetch the original copy of the variable.
+ assert(sym->has<Fortran::semantics::HostAssocDetails>() &&
+ "No host-association found");
+ const Fortran::semantics::Symbol &hsym = sym->GetUltimate();
+ Fortran::lower::SymbolBox hsb = symTable->lookupOneLevelUpSymbol(hsym);
+ assert(hsb && "Host symbol box not found");
+
+ // 2) Fetch the copied one that will mask the original.
+ Fortran::lower::SymbolBox sb = symTable->shallowLookupSymbol(sym);
+ assert(sb && "Host-associated symbol box not found");
+ assert(hsb.getAddr() != sb.getAddr() &&
+ "Host and associated symbol boxes are the same");
+
+ // 3) Perform the assignment.
+ fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+ mlir::Location loc = converter.genLocation(sym->name());
+ mlir::OpBuilder::InsertPoint insPt = builder.saveInsertionPoint();
+ if (lastPrivIP && lastPrivIP->isSet())
+ builder.restoreInsertionPoint(*lastPrivIP);
+ else
+ builder.setInsertionPointAfter(sb.getAddr().getDefiningOp());
+
+ hlfir::Entity dst{hsb.getAddr()};
+ hlfir::Entity src{sb.getAddr()};
+ builder.create<hlfir::AssignOp>(
+ loc, src, dst, /*isWholeAllocatableAssignment=*/allocatable,
+ /*keepLhsLengthInAllocatableAssignment=*/false, /*temporary_lhs=*/true);
+
+ if (lastPrivIP && lastPrivIP->isSet() &&
+ sym->test(Fortran::semantics::Symbol::Flag::OmpLastPrivate)) {
+ builder.restoreInsertionPoint(insPt);
+ }
+ }
}
void DataSharingProcessor::collectOmpObjectListSymbol(
diff --git a/flang/test/Lower/OpenMP/lastprivate-allocatable.f90 b/flang/test/Lower/OpenMP/lastprivate-allocatable.f90
new file mode 100644
index 0000000000000..201c93576bda2
--- /dev/null
+++ b/flang/test/Lower/OpenMP/lastprivate-allocatable.f90
@@ -0,0 +1,44 @@
+! RUN: %flang_fc1 -emit-hlfir -o - -fopenmp %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - -fopenmp %s | FileCheck %s
+
+program lastprivate_allocatable
+ integer, allocatable :: a
+ integer :: i
+ ! a is unallocated here
+ !$omp parallel do lastprivate(a)
+ do i=1,1
+ a = 42
+ enddo
+ !$omp end parallel do
+ ! a should be allocated here
+end program
+
+! CHECK-LABEL: func.func @_QQmain()
+! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<i32>> {bindc_name = "a", uniq_name = "_QFEa"}
+! CHECK: %[[VAL_1:.*]] = fir.zero_bits !fir.heap<i32>
+! CHECK: %[[VAL_2:.*]] = fir.embox %[[VAL_1]] : (!fir.heap<i32>) -> !fir.box<!fir.heap<i32>>
+! CHECK: fir.store %[[VAL_2]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<i32>>>
+! CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_0]] {fortran_attrs = {{.*}}<allocatable>, uniq_name = "_QFEa"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
+! CHECK: omp.parallel {
+! create original copy of private variable
+! CHECK: %[[VAL_16:.*]]:2 = hlfir.declare %{{.*}} {fortran_attrs = {{.*}}<allocatable>, uniq_name = "_QFEa"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
+! CHECK: %[[VAL_17:.*]] = fir.alloca i32 {bindc_name = "i", pinned, uniq_name = "_QFEi"}
+! CHECK: %[[VAL_18:.*]]:2 = hlfir.declare %[[VAL_17]] {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+! CHECK: omp.wsloop {
+! CHECK: omp.loop_nest
+! [...]
+! if this is the last iteration
+! CHECK: fir.if %{{.*}} {
+! store loop IV
+! CHECK: fir.store %{{.*}} to %[[VAL_18]]#1 : !fir.ref<i32>
+! assign private variable to original copy: realloc and temporary_lhs
+! CHECK: hlfir.assign %[[VAL_16]]#0 to %[[VAL_3]]#0 realloc temporary_lhs : !fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>
+! CHECK-NEXT: }
+! CHECK-NEXT: omp.yield
+! CHECK-NEXT: }
+! CHECK-NEXT: omp.terminator
+! CHECK-NEXT: }
+! [no deallocation here]
+! CHECK-NEXT: omp.terminator
+! CHECK-NEXT: }
+
>From fc6346237c94b7d91dd59dffa8e6da8f5b776b5e Mon Sep 17 00:00:00 2001
From: Tom Eccles <tom.eccles at arm.com>
Date: Sat, 20 Jul 2024 10:55:46 +0000
Subject: [PATCH 2/3] Revert deallocation changes + add missing header
I was mistaken about the deallocation. Firstly, all of the other private
copies on threads that don't execute the last iteration need to be
freed. Secondly, the assign copies the data not the pointer.
---
flang/lib/Lower/OpenMP/DataSharingProcessor.cpp | 4 ++--
flang/test/Lower/OpenMP/lastprivate-allocatable.f90 | 6 ------
2 files changed, 2 insertions(+), 8 deletions(-)
diff --git a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
index 597d62f469d75..31eb4132713fc 100644
--- a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
@@ -17,6 +17,7 @@
#include "flang/Lower/SymbolMap.h"
#include "flang/Optimizer/Builder/HLFIRTools.h"
#include "flang/Optimizer/Builder/Todo.h"
+#include "flang/Optimizer/HLFIR/HLFIROps.h"
#include "flang/Semantics/tools.h"
namespace Fortran {
@@ -79,8 +80,7 @@ void DataSharingProcessor::processStep2(mlir::Operation *op, bool isLoop) {
void DataSharingProcessor::insertDeallocs() {
for (const semantics::Symbol *sym : allPrivatizedSymbols)
- if (semantics::IsAllocatable(sym->GetUltimate()) &&
- !sym->test(semantics::Symbol::Flag::OmpLastPrivate)) {
+ if (semantics::IsAllocatable(sym->GetUltimate())) {
if (!useDelayedPrivatization) {
converter.createHostAssociateVarCloneDealloc(*sym);
continue;
diff --git a/flang/test/Lower/OpenMP/lastprivate-allocatable.f90 b/flang/test/Lower/OpenMP/lastprivate-allocatable.f90
index 201c93576bda2..3e4a8956f0bc5 100644
--- a/flang/test/Lower/OpenMP/lastprivate-allocatable.f90
+++ b/flang/test/Lower/OpenMP/lastprivate-allocatable.f90
@@ -36,9 +36,3 @@ program lastprivate_allocatable
! CHECK-NEXT: }
! CHECK-NEXT: omp.yield
! CHECK-NEXT: }
-! CHECK-NEXT: omp.terminator
-! CHECK-NEXT: }
-! [no deallocation here]
-! CHECK-NEXT: omp.terminator
-! CHECK-NEXT: }
-
>From 37839abcebfd22e7ffbcd94dd65f58e6130bc37e Mon Sep 17 00:00:00 2001
From: Tom Eccles <tom.eccles at arm.com>
Date: Sat, 20 Jul 2024 13:35:41 +0000
Subject: [PATCH 3/3] Remove temporary_lhs flag
I thought this was needed to avoid calling destructors, but that was
theoretical. It turns out when this is used, arrays will not be assigned
with different numbers of elements.
---
flang/lib/Lower/OpenMP/DataSharingProcessor.cpp | 2 +-
flang/test/Lower/OpenMP/lastprivate-allocatable.f90 | 4 ++--
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
index 31eb4132713fc..a8f2cac999b25 100644
--- a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
@@ -166,7 +166,7 @@ void DataSharingProcessor::copyLastPrivateSymbol(
hlfir::Entity src{sb.getAddr()};
builder.create<hlfir::AssignOp>(
loc, src, dst, /*isWholeAllocatableAssignment=*/allocatable,
- /*keepLhsLengthInAllocatableAssignment=*/false, /*temporary_lhs=*/true);
+ /*keepLhsLengthInAllocatableAssignment=*/false, /*temporary_lhs=*/false);
if (lastPrivIP && lastPrivIP->isSet() &&
sym->test(Fortran::semantics::Symbol::Flag::OmpLastPrivate)) {
diff --git a/flang/test/Lower/OpenMP/lastprivate-allocatable.f90 b/flang/test/Lower/OpenMP/lastprivate-allocatable.f90
index 3e4a8956f0bc5..41bbb182aade2 100644
--- a/flang/test/Lower/OpenMP/lastprivate-allocatable.f90
+++ b/flang/test/Lower/OpenMP/lastprivate-allocatable.f90
@@ -31,8 +31,8 @@ program lastprivate_allocatable
! CHECK: fir.if %{{.*}} {
! store loop IV
! CHECK: fir.store %{{.*}} to %[[VAL_18]]#1 : !fir.ref<i32>
-! assign private variable to original copy: realloc and temporary_lhs
-! CHECK: hlfir.assign %[[VAL_16]]#0 to %[[VAL_3]]#0 realloc temporary_lhs : !fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>
+! assign private variable to original copy: realloc
+! CHECK: hlfir.assign %[[VAL_16]]#0 to %[[VAL_3]]#0 realloc : !fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>
! CHECK-NEXT: }
! CHECK-NEXT: omp.yield
! CHECK-NEXT: }
More information about the flang-commits
mailing list