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/ArrayConstantPropagation/propagation.cpp

@@ -3,35 +3,13 @@
 #include "../Utils/SgUtils.h"
 
 #include <iostream>
-#include <functional>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 using namespace std;
 
-namespace {
+static SgStatement* declPlace = NULL;
-
-    struct MyHash {
-        size_t operator()(const SgSymbol* s) const {
-            return std::hash<std::string_view>{}(s->identifier());
-        }
-    };
-
-    struct MyEq {
-        bool operator()(const SgSymbol* a, const SgSymbol* b) const {
-            return std::strcmp(a->identifier(), b->identifier()) == 0;
-        }
-    };
-
-}
-
-SgStatement* declPlace = NULL;
-unordered_set<SgStatement*> changed;
-unordered_set<SgSymbol*, MyHash, MyEq> variablesToAdd;
-unordered_set<SgStatement*> positionsToAdd;
-unordered_set<SgStatement*> statementsToRemove;
-unordered_map<string, vector<pair<SgStatement*, SgStatement*>>> expToChange;
 
 static bool CheckConstIndexes(SgExpression* exp)
 {
@@ -62,148 +40,158 @@ static SgExpression* CreateVar(int& variableNumber, SgType* type)
     string name = varName + std::to_string(variableNumber) + "__";
     variableNumber++;
 
-    SgStatement* funcStart = declPlace->controlParent();
+    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *declPlace->controlParent());
-    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *funcStart);
-
-    variablesToAdd.insert(varSymbol);
-    positionsToAdd.insert(declPlace);
-
-    return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
-}
-
-static SgStatement* FindLastDeclStatement(SgStatement* funcStart)
-{
-    SgStatement* endSt = funcStart->lastNodeOfStmt();
-    SgStatement* cur = funcStart->lexNext();
-    SgStatement* lastDecl = funcStart;
-    const set<int> declVariants = { VAR_DECL, VAR_DECL_90, ALLOCATABLE_STMT, DIM_STAT,
-                                    EXTERN_STAT, COMM_STAT, HPF_TEMPLATE_STAT, DVM_VAR_DECL, STRUCT_DECL };
-
-    while (cur && cur != endSt)
-    {
-        if (cur->variant() == INTERFACE_STMT)
-            cur = cur->lastNodeOfStmt();
-
-        if (declVariants.find(cur->variant()) != declVariants.end())
-            lastDecl = cur;
-        else if (isSgExecutableStatement(cur))
-            break;
-
-        cur = cur->lexNext();
-    }
-
-    return lastDecl;
-}
-
-static void InsertCommonAndDeclsForFunction(SgStatement* funcStart, const unordered_set<SgSymbol*, MyHash, MyEq>& symbols)
-{
-    if (symbols.empty())
-        return;
 
     const string commonBlockName = "__propagation_common__";
 
-    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
+    SgStatement* funcStart = declPlace->controlParent();
     SgStatement* commonStat = NULL;
     SgExpression* commonList = NULL;
 
-    for (SgStatement* cur = funcStart->lexNext();
+    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
-         cur && cur != funcEnd; cur = cur->lexNext())
+    SgStatement* current = funcStart->lexNext();
+
+    while (current != funcEnd && current)
     {
-        if (cur->variant() != COMM_STAT)
+        if (current->variant() == COMM_STAT)
-            continue;
-
-        for (SgExpression* exp = cur->expr(0); exp; exp = exp->rhs())
         {
-            if (exp->variant() != COMM_LIST)
+            for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
-                continue;
-
-            const char* id = exp->symbol() ? exp->symbol()->identifier() : NULL;
-            string existingName = id ? string(id) : string("spf_unnamed");
-            if (existingName == commonBlockName)
             {
-                commonStat = cur;
+                if (exp->variant() == COMM_LIST)
-                commonList = exp;
+                {
-                break;
+                    string existingName = exp->symbol() ?
+                        string(exp->symbol()->identifier()) :
+                        string("spf_unnamed");
+                    if (existingName == commonBlockName)
+                    {
+                        commonStat = current;
+                        commonList = exp;
+                        break;
+                    }
+                }
             }
+            if (commonStat)
+                break;
         }
-        if (commonStat)
+        current = current->lexNext();
-            break;
     }
 
     vector<SgExpression*> varRefs;
-    for (SgSymbol* sym : symbols)
+    if (commonList)
     {
-        if (!sym || sym->variant() != VARIABLE_NAME || string(sym->identifier()) == commonBlockName)
+        SgExpression* varList = commonList->lhs();
-            continue;
+        if (varList)
-        SgSymbol* symToAdd = new SgSymbol(VARIABLE_NAME, sym->identifier(), *sym->type(), *funcStart);
+        {
-        varRefs.push_back(new SgVarRefExp(symToAdd));
+            auto extractSymbol = [](SgExpression* exp) -> SgSymbol* {
-    }
+                if (!exp) 
-    SgExpression* varList = makeExprList(varRefs, false);
+                    return NULL;
-
+                if (exp->symbol()) 
-    SgStatement* insertAfter = FindLastDeclStatement(funcStart);
+                    return exp->symbol();
-    for (SgSymbol* sym : symbols)
+                if (exp->lhs() && exp->lhs()->symbol())
-    {
+                    return exp->lhs()->symbol();
-        SgStatement* declStmt = sym->makeVarDeclStmt();
+                return NULL;
-        if (!declStmt)
+                };
-            continue;
+            if (varList->variant() == EXPR_LIST)
-
+            {
-        if (SgVarDeclStmt* vds = isSgVarDeclStmt(declStmt))
+                for (SgExpression* exp = varList; exp; exp = exp->rhs())
-            vds->setVariant(VAR_DECL_90);
+                {
-
+                    SgExpression* varExp = exp->lhs();
-        declStmt->setFileName(funcStart->fileName());
+                    SgSymbol* sym = extractSymbol(varExp);
-        declStmt->setFileId(funcStart->getFileId());
+                    if (sym)
-        declStmt->setProject(funcStart->getProject());
+                    {
-        declStmt->setlineNumber(getNextNegativeLineNumber());
+                        varRefs.push_back(new SgVarRefExp(sym));
-
+                    }
-        insertAfter->insertStmtAfter(*declStmt, *funcStart);
+                }
-        insertAfter = declStmt;
+            }
-        statementsToRemove.insert(declStmt);
+            else
+            {
+                for (SgExpression* varExp = varList; varExp; varExp = varExp->rhs())
+                {
+                    SgSymbol* sym = extractSymbol(varExp);
+                    if (sym)
+                    {
+                        varRefs.push_back(new SgVarRefExp(sym));
+                    }
+                }
+            }
+        }
     }
 
     if (!commonList)
     {
+        current = funcStart->lexNext();
+        while (current != funcEnd && current)
+        {
+            if (current->variant() == COMM_STAT)
+            {
+                commonStat = current;
+                break;
+            }
+            current = current->lexNext();
+        }
+
         SgSymbol* commonSymbol = new SgSymbol(COMMON_NAME, commonBlockName.c_str());
-        commonList = new SgExpression(COMM_LIST, varList, NULL, commonSymbol);
+        commonList = new SgExpression(COMM_LIST, NULL, NULL, commonSymbol);
 
-        commonStat = new SgStatement(COMM_STAT);
+        if (commonStat)
-        commonStat->setFileName(funcStart->fileName());
+        {
-        commonStat->setFileId(funcStart->getFileId());
+            SgExpression* lastCommList = commonStat->expr(0);
-        commonStat->setProject(funcStart->getProject());
+            if (lastCommList)
-        commonStat->setlineNumber(getNextNegativeLineNumber());
+            {
-        commonStat->setExpression(0, commonList);
+                while (lastCommList->rhs())
+                    lastCommList = lastCommList->rhs();
+                lastCommList->setRhs(commonList);
+            }
+            else
+            {
+                commonStat->setExpression(0, commonList);
+            }
+        }
+        else
+        {
+            commonStat = new SgStatement(COMM_STAT);
+            commonStat->setFileName(declPlace->fileName());
+            commonStat->setFileId(declPlace->getFileId());
+            commonStat->setProject(declPlace->getProject());
+            commonStat->setlineNumber(getNextNegativeLineNumber());
+            commonStat->setExpression(0, commonList);
+
+            declPlace->insertStmtBefore(*commonStat, *declPlace->controlParent());
+        }
 
-        SgStatement* lastDecl = FindLastDeclStatement(funcStart);
-        lastDecl->insertStmtAfter(*commonStat, *funcStart);
-        statementsToRemove.insert(commonStat);
     }
-    else
+    varRefs.push_back(new SgVarRefExp(varSymbol));
+
+    if (varRefs.size() > 0)
     {
+        std::reverse(varRefs.begin(), varRefs.end());
+        SgExpression* varList = makeExprList(varRefs, false);
+
         commonList->setLhs(varList);
     }
 
+    return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
 }
 
 static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber) 
 {
     if (!exp)
+    {
         return;
+    }
+
     vector<SgExpression*> subnodes = { exp->lhs(), exp->rhs() };
 
     string expUnparsed;
     SgExpression* toAdd = NULL;
     if (exp->variant() == ARRAY_REF && CheckConstIndexes(exp->lhs()))
     {
-        expUnparsed = exp->unparse();
+        cout << st->unparse() << endl;
         if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
         {
             arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());  
         }
-        positionsToAdd.insert(declPlace);
+        st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
-        SgSymbol* builder = arrayToVariable[expUnparsed]->symbol();
-        auto* sym = new SgSymbol(builder->variant(), builder->identifier(), builder->type(), st->controlParent());
-        auto* newVarExp = new SgVarRefExp(sym);
-        expToChange[st->fileName()].push_back({ st , st->copyPtr() });
-        st->setExpression(1, newVarExp);
         return;
     }
     for (int i = 0; i < 2; i++)
