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

added TRANSFORM_ASSUMED_SIZE_PARAMETERS pass, fixed shared memory parallelization

Browse Source
This commit is contained in:
ALEXks
2025-07-26 20:22:15 +03:00
parent 3095510826
commit d3d6d0bec7
5 changed files with 168 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/Sapfor.cpp
View File

@@ -1914,6 +1914,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
calculateStatsForPredictor(allFuncInfo, gCovInfo);
parseDvmDirForPredictor(declaredArrays, commonBlocks, allFuncInfo, gCovInfo);
}
else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
transformAssumedSizeParameters(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.;
@@ -2149,6 +2151,8 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
runAnalysis(*project, REMOVE_COPIES, false);
runAnalysis(*project, SWAP_LOOPS, false);
runPass(TRANSFORM_ASSUMED_SIZE_PARAMETERS, proj_name, folderName);
if (folderName || consoleMode)
runAnalysis(*project, UNPARSE_FILE, true, additionalName.c_str(), folderName);
}

4
src/Sapfor.h
View File

@@ -185,6 +185,8 @@ enum passes {
FIND_PRIVATE_ARRAYS,
TRANSFORM_ASSUMED_SIZE_PARAMETERS,
TEST_PASS,
EMPTY_PASS
};
@@ -371,6 +373,8 @@ static void setPassValues()
passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";
passNames[TRANSFORM_ASSUMED_SIZE_PARAMETERS] = "TRANSFORM_ASSUMED_SIZE_PARAMETERS";
passNames[TEST_PASS] = "TEST_PASS";
}

145
src/Transformations/FunctionPurifying/function_purifying.cpp
View File

@@ -136,33 +136,41 @@ void createInterfacesForOutCalls(FuncInfo* func)
}
}
static bool changeIfHasStarRange(SgExpression* arrayDecl, bool doReplace = false)
static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, vector<SgSymbol*>& parNames)
{
SgExpression* list = arrayDecl->lhs();
bool has = doReplace;
string varN = arrayDecl->symbol()->identifier() + string("_sz");
bool has = false;
SgExpression* allDimsBefore = NULL;
while (list)
{
const int var = list->lhs()->variant();
if (var == STAR_RANGE)
{
has = true;
list = list->rhs();
parNames.push_back(new SgSymbol(VARIABLE_NAME, varN.c_str(), SgTypeInt(), scope));
SgExpression* par = allDimsBefore ? &(*new SgVarRefExp(parNames.back()) / *allDimsBefore) : (new SgVarRefExp(parNames.back()));
list->setLhs(par);
break;
}
else
{
if (allDimsBefore == NULL)
allDimsBefore = list->lhs();
else
allDimsBefore = &(*allDimsBefore * *list->lhs()->copyPtr());
}
if (has)
{
list = arrayDecl->lhs();
while (list)
{
list->setLhs(new SgExpression(DDOT));
list = list->rhs();
}
}
return has;
}
static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
/*static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
{
vector<SgStatement*> toRem;
for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
@@ -197,7 +205,7 @@ static void removeExternalStat(SgStatement* func, const set<string>& addedInterf
for (auto& rem : toRem)
rem->deleteStmt();
}
}*/
template<typename T>
static vector<FuncInfo*> sortByName(const T &funcs)
@@ -210,10 +218,25 @@ static vector<FuncInfo*> sortByName(const T &funcs)
return funcList;
}
//XXX: incorrect!!
/*void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
static bool hasDvmParallel(SgStatement *func)
{
set<FuncInfo*> hasAssumedSizeArrays;
for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
{
const int var = st->variant();
if (var == DVM_PARALLEL_ON_DIR || var == ACC_REGION_DIR ||
var == ACC_ACTUAL_DIR || var == ACC_GET_ACTUAL_DIR)
return true;
if (st->variant() == CONTAINS_STMT)
break;
}
return false;
}
void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFuncInfo)
{
map<string, vector<int>> assumedSizeArraysByFunc;
for (auto& funcByFile : allFuncInfo)
{
@@ -226,6 +249,12 @@ static vector<FuncInfo*> sortByName(const T &funcs)
if (prog == NULL)
continue;
if (!hasDvmParallel(prog))
continue;
vector<SgSymbol*> parNames;
SgStatement* scope = prog->getScopeForDeclare();
vector<SgExpression*> arrayRefs;
bool hasRefs = false;
for (int z = 0; z < func->funcParams.countOfPars; ++z)
@@ -245,13 +274,8 @@ static vector<FuncInfo*> sortByName(const T &funcs)
{
if (list->lhs() && list->lhs()->symbol()->identifier() == name)
{
if (changeIfHasStarRange(list->lhs()))
{
hasRefs = true;
hasAssumedSizeArrays.insert(func);
}
else
arrayRefs.push_back(list->lhs());
if (changeIfHasStarRange(list->lhs(), scope, parNames))
assumedSizeArraysByFunc[func->funcName].push_back(z);
break;
}
list = list->rhs();
@@ -260,13 +284,33 @@ static vector<FuncInfo*> sortByName(const T &funcs)
}
}
if (hasRefs)
for (auto& ref : arrayRefs)
changeIfHasStarRange(ref, true);
if (parNames.size())
{
SgProcHedrStmt* proc = isSgProcHedrStmt(func->funcPointer->GetOriginal());
checkNull(proc, convertFileName(__FILE__).c_str(), __LINE__);
makeDeclaration(parNames, scope);
for (auto& newPar : parNames)
{
auto arg = new SgVarRefExp(newPar);
BIF_LL1(proc->thebif) = addToExprList(BIF_LL1(proc->thebif), arg->thellnd);
PTR_LLND ll;
PTR_SYMB symb;
ll = giveLlSymbInDeclList(arg->thellnd);
if (ll && (symb = NODE_SYMB(ll)))
{
appendSymbToArgList(BIF_SYMB(proc->thebif), symb);
SYMB_SCOPE(symb) = proc->thebif;
}
//proc->AddArg(*new SgVarRefExp(newPar));
}
}
}
}
if (hasAssumedSizeArrays.size() == 0)
if (assumedSizeArraysByFunc.size() == 0)
return;
for (auto& funcByFile : allFuncInfo)
@@ -274,29 +318,58 @@ static vector<FuncInfo*> sortByName(const T &funcs)
if (SgFile::switchToFile(funcByFile.first) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
SgSymbol* funcSize = new SgSymbol(FUNCTION_NAME, "size");
for (auto& func : sortByName(funcByFile.second))
{
SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
if (prog == NULL)
continue;
set<string> addedInterfaceFor;
for (auto& elem : sortByName(func->callsFromV))
for (auto& detailedCall : func->callsFromDetailed)
{
auto it = hasAssumedSizeArrays.find(elem);
if (it != hasAssumedSizeArrays.end())
auto it = assumedSizeArraysByFunc.find(detailedCall.detailCallsFrom.first);
if (it != assumedSizeArraysByFunc.end())
{
auto callFrom = *it;
DvmhRegionInserter::createInterfaceBlockForOutCall(func, callFrom);
addedInterfaceFor.insert(callFrom->funcName);
auto pointer = detailedCall.pointerDetailCallsFrom;
SgExpression* list = NULL;
if (pointer.second == FUNC_CALL)
{
SgExpression* p = (SgExpression*)pointer.first;
list = p->lhs();
}
else
{
SgStatement* p = (SgStatement*)pointer.first;
list = p->expr(0);
}
if (addedInterfaceFor.size())
removeExternalStat(prog, addedInterfaceFor);
SgExpression* last = list;
vector<SgExpression*> pars;
while (list)
{
last = list;
pars.push_back(list->lhs());
list = list->rhs();
}
for (int z = 0; z < it->second.size(); ++z)
{
int parNum = it->second[z];
if (parNum >= pars.size())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
SgFunctionCallExp* call = new SgFunctionCallExp(*funcSize, *pars[parNum]);
last->setRhs(new SgExpression(EXPR_LIST, call));
last = last->rhs();
}
}
}*/
}
}
}
}
static void setPureStatus(FuncInfo* func)
{

2
src/Transformations/FunctionPurifying/function_purifying.h
View File

@@ -15,3 +15,5 @@ void saveTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncIn
void moduleTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
void insertInterface(SgStatement* func, const FuncInfo* callFrom);
void transformAssumedSizeParameters(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);

2
src/Utils/version.h
View File

@@ -1,3 +1,3 @@
#pragma once
#define VERSION_SPF "2436"
#define VERSION_SPF "2437"