change passes

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -44,7 +44,7 @@ static bool isParentStmt(SgStatement* stmt, SgStatement* parent)
 }
 
 /*returns head block and loop*/
-pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock*> blocks)
+pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const vector<SAPFOR::BasicBlock*> blocks)
 {
     unordered_set<SAPFOR::BasicBlock*> 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<pair<int, int>> coefsForDims;
-            for (int i = 0; i < ref->numberOfSubscripts(); ++i)
+            for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
             {
                 const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ 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<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
@@ -601,9 +625,12 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
     Region* region = new Region;
     auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
     for (SAPFOR::BasicBlock* block : Blocks)
+    {
+        if (bbToRegion.find(block) != bbToRegion.end())
         {
             region->addBasickBlocks(bbToRegion.at(block));
         }
+    }
     for (LoopGraph* childLoop : loop->children)
     {
         region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
@@ -611,13 +638,17 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
     return region;
 }
 
-Region::Region(LoopGraph* loop, vector<SAPFOR::BasicBlock*>& Blocks)
+Region::Region(LoopGraph* loop, const 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);
+        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);
@@ -638,15 +669,29 @@ static void SolveDataFlowIteratively(Region* DFG)
         for (Region* prevBlock : b->getPrevRegions())
         {
             for (const auto& [arrayName, accessSet] : prevBlock->array_out)
+            {
+                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<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
+map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
-    for (const auto& curr_graph_pair: loopGraph)
+    map<LoopGraph*, ArrayAccessingIndexes> result;
+    for (const auto& [loopName, loops] : loopGraph)
     {
-        for (const auto& curr_loop : curr_graph_pair.second)
+        for (const auto& loop : loops)
+        {
+            for (const auto& [funcInfo, blocks]: FullIR)
+            {   
+                //
+                for (auto& bb : blocks)
                 {
-            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);
-            }
-            ArrayAccessingIndexes loopDimensionsInfo;
-            //GetDimensionInfo(curr_loop, loopDimensionsInfo, 0);
-            //print_info(curr_loop);
+                    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);
+            }
+        }
+    }
+    vector<ArrayDimension> A = { {1, 1, 2}, {0, 1, 6} };
+    vector<ArrayDimension> B = { {0, 1, 6}, {2, 1, 2} };
+    vector<ArrayDimension> C = { {1, 1, 2}, {2, 1, 2} };
+    return result;
 }
 
 void GetDimensionInfo(LoopGraph* loop, map<DIST::Array*, vector<vector<ArrayDimension>>>& loopDimensionsInfo, int level)

src/PrivateAnalyzer/private_arrays_search.h

@@ -1,14 +1,12 @@
 #pragma once
 
+#include<vector>
+#include<map>
+#include<unordered_set>
+
 #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<vector<ArrayDimension>> allElements;
+        std::vector<std::vector<ArrayDimension>> allElements;
 
     public:
-        AccessingSet(vector<vector<ArrayDimension>> input) : allElements(input) {};
+        AccessingSet(std::vector<std::vector<ArrayDimension>> input) : allElements(input) {};
         AccessingSet() {};
-        vector<vector<ArrayDimension>> GetElements() const;
-        void Insert(const vector<ArrayDimension>& element);
+        std::vector<std::vector<ArrayDimension>> GetElements() const;
+        void Insert(const std::vector<ArrayDimension>& element);
         AccessingSet Union(const AccessingSet& source);
         AccessingSet Intersect(const AccessingSet& secondSet) const;
         AccessingSet Diff(const AccessingSet& secondSet) const;
-        bool ContainsElement(const vector<ArrayDimension>& element) const;        
-        void FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const;
-        void FindUncovered(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const;
+        bool ContainsElement(const std::vector<ArrayDimension>& element) const;        
+        void FindCoveredBy(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
+        void FindUncovered(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
         friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs);
 };
 
-using ArrayAccessingIndexes = map<string, AccessingSet>;
+using ArrayAccessingIndexes = std::map<std::string, AccessingSet>;
 
 class Region: public SAPFOR::BasicBlock {
     public:
@@ -47,14 +45,14 @@ class Region: public SAPFOR::BasicBlock {
             header = nullptr;
         }
 
-        Region(LoopGraph* loop, vector<SAPFOR::BasicBlock*>& Blocks);
+        Region(LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*>& Blocks);
 
         Region* getHeader()
         {
             return header;
         }
 
-        unordered_set<Region*>& getBasickBlocks()
+        std::unordered_set<Region*>& getBasickBlocks()
         {
             return basickBlocks;
         }
@@ -63,12 +61,12 @@ class Region: public SAPFOR::BasicBlock {
         {
             basickBlocks.insert(region);
         }
-        unordered_set<Region*> getPrevRegions()
+        std::unordered_set<Region*> getPrevRegions()
         {
             return prevRegions;
         }
 
-        unordered_set<Region*> getNextRegions()
+        std::unordered_set<Region*> getNextRegions()
         {
             return nextRegions;
         }
@@ -95,7 +93,7 @@ class Region: public SAPFOR::BasicBlock {
             nextRegions.insert(source);
         }
 
-        unordered_set<Region*> getSubRegions()
+        std::unordered_set<Region*> 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<Region*> subRegions, basickBlocks;
+        std::unordered_set<Region*> subRegions, basickBlocks;
         /*next Region which is BB for current BB Region*/
-        unordered_set<Region*> nextRegions;
+        std::unordered_set<Region*> nextRegions;
         /*prev Regions which is BBs for current BB Region*/
-        unordered_set<Region*> prevRegions;
+        std::unordered_set<Region*> prevRegions;
         Region* header;      
 };
 
 
 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);
-pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock*> blocks);
+std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
+void GetDimensionInfo(LoopGraph* loop, std::map<DIST::Array*, std::vector<std::vector<ArrayDimension>>>& loopDimensionsInfo, int level);
+std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);

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

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";
 }

src/Utils/PassManager.h

@@ -316,6 +316,8 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     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,