mirror of
https://github.com/RPCS3/llvm.git
synced 2024-12-30 16:34:03 +00:00
49128636b6
critical edge has been split. The MachineDominatorTree will when lazy update the underlying dominance properties when require. ** Context ** This is a follow-up of r215410. Each time a critical edge is split this invalidates the dominator tree information. Thus, subsequent queries of that interface will be slow until the underlying information is actually recomputed (costly). ** Problem ** Prior to this patch, splitting a critical edge needed to query the dominator tree to update the dominator information. Therefore, splitting a bunch of critical edges will likely produce poor performance as each query to the dominator tree will use the slow query path. This happens a lot in passes like MachineSink and PHIElimination. ** Proposed Solution ** Splitting a critical edge is a local modification of the CFG. Moreover, as soon as a critical edge is split, it is not critical anymore and thus cannot be a candidate for critical edge splitting anymore. In other words, the predecessor and successor of a basic block inserted on a critical edge cannot be inserted by critical edge splitting. Using these observations, we can pile up the splitting of critical edge and apply then at once before updating the DT information. The core of this patch moves the update of the MachineDominatorTree information from MachineBasicBlock::SplitCriticalEdge to a lazy MachineDominatorTree. ** Performance ** Thanks to this patch, the motivating example compiles in 4- minutes instead of 6+ minutes. No test case added as the motivating example as nothing special but being huge! The binaries are strictly identical for all the llvm test-suite + SPECs with and without this patch for both Os and O3. Regarding compile time, I observed only noise, although on average I saw a small improvement. <rdar://problem/17894619> git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@215576 91177308-0d34-0410-b5e6-96231b3b80d8
62 lines
1.7 KiB
C++
62 lines
1.7 KiB
C++
//===- MachineDominators.cpp - Machine Dominator Calculation --------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements simple dominator construction algorithms for finding
|
|
// forward dominators on machine functions.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/CodeGen/MachineDominators.h"
|
|
#include "llvm/CodeGen/Passes.h"
|
|
|
|
using namespace llvm;
|
|
|
|
namespace llvm {
|
|
TEMPLATE_INSTANTIATION(class DomTreeNodeBase<MachineBasicBlock>);
|
|
TEMPLATE_INSTANTIATION(class DominatorTreeBase<MachineBasicBlock>);
|
|
}
|
|
|
|
char MachineDominatorTree::ID = 0;
|
|
|
|
INITIALIZE_PASS(MachineDominatorTree, "machinedomtree",
|
|
"MachineDominator Tree Construction", true, true)
|
|
|
|
char &llvm::MachineDominatorsID = MachineDominatorTree::ID;
|
|
|
|
void MachineDominatorTree::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.setPreservesAll();
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
}
|
|
|
|
bool MachineDominatorTree::runOnMachineFunction(MachineFunction &F) {
|
|
CriticalEdgesToSplit.clear();
|
|
NewBBs.clear();
|
|
DT->recalculate(F);
|
|
|
|
return false;
|
|
}
|
|
|
|
MachineDominatorTree::MachineDominatorTree()
|
|
: MachineFunctionPass(ID) {
|
|
initializeMachineDominatorTreePass(*PassRegistry::getPassRegistry());
|
|
DT = new DominatorTreeBase<MachineBasicBlock>(false);
|
|
}
|
|
|
|
MachineDominatorTree::~MachineDominatorTree() {
|
|
delete DT;
|
|
}
|
|
|
|
void MachineDominatorTree::releaseMemory() {
|
|
DT->releaseMemory();
|
|
}
|
|
|
|
void MachineDominatorTree::print(raw_ostream &OS, const Module*) const {
|
|
DT->print(OS);
|
|
}
|