REMOVE_DIST_ARRAYS_FROM_IO: use more general isSgVarListDeclStmt and isSgNestedVarListDeclStmt functions

CMakeLists.txt

@@ -331,9 +331,7 @@ set(MAIN src/Sapfor.cpp
         src/Utils/PassManager.h)
 
 set(PREDICTOR src/Predictor/PredictScheme.cpp
-              src/Predictor/PredictScheme.h
-              src/Predictor/PredictSchemeWithLibrary.cpp
-              src/Predictor/PredictSchemeWithLibrary.h)
+              src/Predictor/PredictScheme.h)
               
 set(LIBPREDICTOR  ${libpred_sources}/cluster.cpp
                   ${libpred_sources}/predictor.cpp
@@ -499,7 +497,7 @@ else()
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     endif()
     if(NOT CMAKE_BUILD_TYPE)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
     endif()
 endif()
 

src/DirectiveProcessing/directive_creator_base.cpp

@@ -122,7 +122,6 @@ 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,11 +857,6 @@ 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;
 
@@ -904,10 +899,7 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
                 for (auto& elem : genSubscripts(shadowRenew[i1].second, shadowRenewShifts[i1]))
                     newArrayRef->addSubscript(*elem);
 
-                bool needCornerFlag = shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop);
-                shadowRenewCorner[i1] = needCornerFlag;
-
-                if (needCornerFlag)
+                if (shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop))
                 {
                     SgExpression* tmp = new SgExpression(ARRAY_OP, newArrayRef, NULL, NULL);
                     p->setLhs(*tmp);

src/Distribution/DvmhDirective.h

@@ -102,7 +102,6 @@ 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;
@@ -126,7 +125,6 @@ public:
         privates = copyFrom.privates;
         shadowRenew = copyFrom.shadowRenew;
         shadowRenewShifts = copyFrom.shadowRenewShifts;
-        shadowRenewCorner = copyFrom.shadowRenewCorner;
         across = copyFrom.across;
         acrossShifts = copyFrom.acrossShifts;
         remoteAccess = copyFrom.remoteAccess;
@@ -153,7 +151,6 @@ public:
         on.clear();
         privates.clear();
         shadowRenew.clear();
-        shadowRenewCorner.clear();
         across.clear();
         acrossShifts.clear();
         reduction.clear();

src/Predictor/PredictScheme.cpp

@@ -23,7 +23,6 @@
 #include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "CFGraph/CFGraph.h"
-#include "../Utils/utils.h"
 
 #include "json.hpp"
 
@@ -37,109 +36,6 @@ 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,5 +61,3 @@ 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

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

src/Predictor/PredictSchemeWithLibrary.h

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

src/Sapfor.cpp

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

src/SapforData.h

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

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -17,14 +17,6 @@ using std::pair;
 
 #define DEBUG_TRACE 0
 
-static bool hasArrayRef(SgExpression* ex)
-{
-    if (ex)
-        return isArrayRef(ex) || hasArrayRef(ex->lhs()) || hasArrayRef(ex->rhs());
-
-    return false;
-}
-
 static inline bool isArrayDeclaration(SgStatement* st)
 {
     return isSgDeclarationStatement(st) || isSgVarListDeclStmt(st) || isSgNestedVarListDeclStmt(st);
@@ -209,15 +201,11 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
         if (!arg)
             return false;
 
-        if (hasArrayRef(arg))
-        {
-            if (isArrayRef(arg) && arg->lhs())
-                need_replace = true;
-        }
-        else
-        {
+        if (!isArrayRef(arg))
             return false;
-        }
+
+        if (arg->lhs())
+            need_replace = true;
     }
     else
     {

src/Utils/errors.h

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

src/Utils/russian_errors_text.txt

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

src/Utils/version.h

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

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<size_t>> topologies;
+extern vector<vector<long>> 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__);