libpredict_integration: add smart search by processes_per_processor

- libpredictor: sync with origin/main
- dvm: sync with origin/main

CMakeLists.txt

@@ -338,7 +338,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

src/CFGraph/private_variables_analysis.cpp

@@ -321,6 +321,12 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
         }
     }
 
+    if (currentLoop.empty()) // can't find loop IR - loop unreachable!
+    {
+        __spf_print(1, "Unreachable loop on %s:%d\n", current_file->filename(), loop_operator->lineNumber());
+        return currentLoop;
+    }
+
     if (!head_block)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
     

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/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/Predictor/PredictScheme.cpp

@@ -23,6 +23,7 @@
 #include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "CFGraph/CFGraph.h"
+#include "../Utils/utils.h"
 
 #include "json.hpp"
 
@@ -37,6 +38,109 @@ using SAPFOR::CFG_Settings;
 
 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

@@ -61,3 +61,5 @@ 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 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,470 @@
+#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,
+                      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 and processes_per_processor to find most optimal one
+    if (maxSizeDist) {
+        if (maxSizeDist > 4) {
+            maxSizeDist = 4;
+        }
+
+        // Initialize cluster
+        int maxCoresCount = 0;
+        libpredict::RetInitCluster retInitCluster = libpredict::InitCluster(clusterConfStr, maxCoresCount);
+
+        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;
+        }
+
+        vector<size_t> bestTopology;
+        double bestTime = std::numeric_limits<double>::max();
+        size_t bestProcessesPerProcessor = 0;
+        int prevProcCount = -1;
+
+        for (size_t processes_per_processor = 1; processes_per_processor <= maxCoresCount; ++processes_per_processor) {
+            int procCount = 0;
+            libpredict::RetInitMapping retInitMapping = libpredict::InitMapping(processes_per_processor, procCount);
+
+            if (retInitMapping != libpredict::INIT_MAPPING_SUCCESS) {
+                __spf_print(1, "ERROR: Failed to initialize libpredict mapping with processes_per_processor: %zu, return code: %d\n",
+                            processes_per_processor, (int)retInitMapping);
+
+                std::wstring messageR, messageE;
+                __spf_printToLongBuf(messageE, L"Failed to initialize libpredict mapping with processes_per_processor: %zu, return code: %d",
+                                     processes_per_processor, (int)retInitMapping);
+                __spf_printToLongBuf(messageR, R211);
+                getObjectForFileFromMap(clusterConfStr.c_str(), SPF_messages).push_back(Messages(ERROR, 1, messageR, messageE, 1068));
+                continue;
+            }
+
+            if (procCount == 0) {
+                break; // No more processors available
+            }
+
+            if (procCount == prevProcCount) {
+                continue; // Skip with procCount value unchanged for different processes_per_processor
+            }
+
+            prevProcCount = procCount;
+            __spf_print(1, "Calculate with processes_per_processor=%zu, procCount=%d\n", processes_per_processor, procCount);
+
+            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;
+                            }
+
+                            vector<size_t> topology = {n1, n2, n3, n4};
+                            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) {
+                                continue;
+                            }
+
+                            if (currTime < bestTime) {
+                                bestTime = currTime;
+                                bestTopology = topology;
+                                bestProcessesPerProcessor = processes_per_processor;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!bestTopology.empty()) {
+            string outStr;
+            for (const auto& elem : bestTopology) {
+                outStr += std::to_string(elem) + " ";
+            }
+
+            __spf_print(1, "best topology %s with time %f (processes_per_processor=%zu)\n",
+                        outStr.c_str(), bestTime, bestProcessesPerProcessor);
+        }
+    } else {
+        __spf_print(1, "impossible to calculate best topology: project does not contain distribution directives\n");
+    }
+}

src/Predictor/PredictSchemeWithLibrary.h

@@ -0,0 +1,56 @@
+#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,
+                      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/Sapfor.cpp

@@ -58,6 +58,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"
@@ -1732,103 +1733,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         }
     }
     else if (curr_regime == PREDICT_SCHEME)
-    {
+        runPredictScheme(project, 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)
@@ -2229,9 +2134,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);

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/GlobalVariables/fix_common_blocks.cpp

@@ -18,69 +18,66 @@ using std::tuple;
 
 /// main function:
 // renew unions for all common blocks in the file
