Skip to content

Commit 25ceffe

Browse files
anchurajanchuraj
committed
R5: Addressing review comments
1 parent fe9a702 commit 25ceffe

File tree

7 files changed

+73
-56
lines changed

7 files changed

+73
-56
lines changed

‎flang/include/flang/Frontend/TargetOptions.h

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -54,10 +54,10 @@ class TargetOptions {
5454
/// Print verbose assembly
5555
bool asmVerbose = false;
5656

57-
/// Atomic control options for AMD gpu
58-
bool ignoreDenormalMode = false;
59-
bool remoteMemory = false;
60-
bool fineGrainedMemory = false;
57+
/// Atomic control options
58+
bool atomicIgnoreDenormalMode = false;
59+
bool atomicRemoteMemory = false;
60+
bool atomicFineGrainedMemory = false;
6161
};
6262

6363
} // end namespace Fortran::frontend

‎flang/include/flang/Optimizer/Dialect/Support/FIRContext.h

Lines changed: 12 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -58,13 +58,18 @@ void setTargetCPU(mlir::ModuleOp mod, llvm::StringRef cpu);
5858
/// Get the target CPU string from the Module or return a null reference.
5959
llvm::StringRef getTargetCPU(mlir::ModuleOp mod);
6060

61-
// Setters and getters for atomic control options.
62-
void setIgnoreDenormalMode(mlir::ModuleOp mod);
63-
bool getIgnoreDenormalMode(mlir::ModuleOp mod);
64-
void setFineGrainedMemory(mlir::ModuleOp mod);
65-
bool getFineGrainedMemory(mlir::ModuleOp mod);
66-
void setRemoteMemory(mlir::ModuleOp mod);
67-
bool getRemoteMemory(mlir::ModuleOp mod);
61+
/// Sets that Denormal Mode can be ignored for lowering of floating point atomic operations.
62+
void setAtomicIgnoreDenormalMode(mlir::ModuleOp mod, bool value);
63+
/// Gets whether Denormal Mode can be ignored or not for lowering of floating point atomic operations.
64+
bool getAtomicIgnoreDenormalMode(mlir::ModuleOp mod);
65+
/// Sets that fine grained memory is used for lowering of atomic operations.
66+
void setAtomicFineGrainedMemory(mlir::ModuleOp mod, bool value);
67+
/// Gets whether fine grained memory is used or not for lowering of atomic operations.
68+
bool getAtomicFineGrainedMemory(mlir::ModuleOp mod);
69+
/// Sets that remote memory is used for lowering of atomic operations.
70+
void setAtomicRemoteMemory(mlir::ModuleOp mod, bool value);
71+
/// Gets whether remote memory is used or not for lowering of atomic operations.
72+
bool getAtomicRemoteMemory(mlir::ModuleOp mod);
6873

6974
/// Set the tune CPU for the module. `cpu` must not be deallocated while
7075
/// module `mod` is still live.

‎flang/lib/Frontend/CompilerInvocation.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -495,13 +495,13 @@ static void parseTargetArgs(TargetOptions &opts, llvm::opt::ArgList &args) {
495495
args.getLastArg(clang::driver::options::OPT_triple))
496496
opts.triple = a->getValue();
497497

