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

o.nikitin_private_arrays #58

Merged
Alexander_KS merged 12 commits from o.nikitin_private_arrays into master 2025-05-30 09:45:49 +00:00
Conversation 0 Commits 12 Files Changed 11 +116 -47
6 changed files with 116 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 73d0b201f2 - Show all commits

2
projects/dvm

Submodule projects/dvm updated: ca44a63d14...a711f8ebfd

101
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*/
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; unordered_set<SAPFOR::BasicBlock*> block_loop;
SAPFOR::BasicBlock* head_block = nullptr; SAPFOR::BasicBlock* head_block = nullptr;
@@ -165,7 +165,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
SgArrayRefExp* ref = (SgArrayRefExp*)instruction->getInstruction()->getExpression(); SgArrayRefExp* ref = (SgArrayRefExp*)instruction->getInstruction()->getExpression();
vector<pair<int, int>> coefsForDims; 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 }); const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
if (coefs.size() == 1) 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()) while (!index_vars.empty())
{ {
@@ -547,7 +548,12 @@ static bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingInd
void Collapse(Region* region) 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 (auto& [arrayName, arrayRanges] : region->getHeader()->array_out)
{ {
for (Region* byBlock : region->getBasickBlocks()) 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) 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]);
region->array_use[arrayName] = region->array_use[arrayName].Union(diff); 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()) for (Region* prevBlock : region->getHeader()->getPrevRegions())
{ {
@@ -573,6 +592,11 @@ void Collapse(Region* region)
{ {
nextBlock->replaceInPrevRegions(region, region->getHeader()); 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) static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
@@ -602,7 +626,10 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
for (SAPFOR::BasicBlock* block : Blocks) for (SAPFOR::BasicBlock* block : Blocks)
{ {
region->addBasickBlocks(bbToRegion.at(block)); if (bbToRegion.find(block) != bbToRegion.end())
{
region->addBasickBlocks(bbToRegion.at(block));
}
} }
for (LoopGraph* childLoop : loop->children) for (LoopGraph* childLoop : loop->children)
{ {
@@ -611,13 +638,17 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
return region; 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); auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
unordered_map<SAPFOR::BasicBlock*, Region*> bbToRegion; unordered_map<SAPFOR::BasicBlock*, Region*> bbToRegion;
for (auto poiner : blockSet) for (auto poiner : blockSet)
{ {
bbToRegion[poiner] = new Region(*poiner); 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]; this->header = bbToRegion[header];
SetConnections(bbToRegion, blockSet); SetConnections(bbToRegion, blockSet);
@@ -639,14 +670,28 @@ static void SolveDataFlowIteratively(Region* DFG)
{ {
for (const auto& [arrayName, accessSet] : prevBlock->array_out) for (const auto& [arrayName, accessSet] : prevBlock->array_out)
{ {
newIn[arrayName] = newIn[arrayName].Intersect(accessSet); if (newIn.find(arrayName) != newIn.end())
{
newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
}
else
{
newIn[arrayName] = accessSet;
}
} }
} }
b->array_in = newIn; b->array_in = newIn;
ArrayAccessingIndexes newOut; 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 */ /* can not differ */
if (newOut != b->array_out) if (newOut != b->array_out)
@@ -659,6 +704,7 @@ static void SolveDataFlowIteratively(Region* DFG)
} }
} }
while (!worklist.empty()); while (!worklist.empty());
cout << "solveDFIt\n";
} }
static void SolveDataFlow(Region* DFG) static void SolveDataFlow(Region* DFG)
@@ -669,25 +715,40 @@ static void SolveDataFlow(Region* DFG)
SolveDataFlow(subRegion); SolveDataFlow(subRegion);
} }
Collapse(DFG); 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)
{ {
auto block_loop = GetBasicBlocksForLoop(curr_loop, (*FullIR.begin()).second); for (const auto& [funcInfo, blocks]: FullIR)
for (const auto& bb : block_loop.second) { {
ArrayAccessingIndexes def, use; //
//GetDefUseArray(bb, curr_loop, def, use); for (auto& bb : blocks)
{
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) void GetDimensionInfo(LoopGraph* loop, map<DIST::Array*, vector<vector<ArrayDimension>>>& loopDimensionsInfo, int level)

50
src/PrivateAnalyzer/private_arrays_search.h
View File

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

5
src/Sapfor.cpp
View File

@@ -55,6 +55,7 @@
#include "VerificationCode/verifications.h" #include "VerificationCode/verifications.h"
#include "Distribution/CreateDistributionDirs.h" #include "Distribution/CreateDistributionDirs.h"
#include "PrivateAnalyzer/private_analyzer.h" #include "PrivateAnalyzer/private_analyzer.h"
#include "PrivateAnalyzer/private_arrays_search.h"
#include "ExpressionTransform/expr_transform.h" #include "ExpressionTransform/expr_transform.h"
#include "Predictor/PredictScheme.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) if(func->funcPointer->variant() != ENTRY_STAT)
countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks); countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks);
} }
else if (curr_regime == FIND_PRIVATE_ARRAYS)
{
FindPrivateArrays(loopGraph, fullIR);
}
else if (curr_regime == TEST_PASS) else if (curr_regime == TEST_PASS)
{ {
//test pass //test pass

3
src/Sapfor.h
View File

@@ -183,6 +183,8 @@ enum passes {
SET_IMPLICIT_NONE, SET_IMPLICIT_NONE,
RENAME_INLCUDES, RENAME_INLCUDES,
FIND_PRIVATE_ARRAYS,
TEST_PASS, TEST_PASS,
EMPTY_PASS EMPTY_PASS
}; };
@@ -367,6 +369,7 @@ static void setPassValues()
passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE"; passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE";
passNames[RENAME_INLCUDES] = "RENAME_INLCUDES"; passNames[RENAME_INLCUDES] = "RENAME_INLCUDES";
passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI"; 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"; passNames[TEST_PASS] = "TEST_PASS";
} }

2
src/Utils/PassManager.h
View File

@@ -316,6 +316,8 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE); 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, 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, 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, REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL,