[flang][openacc] Add possibility to add name to alloca of private copy in reduction recipe

[clementval]

Summary

Add possiblity to pass name for the allocation of the private copy
as follow up to D155882

[vzakhari]

LGTM

[razvanlupusoru]

This patch is not what I had in mind when I made the name suggestion. Namely, I was thinking the init region would take an additional argument specifying the name - and this would be related to the original variable name. This way a recipe could be reused, but the fir.alloca operations could expand to proper name during materialization.

flang/lib/Lower/OpenACC.cpp

1000

I expected the name to be extracted from original variable name! This name is not necessarily useful when debugging.

[clementval]

In D156151#4533147, @razvanlupusoru wrote:

This patch is not what I had in mind when I made the name suggestion. Namely, I was thinking the init region would take an additional argument specifying the name - and this would be related to the original variable name. This way a recipe could be reused, but the fir.alloca operations could expand to proper name during materialization.

I see your point but I don't think we can pass a ssa value for the name of the fir.alloca's name. What we can probably do is just leave the init region as is. The materialization should be able to gather any alloca and update them with appropriate name if desired.

[razvanlupusoru]

In D156151#4533188, @clementval wrote:

I see your point but I don't think we can pass a ssa value for the name of the fir.alloca's name. What we can probably do is just leave the init region as is. The materialization should be able to gather any alloca and update them with appropriate name if desired.

Good point. In that case, I am comfortable leaving as-is without a name.

[clementval]

Leave it without name for the moment.

flang/include/flang/Lower/OpenACC.h

mlir::acc::PrivateRecipeOp createOrGetPrivateRecipe(mlir::OpBuilder &,
                                                     llvm::StringRef,
                                                     mlir::Location, mlir::Type);
 
 /// Get a acc.reduction.recipe op for the given type or create it if it does not
 /// exist yet.
 mlir::acc::ReductionRecipeOp
 createOrGetReductionRecipe(fir::FirOpBuilder &, llvm::StringRef, mlir::Location,
                            mlir::Type, mlir::acc::ReductionOperator,
-                           llvm::SmallVector<mlir::Value> &);
+                           llvm::SmallVector<mlir::Value> &,
+                           const llvm::StringRef);
 
 /// Get a acc.firstprivate.recipe op for the given type or create it if it does
 /// not exist yet.
 mlir::acc::FirstprivateRecipeOp createOrGetFirstprivateRecipe(mlir::OpBuilder &,
                                                               llvm::StringRef,
                                                               mlir::Location,
                                                               mlir::Type);
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_OPENACC_H

flang/lib/Lower/OpenACC.cpp

static mlir::Value getReductionInitValue(fir::FirOpBuilder &builder,
   if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(ty))
     return getReductionInitValue(builder, loc, seqTy.getEleTy(), op);
 
   llvm::report_fatal_error("Unsupported OpenACC reduction type");
 }
 
 static mlir::Value genReductionInitRegion(fir::FirOpBuilder &builder,
                                           mlir::Location loc, mlir::Type ty,
-                                          mlir::acc::ReductionOperator op) {
+                                          mlir::acc::ReductionOperator op,
+                                          const llvm::StringRef allocaName) {
   ty = fir::unwrapRefType(ty);
   mlir::Value initValue = getReductionInitValue(builder, loc, ty, op);
   if (fir::isa_trivial(ty)) {
-    mlir::Value alloca = builder.create<fir::AllocaOp>(loc, ty);
+    mlir::Value alloca = builder.create<fir::AllocaOp>(
+        loc, ty, /*unique_name=*/llvm::StringRef{}, allocaName);
     builder.create<fir::StoreOp>(loc, builder.createConvert(loc, ty, initValue),
                                  alloca);
     return alloca;
   } else if (auto seqTy = mlir::dyn_cast_or_null<fir::SequenceType>(ty)) {
     if (seqTy.hasDynamicExtents())
       TODO(loc, "private recipe of array with dynamic extents");
     if (fir::isa_trivial(seqTy.getEleTy())) {
-      mlir::Value alloca = builder.create<fir::AllocaOp>(loc, seqTy);
+      mlir::Value alloca = builder.create<fir::AllocaOp>(
+          loc, seqTy, /*unique_name=*/llvm::StringRef{}, allocaName);
       mlir::Type idxTy = builder.getIndexType();
       mlir::Type refTy = fir::ReferenceType::get(seqTy.getEleTy());
       llvm::SmallVector<fir::DoLoopOp> loops;
       llvm::SmallVector<mlir::Value> ivs;
       for (auto ext : llvm::reverse(seqTy.getShape())) {
         auto lb = builder.createIntegerConstant(loc, idxTy, 0);
         auto ub = builder.createIntegerConstant(loc, idxTy, ext - 1);
         auto step = builder.createIntegerConstant(loc, idxTy, 1);
if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(ty)) {
     mlir::Value res = genScalarCombiner(builder, loc, op, ty, value1, value2);
     builder.create<fir::StoreOp>(loc, res, value1);
   }
 }
 
 mlir::acc::ReductionRecipeOp Fortran::lower::createOrGetReductionRecipe(
     fir::FirOpBuilder &builder, llvm::StringRef recipeName, mlir::Location loc,
     mlir::Type ty, mlir::acc::ReductionOperator op,
-    llvm::SmallVector<mlir::Value> &bounds) {
+    llvm::SmallVector<mlir::Value> &bounds, const llvm::StringRef allocaName) {
   mlir::ModuleOp mod =
       builder.getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();
   if (auto recipe = mod.lookupSymbol<mlir::acc::ReductionRecipeOp>(recipeName))
     return recipe;
 
   auto crtPos = builder.saveInsertionPoint();
   mlir::OpBuilder modBuilder(mod.getBodyRegion());
   auto recipe =
       modBuilder.create<mlir::acc::ReductionRecipeOp>(loc, recipeName, ty, op);
   builder.createBlock(&recipe.getInitRegion(), recipe.getInitRegion().end(),
                       {ty}, {loc});
   builder.setInsertionPointToEnd(&recipe.getInitRegion().back());
-  mlir::Value initValue = genReductionInitRegion(builder, loc, ty, op);
+  mlir::Value initValue =
+      genReductionInitRegion(builder, loc, ty, op, allocaName);
   builder.create<mlir::acc::YieldOp>(loc, initValue);
 
   builder.createBlock(&recipe.getCombinerRegion(),
                       recipe.getCombinerRegion().end(), {ty, ty}, {loc, loc});
   builder.setInsertionPointToEnd(&recipe.getCombinerRegion().back());
   mlir::Value v1 = recipe.getCombinerRegion().front().getArgument(0);
   mlir::Value v2 = recipe.getCombinerRegion().front().getArgument(1);
   genCombiner(builder, loc, op, ty, v1, v2);
auto op = createDataEntryOp<mlir::acc::ReductionOp>(
         /*structured=*/true, mlir::acc::DataClause::acc_reduction,
         baseAddr.getType());
     mlir::Type ty = op.getAccPtr().getType();
     std::string recipeName = fir::getTypeAsString(
         ty, converter.getKindMap(),
         ("reduction_" + stringifyReductionOperator(mlirOp)).str());
     mlir::acc::ReductionRecipeOp recipe =
         Fortran::lower::createOrGetReductionRecipe(
-            builder, recipeName, operandLocation, ty, mlirOp, bounds);
+            builder, recipeName, operandLocation, ty, mlirOp, bounds,
+            ".reduction_private");
     reductionRecipes.push_back(mlir::SymbolRefAttr::get(
         builder.getContext(), recipe.getSymName().str()));
     reductionOperands.push_back(op.getAccPtr());
   }
 }
 
 static void
 addOperands(llvm::SmallVectorImpl<mlir::Value> &operands,

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

 ! CHECK:     fir.store %[[COMBINED]] to %[[COORD1]] : !fir.ref<i32>
 ! CHECK:   }
 ! CHECK:   acc.yield %[[ARG0]] : !fir.ref<!fir.array<100xi32>>
 ! CHECK: }
 
 ! CHECK-LABEL: acc.reduction.recipe @reduction_add_ref_i32 : !fir.ref<i32> reduction_operator <add> init {
 ! CHECK: ^bb0(%{{.*}}: !fir.ref<i32>):
 ! CHECK:   %[[INIT:.*]] = arith.constant 0 : i32
-! CHECK:   %[[ALLOCA:.*]] = fir.alloca i32
+! CHECK:   %[[ALLOCA:.*]] = fir.alloca i32 {bindc_name = ".reduction_private"}
 ! CHECK:   fir.store %[[INIT]] to %[[ALLOCA]] : !fir.ref<i32>
 ! CHECK:   acc.yield %[[ALLOCA]] : !fir.ref<i32>
 ! CHECK: } combiner {
 ! CHECK: ^bb0(%[[ARG0:.*]]: !fir.ref<i32>, %[[ARG1:.*]]: !fir.ref<i32>):
 ! CHECK:   %[[LOAD0:.*]] = fir.load %[[ARG0]] : !fir.ref<i32>
 ! CHECK:   %[[LOAD1:.*]] = fir.load %[[ARG1]] : !fir.ref<i32>
 ! CHECK:   %[[COMBINED:.*]] = arith.addi %[[LOAD0]], %[[LOAD1]] : i32
 ! CHECK:   fir.store %[[COMBINED]] to %[[ARG0]] : !fir.ref<i32>