biulding new order

src/SwapOperators/swapOperators.cpp

@@ -80,14 +80,16 @@ map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st
     return result;
 }
 
-map<SgStatement*, unordered_set<SgStatement*>> AnalyzeLoopAndFindDeps(SgForStmt* forStatement, vector<SAPFOR::BasicBlock*> loopBlocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
+map<SgStatement*, set<SgStatement*>> AnalyzeLoopAndFindDeps(SgForStmt* forStatement, vector<SAPFOR::BasicBlock*> loopBlocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {
-    map<SgStatement*, unordered_set<SgStatement*>> result;
+    map<SgStatement*, set<SgStatement*>> result;
     for (SAPFOR::BasicBlock* bb: loopBlocks) {
         std::map<SAPFOR::Argument*, std::set<int>> blockReachingDefinitions = bb -> getRD_In();
         vector<SAPFOR::IR_Block*> instructions = bb -> getInstructions();
         for (SAPFOR::IR_Block* irBlock: instructions) {
+            // TODO: Think about what to do with function calls and array references. Because there are also dependencies there that are not reflected in RD, but they must be taken into account
             SAPFOR::Instruction* instr = irBlock -> getInstruction();
+            result[instr -> getOperator()];
             // take Argument 1 and it's RD and push operators to final set
             if (instr -> getArg1() != NULL) {
                 SAPFOR::Argument* arg = instr -> getArg1();
@@ -122,18 +124,119 @@ map<SgStatement*, unordered_set<SgStatement*>> AnalyzeLoopAndFindDeps(SgForStmt*
     return result;
 }
 
-int RebuildLoop(int firstLine, int lastLine, map<SgStatement*, unordered_set<SgStatement*>> moveRules) {
+// int PrintSmthFromLoop(int firstLine, int lastLine, map<SgStatement*, unordered_set<SgStatement*>> moveRules) {
-    // only cout done yet ((
+//     // only cout done yet ((
-    cout << "LOOP ANALYZE FROM " << firstLine << " TO " << lastLine << " RES\n" << endl;
+//     cout << "LOOP ANALYZE FROM " << firstLine << " TO " << lastLine << " RES\n" << endl;
-    for (auto r: moveRules) {
+//     for (auto r: moveRules) {
-        cout << "OPERATOR: " << endl;
+//         cout << "OPERATOR: " << endl;
-        cout << r.first -> lineNumber() << r.first -> sunparse();
+//         cout << r.first -> lineNumber() << r.first -> sunparse();
-        cout << "DEPENDS FROM NEXT: " << endl;
+//         cout << "DEPENDS FROM NEXT: " << endl;
-        for (SgStatement* st: r.second)
+//         for (SgStatement* st: r.second)
-            cout << st -> lineNumber() << endl;
+//             cout << st -> lineNumber() << endl;
+//     }
+//     cout << "\n\n\n";
+//     return 0;
+// }
+
+void GenNodesOfGraph(
+    const map<SgStatement*, set<SgStatement*>>& dependencies,
+    set<SgStatement*>& allNodes,
+    map<SgStatement*, set<SgStatement*>>& outEdges,
+    map<SgStatement*, set<SgStatement*>>& inEdges)
+{
+    for (const auto& node: dependencies) {
+        SgStatement* u = node.first;
+        allNodes.insert(u);
+        for (SgStatement* v: node.second) {
+            allNodes.insert(v);
+            outEdges[v].insert(u);
+            inEdges[u].insert(v);
+            outEdges[u];
+            inEdges[v];
+        }
+        outEdges[u];
+        inEdges[u];
     }
-    cout << "\n\n\n";
+}
-    return 0;
+
+vector<set<SgStatement*>> FindLinksInGraph(
+    const set<SgStatement*>& allNodes,
+    const map<SgStatement*, set<SgStatement*>>& outEdges,
+    const map<SgStatement*, set<SgStatement*>>& inEdges)
+{
+    set<SgStatement*> visited;
+    vector<std::set<SgStatement*>> components;
+    for (SgStatement* v: allNodes) {
+        if (visited.count(v)) {
+            continue;
+        }
+        set<SgStatement*> component;
+        queue<SgStatement*> q;
+        q.push(v);
+        visited.insert(v);
+
+        while (!q.empty()) {
+            SgStatement* curr = q.front();
+            q.pop();
+            component.insert(curr);
+            for (SgStatement* neighbour: outEdges.at(curr)) {
+                if (!visited.count(neighbour)) {
+                    q.push(neighbour); visited.insert(neighbour);
+                }
+            }
+            for (SgStatement* neighbour: inEdges.at(curr)) {
+                if (!visited.count(neighbour)) {
+                    q.push(neighbour); visited.insert(neighbour);
+                }
+            }
+        }
+        components.push_back(component);
+    }
+    return components;
+}
+
+vector<SgStatement*> SortComponent(
+    const set<SgStatement*>& component,
+    const map<SgStatement*, set<SgStatement*>>& outEdges,
+    const map<SgStatement*, set<SgStatement*>>& inEdges)
+{
+    map<SgStatement*, int> inDegree;
+    for (auto v: component) {
+        inDegree[v] = inEdges.at(v).size();
+    }
+    queue<SgStatement*> q;
+    for (auto v : component) {
+        if (inDegree[v] == 0) q.push(v);
+    }
+    vector<SgStatement*> result;
+    while (!q.empty()) {
+        auto curr = q.front();
+        q.pop();
+        result.push_back(curr);
+        for (SgStatement* neighbour: outEdges.at(curr)) {
+            if (component.count(neighbour)) {
+                inDegree[neighbour]--;
+                if (inDegree[neighbour] == 0) {
+                    q.push(neighbour);
+                }
+            }
+        }
+    }
+    return result;
+}
+
+vector<SgStatement*> SortNoInterleaving(const map<SgStatement*, set<SgStatement*>>& dependencies)
+{
+    set<SgStatement*> allNodes;
+    map<SgStatement*, set<SgStatement*>> outEdges, inEdges;
+    GenNodesOfGraph(dependencies, allNodes, outEdges, inEdges);
+    auto components = FindLinksInGraph(allNodes, outEdges, inEdges);
+    vector<SgStatement*> totalOrder;
+    for (auto& comp : components) {
+        auto part = SortComponent(comp, outEdges, inEdges);
+        totalOrder.insert(totalOrder.end(), part.begin(), part.end());
+    }
+    return totalOrder;
 }
 
 void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform)
@@ -149,11 +252,25 @@ void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*
         map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
         for (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping)
         {
-            map<SgStatement*, unordered_set<SgStatement*>> moveRules = AnalyzeLoopAndFindDeps(loopForAnalyze.first, loopForAnalyze.second, FullIR);
+            map<SgStatement*, set<SgStatement*>> dependencyGraph = AnalyzeLoopAndFindDeps(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-            if (moveRules.size() != 0) {
+            // TODO: Write a function that will go through the operators and update all dependencies so that there are no mix-ups and splits inside the semantic blocks (for if, do and may be some other cases)
+            cout << "\n\n";
+            for (auto v: dependencyGraph) {
+                cout << "OPERATOR: " << v.first -> lineNumber() << "\nDEPENDS ON:" << endl;
+                for (auto vv: v.second) {
+                    cout << vv -> lineNumber() << "  ";
+                }
+                cout << endl;
+            }
+            if (dependencyGraph.size() != 0) {
                 int firstLine = loopForAnalyze.first -> lineNumber();
                 int lastLine = loopForAnalyze.first -> lastNodeOfStmt() -> lineNumber();
-                countOfTransform += RebuildLoop(firstLine, lastLine, moveRules);
+                // countOfTransform += PrintSmthFromLoop(firstLine, lastLine, dependencyGraph);
+                vector<SgStatement*> new_order = SortNoInterleaving(dependencyGraph);
+                cout << "\n\nLOOP ANALYZE FROM " << firstLine << " TO " << lastLine << " RES\n" << endl;
+                for (auto v: new_order) 
+                    if (v -> lineNumber() > firstLine) 
+                        cout << v -> lineNumber() << "  ";
             }
         }
     }