@@ -212,29 +200,26 @@ static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map
         {
             expUnparsed = subnodes[i]->unparse();
             if (arrayToVariable.find(expUnparsed) == arrayToVariable.end())
-                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());
+            {                
-
+                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());;
-            positionsToAdd.insert(declPlace);
+            }
-            SgSymbol* builder = arrayToVariable[expUnparsed]->symbol();
+            toAdd = arrayToVariable[expUnparsed]->copyPtr();
-            auto* sym = new SgSymbol(builder->variant(), builder->identifier(), builder->type(), st->controlParent());
-            toAdd = new SgVarRefExp(sym);
             if (toAdd)
             {
                 if (i == 0)
                 {
-                    expToChange[st->fileName()].push_back({ st , st->copyPtr() });;
                     exp->setLhs(toAdd);
                 }
                 else
                 {
-                    expToChange[st->fileName()].push_back({ st , st->copyPtr() });;
                     exp->setRhs(toAdd);
                 }
             }
         }
         else
+        {
             TransformRightPart(st, subnodes[i], arrayToVariable, variableNumber);
-        
+        }
     }
 }
 
@@ -242,14 +227,11 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
 {
     if (exp->symbol()->type()->variant() == T_STRING)
         return;
-    if (changed.find(st) != changed.end())
-        return;
     string expUnparsed = exp->unparse();
     if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
     {
         arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
     }
-    positionsToAdd.insert(declPlace);
     SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);
 
     newStatement->setFileId(st->getFileId());
@@ -258,59 +240,6 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
     newStatement->setlineNumber(getNextNegativeLineNumber());
     newStatement->setLocalLineNumber(st->lineNumber());
     st->insertStmtBefore(*newStatement, *st->controlParent());
-    changed.insert(st);
-    statementsToRemove.insert(newStatement);
-}
-
-static void TransformBorder(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
-{
-    SgStatement* firstStatement = declPlace->lexPrev();
-    st = st->lexPrev();
-    string array = exp->unparse();
-    if (arrayToVariable.find(array) == arrayToVariable.end())
-        arrayToVariable[array] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
-    while (st != firstStatement)
-    {
-        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
-        {
-            if (st->expr(1))
-            {
-                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-            }
-            if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()) && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
-                TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
-        }
-        st = st->lexPrev();
-    }
-}
-
-static void CheckVariable(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
-{
-    SgStatement* firstStatement = declPlace->lexPrev();
-    st = st->lexPrev();
-    string varName = exp->unparse();
-    while (st != firstStatement)
-    {
-        if (st->variant() == ASSIGN_STAT && st->expr(0)->symbol() == exp->symbol())
-        {
-            TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-            positionsToAdd.insert(declPlace);
-        }
-        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
-        {
-            if (st->expr(1))
-            {
-                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-                positionsToAdd.insert(declPlace);
-            }
-            if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()) && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
-            {
-                TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
-                positionsToAdd.insert(declPlace);
-            }
-        }
-        st = st->lexPrev();
-    }
 }
 
 void ArrayConstantPropagation(SgProject& project) 
