[mlir][acc] Add ACCImplicitRoutine pass for implicit acc routine
#168433
+276
−0
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This change adds the ACCImplicitRoutine pass which implements the OpenACC specification for implicit routine directives (OpenACC 3.4 spec, section 2.15.1). According to the specification: "If no explicit routine directive applies to a procedure whose definition appears in the program unit being compiled, then the implementation applies an implicit routine directive to that procedure if any of the following conditions holds: The procedure is called or its address is accessed in a compute region." The pass automatically generates `acc.routine` operations for functions called within OpenACC compute constructs or within existing routine functions that do not already have explicit routine directives. It recursively applies implicit routine directives while avoiding infinite recursion when dependencies form cycles. Key features: - Walks through all OpenACC compute constructs (parallel, kernels, serial) to identify function calls - Creates implicit `acc.routine` operations for functions without explicit routine declarations - Recursively processes existing `acc.routine` operations to handle transitive dependencies - Avoids infinite recursion through proper tracking of processed routines - Respects device-type specific bind clauses to skip routines bound to different device types Requirements: - Function operations must implement `mlir::FunctionOpInterface` to be identified and associated with routine directives. - Call operations must implement `mlir::CallOpInterface` to detect function calls and traverse the call graph. - Optionally pre-register `acc::OpenACCSupport` if custom behavior is needed for determining if a symbol use is valid within GPU regions (such as functions which are already considerations for offloading even without `acc routine` markings) Co-authored-by: delaram-talaashrafi<dtalaashrafi@nvidia.com>
Member
|
@llvm/pr-subscribers-openacc @llvm/pr-subscribers-mlir-openacc Author: Razvan Lupusoru (razvanlupusoru) ChangesThis change adds the ACCImplicitRoutine pass which implements the OpenACC specification for implicit routine directives (OpenACC 3.4 spec, section 2.15.1). According to the specification: "If no explicit routine directive applies to a procedure whose definition appears in the program unit being compiled, then the implementation applies an implicit routine directive to that procedure if any of the following conditions holds: The procedure is called or its address is accessed in a compute region." The pass automatically generates Key features:
Requirements:
Full diff: https://github.com/llvm/llvm-project/pull/168433.diff 3 Files Affected:
diff --git a/mlir/include/mlir/Dialect/OpenACC/Transforms/Passes.td b/mlir/include/mlir/Dialect/OpenACC/Transforms/Passes.td
index 40ccd1fc6c1a0..970d9304d8289 100644
--- a/mlir/include/mlir/Dialect/OpenACC/Transforms/Passes.td
+++ b/mlir/include/mlir/Dialect/OpenACC/Transforms/Passes.td
@@ -63,4 +63,42 @@ def ACCImplicitData : Pass<"acc-implicit-data", "mlir::ModuleOp"> {
];
}
+def ACCImplicitRoutine : Pass<"acc-implicit-routine", "mlir::ModuleOp"> {
+ let summary = "Generate implicit acc routine for functions in acc regions";
+ let description = [{
+ This pass implements the implicit rules described in OpenACC specification
+ for `Routine Directive` (OpenACC 3.4 spec, section 2.15.1).
+
+ "If no explicit routine directive applies to a procedure whose definition
+ appears in the program unit being compiled, then the implementation applies
+ an implicit routine directive to that procedure if any of the following
+ conditions holds:
+ - The procedure is called or its address is accessed in a compute region."
+
+ The specification further states:
+ "When the implementation applies an implicit routine directive to a procedure,
+ it must recursively apply implicit routine directives to other procedures for
+ which the above rules specify relevant dependencies. Such dependencies can
+ form a cycle, so the implementation must take care to avoid infinite recursion."
+
+ This pass implements these requirements by:
+ 1. Walking through all OpenACC compute constructs and functions already
+ marked with `acc routine` in the module and identifying function calls
+ within these regions.
+ 2. Creating implicit `acc.routine` operations for functions that don't already
+ have routine declarations.
+ 3. Recursively walking through all existing `acc routine` and creating
+ implicit routine operations for function calls within these routines,
+ while avoiding infinite recursion through proper tracking.
+ }];
+ let dependentDialects = ["mlir::acc::OpenACCDialect"];
+ let options = [
+ Option<"deviceType", "device-type", "mlir::acc::DeviceType",
+ "mlir::acc::DeviceType::None",
+ "Target device type for implicit routine generation. "
+ "Ensures that `acc routine` device_type clauses are "
+ "properly considered not just default clauses.">
+ ];
+}
+
#endif // MLIR_DIALECT_OPENACC_TRANSFORMS_PASSES
diff --git a/mlir/lib/Dialect/OpenACC/Transforms/ACCImplicitRoutine.cpp b/mlir/lib/Dialect/OpenACC/Transforms/ACCImplicitRoutine.cpp
new file mode 100644
index 0000000000000..12efaf487a8ca
--- /dev/null
+++ b/mlir/lib/Dialect/OpenACC/Transforms/ACCImplicitRoutine.cpp
@@ -0,0 +1,237 @@
+//===- ACCImplicitRoutine.cpp - OpenACC Implicit Routine Transform -------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass implements the implicit rules described in OpenACC specification
+// for `Routine Directive` (OpenACC 3.4 spec, section 2.15.1).
+//
+// "If no explicit routine directive applies to a procedure whose definition
+// appears in the program unit being compiled, then the implementation applies
+// an implicit routine directive to that procedure if any of the following
+// conditions holds:
+// - The procedure is called or its address is accessed in a compute region."
+//
+// The specification further states:
+// "When the implementation applies an implicit routine directive to a
+// procedure, it must recursively apply implicit routine directives to other
+// procedures for which the above rules specify relevant dependencies. Such
+// dependencies can form a cycle, so the implementation must take care to avoid
+// infinite recursion."
+//
+// This pass implements these requirements by:
+// 1. Walking through all OpenACC compute constructs and functions already
+// marked with `acc routine` in the module and identifying function calls
+// within these regions.
+// 2. Creating implicit `acc.routine` operations for functions that don't
+// already have routine declarations.
+// 3. Recursively walking through all existing `acc routine` and creating
+// implicit routine operations for function calls within these routines,
+// while avoiding infinite recursion through proper tracking.
+//
+// Requirements:
+// -------------
+// To use this pass in a pipeline, the following requirements must be met:
+//
+// 1. Operation Interface Implementation: Operations that define functions
+// or call functions should implement `mlir::FunctionOpInterface` and
+// `mlir::CallOpInterface` respectively.
+//
+// 2. Analysis Registration (Optional): If custom behavior is needed for
+// determining if a symbol use is valid within GPU regions, the dialect
+// should pre-register the `acc::OpenACCSupport` analysis.
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/OpenACC/Transforms/Passes.h"
+
+#include "mlir/Dialect/OpenACC/Analysis/OpenACCSupport.h"
+#include "mlir/Dialect/OpenACC/OpenACC.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/IR/Value.h"
+#include "mlir/Interfaces/CallInterfaces.h"
+#include "mlir/Interfaces/FunctionInterfaces.h"
+#include <queue>
+
+#define DEBUG_TYPE "acc-implicit-routine"
+
+namespace mlir {
+namespace acc {
+#define GEN_PASS_DEF_ACCIMPLICITROUTINE
+#include "mlir/Dialect/OpenACC/Transforms/Passes.h.inc"
+} // namespace acc
+} // namespace mlir
+
+namespace {
+
+using namespace mlir;
+
+class ACCImplicitRoutine
+ : public acc::impl::ACCImplicitRoutineBase<ACCImplicitRoutine> {
+private:
+ unsigned routineCounter = 0;
+ static constexpr llvm::StringRef accRoutinePrefix = "acc_routine_";
+
+ // Count existing routine operations and update counter
+ void initRoutineCounter(ModuleOp module) {
+ module.walk([&](acc::RoutineOp routineOp) { routineCounter++; });
+ }
+
+ // Check if routine has a default bind clause or a device-type specific bind
+ // clause. Returns true if `acc routine` has a default bind clause or
+ // a device-type specific bind clause.
+ bool isACCRoutineBindDefaultOrDeviceType(acc::RoutineOp op,
+ acc::DeviceType deviceType) {
+ // Fast check to avoid device-type specific lookups.
+ if (!op.getBindIdName() && !op.getBindStrName())
+ return false;
+ return op.getBindNameValue().has_value() ||
+ op.getBindNameValue(deviceType).has_value();
+ }
+
+ // Generate a unique name for the routine and create the routine operation
+ acc::RoutineOp createRoutineOp(OpBuilder &builder, Location loc,
+ FunctionOpInterface &callee) {
+ std::string routineName =
+ (accRoutinePrefix + std::to_string(routineCounter++)).str();
+ auto routineOp = acc::RoutineOp::create(
+ builder, loc,
+ /* sym_name=*/builder.getStringAttr(routineName),
+ /* func_name=*/
+ mlir::SymbolRefAttr::get(builder.getContext(),
+ builder.getStringAttr(callee.getName())),
+ /* bindIdName=*/nullptr,
+ /* bindStrName=*/nullptr,
+ /* bindIdNameDeviceType=*/nullptr,
+ /* bindStrNameDeviceType=*/nullptr,
+ /* worker=*/nullptr,
+ /* vector=*/nullptr,
+ /* seq=*/nullptr,
+ /* nohost=*/nullptr,
+ /* implicit=*/builder.getUnitAttr(),
+ /* gang=*/nullptr,
+ /* gangDim=*/nullptr,
+ /* gangDimDeviceType=*/nullptr);
+
+ // Assert that the callee does not already have routine info attribute
+ assert(!callee->hasAttr(acc::getRoutineInfoAttrName()) &&
+ "function is already associated with a routine");
+
+ callee->setAttr(
+ acc::getRoutineInfoAttrName(),
+ mlir::acc::RoutineInfoAttr::get(
+ builder.getContext(),
+ {mlir::SymbolRefAttr::get(builder.getContext(),
+ builder.getStringAttr(routineName))}));
+ return routineOp;
+ }
+
+ // Used to walk through a compute region looking for function calls.
+ void
+ implicitRoutineForCallsInComputeRegions(Operation *op, SymbolTable &symTab,
+ mlir::OpBuilder &builder,
+ acc::OpenACCSupport &accSupport) {
+ op->walk([&](CallOpInterface callOp) {
+ if (!callOp.getCallableForCallee())
+ return;
+
+ auto calleeSymbolRef =
+ dyn_cast<SymbolRefAttr>(callOp.getCallableForCallee());
+ // When call is done through ssa value, the callee is not a symbol.
+ // Skip it because we don't know the call target.
+ if (!calleeSymbolRef)
+ return;
+
+ auto callee = symTab.lookup<FunctionOpInterface>(
+ calleeSymbolRef.getLeafReference().str());
+ // If the callee does not exist or is already a valid symbol for GPU
+ // regions, skip it
+
+ assert(callee && "callee function must be found in symbol table");
+ if (accSupport.isValidSymbolUse(callOp.getOperation(), calleeSymbolRef))
+ return;
+ builder.setInsertionPoint(callee);
+ createRoutineOp(builder, callee.getLoc(), callee);
+ });
+ }
+
+ // Recursively handle calls within a routine operation
+ void implicitRoutineForCallsInRoutine(acc::RoutineOp routineOp,
+ mlir::OpBuilder &builder,
+ acc::OpenACCSupport &accSupport,
+ acc::DeviceType targetDeviceType) {
+ // When bind clause is used, it means that the target is different than the
+ // function to which the `acc routine` is used with. Skip this case to
+ // avoid implicitly recursively marking calls that would not end up on
+ // device.
+ if (isACCRoutineBindDefaultOrDeviceType(routineOp, targetDeviceType))
+ return;
+
+ SymbolTable symTab(routineOp->getParentOfType<ModuleOp>());
+ std::queue<acc::RoutineOp> routineQueue;
+ routineQueue.push(routineOp);
+ while (!routineQueue.empty()) {
+ auto currentRoutine = routineQueue.front();
+ routineQueue.pop();
+ auto func = symTab.lookup<FunctionOpInterface>(
+ currentRoutine.getFuncName().getLeafReference());
+ func.walk([&](CallOpInterface callOp) {
+ if (!callOp.getCallableForCallee())
+ return;
+
+ auto calleeSymbolRef =
+ dyn_cast<SymbolRefAttr>(callOp.getCallableForCallee());
+ // When call is done through ssa value, the callee is not a symbol.
+ // Skip it because we don't know the call target.
+ if (!calleeSymbolRef)
+ return;
+
+ auto callee = symTab.lookup<FunctionOpInterface>(
+ calleeSymbolRef.getLeafReference().str());
+ // If the callee does not exist or is already a valid symbol for GPU
+ // regions, skip it
+ assert(callee && "callee function must be found in symbol table");
+ if (accSupport.isValidSymbolUse(callOp.getOperation(), calleeSymbolRef))
+ return;
+ builder.setInsertionPoint(callee);
+ auto newRoutineOp = createRoutineOp(builder, callee.getLoc(), callee);
+ routineQueue.push(newRoutineOp);
+ });
+ }
+ }
+
+public:
+ using ACCImplicitRoutineBase<ACCImplicitRoutine>::ACCImplicitRoutineBase;
+
+ void runOnOperation() override {
+ auto module = getOperation();
+ mlir::OpBuilder builder(module.getContext());
+ SymbolTable symTab(module);
+ initRoutineCounter(module);
+
+ acc::OpenACCSupport &accSupport = getAnalysis<acc::OpenACCSupport>();
+
+ // Handle compute regions
+ module.walk([&](Operation *op) {
+ if (isa<ACC_COMPUTE_CONSTRUCT_OPS>(op))
+ implicitRoutineForCallsInComputeRegions(op, symTab, builder,
+ accSupport);
+ });
+
+ // Use the device type option from the pass options.
+ acc::DeviceType targetDeviceType = deviceType;
+
+ // Handle existing routines
+ module.walk([&](acc::RoutineOp routineOp) {
+ implicitRoutineForCallsInRoutine(routineOp, builder, accSupport,
+ targetDeviceType);
+ });
+ }
+};
+
+} // namespace
diff --git a/mlir/lib/Dialect/OpenACC/Transforms/CMakeLists.txt b/mlir/lib/Dialect/OpenACC/Transforms/CMakeLists.txt
index f8fff5958f8c7..028af0362f26e 100644
--- a/mlir/lib/Dialect/OpenACC/Transforms/CMakeLists.txt
+++ b/mlir/lib/Dialect/OpenACC/Transforms/CMakeLists.txt
@@ -1,5 +1,6 @@
add_mlir_dialect_library(MLIROpenACCTransforms
ACCImplicitData.cpp
+ ACCImplicitRoutine.cpp
LegalizeDataValues.cpp
ADDITIONAL_HEADER_DIRS
|
Contributor
Author
|
The primary author for this work is @delaram-talaashrafi . I did add the appropriate co-authored-by line in the commit message - but it does not show in the github description. I will make sure when submitting that this works gets properly attributed. Thank you! |
🐧 Linux x64 Test Results
|
Contributor
You can probably edit the commit message before submitting. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This change adds the ACCImplicitRoutine pass which implements the OpenACC specification for implicit routine directives (OpenACC 3.4 spec, section 2.15.1).
According to the specification: "If no explicit routine directive applies to a procedure whose definition appears in the program unit being compiled, then the implementation applies an implicit routine directive to that procedure if any of the following conditions holds: The procedure is called or its address is accessed in a compute region."
The pass automatically generates
acc.routineoperations for functions called within OpenACC compute constructs or within existing routine functions that do not already have explicit routine directives. It recursively applies implicit routine directives while avoiding infinite recursion when dependencies form cycles.Key features:
acc.routineoperations for functions without explicit routine declarationsacc.routineoperations to handle transitive dependenciesRequirements:
mlir::FunctionOpInterfaceto be identified and associated with routine directives.mlir::CallOpInterfaceto detect function calls and traverse the call graph.acc::OpenACCSupportif custom behavior is needed for determining if a symbol use is valid within GPU regions (such as functions which are already considerations for offloading even withoutacc routinemarkings)