change propagation

.gitignore

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

CMakeLists.txt

@@ -163,6 +163,10 @@ 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
@@ -204,8 +208,6 @@ 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)
-SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
-        src/Transformations/SwapOperators/swap_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -228,8 +230,7 @@ set(TRANSFORMS
         ${TR_REPLACE_ARRAYS_IN_IO}
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS}
-        ${TR_SWAP_OPERATORS})
+        ${TR_RENAME_SYMBOLS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -423,6 +424,7 @@ set(SOURCE_EXE
     ${TRANSFORMS}
     ${PARALLEL_REG}
     ${PRIV}
+    ${ARRAY_PROP}
     ${FDVM}
     ${OMEGA}
     ${UTILS}
@@ -462,7 +464,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\\SwapOperators FILES ${TR_SWAP_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -475,6 +476,7 @@ 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

@@ -0,0 +1,342 @@
+#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 unordered_set<SgStatement*> changed;;
+
+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;
+    if (changed.find(st) != changed.end())
+        return;
+    string expUnparsed = exp->unparse();
+    if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
+    {
+        arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
+    }
+    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());
+    changed.insert(st);
+}
+
+static void TransformBorder(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
+{
+    SgStatement* firstStatement = declPlace->lexPrev();
+    st = st->lexPrev();
+    string array = exp->unparse();
+    arrayToVariable[array] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
+    while (st != firstStatement)
+    {
+        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+        {
+            if (st->expr(1))
+            {
+                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+            }
+            if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()) && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+            {
+                TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
+            }
+        }
+        st = st->lexPrev();
+    }
+}
+
+static void CheckVariable(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
+{
+    SgStatement* firstStatement = declPlace->lexPrev();
+    st = st->lexPrev();
+    string varName = exp->unparse();
+    while (st != firstStatement)
+    {
+        if (st->variant() == ASSIGN_STAT && st->expr(0)->symbol() == exp->symbol())
+        {
+            TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+        }
+        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+        {
+            if (st->expr(1))
+            {
+                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+            }
+            if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()) && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+            {
+                TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
+            }
+        }
+        st = st->lexPrev();
+    }
+}
+
+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() == 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()))
+                    {
+                        TransformBorder(st, upperBound, arrayToVariable, variableNumber);
+                        st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
+                    }
+                    else if (upperBound->variant() == VAR_REF)
+                        CheckVariable(st, upperBound, arrayToVariable, variableNumber);
+
+                    if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
+                    {
+                        TransformBorder(st, lowerBound, arrayToVariable, variableNumber);
+                        st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
+                    }
+                    else if (lowerBound->variant() == VAR_REF)
+                        CheckVariable(st, lowerBound, arrayToVariable, variableNumber);
+                }
+            }
+            cout << file->functions(i)->unparse() << endl;
+        }
+    }
+}

src/ArrayConstantPropagation/propagation.h

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

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>> coefsByDims;
+    vector<vector<attrType>> coeffsByDims;
     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)
-                coefsByDims.push_back(reducedG.GetAllAttributes(V));
+                coeffsByDims.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() && coefsByDims[z].size())
+                if (toCmp[z].size() && coeffsByDims[z].size())
                 {
-                    if (toCmp[z].back().first.first > coefsByDims[z].back().first.first)
+                    if (toCmp[z].back().first.first > coeffsByDims[z].back().first.first)
                     {
-                        coefsByDims = toCmp;
+                        coeffsByDims = 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*> &coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
-                    if (coefs.size() == 1)
+                    const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                    if (coeffs.size() == 1)
                     {
-                        const pair<int, int> coef(coefs[0][0], coefs[0][1]);
+                        const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
                         auto it = shiftsByAccess[i].find(coef);
                         if (it != shiftsByAccess[i].end())
                             if (it->second != 0)

src/Distribution/DvmhDirectiveBase.cpp

@@ -364,11 +364,11 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
             {
                 if (sharedMemoryParallelization)
                 {
-                    for (auto& coefs : currReadOp->first[k].coefficients)
+                    for (auto& coeffs : currReadOp->first[k].coefficients)
                     {
-                        auto currAccess = coefs.first;
+                        auto currAccess = coeffs.first;
 
-                        const int currShift = coefs.first.second;
+                        const int currShift = coeffs.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 &coefs : currReadOp->first[k].coefficients)
+                            for (auto &coeffs : currReadOp->first[k].coefficients)
                             {
-                                auto currAccess = coefs.first;
+                                auto currAccess = coeffs.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(coefs);
+                                    it->second[k].coefficients.insert(coeffs);
                                 }
                             }
 

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 &coefs : ops.coefficients)
+        for (auto &coeffs : ops.coefficients)
         {
-            if (coefs.first.first != 0)
+            if (coeffs.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> coefs = pair<int, int>(0, 0);
+    pair<int, int> coeffs = 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())
             {
-                coefs.first = 1;
+                coeffs.first = 1;
                 needToCacl = false;
             }
         }
 
         if (needToCacl)
-            getCoefsOfSubscript(coefs, subscr, parentLoops[position]->doName());
-        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coefs.first, coefs.second);
+            getCoefsOfSubscript(coeffs, subscr, parentLoops[position]->doName());
+        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coeffs.first, coeffs.second);
 
-        if (coefs.first == 0) // && coefs.second == 0)
+        if (coeffs.first == 0) // && coeffs.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, coefs, UNREC_OP, numOfSubscriptions, currentW);
+                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, 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(coefs);
+                    auto itAdd = currOp[dimNum].coefficients.find(coeffs);
                     if (itAdd == currOp[dimNum].coefficients.end())
-                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coefs, currentW));
+                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coeffs, currentW));
                 }
 
