libpredict_integration: precompute libpredict params

.gitignore

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

CMakeLists.txt

@@ -12,6 +12,7 @@ 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/)
@@ -203,8 +204,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}
@@ -227,8 +226,7 @@ set(TRANSFORMS
         ${TR_REPLACE_ARRAYS_IN_IO}
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS}
+        ${TR_RENAME_SYMBOLS})
-        ${TR_SWAP_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -333,7 +331,9 @@ set(MAIN src/Sapfor.cpp
         src/Utils/PassManager.h)
 
 set(PREDICTOR src/Predictor/PredictScheme.cpp
-              src/Predictor/PredictScheme.h)
+              src/Predictor/PredictScheme.h
+              src/Predictor/PredictSchemeWithLibrary.cpp
+              src/Predictor/PredictSchemeWithLibrary.h)
               
 set(LIBPREDICTOR  ${libpred_sources}/cluster.cpp
                   ${libpred_sources}/predictor.cpp
@@ -461,7 +461,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})
@@ -490,7 +489,7 @@ source_group (Predictor\\Library FILES ${LIBPREDICTOR})
 source_group (Parser FILES ${PARSER})
 source_group (PPPA\\PPPA FILES ${PPPA})
 source_group (PPPA\\ZLib FILES ${ZLIB})
-   
+
 if (MSVC_IDE)   
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /Zc:__cplusplus")
 else()
@@ -499,7 +498,9 @@ else()
     else()
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     endif()
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
+    if(NOT CMAKE_BUILD_TYPE)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+    endif()
 endif()
 
 add_subdirectory(projects/Fdvm)

src/DirectiveProcessing/directive_creator_base.cpp

@@ -122,6 +122,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
                 if (found == false)
                 {
                     directive->shadowRenew.push_back(make_pair(key, vector<pair<int, int>>()));
+                    directive->shadowRenewCorner.push_back(false);
 
                     const DIST::Array *arrayRef = read;
                     for (int i = 0; i < arrayRef->GetDimSize(); ++i)

src/DirectiveProcessing/shadow.cpp

@@ -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"

src/Distribution/ArrayAnalysis.cpp

@@ -241,13 +241,15 @@ 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 (privates.find(symb->identifier()) != privates.end() || isarrayInModule)
+                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
+                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
+                else if (isArrayInModule || privates.find(symb->identifier()) != privates.end())
                 {
                     //check in module
                     if (itNew->second.first->GetLocation().first == DIST::l_MODULE)
@@ -274,8 +276,6 @@ 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

src/Distribution/DvmhDirective.cpp

@@ -857,6 +857,11 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
                 shadowRenewShifts[i].resize(shadowRenew[i].second.size());
         }
 
+        if (shadowRenewCorner.size() == 0)
+        {
+            shadowRenewCorner.resize(shadowRenew.size(), false);
+        }
+
         string shadowAdd = ", SHADOW_RENEW(";
         int inserted = 0;
 
@@ -899,7 +904,10 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
                 for (auto& elem : genSubscripts(shadowRenew[i1].second, shadowRenewShifts[i1]))
                     newArrayRef->addSubscript(*elem);
 
-                if (shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop))
+                bool needCornerFlag = shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop);
+                shadowRenewCorner[i1] = needCornerFlag;
+
+                if (needCornerFlag)
                 {
                     SgExpression* tmp = new SgExpression(ARRAY_OP, newArrayRef, NULL, NULL);
                     p->setLhs(*tmp);

src/Distribution/DvmhDirective.h

@@ -102,6 +102,7 @@ public:
     //                               origin_Name   uniqName                   bounds
     std::vector<std::pair<std::pair<std::string, std::string>, std::vector<std::pair<int, int>>>> shadowRenew;
     std::vector<std::vector<std::pair<int, int>>> shadowRenewShifts;
+    std::vector<bool> shadowRenewCorner;
 
     //                               origin_Name   uniqName                   bounds
     std::vector<std::pair<std::pair<std::string, std::string>, std::vector<std::pair<int, int>>>> across;
@@ -125,6 +126,7 @@ public:
         privates = copyFrom.privates;
         shadowRenew = copyFrom.shadowRenew;
         shadowRenewShifts = copyFrom.shadowRenewShifts;
+        shadowRenewCorner = copyFrom.shadowRenewCorner;
         across = copyFrom.across;
         acrossShifts = copyFrom.acrossShifts;
         remoteAccess = copyFrom.remoteAccess;
@@ -151,6 +153,7 @@ public:
         on.clear();
         privates.clear();
         shadowRenew.clear();
+        shadowRenewCorner.clear();
         across.clear();
         acrossShifts.clear();
         reduction.clear();

src/DvmhRegions/DvmhRegionInserter.cpp

@@ -1297,7 +1297,10 @@ 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)

src/GraphCall/graph_calls.cpp

@@ -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"

src/Predictor/PredictScheme.cpp

@@ -22,7 +22,8 @@
 #include "graph_loops_func.h"
 #include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "../CFGraph/CFGraph.h"
+#include "CFGraph/CFGraph.h"
+#include "../Utils/utils.h"
 
 #include "json.hpp"
 
@@ -36,6 +37,109 @@ using std::tuple;
 
 using json = nlohmann::json;
 
+void runPredictSchemeOld(SgProject &project,
+                      vector<vector<size_t>> &topologies,
+                      vector<ParallelRegion*> &parallelRegions,
+                      map<string, vector<LoopGraph*>> &loopGraph,
+                      map<string, vector<SpfInterval*>> &intervals,
+                      map<string, vector<Messages>> &SPF_messages)
+{
+        int maxSizeDist = 0;
+        for (int z = 0; z < parallelRegions.size(); ++z)
+        {
+            const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
+            const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
+
+            auto &tmp = dataDirectives.distrRules;
+            vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
+            for (int z1 = 0; z1 < currentVariant.size(); ++z1)
+                currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
+
+            for (auto &elem : currentVar)
+            {
+                DIST::Array *array = elem.first;
+                const DistrVariant *var = elem.second;
+
+                int countBlock = 0;
+                for (int z = 0; z < var->distRule.size(); ++z)
+                    if (var->distRule[z] == dist::BLOCK)
+                        ++countBlock;
+                maxSizeDist = std::max(maxSizeDist, countBlock);
+            }
+        }
+                        
+        SpfInterval *mainIterval = getMainInterval(&project, intervals, SPF_messages);
+        topologies.clear();
+        if (maxSizeDist)
+        {
+            const int procNum = 8;
+            //TODO:
+            //topologies = getTopologies(procNum, maxSizeDist);
+            throw -10;
+
+            const int countOfTop = topologies.size();
+            if (countOfTop < 0)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            for (auto &inter : intervals)
+                initTimeForIntervalTree(countOfTop, inter.second);
+
+            for (int z = 0; z < parallelRegions.size(); ++z)
+            {
+                const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
+                const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
+                DIST::Arrays<int> &allArrays = parallelRegions[z]->GetAllArraysToModify();
+
+                auto &tmp = dataDirectives.distrRules;
+                vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
+                for (int z1 = 0; z1 < currentVariant.size(); ++z1)
+                    currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
+
+                map<LoopGraph*, ParallelDirective*> parallelDirs;
+                vector<std::tuple<DIST::Array*, vector<long>, pair<string, int>>> allSingleRemotes;
+                for (int i = project.numberOfFiles() - 1; i >= 0; --i)
+                {
+                    SgFile *file = &(project.file(i));
+                    auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId());
+                    parallelDirs.insert(fountInfo.begin(), fountInfo.end());
+
+                    auto fountRem = findAllSingleRemotes(file, parallelRegions[z]->GetId(), parallelRegions);
+                    allSingleRemotes.insert(allSingleRemotes.end(), fountRem.begin(), fountRem.end());
+                }
+                //TODO!
+                //int err = predictScheme(parallelRegions[z], currentVar, allArrays.GetArrays(), parallelDirs, intervals, SPF_messages, allSingleRemotes, maxSizeDist, procNum);                
+                /*if (err != 0)
+                    internalExit = err;*/
+            }
+
+            vector<SpfInterval*> tmp = { mainIterval };
+            aggregatePredictedTimes(tmp);
+
+            int idx = 0;
+            int best = -1;
+            double bestSpeedUp = 0;
+            for (auto &top : topologies)
+            {
+                string outStr = "";
+                for (auto &elem : top)
+                    outStr += std::to_string(elem) + " ";
+                double currS = mainIterval->exec_time / mainIterval->predictedTimes[idx];
+                __spf_print(1, "%d: speed up %f for top. %s\n", idx, currS, outStr.c_str());
+                
+                if (best == -1 || bestSpeedUp < currS)
+                {
+                    bestSpeedUp = currS;
+                    best = idx;
+                }
+                ++idx;
+            }
+            __spf_print(1, "best topology %d with speed up %f\n", best, bestSpeedUp);
+        }
+        else
+            for (auto &inter : intervals)
+                initTimeForIntervalTree(0, inter.second);
+}
+
 static void fillParallel(SgExpression *exp, ParallelStats &parStats, int &totalScoreComm)
 {
     if (exp)

src/Predictor/PredictScheme.h

@@ -60,4 +60,6 @@ public:
 void processFileToPredict(SgFile *file, PredictorStats &predictorCounts);
 
 void calculateStatsForPredictor(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);
-void parseDvmDirForPredictor(const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays, const std::map<std::string, CommonBlock*>& commonBlocks, const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);
+void parseDvmDirForPredictor(const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays, const std::map<std::string, CommonBlock*>& commonBlocks, const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);
+
+void runPredictSchemeOld(SgProject &project, std::vector<std::vector<size_t>> &topologies, std::vector<ParallelRegion*> &parallelRegions, std::map<std::string, std::vector<LoopGraph*>> &loopGraph, std::map<std::string, std::vector<SpfInterval*>> &intervals, std::map<std::string, std::vector<Messages>> &SPF_messages);

src/Predictor/PredictSchemeWithLibrary.cpp

@@ -0,0 +1,439 @@
+#include "leak_detector.h"
+
+#include <limits>
+#include <map>
+#include <vector>
+#include <string>
+#include <tuple>
+
+#include "dvm.h"
+#include "PredictSchemeWithLibrary.h"
+#include "../../projects/libpredictor/include/libpredict/predictor.h"
+#include "../DirectiveProcessing/directive_parser.h"
+#include "../Distribution/DvmhDirective.h"
+#include "../ParallelizationRegions/ParRegions.h"
+#include "../GraphLoop/graph_loops_func.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+
+using std::map;
+using std::pair;
+using std::string;
+using std::tuple;
+using std::vector;
+
+map<size_t, size_t> createTemplateIdMapping(const vector<ParallelRegion*>& parallelRegions)
+{
+    size_t maxArrayId = 0;
+    for (int z = 0; z < parallelRegions.size(); ++z) {
+        const DataDirective& dataDirectives = parallelRegions[z]->GetDataDir();
+
+        for (const auto& distrRule : dataDirectives.distrRules) {
+            if (distrRule.first && !distrRule.first->IsTemplate()) {
+                maxArrayId = std::max(maxArrayId, (size_t)distrRule.first->GetId());
+            }
+        }
+
+        for (const auto& alignRule : dataDirectives.alignRules) {
+            if (alignRule.alignArray && !alignRule.alignArray->IsTemplate()) {
+                maxArrayId = std::max(maxArrayId, (size_t)alignRule.alignArray->GetId());
+            }
+        }
+    }
+
+    map<size_t, size_t> templateIdMapping;
+    size_t nextTemplateId = maxArrayId + 1;
+    for (int z = 0; z < parallelRegions.size(); ++z) {
+        const DataDirective& dataDirectives = parallelRegions[z]->GetDataDir();
+
+        for (const auto& distrRule : dataDirectives.distrRules) {
+            if (distrRule.first && distrRule.first->IsTemplate()) {
+                size_t originalId = distrRule.first->GetId();
+                if (templateIdMapping.find(originalId) == templateIdMapping.end()) {
+                    templateIdMapping[originalId] = nextTemplateId++;
+                }
+            }
+        }
+
+        for (const auto& alignRule : dataDirectives.alignRules) {
+            if (alignRule.alignWith && alignRule.alignWith->IsTemplate()) {
+                size_t originalId = alignRule.alignWith->GetId();
+                if (templateIdMapping.find(originalId) == templateIdMapping.end()) {
+                    templateIdMapping[originalId] = nextTemplateId++;
+                }
+            }
+        }
+    }
+
+    return templateIdMapping;
+}
+
+PrecomputedLibpredictParams precomputeLibpredictParams(
+    SgProject& project,
+    const vector<ParallelRegion*>& parallelRegions,
+    const map<string, vector<LoopGraph*>>& loopGraph,
+    const map<size_t, size_t>& templateIdMapping)
+{
+    PrecomputedLibpredictParams result;
+
+    // distribute and align from parallelRegions
+    for (int z = 0; z < parallelRegions.size(); ++z) {
+        const DataDirective& dataDirectives = parallelRegions[z]->GetDataDir();
+        const vector<int>& currentVariant = parallelRegions[z]->GetCurrentVariant();
+        const DIST::Arrays<int>& allArrays = parallelRegions[z]->GetAllArrays();
+
+        auto& tmp = dataDirectives.distrRules;
+        vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
+        for (int z1 = 0; z1 < currentVariant.size(); ++z1) {
+            currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
+        }
+
+        // distribute
+        for (const auto& distrRule : currentVar) {
+            DIST::Array* array = distrRule.first;
+            const DistrVariant* variant = distrRule.second;
+
+            if (array && variant && !array->IsNotDistribute()) {
+                PrecomputedDistributeParams params;
+
+                size_t originalId = array->GetId();
+                params.arrayId = originalId;
+
+                if (array->IsTemplate()) {
+                    auto it = templateIdMapping.find(originalId);
+                    if (it != templateIdMapping.end()) {
+                        params.arrayId = it->second;
+                    }
+                }
+
+                params.elemSize = array->GetTypeSize();
+                params.array = array;
+
+                const auto& arraySizes = array->GetSizes();
+                for (int dim = 0; dim < array->GetDimSize(); ++dim) {
+                    size_t dimSize = arraySizes[dim].second - arraySizes[dim].first + 1;
+
+                    if (dim < variant->distRule.size() && variant->distRule[dim] == dist::BLOCK) {
+                        params.axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::BLOCK);
+                    } else {
+                        params.axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::NONE);
+                    }
+                }
+
+                const auto& shadowSpec = array->GetShadowSpec();
+                for (int dim = 0; dim < shadowSpec.size() && dim < array->GetDimSize(); ++dim) {
+                    if (dim < variant->distRule.size() && variant->distRule[dim] == dist::BLOCK) {
+                        params.shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second);
+                    }
+                }
+
+                result.distributeParams.push_back(params);
+            }
+        }
+
+        // align
+        for (const auto& alignRule : dataDirectives.alignRules) {
+            DIST::Array* alignArray = alignRule.alignArray;
+            DIST::Array* alignWithArray = alignRule.alignWith;
+
+            if (alignArray && alignWithArray && !alignArray->IsNotDistribute()) {
+                PrecomputedAlignParams params;
+
+                params.arrayId = alignArray->GetId();
+                size_t originalDistributedArrayId = alignWithArray->GetId();
+                params.distributedArrayId = originalDistributedArrayId;
+
+                if (alignWithArray->IsTemplate()) {
+                    auto it = templateIdMapping.find(originalDistributedArrayId);
+                    if (it != templateIdMapping.end()) {
+                        params.distributedArrayId = it->second;
+                    }
+                }
+
+                params.elemSize = alignArray->GetTypeSize();
+                params.alignArray = alignArray;
+                params.alignWithArray = alignWithArray;
+
+                const auto& arraySizes = alignArray->GetSizes();
+                for (int dim = 0; dim < alignArray->GetDimSize(); ++dim) {
+                    size_t dimSize = arraySizes[dim].second - arraySizes[dim].first + 1;
+                    params.dimensions.push_back(dimSize);
+                }
+
+                for (int dim = 0; dim < alignWithArray->GetDimSize(); ++dim) {
+                    bool found = false;
+                    for (int i = 0; i < alignRule.alignRuleWith.size(); ++i) {
+                        const auto& ruleWith = alignRule.alignRuleWith[i];
+                        if (ruleWith.first == dim) {
+                            const auto& rule = ruleWith.second;
+                            if (rule.first == 0) {
+                                // constant
+                                params.distributionExpressions.emplace_back(rule.second);
+                            } else {
+                                // linear expression a * I + b
+                                params.distributionExpressions.emplace_back(i, rule.first, rule.second);
+                            }
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        // There is no rule for this measurement
+                        params.distributionExpressions.emplace_back();
+                    }
+                }
+
+                const auto& shadowSpec = alignArray->GetShadowSpec();
+                for (int dim = 0; dim < shadowSpec.size() && dim < alignArray->GetDimSize(); ++dim) {
+                    params.shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second);
+                }
+
+                result.alignParams.push_back(params);
+            }
+        }
+
+        // shadow_renew
+        map<LoopGraph*, ParallelDirective*> parallelDirs;
+        for (int i = project.numberOfFiles() - 1; i >= 0; --i) {
+            SgFile* file = &(project.file(i));
+            auto fountInfo = findAllDirectives(
+                file,
+                getObjectForFileFromMap(file->filename(), const_cast<map<string, vector<LoopGraph*>>&>(loopGraph)),
+                parallelRegions[z]->GetId());
+            parallelDirs.insert(fountInfo.begin(), fountInfo.end());
+        }
+
+        for (auto& dirPair : parallelDirs) {
+            LoopGraph* loopPtr = dirPair.first;
+            ParallelDirective* directive = dirPair.second;
+
+            if (directive && !directive->shadowRenew.empty()) {
+                for (size_t shadowIdx = 0; shadowIdx < directive->shadowRenew.size(); ++shadowIdx) {
+                    const auto& shadowRenewItem = directive->shadowRenew[shadowIdx];
+                    const string& arrayName = shadowRenewItem.first.second; // uniqName
+                    const vector<pair<int, int>>& bounds = shadowRenewItem.second;
+
+                    DIST::Array* shadowArray = allArrays.GetArrayByName(arrayName);
+                    if (shadowArray == NULL) {
+                        continue;
+                    }
+
+                    if (shadowArray && !shadowArray->IsNotDistribute()) {
+                        PrecomputedShadowRenewParams params;
+
+                        params.arrayId = shadowArray->GetId();
+                        params.shadowArray = shadowArray;
+
+                        for (const auto& bound : bounds) {
+                            params.shadow_renew.emplace_back(static_cast<size_t>(bound.first),
+                                                             static_cast<size_t>(bound.second));
+                        }
+
+                        params.corner = directive->shadowRenewCorner[shadowIdx];
+                        params.number_loop_iterations = loopPtr ? static_cast<size_t>(loopPtr->countOfIters) : 1;
+
+                        result.shadowRenewParams.push_back(params);
+                    }
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+double runLibpredictCalc(const vector<size_t>& topology,
+                         const string& clusterConfStr,
+                         const PrecomputedLibpredictParams& precomputedParams,
+                         map<string, vector<Messages>>& SPF_messages)
+{
+    libpredict::RetInitGrid retInitGrid = libpredict::InitGrid(topology[0], topology[1], topology[2], topology[3]);
+
+    if (retInitGrid != libpredict::INIT_GRID_SUCCESS) {
+        __spf_print(1, "ERROR: Failed to initialize libpredict grid with topology: %zu %zu %zu %zu, return code: %d\n",
+                    topology[0], topology[1], topology[2], topology[3], (int)retInitGrid);
+
+        std::wstring messageR, messageE;
+        __spf_printToLongBuf(messageE, L"Failed to initialize libpredict grid with topology: %zu %zu %zu %zu, return code: %d",
+                             topology[0], topology[1], topology[2], topology[3], (int)retInitGrid);
+        __spf_printToLongBuf(messageR, R207);
+        getObjectForFileFromMap(clusterConfStr.c_str(), SPF_messages).push_back(Messages(ERROR, 1, messageR, messageE, 1064));
+        return -1;
+    }
+
+    // distribute
+    for (const auto& params : precomputedParams.distributeParams) {
+        libpredict::RetDistribute retDistribute = libpredict::Distribute(
+            params.arrayId, params.elemSize, params.axisDistributions, params.shadowEdges);
+
+        if (retDistribute != libpredict::DISTRIBUTE_SUCCESS) {
+            __spf_print(1, "ERROR: Failed to distribute array '%s' (id=%zu) with libpredict, return code: %d\n",
+                        params.array->GetShortName().c_str(), params.arrayId, (int)retDistribute);
+
+            std::wstring messageR, messageE;
+            __spf_printToLongBuf(messageE, L"Failed to distribute array '%s' with libpredict, return code: %d",
+                                 to_wstring(params.array->GetShortName()).c_str(), (int)retDistribute);
+            __spf_printToLongBuf(messageR, R208);
+            getObjectForFileFromMap(params.array->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(Messages(ERROR, params.array->GetDeclInfo().begin()->second, messageR, messageE, 1065));
+        }
+    }
+
+    // align
+    for (const auto& params : precomputedParams.alignParams) {
+        libpredict::RetAlign retAlign = libpredict::Align(
+            params.arrayId, params.distributedArrayId, params.elemSize,
+            params.dimensions, params.distributionExpressions, params.shadowEdges);
+
+        if (retAlign != libpredict::ALIGN_SUCCESS) {
+            __spf_print(1, "ERROR: Failed to align array '%s' (id=%zu) with array '%s' (id=%zu), return code: %d\n",
+                        params.alignArray->GetShortName().c_str(), params.arrayId,
+                        params.alignWithArray->GetShortName().c_str(), params.distributedArrayId, (int)retAlign);
+
+            std::wstring messageR, messageE;
+            __spf_printToLongBuf(messageE, L"Failed to align array '%s' with array '%s' using libpredict, return code: %d",
+                                 to_wstring(params.alignArray->GetShortName()).c_str(),
+                                 to_wstring(params.alignWithArray->GetShortName()).c_str(), (int)retAlign);
+            __spf_printToLongBuf(messageR, R209);
+            getObjectForFileFromMap(params.alignArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(Messages(ERROR, params.alignArray->GetDeclInfo().begin()->second, messageR, messageE, 1066));
+        }
+    }
+
+    // shadow_renew
+    for (const auto& params : precomputedParams.shadowRenewParams) {
+        libpredict::RetShadowRenew retShadowRenew = libpredict::ShadowRenew(
+            params.arrayId, params.shadow_renew, params.corner, params.number_loop_iterations);
+
+        if (retShadowRenew != libpredict::SHADOW_RENEW_SUCCESS) {
+            __spf_print(1, "ERROR: Failed to process shadow_renew for array '%s' (id=%zu), return code: %d\n",
+                        params.shadowArray->GetShortName().c_str(), params.arrayId, (int)retShadowRenew);
+
+            std::wstring messageR, messageE;
+            __spf_printToLongBuf(messageE, L"Failed to process shadow_renew for array '%s' with libpredict, return code: %d",
+                                 to_wstring(params.shadowArray->GetShortName()).c_str(), (int)retShadowRenew);
+            __spf_printToLongBuf(messageR, R210);
+            getObjectForFileFromMap(params.shadowArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(Messages(ERROR, params.shadowArray->GetDeclInfo().begin()->second, messageR, messageE, 1067));
+        }
+    }
+
+    return libpredict::GetTime();
+}
+
+void runPredictScheme(SgProject& project,
+                      vector<vector<size_t>>& topologies,
+                      const vector<ParallelRegion*>& parallelRegions,
+                      map<string, vector<LoopGraph*>>& loopGraph,
+                      map<string, vector<Messages>>& SPF_messages)
+{
+    // calculating maximum dimension of distribution
+    int maxSizeDist = 0;
+    for (int z = 0; z < parallelRegions.size(); ++z) {
+        const DataDirective& dataDirectives = parallelRegions[z]->GetDataDir();
+        const vector<int>& currentVariant = parallelRegions[z]->GetCurrentVariant();
+
+        auto& tmp = dataDirectives.distrRules;
+        vector<const DistrVariant*> currentVar;
+        for (int z1 = 0; z1 < currentVariant.size(); ++z1) {
+            currentVar.push_back(&tmp[z1].second[currentVariant[z1]]);
+        }
+
+        for (auto var : currentVar) {
+            int countBlock = 0;
+            for (int z = 0; z < var->distRule.size(); ++z) {
+                if (var->distRule[z] == dist::BLOCK) {
+                    ++countBlock;
+                }
+            }
+            maxSizeDist = std::max(maxSizeDist, countBlock);
+        }
+    }
+
+    // calculating name of a cluster configuration file
+    string clusterConfStr;
+    if (project.numberOfFiles() > 0) {
+        string firstFilePath = project.fileName(0);
+
+        size_t lastSlash = firstFilePath.find_last_of("/\\");
+        clusterConfStr = firstFilePath.substr(0, lastSlash + 1) + "cluster.conf";
+    }
+
+    // creating template ID display to avoid conflicts
+    map<size_t, size_t> templateIdMapping = createTemplateIdMapping(parallelRegions);
+
+    // Precomputing parameters of directive functions from libpredict
+    PrecomputedLibpredictParams precomputedParams = precomputeLibpredictParams(
+        project, parallelRegions, loopGraph, templateIdMapping);
+
+    // iterating through topologies to find most optimal one
+    topologies = vector<vector<size_t>>();
+    if (maxSizeDist) {
+        if (maxSizeDist > 4) {
+            maxSizeDist = 4;
+        }
+
+        // Initialize cluster
+        int procCount = 0;
+        libpredict::RetInitCluster retInitCluster = libpredict::InitCluster(clusterConfStr, procCount);
+
+        if (retInitCluster != libpredict::INIT_CLUSTER_SUCCESS) {
+            __spf_print(1, "ERROR: Failed to initialize libpredict cluster with config: %s, return code: %d\n", clusterConfStr.c_str(), (int)retInitCluster);
+
+            std::wstring messageR, messageE;
+            __spf_printToLongBuf(messageE, L"Failed to initialize libpredict cluster with config: %s, return code: %d",
+                                 to_wstring(clusterConfStr).c_str(), (int)retInitCluster);
+            __spf_printToLongBuf(messageR, R206);
+            getObjectForFileFromMap(clusterConfStr.c_str(), SPF_messages).push_back(Messages(ERROR, 1, messageR, messageE, 1063));
+            return;
+        }
+
+        for (size_t n1 = 2; n1 <= procCount; ++n1) {
+            for (size_t n2 = 1; n2 <= n1 && n1 * n2 <= procCount; ++n2) {
+                if (n2 != 1 && maxSizeDist < 2 || n2 == 1 && maxSizeDist == 2) {
+                    continue;
+                }
+
+                for (size_t n3 = 1; n3 <= n2 && n1 * n2 * n3 <= procCount; ++n3) {
+                    if (n3 != 1 && maxSizeDist < 3 || n3 == 1 && maxSizeDist == 3) {
+                        continue;
+                    }
+
+                    for (size_t n4 = 1; n4 <= n3 && n1 * n2 * n3 * n4 <= procCount; ++n4) {
+                        if (n4 != 1 && maxSizeDist < 4 || n4 == 1 && maxSizeDist == 4) {
+                            continue;
+                        }
+
+                        topologies.push_back(vector<size_t>{n1, n2, n3, n4});
+                    }
+                }
+            }
+        }
+
+        vector<size_t> best;
+        double bestTime = std::numeric_limits<double>::max();
+        for (auto& topology : topologies) {
+            double currTime = runLibpredictCalc(topology, clusterConfStr, precomputedParams, SPF_messages);
+
+            string outStr = "";
+            for (const auto& elem : topology) {
+                outStr += std::to_string(elem) + " ";
+            }
+            __spf_print(1, "topology %s has time %f\n", outStr.c_str(), currTime);
+
+            if (currTime == -1) {
+                return;
+            }
+
+            if (currTime < bestTime) {
+                bestTime = currTime;
+                best = topology;
+            }
+        }
+        string outStr;
+        for (const auto& elem : best) {
+            outStr += std::to_string(elem) + " ";
+        }
+
+        __spf_print(1, "best topology %s with time %f\n", outStr.c_str(), bestTime);
+    } else {
+        __spf_print(1, "impossible to calculate best topology: project does not contain distribution directives\n");
+    }
+}

src/Predictor/PredictSchemeWithLibrary.h

@@ -0,0 +1,57 @@
+#pragma once
+#include <vector>
+#include <map>
+#include <string>
+#include "dvm.h"
+#include "graph_calls.h"
+#include "../../projects/libpredictor/include/libpredict/predictor.h"
+
+struct PrecomputedDistributeParams {
+    size_t arrayId;
+    size_t elemSize;
+    std::vector<libpredict::DistributeAxisRule> axisDistributions;
+    std::vector<std::pair<size_t, size_t>> shadowEdges;
+    DIST::Array* array;
+};
+
+struct PrecomputedAlignParams {
+    size_t arrayId;
+    size_t distributedArrayId;
+    size_t elemSize;
+    std::vector<size_t> dimensions;
+    std::vector<libpredict::AlignDisplay> distributionExpressions;
+    std::vector<std::pair<size_t, size_t>> shadowEdges;
+    DIST::Array* alignArray;
+    DIST::Array* alignWithArray;
+};
+
+struct PrecomputedShadowRenewParams {
+    size_t arrayId;
+    std::vector<std::pair<size_t, size_t>> shadow_renew;
+    bool corner;
+    size_t number_loop_iterations;
+    DIST::Array* shadowArray;
+};
+
+struct PrecomputedLibpredictParams {
+    std::vector<PrecomputedDistributeParams> distributeParams;
+    std::vector<PrecomputedAlignParams> alignParams;
+    std::vector<PrecomputedShadowRenewParams> shadowRenewParams;
+};
+
+PrecomputedLibpredictParams precomputeLibpredictParams(
+    SgProject& project,
+    const std::vector<ParallelRegion*>& parallelRegions,
+    const std::map<std::string, std::vector<LoopGraph*>>& loopGraph,
+    const std::map<size_t, size_t>& templateIdMapping);
+
+void runPredictScheme(SgProject& project,
+                      std::vector<std::vector<size_t>>& topologies,
+                      const std::vector<ParallelRegion*>& parallelRegions,
+                      std::map<std::string, std::vector<LoopGraph*>>& loopGraph,
+                      std::map<std::string, std::vector<Messages>>& SPF_messages);
+
+double runLibpredictCalc(const std::vector<size_t>& topology,
+                         const std::string& clusterConfStr,
+                         const PrecomputedLibpredictParams& precomputedParams,
+                         std::map<std::string, std::vector<Messages>>& SPF_messages);

src/PrivateAnalyzer/private_analyzer.cpp

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

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -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;
 
-void Collapse(Region* region)
+static void Collapse(Region* region)
 {
     if (region->getBasickBlocks().empty())
         return;

src/PrivateAnalyzer/private_arrays_search.h

@@ -5,10 +5,8 @@
 #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);

src/PrivateAnalyzer/region.h

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

src/ProjectManipulation/ConvertFiles.cpp

@@ -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);
+            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info, fout_name);
 
         const string fileN = file->filename();
         set<SgStatement*> toRemove;

src/Sapfor.cpp

@@ -57,6 +57,7 @@
 #include "expr_transform.h"
 
 #include "Predictor/PredictScheme.h"
+#include "Predictor/PredictSchemeWithLibrary.h"
 #include "Predictor/PredictorModel.h"
 #include "SageAnalysisTool/depInterfaceExt.h"
 #include "DvmhRegions/DvmhRegionInserter.h"
@@ -89,7 +90,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 +940,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 +1038,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_REMOVING,
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
-                          REMOVE_DEAD_CODE,
+                          REMOVE_DEAD_CODE };
-                          SWAP_OPERATORS };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -1732,103 +1729,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         }
     }
     else if (curr_regime == PREDICT_SCHEME)
-    {
+        runPredictScheme(project, topologies, parallelRegions, loopGraph, SPF_messages);
-        int maxSizeDist = 0;
-        for (int z = 0; z < parallelRegions.size(); ++z)
-        {
-            const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
-            const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
-
-            auto &tmp = dataDirectives.distrRules;
-            vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
-            for (int z1 = 0; z1 < currentVariant.size(); ++z1)
-                currentVar.push_back(make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
-
-            for (auto &elem : currentVar)
-            {
-                DIST::Array *array = elem.first;
-                const DistrVariant *var = elem.second;
-
-                int countBlock = 0;
-                for (int z = 0; z < var->distRule.size(); ++z)
-                    if (var->distRule[z] == dist::BLOCK)
-                        ++countBlock;
-                maxSizeDist = std::max(maxSizeDist, countBlock);
-            }
-        }
-                        
-        SpfInterval *mainIterval = getMainInterval(&project, intervals, SPF_messages);
-        topologies.clear();
-        if (maxSizeDist)
-        {
-            const int procNum = 8;
-            //TODO:
-            //topologies = getTopologies(procNum, maxSizeDist);
-            throw -10;
-
-            const int countOfTop = topologies.size();
-            if (countOfTop < 0)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            for (auto &inter : intervals)
-                initTimeForIntervalTree(countOfTop, inter.second);
-
-            for (int z = 0; z < parallelRegions.size(); ++z)
-            {
-                const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
-                const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
-                DIST::Arrays<int> &allArrays = parallelRegions[z]->GetAllArraysToModify();
-
-                auto &tmp = dataDirectives.distrRules;
-                vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
-                for (int z1 = 0; z1 < currentVariant.size(); ++z1)
-                    currentVar.push_back(make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
-
-                map<LoopGraph*, ParallelDirective*> parallelDirs;
-                vector<std::tuple<DIST::Array*, vector<long>, pair<string, int>>> allSingleRemotes;
-                for (int i = n - 1; i >= 0; --i)
-                {
-                    SgFile *file = &(project.file(i));
-                    auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId());
-                    parallelDirs.insert(fountInfo.begin(), fountInfo.end());
-
-                    auto fountRem = findAllSingleRemotes(file, parallelRegions[z]->GetId(), parallelRegions);
-                    allSingleRemotes.insert(allSingleRemotes.end(), fountRem.begin(), fountRem.end());
-                }
-                //TODO!
-                //int err = predictScheme(parallelRegions[z], currentVar, allArrays.GetArrays(), parallelDirs, intervals, SPF_messages, allSingleRemotes, maxSizeDist, procNum);                
-                /*if (err != 0)
-                    internalExit = err;*/
-            }
-
-            vector<SpfInterval*> tmp = { mainIterval };
-            aggregatePredictedTimes(tmp);
-
-            int idx = 0;
-            int best = -1;
-            double bestSpeedUp = 0;
-            for (auto &top : topologies)
-            {
-                string outStr = "";
-                for (auto &elem : top)
-                    outStr += std::to_string(elem) + " ";
-                double currS = mainIterval->exec_time / mainIterval->predictedTimes[idx];
-                __spf_print(1, "%d: speed up %f for top. %s\n", idx, currS, outStr.c_str());
-                
-                if (best == -1 || bestSpeedUp < currS)
-                {
-                    bestSpeedUp = currS;
-                    best = idx;
-                }
-                ++idx;
-            }
-            __spf_print(1, "best topology %d with speed up %f\n", best, bestSpeedUp);
-        }
-        else
-            for (auto &inter : intervals)
-                initTimeForIntervalTree(0, inter.second);
-
-    }
     else if (curr_regime == CREATE_INTER_TREE)
     {
         if (keepFiles)
@@ -1918,6 +1819,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.;
@@ -2153,6 +2056,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);
     }
@@ -2220,9 +2125,8 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
 
             runAnalysis(*project, CALCULATE_STATS_SCHEME, false);
 
-            //TODO: need to rewrite this to new algo 
+            if (!folderName && !consoleMode || predictOn)
-            /*if (!folderName && !consoleMode || predictOn)
+                runAnalysis(*project, PREDICT_SCHEME, false);
-                runAnalysis(*project, PREDICT_SCHEME, false); */
 
             runAnalysis(*project, REMOVE_COPIES, false);
             runAnalysis(*project, SWAP_LOOPS, false);
@@ -2334,7 +2238,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:

src/Sapfor.h

@@ -122,8 +122,6 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    SWAP_OPERATORS,
-
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
     FILL_PARALLEL_REG_IR,
@@ -187,6 +185,8 @@ enum passes {
 
     FIND_PRIVATE_ARRAYS,
 
+    TRANSFORM_ASSUMED_SIZE_PARAMETERS,
+
     TEST_PASS,
     EMPTY_PASS
 };
@@ -319,7 +319,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";
@@ -374,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";
 }
 

src/SapforData.h

@@ -132,7 +132,7 @@ std::map<std::string, PredictorStats> allPredictorStats;
 
 //for DVM INTERVALS
 std::map<std::string, std::vector<SpfInterval*>> intervals; // file -> intervals
-std::vector<std::vector<long>> topologies; // current topologies
+std::vector<std::vector<size_t>> topologies; // current topologies
 //
 
 //for GCOV_PARSER

src/Transformations/DeadCodeRemoving/dead_code.cpp

@@ -6,7 +6,7 @@
 #include <set>
 #include <algorithm>
 
-#include "../../CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 using std::map;
 using std::string;

src/Transformations/DeadCodeRemoving/dead_code.h

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

src/Transformations/ExpressionSubstitution/expr_transform.cpp

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

src/Transformations/FunctionPurifying/function_purifying.cpp

@@ -66,7 +66,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
 
             void* ptr = call.pointerDetailCallsFrom.first;
             int var = call.pointerDetailCallsFrom.second;
-            
+
             SgSymbol* s = NULL;
             if (var == PROC_STAT)
                 s = ((SgStatement*)ptr)->symbol();
@@ -103,7 +103,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
             if (line <= 0)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            intr->setlineNumber(line);
+            intr->setlineNumber(getNextNegativeLineNumber());
             st->insertStmtBefore(*intr, *func->funcPointer);
         }
         else
@@ -126,7 +126,7 @@ bool checkOutCalls(const set<string>& outCalls)
     return false;
 }
 
-void createInterfacesForOutCalls(FuncInfo* func) 
+void createInterfacesForOutCalls(FuncInfo* func)
 {
     if (func->isPure && !func->isMain)
     {
@@ -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();
-    }
-
-    if (has)
-    {
-        list = arrayDecl->lhs();
-        while (list)
         {
-            list->setLhs(new SgExpression(DDOT));
+            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());
+        }
+
+        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!!
+static bool hasDvmParallel(SgStatement *func)
-/*void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
 {
-    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)
     {
@@ -221,11 +244,17 @@ static vector<FuncInfo*> sortByName(const T &funcs)
             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
         for (auto& func : funcByFile.second)
-        {            
+        {
             SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
             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()))
+                                if (changeIfHasStarRange(list->lhs(), scope, parNames))
-                                {
+                                    assumedSizeArraysByFunc[func->funcName].push_back(z);
-                                    hasRefs = true;
-                                    hasAssumedSizeArrays.insert(func);
-                                }
-                                else
-                                    arrayRefs.push_back(list->lhs());
                                 break;
                             }
                             list = list->rhs();
@@ -260,13 +284,20 @@ static vector<FuncInfo*> sortByName(const T &funcs)
                 }
             }
 
-            if (hasRefs)
+            if (parNames.size())
-                for (auto& ref : arrayRefs)
+            {
-                    changeIfHasStarRange(ref, true);
+                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 (hasAssumedSizeArrays.size() == 0)
+    if (assumedSizeArraysByFunc.size() == 0)
         return;
 
     for (auto& funcByFile : allFuncInfo)
@@ -274,29 +305,63 @@ 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& detailedCall : func->callsFromDetailed)
-            for (auto& elem : sortByName(func->callsFromV))
             {
-                auto it = hasAssumedSizeArrays.find(elem);
+                auto it = assumedSizeArraysByFunc.find(detailedCall.detailCallsFrom.first);
-                if (it != hasAssumedSizeArrays.end())
+                if (it != assumedSizeArraysByFunc.end())
                 {
-                    auto callFrom = *it;
+                    auto pointer = detailedCall.pointerDetailCallsFrom;
-                    DvmhRegionInserter::createInterfaceBlockForOutCall(func, callFrom);
+
-                    addedInterfaceFor.insert(callFrom->funcName);
+                    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();
+                    }
                 }
             }
-
+        }
-            if (addedInterfaceFor.size())
-                removeExternalStat(prog, addedInterfaceFor);
-        }       
     }
-}*/
+}
 
 static void setPureStatus(FuncInfo* func)
 {
@@ -314,7 +379,7 @@ static void setPureStatus(FuncInfo* func)
         bool hasIO = func->linesOfIO.size() || func->linesOfStop.size();
 
         if (!hasPure && !hasIO && ((isFunc == false) || (isFunc && hasOut == false)))
-        {            
+        {
             header->setExpression(2, new SgExpression(PURE_OP));
             header->symbol()->setAttribute(header->symbol()->attributes() | PURE_BIT);
         }
@@ -460,7 +525,7 @@ static void insertIntents(set<string>& identificators, SgStatement* header, cons
     if (args.size())
     {
         SgIntentStmt* intent = new SgIntentStmt(*makeExprList(args), *attr);
-        intent->setlineNumber(lastDecl->lineNumber());
+        intent->setlineNumber(getNextNegativeLineNumber());
 
         lastDecl->insertStmtAfter(*intent, (header == lastDecl) ? *header : *lastDecl->controlParent());
     }
@@ -528,7 +593,7 @@ static void intentInsert(const FuncInfo* func, SgStatement* headerSt)
             OutIdentificators.insert(ident);
     }
 
-    //remove conflicted intents 
+    //remove conflicted intents
     for (auto& entry : func->entry)
     {
         for (int i = 0; i < entry->funcParams.countOfPars; i++)
@@ -559,11 +624,11 @@ static void intentInsert(const FuncInfo* func, SgStatement* headerSt)
     }
 
     insertIntents(InOutIdentificators, headerSt, parSym, INOUT_OP, INOUT_BIT);
-    insertIntents(InIdentificators, headerSt, parSym, IN_OP, IN_BIT);    
+    insertIntents(InIdentificators, headerSt, parSym, IN_OP, IN_BIT);
     insertIntents(OutIdentificators, headerSt, parSym, OUT_OP, OUT_BIT);
 }
 
-void intentInsert(const vector<FuncInfo*>& allFuncInfo) 
+void intentInsert(const vector<FuncInfo*>& allFuncInfo)
 {
     for (auto& func : allFuncInfo)
     {
@@ -632,7 +697,7 @@ static void collectForChange(set<FuncInfo*>& allForChange, FuncInfo* start)
             for (auto& call : elem->callsFromV)
                 if (allForChange.find(call) == allForChange.end())
                     newAdd.insert(call);
-        
+
         chagned = newAdd.size() != 0;
 
         allForChange.insert(newAdd.begin(), newAdd.end());
@@ -640,7 +705,7 @@ static void collectForChange(set<FuncInfo*>& allForChange, FuncInfo* start)
 }
 
 template<typename CallExp>
-static void transferVarToArg(const map<string, vector<int>>& commonVarsUsed, const map<string, CommonBlock*>& commonBlocks, 
+static void transferVarToArg(const map<string, vector<int>>& commonVarsUsed, const map<string, CommonBlock*>& commonBlocks,
                              const FuncInfo* curFunc, CallExp* callExp)
 {
     for (auto& common : commonVarsUsed)
@@ -724,7 +789,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
             {
                 SgFunctionCallExp* callExp = (SgFunctionCallExp*)call.first;
                 if (callExp->funName()->identifier() == precFunc->funcName)
-                    transferVarToArg(commonVarsUsed, commonBlocks, curFunc, callExp);                
+                    transferVarToArg(commonVarsUsed, commonBlocks, curFunc, callExp);
             }
             else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
             {
@@ -749,7 +814,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
                 if (v == var)
                     done = true;
 
-            if (!done) 
+            if (!done)
             {
                 funcCommons[curFunc][common.first].push_back(var);
                 if (nextCommonVarsUsed.count(common.first) == 0)
@@ -767,7 +832,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
     {
         bool uses = false;
         auto groupedVars = commonBlocks.find(common.first)->second->getGroupedVars();
-        
+
         if (curFunc->commonBlocks.count(common.first) > 0) //rename common vars in funcs
         {
             uses = true;
@@ -799,7 +864,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
                     }
                 }
             }
-        }        
+        }
         else if (!allForChange.count(curFunc)) //add of commons to main
         {
             SgExprListExp* res = NULL;
@@ -962,13 +1027,13 @@ void commonTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo, const map
 
             if (func->commonBlocks.size() > 0 && st->variant() != PROG_HEDR)
             {
-                for (SgStatement* start = st, *end = st->lastNodeOfStmt(); start != end;) 
+                for (SgStatement* start = st, *end = st->lastNodeOfStmt(); start != end;)
                 {
                     if (start->variant() == CONTAINS_STMT)
                         break;
 
                     SgStatement* next = start->lexNext();
-                    if (start->variant() == COMM_STAT && string(start->fileName()) == func->fileName) 
+                    if (start->variant() == COMM_STAT && string(start->fileName()) == func->fileName)
                     {
                         if (funcCommonDeclared.count(func) == 0)
                             funcCommonDeclared[func] = set<string>();
@@ -999,11 +1064,11 @@ void commonTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo, const map
         if (st->variant() < 0 || st->variant() == PROG_HEDR || func->isInterface)
             continue;
 
-        if (func->commonBlocks.size() > 0) 
+        if (func->commonBlocks.size() > 0)
         {
             map<string, vector<int>> commonVarsUsed;
             set<string> usedVars;
-            for (SgStatement* start = st->lastDeclaration()->lexNext(), *end = st->lastNodeOfStmt(); start != end; start = start->lexNext()) 
+            for (SgStatement* start = st->lastDeclaration()->lexNext(), *end = st->lastNodeOfStmt(); start != end; start = start->lexNext())
             {
                 if (start->variant() == CONTAINS_STMT)
                     break;
@@ -1073,7 +1138,7 @@ static string changeData(const string& data, const map<string, string>& constSym
     return res;
 }
 
-static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vector <SgSymbol*>& varsToTransfer, vector <string>& dataToTransfer, 
+static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vector <SgSymbol*>& varsToTransfer, vector <string>& dataToTransfer,
                          FuncInfo* curFunc, FuncInfo* precFunc, FuncInfo* startFunc)
 {
     if (curFunc != precFunc)
@@ -1094,7 +1159,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec
             else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
             {
                 SgCallStmt* callSt = (SgCallStmt*)call.first;
-                if (callSt->name()->identifier() == precFunc->funcName)                
+                if (callSt->name()->identifier() == precFunc->funcName)
                     for (auto& var : varsToTransfer)
                         callSt->addArg(*new SgVarRefExp(*var));
             }
@@ -1120,7 +1185,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec
             {
                 ((SgProcHedrStmt*)(hedr))->AddArg(*new SgVarRefExp(var->copy()));
                 hedr->lexNext()->deleteStmt();
-                if (curFunc != startFunc || i!=0) 
+                if (curFunc != startFunc || i!=0)
                 {
                     vector<SgSymbol*> varVec = vector<SgSymbol*>();
                     varVec.push_back(var);
@@ -1160,7 +1225,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec
 
         for (SgStatement* start = hedr->lexNext(), *end = hedr->lastNodeOfStmt(); start != end; start = start->lexNext())
         {
-            if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && !strcmp(hedr->fileName(), start->fileName())) 
+            if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && !strcmp(hedr->fileName(), start->fileName()))
             {
                 firstExDec = start;
                 break;
@@ -1199,7 +1264,7 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
     for (auto& byfile : allFuncInfo)
         for (auto& func : byfile.second)
             if (func->isMain)
-                start = func;    
+                start = func;
 
     collectForChange(allForChange, start);
     allForChange.erase(start);
@@ -1241,8 +1306,8 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
 
             if (s->scope() == st)
             {
-                if ( (s->attributes() & SAVE_BIT) || 
+                if ( (s->attributes() & SAVE_BIT) ||
-                     (s->attributes() & DATA_BIT) || 
+                     (s->attributes() & DATA_BIT) ||
                      allSave && s->variant() == VARIABLE_NAME && !params.count(s->identifier()))
                 {
                     if ((s->type() ? s->type()->variant() : (T_COMPLEX + 1)) > T_COMPLEX)
@@ -1293,21 +1358,21 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
 
                 SgExprListExp* attrsNoSave = new SgExprListExp();
                 bool needChange = false;
-                for (int i = 0; i < vst->numberOfAttributes(); i++) 
+                for (int i = 0; i < vst->numberOfAttributes(); i++)
                 {
                     if (vst->attribute(i)->variant() != SAVE_OP)
                     {
                         attrsNoSave->append(vst->attribute(i)->copy());
-                    } 
+                    }
                     else
-                        needChange = true;                    
+                        needChange = true;
                 }
 
-                if (needChange) 
+                if (needChange)
                 {
                     SgVarDeclStmt* newVst;
                     if (!attrsNoSave->length())
-                        newVst = new SgVarDeclStmt(vst->varList()->copy(), *attrsNoSave, vst->type()->copy());                    
+                        newVst = new SgVarDeclStmt(vst->varList()->copy(), *attrsNoSave, vst->type()->copy());
                     else
                         newVst = new SgVarDeclStmt(vst->varList()->copy(), vst->type()->copy());
 
@@ -1335,8 +1400,8 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
     }
 }*/
 
-static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsToAdd, const set<string>& useMod, 
+static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsToAdd, const set<string>& useMod,
-                       const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUse, 
+                       const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUse,
                        const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUseOnly)
 {
     string name = "", modName = OriginalSymbol(var)->scope()->symbol()->identifier();
@@ -1358,7 +1423,7 @@ static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsTo
         }
 
         if (!name.length())
-            name = varOrName;        
+            name = varOrName;
     }
     else if (mbuo)
     {
@@ -1492,7 +1557,7 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
     //insert tabs
-    const string tab = "    ";    
+    const string tab = "    ";
     const int countEnds = std::count(codeString.begin(), codeString.end(), '\n');
 
     string retVal = "  ";
@@ -1584,7 +1649,7 @@ static void createInterfaceBlockForToCalls(FuncInfo* func)
     }
 }
 
-static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, set<FuncInfo*>& allForChange, 
+static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, set<FuncInfo*>& allForChange,
                            vector<SgSymbol*>& varsToTransfer, FuncInfo* curFunc, FuncInfo* precFunc, set<FuncInfo*>& funcForInterfaceAdd)
 {
     SgStatement* st = curFunc->funcPointer->GetOriginal();
@@ -1636,7 +1701,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
             else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
             {
                 SgCallStmt* callSt = (SgCallStmt*)call.first;
-                if (callSt->name()->identifier() == precFunc->funcName) 
+                if (callSt->name()->identifier() == precFunc->funcName)
                 {
                     for (auto& var : varsToTransfer)
                     {
@@ -1688,7 +1753,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
             {
                 if (i == 0)
                     curFunc->funcParams.identificators.push_back(var->identifier());
-     
+
                 ((SgProcHedrStmt*)(hedr))->AddArg(*new SgVarRefExp(var->copy()));
                 hedr->lexNext()->deleteStmt();
                 vector<SgSymbol*> varVec = vector<SgSymbol*>();
@@ -1712,7 +1777,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
                         }
                     }
 
-                    if (!isAuto) 
+                    if (!isAuto)
                     {
                         funcForInterfaceAdd.insert(curFunc);
                         SgAttributeExp* a = new SgAttributeExp(ALLOCATABLE_OP);
@@ -1732,8 +1797,8 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
                 SgStatement* firstExDec = NULL;
                 for (SgStatement* start = hedr->lexNext(), *end = hedr->lastNodeOfStmt(); start != end; start = start->lexNext())
                 {
-                    if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && 
+                    if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) &&
-                        !strcmp(hedr->fileName(), start->fileName())) 
+                        !strcmp(hedr->fileName(), start->fileName()))
                     {
                         firstExDec = start;
                         break;
@@ -1824,7 +1889,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
                 break;
 
             SgStatement* next = start->lexNext();
-            if (start->variant() == USE_STMT) 
+            if (start->variant() == USE_STMT)
             {
                 SgExpression* onlyE = start->expr(0);
                 if (onlyE)
@@ -1850,7 +1915,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
                     }
 
                     if (renameL)
-                        onlyE->setLhs(renameL);                    
+                        onlyE->setLhs(renameL);
                     else
                         start->deleteStmt();
                 }
@@ -1858,7 +1923,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
             if (isSgExecutableStatement(start)|| isSgDeclarationStatement(start))
                 for (int i = 0; i < 3; i++)
                     fillUsedVars(usedVars, start->expr(i));
-            
+
           //  if (start->variant() == IMPL_DECL)
             //    start->deleteStmt();
             start = next;

src/Transformations/FunctionPurifying/function_purifying.h

@@ -14,4 +14,6 @@ void commonTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFunc
 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 insertInterface(SgStatement* func, const FuncInfo* callFrom);
+
+void transformAssumedSizeParameters(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);

src/Transformations/LoopSplitting/loops_splitter.cpp

@@ -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"

src/Transformations/PrivateArrayRemoving/private_removing.h

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

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -17,6 +17,157 @@ 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)
@@ -29,12 +180,15 @@ static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
     }
 }
 
-static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, SgStatement* stat)
+static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, 
+                                        SgStatement* stat, 
+                                        const string& current_file_name,
+                                        FuncInfo *current_func)
 {
     auto var = stat->variant();
 
     if (var != READ_STAT && var != PRINT_STAT && var != WRITE_STAT)
-        return;
+        return false;
 
     // check if such IO allowed in dvm: 
     // list should consist only of single array and format string should be *
@@ -44,22 +198,26 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     SgExpression* ioList = stat->expr(0);
 
     if (!ioList)
-        return;
+        return false;
 
     if (ioList->variant() != EXPR_LIST)
-        return;
+        return false;
 
     if (ioList->rhs() == NULL)
     {
         SgExpression* arg = ioList->lhs();
         if (!arg)
-            return;
+            return false;
 
-        if (!isArrayRef(arg))
+        if (hasArrayRef(arg))
-            return;
+        {
-
+            if (isArrayRef(arg) && arg->lhs())
-        if (arg->lhs())
+                need_replace = true;
-            need_replace = true;
+        }
+        else
+        {
+            return false;
+        }
     }
     else
     {
@@ -74,15 +232,11 @@ static void 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:
@@ -104,10 +258,7 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                 {
                     auto *kv = spec->lhs();
                     if (!kv || kv->variant() != SPEC_PAIR || !kv->rhs())
-                    {
                         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                        return;
-                    }
 
                     if (kv->rhs()->variant() != KEYWORD_VAL || kv->rhs()->sunparse() != "*")
                     {
@@ -118,6 +269,7 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                     spec = spec->rhs();
                 }
             }
+            break;
         }
         default:
             break;
@@ -125,7 +277,9 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     }
 
     if (!need_replace)
-        return;
+        return false;
+
+    bool ret = false;
 
     set<SgSymbol*> found_arrays;
 
@@ -136,11 +290,21 @@ static void 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 && arrays[by_symb].insert(stat).second)
+        if (array_p && 
-            __spf_print(DEBUG_TRACE, "[%d]: add array %s\n", stat->lineNumber(), array_p->GetName().c_str());
+            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;
+        }
     }
 
     __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)
@@ -210,7 +374,12 @@ 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)
+static void copyArrayBetweenStatements(SgSymbol* replace_symb, 
+                                       SgSymbol* replace_by,
+                                       SgStatement* start, 
+                                       SgStatement* last, 
+                                       bool start_is_scope,
+                                       FuncInfo *func_info)
 {
     while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
         start = start->lexNext();
@@ -229,10 +398,23 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb, SgSymbol* replace
         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
@@ -243,9 +425,14 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb, SgSymbol* replace
     }
 }
 
-static void replaceArrayInFragment(SgSymbol* replace_symb, const set<SgStatement*> usages, SgSymbol* replace_by, SgStatement* start, SgStatement* last, const string& filename)
+static void replaceArrayInFragment(SgSymbol* replace_symb, 
+                                   const set<SgStatement*> usages, 
+                                   SgSymbol* replace_by, 
+                                   SgStatement* start, 
+                                   SgStatement* last, 
+                                   FuncInfo *func_info)
 {
-    while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
+    while (start->lexNext() && (!isSgExecutableStatement(start->lexNext()) || start->lexNext()->variant() == ALLOCATE_STMT))
         start = start->lexNext();
 
     set<SgStatement*> not_opened, not_closed, copied;
@@ -312,7 +499,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb, const set<SgStatement
         }
 
         __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);
+        copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start, func_info);
         copied.insert(copy_scope);
     }
 }
@@ -335,12 +522,16 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
         STOP_STAT,
         STOP_NODE,
         EXIT_STMT,
-        EXIT_NODE
+        EXIT_NODE,
+        GOTO_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;
 
@@ -353,9 +544,9 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
 }
 
 void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
-    const map<string, vector<FuncInfo*>>& allFuncInfo,
+                                  const map<string, vector<FuncInfo*>>& allFuncInfo,
-    map<string, vector<Messages>>& SPF_messages,
+                                  map<string, vector<Messages>>& SPF_messages,
-    map<string, map<int, set<string>>>& newDeclsToInclude)
+                                  map<string, map<int, set<string>>>& newDeclsToInclude)
 {
     map<SgSymbol*, SgSymbol*> created_copies;
     map<string, map<int, set<string>>> copied_syms;
@@ -364,26 +555,29 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
     {
         __spf_print(DEBUG_TRACE, "[%s]: enter region\n", region->GetName().c_str());
 
-        for (auto& linesByFile : region->GetAllLinesToModify())
+        for (auto& lines_by_file : region->GetAllLinesToModify())
         {
-            const auto& filename = linesByFile.first;
+            const auto& current_file_name = lines_by_file.first;
 
-            if (SgFile::switchToFile(filename) < 0)
+            if (SgFile::switchToFile(current_file_name) == -1)
-            {
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                return;
-            }
 
-            for (auto& lines : linesByFile.second)
+            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)
             {
-                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", filename.c_str(), lines.lines.first,
+                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", current_file_name.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);
 
@@ -399,6 +593,7 @@ 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)
                 {
@@ -407,9 +602,21 @@ 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))
                         {
@@ -433,77 +640,192 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                 string array_name = string(array_to_copy->identifier());
                                 DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(array_to_copy), array_name);
 
-                                bool fromModule = (array_p->GetLocation().first == DIST::l_MODULE);
+                                // at this point all considered arrays must have DIST::Array* references
-                                const string locationName = array_p->GetLocation().second;
+                                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__);
 
-                                auto place = *array_p->GetDeclInfo().begin();
-                                string fileName = place.first;
                                 string suffix = "_io_l";
 
-                                if (fromModule)
+                                switch (array_p->GetLocation().first)
-                                    suffix = "_io_m";
-
-                                pair<SgSymbol*, SgSymbol*> copied;
-                                copied.first = array_to_copy;
-
-                                if (SgFile::switchToFile(fileName) == -1)
                                 {
-                                    auto* func_stmt = curr_stmt->getScopeForDeclare();
+                                    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);
 
-                                    SgStatement* insertPlace = NULL;
+                                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();
                                     for (auto iterator = func_stmt->lexNext();
-                                        !isSgExecutableStatement(iterator) || isSPF_stat(iterator) &&
+                                        iterator && !isSgExecutableStatement(iterator);
-                                        !(iterator->variant() == SPF_PARALLEL_REG_DIR || iterator->variant() == SPF_END_PARALLEL_REG_DIR);
                                         iterator = iterator->lexNext())
                                     {
-                                        insertPlace = iterator;
+                                            allocate_stmt_place = iterator;
                                     }
 
                                     //NULL - no decl stats in function!
-                                    if (!insertPlace)
+                                    if (!allocate_stmt_place)
-                                        insertPlace = func_stmt;
+                                        allocate_stmt_place = func_stmt;
 
-                                    auto st = insertPlace->controlParent();
+                                    auto *allocate_stmt_parent = allocate_stmt_place->controlParent();
-                                    if (st->variant() == GLOBAL)
+                                    if (allocate_stmt_parent->variant() == GLOBAL)
-                                        st = insertPlace;
+                                        allocate_stmt_parent = allocate_stmt_place;
+                                    
+                                    auto *created_array_ref = new SgArrayRefExp(*copied_symbol.second);
 
-                                    auto& copied_symb = array_to_copy->copy();
+                                    auto* dim_list = new SgExprListExp();
-                                    copied.second = &copied_symb;
+                                    created_array_ref->setLhs(dim_list);
-
+                                    
-                                    auto new_name = string(array_to_copy->identifier()) + "_io_c";
+                                    int dim_len = array_p->GetSizes().size();
-                                    copied_symb.changeName(new_name.c_str());
+                                    for (int i = 1; i <= dim_len; i++)
-
-                                    auto stat = array_to_copy->makeVarDeclStmt();
-                                    auto res = CalculateInteger(stat->expr(0)->copyPtr());
-                                    res->lhs()->setSymbol(copied_symb);
-                                    stat->setExpression(0, res);
-
-                                    insertPlace->insertStmtAfter(*stat, *st);
-                                }
-                                else
-                                {
-                                    copied = copyArray(place, array_p, linesByFile.second, suffix + to_string(region->GetId()), fileName, newDeclsToInclude, copied_syms);
-                                }
-
-                                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());
+                                        auto *lcall = new SgFunctionCallExp(*lbound_symb);
-                                        if (str_comment.size() && str_comment.back() != '\n')
+                                        auto *rcall = new SgFunctionCallExp(*ubound_symb);
-                                            dir_str += "\n";
+                                        
+                                        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;
+                                        }
                                     }
 
-                                    dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied.second->identifier()) + "))\n";
+                                    auto *allocate_stmt = new SgStatement(ALLOCATE_STMT);
-                                    decl->addComment(dir_str.c_str());
+                                    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;
+                                    }
                                 }
-                                created_copies.insert({ array_to_copy, copied.second });
+
+                                // can't switch back to file with array usage
+                                if (SgFile::switchToFile(current_file_name) == -1)
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
                             }
                         }
 
@@ -515,12 +837,9 @@ 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, filename);
+                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, current_func_info);
                                 else
-                                {
                                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                                    return;
-                                }
                             }
                         }
 
@@ -538,7 +857,17 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                         }
                     }
 
-                    populateDistributedIoArrays(need_replace, curr_stmt);
+                    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();
+                    }
+
                     curr_stmt = curr_stmt->lexNext();
                 }
             }

src/Transformations/SwapOperators/swap_operators.cpp

@@ -1,353 +0,0 @@
-#include <map>
-#include <unordered_set>
-#include <vector>
-#include <queue>
-#include <iostream>
-
-#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;
-
-
-unordered_set<int> loop_tags = {FOR_NODE/*, FORALL_NODE, WHILE_NODE, DO_WHILE_NODE*/};
-unordered_set<int> importantDepsTags = {FOR_NODE, IF_NODE};
-unordered_set<int> importantUpdDepsTags = {ELSEIF_NODE};
-unordered_set<int> importantEndTags = {CONTROL_END};
-
-
-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();
-            if (curOperator -> lineNumber() == st -> lineNumber())
-                result.push_back(instruction);
-        }
-    }
-    return result;
-}
-
-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())
-        {
-            // part with find statements of loop
-            SgForStmt *forSt = (SgForStmt*)st;
-            SgStatement *loopBody = forSt -> body();
-            SgStatement *lastLoopNode = st->lastNodeOfStmt();
-            // part with find blocks and instructions of loops
-            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;
-}
-
-map<SgStatement*, set<SgStatement*>> AnalyzeLoopAndFindDeps(SgForStmt* forStatement, vector<SAPFOR::BasicBlock*> loopBlocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
-{
-    map<SgStatement*, set<SgStatement*>> result;
-    for (SAPFOR::BasicBlock* bb: loopBlocks)
-    {
-        map<SAPFOR::Argument*, set<int>> blockReachingDefinitions = bb -> getRD_In();
-        vector<SAPFOR::IR_Block*> instructions = bb -> getInstructions();
-        for (SAPFOR::IR_Block* irBlock: instructions)
-        {
-            // TODO: Think about what to do with function calls and array references. Because there are also dependencies there that are not reflected in RD, but they must be taken into account
-            SAPFOR::Instruction* instr = irBlock -> getInstruction();
-            result[instr -> getOperator()];
-            // take Argument 1 and it's RD and push operators to final set
-            if (instr -> getArg1() != NULL)
-            {
-                SAPFOR::Argument* arg = instr -> getArg1();
-                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
-                for (int i: prevInstructionsNumbers)
-                {
-                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
-                    if (foundInstruction != NULL)
-                    {
-                        SgStatement* prevOp = foundInstruction -> getOperator();
-                        if (prevOp != forStatement && instr -> getOperator() != forStatement && instr -> getOperator() -> lineNumber() > prevOp -> lineNumber()
-                            && prevOp -> lineNumber() > forStatement -> lineNumber())
-                            result[instr -> getOperator()].insert(prevOp);
-                    }
-                }
-            }
-            // take Argument 2 (if exists) and it's RD and push operators to final set
-            if (instr -> getArg2() != NULL)
-            {
-                SAPFOR::Argument* arg = instr -> getArg2();
-                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
-                for (int i: prevInstructionsNumbers)
-                {
-                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
-                    if (foundInstruction != NULL)
-                    {
-                        SgStatement* prevOp = foundInstruction -> getOperator();
-                        if (prevOp != forStatement && instr -> getOperator() != forStatement&& instr -> getOperator() -> lineNumber() > prevOp -> lineNumber()
-                            && prevOp -> lineNumber() > forStatement -> lineNumber())
-                            result[instr -> getOperator()].insert(prevOp);
-                    }
-                }
-            }
-            // update RD
-            if (instr -> getResult() != NULL)
-                blockReachingDefinitions[instr -> getResult()] = {instr -> getNumber()};
-        }
-    }
-    return result;
-}
-
-void buildAdditionalDeps(SgForStmt* forStatement, map<SgStatement*, set<SgStatement*>>& dependencies)
-{
-    SgStatement* lastNode = forStatement->lastNodeOfStmt();
-    vector<SgStatement*> importantDeps;
-    SgStatement* st = (SgStatement*) forStatement;
-    st = st -> lexNext();
-    SgStatement* logIfOp = NULL;
-    while (st && st != lastNode)
-    {
-        if(importantDeps.size() != 0)
-        {
-            if (st != importantDeps.back())
-            {
-                dependencies[st].insert(importantDeps.back());
-            }
-        }
-        if (logIfOp != NULL)
-        {
-            dependencies[st].insert(logIfOp);
-            logIfOp = NULL;
-        }
-        if (st -> variant() == LOGIF_NODE)
-        {
-            logIfOp = st;
-        }
-        if (importantDepsTags.find(st -> variant()) != importantDepsTags.end())
-        {
-            importantDeps.push_back(st);
-        }
-        if (importantUpdDepsTags.find(st -> variant()) != importantUpdDepsTags.end())
-        {
-            importantDeps.pop_back();
-            importantDeps.push_back(st);
-        }
-        if (importantEndTags.find(st -> variant()) != importantEndTags.end())
-        {
-            if(importantDeps.size() != 0)
-            {
-                importantDeps.pop_back();
-            }
-        }
-        st = st -> lexNext();
-    }
-}
-
-struct ReadyOp {
-    SgStatement* stmt;
-    int degree;
-    size_t arrival;
-    ReadyOp(SgStatement* s, int d, size_t a): stmt(s), degree(d), arrival(a) {}
-};
-
-struct ReadyOpCompare {
-    bool operator()(const ReadyOp& a, const ReadyOp& b) const {
-        if (a.degree != b.degree)
-            return a.degree > b.degree;
-        else
-            return a.arrival > b.arrival;
-    }
-};
-
-vector<SgStatement*> scheduleOperations(const map<SgStatement*, set<SgStatement*>>& dependencies)
-{
-    // get all statements
-    unordered_set<SgStatement*> allStmtsSet;
-    for (const auto& pair : dependencies)
-    {
-        allStmtsSet.insert(pair.first);
-        for (SgStatement* dep : pair.second)
-        {
-            allStmtsSet.insert(dep);
-        }
-    }
-    vector<SgStatement*> allStmts(allStmtsSet.begin(), allStmtsSet.end());
-    // count deps and build reversed graph
-    unordered_map<SgStatement*, vector<SgStatement*>> graph;
-    unordered_map<SgStatement*, int> inDegree;
-    unordered_map<SgStatement*, int> degree;
-    for (auto op : allStmts)
-        inDegree[op] = 0;
-    // find and remember initial dependencies
-    unordered_set<SgStatement*> dependentStmts;
-    for (const auto& pair : dependencies)
-    {
-        SgStatement* op = pair.first;
-        const auto& deps = pair.second;
-        degree[op] = deps.size();
-        inDegree[op] = deps.size();
-        if (!deps.empty())
-            dependentStmts.insert(op);
-        for (auto dep : deps)
-            graph[dep].push_back(op);
-    }
-    for (SgStatement* op : allStmts)
-    {
-        if (!degree.count(op))
-        {
-            degree[op] = 0;
-        }
-    }
-    // build queues
-    using PQ = priority_queue<ReadyOp, vector<ReadyOp>, ReadyOpCompare>;
-    PQ readyDependent;
-    queue<SgStatement*> readyIndependent;
-    size_t arrivalCounter = 0;
-    for (auto op : allStmts)
-    {
-        if (inDegree[op] == 0)
-        {
-            if (dependentStmts.count(op))
-            {
-                readyDependent.emplace(op, degree[op], arrivalCounter++);
-            }
-            else
-            {
-                readyIndependent.push(op);
-            }
-        }
-    }
-    // main sort algorythm
-    vector<SgStatement*> executionOrder;
-    while (!readyDependent.empty() || !readyIndependent.empty())
-    {
-        SgStatement* current = nullptr;
-        if (!readyDependent.empty())
-        {
-            current = readyDependent.top().stmt;
-            readyDependent.pop();
-        }
-        else
-        {
-            current = readyIndependent.front();
-            readyIndependent.pop();
-        }
-        executionOrder.push_back(current);
-        for (SgStatement* neighbor : graph[current])
-        {
-            inDegree[neighbor]--;
-            if (inDegree[neighbor] == 0) {
-                if (dependentStmts.count(neighbor))
-                {
-                    readyDependent.emplace(neighbor, degree[neighbor], arrivalCounter++);
-                }
-                else
-                {
-                    readyIndependent.push(neighbor);
-                }
-            }
-        }
-    }
-    return executionOrder;
-}
-
-void buildNewAST(SgStatement* loop, vector<SgStatement*>& newBody)
-{
-    SgStatement* endDo = loop->lastNodeOfStmt();
-    SgStatement* st = loop;
-    int lineNum = loop -> lineNumber() + 1;
-    for (int i = 0; i < newBody.size(); i++)
-    {
-        st -> setLexNext(*newBody[i]);
-        st = st -> lexNext();
-        st -> setlineNumber(lineNum);
-        lineNum++;
-    }
-    st -> setLexNext(*endDo);
-}
-
-
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform)
-{
-    std::cout << "SWAP_OPERATORS Pass" << std::endl;    // to remove
-    countOfTransform += 1;                              // to remove
-
-    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)
-        {
-            map<SgStatement*, set<SgStatement*>> dependencyGraph = AnalyzeLoopAndFindDeps(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-            // TODO: Write a function that will go through the operators and update all dependencies so that there are no mix-ups and splits inside the semantic blocks (for if, do and may be some other cases)
-            buildAdditionalDeps(loopForAnalyze.first, dependencyGraph);
-            cout << endl;
-            int firstLine = loopForAnalyze.first -> lineNumber();
-            int lastLine = loopForAnalyze.first -> lastNodeOfStmt() -> lineNumber();
-            cout << "LOOP ANALYZE FROM " << firstLine << " TO " << lastLine << " RES" << endl;
-            // for (auto &v: dependencyGraph) {
-            //     cout << "OPERATOR: " << v.first -> lineNumber()  << "    " << v.first -> variant() << "\nDEPENDS ON:" << endl;
-            //     if (v.second.size() != 0)
-            //         for (auto vv: v.second)
-            //             cout << vv -> lineNumber() << "  ";
-            //     cout << endl;
-            // }
-            vector<SgStatement*> new_order = scheduleOperations(dependencyGraph);
-            cout << "RESULT ORDER:" << endl;
-            for (auto v: new_order) 
-                if (v -> lineNumber() > firstLine) 
-                    cout << v -> lineNumber() << endl;
-            buildNewAST(loopForAnalyze.first, new_order);
-            st = loopForAnalyze.first -> lexNext();
-            while (st != loopForAnalyze.first -> lastNodeOfStmt())
-            {
-                cout << st -> lineNumber() << "    " << st -> sunparse() << endl;
-                st = st -> lexNext();
-            }
-        }
-    }
-
-    return;
-};

src/Transformations/SwapOperators/swap_operators.h

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

src/Utils/PassManager.h

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

src/Utils/errors.h

@@ -78,7 +78,12 @@ enum typeMessage { WARR, ERROR, NOTE };
 //   60 "Format misplaced"
 //   61 "Array has declaration area conflict"
 //   62 "need to move common declaration to main for DECLATE"
-// 
+//   63 "Failed to initialize libpredict cluster"
+//   64 "Failed to initialize libpredict grid"
+//   65 "Failed to distribute array with libpredict"
+//   66 "Failed to align array with libpredict"
+//   67 "Failed to process shadow_renew with libpredict"
+//
 // 20xx TRANSFORM GROUP
 //   01 "can not convert array assign to loop"
 //   02 "converted arithmetic IF to simple IF"
@@ -305,7 +310,7 @@ static void printStackTrace() { };
     } \
 } while (0)
 
-// Свободный - R206
+// Свободный - R210
 // Гайд по русификации сообщений: При добавлении нового сообщения, меняется последний сводобный идентификатор.
 // В этом файле остаются только спецификаторы, для которых будет заполнен текст. Полный текст пишется в файле
 // russian_errors_text.txt. Спецификаторы там тоже сохраняются, по ним в визуализаторе будет восстановлен 
@@ -504,6 +509,16 @@ static const wchar_t *R183 = L"R183:";
 static const wchar_t *R184 = L"R184:%s";
 //1062
 static const wchar_t* R205 = L"R205:%s#%s";
+//1063
+static const wchar_t* R206 = L"R206:";
+//1064
+static const wchar_t* R207 = L"R207:";
+//1065
+static const wchar_t* R208 = L"R208:";
+//1066
+static const wchar_t* R209 = L"R209:";
+//1067
+static const wchar_t* R210 = L"R210:";
 
 //2001
 static const wchar_t *R94 = L"R94:";

src/Utils/russian_errors_text.txt

@@ -184,8 +184,18 @@ R182 = "Редукционная операция по элементу масс
 R183 = "Расположение операторов FORMAT не поддерживается, попробуйте применить проход Коррекция стиля кода".
 //1061
 R184 = "Область объявления массива '%s' конфликтует с предыдущей областью. Возможно, это вызвано использованием include-файлов. Попробуйте применить проход 'Подстановка заголовочных файлов'".
-//1042
+//1062
 R205 = "Массив '%s' состоящий в common блоке '%s' должен иметь описание в главной программной единице для объявления в директиве DECLARE"
+//1063
+R206 = "Ошибка инициализации библиотеки libpredict с конфигурацией кластера: %s, код возврата: %d"
+//1064
+R207 = "Ошибка инициализации сетки libpredict с топологией: %zu %zu %zu %zu, код возврата: %d"
+//1065
+R208 = "Ошибка распределения массива '%s' с помощью libpredict, код возврата: %d"
+//1066
+R209 = "Ошибка выравнивания массива '%s' с массивом '%s' с помощью libpredict, код возврата: %d"
+//1067
+R210 = "Ошибка обработки shadow_renew для массива '%s' с помощью libpredict, код возврата: %d"
 
 //2001
 R94 = "Невозможно автоматически преобразовать данное присваивание к циклу"

src/Utils/utils.cpp

@@ -390,32 +390,15 @@ 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();
 }
 
@@ -451,7 +434,7 @@ static map<string, vector<Messages>> removeCopies(map<string, vector<Messages>>
     return out;
 }
 
-static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
+static string convertGlobalMessagesBuffer()
 {
     auto copySPF_messages = removeCopies(SPF_messages);
     for (auto &byFile : copySPF_messages)
@@ -489,21 +472,13 @@ static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
     json all;
     all["allMessages"] = allMessages;
 
-    const string str = all.dump();    
+    return 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)
 {
-    convertGlobalMessagesBuffer(resultM, resultSizeM);
+    resultM = convertGlobalMessagesBuffer();
-    convertGlobalBuffer(result, resultSize);
+    result = getGlobalBuffer();
 }
 
 bool isSPF_comment(const string &bufStr)

src/Utils/utils.h

@@ -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(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize);
+void convertBuffers(std::string& resultM, std::string& result);
 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);

src/Utils/version.h

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