From e5d6dab09e7e1dfaba1a8c51aff9bfbc1fdbffc0 Mon Sep 17 00:00:00 2001 From: Misha Brukman Date: Tue, 22 Jun 2004 18:11:38 +0000 Subject: [PATCH] File depends on DSA, moved to lib/Analysis/DataStructure git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14325 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/IPO/Parallelize.cpp | 495 ----------------------------- 1 file changed, 495 deletions(-) delete mode 100644 lib/Transforms/IPO/Parallelize.cpp diff --git a/lib/Transforms/IPO/Parallelize.cpp b/lib/Transforms/IPO/Parallelize.cpp deleted file mode 100644 index 46bb72f836e..00000000000 --- a/lib/Transforms/IPO/Parallelize.cpp +++ /dev/null @@ -1,495 +0,0 @@ -//===- Parallelize.cpp - Auto parallelization using DS Graphs -------------===// -// -// 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 file implements a pass that automatically parallelizes a program, -// using the Cilk multi-threaded runtime system to execute parallel code. -// -// The pass uses the Program Dependence Graph (class PDGIterator) to -// identify parallelizable function calls, i.e., calls whose instances -// can be executed in parallel with instances of other function calls. -// (In the future, this should also execute different instances of the same -// function call in parallel, but that requires parallelizing across -// loop iterations.) -// -// The output of the pass is LLVM code with: -// (1) all parallelizable functions renamed to flag them as parallelizable; -// (2) calls to a sync() function introduced at synchronization points. -// The CWriter recognizes these functions and inserts the appropriate Cilk -// keywords when writing out C code. This C code must be compiled with cilk2c. -// -// Current algorithmic limitations: -// -- no array dependence analysis -// -- no parallelization for function calls in different loop iterations -// (except in unlikely trivial cases) -// -// Limitations of using Cilk: -// -- No parallelism within a function body, e.g., in a loop; -// -- Simplistic synchronization model requiring all parallel threads -// created within a function to block at a sync(). -// -- Excessive overhead at "spawned" function calls, which has no benefit -// once all threads are busy (especially common when the degree of -// parallelism is low). -// -//===----------------------------------------------------------------------===// - -#include "llvm/DerivedTypes.h" -#include "llvm/Instructions.h" -#include "llvm/Module.h" -#include "llvm/Analysis/PgmDependenceGraph.h" -#include "llvm/Analysis/DataStructure.h" -#include "llvm/Analysis/DSGraph.h" -#include "llvm/Support/InstVisitor.h" -#include "llvm/Transforms/Utils/Local.h" -#include "Support/Statistic.h" -#include "Support/STLExtras.h" -#include "Support/hash_set" -#include "Support/hash_map" -#include -#include -using namespace llvm; - -//---------------------------------------------------------------------------- -// Global constants used in marking Cilk functions and function calls. -//---------------------------------------------------------------------------- - -static const char * const CilkSuffix = ".llvm2cilk"; -static const char * const DummySyncFuncName = "__sync.llvm2cilk"; - -//---------------------------------------------------------------------------- -// Routines to identify Cilk functions, calls to Cilk functions, and syncs. -//---------------------------------------------------------------------------- - -static bool isCilk(const Function& F) { - return (F.getName().rfind(CilkSuffix) == - F.getName().size() - std::strlen(CilkSuffix)); -} - -static bool isCilkMain(const Function& F) { - return F.getName() == "main" + std::string(CilkSuffix); -} - - -static bool isCilk(const CallInst& CI) { - return CI.getCalledFunction() && isCilk(*CI.getCalledFunction()); -} - -static bool isSync(const CallInst& CI) { - return CI.getCalledFunction() && - CI.getCalledFunction()->getName() == DummySyncFuncName; -} - - -//---------------------------------------------------------------------------- -// class Cilkifier -// -// Code generation pass that transforms code to identify where Cilk keywords -// should be inserted. This relies on `llvm-dis -c' to print out the keywords. -//---------------------------------------------------------------------------- -class Cilkifier: public InstVisitor { - Function* DummySyncFunc; - - // Data used when transforming each function. - hash_set stmtsVisited; // Flags for recursive DFS - hash_map > spawnToSyncsMap; - - // Input data for the transformation. - const hash_set* cilkFunctions; // Set of parallel functions - PgmDependenceGraph* depGraph; - - void DFSVisitInstr (Instruction* I, - Instruction* root, - hash_set& depsOfRoot); - -public: - /*ctor*/ Cilkifier (Module& M); - - // Transform a single function including its name, its call sites, and syncs - // - void TransformFunc (Function* F, - const hash_set& cilkFunctions, - PgmDependenceGraph& _depGraph); - - // The visitor function that does most of the hard work, via DFSVisitInstr - // - void visitCallInst(CallInst& CI); -}; - - -Cilkifier::Cilkifier(Module& M) { - // create the dummy Sync function and add it to the Module - DummySyncFunc = M.getOrInsertFunction(DummySyncFuncName, Type::VoidTy, 0); -} - -void Cilkifier::TransformFunc(Function* F, - const hash_set& _cilkFunctions, - PgmDependenceGraph& _depGraph) { - // Memoize the information for this function - cilkFunctions = &_cilkFunctions; - depGraph = &_depGraph; - - // Add the marker suffix to the Function name - // This should automatically mark all calls to the function also! - F->setName(F->getName() + CilkSuffix); - - // Insert sync operations for each separate spawn - visit(*F); - - // Now traverse the CFG in rPostorder and eliminate redundant syncs, i.e., - // two consecutive sync's on a straight-line path with no intervening spawn. - -} - - -void Cilkifier::DFSVisitInstr(Instruction* I, - Instruction* root, - hash_set& depsOfRoot) -{ - assert(stmtsVisited.find(I) == stmtsVisited.end()); - stmtsVisited.insert(I); - - // If there is a dependence from root to I, insert Sync and return - if (depsOfRoot.find(I) != depsOfRoot.end()) { - // Insert a sync before I and stop searching along this path. - // If I is a Phi instruction, the dependence can only be an SSA dep. - // and we need to insert the sync in the predecessor on the appropriate - // incoming edge! - CallInst* syncI = 0; - if (PHINode* phiI = dyn_cast(I)) { - // check all operands of the Phi and insert before each one - for (unsigned i = 0, N = phiI->getNumIncomingValues(); i < N; ++i) - if (phiI->getIncomingValue(i) == root) - syncI = new CallInst(DummySyncFunc, std::vector(), "", - phiI->getIncomingBlock(i)->getTerminator()); - } else - syncI = new CallInst(DummySyncFunc, std::vector(), "", I); - - // Remember the sync for each spawn to eliminate redundant ones later - spawnToSyncsMap[cast(root)].insert(syncI); - - return; - } - - // else visit unvisited successors - if (BranchInst* brI = dyn_cast(I)) { - // visit first instruction in each successor BB - for (unsigned i = 0, N = brI->getNumSuccessors(); i < N; ++i) - if (stmtsVisited.find(&brI->getSuccessor(i)->front()) - == stmtsVisited.end()) - DFSVisitInstr(&brI->getSuccessor(i)->front(), root, depsOfRoot); - } else - if (Instruction* nextI = I->getNext()) - if (stmtsVisited.find(nextI) == stmtsVisited.end()) - DFSVisitInstr(nextI, root, depsOfRoot); -} - - -void Cilkifier::visitCallInst(CallInst& CI) -{ - assert(CI.getCalledFunction() != 0 && "Only direct calls can be spawned."); - if (cilkFunctions->find(CI.getCalledFunction()) == cilkFunctions->end()) - return; // not a spawn - - // Find all the outgoing memory dependences. - hash_set depsOfRoot; - for (PgmDependenceGraph::iterator DI = - depGraph->outDepBegin(CI, MemoryDeps); ! DI.fini(); ++DI) - depsOfRoot.insert(&DI->getSink()->getInstr()); - - // Now find all outgoing SSA dependences to the eventual non-Phi users of - // the call value (i.e., direct users that are not phis, and for any - // user that is a Phi, direct non-Phi users of that Phi, and recursively). - std::vector phiUsers; - hash_set phisSeen; // ensures we don't visit a phi twice - for (Value::use_iterator UI=CI.use_begin(), UE=CI.use_end(); UI != UE; ++UI) - if (const PHINode* phiUser = dyn_cast(*UI)) { - if (phisSeen.find(phiUser) == phisSeen.end()) { - phiUsers.push_back(phiUser); - phisSeen.insert(phiUser); - } - } - else - depsOfRoot.insert(cast(*UI)); - - // Now we've found the non-Phi users and immediate phi users. - // Recursively walk the phi users and add their non-phi users. - for (const PHINode* phiUser; !phiUsers.empty(); phiUsers.pop_back()) { - phiUser = phiUsers.back(); - for (Value::use_const_iterator UI=phiUser->use_begin(), - UE=phiUser->use_end(); UI != UE; ++UI) - if (const PHINode* pn = dyn_cast(*UI)) { - if (phisSeen.find(pn) == phisSeen.end()) { - phiUsers.push_back(pn); - phisSeen.insert(pn); - } - } else - depsOfRoot.insert(cast(*UI)); - } - - // Walk paths of the CFG starting at the call instruction and insert - // one sync before the first dependence on each path, if any. - if (! depsOfRoot.empty()) { - stmtsVisited.clear(); // start a new DFS for this CallInst - assert(CI.getNext() && "Call instruction cannot be a terminator!"); - DFSVisitInstr(CI.getNext(), &CI, depsOfRoot); - } - - // Now, eliminate all users of the SSA value of the CallInst, i.e., - // if the call instruction returns a value, delete the return value - // register and replace it by a stack slot. - if (CI.getType() != Type::VoidTy) - DemoteRegToStack(CI); -} - - -//---------------------------------------------------------------------------- -// class FindParallelCalls -// -// Find all CallInst instructions that have at least one other CallInst -// that is independent. These are the instructions that can produce -// useful parallelism. -//---------------------------------------------------------------------------- - -class FindParallelCalls : public InstVisitor { - typedef hash_set DependentsSet; - typedef DependentsSet::iterator Dependents_iterator; - typedef DependentsSet::const_iterator Dependents_const_iterator; - - PgmDependenceGraph& depGraph; // dependence graph for the function - hash_set stmtsVisited; // flags for DFS walk of depGraph - hash_map completed; // flags marking if a CI is done - hash_map dependents; // dependent CIs for each CI - - void VisitOutEdges(Instruction* I, - CallInst* root, - DependentsSet& depsOfRoot); - - FindParallelCalls(const FindParallelCalls &); // DO NOT IMPLEMENT - void operator=(const FindParallelCalls&); // DO NOT IMPLEMENT -public: - std::vector parallelCalls; - -public: - /*ctor*/ FindParallelCalls (Function& F, PgmDependenceGraph& DG); - void visitCallInst (CallInst& CI); -}; - - -FindParallelCalls::FindParallelCalls(Function& F, - PgmDependenceGraph& DG) - : depGraph(DG) -{ - // Find all CallInsts reachable from each CallInst using a recursive DFS - visit(F); - - // Now we've found all CallInsts reachable from each CallInst. - // Find those CallInsts that are parallel with at least one other CallInst - // by counting total inEdges and outEdges. - unsigned long totalNumCalls = completed.size(); - - if (totalNumCalls == 1) { - // Check first for the special case of a single call instruction not - // in any loop. It is not parallel, even if it has no dependences - // (this is why it is a special case). - // - // FIXME: - // THIS CASE IS NOT HANDLED RIGHT NOW, I.E., THERE IS NO - // PARALLELISM FOR CALLS IN DIFFERENT ITERATIONS OF A LOOP. - return; - } - - hash_map numDeps; - for (hash_map::iterator II = dependents.begin(), - IE = dependents.end(); II != IE; ++II) { - CallInst* fromCI = II->first; - numDeps[fromCI] += II->second.size(); - for (Dependents_iterator DI = II->second.begin(), DE = II->second.end(); - DI != DE; ++DI) - numDeps[*DI]++; // *DI can be reached from II->first - } - - for (hash_map::iterator - II = dependents.begin(), IE = dependents.end(); II != IE; ++II) - - // FIXME: Remove "- 1" when considering parallelism in loops - if (numDeps[II->first] < totalNumCalls - 1) - parallelCalls.push_back(II->first); -} - - -void FindParallelCalls::VisitOutEdges(Instruction* I, - CallInst* root, - DependentsSet& depsOfRoot) -{ - assert(stmtsVisited.find(I) == stmtsVisited.end() && "Stmt visited twice?"); - stmtsVisited.insert(I); - - if (CallInst* CI = dyn_cast(I)) - // FIXME: Ignoring parallelism in a loop. Here we're actually *ignoring* - // a self-dependence in order to get the count comparison right above. - // When we include loop parallelism, self-dependences should be included. - if (CI != root) { - // CallInst root has a path to CallInst I and any calls reachable from I - depsOfRoot.insert(CI); - if (completed[CI]) { - // We have already visited I so we know all nodes it can reach! - DependentsSet& depsOfI = dependents[CI]; - depsOfRoot.insert(depsOfI.begin(), depsOfI.end()); - return; - } - } - - // If we reach here, we need to visit all children of I - for (PgmDependenceGraph::iterator DI = depGraph.outDepBegin(*I); - ! DI.fini(); ++DI) { - Instruction* sink = &DI->getSink()->getInstr(); - if (stmtsVisited.find(sink) == stmtsVisited.end()) - VisitOutEdges(sink, root, depsOfRoot); - } -} - - -void FindParallelCalls::visitCallInst(CallInst& CI) { - if (completed[&CI]) - return; - stmtsVisited.clear(); // clear flags to do a fresh DFS - - // Visit all children of CI using a recursive walk through dep graph - DependentsSet& depsOfRoot = dependents[&CI]; - for (PgmDependenceGraph::iterator DI = depGraph.outDepBegin(CI); - ! DI.fini(); ++DI) { - Instruction* sink = &DI->getSink()->getInstr(); - if (stmtsVisited.find(sink) == stmtsVisited.end()) - VisitOutEdges(sink, &CI, depsOfRoot); - } - - completed[&CI] = true; -} - - -//---------------------------------------------------------------------------- -// class Parallelize -// -// (1) Find candidate parallel functions: any function F s.t. -// there is a call C1 to the function F that is followed or preceded -// by at least one other call C2 that is independent of this one -// (i.e., there is no dependence path from C1 to C2 or C2 to C1) -// (2) Label such a function F as a cilk function. -// (3) Convert every call to F to a spawn -// (4) For every function X, insert sync statements so that -// every spawn is postdominated by a sync before any statements -// with a data dependence to/from the call site for the spawn -// -//---------------------------------------------------------------------------- - -namespace { - class Parallelize: public Pass { - public: - /// Driver functions to transform a program - /// - bool run(Module& M); - - /// getAnalysisUsage - Modifies extensively so preserve nothing. - /// Uses the DependenceGraph and the Top-down DS Graph (only to find - /// all functions called via an indirect call). - /// - void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired(); - AU.addRequired(); // force this not to be released - AU.addRequired(); // because it is needed by this - } - }; - - RegisterOpt X("parallel", "Parallelize program using Cilk"); -} - - -bool Parallelize::run(Module& M) { - hash_set parallelFunctions; - hash_set safeParallelFunctions; - hash_set indirectlyCalled; - - // If there is no main (i.e., for an incomplete program), we can do nothing. - // If there is a main, mark main as a parallel function. - Function* mainFunc = M.getMainFunction(); - if (!mainFunc) - return false; - - // (1) Find candidate parallel functions and mark them as Cilk functions - for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI) - if (! FI->isExternal()) { - Function* F = FI; - DSGraph& tdg = getAnalysis().getDSGraph(*F); - - // All the hard analysis work gets done here! - FindParallelCalls finder(*F, - getAnalysis().getGraph(*F)); - /* getAnalysis().getGraph(*F)); */ - - // Now we know which call instructions are useful to parallelize. - // Remember those callee functions. - for (std::vector::iterator - CII = finder.parallelCalls.begin(), - CIE = finder.parallelCalls.end(); CII != CIE; ++CII) { - // Check if this is a direct call... - if ((*CII)->getCalledFunction() != NULL) { - // direct call: if this is to a non-external function, - // mark it as a parallelizable function - if (! (*CII)->getCalledFunction()->isExternal()) - parallelFunctions.insert((*CII)->getCalledFunction()); - } else { - // Indirect call: mark all potential callees as bad - std::vector callees = - tdg.getNodeForValue((*CII)->getCalledValue()) - .getNode()->getGlobals(); - indirectlyCalled.insert(callees.begin(), callees.end()); - } - } - } - - // Remove all indirectly called functions from the list of Cilk functions. - for (hash_set::iterator PFI = parallelFunctions.begin(), - PFE = parallelFunctions.end(); PFI != PFE; ++PFI) - if (indirectlyCalled.count(*PFI) == 0) - safeParallelFunctions.insert(*PFI); - -#undef CAN_USE_BIND1ST_ON_REFERENCE_TYPE_ARGS -#ifdef CAN_USE_BIND1ST_ON_REFERENCE_TYPE_ARGS - // Use this indecipherable STLese because erase invalidates iterators. - // Otherwise we have to copy sets as above. - hash_set::iterator extrasBegin = - std::remove_if(parallelFunctions.begin(), parallelFunctions.end(), - compose1(std::bind2nd(std::greater(), 0), - bind_obj(&indirectlyCalled, - &hash_set::count))); - parallelFunctions.erase(extrasBegin, parallelFunctions.end()); -#endif - - // If there are no parallel functions, we can just give up. - if (safeParallelFunctions.empty()) - return false; - - // Add main as a parallel function since Cilk requires this. - safeParallelFunctions.insert(mainFunc); - - // (2,3) Transform each Cilk function and all its calls simply by - // adding a unique suffix to the function name. - // This should identify both functions and calls to such functions - // to the code generator. - // (4) Also, insert calls to sync at appropriate points. - Cilkifier cilkifier(M); - for (hash_set::iterator CFI = safeParallelFunctions.begin(), - CFE = safeParallelFunctions.end(); CFI != CFE; ++CFI) { - cilkifier.TransformFunc(*CFI, safeParallelFunctions, - getAnalysis().getGraph(**CFI)); - /* getAnalysis().getGraph(**CFI)); */ - } - - return true; -} -