https://github.com/cdevadas updated
https://github.com/llvm/llvm-project/pull/108507
>From e0e4e978c06a2c78b31382274527201e03082e00 Mon Sep 17 00:00:00 2001
From: Christudasan Devadasan <christudasan.devada...@amd.com>
Date: Thu, 12 Sep 2024 23:38:09 +0530
Subject: [PATCH 1/2] [CodeGen][NewPM] Port machine trace metrics analysis to
new pass manager.
---
.../llvm/CodeGen/MachineTraceMetrics.h | 58 ++++++++++++++---
llvm/include/llvm/InitializePasses.h | 2 +-
.../llvm/Passes/MachinePassRegistry.def | 4 +-
llvm/lib/CodeGen/EarlyIfConversion.cpp | 8 +--
llvm/lib/CodeGen/MachineCombiner.cpp | 8 +--
llvm/lib/CodeGen/MachineTraceMetrics.cpp | 62 +++++++++++++++----
llvm/lib/Passes/PassBuilder.cpp | 1 +
.../AArch64/AArch64ConditionalCompares.cpp | 8 +--
.../AArch64/AArch64StorePairSuppress.cpp | 6 +-
9 files changed, 119 insertions(+), 38 deletions(-)
diff --git a/llvm/include/llvm/CodeGen/MachineTraceMetrics.h
b/llvm/include/llvm/CodeGen/MachineTraceMetrics.h
index c7d97597d551cd..36718f80a1b6dd 100644
--- a/llvm/include/llvm/CodeGen/MachineTraceMetrics.h
+++ b/llvm/include/llvm/CodeGen/MachineTraceMetrics.h
@@ -46,12 +46,13 @@
#ifndef LLVM_CODEGEN_MACHINETRACEMETRICS_H
#define LLVM_CODEGEN_MACHINETRACEMETRICS_H
-#include "llvm/ADT/SparseSet.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/SparseSet.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/TargetSchedule.h"
namespace llvm {
@@ -93,7 +94,7 @@ enum class MachineTraceStrategy {
TS_NumStrategies
};
-class MachineTraceMetrics : public MachineFunctionPass {
+class MachineTraceMetrics {
const MachineFunction *MF = nullptr;
const TargetInstrInfo *TII = nullptr;
const TargetRegisterInfo *TRI = nullptr;
@@ -102,19 +103,22 @@ class MachineTraceMetrics : public MachineFunctionPass {
TargetSchedModel SchedModel;
public:
+ friend class MachineTraceMetricsWrapperPass;
friend class Ensemble;
friend class Trace;
class Ensemble;
- static char ID;
+ // For legacy pass.
+ MachineTraceMetrics() {
+ std::fill(std::begin(Ensembles), std::end(Ensembles), nullptr);
+ }
- MachineTraceMetrics();
+ explicit MachineTraceMetrics(MachineFunction &MF, const MachineLoopInfo &LI);
+ ~MachineTraceMetrics();
- void getAnalysisUsage(AnalysisUsage&) const override;
- bool runOnMachineFunction(MachineFunction&) override;
- void releaseMemory() override;
- void verifyAnalysis() const override;
+ void init(MachineFunction &Func, const MachineLoopInfo &LI);
+ void clear();
/// Per-basic block information that doesn't depend on the trace through the
/// block.
@@ -400,6 +404,12 @@ class MachineTraceMetrics : public MachineFunctionPass {
/// Call Ensemble::getTrace() again to update any trace handles.
void invalidate(const MachineBasicBlock *MBB);
+ /// Handle invalidation explicitly.
+ bool invalidate(MachineFunction &, const PreservedAnalyses &PA,
+ MachineFunctionAnalysisManager::Invalidator &);
+
+ void verifyAnalysis() const;
+
private:
// One entry per basic block, indexed by block number.
SmallVector<FixedBlockInfo, 4> BlockInfo;
@@ -435,6 +445,38 @@ inline raw_ostream &operator<<(raw_ostream &OS,
return OS;
}
+class MachineTraceMetricsAnalysis
+ : public AnalysisInfoMixin<MachineTraceMetricsAnalysis> {
+ friend AnalysisInfoMixin<MachineTraceMetricsAnalysis>;
+ static AnalysisKey Key;
+
+public:
+ using Result = MachineTraceMetrics;
+ Result run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM);
+};
+
+/// Verifier pass for \c MachineTraceMetrics.
+struct MachineTraceMetricsVerifierPass
+ : PassInfoMixin<MachineTraceMetricsVerifierPass> {
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+ static bool isRequired() { return true; }
+};
+
+class MachineTraceMetricsWrapperPass : public MachineFunctionPass {
+public:
+ static char ID;
+ MachineTraceMetrics MTM;
+
+ MachineTraceMetricsWrapperPass();
+
+ void getAnalysisUsage(AnalysisUsage &) const override;
+ bool runOnMachineFunction(MachineFunction &) override;
+ void releaseMemory() override { MTM.clear(); }
+ void verifyAnalysis() const override { MTM.verifyAnalysis(); }
+ MachineTraceMetrics &getMTM() { return MTM; }
+};
+
} // end namespace llvm
#endif // LLVM_CODEGEN_MACHINETRACEMETRICS_H
diff --git a/llvm/include/llvm/InitializePasses.h
b/llvm/include/llvm/InitializePasses.h
index 6a75dc0285cc61..5ed0ad98a2a72d 100644
--- a/llvm/include/llvm/InitializePasses.h
+++ b/llvm/include/llvm/InitializePasses.h
@@ -209,7 +209,7 @@ void initializeMachineRegionInfoPassPass(PassRegistry &);
void initializeMachineSanitizerBinaryMetadataPass(PassRegistry &);
void initializeMachineSchedulerPass(PassRegistry &);
void initializeMachineSinkingPass(PassRegistry &);
-void initializeMachineTraceMetricsPass(PassRegistry &);
+void initializeMachineTraceMetricsWrapperPassPass(PassRegistry &);
void initializeMachineUniformityInfoPrinterPassPass(PassRegistry &);
void initializeMachineUniformityAnalysisPassPass(PassRegistry &);
void initializeMachineVerifierLegacyPassPass(PassRegistry &);
diff --git a/llvm/include/llvm/Passes/MachinePassRegistry.def
b/llvm/include/llvm/Passes/MachinePassRegistry.def
index 2aa5f4fc176aba..1d7084354455c7 100644
--- a/llvm/include/llvm/Passes/MachinePassRegistry.def
+++ b/llvm/include/llvm/Passes/MachinePassRegistry.def
@@ -106,6 +106,7 @@ MACHINE_FUNCTION_ANALYSIS("machine-opt-remark-emitter",
MachineOptimizationRemarkEmitterAnalysis())
MACHINE_FUNCTION_ANALYSIS("machine-post-dom-tree",
MachinePostDominatorTreeAnalysis())
+MACHINE_FUNCTION_ANALYSIS("machine-trace-metrics",
MachineTraceMetricsAnalysis())
MACHINE_FUNCTION_ANALYSIS("pass-instrumentation",
PassInstrumentationAnalysis(PIC))
MACHINE_FUNCTION_ANALYSIS("slot-indexes", SlotIndexesAnalysis())
// MACHINE_FUNCTION_ANALYSIS("live-stacks", LiveStacksPass())
@@ -119,8 +120,6 @@ MACHINE_FUNCTION_ANALYSIS("slot-indexes",
SlotIndexesAnalysis())
// MachinePostDominatorTreeAnalysis())
// MACHINE_FUNCTION_ANALYSIS("machine-region-info",
// MachineRegionInfoPassAnalysis())
-// MACHINE_FUNCTION_ANALYSIS("machine-trace-metrics",
-// MachineTraceMetricsAnalysis()) MACHINE_FUNCTION_ANALYSIS("reaching-def",
// ReachingDefAnalysisAnalysis()) MACHINE_FUNCTION_ANALYSIS("live-reg-matrix",
// LiveRegMatrixAnalysis()) MACHINE_FUNCTION_ANALYSIS("gc-analysis",
// GCMachineCodeAnalysisPass())
@@ -156,6 +155,7 @@ MACHINE_FUNCTION_PASS("stack-coloring", StackColoringPass())
MACHINE_FUNCTION_PASS("trigger-verifier-error", TriggerVerifierErrorPass())
MACHINE_FUNCTION_PASS("two-address-instruction", TwoAddressInstructionPass())
MACHINE_FUNCTION_PASS("verify", MachineVerifierPass())
+MACHINE_FUNCTION_PASS("verify<machine-trace-metrics>",
MachineTraceMetricsVerifierPass())
#undef MACHINE_FUNCTION_PASS
#ifndef MACHINE_FUNCTION_PASS_WITH_PARAMS
diff --git a/llvm/lib/CodeGen/EarlyIfConversion.cpp
b/llvm/lib/CodeGen/EarlyIfConversion.cpp
index 8d9813edd7e52a..53cf6a5169795f 100644
--- a/llvm/lib/CodeGen/EarlyIfConversion.cpp
+++ b/llvm/lib/CodeGen/EarlyIfConversion.cpp
@@ -792,7 +792,7 @@ INITIALIZE_PASS_BEGIN(EarlyIfConverter, DEBUG_TYPE,
"Early If Converter", false, false)
INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(MachineDominatorTreeWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(MachineTraceMetrics)
+INITIALIZE_PASS_DEPENDENCY(MachineTraceMetricsWrapperPass)
INITIALIZE_PASS_END(EarlyIfConverter, DEBUG_TYPE,
"Early If Converter", false, false)
@@ -802,8 +802,8 @@ void EarlyIfConverter::getAnalysisUsage(AnalysisUsage &AU)
const {
AU.addPreserved<MachineDominatorTreeWrapperPass>();
AU.addRequired<MachineLoopInfoWrapperPass>();
AU.addPreserved<MachineLoopInfoWrapperPass>();
- AU.addRequired<MachineTraceMetrics>();
- AU.addPreserved<MachineTraceMetrics>();
+ AU.addRequired<MachineTraceMetricsWrapperPass>();
+ AU.addPreserved<MachineTraceMetricsWrapperPass>();
MachineFunctionPass::getAnalysisUsage(AU);
}
@@ -1093,7 +1093,7 @@ bool
EarlyIfConverter::runOnMachineFunction(MachineFunction &MF) {
MRI = &MF.getRegInfo();
DomTree = &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
Loops = &getAnalysis<MachineLoopInfoWrapperPass>().getLI();
- Traces = &getAnalysis<MachineTraceMetrics>();
+ Traces = &getAnalysis<MachineTraceMetricsWrapperPass>().getMTM();
MinInstr = nullptr;
bool Changed = false;
diff --git a/llvm/lib/CodeGen/MachineCombiner.cpp
b/llvm/lib/CodeGen/MachineCombiner.cpp
index 1a19e053d30fe1..5bfc1d63ac3764 100644
--- a/llvm/lib/CodeGen/MachineCombiner.cpp
+++ b/llvm/lib/CodeGen/MachineCombiner.cpp
@@ -133,7 +133,7 @@ char &llvm::MachineCombinerID = MachineCombiner::ID;
INITIALIZE_PASS_BEGIN(MachineCombiner, DEBUG_TYPE,
"Machine InstCombiner", false, false)
INITIALIZE_PASS_DEPENDENCY(MachineLoopInfoWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(MachineTraceMetrics)
+INITIALIZE_PASS_DEPENDENCY(MachineTraceMetricsWrapperPass)
INITIALIZE_PASS_END(MachineCombiner, DEBUG_TYPE, "Machine InstCombiner",
false, false)
@@ -142,8 +142,8 @@ void MachineCombiner::getAnalysisUsage(AnalysisUsage &AU)
const {
AU.addPreserved<MachineDominatorTreeWrapperPass>();
AU.addRequired<MachineLoopInfoWrapperPass>();
AU.addPreserved<MachineLoopInfoWrapperPass>();
- AU.addRequired<MachineTraceMetrics>();
- AU.addPreserved<MachineTraceMetrics>();
+ AU.addRequired<MachineTraceMetricsWrapperPass>();
+ AU.addPreserved<MachineTraceMetricsWrapperPass>();
AU.addRequired<LazyMachineBlockFrequencyInfoPass>();
AU.addRequired<ProfileSummaryInfoWrapperPass>();
MachineFunctionPass::getAnalysisUsage(AU);
@@ -727,7 +727,7 @@ bool MachineCombiner::runOnMachineFunction(MachineFunction
&MF) {
TSchedModel.init(STI);
MRI = &MF.getRegInfo();
MLI = &getAnalysis<MachineLoopInfoWrapperPass>().getLI();
- Traces = &getAnalysis<MachineTraceMetrics>();
+ Traces = &getAnalysis<MachineTraceMetricsWrapperPass>().getMTM();
PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
MBFI = (PSI && PSI->hasProfileSummary()) ?
&getAnalysis<LazyMachineBlockFrequencyInfoPass>().getBFI() :
diff --git a/llvm/lib/CodeGen/MachineTraceMetrics.cpp
b/llvm/lib/CodeGen/MachineTraceMetrics.cpp
index 5a1670953ddd97..4d873b50f0987b 100644
--- a/llvm/lib/CodeGen/MachineTraceMetrics.cpp
+++ b/llvm/lib/CodeGen/MachineTraceMetrics.cpp
@@ -39,41 +39,68 @@ using namespace llvm;
#define DEBUG_TYPE "machine-trace-metrics"
-char MachineTraceMetrics::ID = 0;
+AnalysisKey MachineTraceMetricsAnalysis::Key;
-char &llvm::MachineTraceMetricsID = MachineTraceMetrics::ID;
+MachineTraceMetricsAnalysis::Result
+MachineTraceMetricsAnalysis::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ return Result(MF, MFAM.getResult<MachineLoopAnalysis>(MF));
+}
+
+PreservedAnalyses
+MachineTraceMetricsVerifierPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ MFAM.getResult<MachineTraceMetricsAnalysis>(MF).verifyAnalysis();
+ return PreservedAnalyses::all();
+}
+
+char MachineTraceMetricsWrapperPass::ID = 0;
-INITIALIZE_PASS_BEGIN(MachineTraceMetrics, DEBUG_TYPE, "Machine Trace Metrics",
- false, true)
+char &llvm::MachineTraceMetricsID = MachineTraceMetricsWrapperPass::ID;
+
+INITIALIZE_PASS_BEGIN(MachineTraceMetricsWrapperPass, DEBUG_TYPE,
+ "Machine Trace Metrics", false, true)
INITIALIZE_PASS_DEPENDENCY(MachineLoopInfoWrapperPass)
-INITIALIZE_PASS_END(MachineTraceMetrics, DEBUG_TYPE,
+INITIALIZE_PASS_END(MachineTraceMetricsWrapperPass, DEBUG_TYPE,
"Machine Trace Metrics", false, true)
-MachineTraceMetrics::MachineTraceMetrics() : MachineFunctionPass(ID) {
- std::fill(std::begin(Ensembles), std::end(Ensembles), nullptr);
-}
+MachineTraceMetricsWrapperPass::MachineTraceMetricsWrapperPass()
+ : MachineFunctionPass(ID) {}
-void MachineTraceMetrics::getAnalysisUsage(AnalysisUsage &AU) const {
+void MachineTraceMetricsWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const
{
AU.setPreservesAll();
AU.addRequired<MachineLoopInfoWrapperPass>();
MachineFunctionPass::getAnalysisUsage(AU);
}
-bool MachineTraceMetrics::runOnMachineFunction(MachineFunction &Func) {
+void MachineTraceMetrics::init(MachineFunction &Func,
+ const MachineLoopInfo &LI) {
MF = &Func;
const TargetSubtargetInfo &ST = MF->getSubtarget();
TII = ST.getInstrInfo();
TRI = ST.getRegisterInfo();
MRI = &MF->getRegInfo();
- Loops = &getAnalysis<MachineLoopInfoWrapperPass>().getLI();
+ Loops = &LI;
SchedModel.init(&ST);
BlockInfo.resize(MF->getNumBlockIDs());
ProcReleaseAtCycles.resize(MF->getNumBlockIDs() *
SchedModel.getNumProcResourceKinds());
+}
+
+bool MachineTraceMetricsWrapperPass::runOnMachineFunction(MachineFunction &MF)
{
+ MTM.init(MF, getAnalysis<MachineLoopInfoWrapperPass>().getLI());
return false;
}
-void MachineTraceMetrics::releaseMemory() {
+MachineTraceMetrics::MachineTraceMetrics(MachineFunction &MF,
+ const MachineLoopInfo &LI) {
+ std::fill(std::begin(Ensembles), std::end(Ensembles), nullptr);
+ init(MF, LI);
+}
+
+MachineTraceMetrics::~MachineTraceMetrics() { clear(); }
+
+void MachineTraceMetrics::clear() {
MF = nullptr;
BlockInfo.clear();
for (Ensemble *&E : Ensembles) {
@@ -418,6 +445,17 @@ void MachineTraceMetrics::invalidate(const
MachineBasicBlock *MBB) {
E->invalidate(MBB);
}
+bool MachineTraceMetrics::invalidate(
+ MachineFunction &, const PreservedAnalyses &PA,
+ MachineFunctionAnalysisManager::Invalidator &) {
+ // Check whether the analysis, all analyses on machine functions, or the
+ // machine function's CFG have been preserved.
+ auto PAC = PA.getChecker<MachineTraceMetricsAnalysis>();
+ return !PAC.preserved() &&
+ !PAC.preservedSet<AllAnalysesOn<MachineFunction>>() &&
+ !PAC.preservedSet<CFGAnalyses>();
+}
+
void MachineTraceMetrics::verifyAnalysis() const {
if (!MF)
return;
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 36c0cea3613105..08cc4ddbe34327 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -109,6 +109,7 @@
#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachinePostDominators.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/MachineTraceMetrics.h"
#include "llvm/CodeGen/MachineVerifier.h"
#include "llvm/CodeGen/PHIElimination.h"
#include "llvm/CodeGen/PreISelIntrinsicLowering.h"
diff --git a/llvm/lib/Target/AArch64/AArch64ConditionalCompares.cpp
b/llvm/lib/Target/AArch64/AArch64ConditionalCompares.cpp
index 9669a393bc2b94..0301032e849772 100644
--- a/llvm/lib/Target/AArch64/AArch64ConditionalCompares.cpp
+++ b/llvm/lib/Target/AArch64/AArch64ConditionalCompares.cpp
@@ -795,7 +795,7 @@ INITIALIZE_PASS_BEGIN(AArch64ConditionalCompares,
"aarch64-ccmp",
"AArch64 CCMP Pass", false, false)
INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(MachineDominatorTreeWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(MachineTraceMetrics)
+INITIALIZE_PASS_DEPENDENCY(MachineTraceMetricsWrapperPass)
INITIALIZE_PASS_END(AArch64ConditionalCompares, "aarch64-ccmp",
"AArch64 CCMP Pass", false, false)
@@ -809,8 +809,8 @@ void
AArch64ConditionalCompares::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addPreserved<MachineDominatorTreeWrapperPass>();
AU.addRequired<MachineLoopInfoWrapperPass>();
AU.addPreserved<MachineLoopInfoWrapperPass>();
- AU.addRequired<MachineTraceMetrics>();
- AU.addPreserved<MachineTraceMetrics>();
+ AU.addRequired<MachineTraceMetricsWrapperPass>();
+ AU.addPreserved<MachineTraceMetricsWrapperPass>();
MachineFunctionPass::getAnalysisUsage(AU);
}
@@ -937,7 +937,7 @@ bool
AArch64ConditionalCompares::runOnMachineFunction(MachineFunction &MF) {
DomTree = &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
Loops = &getAnalysis<MachineLoopInfoWrapperPass>().getLI();
MBPI = &getAnalysis<MachineBranchProbabilityInfoWrapperPass>().getMBPI();
- Traces = &getAnalysis<MachineTraceMetrics>();
+ Traces = &getAnalysis<MachineTraceMetricsWrapperPass>().getMTM();
MinInstr = nullptr;
MinSize = MF.getFunction().hasMinSize();
diff --git a/llvm/lib/Target/AArch64/AArch64StorePairSuppress.cpp
b/llvm/lib/Target/AArch64/AArch64StorePairSuppress.cpp
index 047e38261a6fcd..d8c8b17565abb9 100644
--- a/llvm/lib/Target/AArch64/AArch64StorePairSuppress.cpp
+++ b/llvm/lib/Target/AArch64/AArch64StorePairSuppress.cpp
@@ -53,8 +53,8 @@ class AArch64StorePairSuppress : public MachineFunctionPass {
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesCFG();
- AU.addRequired<MachineTraceMetrics>();
- AU.addPreserved<MachineTraceMetrics>();
+ AU.addRequired<MachineTraceMetricsWrapperPass>();
+ AU.addPreserved<MachineTraceMetricsWrapperPass>();
MachineFunctionPass::getAnalysisUsage(AU);
}
};
@@ -139,7 +139,7 @@ bool
AArch64StorePairSuppress::runOnMachineFunction(MachineFunction &MF) {
TRI = ST.getRegisterInfo();
MRI = &MF.getRegInfo();
SchedModel.init(&ST);
- Traces = &getAnalysis<MachineTraceMetrics>();
+ Traces = &getAnalysis<MachineTraceMetricsWrapperPass>().getMTM();
MinInstr = nullptr;
LLVM_DEBUG(dbgs() << "*** " << getPassName() << ": " << MF.getName() <<
'\n');
>From 89fc422a0b424e8ffa4a70c1a33f67ff5e3ce7dd Mon Sep 17 00:00:00 2001
From: Christudasan Devadasan <christudasan.devada...@amd.com>
Date: Fri, 20 Sep 2024 12:12:46 +0530
Subject: [PATCH 2/2] used unique_ptr for Ensembles
---
.../llvm/CodeGen/MachineTraceMetrics.h | 13 +++++---
llvm/lib/CodeGen/MachineTraceMetrics.cpp | 32 +++++++++----------
2 files changed, 23 insertions(+), 22 deletions(-)
diff --git a/llvm/include/llvm/CodeGen/MachineTraceMetrics.h
b/llvm/include/llvm/CodeGen/MachineTraceMetrics.h
index 36718f80a1b6dd..d51de24d64e8d7 100644
--- a/llvm/include/llvm/CodeGen/MachineTraceMetrics.h
+++ b/llvm/include/llvm/CodeGen/MachineTraceMetrics.h
@@ -110,11 +110,14 @@ class MachineTraceMetrics {
class Ensemble;
// For legacy pass.
- MachineTraceMetrics() {
- std::fill(std::begin(Ensembles), std::end(Ensembles), nullptr);
+ MachineTraceMetrics() = default;
+
+ explicit MachineTraceMetrics(MachineFunction &MF, const MachineLoopInfo &LI)
{
+ init(MF, LI);
}
- explicit MachineTraceMetrics(MachineFunction &MF, const MachineLoopInfo &LI);
+ MachineTraceMetrics(MachineTraceMetrics &&) = default;
+
~MachineTraceMetrics();
void init(MachineFunction &Func, const MachineLoopInfo &LI);
@@ -422,8 +425,8 @@ class MachineTraceMetrics {
SmallVector<unsigned, 0> ProcReleaseAtCycles;
// One ensemble per strategy.
- Ensemble
- *Ensembles[static_cast<size_t>(MachineTraceStrategy::TS_NumStrategies)];
+ std::unique_ptr<Ensemble>
+ Ensembles[static_cast<size_t>(MachineTraceStrategy::TS_NumStrategies)];
// Convert scaled resource usage to a cycle count that can be compared with
// latencies.
diff --git a/llvm/lib/CodeGen/MachineTraceMetrics.cpp
b/llvm/lib/CodeGen/MachineTraceMetrics.cpp
index 4d873b50f0987b..0844add8328059 100644
--- a/llvm/lib/CodeGen/MachineTraceMetrics.cpp
+++ b/llvm/lib/CodeGen/MachineTraceMetrics.cpp
@@ -92,20 +92,14 @@ bool
MachineTraceMetricsWrapperPass::runOnMachineFunction(MachineFunction &MF) {
return false;
}
-MachineTraceMetrics::MachineTraceMetrics(MachineFunction &MF,
- const MachineLoopInfo &LI) {
- std::fill(std::begin(Ensembles), std::end(Ensembles), nullptr);
- init(MF, LI);
-}
-
MachineTraceMetrics::~MachineTraceMetrics() { clear(); }
void MachineTraceMetrics::clear() {
MF = nullptr;
BlockInfo.clear();
- for (Ensemble *&E : Ensembles) {
- delete E;
- E = nullptr;
+ for (auto &E : Ensembles) {
+ if (E)
+ E.reset();
}
}
@@ -422,27 +416,31 @@ MachineTraceMetrics::Ensemble *
MachineTraceMetrics::getEnsemble(MachineTraceStrategy strategy) {
assert(strategy < MachineTraceStrategy::TS_NumStrategies &&
"Invalid trace strategy enum");
- Ensemble *&E = Ensembles[static_cast<size_t>(strategy)];
+ std::unique_ptr<MachineTraceMetrics::Ensemble> &E =
+ Ensembles[static_cast<size_t>(strategy)];
if (E)
- return E;
+ return E.get();
// Allocate new Ensemble on demand.
switch (strategy) {
case MachineTraceStrategy::TS_MinInstrCount:
- return (E = new MinInstrCountEnsemble(this));
+ E = std::make_unique<MinInstrCountEnsemble>(MinInstrCountEnsemble(this));
+ break;
case MachineTraceStrategy::TS_Local:
- return (E = new LocalEnsemble(this));
+ E = std::make_unique<LocalEnsemble>(LocalEnsemble(this));
+ break;
default: llvm_unreachable("Invalid trace strategy enum");
}
+ return E.get();
}
void MachineTraceMetrics::invalidate(const MachineBasicBlock *MBB) {
LLVM_DEBUG(dbgs() << "Invalidate traces through " << printMBBReference(*MBB)
<< '\n');
BlockInfo[MBB->getNumber()].invalidate();
- for (Ensemble *E : Ensembles)
+ for (auto &E : Ensembles)
if (E)
- E->invalidate(MBB);
+ E.get()->invalidate(MBB);
}
bool MachineTraceMetrics::invalidate(
@@ -461,9 +459,9 @@ void MachineTraceMetrics::verifyAnalysis() const {
return;
#ifndef NDEBUG
assert(BlockInfo.size() == MF->getNumBlockIDs() && "Outdated BlockInfo
size");
- for (Ensemble *E : Ensembles)
+ for (auto &E : Ensembles)
if (E)
- E->verify();
+ E.get()->verify();
#endif
}
_______________________________________________
llvm-branch-commits mailing list
llvm-branch-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
