[llvm] 1987626 - [LiveDebugValues] Cache LexicalScopes::getMachineBasicBlocks, NFCI
Vedant Kumar via llvm-commits
llvm-commits at lists.llvm.org
Thu Jun 4 16:59:08 PDT 2020
Author: Vedant Kumar
Date: 2020-06-04T16:58:45-07:00
New Revision: 198762680e1e66518ee531c9cce5bf1933accea3
URL: https://github.com/llvm/llvm-project/commit/198762680e1e66518ee531c9cce5bf1933accea3
DIFF: https://github.com/llvm/llvm-project/commit/198762680e1e66518ee531c9cce5bf1933accea3.diff
LOG: [LiveDebugValues] Cache LexicalScopes::getMachineBasicBlocks, NFCI
Summary:
Cache the results from getMachineBasicBlocks in LexicalScopes to speed
up UserValueScopes::dominates queries. This replaces the caching done
in UserValueScopes. Compared to the old caching method, this reduces
memory traffic when a VarLoc is copied (e.g. when a VarLocMap grows),
and enables caching across basic blocks.
When compiling sqlite 3.5.7 (CTMark version), this patch reduces the
number of calls to getMachineBasicBlocks from 10,207 to 1,093. I also
measured a small compile-time reduction (~ 0.1% of total wall time, on
average, on my machine).
As a drive-by, I made the DebugLoc in UserValueScopes a const reference
to cut down on MetadataTracking traffic.
Reviewers: jmorse, Orlando, aprantl, nikic
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D80957
Added:
Modified:
llvm/include/llvm/CodeGen/LexicalScopes.h
llvm/lib/CodeGen/LexicalScopes.cpp
llvm/lib/CodeGen/LiveDebugValues.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/CodeGen/LexicalScopes.h b/llvm/include/llvm/CodeGen/LexicalScopes.h
index 253d4734995b..bac850d327ef 100644
--- a/llvm/include/llvm/CodeGen/LexicalScopes.h
+++ b/llvm/include/llvm/CodeGen/LexicalScopes.h
@@ -163,8 +163,8 @@ class LexicalScopes {
void getMachineBasicBlocks(const DILocation *DL,
SmallPtrSetImpl<const MachineBasicBlock *> &MBBs);
- /// dominates - Return true if DebugLoc's lexical scope dominates at least one
- /// machine instruction's lexical scope in a given machine basic block.
+ /// Return true if DebugLoc's lexical scope dominates at least one machine
+ /// instruction's lexical scope in a given machine basic block.
bool dominates(const DILocation *DL, MachineBasicBlock *MBB);
/// findLexicalScope - Find lexical scope, either regular or inlined, for the
@@ -250,6 +250,11 @@ class LexicalScopes {
/// CurrentFnLexicalScope - Top level scope for the current function.
///
LexicalScope *CurrentFnLexicalScope = nullptr;
+
+ /// Map a location to the set of basic blocks it dominates. This is a cache
+ /// for \ref LexicalScopes::getMachineBasicBlocks results.
+ using BlockSetT = SmallPtrSet<const MachineBasicBlock *, 4>;
+ DenseMap<const DILocation *, std::unique_ptr<BlockSetT>> DominatedBlocks;
};
} // end namespace llvm
diff --git a/llvm/lib/CodeGen/LexicalScopes.cpp b/llvm/lib/CodeGen/LexicalScopes.cpp
index be1d4c867516..c5d786b13f90 100644
--- a/llvm/lib/CodeGen/LexicalScopes.cpp
+++ b/llvm/lib/CodeGen/LexicalScopes.cpp
@@ -44,6 +44,7 @@ void LexicalScopes::reset() {
AbstractScopeMap.clear();
InlinedLexicalScopeMap.clear();
AbstractScopesList.clear();
+ DominatedBlocks.clear();
}
/// initialize - Scan machine function and constuct lexical scope nest.
@@ -302,8 +303,6 @@ void LexicalScopes::getMachineBasicBlocks(
MBBs.insert(&*CurMBBIt);
}
-/// dominates - Return true if DebugLoc's lexical scope dominates at least one
-/// machine instruction's lexical scope in a given machine basic block.
bool LexicalScopes::dominates(const DILocation *DL, MachineBasicBlock *MBB) {
assert(MF && "Unexpected uninitialized LexicalScopes object!");
LexicalScope *Scope = getOrCreateLexicalScope(DL);
@@ -315,11 +314,17 @@ bool LexicalScopes::dominates(const DILocation *DL, MachineBasicBlock *MBB) {
return true;
// Fetch all the blocks in DLs scope. Because the range / block list also
- // contain any subscopes, any instruction that DL dominates can be found
- // in the block set.
- SmallPtrSet<const MachineBasicBlock *, 32> Set;
- getMachineBasicBlocks(DL, Set);
- return Set.count(MBB) != 0;
+ // contain any subscopes, any instruction that DL dominates can be found in
+ // the block set.
+ //
+ // Cache the set of fetched blocks to avoid repeatedly recomputing the set in
+ // the LiveDebugValues pass.
+ std::unique_ptr<BlockSetT> &Set = DominatedBlocks[DL];
+ if (!Set) {
+ Set = std::make_unique<BlockSetT>();
+ getMachineBasicBlocks(DL, *Set);
+ }
+ return Set->count(MBB) != 0;
}
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
diff --git a/llvm/lib/CodeGen/LiveDebugValues.cpp b/llvm/lib/CodeGen/LiveDebugValues.cpp
index 85fb83dd5ab9..03be54aff96d 100644
--- a/llvm/lib/CodeGen/LiveDebugValues.cpp
+++ b/llvm/lib/CodeGen/LiveDebugValues.cpp
@@ -200,25 +200,6 @@ class LiveDebugValues : public MachineFunctionPass {
enum struct TransferKind { TransferCopy, TransferSpill, TransferRestore };
- /// Keeps track of lexical scopes associated with a user value's source
- /// location.
- class UserValueScopes {
- DebugLoc DL;
- LexicalScopes &LS;
- SmallPtrSet<const MachineBasicBlock *, 4> LBlocks;
-
- public:
- UserValueScopes(DebugLoc D, LexicalScopes &L) : DL(std::move(D)), LS(L) {}
-
- /// Return true if current scope dominates at least one machine
- /// instruction in a given machine basic block.
- bool dominates(MachineBasicBlock *MBB) {
- if (LBlocks.empty())
- LS.getMachineBasicBlocks(DL, LBlocks);
- return LBlocks.count(MBB) != 0 || LS.dominates(DL, MBB);
- }
- };
-
using FragmentInfo = DIExpression::FragmentInfo;
using OptFragmentInfo = Optional<DIExpression::FragmentInfo>;
@@ -247,7 +228,6 @@ class LiveDebugValues : public MachineFunctionPass {
/// is moved.
const MachineInstr &MI;
- mutable UserValueScopes UVS;
enum VarLocKind {
InvalidKind = 0,
RegisterKind,
@@ -272,7 +252,7 @@ class LiveDebugValues : public MachineFunctionPass {
VarLoc(const MachineInstr &MI, LexicalScopes &LS)
: Var(MI.getDebugVariable(), MI.getDebugExpression(),
MI.getDebugLoc()->getInlinedAt()),
- Expr(MI.getDebugExpression()), MI(MI), UVS(MI.getDebugLoc(), LS) {
+ Expr(MI.getDebugExpression()), MI(MI) {
static_assert((sizeof(Loc) == sizeof(uint64_t)),
"hash does not cover all members of Loc");
assert(MI.isDebugValue() && "not a DBG_VALUE");
@@ -438,7 +418,9 @@ class LiveDebugValues : public MachineFunctionPass {
/// Determine whether the lexical scope of this value's debug location
/// dominates MBB.
- bool dominates(MachineBasicBlock &MBB) const { return UVS.dominates(&MBB); }
+ bool dominates(LexicalScopes &LS, MachineBasicBlock &MBB) const {
+ return LS.dominates(MI.getDebugLoc().get(), &MBB);
+ }
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
// TRI can be null.
@@ -1615,7 +1597,7 @@ bool LiveDebugValues::join(
if (!IsArtificial) {
for (uint64_t ID : InLocsT) {
LocIndex Idx = LocIndex::fromRawInteger(ID);
- if (!VarLocIDs[Idx].dominates(MBB)) {
+ if (!VarLocIDs[Idx].dominates(LS, MBB)) {
KillSet.set(ID);
LLVM_DEBUG({
auto Name = VarLocIDs[Idx].Var.getVariable()->getName();
More information about the llvm-commits
mailing list