libpredict_integration: precompute libpredict params

CMakeLists.txt

@@ -331,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
@@ -487,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()
@@ -496,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/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"
@@ -1728,103 +1729,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         }
     }
     else if (curr_regime == PREDICT_SCHEME)
-    {
-        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);
-
-    }
+        runPredictScheme(project, topologies, parallelRegions, loopGraph, SPF_messages);
     else if (curr_regime == CREATE_INTER_TREE)
     {
         if (keepFiles)
@@ -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)
-                runAnalysis(*project, PREDICT_SCHEME, false); */
+            if (!folderName && !consoleMode || predictOn)
+                runAnalysis(*project, PREDICT_SCHEME, false);
 
             runAnalysis(*project, REMOVE_COPIES, false);
             runAnalysis(*project, SWAP_LOOPS, false);

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/live_variable_analysis.h"
-#include "../CFGraph/DataFlow/data_flow.h"
-#include "../CFGraph/DataFlow/backward_data_flow.h"
+#include "CFGraph/CFGraph.h"
+#include "CFGraph/live_variable_analysis.h"
+#include "CFGraph/DataFlow/data_flow.h"
+#include "CFGraph/DataFlow/backward_data_flow.h"
 
 int removeDeadCode(SgStatement* func, 
                    const std::map<std::string, std::vector<FuncInfo*>>&allFuncs,

src/Transformations/FunctionPurifying/function_purifying.cpp

@@ -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
@@ -525,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());
     }

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/RD_subst.h"
+#include "CFGraph/CFGraph.h"
+#include "CFGraph/RD_subst.h"
 
 // Regime defines the regime of private removing
 enum class Regime { DEFLT = 1, REGULAR_INDEXES };

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))
-            return;
-
-        if (arg->lhs())
-            need_replace = true;
+        if (hasArrayRef(arg))
+        {
+            if (isArrayRef(arg) && arg->lhs())
+                need_replace = true;
+        }
+        else
+        {
+            return false;
+        }
     }
     else
     {
@@ -79,7 +237,6 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
             if (fmt->rhs()->variant() != KEYWORD_VAL || fmt->rhs()->sunparse() != "*")
                 need_replace = true;
 
-
             break;
         }
         case READ_STAT:
@@ -112,6 +269,7 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                     spec = spec->rhs();
                 }
             }
+            break;
         }
         default:
             break;
@@ -119,7 +277,9 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     }
 
     if (!need_replace)
-        return;
+        return false;
+
+    bool ret = false;
 
     set<SgSymbol*> found_arrays;
 
@@ -130,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)
-            __spf_print(DEBUG_TRACE, "[%d]: add array %s\n", stat->lineNumber(), array_p->GetName().c_str());
+        if (array_p && 
+            array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && 
+            !checkAssumedSize(array_name, array_p, current_file_name, current_func))
+        {
+            auto inserted = arrays[by_symb].insert(stat).second;
+
+            if (inserted)
+                __spf_print(DEBUG_TRACE, "[%d]: add array %s %p\n", stat->lineNumber(), array_p->GetName().c_str(), by_symb);
+
+            ret = true;
+        }
     }
 
     __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)
@@ -204,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();
@@ -223,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
@@ -237,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;
@@ -306,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);
     }
 }
@@ -329,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;
 
@@ -347,9 +544,9 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
 }
 
 void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
-    const map<string, vector<FuncInfo*>>& allFuncInfo,
-    map<string, vector<Messages>>& SPF_messages,
-    map<string, map<int, set<string>>>& newDeclsToInclude)
+                                  const map<string, vector<FuncInfo*>>& allFuncInfo,
+                                  map<string, vector<Messages>>& SPF_messages,
+                                  map<string, map<int, set<string>>>& newDeclsToInclude)
 {
     map<SgSymbol*, SgSymbol*> created_copies;
     map<string, map<int, set<string>>> copied_syms;
@@ -358,23 +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) == -1)
+            if (SgFile::switchToFile(current_file_name) == -1)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            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);
 
@@ -390,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)
                 {
@@ -398,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))
                         {
@@ -424,78 +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);
-                                const string locationName = array_p->GetLocation().second;
+                                // at this point all considered arrays must have DIST::Array* references
+                                if (!array_p)
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+                                // ... and be declared in switchable files (not in headers)
+                                pair<string, int> decl_place;
+                                if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func_info))
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-                                auto place = *array_p->GetDeclInfo().begin();
-                                string fileName = place.first;
                                 string suffix = "_io_l";
 
-                                if (fromModule)
-                                    suffix = "_io_m";
-
-                                pair<SgSymbol*, SgSymbol*> copied;
-                                copied.first = array_to_copy;
-
-                                if (SgFile::switchToFile(fileName) == -1)
+                                switch (array_p->GetLocation().first)
                                 {
-                                    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->variant() == SPF_PARALLEL_REG_DIR || iterator->variant() == SPF_END_PARALLEL_REG_DIR);
+                                        iterator && !isSgExecutableStatement(iterator);
                                         iterator = iterator->lexNext())
                                     {
-                                        insertPlace = iterator;
+                                            allocate_stmt_place = iterator;
                                     }
 
                                     //NULL - no decl stats in function!
-                                    if (!insertPlace)
-                                        insertPlace = func_stmt;
+                                    if (!allocate_stmt_place)
+                                        allocate_stmt_place = func_stmt;
 
-                                    auto st = insertPlace->controlParent();
-                                    if (st->variant() == GLOBAL)
-                                        st = insertPlace;
+                                    auto *allocate_stmt_parent = allocate_stmt_place->controlParent();
+                                    if (allocate_stmt_parent->variant() == GLOBAL)
+                                        allocate_stmt_parent = allocate_stmt_place;
+                                    
+                                    auto *created_array_ref = new SgArrayRefExp(*copied_symbol.second);
 
-                                    auto& copied_symb = array_to_copy->copy();
-                                    copied.second = &copied_symb;
-
-                                    auto new_name = string(array_to_copy->identifier()) + "_io_c";
-                                    copied_symb.changeName(new_name.c_str());
-
-                                    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())
+                                    auto* dim_list = new SgExprListExp();
+                                    created_array_ref->setLhs(dim_list);
+                                    
+                                    int dim_len = array_p->GetSizes().size();
+                                    for (int i = 1; i <= dim_len; i++)
                                     {
-                                        string str_comment = string(decl->comments());
-                                        if (str_comment.size() && str_comment.back() != '\n')
-                                            dir_str += "\n";
+                                        auto *lcall = new SgFunctionCallExp(*lbound_symb);
+                                        auto *rcall = new SgFunctionCallExp(*ubound_symb);
+                                        
+                                        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";
-                                    decl->addComment(dir_str.c_str());
-                                }
-                                created_copies.insert({ array_to_copy, copied.second });
+                                    auto *allocate_stmt = new SgStatement(ALLOCATE_STMT);
+                                    allocate_stmt->setExpression(0, created_array_ref);
 
-                                if (curr_stmt->switchToFile() == -1)
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                                    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;
+                                    }
+                                }
+
+                                // can't switch back to file with array usage
+                                if (SgFile::switchToFile(current_file_name) == -1)
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
                             }
                         }
 
@@ -507,7 +837,7 @@ 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__);
                             }
@@ -527,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/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;
-    for (auto& elem : allocatedInt)
-        delete[]elem;
+        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();    
-    const unsigned len = (unsigned)str.size();
-
-    copyStringToShort(result, str);
-    allocated.insert(result);
-
-    resultSize = new int[1];
-    resultSize[0] = (int)len;
+    return all.dump();    
 }
 
-
-void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize)
+void convertBuffers(string &resultM, string &result)
 {
-    convertGlobalMessagesBuffer(resultM, resultSizeM);
-    convertGlobalBuffer(result, resultSize);
+    resultM = convertGlobalMessagesBuffer();
+    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 "2441"
+#define VERSION_SPF "2446"