-                if (coefs.first < 0)
+                if (coeffs.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 (coefs.first < 0 && sharedMemoryParallelization == 0)
+            if (coeffs.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, coefs, UNREC_OP, numOfSubscriptions, currentW);
+                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
                 }
             }
             else
             {
                 if (side == LEFT)
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, WRITE_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, WRITE_OP, numOfSubscriptions, currentW);
                 else
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, READ_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, 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] = coefs.first;
-        valueSubs[1] = coefs.second;
+        valueSubs[0] = coeffs.first;
+        valueSubs[1] = coeffs.second;
 #ifdef __SPF
         addToCollection(__LINE__, __FILE__, valueSubs, 2);
 #endif
-        const vector<int*> &coefs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
-        if (coefs.size() == 0)
+        const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
+        if (coeffs.size() == 0)
         {
             subscr->addAttribute(INT_VAL, valueSubs, sizeof(int*));
             if (position != -1 && allPositions.size() == 1 && position < parentLoops.size())

src/Predictor/PredictScheme.cpp

@@ -326,7 +326,7 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
         list = list->rhs();
     }
 
-    vector<pair<int, int>> coefs(srcSymbs.size());
+    vector<pair<int, int>> coeffs(srcSymbs.size());
     list = listTgt;
     while (list)
     {
@@ -337,8 +337,8 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
             has = recSymbolFind(exp, srcSymbs[z].first, VAR_REF);
             if (has)
             {
-                getCoefsOfSubscript(coefs[z], exp, srcSymbs[z].second);
-                if (coefs[z].first == 0)
+                getCoefsOfSubscript(coeffs[z], exp, srcSymbs[z].second);
+                if (coeffs[z].first == 0)
                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                 break;
             }
@@ -346,14 +346,14 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
         list = list->rhs();
     }
 
-    for (int z = 0; z < coefs.size(); ++z)
+    for (int z = 0; z < coeffs.size(); ++z)
     {
-        if (coefs[z].first == 0)
+        if (coeffs[z].first == 0)
             continue;
-        if (coefs[z].second)
-            align["rules"].push_back({ z, coefs[z].first });
+        if (coeffs[z].second)
+            align["rules"].push_back({ z, coeffs[z].first });
         else
-            align["rules"].push_back({ z, coefs[z].first, coefs[z].second });
+            align["rules"].push_back({ z, coeffs[z].first, coeffs[z].second });
     }
     return align;
 }

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -12,9 +12,38 @@
 #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())
@@ -37,13 +66,15 @@ 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]);
 
-    for (auto& [arrayName, arrayRanges] : useUnion)
-        region->array_priv[arrayName] = useUnion[arrayName].Diff(region->array_use[arrayName]);
+    ArrayAccessingIndexes useUnionB;
+    for (auto& byBlock : region->getBasickBlocks())
+        for (auto& [arrayName, _] : byBlock->array_use)
+            useUnionB[arrayName] = useUnionB[arrayName].Union(byBlock->array_use[arrayName]);
+
+    for (auto& [arrayName, _] : useUnionB)
+        region->array_priv[arrayName] = useUnionB[arrayName].Diff(region->array_use[arrayName]);
+
     
     for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
         prevBlock->replaceInNextRegions(region, region->getHeader());
@@ -74,6 +105,7 @@ static void SolveDataFlowIteratively(Region* DFG)
                     newIn.clear();
                     continue;
                 }
+
                 for (const auto& [arrayName, accessSet] : prevBlock->array_out)
                 {
                     if (newIn.find(arrayName) != newIn.end())
@@ -86,6 +118,7 @@ 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())
@@ -121,21 +154,83 @@ static void SolveDataFlow(Region* DFG)
     Collapse(DFG);
 }
 
-map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
+static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
+{
+    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& [loopName, loops] : loopGraph)
+    for (const auto& [fileName, 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);
+                    if (loopRegion->getBasickBlocks().size() <= 1)
+                    {
+                        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,11 +2,12 @@
 
 #include <vector>
 #include <map>
+#include <set>
 #include <unordered_set>
 
 #include "range_structures.h"
 #include "graph_loops.h"
 #include "CFGraph/CFGraph.h"
 
-std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
+void FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, std::set<SgStatement*>& insertedPrivates);
 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 };
+    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array};
     return result;
 }
 
@@ -61,21 +61,16 @@ 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 });
+        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array});
     
     /* add the parts between intersection steps */
+    if (intersection->step > dim1.step)
+    {
         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++)
+        for (int64_t i = start; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
         {
-        uint64_t centerValue = dim1.start + i * dim1.step;
-        if (centerValue == interValue)
-        {
-            if (i - start > 1)
-            {
-                result.push_back({ dim1.start + (start + 1) * dim1.step, dim1.step, i - start - 1 });
-                start = i;
-            }
+            result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
             interValue += intersection->step;
         }
     }
@@ -85,7 +80,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 });
+        result.push_back({ right_start, dim1.step, tripCount, dim1.array });
     }
     delete(intersection);
     return result;
@@ -216,6 +211,10 @@ 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,9 +6,12 @@
 #include <string>
 #include <cstdint>
 
+#include "SgUtils.h"
+
 struct ArrayDimension
 {
     uint64_t start, step, tripCount;
+    SgArrayRefExp* array;
 };
 
 class AccessingSet {

src/PrivateAnalyzer/region.cpp

@@ -4,10 +4,12 @@
 #include<unordered_map>
 #include<string>
 #include <numeric>
+#include <iostream>
 
 #include "range_structures.h"
 #include "region.h"
 
+#include "..\Transformations\ExpressionSubstitution\expr_transform.h"
 #include "SgUtils.h"
 
 using namespace std;
@@ -104,15 +106,33 @@ 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;
-            if (operation == SAPFOR::CFG_OP::STORE)
-                array_name = instruction->getInstruction()->getArg1()->getValue();            
-            else
-                array_name = instruction->getInstruction()->getArg2()->getValue();
+            string array_name = instruction->getInstruction()->getArg1()->getValue();
 
             int j = i - 1;
             while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
@@ -127,7 +147,10 @@ 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;
+            int subs = ref->numberOfSubscripts();
             for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
             {
                 const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
@@ -138,18 +161,15 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                 }
 
             }
+            coefsForDims = {coefsForDims.rbegin(), coefsForDims.rend()};
 
-            if(coefsForDims.empty())
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            while (!index_vars.empty())
+            while (!index_vars.empty() && !refPos.empty() && !coefsForDims.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 };
+                    current_dim = { stoul(var->getValue()), 1, 1, ref };
                 else
                 {
                     string name, full_name = var->getValue();
@@ -175,23 +195,31 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                             return -1;
                     }
 
-                    uint64_t start = currentLoop->startVal * currentCoefs.first + currentCoefs.second;
-                    uint64_t step = currentCoefs.first;
-                    current_dim = { start, step, (uint64_t)currentLoop->calculatedCountOfIters };
+                    uint64_t start = coefsForDims.back().second * currentLoop->startVal + coefsForDims.back().first;
+                    uint64_t step = currentLoop->stepVal;
+                    uint64_t iters = 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;
+                    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);
                 else
                     use[array_name].Insert(accessPoint);
             }
         }
+    }
     return 0;
 
 }
@@ -227,8 +255,11 @@ 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;
 }
 
@@ -247,5 +278,9 @@ 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,6 +46,7 @@
 #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"
@@ -89,7 +90,6 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/SwapOperators/swap_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
@@ -280,6 +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);
 
             for (auto& elem : toDel)
@@ -940,8 +941,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
-        else if (curr_regime == SWAP_OPERATORS)        
-            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1022,8 +1021,6 @@ 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 +1037,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_REMOVING,
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
-                          REMOVE_DEAD_CODE,
-                          SWAP_OPERATORS };
+                          REMOVE_DEAD_CODE };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -1920,6 +1916,11 @@ 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.;
@@ -2338,7 +2339,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 SWAP_OPERATORS:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:
@@ -2378,6 +2378,7 @@ 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
@@ -2639,7 +2640,7 @@ int main(int argc, char **argv)
             }
         }
 
-        if (curr_regime == INSERT_PARALLEL_DIRS_NODIST)
+        if (curr_regime == INSERT_PARALLEL_DIRS_NODIST || curr_regime == FIND_PRIVATE_ARRAYS)
         {
             ignoreArrayDistributeState = true;
             sharedMemoryParallelization = 1;

src/Sapfor.h

@@ -122,8 +122,6 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    SWAP_OPERATORS,
-
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
     FILL_PARALLEL_REG_IR,
@@ -185,9 +183,11 @@ enum passes {
     SET_IMPLICIT_NONE,
     RENAME_INLCUDES,
 
+    FIND_PRIVATE_ARRAYS_ANALYSIS,
     FIND_PRIVATE_ARRAYS,
 
     TRANSFORM_ASSUMED_SIZE_PARAMETERS,
+    ARRAY_PROPAGATION,
 
     TEST_PASS,
     EMPTY_PASS
@@ -321,7 +321,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[SWAP_OPERATORS] = "SWAP_OPERATORS";
     passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";
@@ -374,9 +373,11 @@ 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

@@ -175,6 +175,11 @@ 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>>> coefsRead[2], coefsWrite[2];
+            vector<set<pair<int, int>>> coeffsRead[2], coeffsWrite[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 (coefsRead[k].size() == 0)
-                        coefsRead[k].resize(it->second.size());
+                    if (coeffsRead[k].size() == 0)
+                        coeffsRead[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)
-                                coefsRead[k][z].insert(coef.first);
+                                coeffsRead[k][z].insert(coef.first);
                 }
 
                 auto itW = currLoop[k]->writeOpsForLoop.find(array);
                 if (itW != currLoop[k]->writeOpsForLoop.end())
                 {
-                    if (coefsWrite[k].size() == 0)
-                        coefsWrite[k].resize(itW->second.size());
+                    if (coeffsWrite[k].size() == 0)
+                        coeffsWrite[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)
-                                coefsWrite[k][z].insert(coef.first);
+                                coeffsWrite[k][z].insert(coef.first);
                 }
             }
 
             //нет записей, значит нет зависимости
             bool nulWrite = true;
-            for (auto& wr : coefsWrite)
+            for (auto& wr : coeffsWrite)
                 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(coefsWrite[0].size(), coefsRead[0].size());
+            const int len = std::max(coeffsWrite[0].size(), coeffsRead[0].size());
             int countW[2] = { 0, 0 };
             int countR[2] = { 0, 0 };
 
             for (int L = 0; L < 2; ++L)
-                for (int z = 0; z < coefsWrite[L].size(); ++z)
-                    countW[L] += (coefsWrite[L][z].size() ? 1 : 0);
+                for (int z = 0; z < coeffsWrite[L].size(); ++z)
+                    countW[L] += (coeffsWrite[L][z].size() ? 1 : 0);
 
             for (int L = 0; L < 2; ++L)
-                for (int z = 0; z < coefsRead[L].size(); ++z)
-                    countR[L] += (coefsRead[L][z].size() ? 1 : 0);
+                for (int z = 0; z < coeffsRead[L].size(); ++z)
+                    countR[L] += (coeffsRead[L][z].size() ? 1 : 0);
 
             for (int p = 0; p < len; ++p)
             {
-                if (coefsWrite[1].size() && coefsWrite[0].size())
-                    if (coefsWrite[0][p].size() != 0 && coefsWrite[1][p].size() != 0)
-                        if (coefsWrite[0][p] != coefsWrite[1][p])
+                if (coeffsWrite[1].size() && coeffsWrite[0].size())
+                    if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() != 0)
+                        if (coeffsWrite[0][p] != coeffsWrite[1][p])
                             return true;
 
-                if (coefsRead[1].size() && coefsWrite[0].size())
-                    if (coefsWrite[0][p].size() != 0 && coefsRead[1][p].size() != 0)
-                        if (coefsWrite[0][p] != coefsRead[1][p])
+                if (coeffsRead[1].size() && coeffsWrite[0].size())
+                    if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() != 0)
+                        if (coeffsWrite[0][p] != coeffsRead[1][p])
                             return true;
 
