fix codestyle

.gitignore

@@ -78,4 +78,3 @@ Sapfor/Sapc++/x64/
 
 Sapfor/out/
 Sapfor/_bin/*
-_bin/*

CMakeLists.txt

@@ -204,8 +204,6 @@ 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(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -228,8 +226,7 @@ set(TRANSFORMS
         ${TR_REPLACE_ARRAYS_IN_IO}
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS}
-        ${TR_SWAP_OPERATORS})
+        ${TR_RENAME_SYMBOLS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -462,7 +459,6 @@ 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 (CreateIntervals FILES ${CREATE_INTER_T})

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -124,18 +124,32 @@ static void SolveDataFlow(Region* DFG)
 map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
-    for (const auto& [loopName, loops] : loopGraph)
+    for (const auto& [fileName, loops] : loopGraph)
     {
+        SgFile::switchToFile(fileName);
         for (const auto& loop : loops)
         {
+            SgStatement* search_func = loop->loop->GetOriginal();
+
+            while (search_func && (!isSgProgHedrStmt(search_func)))
+                search_func = search_func->controlParent();
+
             for (const auto& [funcInfo, blocks]: FullIR)
+            {   
+                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
                 {
                     Region* loopRegion = new Region(loop, blocks);
+                    if (loopRegion->getBasickBlocks().size() <= 1)
+                    {
+                        delete(loopRegion);
+                        continue;
+                    }
                     SolveDataFlow(loopRegion);
                     result[loop] = loopRegion->array_priv;
                     delete(loopRegion);
                 }
             }
         }
+    }
     return result;
 }

src/Sapfor.cpp

@@ -89,7 +89,6 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/SwapOperators/swap_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
@@ -940,8 +939,6 @@ 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 == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1022,8 +1019,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                 if(func->funcPointer->variant() != ENTRY_STAT)
                     countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks);
         }
-        else if (curr_regime == FIND_PRIVATE_ARRAYS)
-            FindPrivateArrays(loopGraph, fullIR);
         else if (curr_regime == TEST_PASS)
         {
         //test pass
@@ -1040,8 +1035,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_REMOVING,
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
-                          REMOVE_DEAD_CODE,
-                          SWAP_OPERATORS };
+                          REMOVE_DEAD_CODE };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -1920,6 +1914,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
     }
     else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
         transformAssumedSizeParameters(allFuncInfo);
+    else if (curr_regime == FIND_PRIVATE_ARRAYS) 
+        auto result = FindPrivateArrays(loopGraph, fullIR);
 
     const float elapsed = duration_cast<milliseconds>(high_resolution_clock::now() - timeForPass).count() / 1000.;
     const float elapsedGlobal = duration_cast<milliseconds>(high_resolution_clock::now() - globalTime).count() / 1000.;
@@ -2338,7 +2334,6 @@ 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:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:

src/Sapfor.h

@@ -122,8 +122,6 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    SWAP_OPERATORS,
-
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
     FILL_PARALLEL_REG_IR,
@@ -321,7 +319,6 @@ 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[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";

src/Transformations/SwapOperators/swap_operators.cpp

@@ -1,299 +0,0 @@
-#include <map>
-#include <unordered_set>
-#include <vector>
-#include <queue>
-#include <iostream>
-#include <algorithm>
-
-#include "../../Utils/errors.h"
-#include "../../Utils/SgUtils.h"
-#include "../../GraphCall/graph_calls.h"
-#include "../../GraphCall/graph_calls_func.h"
-#include "../../CFGraph/CFGraph.h"
-#include "../../CFGraph/IR.h"
-#include "../../GraphLoop/graph_loops.h"
-#include "swap_operators.h"
-
-using namespace std;
-
-string getNameByArg(SAPFOR::Argument* arg);
-SgSymbol* getSybolByArg(SAPFOR::Argument* arg);
-
-static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, 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();
-            // Match by line number to find corresponding IR instruction
-            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};
-unordered_set<int> control_end_tags = {CONTROL_END};
-
-struct OperatorInfo {
-    SgStatement* stmt;
-    set<string> usedVars;
-    set<string> definedVars;
-    int lineNumber;
-    bool isMovable;
-    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) {}
-};
-
-static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    vector<OperatorInfo> operators;
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    SgStatement* current = loopStart;
-    while (current && current != loopEnd) {
-        if (isSgExecutableStatement(current)) {
-            OperatorInfo opInfo(current);
-            
-            vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
-            for (auto irBlock : irBlocks) {
-                SAPFOR::Instruction* instr = irBlock->getInstruction();
-                
-                if (instr->getArg1()) {
-                    string varName = getNameByArg(instr->getArg1());
-                    if (!varName.empty()) {
-                        opInfo.usedVars.insert(varName);
-                    }
-                }
-                if (instr->getArg2()) {
-                    string varName = getNameByArg(instr->getArg2());
-                    if (!varName.empty()) {
-                        opInfo.usedVars.insert(varName);
-                    }
-                }
-                if (instr->getResult()) {
-                    string varName = getNameByArg(instr->getResult());
-                    if (!varName.empty()) {
-                        opInfo.definedVars.insert(varName);
-                    }
-                }
-            }
-            
-            if (control_tags.find(current->variant()) != control_tags.end()) {
-                opInfo.isMovable = false;
-            }
-            
-            operators.push_back(opInfo);
-        }
-        current = current->lexNext();
-    }
-    
-    return operators;
-}
-
-static map<string, vector<SgStatement*>> findVariableDefinitions(SgForStmt* loop, vector<OperatorInfo>& operators) {
-    map<string, vector<SgStatement*>> varDefinitions;
-    
-    for (auto& op : operators) {
-        for (const string& var : op.definedVars) {
-            varDefinitions[var].push_back(op.stmt);
-        }
-    }
-    
-    return varDefinitions;
-}
-
-static int calculateDistance(SgStatement* from, SgStatement* to) {
-    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) {
-    OperatorInfo* opInfo = nullptr;
-    for (auto& op : operators) {
-        if (op.stmt == operatorStmt) {
-            opInfo = &op;
-            break;
-        }
-    }
-    
-    if (!opInfo || !opInfo->isMovable) return nullptr;
-    
-    SgStatement* bestPos = nullptr;
-    int minDistance = INT_MAX;
-    
-    for (const string& usedVar : opInfo->usedVars) {
-        if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-            for (SgStatement* defStmt : varDefinitions[usedVar]) {
-                int distance = calculateDistance(operatorStmt, defStmt);
-                if (distance < minDistance) {
-                    minDistance = distance;
-                    bestPos = defStmt;
-                }
-            }
-        }
-    }
-    
-    return bestPos;
-}
-
-static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
-    if (!from || !to || from == to) return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber()) {
-        return false;
-    }
-    
-    SgStatement* current = from;
-    while (current && current != loopEnd) {
-        if (control_tags.find(current->variant()) != control_tags.end()) {
-            return false;
-        }
-        if (current == to) break;
-        current = current->lexNext();
-    }
-    
-    return true;
-}
-
-static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
-    vector<SgStatement*> newOrder;
-    vector<bool> moved(operators.size(), false);
-    
-    for (size_t i = 0; i < operators.size(); i++) {
-        if (moved[i] || !operators[i].isMovable) {
-            newOrder.push_back(operators[i].stmt);
-            moved[i] = true;
-            continue;
-        }
-        
-        SgStatement* bestPos = findBestPosition(operators[i].stmt, operators, varDefinitions);
-        
-        if (bestPos && canMoveTo(operators[i].stmt, bestPos, loop)) {
-            bool inserted = false;
-            for (size_t j = 0; j < newOrder.size(); j++) {
-                if (newOrder[j] == bestPos) {
-                    newOrder.insert(newOrder.begin() + j + 1, operators[i].stmt);
-                    inserted = true;
-                    break;
-                }
-            }
-            if (!inserted) {
-                newOrder.push_back(operators[i].stmt);
-            }
-        } else {
-            newOrder.push_back(operators[i].stmt);
-        }
-        moved[i] = true;
-    }
-    
-    return newOrder;
-}
-
-static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOrder) {
-    if (!loop || newOrder.empty()) return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    vector<SgStatement*> extractedStatements;
-    vector<char*> savedComments;
-    
-    for (SgStatement* stmt : newOrder) {
-        if (stmt && stmt != loop && stmt != loopEnd) {
-            savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
-            SgStatement* extracted = stmt->extractStmt();
-            if (extracted) {
-                extractedStatements.push_back(extracted);
-            }
-        }
-    }
-    
-    SgStatement* currentPos = loop;
-    int lineCounter = loop->lineNumber() + 1;
-    
-    for (size_t i = 0; i < extractedStatements.size(); i++) {
-        SgStatement* stmt = extractedStatements[i];
-        if (stmt) {
-            if (i < savedComments.size() && savedComments[i]) {
-                stmt->setComments(savedComments[i]);
-            }
-            stmt->setlineNumber(lineCounter++);
-            currentPos->insertStmtAfter(*stmt, *loop);
-            currentPos = stmt;
-        }
-    }
-    
-    for (char* comment : savedComments) {
-        if (comment) {
-            free(comment);
-        }
-    }
-    
-    if (currentPos && currentPos->lexNext() != loopEnd) {
-        currentPos->setLexNext(*loopEnd);
-    }
-    
-    return true;
-}
-
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, 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())
-            result = func.second;
-    }
-    return result;
-}
-
-map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, vector<SAPFOR::BasicBlock*> blocks) {
-    map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
-    SgStatement *lastNode = st->lastNodeOfStmt();
-    while (st && st != lastNode) {
-        if (loop_tags.find(st -> variant()) != loop_tags.end()) {
-            SgForStmt *forSt = (SgForStmt*)st;
-            SgStatement *loopBody = forSt -> body();
-            SgStatement *lastLoopNode = st->lastNodeOfStmt();
-            unordered_set<int> blocks_nums;
-            while (loopBody && loopBody != lastLoopNode) {
-                SAPFOR::IR_Block* IR = findInstructionsFromOperator(loopBody, blocks).front();
-                if (blocks_nums.find(IR -> getBasicBlock() -> getNumber()) == blocks_nums.end()) {
-                    result[forSt].push_back(IR -> getBasicBlock());
-                    blocks_nums.insert(IR -> getBasicBlock() -> getNumber());
-                }
-                loopBody = loopBody -> lexNext();
-            }
-            std::sort(result[forSt].begin(), result[forSt].end());
-        }
-        st = st -> lexNext();
-    }
-    return result;
-}
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform) {
-    countOfTransform += 1;
-
-    const int funcNum = file -> numberOfFunctions();
-    for (int i = 0; i < funcNum; ++i) {
-        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) {
-            vector<OperatorInfo> operators = analyzeOperatorsInLoop(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-            map<string, vector<SgStatement*>> varDefinitions = findVariableDefinitions(loopForAnalyze.first, operators);
-            
-            vector<SgStatement*> newOrder = optimizeOperatorOrder(loopForAnalyze.first, operators, varDefinitions);
-            applyOperatorReordering(loopForAnalyze.first, newOrder);
-        }
-    }
-}

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);