[llvm-commits] [parallel] CVS: llvm/lib/Transforms/Instrumentation/EdgeProfiling.cpp ProfilingUtils.cpp ProfilingUtils.h BlockProfiling.cpp EmitFunctions.cpp
Misha Brukman
brukman at cs.uiuc.edu
Wed Mar 10 19:35:01 PST 2004
Changes in directory llvm/lib/Transforms/Instrumentation:
EdgeProfiling.cpp added (r1.1.2.1)
ProfilingUtils.cpp added (r1.1.2.1)
ProfilingUtils.h added (r1.1.2.1)
BlockProfiling.cpp updated: 1.5.2.1 -> 1.5.2.2
EmitFunctions.cpp updated: 1.14.4.1 -> 1.14.4.2
---
Log message:
Merge from trunk.
---
Diffs of the changes: (+245 -99)
Index: llvm/lib/Transforms/Instrumentation/EdgeProfiling.cpp
diff -c /dev/null llvm/lib/Transforms/Instrumentation/EdgeProfiling.cpp:1.1.2.1
*** /dev/null Wed Mar 10 19:34:31 2004
--- llvm/lib/Transforms/Instrumentation/EdgeProfiling.cpp Wed Mar 10 19:34:21 2004
***************
*** 0 ****
--- 1,94 ----
+ //===- EdgeProfiling.cpp - Insert counters for edge profiling -------------===//
+ //
+ // The LLVM Compiler Infrastructure
+ //
+ // This file was developed by the LLVM research group and is distributed under
+ // the University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This pass instruments the specified program with counters for edge profiling.
+ // Edge profiling can give a reasonable approximation of the hot paths through a
+ // program, and is used for a wide variety of program transformations.
+ //
+ // Note that this implementation is very naive. We insert a counter for *every*
+ // edge in the program, instead of using control flow information to prune the
+ // number of counters inserted.
+ //
+ //===----------------------------------------------------------------------===//
+
+ #include "llvm/Constants.h"
+ #include "llvm/DerivedTypes.h"
+ #include "llvm/Module.h"
+ #include "llvm/Pass.h"
+ #include "llvm/Transforms/Utils/BasicBlockUtils.h"
+ #include "ProfilingUtils.h"
+ #include <set>
+ using namespace llvm;
+
+ namespace {
+ class EdgeProfiler : public Pass {
+ bool run(Module &M);
+ };
+
+ RegisterOpt<EdgeProfiler> X("insert-edge-profiling",
+ "Insert instrumentation for edge profiling");
+ }
+
+ bool EdgeProfiler::run(Module &M) {
+ Function *Main = M.getMainFunction();
+ if (Main == 0) {
+ std::cerr << "WARNING: cannot insert edge profiling into a module"
+ << " with no main function!\n";
+ return false; // No main, no instrumentation!
+ }
+
+ std::set<BasicBlock*> BlocksToInstrument;
+ unsigned NumEdges = 0;
+ for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F)
+ for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
+ // Keep track of which blocks need to be instrumented. We don't want to
+ // instrument blocks that are added as the result of breaking critical
+ // edges!
+ BlocksToInstrument.insert(BB);
+ NumEdges += BB->getTerminator()->getNumSuccessors();
+ }
+
+ const Type *ATy = ArrayType::get(Type::UIntTy, NumEdges);
+ GlobalVariable *Counters =
+ new GlobalVariable(ATy, false, GlobalValue::InternalLinkage,
+ Constant::getNullValue(ATy), "EdgeProfCounters", &M);
+
+ ConstantPointerRef *CounterCPR = ConstantPointerRef::get(Counters);
+
+ // Instrument all of the edges...
+ unsigned i = 0;
+ for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F)
+ for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
+ if (BlocksToInstrument.count(BB)) { // Don't instrument inserted blocks
+ // Okay, we have to add a counter of each outgoing edge. If the
+ // outgoing edge is not critical don't split it, just insert the counter
+ // in the source or destination of the edge.
+ TerminatorInst *TI = BB->getTerminator();
+ for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
+ // If the edge is critical, split it.
+ SplitCriticalEdge(TI, s, this);
+
+ // Okay, we are guaranteed that the edge is no longer critical. If we
+ // only have a single successor, insert the counter in this block,
+ // otherwise insert it in the successor block.
+ if (TI->getNumSuccessors() == 0) {
+ // Insert counter at the start of the block
+ IncrementCounterInBlock(BB, i++, CounterCPR);
+ } else {
+ // Insert counter at the start of the block
+ IncrementCounterInBlock(TI->getSuccessor(s), i++, CounterCPR);
+ }
+ }
+ }
+
+ // Add the initialization call to main.
+ InsertProfilingInitCall(Main, "llvm_start_edge_profiling", Counters);
+ return true;
+ }
+
Index: llvm/lib/Transforms/Instrumentation/ProfilingUtils.cpp
diff -c /dev/null llvm/lib/Transforms/Instrumentation/ProfilingUtils.cpp:1.1.2.1
*** /dev/null Wed Mar 10 19:34:31 2004
--- llvm/lib/Transforms/Instrumentation/ProfilingUtils.cpp Wed Mar 10 19:34:21 2004
***************
*** 0 ****
--- 1,102 ----
+ //===- ProfilingUtils.cpp - Helper functions shared by profilers ----------===//
+ //
+ // The LLVM Compiler Infrastructure
+ //
+ // This file was developed by the LLVM research group and is distributed under
+ // the University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This files implements a few helper functions which are used by profile
+ // instrumentation code to instrument the code. This allows the profiler pass
+ // to worry about *what* to insert, and these functions take care of *how* to do
+ // it.
+ //
+ //===----------------------------------------------------------------------===//
+
+ #include "ProfilingUtils.h"
+ #include "llvm/Constants.h"
+ #include "llvm/DerivedTypes.h"
+ #include "llvm/Instructions.h"
+ #include "llvm/Module.h"
+
+ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
+ GlobalValue *Array) {
+ const Type *ArgVTy = PointerType::get(PointerType::get(Type::SByteTy));
+ const Type *UIntPtr = PointerType::get(Type::UIntTy);
+ Module &M = *MainFn->getParent();
+ Function *InitFn = M.getOrInsertFunction(FnName, Type::IntTy, Type::IntTy,
+ ArgVTy, UIntPtr, Type::UIntTy, 0);
+
+ // This could force argc and argv into programs that wouldn't otherwise have
+ // them, but instead we just pass null values in.
+ std::vector<Value*> Args(4);
+ Args[0] = Constant::getNullValue(Type::IntTy);
+ Args[1] = Constant::getNullValue(ArgVTy);
+
+ // Skip over any allocas in the entry block.
+ BasicBlock *Entry = MainFn->begin();
+ BasicBlock::iterator InsertPos = Entry->begin();
+ while (isa<AllocaInst>(InsertPos)) ++InsertPos;
+
+ ConstantPointerRef *ArrayCPR = ConstantPointerRef::get(Array);
+ std::vector<Constant*> GEPIndices(2, Constant::getNullValue(Type::LongTy));
+ Args[2] = ConstantExpr::getGetElementPtr(ArrayCPR, GEPIndices);
+
+ unsigned NumElements =
+ cast<ArrayType>(Array->getType()->getElementType())->getNumElements();
+ Args[3] = ConstantUInt::get(Type::UIntTy, NumElements);
+
+ Instruction *InitCall = new CallInst(InitFn, Args, "newargc", InsertPos);
+
+ // If argc or argv are not available in main, just pass null values in.
+ Function::aiterator AI;
+ switch (MainFn->asize()) {
+ default:
+ case 2:
+ AI = MainFn->abegin(); ++AI;
+ if (AI->getType() != ArgVTy) {
+ InitCall->setOperand(2, new CastInst(AI, ArgVTy, "argv.cast", InitCall));
+ } else {
+ InitCall->setOperand(2, AI);
+ }
+
+ case 1:
+ AI = MainFn->abegin();
+ // If the program looked at argc, have it look at the return value of the
+ // init call instead.
+ if (AI->getType() != Type::IntTy) {
+ if (!AI->use_empty())
+ AI->replaceAllUsesWith(new CastInst(InitCall, AI->getType(), "",
+ InsertPos));
+ InitCall->setOperand(1, new CastInst(AI, Type::IntTy, "argc.cast",
+ InitCall));
+ } else {
+ AI->replaceAllUsesWith(InitCall);
+ InitCall->setOperand(1, AI);
+ }
+
+ case 0: break;
+ }
+ }
+
+ void llvm::IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum,
+ ConstantPointerRef *CounterArray) {
+ // Insert the increment after any alloca or PHI instructions...
+ BasicBlock::iterator InsertPos = BB->begin();
+ while (isa<AllocaInst>(InsertPos) || isa<PHINode>(InsertPos))
+ ++InsertPos;
+
+ // Create the getelementptr constant expression
+ std::vector<Constant*> Indices(2);
+ Indices[0] = Constant::getNullValue(Type::LongTy);
+ Indices[1] = ConstantSInt::get(Type::LongTy, CounterNum);
+ Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices);
+
+ // Load, increment and store the value back.
+ Value *OldVal = new LoadInst(ElementPtr, "OldFuncCounter", InsertPos);
+ Value *NewVal = BinaryOperator::create(Instruction::Add, OldVal,
+ ConstantInt::get(Type::UIntTy, 1),
+ "NewFuncCounter", InsertPos);
+ new StoreInst(NewVal, ElementPtr, InsertPos);
+ }
Index: llvm/lib/Transforms/Instrumentation/ProfilingUtils.h
diff -c /dev/null llvm/lib/Transforms/Instrumentation/ProfilingUtils.h:1.1.2.1
*** /dev/null Wed Mar 10 19:34:31 2004
--- llvm/lib/Transforms/Instrumentation/ProfilingUtils.h Wed Mar 10 19:34:21 2004
***************
*** 0 ****
--- 1,32 ----
+ //===- ProfilingUtils.h - Helper functions shared by profilers --*- C++ -*-===//
+ //
+ // The LLVM Compiler Infrastructure
+ //
+ // This file was developed by the LLVM research group and is distributed under
+ // the University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This files defines a few helper functions which are used by profile
+ // instrumentation code to instrument the code. This allows the profiler pass
+ // to worry about *what* to insert, and these functions take care of *how* to do
+ // it.
+ //
+ //===----------------------------------------------------------------------===//
+
+ #ifndef PROFILINGUTILS_H
+ #define PROFILINGUTILS_H
+
+ namespace llvm {
+ class Function;
+ class GlobalValue;
+ class ConstantPointerRef;
+ class BasicBlock;
+
+ void InsertProfilingInitCall(Function *MainFn, const char *FnName,
+ GlobalValue *Arr);
+ void IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum,
+ ConstantPointerRef *CounterArray);
+ }
+
+ #endif
Index: llvm/lib/Transforms/Instrumentation/BlockProfiling.cpp
diff -u llvm/lib/Transforms/Instrumentation/BlockProfiling.cpp:1.5.2.1 llvm/lib/Transforms/Instrumentation/BlockProfiling.cpp:1.5.2.2
--- llvm/lib/Transforms/Instrumentation/BlockProfiling.cpp:1.5.2.1 Mon Mar 1 17:58:16 2004
+++ llvm/lib/Transforms/Instrumentation/BlockProfiling.cpp Wed Mar 10 19:34:21 2004
@@ -21,93 +21,11 @@
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
-#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/Pass.h"
+#include "ProfilingUtils.h"
using namespace llvm;
-static void insertInitializationCall(Function *MainFn, const char *FnName,
- GlobalValue *Array) {
- const Type *ArgVTy = PointerType::get(PointerType::get(Type::SByteTy));
- const Type *UIntPtr = PointerType::get(Type::UIntTy);
- Module &M = *MainFn->getParent();
- Function *InitFn = M.getOrInsertFunction(FnName, Type::IntTy, Type::IntTy,
- ArgVTy, UIntPtr, Type::UIntTy, 0);
-
- // This could force argc and argv into programs that wouldn't otherwise have
- // them, but instead we just pass null values in.
- std::vector<Value*> Args(4);
- Args[0] = Constant::getNullValue(Type::IntTy);
- Args[1] = Constant::getNullValue(ArgVTy);
-
- // Skip over any allocas in the entry block.
- BasicBlock *Entry = MainFn->begin();
- BasicBlock::iterator InsertPos = Entry->begin();
- while (isa<AllocaInst>(InsertPos)) ++InsertPos;
-
- ConstantPointerRef *ArrayCPR = ConstantPointerRef::get(Array);
- std::vector<Constant*> GEPIndices(2, Constant::getNullValue(Type::LongTy));
- Args[2] = ConstantExpr::getGetElementPtr(ArrayCPR, GEPIndices);
-
- unsigned NumElements =
- cast<ArrayType>(Array->getType()->getElementType())->getNumElements();
- Args[3] = ConstantUInt::get(Type::UIntTy, NumElements);
-
- Instruction *InitCall = new CallInst(InitFn, Args, "newargc", InsertPos);
-
- // If argc or argv are not available in main, just pass null values in.
- Function::aiterator AI;
- switch (MainFn->asize()) {
- default:
- case 2:
- AI = MainFn->abegin(); ++AI;
- if (AI->getType() != ArgVTy) {
- InitCall->setOperand(2, new CastInst(AI, ArgVTy, "argv.cast", InitCall));
- } else {
- InitCall->setOperand(2, AI);
- }
-
- case 1:
- AI = MainFn->abegin();
- // If the program looked at argc, have it look at the return value of the
- // init call instead.
- if (AI->getType() != Type::IntTy) {
- if (!AI->use_empty())
- AI->replaceAllUsesWith(new CastInst(InitCall, AI->getType(), "",
- InsertPos));
- InitCall->setOperand(1, new CastInst(AI, Type::IntTy, "argc.cast",
- InitCall));
- } else {
- AI->replaceAllUsesWith(InitCall);
- InitCall->setOperand(1, AI);
- }
-
- case 0: break;
- }
-}
-
-static void IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum,
- ConstantPointerRef *CounterArray) {
- // Insert the increment after any alloca or PHI instructions...
- BasicBlock::iterator InsertPos = BB->begin();
- while (isa<AllocaInst>(InsertPos) || isa<PHINode>(InsertPos))
- ++InsertPos;
-
- // Create the getelementptr constant expression
- std::vector<Constant*> Indices(2);
- Indices[0] = Constant::getNullValue(Type::LongTy);
- Indices[1] = ConstantSInt::get(Type::LongTy, CounterNum);
- Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices);
-
- // Load, increment and store the value back.
- Value *OldVal = new LoadInst(ElementPtr, "OldFuncCounter", InsertPos);
- Value *NewVal = BinaryOperator::create(Instruction::Add, OldVal,
- ConstantInt::get(Type::UIntTy, 1),
- "NewFuncCounter", InsertPos);
- new StoreInst(NewVal, ElementPtr, InsertPos);
-}
-
-
namespace {
class FunctionProfiler : public Pass {
bool run(Module &M);
@@ -145,7 +63,7 @@
IncrementCounterInBlock(I->begin(), i++, CounterCPR);
// Add the initialization call to main.
- insertInitializationCall(Main, "llvm_start_func_profiling", Counters);
+ InsertProfilingInitCall(Main, "llvm_start_func_profiling", Counters);
return true;
}
@@ -186,7 +104,7 @@
IncrementCounterInBlock(BB, i++, CounterCPR);
// Add the initialization call to main.
- insertInitializationCall(Main, "llvm_start_block_profiling", Counters);
+ InsertProfilingInitCall(Main, "llvm_start_block_profiling", Counters);
return true;
}
Index: llvm/lib/Transforms/Instrumentation/EmitFunctions.cpp
diff -u llvm/lib/Transforms/Instrumentation/EmitFunctions.cpp:1.14.4.1 llvm/lib/Transforms/Instrumentation/EmitFunctions.cpp:1.14.4.2
--- llvm/lib/Transforms/Instrumentation/EmitFunctions.cpp:1.14.4.1 Mon Mar 1 17:58:16 2004
+++ llvm/lib/Transforms/Instrumentation/EmitFunctions.cpp Wed Mar 10 19:34:21 2004
@@ -7,7 +7,9 @@
//
//===----------------------------------------------------------------------===//
//
-// This inserts a global constant table with function pointers all along
+// This inserts a global constant table with function pointers all along.
+//
+// NOTE: This pass is used by the reoptimizer only.
//
//===----------------------------------------------------------------------===//
@@ -16,24 +18,24 @@
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Support/CFG.h"
-
-namespace llvm {
-
-enum Color{
- WHITE,
- GREY,
- BLACK
-};
+using namespace llvm;
namespace {
+ enum Color{
+ WHITE,
+ GREY,
+ BLACK
+ };
+
struct EmitFunctionTable : public Pass {
bool run(Module &M);
};
- RegisterOpt<EmitFunctionTable> X("emitfuncs", "Emit a Function Table");
+ RegisterOpt<EmitFunctionTable>
+ X("emitfuncs", "Emit a function table for the reoptimizer");
}
-char doDFS(BasicBlock * node,std::map<BasicBlock *, Color > &color){
+static char doDFS(BasicBlock * node,std::map<BasicBlock *, Color > &color){
color[node] = GREY;
for(succ_iterator vl = succ_begin(node), ve = succ_end(node); vl != ve; ++vl){
@@ -56,7 +58,7 @@
return 1;
}
-char hasBackEdge(Function *F){
+static char hasBackEdge(Function *F){
std::map<BasicBlock *, Color > color;
return doDFS(F->begin(), color);
}
@@ -106,5 +108,3 @@
M.getGlobalList().push_back(fnCount);
return true; // Always modifies program
}
-
-} // End llvm namespace
More information about the llvm-commits
mailing list