draft of parallel regions merging pass

2025-12-24 23:11:31 +03:00
16 changed files with 129 additions and 478 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -163,9 +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(MERGE_COPY_ARRAYS src/ParallelizationRegions/parse_merge_dirs.cpp
         src/ParallelizationRegions/parse_merge_dirs.h)

@@ -427,7 +424,6 @@ set(SOURCE_EXE
    ${PARALLEL_REG}
    ${MERGE_COPY_ARRAYS}
    ${PRIV}
-    ${ARRAY_PROP}
    ${FDVM}
    ${OMEGA}
    ${UTILS}
@@ -480,7 +476,6 @@ source_group (LoopAnalyzer FILES ${LOOP_ANALYZER})
 source_group (ParallelizationRegions FILES ${PARALLEL_REG})
 source_group (MergeCopyArrays FILES ${MERGE_COPY_ARRAYS})
 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})
--- a/src/ArrayConstantPropagation/propagation.cpp
+++ b/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());
-                    }
-                }
-            }
-        }
-    }
-}
--- a/src/ArrayConstantPropagation/propagation.h
+++ b/src/ArrayConstantPropagation/propagation.h
@@ -1,4 +0,0 @@
-#pragma once
-#include "../Utils/SgUtils.h"
-
-void ArrayConstantPropagation(SgProject& project);
--- a/src/Distribution/CreateDistributionDirs.cpp
+++ b/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;
                    }
--- a/src/Distribution/DvmhDirective.cpp
+++ b/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 });
-                    if (coeffs.size() == 1)
+                    const vector<int*> &coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                    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)
--- a/src/Distribution/DvmhDirectiveBase.cpp
+++ b/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);
                                }
                            }

--- a/src/GraphLoop/graph_loops_base.cpp
+++ b/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;
--- a/src/LoopAnalyzer/loop_analyzer.cpp
+++ b/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());
-        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coeffs.first, coeffs.second);
+            getCoefsOfSubscript(coefs, subscr, parentLoops[position]->doName());
+        __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[1] = coeffs.second;
+        valueSubs[0] = coefs.first;
+        valueSubs[1] = coefs.second;
 #ifdef __SPF
        addToCollection(__LINE__, __FILE__, valueSubs, 2);
 #endif
-        const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
-        if (coeffs.size() == 0)
+        const vector<int*> &coefs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
+        if (coefs.size() == 0)
        {
            subscr->addAttribute(INT_VAL, valueSubs, sizeof(int*));
            if (position != -1 && allPositions.size() == 1 && position < parentLoops.size())
--- a/src/Predictor/PredictScheme.cpp
+++ b/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>> coeffs(srcSymbs.size());
+    vector<pair<int, int>> coefs(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(coeffs[z], exp, srcSymbs[z].second);
-                if (coeffs[z].first == 0)
+                getCoefsOfSubscript(coefs[z], exp, srcSymbs[z].second);
+                if (coefs[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 < 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)
-            align["rules"].push_back({ z, coeffs[z].first });
+        if (coefs[z].second)
+            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;
 }
--- a/src/PrivateAnalyzer/private_arrays_search.cpp
+++ b/src/PrivateAnalyzer/private_arrays_search.cpp
@@ -16,34 +16,6 @@

 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 +38,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 +75,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 +87,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,7 +122,22 @@ static void SolveDataFlow(Region* DFG)
    Collapse(DFG);
 }

-static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
+unsigned long long CalculateLength(const AccessingSet& array) 
+{
+    if (array.GetElements().empty())
+        return 0;
+    unsigned long long result = 1;
+    for (const auto& range : array.GetElements()) 
+    {
+        for (const auto& dim : range)
+        {
+            result *= (dim.step * dim.tripCount);
+        }
+    }
+    return result;
+}
+
+void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
 {
    SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
    spfStat->setlineNumber(loop->loop->lineNumber());
@@ -203,8 +188,6 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*
        SgFile::switchToFile(fileName);
        for (const auto& loop : loops)
        {
-            if (!loop->isFor())
-                continue;
            SgStatement* search_func = loop->loop->GetOriginal();

            while (search_func && (!isSgProgHedrStmt(search_func)))
@@ -221,7 +204,6 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*
                        continue;
                    }
                    SolveDataFlow(loopRegion);
-                    RemoveEmptyPoints(loopRegion->array_priv);
                    result[loop] = loopRegion->array_priv;
                    delete(loopRegion);
                }
--- a/src/PrivateAnalyzer/range_structures.cpp
+++ b/src/PrivateAnalyzer/range_structures.cpp
@@ -64,13 +64,18 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
        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; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
+    for (int64_t i = start; dim1.start + i * dim1.step <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
    {
-            result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
+        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, dim1.array });
+                start = i;
+            }
            interValue += intersection->step;
        }
    }
@@ -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);
--- a/src/PrivateAnalyzer/region.cpp
+++ b/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,12 +127,25 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
            vector<ArrayDimension> accessPoint(n);

            auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
+            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);
+                }
+
+            }
+
            int fillCount = 0;

-            while (!index_vars.empty() && !refPos.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, ref};
@@ -180,19 +174,16 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                            return -1;
                    }

-                    uint64_t start = currentLoop->startVal;
-                    uint64_t step = currentLoop->stepVal;
-                    uint64_t iters = currentLoop->calculatedCountOfIters;
-                    current_dim = { start, step, iters, ref };
+                    uint64_t start = currentLoop->startVal * currentCoefs.first + currentCoefs.second;
+                    uint64_t step = currentCoefs.first;
+                    current_dim = { start, step, (uint64_t)currentLoop->calculatedCountOfIters, 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())
@@ -239,11 +230,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 +250,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));
 }
-}
--- a/src/Sapfor.cpp
+++ b/src/Sapfor.cpp
@@ -47,7 +47,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"
@@ -1924,9 +1923,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        mergeCopyArrays(parallelRegions, allFuncInfo);
    }

-    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.;
    __spf_print(1, "PROFILE: time for this pass = %f sec (total %f sec)\n", elapsed, elapsedGlobal);
--- a/src/Sapfor.h
+++ b/src/Sapfor.h
@@ -189,7 +189,6 @@ enum passes {
    FIND_PRIVATE_ARRAYS,

    TRANSFORM_ASSUMED_SIZE_PARAMETERS,
-    ARRAY_PROPAGATION,

    TEST_PASS,
    EMPTY_PASS
@@ -380,7 +379,6 @@ static void setPassValues()
    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";
 }
--- a/src/Transformations/LoopCombining/loops_combiner.cpp
+++ b/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)
-                        coeffsRead[k].resize(it->second.size());
+                    if (coefsRead[k].size() == 0)
+                        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)
-                        coeffsWrite[k].resize(itW->second.size());
+                    if (coefsWrite[k].size() == 0)
+                        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)
-                    countW[L] += (coeffsWrite[L][z].size() ? 1 : 0);
+                for (int z = 0; z < coefsWrite[L].size(); ++z)
+                    countW[L] += (coefsWrite[L][z].size() ? 1 : 0);

            for (int L = 0; L < 2; ++L)
-                for (int z = 0; z < coeffsRead[L].size(); ++z)
-                    countR[L] += (coeffsRead[L][z].size() ? 1 : 0);
+                for (int z = 0; z < coefsRead[L].size(); ++z)
+                    countR[L] += (coefsRead[L][z].size() ? 1 : 0);

            for (int p = 0; p < len; ++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])
+                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])
                            return true;

-                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])
+                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])
                            return true;

-                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])
+                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])
                            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] ||
-                        coeffsWrite[0][p].size() == 0 && coeffsWrite[1][p].size() != 0 && countW[0])
+                    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])
                        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] ||
-                        coeffsWrite[0][p].size() == 0 && coeffsRead[1][p].size() != 0 && countW[0])
+                    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])
                        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] ||
-                        coeffsWrite[1][p].size() == 0 && coeffsRead[0][p].size() != 0 && countW[1])
+                    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])
                        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;
            }
            
--- a/src/Utils/version.h
+++ b/src/Utils/version.h
@@ -1,3 +1,3 @@
 #pragma once

-#define VERSION_SPF "2450"
+#define VERSION_SPF "2448"