region merging: derive array types

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)
@@ -426,6 +428,7 @@ set(SOURCE_EXE
     ${LOOP_ANALYZER}
     ${TRANSFORMS}
     ${PARALLEL_REG}
+    ${MERGE_COPY_ARRAYS}
     ${PRIV}
     ${ARRAY_PROP}
     ${FDVM}
@@ -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/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/PrivateAnalyzer/private_arrays_search.cpp

@@ -1,4 +1,3 @@
-#include <algorithm>
 #include <map>
 #include <unordered_set>
 #include <unordered_map>
@@ -17,8 +16,6 @@
 
 using namespace std;
 
-static unordered_set<Region*> collapsed;
-
 static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
 {
     ArrayAccessingIndexes resultContainer;
@@ -52,81 +49,41 @@ static void Collapse(Region* region)
     if (region->getBasickBlocks().empty())
         return;
 
-    bool firstRegion = true;
+    for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out)
-    for (Region* basickBlock : region->getBasickBlocks())
     {
-        if (basickBlock->getNextRegions().empty())
+        for (Region* byBlock : region->getBasickBlocks())
         {
-            if (firstRegion)
+            AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges);
-            {
+            region->array_def[arrayName] = region->array_def[arrayName].Union(intersection);
-                region->array_def = basickBlock->array_out;
-                firstRegion = false;
-            }
-            else
-            {
-                unordered_set<string> toErease;
-                for (auto& [arrayName, arrayRanges] : region->array_def)
-                {
-                    if (basickBlock->array_out.find(arrayName) != basickBlock->array_out.end())
-                        arrayRanges = arrayRanges.Intersect(basickBlock->array_out[arrayName]);
-                    else
-                    {
-                        arrayRanges = AccessingSet();
-                        toErease.insert(arrayName);
-                    }
-                }
-                for (string arrayName : toErease)
-                    region->array_def.erase(arrayName);
-            }
         }
     }
 
-    RegionInstruction instruction;
-    instruction.def = move(region->array_def);
-
-
     for (auto& byBlock : region->getBasickBlocks()) 
     {
-        for (auto& instruction : byBlock->instructions)
+        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
         {
-            for (auto& [arrayName, _] : instruction.use)
+            AccessingSet diff = byBlock->array_use[arrayName].Diff(byBlock->array_in[arrayName]);
-            {
+            region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
-                AccessingSet diff = instruction.use[arrayName].Diff(instruction.in[arrayName]);
-                region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
-            }
         }
     }
 
-    ArrayAccessingIndexes useUnionB;
+    ArrayAccessingIndexes useUnion;
     for (auto& byBlock : region->getBasickBlocks())
-        for (auto& instruction : byBlock->instructions)
+        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
-            for (auto& [arrayName, _] : instruction.use)
+            useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
-                useUnionB[arrayName] = useUnionB[arrayName].Union(instruction.use[arrayName]);
 
-    for (auto& [arrayName, _] : useUnionB)
+    region->array_priv = region->array_use;
-        region->array_priv[arrayName] = useUnionB[arrayName].Diff(region->array_use[arrayName]);
-
-    instruction.use = move(region->array_use);
     
     for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
-    {
         prevBlock->replaceInNextRegions(region, region->getHeader());
-        region->addPrevRegion(prevBlock);
-    }
     
     for (Region* nextBlock : region->getHeader()->getNextRegions())
