Skip to content

Commit 964a252

Browse files
clementvalclementval
authored
[flang][openacc] Add support for allocatable and pointer arrays in reduction (llvm#68261)
This patch adds support for allocatable and pointer arrays in the reduction recipe lowering.
1 parent 017a003 commit 964a252

File tree

4 files changed

+128
-14
lines changed

4 files changed

+128
-14
lines changed

‎flang/include/flang/Optimizer/Dialect/FIRType.h

+3
Original file line numberDiff line numberDiff line change
@@ -336,6 +336,9 @@ bool isAssumedType(mlir::Type ty);
336336
/// Return true iff `ty` is the type of an assumed shape array.
337337
bool isAssumedShape(mlir::Type ty);
338338

339+
/// Return true iff `ty` is the type of an allocatable array.
340+
bool isAllocatableOrPointerArray(mlir::Type ty);
341+
339342
/// Return true iff `boxTy` wraps a record type or an unlimited polymorphic
340343
/// entity. Polymorphic entities with intrinsic type spec do not have addendum
341344
inline bool boxHasAddendum(fir::BaseBoxType boxTy) {

‎flang/lib/Lower/OpenACC.cpp

+42-8
Original file line numberDiff line numberDiff line change
@@ -742,9 +742,28 @@ static mlir::Value getReductionInitValue(fir::FirOpBuilder &builder,
742742
if (auto boxTy = mlir::dyn_cast<fir::BaseBoxType>(ty))
743743
return getReductionInitValue(builder, loc, boxTy.getEleTy(), op);
744744

745+
if (auto heapTy = mlir::dyn_cast<fir::HeapType>(ty))
746+
return getReductionInitValue(builder, loc, heapTy.getEleTy(), op);
747+
748+
if (auto ptrTy = mlir::dyn_cast<fir::PointerType>(ty))
749+
return getReductionInitValue(builder, loc, ptrTy.getEleTy(), op);
750+
745751
llvm::report_fatal_error("Unsupported OpenACC reduction type");
746752
}
747753

754+
/// Return the nested sequence type if any.
755+
static mlir::Type extractSequenceType(mlir::Type ty) {
756+
if (mlir::isa<fir::SequenceType>(ty))
757+
return ty;
758+
if (auto boxTy = mlir::dyn_cast<fir::BaseBoxType>(ty))
759+
return extractSequenceType(boxTy.getEleTy());
760+
if (auto heapTy = mlir::dyn_cast<fir::HeapType>(ty))
761+
return extractSequenceType(heapTy.getEleTy());
762+
if (auto ptrTy = mlir::dyn_cast<fir::PointerType>(ty))
763+
return extractSequenceType(ptrTy.getEleTy());
764+
return mlir::Type{};
765+
}
766+
748767
static mlir::Value genReductionInitRegion(fir::FirOpBuilder &builder,
749768
mlir::Location loc, mlir::Type ty,
750769
mlir::acc::ReductionOperator op) {
@@ -788,7 +807,8 @@ static mlir::Value genReductionInitRegion(fir::FirOpBuilder &builder,
788807
return declareOp.getBase();
789808
}
790809
} else if (auto boxTy = mlir::dyn_cast_or_null<fir::BaseBoxType>(ty)) {
791-
if (!mlir::isa<fir::SequenceType>(boxTy.getEleTy()))
810+
mlir::Type innerTy = extractSequenceType(boxTy);
811+
if (!mlir::isa<fir::SequenceType>(innerTy))
792812
TODO(loc, "Unsupported boxed type for reduction");
793813
// Create the private copy from the initial fir.box.
794814
hlfir::Entity source = hlfir::Entity{builder.getBlock()->getArgument(0)};
@@ -993,8 +1013,9 @@ static void genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
9931013
builder.setInsertionPointAfter(loops[0]);
9941014
} else if (auto boxTy = mlir::dyn_cast<fir::BaseBoxType>(ty)) {
9951015
llvm::SmallVector<mlir::Value> tripletArgs;
1016+
mlir::Type innerTy = extractSequenceType(boxTy);
9961017
fir::SequenceType seqTy =
997-
mlir::dyn_cast_or_null<fir::SequenceType>(boxTy.getEleTy());
1018+
mlir::dyn_cast_or_null<fir::SequenceType>(innerTy);
9981019
if (!seqTy)
9991020
TODO(loc, "Unsupported boxed type in OpenACC reduction");
10001021

@@ -1110,6 +1131,19 @@ mlir::acc::ReductionRecipeOp Fortran::lower::createOrGetReductionRecipe(
11101131
return recipe;
11111132
}
11121133

1134+
static bool isSupportedReductionType(mlir::Type ty) {
1135+
ty = fir::unwrapRefType(ty);
1136+
if (auto boxTy = mlir::dyn_cast<fir::BaseBoxType>(ty))
1137+
return isSupportedReductionType(boxTy.getEleTy());
1138+
if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(ty))
1139+
return isSupportedReductionType(seqTy.getEleTy());
1140+
if (auto heapTy = mlir::dyn_cast<fir::HeapType>(ty))
1141+
return isSupportedReductionType(heapTy.getEleTy());
1142+
if (auto ptrTy = mlir::dyn_cast<fir::PointerType>(ty))
1143+
return isSupportedReductionType(ptrTy.getEleTy());
1144+
return fir::isa_trivial(ty);
1145+
}
1146+
11131147
static void
11141148
genReductions(const Fortran::parser::AccObjectListWithReduction &objectList,
11151149
Fortran::lower::AbstractConverter &converter,
@@ -1135,24 +1169,24 @@ genReductions(const Fortran::parser::AccObjectListWithReduction &objectList,
11351169
if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(reductionTy))
11361170
reductionTy = seqTy.getEleTy();
11371171

1138-
if (!fir::isa_trivial(reductionTy) &&
1139-
((fir::isAllocatableType(reductionTy) ||
1140-
fir::isPointerType(reductionTy)) &&
1141-
!bounds.empty()))
1172+
if (!isSupportedReductionType(reductionTy))
11421173
TODO(operandLocation, "reduction with unsupported type");
11431174

11441175
auto op = createDataEntryOp<mlir::acc::ReductionOp>(
11451176
builder, operandLocation, baseAddr, asFortran, bounds,
11461177
/*structured=*/true, /*implicit=*/false,
11471178
mlir::acc::DataClause::acc_reduction, baseAddr.getType());
11481179
mlir::Type ty = op.getAccPtr().getType();
1180+
if (!areAllBoundConstant(bounds) ||
1181+
fir::isAssumedShape(baseAddr.getType()) ||
1182+
fir::isAllocatableOrPointerArray(baseAddr.getType()))
1183+
ty = baseAddr.getType();
11491184
std::string suffix =
11501185
areAllBoundConstant(bounds) ? getBoundsString(bounds) : "";
11511186
std::string recipeName = fir::getTypeAsString(
11521187
ty, converter.getKindMap(),
11531188
("reduction_" + stringifyReductionOperator(mlirOp)).str() + suffix);
1154-
if (!areAllBoundConstant(bounds) || fir::isAssumedShape(baseAddr.getType()))
1155-
ty = baseAddr.getType();
1189+
11561190
mlir::acc::ReductionRecipeOp recipe =
11571191
Fortran::lower::createOrGetReductionRecipe(
11581192
builder, recipeName, operandLocation, ty, mlirOp, bounds);

‎flang/lib/Optimizer/Dialect/FIRType.cpp

+12
Original file line numberDiff line numberDiff line change
@@ -318,6 +318,18 @@ bool isAssumedShape(mlir::Type ty) {
318318
return false;
319319
}
320320

321+
bool isAllocatableOrPointerArray(mlir::Type ty) {
322+
if (auto refTy = fir::dyn_cast_ptrEleTy(ty))
323+
ty = refTy;
324+
if (auto boxTy = mlir::dyn_cast<fir::BoxType>(ty)) {
325+
if (auto heapTy = mlir::dyn_cast<fir::HeapType>(boxTy.getEleTy()))
326+
return mlir::isa<fir::SequenceType>(heapTy.getEleTy());
327+
if (auto ptrTy = mlir::dyn_cast<fir::PointerType>(boxTy.getEleTy()))
328+
return mlir::isa<fir::SequenceType>(ptrTy.getEleTy());
329+
}
330+
return false;
331+
}
332+
321333
bool isPolymorphicType(mlir::Type ty) {
322334
if (auto refTy = fir::dyn_cast_ptrEleTy(ty))
323335
ty = refTy;

‎flang/test/Lower/OpenACC/acc-reduction.f90

+71-6
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,42 @@
33
! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s --check-prefixes=CHECK,FIR
44
! RUN: bbc -fopenacc -emit-hlfir %s -o - | FileCheck %s --check-prefixes=CHECK,HLFIR
55

6-
! CHECK-LABEL: acc.reduction.recipe @reduction_add_section_lb1.ub3_ref_Uxi32 : !fir.box<!fir.array<?xi32>> reduction_operator <add> init {
6+
! CHECK-LABEL: acc.reduction.recipe @reduction_max_box_ptr_Uxf32 : !fir.box<!fir.ptr<!fir.array<?xf32>>> reduction_operator <max> init {
7+
! CHECK: ^bb0(%{{.*}}: !fir.box<!fir.ptr<!fir.array<?xf32>>>):
8+
! CHECK: } combiner {
9+
! CHECK: ^bb0(%{{.*}}: !fir.box<!fir.ptr<!fir.array<?xf32>>>, %{{.*}}: !fir.box<!fir.ptr<!fir.array<?xf32>>>, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index):
10+
! CHECK: }
11+
12+
! CHECK-LABEL: acc.reduction.recipe @reduction_max_box_heap_Uxf32 : !fir.box<!fir.heap<!fir.array<?xf32>>> reduction_operator <max> init {
13+
! CHECK: ^bb0(%[[ARG0:.*]]: !fir.box<!fir.heap<!fir.array<?xf32>>>):
14+
! HLFIR: %[[CST:.*]] = arith.constant -1.401300e-45 : f32
15+
! HLFIR: %[[C0:.*]] = arith.constant 0 : index
16+
! HLFIR: %[[BOX_DIMS:.*]]:3 = fir.box_dims %[[ARG0]], %[[C0]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
17+
! HLFIR: %[[SHAPE:.*]] = fir.shape %[[BOX_DIMS]]#1 : (index) -> !fir.shape<1>
18+
! HLFIR: %[[TEMP:.*]] = fir.allocmem !fir.array<?xf32>, %[[BOX_DIMS]]#1 {bindc_name = ".tmp", uniq_name = ""}
19+
! HLFIR: %[[DECLARE:.*]]:2 = hlfir.declare %2(%1) {uniq_name = ".tmp"} : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xf32>>, !fir.heap<!fir.array<?xf32>>)
20+
! HLFIR: hlfir.assign %[[CST]] to %[[DECLARE]]#0 : f32, !fir.box<!fir.array<?xf32>>
21+
! HLFIR: acc.yield %[[DECLARE]]#0 : !fir.box<!fir.array<?xf32>>
22+
! CHECK: } combiner {
23+
! HLFIR: ^bb0(%[[ARG0:.*]]: !fir.box<!fir.heap<!fir.array<?xf32>>>, %[[ARG1:.*]]: !fir.box<!fir.heap<!fir.array<?xf32>>>, %[[ARG2:.*]]: index, %[[ARG3:.*]]: index, %[[ARG4:.*]]: index):
24+
! HLFIR: %[[SHAPE:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
25+
! HLFIR: %[[DES_V1:.*]] = hlfir.designate %[[ARG0]] (%[[ARG2]]:%[[ARG3]]:%[[ARG4]]) shape %[[SHAPE]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index, index, index, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xf32>>>
26+
! HLFIR: %[[DES_V2:.*]] = hlfir.designate %[[ARG1]] (%[[ARG2]]:%[[ARG3]]:%[[ARG4]]) shape %[[SHAPE]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index, index, index, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xf32>>>
27+
! HLFIR: %[[ELEMENTAL:.*]] = hlfir.elemental %[[SHAPE]] unordered : (!fir.shape<1>) -> !hlfir.expr<?xf32> {
28+
! HLFIR: ^bb0(%[[IV:.*]]: index):
29+
! HLFIR: %[[V1:.*]] = hlfir.designate %[[DES_V1]] (%[[IV]]) : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> !fir.ref<f32>
30+
! HLFIR: %[[V2:.*]] = hlfir.designate %[[DES_V2]] (%[[IV]]) : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> !fir.ref<f32>
31+
! HLFIR: %[[LOAD_V1:.*]] = fir.load %[[V1]] : !fir.ref<f32>
32+
! HLFIR: %[[LOAD_V2:.*]] = fir.load %[[V2]] : !fir.ref<f32>
33+
! HLFIR: %[[CMP:.*]] = arith.cmpf ogt, %[[LOAD_V1]], %[[LOAD_V2]] : f32
34+
! HLFIR: %[[SELECT:.*]] = arith.select %[[CMP]], %[[LOAD_V1]], %[[LOAD_V2]] : f32
35+
! HLFIR: hlfir.yield_element %[[SELECT]] : f32
36+
! HLFIR: }
37+
! HLFIR: hlfir.assign %[[ELEMENTAL]] to %[[ARG0]] : !hlfir.expr<?xf32>, !fir.box<!fir.heap<!fir.array<?xf32>>>
38+
! HLFIR: acc.yield %[[ARG0]] : !fir.box<!fir.heap<!fir.array<?xf32>>>
39+
! CHECK: }
40+
41+
! CHECK-LABEL: acc.reduction.recipe @reduction_add_section_lb1.ub3_box_Uxi32 : !fir.box<!fir.array<?xi32>> reduction_operator <add> init {
742
! CHECK: ^bb0(%[[ARG0:.*]]: !fir.box<!fir.array<?xi32>>):
843
! HLFIR: %[[BOX_DIMS:.*]]:3 = fir.box_dims %[[ARG0]], %c0{{.*}} : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
944
! HLFIR: %[[SHAPE:.*]] = fir.shape %[[BOX_DIMS]]#1 : (index) -> !fir.shape<1>
@@ -29,7 +64,7 @@
2964
! HLFIR: acc.yield %[[ARG0]] : !fir.box<!fir.array<?xi32>>
3065
! HLFIR: }
3166

32-
! CHECK-LABEL: acc.reduction.recipe @reduction_max_ref_Uxf32 : !fir.box<!fir.array<?xf32>> reduction_operator <max> init {
67+
! CHECK-LABEL: acc.reduction.recipe @reduction_max_box_Uxf32 : !fir.box<!fir.array<?xf32>> reduction_operator <max> init {
3368
! CHECK: ^bb0(%[[ARG0:.*]]: !fir.box<!fir.array<?xf32>>):
3469
! CHECK: %[[INIT_VALUE:.*]] = arith.constant -1.401300e-45 : f32
3570
! HLFIR: %[[C0:.*]] = arith.constant 0 : index
@@ -57,7 +92,7 @@
5792
! CHECK: acc.yield %[[ARG0]] : !fir.box<!fir.array<?xf32>>
5893
! CHECK: }
5994

60-
! CHECK-LABEL: acc.reduction.recipe @reduction_add_ref_Uxi32 : !fir.box<!fir.array<?xi32>> reduction_operator <add> init {
95+
! CHECK-LABEL: acc.reduction.recipe @reduction_add_box_Uxi32 : !fir.box<!fir.array<?xi32>> reduction_operator <add> init {
6196
! CHECK: ^bb0(%[[ARG0:.*]]: !fir.box<!fir.array<?xi32>>):
6297
! HLFIR: %[[INIT_VALUE:.*]] = arith.constant 0 : i32
6398
! HLFIR: %[[C0:.*]] = arith.constant 0 : index
@@ -1097,7 +1132,7 @@ subroutine acc_reduction_add_dynamic_extent_add(a)
10971132
! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"})
10981133
! HLFIR: %[[DECLARG0:.*]]:2 = hlfir.declare %[[ARG0]]
10991134
! HLFIR: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref<!fir.array<?xi32>>) bounds(%{{.*}}) -> !fir.ref<!fir.array<?xi32>> {name = "a"}
1100-
! HLFIR: acc.parallel reduction(@reduction_add_ref_Uxi32 -> %[[RED:.*]] : !fir.ref<!fir.array<?xi32>>)
1135+
! HLFIR: acc.parallel reduction(@reduction_add_box_Uxi32 -> %[[RED:.*]] : !fir.ref<!fir.array<?xi32>>)
11011136

11021137
subroutine acc_reduction_add_dynamic_extent_max(a)
11031138
real :: a(:)
@@ -1109,7 +1144,7 @@ subroutine acc_reduction_add_dynamic_extent_max(a)
11091144
! CHECK-SAME: %[[ARG0:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"})
11101145
! HLFIR: %[[DECLARG0:.*]]:2 = hlfir.declare %[[ARG0]]
11111146
! HLFIR: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref<!fir.array<?xf32>>) bounds(%{{.*}}) -> !fir.ref<!fir.array<?xf32>> {name = "a"}
1112-
! HLFIR: acc.parallel reduction(@reduction_max_ref_Uxf32 -> %[[RED]] : !fir.ref<!fir.array<?xf32>>) {
1147+
! HLFIR: acc.parallel reduction(@reduction_max_box_Uxf32 -> %[[RED]] : !fir.ref<!fir.array<?xf32>>) {
11131148

11141149
subroutine acc_reduction_add_dynamic_extent_add_with_section(a)
11151150
integer :: a(:)
@@ -1123,4 +1158,34 @@ subroutine acc_reduction_add_dynamic_extent_add_with_section(a)
11231158
! HLFIR: %[[BOUND:.*]] = acc.bounds lowerbound(%c1{{.*}} : index) upperbound(%c3{{.*}} : index) stride(%{{.*}}#2 : index) startIdx(%{{.*}} : index) {strideInBytes = true}
11241159
! HLFIR: %[[BOX_ADDR:.*]] = fir.box_addr %[[DECL]]#1 : (!fir.box<!fir.array<?xi32>>) -> !fir.ref<!fir.array<?xi32>>
11251160
! HLFIR: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.ref<!fir.array<?xi32>>) bounds(%[[BOUND]]) -> !fir.ref<!fir.array<?xi32>> {name = "a(2:4)"}
1126-
! HLFIR: acc.parallel reduction(@reduction_add_section_lb1.ub3_ref_Uxi32 -> %[[RED]] : !fir.ref<!fir.array<?xi32>>)
1161+
! HLFIR: acc.parallel reduction(@reduction_add_section_lb1.ub3_box_Uxi32 -> %[[RED]] : !fir.ref<!fir.array<?xi32>>)
1162+
1163+
subroutine acc_reduction_add_allocatable(a)
1164+
real, allocatable :: a(:)
1165+
!$acc parallel reduction(max:a)
1166+
!$acc end parallel
1167+
end subroutine
1168+
1169+
! CHECK-LABEL: func.func @_QPacc_reduction_add_allocatable(
1170+
! CHECK-SAME: %[[ARG0:.*]]: !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>> {fir.bindc_name = "a"})
1171+
! HLFIR: %[[DECL:.*]]:2 = hlfir.declare %[[ARG0]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFacc_reduction_add_allocatableEa"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>)
1172+
! HLFIR: %[[BOX:.*]] = fir.load %[[DECL]]#1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
1173+
! HLFIR: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%{{.*}} : index) stride(%{{.*}}#2 : index) startIdx(%{{.*}}#0 : index) {strideInBytes = true}
1174+
! HLFIR: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
1175+
! HLFIR: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.heap<!fir.array<?xf32>>) bounds(%6) -> !fir.heap<!fir.array<?xf32>> {name = "a"}
1176+
! HLFIR: acc.parallel reduction(@reduction_max_box_heap_Uxf32 -> %[[RED]] : !fir.heap<!fir.array<?xf32>>)
1177+
1178+
subroutine acc_reduction_add_pointer_array(a)
1179+
real, pointer :: a(:)
1180+
!$acc parallel reduction(max:a)
1181+
!$acc end parallel
1182+
end subroutine
1183+
1184+
! CHECK-LABEL: func.func @_QPacc_reduction_add_pointer_array(
1185+
! CHECK-SAME: %[[ARG0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>> {fir.bindc_name = "a"})
1186+
! HLFIR: %[[DECL:.*]]:2 = hlfir.declare %[[ARG0]] {fortran_attrs = #fir.var_attrs<pointer>, uniq_name = "_QFacc_reduction_add_pointer_arrayEa"} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>)
1187+
! HLFIR: %[[BOX:.*]] = fir.load %[[DECL]]#1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
1188+
! HLFIR: %[[BOUND:.*]] = acc.bounds lowerbound(%c0{{.*}} : index) upperbound(%{{.*}} : index) stride(%{{.*}}#2 : index) startIdx(%{{.*}}#0 : index) {strideInBytes = true}
1189+
! HLFIR: %[[BOX_ADDR:.*]] = fir.box_addr %[[BOX]] : (!fir.box<!fir.ptr<!fir.array<?xf32>>>) -> !fir.ptr<!fir.array<?xf32>>
1190+
! HLFIR: %[[RED:.*]] = acc.reduction varPtr(%[[BOX_ADDR]] : !fir.ptr<!fir.array<?xf32>>) bounds(%[[BOUND]]) -> !fir.ptr<!fir.array<?xf32>> {name = "a"}
1191+
! HLFIR: acc.parallel reduction(@reduction_max_box_ptr_Uxf32 -> %[[RED]] : !fir.ptr<!fir.array<?xf32>>)

0 commit comments

Comments
 (0)