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

Compare commits

base: Alexander_KS:egormayorov
Branches Tags
Alexander_KS:master Alexander_KS:fix_array_analysis Alexander_KS:replace_io_arrays Alexander_KS:par_reg_merging Alexander_KS:egormayorov Alexander_KS:private_arrays Alexander_KS:libpredict_integration Alexander_KS:analyze_loops_with_IR
..
compare: Alexander_KS:1bb0334fa268fed849fce36f09bac815420ca60a
Branches Tags
Alexander_KS:master Alexander_KS:fix_array_analysis Alexander_KS:replace_io_arrays Alexander_KS:par_reg_merging Alexander_KS:egormayorov Alexander_KS:private_arrays Alexander_KS:libpredict_integration Alexander_KS:analyze_loops_with_IR

1 Commits
egormayoro ... 1bb0334fa2

Author SHA1 Message Date
xnpster
1bb0334fa2 draft of parallel regions merging pass 2025-12-24 23:11:31 +03:00
23 changed files with 722 additions and 1337 deletions
Expand all files Collapse all files

1
.gitignore vendored
View File

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

15
CMakeLists.txt
View File

@@ -163,9 +163,8 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
src/ParallelizationRegions/resolve_par_reg_conflicts.h)
set(ARRAY_PROP src/ArrayConstantPropagation/propagation.cpp
src/ArrayConstantPropagation/propagation.h
)
set(MERGE_COPY_ARRAYS src/ParallelizationRegions/parse_merge_dirs.cpp
src/ParallelizationRegions/parse_merge_dirs.h)
set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
src/Transformations/DeadCodeRemoving/dead_code.h)
@@ -208,8 +207,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_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
src/Transformations/MoveOperators/move_operators.h)
set(TRANSFORMS
${TR_DEAD_CODE}
@@ -232,8 +229,7 @@ set(TRANSFORMS
${TR_REPLACE_ARRAYS_IN_IO}
${TR_EXPR_TRANSFORM}
${TR_INLINER}
${TR_RENAME_SYMBOLS}
${TR_MOVE_OPERATORS})
${TR_RENAME_SYMBOLS})
set(CFG src/CFGraph/IR.cpp
src/CFGraph/IR.h
@@ -426,8 +422,8 @@ set(SOURCE_EXE
${LOOP_ANALYZER}
${TRANSFORMS}
${PARALLEL_REG}
${MERGE_COPY_ARRAYS}
${PRIV}
${ARRAY_PROP}
${FDVM}
${OMEGA}
${UTILS}
@@ -467,7 +463,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\\MoveOperators FILES ${TR_MOVE_OPERATORS})
source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -479,8 +474,8 @@ source_group (GraphCall FILES ${GR_CALL})
source_group (GraphLoop FILES ${GR_LOOP})
source_group (LoopAnalyzer FILES ${LOOP_ANALYZER})
source_group (ParallelizationRegions FILES ${PARALLEL_REG})
source_group (MergeCopyArrays FILES ${MERGE_COPY_ARRAYS})
source_group (PrivateAnalyzer FILES ${PRIV})
source_group (ArrayConstantPropagation FILES ${ARRAY_PROP})
source_group (FDVM_Compiler FILES ${FDVM})
source_group (SageExtension FILES ${OMEGA})
source_group (Utils FILES ${UTILS})

301
src/ArrayConstantPropagation/propagation.cpp
View File

@@ -1,301 +0,0 @@
#include "propagation.h"
#include "../Utils/SgUtils.h"
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
static SgStatement* declPlace = NULL;
static bool CheckConstIndexes(SgExpression* exp)
{
if (!exp)
{
return true;
}
SgExpression* lhs = exp->lhs();
SgExpression* rhs = exp->rhs();
do
{
if (lhs->variant() != INT_VAL)
{
return false;
}
if (rhs)
{
lhs = rhs->lhs();
rhs = rhs->rhs();
}
} while (rhs);
return true;
}
static SgExpression* CreateVar(int& variableNumber, SgType* type)
{
string varName = "__tmp_prop_var";
string name = varName + std::to_string(variableNumber) + "__";
variableNumber++;
SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *declPlace->controlParent());
const string commonBlockName = "__propagation_common__";
SgStatement* funcStart = declPlace->controlParent();
SgStatement* commonStat = NULL;
SgExpression* commonList = NULL;
SgStatement* funcEnd = funcStart->lastNodeOfStmt();
SgStatement* current = funcStart->lexNext();
while (current != funcEnd && current)
{
if (current->variant() == COMM_STAT)
{
for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
{
if (exp->variant() == COMM_LIST)
{
string existingName = exp->symbol() ?
string(exp->symbol()->identifier()) :
string("spf_unnamed");
if (existingName == commonBlockName)
{
commonStat = current;
commonList = exp;
break;
}
}
}
if (commonStat)
break;
}
current = current->lexNext();
}
vector<SgExpression*> varRefs;
if (commonList)
{
SgExpression* varList = commonList->lhs();
if (varList)
{
auto extractSymbol = [](SgExpression* exp) -> SgSymbol* {
if (!exp)
return NULL;
if (exp->symbol())
return exp->symbol();
if (exp->lhs() && exp->lhs()->symbol())
return exp->lhs()->symbol();
return NULL;
};
if (varList->variant() == EXPR_LIST)
{
for (SgExpression* exp = varList; exp; exp = exp->rhs())
{
SgExpression* varExp = exp->lhs();
SgSymbol* sym = extractSymbol(varExp);
if (sym)
{
varRefs.push_back(new SgVarRefExp(sym));
}
}
}
else
{
for (SgExpression* varExp = varList; varExp; varExp = varExp->rhs())
{
SgSymbol* sym = extractSymbol(varExp);
if (sym)
{
varRefs.push_back(new SgVarRefExp(sym));
}
}
}
}
}
if (!commonList)
{
current = funcStart->lexNext();
while (current != funcEnd && current)
{
if (current->variant() == COMM_STAT)
{
commonStat = current;
break;
}
current = current->lexNext();
}
SgSymbol* commonSymbol = new SgSymbol(COMMON_NAME, commonBlockName.c_str());
commonList = new SgExpression(COMM_LIST, NULL, NULL, commonSymbol);
if (commonStat)
{
SgExpression* lastCommList = commonStat->expr(0);
if (lastCommList)
{
while (lastCommList->rhs())
lastCommList = lastCommList->rhs();
lastCommList->setRhs(commonList);
}
else
{
commonStat->setExpression(0, commonList);
}
}
else
{
commonStat = new SgStatement(COMM_STAT);
commonStat->setFileName(declPlace->fileName());
commonStat->setFileId(declPlace->getFileId());
commonStat->setProject(declPlace->getProject());
commonStat->setlineNumber(getNextNegativeLineNumber());
commonStat->setExpression(0, commonList);
declPlace->insertStmtBefore(*commonStat, *declPlace->controlParent());
}
}
varRefs.push_back(new SgVarRefExp(varSymbol));
if (varRefs.size() > 0)
{
std::reverse(varRefs.begin(), varRefs.end());
SgExpression* varList = makeExprList(varRefs, false);
commonList->setLhs(varList);
}
return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
}
static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
{
if (!exp)
{
return;
}
vector<SgExpression*> subnodes = { exp->lhs(), exp->rhs() };
string expUnparsed;
SgExpression* toAdd = NULL;
if (exp->variant() == ARRAY_REF && CheckConstIndexes(exp->lhs()))
{
cout << st->unparse() << endl;
if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
{
arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
}
st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
return;
}
for (int i = 0; i < 2; i++)
{
if (subnodes[i] && subnodes[i]->variant() == ARRAY_REF && subnodes[i]->symbol()->type()->baseType() && CheckConstIndexes(subnodes[i]->lhs()))
{
expUnparsed = subnodes[i]->unparse();
if (arrayToVariable.find(expUnparsed) == arrayToVariable.end())
{
arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());;
}
toAdd = arrayToVariable[expUnparsed]->copyPtr();
if (toAdd)
{
if (i == 0)
{
exp->setLhs(toAdd);
}
else
{
exp->setRhs(toAdd);
}
}
}
else
{
TransformRightPart(st, subnodes[i], arrayToVariable, variableNumber);
}
}
}
static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
{
if (exp->symbol()->type()->variant() == T_STRING)
return;
string expUnparsed = exp->unparse();
if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
{
arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
}
SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);
newStatement->setFileId(st->getFileId());
newStatement->setProject(st->getProject());
newStatement->setlineNumber(getNextNegativeLineNumber());
newStatement->setLocalLineNumber(st->lineNumber());
st->insertStmtBefore(*newStatement, *st->controlParent());
}
void ArrayConstantPropagation(SgProject& project)
{
unordered_map<string, SgExpression*> arrayToVariable;
int variableNumber = 0;
for (int i = 0; i < project.numberOfFiles(); i++)
{
SgFile* file = &(project.file(i));
if (!file)
continue;
const int funcNum = file->numberOfFunctions();
for (int i = 0; i < funcNum; ++i)
{
SgStatement* st = file->functions(i);
declPlace = st->lexNext();
SgStatement* lastNode = st->lastNodeOfStmt();
for (; st != lastNode; st = st->lexNext())
{
if (st->variant() == ASSIGN_STAT)
{
if (st->expr(1))
{
TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
}
if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()))
{
TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
}
}
else if (st->variant() == FOR_NODE)
{
SgExpression* lowerBound = st->expr(0)->lhs();
SgExpression* upperBound = st->expr(0)->rhs();
string lowerBoundUnparsed = lowerBound->unparse(), upperBoundUnparsed = upperBound->unparse();
if (upperBound->variant() == ARRAY_REF && upperBound->symbol()->type()->baseType() && CheckConstIndexes(upperBound->lhs()))
{
if (arrayToVariable.find(upperBoundUnparsed) == arrayToVariable.end())
{
arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
}
st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
}
if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
{
if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
{
arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
}
st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
}
}
}
}
}
}

4
src/ArrayConstantPropagation/propagation.h
View File

@@ -1,4 +0,0 @@
#pragma once
#include "../Utils/SgUtils.h"
void ArrayConstantPropagation(SgProject& project);

10
src/Distribution/CreateDistributionDirs.cpp
View File

@@ -274,7 +274,7 @@ static void convertTrees(const map<DIST::Array*, int> &treesIn, map<int, vector<
static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR<int, double, attrType> &reducedG, DIST::Arrays<int> &allArrays)
{
DIST::Array *retVal = NULL;
vector<vector<attrType>> coeffsByDims;
vector<vector<attrType>> coefsByDims;
for (auto &array : arrays)
{
vector<int> verts;
@@ -285,7 +285,7 @@ static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR
{
retVal = array;
for (auto &V : verts)
coeffsByDims.push_back(reducedG.GetAllAttributes(V));
coefsByDims.push_back(reducedG.GetAllAttributes(V));
}
else
{
@@ -294,11 +294,11 @@ static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR
toCmp.push_back(reducedG.GetAllAttributes(V));
for (int z = 0; z < toCmp.size(); ++z)
{
if (toCmp[z].size() && coeffsByDims[z].size())
if (toCmp[z].size() && coefsByDims[z].size())
{
if (toCmp[z].back().first.first > coeffsByDims[z].back().first.first)
if (toCmp[z].back().first.first > coefsByDims[z].back().first.first)
{
coeffsByDims = toCmp;
coefsByDims = toCmp;
retVal = array;
break;
}

6
src/Distribution/DvmhDirective.cpp
View File

@@ -45,10 +45,10 @@ static bool findArrayRefAndCheck(SgExpression *ex, const DIST::Array* currArray,
int countOfShadows = 0;
for (int i = 0; i < ref->numberOfSubscripts(); ++i)
{
const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
if (coeffs.size() == 1)
const vector<int*> &coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
if (coefs.size() == 1)
{
const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
const pair<int, int> coef(coefs[0][0], coefs[0][1]);
auto it = shiftsByAccess[i].find(coef);
if (it != shiftsByAccess[i].end())
if (it->second != 0)

12
src/Distribution/DvmhDirectiveBase.cpp
View File

@@ -364,11 +364,11 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
{
if (sharedMemoryParallelization)
{
for (auto& coeffs : currReadOp->first[k].coefficients)
for (auto& coefs : currReadOp->first[k].coefficients)
{
auto currAccess = coeffs.first;
auto currAccess = coefs.first;
const int currShift = coeffs.first.second;
const int currShift = coefs.first.second;
auto itFound = shiftsByAccess[k].find(currAccess);
if (itFound == shiftsByAccess[k].end())
@@ -393,9 +393,9 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
int minShift = 9999999;
int maxShift = -9999999;
for (auto &coeffs : currReadOp->first[k].coefficients)
for (auto &coefs : currReadOp->first[k].coefficients)
{
auto currAccess = coeffs.first;
auto currAccess = coefs.first;
auto result = DIST::Fx(currAccess, currRuleShadow);
if (result.first == loopRule.first)
@@ -417,7 +417,7 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
auto it = remoteRegularReads.find(calcForArray);
if (it == remoteRegularReads.end())
it = remoteRegularReads.insert(it, make_pair(calcForArray, vector<ArrayOp>(calcForArray->GetDimSize())));
it->second[k].coefficients.insert(coeffs);
it->second[k].coefficients.insert(coefs);
}
}

4
src/GraphLoop/graph_loops_base.cpp
View File

@@ -1137,9 +1137,9 @@ static bool isMapped(const vector<ArrayOp> &allOps)
bool mapped = false;
for (auto &ops : allOps)
{
for (auto &coeffs : ops.coefficients)
for (auto &coefs : ops.coefficients)
{
if (coeffs.first.first != 0)
if (coefs.first.first != 0)
{
mapped = true;
break;

34
src/LoopAnalyzer/loop_analyzer.cpp
View File

@@ -247,7 +247,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
}
}
pair<int, int> coeffs = pair<int, int>(0, 0);
pair<int, int> coefs = pair<int, int>(0, 0);
// more than one loop symbol in subscription
if (countOfSymbols > 1)
{
@@ -326,16 +326,16 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
{
if (subscr->symbol()->id() == (parentLoops[position]->doName())->id())
{
coeffs.first = 1;
coefs.first = 1;
needToCacl = false;
}
}
if (needToCacl)
getCoefsOfSubscript(coeffs, subscr, parentLoops[position]->doName());
__spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coeffs.first, coeffs.second);
getCoefsOfSubscript(coefs, subscr, parentLoops[position]->doName());
__spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coefs.first, coefs.second);
if (coeffs.first == 0) // && coeffs.second == 0)
if (coefs.first == 0) // && coefs.second == 0)
{
if (currRegime == REMOTE_ACC)
{
@@ -346,7 +346,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
{
const pair<bool, string> &arrayRefString = constructArrayRefForPrint(arrayRef, dimNum, origSubscr);
__spf_print(1, "WARN: can not calculate index expression for array ref '%s' at line %d\n", arrayRefString.second.c_str(), currLine);
addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
if (side == LEFT)
allPositions.clear();
@@ -371,19 +371,19 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
currOp.resize(numOfSubscriptions);
//add only uniq
auto itAdd = currOp[dimNum].coefficients.find(coeffs);
auto itAdd = currOp[dimNum].coefficients.find(coefs);
if (itAdd == currOp[dimNum].coefficients.end())
itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coeffs, currentW));
itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coefs, currentW));
}
if (coeffs.first < 0)
if (coefs.first < 0)
addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_TRUE, currLine, numOfSubscriptions);
else
//if we found regular access to array - set it false
addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_FALSE, currLine, numOfSubscriptions);
}
if (coeffs.first < 0 && sharedMemoryParallelization == 0)
if (coefs.first < 0 && sharedMemoryParallelization == 0)
{
if (currRegime == DATA_DISTR)
{
@@ -402,15 +402,15 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
if (side == LEFT)
allPositions.clear();
else
addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
}
}
else
{
if (side == LEFT)
addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, WRITE_OP, numOfSubscriptions, currentW);
addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, WRITE_OP, numOfSubscriptions, currentW);
else
addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, READ_OP, numOfSubscriptions, currentW);
addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, READ_OP, numOfSubscriptions, currentW);
}
}
}
@@ -418,13 +418,13 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
if (currRegime == ARRAY_ACC_CORNER)
{
int *valueSubs = new int[2];
valueSubs[0] = coeffs.first;
valueSubs[1] = coeffs.second;
valueSubs[0] = coefs.first;
valueSubs[1] = coefs.second;
#ifdef __SPF
addToCollection(__LINE__, __FILE__, valueSubs, 2);
#endif
const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
if (coeffs.size() == 0)
const vector<int*> &coefs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
if (coefs.size() == 0)
{
subscr->addAttribute(INT_VAL, valueSubs, sizeof(int*));
if (position != -1 && allPositions.size() == 1 && position < parentLoops.size())

567
src/ParallelizationRegions/parse_merge_dirs.cpp Normal file
View File

@@ -0,0 +1,567 @@
#include "parse_merge_dirs.h"
#include <unordered_set>
using std::map;
using std::pair;
using std::string;
using std::unordered_map;
using std::unordered_set;
using std::vector;
static void parseMergeDirective(const char *comment,
vector<pair<string, string>> &parsed_mapping)
{
while (comment)
{
auto *line_end = strchr(comment, '\n');
static const char prefix[] = "!!SPF TRANSFORM(MERGE_ARRAYS(";
static const auto compare_chars = sizeof(prefix) - 1;
if (strncasecmp(comment, prefix, compare_chars) == 0)
{
auto *pair_start = comment + compare_chars;
auto *comma = strchr(pair_start, ',');
if (comma)
{
auto *close_br = strchr(comma + 1, ')');
if (close_br)
{
parsed_mapping.emplace_back(
string(pair_start, comma - pair_start),
string(comma + 1, close_br - comma - 1));
}
}
}
comment = line_end;
if (comment)
comment++;
}
}
static string getNonDefaultRegion(DIST::Array *a)
{
string result;
if (!a)
return result;
for (const auto &reg_name : a->GetRegionsName())
{
if (reg_name != "default")
{
if (!result.empty())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
result = reg_name;
}
}
return result;
}
static bool hasSameSizes(DIST::Array *a, DIST::Array *b)
{
for (auto *array : {a, b})
{
for (const auto &p : array->GetSizes())
{
if (p.first < 0 || p.second < 0)
return false;
}
}
return a->GetSizes() == b->GetSizes() && a->GetTypeSize() == b->GetTypeSize();
}
static bool checkSimilarTemplates(vector<ParallelRegion *> &regions,
const unordered_map<string, string> &new_region_mapping)
{
// new region -> old regions
unordered_map<string, unordered_set<string>> new_region_inverse_mapping;
for (const auto &p : new_region_mapping)
new_region_inverse_mapping[p.second].insert(p.first);
for (const auto &new_reg : new_region_inverse_mapping)
{
DIST::Array *template_array = nullptr;
string first_reg_name;
for (const auto &old_region_name : new_reg.second)
{
auto *old_reg = getRegionByName(regions, old_region_name);
if (!old_reg)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
const auto &distr_rules = old_reg->GetDataDir().GetDistrRules();
if (distr_rules.size() != 1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto *current_template = distr_rules.front().first;
if (template_array)
{
if (!hasSameSizes(template_array, current_template))
{
__spf_print(1, "Templates of %s and %s has different sizes\n",
first_reg_name.c_str(),
old_region_name.c_str());
return false;
}
// else everything OK
}
else
{
template_array = current_template;
first_reg_name = old_region_name;
}
}
}
return true;
}
static bool hasSameAlignment(const std::unordered_set<const AlignRule *> &align_a,
const std::unordered_set<const AlignRule *> &align_b)
{
if (align_a.size() != 1 || align_b.size() != 1)
return false;
const auto *rule_a = *align_a.begin();
const auto *rule_b = *align_b.begin();
if (rule_a->alignRule != rule_b->alignRule)
return false;
return true;
}
static void printExpr(SgExpression *e, string pad)
{
if (!e)
return;
__spf_print(1, "%s%d: %s\n", pad.c_str(), e->variant(), e->unparse());
printExpr(e->lhs(), pad + " ");
printExpr(e->rhs(), pad + " ");
}
static pair<vector<SgStatement *>, SgSymbol *> generateDeclaration(const string &array_name, const string &common_block_name,
const vector<pair<int, int>> &sizes, SgType *type, SgStatement *scope)
{
auto *array_symbol = new SgSymbol(VARIABLE_NAME, array_name.c_str(), new SgType(T_ARRAY), scope);
auto *decl = new SgDeclarationStatement(VAR_DECL);
decl->setExpression(1, new SgTypeExp(*type));
SgExpression *subs = new SgExprListExp();
auto *array_ref = new SgArrayRefExp(*array_symbol, *subs);
for (int i = 0; i < sizes.size(); i++)
{
const auto &p = sizes[i];
auto *d = new SgExpression(DDOT, new SgValueExp(p.first), new SgValueExp(p.second));
subs->setLhs(d);
if (i + 1 < sizes.size())
{
subs->setRhs(new SgExprListExp());
subs = subs->rhs();
}
}
decl->setExpression(0, array_ref);
auto comm = new SgStatement(COMM_STAT);
comm->setExpression(0, new SgExpression(COMM_LIST,
new SgVarRefExp(array_symbol),
NULL,
new SgSymbol(COMMON_NAME, common_block_name.c_str())));
return {{decl, comm}, array_symbol};
}
SgSymbol *insertDeclIfNeeded(const string &array_name,
const string &common_block_name,
DIST::Array *example_array,
FuncInfo *dest,
unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
{
if (SgFile::switchToFile(dest->fileName) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto &by_func = inserted_arrays[dest];
auto it = by_func.find(array_name);
if (it != by_func.end())
return it->second;
SgStatement *st = dest->funcPointer;
auto *end = st->lastNodeOfStmt();
st = st->lexNext();
while (st != end && !isSgExecutableStatement(st))
{
st = st->lexNext();
}
auto generated = generateDeclaration(array_name, common_block_name,
example_array->GetSizes(),
SgTypeInt(), dest->funcPointer);
for (auto *new_stmt : generated.first)
st->insertStmtBefore(*new_stmt, *dest->funcPointer);
by_func[array_name] = generated.second;
return generated.second;
}
static pair<string, string> createNewArray(DIST::Array *example_array, const string &base_name,
const map<string, vector<FuncInfo *>> &allFuncInfo,
unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
{
auto common_block_name = base_name + "_merge_cb";
auto array_name = base_name;
for (const auto &by_file : allFuncInfo)
{
for (auto *func_info : by_file.second)
{
if (func_info->isMain)
{
insertDeclIfNeeded(
array_name,
common_block_name,
example_array,
func_info,
inserted_arrays);
}
}
}
return std::make_pair(array_name, common_block_name);
}
static void replaceArrayRec(SgExpression *e,
const unordered_set<string> &arrays_to_replace,
SgSymbol **func_symbol_hint,
const pair<string, string> &replace_by,
DIST::Array *example_array,
FuncInfo *func,
unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
{
if (!e)
return;
if (isArrayRef(e) && arrays_to_replace.find(e->symbol()->identifier()) != arrays_to_replace.end())
{
if (!(*func_symbol_hint))
{
*func_symbol_hint = insertDeclIfNeeded(
replace_by.first, replace_by.second,
example_array,
func,
inserted_arrays);
}
e->setSymbol(*func_symbol_hint);
}
replaceArrayRec(
e->lhs(),
arrays_to_replace,
func_symbol_hint,
replace_by,
example_array,
func,
inserted_arrays);
replaceArrayRec(
e->rhs(),
arrays_to_replace,
func_symbol_hint,
replace_by,
example_array,
func,
inserted_arrays);
}
static void replaceRegion(SgStatement* st, const unordered_map<string, string> &new_region_mapping)
{
if (!st)
return;
if(isSPF_stat(st) && st->variant() == SPF_PARALLEL_REG_DIR)
{
auto it = new_region_mapping.find(st->symbol()->identifier());
if (it != new_region_mapping.end())
st->setSymbol(*(new SgSymbol(CONST_NAME, it->second.c_str())));
}
}
void mergeCopyArrays(vector<ParallelRegion *> &regions, const map<string, vector<FuncInfo *>> &allFuncInfo)
{
for (const auto *region : regions)
{
__spf_print(1, "region %s\n", region->GetName().c_str());
const auto &dirs = region->GetDataDir();
__spf_print(1, " distr rules: %d\n", dirs.distrRules.size());
const auto &currentVariant = region->GetCurrentVariant();
int distr_idx = 0;
for (const auto &distr : dirs.distrRules)
{
const auto &dist_rule = distr.second.back().distRule;
string sizes;
for (const auto &p : distr.first->GetSizes())
{
if (!sizes.empty())
sizes.push_back(',');
sizes += std::to_string(p.first) + ":" + std::to_string(p.second);
}
__spf_print(1, " DIST %s(%s)", distr.first->GetName().c_str(), sizes.c_str());
for (const auto &dim : dist_rule)
__spf_print(1, " %c", dim == dist::BLOCK ? 'B' : '*');
__spf_print(1, "\n");
distr_idx++;
}
__spf_print(1, " align rules: %d\n", dirs.alignRules.size());
for (const auto &align : dirs.alignRules)
{
string sub_a, sub_b;
int i = 0;
for (const auto coefs : align.alignRule)
{
if (!sub_a.empty())
sub_a.push_back(',');
sub_a += std::to_string(coefs.first) + "*i" +
std::to_string(i) + "+" + std::to_string(coefs.second);
i++;
}
for (const auto coefs : align.alignRuleWith)
{
if (!sub_b.empty())
sub_b.push_back(',');
sub_b += std::to_string(coefs.second.first) + "*i" +
std::to_string(coefs.first) + "+" + std::to_string(coefs.second.second);
}
__spf_print(1, " ALIGN %s(%s) WITH %s(%s)\n",
align.alignArray->GetName().c_str(), sub_a.c_str(),
align.alignWith->GetName().c_str(), sub_b.c_str());
}
}
// parse directives
// new array name -> current arrays
unordered_map<string, unordered_set<DIST::Array *>> arrays_to_merge;
unordered_map<DIST::Array *, unordered_set<const AlignRule *>> array_alignment;
for (const auto &by_file : allFuncInfo)
{
const auto current_file_name = by_file.first;
if (SgFile::switchToFile(current_file_name) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
for (auto *func_info : by_file.second)
{
SgStatement *curr_stmt = func_info->funcPointer;
if (!curr_stmt)
continue;
auto *stmt_end = curr_stmt->lastDeclaration();
if (!stmt_end)
continue;
stmt_end = stmt_end->lexNext();
for (; curr_stmt && curr_stmt != stmt_end; curr_stmt = curr_stmt->lexNext())
{
if (curr_stmt->comments())
{
vector<pair<string, string>> parsed_mapping;
parseMergeDirective(curr_stmt->comments(), parsed_mapping);
for (const auto &p : parsed_mapping)
{
auto *found_array = getArrayFromDeclarated(curr_stmt, p.first);
if (found_array)
{
arrays_to_merge[p.second].insert(found_array);
array_alignment[found_array] = {};
}
}
}
}
}
}
// find alignment rules for array
for (const auto *region : regions)
{
const auto &dirs = region->GetDataDir();
for (const auto &align : dirs.alignRules)
{
auto it = array_alignment.find(align.alignArray);
if (it != array_alignment.end())
it->second.insert(&align);
}
}
// old region -> new region
unordered_map<string, string> new_region_mapping;
// new array -> new region
unordered_map<string, string> arrays_new_region_mapping;
vector<string> created_region_names;
for (const auto &by_new_array : arrays_to_merge)
{
string new_region_name;
for (auto *current_array : by_new_array.second)
{
auto current_array_region = getNonDefaultRegion(current_array);
auto it = new_region_mapping.find(current_array_region);
if (it != new_region_mapping.end())
{
if (new_region_name.empty())
new_region_name = it->second;
else if (new_region_name != it->second)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
}
}
if (new_region_name.empty())
{
new_region_name = "merged_reg_" + std::to_string(created_region_names.size());
created_region_names.push_back(new_region_name);
}
for (auto *current_array : by_new_array.second)
{
auto current_array_region = getNonDefaultRegion(current_array);
new_region_mapping[current_array_region] = new_region_name;
}
arrays_new_region_mapping[by_new_array.first] = new_region_name;
}
if (!checkSimilarTemplates(regions, new_region_mapping))
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> inserted_arrays;
for (const auto &by_dest_array : arrays_to_merge)
{
const auto &copy_arrays = by_dest_array.second;
if (copy_arrays.empty())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto *first_element = *copy_arrays.begin();
auto first_elem_rules_it = array_alignment.find(first_element);
if (first_elem_rules_it == array_alignment.end())
continue;
const auto &first_elem_rules = first_elem_rules_it->second;
for (auto *array_to_merge : copy_arrays)
{
auto array_rules_it = array_alignment.find(array_to_merge);
if (array_rules_it == array_alignment.end())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
const auto &array_rules = array_rules_it->second;
if (!hasSameSizes(array_to_merge, first_element) || !hasSameAlignment(first_elem_rules, array_rules))
{
__spf_print(1, "Arrays %s and %s has different sizes or align rules\n",
array_to_merge->GetName().c_str(),
first_element->GetName().c_str());
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
}
}
__spf_print(1, "merge into %s (%s):\n", by_dest_array.first.c_str(), arrays_new_region_mapping[by_dest_array.first].c_str());
for (auto *array_to_merge : copy_arrays)
__spf_print(1, "%s\n", array_to_merge->GetName().c_str());
auto created_array_info = createNewArray(first_element, by_dest_array.first, allFuncInfo, inserted_arrays);
unordered_set<string> arrays_to_replace;
for (auto *array_to_merge : copy_arrays)
arrays_to_replace.insert(array_to_merge->GetShortName());
for (const auto &by_file : allFuncInfo)
{
if (SgFile::switchToFile(by_file.first) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
for (auto *func_info : by_file.second)
{
SgSymbol *func_symbol_hint = nullptr;
SgStatement *st = func_info->funcPointer;
auto *func_end = st->lastNodeOfStmt();
st = st->lexNext();
while (st && !isSgExecutableStatement(st) && st != func_end)
st = st->lexNext();
while (st && st != func_end)
{
for (int i = 0; i < 3; i++)
{
replaceArrayRec(
st->expr(i),
arrays_to_replace,
&func_symbol_hint,
created_array_info,
first_element,
func_info,
inserted_arrays);
}
replaceRegion(st, new_region_mapping);
st = st->lexNext();
}
}
}
}
}

8
src/ParallelizationRegions/parse_merge_dirs.h Normal file
View File

@@ -0,0 +1,8 @@
#include "../GraphCall/graph_calls.h"
#include "ParRegions.h"
#include <string>
#include <vector>
#include <map>
void mergeCopyArrays(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo);

16
src/Predictor/PredictScheme.cpp
View File

@@ -326,7 +326,7 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
list = list->rhs();
}
vector<pair<int, int>> coeffs(srcSymbs.size());
vector<pair<int, int>> coefs(srcSymbs.size());
list = listTgt;
while (list)
{
@@ -337,8 +337,8 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
has = recSymbolFind(exp, srcSymbs[z].first, VAR_REF);
if (has)
{
getCoefsOfSubscript(coeffs[z], exp, srcSymbs[z].second);
if (coeffs[z].first == 0)
getCoefsOfSubscript(coefs[z], exp, srcSymbs[z].second);
if (coefs[z].first == 0)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
break;
}
@@ -346,14 +346,14 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
list = list->rhs();
}
for (int z = 0; z < coeffs.size(); ++z)
for (int z = 0; z < coefs.size(); ++z)
{
if (coeffs[z].first == 0)
if (coefs[z].first == 0)
continue;
if (coeffs[z].second)
align["rules"].push_back({ z, coeffs[z].first });
if (coefs[z].second)
align["rules"].push_back({ z, coefs[z].first });
else
align["rules"].push_back({ z, coeffs[z].first, coeffs[z].second });
align["rules"].push_back({ z, coefs[z].first, coefs[z].second });
}
return align;
}

54
src/PrivateAnalyzer/private_arrays_search.cpp
View File

@@ -16,34 +16,6 @@
using namespace std;
static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
{
ArrayAccessingIndexes resultContainer;
unordered_set<string> toRemove;
for (auto& [arrayName, accessingSet] : container)
{
vector<vector<ArrayDimension>> points;
for (auto& arrayPoint : accessingSet.GetElements())
{
if (!arrayPoint.empty())
points.push_back(arrayPoint);
}
if (points.size() < accessingSet.GetElements().size() && !points.empty())
resultContainer[arrayName] = points;
if (points.empty())
toRemove.insert(arrayName);
}
for (const string& name : toRemove)
container.erase(name);
for (auto& [arrayName, accessingSet] : resultContainer)
container[arrayName] = accessingSet;
}
static void Collapse(Region* region)
{
if (region->getBasickBlocks().empty())
@@ -66,13 +38,13 @@ static void Collapse(Region* region)
region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
}
}
ArrayAccessingIndexes useUnion;
for (auto& byBlock : region->getBasickBlocks())
for (auto& [arrayName, arrayRanges] : byBlock->array_use)
useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
region->array_priv = region->array_use;
for (auto& [arrayName, arrayRanges] : useUnion)
region->array_priv[arrayName] = useUnion[arrayName].Diff(region->array_use[arrayName]);
for (Region* prevBlock : region->getHeader()->getPrevRegions())
prevBlock->replaceInNextRegions(region, region->getHeader());
@@ -103,7 +75,6 @@ static void SolveDataFlowIteratively(Region* DFG)
newIn.clear();
continue;
}
for (const auto& [arrayName, accessSet] : prevBlock->array_out)
{
if (newIn.find(arrayName) != newIn.end())
@@ -116,7 +87,6 @@ static void SolveDataFlowIteratively(Region* DFG)
b->array_in = move(newIn);
ArrayAccessingIndexes newOut;
if (b->array_def.empty())
newOut = b->array_in;
else if (b->array_in.empty())
@@ -152,7 +122,22 @@ static void SolveDataFlow(Region* DFG)
Collapse(DFG);
}
static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
unsigned long long CalculateLength(const AccessingSet& array)
{
if (array.GetElements().empty())
return 0;
unsigned long long result = 1;
for (const auto& range : array.GetElements())
{
for (const auto& dim : range)
{
result *= (dim.step * dim.tripCount);
}
}
return result;
}
void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
{
SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
spfStat->setlineNumber(loop->loop->lineNumber());
@@ -203,8 +188,6 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*
SgFile::switchToFile(fileName);
for (const auto& loop : loops)
{
if (!loop->isFor())
continue;
SgStatement* search_func = loop->loop->GetOriginal();
while (search_func && (!isSgProgHedrStmt(search_func)))
@@ -221,7 +204,6 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*
continue;
}
SolveDataFlow(loopRegion);
RemoveEmptyPoints(loopRegion->array_priv);
result[loop] = loopRegion->array_priv;
delete(loopRegion);
}

17
src/PrivateAnalyzer/range_structures.cpp
View File

@@ -64,13 +64,18 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array});
/* add the parts between intersection steps */
if (intersection->step > dim1.step)
{
uint64_t start = (intersection->start - dim1.start) / dim1.step;
uint64_t interValue = intersection->start;
for (int64_t i = start; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
for (int64_t i = start; dim1.start + i * dim1.step <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
{
result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
uint64_t centerValue = dim1.start + i * dim1.step;
if (centerValue == interValue)
{
if (i - start > 1)
{
result.push_back({ dim1.start + (start + 1) * dim1.step, dim1.step, i - start - 1, dim1.array });
start = i;
}
interValue += intersection->step;
}
}
@@ -211,10 +216,6 @@ void AccessingSet::Insert(const vector<ArrayDimension>& element)
}
AccessingSet AccessingSet::Union(const AccessingSet& source) {
if (source.GetElements().empty())
return *this;
if (allElements.empty())
return source;
AccessingSet result;
for (auto& element : source.GetElements())
result.Insert(element);

64
src/PrivateAnalyzer/region.cpp
View File

@@ -4,7 +4,6 @@
#include<unordered_map>
#include<string>
#include <numeric>
#include <iostream>
#include "range_structures.h"
#include "region.h"
@@ -105,33 +104,15 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
auto operation = instruction->getInstruction()->getOperation();
auto type = instruction->getInstruction()->getArg1()->getType();
if (operation == SAPFOR::CFG_OP::ASSIGN && instruction->getInstruction()->getResult()->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY)
{
SgStatement* op = instruction->getInstruction()->getOperator();
if (op && op->expr(0) && isArrayRef(op->expr(0)) && op->expr(0)->symbol() && op->expr(0)->type())
{
if (isSgArrayType(op->expr(0)->symbol()->type()))
{
SgArrayType* arrayType = (SgArrayType*)op->expr(0)->symbol()->type();
int dimCount = ((SgArrayType*)op->expr(0)->symbol()->type())->dimension();
vector<ArrayDimension> point;
for (int i = 0; i < dimCount; i++)
{
string strDimLength = arrayType->sizeInDim(i)->unparse();
if (arrayType->sizeInDim(i)->variant() == INT_VAL && strDimLength != "0")
point.push_back({ 1ULL, 1ULL, (uint64_t)stoi(strDimLength), (SgArrayRefExp*)op->expr(0) });
}
if (point.size() == dimCount)
def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({point});
}
}
}
if ((operation == SAPFOR::CFG_OP::STORE || operation == SAPFOR::CFG_OP::LOAD) && type == SAPFOR::CFG_ARG_TYPE::ARRAY)
{
vector<SAPFOR::Argument*> index_vars;
vector<int> refPos;
string array_name = instruction->getInstruction()->getArg1()->getValue();
string array_name;
if (operation == SAPFOR::CFG_OP::STORE)
array_name = instruction->getInstruction()->getArg1()->getValue();
else
array_name = instruction->getInstruction()->getArg2()->getValue();
int j = i - 1;
while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
@@ -146,12 +127,25 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
vector<ArrayDimension> accessPoint(n);
auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
vector<pair<int, int>> coefsForDims;
for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
{
const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
if (coefs.size() == 1)
{
const pair<int, int> coef(coefs[0][0], coefs[0][1]);
coefsForDims.push_back(coef);
}
}
int fillCount = 0;
while (!index_vars.empty() && !refPos.empty())
while (!index_vars.empty() && !refPos.empty() && !coefsForDims.empty())
{
auto var = index_vars.back();
int currentVarPos = refPos.back();
pair<int, int> currentCoefs = coefsForDims.back();
ArrayDimension current_dim;
if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
current_dim = { stoul(var->getValue()), 1, 1, ref};
@@ -180,19 +174,16 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
return -1;
}
uint64_t start = currentLoop->startVal;
uint64_t step = currentLoop->stepVal;
uint64_t iters = currentLoop->calculatedCountOfIters;
current_dim = { start, step, iters, ref };
uint64_t start = currentLoop->startVal * currentCoefs.first + currentCoefs.second;
uint64_t step = currentCoefs.first;
current_dim = { start, step, (uint64_t)currentLoop->calculatedCountOfIters, ref };
}
if (current_dim.start != 0 && current_dim.step != 0 && current_dim.tripCount != 0)
{
accessPoint[n - index_vars.size()] = current_dim;
fillCount++;
}
index_vars.pop_back();
refPos.pop_back();
coefsForDims.pop_back();
}
if (fillCount == accessPoint.size())
@@ -239,11 +230,8 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
region->addBasickBlocks(bbToRegion.at(block));
for (LoopGraph* childLoop : loop->children)
{
if (!childLoop->isFor())
continue;
region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
}
return region;
}
@@ -262,9 +250,5 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
SetConnections(bbToRegion, blockSet);
//create subRegions
for (LoopGraph* childLoop : loop->children)
{
if (!childLoop->isFor())
continue;
subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
}
}

17
src/Sapfor.cpp
View File

@@ -23,6 +23,7 @@
#include "ParallelizationRegions/ParRegions_func.h"
#include "ParallelizationRegions/resolve_par_reg_conflicts.h"
#include "ParallelizationRegions/expand_extract_reg.h"
#include "ParallelizationRegions/parse_merge_dirs.h"
#include "Distribution/Distribution.h"
#include "Distribution/GraphCSR.h"
@@ -46,7 +47,6 @@
#include "DynamicAnalysis/gCov_parser_func.h"
#include "DynamicAnalysis/createParallelRegions.h"
#include "ArrayConstantPropagation/propagation.h"
#include "DirectiveProcessing/directive_analyzer.h"
#include "DirectiveProcessing/directive_creator.h"
#include "DirectiveProcessing/insert_directive.h"
@@ -90,7 +90,6 @@
#include "Transformations/DeadCodeRemoving/dead_code.h"
#include "Transformations/RenameSymbols/rename_symbols.h"
#include "Transformations/FunctionInlining/inliner.h"
#include "Transformations/MoveOperators/move_operators.h"
#include "ProjectParameters/projectParameters.h"
@@ -942,8 +941,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
internalExit = err;
}
}
else if (curr_regime == MOVE_OPERATORS)
moveOperators(file, loopGraph, fullIR, countOfTransform);
else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
{
auto itFound = loopGraph.find(file->filename());
@@ -1040,8 +1037,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
PRIVATE_REMOVING,
PRIVATE_ARRAYS_EXPANSION,
PRIVATE_ARRAYS_SHRINKING,
REMOVE_DEAD_CODE,
MOVE_OPERATORS };
REMOVE_DEAD_CODE };
if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
{
@@ -1922,9 +1918,10 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
transformAssumedSizeParameters(allFuncInfo);
else if (curr_regime == FIND_PRIVATE_ARRAYS_ANALYSIS)
FindPrivateArrays(loopGraph, fullIR, insertedPrivates);
else if (curr_regime == ARRAY_PROPAGATION)
ArrayConstantPropagation(project);
else if (curr_regime == MERGE_COPY_ARRAYS)
{
mergeCopyArrays(parallelRegions, allFuncInfo);
}
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.;
@@ -2343,7 +2340,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 MOVE_OPERATORS:
runAnalysis(*project, curr_regime, true, "", folderName);
break;
case INLINE_PROCEDURES:
@@ -2379,6 +2375,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
case FIX_COMMON_BLOCKS:
case TEST_PASS:
case SET_IMPLICIT_NONE:
case MERGE_COPY_ARRAYS:
runAnalysis(*project, curr_regime, false);
case SUBST_EXPR_RD_AND_UNPARSE:
case SUBST_EXPR_AND_UNPARSE:

8
src/Sapfor.h
View File

@@ -88,6 +88,8 @@ enum passes {
REMOVE_DVM_INTERVALS,
VERIFY_DVM_DIRS,
MERGE_COPY_ARRAYS,
REMOVE_DIST_ARRAYS_FROM_IO,
SUBST_EXPR,
@@ -122,8 +124,6 @@ enum passes {
CREATE_INTER_TREE,
INSERT_INTER_TREE,
MOVE_OPERATORS,
SHADOW_GROUPING,
INLINE_PROCEDURES,
FILL_PARALLEL_REG_IR,
@@ -189,7 +189,6 @@ enum passes {
FIND_PRIVATE_ARRAYS,
TRANSFORM_ASSUMED_SIZE_PARAMETERS,
ARRAY_PROPAGATION,
TEST_PASS,
EMPTY_PASS
@@ -273,6 +272,7 @@ static void setPassValues()
passNames[VERIFY_DVM_DIRS] = "VERIFY_DVM_DIRS";
passNames[REMOVE_DVM_DIRS_TO_COMMENTS] = "REMOVE_DVM_DIRS_TO_COMMENTS";
passNames[REMOVE_SPF_DIRS] = "REMOVE_SPF_DIRS";
passNames[MERGE_COPY_ARRAYS] = "MERGE_COPY_ARRAYS";
passNames[REMOVE_DIST_ARRAYS_FROM_IO] = "REMOVE_DIST_ARRAYS_FROM_IO";
passNames[SUBST_EXPR] = "SUBST_EXPR";
passNames[SUBST_EXPR_RD] = "SUBST_EXPR_RD";
@@ -323,7 +323,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[MOVE_OPERATORS] = "MOVE_OPERATORS";
passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";
@@ -380,7 +379,6 @@ static void setPassValues()
passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";
passNames[TRANSFORM_ASSUMED_SIZE_PARAMETERS] = "TRANSFORM_ASSUMED_SIZE_PARAMETERS";
passNames[ARRAY_PROPAGATION] = "ARRAY_PROPAGATION";
passNames[TEST_PASS] = "TEST_PASS";
}

66
src/Transformations/LoopCombining/loops_combiner.cpp
View File

@@ -1123,7 +1123,7 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
for (int d = 0; d < dimensions; ++d)
{
//по измерениям массива отображение на цикл вложенности d
vector<set<pair<int, int>>> coeffsRead[2], coeffsWrite[2];
vector<set<pair<int, int>>> coefsRead[2], coefsWrite[2];
checkNull(currLoop[0], convertFileName(__FILE__).c_str(), __LINE__);
checkNull(currLoop[1], convertFileName(__FILE__).c_str(), __LINE__);
@@ -1133,31 +1133,31 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
auto it = currLoop[k]->readOpsForLoop.find(array);
if (it != currLoop[k]->readOpsForLoop.end())
{
if (coeffsRead[k].size() == 0)
coeffsRead[k].resize(it->second.size());
if (coefsRead[k].size() == 0)
coefsRead[k].resize(it->second.size());
for (int z = 0; z < it->second.size(); ++z)
if (it->second[z].coefficients.size())
for (auto& coef : it->second[z].coefficients)
coeffsRead[k][z].insert(coef.first);
coefsRead[k][z].insert(coef.first);
}
auto itW = currLoop[k]->writeOpsForLoop.find(array);
if (itW != currLoop[k]->writeOpsForLoop.end())
{
if (coeffsWrite[k].size() == 0)
coeffsWrite[k].resize(itW->second.size());
if (coefsWrite[k].size() == 0)
coefsWrite[k].resize(itW->second.size());
for (int z = 0; z < itW->second.size(); ++z)
if (itW->second[z].coefficients.size())
for (auto& coef : itW->second[z].coefficients)
coeffsWrite[k][z].insert(coef.first);
coefsWrite[k][z].insert(coef.first);
}
}
//нет записей, значит нет зависимости
bool nulWrite = true;
for (auto& wr : coeffsWrite)
for (auto& wr : coefsWrite)
for (auto& elem : wr)
if (elem.size() != 0)
nulWrite = false;
@@ -1168,62 +1168,62 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
// если чтение в одном цикле и запись (и наоборот) в другом идут по разным правилам, то пока что это зависимость.
// здесь можно уточнить.
const int len = std::max(coeffsWrite[0].size(), coeffsRead[0].size());
const int len = std::max(coefsWrite[0].size(), coefsRead[0].size());
int countW[2] = { 0, 0 };
int countR[2] = { 0, 0 };
for (int L = 0; L < 2; ++L)
for (int z = 0; z < coeffsWrite[L].size(); ++z)
countW[L] += (coeffsWrite[L][z].size() ? 1 : 0);
for (int z = 0; z < coefsWrite[L].size(); ++z)
countW[L] += (coefsWrite[L][z].size() ? 1 : 0);
for (int L = 0; L < 2; ++L)
for (int z = 0; z < coeffsRead[L].size(); ++z)
countR[L] += (coeffsRead[L][z].size() ? 1 : 0);
for (int z = 0; z < coefsRead[L].size(); ++z)
countR[L] += (coefsRead[L][z].size() ? 1 : 0);
for (int p = 0; p < len; ++p)
{
if (coeffsWrite[1].size() && coeffsWrite[0].size())
if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() != 0)
if (coeffsWrite[0][p] != coeffsWrite[1][p])
if (coefsWrite[1].size() && coefsWrite[0].size())
if (coefsWrite[0][p].size() != 0 && coefsWrite[1][p].size() != 0)
if (coefsWrite[0][p] != coefsWrite[1][p])
return true;
if (coeffsRead[1].size() && coeffsWrite[0].size())
if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() != 0)
if (coeffsWrite[0][p] != coeffsRead[1][p])
if (coefsRead[1].size() && coefsWrite[0].size())
if (coefsWrite[0][p].size() != 0 && coefsRead[1][p].size() != 0)
if (coefsWrite[0][p] != coefsRead[1][p])
return true;
if (coeffsWrite[1].size() && coeffsRead[0].size())
if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() != 0)
if (coeffsWrite[1][p] != coeffsRead[0][p])
if (coefsWrite[1].size() && coefsRead[0].size())
if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() != 0)
if (coefsWrite[1][p] != coefsRead[0][p])
return true;
//отображение на разные измерения
if (coeffsWrite[1].size() && coeffsWrite[0].size())
if (coefsWrite[1].size() && coefsWrite[0].size())
{
if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() == 0 && countW[1] ||
coeffsWrite[0][p].size() == 0 && coeffsWrite[1][p].size() != 0 && countW[0])
if (coefsWrite[0][p].size() != 0 && coefsWrite[1][p].size() == 0 && countW[1] ||
coefsWrite[0][p].size() == 0 && coefsWrite[1][p].size() != 0 && countW[0])
return true;
}
if (coeffsRead[1].size() && coeffsWrite[0].size())
if (coefsRead[1].size() && coefsWrite[0].size())
{
if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() == 0 && countR[1] ||
coeffsWrite[0][p].size() == 0 && coeffsRead[1][p].size() != 0 && countW[0])
if (coefsWrite[0][p].size() != 0 && coefsRead[1][p].size() == 0 && countR[1] ||
coefsWrite[0][p].size() == 0 && coefsRead[1][p].size() != 0 && countW[0])
return true;
}
if (coeffsWrite[1].size() && coeffsRead[1].size())
if (coefsWrite[1].size() && coefsRead[1].size())
{
if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() == 0 && countR[0] ||
coeffsWrite[1][p].size() == 0 && coeffsRead[0][p].size() != 0 && countW[1])
if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() == 0 && countR[0] ||
coefsWrite[1][p].size() == 0 && coefsRead[0][p].size() != 0 && countW[1])
return true;
}
//где то нет правил отображения вообще, но есть факт его наличия.
if ( ((coeffsWrite[0].size() == 0 && coeffsRead[0].size() == 0) && (countW[0] == 0 && countR[0] == 0))
if ( ((coefsWrite[0].size() == 0 && coefsRead[0].size() == 0) && (countW[0] == 0 && countR[0] == 0))
||
((coeffsWrite[1].size() == 0 && coeffsRead[1].size() == 0) && (countW[1] == 0 && countR[1] == 0)) )
((coefsWrite[1].size() == 0 && coefsRead[1].size() == 0) && (countW[1] == 0 && countR[1] == 0)) )
return true;
}

