made functions static

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(const LoopGraph* loop, const 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;
@@ -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; ref && i < ref->numberOfSubscripts(); ++i)
+            for (int i = 0; i < ref->numberOfSubscripts(); ++i)
             {
                 const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
                 if (coefs.size() == 1)
@@ -175,7 +175,6 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                 }
                 
             }
-            cout << coefsForDims.size() << endl;
 
             while (!index_vars.empty())
             {
@@ -548,12 +547,7 @@ static bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingInd
 
 void Collapse(Region* region)
 {
-    if (region->getBasickBlocks().empty())
+    //Region* newBlock = new Region();  
-        return;
-    else
-    {
-        cout << region->getBasickBlocks().size();
-    }
     for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out)
     {
         for (Region* byBlock : region->getBasickBlocks())
@@ -563,26 +557,13 @@ 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()) 
     {
@@ -592,11 +573,6 @@ 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)
@@ -626,10 +602,7 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
     auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
     for (SAPFOR::BasicBlock* block : Blocks)
     {
-        if (bbToRegion.find(block) != bbToRegion.end())
+        region->addBasickBlocks(bbToRegion.at(block));
-        {
-            region->addBasickBlocks(bbToRegion.at(block));
-        }
     }
     for (LoopGraph* childLoop : loop->children)
     {
@@ -638,17 +611,13 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
     return region;
 }
 
-Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
+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);
-        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);
@@ -670,28 +639,14 @@ static void SolveDataFlowIteratively(Region* DFG)
         {
             for (const auto& [arrayName, accessSet] : prevBlock->array_out)
             {
-                if (newIn.find(arrayName) != newIn.end())
+                newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
-                {
-                    newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
-                }
-                else
-                {
-                    newIn[arrayName] = accessSet;
-                }
             }
         }
         b->array_in = newIn;
         ArrayAccessingIndexes newOut;
-        for (auto& [arrayName, accessSet] : b->array_def)
+        for (auto& [arrayName, accessSet] : b->array_in)
         {
-            if (newOut.find(arrayName) != newOut.end())
+            newOut[arrayName] = b->array_in[arrayName].Union(b->array_def[arrayName]);
-            {
-                newOut[arrayName] = b->array_def[arrayName].Union(b->array_in[arrayName]);
-            }
-            else
-            {
-                newOut[arrayName] = accessSet;
-            }
         }
         /* can not differ */
         if (newOut != b->array_out) 
@@ -704,7 +659,6 @@ static void SolveDataFlowIteratively(Region* DFG)
         }
     } 
     while (!worklist.empty());
-    cout << "solveDFIt\n";
 }
 
 static void SolveDataFlow(Region* DFG)
@@ -715,40 +669,25 @@ static void SolveDataFlow(Region* DFG)
         SolveDataFlow(subRegion);
     }
     Collapse(DFG);
-    cout << "SolveDF\n";
 }
 
-map<LoopGraph*, ArrayAccessingIndexes>  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)
 {  
-    map<LoopGraph*, ArrayAccessingIndexes> result;
+    for (const auto& curr_graph_pair: loopGraph)
-    for (const auto& [loopName, loops] : loopGraph)
     {
-        for (const auto& loop : loops)
+        for (const auto& curr_loop : curr_graph_pair.second)
         {
-            for (const auto& [funcInfo, blocks]: FullIR)
+            auto block_loop = GetBasicBlocksForLoop(curr_loop, (*FullIR.begin()).second);
-            {   
+            for (const auto& bb : block_loop.second) {
-                //
+                ArrayAccessingIndexes def, use;
-                for (auto& bb : blocks)
+                //GetDefUseArray(bb, curr_loop, def, use);
-                {
-                    ArrayAccessingIndexes def, use;
-                    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);
             }
+            ArrayAccessingIndexes loopDimensionsInfo;
+            //GetDimensionInfo(curr_loop, loopDimensionsInfo, 0);
+            //print_info(curr_loop);
         }
     }
-    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,12 +1,14 @@
 #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 
 {
@@ -15,23 +17,23 @@ struct ArrayDimension
 
 class AccessingSet {
     private:
-        std::vector<std::vector<ArrayDimension>> allElements;
+        vector<vector<ArrayDimension>> allElements;
 
     public:
-        AccessingSet(std::vector<std::vector<ArrayDimension>> input) : allElements(input) {};
+        AccessingSet(vector<vector<ArrayDimension>> input) : allElements(input) {};
         AccessingSet() {};
-        std::vector<std::vector<ArrayDimension>> GetElements() const;
+        vector<vector<ArrayDimension>> GetElements() const;
-        void Insert(const std::vector<ArrayDimension>& element);
+        void Insert(const vector<ArrayDimension>& element);
         AccessingSet Union(const AccessingSet& source);
         AccessingSet Intersect(const AccessingSet& secondSet) const;
         AccessingSet Diff(const AccessingSet& secondSet) const;
-        bool ContainsElement(const std::vector<ArrayDimension>& element) const;        
+        bool ContainsElement(const vector<ArrayDimension>& element) const;        
-        void FindCoveredBy(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
+        void FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const;
-        void FindUncovered(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
+        void FindUncovered(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const;
         friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs);
 };
 
-using ArrayAccessingIndexes = std::map<std::string, AccessingSet>;
+using ArrayAccessingIndexes = map<string, AccessingSet>;
 
 class Region: public SAPFOR::BasicBlock {
     public:
@@ -45,14 +47,14 @@ class Region: public SAPFOR::BasicBlock {
             header = nullptr;
         }
 
-        Region(LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*>& Blocks);
+        Region(LoopGraph* loop, vector<SAPFOR::BasicBlock*>& Blocks);
 
         Region* getHeader()
         {
             return header;
         }
 
-        std::unordered_set<Region*>& getBasickBlocks()
+        unordered_set<Region*>& getBasickBlocks()
         {
             return basickBlocks;
         }
@@ -61,12 +63,12 @@ class Region: public SAPFOR::BasicBlock {
         {
             basickBlocks.insert(region);
         }
-        std::unordered_set<Region*> getPrevRegions()
+        unordered_set<Region*> getPrevRegions()
         {
             return prevRegions;
         }
 
-        std::unordered_set<Region*> getNextRegions()
+        unordered_set<Region*> getNextRegions()
         {
             return nextRegions;
         }
@@ -93,7 +95,7 @@ class Region: public SAPFOR::BasicBlock {
             nextRegions.insert(source);
         }
 
-        std::unordered_set<Region*> getSubRegions()
+        unordered_set<Region*> getSubRegions()
         {
             return subRegions;
         }
@@ -103,19 +105,19 @@ class Region: public SAPFOR::BasicBlock {
             subRegions.insert(region);
         }
 
-        ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv;
+        ArrayAccessingIndexes array_def, array_use, array_out, array_in;
             
     private:
-        std::unordered_set<Region*> subRegions, basickBlocks;
+        unordered_set<Region*> subRegions, basickBlocks;
         /*next Region which is BB for current BB Region*/
-        std::unordered_set<Region*> nextRegions;
+        unordered_set<Region*> nextRegions;
         /*prev Regions which is BBs for current BB Region*/
-        std::unordered_set<Region*> prevRegions;
+        unordered_set<Region*> prevRegions;
         Region* header;      
 };
 
 
 void Collapse(Region* region);
-std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
+void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR);
-void GetDimensionInfo(LoopGraph* loop, std::map<DIST::Array*, std::vector<std::vector<ArrayDimension>>>& loopDimensionsInfo, int level);
+void GetDimensionInfo(LoopGraph* loop, map<DIST::Array*, vector<vector<ArrayDimension>>>& loopDimensionsInfo, int level);
-std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);
+pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(LoopGraph* loop, vector<SAPFOR::BasicBlock*> blocks);

src/Sapfor.cpp

@@ -55,7 +55,6 @@
 #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"
@@ -1026,10 +1025,6 @@ 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,8 +183,6 @@ enum passes {
     SET_IMPLICIT_NONE,
     RENAME_INLCUDES,
 
-    FIND_PRIVATE_ARRAYS,
-
     TEST_PASS,
     EMPTY_PASS
 };
@@ -369,7 +367,6 @@ 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,8 +316,6 @@ 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,