-    {
         nextBlock->replaceInPrevRegions(region, region->getHeader());
-        region->addNextRegion(nextBlock);
-    }
-    region->instructions.push_back(instruction);
-
 }
 
 static void SolveDataFlowIteratively(Region* DFG) 
 {
-    auto blocks = DFG->getBasickBlocks();
+    unordered_set<Region*> worklist(DFG->getBasickBlocks());
-    std::unordered_set<Region*> worklist(blocks.begin(), blocks.end());
     do
     {
         Region* b = *worklist.begin();
@@ -144,7 +101,7 @@ static void SolveDataFlowIteratively(Region* DFG)
                 if (prevBlock->array_out.empty())
                 {
                     newIn.clear();
-                    break;
+                    continue;
                 }
 
                 for (const auto& [arrayName, accessSet] : prevBlock->array_out)
@@ -180,153 +137,21 @@ static void SolveDataFlowIteratively(Region* DFG)
             b->array_out = newOut;
         else
             worklist.erase(b);
-    } while (!worklist.empty());
-}
-
-static void SolveForBasickBlock(Region* block)
-{
-    ArrayAccessingIndexes newIn;
-    bool flagFirst = true;
-    for (Region* prevBlock : block->getPrevRegions())
-    {
-        if (flagFirst)
-        {
-            newIn = prevBlock->array_out;
-            flagFirst = false;
-        }
-        else
-        {
-            if (prevBlock->array_out.empty())
-            {
-                newIn.clear();
-                break;
-            }
-
-            for (const auto& [arrayName, accessSet] : prevBlock->array_out)
-            {
-                if (newIn.find(arrayName) != newIn.end())
-                    newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
-                else
-                    newIn[arrayName] = AccessingSet();
-            }
-        }
-    }
-
-    if (block->instructions.empty())
-        block->instructions.push_back(RegionInstruction());
-
-    block->instructions[0].in = move(newIn);
-
-    for (int i = 0; i < block->instructions.size(); i++)
-    {
-        auto& instruction = block->instructions[i];
-
-        if (i > 0)
-            instruction.in = block->instructions[i - 1].out;
-
-        ArrayAccessingIndexes newOut;
-        if (instruction.def.empty())
-            newOut = instruction.in;
-        else if (instruction.in.empty())
-            newOut = instruction.def;
-        else
-        {
-            for (auto& [arrayName, accessSet] : instruction.def)
-            {
-                if (instruction.in.find(arrayName) != instruction.in.end())
-                    newOut[arrayName] = instruction.def[arrayName].Union(instruction.in[arrayName]);
-                else
-                    newOut[arrayName] = accessSet;
-            }
-            for (auto& [arrayName, accessSet] : instruction.in)
-            {
-                if (newOut.find(arrayName) == newOut.end())
-                {
-                    newOut[arrayName] = accessSet;
-                }
-            }
-        }
-
-        instruction.out = move(newOut);
-    }
-    if (!block->instructions.empty())
-        block->array_out = block->instructions.back().out;
-}
-
-static void SolveDataFlowTopologically(Region* DFG)
-{
-    for (Region* b : DFG->getBasickBlocks())
-    {
-        collapsed.insert(b);
-        SolveForBasickBlock(b);
     } 
+    while (!worklist.empty());
 }
 
 static void SolveDataFlow(Region* DFG)
 {
     if (!DFG)
         return;
+
+    SolveDataFlowIteratively(DFG);
     for (Region* subRegion : DFG->getSubRegions())
-    {
         SolveDataFlow(subRegion);
-        DFG->addBasickBlocks(subRegion);
-    }
-    vector<Region*>& blocks = DFG->getBasickBlocks();
-    auto pos = remove_if(blocks.begin(), blocks.end(), [](Region* r) { return collapsed.find(r) != collapsed.end(); });
-    blocks.erase(pos, blocks.end());
-    TopologySort(DFG->getBasickBlocks(), DFG->getHeader());
-    SolveDataFlowTopologically(DFG);
     Collapse(DFG);
 }
 
-static bool getArrayDeclaredDimensions(SgArrayRefExp* arrayRef, vector<uint64_t>& declaredDims)
-{
-    declaredDims.clear();
-    if (!arrayRef || !arrayRef->symbol() || !isSgArrayType(arrayRef->symbol()->type()))
-        return false;
-    SgArrayType* arrayType = (SgArrayType*)arrayRef->symbol()->type();
-    int dimCount = arrayType->dimension();
-    for (int i = 0; i < dimCount; i++)
-    {
-        SgExpression* sizeExpr = arrayType->sizeInDim(i);
-        SgConstantSymb* constValSymb = isSgConstantSymb(sizeExpr->symbol());
-        string strDimLength;
-        if (sizeExpr && sizeExpr->variant() == INT_VAL)
-            strDimLength = sizeExpr->unparse();
-        else if (constValSymb)
-            strDimLength = constValSymb->constantValue()->unparse();
-        else
-            return false;
-
-        if (strDimLength == "0")
-            return false;
-        declaredDims.push_back((uint64_t)stoi(strDimLength));
-    }
-    return true;
-}
-
-static bool CheckDimensionLength(const AccessingSet& array)
-{
-    if (array.GetElements().empty())
-        return false;
-    size_t dimCount = array.GetElements()[0].size();
-    SgArrayRefExp* arrayRef = array.GetElements()[0][0].array;
-    if (!arrayRef)
-        return false;
-    vector<uint64_t> declaredDims(dimCount);
-    if (!getArrayDeclaredDimensions(arrayRef, declaredDims))
-        return false;
-    vector<ArrayDimension> testArray(dimCount);
-    for (size_t i = 0; i < dimCount; i++)
-    {
-        testArray[i] = { 1, 1, declaredDims[i], nullptr };
-    }
-    AccessingSet diff = AccessingSet({ testArray }).Diff(array);
-
-    return diff.GetElements().empty();
-}
-
-
 static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
 {
     SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
@@ -336,8 +161,6 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
     set<SgSymbol*> arraysToInsert;
     for (const auto& [_, accessingSet] : privates)
     {
-        if (!CheckDimensionLength(accessingSet))
-            continue;
         for (const auto& arrayElement : accessingSet.GetElements())
         {
             if (arrayElement.empty())
@@ -365,14 +188,14 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
         toAdd->setLhs(new SgVarRefExp(elem));
     }
     
-    if (arraysToInsert.size() != 0)
+    if (arraysToInsert.size() == 0)
-    {
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-        loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
+
-        insertedPrivates.insert(spfStat);
+    loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
-    }
+    insertedPrivates.insert(spfStat);
 }
 
-void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*>& insertedPrivates)
+void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*> &insertedPrivates)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
     for (const auto& [fileName, loops] : loopGraph)
@@ -387,7 +210,7 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*
             while (search_func && (!isSgProgHedrStmt(search_func)))
                 search_func = search_func->controlParent();
 
-            for (const auto& [funcInfo, blocks] : FullIR)
+            for (const auto& [funcInfo, blocks]: FullIR)
             {   
                 if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
                 {

src/PrivateAnalyzer/range_structures.cpp

@@ -47,7 +47,7 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
     
     uint64_t start3 = dim1.start + x0 * dim1.step;
     uint64_t step3 = c * dim1.step;
-    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array };
+    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array};
     return result;
 }
 
@@ -61,7 +61,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
     vector<ArrayDimension> result;
     /* add the part before intersection */
     if (dim1.start < intersection->start)    
-        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array });
+        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array});
     
     /* add the parts between intersection steps */
     if (intersection->step > dim1.step)
@@ -70,7 +70,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
         uint64_t interValue = intersection->start;
         for (int64_t i = start; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
         {
-            result.push_back({ interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array });
+            result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
             interValue += intersection->step;
         }
     }
@@ -132,10 +132,8 @@ static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>&
 static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimension>& firstElement,
     const vector<ArrayDimension>& secondElement)
 {
-    if (firstElement.empty())
+    if (firstElement.empty() || secondElement.empty())
         return {};
-    if (secondElement.empty())
-        return { firstElement };
     
     vector<ArrayDimension> intersection = ElementsIntersection(firstElement, secondElement);
     vector<vector<ArrayDimension>> result;
@@ -190,7 +188,7 @@ bool AccessingSet::ContainsElement(const vector<ArrayDimension>& element) const
 {
     vector<vector<ArrayDimension>> tails;
     FindUncovered(element, tails);
-    return tails.empty();
+    return !tails.empty();
 }
 
 void AccessingSet::FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const
@@ -254,15 +252,13 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const
         return *this;
 
     AccessingSet intersection = this->Intersect(secondSet);
-    vector<vector<ArrayDimension>> uncovered;
+    AccessingSet uncovered = *this;
-    for (const auto& element : allElements)
+    vector<vector<ArrayDimension>> result;
+    for (const auto& element : intersection.GetElements())
     {
         vector<vector<ArrayDimension>> current_uncovered;
-        intersection.FindUncovered(element, current_uncovered);
+        uncovered.FindUncovered(element, current_uncovered);
-        uncovered.insert(uncovered.end(),
+        uncovered = AccessingSet(current_uncovered);
-            std::move_iterator(current_uncovered.begin()),
-            std::move_iterator(current_uncovered.end())
-        );
     }
     return uncovered;
 }

src/PrivateAnalyzer/region.cpp

@@ -1,16 +1,14 @@
-#include <algorithm>
+#include<vector>
-#include <vector>
+#include<map>
-#include <map>
+#include<unordered_set>
-#include <unordered_set>
+#include<unordered_map>
-#include <unordered_map>
+#include<string>
-#include <string>
 #include <numeric>
 #include <iostream>
 
 #include "range_structures.h"
 #include "region.h"
 
-#include "..\Transformations\ExpressionSubstitution\expr_transform.h"
 #include "SgUtils.h"
 
 using namespace std;
@@ -95,7 +93,7 @@ static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, Loop
     return "";
 }
 
-static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use, Region* region) {
+static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use) {
     auto instructions = block->getInstructions();
     map<string, LoopGraph*> loopForIndex;
     BuildLoopIndex(loopForIndex, loop);
@@ -125,11 +123,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                     }
 
                     if (point.size() == dimCount)
-                    {
+                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({point});
-                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({ point });
-                        RegionInstruction regionInstruction;
-                        regionInstruction.def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({ point });
-                    }
                 }
             }
         }
@@ -154,27 +148,13 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
             auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
             int fillCount = 0;
 
-            vector<pair<int, int>> coeffsForDims;
+            while (!index_vars.empty() && !refPos.empty())
-            int subs = ref->numberOfSubscripts();
-            for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
-            {
-                const vector<int*>& coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
-                if (coeffs.size() == 1)
-                {
-                    const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
-                    coeffsForDims.push_back(coef);
-                }
-
-            }
-            coeffsForDims = { coeffsForDims.rbegin(), coeffsForDims.rend() };
-
-            while (!index_vars.empty() && !refPos.empty() && !coeffsForDims.empty())
             {
                 auto var = index_vars.back();
                 int currentVarPos = refPos.back();
                 ArrayDimension current_dim;
                 if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
-                    current_dim = { stoul(var->getValue()), 1, 1, ref };
+                    current_dim = { stoul(var->getValue()), 1, 1, ref};
                 else
                 {
                     string name, full_name = var->getValue();
@@ -200,7 +180,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                             return -1;
                     }
 
-                    uint64_t start = coeffsForDims.back().second * currentLoop->startVal + coeffsForDims.back().first;
+                    uint64_t start = currentLoop->startVal;
                     uint64_t step = currentLoop->stepVal;
                     uint64_t iters = currentLoop->calculatedCountOfIters;
                     current_dim = { start, step, iters, ref };
@@ -213,29 +193,14 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                 }
                 index_vars.pop_back();
                 refPos.pop_back();
-                coeffsForDims.pop_back();
             }
 
             if (fillCount == accessPoint.size())
             {
-                RegionInstruction instruction;
                 if (operation == SAPFOR::CFG_OP::STORE)
-                {
                     def[array_name].Insert(accessPoint);
-                    instruction.def[array_name] = { { accessPoint } };
-                }
                 else
-                {
+                    use[array_name].Insert(accessPoint);
-                    instruction.use[array_name] = { { accessPoint } };
-                    if (def.find(array_name) == def.end())
-                        use[array_name].Insert(accessPoint);
-                    else
-                    {
-                        AccessingSet element({ accessPoint });
-                        use[array_name] = use[array_name].Union(element.Diff(def[array_name]));
-                    }
-                }
-                region->instructions.push_back(instruction);
             }
         }
     }
@@ -243,41 +208,6 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
 
 }
 
-static void RemoveHeaderConnection(SAPFOR::BasicBlock* header, const unordered_set<SAPFOR::BasicBlock*>& blockSet, unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
-{
-    for (SAPFOR::BasicBlock* block : blockSet)
-    {
-        bool isCycleBlock = false;
-        for (SAPFOR::BasicBlock* prevBlock : block->getPrev())
-            isCycleBlock = isCycleBlock || (blockSet.find(prevBlock) != blockSet.end());
-
-        if (isCycleBlock)
-        {
-            bbToRegion[block]->removeNextRegion(bbToRegion[header]);
-            bbToRegion[header]->removePrevRegion(bbToRegion[block]);
-        }
-    }
-}
-
-static void DFS(Region* block, vector<Region*>& result, unordered_set<Region*> cycleBlocks)
-{
-    for (Region* nextBlock : block->getNextRegions())
-    {
-        if (cycleBlocks.find(nextBlock) != cycleBlocks.end())
-            DFS(nextBlock, result, cycleBlocks);
-    }
-    result.push_back(block);
-}
-
-void TopologySort(std::vector<Region*>& basikBlocks, Region* header)
-{
-    vector<Region*> result;
-    unordered_set<Region*> cycleBlocks(basikBlocks.begin(), basikBlocks.end());
-    DFS(header, result, cycleBlocks);
-    reverse(result.begin(), result.end());
-    basikBlocks = result;
-}
-
 static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
 {
     for (SAPFOR::BasicBlock* block : blockSet)
@@ -292,11 +222,10 @@ static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegi
     }
 }
 
-static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
+static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, const unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
 {
     Region* region = new Region;
     auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
-    RemoveHeaderConnection(header, blockSet, bbToRegion);
     if (bbToRegion.find(header) != bbToRegion.end())
         region->setHeader(bbToRegion.at(header));    
     else
@@ -315,7 +244,6 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
             continue;
         region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
     }
-    TopologySort(region->getBasickBlocks(), region->getHeader());
     return region;
 }
 
@@ -326,13 +254,12 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
     for (auto poiner : blockSet)
     {
         bbToRegion[poiner] = new Region(*poiner);
-        this->basickBlocks.push_back(bbToRegion[poiner]);
+        this->basickBlocks.insert(bbToRegion[poiner]);
-        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use, bbToRegion[poiner]);
+        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use);
 
     }
     this->header = bbToRegion[header];
     SetConnections(bbToRegion, blockSet);
-    RemoveHeaderConnection(header, blockSet, bbToRegion);
     //create subRegions
     for (LoopGraph* childLoop : loop->children)
     {
@@ -340,5 +267,4 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
             continue;
         subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
     }
-    TopologySort(basickBlocks, this->header);
 }

src/PrivateAnalyzer/region.h

@@ -8,11 +8,6 @@
 #include "graph_loops.h"
 #include "CFGraph/CFGraph.h"
 
-struct RegionInstruction
-{
-    ArrayAccessingIndexes def, use, in, out;
-};
-
 class Region : public SAPFOR::BasicBlock {
 public:
     Region() { header = nullptr; }
@@ -25,25 +20,13 @@ public:
 
     void setHeader(Region* region) { header = region; }
 
-    std::vector<Region*>& getBasickBlocks() { return basickBlocks; }
+    std::unordered_set<Region*>& getBasickBlocks() { return basickBlocks; }
 
-    void addBasickBlocks(Region* region) { basickBlocks.push_back(region); }
+    void addBasickBlocks(Region* region) { basickBlocks.insert(region); }
 
     const std::unordered_set<Region*>& getPrevRegions() { return prevRegions; }
 
-    std::unordered_set<Region*>& getNextRegions() { return nextRegions; }
+    std::unordered_set<Region*> getNextRegions() { return nextRegions; }
-
-    void removeNextRegion(Region* region)
-    {
-        if (nextRegions.find(region) != nextRegions.end())
-            nextRegions.erase(region);
-    }
-
-    void removePrevRegion(Region* region)
-    {
-        if (prevRegions.find(region) != prevRegions.end())
-            prevRegions.erase(region);
-    }
 
     void addPrevRegion(Region* region) { prevRegions.insert(region); }
 
@@ -65,18 +48,13 @@ public:
 
     void addSubRegions(Region* region) { subRegions.insert(region); }
 
-    std::vector<RegionInstruction> instructions;
-
     ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv;
 
 private:
-    std::vector<Region*> basickBlocks;
+    std::unordered_set<Region*> subRegions, basickBlocks;
-    std::unordered_set<Region*> subRegions;
     /*next Region which is BB for current BB Region*/
     std::unordered_set<Region*> nextRegions;
     /*prev Regions which is BBs for current BB Region*/
     std::unordered_set<Region*> prevRegions;
     Region* header;
 };
-
-void TopologySort(std::vector<Region*>& basikBlocks, Region* header);

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"
@@ -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);
@@ -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,
@@ -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";

src/Utils/PassManager.h

@@ -322,6 +322,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
     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,