498-
opts.ignoreDenormalMode = args.hasFlag(
498+
opts.atomicIgnoreDenormalMode = args.hasFlag(
499499
clang::driver::options::OPT_fatomic_ignore_denormal_mode,
500500
clang::driver::options::OPT_fno_atomic_ignore_denormal_mode, false);
501-
opts.fineGrainedMemory = args.hasFlag(
501+
opts.atomicFineGrainedMemory = args.hasFlag(
502502
clang::driver::options::OPT_fatomic_fine_grained_memory,
503503
clang::driver::options::OPT_fno_atomic_fine_grained_memory, false);
504-
opts.remoteMemory =
504+
opts.atomicRemoteMemory =
505505
args.hasFlag(clang::driver::options::OPT_fatomic_remote_memory,
506506
clang::driver::options::OPT_fno_atomic_remote_memory, false);
507507

‎flang/lib/Lower/Bridge.cpp

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6654,12 +6654,9 @@ Fortran::lower::LoweringBridge::LoweringBridge(
66546654
fir::setKindMapping(*module, kindMap);
66556655
fir::setTargetCPU(*module, targetMachine.getTargetCPU());
66566656
fir::setTuneCPU(*module, targetOpts.cpuToTuneFor);
6657-
if (targetOpts.ignoreDenormalMode)
6658-
fir::setIgnoreDenormalMode(*module);
6659-
if (targetOpts.fineGrainedMemory)
6660-
fir::setFineGrainedMemory(*module);
6661-
if (targetOpts.remoteMemory)
6662-
fir::setRemoteMemory(*module);
6657+
fir::setAtomicIgnoreDenormalMode(*module, targetOpts.atomicIgnoreDenormalMode);
6658+
fir::setAtomicFineGrainedMemory(*module, targetOpts.atomicFineGrainedMemory);
6659+
fir::setAtomicRemoteMemory(*module, targetOpts.atomicRemoteMemory);
66636660
fir::setTargetFeatures(*module, targetMachine.getTargetFeatureString());
66646661
fir::support::setMLIRDataLayout(*module, targetMachine.createDataLayout());
66656662
fir::setIdent(*module, Fortran::common::getFlangFullVersion());

‎flang/lib/Lower/OpenMP/OpenMP.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2982,8 +2982,8 @@ genAtomicUpdate(lower::AbstractConverter &converter,
29822982
mlir::ModuleOp module = builder.getModule();
29832983
mlir::omp::AtomicControlAttr atomicControlAttr =
29842984
mlir::omp::AtomicControlAttr::get(
2985-
builder.getContext(), fir::getIgnoreDenormalMode(module),
2986-
fir::getFineGrainedMemory(module), fir::getRemoteMemory(module));
2985+
builder.getContext(), fir::getAtomicIgnoreDenormalMode(module),
2986+
fir::getAtomicFineGrainedMemory(module), fir::getAtomicRemoteMemory(module));
29872987
builder.restoreInsertionPoint(atomicAt);
29882988
auto updateOp = builder.create<mlir::omp::AtomicUpdateOp>(
29892989
loc, atomAddr, atomicControlAttr, hint,

‎flang/lib/Optimizer/Dialect/Support/FIRContext.cpp

Lines changed: 34 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -88,34 +88,49 @@ void fir::setTuneCPU(mlir::ModuleOp mod, llvm::StringRef cpu) {
8888
mod->setAttr(tuneCpuName, mlir::StringAttr::get(ctx, cpu));
8989
}
9090

91-
static constexpr const char *ignoreDenormalModeName =
92-
"fir.ignore.denormal.mode";
93-
void fir::setIgnoreDenormalMode(mlir::ModuleOp mod) {
94-
auto *ctx = mod.getContext();
95-
mod->setAttr(ignoreDenormalModeName, mlir::UnitAttr::get(ctx));
91+
static constexpr const char *atomicIgnoreDenormalModeName =
92+
"fir.atomic_ignore_denormal_mode";
93+
void fir::setAtomicIgnoreDenormalMode(mlir::ModuleOp mod, bool value) {
94+
if(value) {
95+
auto *ctx = mod.getContext();
96+
mod->setAttr(atomicIgnoreDenormalModeName, mlir::UnitAttr::get(ctx));
97+
} else {
98+
if(mod->hasAttr(atomicIgnoreDenormalModeName))
99+
mod->removeAttr(atomicIgnoreDenormalModeName);
100+
}
96101
}
97102

98-
bool fir::getIgnoreDenormalMode(mlir::ModuleOp mod) {
99-
return mod->hasAttrOfType<mlir::UnitAttr>(ignoreDenormalModeName);
103+
bool fir::getAtomicIgnoreDenormalMode(mlir::ModuleOp mod) {
104+
return mod->hasAttrOfType<mlir::UnitAttr>(atomicIgnoreDenormalModeName);
100105
}
101106

102-
static constexpr const char *fineGrainedMemoryName = "fir.fine.grained.memory";
103-
void fir::setFineGrainedMemory(mlir::ModuleOp mod) {
104-
auto *ctx = mod.getContext();
105-
mod->setAttr(fineGrainedMemoryName, mlir::UnitAttr::get(ctx));
107+
static constexpr const char *atomicFineGrainedMemoryName = "fir.atomic_fine_grained_memory";
108+
void fir::setAtomicFineGrainedMemory(mlir::ModuleOp mod, bool value) {
109+
if(value) {
110+
auto *ctx = mod.getContext();
111+
mod->setAttr(atomicFineGrainedMemoryName, mlir::UnitAttr::get(ctx));
112+
} else {
113+
if(mod->hasAttr(atomicFineGrainedMemoryName))
114+
mod->removeAttr(atomicFineGrainedMemoryName);
115+
}
106116
}
107117

108-
bool fir::getFineGrainedMemory(mlir::ModuleOp mod) {
109-
return mod->hasAttrOfType<mlir::UnitAttr>(fineGrainedMemoryName);
118+
bool fir::getAtomicFineGrainedMemory(mlir::ModuleOp mod) {
119+
return mod->hasAttrOfType<mlir::UnitAttr>(atomicFineGrainedMemoryName);
110120
}
111-
static constexpr const char *remoteMemoryName = "fir.remote.memory";
112-
void fir::setRemoteMemory(mlir::ModuleOp mod) {
113-
auto *ctx = mod.getContext();
114-
mod->setAttr(remoteMemoryName, mlir::UnitAttr::get(ctx));
121+
static constexpr const char *atomicRemoteMemoryName = "fir.atomic_remote_memory";
122+
void fir::setAtomicRemoteMemory(mlir::ModuleOp mod, bool value) {
123+
if(value) {
124+
auto *ctx = mod.getContext();
125+
mod->setAttr(atomicRemoteMemoryName, mlir::UnitAttr::get(ctx));
126+
} else {
127+
if(mod->hasAttr(atomicRemoteMemoryName))
128+
mod->removeAttr(atomicRemoteMemoryName);
129+
}
115130
}
116131

117-
bool fir::getRemoteMemory(mlir::ModuleOp mod) {
118-
return mod->hasAttrOfType<mlir::UnitAttr>(remoteMemoryName);
132+
bool fir::getAtomicRemoteMemory(mlir::ModuleOp mod) {
133+
return mod->hasAttrOfType<mlir::UnitAttr>(atomicRemoteMemoryName);
119134
}
120135

121136
llvm::StringRef fir::getTuneCPU(mlir::ModuleOp mod) {

‎mlir/include/mlir/Dialect/OpenMP/OpenMPAttrDefs.td

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,21 @@ class OpenMP_Attr<string name, string attrMnemonic, list<Trait> traits = [],
2222
let mnemonic = attrMnemonic;
2323
}
2424

25+
//===----------------------------------------------------------------------===//
26+
// AtomicControlAttr
27+
//===----------------------------------------------------------------------===//
28+
29+
// Atomic control attributes hold information about architectural
30+
// characteristics which are required for lowering atomic operations.
31+
def AtomicControlAttr : OpenMP_Attr<"AtomicControl", "atomic_control"> {
32+
let parameters =
33+
(ins DefaultValuedParameter<"bool", "false">:$ignore_denormal_mode,
34+
DefaultValuedParameter<"bool", "false">:$fine_grained_memory,
35+
DefaultValuedParameter<"bool", "false">:$remote_memory);
36+
37+
let assemblyFormat = "`<` struct(params) `>`";
38+
}
39+
2540
//===----------------------------------------------------------------------===//
2641
// DeclareTargetAttr
2742
//===----------------------------------------------------------------------===//
@@ -54,21 +69,6 @@ def FlagsAttr : OpenMP_Attr<"Flags", "flags"> {
5469
let assemblyFormat = "`<` struct(params) `>`";
5570
}
5671

57-
//===----------------------------------------------------------------------===//
58-
// AtomicControlAttr
59-
//===----------------------------------------------------------------------===//
60-
61-
// Atomic control attributes hold information about architectural
62-
// characteristics which are required for lowering atomic operations.
63-
def AtomicControlAttr : OpenMP_Attr<"AtomicControl", "atomic_control"> {
64-
let parameters =
65-
(ins DefaultValuedParameter<"bool", "false">:$ignore_denormal_mode,
66-
DefaultValuedParameter<"bool", "false">:$fine_grained_memory,
67-
DefaultValuedParameter<"bool", "false">:$remote_memory);
68-
69-
let assemblyFormat = "`<` struct(params) `>`";
70-
}
71-
7272
//===----------------------------------------------------------------------===//
7373
// TaskDependArrayAttr
7474
//===----------------------------------------------------------------------===//

0 commit comments

Comments
 (0)