Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactored

Browse Source
This commit is contained in:
ALEXks
2025-12-29 21:10:55 +03:00
parent 6907f44ac5
commit d9f54739d2
7 changed files with 174 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
CMakeLists.txt
View File

@@ -207,9 +207,9 @@ set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_gr
set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
src/Transformations/FunctionInlining/inliner.h) src/Transformations/FunctionInlining/inliner.h)
set(TR_RENAME_SYMBOLS src/Transformations/RenameSymbols/rename_symbols.cpp set(TR_RENAME_SYMBOLS src/Transformations/RenameSymbols/rename_symbols.cpp
src/Transformations/RenameSymbols/rename_symbols.h) src/Transformations/RenameSymbols/rename_symbols.h)
SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp SET(TR_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
src/Transformations/SwapOperators/swap_operators.h) src/Transformations/MoveOperators/move_operators.h)
set(TRANSFORMS set(TRANSFORMS
${TR_DEAD_CODE} ${TR_DEAD_CODE}
@@ -233,7 +233,7 @@ set(TRANSFORMS
${TR_EXPR_TRANSFORM} ${TR_EXPR_TRANSFORM}
${TR_INLINER} ${TR_INLINER}
${TR_RENAME_SYMBOLS} ${TR_RENAME_SYMBOLS}
${TR_SWAP_OPERATORS}) ${TR_MOVE_OPERATORS})
set(CFG src/CFGraph/IR.cpp set(CFG src/CFGraph/IR.cpp
src/CFGraph/IR.h 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\\ConvertToC FILES ${TR_CONV})
source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE}) source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO}) 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}) source_group (CreateIntervals FILES ${CREATE_INTER_T})

10
src/Sapfor.cpp
View File

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

4
src/Sapfor.h
View File

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

302
src/Transformations/SwapOperators/swap_operators.cpp → src/Transformations/MoveOperators/move_operators.cpp
View File

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

6
src/Transformations/MoveOperators/move_operators.h Normal file
View File

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

6
src/Transformations/SwapOperators/swap_operators.h
View File

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

4
src/Utils/PassManager.h
View File

@@ -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); 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({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING); 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({ 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({ 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, 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, 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, REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL,