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

change passes

Browse Source
This commit is contained in:
Oleg Nikitin
2025-05-19 20:50:35 +03:00
parent 1973d095f5
commit 73d0b201f2
6 changed files with 116 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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*/
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)
@@ -602,7 +626,10 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
auto [header, blockSet] = GetBasicBlocksForLoop(loop, 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)
{
@@ -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);
@@ -639,14 +670,28 @@ static void SolveDataFlowIteratively(Region* DFG)
{
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;
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)
{
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);
for (const auto& [funcInfo, blocks]: FullIR)
{
//
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)

50
src/PrivateAnalyzer/private_arrays_search.h
View File

@@ -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);

5
src/Sapfor.cpp
View File

@@ -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

3
src/Sapfor.h
View File

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

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({ 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,