@@ -323,7 +252,7 @@ void ArrayConstantPropagation(SgProject& project)
 
         if (!file)
             continue;
-        SgFile::switchToFile(file->filename());
+
         const int funcNum = file->numberOfFunctions();
         for (int i = 0; i < funcNum; ++i)
         {
@@ -333,48 +262,40 @@ void ArrayConstantPropagation(SgProject& project)
 
             for (; st != lastNode; st = st->lexNext())
             {
-                if (st->variant() == FOR_NODE)
+                if (st->variant() == ASSIGN_STAT)
+                {
+                    if (st->expr(1))
+                    {
+                        TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+                    }
+                    if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()))
+                    {
+                        TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
+                    }
+                }
+                else if (st->variant() == FOR_NODE)
                 {
                     SgExpression* lowerBound = st->expr(0)->lhs();
                     SgExpression* upperBound = st->expr(0)->rhs();
-                    SgStatement* boundCopy = NULL;
                     string lowerBoundUnparsed = lowerBound->unparse(), upperBoundUnparsed = upperBound->unparse();
                     if (upperBound->variant() == ARRAY_REF && upperBound->symbol()->type()->baseType() && CheckConstIndexes(upperBound->lhs()))
                     {
-                        boundCopy = st->copyPtr();
+                        if (arrayToVariable.find(upperBoundUnparsed) == arrayToVariable.end())
-                        TransformBorder(st, upperBound, arrayToVariable, variableNumber);
+                        {
+                            arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
+                        }
                         st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
-                        expToChange[st->fileName()].push_back({ st ,boundCopy });;
-                        positionsToAdd.insert(declPlace);
                     }
-                    else if (upperBound->variant() == VAR_REF)
-                        CheckVariable(st, upperBound, arrayToVariable, variableNumber);
-
                     if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
                     {
-                        boundCopy = st->copyPtr();
+                        if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
-                        TransformBorder(st, lowerBound, arrayToVariable, variableNumber);
+                        {
+                            arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
+                        }
                         st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
-                        expToChange[st->fileName()].push_back({ st , boundCopy });;
-                        positionsToAdd.insert(declPlace);
                     }
-                    else if (lowerBound->variant() == VAR_REF)
-                        CheckVariable(st, lowerBound, arrayToVariable, variableNumber);
                 }
             }
         }
     }
-    unordered_set<SgStatement*> funcStarts;
-    for (SgStatement* st : positionsToAdd)
-    {
-        SgFile::switchToFile(st->fileName());
-        SgStatement* scope = st->controlParent();
-        if (scope)
-            funcStarts.insert(scope);
-    }
-    for (const auto& st : funcStarts)
-    {
-        SgFile::switchToFile(st->fileName());
-        InsertCommonAndDeclsForFunction(st, variablesToAdd);
-    }
 }

src/ArrayConstantPropagation/propagation.h

@@ -1,20 +1,4 @@
 #pragma once
 #include "../Utils/SgUtils.h"
 
-#include <string>
-#include <vector>
-
-using namespace std;
-
-struct ExprRestoreEntry
-{
-    enum Kind { kStatementExpr, kExprChild };
-    Kind kind;
-    SgStatement* stmt;
-    int stmtExprIndex;
-    SgExpression* parent;
-    bool childIsRhs;
-    SgExpression* savedCopy;
-};
-
 void ArrayConstantPropagation(SgProject& project);

src/CreateInterTree/CreateInterTree.cpp

@@ -17,7 +17,7 @@ using std::fstream;
 static long int getNextTag()
 {
     static long int INTERVAL_TAG = 0;
-    return -(INTERVAL_TAG++);
+    return INTERVAL_TAG++;
 }
 
 //Debug funcs
