Merge branch 'master' into par_reg_merging

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)
@@ -207,9 +209,9 @@ set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_gr
 set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
         src/Transformations/FunctionInlining/inliner.h)
 set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
-                    src/Transformations/RenameSymbols/rename_symbols.h)
-SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
-        src/Transformations/SwapOperators/swap_operators.h)
+        src/Transformations/RenameSymbols/rename_symbols.h)
+SET(TR_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
+        src/Transformations/MoveOperators/move_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -233,7 +235,7 @@ set(TRANSFORMS
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
         ${TR_RENAME_SYMBOLS}
-        ${TR_SWAP_OPERATORS})
+        ${TR_MOVE_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -426,6 +428,7 @@ set(SOURCE_EXE
     ${LOOP_ANALYZER}
     ${TRANSFORMS}
     ${PARALLEL_REG}
+    ${MERGE_COPY_ARRAYS}
     ${PRIV}
     ${ARRAY_PROP}
     ${FDVM}
@@ -467,7 +470,7 @@ source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
-source_group (Transformations\\SwapOperators FILES ${TR_SWAP_OPERATORS})
+source_group (Transformations\\MoveOperators FILES ${TR_MOVE_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -479,6 +482,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,20 +200,46 @@ static void fillOutForFunc(const FuncInfo* func, const vector<SAPFOR::BasicBlock
     outForFunc[func->funcName] = { defined, common_defined };
 }
 
-static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>& res, 
+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 (auto ir_block : block->getInstructions())
+    for (const 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);
@@ -236,12 +262,20 @@ 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, block->getInstructions()[place - first_instr_num]->getInstruction());
+                addPlaceWithDef(commonVars, func, def.first, instr);
             }
+        }
+    }
 }
 
 // recursively analyze FOR loops 
@@ -266,7 +300,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 (auto bb : blocks)
+    for (const auto &bb : blocks)
     {
         if (!bb || (bb->getInstructions().size() == 0))
             continue;
@@ -348,7 +382,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
         getDefsFromBlock(*loop_it, changeValueOnExit, commonVars, func);
 
 
-    for (auto bb : currentLoop)
+    for (const auto &bb : currentLoop)
     {
         //fill LiveWhenLoopEnds
         bool has_next_outside_body = false;

src/ParallelizationRegions/parse_merge_dirs.cpp

@@ -0,0 +1,616 @@
+#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};
+}
+
+static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
+{
+    if (exp)
+    {
+        if (exp->variant() == variant)
+            return exp;
+
+        auto *l = findExprWithVariant(exp->lhs(), variant);
+        if (l)
+            return l;
+
+        auto *r = findExprWithVariant(exp->rhs(), variant);
+        if (r)
+            return r;
+    }
+
+    return NULL;
+}
+
+SgType* GetArrayType(DIST::Array *array)
+{
+    if (!array)
+        return NULL;
+
+    for (const auto& decl_place : array->GetDeclInfo())
+    {
+        if (SgFile::switchToFile(decl_place.first) != -1)
+        {
+            auto* decl = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
+            if (decl)
+            {
+                for (int i = 0; i < 3; i++)
+                {
+                    auto* found_type = isSgTypeExp(findExprWithVariant(decl->expr(i), TYPE_OP));
+                    if (found_type)
+                        return found_type->type();
+                }
+            }
+        }
+    }
+
+    return NULL;
+}
+
+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)
+{
+    auto *type = GetArrayType(example_array);
+
+    if (!type)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    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(),
+                                         type, 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,7 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/SwapOperators/swap_operators.h"
+#include "Transformations/MoveOperators/move_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
@@ -942,8 +943,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
-        else if (curr_regime == SWAP_OPERATORS)        
-            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
+        else if (curr_regime == MOVE_OPERATORS)        
+            moveOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1041,7 +1042,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
                           REMOVE_DEAD_CODE,
-                          SWAP_OPERATORS };
+                          MOVE_OPERATORS };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -1922,6 +1923,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 +2348,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case INSERT_NO_DISTR_FLAGS_FROM_GUI:
     case PRIVATE_REMOVING:
     case RENAME_INLCUDES:
-    case SWAP_OPERATORS:
+    case MOVE_OPERATORS:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:
@@ -2379,6 +2384,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,7 +124,7 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    SWAP_OPERATORS,
+    MOVE_OPERATORS,
 
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
@@ -273,6 +275,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 +326,7 @@ static void setPassValues()
     passNames[CHECK_PAR_REG_DIR] = "CHECK_PAR_REG_DIR";
     passNames[CREATE_INTER_TREE] = "CREATE_INTER_TREE";
     passNames[INSERT_INTER_TREE] = "INSERT_INTER_TREE";
-    passNames[SWAP_OPERATORS] = "SWAP_OPERATORS";
+    passNames[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

@@ -12,31 +12,29 @@
 #include "../../CFGraph/CFGraph.h"
 #include "../../CFGraph/IR.h"
 #include "../../GraphLoop/graph_loops.h"
-#include "swap_operators.h"
+#include "move_operators.h"
 
 using namespace std;
 
-string getNameByArg(SAPFOR::Argument* arg);
-
-static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, vector<SAPFOR::BasicBlock*> Blocks) {
+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()) {
+            if (curOperator->lineNumber() == st->lineNumber())
                 result.push_back(instruction);
-            }
         }
     }
     return result;
 }
 
-unordered_set<int> loop_tags = {FOR_NODE};
-unordered_set<int> control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE};
-unordered_set<int> control_end_tags = {CONTROL_END};
+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;
@@ -45,58 +43,58 @@ struct OperatorInfo {
     int lineNumber;
     bool isMovable;
     
-    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) {}
+    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 (!stmt || !parent || stmt == parent)
+        return false;
     
     if (parent->variant() == LOGIF_NODE) {
-        if (stmt->lineNumber() == parent->lineNumber()) {
+        if (stmt->lineNumber() == parent->lineNumber())
             return true;
-        }
         
         SgStatement* current = parent;
         SgStatement* lastNode = parent->lastNodeOfStmt();
 
         while (current && current != lastNode) {
-            if (current == stmt) {
+            if (current == stmt)
                 return true;
-            }
-            if (current->isIncludedInStmt(*stmt)) {
+
+            if (current->isIncludedInStmt(*stmt))
                 return true;
-            }
+
             current = current->lexNext();
         }
     }
     
-    if (parent->isIncludedInStmt(*stmt)) {
+    if (parent->isIncludedInStmt(*stmt))
         return true;
-    }
     
     return false;
 }
 
 static bool isLoopBoundary(SgStatement* stmt) {
-    if (!stmt) return false;
+    if (!stmt)
+        return false;
     
-    if (stmt->variant() == FOR_NODE || stmt->variant() == CONTROL_END) {
+    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;
+    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()) {
+    if (!loopStart || !loopEnd)
+        return false;
+    
+    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
     
     SgStatement* current = loopStart;
     
@@ -121,60 +119,58 @@ static bool isPartOfNestedLoop(SgStatement* stmt, SgForStmt* loop) {
 }
 
 static bool canSafelyExtract(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop) return false;
-    
-    if (isLoopBoundary(stmt)) {
+    if (!stmt || !loop)
         return false;
-    }
     
-    if (control_tags.find(stmt->variant()) != control_tags.end()) {
+    if (isLoopBoundary(stmt))
         return false;
-    }
     
-    if (isPartOfNestedLoop(stmt, loop)) {
+    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;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     SgStatement* current = loopStart;
     
     while (current && current != loopEnd) {
-        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber()) {
+        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber())
             return false;
-        }
 
-        if (control_tags.find(current->variant()) != control_tags.end()) {
-            if (isStatementEmbedded(stmt, current)) {
+        if (control_tags.find(current->variant()) != control_tags.end())
+            if (isStatementEmbedded(stmt, current))
                 return false;
-            }
-        }
-        if (current == stmt) break;
+
+        if (current == stmt) 
+            break;
         current = current->lexNext();
     }
     
     return true;
 }
 
-static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+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) {
+    if (!loopStart || !loopEnd)
         return operators;
-    }
     
     SgStatement* current = loopStart;
     unordered_set<SgStatement*> visited;
     
     while (current && current != loopEnd) {
         
-        if (visited.find(current) != visited.end()) {
+        if (visited.find(current) != visited.end())
             break;
-        }
+
         visited.insert(current);
         
         if (isLoopBoundary(current)) {
@@ -184,11 +180,10 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
         
         if (current->variant() == FOR_NODE && current != loop) {
             SgStatement* nestedEnd = current->lastNodeOfStmt();
-            if (nestedEnd) {
+            if (nestedEnd)
                 current = nestedEnd->lexNext();
-            } else {
+            else
                 current = current->lexNext();
-            }
             continue;
         }
         
@@ -197,6 +192,7 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
                 current = current->lexNext();
                 continue;
             }
+
             if (current->variant() != ASSIGN_STAT) {
                 current = current->lexNext();
                 continue;
@@ -206,27 +202,26 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
             
             vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
             for (auto irBlock : irBlocks) {
-                if (!irBlock || !irBlock->getInstruction()) continue;
-                
-                SAPFOR::Instruction* instr = irBlock->getInstruction();
+                if (!irBlock || !irBlock->getInstruction()) 
+                    continue;
                 
+                const SAPFOR::Instruction* instr = irBlock->getInstruction();
                 if (instr->getArg1()) {
                     string varName = getNameByArg(instr->getArg1());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.usedVars.insert(varName);
-                    }
                 }
+
                 if (instr->getArg2()) {
                     string varName = getNameByArg(instr->getArg2());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.usedVars.insert(varName);
-                    }
                 }
+
                 if (instr->getResult()) {
                     string varName = getNameByArg(instr->getResult());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.definedVars.insert(varName);
-                    }
                 }
             }
             
@@ -240,38 +235,39 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
 
 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) {
+    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;
+    if (!from || !to) 
+        return INT_MAX;
+
     return abs(to->lineNumber() - from->lineNumber());
 }
 
-static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions, SgForStmt* loop) {
-    OperatorInfo* opInfo = nullptr;
+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) {
+
+    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[usedVar]) {
+            for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
                 if (defStmt->lineNumber() < operatorStmt->lineNumber()) {
                     if (defStmt->controlParent() == operatorStmt->controlParent()) {
                         if (defStmt->lineNumber() > bestLine) {
@@ -290,13 +286,11 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
         
         for (const string& usedVar : opInfo->usedVars) {
             if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-                for (SgStatement* defStmt : varDefinitions[usedVar]) {
-                    if (defStmt == operatorStmt) {
+                for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
+                    if (defStmt == operatorStmt)
                         continue;
-                    }
                     
                     hasAnyDefinition = true;
-                    
                     if (defStmt->lineNumber() < operatorStmt->lineNumber() &&
                         defStmt->controlParent() == operatorStmt->controlParent()) {
                         allLoopCarried = false;
@@ -304,7 +298,9 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
                     }
                 }
             }
-            if (!allLoopCarried) break;
+
+            if (!allLoopCarried) 
+                break;
         }
         
         if (allLoopCarried || (!hasAnyDefinition && !opInfo->usedVars.empty())) {
@@ -317,12 +313,14 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
 }
 
 static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
-    if (!from || !to || from == to) return false;
+    if (!from || !to || from == to)
+        return false;
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
     
-    if (!loopStart || !loopEnd) return false;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     if (to == loopStart) {
         SgStatement* fromControlParent = from->controlParent();
@@ -330,20 +328,17 @@ static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
         return fromControlParent == loop || fromControlParent == loopStart->controlParent();
     }
     
-    if (from->lineNumber() < loopStart->lineNumber() || from->lineNumber() > loopEnd->lineNumber()) {
+    if (from->lineNumber() < loopStart->lineNumber() || from->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
-    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber()) {
+
+    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
     
-    if (to->lineNumber() >= from->lineNumber()) {
+    if (to->lineNumber() >= from->lineNumber())
         return false;
-    }
     
-    if (from->controlParent() != to->controlParent()) {
+    if (from->controlParent() != to->controlParent())
         return false;
-    }
     
     SgStatement* current = to->lexNext();
     while (current && current != from && current != loopEnd) {
@@ -361,31 +356,31 @@ static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
     return true;
 }
 
-static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
+static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, 
+                                                  const vector<OperatorInfo>& operators, 
+                                                  const map<string, vector<SgStatement*>>& varDefinitions) {
     vector<SgStatement*> newOrder;
-    for (auto& op : operators) {
+    for (auto& op : operators)
         newOrder.push_back(op.stmt);
-    }
     
-    map<SgStatement*, OperatorInfo*> stmtToOpInfo;
-    for (auto& op : operators) {
+    map<SgStatement*, const OperatorInfo*> stmtToOpInfo;
+    for (auto& op : operators) 
         stmtToOpInfo[op.stmt] = &op;
-    }
     
     bool changed = true;
-    int iterations = 0;
-    const int MAX_ITERATIONS = 50;
     
-    while (changed && iterations < MAX_ITERATIONS) {
+    while (changed) {
         changed = false;
-        iterations++;
         
         for (int i = operators.size() - 1; i >= 0; i--) {
-            if (!operators[i].isMovable) continue;
+            if (!operators[i].isMovable) 
+                continue;
             
             SgStatement* stmt = operators[i].stmt;
-            OperatorInfo* opInfo = stmtToOpInfo[stmt];
-            if (!opInfo) continue;
+            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
+
+            if (!opInfo)
+                continue;
             
             size_t currentPos = 0;
             for (size_t j = 0; j < newOrder.size(); j++) {
@@ -401,7 +396,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                 bool hasDependents = false;
                 for (size_t j = currentPos + 1; j < newOrder.size(); j++) {
                     SgStatement* candidate = newOrder[j];
-                    OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                     if (candidateOpInfo) {
                         for (const string& definedVar : opInfo->definedVars) {
                             if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
@@ -409,7 +404,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                 break;
                             }
                         }
-                        if (hasDependents) break;
+
+                        if (hasDependents) 
+                            break;
                     }
                 }
                 
@@ -424,7 +421,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                 
                 for (size_t j = 0; j < currentPos && j < newOrder.size(); j++) {
                     SgStatement* candidate = newOrder[j];
-                    OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                     if (candidateOpInfo) {
                         bool usesDefinedVar = false;
                         for (const string& definedVar : opInfo->definedVars) {
@@ -433,6 +430,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                 break;
                             }
                         }
+
                         if (usesDefinedVar) {
                             targetPos = j;
                             break;
@@ -463,7 +461,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     
                     for (size_t j = bestPosIdx + 1; j < currentPos && j < newOrder.size(); j++) {
                         SgStatement* candidate = newOrder[j];
-                        OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                         if (candidateOpInfo) {
                             bool definesUsedVar = false;
                             for (const string& usedVar : opInfo->usedVars) {
@@ -472,16 +470,15 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                     break;
                                 }
                             }
-                            if (definesUsedVar) {
+                            if (definesUsedVar)
                                 targetPos = j + 1;
-                            }
                         }
                     }
                     
                     bool wouldBreakDependency = false;
                     for (size_t j = targetPos; j < currentPos && j < newOrder.size(); j++) {
                         SgStatement* candidate = newOrder[j];
-                        OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                         if (candidateOpInfo) {
                             for (const string& definedVar : opInfo->definedVars) {
                                 if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
@@ -489,7 +486,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                     break;
                                 }
                             }
-                            if (wouldBreakDependency) break;
+
+                            if (wouldBreakDependency) 
+                                break;
                         }
                     }
                     
@@ -512,18 +511,19 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
         
         for (size_t i = 0; i < newOrder.size(); i++) {
             SgStatement* stmt = newOrder[i];
-            OperatorInfo* opInfo = stmtToOpInfo[stmt];
-            if (!opInfo) continue;
+            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
+            if (!opInfo) 
+                continue;
             
             for (size_t j = 0; j < i; j++) {
                 SgStatement* prevStmt = newOrder[j];
-                OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
-                if (!prevOpInfo) continue;
+                const OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
+                if (!prevOpInfo)
+                    continue;
                 
                 pair<SgStatement*, SgStatement*> key = make_pair(stmt, prevStmt);
-                if (triedPairs.find(key) != triedPairs.end()) {
+                if (triedPairs.find(key) != triedPairs.end())
                     continue;
-                }
                 
                 bool violation = false;
                 for (const string& definedVar : opInfo->definedVars) {
@@ -539,8 +539,10 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     bool wouldCreateViolation = false;
                     for (size_t k = j; k < i; k++) {
                         SgStatement* betweenStmt = newOrder[k];
-                        OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
-                        if (!betweenOpInfo) continue;
+                        const OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
+
+                        if (!betweenOpInfo)
+                            continue;
                         
                         for (const string& usedVar : opInfo->usedVars) {
                             if (betweenOpInfo->definedVars.find(usedVar) != betweenOpInfo->definedVars.end()) {
@@ -548,7 +550,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                 break;
                             }
                         }
-                        if (wouldCreateViolation) break;
+
+                        if (wouldCreateViolation)
+                            break;
                     }
                     
                     if (!wouldCreateViolation) {
@@ -559,27 +563,31 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     }
                 }
             }
-            if (dependencyViolation) break;
+
+            if (dependencyViolation)
+                break;
         }
     }
     
     return newOrder;
 }
 
-static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOrder) {
-    if (!loop || newOrder.empty()) return false;
+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;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     vector<SgStatement*> originalOrder;
     SgStatement* current = loopStart;
     while (current && current != loopEnd) {
-        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT) {
+        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT)
             originalOrder.push_back(current);
-        }
+
         current = current->lexNext();
     }
     
@@ -591,14 +599,13 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 break;
             }
         }
-    } else {
+    } 
+    else
         orderChanged = true;
-    }
     
-    if (!orderChanged) {
+    if (!orderChanged)
         return false;
-    }
-    
+
     vector<SgStatement*> extractedStatements;
     vector<char*> savedComments;
     unordered_set<SgStatement*> extractedSet;
@@ -607,13 +614,11 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
     
     for (SgStatement* stmt : newOrder) {
         if (stmt && stmt != loop && stmt != loopEnd && extractedSet.find(stmt) == extractedSet.end()) {
-            if (control_tags.find(stmt->variant()) != control_tags.end()) {
+            if (control_tags.find(stmt->variant()) != control_tags.end())
                 continue;
-            }
             
-            if (!canSafelyExtract(stmt, loop)) {
+            if (!canSafelyExtract(stmt, loop))
                 continue;
-            }
             
             bool isMoving = false;
             for (size_t i = 0; i < originalOrder.size(); i++) {
@@ -628,9 +633,8 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 }
             }
             
-            if (!isMoving) {
+            if (!isMoving)
                 continue;
-            }
             
             originalLineNumbers[stmt] = stmt->lineNumber();
             savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
@@ -650,7 +654,9 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
         
         if (extractedSet.find(stmt) != extractedSet.end()) {
             SgStatement* stmtToInsert = stmtToExtracted[stmt];
-            if (!stmtToInsert) continue;
+
+            if (!stmtToInsert) 
+                continue;
             
             SgStatement* insertAfter = loop;
             
@@ -696,16 +702,15 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 }
             }
             
-            if (commentIdx < savedComments.size() && savedComments[commentIdx]) {
+            if (commentIdx < savedComments.size() && savedComments[commentIdx])
                 stmtToInsert->setComments(savedComments[commentIdx]);
-            }
             
-            if (originalLineNumbers.find(stmt) != originalLineNumbers.end()) {
+            if (originalLineNumbers.find(stmt) != originalLineNumbers.end())
                 stmtToInsert->setlineNumber(originalLineNumbers[stmt]);
-            }
             
             SgStatement* controlParent = stmt->controlParent();
-            if (!controlParent) controlParent = loop;
+            if (!controlParent)
+                controlParent = loop;
             
             insertAfter->insertStmtAfter(*stmtToInsert, *controlParent);
             insertedStatements[stmt] = stmtToInsert;
@@ -713,26 +718,28 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
     }
     
     for (char* comment : savedComments) {
-        if (comment) {
+        if (comment)
             free(comment);
-        }
     }
     
     return true;
 }
 
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+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())
+        if (func.first->funcPointer->getCurrProcessFile() == forSt->getCurrProcessFile()
+            && func.first->funcPointer->lineNumber() == forSt->lineNumber())
+        {
             result = func.second;
+        }
     }
     return result;
 }
 
-map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, vector<SAPFOR::BasicBlock*> blocks) {
+map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, const vector<SAPFOR::BasicBlock*>& blocks) {
     map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
     SgStatement *lastNode = st->lastNodeOfStmt();
     
@@ -756,15 +763,17 @@ map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st
                 }
                 loopBody = loopBody -> lexNext();
             }
-            std::sort(result[forSt].begin(), result[forSt].end());
+            sort(result[forSt].begin(), result[forSt].end());
         }
         st = st -> lexNext();
     }
     return result;
 }
 
-static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    if (!loop) return;
+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();
@@ -775,14 +784,14 @@ static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*>
                 SgForStmt* nestedLoop = (SgForStmt*)current;
                 processLoopRecursively(nestedLoop, blocks, FullIR);
                 SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
-                if (nestedEnd) {
+
+                if (nestedEnd)
                     current = nestedEnd->lexNext();
-                } else {
+                else
                     current = current->lexNext();
-                }
-            } else {
+            } 
+            else
                 current = current->lexNext();
-            }
         }
     }
     
@@ -794,24 +803,24 @@ static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*>
     }
 }
 
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform) {
+void moveOperators(SgFile *file, map<string, vector<LoopGraph*>>& loopGraph, 
+                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, 
+                   int& countOfTransform) {
     countOfTransform += 1;
     
-    std::cout << "SWAP_OPERATORS Pass Started" << std::endl;
+    //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);
-        
+        vector<SAPFOR::BasicBlock*> blocks = findFuncBlocksByFuncStatement(st, FullIR);        
         map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
         
-        for (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping) {
+        for (auto& loopForAnalyze: loopsMapping)
             processLoopRecursively(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-        }
     }
     
-    std::cout << "SWAP_OPERATORS Pass Completed" << std::endl;
+    //cout << "MOVE_OPERATORS Pass Completed" << endl;
 }

src/Transformations/MoveOperators/move_operators.h

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

src/Transformations/SwapOperators/swap_operators.h

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

src/Utils/PassManager.h

@@ -212,8 +212,6 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     Pass(BUILD_IR) <= Pass(SUBST_EXPR_RD) <= Pass(SUBST_EXPR_RD_AND_UNPARSE);
 
-    list({BUILD_IR, CALL_GRAPH2}) <= Pass(SWAP_OPERATORS);
-
     list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
     list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING);
 
@@ -321,6 +319,9 @@ 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);
 
+    Pass(CREATE_TEMPLATE_LINKS) <= Pass(MERGE_COPY_ARRAYS);
+    list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);
+
     passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, 
                                    EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW,
                                    REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL,

src/Utils/version.h

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

src/VisualizerCalls/get_information.cpp

@@ -1802,6 +1802,13 @@ 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)
@@ -2510,6 +2517,8 @@ 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;