refactored

CMakeLists.txt

@@ -208,8 +208,8 @@ set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
         src/Transformations/FunctionInlining/inliner.h)
 set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
         src/Transformations/RenameSymbols/rename_symbols.h)
-SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
-        src/Transformations/SwapOperators/swap_operators.h)
+SET(TR_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
+        src/Transformations/MoveOperators/move_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -233,7 +233,7 @@ set(TRANSFORMS
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
         ${TR_RENAME_SYMBOLS}
-        ${TR_SWAP_OPERATORS})
+        ${TR_MOVE_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -467,7 +467,7 @@ source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
-source_group (Transformations\\SwapOperators FILES ${TR_SWAP_OPERATORS})
+source_group (Transformations\\MoveOperators FILES ${TR_MOVE_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})

src/Sapfor.cpp

@@ -90,7 +90,7 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/SwapOperators/swap_operators.h"
+#include "Transformations/MoveOperators/move_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
@@ -942,8 +942,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
-        else if (curr_regime == SWAP_OPERATORS)        
-            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
+        else if (curr_regime == MOVE_OPERATORS)        
+            moveOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1041,7 +1041,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
                           REMOVE_DEAD_CODE,
-                          SWAP_OPERATORS };
+                          MOVE_OPERATORS };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -2343,7 +2343,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case INSERT_NO_DISTR_FLAGS_FROM_GUI:
     case PRIVATE_REMOVING:
     case RENAME_INLCUDES:
-    case SWAP_OPERATORS:
+    case MOVE_OPERATORS:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:

src/Sapfor.h

@@ -122,7 +122,7 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    SWAP_OPERATORS,
+    MOVE_OPERATORS,
 
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
@@ -323,7 +323,7 @@ static void setPassValues()
     passNames[CHECK_PAR_REG_DIR] = "CHECK_PAR_REG_DIR";
     passNames[CREATE_INTER_TREE] = "CREATE_INTER_TREE";
     passNames[INSERT_INTER_TREE] = "INSERT_INTER_TREE";
-    passNames[SWAP_OPERATORS] = "SWAP_OPERATORS";
+    passNames[MOVE_OPERATORS] = "MOVE_OPERATORS";
     passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";

src/Transformations/MoveOperators/move_operators.cpp

@@ -12,31 +12,29 @@
 #include "../../CFGraph/CFGraph.h"
 #include "../../CFGraph/IR.h"
 #include "../../GraphLoop/graph_loops.h"
-#include "swap_operators.h"
+#include "move_operators.h"
 
 using namespace std;
 
-string getNameByArg(SAPFOR::Argument* arg);
-
-static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, vector<SAPFOR::BasicBlock*> Blocks) {
+static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, const vector<SAPFOR::BasicBlock*>& Blocks) {
     vector<SAPFOR::IR_Block*> result;
     string filename = st->fileName();
     
     for (auto& block: Blocks) {
         vector<SAPFOR::IR_Block*> instructionsInBlock = block->getInstructions();
+
         for (auto& instruction: instructionsInBlock) {
             SgStatement* curOperator = instruction->getInstruction()->getOperator();
-            if (curOperator->lineNumber() == st->lineNumber()) {
+            if (curOperator->lineNumber() == st->lineNumber())
                 result.push_back(instruction);
         }
     }
-    }
     return result;
 }
 
-unordered_set<int> loop_tags = {FOR_NODE};
-unordered_set<int> control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE};
-unordered_set<int> control_end_tags = {CONTROL_END};
+const unordered_set<int> loop_tags = { FOR_NODE };
+const unordered_set<int> control_tags = { IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE };
+const unordered_set<int> control_end_tags = { CONTROL_END };
 
 struct OperatorInfo {
     SgStatement* stmt;
@@ -45,58 +43,58 @@ struct OperatorInfo {
     int lineNumber;
     bool isMovable;
     
-    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) {}
+    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) { }
 };
 
 static bool isStatementEmbedded(SgStatement* stmt, SgStatement* parent) {
-    if (!stmt || !parent || stmt == parent) return false;
+    if (!stmt || !parent || stmt == parent)
+        return false;
     
     if (parent->variant() == LOGIF_NODE) {
-        if (stmt->lineNumber() == parent->lineNumber()) {
+        if (stmt->lineNumber() == parent->lineNumber())
             return true;
-        }
         
         SgStatement* current = parent;
         SgStatement* lastNode = parent->lastNodeOfStmt();
 
         while (current && current != lastNode) {
-            if (current == stmt) {
+            if (current == stmt)
                 return true;
-            }
-            if (current->isIncludedInStmt(*stmt)) {
+
+            if (current->isIncludedInStmt(*stmt))
                 return true;
-            }
+
             current = current->lexNext();
         }
     }
     
-    if (parent->isIncludedInStmt(*stmt)) {
+    if (parent->isIncludedInStmt(*stmt))
         return true;
-    }
     
     return false;
 }
 
 static bool isLoopBoundary(SgStatement* stmt) {
-    if (!stmt) return false;
+    if (!stmt)
+        return false;
     
-    if (stmt->variant() == FOR_NODE || stmt->variant() == CONTROL_END) {
+    if (stmt->variant() == FOR_NODE || stmt->variant() == CONTROL_END)
         return true;
-    }
     
     return false;
 }
 
 static bool isPartOfNestedLoop(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop) return false;
+    if (!stmt || !loop)
+        return false;
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd) return false;
-    
-    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber()) {
+    if (!loopStart || !loopEnd)
+        return false;
+    
+    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
     
     SgStatement* current = loopStart;
     
@@ -121,60 +119,58 @@ static bool isPartOfNestedLoop(SgStatement* stmt, SgForStmt* loop) {
 }
 
 static bool canSafelyExtract(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop) return false;
-    
-    if (isLoopBoundary(stmt)) {
+    if (!stmt || !loop)
         return false;
-    }
     
-    if (control_tags.find(stmt->variant()) != control_tags.end()) {
+    if (isLoopBoundary(stmt))
         return false;
-    }
     
-    if (isPartOfNestedLoop(stmt, loop)) {
+    if (control_tags.find(stmt->variant()) != control_tags.end())
+        return false;
+    
+    if (isPartOfNestedLoop(stmt, loop))
         return false;
-    }
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd) return false;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     SgStatement* current = loopStart;
     
     while (current && current != loopEnd) {
-        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber()) {
+        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber())
             return false;
-        }
 
-        if (control_tags.find(current->variant()) != control_tags.end()) {
-            if (isStatementEmbedded(stmt, current)) {
+        if (control_tags.find(current->variant()) != control_tags.end())
+            if (isStatementEmbedded(stmt, current))
                 return false;
-            }
-        }
-        if (current == stmt) break;
+
+        if (current == stmt) 
+            break;
         current = current->lexNext();
     }
     
     return true;
 }
 
-static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
+                                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
     vector<OperatorInfo> operators;
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
     
-    if (!loopStart || !loopEnd) {
+    if (!loopStart || !loopEnd)
         return operators;
-    }
     
     SgStatement* current = loopStart;
     unordered_set<SgStatement*> visited;
     
     while (current && current != loopEnd) {
         
-        if (visited.find(current) != visited.end()) {
+        if (visited.find(current) != visited.end())
             break;
-        }
+
         visited.insert(current);
         
         if (isLoopBoundary(current)) {
@@ -184,11 +180,10 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
         
         if (current->variant() == FOR_NODE && current != loop) {
             SgStatement* nestedEnd = current->lastNodeOfStmt();
-            if (nestedEnd) {
+            if (nestedEnd)
                 current = nestedEnd->lexNext();
-            } else {
+            else
                 current = current->lexNext();
-            }
             continue;
         }
         
@@ -197,6 +192,7 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
                 current = current->lexNext();
                 continue;
             }
+
             if (current->variant() != ASSIGN_STAT) {
                 current = current->lexNext();
                 continue;
@@ -206,29 +202,28 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
             
             vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
             for (auto irBlock : irBlocks) {
-                if (!irBlock || !irBlock->getInstruction()) continue;
-                
-                SAPFOR::Instruction* instr = irBlock->getInstruction();
+                if (!irBlock || !irBlock->getInstruction()) 
+                    continue;
                 
+                const SAPFOR::Instruction* instr = irBlock->getInstruction();
                 if (instr->getArg1()) {
                     string varName = getNameByArg(instr->getArg1());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.usedVars.insert(varName);
                 }
-                }
+
                 if (instr->getArg2()) {
                     string varName = getNameByArg(instr->getArg2());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.usedVars.insert(varName);
                 }
-                }
+
                 if (instr->getResult()) {
                     string varName = getNameByArg(instr->getResult());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.definedVars.insert(varName);
                 }
             }
-            }
             
             operators.push_back(opInfo);
         }
@@ -249,12 +244,15 @@ static map<string, vector<SgStatement*>> findVariableDefinitions(SgForStmt* loop
 }
 
 static int calculateDistance(SgStatement* from, SgStatement* to) {
-    if (!from || !to) return INT_MAX;
+    if (!from || !to) 
+        return INT_MAX;
+
     return abs(to->lineNumber() - from->lineNumber());
 }
 
-static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions, SgForStmt* loop) {
-    OperatorInfo* opInfo = nullptr;
+static SgStatement* findBestPosition(SgStatement* operatorStmt, const vector<OperatorInfo>& operators, 
+                                     const map<string, vector<SgStatement*>>& varDefinitions, SgForStmt* loop) {
+    const OperatorInfo* opInfo = nullptr;
     for (auto& op : operators) {
         if (op.stmt == operatorStmt) {
             opInfo = &op;
@@ -262,16 +260,15 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
         }
     }
 
-    if (!opInfo || !opInfo->isMovable) {
+    if (!opInfo || !opInfo->isMovable)
         return nullptr;
-    }
     
     SgStatement* bestPos = nullptr;
     int bestLine = -1;
     
     for (const string& usedVar : opInfo->usedVars) {
         if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-            for (SgStatement* defStmt : varDefinitions[usedVar]) {
+            for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
                 if (defStmt->lineNumber() < operatorStmt->lineNumber()) {
                     if (defStmt->controlParent() == operatorStmt->controlParent()) {
                         if (defStmt->lineNumber() > bestLine) {
@@ -290,13 +287,11 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
         
         for (const string& usedVar : opInfo->usedVars) {
             if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-                for (SgStatement* defStmt : varDefinitions[usedVar]) {
-                    if (defStmt == operatorStmt) {
+                for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
+                    if (defStmt == operatorStmt)
                         continue;
-                    }
                     
                     hasAnyDefinition = true;
-                    
                     if (defStmt->lineNumber() < operatorStmt->lineNumber() &&
                         defStmt->controlParent() == operatorStmt->controlParent()) {
                         allLoopCarried = false;
@@ -304,7 +299,9 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
                     }
                 }
             }
-            if (!allLoopCarried) break;
+
+            if (!allLoopCarried) 
+                break;
         }
         
         if (allLoopCarried || (!hasAnyDefinition && !opInfo->usedVars.empty())) {
@@ -317,12 +314,14 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
 }
 
 static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
-    if (!from || !to || from == to) return false;
+    if (!from || !to || from == to)
+        return false;
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
     
-    if (!loopStart || !loopEnd) return false;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     if (to == loopStart) {
         SgStatement* fromControlParent = from->controlParent();
@@ -330,20 +329,17 @@ static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
         return fromControlParent == loop || fromControlParent == loopStart->controlParent();
     }
     
-    if (from->lineNumber() < loopStart->lineNumber() || from->lineNumber() > loopEnd->lineNumber()) {
+    if (from->lineNumber() < loopStart->lineNumber() || from->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
-    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber()) {
-        return false;
-    }
 
-    if (to->lineNumber() >= from->lineNumber()) {
+    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
     
-    if (from->controlParent() != to->controlParent()) {
+    if (to->lineNumber() >= from->lineNumber())
+        return false;
+    
+    if (from->controlParent() != to->controlParent())
         return false;
-    }
     
     SgStatement* current = to->lexNext();
     while (current && current != from && current != loopEnd) {
@@ -361,16 +357,16 @@ static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
     return true;
 }
 
-static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
+static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, 
+                                                  const vector<OperatorInfo>& operators, 
+                                                  const map<string, vector<SgStatement*>>& varDefinitions) {
     vector<SgStatement*> newOrder;
-    for (auto& op : operators) {
+    for (auto& op : operators)
         newOrder.push_back(op.stmt);
-    }
     
-    map<SgStatement*, OperatorInfo*> stmtToOpInfo;
-    for (auto& op : operators) {
+    map<SgStatement*, const OperatorInfo*> stmtToOpInfo;
+    for (auto& op : operators) 
         stmtToOpInfo[op.stmt] = &op;
-    }
     
     bool changed = true;
     int iterations = 0;
@@ -381,11 +377,14 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
         iterations++;
         
         for (int i = operators.size() - 1; i >= 0; i--) {
-            if (!operators[i].isMovable) continue;
+            if (!operators[i].isMovable) 
+                continue;
             
             SgStatement* stmt = operators[i].stmt;
-            OperatorInfo* opInfo = stmtToOpInfo[stmt];
-            if (!opInfo) continue;
+            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
+
+            if (!opInfo)
+                continue;
             
             size_t currentPos = 0;
             for (size_t j = 0; j < newOrder.size(); j++) {
@@ -401,7 +400,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                 bool hasDependents = false;
                 for (size_t j = currentPos + 1; j < newOrder.size(); j++) {
                     SgStatement* candidate = newOrder[j];
-                    OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                     if (candidateOpInfo) {
                         for (const string& definedVar : opInfo->definedVars) {
                             if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
@@ -409,7 +408,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                 break;
                             }
                         }
-                        if (hasDependents) break;
+
+                        if (hasDependents) 
+                            break;
                     }
                 }
                 
@@ -424,7 +425,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                 
                 for (size_t j = 0; j < currentPos && j < newOrder.size(); j++) {
                     SgStatement* candidate = newOrder[j];
-                    OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                     if (candidateOpInfo) {
                         bool usesDefinedVar = false;
                         for (const string& definedVar : opInfo->definedVars) {
@@ -463,7 +464,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     
                     for (size_t j = bestPosIdx + 1; j < currentPos && j < newOrder.size(); j++) {
                         SgStatement* candidate = newOrder[j];
-                        OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                         if (candidateOpInfo) {
                             bool definesUsedVar = false;
                             for (const string& usedVar : opInfo->usedVars) {
@@ -472,16 +473,15 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                     break;
                                 }
                             }
-                            if (definesUsedVar) {
+                            if (definesUsedVar)
                                 targetPos = j + 1;
                         }
                     }
-                    }
                     
                     bool wouldBreakDependency = false;
                     for (size_t j = targetPos; j < currentPos && j < newOrder.size(); j++) {
                         SgStatement* candidate = newOrder[j];
-                        OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                         if (candidateOpInfo) {
                             for (const string& definedVar : opInfo->definedVars) {
                                 if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
@@ -489,7 +489,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                     break;
                                 }
                             }
-                            if (wouldBreakDependency) break;
+
+                            if (wouldBreakDependency) 
+                                break;
                         }
                     }
                     
@@ -512,18 +514,19 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
         
         for (size_t i = 0; i < newOrder.size(); i++) {
             SgStatement* stmt = newOrder[i];
-            OperatorInfo* opInfo = stmtToOpInfo[stmt];
-            if (!opInfo) continue;
+            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
+            if (!opInfo) 
+                continue;
             
             for (size_t j = 0; j < i; j++) {
                 SgStatement* prevStmt = newOrder[j];
-                OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
-                if (!prevOpInfo) continue;
+                const OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
+                if (!prevOpInfo)
+                    continue;
                 
                 pair<SgStatement*, SgStatement*> key = make_pair(stmt, prevStmt);
-                if (triedPairs.find(key) != triedPairs.end()) {
+                if (triedPairs.find(key) != triedPairs.end())
                     continue;
-                }
                 
                 bool violation = false;
                 for (const string& definedVar : opInfo->definedVars) {
@@ -539,8 +542,10 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     bool wouldCreateViolation = false;
                     for (size_t k = j; k < i; k++) {
                         SgStatement* betweenStmt = newOrder[k];
-                        OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
-                        if (!betweenOpInfo) continue;
+                        const OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
+
+                        if (!betweenOpInfo)
+                            continue;
                         
                         for (const string& usedVar : opInfo->usedVars) {
                             if (betweenOpInfo->definedVars.find(usedVar) != betweenOpInfo->definedVars.end()) {
@@ -548,7 +553,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                 break;
                             }
                         }
-                        if (wouldCreateViolation) break;
+
+                        if (wouldCreateViolation)
+                            break;
                     }
                     
                     if (!wouldCreateViolation) {
@@ -559,27 +566,30 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     }
                 }
             }
-            if (dependencyViolation) break;
+            if (dependencyViolation)
+                break;
         }
     }
     
     return newOrder;
 }
 
-static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOrder) {
-    if (!loop || newOrder.empty()) return false;
+static bool applyOperatorReordering(SgForStmt* loop, const vector<SgStatement*>& newOrder) {
+    if (!loop || newOrder.empty()) 
+        return false;
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
     
-    if (!loopStart || !loopEnd) return false;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     vector<SgStatement*> originalOrder;
     SgStatement* current = loopStart;
     while (current && current != loopEnd) {
-        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT) {
+        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT)
             originalOrder.push_back(current);
-        }
+
         current = current->lexNext();
     }
     
@@ -591,13 +601,12 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 break;
             }
         }
-    } else {
+    } 
+    else
         orderChanged = true;
-    }
     
-    if (!orderChanged) {
+    if (!orderChanged)
         return false;
-    }
 
     vector<SgStatement*> extractedStatements;
     vector<char*> savedComments;
@@ -607,13 +616,11 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
     
     for (SgStatement* stmt : newOrder) {
         if (stmt && stmt != loop && stmt != loopEnd && extractedSet.find(stmt) == extractedSet.end()) {
-            if (control_tags.find(stmt->variant()) != control_tags.end()) {
+            if (control_tags.find(stmt->variant()) != control_tags.end())
                 continue;
-            }
             
-            if (!canSafelyExtract(stmt, loop)) {
+            if (!canSafelyExtract(stmt, loop))
                 continue;
-            }
             
             bool isMoving = false;
             for (size_t i = 0; i < originalOrder.size(); i++) {
@@ -628,9 +635,8 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 }
             }
             
-            if (!isMoving) {
+            if (!isMoving)
                 continue;
-            }
             
             originalLineNumbers[stmt] = stmt->lineNumber();
             savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
@@ -696,16 +702,15 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 }
             }
             
-            if (commentIdx < savedComments.size() && savedComments[commentIdx]) {
+            if (commentIdx < savedComments.size() && savedComments[commentIdx])
                 stmtToInsert->setComments(savedComments[commentIdx]);
-            }
             
-            if (originalLineNumbers.find(stmt) != originalLineNumbers.end()) {
+            if (originalLineNumbers.find(stmt) != originalLineNumbers.end())
                 stmtToInsert->setlineNumber(originalLineNumbers[stmt]);
-            }
             
             SgStatement* controlParent = stmt->controlParent();
-            if (!controlParent) controlParent = loop;
+            if (!controlParent)
+                controlParent = loop;
             
             insertAfter->insertStmtAfter(*stmtToInsert, *controlParent);
             insertedStatements[stmt] = stmtToInsert;
@@ -713,17 +718,17 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
     }
     
     for (char* comment : savedComments) {
-        if (comment) {
+        if (comment)
             free(comment);
     }
-    }
     
     return true;
 }
 
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
     vector<SAPFOR::BasicBlock*> result;
     Statement* forSt = (Statement*)st;
+
     for (auto& func: FullIR) {
         if (func.first -> funcPointer -> getCurrProcessFile() == forSt -> getCurrProcessFile()
             && func.first -> funcPointer -> lineNumber() == forSt -> lineNumber())
@@ -732,7 +737,7 @@ vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, map<F
     return result;
 }
 
-map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, vector<SAPFOR::BasicBlock*> blocks) {
+map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, const vector<SAPFOR::BasicBlock*>& blocks) {
     map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
     SgStatement *lastNode = st->lastNodeOfStmt();
     
@@ -756,14 +761,15 @@ map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st
                 }
                 loopBody = loopBody -> lexNext();
             }
-            std::sort(result[forSt].begin(), result[forSt].end());
+            sort(result[forSt].begin(), result[forSt].end());
         }
         st = st -> lexNext();
     }
     return result;
 }
 
-static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+static void processLoopRecursively(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
+                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
     if (!loop) return;
     
     SgStatement* loopStart = loop->lexNext();
@@ -775,16 +781,16 @@ static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*>
                 SgForStmt* nestedLoop = (SgForStmt*)current;
                 processLoopRecursively(nestedLoop, blocks, FullIR);
                 SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
-                if (nestedEnd) {
+
+                if (nestedEnd)
                     current = nestedEnd->lexNext();
-                } else {
+                else
                     current = current->lexNext();
             } 
-            } else {
+            else
                 current = current->lexNext();
         }
     }
