Compare commits
1 Commits
master
...
fae76c98cb
| Author | SHA1 | Date | |
|---|---|---|---|
| fae76c98cb |
@@ -108,7 +108,9 @@ set(OMEGA src/SageAnalysisTool/OmegaForSage/add-assert.cpp
|
|||||||
src/SageAnalysisTool/set.cpp)
|
src/SageAnalysisTool/set.cpp)
|
||||||
|
|
||||||
set(PRIV src/PrivateAnalyzer/private_analyzer.cpp
|
set(PRIV src/PrivateAnalyzer/private_analyzer.cpp
|
||||||
src/PrivateAnalyzer/private_analyzer.h)
|
src/PrivateAnalyzer/private_analyzer.h
|
||||||
|
src/PrivateAnalyzer/private_arrays_search.cpp
|
||||||
|
src/PrivateAnalyzer/private_arrays_search.h)
|
||||||
|
|
||||||
set(FDVM ${fdvm_sources}/acc.cpp
|
set(FDVM ${fdvm_sources}/acc.cpp
|
||||||
${fdvm_sources}/acc_across.cpp
|
${fdvm_sources}/acc_across.cpp
|
||||||
|
|||||||
590
src/PrivateAnalyzer/private_arrays_search.cpp
Normal file
590
src/PrivateAnalyzer/private_arrays_search.cpp
Normal file
@@ -0,0 +1,590 @@
|
|||||||
|
#include <map>
|
||||||
|
#include <unordered_set>
|
||||||
|
#include <unordered_map>
|
||||||
|
#include <vector>
|
||||||
|
#include <queue>
|
||||||
|
#include <numeric>
|
||||||
|
#include <iostream>
|
||||||
|
|
||||||
|
#include "private_arrays_search.h"
|
||||||
|
#include "../Utils/SgUtils.h"
|
||||||
|
#include "../GraphLoop/graph_loops.h"
|
||||||
|
#include "../CFGraph/CFGraph.h"
|
||||||
|
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
|
void print_info(LoopGraph* loop)
|
||||||
|
{
|
||||||
|
cout << "loopSymbol: " << loop->loopSymbol << endl;
|
||||||
|
for (const auto& ops : loop->writeOpsForLoop)
|
||||||
|
{
|
||||||
|
cout << "Array name: " << ops.first->GetShortName() << endl;
|
||||||
|
for (const auto i : ops.second)
|
||||||
|
{
|
||||||
|
i.printInfo();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (!loop->children.empty())
|
||||||
|
{
|
||||||
|
for (const auto child : loop->children)
|
||||||
|
{
|
||||||
|
print_info(child);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool isParentStmt(SgStatement* stmt, SgStatement* parent)
|
||||||
|
{
|
||||||
|
for (; stmt; stmt = stmt->controlParent())
|
||||||
|
if (stmt == parent)
|
||||||
|
{
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*returns head block and loop*/
|
||||||
|
static 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;
|
||||||
|
auto loop_operator = loop->loop->GetOriginal();
|
||||||
|
for (const auto& block : blocks)
|
||||||
|
{
|
||||||
|
if (!block || (block->getInstructions().size() == 0))
|
||||||
|
{
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
SgStatement* first = block->getInstructions().front()->getInstruction()->getOperator();
|
||||||
|
SgStatement* last = block->getInstructions().back()->getInstruction()->getOperator();
|
||||||
|
if (isParentStmt(first, loop_operator) && isParentStmt(last, loop_operator))
|
||||||
|
{
|
||||||
|
block_loop.insert(block);
|
||||||
|
|
||||||
|
if ((!head_block) && (first == loop_operator) && (last == loop_operator) &&
|
||||||
|
(block->getInstructions().size() == 2) &&
|
||||||
|
(block->getInstructions().back()->getInstruction()->getOperation() == SAPFOR::CFG_OP::JUMP_IF))
|
||||||
|
{
|
||||||
|
head_block = block;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return { head_block, block_loop };
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
|
||||||
|
string index = loop->loopSymbol;
|
||||||
|
loopForIndex[index] = loop;
|
||||||
|
for (const auto& childLoop : loop->children) {
|
||||||
|
BuildLoopIndex(loopForIndex, childLoop);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, LoopGraph*>& loopForIndex) {
|
||||||
|
unordered_set<SAPFOR::Argument*> args = {block->getInstructions()[pos]->getInstruction()->getArg1()};
|
||||||
|
|
||||||
|
for (int i = pos-1; i >= 0; i--) {
|
||||||
|
SAPFOR::Argument* res = block->getInstructions()[i]->getInstruction()->getResult();
|
||||||
|
if (res && args.find(res) != args.end()) {
|
||||||
|
SAPFOR::Argument* arg1 = block->getInstructions()[i]->getInstruction()->getArg1();
|
||||||
|
SAPFOR::Argument* arg2 = block->getInstructions()[i]->getInstruction()->getArg2();
|
||||||
|
if (arg1) {
|
||||||
|
string name = arg1->getValue();
|
||||||
|
int idx = name.find('%');
|
||||||
|
if (idx != -1 && loopForIndex.find(name.substr(idx + 1)) != loopForIndex.end())
|
||||||
|
return name.substr(idx + 1);
|
||||||
|
else {
|
||||||
|
args.insert(arg1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (arg2) {
|
||||||
|
string name = arg2->getValue();
|
||||||
|
int idx = name.find('%');
|
||||||
|
if (idx != -1 && loopForIndex.find(name.substr(idx + 1)) != loopForIndex.end())
|
||||||
|
return name.substr(idx + 1);
|
||||||
|
else {
|
||||||
|
args.insert(arg2);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use) {
|
||||||
|
auto instructions = block->getInstructions();
|
||||||
|
map<string, LoopGraph*> loopForIndex;
|
||||||
|
BuildLoopIndex(loopForIndex, loop);
|
||||||
|
for(int i = 0; i < instructions.size(); i++)
|
||||||
|
{
|
||||||
|
auto instruction = instructions[i];
|
||||||
|
if(!instruction->getInstruction()->getArg1()) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
auto operation = instruction->getInstruction()->getOperation();
|
||||||
|
auto type = instruction->getInstruction()->getArg1()->getType();
|
||||||
|
if ((operation == SAPFOR::CFG_OP::STORE || operation == SAPFOR::CFG_OP::LOAD) && type == SAPFOR::CFG_ARG_TYPE::ARRAY)
|
||||||
|
{
|
||||||
|
vector<SAPFOR::Argument*> index_vars;
|
||||||
|
vector<int> refPos;
|
||||||
|
string array_name;
|
||||||
|
if (operation == SAPFOR::CFG_OP::STORE)
|
||||||
|
{
|
||||||
|
array_name = instruction->getInstruction()->getArg1()->getValue();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
array_name = instruction->getInstruction()->getArg2()->getValue();
|
||||||
|
}
|
||||||
|
int j = i - 1;
|
||||||
|
while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
|
||||||
|
{
|
||||||
|
index_vars.push_back(instructions[j]->getInstruction()->getArg1());
|
||||||
|
refPos.push_back(j);
|
||||||
|
j--;
|
||||||
|
}
|
||||||
|
/*to choose correct dimension*/
|
||||||
|
int n = index_vars.size();
|
||||||
|
vector<ArrayDimension> accessPoint(n);
|
||||||
|
/*if (operation == SAPFOR::CFG_OP::STORE)
|
||||||
|
{
|
||||||
|
if (def[array_name].empty())
|
||||||
|
{
|
||||||
|
def[array_name].resize(n);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (use[array_name].empty())
|
||||||
|
{
|
||||||
|
use[array_name].resize(n);
|
||||||
|
}
|
||||||
|
}*/
|
||||||
|
|
||||||
|
SgArrayRefExp* ref = (SgArrayRefExp*)instruction->getInstruction()->getExpression();
|
||||||
|
vector<pair<int, int>> coefsForDims;
|
||||||
|
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)
|
||||||
|
{
|
||||||
|
const pair<int, int> coef(coefs[0][0], coefs[0][1]);
|
||||||
|
coefsForDims.push_back(coef);
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
while (!index_vars.empty())
|
||||||
|
{
|
||||||
|
auto var = index_vars.back();
|
||||||
|
int currentVarPos = refPos.back();
|
||||||
|
pair currentCoefs = coefsForDims.back();
|
||||||
|
ArrayDimension current_dim;
|
||||||
|
if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST) {
|
||||||
|
current_dim = { stoul(var->getValue()), 1, 1 };
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
string name, full_name = var->getValue();
|
||||||
|
int pos = full_name.find('%');
|
||||||
|
LoopGraph* currentLoop;
|
||||||
|
if (pos != -1) {
|
||||||
|
name = full_name.substr(pos+1);
|
||||||
|
if (loopForIndex.find(name) != loopForIndex.end()) {
|
||||||
|
currentLoop = loopForIndex[name];
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
name = FindIndexName(currentVarPos, block, loopForIndex);
|
||||||
|
if (name == "") {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if (loopForIndex.find(name) != loopForIndex.end()) {
|
||||||
|
currentLoop = loopForIndex[name];
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
uint64_t start = currentLoop->startVal * currentCoefs.first + currentCoefs.second;
|
||||||
|
uint64_t step = currentCoefs.first;
|
||||||
|
current_dim = { start, step, (uint64_t)currentLoop->calculatedCountOfIters };
|
||||||
|
}
|
||||||
|
/*if (operation == SAPFOR::CFG_OP::STORE)
|
||||||
|
{
|
||||||
|
def[array_name][n - index_vars.size()].push_back(current_dim);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
use[array_name][n - index_vars.size()].push_back(current_dim);
|
||||||
|
}*/
|
||||||
|
accessPoint[n - index_vars.size()] = current_dim;
|
||||||
|
index_vars.pop_back();
|
||||||
|
refPos.pop_back();
|
||||||
|
coefsForDims.pop_back();
|
||||||
|
}
|
||||||
|
if (operation == SAPFOR::CFG_OP::STORE)
|
||||||
|
{
|
||||||
|
def[array_name].Insert(accessPoint);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
use[array_name].Insert(accessPoint);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
static vector<uint64_t> FindParticularSolution(const ArrayDimension& dim1, const ArrayDimension& dim2)
|
||||||
|
{
|
||||||
|
for (uint64_t i = 0; i < dim1.tripCount; i++)
|
||||||
|
{
|
||||||
|
uint64_t leftPart = dim1.start + i * dim1.step;
|
||||||
|
for (uint64_t j = 0; j < dim2.tripCount; j++)
|
||||||
|
{
|
||||||
|
uint64_t rightPart = dim2.start + j * dim2.step;
|
||||||
|
if (leftPart == rightPart)
|
||||||
|
{
|
||||||
|
return {i, j};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
|
||||||
|
/* dim1 /\ dim2 */
|
||||||
|
static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const ArrayDimension& dim2)
|
||||||
|
{
|
||||||
|
vector<uint64_t> partSolution = FindParticularSolution(dim1, dim2);
|
||||||
|
if (partSolution.empty())
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
int64_t x0 = partSolution[0], y0 = partSolution[1];
|
||||||
|
/* x = x_0 + c * t */
|
||||||
|
/* y = y_0 + d * t */
|
||||||
|
int64_t c = dim2.step / gcd(dim1.step, dim2.step);
|
||||||
|
int64_t d = dim1.step / gcd(dim1.step, dim2.step);
|
||||||
|
int64_t tXMin, tXMax, tYMin, tYMax;
|
||||||
|
tXMin = -x0 / c;
|
||||||
|
tXMax = (dim1.tripCount - 1 - x0) / c;
|
||||||
|
tYMin = -y0 / d;
|
||||||
|
tYMax = (dim2.tripCount - 1 - y0) / d;
|
||||||
|
int64_t tMin = max(tXMin, tYMin);
|
||||||
|
uint64_t tMax = min(tXMax, tYMax);
|
||||||
|
if (tMin > tMax)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
uint64_t start3 = dim1.start + x0 * dim1.step;
|
||||||
|
uint64_t step3 = c * dim1.step;
|
||||||
|
ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 };
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* dim1 / dim2 */
|
||||||
|
static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, const ArrayDimension& dim2)
|
||||||
|
{
|
||||||
|
ArrayDimension* intersection = DimensionIntersection(dim1, dim2);
|
||||||
|
if (!intersection)
|
||||||
|
{
|
||||||
|
return {dim1};
|
||||||
|
}
|
||||||
|
vector<ArrayDimension> result;
|
||||||
|
/* add the part before intersection */
|
||||||
|
if (dim1.start < intersection->start)
|
||||||
|
{
|
||||||
|
result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step });
|
||||||
|
}
|
||||||
|
/* add the parts between intersection steps */
|
||||||
|
uint64_t start = (intersection->start - dim1.start) / dim1.step;
|
||||||
|
uint64_t interValue = intersection->start;
|
||||||
|
for (int64_t i = start; dim1.start + i * dim1.step <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
|
||||||
|
{
|
||||||
|
uint64_t centerValue = dim1.start + i * dim1.step;
|
||||||
|
if (centerValue == interValue)
|
||||||
|
{
|
||||||
|
if (i - start > 1)
|
||||||
|
{
|
||||||
|
result.push_back({ dim1.start + (start + 1) * dim1.step, dim1.step, i - start - 1 });
|
||||||
|
start = i;
|
||||||
|
}
|
||||||
|
interValue += intersection->step;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* add the part after intersection */
|
||||||
|
if (intersection->start + intersection->step * (intersection->tripCount - 1) < dim1.start + dim1.step * (dim1.tripCount - 1))
|
||||||
|
{
|
||||||
|
/* first value after intersection */
|
||||||
|
uint64_t right_start = intersection->start + intersection->step * (intersection->tripCount - 1) + dim1.step;
|
||||||
|
uint64_t tripCount = (dim1.start + dim1.step * dim1.tripCount - right_start) / dim1.step;
|
||||||
|
result.push_back({right_start, dim1.step, tripCount});
|
||||||
|
}
|
||||||
|
delete(intersection);
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static vector<ArrayDimension> DimensionUnion(const ArrayDimension& dim1, const ArrayDimension& dim2)
|
||||||
|
{
|
||||||
|
vector<ArrayDimension> res;
|
||||||
|
ArrayDimension* inter = DimensionIntersection(dim1, dim2);
|
||||||
|
if(!inter)
|
||||||
|
{
|
||||||
|
return { dim1, dim2 };
|
||||||
|
}
|
||||||
|
res.push_back(*inter);
|
||||||
|
delete(inter);
|
||||||
|
vector<ArrayDimension> diff1, diff2;
|
||||||
|
diff1 = DimensionDifference(dim1, dim2);
|
||||||
|
diff2 = DimensionDifference(dim2, dim1);
|
||||||
|
res.insert(res.end(), diff1.begin(), diff1.end());
|
||||||
|
res.insert(res.end(), diff2.begin(), diff2.end());
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>& firstElement, const vector<ArrayDimension>& secondElement)
|
||||||
|
{
|
||||||
|
if(firstElement.empty() || secondElement.empty()) {
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
size_t dimAmount = firstElement.size();
|
||||||
|
/* check if there is no intersecction */
|
||||||
|
for(size_t i = 0; i < dimAmount; i++)
|
||||||
|
{
|
||||||
|
if(FindParticularSolution(firstElement[i], secondElement[i]).empty()){
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
vector<ArrayDimension> result(dimAmount);
|
||||||
|
for(size_t i = 0; i < dimAmount; i++)
|
||||||
|
{
|
||||||
|
ArrayDimension* resPtr = DimensionIntersection(firstElement[i], secondElement[i]);
|
||||||
|
if(resPtr)
|
||||||
|
{
|
||||||
|
result[i] = *resPtr;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimension>& firstElement,
|
||||||
|
const vector<ArrayDimension>& secondElement)
|
||||||
|
{
|
||||||
|
if(firstElement.empty() || secondElement.empty()) {
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
vector<ArrayDimension> intersection = ElementsIntersection(firstElement, secondElement);
|
||||||
|
vector<vector<ArrayDimension>> result;
|
||||||
|
if(intersection.empty())
|
||||||
|
{
|
||||||
|
return {firstElement};
|
||||||
|
}
|
||||||
|
for(int i = 0; i < firstElement.size(); i++)
|
||||||
|
{
|
||||||
|
auto dimDiff = DimensionDifference(firstElement[i], secondElement[i]);
|
||||||
|
if(!dimDiff.empty())
|
||||||
|
{
|
||||||
|
vector<ArrayDimension> firstCopy = firstElement;
|
||||||
|
for(const auto range: dimDiff)
|
||||||
|
{
|
||||||
|
firstCopy[i] = range;
|
||||||
|
result.push_back(firstCopy);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void ElementsUnion(const vector<ArrayDimension>& firstElement, const vector<ArrayDimension>& secondElement,
|
||||||
|
vector<vector<ArrayDimension>>& lc, vector<vector<ArrayDimension>>& rc,
|
||||||
|
vector<ArrayDimension>& intersection)
|
||||||
|
{
|
||||||
|
/* lc(rc) is a set of ranges, which only exist in first(second) element*/
|
||||||
|
intersection = ElementsIntersection(firstElement, secondElement);
|
||||||
|
lc = ElementsDifference(firstElement, intersection);
|
||||||
|
rc = ElementsDifference(secondElement, intersection);
|
||||||
|
}
|
||||||
|
|
||||||
|
void AccessingSet::FindUncovered(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const{
|
||||||
|
vector<vector<ArrayDimension>> newTails;
|
||||||
|
result.push_back(element);
|
||||||
|
for(const auto& currentElement: allElements)
|
||||||
|
{
|
||||||
|
for(const auto& tailLoc: result)
|
||||||
|
{
|
||||||
|
auto intersection = ElementsIntersection(tailLoc, currentElement);
|
||||||
|
auto diff = ElementsDifference(tailLoc, intersection);
|
||||||
|
if(!diff.empty()) {
|
||||||
|
newTails.insert(newTails.end(), diff.begin(), diff.end());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
result = move(newTails);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool AccessingSet::ContainsElement(const vector<ArrayDimension>& element) const
|
||||||
|
{
|
||||||
|
vector<vector<ArrayDimension>> tails;
|
||||||
|
FindUncovered(element, tails);
|
||||||
|
return !tails.empty();
|
||||||
|
}
|
||||||
|
|
||||||
|
void AccessingSet::FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const
|
||||||
|
{
|
||||||
|
for(const auto& currentElement: allElements)
|
||||||
|
{
|
||||||
|
auto intersection = ElementsIntersection(element, currentElement);
|
||||||
|
if(!intersection.empty()) {
|
||||||
|
result.push_back(intersection);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
vector<vector<ArrayDimension>> AccessingSet::GetElements() const
|
||||||
|
{
|
||||||
|
return allElements;
|
||||||
|
}
|
||||||
|
|
||||||
|
void AccessingSet::Insert(const vector<ArrayDimension>& element)
|
||||||
|
{
|
||||||
|
vector<vector<ArrayDimension>> tails;
|
||||||
|
FindUncovered(element, tails);
|
||||||
|
allElements.insert(allElements.end(), tails.begin(), tails.end());
|
||||||
|
}
|
||||||
|
|
||||||
|
void AccessingSet::Union(const AccessingSet& source) {
|
||||||
|
for(auto& element: source.GetElements()) {
|
||||||
|
Insert(element);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
AccessingSet AccessingSet::Intersect(const AccessingSet& secondSet) const
|
||||||
|
{
|
||||||
|
vector<vector<ArrayDimension>> result;
|
||||||
|
for(const auto& element: allElements)
|
||||||
|
{
|
||||||
|
if(secondSet.ContainsElement(element))
|
||||||
|
{
|
||||||
|
result.push_back(element);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
vector<vector<ArrayDimension>> coveredBy;
|
||||||
|
secondSet.FindCoveredBy(element, coveredBy);
|
||||||
|
if(!coveredBy.empty())
|
||||||
|
{
|
||||||
|
result.insert(result.end(), coveredBy.begin(), coveredBy.end());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return AccessingSet(result);
|
||||||
|
}
|
||||||
|
|
||||||
|
AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const
|
||||||
|
{
|
||||||
|
AccessingSet intersection = this->Intersect(secondSet);
|
||||||
|
AccessingSet uncovered = *this;
|
||||||
|
vector<vector<ArrayDimension>> result;
|
||||||
|
for (const auto& element : intersection.GetElements())
|
||||||
|
{
|
||||||
|
vector<vector<ArrayDimension>> current_uncovered;
|
||||||
|
uncovered.FindUncovered(element, current_uncovered);
|
||||||
|
uncovered = AccessingSet(current_uncovered);
|
||||||
|
}
|
||||||
|
return uncovered;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Collapse(Region* region)
|
||||||
|
{
|
||||||
|
Region* newBlock = new Region();
|
||||||
|
for (auto& [arrayName, arrayRanges] : region->GetHeader()->array_out)
|
||||||
|
{
|
||||||
|
for (Region* byBlock : region->GetBasickBlocks())
|
||||||
|
{
|
||||||
|
AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges);
|
||||||
|
newBlock->array_def[arrayName].Union(intersection);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for (Region* prevRegion : region->getPrevRegions()) {
|
||||||
|
prevRegion->setNextRegion(newBlock);
|
||||||
|
}
|
||||||
|
region->getNextRegion()->setPrevRegion(newBlock);
|
||||||
|
}
|
||||||
|
|
||||||
|
void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
|
||||||
|
{
|
||||||
|
for (const auto& curr_graph_pair: loopGraph)
|
||||||
|
{
|
||||||
|
for (const auto& curr_loop : curr_graph_pair.second)
|
||||||
|
{
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
void GetDimensionInfo(LoopGraph* loop, map<DIST::Array*, vector<vector<ArrayDimension>>>& loopDimensionsInfo, int level)
|
||||||
|
{
|
||||||
|
cout << "line_num: " << loop->lineNum << endl;
|
||||||
|
for (const auto& writeOpPairs : loop->writeOpsForLoop)
|
||||||
|
{
|
||||||
|
vector<vector<ArrayDimension>> arrayDimensions(writeOpPairs.first->GetDimSize());
|
||||||
|
loopDimensionsInfo[writeOpPairs.first] = arrayDimensions;
|
||||||
|
for (const auto& writeOp : writeOpPairs.second)
|
||||||
|
{
|
||||||
|
for (const auto& coeficient_pair : writeOp.coefficients)
|
||||||
|
{
|
||||||
|
uint64_t start, step, tripCount;
|
||||||
|
start = loop->startVal * coeficient_pair.first.first + coeficient_pair.first.second;
|
||||||
|
step = loop->stepVal * coeficient_pair.first.first;
|
||||||
|
tripCount = (loop->endVal - coeficient_pair.first.second) / step;
|
||||||
|
if (start <= loop->endVal)
|
||||||
|
{
|
||||||
|
loopDimensionsInfo[writeOpPairs.first][level].push_back({start, step, tripCount});
|
||||||
|
cout << "level: " << level << endl;
|
||||||
|
cout << "start: " << start << endl;
|
||||||
|
cout << "step: " << step << endl;
|
||||||
|
cout << "trip_count: " << tripCount << endl;
|
||||||
|
cout << endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
cout << "line_num_after: " << loop->lineNumAfterLoop << endl;
|
||||||
|
if (!loop->children.empty())
|
||||||
|
{
|
||||||
|
for (const auto& childLoop : loop->children)
|
||||||
|
{
|
||||||
|
GetDimensionInfo(childLoop, loopDimensionsInfo, level+1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
84
src/PrivateAnalyzer/private_arrays_search.h
Normal file
84
src/PrivateAnalyzer/private_arrays_search.h
Normal file
@@ -0,0 +1,84 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "../GraphLoop/graph_loops.h"
|
||||||
|
#include "../CFGraph/CFGraph.h"
|
||||||
|
|
||||||
|
using std::vector;
|
||||||
|
using std::map;
|
||||||
|
using std::string;
|
||||||
|
using std::set;
|
||||||
|
|
||||||
|
struct ArrayDimension
|
||||||
|
{
|
||||||
|
uint64_t start, step, tripCount;
|
||||||
|
};
|
||||||
|
|
||||||
|
class AccessingSet {
|
||||||
|
private:
|
||||||
|
vector<vector<ArrayDimension>> allElements;
|
||||||
|
|
||||||
|
public:
|
||||||
|
AccessingSet(vector<vector<ArrayDimension>> input) : allElements(input) {};
|
||||||
|
AccessingSet() {};
|
||||||
|
vector<vector<ArrayDimension>> GetElements() const;
|
||||||
|
void Insert(const vector<ArrayDimension>& element);
|
||||||
|
void 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;
|
||||||
|
};
|
||||||
|
|
||||||
|
using ArrayAccessingIndexes = map<string, AccessingSet>;
|
||||||
|
|
||||||
|
class Region: public SAPFOR::BasicBlock {
|
||||||
|
public:
|
||||||
|
Region()
|
||||||
|
{
|
||||||
|
header = nullptr;
|
||||||
|
nextRegion = nullptr;
|
||||||
|
}
|
||||||
|
Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block)
|
||||||
|
{
|
||||||
|
header = nullptr;
|
||||||
|
nextRegion = nullptr;
|
||||||
|
};
|
||||||
|
//Region(LoopGraph* loop);
|
||||||
|
Region* GetHeader()
|
||||||
|
{
|
||||||
|
return header;
|
||||||
|
}
|
||||||
|
set<Region*> GetBasickBlocks()
|
||||||
|
{
|
||||||
|
return basickBlocks;
|
||||||
|
}
|
||||||
|
vector<Region*> getPrevRegions()
|
||||||
|
{
|
||||||
|
return prevRegions;
|
||||||
|
}
|
||||||
|
Region* getNextRegion()
|
||||||
|
{
|
||||||
|
return nextRegion;
|
||||||
|
}
|
||||||
|
void setPrevRegion(Region* region)
|
||||||
|
{
|
||||||
|
prevRegions.push_back(region);
|
||||||
|
}
|
||||||
|
void setNextRegion(Region* region)
|
||||||
|
{
|
||||||
|
nextRegion = region;
|
||||||
|
}
|
||||||
|
ArrayAccessingIndexes array_def, array_use, array_out, array_in;
|
||||||
|
|
||||||
|
private:
|
||||||
|
set<Region*> subRegions, basickBlocks;
|
||||||
|
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>);
|
||||||
Reference in New Issue
Block a user