[flang-commits] [flang] [mlir] [OpenACC] rename private/firstprivate recipe attributes (PR #140719)
via flang-commits
flang-commits at lists.llvm.org
Tue May 20 05:00:19 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
@llvm/pr-subscribers-mlir-openacc
Author: Scott Manley (rscottmanley)
<details>
<summary>Changes</summary>
Make private and firstprivate recipe attribute names consistent with reductionRecipes attribute
---
Full diff: https://github.com/llvm/llvm-project/pull/140719.diff
3 Files Affected:
- (modified) flang/lib/Lower/OpenACC.cpp (+43-42)
- (modified) mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td (+10-10)
- (modified) mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp (+5-5)
``````````diff
diff --git a/flang/lib/Lower/OpenACC.cpp b/flang/lib/Lower/OpenACC.cpp
index bc94e860ff10b..0405510baeb9b 100644
--- a/flang/lib/Lower/OpenACC.cpp
+++ b/flang/lib/Lower/OpenACC.cpp
@@ -1389,16 +1389,16 @@ mlir::Type getTypeFromBounds(llvm::SmallVector<mlir::Value> &bounds,
}
template <typename RecipeOp>
-static void
-genPrivatizations(const Fortran::parser::AccObjectList &objectList,
- Fortran::lower::AbstractConverter &converter,
- Fortran::semantics::SemanticsContext &semanticsContext,
- Fortran::lower::StatementContext &stmtCtx,
- llvm::SmallVectorImpl<mlir::Value> &dataOperands,
- llvm::SmallVector<mlir::Attribute> &privatizations,
- llvm::ArrayRef<mlir::Value> async,
- llvm::ArrayRef<mlir::Attribute> asyncDeviceTypes,
- llvm::ArrayRef<mlir::Attribute> asyncOnlyDeviceTypes) {
+static void genPrivatizationRecipes(
+ const Fortran::parser::AccObjectList &objectList,
+ Fortran::lower::AbstractConverter &converter,
+ Fortran::semantics::SemanticsContext &semanticsContext,
+ Fortran::lower::StatementContext &stmtCtx,
+ llvm::SmallVectorImpl<mlir::Value> &dataOperands,
+ llvm::SmallVector<mlir::Attribute> &privatizationRecipes,
+ llvm::ArrayRef<mlir::Value> async,
+ llvm::ArrayRef<mlir::Attribute> asyncDeviceTypes,
+ llvm::ArrayRef<mlir::Attribute> asyncOnlyDeviceTypes) {
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
Fortran::evaluate::ExpressionAnalyzer ea{semanticsContext};
for (const auto &accObject : objectList.v) {
@@ -1445,7 +1445,7 @@ genPrivatizations(const Fortran::parser::AccObjectList &objectList,
/*unwrapBoxAddr=*/true);
dataOperands.push_back(op.getAccVar());
}
- privatizations.push_back(mlir::SymbolRefAttr::get(
+ privatizationRecipes.push_back(mlir::SymbolRefAttr::get(
builder.getContext(), recipe.getSymName().str()));
}
}
@@ -2083,15 +2083,15 @@ mlir::Type getTypeFromIvTypeSize(fir::FirOpBuilder &builder,
return builder.getIntegerType(ivTypeSize * 8);
}
-static void privatizeIv(Fortran::lower::AbstractConverter &converter,
- const Fortran::semantics::Symbol &sym,
- mlir::Location loc,
- llvm::SmallVector<mlir::Type> &ivTypes,
- llvm::SmallVector<mlir::Location> &ivLocs,
- llvm::SmallVector<mlir::Value> &privateOperands,
- llvm::SmallVector<mlir::Value> &ivPrivate,
- llvm::SmallVector<mlir::Attribute> &privatizations,
- bool isDoConcurrent = false) {
+static void
+privatizeIv(Fortran::lower::AbstractConverter &converter,
+ const Fortran::semantics::Symbol &sym, mlir::Location loc,
+ llvm::SmallVector<mlir::Type> &ivTypes,
+ llvm::SmallVector<mlir::Location> &ivLocs,
+ llvm::SmallVector<mlir::Value> &privateOperands,
+ llvm::SmallVector<mlir::Value> &ivPrivate,
+ llvm::SmallVector<mlir::Attribute> &privatizationRecipes,
+ bool isDoConcurrent = false) {
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::Type ivTy = getTypeFromIvTypeSize(builder, sym);
@@ -2131,7 +2131,7 @@ static void privatizeIv(Fortran::lower::AbstractConverter &converter,
privateOp = op.getOperation();
privateOperands.push_back(op.getAccVar());
- privatizations.push_back(mlir::SymbolRefAttr::get(
+ privatizationRecipes.push_back(mlir::SymbolRefAttr::get(
builder.getContext(), recipe.getSymName().str()));
}
@@ -2161,7 +2161,7 @@ static mlir::acc::LoopOp createLoopOp(
llvm::SmallVector<mlir::Value> tileOperands, privateOperands, ivPrivate,
reductionOperands, cacheOperands, vectorOperands, workerNumOperands,
gangOperands, lowerbounds, upperbounds, steps;
- llvm::SmallVector<mlir::Attribute> privatizations, reductionRecipes;
+ llvm::SmallVector<mlir::Attribute> privatizationRecipes, reductionRecipes;
llvm::SmallVector<int32_t> tileOperandsSegments, gangOperandsSegments;
llvm::SmallVector<int64_t> collapseValues;
@@ -2282,9 +2282,9 @@ static mlir::acc::LoopOp createLoopOp(
} else if (const auto *privateClause =
std::get_if<Fortran::parser::AccClause::Private>(
&clause.u)) {
- genPrivatizations<mlir::acc::PrivateRecipeOp>(
+ genPrivatizationRecipes<mlir::acc::PrivateRecipeOp>(
privateClause->v, converter, semanticsContext, stmtCtx,
- privateOperands, privatizations, /*async=*/{},
+ privateOperands, privatizationRecipes, /*async=*/{},
/*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{});
} else if (const auto *reductionClause =
std::get_if<Fortran::parser::AccClause::Reduction>(
@@ -2368,7 +2368,8 @@ static mlir::acc::LoopOp createLoopOp(
const auto &name = std::get<Fortran::parser::Name>(control.t);
privatizeIv(converter, *name.symbol, currentLocation, ivTypes, ivLocs,
- privateOperands, ivPrivate, privatizations, isDoConcurrent);
+ privateOperands, ivPrivate, privatizationRecipes,
+ isDoConcurrent);
inclusiveBounds.push_back(true);
}
@@ -2405,7 +2406,7 @@ static mlir::acc::LoopOp createLoopOp(
Fortran::semantics::Symbol &ivSym =
bounds->name.thing.symbol->GetUltimate();
privatizeIv(converter, ivSym, currentLocation, ivTypes, ivLocs,
- privateOperands, ivPrivate, privatizations);
+ privateOperands, ivPrivate, privatizationRecipes);
inclusiveBounds.push_back(true);
@@ -2484,9 +2485,9 @@ static mlir::acc::LoopOp createLoopOp(
if (!autoDeviceTypes.empty())
loopOp.setAuto_Attr(builder.getArrayAttr(autoDeviceTypes));
- if (!privatizations.empty())
- loopOp.setPrivatizationsAttr(
- mlir::ArrayAttr::get(builder.getContext(), privatizations));
+ if (!privatizationRecipes.empty())
+ loopOp.setPrivatizationRecipesAttr(
+ mlir::ArrayAttr::get(builder.getContext(), privatizationRecipes));
if (!reductionRecipes.empty())
loopOp.setReductionRecipesAttr(
@@ -2613,8 +2614,8 @@ static Op createComputeOp(
llvm::SmallVector<mlir::Value> reductionOperands, privateOperands,
firstprivateOperands;
- llvm::SmallVector<mlir::Attribute> privatizations, firstPrivatizations,
- reductionRecipes;
+ llvm::SmallVector<mlir::Attribute> privatizationRecipes,
+ firstPrivatizationRecipes, reductionRecipes;
// Self clause has optional values but can be present with
// no value as well. When there is no value, the op has an attribute to
@@ -2820,17 +2821,17 @@ static Op createComputeOp(
std::get_if<Fortran::parser::AccClause::Private>(
&clause.u)) {
if (!combinedConstructs)
- genPrivatizations<mlir::acc::PrivateRecipeOp>(
+ genPrivatizationRecipes<mlir::acc::PrivateRecipeOp>(
privateClause->v, converter, semanticsContext, stmtCtx,
- privateOperands, privatizations, async, asyncDeviceTypes,
+ privateOperands, privatizationRecipes, async, asyncDeviceTypes,
asyncOnlyDeviceTypes);
} else if (const auto *firstprivateClause =
std::get_if<Fortran::parser::AccClause::Firstprivate>(
&clause.u)) {
- genPrivatizations<mlir::acc::FirstprivateRecipeOp>(
+ genPrivatizationRecipes<mlir::acc::FirstprivateRecipeOp>(
firstprivateClause->v, converter, semanticsContext, stmtCtx,
- firstprivateOperands, firstPrivatizations, async, asyncDeviceTypes,
- asyncOnlyDeviceTypes);
+ firstprivateOperands, firstPrivatizationRecipes, async,
+ asyncDeviceTypes, asyncOnlyDeviceTypes);
} else if (const auto *reductionClause =
std::get_if<Fortran::parser::AccClause::Reduction>(
&clause.u)) {
@@ -2934,15 +2935,15 @@ static Op createComputeOp(
computeOp.setWaitOnlyAttr(builder.getArrayAttr(waitOnlyDeviceTypes));
if constexpr (!std::is_same_v<Op, mlir::acc::KernelsOp>) {
- if (!privatizations.empty())
- computeOp.setPrivatizationsAttr(
- mlir::ArrayAttr::get(builder.getContext(), privatizations));
+ if (!privatizationRecipes.empty())
+ computeOp.setPrivatizationRecipesAttr(
+ mlir::ArrayAttr::get(builder.getContext(), privatizationRecipes));
if (!reductionRecipes.empty())
computeOp.setReductionRecipesAttr(
mlir::ArrayAttr::get(builder.getContext(), reductionRecipes));
- if (!firstPrivatizations.empty())
- computeOp.setFirstprivatizationsAttr(
- mlir::ArrayAttr::get(builder.getContext(), firstPrivatizations));
+ if (!firstPrivatizationRecipes.empty())
+ computeOp.setFirstprivatizationRecipesAttr(mlir::ArrayAttr::get(
+ builder.getContext(), firstPrivatizationRecipes));
}
if (combinedConstructs)
diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
index b9148dc088a6a..083a18d80704e 100644
--- a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
+++ b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
@@ -1327,9 +1327,9 @@ def OpenACC_ParallelOp : OpenACC_Op<"parallel",
Variadic<AnyType>:$reductionOperands,
OptionalAttr<SymbolRefArrayAttr>:$reductionRecipes,
Variadic<OpenACC_AnyPointerOrMappableType>:$privateOperands,
- OptionalAttr<SymbolRefArrayAttr>:$privatizations,
+ OptionalAttr<SymbolRefArrayAttr>:$privatizationRecipes,
Variadic<OpenACC_AnyPointerOrMappableType>:$firstprivateOperands,
- OptionalAttr<SymbolRefArrayAttr>:$firstprivatizations,
+ OptionalAttr<SymbolRefArrayAttr>:$firstprivatizationRecipes,
Variadic<OpenACC_AnyPointerOrMappableType>:$dataClauseOperands,
OptionalAttr<DefaultValueAttr>:$defaultAttr,
UnitAttr:$combined);
@@ -1443,14 +1443,14 @@ def OpenACC_ParallelOp : OpenACC_Op<"parallel",
| `async` `` custom<DeviceTypeOperandsWithKeywordOnly>($asyncOperands,
type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly)
| `firstprivate` `(` custom<SymOperandList>($firstprivateOperands,
- type($firstprivateOperands), $firstprivatizations)
+ type($firstprivateOperands), $firstprivatizationRecipes)
`)`
| `num_gangs` `(` custom<NumGangs>($numGangs,
type($numGangs), $numGangsDeviceType, $numGangsSegments) `)`
| `num_workers` `(` custom<DeviceTypeOperands>($numWorkers,
type($numWorkers), $numWorkersDeviceType) `)`
| `private` `(` custom<SymOperandList>(
- $privateOperands, type($privateOperands), $privatizations)
+ $privateOperands, type($privateOperands), $privatizationRecipes)
`)`
| `vector_length` `(` custom<DeviceTypeOperands>($vectorLength,
type($vectorLength), $vectorLengthDeviceType) `)`
@@ -1512,9 +1512,9 @@ def OpenACC_SerialOp : OpenACC_Op<"serial",
Variadic<AnyType>:$reductionOperands,
OptionalAttr<SymbolRefArrayAttr>:$reductionRecipes,
Variadic<OpenACC_AnyPointerOrMappableType>:$privateOperands,
- OptionalAttr<SymbolRefArrayAttr>:$privatizations,
+ OptionalAttr<SymbolRefArrayAttr>:$privatizationRecipes,
Variadic<OpenACC_AnyPointerOrMappableType>:$firstprivateOperands,
- OptionalAttr<SymbolRefArrayAttr>:$firstprivatizations,
+ OptionalAttr<SymbolRefArrayAttr>:$firstprivatizationRecipes,
Variadic<OpenACC_AnyPointerOrMappableType>:$dataClauseOperands,
OptionalAttr<DefaultValueAttr>:$defaultAttr,
UnitAttr:$combined);
@@ -1585,10 +1585,10 @@ def OpenACC_SerialOp : OpenACC_Op<"serial",
| `async` `` custom<DeviceTypeOperandsWithKeywordOnly>($asyncOperands,
type($asyncOperands), $asyncOperandsDeviceType, $asyncOnly)
| `firstprivate` `(` custom<SymOperandList>($firstprivateOperands,
- type($firstprivateOperands), $firstprivatizations)
+ type($firstprivateOperands), $firstprivatizationRecipes)
`)`
| `private` `(` custom<SymOperandList>(
- $privateOperands, type($privateOperands), $privatizations)
+ $privateOperands, type($privateOperands), $privatizationRecipes)
`)`
| `wait` `` custom<WaitClause>($waitOperands, type($waitOperands),
$waitOperandsDeviceType, $waitOperandsSegments, $hasWaitDevnum,
@@ -2106,7 +2106,7 @@ def OpenACC_LoopOp : OpenACC_Op<"loop",
OptionalAttr<DeviceTypeArrayAttr>:$tileOperandsDeviceType,
Variadic<OpenACC_AnyPointerOrMappableType>:$cacheOperands,
Variadic<OpenACC_AnyPointerOrMappableType>:$privateOperands,
- OptionalAttr<SymbolRefArrayAttr>:$privatizations,
+ OptionalAttr<SymbolRefArrayAttr>:$privatizationRecipes,
Variadic<AnyType>:$reductionOperands,
OptionalAttr<SymbolRefArrayAttr>:$reductionRecipes,
OptionalAttr<OpenACC_CombinedConstructsAttr>:$combined
@@ -2261,7 +2261,7 @@ def OpenACC_LoopOp : OpenACC_Op<"loop",
| `vector` `` custom<DeviceTypeOperandsWithKeywordOnly>($vectorOperands,
type($vectorOperands), $vectorOperandsDeviceType, $vector)
| `private` `(` custom<SymOperandList>(
- $privateOperands, type($privateOperands), $privatizations) `)`
+ $privateOperands, type($privateOperands), $privatizationRecipes) `)`
| `tile` `(` custom<DeviceTypeOperandsWithSegment>($tileOperands,
type($tileOperands), $tileOperandsDeviceType, $tileOperandsSegments)
`)`
diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
index b401d2ec7894a..658ad28477ace 100644
--- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
+++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
@@ -1079,11 +1079,11 @@ static LogicalResult verifyDeviceTypeAndSegmentCountMatch(
LogicalResult acc::ParallelOp::verify() {
if (failed(checkSymOperandList<mlir::acc::PrivateRecipeOp>(
- *this, getPrivatizations(), getPrivateOperands(), "private",
+ *this, getPrivatizationRecipes(), getPrivateOperands(), "private",
"privatizations", /*checkOperandType=*/false)))
return failure();
if (failed(checkSymOperandList<mlir::acc::FirstprivateRecipeOp>(
- *this, getFirstprivatizations(), getFirstprivateOperands(),
+ *this, getFirstprivatizationRecipes(), getFirstprivateOperands(),
"firstprivate", "firstprivatizations", /*checkOperandType=*/false)))
return failure();
if (failed(checkSymOperandList<mlir::acc::ReductionRecipeOp>(
@@ -1870,11 +1870,11 @@ mlir::Value SerialOp::getWaitDevnum(mlir::acc::DeviceType deviceType) {
LogicalResult acc::SerialOp::verify() {
if (failed(checkSymOperandList<mlir::acc::PrivateRecipeOp>(
- *this, getPrivatizations(), getPrivateOperands(), "private",
+ *this, getPrivatizationRecipes(), getPrivateOperands(), "private",
"privatizations", /*checkOperandType=*/false)))
return failure();
if (failed(checkSymOperandList<mlir::acc::FirstprivateRecipeOp>(
- *this, getFirstprivatizations(), getFirstprivateOperands(),
+ *this, getFirstprivatizationRecipes(), getFirstprivateOperands(),
"firstprivate", "firstprivatizations", /*checkOperandType=*/false)))
return failure();
if (failed(checkSymOperandList<mlir::acc::ReductionRecipeOp>(
@@ -2488,7 +2488,7 @@ LogicalResult acc::LoopOp::verify() {
}
if (failed(checkSymOperandList<mlir::acc::PrivateRecipeOp>(
- *this, getPrivatizations(), getPrivateOperands(), "private",
+ *this, getPrivatizationRecipes(), getPrivateOperands(), "private",
"privatizations", false)))
return failure();
``````````
</details>
https://github.com/llvm/llvm-project/pull/140719
More information about the flang-commits
mailing list