From 54eb1ecc9535faa0bb68436bb7078d18a4adc56e Mon Sep 17 00:00:00 2001 From: Oleg Nikitin Date: Tue, 8 Apr 2025 15:25:39 +0300 Subject: [PATCH] add Region constructor and SolveDataflow function --- src/PrivateAnalyzer/private_arrays_search.cpp | 89 ++++++++++++++++--- src/PrivateAnalyzer/private_arrays_search.h | 78 +++++++++++----- 2 files changed, 136 insertions(+), 31 deletions(-) diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index 084cbcc..17bd679 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*/ -static pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks) +pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks) { unordered_set block_loop; SAPFOR::BasicBlock* head_block = nullptr; @@ -397,7 +397,7 @@ static vector> ElementsDifference(const vector firstCopy = firstElement; - for(const auto range: dimDiff) + for(const auto& range: dimDiff) { firstCopy[i] = range; result.push_back(firstCopy); @@ -508,27 +508,94 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const void Collapse(Region* region) { - Region* newBlock = new Region(); - for (auto& [arrayName, arrayRanges] : region->GetHeader()->array_out) + //Region* newBlock = new Region(); + for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out) { - for (Region* byBlock : region->GetBasickBlocks()) + for (Region* byBlock : region->getBasickBlocks()) { AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges); - newBlock->array_def[arrayName].Union(intersection); + region->array_def[arrayName].Union(intersection); } } - 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]); - newBlock->array_use[arrayName].Union(diff); + region->array_use[arrayName].Union(diff); } } - for (Region* prevRegion : region->getPrevRegions()) { - prevRegion->setNextRegion(newBlock); + + for (Region* prevBlock : region->getHeader()->getPrevRegions()) + { + prevBlock->replaceInNextRegions(region, region->getHeader()); } - region->getNextRegion()->setPrevRegion(newBlock); + for (Region* nextBlock : region->getHeader()->getNextRegions()) + { + nextBlock->replaceInPrevRegions(region, region->getHeader()); + } +} + +static void SetConnections(unordered_map& bbToRegion, const unordered_set& blockSet) +{ + for (SAPFOR::BasicBlock* block : blockSet) + { + 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& Blocks, const unordered_map& bbToRegion) +{ + Region* region = new Region; + auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); + for (SAPFOR::BasicBlock* block : Blocks) + { + region->addBasickBlocks(bbToRegion.at(block)); + } + for (LoopGraph* childLoop : loop->children) + { + region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion)); + } + return region; +} + +Region::Region(LoopGraph* loop, vector& Blocks) +{ + auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); + unordered_map bbToRegion; + for (auto poiner : blockSet) + { + bbToRegion[poiner] = new Region(*poiner); + } + SetConnections(bbToRegion, blockSet); + //create subRegions + for (LoopGraph* childLoop : loop->children) + { + subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion)); + } +} + +void SolveDataFlow(Region* DFG) +{ + //SolveDataFlowIteratively(DFG) + for (Region* subRegion : DFG->getSubRegions()) + { + SolveDataFlow(subRegion); + } + Collapse(DFG); } void FindPrivateArrays(map> &loopGraph, map>& FullIR) diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index d146d52..9a5aa49 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -7,6 +7,8 @@ using std::vector; using std::map; using std::string; using std::set; +using std::unordered_set; +using std::pair; struct ArrayDimension { @@ -36,49 +38,85 @@ class Region: public SAPFOR::BasicBlock { public: Region() { - header = nullptr; - nextRegion = nullptr; + header = nullptr; } + Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block) { header = nullptr; - nextRegion = nullptr; - }; - //Region(LoopGraph* loop); - Region* GetHeader() + } + + Region(LoopGraph* loop, vector& Blocks); + + Region* getHeader() { return header; } - set GetBasickBlocks() + + unordered_set& getBasickBlocks() { return basickBlocks; } - vector getPrevRegions() + + void addBasickBlocks(Region* region) + { + basickBlocks.insert(region); + } + unordered_set getPrevRegions() { return prevRegions; } - Region* getNextRegion() + + unordered_set getNextRegions() { - return nextRegion; + return nextRegions; } - void setPrevRegion(Region* region) + + void addPrevRegion(Region* region) { - prevRegions.push_back(region); + prevRegions.insert(region); } - void setNextRegion(Region* region) + + void addNextRegion(Region* region) { - nextRegion = region; + nextRegions.insert(region); } + + void replaceInPrevRegions(Region* source, Region* destination) + { + prevRegions.erase(destination); + prevRegions.insert(source); + } + + void replaceInNextRegions(Region* source, Region* destination) + { + nextRegions.erase(destination); + nextRegions.insert(source); + } + + unordered_set getSubRegions() + { + return subRegions; + } + + void addSubRegions(Region* region) + { + subRegions.insert(region); + } + ArrayAccessingIndexes array_def, array_use, array_out, array_in; - + private: - set subRegions, basickBlocks; - Region* header; - Region* nextRegion; - vector prevRegions; + unordered_set subRegions, basickBlocks; + /*next Region which is BB for current BB Region*/ + unordered_set nextRegions; + /*prev Regions which is BBs for current BB Region*/ + unordered_set prevRegions; + Region* header; }; + void Collapse(Region* region); void FindPrivateArrays(map>& loopGraph, map>& FullIR); void GetDimensionInfo(LoopGraph* loop, map>>& loopDimensionsInfo, int level); -set GetBasicBlocksForLoop(LoopGraph* loop, vector); +pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks);