From d77b6d52882e5e87c2cae8231965be40d7b9405b Mon Sep 17 00:00:00 2001 From: ALEXks Date: Sun, 19 Apr 2026 20:25:20 +0300 Subject: [PATCH] refactored --- CMakeLists.txt | 4 +- src/ParallelizationRegions/merge_regions.cpp | 66 ++++++----- .../resolve_par_reg_conflicts.cpp | 107 +----------------- .../resolve_par_reg_conflicts.h | 4 +- .../uniq_name_creator.cpp | 98 ++++++++++++++++ .../uniq_name_creator.h | 26 +++++ src/Utils/version.h | 2 +- 7 files changed, 170 insertions(+), 137 deletions(-) create mode 100644 src/ParallelizationRegions/uniq_name_creator.cpp create mode 100644 src/ParallelizationRegions/uniq_name_creator.h diff --git a/CMakeLists.txt b/CMakeLists.txt index c679fca..012efa1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -161,7 +161,9 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp src/ParallelizationRegions/expand_extract_reg.cpp src/ParallelizationRegions/expand_extract_reg.h src/ParallelizationRegions/resolve_par_reg_conflicts.cpp - src/ParallelizationRegions/resolve_par_reg_conflicts.h) + src/ParallelizationRegions/resolve_par_reg_conflicts.h + src/ParallelizationRegions/uniq_name_creator.cpp + src/ParallelizationRegions/uniq_name_creator.h) set(ARRAY_PROP src/ArrayConstantPropagation/propagation.cpp src/ArrayConstantPropagation/propagation.h diff --git a/src/ParallelizationRegions/merge_regions.cpp b/src/ParallelizationRegions/merge_regions.cpp index f047085..4c68fb2 100644 --- a/src/ParallelizationRegions/merge_regions.cpp +++ b/src/ParallelizationRegions/merge_regions.cpp @@ -1,14 +1,16 @@ +#include "leak_detector.h" + +#include +#include #include "merge_regions.h" -#include - using std::map; +using std::set; using std::pair; using std::string; -using std::unordered_map; -using std::unordered_set; using std::vector; +//TODO: need to create new clause!! static void parseMergeDirective(const char *comment, vector> &parsed_mapping) { @@ -16,21 +18,27 @@ static void parseMergeDirective(const char *comment, { auto *line_end = strchr(comment, '\n'); - static const char prefix[] = "!!SPF TRANSFORM(MERGE_ARRAYS("; + static const char prefix[] = "!!spf transform(merge_arrays("; static const auto compare_chars = sizeof(prefix) - 1; - if (strncasecmp(comment, prefix, compare_chars) == 0) + if (strlen(comment) >= compare_chars) { - auto *pair_start = comment + compare_chars; - auto *comma = strchr(pair_start, ','); - if (comma) + std::string comment_cmp(comment, compare_chars); + convertToLower(comment_cmp); + + if (comment_cmp == prefix) { - auto *close_br = strchr(comma + 1, ')'); - if (close_br) + auto* pair_start = comment + compare_chars; + auto* comma = strchr(pair_start, ','); + if (comma) { - parsed_mapping.emplace_back( - string(pair_start, comma - pair_start), - string(comma + 1, close_br - comma - 1)); + 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)); + } } } } @@ -78,10 +86,10 @@ static bool hasSameSizes(DIST::Array *a, DIST::Array *b) } static bool checkSimilarTemplates(vector ®ions, - const unordered_map &new_region_mapping) + const map &new_region_mapping) { // new region -> old regions - unordered_map> new_region_inverse_mapping; + map> new_region_inverse_mapping; for (const auto &p : new_region_mapping) new_region_inverse_mapping[p.second].insert(p.first); @@ -126,8 +134,8 @@ static bool checkSimilarTemplates(vector ®ions, return true; } -static bool hasSameAlignment(const std::unordered_set &align_a, - const std::unordered_set &align_b) +static bool hasSameAlignment(const std::set &align_a, + const std::set &align_b) { if (align_a.size() != 1 || align_b.size() != 1) return false; @@ -238,7 +246,7 @@ SgSymbol *insertDeclIfNeeded(const string &array_name, const string &common_block_name, DIST::Array *example_array, FuncInfo *dest, - unordered_map> &inserted_arrays) + map> &inserted_arrays) { auto *type = GetArrayType(example_array); @@ -278,7 +286,7 @@ SgSymbol *insertDeclIfNeeded(const string &array_name, static pair createNewArray(DIST::Array *example_array, const string &base_name, const map> &allFuncInfo, - unordered_map> &inserted_arrays) + map> &inserted_arrays) { auto common_block_name = base_name + "_merge_r"; auto array_name = base_name; @@ -303,12 +311,12 @@ static pair createNewArray(DIST::Array *example_array, const str } static void replaceArrayRec(SgExpression *e, - const unordered_set &arrays_to_replace, + const set &arrays_to_replace, SgSymbol **func_symbol_hint, const pair &replace_by, DIST::Array *example_array, FuncInfo *func, - unordered_map> &inserted_arrays) + map> &inserted_arrays) { if (!e) return; @@ -346,7 +354,7 @@ static void replaceArrayRec(SgExpression *e, inserted_arrays); } -static void replaceRegion(SgStatement* st, const unordered_map &new_region_mapping) +static void replaceRegion(SgStatement* st, const map &new_region_mapping) { if (!st) return; @@ -430,8 +438,8 @@ void mergeRegions(vector ®ions, const map current arrays - unordered_map> arrays_to_merge; - unordered_map> array_alignment; + map> arrays_to_merge; + map> array_alignment; for (const auto &by_file : allFuncInfo) { @@ -489,10 +497,10 @@ void mergeRegions(vector ®ions, const map new region - unordered_map new_region_mapping; + map new_region_mapping; // new array -> new region - unordered_map arrays_new_region_mapping; + map arrays_new_region_mapping; vector created_region_names; for (const auto &by_new_array : arrays_to_merge) @@ -529,7 +537,7 @@ void mergeRegions(vector ®ions, const map> inserted_arrays; + map> inserted_arrays; for (const auto &by_dest_array : arrays_to_merge) { @@ -571,7 +579,7 @@ void mergeRegions(vector ®ions, const map arrays_to_replace; + set arrays_to_replace; for (auto *array_to_merge : copy_arrays) arrays_to_replace.insert(array_to_merge->GetShortName()); diff --git a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp b/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp index 87b3e19..62b9acb 100644 --- a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp +++ b/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp @@ -4,9 +4,7 @@ #include #include #include -#include #include -#include #include #include @@ -21,12 +19,11 @@ #include "SgUtils.h" #include "expr_transform.h" #include "FunctionPurifying/function_purifying.h" +#include "uniq_name_creator.h" using std::map; using std::pair; using std::set; -using std::unordered_set; -using std::unordered_map; using std::vector; using std::stack; using std::string; @@ -34,9 +31,6 @@ using std::wstring; using std::to_string; using std::make_pair; -static const string COMMON_ARRAY_SUFFIX = "_c"; -static const string COMMON_BLOCK_SUFFIX = "_r"; - static inline int getRegionExplicitLine(SgStatement *startR) { checkNull(startR, convertFileName(__FILE__).c_str(), __LINE__); @@ -78,7 +72,7 @@ static bool isSPF_reg(SgStatement *st) return st->variant() == SPF_PARALLEL_REG_DIR || st->variant() == SPF_END_PARALLEL_REG_DIR; } -static const vector getArraySynonyms(DIST::Array *array) +const vector getArraySynonyms(DIST::Array *array) { auto arrayBlock = allUsedCommonArrays.find(array); if (arrayBlock == allUsedCommonArrays.end()) @@ -113,103 +107,6 @@ static const vector getArraySynonyms(DIST::Array *array) return arrayBlock->second->getVariables(pos); } -class UniqueNameCreator -{ - map> func_info; - unordered_set all_declarations; - bool declarations_analyzed = false; - unordered_map> generated_names; - - static void GetSymbolsRec(SgExpression* exp, unordered_set& add_to) - { - if (!exp) - return; - - if (isArrayRef(exp) && exp->symbol() && exp->symbol()->identifier()) - add_to.emplace(exp->symbol()->identifier()); - - GetSymbolsRec(exp->lhs(), add_to); - GetSymbolsRec(exp->rhs(), add_to); - } - - void FillDeclarations() - { - all_declarations.clear(); - - auto* file_before = current_file; - - for (const auto& by_file : func_info) - { - if (SgFile::switchToFile(by_file.first) != -1) - { - for (const auto* by_func : by_file.second) - { - SgStatement* st = by_func->funcPointer; - - if (st) - st = st->lexNext(); - - while (st) - { - for (int i = 0; i < 3; i++) - GetSymbolsRec(st->expr(i), all_declarations); - - st = st->lexNext(); - } - } - } - } - - SgFile::switchToFile(file_before->filename()); - declarations_analyzed = true; - } -public: - UniqueNameCreator(const map> &allFuncInfo) - { - declarations_analyzed = false; - func_info = allFuncInfo; - } - - void GetUniqueName(DIST::Array* array, string& array_name, string& common_block_name) - { - auto varsOnPos = getArraySynonyms(array); - if (!varsOnPos.size()) - printInternalError(convertFileName(__FILE__).c_str(), __LINE__); - - auto array_plain_name = varsOnPos[0]->getName(); - - auto it = generated_names.find(array); - if (it != generated_names.end()) - { - array_name.assign(it->second.first); - common_block_name.assign(it->second.second); - return; - } - - if (!declarations_analyzed) - FillDeclarations(); - - int v = 1; - auto created_array_name = array_plain_name + COMMON_ARRAY_SUFFIX; - auto created_common_name = array_plain_name + COMMON_BLOCK_SUFFIX; - - while (all_declarations.find(created_array_name) != all_declarations.end() || - all_declarations.find(created_common_name) != all_declarations.end()) - { - created_array_name = array_plain_name + "_v" + std::to_string(v) + COMMON_ARRAY_SUFFIX; - created_common_name = array_plain_name + "_v" + std::to_string(v) + COMMON_BLOCK_SUFFIX; - v++; - } - - all_declarations.insert(created_array_name); - all_declarations.insert(created_common_name); - generated_names.emplace(array, std::make_pair(created_array_name, created_common_name)); - - array_name.assign(created_array_name); - common_block_name.assign(created_common_name); - } -}; - static string getStringDeclaration(SgSymbol *symb) { string decl; diff --git a/src/ParallelizationRegions/resolve_par_reg_conflicts.h b/src/ParallelizationRegions/resolve_par_reg_conflicts.h index cfaecbe..38e3fd7 100644 --- a/src/ParallelizationRegions/resolve_par_reg_conflicts.h +++ b/src/ParallelizationRegions/resolve_par_reg_conflicts.h @@ -21,4 +21,6 @@ std::pair copyArray(const std::pair& pla const std::string& suffix, std::string& filename, std::map>>& newDeclsToInclude, - std::map>>& copied); \ No newline at end of file + std::map>>& copied); + +const std::vector getArraySynonyms(DIST::Array* array); \ No newline at end of file diff --git a/src/ParallelizationRegions/uniq_name_creator.cpp b/src/ParallelizationRegions/uniq_name_creator.cpp new file mode 100644 index 0000000..6387d6e --- /dev/null +++ b/src/ParallelizationRegions/uniq_name_creator.cpp @@ -0,0 +1,98 @@ +#include "leak_detector.h" + +#include +#include +#include + +#include "SgUtils.h" +#include "uniq_name_creator.h" +#include "resolve_par_reg_conflicts.h" + +using namespace::std; + +static const string COMMON_ARRAY_SUFFIX = "_c"; +static const string COMMON_BLOCK_SUFFIX = "_r"; + +void UniqueNameCreator::GetSymbolsRec(SgExpression* exp, set& add_to) +{ + if (!exp) + return; + + if (isArrayRef(exp) && exp->symbol() && exp->symbol()->identifier()) + add_to.emplace(exp->symbol()->identifier()); + + GetSymbolsRec(exp->lhs(), add_to); + GetSymbolsRec(exp->rhs(), add_to); +} + +void UniqueNameCreator::FillDeclarations() +{ + allDeclarations.clear(); + auto* file_before = current_file; + + for (const auto& by_file : funcInfo) + { + if (SgFile::switchToFile(by_file.first) != -1) + { + for (const auto* by_func : by_file.second) + { + SgStatement* st = by_func->funcPointer; + + if (st) + st = st->lexNext(); + + while (st) + { + for (int i = 0; i < 3; i++) + GetSymbolsRec(st->expr(i), allDeclarations); + + st = st->lexNext(); + } + } + } + else + printInternalError(convertFileName(__FILE__).c_str(), __LINE__); + } + + SgFile::switchToFile(file_before->filename()); + declarationsAnalyzed = true; +} + +void UniqueNameCreator::GetUniqueName(DIST::Array* array, string& array_name, string& common_block_name) +{ + auto varsOnPos = getArraySynonyms(array); + if (!varsOnPos.size()) + printInternalError(convertFileName(__FILE__).c_str(), __LINE__); + + auto array_plain_name = varsOnPos[0]->getName(); + + auto it = generatedNames.find(array); + if (it != generatedNames.end()) + { + array_name.assign(it->second.first); + common_block_name.assign(it->second.second); + return; + } + + if (!declarationsAnalyzed) + FillDeclarations(); + + int v = 1; + auto created_array_name = array_plain_name + COMMON_ARRAY_SUFFIX; + auto created_common_name = array_plain_name + COMMON_BLOCK_SUFFIX; + + while (allDeclarations.find(created_array_name) != allDeclarations.end() || + allDeclarations.find(created_common_name) != allDeclarations.end()) + { + created_array_name = array_plain_name + "_v" + std::to_string(v) + COMMON_ARRAY_SUFFIX; + created_common_name = array_plain_name + "_v" + std::to_string(v) + COMMON_BLOCK_SUFFIX; + v++; + } + + allDeclarations.insert(created_array_name); + allDeclarations.insert(created_common_name); + generatedNames.emplace(array, std::make_pair(created_array_name, created_common_name)); + + array_name.assign(created_array_name); + common_block_name.assign(created_common_name); +} diff --git a/src/ParallelizationRegions/uniq_name_creator.h b/src/ParallelizationRegions/uniq_name_creator.h new file mode 100644 index 0000000..d509371 --- /dev/null +++ b/src/ParallelizationRegions/uniq_name_creator.h @@ -0,0 +1,26 @@ +#pragma once + +#include +#include +#include +#include "GraphCall/graph_calls.h" + +class UniqueNameCreator +{ + std::map> funcInfo; + std::set allDeclarations; + bool declarationsAnalyzed = false; + std::map> generatedNames; + + static void GetSymbolsRec(SgExpression* exp, std::set& add_to); + void FillDeclarations(); + +public: + UniqueNameCreator(const std::map>& allFuncInfo) + { + declarationsAnalyzed = false; + funcInfo = allFuncInfo; + } + + void GetUniqueName(DIST::Array* array, std::string& array_name, std::string& common_block_name); +}; diff --git a/src/Utils/version.h b/src/Utils/version.h index c4c9c11..11f57e0 100644 --- a/src/Utils/version.h +++ b/src/Utils/version.h @@ -1,3 +1,3 @@ #pragma once -#define VERSION_SPF "2479" +#define VERSION_SPF "2480"