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

add Region constructor and SolveDataflow function

Browse Source
This commit is contained in:
Oleg Nikitin
2025-04-08 15:25:39 +03:00
parent b7ebccf045
commit 54eb1ecc95
2 changed files with 136 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
src/PrivateAnalyzer/private_arrays_search.cpp
View File

@@ -44,7 +44,7 @@ static bool isParentStmt(SgStatement* stmt, SgStatement* parent)
} }
/*returns head block and loop*/ /*returns head block and loop*/
static pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock*> blocks) pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock*> blocks)
{ {
unordered_set<SAPFOR::BasicBlock*> block_loop; unordered_set<SAPFOR::BasicBlock*> block_loop;
SAPFOR::BasicBlock* head_block = nullptr; SAPFOR::BasicBlock* head_block = nullptr;
@@ -397,7 +397,7 @@ static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimen
if(!dimDiff.empty()) if(!dimDiff.empty())
{ {
vector<ArrayDimension> firstCopy = firstElement; vector<ArrayDimension> firstCopy = firstElement;
for(const auto range: dimDiff) for(const auto& range: dimDiff)
{ {
firstCopy[i] = range; firstCopy[i] = range;
result.push_back(firstCopy); result.push_back(firstCopy);
@@ -508,27 +508,94 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const
void Collapse(Region* region) void Collapse(Region* region)
{ {
Region* newBlock = new Region(); //Region* newBlock = new Region();
for (auto& [arrayName, arrayRanges] : region->GetHeader()->array_out) 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); 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) for (auto& [arrayName, arrayRanges] : byBlock->array_use)
{ {
AccessingSet diff = byBlock->array_use[arrayName].Diff(byBlock->array_in[arrayName]); 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<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& 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<SAPFOR::BasicBlock*>& Blocks, const unordered_map<SAPFOR::BasicBlock*, Region*>& 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<SAPFOR::BasicBlock*>& Blocks)
{
auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
unordered_map<SAPFOR::BasicBlock*, Region*> 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<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)

78
src/PrivateAnalyzer/private_arrays_search.h
View File

@@ -7,6 +7,8 @@ using std::vector;
using std::map; using std::map;
using std::string; using std::string;
using std::set; using std::set;
using std::unordered_set;
using std::pair;
struct ArrayDimension struct ArrayDimension
{ {
@@ -36,49 +38,85 @@ class Region: public SAPFOR::BasicBlock {
public: public:
Region() Region()
{ {
header = nullptr; header = nullptr;
nextRegion = nullptr;
} }
Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block) Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block)
{ {
header = nullptr; header = nullptr;
nextRegion = nullptr; }
};
//Region(LoopGraph* loop); Region(LoopGraph* loop, vector<SAPFOR::BasicBlock*>& Blocks);
Region* GetHeader()
Region* getHeader()
{ {
return header; return header;
} }
set<Region*> GetBasickBlocks()
unordered_set<Region*>& getBasickBlocks()
{ {
return basickBlocks; return basickBlocks;
} }
vector<Region*> getPrevRegions()
void addBasickBlocks(Region* region)
{
basickBlocks.insert(region);
}
unordered_set<Region*> getPrevRegions()
{ {
return prevRegions; return prevRegions;
} }
Region* getNextRegion()
unordered_set<Region*> 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<Region*> getSubRegions()
{
return subRegions;
}
void addSubRegions(Region* region)
{
subRegions.insert(region);
}
ArrayAccessingIndexes array_def, array_use, array_out, array_in; ArrayAccessingIndexes array_def, array_use, array_out, array_in;
private: private:
set<Region*> subRegions, basickBlocks; unordered_set<Region*> subRegions, basickBlocks;
Region* header; /*next Region which is BB for current BB Region*/
Region* nextRegion; unordered_set<Region*> nextRegions;
vector<Region*> prevRegions; /*prev Regions which is BBs for current BB Region*/
unordered_set<Region*> prevRegions;
Region* header;
}; };
void Collapse(Region* region); void Collapse(Region* region);
void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR); void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR);
void GetDimensionInfo(LoopGraph* loop, map<DIST::Array*, vector<vector<ArrayDimension>>>& loopDimensionsInfo, int level); void GetDimensionInfo(LoopGraph* loop, map<DIST::Array*, vector<vector<ArrayDimension>>>& loopDimensionsInfo, int level);
set<SAPFOR::BasicBlock> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock>); pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock*> blocks);