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:private_arrays Alexander_KS:libpredict_integration Alexander_KS:egormayorov Alexander_KS:replace_io_arrays Alexander_KS:analyze_loops_with_IR
..
compare: Alexander_KS:374b6c686b2d427efa4170a1aa49d0f3373c43a1
Branches Tags
Alexander_KS:master Alexander_KS:private_arrays Alexander_KS:libpredict_integration Alexander_KS:egormayorov Alexander_KS:replace_io_arrays Alexander_KS:analyze_loops_with_IR

1 Commits
egormayoro ... 374b6c686b

Author SHA1 Message Date
xnpster
374b6c686b REMOVE_DIST_ARRAYS_FROM_IO: STMT_STR while replacing 2025-06-14 19:55:46 +03:00
45 changed files with 934 additions and 1516 deletions
Expand all files Collapse all files

1
.gitignore vendored
View File

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

12
CMakeLists.txt
View File

@@ -12,7 +12,6 @@ add_definitions("-D SYS5")
add_definitions("-D YYDEBUG")
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_C_STANDARD 17)
set(fdvm_include projects/dvm/fdvmh/include/fdvmh/)
set(fdvm_sources projects/dvm/fdvmh/tools/fdvmh/)
@@ -34,7 +33,6 @@ include_directories(src/Distribution)
include_directories(src/GraphCall)
include_directories(src/GraphLoop)
include_directories(src/Transformations/ExpressionSubstitution)
include_directories(src/Transformations)
#Sage lib includes
include_directories(${fdvm_include})
@@ -204,8 +202,6 @@ set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
src/Transformations/FunctionInlining/inliner.h)
set(TR_RENAME_SYMBOLS src/Transformations/RenameSymbols/rename_symbols.cpp
src/Transformations/RenameSymbols/rename_symbols.h)
SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
src/Transformations/SwapOperators/swap_operators.h)
set(TRANSFORMS
${TR_DEAD_CODE}
@@ -228,8 +224,7 @@ set(TRANSFORMS
${TR_REPLACE_ARRAYS_IN_IO}
${TR_EXPR_TRANSFORM}
${TR_INLINER}
${TR_RENAME_SYMBOLS}
${TR_SWAP_OPERATORS})
${TR_RENAME_SYMBOLS})
set(CFG src/CFGraph/IR.cpp
src/CFGraph/IR.h
@@ -462,7 +457,6 @@ source_group (Transformations\\GlobalVariables FILES ${TR_GV})
source_group (Transformations\\ConvertToC FILES ${TR_CONV})
source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
source_group (Transformations\\SwapOperators FILES ${TR_SWAP_OPERATORS})
source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -500,9 +494,7 @@ else()
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
endif()
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
endif()
add_subdirectory(projects/Fdvm)

2
projects/dvm

Submodule projects/dvm updated: 4b7ef11871...3a567d7582

48
src/CFGraph/CFGraph.cpp
View File

@@ -1162,9 +1162,6 @@ map<FuncInfo*, vector<BBlock*>> buildCFG(const map<string, CommonBlock*>& common
if (SgFile::switchToFile(oldFile) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
for (auto& [func, blocks] : result)
removedUnreachableBlocks(blocks);
return result;
}
@@ -1240,48 +1237,3 @@ map<FuncInfo*, vector<SAPFOR::BasicBlock*>>
return buildCFG(commonBlocks, fileFuncInfoMap, settings);
}
void removedUnreachableBlocks(vector<SAPFOR::BasicBlock*>& blocks)
{
set<SAPFOR::BasicBlock*> reachable;
for (auto& b : blocks)
if (b->getInstructions().front()->isHeader() ||
b->getInstructions().front()->getInstruction()->getOperation() == SAPFOR::CFG_OP::ENTRY)
reachable.insert(b);
set<SAPFOR::BasicBlock*> worklist = reachable;
while (worklist.size() != 0)
{
set<SAPFOR::BasicBlock*> to_insert;
for (auto& b : worklist)
for (auto& next : b->getNext())
if (reachable.insert(next).second)
to_insert.insert(next);
worklist = to_insert;
}
auto remove_unreachable_it = remove_if(blocks.begin(), blocks.end(),
[&reachable](SAPFOR::BasicBlock* b)
{
if (reachable.find(b) == reachable.end())
{
for (auto& next : b->getNext())
if (reachable.find(next) != reachable.end())
next->removePrev(b);
delete b;
return true;
}
return false;
}
);
reachable.clear();
blocks.erase(remove_unreachable_it, blocks.end());
}

2
src/CFGraph/CFGraph.h
View File

@@ -156,5 +156,3 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
}
cfg.clear();
}
void removedUnreachableBlocks(std::vector<SAPFOR::BasicBlock*>& blocks);

4
src/CFGraph/private_variables_analysis.cpp
View File

@@ -250,7 +250,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
const map<string, SgSymbol*>& commonArgs, FuncInfo* func,
map<string, vector<Messages>>& messages)
{
if (!loop->isFor())
if (!loop->isFor)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__); //should be called only with FOR loops
SgStatement* loop_operator = loop->loop->GetOriginal();
@@ -450,7 +450,7 @@ static void recAnalyzeLoop(LoopGraph* loop, const set<SAPFOR::BasicBlock*>& bloc
const map<string, SgSymbol*>& commonArgs,
FuncInfo* func, map<string, vector<Messages>>& messages)
{
const auto& loop_body = loop->isFor() ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
const auto& loop_body = loop->isFor ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
for (const auto& inner_loop : loop->children)
recAnalyzeLoop(inner_loop, loop_body, commonVars, commonArgs, func, messages);

2
src/DirectiveProcessing/directive_creator.cpp
View File

@@ -22,7 +22,7 @@
#include "SgUtils.h"
#include "../Sapfor.h"
#include "graph_loops_func.h"
#include "LoopNesting/loop_transform.h"
#include "../Transformations/LoopNesting/loop_transform.h"
#include "expr_transform.h"
#include "graph_calls_func.h"

14
src/DirectiveProcessing/directive_creator_base.cpp
View File

@@ -10,7 +10,7 @@
#include "../ParallelizationRegions/ParRegions.h"
#include "../Distribution/Arrays.h"
#include "LoopNesting/loop_transform.h"
#include "../Transformations/LoopNesting/loop_transform.h"
#include "errors.h"
#include "directive_parser.h"
@@ -75,7 +75,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
}
}
directive->parallel.push_back(currentLoop->loopSymbol());
directive->parallel.push_back(currentLoop->loopSymbol);
directive->arrayRef = mainArray.arrayRef;
DIST::Array *tmp = mainArray.arrayRef;
@@ -84,7 +84,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
for (int i = 0; i < tmp->GetDimSize(); ++i)
{
if (i == pos)
directive->on.push_back(make_pair(currentLoop->loopSymbol(), mainAccess));
directive->on.push_back(make_pair(currentLoop->loopSymbol, mainAccess));
else
directive->on.push_back(make_pair("*", make_pair(0, 0)));
}
@@ -808,7 +808,7 @@ void createParallelDirectives(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*
for (int i = 0; i < mainArrayOfLoop->GetDimSize(); ++i)
{
if (i == dimPos)
parDir->on2.push_back(make_pair(currLoop->loopSymbol(), mainAccess));
parDir->on2.push_back(make_pair(currLoop->loopSymbol, mainAccess));
else
parDir->on2.push_back(make_pair("*", make_pair(0, 0)));
}
@@ -1100,7 +1100,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
LoopGraph* tmpL = loop;
for (int z = 0; z < nested; ++z)
{
deprecateToMatch.insert(tmpL->loopSymbol());
deprecateToMatch.insert(tmpL->loopSymbol);
if (tmpL->children.size())
tmpL = tmpL->children[0];
else if (z != nested - 1)
@@ -1113,7 +1113,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
tmpL = loop->parent;
while (tmpL)
{
if (tmpL->isWhile()) // TODO: need to add all inductive variables!
if (!tmpL->isFor) // TODO: need to add all inductive variables!
{
SgWhileStmt* dow = isSgWhileStmt(tmpL->loop->GetOriginal());
if (dow->conditional())
@@ -1124,7 +1124,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
}
}
else
deprecateToMatch.insert(tmpL->loopSymbol());
deprecateToMatch.insert(tmpL->loopSymbol);
tmpL = tmpL->parent;
}

2
src/DirectiveProcessing/shadow.cpp
View File

@@ -15,7 +15,7 @@
#include "SgUtils.h"
#include "expr_transform.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
#include "shadow.h"
#include "dvm.h"

8
src/Distribution/ArrayAnalysis.cpp
View File

@@ -241,15 +241,13 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
itNew->second.first->SetRegionPlace(reg);
const auto oldVal = itNew->second.first->GetDistributeFlagVal();
bool isArrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
bool isarrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
if (oldVal == DIST::DISTR || oldVal == DIST::NO_DISTR)
{
if (itNew->second.first->IsOmpThreadPrivate())
itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
else if (isArrayInModule || privates.find(symb->identifier()) != privates.end())
else if (privates.find(symb->identifier()) != privates.end() || isarrayInModule)
{
//check in module
if (itNew->second.first->GetLocation().first == DIST::l_MODULE)
@@ -276,6 +274,8 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
else
itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
}
else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
else if (isSgConstantSymb(symb) || inDataStat)
itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
else

2
src/Distribution/DvmhDirective.cpp
View File

@@ -346,7 +346,7 @@ static vector<SgExpression*>
{
needToAdd = true;
dim_found = true;
subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol()));
subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol));
break;
}
}

157
src/DvmhRegions/DvmhRegionInserter.cpp
View File

@@ -11,9 +11,9 @@
#include "DvmhRegionInserter.h"
#include "DvmhRegions/RegionsMerger.h"
#include "../VerificationCode/verifications.h"
#include "../Transformations/FunctionPurifying/function_purifying.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "FunctionPurifying/function_purifying.h"
using namespace std;
@@ -794,6 +794,154 @@ ArraySet DvmhRegionInserter::get_used_arrs_for_block(SgStatement* st, int usage_
return usages;
}
static bool filterFromList(SgStatement* st, const set<string>& idents, bool exclude = false)
{
bool empty = false;
SgExpression* list = st->expr(0);
vector<SgExpression*> newList;
int total = 0;
while (list)
{
if (exclude)
{
if (idents.find(list->lhs()->symbol()->identifier()) == idents.end())
newList.push_back(list->lhs());
}
else
{
if (idents.find(list->lhs()->symbol()->identifier()) != idents.end())
newList.push_back(list->lhs());
}
total++;
list = list->rhs();
}
if (newList.size() == 0)
empty = true;
else if (total != newList.size())
st->setExpression(0, makeExprList(newList));
return empty;
}
static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
{
string oldFile = current_file->filename();
if (!func->switchToFile())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto copy = duplicateProcedure(func, NULL, false, false, false, true);
const set<string> idents(pars.identificators.begin(), pars.identificators.end());
bool need = (func->symbol()->identifier() == string("bl182"));
//remove all exec
SgStatement* st = copy->lexNext();
SgStatement* last = copy->lastNodeOfStmt();
vector<SgStatement*> toExtract;
while (st != last)
{
if (isDVM_stat(st) || isSPF_stat(st))
{
if (st->variant() != ACC_ROUTINE_DIR)
{
toExtract.push_back(st);
st = st->lexNext();
}
else
st = st->lexNext();
}
else if (isSgExecutableStatement(st))
{
SgStatement* next = st->lastNodeOfStmt();
if (next != last)
next = next->lexNext();
toExtract.push_back(st);
st = next;
}
else
st = st->lexNext();
}
//remove unused declarations
st = copy->lexNext();
while (st != last)
{
const int var = st->variant();
if (var == VAR_DECL
|| var == VAR_DECL_90
|| var == DIM_STAT
|| var == INTENT_STMT
|| var == EXTERN_STAT)
{
bool empty = filterFromList(st, idents);
if (empty)
{
toExtract.push_back(st);
st = st->lexNext();
continue;
}
}
else if (!isDVM_stat(st) && !isSPF_stat(st))
toExtract.push_back(st);
if (st->variant() == CONTAINS_STMT)
break;
st = st->lexNext();
}
for (auto& elem : toExtract)
elem->extractStmt();
string retVal = copy->unparse();
if (SgFile::switchToFile(oldFile) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
return retVal;
}
static void insertInterface(SgStatement* func, const string& iface, const string& fName)
{
string oldFile = current_file->filename();
if (!func->switchToFile())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
SgStatement* st = func->lexNext();
SgStatement* last = func->lastNodeOfStmt();
while (st != last)
{
if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
{
bool empty = filterFromList(st, { fName }, true);
if (empty)
{
SgStatement* next = st->lexNext();
st->extractStmt();
st = next;
continue;
}
}
if (isSgExecutableStatement(st))
break;
st = st->lexNext();
}
SgStatement* ifaceBlock = new SgStatement(INTERFACE_STMT);
addControlEndToStmt(ifaceBlock->thebif);
ifaceBlock->setlineNumber(getNextNegativeLineNumber()); // st->lineNumber()
ifaceBlock->setFileName(st->fileName());
st->insertStmtBefore(*ifaceBlock, *st->controlParent());
ifaceBlock->lastNodeOfStmt()->addComment(iface.c_str());
if (SgFile::switchToFile(oldFile) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
}
static LoopGraph* getParallelLoop(LoopGraph* loop)
{
auto prev_st = loop->loop->lexPrev();
@@ -1024,7 +1172,7 @@ static bool isPure(SgStatement* func)
void DvmhRegionInserter::createInterfaceBlockForOutCall(FuncInfo* func, FuncInfo* callFrom)
{
insertInterface(func->funcPointer, callFrom);
insertInterface(func->funcPointer, getInterfaceBlock(callFrom->funcPointer->GetOriginal(), callFrom->funcParams), callFrom->funcName);
}
void DvmhRegionInserter::createInterfaceBlockForParallelFunctions(bool onlyRoutine)
@@ -1298,9 +1446,6 @@ static set<DIST::Array*>
declStat = SgStatement::getStatementByFileAndLine(decl.first, decl.second);
if (declStat == NULL) // check in inlcudes
{
if (!main->switchToFile())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
for (auto st = main; st != main->lastNodeOfStmt() && !declStat; st = st->lexNext())
{
if (st->fileName() == decl.first && st->lineNumber() == decl.second)
@@ -1312,7 +1457,7 @@ static set<DIST::Array*>
}
else
{
declStat = getFuncStat(declStat, { BLOCK_DATA });
declStat = getFuncStat(declStat);
if (declStat != main)
{
declStat = NULL;

23
src/GraphCall/graph_calls.cpp
View File

@@ -14,7 +14,7 @@
#include "dvm.h"
#include "graph_calls_func.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
#include "graph_loops_func.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "SgUtils.h"
@@ -779,20 +779,6 @@ static void checkSpecList(SgExpression *spec, FuncInfo* currF, const map<string,
}
}
static void checkInTypeDescription(SgExpression *ex, FuncInfo* currF, const map<string, int>& parNames)
{
if (ex)
{
if (ex->variant() == ARRAY_REF)
fillIn(currF, ex->lhs(), parNames, false);
else
{
checkInTypeDescription(ex->lhs(), currF, parNames);
checkInTypeDescription(ex->rhs(), currF, parNames);
}
}
}
static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, const set<SgStatement*>& activeOps)
{
if (currF->funcParams.countOfPars == 0)
@@ -813,12 +799,7 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
if (st->variant() == ENTRY_STAT)
continue;
if (isSgExecutableStatement(st) == NULL) {
checkInTypeDescription(st->expr(0), currF, parNames);
continue;
}
if (st->lineNumber() <= 0)
if (isSgExecutableStatement(st) == NULL || st->lineNumber() <= 0)
continue;
if (activeOps.size() && activeOps.find(st) == activeOps.end())

11
src/GraphLoop/graph_loops.cpp
View File

@@ -31,7 +31,7 @@
#include "../DirectiveProcessing/directive_parser.h"
#include "../DynamicAnalysis/gCov_parser_func.h"
#include "VectorAssignToLoop/array_assign_to_loop.h"
#include "../Transformations/VectorAssignToLoop/array_assign_to_loop.h"
using std::vector;
using std::map;
@@ -699,12 +699,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
newLoop->hasPrints = hasThisIds(st, newLoop->linesOfIO, { WRITE_STAT, READ_STAT, OPEN_STAT, CLOSE_STAT, PRINT_STAT } ); // FORMAT_STAT
newLoop->hasStops = hasThisIds(st, newLoop->linesOfStop, { STOP_STAT, PAUSE_NODE });
newLoop->hasDvmIntervals = hasThisIds(st, tmpLines, { DVM_INTERVAL_DIR, DVM_ENDINTERVAL_DIR, DVM_EXIT_INTERVAL_DIR });
if (isSgForStmt(st))
newLoop->loopType = LoopType::FOR;
else if (isSgWhileStmt(st))
newLoop->loopType = LoopType::WHILE;
else
newLoop->loopType = LoopType::NONE;
newLoop->isFor = isSgForStmt(st) ? true : false;
newLoop->inCanonicalFrom = isSgForStmt(st) ? true : false;
newLoop->hasSubstringRefs = hasSubstringRef(st);
@@ -782,7 +777,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
newLoop->startEndExpr = std::make_pair((Expression*)NULL, (Expression*)NULL);
newLoop->loop = new Statement(st);
newLoop->loopSymbols.addMainVar(st->symbol() ? st->symbol()->identifier() : "unknown");
newLoop->loopSymbol = st->symbol() ? st->symbol()->identifier() : "unknown";
findArrayRefs(newLoop);
SgStatement *lexPrev = st->lexPrev();

52
src/GraphLoop/graph_loops.h
View File

@@ -25,33 +25,6 @@ namespace DIST = Distribution;
void getRealArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
void getAllArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
enum class LoopType { NONE, FOR, WHILE, IMPLICIT };
struct InductiveVariables
{
private:
std::string mainVar;
std::set<std::string> allVars;
public:
InductiveVariables() { }
explicit InductiveVariables(const std::string& mainVar, const std::set<std::string>& allVars) : mainVar(mainVar), allVars(allVars) { };
std::string getMainVar() const { return mainVar; }
std::set<std::string> getAllVars() const { return allVars; }
void addVar(const std::string& var) { allVars.insert(var); }
void addMainVar(const std::string& var) { mainVar = var; allVars.insert(var); }
void replaceMainVar(const std::string& var)
{
allVars.erase(mainVar);
addMainVar(var);
}
};
struct LoopGraph
{
private:
@@ -97,7 +70,7 @@ public:
calculatedCountOfIters = 0;
executionTimeInSec = -1.0;
inDvmhRegion = 0;
loopType = LoopType::NONE;
isFor = false;
inCanonicalFrom = false;
hasAccessToSubArray = false;
hasSubstringRefs = false;
@@ -140,24 +113,21 @@ public:
{
return hasUnknownArrayDep || hasUnknownScalarDep || hasGoto || hasPrints || (hasConflicts.size() != 0) || hasStops || hasNonPureProcedures ||
hasUnknownArrayAssigns || hasNonRectangularBounds || hasIndirectAccess || hasWritesToNonDistribute || hasDifferentAlignRules || hasDvmIntervals ||
!isFor() || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
!isFor || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
}
bool hasLimitsToSplit() const
{
return hasGoto || hasStops || !isFor() || hasPrints;
return hasGoto || hasStops || !isFor || hasPrints;
}
bool hasLimitsToCombine() const
{
return hasGoto || hasStops || !isFor() || hasPrints || linesOfCycle.size();
return hasGoto || hasStops || !isFor || hasPrints || linesOfCycle.size();
}
void addConflictMessages(std::vector<Messages> *messages)
{
if (messages == NULL)
return;
const int line = altLineNum > 0 ? altLineNum : lineNum;
if (hasUnknownArrayDep)
messages->push_back(Messages(NOTE, line, R113, L"unknown array dependency prevents parallelization of this loop", 3006));
@@ -198,7 +168,7 @@ public:
if (hasDvmIntervals)
messages->push_back(Messages(NOTE, line, R145, L"DVM intervals prevent parallelization of this loop", 3006));
if (!isFor() || !inCanonicalFrom)
if (!isFor || !inCanonicalFrom)
messages->push_back(Messages(NOTE, line, R178, L"This type of loop is not supported by the system", 3006));
if (lastprivateScalars.size())
@@ -423,14 +393,6 @@ public:
void* getRealStat(const char* file) const;
bool isFor() const { return loopType == LoopType::FOR; }
bool isWhile() const { return loopType == LoopType::WHILE; }
bool isImplicit() const { return loopType == LoopType::IMPLICIT; }
std::string loopSymbol() const { return loopSymbols.getMainVar(); }
public:
int lineNum;
int altLineNum;
@@ -445,7 +407,7 @@ public:
int startVal, endVal, stepVal;
std::tuple<Expression*, Expression*, Expression*> startEndStepVals;
InductiveVariables loopSymbols;
std::string loopSymbol;
std::pair<Expression*, Expression*> startEndExpr;
bool hasGoto;
@@ -486,7 +448,7 @@ public:
bool hasSubstringRefs;
LoopType loopType;
bool isFor;
bool inCanonicalFrom;

4
src/GraphLoop/graph_loops_base.cpp
View File

@@ -551,7 +551,7 @@ void addToDistributionGraph(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*>>
continue;
}
if (!loopAccess.first->isFor())
if (!loopAccess.first->isFor)
continue;
DIST::GraphCSR<int, double, attrType>& G = currReg->GetGraphToModify();
@@ -775,7 +775,7 @@ static void isAllOk(const vector<LoopGraph*> &loops, vector<Messages> &currMessa
{
if (loops[i]->region)
{
if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor())
if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor)
{
wstring bufE, bufR;
__spf_printToLongBuf(bufE, L" Can not calculate count of iterations for this loop, information about iterations in all loops in parallel regions '%s' will be ignored",

4
src/LoopAnalyzer/loop_analyzer.cpp
View File

@@ -48,7 +48,7 @@ extern int passDone;
#include "../VisualizerCalls/get_information.h"
#include "../VisualizerCalls/SendMessage.h"
#include "LoopEndDoConverter/enddo_loop_converter.h"
#include "../Transformations/LoopEndDoConverter/enddo_loop_converter.h"
#include "../DirectiveProcessing/remote_access.h"
#include "../DirectiveProcessing/directive_omp_parser.h"
@@ -2199,7 +2199,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
LoopGraph *tmpLoop = new LoopGraph();
tmpLoop->region = reg;
tmpLoop->loopType = LoopType::FOR;
tmpLoop->isFor = true;
tmpLoops.push_back(tmpLoop);

2
src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
View File

@@ -18,7 +18,7 @@
#include "../DirectiveProcessing/insert_directive.h"
#include "SgUtils.h"
#include "expr_transform.h"
#include "FunctionPurifying/function_purifying.h"
#include "../Transformations/FunctionPurifying/function_purifying.h"
using std::map;
using std::pair;

2
src/Predictor/PredictScheme.cpp
View File

@@ -22,7 +22,7 @@
#include "graph_loops_func.h"
#include "expr_transform.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
#include "json.hpp"

2
src/PrivateAnalyzer/private_analyzer.cpp
View File

@@ -12,7 +12,7 @@
#include "graph_calls.h"
#include "private_analyzer.h"
#include "dvm.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
using std::vector;

4
src/PrivateAnalyzer/private_arrays_search.cpp
View File

@@ -11,11 +11,11 @@
#include "region.h"
#include "SgUtils.h"
#include "graph_loops.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
using namespace std;
static void Collapse(Region* region)
void Collapse(Region* region)
{
if (region->getBasickBlocks().empty())
return;

4
src/PrivateAnalyzer/private_arrays_search.h
View File

@@ -5,8 +5,10 @@
#include <unordered_set>
#include "range_structures.h"
#include "region.h"
#include "graph_loops.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
void Collapse(Region* region);
std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);

2
src/PrivateAnalyzer/region.cpp
View File

@@ -51,7 +51,7 @@ pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForL
}
static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
string index = loop->loopSymbol();
string index = loop->loopSymbol;
loopForIndex[index] = loop;
for (const auto& childLoop : loop->children)

2
src/PrivateAnalyzer/region.h
View File

@@ -6,7 +6,7 @@
#include <string>
#include "graph_loops.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
class Region : public SAPFOR::BasicBlock {
public:

2
src/ProjectManipulation/ConvertFiles.cpp
View File

@@ -403,7 +403,7 @@ static int convertFile(int argc, char* argv[], const set<string>& filesInProj, c
fprintf(stderr, "<<<<< Unparsing %s >>>>>\n", fout_name);
if (mod_gpu) /*ACC*/
UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info, fout_name);
UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info);
const string fileN = file->filename();
set<SgStatement*> toRemove;

15
src/Sapfor.cpp
View File

@@ -89,7 +89,6 @@
#include "Transformations/DeadCodeRemoving/dead_code.h"
#include "Transformations/RenameSymbols/rename_symbols.h"
#include "Transformations/FunctionInlining/inliner.h"
#include "Transformations/SwapOperators/swap_operators.h"
#include "ProjectParameters/projectParameters.h"
@@ -940,8 +939,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
internalExit = err;
}
}
else if (curr_regime == SWAP_OPERATORS)
runSwapOperators(file, loopGraph, fullIR, countOfTransform);
else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
{
auto itFound = loopGraph.find(file->filename());
@@ -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,
SWAP_OPERATORS };
REMOVE_DEAD_CODE };
if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
{
@@ -1285,6 +1281,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
detectCopies(allFuncInfo);
fillInterfaceBlock(allFuncInfo);
intentInsertToInterfaces(allFuncInfo);
createInterfacesForAssumedSize(allFuncInfo);
//this call is only for testing
//setPureStatus(allFuncInfo);
@@ -1918,8 +1915,6 @@ 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.;
@@ -2155,8 +2150,6 @@ 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);
}
@@ -2338,7 +2331,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
case INSERT_NO_DISTR_FLAGS_FROM_GUI:
case PRIVATE_REMOVING:
case RENAME_INLCUDES:
case SWAP_OPERATORS:
runAnalysis(*project, curr_regime, true, "", folderName);
break;
case INLINE_PROCEDURES:
@@ -2640,10 +2632,7 @@ int main(int argc, char **argv)
}
if (curr_regime == INSERT_PARALLEL_DIRS_NODIST)
{
ignoreArrayDistributeState = true;
sharedMemoryParallelization = 1;
}
if (runAsClient)
{

7
src/Sapfor.h
View File

@@ -122,8 +122,6 @@ enum passes {
CREATE_INTER_TREE,
INSERT_INTER_TREE,
SWAP_OPERATORS,
SHADOW_GROUPING,
INLINE_PROCEDURES,
FILL_PARALLEL_REG_IR,
@@ -187,8 +185,6 @@ enum passes {
FIND_PRIVATE_ARRAYS,
TRANSFORM_ASSUMED_SIZE_PARAMETERS,
TEST_PASS,
EMPTY_PASS
};
@@ -321,7 +317,6 @@ static void setPassValues()
passNames[CHECK_PAR_REG_DIR] = "CHECK_PAR_REG_DIR";
passNames[CREATE_INTER_TREE] = "CREATE_INTER_TREE";
passNames[INSERT_INTER_TREE] = "INSERT_INTER_TREE";
passNames[SWAP_OPERATORS] = "SWAP_OPERATORS";
passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";
@@ -376,8 +371,6 @@ 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";
}

56
src/Transformations/DeadCodeRemoving/dead_code.cpp
View File

@@ -6,8 +6,6 @@
#include <set>
#include <algorithm>
#include "../CFGraph/CFGraph.h"
using std::map;
using std::string;
using std::vector;
@@ -90,13 +88,13 @@ static void updateUseDefForInstruction(SAPFOR::BasicBlock* block, SAPFOR::Instru
instr_operation == SAPFOR::CFG_OP::STORE)
last_stack_op_useful = true;
for (auto& e : res)
for (auto e : res)
{
def.insert(e);
use.erase(e);
}
for (auto& e : args)
for (auto e : args)
{
use.insert(e);
def.erase(e);
@@ -166,7 +164,7 @@ public:
{
const auto& example = dynamic_cast<DeadCodeAnalysisNode*>(*prev.begin())->next_notempty_out;
for (auto& p : prev)
for (auto p : prev)
{
DeadCodeAnalysisNode* next = dynamic_cast<DeadCodeAnalysisNode*>(p);
@@ -190,7 +188,7 @@ public:
{
set<DeadCodeAnalysisNode*> current = {};
for (auto& nextP : getPrevBlocks())
for (auto nextP : getPrevBlocks())
{
DeadCodeAnalysisNode* next = dynamic_cast<DeadCodeAnalysisNode*>(nextP);
@@ -430,7 +428,49 @@ int removeDeadCode(SgStatement* func,
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto& cfg_pair = *(cfg.begin());
removedUnreachableBlocks(cfg_pair.second);
// delete unreachable blocks
set<SAPFOR::BasicBlock*> reachable;
for (auto b : cfg_pair.second)
if(b->getInstructions().front()->isHeader() ||
b->getInstructions().front()->getInstruction()->getOperation() == SAPFOR::CFG_OP::ENTRY)
reachable.insert(b);
set<SAPFOR::BasicBlock*> worklist = reachable;
while (worklist.size() != 0)
{
set<SAPFOR::BasicBlock*> to_insert;
for(auto b : worklist)
for(auto next: b->getNext())
if(reachable.insert(next).second)
to_insert.insert(next);
worklist = to_insert;
}
auto remove_unreachable_it = remove_if(cfg_pair.second.begin(), cfg_pair.second.end(),
[&reachable](SAPFOR::BasicBlock* b)
{
if (reachable.find(b) == reachable.end())
{
for(auto next: b->getNext())
if(reachable.find(next) != reachable.end())
next->removePrev(b);
delete b;
return true;
}
return false;
}
);
reachable.clear();
cfg_pair.second.erase(remove_unreachable_it, cfg_pair.second.end());
#if DEBUG_IR
dumpCFG({ cfg_pair }, false);
@@ -441,7 +481,7 @@ int removeDeadCode(SgStatement* func,
map<string, FuncInfo*> funcByName;
for (auto& byFile : allFuncs)
for (auto& byFunc : byFile.second)
for (auto byFunc : byFile.second)
funcByName[byFunc->funcName] = byFunc;
DeadCodeAnalysis analysis_object(func_parameters, funcByName);

8
src/Transformations/DeadCodeRemoving/dead_code.h
View File

@@ -4,10 +4,10 @@
#include<vector>
#include "SgUtils.h"
#include "CFGraph/CFGraph.h"
#include "CFGraph/live_variable_analysis.h"
#include "CFGraph/DataFlow/data_flow.h"
#include "CFGraph/DataFlow/backward_data_flow.h"
#include "../CFGraph/CFGraph.h"
#include "../CFGraph/live_variable_analysis.h"
#include "../CFGraph/DataFlow/data_flow.h"
#include "../CFGraph/DataFlow/backward_data_flow.h"
int removeDeadCode(SgStatement* func,
const std::map<std::string, std::vector<FuncInfo*>>&allFuncs,

11
src/Transformations/ExpressionSubstitution/expr_transform.cpp
View File

@@ -440,18 +440,15 @@ bool replaceConstantRec(SgExpression *&exp)
if (exp->variant() == CONST_REF)
{
SgExpression *ret = ReplaceParameter_(exp);
int sign = 1;
SgExpression* toCalc = ret;
if (toCalc->variant() == UNARY_ADD_OP)
toCalc = toCalc->lhs();
if (toCalc->variant() == MINUS_OP)
if (ret->variant() == UNARY_ADD_OP)
toCalc = ret->lhs();
if (ret->variant() == MINUS_OP)
{
toCalc = toCalc->lhs();
toCalc = ret->lhs();
sign = -1;
}
if (toCalc->isInteger())
{
exp = new SgValueExp(sign * toCalc->valueInteger());

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

@@ -103,7 +103,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
if (line <= 0)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
intr->setlineNumber(getNextNegativeLineNumber());
intr->setlineNumber(line);
st->insertStmtBefore(*intr, *func->funcPointer);
}
else
@@ -136,41 +136,33 @@ void createInterfacesForOutCalls(FuncInfo* func)
}
}
static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, vector<SgSymbol*>& parNames)
static bool changeIfHasStarRange(SgExpression* arrayDecl, bool doReplace = false)
{
SgExpression* list = arrayDecl->lhs();
string varN = arrayDecl->symbol()->identifier() + string("_sz");
bool has = false;
bool has = doReplace;
SgExpression* allDimsBefore = NULL;
while (list)
{
const int var = list->lhs()->variant();
if (var == STAR_RANGE)
{
has = true;
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());
}
list = list->rhs();
}
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())
@@ -205,7 +197,7 @@ static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, ve
for (auto& rem : toRem)
rem->deleteStmt();
}*/
}
template<typename T>
static vector<FuncInfo*> sortByName(const T &funcs)
@@ -218,25 +210,9 @@ static vector<FuncInfo*> sortByName(const T &funcs)
return funcList;
}
static bool hasDvmParallel(SgStatement *func)
void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
{
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;
set<FuncInfo*> hasAssumedSizeArrays;
for (auto& funcByFile : allFuncInfo)
{
@@ -249,12 +225,6 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
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)
@@ -274,8 +244,13 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
{
if (list->lhs() && list->lhs()->symbol()->identifier() == name)
{
if (changeIfHasStarRange(list->lhs(), scope, parNames))
assumedSizeArraysByFunc[func->funcName].push_back(z);
if (changeIfHasStarRange(list->lhs()))
{
hasRefs = true;
hasAssumedSizeArrays.insert(func);
}
else
arrayRefs.push_back(list->lhs());
break;
}
list = list->rhs();
@@ -284,20 +259,13 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
}
}
if (parNames.size())
{
SgProcHedrStmt* proc = isSgProcHedrStmt(func->funcPointer->GetOriginal());
checkNull(proc, convertFileName(__FILE__).c_str(), __LINE__);
//makeDeclaration(parNames, scope);
for (auto& newPar : parNames)
proc->AddArg(*new SgVarRefExp(newPar));
}
if (hasRefs)
for (auto& ref : arrayRefs)
changeIfHasStarRange(ref, true);
}
}
if (assumedSizeArraysByFunc.size() == 0)
if (hasAssumedSizeArrays.size() == 0)
return;
for (auto& funcByFile : allFuncInfo)
@@ -305,60 +273,26 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
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;
for (auto& detailedCall : func->callsFromDetailed)
set<string> addedInterfaceFor;
for (auto& elem : sortByName(func->callsFromV))
{
auto it = assumedSizeArraysByFunc.find(detailedCall.detailCallsFrom.first);
if (it != assumedSizeArraysByFunc.end())
auto it = hasAssumedSizeArrays.find(elem);
if (it != hasAssumedSizeArrays.end())
{
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);
}
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__);
//TODO: need to do it better
SgExpression* parArray = pars[parNum]->copyPtr();
parArray->setLhs(NULL);
parArray->setRhs(NULL);
SgFunctionCallExp* call = new SgFunctionCallExp(*funcSize, *parArray);
last->setRhs(new SgExpression(EXPR_LIST, call));
last = last->rhs();
}
auto callFrom = *it;
DvmhRegionInserter::createInterfaceBlockForOutCall(func, callFrom);
addedInterfaceFor.insert(callFrom->funcName);
}
}
if (addedInterfaceFor.size())
removeExternalStat(prog, addedInterfaceFor);
}
}
}
@@ -525,7 +459,7 @@ static void insertIntents(set<string>& identificators, SgStatement* header, cons
if (args.size())
{
SgIntentStmt* intent = new SgIntentStmt(*makeExprList(args), *attr);
intent->setlineNumber(getNextNegativeLineNumber());
intent->setlineNumber(lastDecl->lineNumber());
lastDecl->insertStmtAfter(*intent, (header == lastDecl) ? *header : *lastDecl->controlParent());
}
@@ -1454,37 +1388,6 @@ static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsTo
return name;
}
static bool filterFromList(SgStatement* st, const set<string>& idents, bool exclude = false)
{
bool empty = false;
SgExpression* list = st->expr(0);
vector<SgExpression*> newList;
int total = 0;
while (list)
{
if (exclude)
{
if (idents.find(list->lhs()->symbol()->identifier()) == idents.end())
newList.push_back(list->lhs());
}
else
{
if (idents.find(list->lhs()->symbol()->identifier()) != idents.end())
newList.push_back(list->lhs());
}
total++;
list = list->rhs();
}
if (newList.size() == 0)
empty = true;
else if (total != newList.size())
st->setExpression(0, makeExprList(newList));
return empty;
}
static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
{
string oldFile = current_file->filename();
@@ -1492,21 +1395,22 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto copy = duplicateProcedure(func, NULL, false, false, false, true);
const set<string> idents(pars.identificators.begin(), pars.identificators.end());
const set<string> ident(pars.identificators.begin(), pars.identificators.end());
//remove all exec
SgStatement* st = copy->lexNext();
SgStatement* last = copy->lastNodeOfStmt();
vector<SgStatement*> toExtract;
while (st != last)
{
if (isDVM_stat(st) || isSPF_stat(st))
{
if (st->variant() != ACC_ROUTINE_DIR)
{
toExtract.push_back(st);
st = st->lexNext();
SgStatement* next = st->lexNext();
st->extractStmt();
st = next;
}
else
st = st->lexNext();
@@ -1527,20 +1431,31 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
st = copy->lexNext();
while (st != last)
{
const int var = st->variant();
if (var == VAR_DECL || var == VAR_DECL_90 || var == DIM_STAT ||
var == INTENT_STMT || var == EXTERN_STAT)
if (st->variant() == VAR_DECL
|| st->variant() == VAR_DECL_90
|| st->variant() == DIM_STAT
|| st->variant() == INTENT_STMT)
{
bool empty = filterFromList(st, idents);
if (empty)
SgExpression* list = st->expr(0);
vector<SgExpression*> newList;
while (list)
{
if (ident.find(list->lhs()->symbol()->identifier()) != ident.end())
newList.push_back(list->lhs());
list = list->rhs();
}
if (newList.size() == 0)
{
SgStatement* next = st->lexNext();
toExtract.push_back(st);
st = st->lexNext();
st = next;
continue;
}
else
st->setExpression(0, makeExprList(newList));
}
else if (!isDVM_stat(st) && !isSPF_stat(st))
else
toExtract.push_back(st);
if (st->variant() == CONTAINS_STMT)
@@ -1551,56 +1466,16 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
for (auto& elem : toExtract)
elem->extractStmt();
string codeString = copy->unparse();
string retVal = copy->unparse();
if (SgFile::switchToFile(oldFile) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
//insert tabs
const string tab = " ";
const int countEnds = std::count(codeString.begin(), codeString.end(), '\n');
string retVal = " ";
retVal.reserve(retVal.size() + codeString.size() + countEnds * tab.size());
for (int z = 0, ends = 0; z < codeString.size(); ++z)
{
retVal += codeString[z];
if (codeString[z] == '\n')
{
ends++;
if (ends == countEnds)
continue;
int p = z + 1;
while (codeString[p] == ' ' && p < codeString.size())
++p;
auto start = p;
auto end = string::npos;
auto sub = codeString.find("subroutine", p);
auto func = codeString.find("function", p);
auto end_sub = codeString.find("end subroutine", p);
auto end_func = codeString.find("end function", p);
if (sub != end && sub == start || end_sub != end && end_sub == start ||
func != end && func == start || end_func != end && end_func == start)
{
retVal += " ";
}
else
retVal += tab;
}
}
return retVal;
}
void insertInterface(SgStatement* func, const FuncInfo *callFrom)
static void insertInterface(SgStatement* func, const string& iface)
{
const string& iface = getInterfaceBlock(callFrom->funcPointer->GetOriginal(), callFrom->funcParams);
const string& fName = callFrom->funcName;
string oldFile = current_file->filename();
if (!func->switchToFile())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -1609,18 +1484,6 @@ void insertInterface(SgStatement* func, const FuncInfo *callFrom)
SgStatement* last = func->lastNodeOfStmt();
while (st != last)
{
if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
{
bool empty = filterFromList(st, { fName }, true);
if (empty)
{
SgStatement* next = st->lexNext();
st->extractStmt();
st = next;
continue;
}
}
if (isSgExecutableStatement(st))
break;
st = st->lexNext();
@@ -1628,7 +1491,7 @@ void insertInterface(SgStatement* func, const FuncInfo *callFrom)
SgStatement* ifaceBlock = new SgStatement(INTERFACE_STMT);
addControlEndToStmt(ifaceBlock->thebif);
ifaceBlock->setlineNumber(getNextNegativeLineNumber());
ifaceBlock->setlineNumber(st->lineNumber());
ifaceBlock->setFileName(st->fileName());
st->insertStmtBefore(*ifaceBlock, *st->controlParent());
ifaceBlock->lastNodeOfStmt()->addComment(iface.c_str());
@@ -1644,7 +1507,7 @@ static void createInterfaceBlockForToCalls(FuncInfo* func)
if (callTo->interfaceBlocks.find(func->funcName) == callTo->interfaceBlocks.end())
{
callTo->interfaceBlocks[func->funcName] = func;
insertInterface(callTo->funcPointer, func);
insertInterface(callTo->funcPointer, getInterfaceBlock(func->funcPointer->GetOriginal(), func->funcParams));
}
}
}

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

@@ -6,6 +6,7 @@ bool checkOutCalls(const std::set<std::string>& outCalls);
std::map<SgStatement*, std::set<std::string>> fillFromIntent(SgStatement* header);
void intentInsert(const std::vector<FuncInfo*>& allFuncInfo);
void intentInsertToInterfaces(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
void createInterfacesForAssumedSize(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
void createInterfacesForOutCalls(FuncInfo* func);
void setPureStatus(const std::set<FuncInfo*>& funcInfo);
void setPureStatus(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
@@ -13,7 +14,3 @@ void setPureStatus(const std::map<std::string, std::vector<FuncInfo*>>& allFuncI
void commonTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, CommonBlock*>& commonBlocks);
void saveTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
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);

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

@@ -20,7 +20,7 @@ using std::wstring;
static SgSymbol* getLoopSymbol(const LoopGraph* loop)
{
if (!loop || !loop->isFor())
if (!loop || !loop->isFor)
return NULL;
SgForStmt* stmt = (SgForStmt*)loop->loop->GetOriginal();
@@ -667,12 +667,12 @@ static void renameIterationVariables(LoopGraph* loop, const map<SgSymbol*, SgSym
{
if (loop)
{
const string& loopName = loop->loopSymbol();
for (auto& [from, to] : symbols)
string& loopName = loop->loopSymbol;
for (auto& pair : symbols)
{
if (from->identifier() == loopName)
if (pair.first->identifier() == loopName)
{
loop->loopSymbols.replaceMainVar(to->identifier());
loop->loopSymbol = (string)pair.second->identifier();
break;
}
}
@@ -691,9 +691,9 @@ static void renameVariablesInLoop(LoopGraph* loop, const map<SgSymbol*, SgSymbol
if (st->variant() == FOR_NODE)
{
SgForStmt* for_st = (SgForStmt*)st;
for (auto& [from, to] : symbols)
if (isEqSymbols(from, for_st->symbol()))
for_st->setDoName(*to);
for (auto& pair : symbols)
if (isEqSymbols(pair.first, for_st->symbol()))
for_st->setDoName(*pair.second);
}
for (int i = 0; i < 3; ++i)
@@ -710,12 +710,12 @@ static void renamePrivatesInMap(LoopGraph* loop, const map<SgSymbol*, SgSymbol*>
for (auto& priv : privates->second)
{
bool found = false;
for (auto& [from, to] : symbols)
for (auto& pair : symbols)
{
if (isEqSymbols(priv, from))
if (isEqSymbols(priv, pair.first))
{
found = true;
newList.insert(to);
newList.insert(pair.second);
break;
}
}
@@ -1590,7 +1590,7 @@ static bool combine(LoopGraph* firstLoop, const vector<LoopGraph*>& nextLoops, s
bool wasCombine = false;
for (LoopGraph* loop : nextLoops)
{
if (!loop->isFor())
if (!loop->isFor)
return wasCombine;
int perfectLoop = std::min(firstLoop->perfectLoop, loop->perfectLoop);
@@ -1723,7 +1723,7 @@ static bool tryToCombine(vector<LoopGraph*>& loopGraphs, map<LoopGraph*, set<SgS
{
LoopGraph* loop = loops[z];
newloopGraphs.push_back(loop);
if (!loop->isFor())
if (!loop->isFor)
continue;
vector<LoopGraph*> nextLoops = getNextLoops(loop, loopGraphs, -1);

4
src/Transformations/LoopSplitting/loops_splitter.cpp
View File

@@ -6,7 +6,7 @@
#include "../LoopAnalyzer/loop_analyzer.h"
#include "expr_transform.h"
#include "errors.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
#include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "../DirectiveProcessing/directive_omp_parser.h"
@@ -1035,7 +1035,7 @@ int splitLoops(SgFile *file, vector<LoopGraph*> &loopGraphs, vector<Messages> &m
for (auto &loopPair : mapLoopGraph)
{
if (!loopPair.second->isFor())
if (!loopPair.second->isFor)
continue;
LoopGraph *loop = loopPair.second;

2
src/Transformations/PrivateArrayRemoving/private_removing.cpp
View File

@@ -2257,7 +2257,7 @@ void removePrivatesAnalysis(string filename,
{
for (LoopGraph* loop : loopGraphs)
{
if (!loop->isFor())
if (!loop->isFor)
continue;
SgForStmt* loopStmt = (SgForStmt*)loop->loop->GetOriginal();

4
src/Transformations/PrivateArrayRemoving/private_removing.h
View File

@@ -2,8 +2,8 @@
#include "dvm.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "CFGraph/CFGraph.h"
#include "CFGraph/RD_subst.h"
#include "../CFGraph/CFGraph.h"
#include "../CFGraph/RD_subst.h"
// Regime defines the regime of private removing
enum class Regime { DEFLT = 1, REGULAR_INDEXES };

4
src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp
View File

@@ -74,7 +74,7 @@ static void fillIterationVariables(const LoopGraph* loop, set<string>& vars, int
{
if (dimensions == -1)
{
vars.insert(loop->loopSymbol());
vars.insert(loop->loopSymbol);
for (LoopGraph* child : loop->children)
fillIterationVariables(child, vars);
}
@@ -82,7 +82,7 @@ static void fillIterationVariables(const LoopGraph* loop, set<string>& vars, int
{
for (int i = 0; i < dimensions; ++i)
{
vars.insert(loop->loopSymbol());
vars.insert(loop->loopSymbol);
if (i != dimensions - 1)
loop = loop->children[0];
}

562
src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp
View File

@@ -17,157 +17,6 @@ using std::pair;
#define DEBUG_TRACE 0
static bool hasArrayRef(SgExpression* ex)
{
if (ex)
return isArrayRef(ex) || hasArrayRef(ex->lhs()) || hasArrayRef(ex->rhs());
return false;
}
static inline bool isArrayDeclaration(SgStatement* st)
{
return isSgDeclarationStatement(st) || isSgVarListDeclStmt(st) || isSgNestedVarListDeclStmt(st);
}
static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
{
if (exp)
{
if (exp->variant() == variant)
return exp;
auto *l = findExprWithVariant(exp->lhs(), variant);
if (l)
return l;
auto *r = findExprWithVariant(exp->rhs(), variant);
if (r)
return r;
}
return NULL;
}
static bool switchToDeclarationFile(DIST::Array* array_p,
pair<string, int>& decl_place,
const string &current_file_name,
FuncInfo *current_func)
{
if (!array_p)
return false;
// try to find declaration from current function
for (const auto &p : array_p->GetDeclInfo())
{
if (p.first == current_file_name &&
current_func->linesNum.first <= p.second &&
p.second <= current_func->linesNum.second)
{
decl_place = p;
return true;
}
}
for (const auto &p : array_p->GetDeclInfo())
{
if (SgFile::switchToFile(p.first) != -1)
{
decl_place = p;
return true;
}
}
return false;
}
static bool checkAssumedShape(SgStatement* decl, const string& array_name)
{
SgExpression* list = decl->expr(0);
SgExpression* dim_list = NULL;
while (list)
{
auto *arr_ref = list->lhs();
if (arr_ref &&
arr_ref->symbol() &&
arr_ref->symbol()->identifier() &&
arr_ref->symbol()->identifier() == array_name)
{
dim_list = arr_ref->lhs();
break;
}
list = list->rhs();
}
if (!dim_list)
{
auto *dim_expr = findExprWithVariant(decl->expr(2), DIMENSION_OP);
if (dim_expr)
dim_list = dim_expr->lhs();
}
while (dim_list)
{
auto *lhs = dim_list->lhs();
if (lhs && lhs->variant() == DDOT && (!lhs->lhs() || !lhs->rhs()))
return true;
dim_list = dim_list->rhs();
}
return false;
}
static bool checkAssumedSize(const string &array_name, DIST::Array* array_p, const string &current_file_name, FuncInfo *current_func)
{
if (!array_p)
return true; // raise true to prevent array from copying
bool found = false;
pair<string, int> decl_place;
if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func))
return true;
auto *st = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
checkNull(st, convertFileName(__FILE__).c_str(), __LINE__);
SgExpression* list = st->expr(0);
while (list)
{
if (list->lhs() &&
list->lhs()->symbol() &&
list->lhs()->symbol()->identifier() &&
list->lhs()->symbol()->identifier() == array_name
)
{
if(findExprWithVariant(list->lhs(), STAR_RANGE))
found = true;
break;
}
list = list->rhs();
}
if (!found)
{
auto *dim_expr = findExprWithVariant(st->expr(2), DIMENSION_OP);
if (dim_expr && findExprWithVariant(dim_expr, STAR_RANGE))
found = true;
}
if (SgFile::switchToFile(current_file_name) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__); // can't switch back to file with array usage
return found;
}
static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
{
if (exp)
@@ -180,15 +29,12 @@ static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
}
}
static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays,
SgStatement* stat,
const string& current_file_name,
FuncInfo *current_func)
static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, SgStatement* stat)
{
auto var = stat->variant();
if (var != READ_STAT && var != PRINT_STAT && var != WRITE_STAT)
return false;
return;
// check if such IO allowed in dvm:
// list should consist only of single array and format string should be *
@@ -198,26 +44,22 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
SgExpression* ioList = stat->expr(0);
if (!ioList)
return false;
return;
if (ioList->variant() != EXPR_LIST)
return false;
return;
if (ioList->rhs() == NULL)
{
SgExpression* arg = ioList->lhs();
if (!arg)
return false;
return;
if (hasArrayRef(arg))
{
if (isArrayRef(arg) && arg->lhs())
need_replace = true;
}
else
{
return false;
}
if (!isArrayRef(arg))
return;
if (arg->lhs())
need_replace = true;
}
else
{
@@ -232,43 +74,37 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
{
SgExpression* fmt = stat->expr(1);
if (!fmt || fmt->variant() != SPEC_PAIR || fmt->lhs()->variant() != KEYWORD_VAL)
{
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
return;
}
if (fmt->rhs()->variant() != KEYWORD_VAL || fmt->rhs()->sunparse() != "*")
need_replace = true;
break;
}
case READ_STAT:
case WRITE_STAT:
{
SgExpression* spec = stat->expr(1);
if (spec->variant() == SPEC_PAIR)
__spf_print(DEBUG_TRACE, "[%d: %s (%d)]\n", 2000, spec->rhs()->unparse(), spec->rhs()->variant());
if (!spec || spec->variant() != EXPR_LIST ||
spec->lhs()->variant() != SPEC_PAIR ||
!spec->rhs() || !spec->rhs()->lhs() || spec->rhs()->lhs()->variant() != SPEC_PAIR)
{
if (spec->rhs()->variant() != KEYWORD_VAL || spec->rhs()->sunparse() != "*")
{
need_replace = true;
break;
}
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
return;
}
else
{
while (spec)
{
auto *kv = spec->lhs();
if (!kv || kv->variant() != SPEC_PAIR || !kv->rhs())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
if (kv->rhs()->variant() != KEYWORD_VAL || kv->rhs()->sunparse() != "*")
{
need_replace = true;
break;
}
SgExpression* unit_val = spec->lhs()->rhs(), * fmt_val = spec->rhs()->lhs()->rhs();
if (unit_val->variant() != KEYWORD_VAL || unit_val->sunparse() != "*" ||
fmt_val->variant() != KEYWORD_VAL || fmt_val->sunparse() != "*")
need_replace = true;
spec = spec->rhs();
}
}
break;
}
default:
@@ -277,9 +113,7 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
}
if (!need_replace)
return false;
bool ret = false;
return;
set<SgSymbol*> found_arrays;
@@ -290,21 +124,11 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
{
string array_name = string(by_symb->identifier());
DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(by_symb), array_name);
if (array_p &&
array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV &&
!checkAssumedSize(array_name, array_p, current_file_name, current_func))
{
auto inserted = arrays[by_symb].insert(stat).second;
if (inserted)
__spf_print(DEBUG_TRACE, "[%d]: add array %s %p\n", stat->lineNumber(), array_p->GetName().c_str(), by_symb);
ret = true;
}
if (array_p && array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && arrays[by_symb].insert(stat).second)
__spf_print(DEBUG_TRACE, "[%d]: add array %s\n", stat->lineNumber(), array_p->GetName().c_str());
}
__spf_print(DEBUG_TRACE, "[replace]\n");
return ret;
}
static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgExpression* exp, bool& has_read, bool& has_write, bool from_read, bool from_write)
@@ -312,7 +136,8 @@ static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgExpression* e
if (!exp)
return;
if (isArrayRef(exp) &&
if (exp->variant() != STMT_STR && exp->symbol() &&
exp->symbol()->identifier() &&
strcmp(exp->symbol()->identifier(), arr->identifier()) == 0)
{
has_read |= from_read;
@@ -374,19 +199,16 @@ static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgStatement* st
}
}
static void copyArrayBetweenStatements(SgSymbol* replace_symb,
SgSymbol* replace_by,
SgStatement* start,
SgStatement* last,
bool start_is_scope,
FuncInfo *func_info)
static void copyArrayBetweenStatements(SgSymbol* replace_symb, SgSymbol* replace_by, SgStatement* start, SgStatement* last, bool start_is_scope)
{
while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
start = start->lexNext();
auto* stop = last->lexNext();
bool has_read = false, has_write = false;
for (auto* st = start->lexNext(); st && st != last; st = st->lexNext())
for (auto* st = start->lexNext(); st && st != stop->lexPrev(); st = st->lexNext())
replaceArrayRec(replace_symb, replace_by, st, has_read, has_write);
@@ -398,23 +220,10 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb,
auto* parent = start_is_scope ? start : start->controlParent();
if (parent && parent->lastNodeOfStmt() == start)
parent = parent->controlParent();
checkNull(parent, convertFileName(__FILE__).c_str(), __LINE__);
start->insertStmtAfter(*assign, *parent);
}
if (has_write)
{
for (int i = 0; i < func_info->funcParams.identificators.size(); i++)
{
if (func_info->funcParams.identificators[i] == replace_symb->identifier())
{
has_write &= func_info->funcParams.isArgOut(i);
break;
}
}
}
if (has_write)
{
// A = A_reg
@@ -425,14 +234,9 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb,
}
}
static void replaceArrayInFragment(SgSymbol* replace_symb,
const set<SgStatement*> usages,
SgSymbol* replace_by,
SgStatement* start,
SgStatement* last,
FuncInfo *func_info)
static void replaceArrayInFragment(SgSymbol* replace_symb, const set<SgStatement*> usages, SgSymbol* replace_by, SgStatement* start, SgStatement* last, const string& filename)
{
while (start->lexNext() && (!isSgExecutableStatement(start->lexNext()) || start->lexNext()->variant() == ALLOCATE_STMT))
while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
start = start->lexNext();
set<SgStatement*> not_opened, not_closed, copied;
@@ -499,7 +303,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb,
}
__spf_print(DEBUG_TRACE, "[copy %s] [%d, %d]\n", replace_symb->identifier(), scope_start->lineNumber(), scope_end->lineNumber());
copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start, func_info);
copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start);
copied.insert(copy_scope);
}
}
@@ -522,16 +326,12 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
STOP_STAT,
STOP_NODE,
EXIT_STMT,
EXIT_NODE,
GOTO_NODE
EXIT_NODE
};
if (border_stats.find(var) != border_stats.end())
return true;
if (stat->hasLabel())
return true;
if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
return true;
@@ -544,9 +344,9 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
}
void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
const map<string, vector<FuncInfo*>>& allFuncInfo,
map<string, vector<Messages>>& SPF_messages,
map<string, map<int, set<string>>>& newDeclsToInclude)
const map<string, vector<FuncInfo*>>& allFuncInfo,
map<string, vector<Messages>>& SPF_messages,
map<string, map<int, set<string>>>& newDeclsToInclude)
{
map<SgSymbol*, SgSymbol*> created_copies;
map<string, map<int, set<string>>> copied_syms;
@@ -555,29 +355,26 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
{
__spf_print(DEBUG_TRACE, "[%s]: enter region\n", region->GetName().c_str());
for (auto& lines_by_file : region->GetAllLinesToModify())
for (auto& linesByFile : region->GetAllLinesToModify())
{
const auto& current_file_name = lines_by_file.first;
const auto& filename = linesByFile.first;
if (SgFile::switchToFile(current_file_name) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto func_info_it = allFuncInfo.find(current_file_name);
if (func_info_it == allFuncInfo.end())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto *lbound_symb = new SgSymbol(FUNCTION_NAME, "lbound");
auto *ubound_symb = new SgSymbol(FUNCTION_NAME, "ubound");
for (auto& lines : lines_by_file.second)
if (SgFile::switchToFile(filename) < 0)
{
__spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", current_file_name.c_str(), lines.lines.first,
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
return;
}
for (auto& lines : linesByFile.second)
{
__spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", filename.c_str(), lines.lines.first,
lines.lines.second, lines.isImplicit());
SgStatement* curr_stmt, * end;
if (lines.isImplicit())
{
curr_stmt = current_file->SgStatementAtLine(lines.lines.first);
end = current_file->SgStatementAtLine(lines.lines.second);
@@ -593,7 +390,6 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
map<SgSymbol*, set<SgStatement*>> need_replace;
SgStatement* last_io_bound = NULL;
FuncInfo *current_func_info = NULL;
while (curr_stmt != end)
{
@@ -602,21 +398,9 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
auto var = curr_stmt->variant();
if (var == PROC_HEDR || var == PROG_HEDR || var == FUNC_HEDR)
{
current_func_info = NULL;
for (auto *func_info : func_info_it->second)
{
if (func_info->funcName == curr_stmt->symbol()->identifier())
{
current_func_info = func_info;
break;
}
}
if (!current_func_info)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
curr_stmt = curr_stmt->lexNext();
while (curr_stmt && !isSgExecutableStatement(curr_stmt))
{
@@ -640,192 +424,77 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
string array_name = string(array_to_copy->identifier());
DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(array_to_copy), array_name);
// at this point all considered arrays must have DIST::Array* references
if (!array_p)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
// ... and be declared in switchable files (not in headers)
pair<string, int> decl_place;
if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func_info))
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
bool fromModule = (array_p->GetLocation().first == DIST::l_MODULE);
const string locationName = array_p->GetLocation().second;
auto place = *array_p->GetDeclInfo().begin();
string fileName = place.first;
string suffix = "_io_l";
switch (array_p->GetLocation().first)
if (fromModule)
suffix = "_io_m";
pair<SgSymbol*, SgSymbol*> copied;
copied.first = array_to_copy;
if (SgFile::switchToFile(fileName) == -1)
{
case DIST::l_MODULE:
suffix = "_io_m";
break;
case DIST::l_COMMON:
suffix = "_io_c";
break;
}
auto copied_symbol = copyArray(decl_place,
array_p,
lines_by_file.second,
suffix + to_string(region->GetId()),
decl_place.first,
newDeclsToInclude,
copied_syms);
// original declaration statement
auto *decl_stmt = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
if (!decl_stmt || !isArrayDeclaration(decl_stmt))
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto dynamic_array = checkAssumedShape(decl_stmt, array_name);
while (decl_stmt && !isSgExecutableStatement(decl_stmt))
{
if (isArrayDeclaration(decl_stmt) &&
decl_stmt->expr(0) &&
decl_stmt->expr(0)->lhs() &&
decl_stmt->expr(0)->lhs()->symbol() == copied_symbol.second)
{
break;
}
decl_stmt = decl_stmt->lexNext();
}
// created declaration statement
if (!decl_stmt || !isArrayDeclaration(decl_stmt))
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
// insert !$SPF ANALYSIS(PROCESS_PRIVATE(array)) directive before declaration statement
string dir_str;
if (decl_stmt->comments())
{
auto str_comment = string(decl_stmt->comments());
if (str_comment.size() && str_comment.back() != '\n')
dir_str += "\n";
}
dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied_symbol.second->identifier()) + "))\n";
decl_stmt->addComment(dir_str.c_str());
created_copies.insert({ array_to_copy, copied_symbol.second });
// make array copy allocatable in case of assumed-shape array
if(dynamic_array)
{
// insert allocatable keyword in declaration
auto *kword_list = decl_stmt->expr(2);
if (!findExprWithVariant(kword_list, ALLOCATABLE_OP))
{
if (!kword_list)
{
kword_list = new SgExprListExp();
decl_stmt->setExpression(2, *kword_list);
}
while (kword_list->rhs())
kword_list = kword_list->rhs();
if (kword_list->lhs())
{
kword_list->setRhs(new SgExprListExp());
kword_list = kword_list->rhs();
}
kword_list->setLhs(new SgExpression(ALLOCATABLE_OP));
}
// can't switch back to file with array usage
if (SgFile::switchToFile(current_file_name) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
// insert allocate(a_l(lbound(a, 1):ubound(a,1),...)) statement
SgStatement* allocate_stmt_place = NULL;
auto* func_stmt = curr_stmt->getScopeForDeclare();
SgStatement* insertPlace = NULL;
for (auto iterator = func_stmt->lexNext();
iterator && !isSgExecutableStatement(iterator);
!isSgExecutableStatement(iterator) || isSPF_stat(iterator) &&
!(iterator->variant() == SPF_PARALLEL_REG_DIR || iterator->variant() == SPF_END_PARALLEL_REG_DIR);
iterator = iterator->lexNext())
{
allocate_stmt_place = iterator;
insertPlace = iterator;
}
//NULL - no decl stats in function!
if (!allocate_stmt_place)
allocate_stmt_place = func_stmt;
if (!insertPlace)
insertPlace = func_stmt;
auto *allocate_stmt_parent = allocate_stmt_place->controlParent();
if (allocate_stmt_parent->variant() == GLOBAL)
allocate_stmt_parent = allocate_stmt_place;
auto st = insertPlace->controlParent();
if (st->variant() == GLOBAL)
st = insertPlace;
auto *created_array_ref = new SgArrayRefExp(*copied_symbol.second);
auto& copied_symb = array_to_copy->copy();
copied.second = &copied_symb;
auto* dim_list = new SgExprListExp();
created_array_ref->setLhs(dim_list);
auto new_name = string(array_to_copy->identifier()) + "_io_c";
copied_symb.changeName(new_name.c_str());
int dim_len = array_p->GetSizes().size();
for (int i = 1; i <= dim_len; i++)
{
auto *lcall = new SgFunctionCallExp(*lbound_symb);
auto *rcall = new SgFunctionCallExp(*ubound_symb);
auto stat = array_to_copy->makeVarDeclStmt();
auto res = CalculateInteger(stat->expr(0)->copyPtr());
res->lhs()->setSymbol(copied_symb);
stat->setExpression(0, res);
for (auto *call : {lcall, rcall})
{
call->setLhs(new SgExprListExp());
call->lhs()->setLhs(new SgArrayRefExp(*array_to_copy));
call->lhs()->setRhs(new SgValueExp(i));
}
auto *dot_expr = new SgExpression(DDOT);
dot_expr->setLhs(lcall);
dot_expr->setRhs(rcall);
dim_list->setLhs(dot_expr);
if (i < dim_len)
{
auto *next = new SgExprListExp();
dim_list->setRhs(next);
dim_list = next;
}
}
auto *allocate_stmt = new SgStatement(ALLOCATE_STMT);
allocate_stmt->setExpression(0, created_array_ref);
allocate_stmt_place->insertStmtAfter(*allocate_stmt, *allocate_stmt_parent);
// insert deallocate statemens before all returns
auto *find_return_stmt = func_stmt;
while (find_return_stmt != func_stmt->lastNodeOfStmt())
{
auto *next = find_return_stmt->lexNext();
if (next && (isSgReturnStmt(next) || next == func_stmt->lastNodeOfStmt()))
{
if (next->hasLabel())
{
moveLabelBefore(next);
find_return_stmt = next->lexPrev();
}
auto *dealloc_stmt = new SgStatement(DEALLOCATE_STMT);
dealloc_stmt->setExpression(0, new SgExprListExp());
dealloc_stmt->expr(0)->setLhs(new SgArrayRefExp(*copied_symbol.second));
find_return_stmt->insertStmtAfter(*dealloc_stmt, *next->controlParent());
if (next == curr_stmt)
curr_stmt = dealloc_stmt;
}
find_return_stmt = next;
}
insertPlace->insertStmtAfter(*stat, *st);
}
else
{
copied = copyArray(place, array_p, linesByFile.second, suffix + to_string(region->GetId()), fileName, newDeclsToInclude, copied_syms);
}
// can't switch back to file with array usage
if (SgFile::switchToFile(current_file_name) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
SgStatement* decl = SgStatement::getStatementByFileAndLine(place.first, place.second);
if (decl)
decl = decl->lexNext();
if (decl)
{
string dir_str;
if (decl->comments())
{
string str_comment = string(decl->comments());
if (str_comment.size() && str_comment.back() != '\n')
dir_str += "\n";
}
dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied.second->identifier()) + "))\n";
decl->addComment(dir_str.c_str());
}
created_copies.insert({ array_to_copy, copied.second });
}
}
@@ -837,9 +506,12 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
{
auto it = created_copies.find(p.first);
if (it != created_copies.end())
replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, current_func_info);
replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, filename);
else
{
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
return;
}
}
}
@@ -857,17 +529,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
}
}
auto need_fix_io = populateDistributedIoArrays(need_replace, curr_stmt, current_file_name, current_func_info);
// incorrect IO statement with label
// move label to dummy statement and insert copy statements between dummy statement and IO
if (need_fix_io && curr_stmt->hasLabel())
{
moveLabelBefore(curr_stmt);
if (last_io_bound == curr_stmt) // always true
last_io_bound = curr_stmt->lexPrev();
}
populateDistributedIoArrays(need_replace, curr_stmt);
curr_stmt = curr_stmt->lexNext();
}
}

299
src/Transformations/SwapOperators/swap_operators.cpp
View File

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

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

2
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);
list({BUILD_IR, CALL_GRAPH2}) <= Pass(SWAP_OPERATORS);
list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING);

39
src/Utils/utils.cpp
View File

@@ -390,14 +390,31 @@ void clearGlobalBuffer() { globalOutputBuffer = ""; }
const string& getGlobalBuffer() { return globalOutputBuffer; }
set<short*> allocated;
set<int*> allocatedInt;
static void convertGlobalBuffer(short *&result, int *&resultSize)
{
const unsigned len = (unsigned)globalOutputBuffer.size();
result = new short[len + 1];
allocated.insert(result);
result[len] = '\0';
for (unsigned i = 0; i < len; ++i)
result[i] = globalOutputBuffer[i];
resultSize = new int[1];
resultSize[0] = (int)len;
}
extern map<string, vector<Messages>> SPF_messages; //file ->messages
void clearGlobalMessagesBuffer()
{
//clear allocated memory
for (auto& elem : allocated)
delete []elem;
delete[]elem;
for (auto& elem : allocatedInt)
delete[]elem;
allocated.clear();
allocatedInt.clear();
SPF_messages.clear();
}
@@ -434,7 +451,7 @@ static map<string, vector<Messages>> removeCopies(map<string, vector<Messages>>
return out;
}
static string convertGlobalMessagesBuffer()
static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
{
auto copySPF_messages = removeCopies(SPF_messages);
for (auto &byFile : copySPF_messages)
@@ -472,13 +489,21 @@ static string convertGlobalMessagesBuffer()
json all;
all["allMessages"] = allMessages;
return all.dump();
const string str = all.dump();
const unsigned len = (unsigned)str.size();
copyStringToShort(result, str);
allocated.insert(result);
resultSize = new int[1];
resultSize[0] = (int)len;
}
void convertBuffers(string &resultM, string &result)
void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize)
{
resultM = convertGlobalMessagesBuffer();
result = getGlobalBuffer();
convertGlobalMessagesBuffer(resultM, resultSizeM);
convertGlobalBuffer(result, resultSize);
}
bool isSPF_comment(const string &bufStr)

2
src/Utils/utils.h
View File

@@ -33,7 +33,7 @@ void addToGlobalBufferAndPrint(const std::string &toPrint);
void clearGlobalBuffer();
const std::string& getGlobalBuffer();
std::wstring to_wstring(const std::string);
void convertBuffers(std::string& resultM, std::string& result);
void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize);
void clearGlobalMessagesBuffer();
std::string renameInclude(const std::string& inc);
void copyIncludes(const std::set<std::string> &allIncludeFiles, const std::map<std::string, std::map<int, std::set<std::string>>> &commentsToInclude, const std::map<std::string, std::map<int, std::set<std::string>>>& newCopyDeclToIncl, const char *folderName, bool keepSpfDirs, bool isFreeStyle, bool isRename, int removeDirs = 0);

2
src/Utils/version.h
View File

@@ -1,3 +1,3 @@
#pragma once
#define VERSION_SPF "2446"
#define VERSION_SPF "2427"

655
src/VisualizerCalls/get_information.cpp
View File

File diff suppressed because it is too large Load Diff