Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Alexander_KS:par_reg_merging
Branches Tags
Alexander_KS:master Alexander_KS:egormayorov Alexander_KS:libpredict_integration Alexander_KS:par_reg_merging Alexander_KS:replace_io_arrays Alexander_KS:private_arrays2 Alexander_KS:private_arrays Alexander_KS:analyze_loops_with_IR
..
compare: Alexander_KS:private_arrays2
Branches Tags
Alexander_KS:egormayorov Alexander_KS:libpredict_integration Alexander_KS:par_reg_merging Alexander_KS:replace_io_arrays Alexander_KS:private_arrays2 Alexander_KS:private_arrays Alexander_KS:master Alexander_KS:analyze_loops_with_IR

1 Commits
par_reg_me ... private_ar

Author SHA1 Message Date
Oleg Nikitin
fc98972bc2 fix algorythm 2026-02-21 02:34:57 +03:00
10 changed files with 365 additions and 726 deletions
Expand all files Collapse all files

4
CMakeLists.txt
View File

@@ -166,8 +166,6 @@ 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)
@@ -428,7 +426,6 @@ set(SOURCE_EXE
${LOOP_ANALYZER}
${TRANSFORMS}
${PARALLEL_REG}
${MERGE_COPY_ARRAYS}
${PRIV}
${ARRAY_PROP}
${FDVM}
@@ -482,7 +479,6 @@ 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})

616
src/ParallelizationRegions/parse_merge_dirs.cpp
View File

@@ -1,616 +0,0 @@
#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();
}
}
}
}
}

8
src/ParallelizationRegions/parse_merge_dirs.h
View File

@@ -1,8 +0,0 @@
#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);

255
src/PrivateAnalyzer/private_arrays_search.cpp
View File

@@ -1,3 +1,4 @@
#include <algorithm>
#include <map>
#include <unordered_set>
#include <unordered_map>
@@ -16,6 +17,8 @@
using namespace std;
static unordered_set<Region*> collapsed;
static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
{
ArrayAccessingIndexes resultContainer;
@@ -49,41 +52,81 @@ static void Collapse(Region* region)
if (region->getBasickBlocks().empty())
return;
for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out)
bool firstRegion = true;
for (Region* basickBlock : region->getBasickBlocks())
{
for (Region* byBlock : region->getBasickBlocks())
if (basickBlock->getNextRegions().empty())
{
AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges);
region->array_def[arrayName] = region->array_def[arrayName].Union(intersection);
if (firstRegion)
{
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);
}
}
}
for (auto& byBlock : region->getBasickBlocks())
{
for (auto& [arrayName, arrayRanges] : byBlock->array_use)
{
AccessingSet diff = byBlock->array_use[arrayName].Diff(byBlock->array_in[arrayName]);
region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
}
}
RegionInstruction instruction;
instruction.def = move(region->array_def);
ArrayAccessingIndexes useUnion;
for (auto& byBlock : region->getBasickBlocks())
for (auto& [arrayName, arrayRanges] : byBlock->array_use)
useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
{
for (auto& instruction : byBlock->instructions)
{
for (auto& [arrayName, _] : instruction.use)
{
AccessingSet diff = instruction.use[arrayName].Diff(instruction.in[arrayName]);
region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
}
}
}
region->array_priv = region->array_use;
for (Region* prevBlock : region->getHeader()->getPrevRegions())
ArrayAccessingIndexes useUnionB;
for (auto& byBlock : region->getBasickBlocks())
for (auto& instruction : byBlock->instructions)
for (auto& [arrayName, _] : instruction.use)
useUnionB[arrayName] = useUnionB[arrayName].Union(instruction.use[arrayName]);
for (auto& [arrayName, _] : useUnionB)
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)
static void SolveDataFlowIteratively(Region* DFG)
{
unordered_set<Region*> worklist(DFG->getBasickBlocks());
auto blocks = DFG->getBasickBlocks();
std::unordered_set<Region*> worklist(blocks.begin(), blocks.end());
do
{
Region* b = *worklist.begin();
@@ -101,13 +144,13 @@ static void SolveDataFlowIteratively(Region* DFG)
if (prevBlock->array_out.empty())
{
newIn.clear();
continue;
break;
}
for (const auto& [arrayName, accessSet] : prevBlock->array_out)
{
if (newIn.find(arrayName) != newIn.end())
newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
else
newIn[arrayName] = AccessingSet();
}
@@ -117,7 +160,7 @@ static void SolveDataFlowIteratively(Region* DFG)
b->array_in = move(newIn);
ArrayAccessingIndexes newOut;
if (b->array_def.empty())
if (b->array_def.empty())
newOut = b->array_in;
else if (b->array_in.empty())
newOut = b->array_def;
@@ -133,25 +176,157 @@ static void SolveDataFlowIteratively(Region* DFG)
}
/* can not differ */
if (newOut != b->array_out)
if (newOut != b->array_out)
b->array_out = newOut;
else
worklist.erase(b);
}
while (!worklist.empty());
} 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);
}
}
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);
@@ -161,6 +336,8 @@ 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())
@@ -187,16 +364,16 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
}
toAdd->setLhs(new SgVarRefExp(elem));
}
if (arraysToInsert.size() == 0)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
insertedPrivates.insert(spfStat);
if (arraysToInsert.size() != 0)
{
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)
{
@@ -210,8 +387,8 @@ 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)
{
Region* loopRegion = new Region(loop, blocks);
@@ -231,4 +408,4 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*
AddPrivateArraysToLoop(loop, result[loop], insertedPrivates);
}
}
}
}

42
src/PrivateAnalyzer/range_structures.cpp
View File

@@ -29,7 +29,7 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
vector<uint64_t> partSolution = FindParticularSolution(dim1, dim2);
if (partSolution.empty())
return NULL;
int64_t x0 = partSolution[0], y0 = partSolution[1];
/* x = x_0 + c * t */
/* y = y_0 + d * t */
@@ -44,10 +44,10 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
uint64_t tMax = min(tXMax, tYMax);
if (tMin > tMax)
return NULL;
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;
}
@@ -57,12 +57,12 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
ArrayDimension* intersection = DimensionIntersection(dim1, dim2);
if (!intersection)
return { dim1 };
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});
if (dim1.start < intersection->start)
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;
}
}
@@ -109,7 +109,7 @@ static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>&
{
if (firstElement.empty() || secondElement.empty())
return {};
size_t dimAmount = firstElement.size();
/* check if there is no intersecction */
for (size_t i = 0; i < dimAmount; i++)
@@ -132,14 +132,16 @@ static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>&
static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimension>& firstElement,
const vector<ArrayDimension>& secondElement)
{
if (firstElement.empty() || secondElement.empty())
if (firstElement.empty())
return {};
if (secondElement.empty())
return { firstElement };
vector<ArrayDimension> intersection = ElementsIntersection(firstElement, secondElement);
vector<vector<ArrayDimension>> result;
if (intersection.empty())
return { firstElement };
for (int i = 0; i < firstElement.size(); i++)
{
auto dimDiff = DimensionDifference(firstElement[i], secondElement[i]);
@@ -188,7 +190,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
@@ -252,13 +254,15 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const
return *this;
AccessingSet intersection = this->Intersect(secondSet);
AccessingSet uncovered = *this;
vector<vector<ArrayDimension>> result;
for (const auto& element : intersection.GetElements())
vector<vector<ArrayDimension>> uncovered;
for (const auto& element : allElements)
{
vector<vector<ArrayDimension>> current_uncovered;
uncovered.FindUncovered(element, current_uncovered);
uncovered = AccessingSet(current_uncovered);
intersection.FindUncovered(element, current_uncovered);
uncovered.insert(uncovered.end(),
std::move_iterator(current_uncovered.begin()),
std::move_iterator(current_uncovered.end())
);
}
return uncovered;
}
@@ -289,4 +293,4 @@ bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& r
return true;
return false;
}
}

126
src/PrivateAnalyzer/region.cpp
View File

@@ -1,14 +1,16 @@
#include<vector>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<string>
#include <algorithm>
#include <vector>
#include <map>
#include <unordered_set>
#include <unordered_map>
#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;
@@ -62,14 +64,14 @@ static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loo
static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, LoopGraph*>& loopForIndex) {
unordered_set<SAPFOR::Argument*> args = { block->getInstructions()[pos]->getInstruction()->getArg1() };
for (int i = pos - 1; i >= 0; i--)
for (int i = pos - 1; i >= 0; i--)
{
SAPFOR::Argument* res = block->getInstructions()[i]->getInstruction()->getResult();
if (res && args.find(res) != args.end())
if (res && args.find(res) != args.end())
{
SAPFOR::Argument* arg1 = block->getInstructions()[i]->getInstruction()->getArg1();
SAPFOR::Argument* arg2 = block->getInstructions()[i]->getInstruction()->getArg2();
if (arg1)
if (arg1)
{
string name = arg1->getValue();
int idx = name.find('%');
@@ -93,7 +95,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) {
static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use, Region* region) {
auto instructions = block->getInstructions();
map<string, LoopGraph*> loopForIndex;
BuildLoopIndex(loopForIndex, loop);
@@ -123,7 +125,11 @@ 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 });
}
}
}
}
@@ -131,7 +137,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
{
vector<SAPFOR::Argument*> index_vars;
vector<int> refPos;
string array_name = instruction->getInstruction()->getArg1()->getValue();
string array_name = instruction->getInstruction()->getArg1()->getValue();
int j = i - 1;
while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
@@ -148,39 +154,53 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
int fillCount = 0;
while (!index_vars.empty() && !refPos.empty())
vector<pair<int, int>> coeffsForDims;
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();
int pos = full_name.find('%');
LoopGraph* currentLoop;
if (pos != -1)
if (pos != -1)
{
name = full_name.substr(pos + 1);
if (loopForIndex.find(name) != loopForIndex.end())
currentLoop = loopForIndex[name];
currentLoop = loopForIndex[name];
else
return -1;
}
else
else
{
name = FindIndexName(currentVarPos, block, loopForIndex);
if (name == "")
return -1;
if (loopForIndex.find(name) != loopForIndex.end())
currentLoop = loopForIndex[name];
currentLoop = loopForIndex[name];
else
return -1;
}
uint64_t start = currentLoop->startVal;
uint64_t start = coeffsForDims.back().second * currentLoop->startVal + coeffsForDims.back().first;
uint64_t step = currentLoop->stepVal;
uint64_t iters = currentLoop->calculatedCountOfIters;
current_dim = { start, step, iters, ref };
@@ -193,14 +213,29 @@ 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);
}
}
}
@@ -208,6 +243,41 @@ 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)
@@ -215,25 +285,26 @@ static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegi
for (SAPFOR::BasicBlock* nextBlock : block->getNext())
if (bbToRegion.find(nextBlock) != bbToRegion.end())
bbToRegion[block]->addNextRegion(bbToRegion[nextBlock]);
for (SAPFOR::BasicBlock* prevBlock : block->getPrev())
if (bbToRegion.find(prevBlock) != bbToRegion.end())
bbToRegion[block]->addPrevRegion(bbToRegion[prevBlock]);
}
}
static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, const unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, 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));
region->setHeader(bbToRegion.at(header));
else
{
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
return NULL;
}
for (SAPFOR::BasicBlock* block : blockSet)
if (bbToRegion.find(block) != bbToRegion.end())
region->addBasickBlocks(bbToRegion.at(block));
@@ -244,6 +315,7 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
continue;
region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
}
TopologySort(region->getBasickBlocks(), region->getHeader());
return region;
}
@@ -254,12 +326,13 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
for (auto poiner : blockSet)
{
bbToRegion[poiner] = new Region(*poiner);
this->basickBlocks.insert(bbToRegion[poiner]);
GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use);
this->basickBlocks.push_back(bbToRegion[poiner]);
GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use, bbToRegion[poiner]);
}
this->header = bbToRegion[header];
SetConnections(bbToRegion, blockSet);
RemoveHeaderConnection(header, blockSet, bbToRegion);
//create subRegions
for (LoopGraph* childLoop : loop->children)
{
@@ -267,4 +340,5 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
continue;
subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
}
}
TopologySort(basickBlocks, this->header);
}

30
src/PrivateAnalyzer/region.h
View File

@@ -8,6 +8,11 @@
#include "graph_loops.h"
#include "CFGraph/CFGraph.h"
struct RegionInstruction
{
ArrayAccessingIndexes def, use, in, out;
};
class Region : public SAPFOR::BasicBlock {
public:
Region() { header = nullptr; }
@@ -20,13 +25,25 @@ public:
void setHeader(Region* region) { header = region; }
std::unordered_set<Region*>& getBasickBlocks() { return basickBlocks; }
std::vector<Region*>& getBasickBlocks() { return basickBlocks; }
void addBasickBlocks(Region* region) { basickBlocks.insert(region); }
void addBasickBlocks(Region* region) { basickBlocks.push_back(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); }
@@ -48,13 +65,18 @@ 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::unordered_set<Region*> subRegions, basickBlocks;
std::vector<Region*> 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);

6
src/Sapfor.cpp
View File

@@ -23,7 +23,6 @@
#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"
@@ -1923,10 +1922,6 @@ 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);
@@ -2384,7 +2379,6 @@ 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:

3
src/Sapfor.h
View File

@@ -88,8 +88,6 @@ enum passes {
REMOVE_DVM_INTERVALS,
VERIFY_DVM_DIRS,
MERGE_COPY_ARRAYS,
REMOVE_DIST_ARRAYS_FROM_IO,
SUBST_EXPR,
@@ -275,7 +273,6 @@ 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";

1
src/Utils/PassManager.h
View File

@@ -322,7 +322,6 @@ 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,