6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-17 20:29:31 +00:00
Code Issues Projects Releases Wiki Activity

Cache non-local memory dependence analysis. This is a significant compile

Browse Source 
time performance win in most cases.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41126 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2007-08-16 21:27:05 +00:00
parent fe8e14a6c9
commit 4d13de4e3b
2 changed files with 33 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/llvm/Analysis/MemoryDependenceAnalysis.h
View File

@ -37,12 +37,20 @@ class MemoryDependenceAnalysis : public FunctionPass {
depMapType;
depMapType depGraphLocal;
// A map from instructions to their non-local dependencies.
typedef DenseMap<Instruction*, DenseMap<BasicBlock*, Value*> >
nonLocalDepMapType;
nonLocalDepMapType depGraphNonLocal;
// A reverse mapping form dependencies to the dependees. This is
// used when removing instructions to keep the cache coherent.
typedef DenseMap<Instruction*, SmallPtrSet<Instruction*, 4> >
typedef DenseMap<Value*, SmallPtrSet<Instruction*, 4> >
reverseDepMapType;
reverseDepMapType reverseDep;
// A reverse mapping form dependencies to the non-local dependees.
reverseDepMapType reverseDepNonLocal;
public:
// Special marker indicating that the query has no dependency
// in the specified block.
@ -61,7 +69,9 @@ class MemoryDependenceAnalysis : public FunctionPass {
/// Clean up memory in between runs
void releaseMemory() {
depGraphLocal.clear();
depGraphNonLocal.clear();
reverseDep.clear();
reverseDepNonLocal.clear();
}
/// getAnalysisUsage - Does not modify anything. It uses Value Numbering

24
lib/Analysis/MemoryDependenceAnalysis.cpp
View File

@ -203,6 +203,11 @@ void MemoryDependenceAnalysis::nonLocalHelper(Instruction* query,
/// blocks between the query and its dependencies.
void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query,
DenseMap<BasicBlock*, Value*>& resp) {
if (depGraphNonLocal.count(query)) {
resp = depGraphNonLocal[query];
return;
}
// First check that we don't actually have a local dependency.
Instruction* localDep = getDependency(query);
if (localDep != NonLocal) {
@ -212,6 +217,13 @@ void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query,
// If not, go ahead and search for non-local ones.
nonLocalHelper(query, query->getParent(), resp);
// Update the non-local dependency cache
for (DenseMap<BasicBlock*, Value*>::iterator I = resp.begin(), E = resp.end();
I != E; ++I) {
depGraphNonLocal[query].insert(*I);
reverseDepNonLocal[I->second].insert(query);
}
}
/// getDependency - Return the instruction on which a memory operation
@ -380,8 +392,6 @@ void MemoryDependenceAnalysis::removeInstruction(Instruction* rem) {
Instruction* newDep = NonLocal;
depMapType::iterator depGraphEntry = depGraphLocal.find(rem);
// We assume here that it's not in the reverse map if it's not in
// the dep map. Checking it could be expensive, so don't do it.
if (depGraphEntry != depGraphLocal.end()) {
if (depGraphEntry->second.first != NonLocal &&
@ -410,8 +420,18 @@ void MemoryDependenceAnalysis::removeInstruction(Instruction* rem) {
// Mark it as unconfirmed as long as it is not the non-local flag
depGraphLocal[*I] = std::make_pair(newDep, !newDep);
}
reverseDep.erase(rem);
}
if (depGraphNonLocal.count(rem)) {
SmallPtrSet<Instruction*, 4>& set = reverseDepNonLocal[rem];
for (SmallPtrSet<Instruction*, 4>::iterator I = set.begin(), E = set.end();
I != E; ++I)
depGraphNonLocal.erase(*I);
reverseDepNonLocal.erase(rem);
}
getAnalysis<AliasAnalysis>().deleteValue(rem);
}