feat(optimizer): graph pruning

.github/workflows/tests/profiler.sh

@@ -20,11 +20,14 @@ TARGET_NAME=$1
 PASS_NAME=$2
 
 function test_discopopPass {
-  cp ${DISCOPOP_SRC}/scripts/dp-fmap .
-  ./dp-fmap
-  clang++ -g -c -O0 -S -emit-llvm -fno-discard-value-names "$1" -o out.ll || return 1
-  opt-11 -S -load=${DISCOPOP_INSTALL}/libi/LLVMDiscoPoP.so --DiscoPoP out.ll -o out_dp.ll || return 1
-  clang++ out_dp.ll -o out_prof -L${DISCOPOP_INSTALL}/rtlib -lDiscoPoP_RT -lpthread || return 1
+   ${DISCOPOP_INSTALL}/scripts/CXX_wrapper.sh "$1" -o out_prof
+
+
+#  cp ${DISCOPOP_SRC}/scripts/dp-fmap .
+#  ./dp-fmap
+#  clang++ -g -c -O0 -S -emit-llvm -fno-discard-value-names "$1" -o out.ll || return 1
+#  opt-11 -S -load=${DISCOPOP_INSTALL}/libi/LLVMDiscoPoP.so --DiscoPoP out.ll -o out_dp.ll || return 1
+#  clang++ out_dp.ll -o out_prof -L${DISCOPOP_INSTALL}/rtlib -lDiscoPoP_RT -lpthread || return 1
   ./out_prof || return 1
 }
 

DiscoPoP/DiscoPoP.cpp

@@ -19,7 +19,8 @@
 #define DP_VERBOSE false  // prints warning messages
 #define DP_hybrid_DEBUG false
 #define DP_hybrid_SKIP false  //todo add parameter to disable hybrid dependence analysis on demand.
-
+#define DP_BRANCH_TRACKING true  // toggles the creation of instrumentation calls for tracking taken branches.
+                                 // Required by the graph pruning step of the DiscoPoP optimizer.
 
 using namespace llvm;
 using namespace std;
@@ -105,6 +106,8 @@ void DiscoPoP::setupCallbacks() {
     DpLoopExit = ThisModule->getOrInsertFunction("__dp_loop_exit",
                                                  Void,
                                                  Int32, Int32);
+
+    DpTakenBranchCounterIncr = ThisModule->getOrInsertFunction("__dp_incr_taken_branch_counter", Void, CharPtr, Int32, Int32);
 }
 
 bool DiscoPoP::doInitialization(Module &M) {
@@ -258,7 +261,6 @@ bool DiscoPoP::doFinalization(Module &M) {
     }
 
     // DPInstrumentationOmission end
-
     return true;
 }
 
@@ -451,6 +453,48 @@ void DiscoPoP::populateGlobalVariablesSet(Region *TopRegion,
     }
 }
 
