From 73d0b201f2d1060820c66da64c5151c722ed8e14 Mon Sep 17 00:00:00 2001 From: Oleg Nikitin Date: Mon, 19 May 2025 20:50:35 +0300 Subject: [PATCH] change passes --- projects/dvm | 2 +- src/PrivateAnalyzer/private_arrays_search.cpp | 101 ++++++++++++++---- src/PrivateAnalyzer/private_arrays_search.h | 50 +++++---- src/Sapfor.cpp | 5 + src/Sapfor.h | 3 + src/Utils/PassManager.h | 2 + 6 files changed, 116 insertions(+), 47 deletions(-) diff --git a/projects/dvm b/projects/dvm index ca44a63..a711f8e 160000 --- a/projects/dvm +++ b/projects/dvm @@ -1 +1 @@ -Subproject commit ca44a63d14c456d4deeea8b9a89125cb942f4550 +Subproject commit a711f8ebfd023ca90a6d9c9bdf5a4726cd276d51 diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index 97c29cc..4461d94 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -44,7 +44,7 @@ static bool isParentStmt(SgStatement* stmt, SgStatement* parent) } /*returns head block and loop*/ -pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks) +pair> GetBasicBlocksForLoop(const LoopGraph* loop, const vector blocks) { unordered_set block_loop; SAPFOR::BasicBlock* head_block = nullptr; @@ -165,7 +165,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces SgArrayRefExp* ref = (SgArrayRefExp*)instruction->getInstruction()->getExpression(); vector> coefsForDims; - for (int i = 0; i < ref->numberOfSubscripts(); ++i) + for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i) { const vector& coefs = getAttributes(ref->subscript(i), set{ INT_VAL }); if (coefs.size() == 1) @@ -175,6 +175,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces } } + cout << coefsForDims.size() << endl; while (!index_vars.empty()) { @@ -547,7 +548,12 @@ static bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingInd void Collapse(Region* region) { - //Region* newBlock = new Region(); + if (region->getBasickBlocks().empty()) + return; + else + { + cout << region->getBasickBlocks().size(); + } for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out) { for (Region* byBlock : region->getBasickBlocks()) @@ -557,13 +563,26 @@ void Collapse(Region* region) } } - for (auto& byBlock : region->getBasickBlocks()) { + 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); } } + 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& [arrayName, arrayRanges] : useUnion) + { + region->array_priv[arrayName] = useUnion[arrayName].Diff(region->array_use[arrayName]); + } for (Region* prevBlock : region->getHeader()->getPrevRegions()) { @@ -573,6 +592,11 @@ void Collapse(Region* region) { nextBlock->replaceInPrevRegions(region, region->getHeader()); } + for (Region* bb : region->getBasickBlocks()) + { + delete(bb); + } + cout << "Collapse\n"; } static void SetConnections(unordered_map& bbToRegion, const unordered_set& blockSet) @@ -602,7 +626,10 @@ static Region* CreateSubRegion(LoopGraph* loop, const vectoraddBasickBlocks(bbToRegion.at(block)); + if (bbToRegion.find(block) != bbToRegion.end()) + { + region->addBasickBlocks(bbToRegion.at(block)); + } } for (LoopGraph* childLoop : loop->children) { @@ -611,13 +638,17 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector& Blocks) +Region::Region(LoopGraph* loop, const vector& Blocks) { auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); unordered_map bbToRegion; for (auto poiner : blockSet) { bbToRegion[poiner] = new Region(*poiner); + this->basickBlocks.insert(bbToRegion[poiner]); + ArrayAccessingIndexes def, use; + GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use); + } this->header = bbToRegion[header]; SetConnections(bbToRegion, blockSet); @@ -639,14 +670,28 @@ static void SolveDataFlowIteratively(Region* DFG) { for (const auto& [arrayName, accessSet] : prevBlock->array_out) { - newIn[arrayName] = newIn[arrayName].Intersect(accessSet); + if (newIn.find(arrayName) != newIn.end()) + { + newIn[arrayName] = newIn[arrayName].Intersect(accessSet); + } + else + { + newIn[arrayName] = accessSet; + } } } b->array_in = newIn; ArrayAccessingIndexes newOut; - for (auto& [arrayName, accessSet] : b->array_in) + for (auto& [arrayName, accessSet] : b->array_def) { - newOut[arrayName] = b->array_in[arrayName].Union(b->array_def[arrayName]); + if (newOut.find(arrayName) != newOut.end()) + { + newOut[arrayName] = b->array_def[arrayName].Union(b->array_in[arrayName]); + } + else + { + newOut[arrayName] = accessSet; + } } /* can not differ */ if (newOut != b->array_out) @@ -659,6 +704,7 @@ static void SolveDataFlowIteratively(Region* DFG) } } while (!worklist.empty()); + cout << "solveDFIt\n"; } static void SolveDataFlow(Region* DFG) @@ -669,25 +715,40 @@ static void SolveDataFlow(Region* DFG) SolveDataFlow(subRegion); } Collapse(DFG); + cout << "SolveDF\n"; } -void FindPrivateArrays(map> &loopGraph, map>& FullIR) +map FindPrivateArrays(map> &loopGraph, map>& FullIR) { - for (const auto& curr_graph_pair: loopGraph) + map result; + for (const auto& [loopName, loops] : loopGraph) { - for (const auto& curr_loop : curr_graph_pair.second) + for (const auto& loop : loops) { - auto block_loop = GetBasicBlocksForLoop(curr_loop, (*FullIR.begin()).second); - for (const auto& bb : block_loop.second) { - ArrayAccessingIndexes def, use; - //GetDefUseArray(bb, curr_loop, def, use); + for (const auto& [funcInfo, blocks]: FullIR) + { + // + for (auto& bb : blocks) + { + ArrayAccessingIndexes def, use; + if (bb->getNumber() == 4) + { + GetDefUseArray(bb, loop, def, use); + return {}; + } + } + // + Region* loopRegion = new Region(loop, blocks); + SolveDataFlow(loopRegion); + result[loop] = loopRegion->array_priv; + delete(loopRegion); } - ArrayAccessingIndexes loopDimensionsInfo; - //GetDimensionInfo(curr_loop, loopDimensionsInfo, 0); - //print_info(curr_loop); } } - + vector A = { {1, 1, 2}, {0, 1, 6} }; + vector B = { {0, 1, 6}, {2, 1, 2} }; + vector C = { {1, 1, 2}, {2, 1, 2} }; + return result; } void GetDimensionInfo(LoopGraph* loop, map>>& loopDimensionsInfo, int level) diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index 983f3dc..cc26f78 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -1,14 +1,12 @@ #pragma once +#include +#include +#include + #include "../GraphLoop/graph_loops.h" #include "../CFGraph/CFGraph.h" -using std::vector; -using std::map; -using std::string; -using std::set; -using std::unordered_set; -using std::pair; struct ArrayDimension { @@ -17,23 +15,23 @@ struct ArrayDimension class AccessingSet { private: - vector> allElements; + std::vector> allElements; public: - AccessingSet(vector> input) : allElements(input) {}; + AccessingSet(std::vector> input) : allElements(input) {}; AccessingSet() {}; - vector> GetElements() const; - void Insert(const vector& element); + std::vector> GetElements() const; + void Insert(const std::vector& element); AccessingSet Union(const AccessingSet& source); AccessingSet Intersect(const AccessingSet& secondSet) const; AccessingSet Diff(const AccessingSet& secondSet) const; - bool ContainsElement(const vector& element) const; - void FindCoveredBy(const vector& element, vector>& result) const; - void FindUncovered(const vector& element, vector>& result) const; + bool ContainsElement(const std::vector& element) const; + void FindCoveredBy(const std::vector& element, std::vector>& result) const; + void FindUncovered(const std::vector& element, std::vector>& result) const; friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs); }; -using ArrayAccessingIndexes = map; +using ArrayAccessingIndexes = std::map; class Region: public SAPFOR::BasicBlock { public: @@ -47,14 +45,14 @@ class Region: public SAPFOR::BasicBlock { header = nullptr; } - Region(LoopGraph* loop, vector& Blocks); + Region(LoopGraph* loop, const std::vector& Blocks); Region* getHeader() { return header; } - unordered_set& getBasickBlocks() + std::unordered_set& getBasickBlocks() { return basickBlocks; } @@ -63,12 +61,12 @@ class Region: public SAPFOR::BasicBlock { { basickBlocks.insert(region); } - unordered_set getPrevRegions() + std::unordered_set getPrevRegions() { return prevRegions; } - unordered_set getNextRegions() + std::unordered_set getNextRegions() { return nextRegions; } @@ -95,7 +93,7 @@ class Region: public SAPFOR::BasicBlock { nextRegions.insert(source); } - unordered_set getSubRegions() + std::unordered_set getSubRegions() { return subRegions; } @@ -105,19 +103,19 @@ class Region: public SAPFOR::BasicBlock { subRegions.insert(region); } - ArrayAccessingIndexes array_def, array_use, array_out, array_in; + ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv; private: - unordered_set subRegions, basickBlocks; + std::unordered_set subRegions, basickBlocks; /*next Region which is BB for current BB Region*/ - unordered_set nextRegions; + std::unordered_set nextRegions; /*prev Regions which is BBs for current BB Region*/ - unordered_set prevRegions; + std::unordered_set prevRegions; Region* header; }; void Collapse(Region* region); -void FindPrivateArrays(map>& loopGraph, map>& FullIR); -void GetDimensionInfo(LoopGraph* loop, map>>& loopDimensionsInfo, int level); -pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks); +std::map FindPrivateArrays(std::map>& loopGraph, std::map>& FullIR); +void GetDimensionInfo(LoopGraph* loop, std::map>>& loopDimensionsInfo, int level); +std::pair> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector blocks); diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index b7e80b8..c106f6a 100644 --- a/src/Sapfor.cpp +++ b/src/Sapfor.cpp @@ -55,6 +55,7 @@ #include "VerificationCode/verifications.h" #include "Distribution/CreateDistributionDirs.h" #include "PrivateAnalyzer/private_analyzer.h" +#include "PrivateAnalyzer/private_arrays_search.h" #include "ExpressionTransform/expr_transform.h" #include "Predictor/PredictScheme.h" @@ -1025,6 +1026,10 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne if(func->funcPointer->variant() != ENTRY_STAT) countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks); } + else if (curr_regime == FIND_PRIVATE_ARRAYS) + { + FindPrivateArrays(loopGraph, fullIR); + } else if (curr_regime == TEST_PASS) { //test pass diff --git a/src/Sapfor.h b/src/Sapfor.h index b7f01d1..2ed5a83 100644 --- a/src/Sapfor.h +++ b/src/Sapfor.h @@ -183,6 +183,8 @@ enum passes { SET_IMPLICIT_NONE, RENAME_INLCUDES, + FIND_PRIVATE_ARRAYS, + TEST_PASS, EMPTY_PASS }; @@ -367,6 +369,7 @@ static void setPassValues() passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE"; passNames[RENAME_INLCUDES] = "RENAME_INLCUDES"; passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI"; + passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS"; passNames[TEST_PASS] = "TEST_PASS"; } diff --git a/src/Utils/PassManager.h b/src/Utils/PassManager.h index 78f4170..dad0a52 100644 --- a/src/Utils/PassManager.h +++ b/src/Utils/PassManager.h @@ -316,6 +316,8 @@ void InitPassesDependencies(map> &passDepsIn, set list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE); + list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH }) <= Pass(FIND_PRIVATE_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,