-                if (coefsWrite[1].size() && coefsRead[0].size())
-                    if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() != 0)
-                        if (coefsWrite[1][p] != coefsRead[0][p])
+                if (coeffsWrite[1].size() && coeffsRead[0].size())
+                    if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() != 0)
+                        if (coeffsWrite[1][p] != coeffsRead[0][p])
                             return true;
                 
 
                 //отображение на разные измерения
-                if (coefsWrite[1].size() && coefsWrite[0].size())
+                if (coeffsWrite[1].size() && coeffsWrite[0].size())
                 {
-                    if (coefsWrite[0][p].size() != 0 && coefsWrite[1][p].size() == 0 && countW[1] ||
-                        coefsWrite[0][p].size() == 0 && coefsWrite[1][p].size() != 0 && countW[0])
+                    if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() == 0 && countW[1] ||
+                        coeffsWrite[0][p].size() == 0 && coeffsWrite[1][p].size() != 0 && countW[0])
                         return true;
                 }
 
-                if (coefsRead[1].size() && coefsWrite[0].size())
+                if (coeffsRead[1].size() && coeffsWrite[0].size())
                 {
-                    if (coefsWrite[0][p].size() != 0 && coefsRead[1][p].size() == 0 && countR[1] ||
-                        coefsWrite[0][p].size() == 0 && coefsRead[1][p].size() != 0 && countW[0])
+                    if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() == 0 && countR[1] ||
+                        coeffsWrite[0][p].size() == 0 && coeffsRead[1][p].size() != 0 && countW[0])
                         return true;
                 }
 
-                if (coefsWrite[1].size() && coefsRead[1].size())
+                if (coeffsWrite[1].size() && coeffsRead[1].size())
                 {
-                    if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() == 0 && countR[0] ||
-                        coefsWrite[1][p].size() == 0 && coefsRead[0][p].size() != 0 && countW[1])
+                    if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() == 0 && countR[0] ||
+                        coeffsWrite[1][p].size() == 0 && coeffsRead[0][p].size() != 0 && countW[1])
                         return true;
                 }
 
                 //где то нет правил отображения вообще, но есть факт его наличия. 
-                if ( ((coefsWrite[0].size() == 0 && coefsRead[0].size() == 0) && (countW[0] == 0 && countR[0] == 0)) 
+                if ( ((coeffsWrite[0].size() == 0 && coeffsRead[0].size() == 0) && (countW[0] == 0 && countR[0] == 0)) 
                     ||
-                    ((coefsWrite[1].size() == 0 && coefsRead[1].size() == 0) && (countW[1] == 0 && countR[1] == 0)) )
+                    ((coeffsWrite[1].size() == 0 && coeffsRead[1].size() == 0) && (countW[1] == 0 && countR[1] == 0)) )
                     return true;
             }
             

src/Transformations/SwapOperators/swap_operators.cpp

@@ -1,422 +0,0 @@
-#include <map>
-#include <unordered_set>
-#include <vector>
-#include <queue>
-#include <iostream>
-
-#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 "swap_operators.h"
-
-using namespace std;
-
-
-unordered_set<int> loop_tags = {FOR_NODE/*, FORALL_NODE, WHILE_NODE, DO_WHILE_NODE*/};
-unordered_set<int> importantDepsTags = {FOR_NODE, IF_NODE};
-unordered_set<int> importantUpdDepsTags = {ELSEIF_NODE};
-unordered_set<int> importantEndTags = {CONTROL_END};
-
-
-vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, 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;
-}
-
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, 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, 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())
-        {
-            // part with find statements of loop
-            SgForStmt *forSt = (SgForStmt*)st;
-            SgStatement *loopBody = forSt -> body();
-            SgStatement *lastLoopNode = st->lastNodeOfStmt();
-            // part with find blocks and instructions of loops
-            unordered_set<int> blocks_nums;
-            while (loopBody && loopBody != lastLoopNode)
-            {
-                SAPFOR::IR_Block* IR = findInstructionsFromOperator(loopBody, blocks).front();
-                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();
-            }
-            std::sort(result[forSt].begin(), result[forSt].end());
-        }
-        st = st -> lexNext();
-    }
-    return result;
-}
-
-map<SgStatement*, set<SgStatement*>> AnalyzeLoopAndFindDeps(SgForStmt* forStatement, vector<SAPFOR::BasicBlock*> loopBlocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
-{
-    map<SgStatement*, set<SgStatement*>> result;
-    for (SAPFOR::BasicBlock* bb: loopBlocks)
-    {
-        map<SAPFOR::Argument*, set<int>> blockReachingDefinitions = bb -> getRD_In();
-        vector<SAPFOR::IR_Block*> instructions = bb -> getInstructions();
-        for (SAPFOR::IR_Block* irBlock: instructions)
-        {
-            // TODO: Think about what to do with function calls and array references. Because there are also dependencies there that are not reflected in RD, but they must be taken into account
-            SAPFOR::Instruction* instr = irBlock -> getInstruction();
-            result[instr -> getOperator()];
-            // take Argument 1 and it's RD and push operators to final set
-            if (instr -> getArg1() != NULL)
-            {
-                SAPFOR::Argument* arg = instr -> getArg1();
-                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
-                for (int i: prevInstructionsNumbers)
-                {
-                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
-                    if (foundInstruction != NULL)
-                    {
-                        SgStatement* prevOp = foundInstruction -> getOperator();
-                        if (prevOp != forStatement && instr -> getOperator() != forStatement && instr -> getOperator() -> lineNumber() > prevOp -> lineNumber()
-                            && prevOp -> lineNumber() > forStatement -> lineNumber())
-                            result[instr -> getOperator()].insert(prevOp);
-                    }
-                }
-            }
-            // take Argument 2 (if exists) and it's RD and push operators to final set
-            if (instr -> getArg2() != NULL)
-            {
-                SAPFOR::Argument* arg = instr -> getArg2();
-                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
-                for (int i: prevInstructionsNumbers)
-                {
-                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
-                    if (foundInstruction != NULL)
-                    {
-                        SgStatement* prevOp = foundInstruction -> getOperator();
-                        if (prevOp != forStatement && instr -> getOperator() != forStatement&& instr -> getOperator() -> lineNumber() > prevOp -> lineNumber()
-                            && prevOp -> lineNumber() > forStatement -> lineNumber())
-                            result[instr -> getOperator()].insert(prevOp);
-                    }
-                }
-            }
-            // update RD
-            if (instr -> getResult() != NULL)
-                blockReachingDefinitions[instr -> getResult()] = {instr -> getNumber()};
-        }
-    }
-    return result;
-}
-
-void buildAdditionalDeps(SgForStmt* forStatement, map<SgStatement*, set<SgStatement*>>& dependencies)
-{
-    SgStatement* lastNode = forStatement->lastNodeOfStmt();
-    vector<SgStatement*> importantDeps;
-    SgStatement* st = (SgStatement*) forStatement;
-    st = st -> lexNext();
-    SgStatement* logIfOp = NULL;
-    while (st && st != lastNode)
-    {
-        if(importantDeps.size() != 0)
-        {
-            if (st != importantDeps.back())
-            {
-                dependencies[st].insert(importantDeps.back());
-            }
-        }
-        if (logIfOp != NULL)
-        {
-            dependencies[st].insert(logIfOp);
-            logIfOp = NULL;
-        }
-        if (st -> variant() == LOGIF_NODE)
-        {
-            logIfOp = st;
-        }
-        if (importantDepsTags.find(st -> variant()) != importantDepsTags.end())
-        {
-            importantDeps.push_back(st);
-        }
-        if (importantUpdDepsTags.find(st -> variant()) != importantUpdDepsTags.end())
-        {
-            importantDeps.pop_back();
-            importantDeps.push_back(st);
-        }
-        if (importantEndTags.find(st -> variant()) != importantEndTags.end())
-        {
-            if(importantDeps.size() != 0)
-            {
-                importantDeps.pop_back();
-            }
-        }
-        st = st -> lexNext();
-    }
-}
-
-struct ReadyOp {
-    SgStatement* stmt;
-    int degree;
-    size_t arrival;
-    ReadyOp(SgStatement* s, int d, size_t a): stmt(s), degree(d), arrival(a) {}
-};
-
-struct ReadyOpCompare {
-    bool operator()(const ReadyOp& a, const ReadyOp& b) const {
-        if (a.degree != b.degree)
-            return a.degree > b.degree;
-        else
-            return a.arrival > b.arrival;
-    }
-};
-
-vector<SgStatement*> scheduleOperations(const map<SgStatement*, set<SgStatement*>>& dependencies)
-{
-    // get all statements
-    unordered_set<SgStatement*> allStmtsSet;
-    for (const auto& pair : dependencies)
-    {
-        allStmtsSet.insert(pair.first);
-        for (SgStatement* dep : pair.second)
-        {
-            allStmtsSet.insert(dep);
-        }
-    }
-    vector<SgStatement*> allStmts(allStmtsSet.begin(), allStmtsSet.end());
-    // count deps and build reversed graph
-    unordered_map<SgStatement*, vector<SgStatement*>> graph;
-    unordered_map<SgStatement*, int> inDegree;
-    unordered_map<SgStatement*, int> degree;
-    for (auto op : allStmts)
-        inDegree[op] = 0;
-    // find and remember initial dependencies
-    unordered_set<SgStatement*> dependentStmts;
-    for (const auto& pair : dependencies)
-    {
-        SgStatement* op = pair.first;
-        const auto& deps = pair.second;
-        degree[op] = deps.size();
-        inDegree[op] = deps.size();
-        if (!deps.empty())
-            dependentStmts.insert(op);
-        for (auto dep : deps)
-            graph[dep].push_back(op);
-    }
-    for (SgStatement* op : allStmts)
-    {
-        if (!degree.count(op))
-        {
-            degree[op] = 0;
-        }
-    }
-    // build queues
-    using PQ = priority_queue<ReadyOp, vector<ReadyOp>, ReadyOpCompare>;
-    PQ readyDependent;
-    queue<SgStatement*> readyIndependent;
-    size_t arrivalCounter = 0;
-    for (auto op : allStmts)
-    {
-        if (inDegree[op] == 0)
-        {
-            if (dependentStmts.count(op))
-            {
-                readyDependent.emplace(op, degree[op], arrivalCounter++);
-            }
-            else
-            {
-                readyIndependent.push(op);
-            }
-        }
-    }
-    // main sort algorythm
-    vector<SgStatement*> executionOrder;
-    while (!readyDependent.empty() || !readyIndependent.empty())
-    {
-        SgStatement* current = nullptr;
-        if (!readyDependent.empty())
-        {
-            current = readyDependent.top().stmt;
-            readyDependent.pop();
-        }
-        else
-        {
-            current = readyIndependent.front();
-            readyIndependent.pop();
-        }
-        executionOrder.push_back(current);
-        for (SgStatement* neighbor : graph[current])
-        {
-            inDegree[neighbor]--;
-            if (inDegree[neighbor] == 0) {
-                if (dependentStmts.count(neighbor))
-                {
-                    readyDependent.emplace(neighbor, degree[neighbor], arrivalCounter++);
-                }
-                else
-                {
-                    readyIndependent.push(neighbor);
-                }
-            }
-        }
-    }
-    return executionOrder;
-}
-
-static bool buildNewAST(SgStatement* loop, vector<SgStatement*>& newBody)
-{
-    if (!loop) {return false;}   
-    if (newBody.empty()) {return true;}
-    if (loop->variant() != FOR_NODE) {return false;}
-
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd) {return false;}
-
-    for (SgStatement* stmt : newBody) {
-        if (stmt && stmt != loop && stmt != loopEnd) {
-            SgStatement* current = loopStart;
-            bool found = false;
-            while (current && current != loopEnd->lexNext()) {
-                if (current == stmt) {
-                    found = true;
-                    break;
-                }
-                current = current->lexNext();
-            }
-            if (!found) {return false;}
-        }
-    }
-
-    vector<SgStatement*> extractedStatements;
-    vector<char*> savedComments;
-    vector<int> savedLineNumbers;
-
-    for (SgStatement* stmt : newBody) {
-        if (stmt && stmt != loop && stmt != loopEnd) {
-            savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
-            savedLineNumbers.push_back(stmt->lineNumber());
-            SgStatement* extracted = stmt->extractStmt();
-            if (extracted) {extractedStatements.push_back(extracted);}
-        }
-    }
-
-    SgStatement* currentPos = loop;
-    int lineCounter = loop->lineNumber() + 1;
-    
-    for (size_t i = 0; i < extractedStatements.size(); i++) {
-        SgStatement* stmt = extractedStatements[i];
-        if (stmt) {
-            if (i < savedComments.size() && savedComments[i]) {
-                stmt->setComments(savedComments[i]);
-            }
-            stmt->setlineNumber(lineCounter++);
-            currentPos->insertStmtAfter(*stmt, *loop);
-            currentPos = stmt;
-        }
-    }
-
-    for (char* comment : savedComments) {
-        if (comment) {
-            free(comment);
-        }
-    }
-
-    if (currentPos && currentPos->lexNext() != loopEnd) {
-        currentPos->setLexNext(*loopEnd);
-    }
-    
-    return true;
-}
-
-static bool validateNewOrder(SgStatement* loop, const vector<SgStatement*>& newOrder)
-{
-    if (!loop || newOrder.empty()) {
-        return true;
-    }
-    unordered_set<SgStatement*> seen;
-    for (SgStatement* stmt : newOrder) {
-        if (stmt && stmt != loop && stmt != loop->lastNodeOfStmt()) {
-            if (seen.count(stmt)) {
-                return false;
-            }
-            seen.insert(stmt);
-        }
-    }
-    return true;
-}
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform)
-{
-    std::cout << "SWAP_OPERATORS Pass" << std::endl;    // to remove
-    countOfTransform += 1;                              // to remove
-
-    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 (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping)
-        {
-            map<SgStatement*, set<SgStatement*>> dependencyGraph = AnalyzeLoopAndFindDeps(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-            // TODO: Write a function that will go through the operators and update all dependencies so that there are no mix-ups and splits inside the semantic blocks (for if, do and may be some other cases)
-            buildAdditionalDeps(loopForAnalyze.first, dependencyGraph);
-            cout << endl;
-            int firstLine = loopForAnalyze.first -> lineNumber();
-            int lastLine = loopForAnalyze.first -> lastNodeOfStmt() -> lineNumber();
-            cout << "LOOP ANALYZE FROM " << firstLine << " TO " << lastLine << " RES" << endl;
-            // for (auto &v: dependencyGraph) {
-            //     cout << "OPERATOR: " << v.first -> lineNumber()  << "    " << v.first -> variant() << "\nDEPENDS ON:" << endl;
-            //     if (v.second.size() != 0)
-            //         for (auto vv: v.second)
-            //             cout << vv -> lineNumber() << "  ";
-            //     cout << endl;
-            // }
-            vector<SgStatement*> new_order = scheduleOperations(dependencyGraph);
-            cout << "RESULT ORDER:" << endl;
-            for (auto v: new_order) 
-                if (v -> lineNumber() > firstLine) 
-                    cout << v -> lineNumber() << endl;
-
-            if (validateNewOrder(loopForAnalyze.first, new_order)) {
-                buildNewAST(loopForAnalyze.first, new_order);
-            }
-            st = loopForAnalyze.first -> lexNext();
-            while (st != loopForAnalyze.first -> lastNodeOfStmt())
-            {
-                cout << st -> lineNumber() << "    " << st -> sunparse() << endl;
-                st = st -> lexNext();
-            }
-        }
-    }
-
-    return;
-};

src/Transformations/SwapOperators/swap_operators.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include "../../GraphLoop/graph_loops.h"
-#include "../../CFGraph/CFGraph.h"
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);

src/Utils/PassManager.h

@@ -212,8 +212,6 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     Pass(BUILD_IR) <= Pass(SUBST_EXPR_RD) <= Pass(SUBST_EXPR_RD_AND_UNPARSE);
 
-    list({BUILD_IR, CALL_GRAPH2}) <= Pass(SWAP_OPERATORS);
-
     list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
     list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING);
 
@@ -318,7 +316,8 @@ 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);
+    list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
+    list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);
 
     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/version.h

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

src/VisualizerCalls/get_information.cpp

@@ -1793,6 +1793,15 @@ 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);
+}
+
 static inline void convertBackSlash(char *str, int strL)
 {
     for (int z = 0; z < strL; ++z)
@@ -2499,6 +2508,8 @@ 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_CreateParallelVariant")
     {
         vector<string> splited;