+
+void DiscoPoP::createTakenBranchInstrumentation(Region* TopRegion, map <string, vector<CU *>> &BBIDToCUIDsMap){
+    /* Create calls to count taken branches inbetween CUs during execution */
+    for (Region::block_iterator bb = TopRegion->block_begin();
+         bb != TopRegion->block_end(); ++bb) {
+        for (BasicBlock::iterator instruction = (*bb)->begin();
+            instruction != (*bb)->end(); ++instruction) {
+            if(isa<BranchInst>(instruction)){
+                BranchInst* branchInst = cast<BranchInst>(instruction);
+                // check for conditional branches, as unconditional ones can be ignored for counting
+                if(! branchInst->isUnconditional()){
+                    // branchInst is conditional
+                    // prepare IRBuilder to insert instrumentation
+                    IRBuilder<> IRB(branchInst);
+                    // get BBId and CU IDS of the source 
+                    string source_BBID = bb->getName().str();
+                    for(auto source_cu : BBIDToCUIDsMap[source_BBID]){
+                        // get BBIds of all targets
+                        for(int i = 0; i < branchInst->getNumSuccessors(); i++){
+                            string successor_BBID = branchInst->getSuccessor(i)->getName().str();
+                            // get CUs of all targets
+                            for(auto target_cu : BBIDToCUIDsMap[successor_BBID]){
+                                // add instrumentation prior to the branch instruction
+                                vector<Value*> args;
+                                string source_and_target = source_cu->ID + ";" + target_cu->ID;
+                                args.push_back(getOrInsertVarName_dynamic(source_and_target, IRB));
+                                args.push_back(branchInst->getCondition());
+                                bool counter_active_on_cmp_value = (i == 0 ? 1 : 0);
+                                args.push_back(ConstantInt::get(Int32, counter_active_on_cmp_value));
+                                IRB.CreateCall(DpTakenBranchCounterIncr, args);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+
+
 void DiscoPoP::createCUs(Region *TopRegion, set <string> &globalVariablesSet,
                          vector<CU *> &CUVector,
                          map <string, vector<CU *>> &BBIDToCUIDsMap,
@@ -1889,13 +1933,17 @@ void DiscoPoP::dp_reduction_insert_functions() {
     llvm::FunctionType* output_fn_type =
             llvm::FunctionType::get(llvm::Type::getVoidTy(*ctx_), false);
     FunctionCallee loop_counter_output_callee = module_->getOrInsertFunction("loop_counter_output", output_fn_type);
+    FunctionCallee cu_taken_branch_counter_output_callee = module_->getOrInsertFunction("__dp_taken_branch_counter_output", output_fn_type);
     llvm::Function* main_fn = module_->getFunction("main");
     if (main_fn) {
         for (auto it = llvm::inst_begin(main_fn); it != llvm::inst_end(main_fn);
              ++it) {
             if (llvm::isa<llvm::ReturnInst>(&(*it))) {
                 llvm::IRBuilder<> ir_builder(&(*it));
                 ir_builder.CreateCall(loop_counter_output_callee);
+                if(DP_BRANCH_TRACKING){
+                    ir_builder.CreateCall(cu_taken_branch_counter_output_callee);
+                }
                 break;
             }
         }
@@ -2087,7 +2135,7 @@ bool DiscoPoP::runOnModule(Module &M) {
 
 bool DiscoPoP::runOnFunction(Function &F) {
     if (DP_DEBUG) {
-        errs() << "pass DiscoPoP: run pass on function\n";
+        errs() << "pass DiscoPoP: run pass on function " << F.getName().str() << "\n";
     }
 
     StringRef funcName = F.getName();
@@ -2173,8 +2221,11 @@ bool DiscoPoP::runOnFunction(Function &F) {
 
         createCUs(TopRegion, globalVariablesSet, CUVector, BBIDToCUIDsMap, root, LI);
 
-        fillCUVariables(TopRegion, globalVariablesSet, CUVector, BBIDToCUIDsMap);
+        if(DP_BRANCH_TRACKING){
+            createTakenBranchInstrumentation(TopRegion, BBIDToCUIDsMap);
+        }
 
+        fillCUVariables(TopRegion, globalVariablesSet, CUVector, BBIDToCUIDsMap);
 
         fillStartEndLineNumbers(root, LI);
 

DiscoPoP/DiscoPoP.hpp

@@ -301,6 +301,7 @@ namespace {
         FunctionCallee DpCallOrInvoke;
         FunctionCallee DpFuncEntry, DpFuncExit;
         FunctionCallee DpLoopEntry, DpLoopExit;
+        FunctionCallee DpTakenBranchCounterIncr;
 
         // Basic types
         Type *Void;
@@ -378,6 +379,8 @@ namespace {
                        map <string, vector<CU *>> &BBIDToCUIDsMap, Node *root,
                        LoopInfo &LI);
 
+        void createTakenBranchInstrumentation(Region* TopRegion, map <string, vector<CU *>> &BBIDToCUIDsMap);
+
         void fillCUVariables(Region *TopRegion, set <string> &globalVariablesSet,
                              vector<CU *> &CUVector,
                              map <string, vector<CU *>> &BBIDToCUIDsMap);

discopop_explorer/pattern_detectors/PatternBase.py

@@ -21,6 +21,7 @@ class PatternBase(object):
     node_id: NodeID
     start_line: LineID
     end_line: LineID
+    applicable_pattern: bool
 
     def __init__(self, node: Node):
         # create a file lock to synchronize processes
@@ -41,6 +42,7 @@ def __init__(self, node: Node):
         self.node_id = node.id
         self.start_line = node.start_position()
         self.end_line = node.end_position()
+        self.applicable_pattern = True
 
     def to_json(self):
         dic = self.__dict__

discopop_library/PatchGenerator/from_json_patterns.py

@@ -34,6 +34,9 @@ def from_json_patterns(
             if suggestion_type == "optimizer_output":
                 from_optimizer_output(file_mapping, patterns_by_type, suggestion, arguments, patch_generator_dir)
                 continue
+            suggestion_dict = json.loads(suggestion)
+            if not suggestion_dict["applicable_pattern"]:
+                continue
             if arguments.verbose:
                 print("Suggestion: ", suggestion)
             file_id_to_modified_code: Dict[int, str] = from_json_strings(