@@ -413,7 +413,7 @@ static void findIntervals(SpfInterval *interval, map<int, int> &labelsRef, map<i
         inter->lineFile = std::make_pair(currentSt->lineNumber(), currentSt->fileName());
         inter->parent = interval;
         inter->exit_levels.push_back(0);
-        inter->tag = currentSt->lineNumber();//getNextTag();
+        inter->tag = getNextTag();
         interval->nested.push_back(inter);
 
         findIntervals(inter, labelsRef, gotoStmts, currentSt);

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/GraphCall/graph_calls.cpp

@@ -723,7 +723,7 @@ static void fillIn(FuncInfo *currF, SgExpression *ex, const map<string, int> &pa
 {
     if (ex)
     {
-        if (!isInFuncPar && (ex->variant() == VAR_REF || ex->variant() == ARRAY_REF))
+        if (!isInFuncPar && (ex->variant() == VAR_REF || isArrayRef(ex)))
         {
             const char *name = ex->symbol()->identifier();
             if (name && name != string(""))
@@ -800,58 +800,29 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
 
     static map<string, vector<int>> supportedKeyWordArg = { {"system_clock", { OUT_BIT, OUT_BIT, OUT_BIT } } };
 
-    map<string, int> parNamesMain;
+    map<string, int> parNames;
-    map<string, int> parNamesContains;
 
     for (int i = 0; i < currF->funcParams.identificators.size(); ++i)
-        parNamesMain[currF->funcParams.identificators[i]] = i;
+        parNames[currF->funcParams.identificators[i]] = i;
 
-    map<string, int>& parNames = parNamesMain;
-
-    bool isContainsFunctions = false;
     for (auto st = start; st != last; st = st->lexNext())
     {
-        if (st->variant() == CONTAINS_STMT) {
+        if (st->variant() == CONTAINS_STMT)
-            isContainsFunctions = true;
+            break;
-            continue;
-        }
-
-        if (isContainsFunctions) {
-            if (st->variant() == PROC_HEDR || st->variant() == FUNC_HEDR) {
-                parNamesContains = parNamesMain;
-                
-                SgProgHedrStmt* hedr = (SgProgHedrStmt*)st;
-
-                int numOfParams = hedr->numberOfParameters();
-                if (numOfParams > 0)
-                {
-                    for (int i = 0; i < numOfParams; ++i)
-                    {
-                        auto it = parNamesContains.find(hedr->parameter(i)->identifier());
-                        if (it != parNamesContains.end())
-                            parNamesContains.erase(it);
-                    }
-                }
-                parNames = parNamesContains;
-            }
-        }
 
         if (st->variant() == ENTRY_STAT)
             continue;
         
         if (isSgExecutableStatement(st) == NULL) {
-            if (!isContainsFunctions)
+            checkInTypeDescription(st->expr(0), currF, parNames);
-                checkInTypeDescription(st->expr(0), currF, parNames);
             continue;
         }
 
         if (st->lineNumber() <= 0)
             continue;
 
-        //XXX: use parameters removing in block ... isContainsFunctions ...
+        if (activeOps.size() && activeOps.find(st) == activeOps.end())
-        //TODO need to use IR for parameters checking
+            continue;
-        /*if (activeOps.size() && activeOps.find(st) == activeOps.end())
-            continue; */
 
         if (st->variant() == ASSIGN_STAT)
         {
@@ -880,7 +851,7 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
             for (auto ex = read->itemList(); ex; ex = ex->rhs())
             {
                 SgExpression* item = ex->lhs();
-                if (item && (item->variant() == VAR_REF || item->variant() == ARRAY_REF))
+                if (item->variant() == VAR_REF || isArrayRef(item))
                 {
                     string symb = "";
                     if (item->symbol())
@@ -901,7 +872,7 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
                         if (item->rhs())
                             queue.push(item->rhs());
 
-                        if (item->variant() == VAR_REF || item->variant() == ARRAY_REF)
+                        if (item->variant() == VAR_REF || isArrayRef(item))
                         {
                             string symb = "";
                             if (item->symbol())

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/PrivateAnalyzer/private_arrays_search.cpp

@@ -1,4 +1,3 @@
-#include <algorithm>
 #include <map>
 #include <unordered_set>
 #include <unordered_map>
@@ -7,26 +6,16 @@
 #include <numeric>
 #include <iostream>
 
-#include "ArrayConstantPropagation/propagation.h"
-#include "CFGraph/CFGraph.h"
-#include "Distribution/Array.h"
-#include "graph_loops.h"
 #include "private_arrays_search.h"
 #include "range_structures.h"
 #include "region.h"
 #include "SgUtils.h"
+#include "graph_loops.h"
+#include "CFGraph/CFGraph.h"
 #include "utils.h"
-#include "Utils/AstWrapper.h"
 
 using namespace std;
 
-extern std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>> declaredArrays;
-
-extern unordered_set<SgStatement*> statementsToRemove;
-extern unordered_map<string, vector<pair<SgStatement*, SgStatement*>>> expToChange;
-
-static unordered_set<Region*> collapsed;
-
 static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
 {
     ArrayAccessingIndexes resultContainer;
@@ -41,9 +30,10 @@ static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
                 points.push_back(arrayPoint);
         }
 
-        if (!points.empty())
+        if (points.size() < accessingSet.GetElements().size() && !points.empty())
             resultContainer[arrayName] = points;
-        else
+
+        if (points.empty())
             toRemove.insert(arrayName);
     }
 
@@ -59,81 +49,41 @@ static void Collapse(Region* region)
     if (region->getBasickBlocks().empty())
         return;
 
-    bool firstRegion = true;
+    for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out)
-    for (Region* basickBlock : region->getBasickBlocks())
     {
-        if (basickBlock->getNextRegions().empty())
+        for (Region* byBlock : region->getBasickBlocks())
         {
-            if (firstRegion)
+            AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges);
-            {
+            region->array_def[arrayName] = region->array_def[arrayName].Union(intersection);
-                region->array_def = basickBlock->array_out;
-                firstRegion = false;
-            }
-            else
-            {
-                unordered_set<string> toErease;
-                for (auto& [arrayName, arrayRanges] : region->array_def)
-                {
-                    if (basickBlock->array_out.find(arrayName) != basickBlock->array_out.end())
-                        arrayRanges = arrayRanges.Intersect(basickBlock->array_out[arrayName]);
-                    else
-                    {
-                        arrayRanges = AccessingSet();
-                        toErease.insert(arrayName);
-                    }
-                }
-                for (string arrayName : toErease)
-                    region->array_def.erase(arrayName);
-            }
         }
     }
 
-    RegionInstruction instruction;
-    instruction.def = move(region->array_def);
-
-
     for (auto& byBlock : region->getBasickBlocks()) 
     {
-        for (auto& instruction : byBlock->instructions)
+        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
         {
-            for (auto& [arrayName, _] : instruction.use)
+            AccessingSet diff = byBlock->array_use[arrayName].Diff(byBlock->array_in[arrayName]);
-            {
+            region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
-                AccessingSet diff = instruction.use[arrayName].Diff(instruction.in[arrayName]);
-                region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
-            }
         }
     }
 
-    ArrayAccessingIndexes useUnionB;
+    ArrayAccessingIndexes useUnion;
     for (auto& byBlock : region->getBasickBlocks())
-        for (auto& instruction : byBlock->instructions)
+        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
-            for (auto& [arrayName, _] : instruction.use)
+            useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
-                useUnionB[arrayName] = useUnionB[arrayName].Union(instruction.use[arrayName]);
 
-    for (auto& [arrayName, _] : useUnionB)
+    region->array_priv = region->array_use;
-        region->array_priv[arrayName] = useUnionB[arrayName].Diff(region->array_use[arrayName]);
-
-    instruction.use = move(region->array_use);
     
     for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
-    {
         prevBlock->replaceInNextRegions(region, region->getHeader());
-        region->addPrevRegion(prevBlock);
-    }
     
     for (Region* nextBlock : region->getHeader()->getNextRegions())
-    {
         nextBlock->replaceInPrevRegions(region, region->getHeader());
-        region->addNextRegion(nextBlock);
-    }
-    region->instructions.push_back(instruction);
-
 }
 
 static void SolveDataFlowIteratively(Region* DFG) 
 {
-    auto blocks = DFG->getBasickBlocks();
+    unordered_set<Region*> worklist(DFG->getBasickBlocks());
-    std::unordered_set<Region*> worklist(blocks.begin(), blocks.end());
     do
     {
         Region* b = *worklist.begin();
@@ -151,7 +101,7 @@ static void SolveDataFlowIteratively(Region* DFG)
                 if (prevBlock->array_out.empty())
                 {
                     newIn.clear();
-                    break;
+                    continue;
                 }
 
                 for (const auto& [arrayName, accessSet] : prevBlock->array_out)
@@ -187,192 +137,21 @@ static void SolveDataFlowIteratively(Region* DFG)
             b->array_out = newOut;
         else
             worklist.erase(b);
-    } while (!worklist.empty());
-}
-
-static void SolveForBasickBlock(Region* block)
-{
-    ArrayAccessingIndexes newIn;
-    bool flagFirst = true;
-    for (Region* prevBlock : block->getPrevRegions())
-    {
-        if (flagFirst)
-        {
-            newIn = prevBlock->array_out;
-            flagFirst = false;
-        }
-        else
-        {
-            if (prevBlock->array_out.empty())
-            {
-                newIn.clear();
-                break;
-            }
-
-            for (const auto& [arrayName, accessSet] : prevBlock->array_out)
-            {
-                if (newIn.find(arrayName) != newIn.end())
-                    newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
-                else
-                    newIn[arrayName] = AccessingSet();
-            }
-        }
-    }
-
-    if (block->instructions.empty())
-        block->instructions.push_back(RegionInstruction());
-
-    block->instructions[0].in = move(newIn);
-
-    for (int i = 0; i < block->instructions.size(); i++)
-    {
-        auto& instruction = block->instructions[i];
-
-        if (i > 0)
-            instruction.in = block->instructions[i - 1].out;
-
-        ArrayAccessingIndexes newOut;
-        if (instruction.def.empty())
-            newOut = instruction.in;
-        else if (instruction.in.empty())
-            newOut = instruction.def;
-        else
-        {
-            for (auto& [arrayName, accessSet] : instruction.def)
-            {
-                if (instruction.in.find(arrayName) != instruction.in.end())
-                    newOut[arrayName] = instruction.def[arrayName].Union(instruction.in[arrayName]);
-                else
-                    newOut[arrayName] = accessSet;
-            }
-            for (auto& [arrayName, accessSet] : instruction.in)
-            {
-                if (newOut.find(arrayName) == newOut.end())
-                {
-                    newOut[arrayName] = accessSet;
-                }
-            }
-        }
-
-        instruction.out = move(newOut);
-    }
-    if (!block->instructions.empty())
-        block->array_out = block->instructions.back().out;
-}
-
-static void SolveDataFlowTopologically(Region* DFG)
-{
-    for (Region* b : DFG->getBasickBlocks())
-    {
-        collapsed.insert(b);
-        SolveForBasickBlock(b);
     } 
+    while (!worklist.empty());
 }
 
 static void SolveDataFlow(Region* DFG)
 {
     if (!DFG)
         return;
+
+    SolveDataFlowIteratively(DFG);
     for (Region* subRegion : DFG->getSubRegions())
-    {
         SolveDataFlow(subRegion);
-        DFG->addBasickBlocks(subRegion);
-    }
-    vector<Region*>& blocks = DFG->getBasickBlocks();
-    auto pos = remove_if(blocks.begin(), blocks.end(), [](Region* r) { return collapsed.find(r) != collapsed.end(); });
-    blocks.erase(pos, blocks.end());
-    TopologySort(DFG->getBasickBlocks(), DFG->getHeader());
-    SolveDataFlowTopologically(DFG);
     Collapse(DFG);
 }
 
-static bool getArrayDeclaredDimensions(SgArrayRefExp* arrayRef, vector<uint64_t>& declaredDims)
-{
-    if (!arrayRef || !arrayRef->symbol() || !isSgArrayType(arrayRef->symbol()->type()))
-        return false;
-    SgArrayType* arrayType = (SgArrayType*)arrayRef->symbol()->type();
-    int dimCount = arrayType->dimension();
-    for (int i = 0; i < dimCount; i++)
-    {
-        SgExpression* sizeExpr = arrayType->sizeInDim(i);
-        SgConstantSymb* constValSymb = isSgConstantSymb(sizeExpr->symbol());
-        SgSubscriptExp* subscriptExpr = isSgSubscriptExp(sizeExpr);
-        uint64_t dimLength;
-        if (sizeExpr && sizeExpr->variant() == INT_VAL)
-            dimLength = stol(sizeExpr->unparse());
-        else if (constValSymb)
-            dimLength = stol(constValSymb->constantValue()->unparse());
-        else if (subscriptExpr)
-        {
-            dimLength = stol(subscriptExpr->rhs()->unparse()) - stol(subscriptExpr->lhs()->unparse());
-        }
-        else
-            return false;
-
-        if (dimLength == 0)
-            return false;
-        declaredDims.push_back(dimLength);
-    }
-    return true;
-}
-
-static DIST::Array* getDistArrayBySymbol(SgSymbol* arrSym)
-{
-    if (!arrSym)
-        return nullptr;
-    for (auto& [key, val] : declaredArrays)
-    {
-        DIST::Array* distArr = val.first;
-        if (!distArr)
-            continue;
-        Symbol* declSym = distArr->GetDeclSymbol();
-        if (!declSym)
-            continue;
-        SgSymbol* sgDecl = declSym->GetOriginal();
-        if (sgDecl && isEqSymbols(sgDecl, arrSym))
-            return distArr;
-    }
-    return nullptr;
-}
-
-static bool CheckDimensionLength(const AccessingSet& array)
-{
-    if (array.GetElements().empty())
-        return false;
-    size_t dimCount = array.GetElements()[0].size();
-    SgArrayRefExp* arrayRef = array.GetElements()[0][0].array;
-    if (!arrayRef || !arrayRef->symbol())
-        return false;
-
-    vector<uint64_t> declaredDims;
-    declaredDims.reserve(dimCount);
-
-    DIST::Array* distArr = getDistArrayBySymbol(arrayRef->symbol());
-    if (distArr && distArr->GetDimSize() == (int)dimCount)
-    {
-        const auto& sizes = distArr->GetSizes();
-        bool valid = true;
-        for (size_t i = 0; i < dimCount && valid; ++i)
-        {
-            int lo = sizes[i].first;
-            int hi = sizes[i].second;
-            if (lo > hi)
-                valid = false;
-            else
-                declaredDims.push_back((uint64_t)(hi - lo + 1));
-        }
-        if (valid && declaredDims.size() == dimCount)
-        {
-            vector<ArrayDimension> testArray(dimCount);
-            for (size_t i = 0; i < dimCount; i++)
-                testArray[i] = { 1, 1, declaredDims[i], nullptr };
-            return AccessingSet({ testArray }).Diff(array).GetElements().empty();
-        }
-    }
-
-    return false;
-}
-
 static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
 {
     SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
@@ -380,11 +159,8 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
     spfStat->setFileName(loop->loop->fileName());
     SgExpression* toAdd = new SgExpression(EXPR_LIST, new SgExpression(ACC_PRIVATE_OP), NULL, NULL);
     set<SgSymbol*> arraysToInsert;
-    std::cout << "First bp\n";
     for (const auto& [_, accessingSet] : privates)
     {
-        if (!CheckDimensionLength(accessingSet))
-            continue;
         for (const auto& arrayElement : accessingSet.GetElements())
         {
             if (arrayElement.empty())
@@ -412,14 +188,14 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
         toAdd->setLhs(new SgVarRefExp(elem));
     }
     
-    if (arraysToInsert.size() != 0)
+    if (arraysToInsert.size() == 0)
-    {
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-        loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
+
-        insertedPrivates.insert(spfStat);
+    loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
-    }
+    insertedPrivates.insert(spfStat);
 }
 
-void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*>& insertedPrivates)
+void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*> &insertedPrivates)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
     for (const auto& [fileName, loops] : loopGraph)
@@ -434,19 +210,11 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*
             while (search_func && (!isSgProgHedrStmt(search_func)))
                 search_func = search_func->controlParent();
 
-            for (const auto& [funcInfo, blocks] : FullIR)
+            for (const auto& [funcInfo, blocks]: FullIR)
             {   
                 if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
                 {
-                    Region* loopRegion;
+                    Region* loopRegion = new Region(loop, blocks);
-                    try
-                    {
-                        loopRegion = new Region(loop, blocks);
-                    }
-                    catch (...)
-                    {
-                        continue;
-                    }
                     if (loopRegion->getBasickBlocks().size() <= 1)
                     {
                         delete(loopRegion);
@@ -458,24 +226,9 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*
                     delete(loopRegion);
                 }
             }
+
             if (result.find(loop) != result.end() && !result[loop].empty())
                 AddPrivateArraysToLoop(loop, result[loop], insertedPrivates);
         }
     }
-
-    for (SgStatement* st : statementsToRemove)
-    {
-        SgFile::switchToFile(st->fileName());
-        st->deleteStmt();
-    }
-
-    for (auto& [filename, statements] : expToChange)
-    {
-        SgFile::switchToFile(filename);
-        for (auto& [statement, statementCopy] : statements) 
-        {
-            statement->insertStmtBefore(*statementCopy, *statement->controlParent());
-            statement->deleteStmt();
-        }
-    }
 }

src/PrivateAnalyzer/range_structures.cpp

@@ -47,7 +47,7 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
     
     uint64_t start3 = dim1.start + x0 * dim1.step;
     uint64_t step3 = c * dim1.step;
-    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array };
+    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array};
     return result;
 }
 
@@ -61,7 +61,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
     vector<ArrayDimension> result;
     /* add the part before intersection */
     if (dim1.start < intersection->start)    
-        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array });
+        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array});
     
     /* add the parts between intersection steps */
     if (intersection->step > dim1.step)
@@ -70,7 +70,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
         uint64_t interValue = intersection->start;
         for (int64_t i = start; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
         {
-            result.push_back({ interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array });
+            result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
             interValue += intersection->step;
         }
     }
@@ -132,10 +132,8 @@ static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>&
 static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimension>& firstElement,
     const vector<ArrayDimension>& secondElement)
 {
-    if (firstElement.empty())
+    if (firstElement.empty() || secondElement.empty())
         return {};
-    if (secondElement.empty())
-        return { firstElement };
     
     vector<ArrayDimension> intersection = ElementsIntersection(firstElement, secondElement);
     vector<vector<ArrayDimension>> result;
@@ -190,7 +188,7 @@ bool AccessingSet::ContainsElement(const vector<ArrayDimension>& element) const
 {
     vector<vector<ArrayDimension>> tails;
     FindUncovered(element, tails);
-    return tails.empty();
+    return !tails.empty();
 }
 
 void AccessingSet::FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const
@@ -254,15 +252,13 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const
         return *this;
 
     AccessingSet intersection = this->Intersect(secondSet);
-    vector<vector<ArrayDimension>> uncovered;
+    AccessingSet uncovered = *this;
-    for (const auto& element : allElements)
+    vector<vector<ArrayDimension>> result;
+    for (const auto& element : intersection.GetElements())
     {
         vector<vector<ArrayDimension>> current_uncovered;
-        intersection.FindUncovered(element, current_uncovered);
+        uncovered.FindUncovered(element, current_uncovered);
-        uncovered.insert(uncovered.end(),
+        uncovered = AccessingSet(current_uncovered);
-            std::move_iterator(current_uncovered.begin()),
-            std::move_iterator(current_uncovered.end())
-        );
     }
     return uncovered;
 }

src/PrivateAnalyzer/region.cpp

@@ -1,14 +1,14 @@
-#include <algorithm>
+#include<vector>
-#include <vector>
+#include<map>
-#include <map>
+#include<unordered_set>
-#include <unordered_set>
+#include<unordered_map>
-#include <unordered_map>
+#include<string>
-#include <string>
 #include <numeric>
 #include <iostream>
 
 #include "range_structures.h"
 #include "region.h"
+
 #include "SgUtils.h"
 
 using namespace std;
@@ -93,7 +93,7 @@ static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, Loop
     return "";
 }
 
-static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use, Region* region) {
+static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use) {
     auto instructions = block->getInstructions();
     map<string, LoopGraph*> loopForIndex;
     BuildLoopIndex(loopForIndex, loop);
@@ -123,11 +123,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                     }
 
                     if (point.size() == dimCount)
-                    {
+                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({point});
-                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({ point });
-                        RegionInstruction regionInstruction;
-                        regionInstruction.def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({ point });
-                    }
                 }
             }
         }
@@ -150,31 +146,15 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
             vector<ArrayDimension> accessPoint(n);
 
             auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
-            if (!ref)
-                continue;
             int fillCount = 0;
 
-            vector<pair<int, int>> coeffsForDims;
+            while (!index_vars.empty() && !refPos.empty())
-            int subs = ref->numberOfSubscripts();
-            for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
-            {
-                const vector<int*>& coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
-                if (coeffs.size() == 1)
-                {
-                    const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
-                    coeffsForDims.push_back(coef);
-                }
-
-            }
-            coeffsForDims = { coeffsForDims.rbegin(), coeffsForDims.rend() };
-
-            while (!index_vars.empty() && !refPos.empty() && !coeffsForDims.empty())
             {
                 auto var = index_vars.back();
                 int currentVarPos = refPos.back();
                 ArrayDimension current_dim;
                 if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
-                    current_dim = { stoul(var->getValue()), 1, 1, ref };
+                    current_dim = { stoul(var->getValue()), 1, 1, ref};
                 else
                 {
                     string name, full_name = var->getValue();
@@ -200,42 +180,27 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                             return -1;
                     }
 
-                    uint64_t start = coeffsForDims.back().second * currentLoop->startVal + coeffsForDims.back().first;
+                    uint64_t start = currentLoop->startVal;
                     uint64_t step = currentLoop->stepVal;
                     uint64_t iters = currentLoop->calculatedCountOfIters;
                     current_dim = { start, step, iters, ref };
                 }
 
-                if (current_dim.step != 0 && current_dim.tripCount != 0)
+                if (current_dim.start != 0 && current_dim.step != 0 && current_dim.tripCount != 0)
                 {
                     accessPoint[n - index_vars.size()] = current_dim;
                     fillCount++;
                 }
                 index_vars.pop_back();
                 refPos.pop_back();
-                coeffsForDims.pop_back();
             }
 
             if (fillCount == accessPoint.size())
             {
-                RegionInstruction instruction;
                 if (operation == SAPFOR::CFG_OP::STORE)
-                {
                     def[array_name].Insert(accessPoint);
-                    instruction.def[array_name] = { { accessPoint } };
-                }
                 else
-                {
+                    use[array_name].Insert(accessPoint);
-                    instruction.use[array_name] = { { accessPoint } };
-                    if (def.find(array_name) == def.end())
-                        use[array_name].Insert(accessPoint);
-                    else
-                    {
-                        AccessingSet element({ accessPoint });
-                        use[array_name] = use[array_name].Union(element.Diff(def[array_name]));
-                    }
-                }
-                region->instructions.push_back(instruction);
             }
         }
     }
@@ -243,58 +208,6 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
 
 }
 
-static void RemoveHeaderConnection(SAPFOR::BasicBlock* header, const unordered_set<SAPFOR::BasicBlock*>& blockSet, unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
-{
-    for (SAPFOR::BasicBlock* block : blockSet)
-    {
-        bool isCycleBlock = false;
-        for (SAPFOR::BasicBlock* prevBlock : block->getPrev())
-            isCycleBlock = isCycleBlock || (blockSet.find(prevBlock) != blockSet.end());
-
-        if (isCycleBlock)
-        {
-            bbToRegion[block]->removeNextRegion(bbToRegion[header]);
-            bbToRegion[header]->removePrevRegion(bbToRegion[block]);
-        }
-    }
-}
-
-static void DFS(Region* block, vector<Region*>& result, unordered_set<Region*> cycleBlocks)
-{
-    for (Region* nextBlock : block->getNextRegions())
-    {
-        if (cycleBlocks.find(nextBlock) != cycleBlocks.end())
-            DFS(nextBlock, result, cycleBlocks);
-    }
-    result.push_back(block);
-}
-
-bool HasCycle(Region* block, const std::unordered_set<Region*>& cycleBlocks, std::unordered_set<Region*>& visitedBlocks)
-{
-    if (visitedBlocks.find(block) != visitedBlocks.end())
-        return true;
-    visitedBlocks.insert(block);
-    for (Region* nextBlock : block->getNextRegions())
-    {
-        if (cycleBlocks.find(nextBlock) != cycleBlocks.end() && HasCycle(nextBlock, cycleBlocks, visitedBlocks))
-            return true;
-    }
-    return false;
-}
-
-bool TopologySort(std::vector<Region*>& basikBlocks, Region* header)
-{
-    unordered_set<Region*> cycleBlocks(basikBlocks.begin(), basikBlocks.end());
-    unordered_set<Region*> visitedBlocks;
-    if (HasCycle(header, cycleBlocks, visitedBlocks))
-        return false;
-    vector<Region*> result;
-    DFS(header, result, cycleBlocks);
-    reverse(result.begin(), result.end());
-    basikBlocks = move(result);
-    return true;
-}
-
 static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
 {
     for (SAPFOR::BasicBlock* block : blockSet)
@@ -309,11 +222,10 @@ static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegi
     }
 }
 
-static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
+static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, const unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
 {
     Region* region = new Region;
     auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
-    RemoveHeaderConnection(header, blockSet, bbToRegion);
     if (bbToRegion.find(header) != bbToRegion.end())
         region->setHeader(bbToRegion.at(header));    
     else
@@ -332,8 +244,6 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
             continue;
         region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
     }
-    if (!TopologySort(region->getBasickBlocks(), region->getHeader()))
-        throw std::runtime_error("Unnoticed cycle");
     return region;
 }
 
@@ -344,20 +254,17 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
     for (auto poiner : blockSet)
     {
         bbToRegion[poiner] = new Region(*poiner);
-        this->basickBlocks.push_back(bbToRegion[poiner]);
+        this->basickBlocks.insert(bbToRegion[poiner]);
-        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use, bbToRegion[poiner]);
+        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use);
 
     }
     this->header = bbToRegion[header];
     SetConnections(bbToRegion, blockSet);
-    RemoveHeaderConnection(header, blockSet, bbToRegion);
     //create subRegions
     for (LoopGraph* childLoop : loop->children)
     {
         if (!childLoop->isFor())
             continue;
         subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
-        }
+    }
-    if (!TopologySort(basickBlocks, this->header))
-        throw std::runtime_error("Unnoticed cycle");
 }

src/PrivateAnalyzer/region.h

@@ -8,11 +8,6 @@
 #include "graph_loops.h"
 #include "CFGraph/CFGraph.h"
 
-struct RegionInstruction
-{
-    ArrayAccessingIndexes def, use, in, out;
-};
-
 class Region : public SAPFOR::BasicBlock {
 public:
     Region() { header = nullptr; }
@@ -25,25 +20,13 @@ public:
 
     void setHeader(Region* region) { header = region; }
 
-    std::vector<Region*>& getBasickBlocks() { return basickBlocks; }
+    std::unordered_set<Region*>& getBasickBlocks() { return basickBlocks; }
 
-    void addBasickBlocks(Region* region) { basickBlocks.push_back(region); }
+    void addBasickBlocks(Region* region) { basickBlocks.insert(region); }
 
     const std::unordered_set<Region*>& getPrevRegions() { return prevRegions; }
 
-    std::unordered_set<Region*>& getNextRegions() { return nextRegions; }
+    std::unordered_set<Region*> getNextRegions() { return nextRegions; }
-
-    void removeNextRegion(Region* region)
-    {
-        if (nextRegions.find(region) != nextRegions.end())
-            nextRegions.erase(region);
-    }
-
-    void removePrevRegion(Region* region)
-    {
-        if (prevRegions.find(region) != prevRegions.end())
-            prevRegions.erase(region);
-    }
 
     void addPrevRegion(Region* region) { prevRegions.insert(region); }
 
@@ -65,20 +48,13 @@ public:
 
     void addSubRegions(Region* region) { subRegions.insert(region); }
 
-    std::vector<RegionInstruction> instructions;
-
     ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv;
 
 private:
-    std::vector<Region*> basickBlocks;
+    std::unordered_set<Region*> subRegions, basickBlocks;
-    std::unordered_set<Region*> subRegions;
     /*next Region which is BB for current BB Region*/
     std::unordered_set<Region*> nextRegions;
     /*prev Regions which is BBs for current BB Region*/
     std::unordered_set<Region*> prevRegions;
     Region* header;
 };
-
-bool HasCycle(Region* block, const std::unordered_set<Region*>& cycleBlocks, std::unordered_set<Region*>& visitedBlocks);
-
-bool TopologySort(std::vector<Region*>& basikBlocks, Region* header);

src/Sapfor.cpp

@@ -1,4 +1,4 @@
-#include "Utils/leak_detector.h"
+#include "Utils/leak_detector.h"
 
 #pragma comment(linker, "/STACK:536870912") // 512 МБ
 
@@ -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"
@@ -943,7 +944,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
             }
         }
         else if (curr_regime == MOVE_OPERATORS)        
-            moveOperators(file, fullIR, countOfTransform);
+            moveOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -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/FunctionInlining/inliner.cpp

@@ -1089,8 +1089,6 @@ static int clean(const string& funcName, SgStatement* funcSt, const map<string,
             }
 
             SgGotoStmt* gotoSt = new SgGotoStmt(*contLab);
-            if (st->label())
-                gotoSt->setLabel(*st->label());
             st->insertStmtBefore(*gotoSt, *st->controlParent());
 
             toDelete.push_back(st);

src/Transformations/MoveOperators/move_operators.h

@@ -3,4 +3,4 @@
 #include "../../GraphLoop/graph_loops.h"
 #include "../../CFGraph/CFGraph.h"
 
-void moveOperators(SgFile* file, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);
+void moveOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -504,7 +504,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb,
     }
 }
 
-static bool ioRegionBorder(SgStatement* stat, SgStatement* last_io_bound)
+static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
 {
     auto var = stat->variant();
 
@@ -535,24 +535,14 @@ static bool ioRegionBorder(SgStatement* stat, SgStatement* last_io_bound)
     if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
         return true;
 
+    int parent_var;
+
     if (var == CONTROL_END && border_stats.find(stat->controlParent()->variant()) != border_stats.end())
         return true;
 
     return false;
 }
 
-FuncInfo* getCurrentFuncInfo(const vector<FuncInfo*>& fileFuncInfo, int line)
-{
-    for (auto* func : fileFuncInfo)
-    {
-        if (func->linesNum.first <= line && line <= func->linesNum.second)
-            return func;
-    }
-
-    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-    return NULL;
-}
-
 void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                   const map<string, vector<FuncInfo*>>& allFuncInfo,
                                   map<string, vector<Messages>>& SPF_messages,
@@ -572,8 +562,6 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
             if (SgFile::switchToFile(current_file_name) == -1)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            FuncInfo *current_func_info = NULL;
-
             auto func_info_it = allFuncInfo.find(current_file_name);
             if (func_info_it == allFuncInfo.end())
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -600,12 +588,13 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                 {
                     curr_stmt = lines.stats.first->GetOriginal();
                     end = lines.stats.second->GetOriginal()->lexNext();
-                    current_func_info = getCurrentFuncInfo(func_info_it->second, curr_stmt->lineNumber());
                 }
 
                 map<SgSymbol*, set<SgStatement*>> need_replace;
                 SgStatement* last_io_bound = NULL;
 
+                FuncInfo *current_func_info = NULL;
+
                 while (curr_stmt != end)
                 {
                     if (!curr_stmt)
@@ -615,7 +604,18 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
 
                     if (var == PROC_HEDR || var == PROG_HEDR || var == FUNC_HEDR)
                     {
-                        current_func_info = getCurrentFuncInfo(func_info_it->second, curr_stmt->lineNumber());
+                        current_func_info = NULL;
+                        for (auto *func_info : func_info_it->second)
+                        {
+                            if (func_info->funcName == curr_stmt->symbol()->identifier())
+                            {
+                                current_func_info = func_info;
+                                break;
+                            }
+                        }
+
+                        if (!current_func_info)
+                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
                         curr_stmt = curr_stmt->lexNext();
                         while (curr_stmt && !isSgExecutableStatement(curr_stmt))
@@ -628,7 +628,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                             break;
                     }
 
-                    if (ioRegionBorder(curr_stmt, last_io_bound))
+                    if (ioReginBorder(curr_stmt, last_io_bound))
                     {
                         for (const auto& by_array_to_copy : need_replace)
                         {

src/Utils/PassManager.h

@@ -318,7 +318,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE);
 
-    list({ ARRAY_PROPAGATION, CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
+    list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
     list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);
 
     list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);

src/Utils/SgUtils.cpp

@@ -577,20 +577,10 @@ string removeIncludeStatsAndUnparse(SgFile *file, const char *fileName, const ch
                 for (auto& incl : inclByPos.second)
                     inlcude += (renameIncludes ? renameInclude(incl) : incl);
 
-            //check inserted operators
+            if (st->comments())
-            SgStatement* toInsert = st;
+                st->setComments((inlcude + st->comments()).c_str());
-            do {
-                auto lexPrev = toInsert->lexPrev();
-                if (lexPrev && lexPrev->variant() > 0 && lexPrev->lineNumber() < 0)
-                    toInsert = lexPrev;
-                else
-                    break;                
-            } while (true);
-
-            if (toInsert->comments())
-                toInsert->setComments((inlcude + toInsert->comments()).c_str());
             else
-                toInsert->addComment(inlcude.c_str());
+                st->addComment(inlcude.c_str());
         }
     }
 
@@ -658,7 +648,7 @@ string removeIncludeStatsAndUnparse(SgFile *file, const char *fileName, const ch
 
                 if (wasDeleted)
                 {
-                    if (str.size() && str.back() != '\n')
+                    if (str.size() || str.back() != '\n')
                         str += '\n';
                     st->setComments(str.c_str());
                 }

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/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 "2476"
+#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__);