add Region constructor and SolveDataflow function

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -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();  
+    //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);
-            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)

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 
 {
@@ -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(LoopGraph* loop, vector<SAPFOR::BasicBlock*>& Blocks);
-        Region* GetHeader()
+
+        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);