libpredict_integration: fix signatures

.gitignore

@@ -78,4 +78,3 @@ Sapfor/Sapc++/x64/
 
 Sapfor/out/
 Sapfor/_bin/*
-_bin/*

CMakeLists.txt

@@ -163,10 +163,6 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
         src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
         src/ParallelizationRegions/resolve_par_reg_conflicts.h)
 
-set(ARRAY_PROP src/ArrayConstantPropagation/propagation.cpp
-	src/ArrayConstantPropagation/propagation.h	
-)
-
 set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
         src/Transformations/DeadCodeRemoving/dead_code.h)
 set(TR_CP src/Transformations/CheckPoints/checkpoints.cpp
@@ -207,9 +203,7 @@ set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_gr
 set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
         src/Transformations/FunctionInlining/inliner.h)
 set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
-        src/Transformations/RenameSymbols/rename_symbols.h)
+                    src/Transformations/RenameSymbols/rename_symbols.h)
-SET(TR_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
-        src/Transformations/MoveOperators/move_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -232,8 +226,7 @@ set(TRANSFORMS
         ${TR_REPLACE_ARRAYS_IN_IO}
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS}
+        ${TR_RENAME_SYMBOLS})
-        ${TR_MOVE_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -338,7 +331,9 @@ set(MAIN src/Sapfor.cpp
         src/Utils/PassManager.h)
 
 set(PREDICTOR src/Predictor/PredictScheme.cpp
-              src/Predictor/PredictScheme.h)
+              src/Predictor/PredictScheme.h
+              src/Predictor/PredictSchemeWithLibrary.cpp
+              src/Predictor/PredictSchemeWithLibrary.h)
               
 set(LIBPREDICTOR  ${libpred_sources}/cluster.cpp
                   ${libpred_sources}/predictor.cpp
@@ -427,7 +422,6 @@ set(SOURCE_EXE
     ${TRANSFORMS}
     ${PARALLEL_REG}
     ${PRIV}
-    ${ARRAY_PROP}
     ${FDVM}
     ${OMEGA}
     ${UTILS}
@@ -467,7 +461,6 @@ source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
-source_group (Transformations\\MoveOperators FILES ${TR_MOVE_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -480,7 +473,6 @@ source_group (GraphLoop FILES ${GR_LOOP})
 source_group (LoopAnalyzer FILES ${LOOP_ANALYZER})
 source_group (ParallelizationRegions FILES ${PARALLEL_REG})
 source_group (PrivateAnalyzer FILES ${PRIV})      
-source_group (ArrayConstantPropagation FILES ${ARRAY_PROP})      
 source_group (FDVM_Compiler FILES ${FDVM})
 source_group (SageExtension FILES ${OMEGA})
 source_group (Utils FILES ${UTILS})

src/ArrayConstantPropagation/propagation.cpp

@@ -1,301 +0,0 @@
-#include "propagation.h"
-
-#include "../Utils/SgUtils.h"
-
-#include <iostream>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-using namespace std;
-
-static SgStatement* declPlace = NULL;
-
-static bool CheckConstIndexes(SgExpression* exp)
-{
-    if (!exp)
-    {
-        return true;
-    }
-    SgExpression* lhs = exp->lhs();
-    SgExpression* rhs = exp->rhs();
-    do
-    {
-        if (lhs->variant() != INT_VAL)
-        {
-            return false;
-        }
-        if (rhs)
-        {
-            lhs = rhs->lhs();
-            rhs = rhs->rhs();
-        }
-    } while (rhs);
-    return true;
-}
-
-static SgExpression* CreateVar(int& variableNumber, SgType* type)
-{
-    string varName = "__tmp_prop_var";
-    string name = varName + std::to_string(variableNumber) + "__";
-    variableNumber++;
-
-    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *declPlace->controlParent());
-
-    const string commonBlockName = "__propagation_common__";
-
-    SgStatement* funcStart = declPlace->controlParent();
-    SgStatement* commonStat = NULL;
-    SgExpression* commonList = NULL;
-
-    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
-    SgStatement* current = funcStart->lexNext();
-
-    while (current != funcEnd && current)
-    {
-        if (current->variant() == COMM_STAT)
-        {
-            for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
-            {
-                if (exp->variant() == COMM_LIST)
-                {
-                    string existingName = exp->symbol() ?
-                        string(exp->symbol()->identifier()) :
-                        string("spf_unnamed");
-                    if (existingName == commonBlockName)
-                    {
-                        commonStat = current;
-                        commonList = exp;
-                        break;
-                    }
-                }
-            }
-            if (commonStat)
-                break;
-        }
-        current = current->lexNext();
-    }
-
-    vector<SgExpression*> varRefs;
-    if (commonList)
-    {
-        SgExpression* varList = commonList->lhs();
-        if (varList)
-        {
-            auto extractSymbol = [](SgExpression* exp) -> SgSymbol* {
-                if (!exp) 
-                    return NULL;
-                if (exp->symbol()) 
-                    return exp->symbol();
-                if (exp->lhs() && exp->lhs()->symbol())
-                    return exp->lhs()->symbol();
-                return NULL;
-                };
-            if (varList->variant() == EXPR_LIST)
-            {
-                for (SgExpression* exp = varList; exp; exp = exp->rhs())
-                {
-                    SgExpression* varExp = exp->lhs();
-                    SgSymbol* sym = extractSymbol(varExp);
-                    if (sym)
-                    {
-                        varRefs.push_back(new SgVarRefExp(sym));
-                    }
-                }
-            }
-            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, NULL, NULL, commonSymbol);
-
-        if (commonStat)
-        {
-            SgExpression* lastCommList = commonStat->expr(0);
-            if (lastCommList)
-            {
-                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());
-        }
-
-    }
-    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()))
-    {
-        cout << st->unparse() << endl;
-        if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
-        {
-            arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());  
-        }
-        st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
-        return;
-    }
-    for (int i = 0; i < 2; i++)
-    {
-        if (subnodes[i] && subnodes[i]->variant() == ARRAY_REF && subnodes[i]->symbol()->type()->baseType() && CheckConstIndexes(subnodes[i]->lhs()))
-        {
-            expUnparsed = subnodes[i]->unparse();
-            if (arrayToVariable.find(expUnparsed) == arrayToVariable.end())
-            {                
-                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());;
-            }
-            toAdd = arrayToVariable[expUnparsed]->copyPtr();
-            if (toAdd)
-            {
-                if (i == 0)
-                {
-                    exp->setLhs(toAdd);
-                }
-                else
-                {
-                    exp->setRhs(toAdd);
-                }
-            }
-        }
-        else
-        {
-            TransformRightPart(st, subnodes[i], arrayToVariable, variableNumber);
-        }
-    }
-}
-
-static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
-{
-    if (exp->symbol()->type()->variant() == T_STRING)
-        return;
-    string expUnparsed = exp->unparse();
-    if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
-    {
-        arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
-    }
-    SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);
-
-    newStatement->setFileId(st->getFileId());
-    newStatement->setProject(st->getProject()); 
-
-    newStatement->setlineNumber(getNextNegativeLineNumber());
-    newStatement->setLocalLineNumber(st->lineNumber());
-    st->insertStmtBefore(*newStatement, *st->controlParent());
-}
-
-void ArrayConstantPropagation(SgProject& project) 
-{
-    unordered_map<string, SgExpression*> arrayToVariable;
-    int variableNumber = 0;
-    for (int i = 0; i < project.numberOfFiles(); i++) 
-    {
-        SgFile* file = &(project.file(i));
-
-        if (!file)
-            continue;
-
-        const int funcNum = file->numberOfFunctions();
-        for (int i = 0; i < funcNum; ++i)
-        {
-            SgStatement* st = file->functions(i);
-            declPlace = st->lexNext();
-            SgStatement* lastNode = st->lastNodeOfStmt();
-
-            for (; st != lastNode; st = st->lexNext())
-            {
-                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();
-                    string lowerBoundUnparsed = lowerBound->unparse(), upperBoundUnparsed = upperBound->unparse();
-                    if (upperBound->variant() == ARRAY_REF && upperBound->symbol()->type()->baseType() && CheckConstIndexes(upperBound->lhs()))
-                    {
-                        if (arrayToVariable.find(upperBoundUnparsed) == arrayToVariable.end())
-                        {
-                            arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
-                        }
-                        st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
-                    }
-                    if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
-                    {
-                        if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
-                        {
-                            arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
-                        }
-                        st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
-                    }
-                }
-            }
-        }
-    }
-}

src/ArrayConstantPropagation/propagation.h

@@ -1,4 +0,0 @@
-#pragma once
-#include "../Utils/SgUtils.h"
-
-void ArrayConstantPropagation(SgProject& project);

src/CFGraph/private_variables_analysis.cpp

@@ -200,46 +200,20 @@ static void fillOutForFunc(const FuncInfo* func, const vector<SAPFOR::BasicBlock
     outForFunc[func->funcName] = { defined, common_defined };
 }
 
-static bool isInstructionSpfParameter(SAPFOR::Instruction* instr)
+static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>& res, 
-{
-    SgStatement* st = instr->getOperator();
-
-    // check if this operator is SPF(ANALYSIS(PARAMETER( )))
-    if (st && st->variant() == ASSIGN_STAT)
-    {
-        if (st->lineNumber() < 0 && st->numberOfAttributes())
-        {
-            for (int i = 0; i < st->numberOfAttributes(); ++i)
-            {
-                SgAttribute* attr = st->getAttribute(i);
-                SgStatement* attributeStatement = (SgStatement*)(attr->getAttributeData());
-                int type = st->attributeType(i);
-
-                if (type == SPF_PARAMETER_OP)
-                    return true;
-            }
-        }
-    }
-    return false;
-}
-
-static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>& res,
                              const vector<pair<const Variable*, CommonBlock*>>& commonVars,
                              const FuncInfo* func)
 {
     vector<SAPFOR::Argument*> lastParamRef;
 
-    for (const auto &ir_block : block->getInstructions())
+    for (auto ir_block : block->getInstructions())
     {
         SAPFOR::Instruction* instr = ir_block->getInstruction();
-        if (isInstructionSpfParameter(instr))
-            continue;
-
         SAPFOR::CFG_OP instr_operation = instr->getOperation();
         if (instr_operation == SAPFOR::CFG_OP::PARAM)
         {
             SAPFOR::Argument* arg = instr->getArg1();
-            if (arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+            if(arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
                 addPlaceWithDef(commonVars, func, arg, instr);
 
             lastParamRef.push_back(arg);
@@ -262,20 +236,12 @@ static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>&
     int last_instr_num = block->getInstructions().back()->getNumber();
 
     for (const auto& def : block->getRD_Out())
-    {
         for (int place : def.second)
-        {
             if (place >= first_instr_num && place <= last_instr_num && def.first->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
             {
-                SAPFOR::Instruction* instr = block->getInstructions()[place - first_instr_num]->getInstruction();
-                if (isInstructionSpfParameter(instr))
-                    continue;
-
                 res.insert(def.first);
-                addPlaceWithDef(commonVars, func, def.first, instr);
+                addPlaceWithDef(commonVars, func, def.first, block->getInstructions()[place - first_instr_num]->getInstruction());
             }
-        }
-    }
 }
 
 // recursively analyze FOR loops 
@@ -300,7 +266,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
     SAPFOR::BasicBlock* head_block = NULL;
 
     int loop_start = loop->lineNum, loop_end = loop->lineNumAfterLoop;
-    for (const auto &bb : blocks)
+    for (auto bb : blocks)
     {
         if (!bb || (bb->getInstructions().size() == 0))
             continue;
@@ -382,7 +348,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
         getDefsFromBlock(*loop_it, changeValueOnExit, commonVars, func);
 
 
-    for (const auto &bb : currentLoop)
+    for (auto bb : currentLoop)
     {
         //fill LiveWhenLoopEnds
         bool has_next_outside_body = false;

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/CreateDistributionDirs.cpp

@@ -274,7 +274,7 @@ static void convertTrees(const map<DIST::Array*, int> &treesIn, map<int, vector<
 static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR<int, double, attrType> &reducedG, DIST::Arrays<int> &allArrays)
 {
     DIST::Array *retVal = NULL;
-    vector<vector<attrType>> coeffsByDims;
+    vector<vector<attrType>> coefsByDims;
     for (auto &array : arrays)
     {
         vector<int> verts;
@@ -285,7 +285,7 @@ static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR
         {
             retVal = array;
             for (auto &V : verts)
-                coeffsByDims.push_back(reducedG.GetAllAttributes(V));
+                coefsByDims.push_back(reducedG.GetAllAttributes(V));
         }
         else
         {
@@ -294,11 +294,11 @@ static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR
                 toCmp.push_back(reducedG.GetAllAttributes(V));
             for (int z = 0; z < toCmp.size(); ++z)
             {
-                if (toCmp[z].size() && coeffsByDims[z].size())
+                if (toCmp[z].size() && coefsByDims[z].size())
                 {
-                    if (toCmp[z].back().first.first > coeffsByDims[z].back().first.first)
+                    if (toCmp[z].back().first.first > coefsByDims[z].back().first.first)
                     {
-                        coeffsByDims = toCmp;
+                        coefsByDims = toCmp;
                         retVal = array;
                         break;
                     }

src/Distribution/DvmhDirective.cpp

@@ -45,10 +45,10 @@ static bool findArrayRefAndCheck(SgExpression *ex, const DIST::Array* currArray,
                 int countOfShadows = 0;
                 for (int i = 0; i < ref->numberOfSubscripts(); ++i)
                 {
-                    const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                    const vector<int*> &coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
-                    if (coeffs.size() == 1)
+                    if (coefs.size() == 1)
                     {
-                        const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
+                        const pair<int, int> coef(coefs[0][0], coefs[0][1]);
                         auto it = shiftsByAccess[i].find(coef);
                         if (it != shiftsByAccess[i].end())
                             if (it->second != 0)
@@ -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/Distribution/DvmhDirectiveBase.cpp

@@ -364,11 +364,11 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
             {
                 if (sharedMemoryParallelization)
                 {
-                    for (auto& coeffs : currReadOp->first[k].coefficients)
+                    for (auto& coefs : currReadOp->first[k].coefficients)
                     {
-                        auto currAccess = coeffs.first;
+                        auto currAccess = coefs.first;
 
-                        const int currShift = coeffs.first.second;
+                        const int currShift = coefs.first.second;
 
                         auto itFound = shiftsByAccess[k].find(currAccess);
                         if (itFound == shiftsByAccess[k].end())
@@ -393,9 +393,9 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
                             int minShift = 9999999;
                             int maxShift = -9999999;
 
-                            for (auto &coeffs : currReadOp->first[k].coefficients)
+                            for (auto &coefs : currReadOp->first[k].coefficients)
                             {
-                                auto currAccess = coeffs.first;
+                                auto currAccess = coefs.first;
                                 auto result = DIST::Fx(currAccess, currRuleShadow);
 
                                 if (result.first == loopRule.first)
@@ -417,7 +417,7 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
                                     auto it = remoteRegularReads.find(calcForArray);
                                     if (it == remoteRegularReads.end())
                                         it = remoteRegularReads.insert(it, make_pair(calcForArray, vector<ArrayOp>(calcForArray->GetDimSize())));
-                                    it->second[k].coefficients.insert(coeffs);
+                                    it->second[k].coefficients.insert(coefs);
                                 }
                             }
 

src/GraphLoop/graph_loops_base.cpp

@@ -1137,9 +1137,9 @@ static bool isMapped(const vector<ArrayOp> &allOps)
     bool mapped = false;
     for (auto &ops : allOps)
     {
-        for (auto &coeffs : ops.coefficients)
+        for (auto &coefs : ops.coefficients)
         {
-            if (coeffs.first.first != 0)
+            if (coefs.first.first != 0)
             {
                 mapped = true;
                 break;

src/LoopAnalyzer/loop_analyzer.cpp

@@ -247,7 +247,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
         }
     }
 
-    pair<int, int> coeffs = pair<int, int>(0, 0);
+    pair<int, int> coefs = pair<int, int>(0, 0);
     // more than one loop symbol in subscription
     if (countOfSymbols > 1)
     {
@@ -326,16 +326,16 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
         {
             if (subscr->symbol()->id() == (parentLoops[position]->doName())->id())
             {
-                coeffs.first = 1;
+                coefs.first = 1;
                 needToCacl = false;
             }
         }
 
         if (needToCacl)
-            getCoefsOfSubscript(coeffs, subscr, parentLoops[position]->doName());
+            getCoefsOfSubscript(coefs, subscr, parentLoops[position]->doName());
-        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coeffs.first, coeffs.second);
+        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coefs.first, coefs.second);
 
-        if (coeffs.first == 0) // && coeffs.second == 0)
+        if (coefs.first == 0) // && coefs.second == 0)
         {
             if (currRegime == REMOTE_ACC)
             {
@@ -346,7 +346,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
             {                
                 const pair<bool, string> &arrayRefString = constructArrayRefForPrint(arrayRef, dimNum, origSubscr);
                 __spf_print(1, "WARN: can not calculate index expression for array ref '%s' at line %d\n", arrayRefString.second.c_str(), currLine);
-                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
+                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
                 if (side == LEFT)
                     allPositions.clear();
 
@@ -371,19 +371,19 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
                         currOp.resize(numOfSubscriptions);
 
                     //add only uniq 
-                    auto itAdd = currOp[dimNum].coefficients.find(coeffs);
+                    auto itAdd = currOp[dimNum].coefficients.find(coefs);
                     if (itAdd == currOp[dimNum].coefficients.end())
-                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coeffs, currentW));
+                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coefs, currentW));
                 }
 
-                if (coeffs.first < 0)
+                if (coefs.first < 0)
                     addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_TRUE, currLine, numOfSubscriptions);
                 else
                     //if we found regular access to array - set it false
                     addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_FALSE, currLine, numOfSubscriptions);
             }
 
-            if (coeffs.first < 0 && sharedMemoryParallelization == 0)
+            if (coefs.first < 0 && sharedMemoryParallelization == 0)
             {
                 if (currRegime == DATA_DISTR)
                 {
@@ -402,15 +402,15 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
                     if (side == LEFT)
                         allPositions.clear();
                     else
-                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
+                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
                 }
             }
             else
             {
                 if (side == LEFT)
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, WRITE_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, WRITE_OP, numOfSubscriptions, currentW);
                 else
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, READ_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, READ_OP, numOfSubscriptions, currentW);
             }
         }
     }
@@ -418,13 +418,13 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
     if (currRegime == ARRAY_ACC_CORNER)
     {
         int *valueSubs = new int[2];
-        valueSubs[0] = coeffs.first;
+        valueSubs[0] = coefs.first;
-        valueSubs[1] = coeffs.second;
+        valueSubs[1] = coefs.second;
 #ifdef __SPF
         addToCollection(__LINE__, __FILE__, valueSubs, 2);
 #endif
-        const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
+        const vector<int*> &coefs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
-        if (coeffs.size() == 0)
+        if (coefs.size() == 0)
         {
             subscr->addAttribute(INT_VAL, valueSubs, sizeof(int*));
             if (position != -1 && allPositions.size() == 1 && position < parentLoops.size())

src/Predictor/PredictScheme.cpp

@@ -23,6 +23,7 @@
 #include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "CFGraph/CFGraph.h"
+#include "../Utils/utils.h"
 
 #include "json.hpp"
 
@@ -36,6 +37,109 @@ using std::tuple;
 
 using json = nlohmann::json;
 
+void runPredictSchemeOld(SgProject &project,
+                      vector<vector<size_t>> &topologies,
+                      vector<ParallelRegion*> &parallelRegions,
+                      map<string, vector<LoopGraph*>> &loopGraph,
+                      map<string, vector<SpfInterval*>> &intervals,
+                      map<string, vector<Messages>> &SPF_messages)
+{
+        int maxSizeDist = 0;
+        for (int z = 0; z < parallelRegions.size(); ++z)
+        {
+            const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
+            const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
+
+            auto &tmp = dataDirectives.distrRules;
+            vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
+            for (int z1 = 0; z1 < currentVariant.size(); ++z1)
+                currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
+
+            for (auto &elem : currentVar)
+            {
+                DIST::Array *array = elem.first;
+                const DistrVariant *var = elem.second;
+
+                int countBlock = 0;
+                for (int z = 0; z < var->distRule.size(); ++z)
+                    if (var->distRule[z] == dist::BLOCK)
+                        ++countBlock;
+                maxSizeDist = std::max(maxSizeDist, countBlock);
+            }
+        }
+                        
+        SpfInterval *mainIterval = getMainInterval(&project, intervals, SPF_messages);
+        topologies.clear();
+        if (maxSizeDist)
+        {
+            const int procNum = 8;
+            //TODO:
+            //topologies = getTopologies(procNum, maxSizeDist);
+            throw -10;
+
+            const int countOfTop = topologies.size();
+            if (countOfTop < 0)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            for (auto &inter : intervals)
+                initTimeForIntervalTree(countOfTop, inter.second);
+
+            for (int z = 0; z < parallelRegions.size(); ++z)
+            {
+                const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
+                const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
+                DIST::Arrays<int> &allArrays = parallelRegions[z]->GetAllArraysToModify();
+
+                auto &tmp = dataDirectives.distrRules;
+                vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
+                for (int z1 = 0; z1 < currentVariant.size(); ++z1)
+                    currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
+
+                map<LoopGraph*, ParallelDirective*> parallelDirs;
+                vector<std::tuple<DIST::Array*, vector<long>, pair<string, int>>> allSingleRemotes;
+                for (int i = project.numberOfFiles() - 1; i >= 0; --i)
+                {
+                    SgFile *file = &(project.file(i));
+                    auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId());
+                    parallelDirs.insert(fountInfo.begin(), fountInfo.end());
+
+                    auto fountRem = findAllSingleRemotes(file, parallelRegions[z]->GetId(), parallelRegions);
+                    allSingleRemotes.insert(allSingleRemotes.end(), fountRem.begin(), fountRem.end());
+                }
+                //TODO!
+                //int err = predictScheme(parallelRegions[z], currentVar, allArrays.GetArrays(), parallelDirs, intervals, SPF_messages, allSingleRemotes, maxSizeDist, procNum);                
+                /*if (err != 0)
+                    internalExit = err;*/
+            }
+
+            vector<SpfInterval*> tmp = { mainIterval };
+            aggregatePredictedTimes(tmp);
+
+            int idx = 0;
+            int best = -1;
+            double bestSpeedUp = 0;
+            for (auto &top : topologies)
+            {
+                string outStr = "";
+                for (auto &elem : top)
+                    outStr += std::to_string(elem) + " ";
+                double currS = mainIterval->exec_time / mainIterval->predictedTimes[idx];
+                __spf_print(1, "%d: speed up %f for top. %s\n", idx, currS, outStr.c_str());
+                
+                if (best == -1 || bestSpeedUp < currS)
+                {
+                    bestSpeedUp = currS;
+                    best = idx;
+                }
+                ++idx;
+            }
+            __spf_print(1, "best topology %d with speed up %f\n", best, bestSpeedUp);
+        }
+        else
+            for (auto &inter : intervals)
+                initTimeForIntervalTree(0, inter.second);
+}
+
 static void fillParallel(SgExpression *exp, ParallelStats &parStats, int &totalScoreComm)
 {
     if (exp)
@@ -326,7 +430,7 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
         list = list->rhs();
     }
 
-    vector<pair<int, int>> coeffs(srcSymbs.size());
+    vector<pair<int, int>> coefs(srcSymbs.size());
     list = listTgt;
     while (list)
     {
@@ -337,8 +441,8 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
             has = recSymbolFind(exp, srcSymbs[z].first, VAR_REF);
             if (has)
             {
-                getCoefsOfSubscript(coeffs[z], exp, srcSymbs[z].second);
+                getCoefsOfSubscript(coefs[z], exp, srcSymbs[z].second);
-                if (coeffs[z].first == 0)
+                if (coefs[z].first == 0)
                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                 break;
             }
@@ -346,14 +450,14 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
         list = list->rhs();
     }
 
-    for (int z = 0; z < coeffs.size(); ++z)
+    for (int z = 0; z < coefs.size(); ++z)
     {
-        if (coeffs[z].first == 0)
+        if (coefs[z].first == 0)
             continue;
-        if (coeffs[z].second)
+        if (coefs[z].second)
-            align["rules"].push_back({ z, coeffs[z].first });
+            align["rules"].push_back({ z, coefs[z].first });
         else
-            align["rules"].push_back({ z, coeffs[z].first, coeffs[z].second });
+            align["rules"].push_back({ z, coefs[z].first, coefs[z].second });
     }
     return align;
 }

src/Predictor/PredictScheme.h

@@ -60,4 +60,6 @@ public:
 void processFileToPredict(SgFile *file, PredictorStats &predictorCounts);
 
 void calculateStatsForPredictor(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);
-void parseDvmDirForPredictor(const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays, const std::map<std::string, CommonBlock*>& commonBlocks, const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);
+void parseDvmDirForPredictor(const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays, const std::map<std::string, CommonBlock*>& commonBlocks, const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);
+
+void runPredictSchemeOld(SgProject &project, std::vector<std::vector<size_t>> &topologies, std::vector<ParallelRegion*> &parallelRegions, std::map<std::string, std::vector<LoopGraph*>> &loopGraph, std::map<std::string, std::vector<SpfInterval*>> &intervals, std::map<std::string, std::vector<Messages>> &SPF_messages);

src/Predictor/PredictSchemeWithLibrary.cpp

@@ -0,0 +1,306 @@
+#include "leak_detector.h"
+
+#include <limits>
+#include <map>
+#include <vector>
+#include <string>
+#include <tuple>
+
+#include "dvm.h"
+#include "PredictSchemeWithLibrary.h"
+#include "../../projects/libpredictor/include/libpredict/predictor.h"
+#include "../DirectiveProcessing/directive_parser.h"
+#include "../Distribution/DvmhDirective.h"
+#include "../ParallelizationRegions/ParRegions.h"
+#include "../GraphLoop/graph_loops_func.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+
+using std::map;
+using std::string;
+using std::vector;
+using std::pair;
+using std::tuple;
+
+// МОЖЕТ КАК-ТО ВЫЧИСЛЯТЬ ДИРЕКТИВЫ, А ПОТОМ ДЕЛАТЬ ПРОГОНЫ?
+double runLibpredictCalc(SgProject &project,
+                      const vector<size_t> &topology,
+                      const string &clusterConfStr,
+                      const vector<ParallelRegion*> &parallelRegions,
+                      map<string, vector<LoopGraph*>> &loopGraph,
+                      map<string, vector<Messages>> &SPF_messages)
+{
+    libpredict::RetInit retInit = libpredict::Init(clusterConfStr, topology[0], topology[1], topology[2], topology[3]);
+
+    if (retInit != libpredict::INIT_SUCCESS) {
+        __spf_print(1, "ERROR: Failed to initialize libpredict with cluster config: %s, return code: %d\n", clusterConfStr.c_str(), (int)retInit);
+    
+        std::wstring messageR, messageE;
+        __spf_printToLongBuf(messageE, L"Failed to initialize libpredict library with cluster config: %s, return code: %d",
+                             to_wstring(clusterConfStr).c_str(), (int)retInit);
+        __spf_printToLongBuf(messageR, R206);
+        getObjectForFileFromMap(clusterConfStr.c_str(), SPF_messages).push_back(Messages(ERROR, 1, messageR, messageE, 1063));
+        return -1;
+    }
+
+    // distribute и align из parallelRegions
+    for (int z = 0; z < parallelRegions.size(); ++z) {
+        const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
+        const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
+        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()) {
+                size_t arrayId = array->GetId();
+                size_t elemSize = array->GetTypeSize();
+
+                vector<libpredict::DistributeAxisRule> axisDistributions;
+                const auto& arraySizes = array->GetSizes();
+                for (int dim = 0; dim < array->GetDimSize(); ++dim) {
+                    size_t dimSize = arraySizes[dim].second - arraySizes[dim].first + 1;
+
+                    if (dim < variant->distRule.size() && variant->distRule[dim] == dist::BLOCK) {
+                        axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::BLOCK);
+                    } else {
+                        axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::NONE);
+                    }
+                }
+
+                vector<pair<size_t, size_t>> shadowEdges;
+                const auto& shadowSpec = array->GetShadowSpec();
+                for (int dim = 0; dim < shadowSpec.size() && dim < array->GetDimSize(); ++dim) {
+                    if (dim < variant->distRule.size() && variant->distRule[dim] == dist::BLOCK) {
+                        shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second);
+                    }
+                }
+
+                libpredict::RetDistribute retDistribute = libpredict::Distribute(arrayId, elemSize, axisDistributions, shadowEdges);
+
+                if (retDistribute != libpredict::DISTRIBUTE_SUCCESS) {
+                    __spf_print(1, "ERROR: Failed to distribute array '%s' (id=%zu) with libpredict, return code: %d\n",
+                               array->GetShortName().c_str(), arrayId, (int)retDistribute);
+
+                    std::wstring messageR, messageE;
+                    __spf_printToLongBuf(messageE, L"Failed to distribute array '%s' with libpredict, return code: %d",
+                                         to_wstring(array->GetShortName()).c_str(), (int)retDistribute);
+                    __spf_printToLongBuf(messageR, R207);
+                    getObjectForFileFromMap(array->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(
+                        Messages(ERROR, array->GetDeclInfo().begin()->second, messageR, messageE, 1064));
+                }
+            }
+        }
+
+        // align
+        for (const auto& alignRule : dataDirectives.alignRules) {
+            DIST::Array* alignArray = alignRule.alignArray;
+            DIST::Array* alignWithArray = alignRule.alignWith;
+
+            if (alignArray && alignWithArray && !alignArray->IsNotDistribute()) {
+                size_t arrayId = alignArray->GetId();
+                size_t distributedArrayId = alignWithArray->GetId();
+                size_t elemSize = alignArray->GetTypeSize();
+
+                const auto& arraySizes = alignArray->GetSizes();
+                vector<size_t> dimensions;
+                for (int dim = 0; dim < alignArray->GetDimSize(); ++dim)
+                    dimensions.push_back(arraySizes[dim].second - arraySizes[dim].first + 1);
+
+                vector<libpredict::AlignDisplay> distributionExpressions;
+                for (int dim = 0; dim < alignWithArray->GetDimSize(); ++dim) {
+                    bool found = false;
+                    for (int i = 0; i < alignRule.alignRuleWith.size(); ++i) {
+                        const auto& ruleWith = alignRule.alignRuleWith[i];
+                        if (ruleWith.first == dim) {
+                            const auto& rule = ruleWith.second;
+                            if (rule.first == 0) {
+                                // Константа
+                                distributionExpressions.emplace_back(rule.second);
+                            } else {
+                                // Линейное выражение a * I + b
+                                distributionExpressions.emplace_back(i, rule.first, rule.second);
+                            }
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        // Нет правила для этого измерения
+                        distributionExpressions.emplace_back();
+                    }
+                }
+
+                vector<pair<size_t, size_t>> shadowEdges;
+                const auto& shadowSpec = alignArray->GetShadowSpec();
+                for (int dim = 0; dim < shadowSpec.size() && dim < alignArray->GetDimSize(); ++dim) {
+                    shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second);
+                }
+
+                libpredict::RetAlign retAlign = libpredict::Align(arrayId, distributedArrayId, elemSize, dimensions, distributionExpressions, shadowEdges);
+                
+                if (retAlign != libpredict::ALIGN_SUCCESS) {
+                    __spf_print(1, "ERROR: Failed to align array '%s' (id=%zu) with array '%s' (id=%zu), return code: %d\n",
+                               alignArray->GetShortName().c_str(), arrayId,
+                               alignWithArray->GetShortName().c_str(), distributedArrayId, (int)retAlign);
+                    
+                    std::wstring messageR, messageE;
+                    __spf_printToLongBuf(messageE, L"Failed to align array '%s' with array '%s' using libpredict, return code: %d",
+                                         to_wstring(alignArray->GetShortName()).c_str(),
+                                         to_wstring(alignWithArray->GetShortName()).c_str(), (int)retAlign);
+                    __spf_printToLongBuf(messageR, R208);
+                    getObjectForFileFromMap(alignArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(
+                        Messages(ERROR, alignArray->GetDeclInfo().begin()->second, messageR, messageE, 1065));
+                }
+            }
+        }
+
+        // shadow_renew
+        map<LoopGraph*, ParallelDirective*> parallelDirs;
+        for (int i = project.numberOfFiles() - 1; i >= 0; --i) {
+            SgFile *file = &(project.file(i));
+            auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId());
+            parallelDirs.insert(fountInfo.begin(), fountInfo.end());
+        }
+
+        for (auto& dirPair : parallelDirs) {
+            LoopGraph* loopPtr = dirPair.first;
+            ParallelDirective* directive = dirPair.second;
+
+            if (directive && !directive->shadowRenew.empty()) {
+                for (size_t shadowIdx = 0; shadowIdx < directive->shadowRenew.size(); ++shadowIdx) {
+                    const auto& shadowRenewItem = directive->shadowRenew[shadowIdx];
+                    const string& arrayName = shadowRenewItem.first.second; // uniqName
+                    const vector<pair<int, int>>& bounds = shadowRenewItem.second;
+
+                    DIST::Array* shadowArray = allArrays.GetArrayByName(arrayName);
+                    if (shadowArray == NULL)
+                        continue;
+
+                    if (shadowArray && !shadowArray->IsNotDistribute()) {
+                        size_t arrayId = shadowArray->GetId();
+
+                        vector<pair<size_t, size_t>> shadow_renew;
+                        for (const auto& bound : bounds) {
+                            shadow_renew.emplace_back(static_cast<size_t>(bound.first),
+                                                    static_cast<size_t>(bound.second));
+                        }
+
+                        bool corner = directive->shadowRenewCorner[shadowIdx];
+
+                        size_t number_loop_iterations = loopPtr ? static_cast<size_t>(loopPtr->countOfIters) : 1;
+
+                        libpredict::RetShadowRenew retShadowRenew = libpredict::ShadowRenew(arrayId, shadow_renew, corner, number_loop_iterations);
+
+                        if (retShadowRenew != libpredict::SHADOW_RENEW_SUCCESS) {
+                            __spf_print(1, "ERROR: Failed to process shadow_renew for array '%s' (id=%zu), return code: %d\n",
+                                       shadowArray->GetShortName().c_str(), arrayId, (int)retShadowRenew);
+                            
+                            std::wstring messageR, messageE;
+                            __spf_printToLongBuf(messageE, L"Failed to process shadow_renew for array '%s' with libpredict, return code: %d",
+                                                 to_wstring(shadowArray->GetShortName()).c_str(), (int)retShadowRenew);
+                            __spf_printToLongBuf(messageR, R209);
+                            getObjectForFileFromMap(shadowArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(
+                                Messages(ERROR, shadowArray->GetDeclInfo().begin()->second, messageR, messageE, 1066));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return libpredict::GetTime();
+}
+
+void runPredictScheme(SgProject &project,
+                      vector<vector<size_t>> &topologies,
+                      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";
+    }
+
+    // iterating through topologies to find most optimal one
+    topologies = vector<vector<size_t>>();
+    if (maxSizeDist) {
+
+        if (maxSizeDist > 4) maxSizeDist = 4;
+
+        // TODO: look at cluster configuration
+        size_t n1max = 10;
+        size_t n2max = (maxSizeDist >= 2) ? 10 : 1;
+        size_t n3max = (maxSizeDist >= 3) ? 10 : 1;
+        size_t n4max = (maxSizeDist >= 4) ? 10 : 1;
+
+        for (size_t n1 = 1; n1 <= n1max; ++n1) {
+            for (size_t n2 = 1; n2 <= n2max; ++n2) {
+                for (size_t n3 = 1; n3 <= n3max; ++n3) {
+                    for (size_t n4 = 1; n4 <= n4max; ++n4) {
+                        topologies.push_back(vector<size_t>{n1, n2, n3, n4});
+                    }
+                }
+            }
+        }
+
+        vector<size_t> best;
+        double bestTime = std::numeric_limits<double>::max();
+        for (auto &topology : topologies) {
+            // if (DEBUG) {
+                // string outStr = "";
+                // for (const auto &elem : top)
+                //     outStr += std::to_string(elem) + " ";
+                // __spf_print(1, "topology %s has time %f\n", outStr.c_str(), currTime);
+            // }
+            double currTime = runLibpredictCalc(project, topology, clusterConfStr, parallelRegions, loopGraph, SPF_messages);
+
+            if (currTime == -1)
+                return;
+            
+            if (currTime < bestTime) {
+                bestTime = currTime;
+                best = topology;
+            }
+        }
+        string outStr;
+        for (const auto &elem : best)
+            outStr += std::to_string(elem) + " ";
+
+        __spf_print(1, "best topology %s with time %f\n", outStr.c_str(), bestTime);
+    } else {
+        __spf_print(1, "impossible to calculate best topology: project does not contain distribution directives\n");
+    }
+}

src/Predictor/PredictSchemeWithLibrary.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <vector>
+#include <map>
+#include <string>
+#include "dvm.h"
+#include "graph_calls.h"
+
+void runPredictScheme(SgProject &project,
+                     std::vector<std::vector<size_t>> &topologies,
+                     const std::vector<ParallelRegion*> &parallelRegions,
+                     std::map<std::string, std::vector<LoopGraph*>> &loopGraph,
+                     std::map<std::string, std::vector<Messages>> &SPF_messages);
+
+double runLibpredictCalc(SgProject &project,
+                        const std::vector<size_t> &topology,
+                        const std::string &clusterConfStr,
+                        const std::vector<ParallelRegion*> &parallelRegions,
+                        std::map<std::string, std::vector<LoopGraph*>> &loopGraph,
+                        std::map<std::string, std::vector<Messages>> &SPF_messages);

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -12,38 +12,9 @@
 #include "SgUtils.h"
 #include "graph_loops.h"
 #include "CFGraph/CFGraph.h"
-#include "utils.h"
 
 using namespace std;
 
-static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
-{
-    ArrayAccessingIndexes resultContainer;
-    unordered_set<string> toRemove;
-
-    for (auto& [arrayName, accessingSet] : container)
-    {
-        vector<vector<ArrayDimension>> points;
-        for (auto& arrayPoint : accessingSet.GetElements())
-        {
-            if (!arrayPoint.empty())
-                points.push_back(arrayPoint);
-        }
-
-        if (points.size() < accessingSet.GetElements().size() && !points.empty())
-            resultContainer[arrayName] = points;
-
-        if (points.empty())
-            toRemove.insert(arrayName);
-    }
-
-    for (const string& name : toRemove)
-        container.erase(name);
-
-    for (auto& [arrayName, accessingSet] : resultContainer)
-        container[arrayName] = accessingSet;
-}
-
 static void Collapse(Region* region)
 {
     if (region->getBasickBlocks().empty())
@@ -66,13 +37,13 @@ static void Collapse(Region* region)
             region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
         }
     }
-
     ArrayAccessingIndexes useUnion;
     for (auto& byBlock : region->getBasickBlocks())
         for (auto& [arrayName, arrayRanges] : byBlock->array_use)
             useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
 
-    region->array_priv = region->array_use;
+    for (auto& [arrayName, arrayRanges] : useUnion)
+        region->array_priv[arrayName] = useUnion[arrayName].Diff(region->array_use[arrayName]);
     
     for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
         prevBlock->replaceInNextRegions(region, region->getHeader());
@@ -103,7 +74,6 @@ static void SolveDataFlowIteratively(Region* DFG)
                     newIn.clear();
                     continue;
                 }
-
                 for (const auto& [arrayName, accessSet] : prevBlock->array_out)
                 {
                     if (newIn.find(arrayName) != newIn.end())
@@ -116,7 +86,6 @@ static void SolveDataFlowIteratively(Region* DFG)
 
         b->array_in = move(newIn);
         ArrayAccessingIndexes newOut;
-
         if (b->array_def.empty())        
             newOut = b->array_in;
         else if (b->array_in.empty())
@@ -152,83 +121,21 @@ static void SolveDataFlow(Region* DFG)
     Collapse(DFG);
 }
 
-static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
+map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
-{
-    SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
-    spfStat->setlineNumber(loop->loop->lineNumber());
-    spfStat->setFileName(loop->loop->fileName());
-    SgExpression* toAdd = new SgExpression(EXPR_LIST, new SgExpression(ACC_PRIVATE_OP), NULL, NULL);
-    set<SgSymbol*> arraysToInsert;
-    for (const auto& [_, accessingSet] : privates)
-    {
-        for (const auto& arrayElement : accessingSet.GetElements())
-        {
-            if (arrayElement.empty())
-                continue;
-            arraysToInsert.insert(arrayElement[0].array->symbol());
-        }
-    }
-
-    spfStat->setExpression(0, *toAdd);
-    toAdd = toAdd->lhs();
-    bool first = true;
-    for (auto& elem : arraysToInsert)
-    {
-        if (first)
-        {
-            toAdd->setLhs(new SgExpression(EXPR_LIST));
-            toAdd = toAdd->lhs();
-            first = false;
-        }
-        else
-        {
-            toAdd->setRhs(new SgExpression(EXPR_LIST));
-            toAdd = toAdd->rhs();
-        }
-        toAdd->setLhs(new SgVarRefExp(elem));
-    }
-    
-    if (arraysToInsert.size() == 0)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    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)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
-    for (const auto& [fileName, loops] : loopGraph)
+    for (const auto& [loopName, loops] : loopGraph)
     {
-        SgFile::switchToFile(fileName);
         for (const auto& loop : loops)
         {
-            if (!loop->isFor())
-                continue;
-            SgStatement* search_func = loop->loop->GetOriginal();
-
-            while (search_func && (!isSgProgHedrStmt(search_func)))
-                search_func = search_func->controlParent();
-
             for (const auto& [funcInfo, blocks]: FullIR)
             {   
-                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
+                Region* loopRegion = new Region(loop, blocks);
-                {
+                SolveDataFlow(loopRegion);
-                    Region* loopRegion = new Region(loop, blocks);
+                result[loop] = loopRegion->array_priv;
-                    if (loopRegion->getBasickBlocks().size() <= 1)
+                delete(loopRegion);
-                    {
-                        delete(loopRegion);
-                        continue;
-                    }
-                    SolveDataFlow(loopRegion);
-                    RemoveEmptyPoints(loopRegion->array_priv);
-                    result[loop] = loopRegion->array_priv;
-                    delete(loopRegion);
-                }
             }
-
-            if (result.find(loop) != result.end() && !result[loop].empty())
-                AddPrivateArraysToLoop(loop, result[loop], insertedPrivates);
         }
     }
+    return result;
 }

src/PrivateAnalyzer/private_arrays_search.h

@@ -2,12 +2,11 @@
 
 #include <vector>
 #include <map>
-#include <set>
 #include <unordered_set>
 
 #include "range_structures.h"
 #include "graph_loops.h"
 #include "CFGraph/CFGraph.h"
 
-void FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, std::set<SgStatement*>& insertedPrivates);
+std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
 std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);

src/PrivateAnalyzer/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 };
     return result;
 }
 
@@ -61,16 +61,21 @@ 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 });
     
     /* add the parts between intersection steps */
-    if (intersection->step > dim1.step)
+    uint64_t start = (intersection->start - dim1.start) / dim1.step;
+    uint64_t interValue = intersection->start;
+    for (int64_t i = start; dim1.start + i * dim1.step <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
     {
-        uint64_t start = (intersection->start - dim1.start) / dim1.step;
+        uint64_t centerValue = dim1.start + i * dim1.step;
-        uint64_t interValue = intersection->start;
+        if (centerValue == interValue)
-        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});
+            if (i - start > 1)
+            {
+                result.push_back({ dim1.start + (start + 1) * dim1.step, dim1.step, i - start - 1 });
+                start = i;
+            }
             interValue += intersection->step;
         }
     }
@@ -80,7 +85,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
         /* first value after intersection */
         uint64_t right_start = intersection->start + intersection->step * (intersection->tripCount - 1) + dim1.step;
         uint64_t tripCount = (dim1.start + dim1.step * dim1.tripCount - right_start) / dim1.step;
-        result.push_back({ right_start, dim1.step, tripCount, dim1.array });
+        result.push_back({ right_start, dim1.step, tripCount });
     }
     delete(intersection);
     return result;
@@ -211,10 +216,6 @@ void AccessingSet::Insert(const vector<ArrayDimension>& element)
 }
 
 AccessingSet AccessingSet::Union(const AccessingSet& source) {
-    if (source.GetElements().empty())
-        return *this;
-    if (allElements.empty())
-        return source;
     AccessingSet result;
     for (auto& element : source.GetElements())
         result.Insert(element);

src/PrivateAnalyzer/range_structures.h

@@ -6,12 +6,9 @@
 #include <string>
 #include <cstdint>
 
-#include "SgUtils.h"
-
 struct ArrayDimension
 {
     uint64_t start, step, tripCount;
-    SgArrayRefExp* array;
 };
 
 class AccessingSet {

src/PrivateAnalyzer/region.cpp

@@ -4,7 +4,6 @@
 #include<unordered_map>
 #include<string>
 #include <numeric>
-#include <iostream>
 
 #include "range_structures.h"
 #include "region.h"
@@ -105,33 +104,15 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
 
         auto operation = instruction->getInstruction()->getOperation();
         auto type = instruction->getInstruction()->getArg1()->getType();
-        if (operation == SAPFOR::CFG_OP::ASSIGN && instruction->getInstruction()->getResult()->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY)
-        {
-            SgStatement* op = instruction->getInstruction()->getOperator();
-            if (op && op->expr(0) && isArrayRef(op->expr(0)) && op->expr(0)->symbol() && op->expr(0)->type())
-            {
-                if (isSgArrayType(op->expr(0)->symbol()->type()))
-                {
-                    SgArrayType* arrayType = (SgArrayType*)op->expr(0)->symbol()->type();
-                    int dimCount = ((SgArrayType*)op->expr(0)->symbol()->type())->dimension();
-                    vector<ArrayDimension> point;
-                    for (int i = 0; i < dimCount; i++)
-                    {
-                        string strDimLength = arrayType->sizeInDim(i)->unparse();
-                        if (arrayType->sizeInDim(i)->variant() == INT_VAL && strDimLength != "0")
-                            point.push_back({ 1ULL, 1ULL, (uint64_t)stoi(strDimLength), (SgArrayRefExp*)op->expr(0) });
-                    }
-
-                    if (point.size() == dimCount)
-                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({point});
-                }
-            }
-        }
         if ((operation == SAPFOR::CFG_OP::STORE || operation == SAPFOR::CFG_OP::LOAD) && type == SAPFOR::CFG_ARG_TYPE::ARRAY)
         {
             vector<SAPFOR::Argument*> index_vars;
             vector<int> refPos;
-            string array_name = instruction->getInstruction()->getArg1()->getValue();            
+            string array_name;
+            if (operation == SAPFOR::CFG_OP::STORE)
+                array_name = instruction->getInstruction()->getArg1()->getValue();            
+            else
+                array_name = instruction->getInstruction()->getArg2()->getValue();
 
             int j = i - 1;
             while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
@@ -146,15 +127,29 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
             vector<ArrayDimension> accessPoint(n);
 
             auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
-            int fillCount = 0;
+            vector<pair<int, int>> coefsForDims;
+            for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
+            {
+                const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                if (coefs.size() == 1)
+                {
+                    const pair<int, int> coef(coefs[0][0], coefs[0][1]);
+                    coefsForDims.push_back(coef);
+                }
 
-            while (!index_vars.empty() && !refPos.empty())
+            }
+
+            if(coefsForDims.empty())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            while (!index_vars.empty())
             {
                 auto var = index_vars.back();
                 int currentVarPos = refPos.back();
+                pair<int, int> currentCoefs = coefsForDims.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 };
                 else
                 {
                     string name, full_name = var->getValue();
@@ -180,28 +175,21 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                             return -1;
                     }
 
-                    uint64_t start = currentLoop->startVal;
+                    uint64_t start = currentLoop->startVal * currentCoefs.first + currentCoefs.second;
-                    uint64_t step = currentLoop->stepVal;
+                    uint64_t step = currentCoefs.first;
-                    uint64_t iters = currentLoop->calculatedCountOfIters;
+                    current_dim = { start, step, (uint64_t)currentLoop->calculatedCountOfIters };
-                    current_dim = { start, step, iters, ref };
                 }
 
-                if (current_dim.start != 0 && current_dim.step != 0 && current_dim.tripCount != 0)
+                accessPoint[n - index_vars.size()] = current_dim;
-                {
-                    accessPoint[n - index_vars.size()] = current_dim;
-                    fillCount++;
-                }
                 index_vars.pop_back();
                 refPos.pop_back();
+                coefsForDims.pop_back();
             }
 
-            if (fillCount == accessPoint.size())
+            if (operation == SAPFOR::CFG_OP::STORE)            
-            {
+                def[array_name].Insert(accessPoint);
-                if (operation == SAPFOR::CFG_OP::STORE)
+            else
-                    def[array_name].Insert(accessPoint);
+                use[array_name].Insert(accessPoint);
-                else
-                    use[array_name].Insert(accessPoint);
-            }
         }
     }
     return 0;
@@ -239,11 +227,8 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
             region->addBasickBlocks(bbToRegion.at(block));
 
     for (LoopGraph* childLoop : loop->children)
-    {
-        if (!childLoop->isFor())
-            continue;
         region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
-    }
+
     return region;
 }
 
@@ -262,9 +247,5 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
     SetConnections(bbToRegion, blockSet);
     //create subRegions
     for (LoopGraph* childLoop : loop->children)
-    {
-        if (!childLoop->isFor())
-            continue;
         subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
-    }
 }

src/Sapfor.cpp

@@ -46,7 +46,6 @@
 #include "DynamicAnalysis/gCov_parser_func.h"
 #include "DynamicAnalysis/createParallelRegions.h"
 
-#include "ArrayConstantPropagation/propagation.h"
 #include "DirectiveProcessing/directive_analyzer.h"
 #include "DirectiveProcessing/directive_creator.h"
 #include "DirectiveProcessing/insert_directive.h"
@@ -58,6 +57,7 @@
 #include "expr_transform.h"
 
 #include "Predictor/PredictScheme.h"
+#include "Predictor/PredictSchemeWithLibrary.h"
 #include "Predictor/PredictorModel.h"
 #include "SageAnalysisTool/depInterfaceExt.h"
 #include "DvmhRegions/DvmhRegionInserter.h"
@@ -90,7 +90,6 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/MoveOperators/move_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
@@ -281,8 +280,7 @@ static string unparseProjectIfNeed(SgFile* file, const int curr_regime, const bo
             for (SgStatement* st = file->firstStatement(); st; st = st->lexNext())
                 if (isSPF_stat(st)) // except sapfor parallel regions and if attributes dont move
                     if (st->variant() != SPF_PARALLEL_REG_DIR && st->variant() != SPF_END_PARALLEL_REG_DIR)
-                        if (insertedPrivates.find(st) == insertedPrivates.end())
+                        toDel.push_back(st);
-                            toDel.push_back(st);
 
             for (auto& elem : toDel)
                 elem->deleteStmt();
@@ -942,8 +940,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
-        else if (curr_regime == MOVE_OPERATORS)        
-            moveOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1024,6 +1020,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                 if(func->funcPointer->variant() != ENTRY_STAT)
                     countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks);
         }
+        else if (curr_regime == FIND_PRIVATE_ARRAYS)
+            FindPrivateArrays(loopGraph, fullIR);
         else if (curr_regime == TEST_PASS)
         {
         //test pass
@@ -1040,8 +1038,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_REMOVING,
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
-                          REMOVE_DEAD_CODE,
+                          REMOVE_DEAD_CODE };
-                          MOVE_OPERATORS };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -1732,103 +1729,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         }
     }
     else if (curr_regime == PREDICT_SCHEME)
-    {
+        runPredictScheme(project, topologies, parallelRegions, loopGraph, SPF_messages);
-        int maxSizeDist = 0;
-        for (int z = 0; z < parallelRegions.size(); ++z)
-        {
-            const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
-            const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
-
-            auto &tmp = dataDirectives.distrRules;
-            vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
-            for (int z1 = 0; z1 < currentVariant.size(); ++z1)
-                currentVar.push_back(make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
-
-            for (auto &elem : currentVar)
-            {
-                DIST::Array *array = elem.first;
-                const DistrVariant *var = elem.second;
-
-                int countBlock = 0;
-                for (int z = 0; z < var->distRule.size(); ++z)
-                    if (var->distRule[z] == dist::BLOCK)
-                        ++countBlock;
-                maxSizeDist = std::max(maxSizeDist, countBlock);
-            }
-        }
-                        
-        SpfInterval *mainIterval = getMainInterval(&project, intervals, SPF_messages);
-        topologies.clear();
-        if (maxSizeDist)
-        {
-            const int procNum = 8;
-            //TODO:
-            //topologies = getTopologies(procNum, maxSizeDist);
-            throw -10;
-
-            const int countOfTop = topologies.size();
-            if (countOfTop < 0)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            for (auto &inter : intervals)
-                initTimeForIntervalTree(countOfTop, inter.second);
-
-            for (int z = 0; z < parallelRegions.size(); ++z)
-            {
-                const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
-                const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
-                DIST::Arrays<int> &allArrays = parallelRegions[z]->GetAllArraysToModify();
-
-                auto &tmp = dataDirectives.distrRules;
-                vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
-                for (int z1 = 0; z1 < currentVariant.size(); ++z1)
-                    currentVar.push_back(make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
-
-                map<LoopGraph*, ParallelDirective*> parallelDirs;
-                vector<std::tuple<DIST::Array*, vector<long>, pair<string, int>>> allSingleRemotes;
-                for (int i = n - 1; i >= 0; --i)
-                {
-                    SgFile *file = &(project.file(i));
-                    auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId());
-                    parallelDirs.insert(fountInfo.begin(), fountInfo.end());
-
-                    auto fountRem = findAllSingleRemotes(file, parallelRegions[z]->GetId(), parallelRegions);
-                    allSingleRemotes.insert(allSingleRemotes.end(), fountRem.begin(), fountRem.end());
-                }
-                //TODO!
-                //int err = predictScheme(parallelRegions[z], currentVar, allArrays.GetArrays(), parallelDirs, intervals, SPF_messages, allSingleRemotes, maxSizeDist, procNum);                
-                /*if (err != 0)
-                    internalExit = err;*/
-            }
-
-            vector<SpfInterval*> tmp = { mainIterval };
-            aggregatePredictedTimes(tmp);
-
-            int idx = 0;
-            int best = -1;
-            double bestSpeedUp = 0;
-            for (auto &top : topologies)
-            {
-                string outStr = "";
-                for (auto &elem : top)
-                    outStr += std::to_string(elem) + " ";
-                double currS = mainIterval->exec_time / mainIterval->predictedTimes[idx];
-                __spf_print(1, "%d: speed up %f for top. %s\n", idx, currS, outStr.c_str());
-                
-                if (best == -1 || bestSpeedUp < currS)
-                {
-                    bestSpeedUp = currS;
-                    best = idx;
-                }
-                ++idx;
-            }
-            __spf_print(1, "best topology %d with speed up %f\n", best, bestSpeedUp);
-        }
-        else
-            for (auto &inter : intervals)
-                initTimeForIntervalTree(0, inter.second);
-
-    }
     else if (curr_regime == CREATE_INTER_TREE)
     {
         if (keepFiles)
@@ -1920,11 +1821,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
     }
     else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
         transformAssumedSizeParameters(allFuncInfo);
-    else if (curr_regime == FIND_PRIVATE_ARRAYS_ANALYSIS)
-        FindPrivateArrays(loopGraph, fullIR, insertedPrivates);
-
-    else if (curr_regime == ARRAY_PROPAGATION)
-        ArrayConstantPropagation(project);
 
     const float elapsed = duration_cast<milliseconds>(high_resolution_clock::now() - timeForPass).count() / 1000.;
     const float elapsedGlobal = duration_cast<milliseconds>(high_resolution_clock::now() - globalTime).count() / 1000.;
@@ -2229,9 +2125,8 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
 
             runAnalysis(*project, CALCULATE_STATS_SCHEME, false);
 
-            //TODO: need to rewrite this to new algo 
+            if (!folderName && !consoleMode || predictOn)
-            /*if (!folderName && !consoleMode || predictOn)
+                runAnalysis(*project, PREDICT_SCHEME, false);
-                runAnalysis(*project, PREDICT_SCHEME, false); */
 
             runAnalysis(*project, REMOVE_COPIES, false);
             runAnalysis(*project, SWAP_LOOPS, false);
@@ -2343,7 +2238,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case INSERT_NO_DISTR_FLAGS_FROM_GUI:
     case PRIVATE_REMOVING:
     case RENAME_INLCUDES:
-    case MOVE_OPERATORS:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:
@@ -2383,7 +2277,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case SUBST_EXPR_RD_AND_UNPARSE:
     case SUBST_EXPR_AND_UNPARSE:
     case REMOVE_DEAD_CODE_AND_UNPARSE:
-    case FIND_PRIVATE_ARRAYS:
         if (folderName)
             runAnalysis(*project, UNPARSE_FILE, true, "", folderName);
         else
@@ -2645,7 +2538,7 @@ int main(int argc, char **argv)
             }
         }
 
-        if (curr_regime == INSERT_PARALLEL_DIRS_NODIST || curr_regime == FIND_PRIVATE_ARRAYS)
+        if (curr_regime == INSERT_PARALLEL_DIRS_NODIST)
         {
             ignoreArrayDistributeState = true;
             sharedMemoryParallelization = 1;

src/Sapfor.h

@@ -122,8 +122,6 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    MOVE_OPERATORS,
-
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
     FILL_PARALLEL_REG_IR,
@@ -185,11 +183,9 @@ enum passes {
     SET_IMPLICIT_NONE,
     RENAME_INLCUDES,
 
-    FIND_PRIVATE_ARRAYS_ANALYSIS,
     FIND_PRIVATE_ARRAYS,
 
     TRANSFORM_ASSUMED_SIZE_PARAMETERS,
-    ARRAY_PROPAGATION,
 
     TEST_PASS,
     EMPTY_PASS
@@ -323,7 +319,6 @@ static void setPassValues()
     passNames[CHECK_PAR_REG_DIR] = "CHECK_PAR_REG_DIR";
     passNames[CREATE_INTER_TREE] = "CREATE_INTER_TREE";
     passNames[INSERT_INTER_TREE] = "INSERT_INTER_TREE";
-    passNames[MOVE_OPERATORS] = "MOVE_OPERATORS";
     passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";
@@ -376,11 +371,9 @@ static void setPassValues()
     passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE";
     passNames[RENAME_INLCUDES] = "RENAME_INLCUDES";
     passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
-    passNames[FIND_PRIVATE_ARRAYS_ANALYSIS] = "FIND_PRIVATE_ARRAYS_ANALYSIS";
     passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";
 
     passNames[TRANSFORM_ASSUMED_SIZE_PARAMETERS] = "TRANSFORM_ASSUMED_SIZE_PARAMETERS";
-    passNames[ARRAY_PROPAGATION] = "ARRAY_PROPAGATION";
 
     passNames[TEST_PASS] = "TEST_PASS";
 }

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
@@ -175,11 +175,6 @@ std::set<std::tuple<std::string, int, std::string>> parametersOfProject; // [fil
 //for GET_MIN_MAX_BLOCK_DIST
 std::pair<int, int> min_max_block = std::make_pair(-1, -1);
 //
-
-//for FIND_PRIVATE_ARRAYS
-std::set<SgStatement*> insertedPrivates;
-//
-
 const char* passNames[EMPTY_PASS + 1];
 const char* optionNames[EMPTY_OPTION + 1];
 bool passNamesWasInit = false;

src/Transformations/LoopCombining/loops_combiner.cpp

@@ -1123,7 +1123,7 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
         for (int d = 0; d < dimensions; ++d)
         {
             //по измерениям массива отображение на цикл вложенности d
-            vector<set<pair<int, int>>> coeffsRead[2], coeffsWrite[2];
+            vector<set<pair<int, int>>> coefsRead[2], coefsWrite[2];
 
             checkNull(currLoop[0], convertFileName(__FILE__).c_str(), __LINE__);
             checkNull(currLoop[1], convertFileName(__FILE__).c_str(), __LINE__);
@@ -1133,31 +1133,31 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
                 auto it = currLoop[k]->readOpsForLoop.find(array);
                 if (it != currLoop[k]->readOpsForLoop.end())
                 {
-                    if (coeffsRead[k].size() == 0)
+                    if (coefsRead[k].size() == 0)
-                        coeffsRead[k].resize(it->second.size());
+                        coefsRead[k].resize(it->second.size());
 
                     for (int z = 0; z < it->second.size(); ++z)
                         if (it->second[z].coefficients.size())
                             for (auto& coef : it->second[z].coefficients)
-                                coeffsRead[k][z].insert(coef.first);
+                                coefsRead[k][z].insert(coef.first);
                 }
 
                 auto itW = currLoop[k]->writeOpsForLoop.find(array);
                 if (itW != currLoop[k]->writeOpsForLoop.end())
                 {
-                    if (coeffsWrite[k].size() == 0)
+                    if (coefsWrite[k].size() == 0)
-                        coeffsWrite[k].resize(itW->second.size());
+                        coefsWrite[k].resize(itW->second.size());
 
                     for (int z = 0; z < itW->second.size(); ++z)
                         if (itW->second[z].coefficients.size())
                             for (auto& coef : itW->second[z].coefficients)
-                                coeffsWrite[k][z].insert(coef.first);
+                                coefsWrite[k][z].insert(coef.first);
                 }
             }
 
             //нет записей, значит нет зависимости
             bool nulWrite = true;
-            for (auto& wr : coeffsWrite)
+            for (auto& wr : coefsWrite)
                 for (auto& elem : wr)
                     if (elem.size() != 0)
                         nulWrite = false;
@@ -1168,62 +1168,62 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
             // если чтение в одном цикле и запись (и наоборот) в другом идут по разным правилам, то пока что это зависимость.
             // здесь можно уточнить.
 
-            const int len = std::max(coeffsWrite[0].size(), coeffsRead[0].size());
+            const int len = std::max(coefsWrite[0].size(), coefsRead[0].size());
             int countW[2] = { 0, 0 };
             int countR[2] = { 0, 0 };
 
             for (int L = 0; L < 2; ++L)
-                for (int z = 0; z < coeffsWrite[L].size(); ++z)
+                for (int z = 0; z < coefsWrite[L].size(); ++z)
-                    countW[L] += (coeffsWrite[L][z].size() ? 1 : 0);
+                    countW[L] += (coefsWrite[L][z].size() ? 1 : 0);
 
             for (int L = 0; L < 2; ++L)
-                for (int z = 0; z < coeffsRead[L].size(); ++z)
+                for (int z = 0; z < coefsRead[L].size(); ++z)
-                    countR[L] += (coeffsRead[L][z].size() ? 1 : 0);
+                    countR[L] += (coefsRead[L][z].size() ? 1 : 0);
 
             for (int p = 0; p < len; ++p)
             {
-                if (coeffsWrite[1].size() && coeffsWrite[0].size())
+                if (coefsWrite[1].size() && coefsWrite[0].size())
-                    if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() != 0)
+                    if (coefsWrite[0][p].size() != 0 && coefsWrite[1][p].size() != 0)
-                        if (coeffsWrite[0][p] != coeffsWrite[1][p])
+                        if (coefsWrite[0][p] != coefsWrite[1][p])
                             return true;
 
-                if (coeffsRead[1].size() && coeffsWrite[0].size())
+                if (coefsRead[1].size() && coefsWrite[0].size())
-                    if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() != 0)
+                    if (coefsWrite[0][p].size() != 0 && coefsRead[1][p].size() != 0)
-                        if (coeffsWrite[0][p] != coeffsRead[1][p])
+                        if (coefsWrite[0][p] != coefsRead[1][p])
                             return true;
 
-                if (coeffsWrite[1].size() && coeffsRead[0].size())
+                if (coefsWrite[1].size() && coefsRead[0].size())
-                    if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() != 0)
+                    if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() != 0)
-                        if (coeffsWrite[1][p] != coeffsRead[0][p])
+                        if (coefsWrite[1][p] != coefsRead[0][p])
                             return true;
                 
 
                 //отображение на разные измерения
-                if (coeffsWrite[1].size() && coeffsWrite[0].size())
+                if (coefsWrite[1].size() && coefsWrite[0].size())
                 {
-                    if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() == 0 && countW[1] ||
+                    if (coefsWrite[0][p].size() != 0 && coefsWrite[1][p].size() == 0 && countW[1] ||
-                        coeffsWrite[0][p].size() == 0 && coeffsWrite[1][p].size() != 0 && countW[0])
+                        coefsWrite[0][p].size() == 0 && coefsWrite[1][p].size() != 0 && countW[0])
                         return true;
                 }
 
-                if (coeffsRead[1].size() && coeffsWrite[0].size())
+                if (coefsRead[1].size() && coefsWrite[0].size())
                 {
-                    if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() == 0 && countR[1] ||
+                    if (coefsWrite[0][p].size() != 0 && coefsRead[1][p].size() == 0 && countR[1] ||
-                        coeffsWrite[0][p].size() == 0 && coeffsRead[1][p].size() != 0 && countW[0])
+                        coefsWrite[0][p].size() == 0 && coefsRead[1][p].size() != 0 && countW[0])
                         return true;
                 }
 
-                if (coeffsWrite[1].size() && coeffsRead[1].size())
+                if (coefsWrite[1].size() && coefsRead[1].size())
                 {
-                    if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() == 0 && countR[0] ||
+                    if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() == 0 && countR[0] ||
-                        coeffsWrite[1][p].size() == 0 && coeffsRead[0][p].size() != 0 && countW[1])
+                        coefsWrite[1][p].size() == 0 && coefsRead[0][p].size() != 0 && countW[1])
                         return true;
                 }
 
                 //где то нет правил отображения вообще, но есть факт его наличия. 
-                if ( ((coeffsWrite[0].size() == 0 && coeffsRead[0].size() == 0) && (countW[0] == 0 && countR[0] == 0)) 
+                if ( ((coefsWrite[0].size() == 0 && coefsRead[0].size() == 0) && (countW[0] == 0 && countR[0] == 0)) 
                     ||
-                    ((coeffsWrite[1].size() == 0 && coeffsRead[1].size() == 0) && (countW[1] == 0 && countR[1] == 0)) )
+                    ((coefsWrite[1].size() == 0 && coefsRead[1].size() == 0) && (countW[1] == 0 && countR[1] == 0)) )
                     return true;
             }
             

src/Transformations/MoveOperators/move_operators.cpp

@@ -1,826 +0,0 @@
-#include <map>
-#include <unordered_set>
-#include <vector>
-#include <queue>
-#include <iostream>
-#include <algorithm>
-
-#include "../../Utils/errors.h"
-#include "../../Utils/SgUtils.h"
-#include "../../GraphCall/graph_calls.h"
-#include "../../GraphCall/graph_calls_func.h"
-#include "../../CFGraph/CFGraph.h"
-#include "../../CFGraph/IR.h"
-#include "../../GraphLoop/graph_loops.h"
-#include "move_operators.h"
-
-using namespace std;
-
-static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, const vector<SAPFOR::BasicBlock*>& Blocks) {
-    vector<SAPFOR::IR_Block*> result;
-    string filename = st->fileName();
-    
-    for (auto& block: Blocks) {
-        vector<SAPFOR::IR_Block*> instructionsInBlock = block->getInstructions();
-
-        for (auto& instruction: instructionsInBlock) {
-            SgStatement* curOperator = instruction->getInstruction()->getOperator();
-            if (curOperator->lineNumber() == st->lineNumber())
-                result.push_back(instruction);
-        }
-    }
-    return result;
-}
-
-const unordered_set<int> loop_tags = { FOR_NODE };
-const unordered_set<int> control_tags = { IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE };
-const unordered_set<int> control_end_tags = { CONTROL_END };
-
-struct OperatorInfo {
-    SgStatement* stmt;
-    set<string> usedVars;
-    set<string> definedVars;
-    int lineNumber;
-    bool isMovable;
-    
-    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) { }
-};
-
-static bool isStatementEmbedded(SgStatement* stmt, SgStatement* parent) {
-    if (!stmt || !parent || stmt == parent)
-        return false;
-    
-    if (parent->variant() == LOGIF_NODE) {
-        if (stmt->lineNumber() == parent->lineNumber())
-            return true;
-        
-        SgStatement* current = parent;
-        SgStatement* lastNode = parent->lastNodeOfStmt();
-
-        while (current && current != lastNode) {
-            if (current == stmt)
-                return true;
-
-            if (current->isIncludedInStmt(*stmt))
-                return true;
-
-            current = current->lexNext();
-        }
-    }
-    
-    if (parent->isIncludedInStmt(*stmt))
-        return true;
-    
-    return false;
-}
-
-static bool isLoopBoundary(SgStatement* stmt) {
-    if (!stmt)
-        return false;
-    
-    if (stmt->variant() == FOR_NODE || stmt->variant() == CONTROL_END)
-        return true;
-    
-    return false;
-}
-
-static bool isPartOfNestedLoop(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop)
-        return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd)
-        return false;
-    
-    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber())
-        return false;
-    
-    SgStatement* current = loopStart;
-    
-    while (current && current != loopEnd) {
-        
-        if (current->variant() == FOR_NODE && current != loop) {
-            SgForStmt* nestedLoop = (SgForStmt*)current;
-            SgStatement* nestedStart = nestedLoop->lexNext();
-            SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
-            
-            if (nestedStart && nestedEnd && 
-                stmt->lineNumber() >= nestedStart->lineNumber() && 
-                stmt->lineNumber() <= nestedEnd->lineNumber()) {
-                return true;
-            }
-        }
-        
-        current = current->lexNext();
-    }
-    
-    return false;
-}
-
-static bool canSafelyExtract(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop)
-        return false;
-    
-    if (isLoopBoundary(stmt))
-        return false;
-    
-    if (control_tags.find(stmt->variant()) != control_tags.end())
-        return false;
-    
-    if (isPartOfNestedLoop(stmt, loop))
-        return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd) 
-        return false;
-    
-    SgStatement* current = loopStart;
-    
-    while (current && current != loopEnd) {
-        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber())
-            return false;
-
-        if (control_tags.find(current->variant()) != control_tags.end())
-            if (isStatementEmbedded(stmt, current))
-                return false;
-
-        if (current == stmt) 
-            break;
-        current = current->lexNext();
-    }
-    
-    return true;
-}
-
-static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
-                                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    vector<OperatorInfo> operators;
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    if (!loopStart || !loopEnd)
-        return operators;
-    
-    SgStatement* current = loopStart;
-    unordered_set<SgStatement*> visited;
-    
-    while (current && current != loopEnd) {
-        
-        if (visited.find(current) != visited.end())
-            break;
-
-        visited.insert(current);
-        
-        if (isLoopBoundary(current)) {
-            current = current->lexNext();
-            continue;
-        }
-        
-        if (current->variant() == FOR_NODE && current != loop) {
-            SgStatement* nestedEnd = current->lastNodeOfStmt();
-            if (nestedEnd)
-                current = nestedEnd->lexNext();
-            else
-                current = current->lexNext();
-            continue;
-        }
-        
-        if (isSgExecutableStatement(current)) {
-            if (control_tags.find(current->variant()) != control_tags.end()) {
-                current = current->lexNext();
-                continue;
-            }
-
-            if (current->variant() != ASSIGN_STAT) {
-                current = current->lexNext();
-                continue;
-            }
-            
-            OperatorInfo opInfo(current);
-            
-            vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
-            for (auto irBlock : irBlocks) {
-                if (!irBlock || !irBlock->getInstruction()) 
-                    continue;
-                
-                const SAPFOR::Instruction* instr = irBlock->getInstruction();
-                if (instr->getArg1()) {
-                    string varName = getNameByArg(instr->getArg1());
-                    if (!varName.empty())
-                        opInfo.usedVars.insert(varName);
-                }
-
-                if (instr->getArg2()) {
-                    string varName = getNameByArg(instr->getArg2());
-                    if (!varName.empty())
-                        opInfo.usedVars.insert(varName);
-                }
-
-                if (instr->getResult()) {
-                    string varName = getNameByArg(instr->getResult());
-                    if (!varName.empty())
-                        opInfo.definedVars.insert(varName);
-                }
-            }
-            
-            operators.push_back(opInfo);
-        }
-        current = current->lexNext();
-    }
-    
-    return operators;
-}
-
-static map<string, vector<SgStatement*>> findVariableDefinitions(SgForStmt* loop, vector<OperatorInfo>& operators) {
-    map<string, vector<SgStatement*>> varDefinitions;
-    for (auto& op : operators)
-        for (const string& var : op.definedVars)
-            varDefinitions[var].push_back(op.stmt);
-
-    return varDefinitions;
-}
-
-static int calculateDistance(SgStatement* from, SgStatement* to) {
-    if (!from || !to) 
-        return INT_MAX;
-
-    return abs(to->lineNumber() - from->lineNumber());
-}
-
-static SgStatement* findBestPosition(SgStatement* operatorStmt, const vector<OperatorInfo>& operators, 
-                                     const map<string, vector<SgStatement*>>& varDefinitions, SgForStmt* loop) {
-    const OperatorInfo* opInfo = nullptr;
-    for (auto& op : operators) {
-        if (op.stmt == operatorStmt) {
-            opInfo = &op;
-            break;
-        }
-    }
-
-    if (!opInfo || !opInfo->isMovable)
-        return nullptr;
-    
-    SgStatement* bestPos = nullptr;
-    int bestLine = -1;
-    
-    for (const string& usedVar : opInfo->usedVars) {
-        if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-            for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
-                if (defStmt->lineNumber() < operatorStmt->lineNumber()) {
-                    if (defStmt->controlParent() == operatorStmt->controlParent()) {
-                        if (defStmt->lineNumber() > bestLine) {
-                            bestLine = defStmt->lineNumber();
-                            bestPos = defStmt;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    
-    if (!bestPos) {
-        bool allLoopCarried = true;
-        bool hasAnyDefinition = false;
-        
-        for (const string& usedVar : opInfo->usedVars) {
-            if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-                for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
-                    if (defStmt == operatorStmt)
-                        continue;
-                    
-                    hasAnyDefinition = true;
-                    if (defStmt->lineNumber() < operatorStmt->lineNumber() &&
-                        defStmt->controlParent() == operatorStmt->controlParent()) {
-                        allLoopCarried = false;
-                        break;
-                    }
-                }
-            }
-
-            if (!allLoopCarried) 
-                break;
-        }
-        
-        if (allLoopCarried || (!hasAnyDefinition && !opInfo->usedVars.empty())) {
-            SgStatement* loopStart = loop->lexNext();
-            return loopStart;
-        }
-    }
-    
-    return bestPos;
-}
-
-static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
-    if (!from || !to || from == to)
-        return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    if (!loopStart || !loopEnd) 
-        return false;
-    
-    if (to == loopStart) {
-        SgStatement* fromControlParent = from->controlParent();
-        if (!fromControlParent) fromControlParent = loop;
-        return fromControlParent == loop || fromControlParent == loopStart->controlParent();
-    }
-    
-    if (from->lineNumber() < loopStart->lineNumber() || from->lineNumber() > loopEnd->lineNumber())
-        return false;
-
-    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber())
-        return false;
-    
-    if (to->lineNumber() >= from->lineNumber())
-        return false;
-    
-    if (from->controlParent() != to->controlParent())
-        return false;
-    
-    SgStatement* current = to->lexNext();
-    while (current && current != from && current != loopEnd) {
-        if (control_tags.find(current->variant()) != control_tags.end()) {
-            SgStatement* controlEnd = current->lastNodeOfStmt();
-            if (controlEnd && from->lineNumber() <= controlEnd->lineNumber()) {
-                if (from->controlParent() == current && to->controlParent() != current) {
-                    return false;
-                }
-            }
-        }
-        current = current->lexNext();
-    }
-    
-    return true;
-}
-
-static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, 
-                                                  const vector<OperatorInfo>& operators, 
-                                                  const map<string, vector<SgStatement*>>& varDefinitions) {
-    vector<SgStatement*> newOrder;
-    for (auto& op : operators)
-        newOrder.push_back(op.stmt);
-    
-    map<SgStatement*, const OperatorInfo*> stmtToOpInfo;
-    for (auto& op : operators) 
-        stmtToOpInfo[op.stmt] = &op;
-    
-    bool changed = true;
-    
-    while (changed) {
-        changed = false;
-        
-        for (int i = operators.size() - 1; i >= 0; i--) {
-            if (!operators[i].isMovable) 
-                continue;
-            
-            SgStatement* stmt = operators[i].stmt;
-            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
-
-            if (!opInfo)
-                continue;
-            
-            size_t currentPos = 0;
-            for (size_t j = 0; j < newOrder.size(); j++) {
-                if (newOrder[j] == stmt) {
-                    currentPos = j;
-                    break;
-                }
-            }
-            
-            SgStatement* bestPos = findBestPosition(stmt, operators, varDefinitions, loop);
-            
-            if (!bestPos) {
-                bool hasDependents = false;
-                for (size_t j = currentPos + 1; j < newOrder.size(); j++) {
-                    SgStatement* candidate = newOrder[j];
-                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
-                    if (candidateOpInfo) {
-                        for (const string& definedVar : opInfo->definedVars) {
-                            if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
-                                hasDependents = true;
-                                break;
-                            }
-                        }
-
-                        if (hasDependents) 
-                            break;
-                    }
-                }
-                
-                continue;
-            }
-            
-            size_t targetPos = 0;
-            bool foundTarget = false;
-            
-            if (bestPos == loop->lexNext()) {
-                targetPos = 0;
-                
-                for (size_t j = 0; j < currentPos && j < newOrder.size(); j++) {
-                    SgStatement* candidate = newOrder[j];
-                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
-                    if (candidateOpInfo) {
-                        bool usesDefinedVar = false;
-                        for (const string& definedVar : opInfo->definedVars) {
-                            if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
-                                usesDefinedVar = true;
-                                break;
-                            }
-                        }
-
-                        if (usesDefinedVar) {
-                            targetPos = j;
-                            break;
-                        }
-                    }
-                }
-                
-                foundTarget = true;
-                
-                if (currentPos != targetPos && canMoveTo(stmt, bestPos, loop)) {
-                    newOrder.erase(newOrder.begin() + currentPos);
-                    newOrder.insert(newOrder.begin() + targetPos, stmt);
-                    changed = true;
-                }
-            } else {
-                size_t bestPosIdx = 0;
-                bool foundBestPos = false;
-                for (size_t j = 0; j < newOrder.size(); j++) {
-                    if (newOrder[j] == bestPos) {
-                        bestPosIdx = j;
-                        foundBestPos = true;
-                        break;
-                    }
-                }
-                
-                if (foundBestPos) {
-                    targetPos = bestPosIdx + 1;
-                    
-                    for (size_t j = bestPosIdx + 1; j < currentPos && j < newOrder.size(); j++) {
-                        SgStatement* candidate = newOrder[j];
-                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
-                        if (candidateOpInfo) {
-                            bool definesUsedVar = false;
-                            for (const string& usedVar : opInfo->usedVars) {
-                                if (candidateOpInfo->definedVars.find(usedVar) != candidateOpInfo->definedVars.end()) {
-                                    definesUsedVar = true;
-                                    break;
-                                }
-                            }
-                            if (definesUsedVar)
-                                targetPos = j + 1;
-                        }
-                    }
-                    
-                    bool wouldBreakDependency = false;
-                    for (size_t j = targetPos; j < currentPos && j < newOrder.size(); j++) {
-                        SgStatement* candidate = newOrder[j];
-                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
-                        if (candidateOpInfo) {
-                            for (const string& definedVar : opInfo->definedVars) {
-                                if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
-                                    wouldBreakDependency = true;
-                                    break;
-                                }
-                            }
-
-                            if (wouldBreakDependency) 
-                                break;
-                        }
-                    }
-                    
-                    if (!wouldBreakDependency && currentPos > targetPos && canMoveTo(stmt, bestPos, loop)) {
-                        newOrder.erase(newOrder.begin() + currentPos);
-                        newOrder.insert(newOrder.begin() + targetPos, stmt);
-                        changed = true;
-                    }
-                }
-            }
-        }
-    }
-    
-    bool dependencyViolation = true;
-    set<pair<SgStatement*, SgStatement*>> triedPairs;
-    
-    while (dependencyViolation) {
-        dependencyViolation = false;
-        triedPairs.clear();
-        
-        for (size_t i = 0; i < newOrder.size(); i++) {
-            SgStatement* stmt = newOrder[i];
-            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
-            if (!opInfo) 
-                continue;
-            
-            for (size_t j = 0; j < i; j++) {
-                SgStatement* prevStmt = newOrder[j];
-                const OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
-                if (!prevOpInfo)
-                    continue;
-                
-                pair<SgStatement*, SgStatement*> key = make_pair(stmt, prevStmt);
-                if (triedPairs.find(key) != triedPairs.end())
-                    continue;
-                
-                bool violation = false;
-                for (const string& definedVar : opInfo->definedVars) {
-                    if (prevOpInfo->usedVars.find(definedVar) != prevOpInfo->usedVars.end()) {
-                        violation = true;
-                        break;
-                    }
-                }
-                
-                if (violation) {
-                    triedPairs.insert(key);
-                    
-                    bool wouldCreateViolation = false;
-                    for (size_t k = j; k < i; k++) {
-                        SgStatement* betweenStmt = newOrder[k];
-                        const OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
-
-                        if (!betweenOpInfo)
-                            continue;
-                        
-                        for (const string& usedVar : opInfo->usedVars) {
-                            if (betweenOpInfo->definedVars.find(usedVar) != betweenOpInfo->definedVars.end()) {
-                                wouldCreateViolation = true;
-                                break;
-                            }
-                        }
-
-                        if (wouldCreateViolation)
-                            break;
-                    }
-                    
-                    if (!wouldCreateViolation) {
-                        newOrder.erase(newOrder.begin() + i);
-                        newOrder.insert(newOrder.begin() + j, stmt);
-                        dependencyViolation = true;
-                        break;
-                    }
-                }
-            }
-
-            if (dependencyViolation)
-                break;
-        }
-    }
-    
-    return newOrder;
-}
-
-static bool applyOperatorReordering(SgForStmt* loop, const vector<SgStatement*>& newOrder) {
-    if (!loop || newOrder.empty()) 
-        return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    if (!loopStart || !loopEnd) 
-        return false;
-    
-    vector<SgStatement*> originalOrder;
-    SgStatement* current = loopStart;
-    while (current && current != loopEnd) {
-        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT)
-            originalOrder.push_back(current);
-
-        current = current->lexNext();
-    }
-    
-    bool orderChanged = false;
-    if (originalOrder.size() == newOrder.size()) {
-        for (size_t i = 0; i < originalOrder.size(); i++) {
-            if (originalOrder[i] != newOrder[i]) {
-                orderChanged = true;
-                break;
-            }
-        }
-    } 
-    else
-        orderChanged = true;
-    
-    if (!orderChanged)
-        return false;
-
-    vector<SgStatement*> extractedStatements;
-    vector<char*> savedComments;
-    unordered_set<SgStatement*> extractedSet;
-    map<SgStatement*, int> originalLineNumbers;
-    map<SgStatement*, SgStatement*> stmtToExtracted;
-    
-    for (SgStatement* stmt : newOrder) {
-        if (stmt && stmt != loop && stmt != loopEnd && extractedSet.find(stmt) == extractedSet.end()) {
-            if (control_tags.find(stmt->variant()) != control_tags.end())
-                continue;
-            
-            if (!canSafelyExtract(stmt, loop))
-                continue;
-            
-            bool isMoving = false;
-            for (size_t i = 0; i < originalOrder.size(); i++) {
-                if (originalOrder[i] == stmt) {
-                    for (size_t j = 0; j < newOrder.size(); j++) {
-                        if (newOrder[j] == stmt && i != j) {
-                            isMoving = true;
-                            break;
-                        }
-                    }
-                    break;
-                }
-            }
-            
-            if (!isMoving)
-                continue;
-            
-            originalLineNumbers[stmt] = stmt->lineNumber();
-            savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
-            SgStatement* extracted = stmt->extractStmt();
-            if (extracted) {
-                extractedStatements.push_back(extracted);
-                extractedSet.insert(stmt);
-                stmtToExtracted[stmt] = extracted;
-            }
-        }
-    }
-    
-    map<SgStatement*, SgStatement*> insertedStatements;
-    
-    for (size_t idx = 0; idx < newOrder.size(); idx++) {
-        SgStatement* stmt = newOrder[idx];
-        
-        if (extractedSet.find(stmt) != extractedSet.end()) {
-            SgStatement* stmtToInsert = stmtToExtracted[stmt];
-
-            if (!stmtToInsert) 
-                continue;
-            
-            SgStatement* insertAfter = loop;
-            
-            for (int i = idx - 1; i >= 0; i--) {
-                SgStatement* prevStmt = newOrder[i];
-                
-                if (extractedSet.find(prevStmt) != extractedSet.end()) {
-                    if (insertedStatements.find(prevStmt) != insertedStatements.end()) {
-                        insertAfter = insertedStatements[prevStmt];
-                        break;
-                    }
-                } else {
-                    SgStatement* search = loop->lexNext();
-                    while (search && search != loopEnd) {
-                        bool skip = false;
-                        for (size_t j = idx; j < newOrder.size(); j++) {
-                            if (extractedSet.find(newOrder[j]) != extractedSet.end() && 
-                                search == newOrder[j]) {
-                                skip = true;
-                                break;
-                            }
-                        }
-                        if (skip) {
-                            search = search->lexNext();
-                            continue;
-                        }
-                        
-                        if (search == prevStmt) {
-                            insertAfter = search;
-                            break;
-                        }
-                        search = search->lexNext();
-                    }
-                    if (insertAfter != loop) break;
-                }
-            }
-            
-            size_t commentIdx = 0;
-            for (size_t i = 0; i < extractedStatements.size(); i++) {
-                if (extractedStatements[i] == stmtToInsert) {
-                    commentIdx = i;
-                    break;
-                }
-            }
-            
-            if (commentIdx < savedComments.size() && savedComments[commentIdx])
-                stmtToInsert->setComments(savedComments[commentIdx]);
-            
-            if (originalLineNumbers.find(stmt) != originalLineNumbers.end())
-                stmtToInsert->setlineNumber(originalLineNumbers[stmt]);
-            
-            SgStatement* controlParent = stmt->controlParent();
-            if (!controlParent)
-                controlParent = loop;
-            
-            insertAfter->insertStmtAfter(*stmtToInsert, *controlParent);
-            insertedStatements[stmt] = stmtToInsert;
-        }
-    }
-    
-    for (char* comment : savedComments) {
-        if (comment)
-            free(comment);
-    }
-    
-    return true;
-}
-
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    vector<SAPFOR::BasicBlock*> result;
-    Statement* forSt = (Statement*)st;
-
-    for (auto& func: FullIR) {
-        if (func.first->funcPointer->getCurrProcessFile() == forSt->getCurrProcessFile()
-            && func.first->funcPointer->lineNumber() == forSt->lineNumber())
-        {
-            result = func.second;
-        }
-    }
-    return result;
-}
-
-map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, const vector<SAPFOR::BasicBlock*>& blocks) {
-    map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
-    SgStatement *lastNode = st->lastNodeOfStmt();
-    
-    while (st && st != lastNode) {
-        if (loop_tags.find(st -> variant()) != loop_tags.end()) {
-            SgForStmt *forSt = (SgForStmt*)st;
-            SgStatement *loopBody = forSt -> body();
-            SgStatement *lastLoopNode = st->lastNodeOfStmt();
-            unordered_set<int> blocks_nums;
-            
-            while (loopBody && loopBody != lastLoopNode) {
-                vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(loopBody, blocks);
-                if (!irBlocks.empty()) {
-                    SAPFOR::IR_Block* IR = irBlocks.front();
-                    if (IR && IR->getBasicBlock()) {
-                        if (blocks_nums.find(IR -> getBasicBlock() -> getNumber()) == blocks_nums.end()) {
-                            result[forSt].push_back(IR -> getBasicBlock());
-                            blocks_nums.insert(IR -> getBasicBlock() -> getNumber());
-                        }
-                    }
-                }
-                loopBody = loopBody -> lexNext();
-            }
-            sort(result[forSt].begin(), result[forSt].end());
-        }
-        st = st -> lexNext();
-    }
-    return result;
-}
-
-static void processLoopRecursively(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
-                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    if (!loop) 
-        return;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (loopStart && loopEnd) {
-        SgStatement* current = loopStart;
-        while (current && current != loopEnd) {
-            if (current->variant() == FOR_NODE && current != loop) {
-                SgForStmt* nestedLoop = (SgForStmt*)current;
-                processLoopRecursively(nestedLoop, blocks, FullIR);
-                SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
-
-                if (nestedEnd)
-                    current = nestedEnd->lexNext();
-                else
-                    current = current->lexNext();
-            } 
-            else
-                current = current->lexNext();
-        }
-    }
-    
-    vector<OperatorInfo> operators = analyzeOperatorsInLoop(loop, blocks, FullIR);
-    if (!operators.empty()) {
-        map<string, vector<SgStatement*>> varDefinitions = findVariableDefinitions(loop, operators);
-        vector<SgStatement*> newOrder = optimizeOperatorOrder(loop, operators, varDefinitions);
-        applyOperatorReordering(loop, newOrder);
-    }
-}
-
-void moveOperators(SgFile *file, map<string, vector<LoopGraph*>>& loopGraph, 
-                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, 
-                   int& countOfTransform) {
-    countOfTransform += 1;
-    
-    //cout << "MOVE_OPERATORS Pass Started" << endl;
-
-    const int funcNum = file -> numberOfFunctions();
-    
-    for (int i = 0; i < funcNum; ++i) {
-        SgStatement *st = file -> functions(i);
-        
-        vector<SAPFOR::BasicBlock*> blocks = findFuncBlocksByFuncStatement(st, FullIR);        
-        map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
-        
-        for (auto& loopForAnalyze: loopsMapping)
-            processLoopRecursively(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-    }
-    
-    //cout << "MOVE_OPERATORS Pass Completed" << endl;
-}

src/Transformations/MoveOperators/move_operators.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include "../../GraphLoop/graph_loops.h"
-#include "../../CFGraph/CFGraph.h"
-
-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,6 +535,8 @@ 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;
 
@@ -600,7 +602,6 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
 
                     auto var = curr_stmt->variant();
 
-                    // TODO: does not work with user regions
                     if (var == PROC_HEDR || var == PROG_HEDR || var == FUNC_HEDR)
                     {
                         current_func_info = NULL;
@@ -627,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

@@ -316,10 +316,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE);
 
-    list({ 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);
-    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);
 
     passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, 
                                    EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW,

src/Utils/errors.h

@@ -78,6 +78,10 @@ enum typeMessage { WARR, ERROR, NOTE };
 //   60 "Format misplaced"
 //   61 "Array has declaration area conflict"
 //   62 "need to move common declaration to main for DECLATE"
+//   63 "Failed to initialize libpredict library"
+//   64 "Failed to distribute array with libpredict"
+//   65 "Failed to align array with libpredict"
+//   66 "Failed to process shadow_renew with libpredict"
 // 
 // 20xx TRANSFORM GROUP
 //   01 "can not convert array assign to loop"
@@ -305,7 +309,7 @@ static void printStackTrace() { };
     } \
 } while (0)
 
-// Свободный - R206
+// Свободный - R209
 // Гайд по русификации сообщений: При добавлении нового сообщения, меняется последний сводобный идентификатор.
 // В этом файле остаются только спецификаторы, для которых будет заполнен текст. Полный текст пишется в файле
 // russian_errors_text.txt. Спецификаторы там тоже сохраняются, по ним в визуализаторе будет восстановлен 
@@ -504,6 +508,14 @@ static const wchar_t *R183 = L"R183:";
 static const wchar_t *R184 = L"R184:%s";
 //1062
 static const wchar_t* R205 = L"R205:%s#%s";
+//1063
+static const wchar_t* R206 = L"R206:";
+//1064
+static const wchar_t* R207 = L"R207:";
+//1065
+static const wchar_t* R208 = L"R208:";
+//1066
+static const wchar_t* R209 = L"R209:";
 
 //2001
 static const wchar_t *R94 = L"R94:";

src/Utils/russian_errors_text.txt

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

src/Utils/version.h

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

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)
@@ -1793,22 +1793,6 @@ int SPF_RenameIncludes(void*& context, int winHandler, short* options, short* pr
     return simpleTransformPass(RENAME_INLCUDES, options, projName, folderName, output, outputMessage);
 }
 
-int SPF_InsertPrivateArrayDirectives(void*& context, int winHandler, short* options, short* projName, short* folderName, string& output, string& outputMessage)
-{
-    MessageManager::clearCache();
-    MessageManager::setWinHandler(winHandler);
-    ignoreArrayDistributeState = true;
-    sharedMemoryParallelization = 1;
-    return simpleTransformPass(FIND_PRIVATE_ARRAYS, options, projName, folderName, output, outputMessage);
-}
-
-int SPF_MoveOperators(void*& context, int winHandler, short* options, short* projName, short* folderName, string& output, string& outputMessage)
-{
-    MessageManager::clearCache();
-    MessageManager::setWinHandler(winHandler);
-    return simpleTransformPass(MOVE_OPERATORS, options, projName, folderName, output, outputMessage);
-}
-
 static inline void convertBackSlash(char *str, int strL)
 {
     for (int z = 0; z < strL; ++z)
@@ -1823,7 +1807,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 +2376,7 @@ const wstring Sapfor_RunAnalysis(const char* analysisName_c, const char* options
             retCode = SPF_GetArrayLinks(context, winHandler, optSh, projSh, result, output, outputMessage);
         else if (whichRun == "SPF_GetMaxMinBlockDistribution")
             retCode = SPF_GetMaxMinBlockDistribution(context, winHandler, optSh, projSh, result, output, outputMessage);
-        else if (whichRun == "SPF_ÑhangeDirectory") // russian C
+        else if (whichRun == "SPF_<EFBFBD>hangeDirectory") // russian C
         {
             if (options_c == NULL)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -2515,10 +2499,6 @@ const wstring Sapfor_RunTransformation(const char* transformName_c, const char*
         retCode = SPF_InsertImplicitNone(context, winHandler, optSh, projSh, fold, output, outputMessage);
     else if (whichRun == "SPF_RenameIncludes")
         retCode = SPF_RenameIncludes(context, winHandler, optSh, projSh, fold, output, outputMessage);
-    else if (whichRun == "SPF_InsertPrivateArrayDirectives")
-        retCode = SPF_InsertPrivateArrayDirectives(context, winHandler, optSh, projSh, fold, output, outputMessage);
-    else if (whichRun == "SPF_MoveOperators")
-        retCode = SPF_MoveOperators(context, winHandler, optSh, projSh, fold, output, outputMessage);
     else if (whichRun == "SPF_CreateParallelVariant")
     {
         vector<string> splited;