From 33851c0e4c6ac209be93d57620c0f3040bdf7a4f Mon Sep 17 00:00:00 2001 From: xnpster Date: Wed, 24 Dec 2025 23:18:38 +0300 Subject: [PATCH] draft of parallel regions merging pass --- CMakeLists.txt | 4 + .../parse_merge_dirs.cpp | 567 ++++++++++++++++++ src/ParallelizationRegions/parse_merge_dirs.h | 8 + src/Sapfor.cpp | 6 + src/Sapfor.h | 3 + src/Utils/PassManager.h | 2 + 6 files changed, 590 insertions(+) create mode 100644 src/ParallelizationRegions/parse_merge_dirs.cpp create mode 100644 src/ParallelizationRegions/parse_merge_dirs.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 580342b..cbc5e14 100644 --- a/CMakeLists.txt +++ b/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) @@ -423,6 +425,7 @@ set(SOURCE_EXE ${LOOP_ANALYZER} ${TRANSFORMS} ${PARALLEL_REG} + ${MERGE_COPY_ARRAYS} ${PRIV} ${ARRAY_PROP} ${FDVM} @@ -475,6 +478,7 @@ source_group (GraphCall FILES ${GR_CALL}) source_group (GraphLoop FILES ${GR_LOOP}) source_group (LoopAnalyzer FILES ${LOOP_ANALYZER}) source_group (ParallelizationRegions FILES ${PARALLEL_REG}) +source_group (MergeCopyArrays FILES ${MERGE_COPY_ARRAYS}) source_group (PrivateAnalyzer FILES ${PRIV}) source_group (ArrayConstantPropagation FILES ${ARRAY_PROP}) source_group (FDVM_Compiler FILES ${FDVM}) diff --git a/src/ParallelizationRegions/parse_merge_dirs.cpp b/src/ParallelizationRegions/parse_merge_dirs.cpp new file mode 100644 index 0000000..1701427 --- /dev/null +++ b/src/ParallelizationRegions/parse_merge_dirs.cpp @@ -0,0 +1,567 @@ +#include "parse_merge_dirs.h" + +#include + +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> &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 ®_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 ®ions, + const unordered_map &new_region_mapping) +{ + // new region -> old regions + unordered_map> 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 &align_a, + const std::unordered_set &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, SgSymbol *> generateDeclaration(const string &array_name, const string &common_block_name, + const vector> &sizes, SgType *type, SgStatement *scope) +{ + auto *array_symbol = new SgSymbol(VARIABLE_NAME, array_name.c_str(), new SgType(T_ARRAY), scope); + + auto *decl = new SgDeclarationStatement(VAR_DECL); + + decl->setExpression(1, new SgTypeExp(*type)); + + SgExpression *subs = new SgExprListExp(); + + auto *array_ref = new SgArrayRefExp(*array_symbol, *subs); + + for (int i = 0; i < sizes.size(); i++) + { + const auto &p = sizes[i]; + auto *d = new SgExpression(DDOT, new SgValueExp(p.first), new SgValueExp(p.second)); + subs->setLhs(d); + + if (i + 1 < sizes.size()) + { + subs->setRhs(new SgExprListExp()); + subs = subs->rhs(); + } + } + + decl->setExpression(0, array_ref); + + auto comm = new SgStatement(COMM_STAT); + + comm->setExpression(0, new SgExpression(COMM_LIST, + new SgVarRefExp(array_symbol), + NULL, + new SgSymbol(COMMON_NAME, common_block_name.c_str()))); + + return {{decl, comm}, array_symbol}; +} + +SgSymbol *insertDeclIfNeeded(const string &array_name, + const string &common_block_name, + DIST::Array *example_array, + FuncInfo *dest, + unordered_map> &inserted_arrays) +{ + if (SgFile::switchToFile(dest->fileName) == -1) + printInternalError(convertFileName(__FILE__).c_str(), __LINE__); + + auto &by_func = inserted_arrays[dest]; + auto it = by_func.find(array_name); + + if (it != by_func.end()) + return it->second; + + SgStatement *st = dest->funcPointer; + + auto *end = st->lastNodeOfStmt(); + + st = st->lexNext(); + + while (st != end && !isSgExecutableStatement(st)) + { + st = st->lexNext(); + } + + auto generated = generateDeclaration(array_name, common_block_name, + example_array->GetSizes(), + SgTypeInt(), dest->funcPointer); + for (auto *new_stmt : generated.first) + st->insertStmtBefore(*new_stmt, *dest->funcPointer); + + by_func[array_name] = generated.second; + + return generated.second; +} + +static pair createNewArray(DIST::Array *example_array, const string &base_name, + const map> &allFuncInfo, + unordered_map> &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 &arrays_to_replace, + SgSymbol **func_symbol_hint, + const pair &replace_by, + DIST::Array *example_array, + FuncInfo *func, + unordered_map> &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 &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 ®ions, const map> &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 ¤tVariant = 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> arrays_to_merge; + unordered_map> 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> 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 new_region_mapping; + + // new array -> new region + unordered_map arrays_new_region_mapping; + vector 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> inserted_arrays; + + for (const auto &by_dest_array : arrays_to_merge) + { + const auto ©_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 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(); + } + } + } + } +} \ No newline at end of file diff --git a/src/ParallelizationRegions/parse_merge_dirs.h b/src/ParallelizationRegions/parse_merge_dirs.h new file mode 100644 index 0000000..54c2287 --- /dev/null +++ b/src/ParallelizationRegions/parse_merge_dirs.h @@ -0,0 +1,8 @@ +#include "../GraphCall/graph_calls.h" +#include "ParRegions.h" + +#include +#include +#include + +void mergeCopyArrays(std::vector ®ions, const std::map> &allFuncInfo); \ No newline at end of file diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index d37f078..03610aa 100644 --- a/src/Sapfor.cpp +++ b/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" @@ -1918,6 +1919,10 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne transformAssumedSizeParameters(allFuncInfo); else if (curr_regime == FIND_PRIVATE_ARRAYS_ANALYSIS) FindPrivateArrays(loopGraph, fullIR, insertedPrivates); + else if (curr_regime == MERGE_COPY_ARRAYS) + { + mergeCopyArrays(parallelRegions, allFuncInfo); + } else if (curr_regime == ARRAY_PROPAGATION) ArrayConstantPropagation(project); @@ -2374,6 +2379,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam case FIX_COMMON_BLOCKS: case TEST_PASS: case SET_IMPLICIT_NONE: + case MERGE_COPY_ARRAYS: runAnalysis(*project, curr_regime, false); case SUBST_EXPR_RD_AND_UNPARSE: case SUBST_EXPR_AND_UNPARSE: diff --git a/src/Sapfor.h b/src/Sapfor.h index 7f21c22..f51127b 100644 --- a/src/Sapfor.h +++ b/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, @@ -271,6 +273,7 @@ static void setPassValues() passNames[VERIFY_DVM_DIRS] = "VERIFY_DVM_DIRS"; passNames[REMOVE_DVM_DIRS_TO_COMMENTS] = "REMOVE_DVM_DIRS_TO_COMMENTS"; passNames[REMOVE_SPF_DIRS] = "REMOVE_SPF_DIRS"; + passNames[MERGE_COPY_ARRAYS] = "MERGE_COPY_ARRAYS"; passNames[REMOVE_DIST_ARRAYS_FROM_IO] = "REMOVE_DIST_ARRAYS_FROM_IO"; passNames[SUBST_EXPR] = "SUBST_EXPR"; passNames[SUBST_EXPR_RD] = "SUBST_EXPR_RD"; diff --git a/src/Utils/PassManager.h b/src/Utils/PassManager.h index f2715d3..41432e1 100644 --- a/src/Utils/PassManager.h +++ b/src/Utils/PassManager.h @@ -319,6 +319,8 @@ void InitPassesDependencies(map> &passDepsIn, set 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); + 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,