-static void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBlocks,
+//void BuildNewCommDecls
-    map<string, deque<CommConstraint>>& newCommonDecls, map<string, map<string, deque<CommConstraint>>>& commDecls,
-    set<string>& badCommon, map<string, set<string>>& notUsedVars, vector<SgStatement*>& programUnits);
 
 // get names of variables and array elements, which were referenced in programm unit
-static set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames);
+//set<string> getUses
-static void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used);
+//void getUsesFromExpr
 
 // splits arrays into elements and replaces not used vars with empty constraints
-static bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars);
+//bool splitType
+ 
 // create constraits set
-static deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars);
+//deque<CommConstraint> makeConstraints
+ 
 // build union
-static bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints);
+//bool buildConstraintsUnion
-static bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, pair<CommConstraint, CommConstraint>& problemConstraints);
+//bool docheckUnequalConstraints
-static bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints);
+//bool check
 
 /// small help functions:
-static string getParentName(const string& name);
+//string getParentName
-static bool equalDims(const CommConstraint& a, const CommConstraint& b);
+//bool equalDims
-static bool equalConstraints(const CommConstraint& a, const CommConstraint& b);
+//bool equalConstraints
-static void addElem(deque<CommConstraint>& comm, const CommConstraint& elem);
+//void addElem
-//////
 
 // change names of variables in 'constraints'
-static void fixNames(deque<CommConstraint>& constraints, const string& commName);
+//void fixNames
 
 ////// step2: transformation
-
 /// main function
 // peform transformation on every program unit in the file
-static void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
+//void fixFunctions
-    map<string, map<string, deque<CommConstraint>>>& commDecls, const set<string>& badCommon, map<string, set<string>>& notUsedVars);
 
 // get pairs of names (namesOldToNew) for renaming
-static bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew);
+//bool getNamesOldToNew
 
 // create new symbols for new variables in new common declaration (constraints)
-static void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, string commName,
+//void makeCommVarSymbs
-    map<string, SgSymbol*>& symbs, vector<SgSymbol*>& needNewDecl);
+
 // delete from program unit all references to names in commVarNames
-static void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames);
+//void deleteOldVars
 
 // calls fixExpression for each statement, replaces names in data statement
-static void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew);
+//void renameVariables
+
 // replacing variables or array elements in expression expr if their names are in namesOldToNew
-static SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew);
+//SgExpression* fixExpression
 
 // make new exprList exprssion for new declaration decl with symbols from newSymbs
-static SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
+//SgExpression* makeExprListForCommon
-    SgFile* file, SgStatement* firstSt);
+
 // replace old common declarations with new ones
-static void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs);
+//void rewriteCommon
 
 /// help functions:
-static SgExpression* makeIdxFromStr(const string& str);
+//SgExpression* makeIdxFromStr(const string& str);
+
 // make new expression of array element
-static SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs);
+//SgExpression* newArrElemExpr
-static bool variablePositionComp(const Variable* lhs, const Variable* rhs);
+//bool variablePositionComp
 //////
 
-
-
 CommConstraint::CommConstraint(const Variable* var, bool u, const string& funcName, const string& fileName)
 {
     used = u;
@@ -125,7 +122,6 @@ CommConstraint::CommConstraint(const Variable* var, bool u, const string& funcNa
     }
 }
 
-
 CommConstraint::CommConstraint(const string& name, SgType* t, bool u) : used(u), type(t), identifier(name)
 {
     typeVariant = type->variant();
@@ -139,8 +135,7 @@ CommConstraint::CommConstraint(const string& name, SgType* t, bool u, vector<Dec
     size = getSizeOfType(type);
 }
 
-
+static string getParentName(const string& name)
-string getParentName(const string& name)
 {
     size_t len = name.find("%");
     size_t posB = name.find("(");
@@ -154,8 +149,7 @@ string getParentName(const string& name)
     return name.substr(0, len);
 }
 
-
+static void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used)
-void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used)
 {
     if (expr == NULL)
         return;
@@ -194,8 +188,7 @@ void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<
     getUsesFromExpr(expr->rhs(), commonVarNames, used);
 }
 
-
+static set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
-set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
 {
     set<string> used;
     SgStatement* lastSt = firstSt->lastNodeOfStmt();
@@ -212,8 +205,7 @@ set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
     return used;
 }
 
-
+static bool equalDims(const CommConstraint& a, const CommConstraint& b)
-bool equalDims(const CommConstraint& a, const CommConstraint& b)
 {
     const vector<pair<int, int>>& adim = a.arrayInfo->GetSizes();
     const vector<pair<int, int>>& bdim = b.arrayInfo->GetSizes();
@@ -228,9 +220,8 @@ bool equalDims(const CommConstraint& a, const CommConstraint& b)
     return true;
 }
 
-
 // TODO: add attributes to CommConstraints, check if a and b have equal attributes
-bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
+static bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
 {
     if ((a.arrayInfo != NULL && b.arrayInfo == NULL) || ((a.arrayInfo == NULL && b.arrayInfo != NULL)))
         return false;
@@ -241,8 +232,7 @@ bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
     return true;
 }
 
-
+static void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
-void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
 {
     if (elem.typeVariant == 0 && !comm.empty() && comm.back().typeVariant == 0)
         comm.back().size += elem.size;
@@ -250,9 +240,8 @@ void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
         comm.push_back(elem);
 }
 
-
 // TODO: check attributes: do not split arrays with pointer or target attributes if check_use == true
-bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars = {})
+static bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars = {})
 {
     CommConstraint var = d.front();
     string name = var.identifier;
@@ -300,8 +289,7 @@ bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& name
     }
 }
 
-
+static deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars)
-deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars)
 {
     deque<CommConstraint> res;
     while (!constraints.empty())
@@ -318,8 +306,7 @@ deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const
     return res;
 }
 
-
+static bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints)
-bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints)
 {
     while (!A.empty() && !B.empty())
     {
@@ -358,8 +345,8 @@ bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstrai
     return true;
 }
 
-
+static bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, 
-bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, pair<CommConstraint, CommConstraint>& problemConstraints)
+                                      pair<CommConstraint, CommConstraint>& problemConstraints)
 {
     if (U.front().typeVariant == 0)
     {
@@ -382,8 +369,8 @@ bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>&
     return true;
 }
 
-
+static bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, 
-bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints)
+                                  const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints)
 {
     deque<CommConstraint> newU;
     while (!U.empty() && !B.empty())
@@ -438,8 +425,8 @@ bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, co
     return true;
 }
 
-
+//TODO: check this: newDecl and oldDecl => do these variables need references?
-bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew)
+static bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew)
 {
     bool needChange = false;
     map<string, string> rename;
@@ -504,16 +491,18 @@ bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDe
             newDecl.pop_front();
         }
     }
+
     if (!oldDecl.empty() || !newDecl.empty())
         needChange = true;
+
     if (needChange)
         namesOldToNew.insert(rename.begin(), rename.end());
+
     return needChange;
 }
 
-
+static void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, const string& commName,
-void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, string commName,
+                             map<string, SgSymbol*>& symbs, vector<SgSymbol*>& needNewDecl)
-    map<string, SgSymbol*>& symbs, vector<SgSymbol*>& needNewDecl)
 {
     for (const CommConstraint& var : constraints)
     {
@@ -526,8 +515,7 @@ void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, Sg
     }
 }
 
-
+static void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
-void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
 {
     SgStatement* lastSt = firstSt->lastNodeOfStmt();
     vector<SgStatement*> stmtsToDelete;
@@ -573,12 +561,12 @@ void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
         }
         // TODO: delete common variables form attributes statements (like DIM_STAT)
     }
+
     for (SgStatement* st : stmtsToDelete)
         st->deleteStmt();
 }
 
-
+static SgExpression* makeIdxFromStr(const string& str)
-SgExpression* makeIdxFromStr(const string& str)
 {
     vector<SgExpression*> items;
     int num = 0;
@@ -593,13 +581,13 @@ SgExpression* makeIdxFromStr(const string& str)
             num = 0;
         }
     }
+
     reverse(items.begin(), items.end());
     SgExpression* exprList = makeExprList(items, false);
     return exprList;
 }
 
-
+static SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs)
-SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs)
 {
     size_t pos = newName.find('(');
     SgExpression* newExpr = new SgArrayRefExp(*newSymbs.at(newName.substr(0, pos)));
@@ -607,11 +595,11 @@ SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>
     return newExpr;
 }
 
-
+static SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew)
-SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew)
 {
     if (expr == NULL)
         return NULL;
+
     if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF)
     {
         string name = expr->symbol()->identifier();
@@ -647,17 +635,18 @@ SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& ne
             }
         }
     }
+
     SgExpression* lhs = fixExpression(expr->lhs(), newSymbs, namesOldToNew);
     if (lhs != NULL)
         expr->setLhs(lhs);
+
     SgExpression* rhs = fixExpression(expr->rhs(), newSymbs, namesOldToNew);
     if (rhs != NULL)
         expr->setRhs(rhs);
     return NULL;
 }
 
-
+static void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew)
-void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew)
 {
     SgStatement* lastSt = firstSt->lastNodeOfStmt();
     for (SgStatement* curSt = firstSt; curSt != NULL && curSt != lastSt; curSt = curSt->lexNext())
@@ -705,8 +694,7 @@ void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarS
     }
 }
 
-
+static SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
-SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
     SgFile* file, SgStatement* firstSt)
 {
     vector<SgExpression*> items;
@@ -740,8 +728,7 @@ SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map
     return exprList;
 }
 
-
+static void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs)
-void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs)
 {
     vector<SgStatement*> commonStmtsToDelete;
     for (SgStatement* st = firstSt; st != firstSt->lastDeclaration()->lexNext(); st = st->lexNext())
@@ -792,12 +779,12 @@ void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExp
                 commonStmtsToDelete.push_back(st);
         }
     }
+
     for (SgStatement* st : commonStmtsToDelete)
         st->deleteStmt();
 }
 
-
+static void fixNames(deque<CommConstraint>& constraints, const string& commName)
-void fixNames(deque<CommConstraint>& constraints, const string& commName)
 {
     for (auto& var : constraints)
     {
@@ -812,26 +799,26 @@ void fixNames(deque<CommConstraint>& constraints, const string& commName)
     }
 }
 
-
+static bool variablePositionComp(const Variable* lhs, const Variable* rhs)
-bool variablePositionComp(const Variable* lhs, const Variable* rhs)
 {
     return lhs->getPosition() < rhs->getPosition();
 }
 
-
+static void fixFunctions(SgFile* file, const vector<SgStatement*>& programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
-void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
+                         map<string, map<string, deque<CommConstraint>>>& commDecls, const set<string>& badCommon, map<string, set<string>>& notUsedVars)
-    map<string, map<string, deque<CommConstraint>>>& commDecls, const set<string>& badCommon, map<string, set<string>>& notUsedVars)
 {
     for (SgStatement* unitSt : programUnits)
     {
         string funcName = unitSt->symbol()->identifier();
         if (commDecls.find(funcName) == commDecls.end())
             continue;
+
         SgStatement* firstSt = unitSt;
         map<string, SgExpression*> commListExprs;
         map<string, SgSymbol*> newVarSymbs; // new symbols for new variables
         map<string, string> namesOldToNew; // for ranaming: old name -> new name
         vector<SgSymbol*> needNewDecl;
+
         for (auto& common : commDecls[funcName])
         {
             string commName = common.first;
@@ -842,9 +829,11 @@ void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, d
             bool needChange = getNamesOldToNew(newDecl, common.second, namesOldToNew);
             if (!needChange)
                 continue;
+
             makeCommVarSymbs(newDecl, file, firstSt, commName, newVarSymbs, needNewDecl);
             commListExprs[commName] = makeExprListForCommon(newDecl, newVarSymbs, file, firstSt);
         }
+
         if (!commListExprs.empty())
         {
             for (const auto& item : commListExprs)
@@ -858,10 +847,9 @@ void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, d
     }
 }
 
-
+static void buildNewCommDecls(SgFile* file, const map<string, CommonBlock*>& allCommonBlocks,
-void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBlocks,
+                              map<string, deque<CommConstraint>>& newCommonDecls, map<string, map<string, deque<CommConstraint>>>& commDecls,
-        map<string, deque<CommConstraint>>& newCommonDecls, map<string, map<string, deque<CommConstraint>>>& commDecls,
+                              set<string>& badCommon, map<string, set<string>>& notUsedVars, vector<SgStatement*>& programUnits)
-        set<string>& badCommon, map<string, set<string>>& notUsedVars, vector<SgStatement*>& programUnits)
 {
     string fileName = file->filename();
     SgStatement* curSt = file->firstStatement();
@@ -900,7 +888,8 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl
                     constraints.push_back(newConstr);
                 }
                 if (hasChar && hasNotChar)  // TDOO: make proper warning message or separate such common blocks
-                    __spf_print(1, "common block '%s' ('%s':%d) contains variables of symbolic and numeric types. It is required to divide\n", commName.c_str(), fileName.c_str(), constraints.back().uses.back().lineNum);
+                    __spf_print(1, "common block '%s' ('%s':%d) contains variables of symbolic and numeric types. It is required to divide\n", 
+                                    commName.c_str(), fileName.c_str(), constraints.back().uses.back().getLineNum());
                 if (hasChar)
                 {
                     badCommon.insert(commName);
@@ -917,7 +906,7 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl
                     for (auto x : problemConstraints.first.uses)         // TODO: make proper warning message
                         for (auto y : problemConstraints.second.uses)
                             __spf_print(1, "variables '%s' and '%s' in one storage association (common block '%s') have different types (files - %s:%d and %s:%d)\n",
-                                x.varName.c_str(), y.varName.c_str(), commName.c_str(), x.fileName.c_str(), x.lineNum, y.fileName.c_str(), y.lineNum);
+                                            x.getVarName(), y.getVarName(), commName.c_str(), x.getFileName(), x.getLineNum(), y.getFileName(), y.getLineNum());
                 }
             }
             curSt = curSt->lastNodeOfStmt();
@@ -929,7 +918,7 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl
 
 
 // main function
-void fixCommonBlocks(const map<string, vector<FuncInfo*>> allFuncInfo, const map<string, CommonBlock*> allCommonBlocks, SgProject* project)  // TODO: separate into 2 steps?
+void fixCommonBlocks(const map<string, vector<FuncInfo*>>& allFuncInfo, const map<string, CommonBlock*>& allCommonBlocks, SgProject* project)  // TODO: separate into 2 steps?
 {
     int filesNum = project->numberOfFiles();
     map<string, map<string, map<string, deque<CommConstraint>>>> commDecls; // file_name -> function_name -> common block name -> old declaration of common block
@@ -943,10 +932,12 @@ void fixCommonBlocks(const map<string, vector<FuncInfo*>> allFuncInfo, const map
         SgFile* file = &project->file(i);
         string fileName = file->filename();
         file->switchToFile(fileName);
-        BuildNewCommDecls(file, allCommonBlocks, newCommonDecls, commDecls[fileName], badCommon, notUsedVars, programUnitsInFile[fileName]);
+        buildNewCommDecls(file, allCommonBlocks, newCommonDecls, commDecls[fileName], badCommon, notUsedVars, programUnitsInFile[fileName]);
     }
+
     for (auto& elem : newCommonDecls)
         fixNames(elem.second, elem.first);
+
     for (int i = 0; i < filesNum; i++)  // second step
     {
         SgFile* file = &project->file(i);

src/Transformations/GlobalVariables/fix_common_blocks.h

@@ -16,12 +16,18 @@
 
 struct DeclInfo // for error messages
 {
+private:
     std::string varName;
     std::string fileName;
     int lineNum;
 
+public:
     DeclInfo() : varName(""), fileName(""), lineNum(0) {};
     DeclInfo(const std::string& vn, const std::string& fn, int ln) : varName(vn), fileName(fn), lineNum(ln) {};
+
+    const char* getVarName() const { return varName.c_str(); }
+    const char* getFileName() const { return fileName.c_str(); }
+    int getLineNum() const { return lineNum; }
 };
 
 struct CommConstraint  // TODO: add variable attributes
@@ -42,4 +48,4 @@ struct CommConstraint  // TODO: add variable attributes
 };
 
 
-void fixCommonBlocks(const std::map<std::string, std::vector<FuncInfo*>> allFuncInfo, const std::map<std::string, CommonBlock*> allCommonBlocks, SgProject* project);
+void fixCommonBlocks(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, CommonBlock*>& allCommonBlocks, SgProject* project);

src/Utils/errors.h

@@ -78,6 +78,11 @@ 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"
@@ -305,7 +310,7 @@ static void printStackTrace() { };
     } \
 } while (0)
 
-// Свободный - R206
+// Свободный - R210
 // Гайд по русификации сообщений: При добавлении нового сообщения, меняется последний сводобный идентификатор.
 // В этом файле остаются только спецификаторы, для которых будет заполнен текст. Полный текст пишется в файле
 // russian_errors_text.txt. Спецификаторы там тоже сохраняются, по ним в визуализаторе будет восстановлен 
@@ -504,6 +509,18 @@ 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:";
+//1068
+static const wchar_t* R211 = L"R211:";
 
 //2001
 static const wchar_t *R94 = L"R94:";

src/Utils/module_utils.cpp

@@ -325,7 +325,7 @@ static void getModuleSymbols(SgStatement* func, set<SgSymbol*>& symbs)
     }
 }
 
-set<SgSymbol*> getModuleSymbols(SgStatement *func)
+const set<SgSymbol*>& getModuleSymbols(SgStatement *func)
 {
     auto it = symbolsForFunc.find(func->symbol()->identifier());
     if (it != symbolsForFunc.end())
@@ -345,7 +345,7 @@ set<SgSymbol*> getModuleSymbols(SgStatement *func)
     }
 
     symbolsForFunc[func->symbol()->identifier()] = symbs;
-    return symbs;
+    return symbolsForFunc[func->symbol()->identifier()];
 }
 
 static void findSymbol(SgStatement* func, const string& varName, const string& locName,

src/Utils/module_utils.h

@@ -1,7 +1,7 @@
 #pragma once
 
 std::string correctSymbolModuleName(const std::string& origFull);
-std::set<SgSymbol*> getModuleSymbols(SgStatement* func);
+const std::set<SgSymbol*>& getModuleSymbols(SgStatement* func);
 void getModulesAndFunctions(SgFile* file, std::vector<SgStatement*>& modulesAndFunctions);
 void findModulesInFile(SgFile* file, std::vector<SgStatement*>& modules);
 std::map<std::string, std::set<std::string>> createMapOfModuleUses(SgFile* file);

src/Utils/russian_errors_text.txt

@@ -184,8 +184,20 @@ 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"
+//1068
+R211 = "Ошибка инициализации отображения libpredict с processes_per_processor: %zu, код возврата: %d"
 
 //2001
 R94 = "Невозможно автоматически преобразовать данное присваивание к циклу"

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2464"
+#define VERSION_SPF "2465"

src/VisualizerCalls/get_information.cpp

@@ -950,7 +950,7 @@ int SPF_ModifyArrayDistribution(void*& context, int winHandler, short *options,
 
 extern map<string, PredictorStats> allPredictorStats;
 extern map<string, vector<SpfInterval*>> intervals;
-extern vector<vector<long>> topologies;
+extern vector<vector<size_t>> topologies;
 
 int SPF_CreateParallelVariant(void*& context, int winHandler, short *options, short *projName, short *folderName, int64_t *variants, int *varLen,
                               string &output, string &outputMessage, string &predictorStats)
@@ -1823,7 +1823,7 @@ static int inline runModificationPass(passes passName, short* projName, short* f
     runPassesForVisualizer(projName, { passName }, folderName);
 
     //fill data
-    // newFiles: <èìåíà ôàéëîâ äëÿ ìîä, ñîäåðæèìîå ôàéëà>
+    // newFiles: <<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>>
     string newFile;
     
     if (SgFile::switchToFile(outFileName.c_str()) == -1)
@@ -2392,7 +2392,7 @@ const wstring Sapfor_RunAnalysis(const char* analysisName_c, const char* options
             retCode = SPF_GetArrayLinks(context, winHandler, optSh, projSh, result, output, outputMessage);
         else if (whichRun == "SPF_GetMaxMinBlockDistribution")
             retCode = SPF_GetMaxMinBlockDistribution(context, winHandler, optSh, projSh, result, output, outputMessage);
-        else if (whichRun == "SPF_ÑhangeDirectory") // russian C
+        else if (whichRun == "SPF_<EFBFBD>hangeDirectory") // russian C
         {
             if (options_c == NULL)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);