From b7ebccf045d910dafc97cb1a3f34208f6fcd5b2e Mon Sep 17 00:00:00 2001 From: Oleg Nikitin Date: Mon, 31 Mar 2025 02:50:30 +0300 Subject: [PATCH 01/22] add Collapse --- CMakeLists.txt | 4 +- src/PrivateAnalyzer/private_arrays_search.cpp | 590 ++++++++++++++++++ src/PrivateAnalyzer/private_arrays_search.h | 84 +++ 3 files changed, 677 insertions(+), 1 deletion(-) create mode 100644 src/PrivateAnalyzer/private_arrays_search.cpp create mode 100644 src/PrivateAnalyzer/private_arrays_search.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 87eb86c..1b0f054 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -113,7 +113,9 @@ set(OMEGA src/SageAnalysisTool/OmegaForSage/add-assert.cpp src/SageAnalysisTool/set.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 ${fdvm_sources}/acc_across.cpp diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp new file mode 100644 index 0000000..084cbcc --- /dev/null +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -0,0 +1,590 @@ +#include +#include +#include +#include +#include +#include +#include + +#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> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks) +{ + unordered_set 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& 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& loopForIndex) { + unordered_set 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 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 index_vars; + vector 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 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> coefsForDims; + for (int i = 0; i < ref->numberOfSubscripts(); ++i) + { + const vector& coefs = getAttributes(ref->subscript(i), set{ INT_VAL }); + if (coefs.size() == 1) + { + const pair 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 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 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 DimensionDifference(const ArrayDimension& dim1, const ArrayDimension& dim2) +{ + ArrayDimension* intersection = DimensionIntersection(dim1, dim2); + if (!intersection) + { + return {dim1}; + } + vector 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 DimensionUnion(const ArrayDimension& dim1, const ArrayDimension& dim2) +{ + vector res; + ArrayDimension* inter = DimensionIntersection(dim1, dim2); + if(!inter) + { + return { dim1, dim2 }; + } + res.push_back(*inter); + delete(inter); + vector 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 ElementsIntersection(const vector& firstElement, const vector& 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 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> ElementsDifference(const vector& firstElement, + const vector& secondElement) +{ + if(firstElement.empty() || secondElement.empty()) { + return {}; + } + vector intersection = ElementsIntersection(firstElement, secondElement); + vector> 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 firstCopy = firstElement; + for(const auto range: dimDiff) + { + firstCopy[i] = range; + result.push_back(firstCopy); + } + } + } + return result; +} + +static void ElementsUnion(const vector& firstElement, const vector& secondElement, + vector>& lc, vector>& rc, + vector& 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& element, vector>& result) const{ + vector> 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& element) const +{ + vector> tails; + FindUncovered(element, tails); + return !tails.empty(); +} + +void AccessingSet::FindCoveredBy(const vector& element, vector>& result) const +{ + for(const auto& currentElement: allElements) + { + auto intersection = ElementsIntersection(element, currentElement); + if(!intersection.empty()) { + result.push_back(intersection); + } + } +} + +vector> AccessingSet::GetElements() const +{ + return allElements; +} + +void AccessingSet::Insert(const vector& element) +{ + vector> 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> result; + for(const auto& element: allElements) + { + if(secondSet.ContainsElement(element)) + { + result.push_back(element); + } + else + { + vector> 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> result; + for (const auto& element : intersection.GetElements()) + { + vector> 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> &loopGraph, map>& 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>>& loopDimensionsInfo, int level) +{ + cout << "line_num: " << loop->lineNum << endl; + for (const auto& writeOpPairs : loop->writeOpsForLoop) + { + vector> 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); + } + } +} diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h new file mode 100644 index 0000000..d146d52 --- /dev/null +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -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> allElements; + + public: + AccessingSet(vector> input) : allElements(input) {}; + AccessingSet() {}; + vector> GetElements() const; + void Insert(const vector& element); + void Union(const AccessingSet& source); + AccessingSet Intersect(const AccessingSet& secondSet) const; + AccessingSet Diff(const AccessingSet& secondSet) const; + bool ContainsElement(const vector& element) const; + void FindCoveredBy(const vector& element, vector>& result) const; + void FindUncovered(const vector& element, vector>& result) const; +}; + +using ArrayAccessingIndexes = map; + +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 GetBasickBlocks() + { + return basickBlocks; + } + vector 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 subRegions, basickBlocks; + Region* header; + Region* nextRegion; + vector prevRegions; +}; + +void Collapse(Region* region); +void FindPrivateArrays(map>& loopGraph, map>& FullIR); +void GetDimensionInfo(LoopGraph* loop, map>>& loopDimensionsInfo, int level); +set GetBasicBlocksForLoop(LoopGraph* loop, vector); From 54eb1ecc9535faa0bb68436bb7078d18a4adc56e Mon Sep 17 00:00:00 2001 From: Oleg Nikitin Date: Tue, 8 Apr 2025 15:25:39 +0300 Subject: [PATCH 02/22] add Region constructor and SolveDataflow function --- src/PrivateAnalyzer/private_arrays_search.cpp | 89 ++++++++++++++++--- src/PrivateAnalyzer/private_arrays_search.h | 78 +++++++++++----- 2 files changed, 136 insertions(+), 31 deletions(-) diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index 084cbcc..17bd679 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -44,7 +44,7 @@ static bool isParentStmt(SgStatement* stmt, SgStatement* parent) } /*returns head block and loop*/ -static pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks) +pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks) { unordered_set block_loop; SAPFOR::BasicBlock* head_block = nullptr; @@ -397,7 +397,7 @@ static vector> ElementsDifference(const vector firstCopy = firstElement; - for(const auto range: dimDiff) + for(const auto& range: dimDiff) { firstCopy[i] = range; result.push_back(firstCopy); @@ -508,27 +508,94 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const void Collapse(Region* region) { - Region* newBlock = new Region(); - for (auto& [arrayName, arrayRanges] : region->GetHeader()->array_out) + //Region* newBlock = new Region(); + for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out) { - for (Region* byBlock : region->GetBasickBlocks()) + for (Region* byBlock : region->getBasickBlocks()) { AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges); - newBlock->array_def[arrayName].Union(intersection); + region->array_def[arrayName].Union(intersection); } } - 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]); - newBlock->array_use[arrayName].Union(diff); + region->array_use[arrayName].Union(diff); } } - for (Region* prevRegion : region->getPrevRegions()) { - prevRegion->setNextRegion(newBlock); + + for (Region* prevBlock : region->getHeader()->getPrevRegions()) + { + prevBlock->replaceInNextRegions(region, region->getHeader()); } - region->getNextRegion()->setPrevRegion(newBlock); + for (Region* nextBlock : region->getHeader()->getNextRegions()) + { + nextBlock->replaceInPrevRegions(region, region->getHeader()); + } +} + +static void SetConnections(unordered_map& bbToRegion, const unordered_set& blockSet) +{ + for (SAPFOR::BasicBlock* block : blockSet) + { + for (SAPFOR::BasicBlock* nextBlock : block->getNext()) + { + if (bbToRegion.find(nextBlock) != bbToRegion.end()) + { + bbToRegion[block]->addNextRegion(bbToRegion[nextBlock]); + } + } + for (SAPFOR::BasicBlock* prevBlock : block->getPrev()) + { + if (bbToRegion.find(prevBlock) != bbToRegion.end()) + { + bbToRegion[block]->addPrevRegion(bbToRegion[prevBlock]); + } + } + } +} + +static Region* CreateSubRegion(LoopGraph* loop, const vector& Blocks, const unordered_map& bbToRegion) +{ + Region* region = new Region; + auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); + for (SAPFOR::BasicBlock* block : Blocks) + { + region->addBasickBlocks(bbToRegion.at(block)); + } + for (LoopGraph* childLoop : loop->children) + { + region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion)); + } + return region; +} + +Region::Region(LoopGraph* loop, vector& Blocks) +{ + auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); + unordered_map bbToRegion; + for (auto poiner : blockSet) + { + bbToRegion[poiner] = new Region(*poiner); + } + SetConnections(bbToRegion, blockSet); + //create subRegions + for (LoopGraph* childLoop : loop->children) + { + subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion)); + } +} + +void SolveDataFlow(Region* DFG) +{ + //SolveDataFlowIteratively(DFG) + for (Region* subRegion : DFG->getSubRegions()) + { + SolveDataFlow(subRegion); + } + Collapse(DFG); } void FindPrivateArrays(map> &loopGraph, map>& FullIR) diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index d146d52..9a5aa49 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -7,6 +7,8 @@ using std::vector; using std::map; using std::string; using std::set; +using std::unordered_set; +using std::pair; struct ArrayDimension { @@ -36,49 +38,85 @@ class Region: public SAPFOR::BasicBlock { public: Region() { - header = nullptr; - nextRegion = nullptr; + header = nullptr; } + Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block) { header = nullptr; - nextRegion = nullptr; - }; - //Region(LoopGraph* loop); - Region* GetHeader() + } + + Region(LoopGraph* loop, vector& Blocks); + + Region* getHeader() { return header; } - set GetBasickBlocks() + + unordered_set& getBasickBlocks() { return basickBlocks; } - vector getPrevRegions() + + void addBasickBlocks(Region* region) + { + basickBlocks.insert(region); + } + unordered_set getPrevRegions() { return prevRegions; } - Region* getNextRegion() + + unordered_set getNextRegions() { - return nextRegion; + return nextRegions; } - void setPrevRegion(Region* region) + + void addPrevRegion(Region* region) { - prevRegions.push_back(region); + prevRegions.insert(region); } - void setNextRegion(Region* region) + + void addNextRegion(Region* region) { - nextRegion = region; + nextRegions.insert(region); } + + void replaceInPrevRegions(Region* source, Region* destination) + { + prevRegions.erase(destination); + prevRegions.insert(source); + } + + void replaceInNextRegions(Region* source, Region* destination) + { + nextRegions.erase(destination); + nextRegions.insert(source); + } + + unordered_set getSubRegions() + { + return subRegions; + } + + void addSubRegions(Region* region) + { + subRegions.insert(region); + } + ArrayAccessingIndexes array_def, array_use, array_out, array_in; - + private: - set subRegions, basickBlocks; - Region* header; - Region* nextRegion; - vector prevRegions; + unordered_set subRegions, basickBlocks; + /*next Region which is BB for current BB Region*/ + unordered_set nextRegions; + /*prev Regions which is BBs for current BB Region*/ + unordered_set prevRegions; + Region* header; }; + void Collapse(Region* region); void FindPrivateArrays(map>& loopGraph, map>& FullIR); void GetDimensionInfo(LoopGraph* loop, map>>& loopDimensionsInfo, int level); -set GetBasicBlocksForLoop(LoopGraph* loop, vector); +pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks); From 0df1d3d5fe85873b96303eba2b7a2f5e9403bca4 Mon Sep 17 00:00:00 2001 From: Oleg Nikitin Date: Tue, 29 Apr 2025 17:55:51 +0300 Subject: [PATCH 03/22] add dataflow solvation --- src/PrivateAnalyzer/private_arrays_search.cpp | 67 +++++++++++++++++-- src/PrivateAnalyzer/private_arrays_search.h | 3 +- 2 files changed, 64 insertions(+), 6 deletions(-) diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index 17bd679..f8ab229 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -464,10 +464,12 @@ void AccessingSet::Insert(const vector& element) allElements.insert(allElements.end(), tails.begin(), tails.end()); } -void AccessingSet::Union(const AccessingSet& source) { +AccessingSet AccessingSet::Union(const AccessingSet& source) { + AccessingSet result; for(auto& element: source.GetElements()) { - Insert(element); + result.Insert(element); } + return result; } AccessingSet AccessingSet::Intersect(const AccessingSet& secondSet) const @@ -506,6 +508,27 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const return uncovered; } +bool operator==(const ArrayDimension& lhs, const ArrayDimension& rhs) +{ + return lhs.start == rhs.start && lhs.step == rhs.step && lhs.tripCount == rhs.tripCount; +} + + +bool operator==(const AccessingSet& lhs, const AccessingSet& rhs) +{ + for (size_t i = 0; i < lhs.allElements.size(); i++) + { + for (size_t j = 0; j < lhs.allElements[i].size(); j++) + { + if (lhs.allElements[i][j] != rhs.allElements[i][j]) + { + return false; + } + } + } + return true; +} + void Collapse(Region* region) { //Region* newBlock = new Region(); @@ -514,7 +537,7 @@ void Collapse(Region* region) for (Region* byBlock : region->getBasickBlocks()) { AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges); - region->array_def[arrayName].Union(intersection); + region->array_def[arrayName] = region->array_def[arrayName].Union(intersection); } } @@ -522,7 +545,7 @@ void Collapse(Region* region) for (auto& [arrayName, arrayRanges] : byBlock->array_use) { AccessingSet diff = byBlock->array_use[arrayName].Diff(byBlock->array_in[arrayName]); - region->array_use[arrayName].Union(diff); + region->array_use[arrayName] = region->array_use[arrayName].Union(diff); } } @@ -580,6 +603,7 @@ Region::Region(LoopGraph* loop, vector& Blocks) { bbToRegion[poiner] = new Region(*poiner); } + this->header = bbToRegion[header]; SetConnections(bbToRegion, blockSet); //create subRegions for (LoopGraph* childLoop : loop->children) @@ -588,9 +612,42 @@ Region::Region(LoopGraph* loop, vector& Blocks) } } +void SolveDataFlowIteratively(Region* DFG) +{ + unordered_set worklist(DFG->getBasickBlocks()); + do + { + Region* b = *worklist.begin(); + ArrayAccessingIndexes newIn; + for (Region* prevBlock : b->getPrevRegions()) + { + for (const auto& [arrayName, accessSet] : prevBlock->array_out) + { + newIn[arrayName] = newIn[arrayName].Intersect(accessSet); + } + } + b->array_in = newIn; + ArrayAccessingIndexes newOut; + for (auto& [arrayName, accessSet] : b->array_in) + { + newOut[arrayName] = b->array_in[arrayName].Union(b->array_def[arrayName]); + } + /* can not differ */ + if (newOut != b->array_out) + { + b->array_out = newOut; + } + else + { + worklist.erase(b); + } + } + while (!worklist.empty()); +} + void SolveDataFlow(Region* DFG) { - //SolveDataFlowIteratively(DFG) + SolveDataFlowIteratively(DFG); for (Region* subRegion : DFG->getSubRegions()) { SolveDataFlow(subRegion); diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index 9a5aa49..f8508f3 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -24,12 +24,13 @@ class AccessingSet { AccessingSet() {}; vector> GetElements() const; void Insert(const vector& element); - void Union(const AccessingSet& source); + AccessingSet Union(const AccessingSet& source); AccessingSet Intersect(const AccessingSet& secondSet) const; AccessingSet Diff(const AccessingSet& secondSet) const; bool ContainsElement(const vector& element) const; void FindCoveredBy(const vector& element, vector>& result) const; void FindUncovered(const vector& element, vector>& result) const; + friend bool operator==(const AccessingSet& lhs, const AccessingSet& rhs); }; using ArrayAccessingIndexes = map; From f679666d0168d731ff57bdbc0585520f1c628f21 Mon Sep 17 00:00:00 2001 From: "O. Nikitin" Date: Mon, 5 May 2025 21:53:34 +0300 Subject: [PATCH 04/22] fix operator!= --- src/PrivateAnalyzer/private_arrays_search.cpp | 26 +++++++++++++++---- src/PrivateAnalyzer/private_arrays_search.h | 2 +- 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index f8ab229..ce70854 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -508,13 +508,13 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const return uncovered; } -bool operator==(const ArrayDimension& lhs, const ArrayDimension& rhs) +bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs) { - return lhs.start == rhs.start && lhs.step == rhs.step && lhs.tripCount == rhs.tripCount; + return !(lhs.start == rhs.start && lhs.step == rhs.step && lhs.tripCount == rhs.tripCount); } -bool operator==(const AccessingSet& lhs, const AccessingSet& rhs) +bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs) { for (size_t i = 0; i < lhs.allElements.size(); i++) { @@ -522,11 +522,27 @@ bool operator==(const AccessingSet& lhs, const AccessingSet& rhs) { if (lhs.allElements[i][j] != rhs.allElements[i][j]) { - return false; + return true; } } } - return true; + return false; +} + +bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs) +{ + if(lhs.size() != rhs.size()) + { + return true; + } + for(auto& [key, value]: lhs) + { + if(rhs.find(key) == rhs.end()) + { + return true; + } + } + return false; } void Collapse(Region* region) diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index f8508f3..983f3dc 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -30,7 +30,7 @@ class AccessingSet { bool ContainsElement(const vector& element) const; void FindCoveredBy(const vector& element, vector>& result) const; void FindUncovered(const vector& element, vector>& result) const; - friend bool operator==(const AccessingSet& lhs, const AccessingSet& rhs); + friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs); }; using ArrayAccessingIndexes = map; From 1973d095f53fcb5b20ebf4f125408ca1d5f35194 Mon Sep 17 00:00:00 2001 From: Oleg Nikitin Date: Mon, 5 May 2025 22:49:53 +0300 Subject: [PATCH 05/22] made functions static --- projects/dvm | 2 +- src/PrivateAnalyzer/private_arrays_search.cpp | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/projects/dvm b/projects/dvm index a711f8e..ca44a63 160000 --- a/projects/dvm +++ b/projects/dvm @@ -1 +1 @@ -Subproject commit a711f8ebfd023ca90a6d9c9bdf5a4726cd276d51 +Subproject commit ca44a63d14c456d4deeea8b9a89125cb942f4550 diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index ce70854..97c29cc 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -508,13 +508,13 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const return uncovered; } -bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs) +static bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs) { return !(lhs.start == rhs.start && lhs.step == rhs.step && lhs.tripCount == rhs.tripCount); } -bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs) +static bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs) { for (size_t i = 0; i < lhs.allElements.size(); i++) { @@ -529,7 +529,7 @@ bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs) return false; } -bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs) +static bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs) { if(lhs.size() != rhs.size()) { @@ -628,7 +628,7 @@ Region::Region(LoopGraph* loop, vector& Blocks) } } -void SolveDataFlowIteratively(Region* DFG) +static void SolveDataFlowIteratively(Region* DFG) { unordered_set worklist(DFG->getBasickBlocks()); do @@ -661,7 +661,7 @@ void SolveDataFlowIteratively(Region* DFG) while (!worklist.empty()); } -void SolveDataFlow(Region* DFG) +static void SolveDataFlow(Region* DFG) { SolveDataFlowIteratively(DFG); for (Region* subRegion : DFG->getSubRegions()) From 73d0b201f2d1060820c66da64c5151c722ed8e14 Mon Sep 17 00:00:00 2001 From: Oleg Nikitin Date: Mon, 19 May 2025 20:50:35 +0300 Subject: [PATCH 06/22] change passes --- projects/dvm | 2 +- src/PrivateAnalyzer/private_arrays_search.cpp | 101 ++++++++++++++---- src/PrivateAnalyzer/private_arrays_search.h | 50 +++++---- src/Sapfor.cpp | 5 + src/Sapfor.h | 3 + src/Utils/PassManager.h | 2 + 6 files changed, 116 insertions(+), 47 deletions(-) diff --git a/projects/dvm b/projects/dvm index ca44a63..a711f8e 160000 --- a/projects/dvm +++ b/projects/dvm @@ -1 +1 @@ -Subproject commit ca44a63d14c456d4deeea8b9a89125cb942f4550 +Subproject commit a711f8ebfd023ca90a6d9c9bdf5a4726cd276d51 diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index 97c29cc..4461d94 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -44,7 +44,7 @@ static bool isParentStmt(SgStatement* stmt, SgStatement* parent) } /*returns head block and loop*/ -pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks) +pair> GetBasicBlocksForLoop(const LoopGraph* loop, const vector blocks) { unordered_set 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> coefsForDims; - for (int i = 0; i < ref->numberOfSubscripts(); ++i) + for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i) { const vector& coefs = getAttributes(ref->subscript(i), set{ 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& bbToRegion, const unordered_set& blockSet) @@ -602,7 +626,10 @@ static Region* CreateSubRegion(LoopGraph* loop, const vectoraddBasickBlocks(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& Blocks) +Region::Region(LoopGraph* loop, const vector& Blocks) { auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); unordered_map 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> &loopGraph, map>& FullIR) +map FindPrivateArrays(map> &loopGraph, map>& FullIR) { - for (const auto& curr_graph_pair: loopGraph) + map 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 A = { {1, 1, 2}, {0, 1, 6} }; + vector B = { {0, 1, 6}, {2, 1, 2} }; + vector C = { {1, 1, 2}, {2, 1, 2} }; + return result; } void GetDimensionInfo(LoopGraph* loop, map>>& loopDimensionsInfo, int level) diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index 983f3dc..cc26f78 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -1,14 +1,12 @@ #pragma once +#include +#include +#include + #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> allElements; + std::vector> allElements; public: - AccessingSet(vector> input) : allElements(input) {}; + AccessingSet(std::vector> input) : allElements(input) {}; AccessingSet() {}; - vector> GetElements() const; - void Insert(const vector& element); + std::vector> GetElements() const; + void Insert(const std::vector& element); AccessingSet Union(const AccessingSet& source); AccessingSet Intersect(const AccessingSet& secondSet) const; AccessingSet Diff(const AccessingSet& secondSet) const; - bool ContainsElement(const vector& element) const; - void FindCoveredBy(const vector& element, vector>& result) const; - void FindUncovered(const vector& element, vector>& result) const; + bool ContainsElement(const std::vector& element) const; + void FindCoveredBy(const std::vector& element, std::vector>& result) const; + void FindUncovered(const std::vector& element, std::vector>& result) const; friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs); }; -using ArrayAccessingIndexes = map; +using ArrayAccessingIndexes = std::map; class Region: public SAPFOR::BasicBlock { public: @@ -47,14 +45,14 @@ class Region: public SAPFOR::BasicBlock { header = nullptr; } - Region(LoopGraph* loop, vector& Blocks); + Region(LoopGraph* loop, const std::vector& Blocks); Region* getHeader() { return header; } - unordered_set& getBasickBlocks() + std::unordered_set& getBasickBlocks() { return basickBlocks; } @@ -63,12 +61,12 @@ class Region: public SAPFOR::BasicBlock { { basickBlocks.insert(region); } - unordered_set getPrevRegions() + std::unordered_set getPrevRegions() { return prevRegions; } - unordered_set getNextRegions() + std::unordered_set getNextRegions() { return nextRegions; } @@ -95,7 +93,7 @@ class Region: public SAPFOR::BasicBlock { nextRegions.insert(source); } - unordered_set getSubRegions() + std::unordered_set 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 subRegions, basickBlocks; + std::unordered_set subRegions, basickBlocks; /*next Region which is BB for current BB Region*/ - unordered_set nextRegions; + std::unordered_set nextRegions; /*prev Regions which is BBs for current BB Region*/ - unordered_set prevRegions; + std::unordered_set prevRegions; Region* header; }; void Collapse(Region* region); -void FindPrivateArrays(map>& loopGraph, map>& FullIR); -void GetDimensionInfo(LoopGraph* loop, map>>& loopDimensionsInfo, int level); -pair> GetBasicBlocksForLoop(LoopGraph* loop, vector blocks); +std::map FindPrivateArrays(std::map>& loopGraph, std::map>& FullIR); +void GetDimensionInfo(LoopGraph* loop, std::map>>& loopDimensionsInfo, int level); +std::pair> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector blocks); diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index b7e80b8..c106f6a 100644 --- a/src/Sapfor.cpp +++ b/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 diff --git a/src/Sapfor.h b/src/Sapfor.h index b7f01d1..2ed5a83 100644 --- a/src/Sapfor.h +++ b/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"; } diff --git a/src/Utils/PassManager.h b/src/Utils/PassManager.h index 78f4170..dad0a52 100644 --- a/src/Utils/PassManager.h +++ b/src/Utils/PassManager.h @@ -316,6 +316,8 @@ void InitPassesDependencies(map> &passDepsIn, set 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, From 11e9fab482799ac5fe830e7b88068be217a49789 Mon Sep 17 00:00:00 2001 From: Oleg Nikitin Date: Tue, 27 May 2025 02:25:39 +0300 Subject: [PATCH 07/22] change file structure --- CMakeLists.txt | 6 +- src/CFGraph/IR.cpp | 12 +- src/PrivateAnalyzer/private_arrays_search.cpp | 725 ++---------------- src/PrivateAnalyzer/private_arrays_search.h | 111 +-- src/PrivateAnalyzer/range_structures.cpp | 317 ++++++++ src/PrivateAnalyzer/range_structures.h | 36 + src/PrivateAnalyzer/region.cpp | 268 +++++++ src/PrivateAnalyzer/region.h | 60 ++ src/Utils/PassManager.h | 2 +- 9 files changed, 744 insertions(+), 793 deletions(-) create mode 100644 src/PrivateAnalyzer/range_structures.cpp create mode 100644 src/PrivateAnalyzer/range_structures.h create mode 100644 src/PrivateAnalyzer/region.cpp create mode 100644 src/PrivateAnalyzer/region.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 1b0f054..145d672 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -115,7 +115,11 @@ set(OMEGA src/SageAnalysisTool/OmegaForSage/add-assert.cpp set(PRIV src/PrivateAnalyzer/private_analyzer.cpp src/PrivateAnalyzer/private_analyzer.h src/PrivateAnalyzer/private_arrays_search.cpp - src/PrivateAnalyzer/private_arrays_search.h) + src/PrivateAnalyzer/private_arrays_search.h + src/PrivateAnalyzer/range_structures.cpp + src/PrivateAnalyzer/range_structures.h + src/PrivateAnalyzer/region.cpp + src/PrivateAnalyzer/region.h) set(FDVM ${fdvm_sources}/acc.cpp ${fdvm_sources}/acc_across.cpp diff --git a/src/CFGraph/IR.cpp b/src/CFGraph/IR.cpp index 5c8bd0c..6ead0e4 100644 --- a/src/CFGraph/IR.cpp +++ b/src/CFGraph/IR.cpp @@ -395,7 +395,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector& if (ex) { const int var = ex->variant(); - if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // îáðàùåíèå ê ïåðåìåííîé + if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // ��������� � ���������� { if (var == CONST_REF) { @@ -450,7 +450,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector& return arg1; auto reg = isLeft ? NULL : createRegister(); - Instruction* instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(numArgs), isLeft ? isLeft : reg); + Instruction* instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(numArgs), isLeft ? isLeft : reg, NULL, ex); blocks.push_back(new IR_Block(instr)); return reg; } @@ -485,7 +485,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector& auto arg1 = arrayRef ? arrayRef : createArrayArg(ref, blocks, func, numArgs, commonVars); auto reg = isLeft ? NULL : createRegister(); - instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(1), isLeft ? isLeft : reg); + instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(1), isLeft ? isLeft : reg, NULL, ex); blocks.push_back(new IR_Block(instr)); return reg; } @@ -602,7 +602,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector& { if (returnReg == NULL) { - Instruction* instr = new Instruction(CFG_OP::LOAD, arg, NULL, reg); + Instruction* instr = new Instruction(CFG_OP::LOAD, arg, NULL, reg, NULL, ex); blocks.push_back(new IR_Block(instr)); } else @@ -1572,7 +1572,7 @@ vector buildIR(SgStatement* function, const FuncInfo* func, const vec else findReturn(0, blocks.size(), blocks, blocks.back()->getNumber()); - // äîáàâëåíèå ñâÿçåé ïî GOTO è ïåðåõîäàì + // ���������� ������ �� GOTO � ��������� for (int z = 0; z < blocks.size(); ++z) { auto op = blocks[z]->getInstruction()->getOperation(); @@ -1592,7 +1592,7 @@ vector buildIR(SgStatement* function, const FuncInfo* func, const vec blocks[z]->setJump(it->second); - // çàìåíèì ìåòêó íà íîìåð èíñòðóêöèè + // ������� ����� �� ����� ���������� arg->setValue(to_string(it->second->getNumber())); arg->setType(CFG_ARG_TYPE::INSTR); } diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index 4461d94..c603178 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -7,553 +7,19 @@ #include #include "private_arrays_search.h" +#include "range_structures.h" +#include "region.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*/ -pair> GetBasicBlocksForLoop(const LoopGraph* loop, const vector blocks) -{ - unordered_set 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& 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& loopForIndex) { - unordered_set 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 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 index_vars; - vector 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 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> coefsForDims; - for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i) - { - const vector& coefs = getAttributes(ref->subscript(i), set{ INT_VAL }); - if (coefs.size() == 1) - { - const pair coef(coefs[0][0], coefs[0][1]); - coefsForDims.push_back(coef); - } - - } - cout << coefsForDims.size() << endl; - - 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 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 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 DimensionDifference(const ArrayDimension& dim1, const ArrayDimension& dim2) -{ - ArrayDimension* intersection = DimensionIntersection(dim1, dim2); - if (!intersection) - { - return {dim1}; - } - vector 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 DimensionUnion(const ArrayDimension& dim1, const ArrayDimension& dim2) -{ - vector res; - ArrayDimension* inter = DimensionIntersection(dim1, dim2); - if(!inter) - { - return { dim1, dim2 }; - } - res.push_back(*inter); - delete(inter); - vector 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 ElementsIntersection(const vector& firstElement, const vector& 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 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> ElementsDifference(const vector& firstElement, - const vector& secondElement) -{ - if(firstElement.empty() || secondElement.empty()) { - return {}; - } - vector intersection = ElementsIntersection(firstElement, secondElement); - vector> 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 firstCopy = firstElement; - for(const auto& range: dimDiff) - { - firstCopy[i] = range; - result.push_back(firstCopy); - } - } - } - return result; -} - -static void ElementsUnion(const vector& firstElement, const vector& secondElement, - vector>& lc, vector>& rc, - vector& 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& element, vector>& result) const{ - vector> 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& element) const -{ - vector> tails; - FindUncovered(element, tails); - return !tails.empty(); -} - -void AccessingSet::FindCoveredBy(const vector& element, vector>& result) const -{ - for(const auto& currentElement: allElements) - { - auto intersection = ElementsIntersection(element, currentElement); - if(!intersection.empty()) { - result.push_back(intersection); - } - } -} - -vector> AccessingSet::GetElements() const -{ - return allElements; -} - -void AccessingSet::Insert(const vector& element) -{ - vector> tails; - FindUncovered(element, tails); - allElements.insert(allElements.end(), tails.begin(), tails.end()); -} - -AccessingSet AccessingSet::Union(const AccessingSet& source) { - AccessingSet result; - for(auto& element: source.GetElements()) { - result.Insert(element); - } - return result; -} - -AccessingSet AccessingSet::Intersect(const AccessingSet& secondSet) const -{ - vector> result; - for(const auto& element: allElements) - { - if(secondSet.ContainsElement(element)) - { - result.push_back(element); - } - else - { - vector> 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> result; - for (const auto& element : intersection.GetElements()) - { - vector> current_uncovered; - uncovered.FindUncovered(element, current_uncovered); - uncovered = AccessingSet(current_uncovered); - } - return uncovered; -} - -static bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs) -{ - return !(lhs.start == rhs.start && lhs.step == rhs.step && lhs.tripCount == rhs.tripCount); -} - - -static bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs) -{ - for (size_t i = 0; i < lhs.allElements.size(); i++) - { - for (size_t j = 0; j < lhs.allElements[i].size(); j++) - { - if (lhs.allElements[i][j] != rhs.allElements[i][j]) - { - return true; - } - } - } - return false; -} - -static bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs) -{ - if(lhs.size() != rhs.size()) - { - return true; - } - for(auto& [key, value]: lhs) - { - if(rhs.find(key) == rhs.end()) - { - return true; - } - } - return false; -} - void Collapse(Region* region) { if (region->getBasickBlocks().empty()) return; - else - { - cout << region->getBasickBlocks().size(); - } + for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out) { for (Region* byBlock : region->getBasickBlocks()) @@ -592,71 +58,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& bbToRegion, const unordered_set& blockSet) -{ - for (SAPFOR::BasicBlock* block : blockSet) - { - for (SAPFOR::BasicBlock* nextBlock : block->getNext()) - { - if (bbToRegion.find(nextBlock) != bbToRegion.end()) - { - bbToRegion[block]->addNextRegion(bbToRegion[nextBlock]); - } - } - for (SAPFOR::BasicBlock* prevBlock : block->getPrev()) - { - if (bbToRegion.find(prevBlock) != bbToRegion.end()) - { - bbToRegion[block]->addPrevRegion(bbToRegion[prevBlock]); - } - } - } -} - -static Region* CreateSubRegion(LoopGraph* loop, const vector& Blocks, const unordered_map& bbToRegion) -{ - 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)); - } - return region; -} - -Region::Region(LoopGraph* loop, const vector& Blocks) -{ - auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); - unordered_map 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); - //create subRegions - for (LoopGraph* childLoop : loop->children) - { - subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion)); - } } static void SolveDataFlowIteratively(Region* DFG) @@ -666,31 +67,56 @@ static void SolveDataFlowIteratively(Region* DFG) { Region* b = *worklist.begin(); ArrayAccessingIndexes newIn; + bool flagFirst = true; for (Region* prevBlock : b->getPrevRegions()) { - for (const auto& [arrayName, accessSet] : prevBlock->array_out) + if (flagFirst) { - 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_def) - { - if (newOut.find(arrayName) != newOut.end()) - { - newOut[arrayName] = b->array_def[arrayName].Union(b->array_in[arrayName]); + newIn = prevBlock->array_out; + flagFirst = false; } else { - newOut[arrayName] = accessSet; + if (prevBlock->array_out.empty()) + { + newIn.clear(); + continue; + } + for (const auto& [arrayName, accessSet] : prevBlock->array_out) + { + if (newIn.find(arrayName) != newIn.end()) + { + newIn[arrayName] = newIn[arrayName].Intersect(accessSet); + } + else + { + newIn[arrayName] = AccessingSet(); + } + } + } + } + b->array_in = move(newIn); + ArrayAccessingIndexes newOut; + if (b->array_def.empty()) + { + newOut = b->array_in; + } + else if (b->array_in.empty()) + { + newOut = b->array_def; + } + else + { + for (auto& [arrayName, accessSet] : b->array_def) + { + if (newOut.find(arrayName) != newOut.end()) + { + newOut[arrayName] = b->array_def[arrayName].Union(b->array_in[arrayName]); + } + else + { + newOut[arrayName] = accessSet; + } } } /* can not differ */ @@ -704,18 +130,18 @@ static void SolveDataFlowIteratively(Region* DFG) } } while (!worklist.empty()); - cout << "solveDFIt\n"; } static void SolveDataFlow(Region* DFG) { + if (!DFG) + return; SolveDataFlowIteratively(DFG); for (Region* subRegion : DFG->getSubRegions()) { SolveDataFlow(subRegion); } Collapse(DFG); - cout << "SolveDF\n"; } map FindPrivateArrays(map> &loopGraph, map>& FullIR) @@ -727,17 +153,6 @@ map FindPrivateArrays(mapgetNumber() == 4) - { - GetDefUseArray(bb, loop, def, use); - return {}; - } - } - // Region* loopRegion = new Region(loop, blocks); SolveDataFlow(loopRegion); result[loop] = loopRegion->array_priv; @@ -745,47 +160,5 @@ map FindPrivateArrays(map A = { {1, 1, 2}, {0, 1, 6} }; - vector B = { {0, 1, 6}, {2, 1, 2} }; - vector C = { {1, 1, 2}, {2, 1, 2} }; return result; } - -void GetDimensionInfo(LoopGraph* loop, map>>& loopDimensionsInfo, int level) -{ - cout << "line_num: " << loop->lineNum << endl; - for (const auto& writeOpPairs : loop->writeOpsForLoop) - { - vector> 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); - } - } -} diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index cc26f78..1b8dfdd 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -4,118 +4,11 @@ #include #include +#include "range_structures.h" +#include "region.h" #include "../GraphLoop/graph_loops.h" #include "../CFGraph/CFGraph.h" - -struct ArrayDimension -{ - uint64_t start, step, tripCount; -}; - -class AccessingSet { - private: - std::vector> allElements; - - public: - AccessingSet(std::vector> input) : allElements(input) {}; - AccessingSet() {}; - std::vector> GetElements() const; - void Insert(const std::vector& element); - AccessingSet Union(const AccessingSet& source); - AccessingSet Intersect(const AccessingSet& secondSet) const; - AccessingSet Diff(const AccessingSet& secondSet) const; - bool ContainsElement(const std::vector& element) const; - void FindCoveredBy(const std::vector& element, std::vector>& result) const; - void FindUncovered(const std::vector& element, std::vector>& result) const; - friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs); -}; - -using ArrayAccessingIndexes = std::map; - -class Region: public SAPFOR::BasicBlock { - public: - Region() - { - header = nullptr; - } - - Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block) - { - header = nullptr; - } - - Region(LoopGraph* loop, const std::vector& Blocks); - - Region* getHeader() - { - return header; - } - - std::unordered_set& getBasickBlocks() - { - return basickBlocks; - } - - void addBasickBlocks(Region* region) - { - basickBlocks.insert(region); - } - std::unordered_set getPrevRegions() - { - return prevRegions; - } - - std::unordered_set getNextRegions() - { - return nextRegions; - } - - void addPrevRegion(Region* region) - { - prevRegions.insert(region); - } - - void addNextRegion(Region* region) - { - nextRegions.insert(region); - } - - void replaceInPrevRegions(Region* source, Region* destination) - { - prevRegions.erase(destination); - prevRegions.insert(source); - } - - void replaceInNextRegions(Region* source, Region* destination) - { - nextRegions.erase(destination); - nextRegions.insert(source); - } - - std::unordered_set getSubRegions() - { - return subRegions; - } - - void addSubRegions(Region* region) - { - subRegions.insert(region); - } - - ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv; - - private: - std::unordered_set subRegions, basickBlocks; - /*next Region which is BB for current BB Region*/ - std::unordered_set nextRegions; - /*prev Regions which is BBs for current BB Region*/ - std::unordered_set prevRegions; - Region* header; -}; - - void Collapse(Region* region); std::map FindPrivateArrays(std::map>& loopGraph, std::map>& FullIR); -void GetDimensionInfo(LoopGraph* loop, std::map>>& loopDimensionsInfo, int level); std::pair> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector blocks); diff --git a/src/PrivateAnalyzer/range_structures.cpp b/src/PrivateAnalyzer/range_structures.cpp new file mode 100644 index 0000000..618fcfa --- /dev/null +++ b/src/PrivateAnalyzer/range_structures.cpp @@ -0,0 +1,317 @@ +#include +#include +#include +#include +#include + +#include "range_structures.h" + +using namespace std; + +static vector 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 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 DimensionDifference(const ArrayDimension& dim1, const ArrayDimension& dim2) +{ + ArrayDimension* intersection = DimensionIntersection(dim1, dim2); + if (!intersection) + { + return { dim1 }; + } + vector 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 DimensionUnion(const ArrayDimension& dim1, const ArrayDimension& dim2) +{ + vector res; + ArrayDimension* inter = DimensionIntersection(dim1, dim2); + if (!inter) + { + return { dim1, dim2 }; + } + res.push_back(*inter); + delete(inter); + vector 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 ElementsIntersection(const vector& firstElement, const vector& 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 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> ElementsDifference(const vector& firstElement, + const vector& secondElement) +{ + if (firstElement.empty() || secondElement.empty()) { + return {}; + } + vector intersection = ElementsIntersection(firstElement, secondElement); + vector> 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 firstCopy = firstElement; + for (const auto& range : dimDiff) + { + firstCopy[i] = range; + result.push_back(firstCopy); + } + } + } + return result; +} + +static void ElementsUnion(const vector& firstElement, const vector& secondElement, + vector>& lc, vector>& rc, + vector& 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& element, vector>& result) const { + vector> 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& element) const +{ + vector> tails; + FindUncovered(element, tails); + return !tails.empty(); +} + +void AccessingSet::FindCoveredBy(const vector& element, vector>& result) const +{ + for (const auto& currentElement : allElements) + { + auto intersection = ElementsIntersection(element, currentElement); + if (!intersection.empty()) { + result.push_back(intersection); + } + } +} + +vector> AccessingSet::GetElements() const { return allElements; } + +void AccessingSet::Insert(const vector& element) +{ + vector> tails; + FindUncovered(element, tails); + allElements.insert(allElements.end(), tails.begin(), tails.end()); +} + +AccessingSet AccessingSet::Union(const AccessingSet& source) { + AccessingSet result; + for (auto& element : source.GetElements()) { + result.Insert(element); + } + for (auto& element : allElements) + { + result.Insert(element); + } + return result; +} + +AccessingSet AccessingSet::Intersect(const AccessingSet& secondSet) const +{ + vector> result; + if (secondSet.GetElements().empty() || this->allElements.empty()) + return AccessingSet(result); + for (const auto& element : allElements) + { + if (secondSet.ContainsElement(element)) + { + result.push_back(element); + } + else + { + vector> 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 +{ + if (secondSet.GetElements().empty() || allElements.empty()) + return *this; + AccessingSet intersection = this->Intersect(secondSet); + AccessingSet uncovered = *this; + vector> result; + for (const auto& element : intersection.GetElements()) + { + vector> current_uncovered; + uncovered.FindUncovered(element, current_uncovered); + uncovered = AccessingSet(current_uncovered); + } + return uncovered; +} + +bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs) +{ + return !(lhs.start == rhs.start && lhs.step == rhs.step && lhs.tripCount == rhs.tripCount); +} + + +bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs) +{ + for (size_t i = 0; i < lhs.allElements.size(); i++) + { + for (size_t j = 0; j < lhs.allElements[i].size(); j++) + { + if (lhs.allElements[i][j] != rhs.allElements[i][j]) + { + return true; + } + } + } + return false; +} + +bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs) +{ + if (lhs.size() != rhs.size()) + { + return true; + } + for (auto& [key, value] : lhs) + { + if (rhs.find(key) == rhs.end()) + { + return true; + } + } + return false; +} diff --git a/src/PrivateAnalyzer/range_structures.h b/src/PrivateAnalyzer/range_structures.h new file mode 100644 index 0000000..004f73e --- /dev/null +++ b/src/PrivateAnalyzer/range_structures.h @@ -0,0 +1,36 @@ +#pragma once + +#include +#include +#include +#include + +struct ArrayDimension +{ + uint64_t start, step, tripCount; +}; + +class AccessingSet { +private: + std::vector> allElements; + +public: + AccessingSet(std::vector> input) : allElements(input) {}; + AccessingSet() {}; + AccessingSet(const AccessingSet& a) { allElements = a.GetElements(); }; + std::vector> GetElements() const; + void Insert(const std::vector& element); + AccessingSet Union(const AccessingSet& source); + AccessingSet Intersect(const AccessingSet& secondSet) const; + AccessingSet Diff(const AccessingSet& secondSet) const; + bool ContainsElement(const std::vector& element) const; + void FindCoveredBy(const std::vector& element, std::vector>& result) const; + void FindUncovered(const std::vector& element, std::vector>& result) const; + friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs); +}; + +using ArrayAccessingIndexes = std::map; + +bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs); +bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs); +bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs); \ No newline at end of file diff --git a/src/PrivateAnalyzer/region.cpp b/src/PrivateAnalyzer/region.cpp new file mode 100644 index 0000000..64375d9 --- /dev/null +++ b/src/PrivateAnalyzer/region.cpp @@ -0,0 +1,268 @@ +#include +#include +#include +#include +#include +#include + +#include "range_structures.h" +#include "region.h" + +#include "../Utils/SgUtils.h" + +using namespace std; + +static bool isParentStmt(SgStatement* stmt, SgStatement* parent) +{ + for (; stmt; stmt = stmt->controlParent()) + if (stmt == parent) + { + return true; + } + return false; +} + +/*returns head block and loop*/ +pair> GetBasicBlocksForLoop(const LoopGraph* loop, const vector blocks) +{ + unordered_set 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& 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& loopForIndex) { + unordered_set 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 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 index_vars; + vector 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 accessPoint(n); + + auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression()); + + vector> coefsForDims; + for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i) + { + const vector& coefs = getAttributes(ref->subscript(i), set{ INT_VAL }); + if (coefs.size() == 1) + { + const pair 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 }; + } + 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 void SetConnections(unordered_map& bbToRegion, const unordered_set& blockSet) +{ + for (SAPFOR::BasicBlock* block : blockSet) + { + for (SAPFOR::BasicBlock* nextBlock : block->getNext()) + { + if (bbToRegion.find(nextBlock) != bbToRegion.end()) + { + bbToRegion[block]->addNextRegion(bbToRegion[nextBlock]); + } + } + for (SAPFOR::BasicBlock* prevBlock : block->getPrev()) + { + if (bbToRegion.find(prevBlock) != bbToRegion.end()) + { + bbToRegion[block]->addPrevRegion(bbToRegion[prevBlock]); + } + } + } +} + +static Region* CreateSubRegion(LoopGraph* loop, const vector& Blocks, const unordered_map& bbToRegion) +{ + Region* region = new Region; + auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); + if (bbToRegion.find(header) != bbToRegion.end()) + { + region->setHeader(bbToRegion.at(header)); + } + else + { + return NULL; + } + for (SAPFOR::BasicBlock* block : blockSet) + { + if (bbToRegion.find(block) != bbToRegion.end()) + { + region->addBasickBlocks(bbToRegion.at(block)); + } + } + for (LoopGraph* childLoop : loop->children) + { + region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion)); + } + cout << header << endl; + return region; +} + +Region::Region(LoopGraph* loop, const vector& Blocks) +{ + auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks); + unordered_map bbToRegion; + for (auto poiner : blockSet) + { + bbToRegion[poiner] = new Region(*poiner); + this->basickBlocks.insert(bbToRegion[poiner]); + GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use); + + } + this->header = bbToRegion[header]; + SetConnections(bbToRegion, blockSet); + //create subRegions + for (LoopGraph* childLoop : loop->children) + { + subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion)); + } +} diff --git a/src/PrivateAnalyzer/region.h b/src/PrivateAnalyzer/region.h new file mode 100644 index 0000000..5e85900 --- /dev/null +++ b/src/PrivateAnalyzer/region.h @@ -0,0 +1,60 @@ +#pragma once + +#include +#include +#include +#include + +#include "../GraphLoop/graph_loops.h" +#include "../CFGraph/CFGraph.h" + +class Region : public SAPFOR::BasicBlock { +public: + Region() { header = nullptr; } + + Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block) { header = nullptr; } + + Region(LoopGraph* loop, const std::vector& Blocks); + + Region* getHeader() { return header; } + + void setHeader(Region* region) { header = region; } + + std::unordered_set& getBasickBlocks() { return basickBlocks; } + + void addBasickBlocks(Region* region) { basickBlocks.insert(region); } + + const std::unordered_set& getPrevRegions() { return prevRegions; } + + std::unordered_set getNextRegions() { return nextRegions; } + + void addPrevRegion(Region* region) { prevRegions.insert(region); } + + void addNextRegion(Region* region) { nextRegions.insert(region); } + + void replaceInPrevRegions(Region* source, Region* destination) + { + prevRegions.erase(destination); + prevRegions.insert(source); + } + + void replaceInNextRegions(Region* source, Region* destination) + { + nextRegions.erase(destination); + nextRegions.insert(source); + } + + std::unordered_set getSubRegions() { return subRegions; } + + void addSubRegions(Region* region) { subRegions.insert(region); } + + ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv; + +private: + std::unordered_set subRegions, basickBlocks; + /*next Region which is BB for current BB Region*/ + std::unordered_set nextRegions; + /*prev Regions which is BBs for current BB Region*/ + std::unordered_set prevRegions; + Region* header; +}; diff --git a/src/Utils/PassManager.h b/src/Utils/PassManager.h index dad0a52..482b949 100644 --- a/src/Utils/PassManager.h +++ b/src/Utils/PassManager.h @@ -316,7 +316,7 @@ void InitPassesDependencies(map> &passDepsIn, set list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE); - list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH }) <= Pass(FIND_PRIVATE_ARRAYS); + list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= 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, From bbb9823f1d78c6fb86e329beffd1aceea8daa6b0 Mon Sep 17 00:00:00 2001 From: Alexander Date: Fri, 30 May 2025 12:20:08 +0300 Subject: [PATCH 08/22] updated submodule --- projects/dvm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/projects/dvm b/projects/dvm index 6a86c96..3a567d7 160000 --- a/projects/dvm +++ b/projects/dvm @@ -1 +1 @@ -Subproject commit 6a86c96abec37282bc2aaa8f11b047d1d3f0b84e +Subproject commit 3a567d7582d01ec80d026a320415820e32e82c7c From f7a78f96265cff4aa906bcbef5fa15bad955b944 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Fri, 30 May 2025 12:29:35 +0300 Subject: [PATCH 09/22] restored messages --- projects/dvm | 2 +- src/CFGraph/IR.cpp | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/projects/dvm b/projects/dvm index 3a567d7..6a86c96 160000 --- a/projects/dvm +++ b/projects/dvm @@ -1 +1 @@ -Subproject commit 3a567d7582d01ec80d026a320415820e32e82c7c +Subproject commit 6a86c96abec37282bc2aaa8f11b047d1d3f0b84e diff --git a/src/CFGraph/IR.cpp b/src/CFGraph/IR.cpp index 6ead0e4..a46226b 100644 --- a/src/CFGraph/IR.cpp +++ b/src/CFGraph/IR.cpp @@ -395,7 +395,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector& if (ex) { const int var = ex->variant(); - if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // ��������� � ���������� + if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // variable reference { if (var == CONST_REF) { @@ -1572,7 +1572,7 @@ vector buildIR(SgStatement* function, const FuncInfo* func, const vec else findReturn(0, blocks.size(), blocks, blocks.back()->getNumber()); - // ���������� ������ �� GOTO � ��������� + // adding links by GOTO and jumps for (int z = 0; z < blocks.size(); ++z) { auto op = blocks[z]->getInstruction()->getOperation(); @@ -1592,7 +1592,7 @@ vector buildIR(SgStatement* function, const FuncInfo* func, const vec blocks[z]->setJump(it->second); - // ������� ����� �� ����� ���������� + // replacing the label with the instruction number arg->setValue(to_string(it->second->getNumber())); arg->setType(CFG_ARG_TYPE::INSTR); } From 8dcbd587ec9ecd3a40f43b1959c01aab6826482d Mon Sep 17 00:00:00 2001 From: ALEXks Date: Fri, 30 May 2025 12:31:19 +0300 Subject: [PATCH 10/22] fixed submodule --- projects/dvm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/projects/dvm b/projects/dvm index 6a86c96..3a567d7 160000 --- a/projects/dvm +++ b/projects/dvm @@ -1 +1 @@ -Subproject commit 6a86c96abec37282bc2aaa8f11b047d1d3f0b84e +Subproject commit 3a567d7582d01ec80d026a320415820e32e82c7c From 26e36bed46687afee96f93b7863c54b7c48afd04 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Fri, 30 May 2025 12:45:05 +0300 Subject: [PATCH 11/22] fixed code style --- src/PrivateAnalyzer/private_arrays_search.cpp | 41 ++----- src/PrivateAnalyzer/private_arrays_search.h | 6 +- src/PrivateAnalyzer/range_structures.cpp | 81 +++++-------- src/PrivateAnalyzer/range_structures.h | 8 +- src/PrivateAnalyzer/region.cpp | 106 +++++++----------- src/Sapfor.cpp | 2 - 6 files changed, 86 insertions(+), 158 deletions(-) diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index c603178..985baf6 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -39,25 +39,17 @@ void Collapse(Region* region) } 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 (auto& [arrayName, arrayRanges] : useUnion) + region->array_priv[arrayName] = useUnion[arrayName].Diff(region->array_use[arrayName]); + for (Region* prevBlock : region->getHeader()->getPrevRegions()) - { prevBlock->replaceInNextRegions(region, region->getHeader()); - } + for (Region* nextBlock : region->getHeader()->getNextRegions()) - { nextBlock->replaceInPrevRegions(region, region->getHeader()); - } } static void SolveDataFlowIteratively(Region* DFG) @@ -85,49 +77,35 @@ 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] = AccessingSet(); - } } } } + b->array_in = move(newIn); ArrayAccessingIndexes newOut; - if (b->array_def.empty()) - { + if (b->array_def.empty()) newOut = b->array_in; - } else if (b->array_in.empty()) - { newOut = b->array_def; - } else { for (auto& [arrayName, accessSet] : b->array_def) { 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) - { b->array_out = newOut; - } else - { worklist.erase(b); - } } while (!worklist.empty()); } @@ -136,11 +114,10 @@ static void SolveDataFlow(Region* DFG) { if (!DFG) return; + SolveDataFlowIteratively(DFG); for (Region* subRegion : DFG->getSubRegions()) - { SolveDataFlow(subRegion); - } Collapse(DFG); } diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index 1b8dfdd..2faaa27 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -1,8 +1,8 @@ #pragma once -#include -#include -#include +#include +#include +#include #include "range_structures.h" #include "region.h" diff --git a/src/PrivateAnalyzer/range_structures.cpp b/src/PrivateAnalyzer/range_structures.cpp index 618fcfa..9a2f437 100644 --- a/src/PrivateAnalyzer/range_structures.cpp +++ b/src/PrivateAnalyzer/range_structures.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include +#include +#include +#include #include #include "range_structures.h" @@ -17,9 +17,7 @@ static vector FindParticularSolution(const ArrayDimension& dim1, const { uint64_t rightPart = dim2.start + j * dim2.step; if (leftPart == rightPart) - { return { i, j }; - } } } return {}; @@ -30,9 +28,8 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A { vector 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 */ @@ -46,9 +43,8 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A 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 }; @@ -60,15 +56,13 @@ static vector DimensionDifference(const ArrayDimension& dim1, co { ArrayDimension* intersection = DimensionIntersection(dim1, dim2); if (!intersection) - { return { dim1 }; - } + vector result; /* add the part before intersection */ - if (dim1.start < intersection->start) - { + 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; @@ -103,11 +97,11 @@ static vector DimensionUnion(const ArrayDimension& dim1, const A vector res; ArrayDimension* inter = DimensionIntersection(dim1, dim2); if (!inter) - { return { dim1, dim2 }; - } + res.push_back(*inter); delete(inter); + vector diff1, diff2; diff1 = DimensionDifference(dim1, dim2); diff2 = DimensionDifference(dim2, dim1); @@ -118,29 +112,24 @@ static vector DimensionUnion(const ArrayDimension& dim1, const A static vector ElementsIntersection(const vector& firstElement, const vector& secondElement) { - if (firstElement.empty() || secondElement.empty()) { + 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()) { + if (FindParticularSolution(firstElement[i], secondElement[i]).empty()) return {}; - } - } + vector 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; } @@ -148,15 +137,14 @@ static vector ElementsIntersection(const vector& static vector> ElementsDifference(const vector& firstElement, const vector& secondElement) { - if (firstElement.empty() || secondElement.empty()) { + if (firstElement.empty() || secondElement.empty()) return {}; - } + vector intersection = ElementsIntersection(firstElement, secondElement); vector> result; if (intersection.empty()) - { return { firstElement }; - } + for (int i = 0; i < firstElement.size(); i++) { auto dimDiff = DimensionDifference(firstElement[i], secondElement[i]); @@ -212,9 +200,8 @@ void AccessingSet::FindCoveredBy(const vector& element, vector& element) AccessingSet AccessingSet::Union(const AccessingSet& source) { AccessingSet result; - for (auto& element : source.GetElements()) { + for (auto& element : source.GetElements()) result.Insert(element); - } + for (auto& element : allElements) - { result.Insert(element); - } return result; } @@ -244,22 +229,20 @@ AccessingSet AccessingSet::Intersect(const AccessingSet& secondSet) const vector> result; if (secondSet.GetElements().empty() || this->allElements.empty()) return AccessingSet(result); + for (const auto& element : allElements) { if (secondSet.ContainsElement(element)) - { result.push_back(element); - } else { vector> coveredBy; secondSet.FindCoveredBy(element, coveredBy); if (!coveredBy.empty()) - { result.insert(result.end(), coveredBy.begin(), coveredBy.end()); - } } } + return AccessingSet(result); } @@ -267,6 +250,7 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const { if (secondSet.GetElements().empty() || allElements.empty()) return *this; + AccessingSet intersection = this->Intersect(secondSet); AccessingSet uncovered = *this; vector> result; @@ -288,30 +272,21 @@ bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs) bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs) { for (size_t i = 0; i < lhs.allElements.size(); i++) - { for (size_t j = 0; j < lhs.allElements[i].size(); j++) - { if (lhs.allElements[i][j] != rhs.allElements[i][j]) - { return true; - } - } - } + return false; } bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs) { if (lhs.size() != rhs.size()) - { return true; - } + for (auto& [key, value] : lhs) - { if (rhs.find(key) == rhs.end()) - { return true; - } - } + return false; } diff --git a/src/PrivateAnalyzer/range_structures.h b/src/PrivateAnalyzer/range_structures.h index 004f73e..257fbcf 100644 --- a/src/PrivateAnalyzer/range_structures.h +++ b/src/PrivateAnalyzer/range_structures.h @@ -1,9 +1,9 @@ #pragma once -#include -#include -#include -#include +#include +#include +#include +#include struct ArrayDimension { diff --git a/src/PrivateAnalyzer/region.cpp b/src/PrivateAnalyzer/region.cpp index 64375d9..dfe30b1 100644 --- a/src/PrivateAnalyzer/region.cpp +++ b/src/PrivateAnalyzer/region.cpp @@ -16,9 +16,8 @@ static bool isParentStmt(SgStatement* stmt, SgStatement* parent) { for (; stmt; stmt = stmt->controlParent()) if (stmt == parent) - { return true; - } + return false; } @@ -31,9 +30,8 @@ pair> GetBasicBlocksForL 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)) @@ -55,36 +53,39 @@ pair> GetBasicBlocksForL static void BuildLoopIndex(map& loopForIndex, LoopGraph* loop) { string index = loop->loopSymbol; loopForIndex[index] = loop; - for (const auto& childLoop : loop->children) { + + for (const auto& childLoop : loop->children) BuildLoopIndex(loopForIndex, childLoop); - } } static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map& loopForIndex) { unordered_set args = { block->getInstructions()[pos]->getInstruction()->getArg1() }; - for (int i = pos - 1; i >= 0; i--) { + for (int i = pos - 1; i >= 0; i--) + { SAPFOR::Argument* res = block->getInstructions()[i]->getInstruction()->getResult(); - if (res && args.find(res) != args.end()) { + 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) { + 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 { + else args.insert(arg1); - } } - if (arg2) { + + 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 { + else args.insert(arg2); - } } } } @@ -98,9 +99,9 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces for (int i = 0; i < instructions.size(); i++) { auto instruction = instructions[i]; - if (!instruction->getInstruction()->getArg1()) { + 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) @@ -109,13 +110,10 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces vector refPos; string array_name; if (operation == SAPFOR::CFG_OP::STORE) - { - array_name = instruction->getInstruction()->getArg1()->getValue(); - } + 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) { @@ -123,12 +121,12 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces refPos.push_back(j); j--; } + /*to choose correct dimension*/ int n = index_vars.size(); vector accessPoint(n); auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression()); - vector> coefsForDims; for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i) { @@ -147,52 +145,48 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces int currentVarPos = refPos.back(); pair currentCoefs = coefsForDims.back(); ArrayDimension current_dim; - if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST) { + 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) { + if (pos != -1) + { name = full_name.substr(pos + 1); - if (loopForIndex.find(name) != loopForIndex.end()) { - currentLoop = loopForIndex[name]; - } - else { + if (loopForIndex.find(name) != loopForIndex.end()) + currentLoop = loopForIndex[name]; + else return -1; - } } - else { + else + { name = FindIndexName(currentVarPos, block, loopForIndex); - if (name == "") { + if (name == "") return -1; - } - if (loopForIndex.find(name) != loopForIndex.end()) { - currentLoop = loopForIndex[name]; - } - else { + + 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 }; } + accessPoint[n - index_vars.size()] = current_dim; index_vars.pop_back(); refPos.pop_back(); coefsForDims.pop_back(); } - if (operation == SAPFOR::CFG_OP::STORE) - { + + if (operation == SAPFOR::CFG_OP::STORE) def[array_name].Insert(accessPoint); - } else - { use[array_name].Insert(accessPoint); - } } } return 0; @@ -204,19 +198,12 @@ static void SetConnections(unordered_map& bbToRegi for (SAPFOR::BasicBlock* block : blockSet) { for (SAPFOR::BasicBlock* nextBlock : block->getNext()) - { if (bbToRegion.find(nextBlock) != bbToRegion.end()) - { bbToRegion[block]->addNextRegion(bbToRegion[nextBlock]); - } - } + for (SAPFOR::BasicBlock* prevBlock : block->getPrev()) - { if (bbToRegion.find(prevBlock) != bbToRegion.end()) - { bbToRegion[block]->addPrevRegion(bbToRegion[prevBlock]); - } - } } } @@ -225,24 +212,17 @@ static Region* CreateSubRegion(LoopGraph* loop, const vectorsetHeader(bbToRegion.at(header)); - } + region->setHeader(bbToRegion.at(header)); else - { return NULL; - } + for (SAPFOR::BasicBlock* block : blockSet) - { if (bbToRegion.find(block) != bbToRegion.end()) - { region->addBasickBlocks(bbToRegion.at(block)); - } - } + for (LoopGraph* childLoop : loop->children) - { region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion)); - } + cout << header << endl; return region; } @@ -262,7 +242,5 @@ Region::Region(LoopGraph* loop, const vector& Blocks) SetConnections(bbToRegion, blockSet); //create subRegions for (LoopGraph* childLoop : loop->children) - { subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion)); - } } diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index 8583e19..9f5ac64 100644 --- a/src/Sapfor.cpp +++ b/src/Sapfor.cpp @@ -1030,9 +1030,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks); } else if (curr_regime == FIND_PRIVATE_ARRAYS) - { FindPrivateArrays(loopGraph, fullIR); - } else if (curr_regime == TEST_PASS) { //test pass From 72a1c1d8534421cc6a23066f7bcd0033b6cd234f Mon Sep 17 00:00:00 2001 From: ALEXks Date: Fri, 30 May 2025 13:00:40 +0300 Subject: [PATCH 12/22] fixed merge --- src/PrivateAnalyzer/range_structures.h | 1 + src/PrivateAnalyzer/region.h | 8 ++++---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/PrivateAnalyzer/range_structures.h b/src/PrivateAnalyzer/range_structures.h index 257fbcf..4b52f97 100644 --- a/src/PrivateAnalyzer/range_structures.h +++ b/src/PrivateAnalyzer/range_structures.h @@ -4,6 +4,7 @@ #include #include #include +#include struct ArrayDimension { diff --git a/src/PrivateAnalyzer/region.h b/src/PrivateAnalyzer/region.h index 5e85900..95121b2 100644 --- a/src/PrivateAnalyzer/region.h +++ b/src/PrivateAnalyzer/region.h @@ -1,9 +1,9 @@ #pragma once -#include -#include -#include -#include +#include +#include +#include +#include #include "../GraphLoop/graph_loops.h" #include "../CFGraph/CFGraph.h" From a2e6269508b7682c5fe9dbc163bff030557d8d33 Mon Sep 17 00:00:00 2001 From: Alexander Date: Mon, 2 Jun 2025 08:23:40 +0300 Subject: [PATCH 13/22] fix range stuctures --- src/PrivateAnalyzer/range_structures.cpp | 3 ++- src/PrivateAnalyzer/region.cpp | 7 ++++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/PrivateAnalyzer/range_structures.cpp b/src/PrivateAnalyzer/range_structures.cpp index 9a2f437..75f2779 100644 --- a/src/PrivateAnalyzer/range_structures.cpp +++ b/src/PrivateAnalyzer/range_structures.cpp @@ -184,7 +184,8 @@ void AccessingSet::FindUncovered(const vector& element, vectorsetHeader(bbToRegion.at(header)); else + { + printInternalError(convertFileName(__FILE__).c_str(), __LINE__); return NULL; + } for (SAPFOR::BasicBlock* block : blockSet) if (bbToRegion.find(block) != bbToRegion.end()) @@ -223,7 +229,6 @@ static Region* CreateSubRegion(LoopGraph* loop, const vectorchildren) region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion)); - cout << header << endl; return region; } From a0a401c42acba29e8c8fbcaaa7be21f011fa9578 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Mon, 2 Jun 2025 19:08:09 +0300 Subject: [PATCH 14/22] refactored transformation: added folders for each transformation --- CMakeLists.txt | 107 +++++++++--------- src/CFGraph/CFGraph.cpp | 4 +- src/CFGraph/IR.cpp | 6 +- src/CFGraph/RD_subst.cpp | 4 +- src/CFGraph/RD_subst.h | 2 +- .../directive_analyzer.cpp | 2 +- src/DirectiveProcessing/directive_creator.cpp | 6 +- .../directive_creator_base.cpp | 4 +- .../directive_omp_parser.cpp | 2 +- src/DirectiveProcessing/directive_parser.cpp | 2 +- src/DirectiveProcessing/insert_directive.cpp | 2 +- src/DirectiveProcessing/remote_access.cpp | 4 +- .../remote_access_base.cpp | 4 +- src/DirectiveProcessing/shadow.cpp | 6 +- .../spf_directive_preproc.cpp | 4 +- src/Distribution/Array.cpp | 2 +- src/Distribution/ArrayAnalysis.cpp | 2 +- src/Distribution/CreateDistributionDirs.cpp | 2 +- src/Distribution/Cycle.cpp | 2 +- src/Distribution/Distribution.cpp | 2 +- src/Distribution/DvmhDirective.cpp | 2 +- src/Distribution/DvmhDirectiveBase.cpp | 2 +- src/Distribution/GraphCSR.cpp | 2 +- src/DvmhRegions/DvmhRegionInserter.cpp | 2 +- src/DvmhRegions/DvmhRegionInserter.h | 2 +- src/DynamicAnalysis/createParallelRegions.cpp | 4 +- src/DynamicAnalysis/createParallelRegions.h | 2 +- src/DynamicAnalysis/gCov_parser.cpp | 2 +- src/DynamicAnalysis/gcov_info.cpp | 2 +- src/GraphCall/graph_calls.cpp | 4 +- src/GraphCall/graph_calls_base.cpp | 2 +- src/GraphLoop/graph_loops.cpp | 6 +- src/GraphLoop/graph_loops_base.cpp | 2 +- src/LoopAnalyzer/allocations_prepoc.cpp | 2 +- src/LoopAnalyzer/dep_analyzer.cpp | 2 +- src/LoopAnalyzer/loop_analyzer.cpp | 6 +- src/LoopAnalyzer/loop_analyzer.h | 2 +- src/ParallelizationRegions/ParRegions.cpp | 4 +- src/ParallelizationRegions/ParRegions_func.h | 2 +- .../expand_extract_reg.cpp | 2 +- .../resolve_par_reg_conflicts.cpp | 6 +- .../resolve_par_reg_conflicts.h | 2 +- src/Predictor/PredictScheme.cpp | 4 +- src/Predictor/PredictScheme.h | 2 +- src/PrivateAnalyzer/private_analyzer.cpp | 4 +- src/PrivateAnalyzer/private_analyzer.h | 2 +- src/ProjectManipulation/ConvertFiles.cpp | 2 +- src/ProjectManipulation/FileInfo.cpp | 2 +- src/ProjectManipulation/ParseFiles.cpp | 2 +- src/ProjectManipulation/PerfAnalyzer.cpp | 2 +- src/ProjectParameters/projectParameters.cpp | 4 +- src/SageAnalysisTool/defUse.cpp | 2 +- src/SageAnalysisTool/depGraph.cpp | 2 +- src/Sapfor.cpp | 42 ++++--- .../swap_array_dims.cpp | 0 .../{ => ArrayDimsSwapping}/swap_array_dims.h | 0 .../{ => CheckPoints}/checkpoints.cpp | 4 +- .../{ => CheckPoints}/checkpoints.h | 0 .../{ => ConvertToC}/convert_to_c.cpp | 2 +- .../{ => ConvertToC}/convert_to_c.h | 0 .../{ => DeadCodeRemoving}/dead_code.cpp | 0 .../{ => DeadCodeRemoving}/dead_code.h | 0 .../control_flow_graph_part.cpp | 2 +- .../expr_transform.cpp | 4 +- .../ExpressionSubstitution}/expr_transform.h | 2 +- .../uniq_call_chain_dup.cpp | 6 +- .../uniq_call_chain_dup.h | 2 +- .../FunctionInlining}/inliner.cpp | 4 +- .../FunctionInlining}/inliner.h | 0 .../function_purifying.cpp | 4 +- .../function_purifying.h | 0 .../fix_common_blocks.cpp | 0 .../{ => GlobalVariables}/fix_common_blocks.h | 2 +- .../{ => LoopCombining}/loops_combiner.cpp | 2 +- .../{ => LoopCombining}/loops_combiner.h | 0 .../enddo_loop_converter.cpp | 2 +- .../enddo_loop_converter.h | 0 .../{ => LoopNesting}/loop_transform.cpp | 2 +- .../{ => LoopNesting}/loop_transform.h | 0 .../{ => LoopSplitting}/loops_splitter.cpp | 2 +- .../{ => LoopSplitting}/loops_splitter.h | 0 .../{ => LoopUnrolling}/loops_unrolling.cpp | 0 .../{ => LoopUnrolling}/loops_unrolling.h | 0 .../private_removing.cpp | 4 +- .../private_removing.h | 0 .../private_arrays_resizing.cpp | 0 .../private_arrays_resizing.h | 0 .../RenameSymbols/rename_symbols.cpp | 2 +- .../RenameSymbols/rename_symbols.h | 0 .../replace_dist_arrays_in_io.cpp | 6 +- .../replace_dist_arrays_in_io.h | 2 +- .../set_implicit_none.cpp | 2 +- .../{ => SetImplicitNone}/set_implicit_none.h | 0 .../array_assign_to_loop.cpp | 4 +- .../array_assign_to_loop.h | 0 src/Utils/SgUtils.cpp | 4 +- src/Utils/SgUtils.h | 2 +- src/Utils/utils.cpp | 2 +- src/VerificationCode/CorrectVarDecl.cpp | 2 +- src/VerificationCode/IncludeChecker.cpp | 2 +- src/VerificationCode/StructureChecker.cpp | 2 +- src/VerificationCode/VerifySageStructures.cpp | 2 +- 102 files changed, 189 insertions(+), 188 deletions(-) rename src/Transformations/{ => ArrayDimsSwapping}/swap_array_dims.cpp (100%) rename src/Transformations/{ => ArrayDimsSwapping}/swap_array_dims.h (100%) rename src/Transformations/{ => CheckPoints}/checkpoints.cpp (97%) rename src/Transformations/{ => CheckPoints}/checkpoints.h (100%) rename src/Transformations/{ => ConvertToC}/convert_to_c.cpp (96%) rename src/Transformations/{ => ConvertToC}/convert_to_c.h (100%) rename src/Transformations/{ => DeadCodeRemoving}/dead_code.cpp (100%) rename src/Transformations/{ => DeadCodeRemoving}/dead_code.h (100%) rename src/{ExpressionTransform => Transformations/ExpressionSubstitution}/control_flow_graph_part.cpp (96%) rename src/{ExpressionTransform => Transformations/ExpressionSubstitution}/expr_transform.cpp (96%) rename src/{ExpressionTransform => Transformations/ExpressionSubstitution}/expr_transform.h (96%) rename src/Transformations/{ => FunctionDuplication}/uniq_call_chain_dup.cpp (96%) rename src/Transformations/{ => FunctionDuplication}/uniq_call_chain_dup.h (89%) rename src/{Inliner => Transformations/FunctionInlining}/inliner.cpp (97%) rename src/{Inliner => Transformations/FunctionInlining}/inliner.h (100%) rename src/Transformations/{ => FunctionPurifying}/function_purifying.cpp (97%) rename src/Transformations/{ => FunctionPurifying}/function_purifying.h (100%) rename src/Transformations/{ => GlobalVariables}/fix_common_blocks.cpp (100%) rename src/Transformations/{ => GlobalVariables}/fix_common_blocks.h (93%) rename src/Transformations/{ => LoopCombining}/loops_combiner.cpp (96%) rename src/Transformations/{ => LoopCombining}/loops_combiner.h (100%) rename src/Transformations/{ => LoopEndDoConverter}/enddo_loop_converter.cpp (96%) rename src/Transformations/{ => LoopEndDoConverter}/enddo_loop_converter.h (100%) rename src/Transformations/{ => LoopNesting}/loop_transform.cpp (96%) rename src/Transformations/{ => LoopNesting}/loop_transform.h (100%) rename src/Transformations/{ => LoopSplitting}/loops_splitter.cpp (97%) rename src/Transformations/{ => LoopSplitting}/loops_splitter.h (100%) rename src/Transformations/{ => LoopUnrolling}/loops_unrolling.cpp (100%) rename src/Transformations/{ => LoopUnrolling}/loops_unrolling.h (100%) rename src/Transformations/{ => PrivateArrayRemoving}/private_removing.cpp (97%) rename src/Transformations/{ => PrivateArrayRemoving}/private_removing.h (100%) rename src/Transformations/{ => PrivateArrayResizing}/private_arrays_resizing.cpp (100%) rename src/Transformations/{ => PrivateArrayResizing}/private_arrays_resizing.h (100%) rename src/{ => Transformations}/RenameSymbols/rename_symbols.cpp (96%) rename src/{ => Transformations}/RenameSymbols/rename_symbols.h (100%) rename src/Transformations/{ => ReplaceArraysInIO}/replace_dist_arrays_in_io.cpp (96%) rename src/Transformations/{ => ReplaceArraysInIO}/replace_dist_arrays_in_io.h (91%) rename src/Transformations/{ => SetImplicitNone}/set_implicit_none.cpp (96%) rename src/Transformations/{ => SetImplicitNone}/set_implicit_none.h (100%) rename src/Transformations/{ => VectorAssignToLoop}/array_assign_to_loop.cpp (97%) rename src/Transformations/{ => VectorAssignToLoop}/array_assign_to_loop.h (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 145d672..ba85c74 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -27,6 +27,13 @@ set(libpred_sources projects/libpredictor/src/) set(libpred_include projects/libpredictor/include/) include_directories(src) +include_directories(src/Utils) +include_directories(src/SgUtils) +include_directories(src/Distribution) +include_directories(src/GraphCall) +include_directories(src/GraphLoop) +include_directories(src/Transformations/ExpressionSubstitution) + #Sage lib includes include_directories(${fdvm_include}) include_directories(${sage_include_1}) @@ -154,40 +161,47 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp src/ParallelizationRegions/resolve_par_reg_conflicts.cpp src/ParallelizationRegions/resolve_par_reg_conflicts.h) -set(TR_DEAD_CODE src/Transformations/dead_code.cpp - src/Transformations/dead_code.h) -set(TR_CP src/Transformations/checkpoints.cpp - src/Transformations/checkpoints.h) -set(TR_VECTOR src/Transformations/array_assign_to_loop.cpp - src/Transformations/array_assign_to_loop.h) -set(TR_ENDDO_LOOP src/Transformations/enddo_loop_converter.cpp - src/Transformations/enddo_loop_converter.h) -set(TR_LOOP_NEST src/Transformations/loop_transform.cpp - src/Transformations/loop_transform.h) -set(TR_LOOP_COMB src/Transformations/loops_combiner.cpp - src/Transformations/loops_combiner.h) -set(TR_LOOP_SPLIT src/Transformations/loops_splitter.cpp - src/Transformations/loops_splitter.h) -set(TR_LOOP_UNROLL src/Transformations/loops_unrolling.cpp - src/Transformations/loops_unrolling.h) -set(TR_PRIV_BR src/Transformations/private_arrays_resizing.cpp - src/Transformations/private_arrays_resizing.h) -set(TR_PRIV_DEL src/Transformations/private_removing.cpp - src/Transformations/private_removing.h) -set(TR_SWAP_ARR_DIMS src/Transformations/swap_array_dims.cpp - src/Transformations/swap_array_dims.h) -set(TR_FUNC_DUP src/Transformations/uniq_call_chain_dup.cpp - src/Transformations/uniq_call_chain_dup.h) -set(TR_FUNC_PURE src/Transformations/function_purifying.cpp - src/Transformations/function_purifying.h) -set(TR_GV src/Transformations/fix_common_blocks.cpp - src/Transformations/fix_common_blocks.h) -set(TR_CONV src/Transformations/convert_to_c.cpp - src/Transformations/convert_to_c.h) -set(TR_IMPLICIT_NONE src/Transformations/set_implicit_none.cpp - src/Transformations/set_implicit_none.h) -set(TR_REPLACE_ARRAYS_IN_IO src/Transformations/replace_dist_arrays_in_io.cpp - src/Transformations/replace_dist_arrays_in_io.h) +set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp + src/Transformations/DeadCodeRemoving/dead_code.h) +set(TR_CP src/Transformations/CheckPoints/checkpoints.cpp + src/Transformations/CheckPoints/checkpoints.h) +set(TR_VECTOR src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp + src/Transformations/VectorAssignToLoop/array_assign_to_loop.h) +set(TR_ENDDO_LOOP src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp + src/Transformations/LoopEndDoConverter/enddo_loop_converter.h) +set(TR_LOOP_NEST src/Transformations/LoopNesting/loop_transform.cpp + src/Transformations/LoopNesting/loop_transform.h) +set(TR_LOOP_COMB src/Transformations/LoopCombining/loops_combiner.cpp + src/Transformations/LoopCombining/loops_combiner.h) +set(TR_LOOP_SPLIT src/Transformations/LoopSplitting/loops_splitter.cpp + src/Transformations/LoopSplitting/loops_splitter.h) +set(TR_LOOP_UNROLL src/Transformations/LoopUnrolling/loops_unrolling.cpp + src/Transformations/LoopUnrolling/loops_unrolling.h) +set(TR_PRIV_BR src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp + src/Transformations/PrivateArrayResizing/private_arrays_resizing.h) +set(TR_PRIV_DEL src/Transformations/PrivateArrayRemoving/private_removing.cpp + src/Transformations/PrivateArrayRemoving/private_removing.h) +set(TR_SWAP_ARR_DIMS src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp + src/Transformations/ArrayDimsSwapping/swap_array_dims.h) +set(TR_FUNC_DUP src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp + src/Transformations/FunctionDuplication/uniq_call_chain_dup.h) +set(TR_FUNC_PURE src/Transformations/FunctionPurifying/function_purifying.cpp + src/Transformations/FunctionPurifying/function_purifying.h) +set(TR_GV src/Transformations/GlobalVariables/fix_common_blocks.cpp + src/Transformations/GlobalVariables/fix_common_blocks.h) +set(TR_CONV src/Transformations/ConvertToC/convert_to_c.cpp + src/Transformations/ConvertToC/convert_to_c.h) +set(TR_IMPLICIT_NONE src/Transformations/SetImplicitNone/set_implicit_none.cpp + src/Transformations/SetImplicitNone/set_implicit_none.h) +set(TR_REPLACE_ARRAYS_IN_IO src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp + src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h) +set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp + src/Transformations/ExpressionSubstitution/expr_transform.cpp + src/Transformations/ExpressionSubstitution/expr_transform.h) +set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp + src/Transformations/FunctionInlining/inliner.h) +set(TR_RENAME_SYMBOLS src/Transformations/RenameSymbols/rename_symbols.cpp + src/Transformations/RenameSymbols/rename_symbols.h) set(TRANSFORMS ${TR_DEAD_CODE} @@ -207,7 +221,10 @@ set(TRANSFORMS ${TR_CONV} ${TR_PRIV_DEL} ${TR_IMPLICIT_NONE} - ${TR_REPLACE_ARRAYS_IN_IO}) + ${TR_REPLACE_ARRAYS_IN_IO} + ${TR_EXPR_TRANSFORM} + ${TR_INLINER} + ${TR_RENAME_SYMBOLS}) set(CFG src/CFGraph/IR.cpp src/CFGraph/IR.h @@ -288,10 +305,6 @@ set(DYNA src/DynamicAnalysis/createParallelRegions.cpp src/DynamicAnalysis/gcov_info.h src/DynamicAnalysis/gCov_parser.cpp src/DynamicAnalysis/gCov_parser_func.h) - -set(EXPR_TRANSFORM src/ExpressionTransform/control_flow_graph_part.cpp - src/ExpressionTransform/expr_transform.cpp - src/ExpressionTransform/expr_transform.h) set(GR_CALL src/GraphCall/graph_calls.cpp src/GraphCall/graph_calls.h @@ -303,18 +316,11 @@ set(GR_LOOP src/GraphLoop/graph_loops_base.cpp src/GraphLoop/graph_loops.h src/GraphLoop/graph_loops_func.h) -set(INLINER src/Inliner/inliner.cpp - src/Inliner/inliner.h) - set(LOOP_ANALYZER src/LoopAnalyzer/allocations_prepoc.cpp src/LoopAnalyzer/dep_analyzer.cpp src/LoopAnalyzer/loop_analyzer.cpp src/LoopAnalyzer/loop_analyzer.h) -set(RENAME_SYMBOLS src/RenameSymbols/rename_symbols.cpp - src/RenameSymbols/rename_symbols.h) - - set(MAIN src/Sapfor.cpp src/Sapfor.h src/SapforData.h @@ -404,12 +410,9 @@ set(SOURCE_EXE ${DISTR} ${DVMH_REG} ${DYNA} - ${EXPR_TRANSFORM} ${GR_CALL} ${GR_LOOP} - ${INLINER} ${LOOP_ANALYZER} - ${RENAME_SYMBOLS} ${TRANSFORMS} ${PARALLEL_REG} ${PRIV} @@ -433,7 +436,7 @@ source_group (CFGraph FILES ${CFG}) source_group (CFGraph\\DataFlow FILES ${DATA_FLOW}) source_group (Transformations\\DeadCodeRemoving FILES ${TR_DEAD_CODE}) -source_group (Transformations\\ExpressionSubstitution FILES ${EXPR_TRANSFORM}) +source_group (Transformations\\ExpressionSubstitution FILES ${TR_EXPR_TRANSFORM}) source_group (Transformations\\CheckPoints FILES ${TR_CP}) source_group (Transformations\\LoopEndDoConverter FILES ${TR_ENDDO_LOOP}) source_group (Transformations\\LoopNesting FILES ${TR_LOOP_NEST}) @@ -441,13 +444,13 @@ source_group (Transformations\\LoopCombining FILES ${TR_LOOP_COMB}) source_group (Transformations\\LoopSplitting FILES ${TR_LOOP_SPLIT}) source_group (Transformations\\LoopUnrolling FILES ${TR_LOOP_UNROLL}) source_group (Transformations\\FunctionDuplication FILES ${TR_FUNC_DUP}) -source_group (Transformations\\FunctionInlining FILES ${INLINER}) +source_group (Transformations\\FunctionInlining FILES ${TR_INLINER}) source_group (Transformations\\FunctionPurifying FILES ${TR_FUNC_PURE}) source_group (Transformations\\ArrayDimsSwapping FILES ${TR_SWAP_ARR_DIMS}) source_group (Transformations\\PrivateArrayResizing FILES ${TR_PRIV_BR}) source_group (Transformations\\PrivateArrayRemoving FILES ${TR_PRIV_DEL}) source_group (Transformations\\VectorAssignToLoop FILES ${TR_VECTOR}) -source_group (Transformations\\RenameSymbols FILES ${RENAME_SYMBOLS}) +source_group (Transformations\\RenameSymbols FILES ${TR_RENAME_SYMBOLS}) source_group (Transformations\\GlobalVariables FILES ${TR_GV}) source_group (Transformations\\ConvertToC FILES ${TR_CONV}) source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE}) diff --git a/src/CFGraph/CFGraph.cpp b/src/CFGraph/CFGraph.cpp index 4c414d4..56af300 100644 --- a/src/CFGraph/CFGraph.cpp +++ b/src/CFGraph/CFGraph.cpp @@ -1,5 +1,5 @@ #define _LEAK_ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -10,7 +10,7 @@ #include "../Utils/SgUtils.h" #include "../Utils/CommonBlock.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "dvm.h" #include "IR.h" diff --git a/src/CFGraph/IR.cpp b/src/CFGraph/IR.cpp index a46226b..9c110f8 100644 --- a/src/CFGraph/IR.cpp +++ b/src/CFGraph/IR.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -7,8 +7,8 @@ #include "../Utils/SgUtils.h" #include "../Utils/CommonBlock.h" -#include "../GraphCall/graph_calls.h" -#include "../ExpressionTransform/expr_transform.h" +#include "graph_calls.h" +#include "expr_transform.h" #include "dvm.h" #include "IR.h" diff --git a/src/CFGraph/RD_subst.cpp b/src/CFGraph/RD_subst.cpp index 948fb97..4f48deb 100644 --- a/src/CFGraph/RD_subst.cpp +++ b/src/CFGraph/RD_subst.cpp @@ -10,8 +10,8 @@ #include "../Utils/SgUtils.h" #include "../Utils/CommonBlock.h" -#include "../GraphCall/graph_calls.h" -#include "../ExpressionTransform/expr_transform.h" +#include "graph_calls.h" +#include "expr_transform.h" #define PRINT_PROF_INFO 0 #define DEBUG_CHECKS 0 diff --git a/src/CFGraph/RD_subst.h b/src/CFGraph/RD_subst.h index 188effb..d9e4143 100644 --- a/src/CFGraph/RD_subst.h +++ b/src/CFGraph/RD_subst.h @@ -4,7 +4,7 @@ #include "../Utils/SgUtils.h" #include "../Utils/CommonBlock.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "CFGraph.h" #include "IR.h" diff --git a/src/DirectiveProcessing/directive_analyzer.cpp b/src/DirectiveProcessing/directive_analyzer.cpp index afc3da8..00d7dd2 100644 --- a/src/DirectiveProcessing/directive_analyzer.cpp +++ b/src/DirectiveProcessing/directive_analyzer.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/DirectiveProcessing/directive_creator.cpp b/src/DirectiveProcessing/directive_creator.cpp index 2bd6d86..56225e3 100644 --- a/src/DirectiveProcessing/directive_creator.cpp +++ b/src/DirectiveProcessing/directive_creator.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -22,8 +22,8 @@ #include "../Utils/SgUtils.h" #include "../Sapfor.h" #include "../GraphLoop/graph_loops_func.h" -#include "../Transformations/loop_transform.h" -#include "../ExpressionTransform/expr_transform.h" +#include "../Transformations/LoopNesting/loop_transform.h" +#include "expr_transform.h" #include "../GraphCall/graph_calls_func.h" #include "../Utils/AstWrapper.h" diff --git a/src/DirectiveProcessing/directive_creator_base.cpp b/src/DirectiveProcessing/directive_creator_base.cpp index 6a7f183..7cb2d4f 100644 --- a/src/DirectiveProcessing/directive_creator_base.cpp +++ b/src/DirectiveProcessing/directive_creator_base.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -10,7 +10,7 @@ #include "../ParallelizationRegions/ParRegions.h" #include "../Distribution/Arrays.h" -#include "../Transformations/loop_transform.h" +#include "../Transformations/LoopNesting/loop_transform.h" #include "../Utils/errors.h" #include "directive_parser.h" diff --git a/src/DirectiveProcessing/directive_omp_parser.cpp b/src/DirectiveProcessing/directive_omp_parser.cpp index 6654abf..3fd3a92 100644 --- a/src/DirectiveProcessing/directive_omp_parser.cpp +++ b/src/DirectiveProcessing/directive_omp_parser.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/DirectiveProcessing/directive_parser.cpp b/src/DirectiveProcessing/directive_parser.cpp index ac11540..3e4b901 100644 --- a/src/DirectiveProcessing/directive_parser.cpp +++ b/src/DirectiveProcessing/directive_parser.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/DirectiveProcessing/insert_directive.cpp b/src/DirectiveProcessing/insert_directive.cpp index 4a8f7ed..e2d1ed2 100644 --- a/src/DirectiveProcessing/insert_directive.cpp +++ b/src/DirectiveProcessing/insert_directive.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/DirectiveProcessing/remote_access.cpp b/src/DirectiveProcessing/remote_access.cpp index a35c844..1df252b 100644 --- a/src/DirectiveProcessing/remote_access.cpp +++ b/src/DirectiveProcessing/remote_access.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -22,7 +22,7 @@ #include "../Utils/errors.h" #include "../Utils/SgUtils.h" #include "../Distribution/Arrays.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../GraphCall/graph_calls_func.h" #include "../GraphLoop/graph_loops_func.h" #include "remote_access.h" diff --git a/src/DirectiveProcessing/remote_access_base.cpp b/src/DirectiveProcessing/remote_access_base.cpp index c81ddbf..fe027e1 100644 --- a/src/DirectiveProcessing/remote_access_base.cpp +++ b/src/DirectiveProcessing/remote_access_base.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -17,7 +17,7 @@ #include #include "../Distribution/Arrays.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../GraphLoop/graph_loops.h" #include "../ParallelizationRegions/ParRegions.h" #include "remote_access.h" diff --git a/src/DirectiveProcessing/shadow.cpp b/src/DirectiveProcessing/shadow.cpp index e8eb705..b0a3b92 100644 --- a/src/DirectiveProcessing/shadow.cpp +++ b/src/DirectiveProcessing/shadow.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -8,12 +8,12 @@ #include "../Utils/errors.h" #include "../Utils/utils.h" #include "../GraphLoop/graph_loops_func.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../GraphCall/graph_calls_func.h" #include "directive_parser.h" #include "../Distribution/DvmhDirective_func.h" #include "../Utils/SgUtils.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../CFGraph/CFGraph.h" diff --git a/src/DirectiveProcessing/spf_directive_preproc.cpp b/src/DirectiveProcessing/spf_directive_preproc.cpp index da7ddee..e380df5 100644 --- a/src/DirectiveProcessing/spf_directive_preproc.cpp +++ b/src/DirectiveProcessing/spf_directive_preproc.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -18,7 +18,7 @@ #include "../Utils/SgUtils.h" #include "../Utils/errors.h" #include "directive_parser.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "../DirectiveProcessing/directive_omp_parser.h" diff --git a/src/Distribution/Array.cpp b/src/Distribution/Array.cpp index 4149bda..c3cc653 100644 --- a/src/Distribution/Array.cpp +++ b/src/Distribution/Array.cpp @@ -1,7 +1,7 @@ #include "Array.h" #include "../Utils/errors.h" #include "../Utils/utils.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" using namespace std; diff --git a/src/Distribution/ArrayAnalysis.cpp b/src/Distribution/ArrayAnalysis.cpp index c56f3a4..56527b7 100644 --- a/src/Distribution/ArrayAnalysis.cpp +++ b/src/Distribution/ArrayAnalysis.cpp @@ -1,7 +1,7 @@ #include "Array.h" #include "../Utils/errors.h" #include "../Utils/utils.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../Utils/SgUtils.h" #include "../DirectiveProcessing/directive_parser.h" #include "../DirectiveProcessing/directive_omp_parser.h" diff --git a/src/Distribution/CreateDistributionDirs.cpp b/src/Distribution/CreateDistributionDirs.cpp index ef34757..cdb2720 100644 --- a/src/Distribution/CreateDistributionDirs.cpp +++ b/src/Distribution/CreateDistributionDirs.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Distribution/Cycle.cpp b/src/Distribution/Cycle.cpp index bb307ba..ade7a12 100644 --- a/src/Distribution/Cycle.cpp +++ b/src/Distribution/Cycle.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Distribution/Distribution.cpp b/src/Distribution/Distribution.cpp index 6f99a0c..1ec89fb 100644 --- a/src/Distribution/Distribution.cpp +++ b/src/Distribution/Distribution.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Distribution/DvmhDirective.cpp b/src/Distribution/DvmhDirective.cpp index 1f8f0d2..b485a6e 100644 --- a/src/Distribution/DvmhDirective.cpp +++ b/src/Distribution/DvmhDirective.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Distribution/DvmhDirectiveBase.cpp b/src/Distribution/DvmhDirectiveBase.cpp index 28576a8..0cd3f4c 100644 --- a/src/Distribution/DvmhDirectiveBase.cpp +++ b/src/Distribution/DvmhDirectiveBase.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Distribution/GraphCSR.cpp b/src/Distribution/GraphCSR.cpp index 08f712e..0a22ff9 100644 --- a/src/Distribution/GraphCSR.cpp +++ b/src/Distribution/GraphCSR.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/DvmhRegions/DvmhRegionInserter.cpp b/src/DvmhRegions/DvmhRegionInserter.cpp index 57dff85..db6f51d 100644 --- a/src/DvmhRegions/DvmhRegionInserter.cpp +++ b/src/DvmhRegions/DvmhRegionInserter.cpp @@ -11,7 +11,7 @@ #include "DvmhRegionInserter.h" #include "DvmhRegions/RegionsMerger.h" #include "../VerificationCode/verifications.h" -#include "../Transformations/function_purifying.h" +#include "../Transformations/FunctionPurifying/function_purifying.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "../DirectiveProcessing/directive_parser.h" diff --git a/src/DvmhRegions/DvmhRegionInserter.h b/src/DvmhRegions/DvmhRegionInserter.h index eba428d..8d34be1 100644 --- a/src/DvmhRegions/DvmhRegionInserter.h +++ b/src/DvmhRegions/DvmhRegionInserter.h @@ -2,7 +2,7 @@ #include "../GraphCall/graph_calls_func.h" #include "../GraphLoop/graph_loops_func.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../ParallelizationRegions/ParRegions.h" #include "../Utils/SgUtils.h" #include "ReadWriteAnalyzer.h" diff --git a/src/DynamicAnalysis/createParallelRegions.cpp b/src/DynamicAnalysis/createParallelRegions.cpp index 43be93b..7d641c3 100644 --- a/src/DynamicAnalysis/createParallelRegions.cpp +++ b/src/DynamicAnalysis/createParallelRegions.cpp @@ -5,10 +5,10 @@ #include "./createParallelRegions.h" #include "../CreateInterTree/CreateInterTree.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "./gcov_info.h" #include "./gCov_parser_func.h" -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/DynamicAnalysis/createParallelRegions.h b/src/DynamicAnalysis/createParallelRegions.h index 8818511..a75c928 100644 --- a/src/DynamicAnalysis/createParallelRegions.h +++ b/src/DynamicAnalysis/createParallelRegions.h @@ -4,7 +4,7 @@ #include "./gcov_info.h" #include "../CreateInterTree/CreateInterTree.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include #include diff --git a/src/DynamicAnalysis/gCov_parser.cpp b/src/DynamicAnalysis/gCov_parser.cpp index c8db6e7..dd2cb90 100644 --- a/src/DynamicAnalysis/gCov_parser.cpp +++ b/src/DynamicAnalysis/gCov_parser.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/DynamicAnalysis/gcov_info.cpp b/src/DynamicAnalysis/gcov_info.cpp index c37cf81..c34d64a 100644 --- a/src/DynamicAnalysis/gcov_info.cpp +++ b/src/DynamicAnalysis/gcov_info.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/GraphCall/graph_calls.cpp b/src/GraphCall/graph_calls.cpp index 4ce117d..530f9b1 100644 --- a/src/GraphCall/graph_calls.cpp +++ b/src/GraphCall/graph_calls.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -21,7 +21,7 @@ #include "../Utils/json.hpp" #include "../ParallelizationRegions/ParRegions_func.h" #include "../DynamicAnalysis/gCov_parser_func.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "../VerificationCode/verifications.h" diff --git a/src/GraphCall/graph_calls_base.cpp b/src/GraphCall/graph_calls_base.cpp index 94fdd43..44bb7d2 100644 --- a/src/GraphCall/graph_calls_base.cpp +++ b/src/GraphCall/graph_calls_base.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/GraphLoop/graph_loops.cpp b/src/GraphLoop/graph_loops.cpp index 485fe21..ded6d93 100644 --- a/src/GraphLoop/graph_loops.cpp +++ b/src/GraphLoop/graph_loops.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -14,7 +14,7 @@ #include "../Sapfor.h" #include "../GraphCall/graph_calls_func.h" #include "../ParallelizationRegions/ParRegions_func.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../Distribution/GraphCSR.h" #include "../Distribution/Arrays.h" @@ -31,7 +31,7 @@ #include "../DirectiveProcessing/directive_parser.h" #include "../DynamicAnalysis/gCov_parser_func.h" -#include "../Transformations/array_assign_to_loop.h" +#include "../Transformations/VectorAssignToLoop/array_assign_to_loop.h" using std::vector; using std::map; diff --git a/src/GraphLoop/graph_loops_base.cpp b/src/GraphLoop/graph_loops_base.cpp index 98e13ca..514c4c5 100644 --- a/src/GraphLoop/graph_loops_base.cpp +++ b/src/GraphLoop/graph_loops_base.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/LoopAnalyzer/allocations_prepoc.cpp b/src/LoopAnalyzer/allocations_prepoc.cpp index fdf04dc..9655798 100644 --- a/src/LoopAnalyzer/allocations_prepoc.cpp +++ b/src/LoopAnalyzer/allocations_prepoc.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/LoopAnalyzer/dep_analyzer.cpp b/src/LoopAnalyzer/dep_analyzer.cpp index 67d99ed..ecf4f2a 100644 --- a/src/LoopAnalyzer/dep_analyzer.cpp +++ b/src/LoopAnalyzer/dep_analyzer.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/LoopAnalyzer/loop_analyzer.cpp b/src/LoopAnalyzer/loop_analyzer.cpp index a544fca..b284246 100644 --- a/src/LoopAnalyzer/loop_analyzer.cpp +++ b/src/LoopAnalyzer/loop_analyzer.cpp @@ -18,7 +18,7 @@ #include #include -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #if _WIN32 && NDEBUG && __BOOST #include @@ -42,13 +42,13 @@ extern int passDone; #include "../ParallelizationRegions/ParRegions_func.h" #include "../DynamicAnalysis/gCov_parser_func.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../SageAnalysisTool/depInterfaceExt.h" #include "../VisualizerCalls/get_information.h" #include "../VisualizerCalls/SendMessage.h" -#include "../Transformations/enddo_loop_converter.h" +#include "../Transformations/LoopEndDoConverter/enddo_loop_converter.h" #include "../DirectiveProcessing/remote_access.h" #include "../DirectiveProcessing/directive_omp_parser.h" diff --git a/src/LoopAnalyzer/loop_analyzer.h b/src/LoopAnalyzer/loop_analyzer.h index 5fa5f42..ececa21 100644 --- a/src/LoopAnalyzer/loop_analyzer.h +++ b/src/LoopAnalyzer/loop_analyzer.h @@ -6,7 +6,7 @@ #include #include #include "../GraphLoop/graph_loops.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../ParallelizationRegions/ParRegions.h" #include "../SageAnalysisTool/depInterfaceExt.h" #include "../Utils/AstWrapper.h" diff --git a/src/ParallelizationRegions/ParRegions.cpp b/src/ParallelizationRegions/ParRegions.cpp index f01be39..903fa5e 100644 --- a/src/ParallelizationRegions/ParRegions.cpp +++ b/src/ParallelizationRegions/ParRegions.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -15,7 +15,7 @@ #include "../GraphCall/graph_calls_func.h" #include "../GraphLoop/graph_loops.h" #include "../Distribution/Distribution.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" using std::vector; using std::string; diff --git a/src/ParallelizationRegions/ParRegions_func.h b/src/ParallelizationRegions/ParRegions_func.h index e5d62c6..6420a37 100644 --- a/src/ParallelizationRegions/ParRegions_func.h +++ b/src/ParallelizationRegions/ParRegions_func.h @@ -1,7 +1,7 @@ #pragma once #include "ParRegions.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../GraphLoop/graph_loops.h" void fillRegionLines(SgFile *file, std::vector ®ions, std::vector& messagesForFile, std::vector *loops = NULL, std::vector *funcs = NULL); diff --git a/src/ParallelizationRegions/expand_extract_reg.cpp b/src/ParallelizationRegions/expand_extract_reg.cpp index 5aa341a..86cad84 100644 --- a/src/ParallelizationRegions/expand_extract_reg.cpp +++ b/src/ParallelizationRegions/expand_extract_reg.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp b/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp index 277b46c..43d842f 100644 --- a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp +++ b/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -17,8 +17,8 @@ #include "../DirectiveProcessing/directive_creator.h" #include "../DirectiveProcessing/insert_directive.h" #include "../Utils/SgUtils.h" -#include "../ExpressionTransform/expr_transform.h" -#include "../Transformations/function_purifying.h" +#include "expr_transform.h" +#include "../Transformations/FunctionPurifying/function_purifying.h" using std::map; using std::pair; diff --git a/src/ParallelizationRegions/resolve_par_reg_conflicts.h b/src/ParallelizationRegions/resolve_par_reg_conflicts.h index 4e5e3c4..1523306 100644 --- a/src/ParallelizationRegions/resolve_par_reg_conflicts.h +++ b/src/ParallelizationRegions/resolve_par_reg_conflicts.h @@ -3,7 +3,7 @@ #include "ParRegions.h" #include "../Utils/SgUtils.h" #include "../Utils/errors.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" void fillRegionIntervals(std::vector ®ions); void fillRegionArrays(std::vector ®ions, const std::map> &allFuncInfo, const std::map &commonBlocks); diff --git a/src/Predictor/PredictScheme.cpp b/src/Predictor/PredictScheme.cpp index a63b241..146427d 100644 --- a/src/Predictor/PredictScheme.cpp +++ b/src/Predictor/PredictScheme.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -20,7 +20,7 @@ #include "../DirectiveProcessing/directive_parser.h" #include "../Distribution/DvmhDirective.h" #include "../GraphLoop/graph_loops_func.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "../CFGraph/CFGraph.h" diff --git a/src/Predictor/PredictScheme.h b/src/Predictor/PredictScheme.h index 35ccf9e..b8fb310 100644 --- a/src/Predictor/PredictScheme.h +++ b/src/Predictor/PredictScheme.h @@ -1,7 +1,7 @@ #pragma once #include #include "dvm.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../Utils/json.hpp" class ParallelStats diff --git a/src/PrivateAnalyzer/private_analyzer.cpp b/src/PrivateAnalyzer/private_analyzer.cpp index deb0c94..99b621e 100644 --- a/src/PrivateAnalyzer/private_analyzer.cpp +++ b/src/PrivateAnalyzer/private_analyzer.cpp @@ -1,5 +1,5 @@ #define _LEAK_ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -9,7 +9,7 @@ #include #include -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "private_analyzer.h" #include "dvm.h" #include "../CFGraph/CFGraph.h" diff --git a/src/PrivateAnalyzer/private_analyzer.h b/src/PrivateAnalyzer/private_analyzer.h index 8835950..1a4804c 100644 --- a/src/PrivateAnalyzer/private_analyzer.h +++ b/src/PrivateAnalyzer/private_analyzer.h @@ -3,7 +3,7 @@ #include #include "dvm.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" extern void Private_Vars_Analyzer(SgStatement* start); void PrivateAnalyzer(SgFile *file, std::vector &funcs); diff --git a/src/ProjectManipulation/ConvertFiles.cpp b/src/ProjectManipulation/ConvertFiles.cpp index 78610d8..1fd7715 100644 --- a/src/ProjectManipulation/ConvertFiles.cpp +++ b/src/ProjectManipulation/ConvertFiles.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/ProjectManipulation/FileInfo.cpp b/src/ProjectManipulation/FileInfo.cpp index aa95940..7aa5215 100644 --- a/src/ProjectManipulation/FileInfo.cpp +++ b/src/ProjectManipulation/FileInfo.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/ProjectManipulation/ParseFiles.cpp b/src/ProjectManipulation/ParseFiles.cpp index d474b85..0d1e485 100644 --- a/src/ProjectManipulation/ParseFiles.cpp +++ b/src/ProjectManipulation/ParseFiles.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/ProjectManipulation/PerfAnalyzer.cpp b/src/ProjectManipulation/PerfAnalyzer.cpp index c3ee28c..f8579d1 100644 --- a/src/ProjectManipulation/PerfAnalyzer.cpp +++ b/src/ProjectManipulation/PerfAnalyzer.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/ProjectParameters/projectParameters.cpp b/src/ProjectParameters/projectParameters.cpp index fd395dc..64531b1 100644 --- a/src/ProjectParameters/projectParameters.cpp +++ b/src/ProjectParameters/projectParameters.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -14,7 +14,7 @@ #include "dvm.h" #include "../Utils/errors.h" #include "../Utils/SgUtils.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../GraphCall/graph_calls_func.h" #include "projectParameters.h" diff --git a/src/SageAnalysisTool/defUse.cpp b/src/SageAnalysisTool/defUse.cpp index e400158..24ade01 100644 --- a/src/SageAnalysisTool/defUse.cpp +++ b/src/SageAnalysisTool/defUse.cpp @@ -4,7 +4,7 @@ #include #include -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../Utils/errors.h" #include "../Utils/utils.h" #include "sage++user.h" diff --git a/src/SageAnalysisTool/depGraph.cpp b/src/SageAnalysisTool/depGraph.cpp index a413d99..78a1e6d 100644 --- a/src/SageAnalysisTool/depGraph.cpp +++ b/src/SageAnalysisTool/depGraph.cpp @@ -15,7 +15,7 @@ extern "C" void removeFromCollection(void *pointer); #endif extern int passDone; -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../Utils/errors.h" #include "../VisualizerCalls/get_information.h" diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index 9f5ac64..9fd4793 100644 --- a/src/Sapfor.cpp +++ b/src/Sapfor.cpp @@ -24,8 +24,6 @@ #include "ParallelizationRegions/resolve_par_reg_conflicts.h" #include "ParallelizationRegions/expand_extract_reg.h" -#include "Transformations/replace_dist_arrays_in_io.h" - #include "Distribution/Distribution.h" #include "Distribution/GraphCSR.h" #include "Distribution/Arrays.h" @@ -56,7 +54,7 @@ #include "Distribution/CreateDistributionDirs.h" #include "PrivateAnalyzer/private_analyzer.h" #include "PrivateAnalyzer/private_arrays_search.h" -#include "ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "Predictor/PredictScheme.h" #include "Predictor/PredictorModel.h" @@ -72,24 +70,26 @@ #include "VisualizerCalls/SendMessage.h" #include "VisualizerCalls/BuildGraph.h" -#include "Transformations/enddo_loop_converter.h" -#include "Transformations/loop_transform.h" -#include "Transformations/array_assign_to_loop.h" -#include "Transformations/private_arrays_resizing.h" -#include "Transformations/loops_splitter.h" -#include "Transformations/loops_combiner.h" -#include "Transformations/loops_unrolling.h" -#include "Transformations/uniq_call_chain_dup.h" -#include "Transformations/checkpoints.h" -#include "Transformations/swap_array_dims.h" -#include "Transformations/function_purifying.h" -#include "Transformations/private_removing.h" -#include "Transformations/fix_common_blocks.h" -#include "Transformations/convert_to_c.h" -#include "Transformations/set_implicit_none.h" -#include "Transformations/dead_code.h" +#include "Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h" +#include "Transformations/LoopEndDoConverter/enddo_loop_converter.h" +#include "Transformations/LoopNesting/loop_transform.h" +#include "Transformations/VectorAssignToLoop/array_assign_to_loop.h" +#include "Transformations/PrivateArrayResizing/private_arrays_resizing.h" +#include "Transformations/LoopSplitting/loops_splitter.h" +#include "Transformations/LoopCombining/loops_combiner.h" +#include "Transformations/LoopUnrolling/loops_unrolling.h" +#include "Transformations/FunctionDuplication/uniq_call_chain_dup.h" +#include "Transformations/CheckPoints/checkpoints.h" +#include "Transformations/ArrayDimsSwapping/swap_array_dims.h" +#include "Transformations/FunctionPurifying/function_purifying.h" +#include "Transformations/PrivateArrayRemoving/private_removing.h" +#include "Transformations/GlobalVariables/fix_common_blocks.h" +#include "Transformations/ConvertToC/convert_to_c.h" +#include "Transformations/SetImplicitNone/set_implicit_none.h" +#include "Transformations/DeadCodeRemoving/dead_code.h" +#include "Transformations/RenameSymbols/rename_symbols.h" +#include "Transformations/FunctionInlining/inliner.h" -#include "RenameSymbols/rename_symbols.h" #include "ProjectParameters/projectParameters.h" #include "CFGraph/IR.h" @@ -99,8 +99,6 @@ #include "CFGraph/live_variable_analysis.h" #include "CFGraph/private_variables_analysis.h" -#include "Inliner/inliner.h" - #include "dvm.h" #include "Sapfor.h" #include "Utils/PassManager.h" diff --git a/src/Transformations/swap_array_dims.cpp b/src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp similarity index 100% rename from src/Transformations/swap_array_dims.cpp rename to src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp diff --git a/src/Transformations/swap_array_dims.h b/src/Transformations/ArrayDimsSwapping/swap_array_dims.h similarity index 100% rename from src/Transformations/swap_array_dims.h rename to src/Transformations/ArrayDimsSwapping/swap_array_dims.h diff --git a/src/Transformations/checkpoints.cpp b/src/Transformations/CheckPoints/checkpoints.cpp similarity index 97% rename from src/Transformations/checkpoints.cpp rename to src/Transformations/CheckPoints/checkpoints.cpp index 5003f1a..2549f6c 100644 --- a/src/Transformations/checkpoints.cpp +++ b/src/Transformations/CheckPoints/checkpoints.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -6,7 +6,7 @@ #include "../Utils/SgUtils.h" #include "../Utils/utils.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "checkpoints.h" diff --git a/src/Transformations/checkpoints.h b/src/Transformations/CheckPoints/checkpoints.h similarity index 100% rename from src/Transformations/checkpoints.h rename to src/Transformations/CheckPoints/checkpoints.h diff --git a/src/Transformations/convert_to_c.cpp b/src/Transformations/ConvertToC/convert_to_c.cpp similarity index 96% rename from src/Transformations/convert_to_c.cpp rename to src/Transformations/ConvertToC/convert_to_c.cpp index 2b3f7a6..867dc2b 100644 --- a/src/Transformations/convert_to_c.cpp +++ b/src/Transformations/ConvertToC/convert_to_c.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Transformations/convert_to_c.h b/src/Transformations/ConvertToC/convert_to_c.h similarity index 100% rename from src/Transformations/convert_to_c.h rename to src/Transformations/ConvertToC/convert_to_c.h diff --git a/src/Transformations/dead_code.cpp b/src/Transformations/DeadCodeRemoving/dead_code.cpp similarity index 100% rename from src/Transformations/dead_code.cpp rename to src/Transformations/DeadCodeRemoving/dead_code.cpp diff --git a/src/Transformations/dead_code.h b/src/Transformations/DeadCodeRemoving/dead_code.h similarity index 100% rename from src/Transformations/dead_code.h rename to src/Transformations/DeadCodeRemoving/dead_code.h diff --git a/src/ExpressionTransform/control_flow_graph_part.cpp b/src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp similarity index 96% rename from src/ExpressionTransform/control_flow_graph_part.cpp rename to src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp index 2245ccb..6f3fa08 100644 --- a/src/ExpressionTransform/control_flow_graph_part.cpp +++ b/src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include "dvm.h" #include "acc_analyzer.h" diff --git a/src/ExpressionTransform/expr_transform.cpp b/src/Transformations/ExpressionSubstitution/expr_transform.cpp similarity index 96% rename from src/ExpressionTransform/expr_transform.cpp rename to src/Transformations/ExpressionSubstitution/expr_transform.cpp index 1fdcf65..e8db58d 100644 --- a/src/ExpressionTransform/expr_transform.cpp +++ b/src/Transformations/ExpressionSubstitution/expr_transform.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #if _WIN32 && NDEBUG && __SPF && __BOOST #include @@ -20,7 +20,7 @@ extern int passDone; #include "../ParallelizationRegions/ParRegions.h" #include "../ParallelizationRegions/ParRegions_func.h" #include "../GraphLoop/graph_loops.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../GraphCall/graph_calls_func.h" #include "../Utils/utils.h" #include "../Utils/SgUtils.h" diff --git a/src/ExpressionTransform/expr_transform.h b/src/Transformations/ExpressionSubstitution/expr_transform.h similarity index 96% rename from src/ExpressionTransform/expr_transform.h rename to src/Transformations/ExpressionSubstitution/expr_transform.h index fd11907..c9924d5 100644 --- a/src/ExpressionTransform/expr_transform.h +++ b/src/Transformations/ExpressionSubstitution/expr_transform.h @@ -7,7 +7,7 @@ #include "../Distribution/Distribution.h" #include "../GraphLoop/graph_loops.h" #include "../ParallelizationRegions/ParRegions.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../Utils/SgUtils.h" #include "acc_analyzer.h" diff --git a/src/Transformations/uniq_call_chain_dup.cpp b/src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp similarity index 96% rename from src/Transformations/uniq_call_chain_dup.cpp rename to src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp index 838df37..8bf71db 100644 --- a/src/Transformations/uniq_call_chain_dup.cpp +++ b/src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -16,9 +16,9 @@ #include "../Utils/SgUtils.h" #include "uniq_call_chain_dup.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../GraphCall/graph_calls_func.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../VerificationCode/verifications.h" using namespace std; diff --git a/src/Transformations/uniq_call_chain_dup.h b/src/Transformations/FunctionDuplication/uniq_call_chain_dup.h similarity index 89% rename from src/Transformations/uniq_call_chain_dup.h rename to src/Transformations/FunctionDuplication/uniq_call_chain_dup.h index 609e978..4e3e16d 100644 --- a/src/Transformations/uniq_call_chain_dup.h +++ b/src/Transformations/FunctionDuplication/uniq_call_chain_dup.h @@ -1,6 +1,6 @@ #pragma once -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include #include #include diff --git a/src/Inliner/inliner.cpp b/src/Transformations/FunctionInlining/inliner.cpp similarity index 97% rename from src/Inliner/inliner.cpp rename to src/Transformations/FunctionInlining/inliner.cpp index ad87c5a..5a00fae 100644 --- a/src/Inliner/inliner.cpp +++ b/src/Transformations/FunctionInlining/inliner.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -14,7 +14,7 @@ #include "../GraphCall/graph_calls_func.h" #include "inliner.h" #include "../VisualizerCalls/SendMessage.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" using std::set; using std::map; diff --git a/src/Inliner/inliner.h b/src/Transformations/FunctionInlining/inliner.h similarity index 100% rename from src/Inliner/inliner.h rename to src/Transformations/FunctionInlining/inliner.h diff --git a/src/Transformations/function_purifying.cpp b/src/Transformations/FunctionPurifying/function_purifying.cpp similarity index 97% rename from src/Transformations/function_purifying.cpp rename to src/Transformations/FunctionPurifying/function_purifying.cpp index 28d454f..af93f22 100644 --- a/src/Transformations/function_purifying.cpp +++ b/src/Transformations/FunctionPurifying/function_purifying.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -15,7 +15,7 @@ #include "../Utils/SgUtils.h" #include "../Utils/CommonBlock.h" #include "../Utils/DefUseList.h" -#include "ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../VerificationCode/verifications.h" #include "../DvmhRegions/DvmhRegionInserter.h" #include "function_purifying.h" diff --git a/src/Transformations/function_purifying.h b/src/Transformations/FunctionPurifying/function_purifying.h similarity index 100% rename from src/Transformations/function_purifying.h rename to src/Transformations/FunctionPurifying/function_purifying.h diff --git a/src/Transformations/fix_common_blocks.cpp b/src/Transformations/GlobalVariables/fix_common_blocks.cpp similarity index 100% rename from src/Transformations/fix_common_blocks.cpp rename to src/Transformations/GlobalVariables/fix_common_blocks.cpp diff --git a/src/Transformations/fix_common_blocks.h b/src/Transformations/GlobalVariables/fix_common_blocks.h similarity index 93% rename from src/Transformations/fix_common_blocks.h rename to src/Transformations/GlobalVariables/fix_common_blocks.h index 60b5855..8c0ff32 100644 --- a/src/Transformations/fix_common_blocks.h +++ b/src/Transformations/GlobalVariables/fix_common_blocks.h @@ -11,7 +11,7 @@ #include "../Utils/SgUtils.h" #include "../LoopAnalyzer/loop_analyzer.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" struct DeclInfo // for error messages diff --git a/src/Transformations/loops_combiner.cpp b/src/Transformations/LoopCombining/loops_combiner.cpp similarity index 96% rename from src/Transformations/loops_combiner.cpp rename to src/Transformations/LoopCombining/loops_combiner.cpp index ae5db2e..81ca24c 100644 --- a/src/Transformations/loops_combiner.cpp +++ b/src/Transformations/LoopCombining/loops_combiner.cpp @@ -1,7 +1,7 @@ #include "loops_combiner.h" #include "../LoopAnalyzer/loop_analyzer.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../Utils/errors.h" #include "../Utils/SgUtils.h" #include diff --git a/src/Transformations/loops_combiner.h b/src/Transformations/LoopCombining/loops_combiner.h similarity index 100% rename from src/Transformations/loops_combiner.h rename to src/Transformations/LoopCombining/loops_combiner.h diff --git a/src/Transformations/enddo_loop_converter.cpp b/src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp similarity index 96% rename from src/Transformations/enddo_loop_converter.cpp rename to src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp index d4c45e1..511b743 100644 --- a/src/Transformations/enddo_loop_converter.cpp +++ b/src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Transformations/enddo_loop_converter.h b/src/Transformations/LoopEndDoConverter/enddo_loop_converter.h similarity index 100% rename from src/Transformations/enddo_loop_converter.h rename to src/Transformations/LoopEndDoConverter/enddo_loop_converter.h diff --git a/src/Transformations/loop_transform.cpp b/src/Transformations/LoopNesting/loop_transform.cpp similarity index 96% rename from src/Transformations/loop_transform.cpp rename to src/Transformations/LoopNesting/loop_transform.cpp index b720652..6679deb 100644 --- a/src/Transformations/loop_transform.cpp +++ b/src/Transformations/LoopNesting/loop_transform.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Transformations/loop_transform.h b/src/Transformations/LoopNesting/loop_transform.h similarity index 100% rename from src/Transformations/loop_transform.h rename to src/Transformations/LoopNesting/loop_transform.h diff --git a/src/Transformations/loops_splitter.cpp b/src/Transformations/LoopSplitting/loops_splitter.cpp similarity index 97% rename from src/Transformations/loops_splitter.cpp rename to src/Transformations/LoopSplitting/loops_splitter.cpp index 65f7eca..09065d7 100644 --- a/src/Transformations/loops_splitter.cpp +++ b/src/Transformations/LoopSplitting/loops_splitter.cpp @@ -4,7 +4,7 @@ #include #include "../LoopAnalyzer/loop_analyzer.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../Utils/errors.h" #include "../CFGraph/CFGraph.h" #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h" diff --git a/src/Transformations/loops_splitter.h b/src/Transformations/LoopSplitting/loops_splitter.h similarity index 100% rename from src/Transformations/loops_splitter.h rename to src/Transformations/LoopSplitting/loops_splitter.h diff --git a/src/Transformations/loops_unrolling.cpp b/src/Transformations/LoopUnrolling/loops_unrolling.cpp similarity index 100% rename from src/Transformations/loops_unrolling.cpp rename to src/Transformations/LoopUnrolling/loops_unrolling.cpp diff --git a/src/Transformations/loops_unrolling.h b/src/Transformations/LoopUnrolling/loops_unrolling.h similarity index 100% rename from src/Transformations/loops_unrolling.h rename to src/Transformations/LoopUnrolling/loops_unrolling.h diff --git a/src/Transformations/private_removing.cpp b/src/Transformations/PrivateArrayRemoving/private_removing.cpp similarity index 97% rename from src/Transformations/private_removing.cpp rename to src/Transformations/PrivateArrayRemoving/private_removing.cpp index 51414e8..5589073 100644 --- a/src/Transformations/private_removing.cpp +++ b/src/Transformations/PrivateArrayRemoving/private_removing.cpp @@ -3,8 +3,8 @@ #include "../Utils/errors.h" #include "../Utils/SgUtils.h" #include "../Utils/utils.h" -#include "../ExpressionTransform/expr_transform.h" -#include "dead_code.h" +#include "expr_transform.h" +#include "../DeadCodeRemoving/dead_code.h" using std::make_pair; using std::map; diff --git a/src/Transformations/private_removing.h b/src/Transformations/PrivateArrayRemoving/private_removing.h similarity index 100% rename from src/Transformations/private_removing.h rename to src/Transformations/PrivateArrayRemoving/private_removing.h diff --git a/src/Transformations/private_arrays_resizing.cpp b/src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp similarity index 100% rename from src/Transformations/private_arrays_resizing.cpp rename to src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp diff --git a/src/Transformations/private_arrays_resizing.h b/src/Transformations/PrivateArrayResizing/private_arrays_resizing.h similarity index 100% rename from src/Transformations/private_arrays_resizing.h rename to src/Transformations/PrivateArrayResizing/private_arrays_resizing.h diff --git a/src/RenameSymbols/rename_symbols.cpp b/src/Transformations/RenameSymbols/rename_symbols.cpp similarity index 96% rename from src/RenameSymbols/rename_symbols.cpp rename to src/Transformations/RenameSymbols/rename_symbols.cpp index 1e812de..bcb593b 100644 --- a/src/RenameSymbols/rename_symbols.cpp +++ b/src/Transformations/RenameSymbols/rename_symbols.cpp @@ -4,7 +4,7 @@ #include #include "Utils/SgUtils.h" -#include "RenameSymbols/rename_symbols.h" +#include "rename_symbols.h" using std::vector; using std::map; diff --git a/src/RenameSymbols/rename_symbols.h b/src/Transformations/RenameSymbols/rename_symbols.h similarity index 100% rename from src/RenameSymbols/rename_symbols.h rename to src/Transformations/RenameSymbols/rename_symbols.h diff --git a/src/Transformations/replace_dist_arrays_in_io.cpp b/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp similarity index 96% rename from src/Transformations/replace_dist_arrays_in_io.cpp rename to src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp index efb63e4..e9c088d 100644 --- a/src/Transformations/replace_dist_arrays_in_io.cpp +++ b/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp @@ -1,11 +1,11 @@ #include "replace_dist_arrays_in_io.h" -#include "../ParallelizationRegions/resolve_par_reg_conflicts.h" - #include #include #include -#include + +#include "expr_transform.h" +#include "../ParallelizationRegions/resolve_par_reg_conflicts.h" using std::map; using std::set; diff --git a/src/Transformations/replace_dist_arrays_in_io.h b/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h similarity index 91% rename from src/Transformations/replace_dist_arrays_in_io.h rename to src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h index a9998ef..cd5c912 100644 --- a/src/Transformations/replace_dist_arrays_in_io.h +++ b/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h @@ -3,7 +3,7 @@ #include "../ParallelizationRegions/ParRegions.h" #include "../Utils/SgUtils.h" #include "../Utils/errors.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" void replaceDistributedArraysInIO(std::vector& regions, const std::map>& allFuncInfo, diff --git a/src/Transformations/set_implicit_none.cpp b/src/Transformations/SetImplicitNone/set_implicit_none.cpp similarity index 96% rename from src/Transformations/set_implicit_none.cpp rename to src/Transformations/SetImplicitNone/set_implicit_none.cpp index 8407685..6559a24 100644 --- a/src/Transformations/set_implicit_none.cpp +++ b/src/Transformations/SetImplicitNone/set_implicit_none.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/Transformations/set_implicit_none.h b/src/Transformations/SetImplicitNone/set_implicit_none.h similarity index 100% rename from src/Transformations/set_implicit_none.h rename to src/Transformations/SetImplicitNone/set_implicit_none.h diff --git a/src/Transformations/array_assign_to_loop.cpp b/src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp similarity index 97% rename from src/Transformations/array_assign_to_loop.cpp rename to src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp index 01bd012..20e1d37 100644 --- a/src/Transformations/array_assign_to_loop.cpp +++ b/src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -14,7 +14,7 @@ #include "../ParallelizationRegions/ParRegions.h" #include "array_assign_to_loop.h" #include "../Utils/SgUtils.h" -#include "../ExpressionTransform/expr_transform.h" +#include "expr_transform.h" #include "../GraphCall/graph_calls_func.h" #include "../VerificationCode/verifications.h" diff --git a/src/Transformations/array_assign_to_loop.h b/src/Transformations/VectorAssignToLoop/array_assign_to_loop.h similarity index 100% rename from src/Transformations/array_assign_to_loop.h rename to src/Transformations/VectorAssignToLoop/array_assign_to_loop.h diff --git a/src/Utils/SgUtils.cpp b/src/Utils/SgUtils.cpp index 677e0a9..51b0dce 100644 --- a/src/Utils/SgUtils.cpp +++ b/src/Utils/SgUtils.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include @@ -37,7 +37,7 @@ #include "../DirectiveProcessing/directive_parser.h" #include "../Distribution/Distribution.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../GraphCall/graph_calls_func.h" #include "../CreateInterTree/CreateInterTree.h" #include "../Predictor/PredictScheme.h" diff --git a/src/Utils/SgUtils.h b/src/Utils/SgUtils.h index 5ce6d38..68b726e 100644 --- a/src/Utils/SgUtils.h +++ b/src/Utils/SgUtils.h @@ -3,7 +3,7 @@ #include "dvm.h" #include "utils.h" #include "../Distribution/Distribution.h" -#include "../GraphCall/graph_calls.h" +#include "graph_calls.h" #include "../DynamicAnalysis/gcov_info.h" #include "module_utils.h" diff --git a/src/Utils/utils.cpp b/src/Utils/utils.cpp index 2ee26d1..e9f8bcf 100644 --- a/src/Utils/utils.cpp +++ b/src/Utils/utils.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/VerificationCode/CorrectVarDecl.cpp b/src/VerificationCode/CorrectVarDecl.cpp index 96625f0..ccae540 100644 --- a/src/VerificationCode/CorrectVarDecl.cpp +++ b/src/VerificationCode/CorrectVarDecl.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/VerificationCode/IncludeChecker.cpp b/src/VerificationCode/IncludeChecker.cpp index 15fe93e..04ad02f 100644 --- a/src/VerificationCode/IncludeChecker.cpp +++ b/src/VerificationCode/IncludeChecker.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/VerificationCode/StructureChecker.cpp b/src/VerificationCode/StructureChecker.cpp index 407510b..1eb17b4 100644 --- a/src/VerificationCode/StructureChecker.cpp +++ b/src/VerificationCode/StructureChecker.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include diff --git a/src/VerificationCode/VerifySageStructures.cpp b/src/VerificationCode/VerifySageStructures.cpp index 0c8da72..1056bcc 100644 --- a/src/VerificationCode/VerifySageStructures.cpp +++ b/src/VerificationCode/VerifySageStructures.cpp @@ -1,4 +1,4 @@ -#include "../Utils/leak_detector.h" +#include "leak_detector.h" #include #include From db32a3e2b288237b2955a29aee255ac49884ad67 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Wed, 4 Jun 2025 08:32:25 +0300 Subject: [PATCH 15/22] small fix --- src/Sapfor.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index 9fd4793..36f8cfa 100644 --- a/src/Sapfor.cpp +++ b/src/Sapfor.cpp @@ -2678,7 +2678,7 @@ int main(int argc, char **argv) byFileArray.push_back(inFile); } json allMessages; - allMessages["allMessage"] = byFileArray; + allMessages["allMessages"] = byFileArray; FILE* outF = fopen("dump_messages.json", "w"); fprintf(outF, "%s", allMessages.dump().c_str()); From f53d514a47c113014dfaefdba55346d5dae458d7 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Wed, 4 Jun 2025 13:01:50 +0300 Subject: [PATCH 16/22] added VISUALIZER_DATA_PATH variable --- src/ProjectManipulation/ParseFiles.cpp | 9 ++--- src/Sapfor.cpp | 45 +++++++++++++------------ src/SapforData.h | 1 + src/Utils/version.h | 2 +- src/VisualizerCalls/get_information.cpp | 3 +- 5 files changed, 33 insertions(+), 27 deletions(-) diff --git a/src/ProjectManipulation/ParseFiles.cpp b/src/ProjectManipulation/ParseFiles.cpp index 0d1e485..3e6e40a 100644 --- a/src/ProjectManipulation/ParseFiles.cpp +++ b/src/ProjectManipulation/ParseFiles.cpp @@ -34,6 +34,7 @@ using namespace std; extern "C" int parse_file(int argc, char* argv[], char* proj_name); +extern const char* VISUALIZER_DATA_PATH; static void findModuleDeclInProject(const string& name, const vector& files, map& modDecls) { @@ -713,7 +714,7 @@ int parseFiles(const char* proj, vector& filesCompilationOrder, int pars if (pathSplit.size() < 2) printInternalError(convertFileName(__FILE__).c_str(), __LINE__); - if (pathSplit[pathSplit.size() - 2] != "visualiser_data") + if (pathSplit[pathSplit.size() - 2] != VISUALIZER_DATA_PATH) printInternalError(convertFileName(__FILE__).c_str(), __LINE__); string fullPath = ""; for (int z = 0; z < pathSplit.size() - 2; ++z) @@ -745,9 +746,9 @@ int parseFiles(const char* proj, vector& filesCompilationOrder, int pars else fileNameFixed = (toAdd.substr(0, 2) == "./") ? toAdd.substr(2) : toAdd; - const string optPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".opt"; - const string errPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".err"; - const string outPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".out"; + const string optPath = fullPath + VISUALIZER_DATA_PATH + "/options/" + fileNameFixed + ".opt"; + const string errPath = fullPath + VISUALIZER_DATA_PATH + "/options/" + fileNameFixed + ".err"; + const string outPath = fullPath + VISUALIZER_DATA_PATH + "/options/" + fileNameFixed + ".out"; const string fileText = readFileToStr(toAdd); diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index 36f8cfa..1106d5f 100644 --- a/src/Sapfor.cpp +++ b/src/Sapfor.cpp @@ -908,7 +908,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne else if (curr_regime == ADD_TEMPL_TO_USE_ONLY) fixUseOnlyStmt(file, parallelRegions); else if (curr_regime == GCOV_PARSER) - parse_gcovfile(file, consoleMode == 1 ? file_name : "./visualiser_data/gcov/" + string(file_name), getObjectForFileFromMap(file_name, gCovInfo), keepFiles); + parse_gcovfile(file, consoleMode == 1 ? file_name : string(VISUALIZER_DATA_PATH) + "/gcov/" + file_name, getObjectForFileFromMap(file_name, gCovInfo), keepFiles); else if(curr_regime == PRIVATE_ARRAYS_EXPANSION) { auto founded = loopGraph.find(file->filename()); @@ -960,7 +960,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne vector include_functions; createInterTree(file, getObjectForFileFromMap(file_name, intervals), removeNestedIntervals, getObjectForFileFromMap(file_name, SPF_messages)); - assignCallsToFile(consoleMode == 1 ? file_name : "./visualiser_data/gcov/" + string(file_name), getObjectForFileFromMap(file_name, intervals)); + assignCallsToFile(consoleMode == 1 ? file_name : string(VISUALIZER_DATA_PATH) + "/gcov/" + file_name, getObjectForFileFromMap(file_name, intervals)); removeNodes(intervals_threshold, getObjectForFileFromMap(file_name, intervals), include_functions); } else if (curr_regime == INSERT_INTER_TREE) @@ -1713,7 +1713,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne } else if (curr_regime == GCOV_PARSER) { - parseTimesDvmStatisticFile((consoleMode == 1) ? string("statistic.txt") : "./visualiser_data/statistic/" + string("statistic.txt"), intervals); + parseTimesDvmStatisticFile((consoleMode == 1) ? string("statistic.txt") : string(VISUALIZER_DATA_PATH) + "/statistic/statistic.txt", intervals); //fixed count, devide by value from PROG_HEDR SgStatement* mainUnit = findMainUnit(&project, SPF_messages); @@ -2662,27 +2662,30 @@ int main(int argc, char **argv) printStackTrace(); printf("exception occurred\n"); - json byFileArray = json::array(); - for (auto& byFile : SPF_messages) + FILE* outF = fopen((string(VISUALIZER_DATA_PATH) + "error_messages.json").c_str(), "w"); + if (outF) { - json inFile; - inFile["file"] = byFile.first; - - json messages = json::array(); - for (auto& message : byFile.second) + json byFileArray = json::array(); + for (auto& byFile : SPF_messages) { - message.print(byFile.first); - messages.push_back(message.toJson()); - } - inFile["messages"] = messages; - byFileArray.push_back(inFile); - } - json allMessages; - allMessages["allMessages"] = byFileArray; + json inFile; + inFile["file"] = byFile.first; - FILE* outF = fopen("dump_messages.json", "w"); - fprintf(outF, "%s", allMessages.dump().c_str()); - fclose(outF); + json messages = json::array(); + for (auto& message : byFile.second) + { + message.print(byFile.first); + messages.push_back(message.toJson()); + } + inFile["messages"] = messages; + byFileArray.push_back(inFile); + } + json allMessages; + allMessages["allMessages"] = byFileArray; + + fprintf(outF, "%s", allMessages.dump().c_str()); + fclose(outF); + } } deleteAllAllocatedData(withDel); diff --git a/src/SapforData.h b/src/SapforData.h index cfd4f42..b62ae99 100644 --- a/src/SapforData.h +++ b/src/SapforData.h @@ -49,6 +49,7 @@ bool withTemplateInfo = false; bool inlcudeAllFiles = false; // for pass INSERT_INLCUDES bool runAsClient = false; // run console project as client for Visualizer bool printSymbTable = false; +const char* VISUALIZER_DATA_PATH = "visualiser_data"; uint64_t currentAvailMemory = 0; int QUALITY; // quality of conflicts search in graph diff --git a/src/Utils/version.h b/src/Utils/version.h index 43758a9..6f49767 100644 --- a/src/Utils/version.h +++ b/src/Utils/version.h @@ -1,3 +1,3 @@ #pragma once -#define VERSION_SPF "2422" +#define VERSION_SPF "2423" diff --git a/src/VisualizerCalls/get_information.cpp b/src/VisualizerCalls/get_information.cpp index 8aa5102..1e2adf1 100644 --- a/src/VisualizerCalls/get_information.cpp +++ b/src/VisualizerCalls/get_information.cpp @@ -67,6 +67,7 @@ using json = nlohmann::json; extern set allocated; extern set allocatedInt; extern bool runAsClient; +extern const char* VISUALIZER_DATA_PATH; bool showDebug = false; static const string interruptEx = "Interrupted by user"; @@ -298,7 +299,7 @@ static void runPassesForVisualizer(const short *projName, const vector & while (passDone == 0) { FILE* interrupt_old = fopen("INTERRUPT", "r"); - FILE* interrupt = fopen("visualiser_data/INTERRUPT", "r"); + FILE* interrupt = fopen((string(VISUALIZER_DATA_PATH) + "/INTERRUPT").c_str(), "r"); if (interrupt || interrupt_old) { if (showDebug) From fca4f632e470975b66da331dd70de905e56f4907 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Wed, 4 Jun 2025 13:08:38 +0300 Subject: [PATCH 17/22] refactoring: removed unnecessary --- src/CFGraph/CFGraph.cpp | 4 ++-- src/CFGraph/DataFlow/backward_data_flow.h | 2 +- src/CFGraph/DataFlow/backward_data_flow_impl.h | 2 +- src/CFGraph/DataFlow/data_flow.h | 2 +- src/CFGraph/DataFlow/data_flow_impl.h | 2 +- src/CFGraph/IR.cpp | 4 ++-- src/CFGraph/IR.h | 2 +- src/CFGraph/RD_subst.cpp | 4 ++-- src/CFGraph/RD_subst.h | 4 ++-- src/CFGraph/live_variable_analysis.h | 2 +- src/CFGraph/private_variables_analysis.cpp | 4 ++-- src/CFGraph/private_variables_analysis.h | 4 ++-- src/CreateInterTree/CreateInterTree.cpp | 6 +++--- src/CreateInterTree/CreateInterTree.h | 2 +- src/DirectiveProcessing/directive_analyzer.cpp | 4 ++-- src/DirectiveProcessing/directive_analyzer.h | 2 +- src/DirectiveProcessing/directive_creator.cpp | 10 +++++----- src/DirectiveProcessing/directive_creator.h | 6 +++--- src/DirectiveProcessing/directive_creator_base.cpp | 2 +- src/DirectiveProcessing/directive_omp_parser.cpp | 2 +- src/DirectiveProcessing/directive_omp_parser.h | 2 +- src/DirectiveProcessing/directive_parser.cpp | 6 +++--- src/DirectiveProcessing/directive_parser.h | 4 ++-- src/DirectiveProcessing/insert_directive.cpp | 8 ++++---- src/DirectiveProcessing/remote_access.cpp | 10 +++++----- src/DirectiveProcessing/remote_access_base.cpp | 2 +- src/DirectiveProcessing/shadow.cpp | 10 +++++----- src/DirectiveProcessing/spf_directive_preproc.cpp | 8 ++++---- src/Distribution/Array.cpp | 4 ++-- src/Distribution/Array.h | 6 +++--- src/Distribution/ArrayAnalysis.cpp | 6 +++--- src/Distribution/CreateDistributionDirs.cpp | 6 +++--- src/Distribution/CreateDistributionDirs.h | 4 ++-- src/Distribution/Cycle.h | 2 +- src/Distribution/Distribution.cpp | 6 +++--- src/Distribution/DvmhDirective.cpp | 8 ++++---- src/Distribution/DvmhDirective.h | 6 +++--- src/Distribution/DvmhDirectiveBase.cpp | 8 ++++---- src/Distribution/DvmhDirectiveBase.h | 2 +- src/Distribution/DvmhDirective_func.h | 2 +- src/Distribution/GraphCSR.cpp | 4 ++-- src/Distribution/GraphCSR.h | 2 +- src/DvmhRegions/DvmhRegion.h | 2 +- src/DvmhRegions/DvmhRegionInserter.h | 6 +++--- src/DvmhRegions/LoopChecker.h | 4 ++-- src/DvmhRegions/ReadWriteAnalyzer.h | 2 +- src/DvmhRegions/TypedSymbol.h | 2 +- src/DynamicAnalysis/createParallelRegions.h | 2 +- src/DynamicAnalysis/gCov_parser.cpp | 2 +- src/DynamicAnalysis/gCov_parser_func.h | 2 +- src/DynamicAnalysis/gcov_info.cpp | 2 +- src/DynamicAnalysis/gcov_info.h | 2 +- src/GraphCall/graph_calls.cpp | 6 +++--- src/GraphCall/graph_calls.h | 6 +++--- src/GraphCall/graph_calls_base.cpp | 4 ++-- src/GraphCall/graph_calls_func.h | 2 +- src/GraphLoop/graph_loops.cpp | 12 ++++++------ src/GraphLoop/graph_loops.h | 4 ++-- src/GraphLoop/graph_loops_base.cpp | 4 ++-- src/LoopAnalyzer/allocations_prepoc.cpp | 4 ++-- src/LoopAnalyzer/dep_analyzer.cpp | 4 ++-- src/LoopAnalyzer/loop_analyzer.cpp | 10 +++++----- src/LoopAnalyzer/loop_analyzer.h | 6 +++--- src/ParallelizationRegions/ParRegions.cpp | 8 ++++---- src/ParallelizationRegions/ParRegions.h | 6 +++--- src/ParallelizationRegions/ParRegions_func.h | 2 +- src/ParallelizationRegions/expand_extract_reg.h | 4 ++-- .../resolve_par_reg_conflicts.cpp | 6 +++--- .../resolve_par_reg_conflicts.h | 4 ++-- src/Predictor/PredictScheme.cpp | 4 ++-- src/Predictor/PredictScheme.h | 2 +- src/PrivateAnalyzer/private_arrays_search.cpp | 4 ++-- src/PrivateAnalyzer/private_arrays_search.h | 2 +- src/PrivateAnalyzer/region.cpp | 2 +- src/PrivateAnalyzer/region.h | 2 +- src/ProjectManipulation/ConvertFiles.cpp | 6 +++--- src/ProjectManipulation/FileInfo.cpp | 4 ++-- src/ProjectManipulation/ParseFiles.cpp | 4 ++-- src/ProjectManipulation/PerfAnalyzer.cpp | 4 ++-- src/ProjectParameters/projectParameters.cpp | 6 +++--- src/SageAnalysisTool/defUse.cpp | 4 ++-- src/SageAnalysisTool/depGraph.cpp | 2 +- .../ArrayDimsSwapping/swap_array_dims.cpp | 6 +++--- src/Transformations/CheckPoints/checkpoints.cpp | 4 ++-- src/Transformations/DeadCodeRemoving/dead_code.h | 2 +- .../ExpressionSubstitution/expr_transform.cpp | 8 ++++---- .../ExpressionSubstitution/expr_transform.h | 4 ++-- .../FunctionDuplication/uniq_call_chain_dup.cpp | 6 +++--- src/Transformations/FunctionInlining/inliner.cpp | 8 ++++---- .../FunctionPurifying/function_purifying.cpp | 8 ++++---- .../GlobalVariables/fix_common_blocks.h | 2 +- src/Transformations/LoopCombining/loops_combiner.cpp | 4 ++-- src/Transformations/LoopCombining/loops_combiner.h | 2 +- .../LoopEndDoConverter/enddo_loop_converter.cpp | 6 +++--- .../LoopEndDoConverter/enddo_loop_converter.h | 2 +- src/Transformations/LoopNesting/loop_transform.cpp | 4 ++-- src/Transformations/LoopNesting/loop_transform.h | 2 +- src/Transformations/LoopSplitting/loops_splitter.cpp | 2 +- src/Transformations/LoopSplitting/loops_splitter.h | 4 ++-- .../LoopUnrolling/loops_unrolling.cpp | 4 ++-- src/Transformations/LoopUnrolling/loops_unrolling.h | 2 +- .../PrivateArrayRemoving/private_removing.cpp | 6 +++--- .../PrivateArrayResizing/private_arrays_resizing.cpp | 8 ++++---- .../PrivateArrayResizing/private_arrays_resizing.h | 2 +- .../ReplaceArraysInIO/replace_dist_arrays_in_io.h | 4 ++-- .../VectorAssignToLoop/array_assign_to_loop.cpp | 4 ++-- .../VectorAssignToLoop/array_assign_to_loop.h | 2 +- src/Utils/SgUtils.cpp | 2 +- src/Utils/module_utils.cpp | 2 +- src/Utils/utils.cpp | 2 +- src/VerificationCode/CorrectVarDecl.cpp | 4 ++-- src/VerificationCode/IncludeChecker.cpp | 6 +++--- src/VerificationCode/StructureChecker.cpp | 6 +++--- src/VerificationCode/VerifySageStructures.cpp | 4 ++-- src/VerificationCode/verifications.h | 4 ++-- src/VisualizerCalls/BuildGraph.cpp | 2 +- src/VisualizerCalls/SendMessage.cpp | 2 +- src/VisualizerCalls/get_information.cpp | 10 +++++----- 118 files changed, 250 insertions(+), 250 deletions(-) diff --git a/src/CFGraph/CFGraph.cpp b/src/CFGraph/CFGraph.cpp index 56af300..a529705 100644 --- a/src/CFGraph/CFGraph.cpp +++ b/src/CFGraph/CFGraph.cpp @@ -8,8 +8,8 @@ #include #include -#include "../Utils/SgUtils.h" -#include "../Utils/CommonBlock.h" +#include "SgUtils.h" +#include "CommonBlock.h" #include "graph_calls.h" #include "dvm.h" diff --git a/src/CFGraph/DataFlow/backward_data_flow.h b/src/CFGraph/DataFlow/backward_data_flow.h index 556af90..bdccf02 100644 --- a/src/CFGraph/DataFlow/backward_data_flow.h +++ b/src/CFGraph/DataFlow/backward_data_flow.h @@ -5,7 +5,7 @@ #include #include -#include "../../Utils/SgUtils.h" +#include "SgUtils.h" #include "../CFGraph.h" #include "../IR.h" diff --git a/src/CFGraph/DataFlow/backward_data_flow_impl.h b/src/CFGraph/DataFlow/backward_data_flow_impl.h index 4578e7b..ae52690 100644 --- a/src/CFGraph/DataFlow/backward_data_flow_impl.h +++ b/src/CFGraph/DataFlow/backward_data_flow_impl.h @@ -5,7 +5,7 @@ #include #include -#include "../../Utils/SgUtils.h" +#include "SgUtils.h" #include "../CFGraph.h" #include "../IR.h" #include "../RD_subst.h" diff --git a/src/CFGraph/DataFlow/data_flow.h b/src/CFGraph/DataFlow/data_flow.h index d58755f..d4b6b3b 100644 --- a/src/CFGraph/DataFlow/data_flow.h +++ b/src/CFGraph/DataFlow/data_flow.h @@ -2,7 +2,7 @@ #include #include -#include "../../Utils/SgUtils.h" +#include "SgUtils.h" #include "../CFGraph.h" #include "../IR.h" diff --git a/src/CFGraph/DataFlow/data_flow_impl.h b/src/CFGraph/DataFlow/data_flow_impl.h index c6a88f6..5a414eb 100644 --- a/src/CFGraph/DataFlow/data_flow_impl.h +++ b/src/CFGraph/DataFlow/data_flow_impl.h @@ -4,7 +4,7 @@ #include #include -#include "../../Utils/SgUtils.h" +#include "SgUtils.h" #include "../CFGraph.h" #include "../IR.h" diff --git a/src/CFGraph/IR.cpp b/src/CFGraph/IR.cpp index 9c110f8..cd2d0ae 100644 --- a/src/CFGraph/IR.cpp +++ b/src/CFGraph/IR.cpp @@ -5,8 +5,8 @@ #include #include -#include "../Utils/SgUtils.h" -#include "../Utils/CommonBlock.h" +#include "SgUtils.h" +#include "CommonBlock.h" #include "graph_calls.h" #include "expr_transform.h" diff --git a/src/CFGraph/IR.h b/src/CFGraph/IR.h index a887a39..97998ac 100644 --- a/src/CFGraph/IR.h +++ b/src/CFGraph/IR.h @@ -6,7 +6,7 @@ #include #include "CFGraph.h" -#include "../Utils/CommonBlock.h" +#include "CommonBlock.h" namespace SAPFOR { diff --git a/src/CFGraph/RD_subst.cpp b/src/CFGraph/RD_subst.cpp index 4f48deb..ac6f00a 100644 --- a/src/CFGraph/RD_subst.cpp +++ b/src/CFGraph/RD_subst.cpp @@ -8,8 +8,8 @@ #include #include -#include "../Utils/SgUtils.h" -#include "../Utils/CommonBlock.h" +#include "SgUtils.h" +#include "CommonBlock.h" #include "graph_calls.h" #include "expr_transform.h" diff --git a/src/CFGraph/RD_subst.h b/src/CFGraph/RD_subst.h index d9e4143..e51c51b 100644 --- a/src/CFGraph/RD_subst.h +++ b/src/CFGraph/RD_subst.h @@ -2,8 +2,8 @@ #include -#include "../Utils/SgUtils.h" -#include "../Utils/CommonBlock.h" +#include "SgUtils.h" +#include "CommonBlock.h" #include "graph_calls.h" #include "CFGraph.h" diff --git a/src/CFGraph/live_variable_analysis.h b/src/CFGraph/live_variable_analysis.h index 9b92523..b5c2d17 100644 --- a/src/CFGraph/live_variable_analysis.h +++ b/src/CFGraph/live_variable_analysis.h @@ -1,6 +1,6 @@ #pragma once -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "CFGraph.h" namespace LIVE_VARIABLES diff --git a/src/CFGraph/private_variables_analysis.cpp b/src/CFGraph/private_variables_analysis.cpp index 72f5fc9..1a5b24a 100644 --- a/src/CFGraph/private_variables_analysis.cpp +++ b/src/CFGraph/private_variables_analysis.cpp @@ -1,6 +1,6 @@ -#include "../Utils/errors.h" +#include "errors.h" #include "private_variables_analysis.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "../SageAnalysisTool/depGraph.h" #include "../DirectiveProcessing/directive_parser.h" diff --git a/src/CFGraph/private_variables_analysis.h b/src/CFGraph/private_variables_analysis.h index 649b5cf..59bbb7d 100644 --- a/src/CFGraph/private_variables_analysis.h +++ b/src/CFGraph/private_variables_analysis.h @@ -1,5 +1,5 @@ -#include "../Utils/SgUtils.h" -#include "../GraphLoop/graph_loops.h" +#include "SgUtils.h" +#include "graph_loops.h" #include "CFGraph.h" #include diff --git a/src/CreateInterTree/CreateInterTree.cpp b/src/CreateInterTree/CreateInterTree.cpp index 2699766..c48a111 100644 --- a/src/CreateInterTree/CreateInterTree.cpp +++ b/src/CreateInterTree/CreateInterTree.cpp @@ -1,7 +1,7 @@ #include "CreateInterTree.h" -#include "../Utils/SgUtils.h" -#include "../Utils/utils.h" -#include "../GraphCall/graph_calls_func.h" +#include "SgUtils.h" +#include "utils.h" +#include "graph_calls_func.h" using std::string; using std::wstring; diff --git a/src/CreateInterTree/CreateInterTree.h b/src/CreateInterTree/CreateInterTree.h index d6147a3..74f87db 100644 --- a/src/CreateInterTree/CreateInterTree.h +++ b/src/CreateInterTree/CreateInterTree.h @@ -8,7 +8,7 @@ #include "dvm.h" -#include "../GraphLoop/graph_loops_func.h" +#include "graph_loops_func.h" struct SpfInterval { diff --git a/src/DirectiveProcessing/directive_analyzer.cpp b/src/DirectiveProcessing/directive_analyzer.cpp index 00d7dd2..198b86a 100644 --- a/src/DirectiveProcessing/directive_analyzer.cpp +++ b/src/DirectiveProcessing/directive_analyzer.cpp @@ -16,9 +16,9 @@ #include #include "../Distribution/DvmhDirective.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "directive_analyzer.h" -#include "../Utils/utils.h" +#include "utils.h" using std::vector; using std::map; diff --git a/src/DirectiveProcessing/directive_analyzer.h b/src/DirectiveProcessing/directive_analyzer.h index 28892b2..bec85df 100644 --- a/src/DirectiveProcessing/directive_analyzer.h +++ b/src/DirectiveProcessing/directive_analyzer.h @@ -1,6 +1,6 @@ #pragma once #include -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" void UniteNestedDirectives(std::vector &loopGraph); diff --git a/src/DirectiveProcessing/directive_creator.cpp b/src/DirectiveProcessing/directive_creator.cpp index 56225e3..1601d27 100644 --- a/src/DirectiveProcessing/directive_creator.cpp +++ b/src/DirectiveProcessing/directive_creator.cpp @@ -15,18 +15,18 @@ #include "../Distribution/Distribution.h" #include "../Distribution/DvmhDirective_func.h" -#include "../Utils/errors.h" +#include "errors.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "directive_parser.h" #include "directive_creator.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "../Sapfor.h" -#include "../GraphLoop/graph_loops_func.h" +#include "graph_loops_func.h" #include "../Transformations/LoopNesting/loop_transform.h" #include "expr_transform.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" -#include "../Utils/AstWrapper.h" +#include "AstWrapper.h" #define PRINT_DIR_RESULT 0 diff --git a/src/DirectiveProcessing/directive_creator.h b/src/DirectiveProcessing/directive_creator.h index c2f24cd..5b20b8b 100644 --- a/src/DirectiveProcessing/directive_creator.h +++ b/src/DirectiveProcessing/directive_creator.h @@ -1,9 +1,9 @@ #pragma once #include "../Distribution/Distribution.h" -#include "../Utils/errors.h" -#include "../GraphLoop/graph_loops.h" -#include "../Utils/types.h" +#include "errors.h" +#include "graph_loops.h" +#include "types.h" void createParallelDirectives(const std::map> &loopInfo, const std::vector& regions, diff --git a/src/DirectiveProcessing/directive_creator_base.cpp b/src/DirectiveProcessing/directive_creator_base.cpp index 7cb2d4f..7cdb252 100644 --- a/src/DirectiveProcessing/directive_creator_base.cpp +++ b/src/DirectiveProcessing/directive_creator_base.cpp @@ -12,7 +12,7 @@ #include "../Distribution/Arrays.h" #include "../Transformations/LoopNesting/loop_transform.h" -#include "../Utils/errors.h" +#include "errors.h" #include "directive_parser.h" #include "directive_creator.h" diff --git a/src/DirectiveProcessing/directive_omp_parser.cpp b/src/DirectiveProcessing/directive_omp_parser.cpp index 3fd3a92..b54fa3f 100644 --- a/src/DirectiveProcessing/directive_omp_parser.cpp +++ b/src/DirectiveProcessing/directive_omp_parser.cpp @@ -9,7 +9,7 @@ #include "directive_omp_parser.h" #include "directive_parser.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" using std::vector; using std::map; diff --git a/src/DirectiveProcessing/directive_omp_parser.h b/src/DirectiveProcessing/directive_omp_parser.h index 8895289..a34adea 100644 --- a/src/DirectiveProcessing/directive_omp_parser.h +++ b/src/DirectiveProcessing/directive_omp_parser.h @@ -4,7 +4,7 @@ #include #include -#include "../Utils/errors.h" +#include "errors.h" #define SPF_USER_DIR 777 #define SPF_USER_DIR_COPY 999 diff --git a/src/DirectiveProcessing/directive_parser.cpp b/src/DirectiveProcessing/directive_parser.cpp index 3e4b901..e653f26 100644 --- a/src/DirectiveProcessing/directive_parser.cpp +++ b/src/DirectiveProcessing/directive_parser.cpp @@ -12,10 +12,10 @@ #include #include "directive_parser.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "../LoopAnalyzer/loop_analyzer.h" -#include "../Utils/AstWrapper.h" -#include "../Utils/errors.h" +#include "AstWrapper.h" +#include "errors.h" using std::string; using std::vector; diff --git a/src/DirectiveProcessing/directive_parser.h b/src/DirectiveProcessing/directive_parser.h index 4f6bd3c..f632940 100644 --- a/src/DirectiveProcessing/directive_parser.h +++ b/src/DirectiveProcessing/directive_parser.h @@ -4,8 +4,8 @@ #include #include -#include "../Utils/AstWrapper.h" -#include "../GraphLoop/graph_loops.h" +#include "AstWrapper.h" +#include "graph_loops.h" #include "../Distribution/DvmhDirective.h" struct DvmDirective diff --git a/src/DirectiveProcessing/insert_directive.cpp b/src/DirectiveProcessing/insert_directive.cpp index e2d1ed2..c927150 100644 --- a/src/DirectiveProcessing/insert_directive.cpp +++ b/src/DirectiveProcessing/insert_directive.cpp @@ -16,13 +16,13 @@ #include "../Distribution/Arrays.h" #include "../Distribution/Distribution.h" #include "../Distribution/DvmhDirective_func.h" -#include "../GraphLoop/graph_loops_func.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_loops_func.h" +#include "graph_calls_func.h" -#include "../Utils/errors.h" +#include "errors.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "directive_parser.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "../Sapfor.h" #include "directive_creator.h" #include "insert_directive.h" diff --git a/src/DirectiveProcessing/remote_access.cpp b/src/DirectiveProcessing/remote_access.cpp index 1df252b..0323cf1 100644 --- a/src/DirectiveProcessing/remote_access.cpp +++ b/src/DirectiveProcessing/remote_access.cpp @@ -18,13 +18,13 @@ #include "dvm.h" #include "../LoopAnalyzer/loop_analyzer.h" -#include "../Utils/types.h" -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" +#include "types.h" +#include "errors.h" +#include "SgUtils.h" #include "../Distribution/Arrays.h" #include "graph_calls.h" -#include "../GraphCall/graph_calls_func.h" -#include "../GraphLoop/graph_loops_func.h" +#include "graph_calls_func.h" +#include "graph_loops_func.h" #include "remote_access.h" using std::vector; diff --git a/src/DirectiveProcessing/remote_access_base.cpp b/src/DirectiveProcessing/remote_access_base.cpp index fe027e1..9f2bb39 100644 --- a/src/DirectiveProcessing/remote_access_base.cpp +++ b/src/DirectiveProcessing/remote_access_base.cpp @@ -18,7 +18,7 @@ #include "../Distribution/Arrays.h" #include "graph_calls.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../ParallelizationRegions/ParRegions.h" #include "remote_access.h" diff --git a/src/DirectiveProcessing/shadow.cpp b/src/DirectiveProcessing/shadow.cpp index b0a3b92..ce190ab 100644 --- a/src/DirectiveProcessing/shadow.cpp +++ b/src/DirectiveProcessing/shadow.cpp @@ -5,14 +5,14 @@ #include #include -#include "../Utils/errors.h" -#include "../Utils/utils.h" -#include "../GraphLoop/graph_loops_func.h" +#include "errors.h" +#include "utils.h" +#include "graph_loops_func.h" #include "graph_calls.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "directive_parser.h" #include "../Distribution/DvmhDirective_func.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "expr_transform.h" #include "../CFGraph/CFGraph.h" diff --git a/src/DirectiveProcessing/spf_directive_preproc.cpp b/src/DirectiveProcessing/spf_directive_preproc.cpp index e380df5..6039de6 100644 --- a/src/DirectiveProcessing/spf_directive_preproc.cpp +++ b/src/DirectiveProcessing/spf_directive_preproc.cpp @@ -12,11 +12,11 @@ #include "dvm.h" #include "../Sapfor.h" -#include "../GraphLoop/graph_loops.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_loops.h" +#include "graph_calls_func.h" #include "../SageAnalysisTool/depInterfaceExt.h" -#include "../Utils/SgUtils.h" -#include "../Utils/errors.h" +#include "SgUtils.h" +#include "errors.h" #include "directive_parser.h" #include "expr_transform.h" #include "../LoopAnalyzer/loop_analyzer.h" diff --git a/src/Distribution/Array.cpp b/src/Distribution/Array.cpp index c3cc653..8f0cf0c 100644 --- a/src/Distribution/Array.cpp +++ b/src/Distribution/Array.cpp @@ -1,6 +1,6 @@ #include "Array.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" +#include "errors.h" +#include "utils.h" #include "graph_calls.h" using namespace std; diff --git a/src/Distribution/Array.h b/src/Distribution/Array.h index 74a8a08..2092451 100644 --- a/src/Distribution/Array.h +++ b/src/Distribution/Array.h @@ -7,9 +7,9 @@ #include #include #include "DvmhDirectiveBase.h" -#include "../Utils/utils.h" -#include "../Utils/errors.h" -#include "../Utils/json.hpp" +#include "utils.h" +#include "errors.h" +#include "json.hpp" class Symbol; class Expression; diff --git a/src/Distribution/ArrayAnalysis.cpp b/src/Distribution/ArrayAnalysis.cpp index 56527b7..57ac0d9 100644 --- a/src/Distribution/ArrayAnalysis.cpp +++ b/src/Distribution/ArrayAnalysis.cpp @@ -1,8 +1,8 @@ #include "Array.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" +#include "errors.h" +#include "utils.h" #include "graph_calls.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "../DirectiveProcessing/directive_parser.h" #include "../DirectiveProcessing/directive_omp_parser.h" #include "../LoopAnalyzer/loop_analyzer.h" diff --git a/src/Distribution/CreateDistributionDirs.cpp b/src/Distribution/CreateDistributionDirs.cpp index cdb2720..4ec1342 100644 --- a/src/Distribution/CreateDistributionDirs.cpp +++ b/src/Distribution/CreateDistributionDirs.cpp @@ -14,9 +14,9 @@ #include "GraphCSR.h" #include "Arrays.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" -#include "../GraphLoop/graph_loops.h" +#include "errors.h" +#include "utils.h" +#include "graph_loops.h" using std::vector; using std::set; diff --git a/src/Distribution/CreateDistributionDirs.h b/src/Distribution/CreateDistributionDirs.h index 55c3bee..44eb45d 100644 --- a/src/Distribution/CreateDistributionDirs.h +++ b/src/Distribution/CreateDistributionDirs.h @@ -1,7 +1,7 @@ #pragma once -#include "../GraphLoop/graph_loops.h" -#include "../Utils/errors.h" +#include "graph_loops.h" +#include "errors.h" void createDistributionDirs(DIST::GraphCSR &reducedG, DIST::Arrays &allArrays, DataDirective &dataDirectives, std::map> &allMessages, diff --git a/src/Distribution/Cycle.h b/src/Distribution/Cycle.h index 622bf88..31c7fb5 100644 --- a/src/Distribution/Cycle.h +++ b/src/Distribution/Cycle.h @@ -3,7 +3,7 @@ #include #include -#include "../Utils/types.h" +#include "types.h" namespace Distribution { diff --git a/src/Distribution/Distribution.cpp b/src/Distribution/Distribution.cpp index 1ec89fb..1ff6149 100644 --- a/src/Distribution/Distribution.cpp +++ b/src/Distribution/Distribution.cpp @@ -30,9 +30,9 @@ using namespace std::chrono; #include "Arrays.h" #include "Array.h" #include "Distribution.h" -#include "../Utils/utils.h" -#include "../Utils/errors.h" -#include "../Utils/types.h" +#include "utils.h" +#include "errors.h" +#include "types.h" #include "../Distribution/Cycle.h" #include "../VisualizerCalls/get_information.h" #include "../VisualizerCalls/SendMessage.h" diff --git a/src/Distribution/DvmhDirective.cpp b/src/Distribution/DvmhDirective.cpp index b485a6e..558f4c0 100644 --- a/src/Distribution/DvmhDirective.cpp +++ b/src/Distribution/DvmhDirective.cpp @@ -7,12 +7,12 @@ #include #include -#include "../Utils/types.h" +#include "types.h" #include "DvmhDirective.h" -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" +#include "errors.h" +#include "SgUtils.h" #include "../Sapfor.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "dvm.h" diff --git a/src/Distribution/DvmhDirective.h b/src/Distribution/DvmhDirective.h index 24c5425..0d1b7e0 100644 --- a/src/Distribution/DvmhDirective.h +++ b/src/Distribution/DvmhDirective.h @@ -7,9 +7,9 @@ #include "Array.h" #include "DvmhDirectiveBase.h" -#include "../Utils/AstWrapper.h" -#include "../Utils/types.h" -#include "../Utils/utils.h" +#include "AstWrapper.h" +#include "types.h" +#include "utils.h" extern int sharedMemoryParallelization; diff --git a/src/Distribution/DvmhDirectiveBase.cpp b/src/Distribution/DvmhDirectiveBase.cpp index 0cd3f4c..88f2491 100644 --- a/src/Distribution/DvmhDirectiveBase.cpp +++ b/src/Distribution/DvmhDirectiveBase.cpp @@ -10,11 +10,11 @@ #include "../Distribution/Array.h" #include "../Distribution/Arrays.h" #include "../Distribution/GraphCSR.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" -#include "../Utils/json.hpp" +#include "errors.h" +#include "utils.h" +#include "json.hpp" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" using std::vector; using std::tuple; diff --git a/src/Distribution/DvmhDirectiveBase.h b/src/Distribution/DvmhDirectiveBase.h index d3c98a7..b1bfe90 100644 --- a/src/Distribution/DvmhDirectiveBase.h +++ b/src/Distribution/DvmhDirectiveBase.h @@ -3,7 +3,7 @@ #include #include -#include "../Utils/json.hpp" +#include "json.hpp" typedef enum lang : int { LANG_C, LANG_F } language; typedef enum dist : int { BLOCK, NONE } distType; diff --git a/src/Distribution/DvmhDirective_func.h b/src/Distribution/DvmhDirective_func.h index 78bf560..7d4fa13 100644 --- a/src/Distribution/DvmhDirective_func.h +++ b/src/Distribution/DvmhDirective_func.h @@ -4,7 +4,7 @@ #include #include #include "dvm.h" -#include "../Utils/types.h" +#include "types.h" SgExpression* createAndSetNext(const int side, const int variant, SgExpression *p); std::vector genSubscripts(const std::vector> &shadowRenew, const std::vector> &shadowRenewShifts); diff --git a/src/Distribution/GraphCSR.cpp b/src/Distribution/GraphCSR.cpp index 0a22ff9..1890479 100644 --- a/src/Distribution/GraphCSR.cpp +++ b/src/Distribution/GraphCSR.cpp @@ -19,8 +19,8 @@ extern int passDone; #include "Cycle.h" #include "Arrays.h" #include "Array.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" +#include "errors.h" +#include "utils.h" #include "../VisualizerCalls/get_information.h" #include "../VisualizerCalls/SendMessage.h" diff --git a/src/Distribution/GraphCSR.h b/src/Distribution/GraphCSR.h index c52d665..03024de 100644 --- a/src/Distribution/GraphCSR.h +++ b/src/Distribution/GraphCSR.h @@ -5,7 +5,7 @@ #include #include -#include "../Utils/RationalNum.h" +#include "RationalNum.h" typedef enum links { RR_link, WR_link, WW_link } LinkType; diff --git a/src/DvmhRegions/DvmhRegion.h b/src/DvmhRegions/DvmhRegion.h index 10a9d34..2db6d20 100644 --- a/src/DvmhRegions/DvmhRegion.h +++ b/src/DvmhRegions/DvmhRegion.h @@ -1,6 +1,6 @@ #pragma once -#include "../GraphLoop/graph_loops_func.h" +#include "graph_loops_func.h" #include diff --git a/src/DvmhRegions/DvmhRegionInserter.h b/src/DvmhRegions/DvmhRegionInserter.h index 8d34be1..651428d 100644 --- a/src/DvmhRegions/DvmhRegionInserter.h +++ b/src/DvmhRegions/DvmhRegionInserter.h @@ -1,10 +1,10 @@ #pragma once -#include "../GraphCall/graph_calls_func.h" -#include "../GraphLoop/graph_loops_func.h" +#include "graph_calls_func.h" +#include "graph_loops_func.h" #include "expr_transform.h" #include "../ParallelizationRegions/ParRegions.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "ReadWriteAnalyzer.h" #include "DvmhRegion.h" diff --git a/src/DvmhRegions/LoopChecker.h b/src/DvmhRegions/LoopChecker.h index 793b5ed..6e2c7ae 100644 --- a/src/DvmhRegions/LoopChecker.h +++ b/src/DvmhRegions/LoopChecker.h @@ -1,7 +1,7 @@ #pragma once -#include "../GraphLoop/graph_loops_func.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_loops_func.h" +#include "graph_calls_func.h" #include #include diff --git a/src/DvmhRegions/ReadWriteAnalyzer.h b/src/DvmhRegions/ReadWriteAnalyzer.h index 8e31306..5a9d49f 100644 --- a/src/DvmhRegions/ReadWriteAnalyzer.h +++ b/src/DvmhRegions/ReadWriteAnalyzer.h @@ -1,7 +1,7 @@ #pragma once #include "dvm.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "VarUsages.h" #include #include diff --git a/src/DvmhRegions/TypedSymbol.h b/src/DvmhRegions/TypedSymbol.h index 5e74310..e4b0a03 100644 --- a/src/DvmhRegions/TypedSymbol.h +++ b/src/DvmhRegions/TypedSymbol.h @@ -1,7 +1,7 @@ #pragma once #include "dvm.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include enum class VAR_TYPE { VAR_ARR, VAR_DISTR_ARR, VAR_SCALAR, VAR_ANY, VAR_UNDEFINED }; diff --git a/src/DynamicAnalysis/createParallelRegions.h b/src/DynamicAnalysis/createParallelRegions.h index a75c928..ced7137 100644 --- a/src/DynamicAnalysis/createParallelRegions.h +++ b/src/DynamicAnalysis/createParallelRegions.h @@ -1,6 +1,6 @@ #pragma once -#include "../Utils/utils.h" +#include "utils.h" #include "./gcov_info.h" #include "../CreateInterTree/CreateInterTree.h" diff --git a/src/DynamicAnalysis/gCov_parser.cpp b/src/DynamicAnalysis/gCov_parser.cpp index dd2cb90..53ff70d 100644 --- a/src/DynamicAnalysis/gCov_parser.cpp +++ b/src/DynamicAnalysis/gCov_parser.cpp @@ -8,7 +8,7 @@ #include "dvm.h" #include "gCov_parser_func.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" using namespace std; diff --git a/src/DynamicAnalysis/gCov_parser_func.h b/src/DynamicAnalysis/gCov_parser_func.h index 843d150..87594a9 100644 --- a/src/DynamicAnalysis/gCov_parser_func.h +++ b/src/DynamicAnalysis/gCov_parser_func.h @@ -5,7 +5,7 @@ #include #include "dvm.h" -#include "../Utils/errors.h" +#include "errors.h" #include "gcov_info.h" #include "../CreateInterTree/CreateInterTree.h" diff --git a/src/DynamicAnalysis/gcov_info.cpp b/src/DynamicAnalysis/gcov_info.cpp index c34d64a..0814a68 100644 --- a/src/DynamicAnalysis/gcov_info.cpp +++ b/src/DynamicAnalysis/gcov_info.cpp @@ -4,7 +4,7 @@ #include #include -#include "../Utils/errors.h" +#include "errors.h" #include "gcov_info.h" diff --git a/src/DynamicAnalysis/gcov_info.h b/src/DynamicAnalysis/gcov_info.h index 29f7527..91b09d4 100644 --- a/src/DynamicAnalysis/gcov_info.h +++ b/src/DynamicAnalysis/gcov_info.h @@ -5,7 +5,7 @@ #include #include -#include "../Utils/utils.h" +#include "utils.h" //make 'class' - need friend for Gcov_info struct Perform diff --git a/src/GraphCall/graph_calls.cpp b/src/GraphCall/graph_calls.cpp index 530f9b1..1109d48 100644 --- a/src/GraphCall/graph_calls.cpp +++ b/src/GraphCall/graph_calls.cpp @@ -15,10 +15,10 @@ #include "graph_calls_func.h" #include "../CFGraph/CFGraph.h" -#include "../GraphLoop/graph_loops_func.h" +#include "graph_loops_func.h" #include "../DirectiveProcessing/directive_parser.h" -#include "../Utils/SgUtils.h" -#include "../Utils/json.hpp" +#include "SgUtils.h" +#include "json.hpp" #include "../ParallelizationRegions/ParRegions_func.h" #include "../DynamicAnalysis/gCov_parser_func.h" #include "expr_transform.h" diff --git a/src/GraphCall/graph_calls.h b/src/GraphCall/graph_calls.h index 17fc462..0de481e 100644 --- a/src/GraphCall/graph_calls.h +++ b/src/GraphCall/graph_calls.h @@ -3,10 +3,10 @@ #include #include -#include "../Utils/AstWrapper.h" -#include "../Utils/utils.h" +#include "AstWrapper.h" +#include "utils.h" #include "../DirectiveProcessing/shadow.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" static const char* paramNames[] = { "NONE_T", "ARRAY_T", "STRING_ARRAY_T", "STRING_T", "SCALAR_CHAR_T", "SCALAR_BOOL_T", "SCALAR_SHORT_T", "SCALAR_INT_T", "SCALAR_LONG_INT_T", diff --git a/src/GraphCall/graph_calls_base.cpp b/src/GraphCall/graph_calls_base.cpp index 44bb7d2..fdb6393 100644 --- a/src/GraphCall/graph_calls_base.cpp +++ b/src/GraphCall/graph_calls_base.cpp @@ -10,10 +10,10 @@ #include #include -#include "../Utils/errors.h" +#include "errors.h" #include "graph_calls.h" #include "../Distribution/Distribution.h" -#include "../Utils/utils.h" +#include "utils.h" #include "../ParallelizationRegions/ParRegions.h" using std::vector; diff --git a/src/GraphCall/graph_calls_func.h b/src/GraphCall/graph_calls_func.h index acba4a7..44e029c 100644 --- a/src/GraphCall/graph_calls_func.h +++ b/src/GraphCall/graph_calls_func.h @@ -5,7 +5,7 @@ #include #include "graph_calls.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../ParallelizationRegions/ParRegions.h" #include "Utils/json.hpp" diff --git a/src/GraphLoop/graph_loops.cpp b/src/GraphLoop/graph_loops.cpp index ded6d93..16438ee 100644 --- a/src/GraphLoop/graph_loops.cpp +++ b/src/GraphLoop/graph_loops.cpp @@ -12,7 +12,7 @@ #include "dvm.h" #include "../Sapfor.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "../ParallelizationRegions/ParRegions_func.h" #include "expr_transform.h" @@ -21,12 +21,12 @@ #include "../Distribution/Distribution.h" #include "graph_loops.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" +#include "utils.h" +#include "SgUtils.h" -#include "../Utils/errors.h" -#include "../Utils/AstWrapper.h" -#include "../Utils/json.hpp" +#include "errors.h" +#include "AstWrapper.h" +#include "json.hpp" #include "../DirectiveProcessing/directive_parser.h" #include "../DynamicAnalysis/gCov_parser_func.h" diff --git a/src/GraphLoop/graph_loops.h b/src/GraphLoop/graph_loops.h index 39fd48b..70d12e5 100644 --- a/src/GraphLoop/graph_loops.h +++ b/src/GraphLoop/graph_loops.h @@ -5,8 +5,8 @@ #include #include -#include "../Utils/errors.h" -#include "../Utils/types.h" +#include "errors.h" +#include "types.h" #include "../Distribution/DvmhDirective.h" #include "../Distribution/Distribution.h" diff --git a/src/GraphLoop/graph_loops_base.cpp b/src/GraphLoop/graph_loops_base.cpp index 514c4c5..031a4d6 100644 --- a/src/GraphLoop/graph_loops_base.cpp +++ b/src/GraphLoop/graph_loops_base.cpp @@ -23,8 +23,8 @@ using std::make_pair; using std::get; #include "graph_loops.h" -#include "../GraphCall/graph_calls_func.h" -#include "../Utils/errors.h" +#include "graph_calls_func.h" +#include "errors.h" #include "../Distribution/Distribution.h" #include "../Distribution/CreateDistributionDirs.h" #include "../ParallelizationRegions/ParRegions.h" diff --git a/src/LoopAnalyzer/allocations_prepoc.cpp b/src/LoopAnalyzer/allocations_prepoc.cpp index 9655798..4d714d2 100644 --- a/src/LoopAnalyzer/allocations_prepoc.cpp +++ b/src/LoopAnalyzer/allocations_prepoc.cpp @@ -8,8 +8,8 @@ #include #include "dvm.h" -#include "../Utils/SgUtils.h" -#include "../Utils/errors.h" +#include "SgUtils.h" +#include "errors.h" using std::set; using std::pair; diff --git a/src/LoopAnalyzer/dep_analyzer.cpp b/src/LoopAnalyzer/dep_analyzer.cpp index ecf4f2a..aa17a19 100644 --- a/src/LoopAnalyzer/dep_analyzer.cpp +++ b/src/LoopAnalyzer/dep_analyzer.cpp @@ -20,8 +20,8 @@ #include "dvm.h" #include "loop_analyzer.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" +#include "utils.h" +#include "SgUtils.h" #include "../ParallelizationRegions/ParRegions_func.h" #include "../SageAnalysisTool/depGraph.h" #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h" diff --git a/src/LoopAnalyzer/loop_analyzer.cpp b/src/LoopAnalyzer/loop_analyzer.cpp index b284246..cdbbc7d 100644 --- a/src/LoopAnalyzer/loop_analyzer.cpp +++ b/src/LoopAnalyzer/loop_analyzer.cpp @@ -30,15 +30,15 @@ extern int passDone; #include "../Distribution/Arrays.h" #include "../ParallelizationRegions/ParRegions.h" -#include "../Utils/errors.h" +#include "errors.h" #include "../DirectiveProcessing/directive_parser.h" #include "../DirectiveProcessing/directive_creator.h" -#include "../Utils/SgUtils.h" -#include "../Utils/AstWrapper.h" +#include "SgUtils.h" +#include "AstWrapper.h" -#include "../GraphCall/graph_calls_func.h" -#include "../GraphLoop/graph_loops_func.h" +#include "graph_calls_func.h" +#include "graph_loops_func.h" #include "../ParallelizationRegions/ParRegions_func.h" #include "../DynamicAnalysis/gCov_parser_func.h" diff --git a/src/LoopAnalyzer/loop_analyzer.h b/src/LoopAnalyzer/loop_analyzer.h index ececa21..96e18d2 100644 --- a/src/LoopAnalyzer/loop_analyzer.h +++ b/src/LoopAnalyzer/loop_analyzer.h @@ -5,12 +5,12 @@ #include #include #include -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "graph_calls.h" #include "../ParallelizationRegions/ParRegions.h" #include "../SageAnalysisTool/depInterfaceExt.h" -#include "../Utils/AstWrapper.h" -#include "../Utils/SgUtils.h" +#include "AstWrapper.h" +#include "SgUtils.h" #include "dvm.h" diff --git a/src/ParallelizationRegions/ParRegions.cpp b/src/ParallelizationRegions/ParRegions.cpp index 903fa5e..a05d827 100644 --- a/src/ParallelizationRegions/ParRegions.cpp +++ b/src/ParallelizationRegions/ParRegions.cpp @@ -10,10 +10,10 @@ #include "dvm.h" #include "ParRegions.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" -#include "../GraphCall/graph_calls_func.h" -#include "../GraphLoop/graph_loops.h" +#include "utils.h" +#include "SgUtils.h" +#include "graph_calls_func.h" +#include "graph_loops.h" #include "../Distribution/Distribution.h" #include "expr_transform.h" diff --git a/src/ParallelizationRegions/ParRegions.h b/src/ParallelizationRegions/ParRegions.h index d613d31..6f78563 100644 --- a/src/ParallelizationRegions/ParRegions.h +++ b/src/ParallelizationRegions/ParRegions.h @@ -9,12 +9,12 @@ #include "../Distribution/DvmhDirective.h" #include "../Distribution/GraphCSR.h" #include "../Distribution/Distribution.h" -#include "../Utils/AstWrapper.h" +#include "AstWrapper.h" -#include "../Utils/json.hpp" +#include "json.hpp" #if __SPF -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #endif struct ParallelRegionLines diff --git a/src/ParallelizationRegions/ParRegions_func.h b/src/ParallelizationRegions/ParRegions_func.h index 6420a37..d1ac9b8 100644 --- a/src/ParallelizationRegions/ParRegions_func.h +++ b/src/ParallelizationRegions/ParRegions_func.h @@ -2,7 +2,7 @@ #include "ParRegions.h" #include "graph_calls.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" void fillRegionLines(SgFile *file, std::vector ®ions, std::vector& messagesForFile, std::vector *loops = NULL, std::vector *funcs = NULL); void fillRegionLinesStep2(std::vector ®ions, const std::map> &allFuncInfo, std::map> *loopGraph = NULL); diff --git a/src/ParallelizationRegions/expand_extract_reg.h b/src/ParallelizationRegions/expand_extract_reg.h index c1e0d50..2040a9d 100644 --- a/src/ParallelizationRegions/expand_extract_reg.h +++ b/src/ParallelizationRegions/expand_extract_reg.h @@ -1,7 +1,7 @@ #pragma once #include "ParRegions.h" -#include "../Utils/SgUtils.h" -#include "../Utils/errors.h" +#include "SgUtils.h" +#include "errors.h" bool expandExtractReg(const std::string &fileName, const int startLine, const int endLine, const std::vector ®ions, std::vector &messagesForFile, const bool toDelete = false); diff --git a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp b/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp index 43d842f..dc77d6a 100644 --- a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp +++ b/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp @@ -11,12 +11,12 @@ #include "ParRegions_func.h" #include "resolve_par_reg_conflicts.h" -#include "../GraphCall/graph_calls_func.h" -#include "../GraphLoop/graph_loops_func.h" +#include "graph_calls_func.h" +#include "graph_loops_func.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "../DirectiveProcessing/directive_creator.h" #include "../DirectiveProcessing/insert_directive.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "expr_transform.h" #include "../Transformations/FunctionPurifying/function_purifying.h" diff --git a/src/ParallelizationRegions/resolve_par_reg_conflicts.h b/src/ParallelizationRegions/resolve_par_reg_conflicts.h index 1523306..cfaecbe 100644 --- a/src/ParallelizationRegions/resolve_par_reg_conflicts.h +++ b/src/ParallelizationRegions/resolve_par_reg_conflicts.h @@ -1,8 +1,8 @@ #pragma once #include "ParRegions.h" -#include "../Utils/SgUtils.h" -#include "../Utils/errors.h" +#include "SgUtils.h" +#include "errors.h" #include "graph_calls.h" void fillRegionIntervals(std::vector ®ions); diff --git a/src/Predictor/PredictScheme.cpp b/src/Predictor/PredictScheme.cpp index 146427d..4e09007 100644 --- a/src/Predictor/PredictScheme.cpp +++ b/src/Predictor/PredictScheme.cpp @@ -16,10 +16,10 @@ #include "../DynamicAnalysis/gcov_info.h" #include "../DynamicAnalysis/gCov_parser_func.h" #include "PredictScheme.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "../DirectiveProcessing/directive_parser.h" #include "../Distribution/DvmhDirective.h" -#include "../GraphLoop/graph_loops_func.h" +#include "graph_loops_func.h" #include "expr_transform.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "../CFGraph/CFGraph.h" diff --git a/src/Predictor/PredictScheme.h b/src/Predictor/PredictScheme.h index b8fb310..a9c91f2 100644 --- a/src/Predictor/PredictScheme.h +++ b/src/Predictor/PredictScheme.h @@ -2,7 +2,7 @@ #include #include "dvm.h" #include "graph_calls.h" -#include "../Utils/json.hpp" +#include "json.hpp" class ParallelStats { diff --git a/src/PrivateAnalyzer/private_arrays_search.cpp b/src/PrivateAnalyzer/private_arrays_search.cpp index 985baf6..36a6a18 100644 --- a/src/PrivateAnalyzer/private_arrays_search.cpp +++ b/src/PrivateAnalyzer/private_arrays_search.cpp @@ -9,8 +9,8 @@ #include "private_arrays_search.h" #include "range_structures.h" #include "region.h" -#include "../Utils/SgUtils.h" -#include "../GraphLoop/graph_loops.h" +#include "SgUtils.h" +#include "graph_loops.h" #include "../CFGraph/CFGraph.h" using namespace std; diff --git a/src/PrivateAnalyzer/private_arrays_search.h b/src/PrivateAnalyzer/private_arrays_search.h index 2faaa27..504349d 100644 --- a/src/PrivateAnalyzer/private_arrays_search.h +++ b/src/PrivateAnalyzer/private_arrays_search.h @@ -6,7 +6,7 @@ #include "range_structures.h" #include "region.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../CFGraph/CFGraph.h" void Collapse(Region* region); diff --git a/src/PrivateAnalyzer/region.cpp b/src/PrivateAnalyzer/region.cpp index 54540d2..5030fe3 100644 --- a/src/PrivateAnalyzer/region.cpp +++ b/src/PrivateAnalyzer/region.cpp @@ -8,7 +8,7 @@ #include "range_structures.h" #include "region.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" using namespace std; diff --git a/src/PrivateAnalyzer/region.h b/src/PrivateAnalyzer/region.h index 95121b2..4a474ca 100644 --- a/src/PrivateAnalyzer/region.h +++ b/src/PrivateAnalyzer/region.h @@ -5,7 +5,7 @@ #include #include -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../CFGraph/CFGraph.h" class Region : public SAPFOR::BasicBlock { diff --git a/src/ProjectManipulation/ConvertFiles.cpp b/src/ProjectManipulation/ConvertFiles.cpp index 1fd7715..ecfe69a 100644 --- a/src/ProjectManipulation/ConvertFiles.cpp +++ b/src/ProjectManipulation/ConvertFiles.cpp @@ -6,9 +6,9 @@ #include #include -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" -#include "../Utils/utils.h" +#include "errors.h" +#include "SgUtils.h" +#include "utils.h" #include "../VerificationCode/verifications.h" diff --git a/src/ProjectManipulation/FileInfo.cpp b/src/ProjectManipulation/FileInfo.cpp index 7aa5215..d7de1b1 100644 --- a/src/ProjectManipulation/FileInfo.cpp +++ b/src/ProjectManipulation/FileInfo.cpp @@ -7,8 +7,8 @@ #include #include "FileInfo.h" -#include "../Utils/utils.h" -#include "../Utils/errors.h" +#include "utils.h" +#include "errors.h" using namespace std; diff --git a/src/ProjectManipulation/ParseFiles.cpp b/src/ProjectManipulation/ParseFiles.cpp index 3e6e40a..45a68a2 100644 --- a/src/ProjectManipulation/ParseFiles.cpp +++ b/src/ProjectManipulation/ParseFiles.cpp @@ -22,8 +22,8 @@ #include #include -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" +#include "errors.h" +#include "SgUtils.h" #include "../VisualizerCalls/get_information.h" #include "../VisualizerCalls/SendMessage.h" diff --git a/src/ProjectManipulation/PerfAnalyzer.cpp b/src/ProjectManipulation/PerfAnalyzer.cpp index f8579d1..bc2428a 100644 --- a/src/ProjectManipulation/PerfAnalyzer.cpp +++ b/src/ProjectManipulation/PerfAnalyzer.cpp @@ -6,8 +6,8 @@ #include #include -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" +#include "errors.h" +#include "SgUtils.h" #include "StdCapture.h" diff --git a/src/ProjectParameters/projectParameters.cpp b/src/ProjectParameters/projectParameters.cpp index 64531b1..d8d96d9 100644 --- a/src/ProjectParameters/projectParameters.cpp +++ b/src/ProjectParameters/projectParameters.cpp @@ -12,10 +12,10 @@ #include #include "dvm.h" -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" +#include "errors.h" +#include "SgUtils.h" #include "graph_calls.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "projectParameters.h" diff --git a/src/SageAnalysisTool/defUse.cpp b/src/SageAnalysisTool/defUse.cpp index 24ade01..fea079a 100644 --- a/src/SageAnalysisTool/defUse.cpp +++ b/src/SageAnalysisTool/defUse.cpp @@ -5,8 +5,8 @@ #include #include "graph_calls.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" +#include "errors.h" +#include "utils.h" #include "sage++user.h" #include "definesValues.h" #include "set.h" diff --git a/src/SageAnalysisTool/depGraph.cpp b/src/SageAnalysisTool/depGraph.cpp index 78a1e6d..800cc45 100644 --- a/src/SageAnalysisTool/depGraph.cpp +++ b/src/SageAnalysisTool/depGraph.cpp @@ -16,7 +16,7 @@ extern "C" void removeFromCollection(void *pointer); extern int passDone; #include "graph_calls.h" -#include "../Utils/errors.h" +#include "errors.h" #include "../VisualizerCalls/get_information.h" #include "sage++user.h" diff --git a/src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp b/src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp index 64685e7..7ebc316 100644 --- a/src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp +++ b/src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp @@ -11,9 +11,9 @@ #include "../Distribution/Array.h" #include "dvm.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" +#include "errors.h" +#include "utils.h" +#include "SgUtils.h" using namespace std; diff --git a/src/Transformations/CheckPoints/checkpoints.cpp b/src/Transformations/CheckPoints/checkpoints.cpp index 2549f6c..372d62e 100644 --- a/src/Transformations/CheckPoints/checkpoints.cpp +++ b/src/Transformations/CheckPoints/checkpoints.cpp @@ -4,8 +4,8 @@ #include #include -#include "../Utils/SgUtils.h" -#include "../Utils/utils.h" +#include "SgUtils.h" +#include "utils.h" #include "expr_transform.h" #include "checkpoints.h" diff --git a/src/Transformations/DeadCodeRemoving/dead_code.h b/src/Transformations/DeadCodeRemoving/dead_code.h index 741acff..8f7b1fa 100644 --- a/src/Transformations/DeadCodeRemoving/dead_code.h +++ b/src/Transformations/DeadCodeRemoving/dead_code.h @@ -3,7 +3,7 @@ #include #include -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "../CFGraph/CFGraph.h" #include "../CFGraph/live_variable_analysis.h" #include "../CFGraph/DataFlow/data_flow.h" diff --git a/src/Transformations/ExpressionSubstitution/expr_transform.cpp b/src/Transformations/ExpressionSubstitution/expr_transform.cpp index e8db58d..eff3540 100644 --- a/src/Transformations/ExpressionSubstitution/expr_transform.cpp +++ b/src/Transformations/ExpressionSubstitution/expr_transform.cpp @@ -19,11 +19,11 @@ extern int passDone; #include "../ParallelizationRegions/ParRegions.h" #include "../ParallelizationRegions/ParRegions_func.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "graph_calls.h" -#include "../GraphCall/graph_calls_func.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" +#include "graph_calls_func.h" +#include "utils.h" +#include "SgUtils.h" #include "../Distribution/Distribution.h" #include "../VisualizerCalls/get_information.h" #include "expr_transform.h" diff --git a/src/Transformations/ExpressionSubstitution/expr_transform.h b/src/Transformations/ExpressionSubstitution/expr_transform.h index c9924d5..d79cd06 100644 --- a/src/Transformations/ExpressionSubstitution/expr_transform.h +++ b/src/Transformations/ExpressionSubstitution/expr_transform.h @@ -5,10 +5,10 @@ #include #include "dvm.h" #include "../Distribution/Distribution.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../ParallelizationRegions/ParRegions.h" #include "graph_calls.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "acc_analyzer.h" diff --git a/src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp b/src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp index 8bf71db..b2e5eb9 100644 --- a/src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp +++ b/src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp @@ -12,12 +12,12 @@ #include #include "dvm.h" -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" +#include "errors.h" +#include "SgUtils.h" #include "uniq_call_chain_dup.h" #include "graph_calls.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "expr_transform.h" #include "../VerificationCode/verifications.h" diff --git a/src/Transformations/FunctionInlining/inliner.cpp b/src/Transformations/FunctionInlining/inliner.cpp index 5a00fae..209cffd 100644 --- a/src/Transformations/FunctionInlining/inliner.cpp +++ b/src/Transformations/FunctionInlining/inliner.cpp @@ -8,10 +8,10 @@ #include #include "dvm.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" -#include "../GraphCall/graph_calls_func.h" +#include "errors.h" +#include "utils.h" +#include "SgUtils.h" +#include "graph_calls_func.h" #include "inliner.h" #include "../VisualizerCalls/SendMessage.h" #include "expr_transform.h" diff --git a/src/Transformations/FunctionPurifying/function_purifying.cpp b/src/Transformations/FunctionPurifying/function_purifying.cpp index af93f22..2eb2470 100644 --- a/src/Transformations/FunctionPurifying/function_purifying.cpp +++ b/src/Transformations/FunctionPurifying/function_purifying.cpp @@ -11,10 +11,10 @@ #include #include "dvm.h" -#include "../GraphCall/graph_calls_func.h" -#include "../Utils/SgUtils.h" -#include "../Utils/CommonBlock.h" -#include "../Utils/DefUseList.h" +#include "graph_calls_func.h" +#include "SgUtils.h" +#include "CommonBlock.h" +#include "DefUseList.h" #include "expr_transform.h" #include "../VerificationCode/verifications.h" #include "../DvmhRegions/DvmhRegionInserter.h" diff --git a/src/Transformations/GlobalVariables/fix_common_blocks.h b/src/Transformations/GlobalVariables/fix_common_blocks.h index 8c0ff32..13bbd3e 100644 --- a/src/Transformations/GlobalVariables/fix_common_blocks.h +++ b/src/Transformations/GlobalVariables/fix_common_blocks.h @@ -8,7 +8,7 @@ #include #include "dvm.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "../LoopAnalyzer/loop_analyzer.h" #include "expr_transform.h" diff --git a/src/Transformations/LoopCombining/loops_combiner.cpp b/src/Transformations/LoopCombining/loops_combiner.cpp index 81ca24c..747839a 100644 --- a/src/Transformations/LoopCombining/loops_combiner.cpp +++ b/src/Transformations/LoopCombining/loops_combiner.cpp @@ -2,8 +2,8 @@ #include "../LoopAnalyzer/loop_analyzer.h" #include "expr_transform.h" -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" +#include "errors.h" +#include "SgUtils.h" #include #include #include diff --git a/src/Transformations/LoopCombining/loops_combiner.h b/src/Transformations/LoopCombining/loops_combiner.h index 49244f6..9153a1e 100644 --- a/src/Transformations/LoopCombining/loops_combiner.h +++ b/src/Transformations/LoopCombining/loops_combiner.h @@ -1,7 +1,7 @@ #pragma once #include "dvm.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../SageAnalysisTool/depGraph.h" #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h" #include "../DirectiveProcessing/directive_parser.h" diff --git a/src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp b/src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp index 511b743..4f1c253 100644 --- a/src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp +++ b/src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp @@ -11,9 +11,9 @@ #include "dvm.h" #include "enddo_loop_converter.h" -#include "../Utils/errors.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" +#include "errors.h" +#include "utils.h" +#include "SgUtils.h" using namespace std; diff --git a/src/Transformations/LoopEndDoConverter/enddo_loop_converter.h b/src/Transformations/LoopEndDoConverter/enddo_loop_converter.h index 6de9691..39a307b 100644 --- a/src/Transformations/LoopEndDoConverter/enddo_loop_converter.h +++ b/src/Transformations/LoopEndDoConverter/enddo_loop_converter.h @@ -1,6 +1,6 @@ #pragma once -#include "../Utils/errors.h" +#include "errors.h" void ConverToEndDo(SgFile *file, std::vector &messagesForFile); std::vector createIfConditions(std::stack& conds, std::stack& ifBlocks, SgStatement *control); diff --git a/src/Transformations/LoopNesting/loop_transform.cpp b/src/Transformations/LoopNesting/loop_transform.cpp index 6679deb..41e4394 100644 --- a/src/Transformations/LoopNesting/loop_transform.cpp +++ b/src/Transformations/LoopNesting/loop_transform.cpp @@ -8,9 +8,9 @@ #include "../DirectiveProcessing/directive_parser.h" #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h" #include "../SageAnalysisTool/definesValues.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "../SageAnalysisTool/depGraph.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" using std::pair; using std::map; diff --git a/src/Transformations/LoopNesting/loop_transform.h b/src/Transformations/LoopNesting/loop_transform.h index 3713dba..49c5378 100644 --- a/src/Transformations/LoopNesting/loop_transform.h +++ b/src/Transformations/LoopNesting/loop_transform.h @@ -1,7 +1,7 @@ #pragma once #include -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" void reverseCreatedNestedLoops(const std::string &file, std::vector &loopsInFile); bool createNestedLoops(LoopGraph *current, const std::map &depInfoForLoopGraph, diff --git a/src/Transformations/LoopSplitting/loops_splitter.cpp b/src/Transformations/LoopSplitting/loops_splitter.cpp index 09065d7..07d5776 100644 --- a/src/Transformations/LoopSplitting/loops_splitter.cpp +++ b/src/Transformations/LoopSplitting/loops_splitter.cpp @@ -5,7 +5,7 @@ #include "../LoopAnalyzer/loop_analyzer.h" #include "expr_transform.h" -#include "../Utils/errors.h" +#include "errors.h" #include "../CFGraph/CFGraph.h" #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h" #include "../DirectiveProcessing/directive_parser.h" diff --git a/src/Transformations/LoopSplitting/loops_splitter.h b/src/Transformations/LoopSplitting/loops_splitter.h index 9bdaa5e..084387b 100644 --- a/src/Transformations/LoopSplitting/loops_splitter.h +++ b/src/Transformations/LoopSplitting/loops_splitter.h @@ -4,8 +4,8 @@ #include #include "dvm.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../SageAnalysisTool/depGraph.h" -#include "../Utils/CommonBlock.h" +#include "CommonBlock.h" int splitLoops(SgFile *file, std::vector &loopGraphs, std::vector &messages, const std::map& depInfoForLoopGraph, const std::map& commonBlocks, const std::map>& allFuncInfo, int& countOfTransform); diff --git a/src/Transformations/LoopUnrolling/loops_unrolling.cpp b/src/Transformations/LoopUnrolling/loops_unrolling.cpp index 214c5ab..79fc511 100644 --- a/src/Transformations/LoopUnrolling/loops_unrolling.cpp +++ b/src/Transformations/LoopUnrolling/loops_unrolling.cpp @@ -1,8 +1,8 @@ #include "loops_unrolling.h" #include "../LoopAnalyzer/loop_analyzer.h" -#include "../Utils/errors.h" -#include "../GraphLoop/graph_loops_func.h" +#include "errors.h" +#include "graph_loops_func.h" #include #include diff --git a/src/Transformations/LoopUnrolling/loops_unrolling.h b/src/Transformations/LoopUnrolling/loops_unrolling.h index 4664fcc..f04c2ce 100644 --- a/src/Transformations/LoopUnrolling/loops_unrolling.h +++ b/src/Transformations/LoopUnrolling/loops_unrolling.h @@ -1,7 +1,7 @@ #pragma once #include "dvm.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include int unrollLoops(SgFile* file, std::vector& loopGraph, std::vector& messages); \ No newline at end of file diff --git a/src/Transformations/PrivateArrayRemoving/private_removing.cpp b/src/Transformations/PrivateArrayRemoving/private_removing.cpp index 5589073..0ddd7a6 100644 --- a/src/Transformations/PrivateArrayRemoving/private_removing.cpp +++ b/src/Transformations/PrivateArrayRemoving/private_removing.cpp @@ -1,8 +1,8 @@ #include "private_removing.h" -#include "../Utils/errors.h" -#include "../Utils/SgUtils.h" -#include "../Utils/utils.h" +#include "errors.h" +#include "SgUtils.h" +#include "utils.h" #include "expr_transform.h" #include "../DeadCodeRemoving/dead_code.h" diff --git a/src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp b/src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp index 25d2766..d2d4a58 100644 --- a/src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp +++ b/src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp @@ -1,8 +1,8 @@ #include "private_arrays_resizing.h" -#include "../GraphLoop/graph_loops.h" -#include "../Utils/SgUtils.h" -#include "../Utils/utils.h" -#include "../Utils/errors.h" +#include "graph_loops.h" +#include "SgUtils.h" +#include "utils.h" +#include "errors.h" #include "../DirectiveProcessing/directive_parser.h" #include "../LoopAnalyzer/loop_analyzer.h" diff --git a/src/Transformations/PrivateArrayResizing/private_arrays_resizing.h b/src/Transformations/PrivateArrayResizing/private_arrays_resizing.h index 1ad162d..e5f00a3 100644 --- a/src/Transformations/PrivateArrayResizing/private_arrays_resizing.h +++ b/src/Transformations/PrivateArrayResizing/private_arrays_resizing.h @@ -1,5 +1,5 @@ #include "dvm.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include #include #include diff --git a/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h b/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h index cd5c912..e643f59 100644 --- a/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h +++ b/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h @@ -1,8 +1,8 @@ #pragma once #include "../ParallelizationRegions/ParRegions.h" -#include "../Utils/SgUtils.h" -#include "../Utils/errors.h" +#include "SgUtils.h" +#include "errors.h" #include "graph_calls.h" void replaceDistributedArraysInIO(std::vector& regions, diff --git a/src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp b/src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp index 20e1d37..4e2480f 100644 --- a/src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp +++ b/src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp @@ -13,9 +13,9 @@ #include "dvm.h" #include "../ParallelizationRegions/ParRegions.h" #include "array_assign_to_loop.h" -#include "../Utils/SgUtils.h" +#include "SgUtils.h" #include "expr_transform.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "../VerificationCode/verifications.h" using std::vector; diff --git a/src/Transformations/VectorAssignToLoop/array_assign_to_loop.h b/src/Transformations/VectorAssignToLoop/array_assign_to_loop.h index dade68e..5fc40f3 100644 --- a/src/Transformations/VectorAssignToLoop/array_assign_to_loop.h +++ b/src/Transformations/VectorAssignToLoop/array_assign_to_loop.h @@ -2,7 +2,7 @@ #include #include "dvm.h" -#include "../Utils/errors.h" +#include "errors.h" void convertFromAssignToLoop(SgFile *file, const std::vector& regions, std::vector &messagesForFile, const std::map>& arrayLinksByFuncCalls); void restoreAssignsFromLoop(SgFile *file, const std::map>& arrayLinksByFuncCalls); diff --git a/src/Utils/SgUtils.cpp b/src/Utils/SgUtils.cpp index 51b0dce..5017822 100644 --- a/src/Utils/SgUtils.cpp +++ b/src/Utils/SgUtils.cpp @@ -38,7 +38,7 @@ #include "../Distribution/Distribution.h" #include "graph_calls.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "../CreateInterTree/CreateInterTree.h" #include "../Predictor/PredictScheme.h" #include "../VisualizerCalls/get_information.h" diff --git a/src/Utils/module_utils.cpp b/src/Utils/module_utils.cpp index 9bc9e1a..8d1de0a 100644 --- a/src/Utils/module_utils.cpp +++ b/src/Utils/module_utils.cpp @@ -7,7 +7,7 @@ #include "dvm.h" #include "errors.h" #include "utils.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "module_utils.h" diff --git a/src/Utils/utils.cpp b/src/Utils/utils.cpp index e9f8bcf..dc24ba4 100644 --- a/src/Utils/utils.cpp +++ b/src/Utils/utils.cpp @@ -25,7 +25,7 @@ #include "errors.h" #include "version.h" -#include "../GraphLoop/graph_loops.h" +#include "graph_loops.h" #include "../Distribution/Array.h" #include "../Distribution/Arrays.h" #include "../DynamicAnalysis/gcov_info.h" diff --git a/src/VerificationCode/CorrectVarDecl.cpp b/src/VerificationCode/CorrectVarDecl.cpp index ccae540..95ea158 100644 --- a/src/VerificationCode/CorrectVarDecl.cpp +++ b/src/VerificationCode/CorrectVarDecl.cpp @@ -10,10 +10,10 @@ #include "dvm.h" #include "verifications.h" -#include "../Utils/errors.h" +#include "errors.h" #include "../ParallelizationRegions/ParRegions.h" -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" using std::vector; using std::string; diff --git a/src/VerificationCode/IncludeChecker.cpp b/src/VerificationCode/IncludeChecker.cpp index 04ad02f..d8caf31 100644 --- a/src/VerificationCode/IncludeChecker.cpp +++ b/src/VerificationCode/IncludeChecker.cpp @@ -8,9 +8,9 @@ #include "dvm.h" #include "verifications.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" -#include "../Utils/errors.h" +#include "utils.h" +#include "SgUtils.h" +#include "errors.h" #include "../Distribution/DvmhDirective.h" using std::vector; diff --git a/src/VerificationCode/StructureChecker.cpp b/src/VerificationCode/StructureChecker.cpp index 1eb17b4..aac7c76 100644 --- a/src/VerificationCode/StructureChecker.cpp +++ b/src/VerificationCode/StructureChecker.cpp @@ -9,9 +9,9 @@ #include "verifications.h" #include "../ParallelizationRegions/ParRegions.h" -#include "../Utils/utils.h" -#include "../Utils/SgUtils.h" -#include "../Utils/errors.h" +#include "utils.h" +#include "SgUtils.h" +#include "errors.h" using std::vector; using std::map; diff --git a/src/VerificationCode/VerifySageStructures.cpp b/src/VerificationCode/VerifySageStructures.cpp index 1056bcc..652fe56 100644 --- a/src/VerificationCode/VerifySageStructures.cpp +++ b/src/VerificationCode/VerifySageStructures.cpp @@ -8,8 +8,8 @@ #include "dvm.h" #include "verifications.h" -#include "../Utils/utils.h" -#include "../Utils/errors.h" +#include "utils.h" +#include "errors.h" int VerifyFile(SgFile *file) { diff --git a/src/VerificationCode/verifications.h b/src/VerificationCode/verifications.h index ae62d4f..af1a3ba 100644 --- a/src/VerificationCode/verifications.h +++ b/src/VerificationCode/verifications.h @@ -4,11 +4,11 @@ #include #include #include "dvm.h" -#include "../Utils/errors.h" +#include "errors.h" #include "../ParallelizationRegions/ParRegions.h" #include "../ParallelizationRegions/ParRegions_func.h" -#include "../Utils/CommonBlock.h" +#include "CommonBlock.h" struct Function { diff --git a/src/VisualizerCalls/BuildGraph.cpp b/src/VisualizerCalls/BuildGraph.cpp index 8519016..bebebb1 100644 --- a/src/VisualizerCalls/BuildGraph.cpp +++ b/src/VisualizerCalls/BuildGraph.cpp @@ -14,7 +14,7 @@ #include #include -#include "../GraphCall/graph_calls_func.h" +#include "graph_calls_func.h" #include "graphLayout/nodesoup.hpp" #include "BuildGraph.h" diff --git a/src/VisualizerCalls/SendMessage.cpp b/src/VisualizerCalls/SendMessage.cpp index 81cabb1..0997195 100644 --- a/src/VisualizerCalls/SendMessage.cpp +++ b/src/VisualizerCalls/SendMessage.cpp @@ -6,7 +6,7 @@ #include #include "SendMessage.h" -#include "../Utils/utils.h" +#include "utils.h" #include "get_information.h" diff --git a/src/VisualizerCalls/get_information.cpp b/src/VisualizerCalls/get_information.cpp index 1e2adf1..d375cd0 100644 --- a/src/VisualizerCalls/get_information.cpp +++ b/src/VisualizerCalls/get_information.cpp @@ -23,14 +23,14 @@ #include #endif -#include "../Utils/errors.h" -#include "../Utils/version.h" +#include "errors.h" +#include "version.h" #include "get_information.h" #include "dvm.h" #include "../Sapfor.h" -#include "../GraphLoop/graph_loops_func.h" -#include "../GraphCall/graph_calls_func.h" -#include "../Utils/utils.h" +#include "graph_loops_func.h" +#include "graph_calls_func.h" +#include "utils.h" #include "../Sapfor.h" #include "../ParallelizationRegions/ParRegions.h" #include "SendMessage.h" From a7764847c408bb27ab80b3aabef41570ce53dcc5 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Wed, 4 Jun 2025 13:55:37 +0300 Subject: [PATCH 18/22] fixed --- src/Sapfor.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index 1106d5f..fdcefed 100644 --- a/src/Sapfor.cpp +++ b/src/Sapfor.cpp @@ -2662,7 +2662,7 @@ int main(int argc, char **argv) printStackTrace(); printf("exception occurred\n"); - FILE* outF = fopen((string(VISUALIZER_DATA_PATH) + "error_messages.json").c_str(), "w"); + FILE* outF = fopen((string(VISUALIZER_DATA_PATH) + "/error_messages.json").c_str(), "w"); if (outF) { json byFileArray = json::array(); From a96a4bcaa67c0a5c793f1adeebea2ffe8e86a2b0 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Wed, 4 Jun 2025 15:07:20 +0300 Subject: [PATCH 19/22] added dump messages function --- src/Sapfor.cpp | 61 +++++++++++++++++++++++++++++--------------------- 1 file changed, 36 insertions(+), 25 deletions(-) diff --git a/src/Sapfor.cpp b/src/Sapfor.cpp index fdcefed..69a9404 100644 --- a/src/Sapfor.cpp +++ b/src/Sapfor.cpp @@ -2403,6 +2403,40 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam } } +static void dumpMessages(bool inCatch) +{ + json byFileArray = json::array(); + for (auto& byFile : SPF_messages) + { + json inFile; + inFile["file"] = byFile.first; + + json messages = json::array(); + for (auto& message : byFile.second) + { + if (inCatch) + message.print(byFile.first); + messages.push_back(message.toJson()); + } + inFile["messages"] = messages; + byFileArray.push_back(inFile); + } + json allMessages; + allMessages["allMessages"] = byFileArray; + + const string dump = allMessages.dump().c_str(); + + if (dump.size()) + { + FILE* outF = fopen((string(VISUALIZER_DATA_PATH) + "/error_messages.json").c_str(), "w"); + if (outF) + { + fprintf(outF, "%s", dump.c_str()); + fclose(outF); + } + } +} + int main(int argc, char **argv) { int leakMemDump = 0; @@ -2662,35 +2696,12 @@ int main(int argc, char **argv) printStackTrace(); printf("exception occurred\n"); - FILE* outF = fopen((string(VISUALIZER_DATA_PATH) + "/error_messages.json").c_str(), "w"); - if (outF) - { - json byFileArray = json::array(); - for (auto& byFile : SPF_messages) - { - json inFile; - inFile["file"] = byFile.first; - - json messages = json::array(); - for (auto& message : byFile.second) - { - message.print(byFile.first); - messages.push_back(message.toJson()); - } - inFile["messages"] = messages; - byFileArray.push_back(inFile); - } - json allMessages; - allMessages["allMessages"] = byFileArray; - - fprintf(outF, "%s", allMessages.dump().c_str()); - fclose(outF); - } + dumpMessages(true); } + dumpMessages(false); deleteAllAllocatedData(withDel); - #if _WIN32 && _DEBUG if (leakMemDump) { From 623898d9132c3f108f87225711c887d30e53cb46 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Thu, 5 Jun 2025 19:04:56 +0300 Subject: [PATCH 20/22] added message dumping for -parse option if running from console --- src/ProjectManipulation/ParseFiles.cpp | 30 ++++++++++++-------- src/Sapfor.cpp | 38 ++------------------------ src/Utils/utils.cpp | 38 ++++++++++++++++++++++++-- src/Utils/utils.h | 3 ++ 4 files changed, 58 insertions(+), 51 deletions(-) diff --git a/src/ProjectManipulation/ParseFiles.cpp b/src/ProjectManipulation/ParseFiles.cpp index 45a68a2..35494f6 100644 --- a/src/ProjectManipulation/ParseFiles.cpp +++ b/src/ProjectManipulation/ParseFiles.cpp @@ -451,13 +451,6 @@ static int dumpErrors(const vector& listOfProject, const vector splited; splitString(errors[z], '\n', splited); @@ -476,13 +469,22 @@ static int dumpErrors(const vector& listOfProject, const vector #include #include -#include #include #include #include #include -#include -#include "utils.h" #include "errors.h" +#include "utils.h" #include "version.h" #include "graph_loops.h" @@ -1737,4 +1735,38 @@ void copyStringToShort(short*& result, const string& resVal, bool withEnd) if (withEnd) result[resVal.size()] = (short)'\0'; +} + +void dumpMessages(bool inCatch, const map>& messages, const char *vis_path) +{ + json byFileArray = json::array(); + for (auto& byFile : messages) + { + json inFile; + inFile["file"] = byFile.first; + + json messages = json::array(); + for (auto& message : byFile.second) + { + if (inCatch) + message.print(byFile.first); + messages.push_back(message.toJson()); + } + inFile["messages"] = messages; + byFileArray.push_back(inFile); + } + json allMessages; + allMessages["allMessages"] = byFileArray; + + const string dump = allMessages.dump().c_str(); + + if (dump.size()) + { + FILE* outF = fopen((string(vis_path) + "/error_messages.json").c_str(), "w"); + if (outF) + { + fprintf(outF, "%s", dump.c_str()); + fclose(outF); + } + } } \ No newline at end of file diff --git a/src/Utils/utils.h b/src/Utils/utils.h index e96fd1b..77136e4 100644 --- a/src/Utils/utils.h +++ b/src/Utils/utils.h @@ -5,7 +5,9 @@ #include #include +struct Messages; struct DataDirective; + namespace Distribution { class Array; @@ -98,3 +100,4 @@ std::set fillDistributedArraysD(const DataDirective& dataDirective std::set fillDistributedArrays(const DataDirective& dataDirectives, const std::map>& tableOfUniqNamesByArray, const std::map>& arrayLinksByFuncCalls, bool onlyCommon = false, bool shortName = false); void copyStringToShort(short*& result, const std::string& resVal, bool withEnd = true); +void dumpMessages(bool inCatch, const std::map>& messages, const char* vis_path); From 1895a4b02a8c8d95f1e218a6d08473af3af10a70 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Fri, 6 Jun 2025 08:15:10 +0300 Subject: [PATCH 21/22] fixed --- src/ProjectManipulation/ParseFiles.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/ProjectManipulation/ParseFiles.cpp b/src/ProjectManipulation/ParseFiles.cpp index 35494f6..4efb801 100644 --- a/src/ProjectManipulation/ParseFiles.cpp +++ b/src/ProjectManipulation/ParseFiles.cpp @@ -444,9 +444,8 @@ static int dumpErrors(const vector& listOfProject, const vector Date: Wed, 11 Jun 2025 11:31:48 +0300 Subject: [PATCH 22/22] fixed merging --- src/PrivateAnalyzer/range_structures.cpp | 2 +- src/PrivateAnalyzer/region.cpp | 2 +- .../LoopCombining/loops_combiner.cpp | 15 +-------------- src/Utils/utils.h | 13 +++++++++++++ src/Utils/version.h | 2 +- 5 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/PrivateAnalyzer/range_structures.cpp b/src/PrivateAnalyzer/range_structures.cpp index 75f2779..80255ab 100644 --- a/src/PrivateAnalyzer/range_structures.cpp +++ b/src/PrivateAnalyzer/range_structures.cpp @@ -2,8 +2,8 @@ #include #include #include -#include +#include "utils.h" #include "range_structures.h" using namespace std; diff --git a/src/PrivateAnalyzer/region.cpp b/src/PrivateAnalyzer/region.cpp index 5030fe3..71fbd22 100644 --- a/src/PrivateAnalyzer/region.cpp +++ b/src/PrivateAnalyzer/region.cpp @@ -146,7 +146,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces { auto var = index_vars.back(); int currentVarPos = refPos.back(); - pair currentCoefs = coefsForDims.back(); + pair currentCoefs = coefsForDims.back(); ArrayDimension current_dim; if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST) current_dim = { stoul(var->getValue()), 1, 1 }; diff --git a/src/Transformations/LoopCombining/loops_combiner.cpp b/src/Transformations/LoopCombining/loops_combiner.cpp index 747839a..c0ac86e 100644 --- a/src/Transformations/LoopCombining/loops_combiner.cpp +++ b/src/Transformations/LoopCombining/loops_combiner.cpp @@ -4,6 +4,7 @@ #include "expr_transform.h" #include "errors.h" #include "SgUtils.h" +#include "utils.h" #include #include #include @@ -17,19 +18,6 @@ using std::make_pair; using std::queue; using std::wstring; -static int gcd(int a, int b) -{ - while (a != b) - { - if (a > b) - a = a - b; - else - b = b - a; - } - - return a; -} - static SgSymbol* getLoopSymbol(const LoopGraph* loop) { if (!loop || !loop->isFor) @@ -1385,7 +1373,6 @@ static int getNewStep(SgForStmt* firstLoopStmt, SgForStmt* loopStmt) step2Val = step2->valueInteger(); int stepGcd = gcd(std::abs(step1Val), std::abs(step2Val)); - int newStep = stepGcd; int startDifference = 0; diff --git a/src/Utils/utils.h b/src/Utils/utils.h index 77136e4..fc2611f 100644 --- a/src/Utils/utils.h +++ b/src/Utils/utils.h @@ -101,3 +101,16 @@ std::set fillDistributedArrays(const DataDirective& dataDirectives, void copyStringToShort(short*& result, const std::string& resVal, bool withEnd = true); void dumpMessages(bool inCatch, const std::map>& messages, const char* vis_path); + +template +inline T gcd(T a, T b) +{ + while (a != b) + { + if (a > b) + a = a - b; + else + b = b - a; + } + return a; +} diff --git a/src/Utils/version.h b/src/Utils/version.h index 6f49767..4f8972a 100644 --- a/src/Utils/version.h +++ b/src/Utils/version.h @@ -1,3 +1,3 @@ #pragma once -#define VERSION_SPF "2423" +#define VERSION_SPF "2424"