[flang][openacc] Generate the declare register function

[clementval]

Summary

Generate the register function for global declare
variable. This function is meant to be called after the
actual data is allocated. Patch to insert the function call
and attribute will follow.

Depends on D157338

[razvanlupusoru]

The "register" function looks great - but it is incomplete.
The descriptor itself should be updated - possibly through using an implicit "update device" clause.

Also, attachment needs to happen - aka the device descriptor needs to point to the device data. From an IR perspective, to achieve this we need to generate the varPtrPtr. No need to do it in this change since this is not declare clause specific - but seems this functionality will need added at some point.

[razvanlupusoru]

flang/lib/Lower/OpenACC.cpp

2355

As I thought more about this today, I prefer the following naming:

The routines should be suffixed with something more descriptive like "_acc_declare_update_box_post_alloc" and "_acc_declare_update_box_post_dealloc"
The attribute can either be names "acc.declare_register"/"acc.declare_unregister" or "acc.declare_inform"/"acc.declare_renounce"

[vzakhari]

flang/lib/Lower/OpenACC.cpp

2355

I would like to suggest not using box word for names that are user visible to certain extent. desc may be more appropriate.

[razvanlupusoru]

flang/lib/Lower/OpenACC.cpp

2355

Agreed. desc also seems OK to me.

Technically these functions should not be "user-visible" but likely there is a chance these names will leak. From debugging perspective, the location should be the declare clause which will be the original function name. But I am not sure how well this information is preserved when converting to LLVM.

[clementval]

• Update function's name
• Add implicit update device for the descriptor

[razvanlupusoru]

Thank you!

[clementval]

clang-format

flang/lib/Lower/OpenACC.cpp

builder.create<ExitOp>(entryOp.getLoc(), entryOp.getAccPtr(), varPtr,
                            entryOp.getBounds(), entryOp.getDataClause(),
                            /*structured=*/false, /*implicit=*/false,
                            builder.getStringAttr(*entryOp.getName()));
   }
   builder.create<mlir::acc::TerminatorOp>(loc);
   modBuilder.setInsertionPointAfter(declareGlobalOp);
 }
 
+template <typename EntryOp>
+static void createRegisterFunc(mlir::OpBuilder &modBuilder,
+                               fir::FirOpBuilder &builder, mlir::Location loc,
+                               fir::GlobalOp &globalOp,
+                               mlir::acc::DataClause clause) {
+  std::stringstream registerFuncName;
+  registerFuncName << globalOp.getSymName().str()
+                   << "_acc_declare_update_desc_post_alloc";
+  auto funcTy = mlir::FunctionType::get(modBuilder.getContext(), {}, {});
+  mlir::func::FuncOp registerFuncOp = modBuilder.create<mlir::func::FuncOp>(
+      loc, registerFuncName.str(), funcTy);
+  registerFuncOp.setVisibility(mlir::SymbolTable::Visibility::Private);
+
+  builder.createBlock(&registerFuncOp.getRegion(),
+                      registerFuncOp.getRegion().end(), {}, {});
+  builder.setInsertionPointToEnd(&registerFuncOp.getRegion().back());
+
+  fir::AddrOfOp addrOp = builder.create<fir::AddrOfOp>(
+      loc, fir::ReferenceType::get(globalOp.getType()), globalOp.getSymbol());
+  auto loadOp = builder.create<fir::LoadOp>(loc, addrOp.getResult());
+  fir::BoxAddrOp boxAddrOp = builder.create<fir::BoxAddrOp>(loc, loadOp);
+  addDeclareAttr(builder, boxAddrOp.getOperation(), clause);
+
+  std::stringstream asFortran;
+  asFortran << Fortran::lower::mangle::demangleName(globalOp.getSymName());
+  llvm::SmallVector<mlir::Value> bounds;
+  EntryOp entryOp = createDataEntryOp<EntryOp>(
+      builder, loc, boxAddrOp.getResult(), asFortran, bounds,
+      /*structured=*/false, /*implicit=*/false, clause, boxAddrOp.getType());
+  builder.create<mlir::acc::DeclareEnterOp>(
+      loc, mlir::ValueRange(entryOp.getAccPtr()));
+
+  asFortran << "_desc";
+  mlir::acc::UpdateDeviceOp updateDeviceOp =
+      createDataEntryOp<mlir::acc::UpdateDeviceOp>(
+          builder, loc, addrOp, asFortran, bounds,
+          /*structured=*/false, /*implicit=*/true,
+          mlir::acc::DataClause::acc_update_device, addrOp.getType());
+  llvm::SmallVector<int32_t> operandSegments{0, 0, 0, 0, 0, 1};
+  llvm::SmallVector<mlir::Value> operands{updateDeviceOp.getResult()};
+  mlir::acc::UpdateOp updateOp = createSimpleOp<mlir::acc::UpdateOp>(
+      builder, loc, operands, operandSegments);
+
+  builder.create<mlir::func::ReturnOp>(loc);
+  modBuilder.setInsertionPointAfter(registerFuncOp);
+}
+
 template <typename EntryOp, typename ExitOp>
 static void genGlobalCtors(Fortran::lower::AbstractConverter &converter,
                            mlir::OpBuilder &modBuilder,
                            const Fortran::parser::AccObjectList &accObjectList,
                            mlir::acc::DataClause clause) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   for (const auto &accObject : accObjectList.v) {
     mlir::Location operandLocation = genOperandLocation(converter, accObject);
std::visit(
                 modBuilder.setInsertionPointAfter(globalOp);
                 if (mlir::isa<fir::BaseBoxType>(
                         fir::unwrapRefType(globalOp.getType()))) {
                   createDeclareGlobalOp<mlir::acc::GlobalConstructorOp,
                                         mlir::acc::CopyinOp,
                                         mlir::acc::DeclareEnterOp, ExitOp>(
                       modBuilder, builder, operandLocation, globalOp, clause,
                       /*implicit=*/true);
+                  createRegisterFunc<EntryOp>(
+                      modBuilder, builder, operandLocation, globalOp, clause);
                 } else {
                   createDeclareGlobalOp<mlir::acc::GlobalConstructorOp, EntryOp,
                                         mlir::acc::DeclareEnterOp, ExitOp>(
                       modBuilder, builder, operandLocation, globalOp, clause,
                       /*implicit=*/false);
                 }
                 if constexpr (!std::is_same_v<EntryOp, ExitOp>) {
                   createDeclareGlobalOp<mlir::acc::GlobalDestructorOp,

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

 
 ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_allocatable_testEdata1_acc_ctor {
 ! CHECK:         %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) {acc.declare = #acc.declare<dataClause =  acc_create>} : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
 ! CHECK:         %[[COPYIN:.*]] = acc.copyin varPtr(%[[GLOBAL_ADDR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>)   -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {dataClause = #acc<data_clause acc_create>, implicit = true, name = "data1", structured = false}
 ! CHECK:         acc.declare_enter dataOperands(%[[COPYIN]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>)
 ! CHECK:         acc.terminator
 ! CHECK:       }
 
+! CHECK-LABEL: func.func private @_QMacc_declare_allocatable_testEdata1_acc_declare_update_desc_post_alloc() {
+! CHECK:         %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+! CHECK:         %[[LOAD:.*]] = fir.load %[[GLOBAL_ADDR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+! CHECK:         %[[BOXADDR:.*]] = fir.box_addr %[[LOAD]] {acc.declare = #acc.declare<dataClause =  acc_create>} : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
+! CHECK:         %[[CREATE:.*]] = acc.create varPtr(%[[BOXADDR]] : !fir.heap<!fir.array<?xi32>>) -> !fir.heap<!fir.array<?xi32>> {name = "data1", structured = false}
+! CHECK:         acc.declare_enter dataOperands(%[[CREATE]] : !fir.heap<!fir.array<?xi32>>)
+! CHECK:         %[[UPDATE:.*]] = acc.update_device varPtr(%[[GLOBAL_ADDR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {implicit = true, name = "data1_desc", structured = false}
+! CHECK:         acc.update dataOperands(%[[UPDATE]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>)
+! CHECK:         return
+! CHECK:       }
+
 ! CHECK-LABEL: acc.global_dtor @_QMacc_declare_allocatable_testEdata1_acc_dtor {
 ! CHECK:         %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_allocatable_testEdata1) {acc.declare = #acc.declare<dataClause =  acc_create>} : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
 ! CHECK:         %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>)   -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>> {dataClause = #acc<data_clause acc_create>, name = "data1", structured = false}
 ! CHECK:         acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>)
 ! CHECK:         acc.delete accPtr(%[[DEVICEPTR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) {dataClause = #acc<data_clause acc_create>, name = "data1", structured = false}
 ! CHECK:         acc.terminator
 ! CHECK:       }