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*/
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;
SAPFOR::BasicBlock* head_block = nullptr;
@@ -397,7 +397,7 @@ static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimen
if(!dimDiff.empty())
{
vector<ArrayDimension> 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<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)

72
src/PrivateAnalyzer/private_arrays_search.h
View File

@@ -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
{
@@ -37,48 +39,84 @@ class Region: public SAPFOR::BasicBlock {
Region()
{
header = nullptr;
nextRegion = nullptr;
}
Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block)
{
header = nullptr;
nextRegion = nullptr;
};
//Region(LoopGraph* loop);
Region* GetHeader()
}
Region(LoopGraph* loop, vector<SAPFOR::BasicBlock*>& Blocks);
Region* getHeader()
{
return header;
}
set<Region*> GetBasickBlocks()
unordered_set<Region*>& getBasickBlocks()
{
return basickBlocks;
}
vector<Region*> getPrevRegions()
void addBasickBlocks(Region* region)
{
basickBlocks.insert(region);
}
unordered_set<Region*> getPrevRegions()
{
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;
private:
set<Region*> subRegions, basickBlocks;
unordered_set<Region*> subRegions, basickBlocks;
/*next Region which is BB for current BB Region*/
unordered_set<Region*> nextRegions;
/*prev Regions which is BBs for current BB Region*/
unordered_set<Region*> prevRegions;
Region* header;
Region* nextRegion;
vector<Region*> prevRegions;
};
void Collapse(Region* region);
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);
set<SAPFOR::BasicBlock> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock>);
pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock*> blocks);