826
src/Transformations/MoveOperators/move_operators.cpp
View File

@@ -1,826 +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 "move_operators.h"
using namespace std;
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())
result.push_back(instruction);
}
}
return result;
}
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;
set<string> usedVars;
set<string> definedVars;
int lineNumber;
bool isMovable;
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 (parent->variant() == LOGIF_NODE) {
if (stmt->lineNumber() == parent->lineNumber())
return true;
SgStatement* current = parent;
SgStatement* lastNode = parent->lastNodeOfStmt();
while (current && current != lastNode) {
if (current == stmt)
return true;
if (current->isIncludedInStmt(*stmt))
return true;
current = current->lexNext();
}
}
if (parent->isIncludedInStmt(*stmt))
return true;
return false;
}
static bool isLoopBoundary(SgStatement* stmt) {
if (!stmt)
return false;
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;
SgStatement* loopStart = loop->lexNext();
SgStatement* loopEnd = loop->lastNodeOfStmt();
if (!loopStart || !loopEnd)
return false;
if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber())
return false;
SgStatement* current = loopStart;
while (current && current != loopEnd) {
if (current->variant() == FOR_NODE && current != loop) {
SgForStmt* nestedLoop = (SgForStmt*)current;
SgStatement* nestedStart = nestedLoop->lexNext();
SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
if (nestedStart && nestedEnd &&
stmt->lineNumber() >= nestedStart->lineNumber() &&
stmt->lineNumber() <= nestedEnd->lineNumber()) {
return true;
}
}
current = current->lexNext();
}
return false;
}
static bool canSafelyExtract(SgStatement* stmt, SgForStmt* loop) {
if (!stmt || !loop)
return false;
if (isLoopBoundary(stmt))
return false;
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;
SgStatement* current = loopStart;
while (current && current != loopEnd) {
if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber())
return false;
if (control_tags.find(current->variant()) != control_tags.end())
if (isStatementEmbedded(stmt, current))
return false;
if (current == stmt)
break;
current = current->lexNext();
}
return true;
}
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)
return operators;
SgStatement* current = loopStart;
unordered_set<SgStatement*> visited;
while (current && current != loopEnd) {
if (visited.find(current) != visited.end())
break;
visited.insert(current);
if (isLoopBoundary(current)) {
current = current->lexNext();
continue;
}
if (current->variant() == FOR_NODE && current != loop) {
SgStatement* nestedEnd = current->lastNodeOfStmt();
if (nestedEnd)
current = nestedEnd->lexNext();
else
current = current->lexNext();
continue;
}
if (isSgExecutableStatement(current)) {
if (control_tags.find(current->variant()) != control_tags.end()) {
current = current->lexNext();
continue;
}
if (current->variant() != ASSIGN_STAT) {
current = current->lexNext();
continue;
}
OperatorInfo opInfo(current);
vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
for (auto irBlock : irBlocks) {
if (!irBlock || !irBlock->getInstruction())
continue;
const 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);
}
}
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, 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;
break;
}
}
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.at(usedVar)) {
if (defStmt->lineNumber() < operatorStmt->lineNumber()) {
if (defStmt->controlParent() == operatorStmt->controlParent()) {
if (defStmt->lineNumber() > bestLine) {
bestLine = defStmt->lineNumber();
bestPos = defStmt;
}
}
}
}
}
}
if (!bestPos) {
bool allLoopCarried = true;
bool hasAnyDefinition = false;
for (const string& usedVar : opInfo->usedVars) {
if (varDefinitions.find(usedVar) != varDefinitions.end()) {
for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
if (defStmt == operatorStmt)
continue;
hasAnyDefinition = true;
if (defStmt->lineNumber() < operatorStmt->lineNumber() &&
defStmt->controlParent() == operatorStmt->controlParent()) {
allLoopCarried = false;
break;
}
}
}
if (!allLoopCarried)
break;
}
if (allLoopCarried || (!hasAnyDefinition && !opInfo->usedVars.empty())) {
SgStatement* loopStart = loop->lexNext();
return loopStart;
}
}
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 (!loopStart || !loopEnd)
return false;
if (to == loopStart) {
SgStatement* fromControlParent = from->controlParent();
if (!fromControlParent) fromControlParent = loop;
return fromControlParent == loop || fromControlParent == loopStart->controlParent();
}
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())
return false;
if (from->controlParent() != to->controlParent())
return false;
SgStatement* current = to->lexNext();
while (current && current != from && current != loopEnd) {
if (control_tags.find(current->variant()) != control_tags.end()) {
SgStatement* controlEnd = current->lastNodeOfStmt();
if (controlEnd && from->lineNumber() <= controlEnd->lineNumber()) {
if (from->controlParent() == current && to->controlParent() != current) {
return false;
}
}
}
current = current->lexNext();
}
return true;
}
static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop,
const vector<OperatorInfo>& operators,
const map<string, vector<SgStatement*>>& varDefinitions) {
vector<SgStatement*> newOrder;
for (auto& op : operators)
newOrder.push_back(op.stmt);
map<SgStatement*, const OperatorInfo*> stmtToOpInfo;
for (auto& op : operators)
stmtToOpInfo[op.stmt] = &op;
bool changed = true;
while (changed) {
changed = false;
for (int i = operators.size() - 1; i >= 0; i--) {
if (!operators[i].isMovable)
continue;
SgStatement* stmt = operators[i].stmt;
const OperatorInfo* opInfo = stmtToOpInfo[stmt];
if (!opInfo)
continue;
size_t currentPos = 0;
for (size_t j = 0; j < newOrder.size(); j++) {
if (newOrder[j] == stmt) {
currentPos = j;
break;
}
}
SgStatement* bestPos = findBestPosition(stmt, operators, varDefinitions, loop);
if (!bestPos) {
bool hasDependents = false;
for (size_t j = currentPos + 1; j < newOrder.size(); j++) {
SgStatement* candidate = newOrder[j];
const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
if (candidateOpInfo) {
for (const string& definedVar : opInfo->definedVars) {
if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
hasDependents = true;
break;
}
}
if (hasDependents)
break;
}
}
continue;
}
size_t targetPos = 0;
bool foundTarget = false;
if (bestPos == loop->lexNext()) {
targetPos = 0;
for (size_t j = 0; j < currentPos && j < newOrder.size(); j++) {
SgStatement* candidate = newOrder[j];
const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
if (candidateOpInfo) {
bool usesDefinedVar = false;
for (const string& definedVar : opInfo->definedVars) {
if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
usesDefinedVar = true;
break;
}
}
if (usesDefinedVar) {
targetPos = j;
break;
}
}
}
foundTarget = true;
if (currentPos != targetPos && canMoveTo(stmt, bestPos, loop)) {
newOrder.erase(newOrder.begin() + currentPos);
newOrder.insert(newOrder.begin() + targetPos, stmt);
changed = true;
}
} else {
size_t bestPosIdx = 0;
bool foundBestPos = false;
for (size_t j = 0; j < newOrder.size(); j++) {
if (newOrder[j] == bestPos) {
bestPosIdx = j;
foundBestPos = true;
break;
}
}
if (foundBestPos) {
targetPos = bestPosIdx + 1;
for (size_t j = bestPosIdx + 1; j < currentPos && j < newOrder.size(); j++) {
SgStatement* candidate = newOrder[j];
const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
if (candidateOpInfo) {
bool definesUsedVar = false;
for (const string& usedVar : opInfo->usedVars) {
if (candidateOpInfo->definedVars.find(usedVar) != candidateOpInfo->definedVars.end()) {
definesUsedVar = true;
break;
}
}
if (definesUsedVar)
targetPos = j + 1;
}
}
bool wouldBreakDependency = false;
for (size_t j = targetPos; j < currentPos && j < newOrder.size(); j++) {
SgStatement* candidate = newOrder[j];
const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
if (candidateOpInfo) {
for (const string& definedVar : opInfo->definedVars) {
if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
wouldBreakDependency = true;
break;
}
}
if (wouldBreakDependency)
break;
}
}
if (!wouldBreakDependency && currentPos > targetPos && canMoveTo(stmt, bestPos, loop)) {
newOrder.erase(newOrder.begin() + currentPos);
newOrder.insert(newOrder.begin() + targetPos, stmt);
changed = true;
}
}
}
}
}
bool dependencyViolation = true;
set<pair<SgStatement*, SgStatement*>> triedPairs;
while (dependencyViolation) {
dependencyViolation = false;
triedPairs.clear();
for (size_t i = 0; i < newOrder.size(); i++) {
SgStatement* stmt = newOrder[i];
const OperatorInfo* opInfo = stmtToOpInfo[stmt];
if (!opInfo)
continue;
for (size_t j = 0; j < i; j++) {
SgStatement* prevStmt = newOrder[j];
const OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
if (!prevOpInfo)
continue;
pair<SgStatement*, SgStatement*> key = make_pair(stmt, prevStmt);
if (triedPairs.find(key) != triedPairs.end())
continue;
bool violation = false;
for (const string& definedVar : opInfo->definedVars) {
if (prevOpInfo->usedVars.find(definedVar) != prevOpInfo->usedVars.end()) {
violation = true;
break;
}
}
if (violation) {
triedPairs.insert(key);
bool wouldCreateViolation = false;
for (size_t k = j; k < i; k++) {
SgStatement* betweenStmt = newOrder[k];
const OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
if (!betweenOpInfo)
continue;
for (const string& usedVar : opInfo->usedVars) {
if (betweenOpInfo->definedVars.find(usedVar) != betweenOpInfo->definedVars.end()) {
wouldCreateViolation = true;
break;
}
}
if (wouldCreateViolation)
break;
}
if (!wouldCreateViolation) {
newOrder.erase(newOrder.begin() + i);
newOrder.insert(newOrder.begin() + j, stmt);
dependencyViolation = true;
break;
}
}
}
if (dependencyViolation)
break;
}
}
return newOrder;
}
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;
vector<SgStatement*> originalOrder;
SgStatement* current = loopStart;
while (current && current != loopEnd) {
if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT)
originalOrder.push_back(current);
current = current->lexNext();
}
bool orderChanged = false;
if (originalOrder.size() == newOrder.size()) {
for (size_t i = 0; i < originalOrder.size(); i++) {
if (originalOrder[i] != newOrder[i]) {
orderChanged = true;
break;
}
}
}
else
orderChanged = true;
if (!orderChanged)
return false;
vector<SgStatement*> extractedStatements;
vector<char*> savedComments;
unordered_set<SgStatement*> extractedSet;
map<SgStatement*, int> originalLineNumbers;
map<SgStatement*, SgStatement*> stmtToExtracted;
for (SgStatement* stmt : newOrder) {
if (stmt && stmt != loop && stmt != loopEnd && extractedSet.find(stmt) == extractedSet.end()) {
if (control_tags.find(stmt->variant()) != control_tags.end())
continue;
if (!canSafelyExtract(stmt, loop))
continue;
bool isMoving = false;
for (size_t i = 0; i < originalOrder.size(); i++) {
if (originalOrder[i] == stmt) {
for (size_t j = 0; j < newOrder.size(); j++) {
if (newOrder[j] == stmt && i != j) {
isMoving = true;
break;
}
}
break;
}
}
if (!isMoving)
continue;
originalLineNumbers[stmt] = stmt->lineNumber();
savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
SgStatement* extracted = stmt->extractStmt();
if (extracted) {
extractedStatements.push_back(extracted);
extractedSet.insert(stmt);
stmtToExtracted[stmt] = extracted;
}
}
}
map<SgStatement*, SgStatement*> insertedStatements;
for (size_t idx = 0; idx < newOrder.size(); idx++) {
SgStatement* stmt = newOrder[idx];
if (extractedSet.find(stmt) != extractedSet.end()) {
SgStatement* stmtToInsert = stmtToExtracted[stmt];
if (!stmtToInsert)
continue;
SgStatement* insertAfter = loop;
for (int i = idx - 1; i >= 0; i--) {
SgStatement* prevStmt = newOrder[i];
if (extractedSet.find(prevStmt) != extractedSet.end()) {
if (insertedStatements.find(prevStmt) != insertedStatements.end()) {
insertAfter = insertedStatements[prevStmt];
break;
}
} else {
SgStatement* search = loop->lexNext();
while (search && search != loopEnd) {
bool skip = false;
for (size_t j = idx; j < newOrder.size(); j++) {
if (extractedSet.find(newOrder[j]) != extractedSet.end() &&
search == newOrder[j]) {
skip = true;
break;
}
}
if (skip) {
search = search->lexNext();
continue;
}
if (search == prevStmt) {
insertAfter = search;
break;
}
search = search->lexNext();
}
if (insertAfter != loop) break;
}
}
size_t commentIdx = 0;
for (size_t i = 0; i < extractedStatements.size(); i++) {
if (extractedStatements[i] == stmtToInsert) {
commentIdx = i;
break;
}
}
if (commentIdx < savedComments.size() && savedComments[commentIdx])
stmtToInsert->setComments(savedComments[commentIdx]);
if (originalLineNumbers.find(stmt) != originalLineNumbers.end())
stmtToInsert->setlineNumber(originalLineNumbers[stmt]);
SgStatement* controlParent = stmt->controlParent();
if (!controlParent)
controlParent = loop;
insertAfter->insertStmtAfter(*stmtToInsert, *controlParent);
insertedStatements[stmt] = stmtToInsert;
}
}
for (char* comment : savedComments) {
if (comment)
free(comment);
}
return true;
}
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())
{
result = func.second;
}
}
return result;
}
map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, const 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) {
vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(loopBody, blocks);
if (!irBlocks.empty()) {
SAPFOR::IR_Block* IR = irBlocks.front();
if (IR && IR->getBasicBlock()) {
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();
}
sort(result[forSt].begin(), result[forSt].end());
}
st = st -> lexNext();
}
return result;
}
static void processLoopRecursively(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks,
const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
if (!loop)
return;
SgStatement* loopStart = loop->lexNext();
SgStatement* loopEnd = loop->lastNodeOfStmt();
if (loopStart && loopEnd) {
SgStatement* current = loopStart;
while (current && current != loopEnd) {
if (current->variant() == FOR_NODE && current != loop) {
SgForStmt* nestedLoop = (SgForStmt*)current;
processLoopRecursively(nestedLoop, blocks, FullIR);
SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
if (nestedEnd)
current = nestedEnd->lexNext();
else
current = current->lexNext();
}
else
current = current->lexNext();
}
}
vector<OperatorInfo> operators = analyzeOperatorsInLoop(loop, blocks, FullIR);
if (!operators.empty()) {
map<string, vector<SgStatement*>> varDefinitions = findVariableDefinitions(loop, operators);
vector<SgStatement*> newOrder = optimizeOperatorOrder(loop, operators, varDefinitions);
applyOperatorReordering(loop, newOrder);
}
}
void moveOperators(SgFile *file, map<string, vector<LoopGraph*>>& loopGraph,
const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR,
int& countOfTransform) {
countOfTransform += 1;
//cout << "MOVE_OPERATORS Pass Started" << endl;
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 (auto& loopForAnalyze: loopsMapping)
processLoopRecursively(loopForAnalyze.first, loopForAnalyze.second, FullIR);
}
//cout << "MOVE_OPERATORS Pass Completed" << endl;
}

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

@@ -1,6 +0,0 @@
#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);

2
src/Utils/PassManager.h
View File

@@ -319,7 +319,7 @@ 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);
Pass(CREATE_TEMPLATE_LINKS) <= Pass(MERGE_COPY_ARRAYS);
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,

2
src/Utils/version.h
View File

@@ -1,3 +1,3 @@
#pragma once
#define VERSION_SPF "2451"
#define VERSION_SPF "2448"

9
src/VisualizerCalls/get_information.cpp
View File

@@ -1802,13 +1802,6 @@ int SPF_InsertPrivateArrayDirectives(void*& context, int winHandler, short* opti
return simpleTransformPass(FIND_PRIVATE_ARRAYS, options, projName, folderName, output, outputMessage);
}
int SPF_MoveOperators(void*& context, int winHandler, short* options, short* projName, short* folderName, string& output, string& outputMessage)
{
MessageManager::clearCache();
MessageManager::setWinHandler(winHandler);
return simpleTransformPass(MOVE_OPERATORS, options, projName, folderName, output, outputMessage);
}
static inline void convertBackSlash(char *str, int strL)
{
for (int z = 0; z < strL; ++z)
@@ -2517,8 +2510,6 @@ const wstring Sapfor_RunTransformation(const char* transformName_c, const char*
retCode = SPF_RenameIncludes(context, winHandler, optSh, projSh, fold, output, outputMessage);
else if (whichRun == "SPF_InsertPrivateArrayDirectives")
retCode = SPF_InsertPrivateArrayDirectives(context, winHandler, optSh, projSh, fold, output, outputMessage);
else if (whichRun == "SPF_MoveOperators")
retCode = SPF_MoveOperators(context, winHandler, optSh, projSh, fold, output, outputMessage);
else if (whichRun == "SPF_CreateParallelVariant")
{
vector<string> splited;