-    }
     
     vector<OperatorInfo> operators = analyzeOperatorsInLoop(loop, blocks, FullIR);
     if (!operators.empty()) {
@@ -794,10 +800,12 @@ static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*>
     }
 }
 
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform) {
+void moveOperators(SgFile *file, map<string, vector<LoopGraph*>>& loopGraph, 
+                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, 
+                   int& countOfTransform) {
     countOfTransform += 1;
     
-    std::cout << "SWAP_OPERATORS Pass Started" << std::endl;
+    //cout << "MOVE_OPERATORS Pass Started" << endl;
 
     const int funcNum = file -> numberOfFunctions();
     
@@ -805,13 +813,11 @@ void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*
         SgStatement *st = file -> functions(i);
         
         vector<SAPFOR::BasicBlock*> blocks = findFuncBlocksByFuncStatement(st, FullIR);        
-        
         map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
         
-        for (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping) {
+        for (auto& loopForAnalyze: loopsMapping)
             processLoopRecursively(loopForAnalyze.first, loopForAnalyze.second, FullIR);
     }
-    }
     
-    std::cout << "SWAP_OPERATORS Pass Completed" << std::endl;
+    //cout << "MOVE_OPERATORS Pass Completed" << endl;
 }

src/Transformations/MoveOperators/move_operators.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "../../GraphLoop/graph_loops.h"
+#include "../../CFGraph/CFGraph.h"
+
+void moveOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);

src/Transformations/SwapOperators/swap_operators.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include "../../GraphLoop/graph_loops.h"
-#include "../../CFGraph/CFGraph.h"
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);

src/Utils/PassManager.h

@@ -212,8 +212,6 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     Pass(BUILD_IR) <= Pass(SUBST_EXPR_RD) <= Pass(SUBST_EXPR_RD_AND_UNPARSE);
 
-    list({BUILD_IR, CALL_GRAPH2}) <= Pass(SWAP_OPERATORS);
-
     list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
     list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING);
 
@@ -321,6 +319,8 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
     list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
     list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);
 
+    list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);
+
     passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, 
                                    EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW,
                                    REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL,