libpredict_integration: init

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

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

@@ -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,306 @@
+#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::string;
+using std::vector;
+using std::pair;
+using std::tuple;
+
+// МОЖЕТ КАК-ТО ВЫЧИСЛЯТЬ ДИРЕКТИВЫ, А ПОТОМ ДЕЛАТЬ ПРОГОНЫ?
+double runLibpredictCalc(SgProject &project,
+                      vector<size_t> topology,
+                      string clusterConfStr,
+                      vector<ParallelRegion*> &parallelRegions,
+                      map<string, vector<LoopGraph*>> loopGraph,
+                      map<string, vector<Messages>> &SPF_messages)
+{
+    libpredict::RetInit retInit = libpredict::Init(clusterConfStr, topology[0], topology[1], topology[2], topology[3]);
+
+    if (retInit != libpredict::INIT_SUCCESS) {
+        __spf_print(1, "ERROR: Failed to initialize libpredict with cluster config: %s, return code: %d\n", clusterConfStr.c_str(), (int)retInit);
+    
+        std::wstring messageR, messageE;
+        __spf_printToLongBuf(messageE, L"Failed to initialize libpredict library with cluster config: %s, return code: %d",
+                             to_wstring(clusterConfStr).c_str(), (int)retInit);
+        __spf_printToLongBuf(messageR, R206);
+        getObjectForFileFromMap(clusterConfStr.c_str(), SPF_messages).push_back(Messages(ERROR, 1, messageR, messageE, 1063));
+        return -1;
+    }
+
+    // distribute и align из parallelRegions
+    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]]));
+
+        // distribute
+        for (const auto& distrRule : currentVar) {
+            DIST::Array* array = distrRule.first;
+            const DistrVariant* variant = distrRule.second;
+
+            if (array && variant && !array->IsNotDistribute()) {
+                size_t arrayId = array->GetId();
+                size_t elemSize = array->GetTypeSize();
+
+                vector<libpredict::DistributeAxisRule> axisDistributions;
+                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) {
+                        axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::BLOCK);
+                    } else {
+                        axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::NONE);
+                    }
+                }
+
+                vector<pair<size_t, size_t>> shadowEdges;
+                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) {
+                        shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second);
+                    }
+                }
+
+                libpredict::RetDistribute retDistribute = libpredict::Distribute(arrayId, elemSize, axisDistributions, shadowEdges);
+
+                if (retDistribute != libpredict::DISTRIBUTE_SUCCESS) {
+                    __spf_print(1, "ERROR: Failed to distribute array '%s' (id=%zu) with libpredict, return code: %d\n",
+                               array->GetShortName().c_str(), arrayId, (int)retDistribute);
+
+                    std::wstring messageR, messageE;
+                    __spf_printToLongBuf(messageE, L"Failed to distribute array '%s' with libpredict, return code: %d",
+                                         to_wstring(array->GetShortName()).c_str(), (int)retDistribute);
+                    __spf_printToLongBuf(messageR, R207);
+                    getObjectForFileFromMap(array->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(
+                        Messages(ERROR, array->GetDeclInfo().begin()->second, messageR, messageE, 1064));
+                }
+            }
+        }
+
+        // align
+        for (const auto& alignRule : dataDirectives.alignRules) {
+            DIST::Array* alignArray = alignRule.alignArray;
+            DIST::Array* alignWithArray = alignRule.alignWith;
+
+            if (alignArray && alignWithArray && !alignArray->IsNotDistribute()) {
+                size_t arrayId = alignArray->GetId();
+                size_t distributedArrayId = alignWithArray->GetId();
+                size_t elemSize = alignArray->GetTypeSize();
+
+                const auto& arraySizes = alignArray->GetSizes();
+                vector<size_t> dimensions;
+                for (int dim = 0; dim < alignArray->GetDimSize(); ++dim)
+                    dimensions.push_back(arraySizes[dim].second - arraySizes[dim].first + 1);
+
+                vector<libpredict::AlignDisplay> distributionExpressions;
+                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) {
+                                // Константа
+                                distributionExpressions.emplace_back(rule.second);
+                            } else {
+                                // Линейное выражение a * I + b
+                                distributionExpressions.emplace_back(i, rule.first, rule.second);
+                            }
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        // Нет правила для этого измерения
+                        distributionExpressions.emplace_back();
+                    }
+                }
+
+                vector<pair<size_t, size_t>> shadowEdges;
+                const auto& shadowSpec = alignArray->GetShadowSpec();
+                for (int dim = 0; dim < shadowSpec.size() && dim < alignArray->GetDimSize(); ++dim) {
+                    shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second);
+                }
+
+                libpredict::RetAlign retAlign = libpredict::Align(arrayId, distributedArrayId, elemSize, dimensions, distributionExpressions, 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",
+                               alignArray->GetShortName().c_str(), arrayId,
+                               alignWithArray->GetShortName().c_str(), 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(alignArray->GetShortName()).c_str(),
+                                         to_wstring(alignWithArray->GetShortName()).c_str(), (int)retAlign);
+                    __spf_printToLongBuf(messageR, R208);
+                    getObjectForFileFromMap(alignArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(
+                        Messages(ERROR, alignArray->GetDeclInfo().begin()->second, messageR, messageE, 1065));
+                }
+            }
+        }
+
+        // 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(), 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()) {
+                        size_t arrayId = shadowArray->GetId();
+
+                        vector<pair<size_t, size_t>> shadow_renew;
+                        for (const auto& bound : bounds) {
+                            shadow_renew.emplace_back(static_cast<size_t>(bound.first),
+                                                    static_cast<size_t>(bound.second));
+                        }
+
+                        bool corner = directive->shadowRenewCorner[shadowIdx];
+
+                        size_t number_loop_iterations = loopPtr ? static_cast<size_t>(loopPtr->countOfIters) : 1;
+
+                        libpredict::RetShadowRenew retShadowRenew = libpredict::ShadowRenew(arrayId, shadow_renew, corner, 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",
+                                       shadowArray->GetShortName().c_str(), 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(shadowArray->GetShortName()).c_str(), (int)retShadowRenew);
+                            __spf_printToLongBuf(messageR, R209);
+                            getObjectForFileFromMap(shadowArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(
+                                Messages(ERROR, shadowArray->GetDeclInfo().begin()->second, messageR, messageE, 1066));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return libpredict::GetTime();
+}
+
+void runPredictScheme(SgProject &project,
+                      vector<vector<size_t>> &topologies, // такой способ передачи разве хочу?
+                      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 = 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";
+    }
+
+    // iterating through topologies to find most optimal one
+    topologies = vector<vector<size_t>>();
+    if (maxSizeDist) {
+
+        if (maxSizeDist > 4) maxSizeDist = 4;
+
+        // TODO: look at cluster configuration
+        size_t n1max = 10;
+        size_t n2max = (maxSizeDist >= 2) ? 10 : 1;
+        size_t n3max = (maxSizeDist >= 3) ? 10 : 1;
+        size_t n4max = (maxSizeDist >= 4) ? 10 : 1;
+
+        for (size_t n1 = 1; n1 <= n1max; ++n1) {
+            for (size_t n2 = 1; n2 <= n2max; ++n2) {
+                for (size_t n3 = 1; n3 <= n3max; ++n3) {
+                    for (size_t n4 = 1; n4 <= n4max; ++n4) {
+                        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) {
+            // if (DEBUG) {
+                // string outStr = "";
+                // for (const auto &elem : top)
+                //     outStr += std::to_string(elem) + " ";
+                // __spf_print(1, "topology %s has time %f\n", outStr.c_str(), currTime);
+            // }
+            double currTime = runLibpredictCalc(project, topology, clusterConfStr, parallelRegions, loopGraph, SPF_messages);
+
+            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,19 @@
+#pragma once
+#include <vector>
+#include <map>
+#include <string>
+#include "dvm.h"
+#include "graph_calls.h"
+
+void runPredictScheme(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<Messages>> &SPF_messages);
+
+double runLibpredictCalc(SgProject &project,
+                        std::vector<size_t> topology,
+                        std::string clusterConfStr,
+                        std::vector<ParallelRegion*> &parallelRegions,
+                        std::map<std::string, std::vector<LoopGraph*>> loopGraph,
+                        std::map<std::string, std::vector<Messages>> &SPF_messages);

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)

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/Utils/errors.h

@@ -78,6 +78,10 @@ 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 library"
+//   64 "Failed to distribute array with libpredict"
+//   65 "Failed to align array with libpredict"
+//   66 "Failed to process shadow_renew with libpredict"
 // 
 // 20xx TRANSFORM GROUP
 //   01 "can not convert array assign to loop"
@@ -305,7 +309,7 @@ static void printStackTrace() { };
     } \
 } while (0)
 
-// Свободный - R206
+// Свободный - R209
 // Гайд по русификации сообщений: При добавлении нового сообщения, меняется последний сводобный идентификатор.
 // В этом файле остаются только спецификаторы, для которых будет заполнен текст. Полный текст пишется в файле
 // russian_errors_text.txt. Спецификаторы там тоже сохраняются, по ним в визуализаторе будет восстановлен 
@@ -504,6 +508,14 @@ 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:";
 
 //2001
 static const wchar_t *R94 = L"R94:";

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)
@@ -1807,7 +1807,7 @@ static int inline runModificationPass(passes passName, short* projName, short* f
     runPassesForVisualizer(projName, { passName }, folderName);
 
     //fill data
-    // newFiles: <<3C><><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>>
+    // newFiles: <<3C><><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)
@@ -2376,7 +2376,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_<EFBFBD>hangeDirectory") // russian C
+        else if (whichRun == "SPF_<EFBFBD>hangeDirectory") // russian C
         {
             if (options_c == NULL)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);