//===- Parallelize.cpp - Auto parallelization using DS Graphs ---*- C++ -*-===// // // 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/Transforms/Parallelize.h" #include "llvm/Transforms/Utils/DemoteRegToStack.h" #include "llvm/Analysis/PgmDependenceGraph.h" #include "llvm/Analysis/Dominators.h" #include "llvm/Analysis/DataStructure.h" #include "llvm/Analysis/DSGraph.h" #include "llvm/Module.h" #include "llvm/Function.h" #include "llvm/iOther.h" #include "llvm/iPHINode.h" #include "llvm/iTerminators.h" #include "llvm/DerivedTypes.h" #include "llvm/Support/InstVisitor.h" #include "llvm/Support/Cilkifier.h" #include "Support/NonCopyable.h" #include "Support/Statistic.h" #include "Support/STLExtras.h" #include "Support/hash_set" #include "Support/hash_map" #include #include #include #include #if 0 void AddToDomSet(vector& domSet, BasicBlock* bb, const DominatorTree& domTree) { DominatorTreeBase::Node* bbNode = domTree.getNode(bb); const std::vector& domKids = bbNode.getChildren(); domSet.insert(domSet.end(), domKids.begin(), domKids.end()); for (unsigned i = 0; i < domKids.size(); ++i) AddToDomSet(domSet, domKids[i]->getNode(), domTree); } bool CheckDominance(Function& func, const CallInst& callInst1, const CallInst& callInst2) { if (callInst1 == callInst2) // makes sense if this is in a loop but return false; // we're not handling loops yet // Check first if one call dominates the other DominatorSet& domSet = getAnalysis(func); if (domSet.dominates(callInst2, callInst1)) { // swap callInst1 and callInst2 const CallInst& tmp = callInst2; callInst2 = callInst1; callInst1 = tmp; } else if (! domSet.dominates(callInst1, callInst2)) return false; // neither dominates the other: // if (! AreIndependent(func, callInst1, callInst2)) return false; } #endif //---------------------------------------------------------------------------- // class Cilkifier // // Code generation pass that transforms code to identify where Cilk keywords // should be inserted. This relies on 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 = new Function(FunctionType::get( Type::VoidTy, std::vector(), /*isVararg*/ false), /*isInternal*/ false, DummySyncFuncName, &M); } 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 rendundant 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::stack 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(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()) { phiUser = phiUsers.top(); 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(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, public NonCopyable { 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); 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"); } static Function* FindMain(Module& M) { for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI) if (FI->getName() == std::string("main")) return FI; return NULL; } 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 = FindMain(M); 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 undecipherable 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; }