draft of parallel regions merging pass

.gitignore

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

CMakeLists.txt

@@ -166,6 +166,8 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
 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)
 
 set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
         src/Transformations/DeadCodeRemoving/dead_code.h)
@@ -208,8 +210,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_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
-        src/Transformations/MoveOperators/move_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -232,8 +232,7 @@ set(TRANSFORMS
         ${TR_REPLACE_ARRAYS_IN_IO}
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS}
+        ${TR_RENAME_SYMBOLS})
-        ${TR_MOVE_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -426,6 +425,7 @@ set(SOURCE_EXE
     ${LOOP_ANALYZER}
     ${TRANSFORMS}
     ${PARALLEL_REG}
+    ${MERGE_COPY_ARRAYS}
     ${PRIV}
     ${ARRAY_PROP}
     ${FDVM}
@@ -467,7 +467,6 @@ source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
-source_group (Transformations\\MoveOperators FILES ${TR_MOVE_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -479,6 +478,7 @@ source_group (GraphCall FILES ${GR_CALL})
 source_group (GraphLoop FILES ${GR_LOOP})
 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})

src/CFGraph/private_variables_analysis.cpp

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

src/DirectiveProcessing/insert_directive.cpp

@@ -853,21 +853,12 @@ static pair<string, string> getModuleRename(const set<SgStatement*>& allocatable
         return make_pair("", "");
 }
 
-static void doRename(string& str, const pair<string, string>& renamePair)
-{
-    auto it = str.find(renamePair.first);
-    if (it != string::npos)
-        if (str[it + renamePair.first.size()] == '(' && str[it - 1] == ' ')
-            str = str.replace(it, renamePair.first.size(), renamePair.second);
-}
-
 static pair<DIST::Array*, string>
 getNewDirective(const string &fullArrayName, 
                 const vector<string> &distrRules,
                 const vector<string> &alignRules,
                 const DataDirective &dataDir,
-                const set<SgStatement*>& allocatableStmts,
+                const set<SgStatement*>& allocatableStmts)
-                const pair<string, int>& position_decl)
 {
     string out = "";
     DIST::Array* outA = NULL;
@@ -886,8 +877,7 @@ getNewDirective(const string &fullArrayName,
 
     for (int i = 0; i < dataDir.alignRules.size(); ++i)
     {
-        auto alignArray = dataDir.alignRules[i].alignArray;
+        if (dataDir.alignRules[i].alignArray->GetName() == fullArrayName)
-        if (alignArray->GetName() == fullArrayName)
         {
             string rule = alignRules[i];
             if (allocatableStmts.size())
@@ -899,21 +889,21 @@ getNewDirective(const string &fullArrayName,
                     it = rule.find("ALIGN", it + 7);
                 }
                 
-                auto renamePair = getModuleRename(allocatableStmts, alignArray);
+                auto renamePair = getModuleRename(allocatableStmts, dataDir.alignRules[i].alignArray);
-                doRename(rule, renamePair);
+                if (renamePair.first != "")
-            }
-            else if (alignArray->GetLocation().first == DIST::l_COMMON)
                 {
-                auto symb = alignArray->GetDeclSymbol(position_decl);
+                    it = rule.find(renamePair.first);
-                if (symb->identifier() != alignArray->GetShortName())
+                    if (it != string::npos)
-                    doRename(rule, make_pair(alignArray->GetShortName(), symb->identifier()));
+                        if (rule[it + renamePair.first.size()] == '(' && rule[it - 1] == ' ')
+                            rule = rule.replace(it, renamePair.first.size(), renamePair.second);
+                }
             }
 
             out += "!DVM$ " + rule + "\n";
             if (!out_free_form)
                 out = splitDirective(out);
 
-            return make_pair(alignArray, out);
+            return make_pair(dataDir.alignRules[i].alignArray, out);
         }
     }
     
@@ -1753,7 +1743,7 @@ void insertDistributionToFile(SgFile *file, const char *fin_name, const DataDire
                             if (allocatableStmtsCopy.size())
                                 allocatableStmts = filterAllocateStats(file, allocatableStmtsCopy, currSymb->identifier());
    
-                            pair<DIST::Array*, string> dirWithArray = getNewDirective(fullArrayName, distrRules, alignRules, dataDir, allocatableStmts, make_pair(st->fileName(), st->lineNumber()));
+                            pair<DIST::Array*, string> dirWithArray = getNewDirective(fullArrayName, distrRules, alignRules, dataDir, allocatableStmts);
 
                             string toInsert = dirWithArray.second;
                             if (toInsert != "")
@@ -1985,27 +1975,20 @@ void insertDistributionToFile(SgFile *file, const char *fin_name, const DataDire
                 set<string> toInsertArrays;
                 for (auto &array : dynamicArraysLocal)
                 {
-                    string name = array->GetShortName();
-                    if (array->GetLocation().first == DIST::l_COMMON)
-                    {
-                        auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
-                        name = symb->identifier();
-                    }
-
                     if (extractDir)
                     {
-                        if (dynamicArraysAdded.find(name) != dynamicArraysAdded.end())
+                        if (dynamicArraysAdded.find(array->GetShortName()) != dynamicArraysAdded.end())
                         {
-                            dynamicArraysAdded.erase(name);
+                            dynamicArraysAdded.erase(array->GetShortName());
-                            toInsertArrays.insert(name);
+                            toInsertArrays.insert(array->GetShortName());
                         }
                     }
                     else
                     {
-                        if (dynamicArraysAdded.find(name) == dynamicArraysAdded.end())
+                        if (dynamicArraysAdded.find(array->GetShortName()) == dynamicArraysAdded.end())
                         {
-                            dynamicArraysAdded.insert(name);
+                            dynamicArraysAdded.insert(array->GetShortName());
-                            toInsertArrays.insert(name);
+                            toInsertArrays.insert(array->GetShortName());
                         }
                     }
                 }
@@ -2162,14 +2145,7 @@ void insertShadowSpecToFile(SgFile *file, const char *fin_name, const set<string
 
                     if (needToGen)
                     {
-                        string name = array->GetShortName();
+                        string shadowSpecInsert = "!DVM$ SHADOW " + array->GetShortName() + "(";
-                        if (array->GetLocation().first == DIST::l_COMMON)
-                        {
-                            auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
-                            name = symb->identifier();
-                        }
-
-                        string shadowSpecInsert = "!DVM$ SHADOW " + name + "(";
                         for (int k = 0; k < currSpec.size(); ++k)
                         {
                             char buf[256];
@@ -2181,7 +2157,7 @@ void insertShadowSpecToFile(SgFile *file, const char *fin_name, const set<string
                         shadowSpecInsert += ")\n";
 
                         shadowsSpecsString.push_back(shadowSpecInsert);
-                        pair<SgExpression*, SgExpression*> newSpec = genShadowSpec(file, make_pair(name, currSpec));
+                        pair<SgExpression*, SgExpression*> newSpec = genShadowSpec(file, make_pair(array->GetShortName(), currSpec));
                         if (newSpec.first == NULL || newSpec.second == NULL)
                             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                         shadowsSpecs.push_back(newSpec);

src/Distribution/Array.h

@@ -336,24 +336,9 @@ namespace Distribution
             if (pos != STRING::npos)
             {
                 name.erase(pos, shortName.size());
-                name += newName;
-            }
-            else if (locationPos.first == l_COMMON) // name of array in common may be different
-            {
-                pos = name.rfind("_");
-                if (pos != STRING::npos)
-                {
-                    name.erase(pos + 1, shortName.size());
-                    name += newName;
-                }
-                else
-                {
-#if __SPF
-                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-#endif
-                }
-            }
                 shortName = newName;
+                name += newName;
+            }
             GenUniqKey();
         }
 
@@ -557,44 +542,6 @@ namespace Distribution
             return NULL; 
         }
 
-        Symbol* GetDeclSymbol(const PAIR<STRING, int>& position_decl) const
-        {
-            if (!IsArray() || locationPos.first != l_COMMON)
-                return declSymbol;
-
-            auto it = declPlacesSymbol.find(position_decl);
-            if (it != declPlacesSymbol.end())
-                return it->second;
-            else // find nearest
-            {
-                MAP<PAIR<STRING, int>, Symbol*> currFile;
-                for (auto& [position, symb] : declPlacesSymbol)
-                {
-                    if (position.first == position_decl.first)
-                        currFile[position] = symb;
-                }
-
-                PAIR<int, Symbol*> nearest = { (int)0, NULL };
-                const int needed_pos = position_decl.second;
-
-                for (auto& [position, symb] : currFile)
-                {
-                    if (nearest.second == NULL)
-                        nearest = { abs(position.second - needed_pos), symb };
-
-                    if (abs(position.second - needed_pos) < nearest.first)
-                        nearest = { abs(position.second - needed_pos), symb };
-                }
-
-                if (nearest.second)
-                    return nearest.second;
-#if __SPF
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-#endif
-            }
-            return NULL;
-        }
-
         Symbol* GetDeclSymbol() const { return declSymbol; }
         void SetDeclSymbol(Symbol *s) { declSymbol = s; }
 

src/ParallelizationRegions/parse_merge_dirs.cpp

@@ -0,0 +1,567 @@
+#include "parse_merge_dirs.h"
+
+#include <unordered_set>
+
+using std::map;
+using std::pair;
+using std::string;
+using std::unordered_map;
+using std::unordered_set;
+using std::vector;
+
+static void parseMergeDirective(const char *comment,
+                                vector<pair<string, string>> &parsed_mapping)
+{
+    while (comment)
+    {
+        auto *line_end = strchr(comment, '\n');
+
+        static const char prefix[] = "!!SPF TRANSFORM(MERGE_ARRAYS(";
+        static const auto compare_chars = sizeof(prefix) - 1;
+
+        if (strncasecmp(comment, prefix, compare_chars) == 0)
+        {
+            auto *pair_start = comment + compare_chars;
+            auto *comma = strchr(pair_start, ',');
+            if (comma)
+            {
+                auto *close_br = strchr(comma + 1, ')');
+                if (close_br)
+                {
+                    parsed_mapping.emplace_back(
+                        string(pair_start, comma - pair_start),
+                        string(comma + 1, close_br - comma - 1));
+                }
+            }
+        }
+
+        comment = line_end;
+
+        if (comment)
+            comment++;
+    }
+}
+
+static string getNonDefaultRegion(DIST::Array *a)
+{
+    string result;
+
+    if (!a)
+        return result;
+
+    for (const auto &reg_name : a->GetRegionsName())
+    {
+        if (reg_name != "default")
+        {
+            if (!result.empty())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            result = reg_name;
+        }
+    }
+
+    return result;
+}
+
+static bool hasSameSizes(DIST::Array *a, DIST::Array *b)
+{
+    for (auto *array : {a, b})
+    {
+        for (const auto &p : array->GetSizes())
+        {
+            if (p.first < 0 || p.second < 0)
+                return false;
+        }
+    }
+
+    return a->GetSizes() == b->GetSizes() && a->GetTypeSize() == b->GetTypeSize();
+}
+
+static bool checkSimilarTemplates(vector<ParallelRegion *> &regions,
+                                  const unordered_map<string, string> &new_region_mapping)
+{
+    // new region -> old regions
+    unordered_map<string, unordered_set<string>> new_region_inverse_mapping;
+    for (const auto &p : new_region_mapping)
+        new_region_inverse_mapping[p.second].insert(p.first);
+
+    for (const auto &new_reg : new_region_inverse_mapping)
+    {
+        DIST::Array *template_array = nullptr;
+        string first_reg_name;
+
+        for (const auto &old_region_name : new_reg.second)
+        {
+            auto *old_reg = getRegionByName(regions, old_region_name);
+
+            if (!old_reg)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            const auto &distr_rules = old_reg->GetDataDir().GetDistrRules();
+            if (distr_rules.size() != 1)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            auto *current_template = distr_rules.front().first;
+
+            if (template_array)
+            {
+                if (!hasSameSizes(template_array, current_template))
+                {
+                    __spf_print(1, "Templates of %s and %s has different sizes\n",
+                                first_reg_name.c_str(),
+                                old_region_name.c_str());
+
+                    return false;
+                }
+                // else everything OK
+            }
+            else
+            {
+                template_array = current_template;
+                first_reg_name = old_region_name;
+            }
+        }
+    }
+
+    return true;
+}
+
+static bool hasSameAlignment(const std::unordered_set<const AlignRule *> &align_a,
+                             const std::unordered_set<const AlignRule *> &align_b)
+{
+    if (align_a.size() != 1 || align_b.size() != 1)
+        return false;
+
+    const auto *rule_a = *align_a.begin();
+    const auto *rule_b = *align_b.begin();
+
+    if (rule_a->alignRule != rule_b->alignRule)
+        return false;
+
+    return true;
+}
+
+static void printExpr(SgExpression *e, string pad)
+{
+    if (!e)
+        return;
+
+    __spf_print(1, "%s%d: %s\n", pad.c_str(), e->variant(), e->unparse());
+
+    printExpr(e->lhs(), pad + "  ");
+    printExpr(e->rhs(), pad + "  ");
+}
+
+static pair<vector<SgStatement *>, SgSymbol *> generateDeclaration(const string &array_name, const string &common_block_name,
+                                                                   const vector<pair<int, int>> &sizes, SgType *type, SgStatement *scope)
+{
+    auto *array_symbol = new SgSymbol(VARIABLE_NAME, array_name.c_str(), new SgType(T_ARRAY), scope);
+
+    auto *decl = new SgDeclarationStatement(VAR_DECL);
+
+    decl->setExpression(1, new SgTypeExp(*type));
+
+    SgExpression *subs = new SgExprListExp();
+
+    auto *array_ref = new SgArrayRefExp(*array_symbol, *subs);
+
+    for (int i = 0; i < sizes.size(); i++)
+    {
+        const auto &p = sizes[i];
+        auto *d = new SgExpression(DDOT, new SgValueExp(p.first), new SgValueExp(p.second));
+        subs->setLhs(d);
+
+        if (i + 1 < sizes.size())
+        {
+            subs->setRhs(new SgExprListExp());
+            subs = subs->rhs();
+        }
+    }
+
+    decl->setExpression(0, array_ref);
+
+    auto comm = new SgStatement(COMM_STAT);
+
+    comm->setExpression(0, new SgExpression(COMM_LIST,
+                                            new SgVarRefExp(array_symbol),
+                                            NULL,
+                                            new SgSymbol(COMMON_NAME, common_block_name.c_str())));
+
+    return {{decl, comm}, array_symbol};
+}
+
+SgSymbol *insertDeclIfNeeded(const string &array_name,
+                             const string &common_block_name,
+                             DIST::Array *example_array,
+                             FuncInfo *dest,
+                             unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
+{
+    if (SgFile::switchToFile(dest->fileName) == -1)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    auto &by_func = inserted_arrays[dest];
+    auto it = by_func.find(array_name);
+
+    if (it != by_func.end())
+        return it->second;
+
+    SgStatement *st = dest->funcPointer;
+
+    auto *end = st->lastNodeOfStmt();
+
+    st = st->lexNext();
+
+    while (st != end && !isSgExecutableStatement(st))
+    {
+        st = st->lexNext();
+    }
+
+    auto generated = generateDeclaration(array_name, common_block_name,
+                                         example_array->GetSizes(),
+                                         SgTypeInt(), dest->funcPointer);
+    for (auto *new_stmt : generated.first)
+        st->insertStmtBefore(*new_stmt, *dest->funcPointer);
+
+    by_func[array_name] = generated.second;
+
+    return generated.second;
+}
+
+static pair<string, string> createNewArray(DIST::Array *example_array, const string &base_name,
+                                           const map<string, vector<FuncInfo *>> &allFuncInfo,
+                                           unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
+{
+    auto common_block_name = base_name + "_merge_cb";
+    auto array_name = base_name;
+
+    for (const auto &by_file : allFuncInfo)
+    {
+        for (auto *func_info : by_file.second)
+        {
+            if (func_info->isMain)
+            {
+                insertDeclIfNeeded(
+                    array_name,
+                    common_block_name,
+                    example_array,
+                    func_info,
+                    inserted_arrays);
+            }
+        }
+    }
+
+    return std::make_pair(array_name, common_block_name);
+}
+
+static void replaceArrayRec(SgExpression *e,
+                            const unordered_set<string> &arrays_to_replace,
+                            SgSymbol **func_symbol_hint,
+                            const pair<string, string> &replace_by,
+                            DIST::Array *example_array,
+                            FuncInfo *func,
+                            unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
+{
+    if (!e)
+        return;
+
+    if (isArrayRef(e) && arrays_to_replace.find(e->symbol()->identifier()) != arrays_to_replace.end())
+    {
+        if (!(*func_symbol_hint))
+        {
+            *func_symbol_hint = insertDeclIfNeeded(
+                replace_by.first, replace_by.second,
+                example_array,
+                func,
+                inserted_arrays);
+        }
+
+        e->setSymbol(*func_symbol_hint);
+    }
+
+    replaceArrayRec(
+        e->lhs(),
+        arrays_to_replace,
+        func_symbol_hint,
+        replace_by,
+        example_array,
+        func,
+        inserted_arrays);
+
+    replaceArrayRec(
+        e->rhs(),
+        arrays_to_replace,
+        func_symbol_hint,
+        replace_by,
+        example_array,
+        func,
+        inserted_arrays);
+}
+
+static void replaceRegion(SgStatement* st, const unordered_map<string, string> &new_region_mapping)
+{
+    if (!st)
+        return;
+
+    if(isSPF_stat(st) && st->variant() == SPF_PARALLEL_REG_DIR)
+    {
+        auto it = new_region_mapping.find(st->symbol()->identifier());
+
+        if (it != new_region_mapping.end())
+            st->setSymbol(*(new SgSymbol(CONST_NAME, it->second.c_str())));
+    }
+}
+
+void mergeCopyArrays(vector<ParallelRegion *> &regions, const map<string, vector<FuncInfo *>> &allFuncInfo)
+{
+    for (const auto *region : regions)
+    {
+        __spf_print(1, "region %s\n", region->GetName().c_str());
+
+        const auto &dirs = region->GetDataDir();
+
+        __spf_print(1, "  distr rules: %d\n", dirs.distrRules.size());
+
+        const auto &currentVariant = region->GetCurrentVariant();
+
+        int distr_idx = 0;
+        for (const auto &distr : dirs.distrRules)
+        {
+            const auto &dist_rule = distr.second.back().distRule;
+
+            string sizes;
+            for (const auto &p : distr.first->GetSizes())
+            {
+                if (!sizes.empty())
+                    sizes.push_back(',');
+
+                sizes += std::to_string(p.first) + ":" + std::to_string(p.second);
+            }
+
+            __spf_print(1, "      DIST %s(%s)", distr.first->GetName().c_str(), sizes.c_str());
+            for (const auto &dim : dist_rule)
+                __spf_print(1, " %c", dim == dist::BLOCK ? 'B' : '*');
+
+            __spf_print(1, "\n");
+            distr_idx++;
+        }
+
+        __spf_print(1, "  align rules: %d\n", dirs.alignRules.size());
+
+        for (const auto &align : dirs.alignRules)
+        {
+            string sub_a, sub_b;
+
+            int i = 0;
+            for (const auto coefs : align.alignRule)
+            {
+                if (!sub_a.empty())
+                    sub_a.push_back(',');
+
+                sub_a += std::to_string(coefs.first) + "*i" +
+                         std::to_string(i) + "+" + std::to_string(coefs.second);
+
+                i++;
+            }
+
+            for (const auto coefs : align.alignRuleWith)
+            {
+                if (!sub_b.empty())
+                    sub_b.push_back(',');
+
+                sub_b += std::to_string(coefs.second.first) + "*i" +
+                         std::to_string(coefs.first) + "+" + std::to_string(coefs.second.second);
+            }
+
+            __spf_print(1, "      ALIGN %s(%s) WITH %s(%s)\n",
+                        align.alignArray->GetName().c_str(), sub_a.c_str(),
+                        align.alignWith->GetName().c_str(), sub_b.c_str());
+        }
+    }
+
+    // parse directives
+
+    // new array name -> current arrays
+    unordered_map<string, unordered_set<DIST::Array *>> arrays_to_merge;
+    unordered_map<DIST::Array *, unordered_set<const AlignRule *>> array_alignment;
+
+    for (const auto &by_file : allFuncInfo)
+    {
+        const auto current_file_name = by_file.first;
+
+        if (SgFile::switchToFile(current_file_name) == -1)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+        for (auto *func_info : by_file.second)
+        {
+            SgStatement *curr_stmt = func_info->funcPointer;
+            if (!curr_stmt)
+                continue;
+
+            auto *stmt_end = curr_stmt->lastDeclaration();
+            if (!stmt_end)
+                continue;
+
+            stmt_end = stmt_end->lexNext();
+
+            for (; curr_stmt && curr_stmt != stmt_end; curr_stmt = curr_stmt->lexNext())
+            {
+                if (curr_stmt->comments())
+                {
+                    vector<pair<string, string>> parsed_mapping;
+                    parseMergeDirective(curr_stmt->comments(), parsed_mapping);
+
+                    for (const auto &p : parsed_mapping)
+                    {
+                        auto *found_array = getArrayFromDeclarated(curr_stmt, p.first);
+                        if (found_array)
+                        {
+                            arrays_to_merge[p.second].insert(found_array);
+                            array_alignment[found_array] = {};
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // find alignment rules for array
+
+    for (const auto *region : regions)
+    {
+        const auto &dirs = region->GetDataDir();
+
+        for (const auto &align : dirs.alignRules)
+        {
+            auto it = array_alignment.find(align.alignArray);
+
+            if (it != array_alignment.end())
+                it->second.insert(&align);
+        }
+    }
+
+    // old region -> new region
+    unordered_map<string, string> new_region_mapping;
+
+    // new array -> new region
+    unordered_map<string, string> arrays_new_region_mapping;
+    vector<string> created_region_names;
+
+    for (const auto &by_new_array : arrays_to_merge)
+    {
+        string new_region_name;
+        for (auto *current_array : by_new_array.second)
+        {
+            auto current_array_region = getNonDefaultRegion(current_array);
+            auto it = new_region_mapping.find(current_array_region);
+            if (it != new_region_mapping.end())
+            {
+                if (new_region_name.empty())
+                    new_region_name = it->second;
+                else if (new_region_name != it->second)
+                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            }
+        }
+
+        if (new_region_name.empty())
+        {
+            new_region_name = "merged_reg_" + std::to_string(created_region_names.size());
+            created_region_names.push_back(new_region_name);
+        }
+
+        for (auto *current_array : by_new_array.second)
+        {
+            auto current_array_region = getNonDefaultRegion(current_array);
+            new_region_mapping[current_array_region] = new_region_name;
+        }
+
+        arrays_new_region_mapping[by_new_array.first] = new_region_name;
+    }
+
+    if (!checkSimilarTemplates(regions, new_region_mapping))
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> inserted_arrays;
+
+    for (const auto &by_dest_array : arrays_to_merge)
+    {
+        const auto &copy_arrays = by_dest_array.second;
+
+        if (copy_arrays.empty())
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+        auto *first_element = *copy_arrays.begin();
+        auto first_elem_rules_it = array_alignment.find(first_element);
+
+        if (first_elem_rules_it == array_alignment.end())
+            continue;
+
+        const auto &first_elem_rules = first_elem_rules_it->second;
+
+        for (auto *array_to_merge : copy_arrays)
+        {
+            auto array_rules_it = array_alignment.find(array_to_merge);
+
+            if (array_rules_it == array_alignment.end())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            const auto &array_rules = array_rules_it->second;
+
+            if (!hasSameSizes(array_to_merge, first_element) || !hasSameAlignment(first_elem_rules, array_rules))
+            {
+                __spf_print(1, "Arrays %s and %s has different sizes or align rules\n",
+                            array_to_merge->GetName().c_str(),
+                            first_element->GetName().c_str());
+
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            }
+        }
+
+        __spf_print(1, "merge into %s (%s):\n", by_dest_array.first.c_str(), arrays_new_region_mapping[by_dest_array.first].c_str());
+        for (auto *array_to_merge : copy_arrays)
+            __spf_print(1, "%s\n", array_to_merge->GetName().c_str());
+
+        auto created_array_info = createNewArray(first_element, by_dest_array.first, allFuncInfo, inserted_arrays);
+
+        unordered_set<string> arrays_to_replace;
+        for (auto *array_to_merge : copy_arrays)
+            arrays_to_replace.insert(array_to_merge->GetShortName());
+
+        for (const auto &by_file : allFuncInfo)
+        {
+            if (SgFile::switchToFile(by_file.first) == -1)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            for (auto *func_info : by_file.second)
+            {
+                SgSymbol *func_symbol_hint = nullptr;
+                SgStatement *st = func_info->funcPointer;
+
+                auto *func_end = st->lastNodeOfStmt();
+
+                st = st->lexNext();
+
+                while (st && !isSgExecutableStatement(st) && st != func_end)
+                    st = st->lexNext();
+
+                while (st && st != func_end)
+                {
+                    for (int i = 0; i < 3; i++)
+                    {
+                        replaceArrayRec(
+                            st->expr(i),
+                            arrays_to_replace,
+                            &func_symbol_hint,
+                            created_array_info,
+                            first_element,
+                            func_info,
+                            inserted_arrays);
+                    }
+
+                    replaceRegion(st, new_region_mapping);
+
+                    st = st->lexNext();
+                }
+            }
+        }
+    }
+}

src/ParallelizationRegions/parse_merge_dirs.h

@@ -0,0 +1,8 @@
+#include "../GraphCall/graph_calls.h"
+#include "ParRegions.h"
+
+#include <string>
+#include <vector>
+#include <map>
+
+void mergeCopyArrays(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo);

src/Sapfor.cpp

@@ -23,6 +23,7 @@
 #include "ParallelizationRegions/ParRegions_func.h"
 #include "ParallelizationRegions/resolve_par_reg_conflicts.h"
 #include "ParallelizationRegions/expand_extract_reg.h"
+#include "ParallelizationRegions/parse_merge_dirs.h"
 
 #include "Distribution/Distribution.h"
 #include "Distribution/GraphCSR.h"
@@ -90,7 +91,6 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/MoveOperators/move_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
@@ -942,8 +942,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
-        else if (curr_regime == MOVE_OPERATORS)        
-            moveOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1040,8 +1038,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_REMOVING,
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
-                          REMOVE_DEAD_CODE,
+                          REMOVE_DEAD_CODE };
-                          MOVE_OPERATORS };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -1922,6 +1919,10 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         transformAssumedSizeParameters(allFuncInfo);
     else if (curr_regime == FIND_PRIVATE_ARRAYS_ANALYSIS)
         FindPrivateArrays(loopGraph, fullIR, insertedPrivates);
+    else if (curr_regime == MERGE_COPY_ARRAYS)
+    {
+        mergeCopyArrays(parallelRegions, allFuncInfo);
+    }
 
     else if (curr_regime == ARRAY_PROPAGATION)
         ArrayConstantPropagation(project);
@@ -2343,7 +2344,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case INSERT_NO_DISTR_FLAGS_FROM_GUI:
     case PRIVATE_REMOVING:
     case RENAME_INLCUDES:
-    case MOVE_OPERATORS:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:
@@ -2379,6 +2379,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case FIX_COMMON_BLOCKS:
     case TEST_PASS:
     case SET_IMPLICIT_NONE:
+    case MERGE_COPY_ARRAYS:
         runAnalysis(*project, curr_regime, false);
     case SUBST_EXPR_RD_AND_UNPARSE:
     case SUBST_EXPR_AND_UNPARSE:

src/Sapfor.h

@@ -88,6 +88,8 @@ enum passes {
     REMOVE_DVM_INTERVALS,
     VERIFY_DVM_DIRS,
 
+    MERGE_COPY_ARRAYS,
+
     REMOVE_DIST_ARRAYS_FROM_IO,
 
     SUBST_EXPR,
@@ -122,8 +124,6 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    MOVE_OPERATORS,
-
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
     FILL_PARALLEL_REG_IR,
@@ -273,6 +273,7 @@ static void setPassValues()
     passNames[VERIFY_DVM_DIRS] = "VERIFY_DVM_DIRS";
     passNames[REMOVE_DVM_DIRS_TO_COMMENTS] = "REMOVE_DVM_DIRS_TO_COMMENTS";
     passNames[REMOVE_SPF_DIRS] = "REMOVE_SPF_DIRS";
+    passNames[MERGE_COPY_ARRAYS] = "MERGE_COPY_ARRAYS";
     passNames[REMOVE_DIST_ARRAYS_FROM_IO] = "REMOVE_DIST_ARRAYS_FROM_IO";
     passNames[SUBST_EXPR] = "SUBST_EXPR";
     passNames[SUBST_EXPR_RD] = "SUBST_EXPR_RD";
@@ -323,7 +324,6 @@ static void setPassValues()
     passNames[CHECK_PAR_REG_DIR] = "CHECK_PAR_REG_DIR";
     passNames[CREATE_INTER_TREE] = "CREATE_INTER_TREE";
     passNames[INSERT_INTER_TREE] = "INSERT_INTER_TREE";
-    passNames[MOVE_OPERATORS] = "MOVE_OPERATORS";
     passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";

src/Transformations/MoveOperators/move_operators.cpp

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

src/Transformations/MoveOperators/move_operators.h

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

src/Utils/PassManager.h

@@ -206,9 +206,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     Pass(DEF_USE_STAGE1) <= Pass(DEF_USE_STAGE2);
 
-    list({ VERIFY_DVM_DIRS, VERIFY_COMMON, FILL_COMMON_BLOCKS, PRIVATE_CALL_GRAPH_STAGE1, PRIVATE_CALL_GRAPH_STAGE2, MACRO_EXPANSION, CONVERT_ASSIGN_TO_LOOP, DEF_USE_STAGE1, DEF_USE_STAGE2, FILL_PARALLEL_REG_IR, CALL_GRAPH_IR }) <= list({ SUBST_EXPR, SUBST_EXPR_RD, BUILD_IR });
+    list({ VERIFY_DVM_DIRS, PRIVATE_CALL_GRAPH_STAGE1, PRIVATE_CALL_GRAPH_STAGE2, MACRO_EXPANSION, CONVERT_ASSIGN_TO_LOOP, DEF_USE_STAGE1, DEF_USE_STAGE2, FILL_PARALLEL_REG_IR, VERIFY_COMMON, FILL_COMMON_BLOCKS, CALL_GRAPH_IR }) <= list({ SUBST_EXPR, SUBST_EXPR_RD, BUILD_IR });
-
-    Pass(VERIFY_COMMON) <= Pass(FILL_COMMON_BLOCKS);
 
     Pass(BUILD_IR) <= Pass(SUBST_EXPR) <= Pass(SUBST_EXPR_AND_UNPARSE);
 
@@ -219,7 +217,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     Pass(RESTORE_LOOP_FROM_ASSIGN) <= list({ SUBST_EXPR_AND_UNPARSE, SUBST_EXPR_RD_AND_UNPARSE });
 
-    Pass(FILL_COMMON_BLOCKS) <= Pass(GET_ALL_ARRAY_DECL) <= list({ CALL_GRAPH_IR, INSERT_NO_DISTR_FLAGS_FROM_GUI });
+    Pass(GET_ALL_ARRAY_DECL) <= list({ CALL_GRAPH_IR, INSERT_NO_DISTR_FLAGS_FROM_GUI });
 
     Pass(LOOP_GRAPH) <= Pass(PRIVATE_CALL_GRAPH_STAGE3) <= list(FIND_FUNC_TO_INCLUDE, PRIVATE_ANALYSIS_IR) <= list({ LOOP_ANALYZER_DATA_DIST_S0, LOOP_ANALYZER_DATA_DIST_S1, ONLY_ARRAY_GRAPH, LOOP_ANALYZER_ALIGNS });
 
@@ -229,7 +227,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     list({ VERIFY_OPERATORS, VERIFY_ENDDO, VERIFY_INCLUDES, PREPROC_SPF, PREPROC_ALLOCATES, GET_ALL_ARRAY_DECL, GCOV_PARSER }) <= list({ CALL_GRAPH, MACRO_EXPANSION, DEF_USE_STAGE1 });
 
-    list({ VERIFY_OPERATORS, VERIFY_ENDDO, VERIFY_INCLUDES, PREPROC_ALLOCATES, FILL_PARALLEL_REG_IR }) <= list({ FILL_COMMON_BLOCKS, GET_ALL_ARRAY_DECL, PARSE_OMP_DIRS }) <= Pass(PREPROC_SPF);
+    list({ VERIFY_OPERATORS, VERIFY_ENDDO, VERIFY_INCLUDES, PREPROC_ALLOCATES, FILL_PARALLEL_REG_IR }) <= list({ GET_ALL_ARRAY_DECL, FILL_COMMON_BLOCKS, PARSE_OMP_DIRS }) <= Pass(PREPROC_SPF);
 
     Pass(CHECK_PAR_REG_DIR) <= Pass(FILL_PARALLEL_REG_IR);
 
@@ -321,7 +319,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
     list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
     list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);
 
-    list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);
+    Pass(CREATE_TEMPLATE_LINKS) <= Pass(MERGE_COPY_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/SgUtils.cpp

@@ -954,20 +954,8 @@ DIST::Array* getArrayFromDeclarated(SgStatement *st, const string &arrayName)
         {
             auto itD = declaredArrays.find(*itSet);
             if (itD != declaredArrays.end())
-            {
+                if (itD->second.first->GetShortName() == arrayName)
-                DIST::Array* array = itD->second.first;
+                    found = itD->second.first;
-                if (array->GetLocation().first == DIST::l_COMMON)
-                {
-                    auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
-                    if (symb && symb->identifier() == arrayName)
-                        found = array;
-                }
-                else
-                {
-                    if (array->GetShortName() == arrayName)
-                        found = array;
-                }
-            }
         }
     }
     return found;
@@ -1276,32 +1264,6 @@ static SgExpression* isInCommon(const vector<SgExpression*> &commonBlocks, const
     return NULL;
 }
 
-//all common block in project
-extern map<string, CommonBlock*> commonBlocks;
-static string getCommonNameOnPos(const string& name, const int commonPos)
-{
-    if (commonBlocks.size() == 0)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    auto it = commonBlocks.find(name);
-    if (it == commonBlocks.end())
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    auto inPos = it->second->getGroupedVars().find(commonPos);
-    if (inPos == it->second->getGroupedVars().end())
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    set<string> namesOnPos;
-
-    for (auto& var : inPos->second)
-        namesOnPos.insert(var->getName());
-
-    if (namesOnPos.size() == 0)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    return *namesOnPos.begin();
-}
-
 static map<tuple<string, string, int>, tuple<int, string, string>> tableOfUniqNames;
 tuple<int, string, string> getUniqName(const map<string, vector<SgExpression*>> &commonBlocks, SgStatement *decl, SgSymbol *symb)
 {
@@ -1310,7 +1272,6 @@ tuple<int, string, string> getUniqName(const map<string, vector<SgExpression*>>
     int commonPos = 0;
 
     SgExpression *foundCommon = NULL;
-    string symbCommn = "";
 
     SgStatement *declCP = decl->controlParent();
     // find symbol in parameter list of functions
@@ -1346,7 +1307,6 @@ tuple<int, string, string> getUniqName(const map<string, vector<SgExpression*>>
             if (foundCommon)
             {
                 inCommon = true;
-                symbCommn = getCommonNameOnPos(common.first, commonPos);
                 break;
             }
         }
@@ -1354,7 +1314,7 @@ tuple<int, string, string> getUniqName(const map<string, vector<SgExpression*>>
 
     tuple<int, string, string> retVal;
     if (inCommon)
-        retVal = make_tuple(commonPos, string("common_") + getCommonName(foundCommon), symbCommn);
+        retVal = make_tuple(commonPos, string("common_") + getCommonName(foundCommon), string(symb->identifier()));
     else
         retVal = make_tuple(decl->lineNumber(), string(decl->fileName()), string(symb->identifier()));
 

src/Utils/module_utils.cpp

@@ -337,13 +337,8 @@ const set<SgSymbol*>& getModuleSymbols(SgStatement *func)
     //if function or module in contains
     auto cp = func->controlParent();
     if (isSgProgHedrStmt(cp) || cp->variant() == MODULE_STMT)
-    {
         getModuleSymbols(cp, symbs);
 
-        if (func->variant() == FUNC_HEDR)
-            symbs.insert(func->symbol());
-    }
-
     symbolsForFunc[func->symbol()->identifier()] = symbs;
     return symbs;
 }
@@ -354,20 +349,10 @@ static void findSymbol(SgStatement* func, const string& varName, const string& l
     for (const auto& s : getModuleSymbols(func))
     {
         SgSymbol* orig = OriginalSymbol(s);
-        printf("%s == %s\n", orig->identifier(), s->identifier());
         //any suitable symbol can be used
-
-        if (orig->variant() == FUNCTION_NAME)
-        {
-            if (orig->identifier() == varName)
-                altNames[s->identifier()] = s;
-        }
-        else
-        {
         if (orig->identifier() == varName && orig->scope()->symbol()->identifier() == locName)
             altNames[s->identifier()] = s;
     }
-    }
 }
 
 SgSymbol* getNameInLocation(SgStatement* func, const string& varName, const string& locName)
@@ -384,7 +369,6 @@ SgSymbol* getNameInLocation(SgStatement* func, const string& varName, const stri
         return altNames.begin()->second;
     else {
         __spf_print(1, "%s (%s %s) %s\n", func->symbol()->identifier(), clearName.c_str(), varName.c_str(), locName.c_str());
-        findSymbol(func, varName, locName, altNames);
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
     }
 

src/Utils/version.h

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

src/VisualizerCalls/get_information.cpp

@@ -1802,13 +1802,6 @@ int SPF_InsertPrivateArrayDirectives(void*& context, int winHandler, short* opti
     return simpleTransformPass(FIND_PRIVATE_ARRAYS, options, projName, folderName, output, outputMessage);
 }
 
-int SPF_MoveOperators(void*& context, int winHandler, short* options, short* projName, short* folderName, string& output, string& outputMessage)
-{
-    MessageManager::clearCache();
-    MessageManager::setWinHandler(winHandler);
-    return simpleTransformPass(MOVE_OPERATORS, options, projName, folderName, output, outputMessage);
-}
-
 static inline void convertBackSlash(char *str, int strL)
 {
     for (int z = 0; z < strL; ++z)
@@ -2517,8 +2510,6 @@ const wstring Sapfor_RunTransformation(const char* transformName_c, const char*
         retCode = SPF_RenameIncludes(context, winHandler, optSh, projSh, fold, output, outputMessage);
     else if (whichRun == "SPF_InsertPrivateArrayDirectives")
         retCode = SPF_InsertPrivateArrayDirectives(context, winHandler, optSh, projSh, fold, output, outputMessage);
-    else if (whichRun == "SPF_MoveOperators")
-        retCode = SPF_MoveOperators(context, winHandler, optSh, projSh, fold, output, outputMessage);
     else if (whichRun == "SPF_CreateParallelVariant")
     {
         vector<string> splited;