change propagation

src/ArrayConstantPropagation/propagation.cpp

@@ -10,6 +10,7 @@
 using namespace std;
 
 static SgStatement* declPlace = NULL;
+static unordered_set<SgStatement*> changed;;
 
 static bool CheckConstIndexes(SgExpression* exp)
 {
@@ -36,13 +37,13 @@ static bool CheckConstIndexes(SgExpression* exp)
 
 static SgExpression* CreateVar(int& variableNumber, SgType* type)
 {
-    string varName = "__tmp_prop_var";
+    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__";
+    const string commonBlockName = "propagation_common__";
 
     SgStatement* funcStart = declPlace->controlParent();
     SgStatement* commonStat = NULL;
@@ -169,8 +170,7 @@ static SgExpression* CreateVar(int& variableNumber, SgType* type)
 
         commonList->setLhs(varList);
     }
-
+    return  new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
-    return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
 }
 
 static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber) 
@@ -227,6 +227,8 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
 {
     if (exp->symbol()->type()->variant() == T_STRING)
         return;
+    if (changed.find(st) != changed.end())
+        return;
     string expUnparsed = exp->unparse();
     if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
     {
@@ -234,12 +236,62 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
     }
     SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);
 
-    newStatement->setFileId(st->getFileId());
+   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) 
@@ -262,40 +314,29 @@ void ArrayConstantPropagation(SgProject& project)
 
             for (; st != lastNode; st = st->lexNext())
             {
-                if (st->variant() == ASSIGN_STAT)
+                if (st->variant() == FOR_NODE)
-                {
-                    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())
+                        TransformBorder(st, upperBound, arrayToVariable, variableNumber);
-                        {
-                            arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
-                        }
                         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()))
                     {
-                        if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
+                        TransformBorder(st, lowerBound, arrayToVariable, variableNumber);
-                        {
-                            arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
-                        }
                         st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
                     }
+                    else if (lowerBound->variant() == VAR_REF)
+                        CheckVariable(st, lowerBound, arrayToVariable, variableNumber);
                 }
             }
+            cout << file->functions(i)->unparse() << endl;
         }
     }
 }

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 });
+                    const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
-                    if (coefs.size() == 1)
+                    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());
+            getCoefsOfSubscript(coeffs, subscr, parentLoops[position]->doName());
-        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coefs.first, coefs.second);
+        __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[0] = coeffs.first;
-        valueSubs[1] = coefs.second;
+        valueSubs[1] = coeffs.second;
 #ifdef __SPF
         addToCollection(__LINE__, __FILE__, valueSubs, 2);
 #endif
-        const vector<int*> &coefs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
+        const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
-        if (coefs.size() == 0)
+        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);
+                getCoefsOfSubscript(coeffs[z], exp, srcSymbs[z].second);
-                if (coefs[z].first == 0)
+                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)
+        if (coeffs[z].second)
-            align["rules"].push_back({ z, coefs[z].first });
+            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

@@ -67,12 +67,14 @@ static void Collapse(Region* region)
         }
     }
 
-    ArrayAccessingIndexes useUnion;
+    ArrayAccessingIndexes useUnionB;
     for (auto& byBlock : region->getBasickBlocks())
-        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
+        for (auto& [arrayName, _] : byBlock->array_use)
-            useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
+            useUnionB[arrayName] = useUnionB[arrayName].Union(byBlock->array_use[arrayName]);
+
+    for (auto& [arrayName, _] : useUnionB)
+        region->array_priv[arrayName] = useUnionB[arrayName].Diff(region->array_use[arrayName]);
 
-    region->array_priv = region->array_use;
     
     for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
         prevBlock->replaceInNextRegions(region, region->getHeader());

src/PrivateAnalyzer/region.cpp

@@ -9,6 +9,7 @@
 #include "range_structures.h"
 #include "region.h"
 
+#include "..\Transformations\ExpressionSubstitution\expr_transform.h"
 #include "SgUtils.h"
 
 using namespace std;
@@ -119,14 +120,11 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                     {
                         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});
-                    }
                 }
             }
         }
@@ -134,7 +132,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
         {
             vector<SAPFOR::Argument*> index_vars;
             vector<int> refPos;
-            string array_name = instruction->getInstruction()->getArg1()->getValue();            
+            string array_name = instruction->getInstruction()->getArg1()->getValue();
 
             int j = i - 1;
             while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
@@ -149,16 +147,29 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
             vector<ArrayDimension> accessPoint(n);
 
             auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
-
             int fillCount = 0;
 
-            while (!index_vars.empty() && !refPos.empty())
+            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 });
+                if (coefs.size() == 1)
+                {
+                    const pair<int, int> coef(coefs[0][0], coefs[0][1]);
+                    coefsForDims.push_back(coef);
+                }
+
+            }
+            coefsForDims = {coefsForDims.rbegin(), coefsForDims.rend()};
+
+            while (!index_vars.empty() && !refPos.empty() && !coefsForDims.empty())
             {
                 auto var = index_vars.back();
                 int currentVarPos = refPos.back();
                 ArrayDimension current_dim;
                 if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
-                    current_dim = { stoul(var->getValue()), 1, 1, ref};
+                    current_dim = { stoul(var->getValue()), 1, 1, ref };
                 else
                 {
                     string name, full_name = var->getValue();
@@ -184,7 +195,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                             return -1;
                     }
 
-                    uint64_t start = currentLoop->startVal;
+                    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 };
@@ -197,6 +208,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                 }
                 index_vars.pop_back();
                 refPos.pop_back();
+                coefsForDims.pop_back();
             }
 
             if (fillCount == accessPoint.size())

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)
+                    if (coeffsRead[k].size() == 0)
-                        coefsRead[k].resize(it->second.size());
+                        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)
+                    if (coeffsWrite[k].size() == 0)
-                        coefsWrite[k].resize(itW->second.size());
+                        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)
+                for (int z = 0; z < coeffsWrite[L].size(); ++z)
-                    countW[L] += (coefsWrite[L][z].size() ? 1 : 0);
+                    countW[L] += (coeffsWrite[L][z].size() ? 1 : 0);
 
             for (int L = 0; L < 2; ++L)
-                for (int z = 0; z < coefsRead[L].size(); ++z)
+                for (int z = 0; z < coeffsRead[L].size(); ++z)
-                    countR[L] += (coefsRead[L][z].size() ? 1 : 0);
+                    countR[L] += (coeffsRead[L][z].size() ? 1 : 0);
 
             for (int p = 0; p < len; ++p)
             {
-                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)
+                    if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() != 0)
-                        if (coefsWrite[0][p] != coefsWrite[1][p])
+                        if (coeffsWrite[0][p] != coeffsWrite[1][p])
                             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)
+                    if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() != 0)
-                        if (coefsWrite[0][p] != coefsRead[1][p])
+                        if (coeffsWrite[0][p] != coeffsRead[1][p])
                             return true;
 
-                if (coefsWrite[1].size() && coefsRead[0].size())
+                if (coeffsWrite[1].size() && coeffsRead[0].size())
-                    if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() != 0)
+                    if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() != 0)
-                        if (coefsWrite[1][p] != coefsRead[0][p])
+                        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] ||
+                    if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() == 0 && countW[1] ||
-                        coefsWrite[0][p].size() == 0 && coefsWrite[1][p].size() != 0 && countW[0])
+                        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] ||
+                    if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() == 0 && countR[1] ||
-                        coefsWrite[0][p].size() == 0 && coefsRead[1][p].size() != 0 && countW[0])
+                        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] ||
+                    if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() == 0 && countR[0] ||
-                        coefsWrite[1][p].size() == 0 && coefsRead[0][p].size() != 0 && countW[1])
+                        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/Utils/version.h

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