From d9f54739d25dc4b90ad63215d03547e12e669f2c Mon Sep 17 00:00:00 2001 From: ALEXks Date: Mon, 29 Dec 2025 21:10:55 +0300 Subject: [PATCH] refactored --- CMakeLists.txt | 10 +- src/Sapfor.cpp | 10 +- src/Sapfor.h | 4 +- .../move_operators.cpp} | 302 +++++++++--------- .../MoveOperators/move_operators.h | 6 + .../SwapOperators/swap_operators.h | 6 - src/Utils/PassManager.h | 4 +- 7 files changed, 174 insertions(+), 168 deletions(-) rename src/Transformations/{SwapOperators/swap_operators.cpp => MoveOperators/move_operators.cpp} (81%) create mode 100644 src/Transformations/MoveOperators/move_operators.h delete mode 100644 src/Transformations/SwapOperators/swap_operators.h diff --git a/CMakeLists.txt b/CMakeLists.txt index eb214e5..12e61a7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -207,9 +207,9 @@ set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_gr 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) + src/Transformations/RenameSymbols/rename_symbols.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}) diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index 257d38d..7baa9b8 100644 --- a/src/Sapfor.cpp +++ b/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: diff --git a/src/Sapfor.h b/src/Sapfor.h index 7c2b74c..f5dadd1 100644 --- a/src/Sapfor.h +++ b/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"; diff --git a/src/Transformations/SwapOperators/swap_operators.cpp b/src/Transformations/MoveOperators/move_operators.cpp similarity index 81% rename from src/Transformations/SwapOperators/swap_operators.cpp rename to src/Transformations/MoveOperators/move_operators.cpp index 8871145..00fec2d 100644 --- a/src/Transformations/SwapOperators/swap_operators.cpp +++ b/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 findInstructionsFromOperator(SgStatement* st, vector Blocks) { +static vector findInstructionsFromOperator(SgStatement* st, const vector& Blocks) { vector result; string filename = st->fileName(); for (auto& block: Blocks) { vector 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 loop_tags = {FOR_NODE}; -unordered_set control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE}; -unordered_set control_end_tags = {CONTROL_END}; +const unordered_set loop_tags = { FOR_NODE }; +const unordered_set control_tags = { IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE }; +const unordered_set 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 analyzeOperatorsInLoop(SgForStmt* loop, vector blocks, map>& FullIR) { +static vector analyzeOperatorsInLoop(SgForStmt* loop, const vector& blocks, + const map>& FullIR) { vector operators; SgStatement* loopStart = loop->lexNext(); SgStatement* loopEnd = loop->lastNodeOfStmt(); - if (!loopStart || !loopEnd) { + if (!loopStart || !loopEnd) return operators; - } SgStatement* current = loopStart; unordered_set 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 analyzeOperatorsInLoop(SgForStmt* loop, vectorvariant() == 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 analyzeOperatorsInLoop(SgForStmt* loop, vectorlexNext(); continue; } + if (current->variant() != ASSIGN_STAT) { current = current->lexNext(); continue; @@ -206,27 +202,26 @@ static vector analyzeOperatorsInLoop(SgForStmt* loop, vector 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); - } } } @@ -249,29 +244,31 @@ static map> 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& operators, map>& varDefinitions, SgForStmt* loop) { - OperatorInfo* opInfo = nullptr; +static SgStatement* findBestPosition(SgStatement* operatorStmt, const vector& operators, + const map>& varDefinitions, SgForStmt* loop) { + const OperatorInfo* opInfo = nullptr; for (auto& op : operators) { if (op.stmt == operatorStmt) { opInfo = &op; break; } } - - 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, vectorusedVars) { 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, vectorusedVars.empty())) { @@ -317,12 +314,14 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vectorlexNext(); 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()) { + + if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber()) return false; - } - if (to->lineNumber() >= from->lineNumber()) { + if (to->lineNumber() >= from->lineNumber()) return false; - } - if (from->controlParent() != to->controlParent()) { + 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 optimizeOperatorOrder(SgForStmt* loop, vector& operators, map>& varDefinitions) { +static vector optimizeOperatorOrder(SgForStmt* loop, + const vector& operators, + const map>& varDefinitions) { vector newOrder; - for (auto& op : operators) { + for (auto& op : operators) newOrder.push_back(op.stmt); - } - map stmtToOpInfo; - for (auto& op : operators) { + map stmtToOpInfo; + for (auto& op : operators) stmtToOpInfo[op.stmt] = &op; - } bool changed = true; int iterations = 0; @@ -381,11 +377,14 @@ static vector optimizeOperatorOrder(SgForStmt* loop, vector= 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 optimizeOperatorOrder(SgForStmt* loop, vectordefinedVars) { if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) { @@ -409,7 +408,9 @@ static vector optimizeOperatorOrder(SgForStmt* loop, vector optimizeOperatorOrder(SgForStmt* loop, vectordefinedVars) { @@ -463,7 +464,7 @@ static vector optimizeOperatorOrder(SgForStmt* loop, vectorusedVars) { @@ -472,16 +473,15 @@ static vector optimizeOperatorOrder(SgForStmt* loop, vectordefinedVars) { if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) { @@ -489,7 +489,9 @@ static vector optimizeOperatorOrder(SgForStmt* loop, vector optimizeOperatorOrder(SgForStmt* loop, vector 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 optimizeOperatorOrder(SgForStmt* loop, vectorusedVars) { if (betweenOpInfo->definedVars.find(usedVar) != betweenOpInfo->definedVars.end()) { @@ -548,7 +553,9 @@ static vector optimizeOperatorOrder(SgForStmt* loop, vector optimizeOperatorOrder(SgForStmt* loop, vector& newOrder) { - if (!loop || newOrder.empty()) return false; +static bool applyOperatorReordering(SgForStmt* loop, const vector& 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 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,14 +601,13 @@ static bool applyOperatorReordering(SgForStmt* loop, vector& newOr break; } } - } else { + } + else orderChanged = true; - } - if (!orderChanged) { + if (!orderChanged) return false; - } - + vector extractedStatements; vector savedComments; unordered_set extractedSet; @@ -607,13 +616,11 @@ static bool applyOperatorReordering(SgForStmt* loop, vector& 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& 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& 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& newOr } for (char* comment : savedComments) { - if (comment) { + if (comment) free(comment); - } } return true; } -vector findFuncBlocksByFuncStatement(SgStatement *st, map>& FullIR) { +vector findFuncBlocksByFuncStatement(SgStatement *st, const map>& FullIR) { vector 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 findFuncBlocksByFuncStatement(SgStatement *st, map> findAndAnalyzeLoops(SgStatement *st, vector blocks) { +map> findAndAnalyzeLoops(SgStatement *st, const vector& blocks) { map> result; SgStatement *lastNode = st->lastNodeOfStmt(); @@ -756,14 +761,15 @@ map> 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 blocks, map>& FullIR) { +static void processLoopRecursively(SgForStmt* loop, const vector& blocks, + const map>& FullIR) { if (!loop) return; SgStatement* loopStart = loop->lexNext(); @@ -775,14 +781,14 @@ static void processLoopRecursively(SgForStmt* loop, vector 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(); - } } } @@ -794,24 +800,24 @@ static void processLoopRecursively(SgForStmt* loop, vector } } -void runSwapOperators(SgFile *file, std::map>& loopGraph, std::map>& FullIR, int& countOfTransform) { +void moveOperators(SgFile *file, map>& loopGraph, + const map>& FullIR, + int& countOfTransform) { countOfTransform += 1; - std::cout << "SWAP_OPERATORS Pass Started" << std::endl; + //cout << "MOVE_OPERATORS Pass Started" << endl; const int funcNum = file -> numberOfFunctions(); for (int i = 0; i < funcNum; ++i) { SgStatement *st = file -> functions(i); - vector blocks = findFuncBlocksByFuncStatement(st, FullIR); - + vector blocks = findFuncBlocksByFuncStatement(st, FullIR); map> loopsMapping = findAndAnalyzeLoops(st, blocks); - for (pair> 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; } \ No newline at end of file diff --git a/src/Transformations/MoveOperators/move_operators.h b/src/Transformations/MoveOperators/move_operators.h new file mode 100644 index 0000000..0bbbc9a --- /dev/null +++ b/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>& loopGraph, const std::map>& FullIR, int& countOfTransform); diff --git a/src/Transformations/SwapOperators/swap_operators.h b/src/Transformations/SwapOperators/swap_operators.h deleted file mode 100644 index a23add9..0000000 --- a/src/Transformations/SwapOperators/swap_operators.h +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once - -#include "../../GraphLoop/graph_loops.h" -#include "../../CFGraph/CFGraph.h" - -void runSwapOperators(SgFile *file, std::map>& loopGraph, std::map>& FullIR, int& countOfTransform); diff --git a/src/Utils/PassManager.h b/src/Utils/PassManager.h index a9a866a..0ca232e 100644 --- a/src/Utils/PassManager.h +++ b/src/Utils/PassManager.h @@ -212,8 +212,6 @@ void InitPassesDependencies(map> &passDepsIn, set 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> &passDepsIn, set 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,