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

Compare commits

base: Alexander_KS:libpredict_integration
Branches Tags
Alexander_KS:master Alexander_KS:private_arrays Alexander_KS:libpredict_integration Alexander_KS:egormayorov Alexander_KS:replace_io_arrays Alexander_KS:analyze_loops_with_IR
..
compare: Alexander_KS:e3560088c90973b1eca2bcfc465ed518cdbd771c
Branches Tags
Alexander_KS:master Alexander_KS:private_arrays Alexander_KS:libpredict_integration Alexander_KS:egormayorov Alexander_KS:replace_io_arrays Alexander_KS:analyze_loops_with_IR

6 Commits
libpredict ... e3560088c9

Author SHA1 Message Date
Vladislav Abrosimov
e3560088c9 Clean up 2025-05-01 18:52:29 +03:00
Vladislav Abrosimov
2583f114ee Add SPF directive insertion 2025-05-01 18:43:51 +03:00
Vladislav Abrosimov
5337dd75cd Extend interprocedural analysis 2025-05-01 11:43:35 +03:00
Vladislav Abrosimov
c11942584a unparse after 2025-04-15 18:45:04 +03:00
Vladislav Abrosimov
79d57493b8 Add Dominator tree builder and interprocedural analysis 2025-04-15 12:29:09 +03:00
Vladislav Abrosimov
8af2221626 trivial case for local variables only 2025-04-15 12:29:09 +03:00
167 changed files with 2509 additions and 4619 deletions
Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -74,7 +74,6 @@ Sapfor/Sapc++/Sapc++/x64/
Sapfor/Sapc++/x64/
/build
/cmake-build-debug
Sapfor/out/
Sapfor/_bin/*

3
.gitmodules vendored
View File

@@ -1,6 +1,3 @@
[submodule "projects/dvm"]
path = projects/dvm
url = https://dvmguest:dvmguest@dvm.keldysh.ru/dvm-system/dvm
[submodule "projects/libpredictor"]
path = projects/libpredictor
url = https://dvmguest:dvmguest@dvm.keldysh.ru/sapfor/dvm-perfm

166
CMakeLists.txt
View File

@@ -12,30 +12,19 @@ add_definitions("-D SYS5")
add_definitions("-D YYDEBUG")
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_C_STANDARD 17)
set(fdvm_include projects/dvm/fdvmh/include/fdvmh/)
set(fdvm_sources projects/dvm/fdvmh/tools/fdvmh/)
set(sage_include_1 projects/dvm/fdvmh/include/sage/lib/)
set(sage_include_2 projects/dvm/fdvmh/include/sage/h/)
set(libdb_sources projects/dvm/fdvmh/lib/sage/db/)
set(sage_sources projects/dvm/fdvmh/lib/sage/sage/)
set(sagepp_sources projects/dvm/fdvmh/lib/sage/sage++/)
set(parser_sources projects/dvm/fdvmh/tools/parser/)
set(pppa_sources projects/dvm/pppa/src/)
set(zlib_sources projects/dvm/third-party/Zlib/)
set(libpred_sources projects/libpredictor/src/)
set(libpred_include projects/libpredictor/include/)
set(fdvm_include projects/dvm/fdvmh/include/fdvmh/)
set(fdvm_sources projects/dvm/fdvmh/tools/fdvmh/)
set(sage_include_1 projects/dvm/fdvmh/include/sage/lib/)
set(sage_include_2 projects/dvm/fdvmh/include/sage/h/)
set(libdb_sources projects/dvm/fdvmh/lib/sage/db/)
set(sage_sources projects/dvm/fdvmh/lib/sage/sage/)
set(sagepp_sources projects/dvm/fdvmh/lib/sage/sage++/)
set(parser_sources projects/dvm/fdvmh/tools/parser/)
set(pppa_sources projects/dvm/pppa/src/)
set(zlib_sources projects/dvm/third-party/Zlib/)
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)
include_directories(src/Transformations)
#Sage lib includes
include_directories(${fdvm_include})
include_directories(${sage_include_1})
@@ -44,8 +33,6 @@ include_directories(${sage_include_2})
include_directories(${zlib_sources}/include)
#PPPA includes
include_directories(${pppa_sources})
#Libpredictor includes
include_directories(${libpred_include})
set(PR_PARAM src/ProjectParameters/projectParameters.cpp
src/ProjectParameters/projectParameters.h)
@@ -122,13 +109,7 @@ 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_arrays_search.cpp
src/PrivateAnalyzer/private_arrays_search.h
src/PrivateAnalyzer/range_structures.cpp
src/PrivateAnalyzer/range_structures.h
src/PrivateAnalyzer/region.cpp
src/PrivateAnalyzer/region.h)
src/PrivateAnalyzer/private_analyzer.h)
set(FDVM ${fdvm_sources}/acc.cpp
${fdvm_sources}/acc_across.cpp
@@ -163,47 +144,40 @@ 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/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(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(TRANSFORMS
${TR_DEAD_CODE}
@@ -223,15 +197,10 @@ set(TRANSFORMS
${TR_CONV}
${TR_PRIV_DEL}
${TR_IMPLICIT_NONE}
${TR_REPLACE_ARRAYS_IN_IO}
${TR_EXPR_TRANSFORM}
${TR_INLINER}
${TR_RENAME_SYMBOLS})
${TR_REPLACE_ARRAYS_IN_IO})
set(CFG src/CFGraph/IR.cpp
src/CFGraph/IR.h
src/CFGraph/IR_domTree.cpp
src/CFGraph/IR_domTree.h
src/CFGraph/CFGraph.cpp
src/CFGraph/CFGraph.h
src/CFGraph/RD_subst.cpp
@@ -309,6 +278,10 @@ 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
@@ -320,29 +293,25 @@ 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
src/Utils/PassManager.h)
set(PREDICTOR src/Predictor/PredictScheme.cpp
src/Predictor/PredictScheme.h
src/Predictor/PredictSchemeWithLibrary.cpp
src/Predictor/PredictSchemeWithLibrary.h)
set(LIBPREDICTOR ${libpred_sources}/cluster.cpp
${libpred_sources}/predictor.cpp
${libpred_sources}/transfer.cpp
${libpred_sources}/utils.cpp
${libpred_include}/libpredict/predictor.h
${libpred_include}/internal/cluster.h
${libpred_include}/internal/transfer.h
${libpred_include}/internal/utils.h)
src/Predictor/PredictScheme.h)
set(PROJ_MAN src/ProjectManipulation/ParseFiles.cpp
src/ProjectManipulation/ParseFiles.h
@@ -416,9 +385,12 @@ set(SOURCE_EXE
${DISTR}
${DVMH_REG}
${DYNA}
${EXPR_TRANSFORM}
${GR_CALL}
${GR_LOOP}
${INLINER}
${LOOP_ANALYZER}
${RENAME_SYMBOLS}
${TRANSFORMS}
${PARALLEL_REG}
${PRIV}
@@ -429,7 +401,6 @@ set(SOURCE_EXE
${VS_CALLS}
${MAIN}
${PREDICTOR}
${LIBPREDICTOR}
${PARSER}
${PPPA}
${ZLIB}
@@ -442,7 +413,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 ${TR_EXPR_TRANSFORM})
source_group (Transformations\\ExpressionSubstitution FILES ${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})
@@ -450,13 +421,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 ${TR_INLINER})
source_group (Transformations\\FunctionInlining FILES ${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 ${TR_RENAME_SYMBOLS})
source_group (Transformations\\RenameSymbols FILES ${RENAME_SYMBOLS})
source_group (Transformations\\GlobalVariables FILES ${TR_GV})
source_group (Transformations\\ConvertToC FILES ${TR_CONV})
source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
@@ -484,12 +455,11 @@ source_group (VisualizerCalls FILES ${VS_CALLS})
source_group (VisualizerCalls\\GraphLayout FILES ${GR_LAYOUT})
source_group (_SapforMain FILES ${MAIN})
source_group (Predictor\\Analyzer FILES ${PREDICTOR})
source_group (Predictor\\Library FILES ${LIBPREDICTOR})
source_group (Predictor FILES ${PREDICTOR})
source_group (Parser FILES ${PARSER})
source_group (PPPA\\PPPA FILES ${PPPA})
source_group (PPPA\\ZLib FILES ${ZLIB})
if (MSVC_IDE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /Zc:__cplusplus")
else()
@@ -498,9 +468,7 @@ else()
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
endif()
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
endif()
add_subdirectory(projects/Fdvm)

2
projects/dvm

Submodule projects/dvm updated: 4b7ef11871...c00e381812

1
projects/libpredictor

Submodule projects/libpredictor deleted from e6e805a390

66
src/CFGraph/CFGraph.cpp
View File

@@ -1,5 +1,5 @@
#define _LEAK_
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <stdlib.h>
#include <stdio.h>
@@ -8,9 +8,9 @@
#include <chrono>
#include <functional>
#include "SgUtils.h"
#include "CommonBlock.h"
#include "graph_calls.h"
#include "../Utils/SgUtils.h"
#include "../Utils/CommonBlock.h"
#include "../GraphCall/graph_calls.h"
#include "dvm.h"
#include "IR.h"
@@ -1149,22 +1149,9 @@ map<FuncInfo*, vector<BBlock*>> buildCFG(const map<string, CommonBlock*>& common
if (settings.withRD)
buildReachingDefs(result, settings);
if (settings.withDominators)
{
auto t = high_resolution_clock::now();
for (auto& [func, bblocks] : result)
SAPFOR::buildDominatorTree(bblocks);
auto msec = duration_cast<milliseconds>(high_resolution_clock::now() - t).count();
__spf_print(1, " dominator build time is %.3f sec\n", msec / 1000.);
}
if (SgFile::switchToFile(oldFile) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
for (auto& [func, blocks] : result)
removedUnreachableBlocks(blocks);
return result;
}
@@ -1239,49 +1226,4 @@ map<FuncInfo*, vector<SAPFOR::BasicBlock*>>
fileFuncInfoMap[callFrom->fileName].push_back(callFrom);
return buildCFG(commonBlocks, fileFuncInfoMap, settings);
}
void removedUnreachableBlocks(vector<SAPFOR::BasicBlock*>& blocks)
{
set<SAPFOR::BasicBlock*> reachable;
for (auto& b : blocks)
if (b->getInstructions().front()->isHeader() ||
b->getInstructions().front()->getInstruction()->getOperation() == SAPFOR::CFG_OP::ENTRY)
reachable.insert(b);
set<SAPFOR::BasicBlock*> worklist = reachable;
while (worklist.size() != 0)
{
set<SAPFOR::BasicBlock*> to_insert;
for (auto& b : worklist)
for (auto& next : b->getNext())
if (reachable.insert(next).second)
to_insert.insert(next);
worklist = to_insert;
}
auto remove_unreachable_it = remove_if(blocks.begin(), blocks.end(),
[&reachable](SAPFOR::BasicBlock* b)
{
if (reachable.find(b) == reachable.end())
{
for (auto& next : b->getNext())
if (reachable.find(next) != reachable.end())
next->removePrev(b);
delete b;
return true;
}
return false;
}
);
reachable.clear();
blocks.erase(remove_unreachable_it, blocks.end());
}

19
src/CFGraph/CFGraph.h
View File

@@ -6,7 +6,6 @@
#include <vector>
#include "IR.h"
#include "IR_domTree.h"
namespace SAPFOR
{
@@ -25,7 +24,7 @@ namespace SAPFOR
std::vector<BasicBlock*> next;
std::vector<BasicBlock*> prev;
BasicBlock* directDominator = NULL;
BasicBlock* idom{};
//reaching definition
std::map<SAPFOR::Argument*, std::set<int>> RD_in, RD_out;
@@ -35,7 +34,6 @@ namespace SAPFOR
bool addLive(const std::map<SAPFOR::Argument*, std::vector<SAPFOR::BasicBlock*>>& to_add, bool in);
std::map<SAPFOR::Argument*, std::vector<SAPFOR::BasicBlock*>> getLive(bool in) const;
bool removeLive(SAPFOR::Argument* to_remove, bool in);
public:
BasicBlock() { num = lastNumBlock++; }
BasicBlock(IR_Block* item);
@@ -44,7 +42,7 @@ namespace SAPFOR
void addInstruction(IR_Block* item);
void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
void addNext(BasicBlock* next_) { next.push_back(next_); }
void setDom(BasicBlock* dom) { directDominator = dom; }
void setIdom(BasicBlock* idom_) { idom = idom_; }
int removePrev(BasicBlock* removed);
int removeNext(BasicBlock* removed);
@@ -72,10 +70,7 @@ namespace SAPFOR
const std::vector<IR_Block*>& getInstructions() const { return instructions; }
const std::vector<BasicBlock*>& getNext() const { return next; }
const std::vector<BasicBlock*>& getPrev() const { return prev; }
BasicBlock* getDom() const
{
return directDominator;
}
BasicBlock* getIdom() const { return idom; }
/*
* FOR LIVE ANALYSIS
@@ -112,15 +107,13 @@ namespace SAPFOR
bool withDVM = false;
bool withCallsInBlocks = false; // separate each F_CALL to own BasicBlock
bool withCallFrom = true;
bool withDominators = true;
explicit CFG_Settings(int) { }
explicit CFG_Settings(bool atLeastOneIterInLoop = false, bool withRD = true, bool withRegisters = false,
bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false,
bool withCallFrom = true, bool withDominators = true) :
bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, bool withCallFrom = true) :
atLeastOneIterInLoop(atLeastOneIterInLoop), withRD(withRD), withRegisters(withRegisters), withDVM(withDVM), withSPF(withSPF),
withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom), withDominators(withDominators)
withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom)
{ }
};
}
@@ -156,5 +149,3 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
}
cfg.clear();
}
void removedUnreachableBlocks(std::vector<SAPFOR::BasicBlock*>& blocks);

2
src/CFGraph/DataFlow/backward_data_flow.h
View File

@@ -5,7 +5,7 @@
#include <set>
#include <algorithm>
#include "SgUtils.h"
#include "../../Utils/SgUtils.h"
#include "../CFGraph.h"
#include "../IR.h"

2
src/CFGraph/DataFlow/backward_data_flow_impl.h
View File

@@ -5,7 +5,7 @@
#include <set>
#include <algorithm>
#include "SgUtils.h"
#include "../../Utils/SgUtils.h"
#include "../CFGraph.h"
#include "../IR.h"
#include "../RD_subst.h"

2
src/CFGraph/DataFlow/data_flow.h
View File

@@ -2,7 +2,7 @@
#include<vector>
#include<set>
#include "SgUtils.h"
#include "../../Utils/SgUtils.h"
#include "../CFGraph.h"
#include "../IR.h"

2
src/CFGraph/DataFlow/data_flow_impl.h
View File

@@ -4,7 +4,7 @@
#include<vector>
#include<set>
#include "SgUtils.h"
#include "../../Utils/SgUtils.h"
#include "../CFGraph.h"
#include "../IR.h"

22
src/CFGraph/IR.cpp
View File

@@ -1,14 +1,14 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <stdlib.h>
#include <stdio.h>
#include <vector>
#include <set>
#include "SgUtils.h"
#include "CommonBlock.h"
#include "graph_calls.h"
#include "expr_transform.h"
#include "../Utils/SgUtils.h"
#include "../Utils/CommonBlock.h"
#include "../GraphCall/graph_calls.h"
#include "../ExpressionTransform/expr_transform.h"
#include "dvm.h"
#include "IR.h"
@@ -395,7 +395,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
if (ex)
{
const int var = ex->variant();
if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // variable reference
if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
if (var == CONST_REF)
{
@@ -450,7 +450,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
return arg1;
auto reg = isLeft ? NULL : createRegister();
Instruction* instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(numArgs), isLeft ? isLeft : reg, NULL, ex);
Instruction* instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(numArgs), isLeft ? isLeft : reg);
blocks.push_back(new IR_Block(instr));
return reg;
}
@@ -485,7 +485,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
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, NULL, ex);
instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(1), isLeft ? isLeft : reg);
blocks.push_back(new IR_Block(instr));
return reg;
}
@@ -602,7 +602,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
{
if (returnReg == NULL)
{
Instruction* instr = new Instruction(CFG_OP::LOAD, arg, NULL, reg, NULL, ex);
Instruction* instr = new Instruction(CFG_OP::LOAD, arg, NULL, reg);
blocks.push_back(new IR_Block(instr));
}
else
@@ -1572,7 +1572,7 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
else
findReturn(0, blocks.size(), blocks, blocks.back()->getNumber());
// adding links by GOTO and jumps
// <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> GOTO <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for (int z = 0; z < blocks.size(); ++z)
{
auto op = blocks[z]->getInstruction()->getOperation();
@@ -1592,7 +1592,7 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
blocks[z]->setJump(it->second);
// replacing the label with the instruction number
// <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
arg->setValue(to_string(it->second->getNumber()));
arg->setType(CFG_ARG_TYPE::INSTR);
}

2
src/CFGraph/IR.h
View File

@@ -6,7 +6,7 @@
#include <algorithm>
#include "CFGraph.h"
#include "CommonBlock.h"
#include "../Utils/CommonBlock.h"
namespace SAPFOR
{

35
src/CFGraph/IR_domTree.h
View File

@@ -1,35 +0,0 @@
#pragma once
#include <vector>
#include <map>
#include <unordered_map>
#include "CFGraph.h"
// Lengauer, Thomas. A fast algorithm for finding dominators in a flowgraph / Thomas Lengauer, Robert Endre Tarjan
// ACM Transactions on Programming Languages and Systems (TOPLAS). <20> 1979. <20> Vol. 1, no. 1. <20> Pp. 121<32>141.
namespace SAPFOR {
class BasicBlock;
class DominatorFinder {
private:
BasicBlock* entry;
std::vector<BasicBlock*> vertices;
std::unordered_map<BasicBlock*, int> dfs_num;
std::vector<int> parent, semi, vertex, ancestor, label;
std::vector<std::vector<int>> bucket;
int n;
void DFS(BasicBlock* v, int parent_num);
void Compress(int v);
int Eval(int v);
void Link(int v, int w);
public:
DominatorFinder(std::vector<BasicBlock*>& blocks);
};
void buildDominatorTree(std::vector<BasicBlock*>& blocks);
}

8
src/CFGraph/RD_subst.cpp
View File

@@ -8,10 +8,10 @@
#include <unordered_map>
#include <unordered_set>
#include "SgUtils.h"
#include "CommonBlock.h"
#include "graph_calls.h"
#include "expr_transform.h"
#include "../Utils/SgUtils.h"
#include "../Utils/CommonBlock.h"
#include "../GraphCall/graph_calls.h"
#include "../ExpressionTransform/expr_transform.h"
#define PRINT_PROF_INFO 0
#define DEBUG_CHECKS 0

6
src/CFGraph/RD_subst.h
View File

@@ -2,9 +2,9 @@
#include<unordered_map>
#include "SgUtils.h"
#include "CommonBlock.h"
#include "graph_calls.h"
#include "../Utils/SgUtils.h"
#include "../Utils/CommonBlock.h"
#include "../GraphCall/graph_calls.h"
#include "CFGraph.h"
#include "IR.h"

2
src/CFGraph/live_variable_analysis.h
View File

@@ -1,6 +1,6 @@
#pragma once
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#include "CFGraph.h"
namespace LIVE_VARIABLES

8
src/CFGraph/private_variables_analysis.cpp
View File

@@ -1,6 +1,6 @@
#include "errors.h"
#include "../Utils/errors.h"
#include "private_variables_analysis.h"
#include "graph_loops.h"
#include "../GraphLoop/graph_loops.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "../SageAnalysisTool/depGraph.h"
#include "../DirectiveProcessing/directive_parser.h"
@@ -250,7 +250,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
const map<string, SgSymbol*>& commonArgs, FuncInfo* func,
map<string, vector<Messages>>& messages)
{
if (!loop->isFor())
if (!loop->isFor)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__); //should be called only with FOR loops
SgStatement* loop_operator = loop->loop->GetOriginal();
@@ -450,7 +450,7 @@ static void recAnalyzeLoop(LoopGraph* loop, const set<SAPFOR::BasicBlock*>& bloc
const map<string, SgSymbol*>& commonArgs,
FuncInfo* func, map<string, vector<Messages>>& messages)
{
const auto& loop_body = loop->isFor() ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
const auto& loop_body = loop->isFor ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
for (const auto& inner_loop : loop->children)
recAnalyzeLoop(inner_loop, loop_body, commonVars, commonArgs, func, messages);

4
src/CFGraph/private_variables_analysis.h
View File

@@ -1,5 +1,5 @@
#include "SgUtils.h"
#include "graph_loops.h"
#include "../Utils/SgUtils.h"
#include "../GraphLoop/graph_loops.h"
#include "CFGraph.h"
#include <string>

6
src/CreateInterTree/CreateInterTree.cpp
View File

@@ -1,7 +1,7 @@
#include "CreateInterTree.h"
#include "SgUtils.h"
#include "utils.h"
#include "graph_calls_func.h"
#include "../Utils/SgUtils.h"
#include "../Utils/utils.h"
#include "../GraphCall/graph_calls_func.h"
using std::string;
using std::wstring;

2
src/CreateInterTree/CreateInterTree.h
View File

@@ -8,7 +8,7 @@
#include "dvm.h"
#include "graph_loops_func.h"
#include "../GraphLoop/graph_loops_func.h"
struct SpfInterval
{

6
src/DirectiveProcessing/directive_analyzer.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -16,9 +16,9 @@
#include <assert.h>
#include "../Distribution/DvmhDirective.h"
#include "graph_loops.h"
#include "../GraphLoop/graph_loops.h"
#include "directive_analyzer.h"
#include "utils.h"
#include "../Utils/utils.h"
using std::vector;
using std::map;

2
src/DirectiveProcessing/directive_analyzer.h
View File

@@ -1,6 +1,6 @@
#pragma once
#include <vector>
#include "graph_loops.h"
#include "../GraphLoop/graph_loops.h"
void UniteNestedDirectives(std::vector<LoopGraph*> &loopGraph);

16
src/DirectiveProcessing/directive_creator.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -15,18 +15,18 @@
#include "../Distribution/Distribution.h"
#include "../Distribution/DvmhDirective_func.h"
#include "errors.h"
#include "../Utils/errors.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "directive_parser.h"
#include "directive_creator.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#include "../Sapfor.h"
#include "graph_loops_func.h"
#include "LoopNesting/loop_transform.h"
#include "expr_transform.h"
#include "graph_calls_func.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../Transformations/loop_transform.h"
#include "../ExpressionTransform/expr_transform.h"
#include "../GraphCall/graph_calls_func.h"
#include "AstWrapper.h"
#include "../Utils/AstWrapper.h"
#define PRINT_DIR_RESULT 0

6
src/DirectiveProcessing/directive_creator.h
View File

@@ -1,9 +1,9 @@
#pragma once
#include "../Distribution/Distribution.h"
#include "errors.h"
#include "graph_loops.h"
#include "types.h"
#include "../Utils/errors.h"
#include "../GraphLoop/graph_loops.h"
#include "../Utils/types.h"
void createParallelDirectives(const std::map<LoopGraph*, std::map<DIST::Array*, ArrayInfo*>> &loopInfo,
const std::vector<ParallelRegion*>& regions,

21
src/DirectiveProcessing/directive_creator_base.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -10,9 +10,9 @@
#include "../ParallelizationRegions/ParRegions.h"
#include "../Distribution/Arrays.h"
#include "LoopNesting/loop_transform.h"
#include "../Transformations/loop_transform.h"
#include "errors.h"
#include "../Utils/errors.h"
#include "directive_parser.h"
#include "directive_creator.h"
@@ -75,7 +75,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
}
}
directive->parallel.push_back(currentLoop->loopSymbol());
directive->parallel.push_back(currentLoop->loopSymbol);
directive->arrayRef = mainArray.arrayRef;
DIST::Array *tmp = mainArray.arrayRef;
@@ -84,7 +84,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
for (int i = 0; i < tmp->GetDimSize(); ++i)
{
if (i == pos)
directive->on.push_back(make_pair(currentLoop->loopSymbol(), mainAccess));
directive->on.push_back(make_pair(currentLoop->loopSymbol, mainAccess));
else
directive->on.push_back(make_pair("*", make_pair(0, 0)));
}
@@ -122,7 +122,6 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
if (found == false)
{
directive->shadowRenew.push_back(make_pair(key, vector<pair<int, int>>()));
directive->shadowRenewCorner.push_back(false);
const DIST::Array *arrayRef = read;
for (int i = 0; i < arrayRef->GetDimSize(); ++i)
@@ -809,7 +808,7 @@ void createParallelDirectives(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*
for (int i = 0; i < mainArrayOfLoop->GetDimSize(); ++i)
{
if (i == dimPos)
parDir->on2.push_back(make_pair(currLoop->loopSymbol(), mainAccess));
parDir->on2.push_back(make_pair(currLoop->loopSymbol, mainAccess));
else
parDir->on2.push_back(make_pair("*", make_pair(0, 0)));
}
@@ -1101,7 +1100,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
LoopGraph* tmpL = loop;
for (int z = 0; z < nested; ++z)
{
deprecateToMatch.insert(tmpL->loopSymbol());
deprecateToMatch.insert(tmpL->loopSymbol);
if (tmpL->children.size())
tmpL = tmpL->children[0];
else if (z != nested - 1)
@@ -1114,7 +1113,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
tmpL = loop->parent;
while (tmpL)
{
if (tmpL->isWhile()) // TODO: need to add all inductive variables!
if (!tmpL->isFor) // TODO: need to add all inductive variables!
{
SgWhileStmt* dow = isSgWhileStmt(tmpL->loop->GetOriginal());
if (dow->conditional())
@@ -1125,7 +1124,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
}
}
else
deprecateToMatch.insert(tmpL->loopSymbol());
deprecateToMatch.insert(tmpL->loopSymbol);
tmpL = tmpL->parent;
}
@@ -1602,7 +1601,7 @@ static bool matchParallelAndDist(const pair<DIST::Array*, const DistrVariant*>&
parallelOn = NULL;
for (auto& refOn : realRefs)
{
linkWithTempl = refOn->GetLinksWithTemplate(regionId);
linkWithTempl = parallelOn->GetLinksWithTemplate(regionId);
int z = 0;
for (int k = 0; k < linkWithTempl.size(); ++k)
if (linkWithTempl[k] != -1)

4
src/DirectiveProcessing/directive_omp_parser.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -9,7 +9,7 @@
#include "directive_omp_parser.h"
#include "directive_parser.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
using std::vector;
using std::map;

2
src/DirectiveProcessing/directive_omp_parser.h
View File

@@ -4,7 +4,7 @@
#include <map>
#include <vector>
#include "errors.h"
#include "../Utils/errors.h"
#define SPF_USER_DIR 777
#define SPF_USER_DIR_COPY 999

8
src/DirectiveProcessing/directive_parser.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstring>
@@ -12,10 +12,10 @@
#include <assert.h>
#include "directive_parser.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "AstWrapper.h"
#include "errors.h"
#include "../Utils/AstWrapper.h"
#include "../Utils/errors.h"
using std::string;
using std::vector;

4
src/DirectiveProcessing/directive_parser.h
View File

@@ -4,8 +4,8 @@
#include <set>
#include <map>
#include "AstWrapper.h"
#include "graph_loops.h"
#include "../Utils/AstWrapper.h"
#include "../GraphLoop/graph_loops.h"
#include "../Distribution/DvmhDirective.h"
struct DvmDirective

10
src/DirectiveProcessing/insert_directive.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -16,13 +16,13 @@
#include "../Distribution/Arrays.h"
#include "../Distribution/Distribution.h"
#include "../Distribution/DvmhDirective_func.h"
#include "graph_loops_func.h"
#include "graph_calls_func.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../GraphCall/graph_calls_func.h"
#include "errors.h"
#include "../Utils/errors.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "directive_parser.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#include "../Sapfor.h"
#include "directive_creator.h"
#include "insert_directive.h"

14
src/DirectiveProcessing/remote_access.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -18,13 +18,13 @@
#include "dvm.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "types.h"
#include "errors.h"
#include "SgUtils.h"
#include "../Utils/types.h"
#include "../Utils/errors.h"
#include "../Utils/SgUtils.h"
#include "../Distribution/Arrays.h"
#include "graph_calls.h"
#include "graph_calls_func.h"
#include "graph_loops_func.h"
#include "../GraphCall/graph_calls.h"
#include "../GraphCall/graph_calls_func.h"
#include "../GraphLoop/graph_loops_func.h"
#include "remote_access.h"
using std::vector;

6
src/DirectiveProcessing/remote_access_base.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -17,8 +17,8 @@
#include <assert.h>
#include "../Distribution/Arrays.h"
#include "graph_calls.h"
#include "graph_loops.h"
#include "../GraphCall/graph_calls.h"
#include "../GraphLoop/graph_loops.h"
#include "../ParallelizationRegions/ParRegions.h"
#include "remote_access.h"

18
src/DirectiveProcessing/shadow.cpp
View File

@@ -1,21 +1,21 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <set>
#include <map>
#include <string>
#include <vector>
#include "errors.h"
#include "utils.h"
#include "graph_loops_func.h"
#include "graph_calls.h"
#include "graph_calls_func.h"
#include "../Utils/errors.h"
#include "../Utils/utils.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../GraphCall/graph_calls.h"
#include "../GraphCall/graph_calls_func.h"
#include "directive_parser.h"
#include "../Distribution/DvmhDirective_func.h"
#include "SgUtils.h"
#include "expr_transform.h"
#include "../Utils/SgUtils.h"
#include "../ExpressionTransform/expr_transform.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
#include "shadow.h"
#include "dvm.h"

12
src/DirectiveProcessing/spf_directive_preproc.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -12,13 +12,13 @@
#include "dvm.h"
#include "../Sapfor.h"
#include "graph_loops.h"
#include "graph_calls_func.h"
#include "../GraphLoop/graph_loops.h"
#include "../GraphCall/graph_calls_func.h"
#include "../SageAnalysisTool/depInterfaceExt.h"
#include "SgUtils.h"
#include "errors.h"
#include "../Utils/SgUtils.h"
#include "../Utils/errors.h"
#include "directive_parser.h"
#include "expr_transform.h"
#include "../ExpressionTransform/expr_transform.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "../DirectiveProcessing/directive_omp_parser.h"

6
src/Distribution/Array.cpp
View File

@@ -1,7 +1,7 @@
#include "Array.h"
#include "errors.h"
#include "utils.h"
#include "graph_calls.h"
#include "../Utils/errors.h"
#include "../Utils/utils.h"
#include "../GraphCall/graph_calls.h"
using namespace std;

116
src/Distribution/Array.h
View File

@@ -7,9 +7,8 @@
#include <algorithm>
#include <climits>
#include "DvmhDirectiveBase.h"
#include "utils.h"
#include "errors.h"
#include "json.hpp"
#include "../Utils/utils.h"
#include "../Utils/errors.h"
class Symbol;
class Expression;
@@ -21,7 +20,6 @@ struct FuncInfo;
#define MAP std::map
#define SET std::set
#define TO_STR std::to_string
#define JSON nlohmann::json
#if __SPF
extern int sharedMemoryParallelization;
@@ -106,7 +104,7 @@ namespace Distribution
MAP<STRING, SET<int>> usagePlaces;
VECTOR<bool> mappedDims;
VECTOR<bool> deprecateToDistribute;
VECTOR<bool> depracateToDistribute;
bool ompThreadPrivate;
bool privateInLoop;
@@ -171,7 +169,7 @@ namespace Distribution
sizes.resize(dimSize);
sizesExpr.resize(dimSize);
mappedDims.resize(dimSize);
deprecateToDistribute.resize(dimSize);
depracateToDistribute.resize(dimSize);
for (int z = 0; z < dimSize; ++z)
{
@@ -179,7 +177,7 @@ namespace Distribution
PAIR<int, int> initVal = std::make_pair(0, 0);
sizesExpr[z] = std::make_pair(std::make_pair((Expression*)NULL, initVal), std::make_pair((Expression*)NULL, initVal));
mappedDims[z] = false;
deprecateToDistribute[z] = false;
depracateToDistribute[z] = false;
}
GenUniqKey();
@@ -214,7 +212,7 @@ namespace Distribution
uniqKey = copy.uniqKey;
containsInRegions = copy.containsInRegions;
mappedDims = copy.mappedDims;
deprecateToDistribute = copy.deprecateToDistribute;
depracateToDistribute = copy.depracateToDistribute;
ompThreadPrivate = copy.ompThreadPrivate;
privateInLoop = copy.privateInLoop;
inEquivalence = copy.inEquivalence;
@@ -226,7 +224,7 @@ namespace Distribution
int countToRem = 0;
for (int z = 0; z < dimSize; ++z)
{
if (!mappedDims[z] || deprecateToDistribute[z])
if (!mappedDims[z] || depracateToDistribute[z])
{
needToRemove = true;
countToRem++;
@@ -246,19 +244,19 @@ namespace Distribution
for (int z = 0; z < dimSize; ++z)
{
if (mappedDims[z] && !deprecateToDistribute[z])
if (mappedDims[z] && !depracateToDistribute[z])
{
newSizes.push_back(sizes[z]);
newSizesExpr.push_back(sizesExpr[z]);
newMappedDims.push_back(mappedDims[z]);
newDepr.push_back(deprecateToDistribute[z]);
newDepr.push_back(depracateToDistribute[z]);
}
}
sizes = newSizes;
sizesExpr = newSizesExpr;
mappedDims = newMappedDims;
deprecateToDistribute = newDepr;
depracateToDistribute = newDepr;
dimSize = (int)sizes.size();
return false;
@@ -426,64 +424,48 @@ namespace Distribution
void ClearShadowSpecs() { allShadowSpecs.clear(); }
JSON toJson()
STRING toString()
{
JSON retVal;
STRING retVal = "";
retVal += TO_STR(id);
retVal += "#" + name;
retVal += "#" + shortName;
retVal += "#" + TO_STR(dimSize);
retVal += "#" + TO_STR(typeSize);
retVal += "#" + TO_STR(isNonDistribute);
retVal += "#" + TO_STR(locationPos.first);
retVal += "#" + locationPos.second;
retVal["id"] = (int64_t)id;
retVal["name"] = name;
retVal["shortName"] = shortName;
retVal["packedAddress"] = std::to_string((long long)this);
retVal["dimSize"] = dimSize;
retVal["typeSize"] = typeSize;
retVal["state"] = (int)isNonDistribute;
retVal["location"] = (int)locationPos.first;
retVal["locName"] = locationPos.second;
retVal["isTemplFlag"] = (int)isTemplFlag;
retVal["isLoopArrayFlag"] = (int)isLoopArrayFlag;
JSON deprToDist = nlohmann::json::array();
for (int i = 0; i < deprecateToDistribute.size(); ++i)
deprToDist.push_back((int)deprecateToDistribute[i]);
retVal["deprecateToDist"] = deprToDist;
JSON mappedDimsJ = nlohmann::json::array();
for (int i = 0; i < mappedDims.size(); ++i)
mappedDimsJ.push_back((int)mappedDims[i]);
retVal["mappedDims"] = mappedDimsJ;
JSON sizesJ = nlohmann::json::array();
retVal += "#" + TO_STR(sizes.size());
for (int i = 0; i < sizes.size(); ++i)
{
JSON pair;
pair["key"] = sizes[i].first;
pair["value"] = sizes[i].second;
sizesJ.push_back(pair);
}
retVal["sizes"] = sizesJ;
retVal += "#" + TO_STR(sizes[i].first) + "#" + TO_STR(sizes[i].second);
JSON regions = nlohmann::json::array();
for (auto& reg : containsInRegions)
regions.push_back(reg);
retVal["regions"] = regions;
retVal += "#" + TO_STR(depracateToDistribute.size());
for (int i = 0; i < depracateToDistribute.size(); ++i)
retVal += "#" + TO_STR((int)depracateToDistribute[i]);
retVal += "#" + TO_STR(mappedDims.size());
for (int i = 0; i < mappedDims.size(); ++i)
retVal += "#" + TO_STR((int)mappedDims[i]);
JSON declPlacesJ = nlohmann::json::array();
for (auto& place : declPlaces)
{
JSON elem;
elem["file"] = place.first;
elem["line"] = place.second;
retVal += "#" + TO_STR(templateInfo.size());
for (auto it = templateInfo.begin(); it != templateInfo.end(); ++it)
retVal += "#" + TO_STR(it->first) + it->second->toString();
retVal += "#" + TO_STR((int)isTemplFlag);
retVal += "|" + TO_STR((int)isLoopArrayFlag);
retVal += "|" + TO_STR(declPlaces.size());
declPlacesJ.push_back(elem);
}
retVal["declPlaces"] = declPlacesJ;
for (auto &place : declPlaces)
retVal += "|" + place.first + "|" + TO_STR(place.second);
retVal += "|" + TO_STR(containsInRegions.size());
for (auto &reg : containsInRegions)
retVal += "|" + reg;
return retVal;
}
Array* GetTemplateArray(const uint64_t regionId, bool withCheck = true)
{
TemplateLink *currLink = getTemlateInfo(regionId, withCheck);
@@ -605,13 +587,13 @@ namespace Distribution
{
if (dim >= dimSize)
return;
deprecateToDistribute[dim] = value;
depracateToDistribute[dim] = value;
}
void DeprecateAllDims()
{
for (int dim = 0; dim < dimSize; ++dim)
deprecateToDistribute[dim] = true;
depracateToDistribute[dim] = true;
}
bool IsDimDepracated(const int dim) const
@@ -621,9 +603,9 @@ namespace Distribution
else
{
if (templateDimsOrder.size() == 0)
return deprecateToDistribute[dim];
return depracateToDistribute[dim];
else
return deprecateToDistribute[templateDimsOrder[dim]];
return depracateToDistribute[templateDimsOrder[dim]];
}
}
@@ -631,11 +613,11 @@ namespace Distribution
{
bool ret = true;
for (int z = 0; z < dimSize; ++z)
ret = ret && deprecateToDistribute[z];
ret = ret && depracateToDistribute[z];
return ret;
}
const VECTOR<bool>& GetDeprecetedDims() const { return deprecateToDistribute; }
const VECTOR<bool>& GetDeprecetedDims() const { return depracateToDistribute; }
int GetTypeSize() const { return typeSize; }
@@ -827,4 +809,4 @@ namespace Distribution
#undef PAIR
#undef MAP
#undef SET
#undef TO_STR
#undef TO_STR

16
src/Distribution/ArrayAnalysis.cpp
View File

@@ -1,8 +1,8 @@
#include "Array.h"
#include "errors.h"
#include "utils.h"
#include "graph_calls.h"
#include "SgUtils.h"
#include "../Utils/errors.h"
#include "../Utils/utils.h"
#include "../GraphCall/graph_calls.h"
#include "../Utils/SgUtils.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "../DirectiveProcessing/directive_omp_parser.h"
#include "../LoopAnalyzer/loop_analyzer.h"
@@ -241,15 +241,13 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
itNew->second.first->SetRegionPlace(reg);
const auto oldVal = itNew->second.first->GetDistributeFlagVal();
bool isArrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
bool isarrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
if (oldVal == DIST::DISTR || oldVal == DIST::NO_DISTR)
{
if (itNew->second.first->IsOmpThreadPrivate())
itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
else if (isArrayInModule || privates.find(symb->identifier()) != privates.end())
else if (privates.find(symb->identifier()) != privates.end() || isarrayInModule)
{
//check in module
if (itNew->second.first->GetLocation().first == DIST::l_MODULE)
@@ -276,6 +274,8 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
else
itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
}
else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
else if (isSgConstantSymb(symb) || inDataStat)
itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
else

8
src/Distribution/CreateDistributionDirs.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <stdio.h>
#include <stdlib.h>
@@ -14,9 +14,9 @@
#include "GraphCSR.h"
#include "Arrays.h"
#include "errors.h"
#include "utils.h"
#include "graph_loops.h"
#include "../Utils/errors.h"
#include "../Utils/utils.h"
#include "../GraphLoop/graph_loops.h"
using std::vector;
using std::set;

4
src/Distribution/CreateDistributionDirs.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include "graph_loops.h"
#include "errors.h"
#include "../GraphLoop/graph_loops.h"
#include "../Utils/errors.h"
void createDistributionDirs(DIST::GraphCSR<int, double, attrType> &reducedG, DIST::Arrays<int> &allArrays,
DataDirective &dataDirectives, std::map<std::string, std::vector<Messages>> &allMessages,

2
src/Distribution/Cycle.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <vector>
#include <algorithm>

2
src/Distribution/Cycle.h
View File

@@ -3,7 +3,7 @@
#include <vector>
#include <algorithm>
#include "types.h"
#include "../Utils/types.h"
namespace Distribution
{

30
src/Distribution/Distribution.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -30,9 +30,9 @@ using namespace std::chrono;
#include "Arrays.h"
#include "Array.h"
#include "Distribution.h"
#include "utils.h"
#include "errors.h"
#include "types.h"
#include "../Utils/utils.h"
#include "../Utils/errors.h"
#include "../Utils/types.h"
#include "../Distribution/Cycle.h"
#include "../VisualizerCalls/get_information.h"
#include "../VisualizerCalls/SendMessage.h"
@@ -455,7 +455,15 @@ namespace Distribution
}
if (needPrint)
sendMessage_2lvl(4, k, (int)AllCycles.size());
{
#if _WIN32
wstring treeM = L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + std::to_wstring(k + 1) + L"/" + std::to_wstring(AllCycles.size());
#else
wstring treeM = L"conflict resolution, processing group " + std::to_wstring(k + 1) + L"/" + std::to_wstring(AllCycles.size());
#endif
sendMessage_2lvl(treeM);
}
auto timeR = steady_clock::now();
if (countConflicts != 0)
@@ -508,7 +516,7 @@ namespace Distribution
}
if (needPrint)
sendMessage_2lvl(2);
sendMessage_2lvl(L"");
return make_pair(allOnlySecondType, globalSum);
}
@@ -564,7 +572,13 @@ namespace Distribution
for (int z = 0; z < arraysV.size(); ++z)
{
const DIST::Array *array = arraysV[z];
sendMessage_2lvl(5, z, (int)arrays.size());
#ifdef _WIN32
wstring treeM = L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + std::to_wstring(z + 1) + L"/" + std::to_wstring(arrays.size());
#else
wstring treeM = L"conflict resolution, processing array " + std::to_wstring(z + 1) + L"/" + std::to_wstring(arrays.size());
#endif
sendMessage_2lvl(treeM);
vector<vType> verts;
@@ -591,7 +605,7 @@ namespace Distribution
}
}
}
sendMessage_2lvl(2);
sendMessage_2lvl(L"");
}
else
{

37
src/Distribution/DvmhDirective.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <stdio.h>
#include <stdlib.h>
@@ -7,12 +7,12 @@
#include <string>
#include <algorithm>
#include "types.h"
#include "../Utils/types.h"
#include "DvmhDirective.h"
#include "errors.h"
#include "SgUtils.h"
#include "../Utils/errors.h"
#include "../Utils/SgUtils.h"
#include "../Sapfor.h"
#include "graph_calls_func.h"
#include "../GraphCall/graph_calls_func.h"
#include "dvm.h"
@@ -199,6 +199,15 @@ static set<string> fillUsedSymbols(SgStatement *loop)
return usedS;
}
static string correctSymbolModuleName(const string& origFull)
{
auto it = origFull.find("::");
if (it == string::npos)
return origFull;
else
return origFull.substr(it + 2);
}
static SgStatement* getModuleScope(const string& origFull, vector<SgStatement*>& moduleList, SgStatement *local)
{
auto it = origFull.find("::");
@@ -346,7 +355,7 @@ static vector<SgExpression*>
{
needToAdd = true;
dim_found = true;
subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol()));
subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol));
break;
}
}
@@ -857,11 +866,6 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
shadowRenewShifts[i].resize(shadowRenew[i].second.size());
}
if (shadowRenewCorner.size() == 0)
{
shadowRenewCorner.resize(shadowRenew.size(), false);
}
string shadowAdd = ", SHADOW_RENEW(";
int inserted = 0;
@@ -904,10 +908,7 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
for (auto& elem : genSubscripts(shadowRenew[i1].second, shadowRenewShifts[i1]))
newArrayRef->addSubscript(*elem);
bool needCornerFlag = shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop);
shadowRenewCorner[i1] = needCornerFlag;
if (needCornerFlag)
if (shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop))
{
SgExpression* tmp = new SgExpression(ARRAY_OP, newArrayRef, NULL, NULL);
p->setLhs(*tmp);
@@ -958,7 +959,7 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
SgSymbol* redS;
string clearName = correctSymbolModuleName(red);
if (clearName != red)
redS = getNameInLocation(parentFunc, red, getModuleScope(red, moduleList, parentFunc)->symbol()->identifier());
redS = getNameInLocation(parentFunc, clearName, getModuleScope(red, moduleList, parentFunc)->symbol()->identifier());
else
redS = findSymbolOrCreate(file, clearName, NULL, parentFunc);
@@ -1016,12 +1017,12 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
string clearName2 = correctSymbolModuleName(get<1>(list));
if (clearName1 != get<0>(list))
redS1 = getNameInLocation(parentFunc, get<0>(list), getModuleScope(get<0>(list), moduleList, parentFunc)->symbol()->identifier());
redS1 = getNameInLocation(parentFunc, clearName1, getModuleScope(get<0>(list), moduleList, parentFunc)->symbol()->identifier());
else
redS1 = findSymbolOrCreate(file, clearName1, NULL, parentFunc);
if (clearName2 != get<1>(list))
redS2 = getNameInLocation(parentFunc, get<1>(list), getModuleScope(get<1>(list), moduleList, parentFunc)->symbol()->identifier());
redS2 = getNameInLocation(parentFunc, clearName2, getModuleScope(get<1>(list), moduleList, parentFunc)->symbol()->identifier());
else
redS2 = findSymbolOrCreate(file, clearName2, NULL, parentFunc);

9
src/Distribution/DvmhDirective.h
View File

@@ -7,9 +7,9 @@
#include "Array.h"
#include "DvmhDirectiveBase.h"
#include "AstWrapper.h"
#include "types.h"
#include "utils.h"
#include "../Utils/AstWrapper.h"
#include "../Utils/types.h"
#include "../Utils/utils.h"
extern int sharedMemoryParallelization;
@@ -102,7 +102,6 @@ public:
// origin_Name uniqName bounds
std::vector<std::pair<std::pair<std::string, std::string>, std::vector<std::pair<int, int>>>> shadowRenew;
std::vector<std::vector<std::pair<int, int>>> shadowRenewShifts;
std::vector<bool> shadowRenewCorner;
// origin_Name uniqName bounds
std::vector<std::pair<std::pair<std::string, std::string>, std::vector<std::pair<int, int>>>> across;
@@ -126,7 +125,6 @@ public:
privates = copyFrom.privates;
shadowRenew = copyFrom.shadowRenew;
shadowRenewShifts = copyFrom.shadowRenewShifts;
shadowRenewCorner = copyFrom.shadowRenewCorner;
across = copyFrom.across;
acrossShifts = copyFrom.acrossShifts;
remoteAccess = copyFrom.remoteAccess;
@@ -153,7 +151,6 @@ public:
on.clear();
privates.clear();
shadowRenew.clear();
shadowRenewCorner.clear();
across.clear();
acrossShifts.clear();
reduction.clear();

54
src/Distribution/DvmhDirectiveBase.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <stdio.h>
#include <stdlib.h>
@@ -10,11 +10,9 @@
#include "../Distribution/Array.h"
#include "../Distribution/Arrays.h"
#include "../Distribution/GraphCSR.h"
#include "errors.h"
#include "utils.h"
#include "json.hpp"
#include "graph_calls_func.h"
#include "../Utils/errors.h"
#include "../Utils/utils.h"
#include "../GraphCall/graph_calls_func.h"
using std::vector;
using std::tuple;
@@ -29,8 +27,6 @@ using std::make_pair;
using std::min;
using std::max;
using nlohmann::json;
template<typename setT>
static void uniteSets(const set<setT> &first, const set<setT> &second, set<setT> &result)
{
@@ -736,34 +732,30 @@ string AlignRuleBase::GenRuleBase() const
return retVal;
}
json AlignRuleBase::toJson()
string AlignRuleBase::toString()
{
json retVal;
string retVal = "";
retVal["packedAlignArrayAddress"] = alignArray ? std::to_string((long long)alignArray) : std::to_string((long long)-1);
retVal["packedAlignWithAddress"] = alignWith ? std::to_string((long long)alignWith) : std::to_string((long long)-1);
if (alignArray)
retVal += "#" + std::to_string((long long)alignArray);
else
retVal += "#-1";
json alignRules = json::array();
for (auto& rule : alignRule)
{
json pair;
pair["key"] = rule.first;
pair["value"] = rule.second;
alignRules.push_back(pair);
}
retVal["alignRule"] = alignRules;
if (alignWith)
retVal += "#" + std::to_string((long long)alignWith);
else
retVal += "#-1";
json alignRuleWithJ = json::array();
for (auto& [dimNum, AB] : alignRuleWith)
{
json tuple;
tuple["dimNum"] = dimNum;
tuple["a"] = AB.first;
tuple["b"] = AB.second;
retVal += "#" + std::to_string(alignRule.size());
for (int i = 0; i < alignRule.size(); ++i)
retVal += "#" + std::to_string(alignRule[i].first) + "#" + std::to_string(alignRule[i].second);
retVal += "#" + std::to_string(alignRuleWith.size());
for (int i = 0; i < alignRuleWith.size(); ++i)
retVal += "#" + std::to_string(alignRuleWith[i].first)
+ "#" + std::to_string(alignRuleWith[i].second.first)
+ "#" + std::to_string(alignRuleWith[i].second.second);
alignRuleWithJ.push_back(tuple);
}
retVal["alignRuleWith"] = alignRuleWithJ;
return retVal;
}

4
src/Distribution/DvmhDirectiveBase.h
View File

@@ -3,8 +3,6 @@
#include <vector>
#include <string>
#include "json.hpp"
typedef enum lang : int { LANG_C, LANG_F } language;
typedef enum dist : int { BLOCK, NONE } distType;
typedef std::pair<std::pair<int, int>, std::pair<int, int>> attrType;
@@ -50,7 +48,7 @@ public:
public:
std::string GenRuleBase() const;
nlohmann::json toJson();
std::string toString();
public:
DIST::Array *alignArray;

2
src/Distribution/DvmhDirective_func.h
View File

@@ -4,7 +4,7 @@
#include <string>
#include <set>
#include "dvm.h"
#include "types.h"
#include "../Utils/types.h"
SgExpression* createAndSetNext(const int side, const int variant, SgExpression *p);
std::vector<SgExpression*> genSubscripts(const std::vector<std::pair<int, int>> &shadowRenew, const std::vector<std::pair<int, int>> &shadowRenewShifts);

14
src/Distribution/GraphCSR.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <algorithm>
#include <string>
@@ -19,8 +19,8 @@ extern int passDone;
#include "Cycle.h"
#include "Arrays.h"
#include "Array.h"
#include "errors.h"
#include "utils.h"
#include "../Utils/errors.h"
#include "../Utils/utils.h"
#include "../VisualizerCalls/get_information.h"
#include "../VisualizerCalls/SendMessage.h"
@@ -830,13 +830,13 @@ namespace Distribution
color[k] = WHITE;
findFrom = currentV;
/*#ifdef _WIN32
#ifdef _WIN32
if (needPrint)
{
wstring vertexM = std::to_wstring(k + 1) + L"/" + std::to_wstring(vertByTrees[t].size());
sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ") + wstring(treeM.begin(), treeM.end()) + L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + wstring(vertexM.begin(), vertexM.end()));
}
#endif*/
#endif
__spf_print(PRINT_TIMES && needPrint, "v (tree %d) = %d (with neighb %d) ", t, i, neighbors[i + 1] - neighbors[i]);
activeV[activeCounter++] = currentV;
FindLoop(cyclesTmp[t], currentV, currentV, numbers);
@@ -847,8 +847,8 @@ namespace Distribution
maxLoopDim = wasMaxLoopDim;
}
/*if (needPrint)
sendMessage_2lvl(2);*/
if (needPrint)
sendMessage_2lvl(L"");
}
catch (int code)
{

2
src/Distribution/GraphCSR.h
View File

@@ -5,7 +5,7 @@
#include <set>
#include <tuple>
#include "RationalNum.h"
#include "../Utils/RationalNum.h"
typedef enum links { RR_link, WR_link, WW_link } LinkType;

2
src/DvmhRegions/DvmhRegion.h
View File

@@ -1,6 +1,6 @@
#pragma once
#include "graph_loops_func.h"
#include "../GraphLoop/graph_loops_func.h"
#include <string>

157
src/DvmhRegions/DvmhRegionInserter.cpp
View File

@@ -11,9 +11,9 @@
#include "DvmhRegionInserter.h"
#include "DvmhRegions/RegionsMerger.h"
#include "../VerificationCode/verifications.h"
#include "../Transformations/function_purifying.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "FunctionPurifying/function_purifying.h"
using namespace std;
@@ -794,6 +794,152 @@ ArraySet DvmhRegionInserter::get_used_arrs_for_block(SgStatement* st, int usage_
return usages;
}
static bool filterFromList(SgStatement* st, const set<string>& idents, bool exclude = false)
{
bool empty = false;
SgExpression* list = st->expr(0);
vector<SgExpression*> newList;
int total = 0;
while (list)
{
if (exclude)
{
if (idents.find(list->lhs()->symbol()->identifier()) == idents.end())
newList.push_back(list->lhs());
}
else
{
if (idents.find(list->lhs()->symbol()->identifier()) != idents.end())
newList.push_back(list->lhs());
}
total++;
list = list->rhs();
}
if (newList.size() == 0)
empty = true;
else if (total != newList.size())
st->setExpression(0, makeExprList(newList));
return empty;
}
static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
{
string oldFile = current_file->filename();
if (!func->switchToFile())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto copy = duplicateProcedure(func, NULL, false, false, false, true);
const set<string> idents(pars.identificators.begin(), pars.identificators.end());
//remove all exec
SgStatement* st = copy->lexNext();
SgStatement* last = copy->lastNodeOfStmt();
vector<SgStatement*> toExtract;
while (st != last)
{
if (isDVM_stat(st) || isSPF_stat(st))
{
if (st->variant() != ACC_ROUTINE_DIR)
{
SgStatement* next = st->lexNext();
st->extractStmt();
st = next;
}
else
st = st->lexNext();
}
else if (isSgExecutableStatement(st))
{
SgStatement* next = st->lastNodeOfStmt();
if (next != last)
next = next->lexNext();
toExtract.push_back(st);
st = next;
}
else
st = st->lexNext();
}
//remove unused declarations
st = copy->lexNext();
while (st != last)
{
const int var = st->variant();
if (var == VAR_DECL
|| var == VAR_DECL_90
|| var == DIM_STAT
|| var == INTENT_STMT
|| var == EXTERN_STAT)
{
bool empty = filterFromList(st, idents);
if (empty)
{
SgStatement* next = st->lexNext();
toExtract.push_back(st);
st = next;
continue;
}
}
else if (!isDVM_stat(st) && !isSPF_stat(st))
toExtract.push_back(st);
if (st->variant() == CONTAINS_STMT)
break;
st = st->lexNext();
}
for (auto& elem : toExtract)
elem->extractStmt();
string retVal = copy->unparse();
if (SgFile::switchToFile(oldFile) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
return retVal;
}
static void insertInterface(SgStatement* func, const string& iface, const string& fName)
{
string oldFile = current_file->filename();
if (!func->switchToFile())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
SgStatement* st = func->lexNext();
SgStatement* last = func->lastNodeOfStmt();
while (st != last)
{
if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
{
bool empty = filterFromList(st, { fName }, true);
if (empty)
{
SgStatement* next = st->lexNext();
st->extractStmt();
st = next;
continue;
}
}
if (isSgExecutableStatement(st))
break;
st = st->lexNext();
}
SgStatement* ifaceBlock = new SgStatement(INTERFACE_STMT);
addControlEndToStmt(ifaceBlock->thebif);
ifaceBlock->setlineNumber(getNextNegativeLineNumber()); // st->lineNumber()
ifaceBlock->setFileName(st->fileName());
st->insertStmtBefore(*ifaceBlock, *st->controlParent());
ifaceBlock->lastNodeOfStmt()->addComment(iface.c_str());
if (SgFile::switchToFile(oldFile) == -1)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
}
static LoopGraph* getParallelLoop(LoopGraph* loop)
{
auto prev_st = loop->loop->lexPrev();
@@ -1024,7 +1170,7 @@ static bool isPure(SgStatement* func)
void DvmhRegionInserter::createInterfaceBlockForOutCall(FuncInfo* func, FuncInfo* callFrom)
{
insertInterface(func->funcPointer, callFrom);
insertInterface(func->funcPointer, getInterfaceBlock(callFrom->funcPointer->GetOriginal(), callFrom->funcParams), callFrom->funcName);
}
void DvmhRegionInserter::createInterfaceBlockForParallelFunctions(bool onlyRoutine)
@@ -1297,10 +1443,7 @@ static set<DIST::Array*>
{
declStat = SgStatement::getStatementByFileAndLine(decl.first, decl.second);
if (declStat == NULL) // check in inlcudes
{
if (!main->switchToFile())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
{
for (auto st = main; st != main->lastNodeOfStmt() && !declStat; st = st->lexNext())
{
if (st->fileName() == decl.first && st->lineNumber() == decl.second)
@@ -1312,7 +1455,7 @@ static set<DIST::Array*>
}
else
{
declStat = getFuncStat(declStat, { BLOCK_DATA });
declStat = getFuncStat(declStat);
if (declStat != main)
{
declStat = NULL;

8
src/DvmhRegions/DvmhRegionInserter.h
View File

@@ -1,10 +1,10 @@
#pragma once
#include "graph_calls_func.h"
#include "graph_loops_func.h"
#include "expr_transform.h"
#include "../GraphCall/graph_calls_func.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../ExpressionTransform/expr_transform.h"
#include "../ParallelizationRegions/ParRegions.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#include "ReadWriteAnalyzer.h"
#include "DvmhRegion.h"

4
src/DvmhRegions/LoopChecker.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include "graph_loops_func.h"
#include "graph_calls_func.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../GraphCall/graph_calls_func.h"
#include <vector>
#include <string>

2
src/DvmhRegions/ReadWriteAnalyzer.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include "dvm.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#include "VarUsages.h"
#include <set>
#include <tuple>

2
src/DvmhRegions/TypedSymbol.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include "dvm.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#include <string>
enum class VAR_TYPE { VAR_ARR, VAR_DISTR_ARR, VAR_SCALAR, VAR_ANY, VAR_UNDEFINED };

4
src/DynamicAnalysis/createParallelRegions.cpp
View File

@@ -5,10 +5,10 @@
#include "./createParallelRegions.h"
#include "../CreateInterTree/CreateInterTree.h"
#include "graph_calls.h"
#include "../GraphCall/graph_calls.h"
#include "./gcov_info.h"
#include "./gCov_parser_func.h"
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <map>
#include <vector>

4
src/DynamicAnalysis/createParallelRegions.h
View File

@@ -1,10 +1,10 @@
#pragma once
#include "utils.h"
#include "../Utils/utils.h"
#include "./gcov_info.h"
#include "../CreateInterTree/CreateInterTree.h"
#include "graph_calls.h"
#include "../GraphCall/graph_calls.h"
#include <map>
#include <vector>

4
src/DynamicAnalysis/gCov_parser.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <stdio.h>
#include <fstream>
@@ -8,7 +8,7 @@
#include "dvm.h"
#include "gCov_parser_func.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
using namespace std;

2
src/DynamicAnalysis/gCov_parser_func.h
View File

@@ -5,7 +5,7 @@
#include <vector>
#include "dvm.h"
#include "errors.h"
#include "../Utils/errors.h"
#include "gcov_info.h"
#include "../CreateInterTree/CreateInterTree.h"

4
src/DynamicAnalysis/gcov_info.cpp
View File

@@ -1,10 +1,10 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <iostream>
#include <map>
#include <algorithm>
#include "errors.h"
#include "../Utils/errors.h"
#include "gcov_info.h"

2
src/DynamicAnalysis/gcov_info.h
View File

@@ -5,7 +5,7 @@
#include <map>
#include <stdint.h>
#include "utils.h"
#include "../Utils/utils.h"
//make 'class' - need friend for Gcov_info
struct Perform

2
src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp → src/ExpressionTransform/control_flow_graph_part.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include "dvm.h"
#include "acc_analyzer.h"

23
src/Transformations/ExpressionSubstitution/expr_transform.cpp → src/ExpressionTransform/expr_transform.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#if _WIN32 && NDEBUG && __SPF && __BOOST
#include <boost/thread.hpp>
@@ -19,11 +19,11 @@ extern int passDone;
#include "../ParallelizationRegions/ParRegions.h"
#include "../ParallelizationRegions/ParRegions_func.h"
#include "graph_loops.h"
#include "graph_calls.h"
#include "graph_calls_func.h"
#include "utils.h"
#include "SgUtils.h"
#include "../GraphLoop/graph_loops.h"
#include "../GraphCall/graph_calls.h"
#include "../GraphCall/graph_calls_func.h"
#include "../Utils/utils.h"
#include "../Utils/SgUtils.h"
#include "../Distribution/Distribution.h"
#include "../VisualizerCalls/get_information.h"
#include "expr_transform.h"
@@ -440,18 +440,15 @@ bool replaceConstantRec(SgExpression *&exp)
if (exp->variant() == CONST_REF)
{
SgExpression *ret = ReplaceParameter_(exp);
int sign = 1;
SgExpression* toCalc = ret;
if (toCalc->variant() == UNARY_ADD_OP)
toCalc = toCalc->lhs();
if (toCalc->variant() == MINUS_OP)
if (ret->variant() == UNARY_ADD_OP)
toCalc = ret->lhs();
if (ret->variant() == MINUS_OP)
{
toCalc = toCalc->lhs();
toCalc = ret->lhs();
sign = -1;
}
if (toCalc->isInteger())
{
exp = new SgValueExp(sign * toCalc->valueInteger());

6
src/Transformations/ExpressionSubstitution/expr_transform.h → src/ExpressionTransform/expr_transform.h
View File

@@ -5,10 +5,10 @@
#include <string>
#include "dvm.h"
#include "../Distribution/Distribution.h"
#include "graph_loops.h"
#include "../GraphLoop/graph_loops.h"
#include "../ParallelizationRegions/ParRegions.h"
#include "graph_calls.h"
#include "SgUtils.h"
#include "../GraphCall/graph_calls.h"
#include "../Utils/SgUtils.h"
#include "acc_analyzer.h"

33
src/GraphCall/graph_calls.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -14,14 +14,14 @@
#include "dvm.h"
#include "graph_calls_func.h"
#include "CFGraph/CFGraph.h"
#include "graph_loops_func.h"
#include "../CFGraph/CFGraph.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "SgUtils.h"
#include "json.hpp"
#include "../Utils/SgUtils.h"
#include "../Utils/json.hpp"
#include "../ParallelizationRegions/ParRegions_func.h"
#include "../DynamicAnalysis/gCov_parser_func.h"
#include "expr_transform.h"
#include "../ExpressionTransform/expr_transform.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "../VerificationCode/verifications.h"
@@ -779,20 +779,6 @@ static void checkSpecList(SgExpression *spec, FuncInfo* currF, const map<string,
}
}
static void checkInTypeDescription(SgExpression *ex, FuncInfo* currF, const map<string, int>& parNames)
{
if (ex)
{
if (ex->variant() == ARRAY_REF)
fillIn(currF, ex->lhs(), parNames, false);
else
{
checkInTypeDescription(ex->lhs(), currF, parNames);
checkInTypeDescription(ex->rhs(), currF, parNames);
}
}
}
static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, const set<SgStatement*>& activeOps)
{
if (currF->funcParams.countOfPars == 0)
@@ -812,13 +798,8 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
if (st->variant() == ENTRY_STAT)
continue;
if (isSgExecutableStatement(st) == NULL) {
checkInTypeDescription(st->expr(0), currF, parNames);
continue;
}
if (st->lineNumber() <= 0)
if (isSgExecutableStatement(st) == NULL || st->lineNumber() <= 0)
continue;
if (activeOps.size() && activeOps.find(st) == activeOps.end())

6
src/GraphCall/graph_calls.h
View File

@@ -3,10 +3,10 @@
#include <string>
#include <set>
#include "AstWrapper.h"
#include "utils.h"
#include "../Utils/AstWrapper.h"
#include "../Utils/utils.h"
#include "../DirectiveProcessing/shadow.h"
#include "graph_loops.h"
#include "../GraphLoop/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",

6
src/GraphCall/graph_calls_base.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -10,10 +10,10 @@
#include <set>
#include <string>
#include "errors.h"
#include "../Utils/errors.h"
#include "graph_calls.h"
#include "../Distribution/Distribution.h"
#include "utils.h"
#include "../Utils/utils.h"
#include "../ParallelizationRegions/ParRegions.h"
using std::vector;

2
src/GraphCall/graph_calls_func.h
View File

@@ -5,7 +5,7 @@
#include <set>
#include "graph_calls.h"
#include "graph_loops.h"
#include "../GraphLoop/graph_loops.h"
#include "../ParallelizationRegions/ParRegions.h"
#include "Utils/json.hpp"

29
src/GraphLoop/graph_loops.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -12,26 +12,26 @@
#include "dvm.h"
#include "../Sapfor.h"
#include "graph_calls_func.h"
#include "../GraphCall/graph_calls_func.h"
#include "../ParallelizationRegions/ParRegions_func.h"
#include "expr_transform.h"
#include "../ExpressionTransform/expr_transform.h"
#include "../Distribution/GraphCSR.h"
#include "../Distribution/Arrays.h"
#include "../Distribution/Distribution.h"
#include "graph_loops.h"
#include "utils.h"
#include "SgUtils.h"
#include "../Utils/utils.h"
#include "../Utils/SgUtils.h"
#include "errors.h"
#include "AstWrapper.h"
#include "json.hpp"
#include "../Utils/errors.h"
#include "../Utils/AstWrapper.h"
#include "../Utils/json.hpp"
#include "../DirectiveProcessing/directive_parser.h"
#include "../DynamicAnalysis/gCov_parser_func.h"
#include "VectorAssignToLoop/array_assign_to_loop.h"
#include "../Transformations/array_assign_to_loop.h"
using std::vector;
using std::map;
@@ -520,7 +520,7 @@ static void findArrayRef(SgExpression *exp, bool isWirte, set<DIST::Array*>& use
{
if (exp)
{
if (isArrayRef(exp))
if (exp->variant() == ARRAY_REF)
{
DIST::Array *arrayRef = NULL;
SgSymbol *symbS = OriginalSymbol(exp->symbol());
@@ -699,12 +699,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
newLoop->hasPrints = hasThisIds(st, newLoop->linesOfIO, { WRITE_STAT, READ_STAT, OPEN_STAT, CLOSE_STAT, PRINT_STAT } ); // FORMAT_STAT
newLoop->hasStops = hasThisIds(st, newLoop->linesOfStop, { STOP_STAT, PAUSE_NODE });
newLoop->hasDvmIntervals = hasThisIds(st, tmpLines, { DVM_INTERVAL_DIR, DVM_ENDINTERVAL_DIR, DVM_EXIT_INTERVAL_DIR });
if (isSgForStmt(st))
newLoop->loopType = LoopType::FOR;
else if (isSgWhileStmt(st))
newLoop->loopType = LoopType::WHILE;
else
newLoop->loopType = LoopType::NONE;
newLoop->isFor = isSgForStmt(st) ? true : false;
newLoop->inCanonicalFrom = isSgForStmt(st) ? true : false;
newLoop->hasSubstringRefs = hasSubstringRef(st);
@@ -782,7 +777,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
newLoop->startEndExpr = std::make_pair((Expression*)NULL, (Expression*)NULL);
newLoop->loop = new Statement(st);
newLoop->loopSymbols.addMainVar(st->symbol() ? st->symbol()->identifier() : "unknown");
newLoop->loopSymbol = st->symbol() ? st->symbol()->identifier() : "unknown";
findArrayRefs(newLoop);
SgStatement *lexPrev = st->lexPrev();

56
src/GraphLoop/graph_loops.h
View File

@@ -5,8 +5,8 @@
#include <map>
#include <set>
#include "errors.h"
#include "types.h"
#include "../Utils/errors.h"
#include "../Utils/types.h"
#include "../Distribution/DvmhDirective.h"
#include "../Distribution/Distribution.h"
@@ -25,33 +25,6 @@ namespace DIST = Distribution;
void getRealArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
void getAllArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
enum class LoopType { NONE, FOR, WHILE, IMPLICIT };
struct InductiveVariables
{
private:
std::string mainVar;
std::set<std::string> allVars;
public:
InductiveVariables() { }
explicit InductiveVariables(const std::string& mainVar, const std::set<std::string>& allVars) : mainVar(mainVar), allVars(allVars) { };
std::string getMainVar() const { return mainVar; }
std::set<std::string> getAllVars() const { return allVars; }
void addVar(const std::string& var) { allVars.insert(var); }
void addMainVar(const std::string& var) { mainVar = var; allVars.insert(var); }
void replaceMainVar(const std::string& var)
{
allVars.erase(mainVar);
addMainVar(var);
}
};
struct LoopGraph
{
private:
@@ -97,7 +70,7 @@ public:
calculatedCountOfIters = 0;
executionTimeInSec = -1.0;
inDvmhRegion = 0;
loopType = LoopType::NONE;
isFor = false;
inCanonicalFrom = false;
hasAccessToSubArray = false;
hasSubstringRefs = false;
@@ -140,24 +113,21 @@ public:
{
return hasUnknownArrayDep || hasUnknownScalarDep || hasGoto || hasPrints || (hasConflicts.size() != 0) || hasStops || hasNonPureProcedures ||
hasUnknownArrayAssigns || hasNonRectangularBounds || hasIndirectAccess || hasWritesToNonDistribute || hasDifferentAlignRules || hasDvmIntervals ||
!isFor() || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
!isFor || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
}
bool hasLimitsToSplit() const
{
return hasGoto || hasStops || !isFor() || hasPrints;
return hasGoto || hasStops || !isFor || hasPrints;
}
bool hasLimitsToCombine() const
{
return hasGoto || hasStops || !isFor() || hasPrints || linesOfCycle.size();
return hasGoto || hasStops || !isFor || hasPrints || linesOfCycle.size();
}
void addConflictMessages(std::vector<Messages> *messages)
{
if (messages == NULL)
return;
const int line = altLineNum > 0 ? altLineNum : lineNum;
if (hasUnknownArrayDep)
messages->push_back(Messages(NOTE, line, R113, L"unknown array dependency prevents parallelization of this loop", 3006));
@@ -198,7 +168,7 @@ public:
if (hasDvmIntervals)
messages->push_back(Messages(NOTE, line, R145, L"DVM intervals prevent parallelization of this loop", 3006));
if (!isFor() || !inCanonicalFrom)
if (!isFor || !inCanonicalFrom)
messages->push_back(Messages(NOTE, line, R178, L"This type of loop is not supported by the system", 3006));
if (lastprivateScalars.size())
@@ -423,14 +393,6 @@ public:
void* getRealStat(const char* file) const;
bool isFor() const { return loopType == LoopType::FOR; }
bool isWhile() const { return loopType == LoopType::WHILE; }
bool isImplicit() const { return loopType == LoopType::IMPLICIT; }
std::string loopSymbol() const { return loopSymbols.getMainVar(); }
public:
int lineNum;
int altLineNum;
@@ -445,7 +407,7 @@ public:
int startVal, endVal, stepVal;
std::tuple<Expression*, Expression*, Expression*> startEndStepVals;
InductiveVariables loopSymbols;
std::string loopSymbol;
std::pair<Expression*, Expression*> startEndExpr;
bool hasGoto;
@@ -486,7 +448,7 @@ public:
bool hasSubstringRefs;
LoopType loopType;
bool isFor;
bool inCanonicalFrom;

10
src/GraphLoop/graph_loops_base.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -23,8 +23,8 @@ using std::make_pair;
using std::get;
#include "graph_loops.h"
#include "graph_calls_func.h"
#include "errors.h"
#include "../GraphCall/graph_calls_func.h"
#include "../Utils/errors.h"
#include "../Distribution/Distribution.h"
#include "../Distribution/CreateDistributionDirs.h"
#include "../ParallelizationRegions/ParRegions.h"
@@ -551,7 +551,7 @@ void addToDistributionGraph(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*>>
continue;
}
if (!loopAccess.first->isFor())
if (!loopAccess.first->isFor)
continue;
DIST::GraphCSR<int, double, attrType>& G = currReg->GetGraphToModify();
@@ -775,7 +775,7 @@ static void isAllOk(const vector<LoopGraph*> &loops, vector<Messages> &currMessa
{
if (loops[i]->region)
{
if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor())
if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor)
{
wstring bufE, bufR;
__spf_printToLongBuf(bufE, L" Can not calculate count of iterations for this loop, information about iterations in all loops in parallel regions '%s' will be ignored",

19
src/Transformations/FunctionInlining/inliner.cpp → src/Inliner/inliner.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <stdlib.h>
#include <stdio.h>
@@ -8,13 +8,13 @@
#include <algorithm>
#include "dvm.h"
#include "errors.h"
#include "utils.h"
#include "SgUtils.h"
#include "graph_calls_func.h"
#include "../Utils/errors.h"
#include "../Utils/utils.h"
#include "../Utils/SgUtils.h"
#include "../GraphCall/graph_calls_func.h"
#include "inliner.h"
#include "../VisualizerCalls/SendMessage.h"
#include "expr_transform.h"
#include "../ExpressionTransform/expr_transform.h"
using std::set;
using std::map;
@@ -1776,8 +1776,11 @@ static bool inliner(const string& fileName_in, const string& funcName, const int
point.currCall = func->funcName;
__spf_print(1, " INLINE %s - ", func->funcName.c_str());
sendMessage_2lvl(6, func->funcName);
#ifdef _WIN32
sendMessage_2lvl(wstring(L"ïîäñòàíîâêà ôóíêöèè '") + wstring(func->funcName.begin(), func->funcName.end()) + L"'");
#else
sendMessage_2lvl(wstring(L"inlinig of function '") + wstring(func->funcName.begin(), func->funcName.end()) + L"'");
#endif
//1 level
bool isInlined = run_inliner(funcMap, toInsert, SPF_messages, fileName, func, newSymbsToDeclare, point, commonBlocks);
__spf_print(1, "%s\n", isInlined ? "done" : "fault");

0
src/Transformations/FunctionInlining/inliner.h → src/Inliner/inliner.h
View File

6
src/LoopAnalyzer/allocations_prepoc.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -8,8 +8,8 @@
#include <set>
#include "dvm.h"
#include "SgUtils.h"
#include "errors.h"
#include "../Utils/SgUtils.h"
#include "../Utils/errors.h"
using std::set;
using std::pair;

6
src/LoopAnalyzer/dep_analyzer.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -20,8 +20,8 @@
#include "dvm.h"
#include "loop_analyzer.h"
#include "utils.h"
#include "SgUtils.h"
#include "../Utils/utils.h"
#include "../Utils/SgUtils.h"
#include "../ParallelizationRegions/ParRegions_func.h"
#include "../SageAnalysisTool/depGraph.h"
#include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h"

62
src/LoopAnalyzer/loop_analyzer.cpp
View File

@@ -18,7 +18,7 @@
#include <tuple>
#include <stack>
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#if _WIN32 && NDEBUG && __BOOST
#include <boost/thread.hpp>
@@ -30,25 +30,25 @@ extern int passDone;
#include "../Distribution/Arrays.h"
#include "../ParallelizationRegions/ParRegions.h"
#include "errors.h"
#include "../Utils/errors.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "../DirectiveProcessing/directive_creator.h"
#include "SgUtils.h"
#include "AstWrapper.h"
#include "../Utils/SgUtils.h"
#include "../Utils/AstWrapper.h"
#include "graph_calls_func.h"
#include "graph_loops_func.h"
#include "../GraphCall/graph_calls_func.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../ParallelizationRegions/ParRegions_func.h"
#include "../DynamicAnalysis/gCov_parser_func.h"
#include "expr_transform.h"
#include "../ExpressionTransform/expr_transform.h"
#include "../SageAnalysisTool/depInterfaceExt.h"
#include "../VisualizerCalls/get_information.h"
#include "../VisualizerCalls/SendMessage.h"
#include "LoopEndDoConverter/enddo_loop_converter.h"
#include "../Transformations/enddo_loop_converter.h"
#include "../DirectiveProcessing/remote_access.h"
#include "../DirectiveProcessing/directive_omp_parser.h"
@@ -1633,7 +1633,17 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
createNeededException();
string fName = file->functions(i)->symbol()->identifier();
sendMessage_2lvl(0, (file->functions(i)->variant() != MODULE_STMT), fName);
#if _WIN32
if (file->functions(i)->variant() != MODULE_STMT)
sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> '") + wstring(fName.begin(), fName.end()) + L"'");
else
sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> '") + wstring(fName.begin(), fName.end()) + L"'");
#else
if (file->functions(i)->variant() != MODULE_STMT)
sendMessage_2lvl(wstring(L"processing function '") + wstring(fName.begin(), fName.end()) + L"'");
else
sendMessage_2lvl(wstring(L"processing module '") + wstring(fName.begin(), fName.end()) + L"'");
#endif
set<SgSymbol*> delcsSymbViewed;
set<SgStatement*> delcsStatViewed;
@@ -1700,10 +1710,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
map<string, pair<SgSymbol*, SgStatement*>> notMappedDistributedArrays;
set<string> mappedDistrbutedArrays;
const ParallelRegionLines* prevParLines = NULL;
double prevLinesWeight = 1.0;
double currentWeight = 1.0;
while (st != lastNode)
{
createNeededException();
@@ -1726,31 +1733,13 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
}
const int currentLine = st->lineNumber() < -1 ? st->localLineNumber() : st->lineNumber();
auto regAndLines = getRegionAndLinesByLine(regions, st->fileName(), currentLine);
auto *currReg = regAndLines.first;
auto *parLines = regAndLines.second;
ParallelRegion *currReg = getRegionByLine(regions, st->fileName(), currentLine);
if (currReg == NULL)
{
st = st->lexNext();
continue;
}
if (parLines != prevParLines)
{
prevParLines = parLines;
auto newParLinesWeight = parLines ? parLines->weight : 1.0;
if (prevParLines)
currentWeight /= prevLinesWeight;
if (parLines)
currentWeight *= newParLinesWeight;
prevLinesWeight = newParLinesWeight;
prevParLines = parLines;
}
if (isSgExecutableStatement(st) == NULL)
delcsStatViewed.insert(st);
else if (!sharedMemoryParallelization &&
@@ -2178,8 +2167,11 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
if (!skipDeps)
{
string fName = file->functions(i)->symbol()->identifier();
sendMessage_2lvl(1, idx, (int)convertedLoopInfo.size());
#ifdef _WIN32
sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
#else
sendMessage_2lvl(wstring(L"processing loop ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
#endif
tryToFindDependencies(loop.first, allLoops, funcWasInit, file, regions, currMessages, collection, funcByName, defUseByPlace);
}
}
@@ -2199,7 +2191,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
LoopGraph *tmpLoop = new LoopGraph();
tmpLoop->region = reg;
tmpLoop->loopType = LoopType::FOR;
tmpLoop->isFor = true;
tmpLoops.push_back(tmpLoop);
@@ -2327,7 +2319,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
if (parallizeFreeLoops)
selectFreeLoopsForParallelization(loopsForFunction, funcName, (regime == DATA_DISTR), regions, messagesForFile);
}
sendMessage_2lvl(2);
sendMessage_2lvl(L"");
}
else if (regime == COMP_DISTR)
{

8
src/LoopAnalyzer/loop_analyzer.h
View File

@@ -5,12 +5,12 @@
#include <tuple>
#include <vector>
#include <set>
#include "graph_loops.h"
#include "graph_calls.h"
#include "../GraphLoop/graph_loops.h"
#include "../GraphCall/graph_calls.h"
#include "../ParallelizationRegions/ParRegions.h"
#include "../SageAnalysisTool/depInterfaceExt.h"
#include "AstWrapper.h"
#include "SgUtils.h"
#include "../Utils/AstWrapper.h"
#include "../Utils/SgUtils.h"
#include "dvm.h"

123
src/ParallelizationRegions/ParRegions.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <stdio.h>
#include <stdlib.h>
@@ -10,12 +10,12 @@
#include "dvm.h"
#include "ParRegions.h"
#include "utils.h"
#include "SgUtils.h"
#include "graph_calls_func.h"
#include "graph_loops.h"
#include "../Utils/utils.h"
#include "../Utils/SgUtils.h"
#include "../GraphCall/graph_calls_func.h"
#include "../GraphLoop/graph_loops.h"
#include "../Distribution/Distribution.h"
#include "expr_transform.h"
#include "../ExpressionTransform/expr_transform.h"
using std::vector;
using std::string;
@@ -93,10 +93,8 @@ static inline SgStatement* getParentStat(SgStatement *st)
return iterator;
}
static void updateRegionInfo(SgStatement *st, map<string, pair<Statement*, Statement*>> &startEnd,
map<string, pair<int, int>> &lines_,
map<string, map<string, set<int>>> &funcCallFromReg,
const map<string, FuncInfo*> &mapFuncs)
static void updateRegionInfo(SgStatement *st, map<string, pair<Statement*, Statement*>> &startEnd, map<string, pair<int, int>> &lines_,
set<string> &funcCallFromReg, const map<string, FuncInfo*> &mapFuncs)
{
string containsPrefix = "";
SgStatement *st_ps = getParentStat(st);
@@ -105,26 +103,17 @@ static void updateRegionInfo(SgStatement *st, map<string, pair<Statement*, State
containsPrefix = st_ps->symbol()->identifier() + string(".");
extendRegionInfo(st, startEnd, lines_);
set<string> callsFromStatement;
if (st->variant() == PROC_STAT)
{
string fullName = st->symbol()->identifier();
//check contains
if (mapFuncs.find(containsPrefix + fullName) != mapFuncs.end())
fullName = containsPrefix + fullName;
callsFromStatement.insert(fullName);
funcCallFromReg.insert(fullName);
}
for (int z = 0; z < 3; ++z)
findFuncCalls(st->expr(z), callsFromStatement, containsPrefix, mapFuncs);
string filename = st->fileName();
int line = st->lineNumber();
for (const auto &func_name : callsFromStatement)
funcCallFromReg[func_name][filename].insert(line);
findFuncCalls(st->expr(z), funcCallFromReg, containsPrefix, mapFuncs);
}
static void fillArrayNamesInReg(set<string> &usedArrayInRegion, SgExpression *exp)
@@ -329,9 +318,8 @@ void fillRegionLines(SgFile *file, vector<ParallelRegion*> &regions, vector<Mess
string regionName = "";
map<string, pair<Statement*, Statement*>> startEnd;
map<string, pair<int, int>> lines_;
map<string, map<string, set<int>>> funcCallFromReg;
set<string> funcCallFromReg;
bool regionStarted = false;
double fragmentWeight = 1.0;
vector<SgStatement*> toDel;
for (int i = 0; i < funcNum; ++i)
@@ -380,33 +368,6 @@ void fillRegionLines(SgFile *file, vector<ParallelRegion*> &regions, vector<Mess
itFunc->second->callRegions.insert(0);
}
}
// parse SPF_APPLY_FRAGMENT clause
auto *apply_fragment = data->expr(1);
fragmentWeight = 1.0;
while (apply_fragment)
{
auto *curr = apply_fragment->lhs();
if (curr)
{
__spf_print(1, "%s %d\n", curr->unparse(), curr->variant());
if (curr->variant() == SPF_WEIGHT_OP)
{
if (curr->lhs() &&
isSgValueExp(curr->lhs()) &&
isSgValueExp(curr->lhs())->doubleValue())
{
fragmentWeight = strtod(isSgValueExp(curr->lhs())->doubleValue(), NULL);
__spf_print(1, "->> %lf\n", fragmentWeight);
}
else
__spf_print(1, "WEIGHT clause without double argument\n");
}
}
apply_fragment = apply_fragment->rhs();
}
}
if (next && next->variant() == SPF_END_PARALLEL_REG_DIR)
@@ -439,12 +400,10 @@ void fillRegionLines(SgFile *file, vector<ParallelRegion*> &regions, vector<Mess
extendRegionInfo(st, startEnd, lines_, true);
for (auto itRegInfo = startEnd.begin(); itRegInfo != startEnd.end(); ++itRegInfo)
currReg->AddLines(lines_[itRegInfo->first], itRegInfo->first, &itRegInfo->second, fragmentWeight);
currReg->AddLines(lines_[itRegInfo->first], itRegInfo->first, &itRegInfo->second);
for (auto &by_func : funcCallFromReg)
for (auto &by_file : by_func.second)
for(auto &by_line : by_file.second)
currReg->AddFuncCalls(by_func.first, by_file.first, by_line);
for (auto &func : funcCallFromReg)
currReg->AddFuncCalls(func);
filterUserDirectives(currReg, usedArrayInRegion, userDvmRedistrDirs, userDvmRealignDirs, userDvmShadowDirs);
currReg->AddUserDirectives(userDvmRealignDirs, DVM_REALIGN_DIR);
@@ -537,48 +496,34 @@ void fillRegionLinesStep2(vector<ParallelRegion*> &regions, const map<string, ve
{
if (regions[i]->GetName() != "DEFAULT")
for (auto &func : regions[i]->GetFuncCalls())
setExplicitFlag(func.first, funcMap);
setExplicitFlag(func, funcMap);
}
for (int i = 0; i < regions.size(); ++i)
{
if (regions[i]->GetName() != "DEFAULT")
{
map<string, double> uniqFuncCalls;
map<string, map<string, set<int>>> callPlaces;
set<string> uniqFuncCalls;
for (auto &elem : regions[i]->GetFuncCalls())
{
double max_weight = 0;
for (auto* fragment : elem.second)
if (fragment->weight > max_weight)
max_weight = fragment->weight;
uniqFuncCalls[elem.first] = max_weight;
}
bool wasChanged = true;
auto funcsBefore = uniqFuncCalls;
uniqFuncCalls.insert(elem);
bool wasChanged = 1;
while (wasChanged)
{
wasChanged = false;
auto updated = uniqFuncCalls;
wasChanged = 0;
for (auto &uniqF : uniqFuncCalls)
{
auto func = funcMap.find(uniqF.first);
auto func = funcMap.find(uniqF);
if (func != funcMap.end())
{
for (auto &call : func->second->callsFromDetailed)
for (auto &calls : func->second->callsFrom)
{
auto it = updated.find(call.detailCallsFrom.first);
if (it == updated.end())
updated.insert({call.detailCallsFrom.first, uniqF.second});
else
it->second = std::max(it->second, uniqF.second);
callPlaces[call.detailCallsFrom.first][func->second->fileName].insert(call.detailCallsFrom.second);
auto it = uniqFuncCalls.find(calls);
if (it == uniqFuncCalls.end())
{
uniqFuncCalls.insert(it, calls);
wasChanged = 1;
}
}
}
}
@@ -587,27 +532,21 @@ void fillRegionLinesStep2(vector<ParallelRegion*> &regions, const map<string, ve
string toPrint = "";
for (auto &elem : uniqFuncCalls)
{
auto it = funcMap.find(elem.first);
auto it = funcMap.find(elem);
if (it != funcMap.end())
{
regions[i]->AddLines(it->second->linesNum, it->second->fileName, NULL, elem.second);
regions[i]->AddLines(it->second->linesNum, it->second->fileName);
regions[i]->AddFuncCallsToAllCalls(it->second);
if (it->second->inRegion == 0)
it->second->inRegion = 2;
it->second->callRegions.insert(i);
toPrint += elem.first + " ";
toPrint += elem + " ";
}
}
for (auto &elem : callPlaces)
{
for (const auto &byFile : elem.second)
for (auto byLine : byFile.second)
regions[i]->AddFuncCalls(elem.first, byFile.first, byLine);
}
if (toPrint != "")
__spf_print(1, "[%s]: funcs: %s\n", regions[i]->GetName().c_str(), toPrint.c_str());
}

106
src/ParallelizationRegions/ParRegions.h
View File

@@ -9,17 +9,15 @@
#include "../Distribution/DvmhDirective.h"
#include "../Distribution/GraphCSR.h"
#include "../Distribution/Distribution.h"
#include "AstWrapper.h"
#include "json.hpp"
#include "../Utils/AstWrapper.h"
#if __SPF
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#endif
struct ParallelRegionLines
{
ParallelRegionLines(double weight = 1.0) : weight(weight)
ParallelRegionLines()
{
lines = std::make_pair(-1, -1);
stats = std::make_pair<Statement*, Statement*>(NULL, NULL);
@@ -27,15 +25,14 @@ struct ParallelRegionLines
intervalAfter = std::make_pair<Statement*, Statement*>(NULL, NULL);
}
ParallelRegionLines(const std::pair<int, int> &lines, double weight = 1.0) : lines(lines), weight(weight)
ParallelRegionLines(const std::pair<int, int> &lines) : lines(lines)
{
stats = std::make_pair<Statement*, Statement*>(NULL, NULL);
intervalBefore = std::make_pair<Statement*, Statement*>(NULL, NULL);
intervalAfter = std::make_pair<Statement*, Statement*>(NULL, NULL);
}
ParallelRegionLines(const std::pair<int, int> &lines, const std::pair<Statement*, Statement*> stats, double weight = 1.0)
: lines(lines), stats(stats), weight(weight)
ParallelRegionLines(const std::pair<int, int> &lines, const std::pair<Statement*, Statement*> stats) : lines(lines), stats(stats)
{
intervalBefore = std::make_pair<Statement*, Statement*>(NULL, NULL);
intervalAfter = std::make_pair<Statement*, Statement*>(NULL, NULL);
@@ -63,8 +60,6 @@ struct ParallelRegionLines
// <start, end> interval
std::pair<Statement*, Statement*> intervalBefore;
std::pair<Statement*, Statement*> intervalAfter;
double weight; // weight of the fragment among all fragments of this region
};
#if __SPF
@@ -119,7 +114,7 @@ public:
currentVariant = copy.currentVariant;
}
int AddLines(const std::pair<int, int> &linesToAdd, const std::string &file, const std::pair<Statement*, Statement*> *startEnd = NULL, double weight = 1.0)
int AddLines(const std::pair<int, int> &linesToAdd, const std::string &file, const std::pair<Statement*, Statement*> *startEnd = NULL)
{
if (linesToAdd.first > linesToAdd.second)
return -1;
@@ -129,29 +124,17 @@ public:
it = lines.insert(it, make_pair(file, std::vector<ParallelRegionLines>()));
if (startEnd)
it->second.push_back(ParallelRegionLines(linesToAdd, *startEnd, weight));
it->second.push_back(ParallelRegionLines(linesToAdd, *startEnd));
else
it->second.push_back(ParallelRegionLines(linesToAdd, weight));
it->second.push_back(ParallelRegionLines(linesToAdd));
return 0;
}
void AddFuncCalls(const std::string &func, const std::string &file, const int line)
{
auto *found_lines = GetLinesByLine(file, line);
if (found_lines)
functionsCall[func].insert(found_lines);
}
void AddFuncCalls(const std::string &func) { functionsCall.insert(func); }
#if __SPF
void AddFuncCallsToAllCalls(FuncInfo *func, const std::string &file, const int line)
{
auto *found_lines = GetLinesByLine(file, line);
if (found_lines)
allFunctionsCall[func].insert(found_lines);
}
void AddFuncCallsToAllCalls(FuncInfo *func) { allFunctionsCall.insert(func); }
#endif
uint64_t GetId() const { return regionId; }
@@ -191,10 +174,10 @@ public:
const DataDirective& GetDataDir() const { return dataDirectives; }
DataDirective& GetDataDirToModify() { return dataDirectives; }
const std::map<std::string, std::set<const ParallelRegionLines*>>& GetFuncCalls() const { return functionsCall; }
const std::set<std::string>& GetFuncCalls() const { return functionsCall; }
#if __SPF
const std::map<FuncInfo*, std::set<const ParallelRegionLines*>>& GetAllFuncCalls() const { return allFunctionsCall; }
const std::set<FuncInfo*>& GetAllFuncCalls() const { return allFunctionsCall; }
const std::map<FuncInfo*, std::map<DIST::Array*, std::vector<ParallelRegionLines>>>& GetUsedLocalArrays() const { return usedLocalArrays; }
const std::map<FuncInfo*, std::map<DIST::Array*, std::vector<ParallelRegionLines>>>& GetUsedCommonArrays() const { return usedCommonArrays; }
@@ -233,7 +216,7 @@ public:
}
#endif
bool HasThisLine(const int line, const std::string &file, const ParallelRegionLines** found = nullptr) const
bool HasThisLine(const int line, const std::string &file) const
{
bool retVal = false;
auto it = lines.find(file);
@@ -244,9 +227,6 @@ public:
if (it->second[i].lines.first <= line && it->second[i].lines.second >= line)
{
retVal = true;
if (found)
*found = &(it->second[i]);
break;
}
}
@@ -255,42 +235,35 @@ public:
return retVal;
}
nlohmann::json toJson()
std::string toString()
{
nlohmann::json retVal;
std::string retVal = "";
retVal["packedRegionId"] = std::to_string(regionId);
retVal["originalName"] = originalName;
retVal += "#" + std::to_string(regionId);
retVal += "#" + originalName;
retVal += "#" + std::to_string(lines.size());
nlohmann::json arrays = nlohmann::json::array();
for (auto& array : allArrays.GetArrays())
arrays.push_back(array->toJson());
retVal["packedArrays"] = arrays;
nlohmann::json linesInfo = nlohmann::json::array();
for (auto& [file, linesByFile] : lines)
for (auto it = lines.begin(); it != lines.end(); ++it)
{
nlohmann::json linesRegs;
nlohmann::json lines = nlohmann::json::array();
for (auto& elem : linesByFile)
{
JSON pair;
pair["key"] = elem.lines.first;
pair["value"] = elem.lines.second;
lines.push_back(pair);
}
linesRegs["file"] = file;
linesRegs["lines"] = lines;
linesInfo.push_back(linesRegs);
retVal += "|" + it->first + "|";
retVal += std::to_string(it->second.size());
for (int i = 0; i < it->second.size(); ++i)
retVal += "#" + std::to_string(it->second[i].lines.first) + "#" + std::to_string(it->second[i].lines.second);
}
retVal["regionsLines"] = linesInfo;
nlohmann::json alignRules = nlohmann::json::array();
for (auto& rule : dataDirectives.alignRules)
alignRules.push_back(rule.toJson());
retVal["alignRules"] = alignRules;
const std::set<DIST::Array*> &arrays = allArrays.GetArrays();
retVal += "#" + std::to_string(arrays.size());
//create map<array_address, DIST::Array_toString()>
for (auto it = arrays.begin(); it != arrays.end(); ++it)
{
retVal += "#" + std::to_string((long long)(*it));
retVal += "#" + (*it)->toString();
}
retVal += "#" + std::to_string(dataDirectives.alignRules.size());
for (int i = 0; i < dataDirectives.alignRules.size(); ++i)
retVal += dataDirectives.alignRules[i].toString();
return retVal;
}
@@ -310,7 +283,7 @@ public:
fprintf(fileOut, " originalName '%s'\n", originalName.c_str());
fprintf(fileOut, " functions call from %d:\n", (int)functionsCall.size());
for (auto &func : functionsCall)
fprintf(fileOut, " '%s'\n", func.first.c_str());
fprintf(fileOut, " '%s'\n", func.c_str());
fprintf(fileOut, " total lines %d:\n", (int)lines.size());
for (auto &line : lines)
{
@@ -380,11 +353,11 @@ private:
std::string originalName;
// file -> lines info
std::map<std::string, std::vector<ParallelRegionLines>> lines;
std::map<std::string, std::set<const ParallelRegionLines*>> functionsCall; // func name -> fragments with calls
std::set<std::string> functionsCall;
#if __SPF
// for RESOLVE_PAR_REGIONS
std::map<FuncInfo*, std::set<const ParallelRegionLines*>> allFunctionsCall; // function -> fragments with calls
std::set<FuncInfo*> allFunctionsCall;
std::map<FuncInfo*, std::map<DIST::Array*, std::vector<ParallelRegionLines>>> usedLocalArrays; // func -> array -> lines
std::map<FuncInfo*, std::map<DIST::Array*, std::vector<ParallelRegionLines>>> usedCommonArrays; // func -> array -> lines
//
@@ -426,5 +399,4 @@ private:
ParallelRegion* getRegionById(const std::vector<ParallelRegion*>& regions, const uint64_t regionId);
ParallelRegion* getRegionByName(const std::vector<ParallelRegion*>& regions, const std::string& regionName);
ParallelRegion* getRegionByLine(const std::vector<ParallelRegion*>& regions, const std::string& file, const int line);
std::pair<ParallelRegion*, const ParallelRegionLines*> getRegionAndLinesByLine(const std::vector<ParallelRegion*>& regions, const std::string& file, const int line);
std::set<ParallelRegion*> getAllRegionsByLine(const std::vector<ParallelRegion*>& regions, const std::string& file, const int line);

4
src/ParallelizationRegions/ParRegions_func.h
View File

@@ -1,8 +1,8 @@
#pragma once
#include "ParRegions.h"
#include "graph_calls.h"
#include "graph_loops.h"
#include "../GraphCall/graph_calls.h"
#include "../GraphLoop/graph_loops.h"
void fillRegionLines(SgFile *file, std::vector<ParallelRegion*> &regions, std::vector<Messages>& messagesForFile, std::vector<LoopGraph*> *loops = NULL, std::vector<FuncInfo*> *funcs = NULL);
void fillRegionLinesStep2(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo, std::map<std::string, std::vector<LoopGraph*>> *loopGraph = NULL);

2
src/ParallelizationRegions/expand_extract_reg.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <map>
#include <string>

4
src/ParallelizationRegions/expand_extract_reg.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include "ParRegions.h"
#include "SgUtils.h"
#include "errors.h"
#include "../Utils/SgUtils.h"
#include "../Utils/errors.h"
bool expandExtractReg(const std::string &fileName, const int startLine, const int endLine, const std::vector<ParallelRegion*> &regions, std::vector<Messages> &messagesForFile, const bool toDelete = false);

12
src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <string>
#include <vector>
@@ -11,14 +11,14 @@
#include "ParRegions_func.h"
#include "resolve_par_reg_conflicts.h"
#include "graph_calls_func.h"
#include "graph_loops_func.h"
#include "../GraphCall/graph_calls_func.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "../DirectiveProcessing/directive_creator.h"
#include "../DirectiveProcessing/insert_directive.h"
#include "SgUtils.h"
#include "expr_transform.h"
#include "FunctionPurifying/function_purifying.h"
#include "../Utils/SgUtils.h"
#include "../ExpressionTransform/expr_transform.h"
#include "../Transformations/function_purifying.h"
using std::map;
using std::pair;

6
src/ParallelizationRegions/resolve_par_reg_conflicts.h
View File

@@ -1,9 +1,9 @@
#pragma once
#include "ParRegions.h"
#include "SgUtils.h"
#include "errors.h"
#include "graph_calls.h"
#include "../Utils/SgUtils.h"
#include "../Utils/errors.h"
#include "../GraphCall/graph_calls.h"
void fillRegionIntervals(std::vector<ParallelRegion*> &regions);
void fillRegionArrays(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo, const std::map<std::string, CommonBlock*> &commonBlocks);

159
src/Predictor/PredictScheme.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -14,16 +14,15 @@
#include "dvm.h"
#include "../DynamicAnalysis/gcov_info.h"
#include "../DynamicAnalysis/gCov_parser_func.h"
#include "PredictScheme.h"
#include "SgUtils.h"
#include "../Utils/SgUtils.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "../Distribution/DvmhDirective.h"
#include "graph_loops_func.h"
#include "expr_transform.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../ExpressionTransform/expr_transform.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "../LoopAnalyzer/loop_analyzer.h"
#include "CFGraph/CFGraph.h"
#include "../Utils/utils.h"
#include "../CFGraph/CFGraph.h"
#include "json.hpp"
@@ -37,109 +36,6 @@ using std::tuple;
using json = nlohmann::json;
void runPredictSchemeOld(SgProject &project,
vector<vector<size_t>> &topologies,
vector<ParallelRegion*> &parallelRegions,
map<string, vector<LoopGraph*>> &loopGraph,
map<string, vector<SpfInterval*>> &intervals,
map<string, vector<Messages>> &SPF_messages)
{
int maxSizeDist = 0;
for (int z = 0; z < parallelRegions.size(); ++z)
{
const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
auto &tmp = dataDirectives.distrRules;
vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
for (int z1 = 0; z1 < currentVariant.size(); ++z1)
currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
for (auto &elem : currentVar)
{
DIST::Array *array = elem.first;
const DistrVariant *var = elem.second;
int countBlock = 0;
for (int z = 0; z < var->distRule.size(); ++z)
if (var->distRule[z] == dist::BLOCK)
++countBlock;
maxSizeDist = std::max(maxSizeDist, countBlock);
}
}
SpfInterval *mainIterval = getMainInterval(&project, intervals, SPF_messages);
topologies.clear();
if (maxSizeDist)
{
const int procNum = 8;
//TODO:
//topologies = getTopologies(procNum, maxSizeDist);
throw -10;
const int countOfTop = topologies.size();
if (countOfTop < 0)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
for (auto &inter : intervals)
initTimeForIntervalTree(countOfTop, inter.second);
for (int z = 0; z < parallelRegions.size(); ++z)
{
const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
DIST::Arrays<int> &allArrays = parallelRegions[z]->GetAllArraysToModify();
auto &tmp = dataDirectives.distrRules;
vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
for (int z1 = 0; z1 < currentVariant.size(); ++z1)
currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
map<LoopGraph*, ParallelDirective*> parallelDirs;
vector<std::tuple<DIST::Array*, vector<long>, pair<string, int>>> allSingleRemotes;
for (int i = project.numberOfFiles() - 1; i >= 0; --i)
{
SgFile *file = &(project.file(i));
auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId());
parallelDirs.insert(fountInfo.begin(), fountInfo.end());
auto fountRem = findAllSingleRemotes(file, parallelRegions[z]->GetId(), parallelRegions);
allSingleRemotes.insert(allSingleRemotes.end(), fountRem.begin(), fountRem.end());
}
//TODO!
//int err = predictScheme(parallelRegions[z], currentVar, allArrays.GetArrays(), parallelDirs, intervals, SPF_messages, allSingleRemotes, maxSizeDist, procNum);
/*if (err != 0)
internalExit = err;*/
}
vector<SpfInterval*> tmp = { mainIterval };
aggregatePredictedTimes(tmp);
int idx = 0;
int best = -1;
double bestSpeedUp = 0;
for (auto &top : topologies)
{
string outStr = "";
for (auto &elem : top)
outStr += std::to_string(elem) + " ";
double currS = mainIterval->exec_time / mainIterval->predictedTimes[idx];
__spf_print(1, "%d: speed up %f for top. %s\n", idx, currS, outStr.c_str());
if (best == -1 || bestSpeedUp < currS)
{
bestSpeedUp = currS;
best = idx;
}
++idx;
}
__spf_print(1, "best topology %d with speed up %f\n", best, bestSpeedUp);
}
else
for (auto &inter : intervals)
initTimeForIntervalTree(0, inter.second);
}
static void fillParallel(SgExpression *exp, ParallelStats &parStats, int &totalScoreComm)
{
if (exp)
@@ -312,31 +208,27 @@ void calculateStatsForPredictor(const map<string, vector<FuncInfo*>>& allFuncInf
uint64_t paralle_exec = 0;
uint64_t lines_count = 0;
if (st->variant() == DVM_PARALLEL_ON_DIR)
if (st->variant() == DVM_PARALLEL_ON_DIR)
{
auto loop = st->lexNext();
checkNull(loop, convertFileName(__FILE__).c_str(), __LINE__);
if (loop->variant() != FOR_NODE)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
if (__gcov_doesThisLineExecuted(byFile.first, loop->lineNumber()))
{
calculateForParallelLoop(loop, gcov, paralle_exec, lines_count);
st = loop->lastNodeOfStmt();
calculateForParallelLoop(loop, gcov, paralle_exec, lines_count);
st = loop->lastNodeOfStmt();
parallel_exec_count += paralle_exec;
count_of_parallel_lines += lines_count;
parallel_exec_count += paralle_exec;
count_of_parallel_lines += lines_count;
__spf_print(1, " PAR LOOP [%d %s] total exec %llu, total exec lines %llu, avg %.16e\n",
loop->lineNumber(), byFile.first.c_str(), paralle_exec, lines_count, paralle_exec / (double)lines_count);
}
__spf_print(1, " PAR LOOP [%d %s] total exec %llu, total exec lines %llu, avg %.16e\n",
loop->lineNumber(), byFile.first.c_str(), paralle_exec, lines_count, paralle_exec / (double)lines_count);
}
}
for (auto st = stat->lexNext(); st != stat->lastNodeOfStmt(); st = st->lexNext())
{
if (!isSgExecutableStatement(st) || isDVM_stat(st) || isSPF_stat(st) ||
!__gcov_doesThisLineExecuted(byFile.first, st->lineNumber()))
if (!isSgExecutableStatement(st) || isDVM_stat(st) || isSPF_stat(st))
continue;
int line = st->lineNumber();
@@ -536,7 +428,6 @@ static void parallelDir(const map<DIST::Array*, int>& byPos, SgExpression* spec,
parallel["loops_count"] = loopSymbs.size();
SgStatement* loop = isSgForStmt(st->lexNext());
if (loop == NULL)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
SgStatement* lastNode = loop->lastNodeOfStmt();
@@ -553,13 +444,11 @@ static void parallelDir(const map<DIST::Array*, int>& byPos, SgExpression* spec,
loop = loop->lexNext();
}
for (int z = execs.size() - 1; z > 0; --z)
if (execs[z - 1] != 0)
execs[z] /= execs[z - 1];
for (int z = execs.size() - 1; z > 0; --z)
execs[z] /= execs[z - 1];
auto& info = getInfo(before, gcov);
if (info.getExecutedCount() && loopSymbs.size() > 1)
execs[0] /= info.getExecutedCount();
execs[0] /= info.getExecutedCount();
parallel["iterations_count"] = execs;
@@ -698,9 +587,6 @@ void parseDvmDirForPredictor(const map<tuple<int, string, string>, pair<DIST::Ar
for (auto st = stat->lexNext(); st != stat->lastNodeOfStmt(); st = st->lexNext())
{
if (!__gcov_doesThisLineExecuted(byFile.first, st->lineNumber()))
continue;
SgExpression* list;
SgExpression* dup;
auto line = 0;
@@ -708,10 +594,7 @@ void parseDvmDirForPredictor(const map<tuple<int, string, string>, pair<DIST::Ar
switch (st->variant())
{
case DVM_PARALLEL_ON_DIR:
parallelDir(byPos, st->expr(2),
st->expr(0) ? st->expr(0)->symbol() : NULL,
st->expr(0) ? st->expr(0)->lhs() : NULL,
st, st->expr(1), gcov, directives, commonBlocks, allFuncInfo);
parallelDir(byPos, st->expr(2), st->expr(0)->symbol(), st->expr(0)->lhs(), st, st->expr(1), gcov, directives, commonBlocks, allFuncInfo);
break;
case DVM_VAR_DECL: // TODO
{
@@ -730,8 +613,7 @@ void parseDvmDirForPredictor(const map<tuple<int, string, string>, pair<DIST::Ar
list = st->expr(0);
while (list)
{
if (type->lhs()) // if ALIGN A(...) with B(...)
directives["align"].push_back(parseAlign(byPos, list->lhs()->symbol(), type->rhs()->symbol(), type->lhs(), type->rhs()->lhs(), st->lineNumber()));
directives["align"].push_back(parseAlign(byPos, list->lhs()->symbol(), type->rhs()->symbol(), type->lhs(), type->rhs()->lhs(), st->lineNumber()));
list = list->rhs();
}
}
@@ -743,9 +625,6 @@ void parseDvmDirForPredictor(const map<tuple<int, string, string>, pair<DIST::Ar
case DVM_ALIGN_DIR:
directives["align"].push_back(parseAlign(byPos, st->expr(0)->lhs()->symbol(), st->expr(2)->symbol(), st->expr(1), st->expr(2)->lhs(), st->lineNumber()));
break;
case DVM_REALIGN_DIR:
directives["realign"].push_back(parseAlign(byPos, st->expr(0)->lhs()->symbol(), st->expr(2)->symbol(), st->expr(1), st->expr(2)->lhs(), st->lineNumber()));
break;
case DVM_SHADOW_DIR:
//dirs << "1;" << "SHADOW;" << st->expr(0)->unparse() << "(" << st->expr(1)->unparse() << ");\n";
break;

55
src/Predictor/PredictScheme.h
View File

@@ -1,8 +1,7 @@
#pragma once
#include <vector>
#include "dvm.h"
#include "graph_calls.h"
#include "json.hpp"
#include "../GraphCall/graph_calls.h"
class ParallelStats
{
@@ -12,10 +11,10 @@ public:
RemoteCount = ShadowCount = ReductionCount = AcrossCount = 0;
}
int RemoteCount = 0;
int ShadowCount = 0;
int ReductionCount = 0;
int AcrossCount = 0;
int RemoteCount;
int ShadowCount;
int ReductionCount;
int AcrossCount;
};
class PredictorStats
@@ -28,38 +27,32 @@ public:
}
ParallelStats ParallelStat;
int ParallelCount = 0;
int RemoteCount = 0;
int RedistributeCount = 0;
int IntervalCount = 0;
int TotalScoreComm = 0;
int TotalScorePar = 0;
int TotalScoreDist = 0;
int ParallelCount;
int RemoteCount;
int RedistributeCount;
int IntervalCount;
int TotalScoreComm;
int TotalScorePar;
int TotalScoreDist;
nlohmann::json toJson()
std::string to_string()
{
nlohmann::json stat;
std::string res = "";
res += std::to_string(ParallelCount) + "|";
res += std::to_string(RemoteCount) + "|";
res += std::to_string(RedistributeCount) + "|";
res += std::to_string(IntervalCount) + "|";
stat["ParallelCount"] = ParallelCount;
stat["RemoteCount"] = RemoteCount;
stat["RedistributeCount"] = RedistributeCount;
stat["IntervalCount"] = IntervalCount;
res += std::to_string(ParallelStat.RemoteCount) + "|";
res += std::to_string(ParallelStat.ShadowCount) + "|";
res += std::to_string(ParallelStat.ReductionCount) + "|";
res += std::to_string(ParallelStat.AcrossCount);
stat["PS_RemoteCount"] = ParallelStat.RemoteCount;
stat["PS_ShadowCount"] = ParallelStat.ShadowCount;
stat["PS_ReductionCount"] = ParallelStat.ReductionCount;
stat["PS_AcrossCount"] = ParallelStat.AcrossCount;
//TODO: need to improve
// (summed.TotalScoreComm != 0 ? 1.0 / summed.TotalScoreComm : 0.0) + (double)summed.TotalScorePar * 1000 + (countOfDist == 0 ? -5000 : countOfDist);
stat["TotalScore"] = -1 * (ParallelStat.RemoteCount + ParallelStat.ShadowCount + ParallelStat.ReductionCount + ParallelStat.AcrossCount);
return stat;
return res;
}
};
void processFileToPredict(SgFile *file, PredictorStats &predictorCounts);
void calculateStatsForPredictor(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);
void parseDvmDirForPredictor(const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays, const std::map<std::string, CommonBlock*>& commonBlocks, const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);
void runPredictSchemeOld(SgProject &project, std::vector<std::vector<size_t>> &topologies, std::vector<ParallelRegion*> &parallelRegions, std::map<std::string, std::vector<LoopGraph*>> &loopGraph, std::map<std::string, std::vector<SpfInterval*>> &intervals, std::map<std::string, std::vector<Messages>> &SPF_messages);
void parseDvmDirForPredictor(const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays, const std::map<std::string, CommonBlock*>& commonBlocks, const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, std::map<int, Gcov_info>>& gCovInfo);

439
src/Predictor/PredictSchemeWithLibrary.cpp
View File

@@ -1,439 +0,0 @@
#include "leak_detector.h"
#include <limits>
#include <map>
#include <vector>
#include <string>
#include <tuple>
#include "dvm.h"
#include "PredictSchemeWithLibrary.h"
#include "../../projects/libpredictor/include/libpredict/predictor.h"
#include "../DirectiveProcessing/directive_parser.h"
#include "../Distribution/DvmhDirective.h"
#include "../ParallelizationRegions/ParRegions.h"
#include "../GraphLoop/graph_loops_func.h"
#include "../Utils/errors.h"
#include "../Utils/utils.h"
using std::map;
using std::pair;
using std::string;
using std::tuple;
using std::vector;
map<size_t, size_t> createTemplateIdMapping(const vector<ParallelRegion*>& parallelRegions)
{
size_t maxArrayId = 0;
for (int z = 0; z < parallelRegions.size(); ++z) {
const DataDirective& dataDirectives = parallelRegions[z]->GetDataDir();
for (const auto& distrRule : dataDirectives.distrRules) {
if (distrRule.first && !distrRule.first->IsTemplate()) {
maxArrayId = std::max(maxArrayId, (size_t)distrRule.first->GetId());
}
}
for (const auto& alignRule : dataDirectives.alignRules) {
if (alignRule.alignArray && !alignRule.alignArray->IsTemplate()) {
maxArrayId = std::max(maxArrayId, (size_t)alignRule.alignArray->GetId());
}
}
}
map<size_t, size_t> templateIdMapping;
size_t nextTemplateId = maxArrayId + 1;
for (int z = 0; z < parallelRegions.size(); ++z) {
const DataDirective& dataDirectives = parallelRegions[z]->GetDataDir();
for (const auto& distrRule : dataDirectives.distrRules) {
if (distrRule.first && distrRule.first->IsTemplate()) {
size_t originalId = distrRule.first->GetId();
if (templateIdMapping.find(originalId) == templateIdMapping.end()) {
templateIdMapping[originalId] = nextTemplateId++;
}
}
}
for (const auto& alignRule : dataDirectives.alignRules) {
if (alignRule.alignWith && alignRule.alignWith->IsTemplate()) {
size_t originalId = alignRule.alignWith->GetId();
if (templateIdMapping.find(originalId) == templateIdMapping.end()) {
templateIdMapping[originalId] = nextTemplateId++;
}
}
}
}
return templateIdMapping;
}
PrecomputedLibpredictParams precomputeLibpredictParams(
SgProject& project,
const vector<ParallelRegion*>& parallelRegions,
const map<string, vector<LoopGraph*>>& loopGraph,
const map<size_t, size_t>& templateIdMapping)
{
PrecomputedLibpredictParams result;
// distribute and align from parallelRegions
for (int z = 0; z < parallelRegions.size(); ++z) {
const DataDirective& dataDirectives = parallelRegions[z]->GetDataDir();
const vector<int>& currentVariant = parallelRegions[z]->GetCurrentVariant();
const DIST::Arrays<int>& allArrays = parallelRegions[z]->GetAllArrays();
auto& tmp = dataDirectives.distrRules;
vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
for (int z1 = 0; z1 < currentVariant.size(); ++z1) {
currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
}
// distribute
for (const auto& distrRule : currentVar) {
DIST::Array* array = distrRule.first;
const DistrVariant* variant = distrRule.second;
if (array && variant && !array->IsNotDistribute()) {
PrecomputedDistributeParams params;
size_t originalId = array->GetId();
params.arrayId = originalId;
if (array->IsTemplate()) {
auto it = templateIdMapping.find(originalId);
if (it != templateIdMapping.end()) {
params.arrayId = it->second;
}
}
params.elemSize = array->GetTypeSize();
params.array = array;
const auto& arraySizes = array->GetSizes();
for (int dim = 0; dim < array->GetDimSize(); ++dim) {
size_t dimSize = arraySizes[dim].second - arraySizes[dim].first + 1;
if (dim < variant->distRule.size() && variant->distRule[dim] == dist::BLOCK) {
params.axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::BLOCK);
} else {
params.axisDistributions.emplace_back(dimSize, libpredict::TypeDistribute::NONE);
}
}
const auto& shadowSpec = array->GetShadowSpec();
for (int dim = 0; dim < shadowSpec.size() && dim < array->GetDimSize(); ++dim) {
if (dim < variant->distRule.size() && variant->distRule[dim] == dist::BLOCK) {
params.shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second);
}
}
result.distributeParams.push_back(params);
}
}
// align
for (const auto& alignRule : dataDirectives.alignRules) {
DIST::Array* alignArray = alignRule.alignArray;
DIST::Array* alignWithArray = alignRule.alignWith;
if (alignArray && alignWithArray && !alignArray->IsNotDistribute()) {
PrecomputedAlignParams params;
params.arrayId = alignArray->GetId();
size_t originalDistributedArrayId = alignWithArray->GetId();
params.distributedArrayId = originalDistributedArrayId;
if (alignWithArray->IsTemplate()) {
auto it = templateIdMapping.find(originalDistributedArrayId);
if (it != templateIdMapping.end()) {
params.distributedArrayId = it->second;
}
}
params.elemSize = alignArray->GetTypeSize();
params.alignArray = alignArray;
params.alignWithArray = alignWithArray;
const auto& arraySizes = alignArray->GetSizes();
for (int dim = 0; dim < alignArray->GetDimSize(); ++dim) {
size_t dimSize = arraySizes[dim].second - arraySizes[dim].first + 1;
params.dimensions.push_back(dimSize);
}
for (int dim = 0; dim < alignWithArray->GetDimSize(); ++dim) {
bool found = false;
for (int i = 0; i < alignRule.alignRuleWith.size(); ++i) {
const auto& ruleWith = alignRule.alignRuleWith[i];
if (ruleWith.first == dim) {
const auto& rule = ruleWith.second;
if (rule.first == 0) {
// constant
params.distributionExpressions.emplace_back(rule.second);
} else {
// linear expression a * I + b
params.distributionExpressions.emplace_back(i, rule.first, rule.second);
}
found = true;
break;
}
}
if (!found) {
// There is no rule for this measurement
params.distributionExpressions.emplace_back();
}
}
const auto& shadowSpec = alignArray->GetShadowSpec();
for (int dim = 0; dim < shadowSpec.size() && dim < alignArray->GetDimSize(); ++dim) {
params.shadowEdges.emplace_back(shadowSpec[dim].first, shadowSpec[dim].second);
}
result.alignParams.push_back(params);
}
}
// shadow_renew
map<LoopGraph*, ParallelDirective*> parallelDirs;
for (int i = project.numberOfFiles() - 1; i >= 0; --i) {
SgFile* file = &(project.file(i));
auto fountInfo = findAllDirectives(
file,
getObjectForFileFromMap(file->filename(), const_cast<map<string, vector<LoopGraph*>>&>(loopGraph)),
parallelRegions[z]->GetId());
parallelDirs.insert(fountInfo.begin(), fountInfo.end());
}
for (auto& dirPair : parallelDirs) {
LoopGraph* loopPtr = dirPair.first;
ParallelDirective* directive = dirPair.second;
if (directive && !directive->shadowRenew.empty()) {
for (size_t shadowIdx = 0; shadowIdx < directive->shadowRenew.size(); ++shadowIdx) {
const auto& shadowRenewItem = directive->shadowRenew[shadowIdx];
const string& arrayName = shadowRenewItem.first.second; // uniqName
const vector<pair<int, int>>& bounds = shadowRenewItem.second;
DIST::Array* shadowArray = allArrays.GetArrayByName(arrayName);
if (shadowArray == NULL) {
continue;
}
if (shadowArray && !shadowArray->IsNotDistribute()) {
PrecomputedShadowRenewParams params;
params.arrayId = shadowArray->GetId();
params.shadowArray = shadowArray;
for (const auto& bound : bounds) {
params.shadow_renew.emplace_back(static_cast<size_t>(bound.first),
static_cast<size_t>(bound.second));
}
params.corner = directive->shadowRenewCorner[shadowIdx];
params.number_loop_iterations = loopPtr ? static_cast<size_t>(loopPtr->countOfIters) : 1;
result.shadowRenewParams.push_back(params);
}
}
}
}
}
return result;
}
double runLibpredictCalc(const vector<size_t>& topology,
const string& clusterConfStr,
const PrecomputedLibpredictParams& precomputedParams,
map<string, vector<Messages>>& SPF_messages)
{
libpredict::RetInitGrid retInitGrid = libpredict::InitGrid(topology[0], topology[1], topology[2], topology[3]);
if (retInitGrid != libpredict::INIT_GRID_SUCCESS) {
__spf_print(1, "ERROR: Failed to initialize libpredict grid with topology: %zu %zu %zu %zu, return code: %d\n",
topology[0], topology[1], topology[2], topology[3], (int)retInitGrid);
std::wstring messageR, messageE;
__spf_printToLongBuf(messageE, L"Failed to initialize libpredict grid with topology: %zu %zu %zu %zu, return code: %d",
topology[0], topology[1], topology[2], topology[3], (int)retInitGrid);
__spf_printToLongBuf(messageR, R207);
getObjectForFileFromMap(clusterConfStr.c_str(), SPF_messages).push_back(Messages(ERROR, 1, messageR, messageE, 1064));
return -1;
}
// distribute
for (const auto& params : precomputedParams.distributeParams) {
libpredict::RetDistribute retDistribute = libpredict::Distribute(
params.arrayId, params.elemSize, params.axisDistributions, params.shadowEdges);
if (retDistribute != libpredict::DISTRIBUTE_SUCCESS) {
__spf_print(1, "ERROR: Failed to distribute array '%s' (id=%zu) with libpredict, return code: %d\n",
params.array->GetShortName().c_str(), params.arrayId, (int)retDistribute);
std::wstring messageR, messageE;
__spf_printToLongBuf(messageE, L"Failed to distribute array '%s' with libpredict, return code: %d",
to_wstring(params.array->GetShortName()).c_str(), (int)retDistribute);
__spf_printToLongBuf(messageR, R208);
getObjectForFileFromMap(params.array->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(Messages(ERROR, params.array->GetDeclInfo().begin()->second, messageR, messageE, 1065));
}
}
// align
for (const auto& params : precomputedParams.alignParams) {
libpredict::RetAlign retAlign = libpredict::Align(
params.arrayId, params.distributedArrayId, params.elemSize,
params.dimensions, params.distributionExpressions, params.shadowEdges);
if (retAlign != libpredict::ALIGN_SUCCESS) {
__spf_print(1, "ERROR: Failed to align array '%s' (id=%zu) with array '%s' (id=%zu), return code: %d\n",
params.alignArray->GetShortName().c_str(), params.arrayId,
params.alignWithArray->GetShortName().c_str(), params.distributedArrayId, (int)retAlign);
std::wstring messageR, messageE;
__spf_printToLongBuf(messageE, L"Failed to align array '%s' with array '%s' using libpredict, return code: %d",
to_wstring(params.alignArray->GetShortName()).c_str(),
to_wstring(params.alignWithArray->GetShortName()).c_str(), (int)retAlign);
__spf_printToLongBuf(messageR, R209);
getObjectForFileFromMap(params.alignArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(Messages(ERROR, params.alignArray->GetDeclInfo().begin()->second, messageR, messageE, 1066));
}
}
// shadow_renew
for (const auto& params : precomputedParams.shadowRenewParams) {
libpredict::RetShadowRenew retShadowRenew = libpredict::ShadowRenew(
params.arrayId, params.shadow_renew, params.corner, params.number_loop_iterations);
if (retShadowRenew != libpredict::SHADOW_RENEW_SUCCESS) {
__spf_print(1, "ERROR: Failed to process shadow_renew for array '%s' (id=%zu), return code: %d\n",
params.shadowArray->GetShortName().c_str(), params.arrayId, (int)retShadowRenew);
std::wstring messageR, messageE;
__spf_printToLongBuf(messageE, L"Failed to process shadow_renew for array '%s' with libpredict, return code: %d",
to_wstring(params.shadowArray->GetShortName()).c_str(), (int)retShadowRenew);
__spf_printToLongBuf(messageR, R210);
getObjectForFileFromMap(params.shadowArray->GetDeclInfo().begin()->first.c_str(), SPF_messages).push_back(Messages(ERROR, params.shadowArray->GetDeclInfo().begin()->second, messageR, messageE, 1067));
}
}
return libpredict::GetTime();
}
void runPredictScheme(SgProject& project,
vector<vector<size_t>>& topologies,
const vector<ParallelRegion*>& parallelRegions,
map<string, vector<LoopGraph*>>& loopGraph,
map<string, vector<Messages>>& SPF_messages)
{
// calculating maximum dimension of distribution
int maxSizeDist = 0;
for (int z = 0; z < parallelRegions.size(); ++z) {
const DataDirective& dataDirectives = parallelRegions[z]->GetDataDir();
const vector<int>& currentVariant = parallelRegions[z]->GetCurrentVariant();
auto& tmp = dataDirectives.distrRules;
vector<const DistrVariant*> currentVar;
for (int z1 = 0; z1 < currentVariant.size(); ++z1) {
currentVar.push_back(&tmp[z1].second[currentVariant[z1]]);
}
for (auto var : currentVar) {
int countBlock = 0;
for (int z = 0; z < var->distRule.size(); ++z) {
if (var->distRule[z] == dist::BLOCK) {
++countBlock;
}
}
maxSizeDist = std::max(maxSizeDist, countBlock);
}
}
// calculating name of a cluster configuration file
string clusterConfStr;
if (project.numberOfFiles() > 0) {
string firstFilePath = project.fileName(0);
size_t lastSlash = firstFilePath.find_last_of("/\\");
clusterConfStr = firstFilePath.substr(0, lastSlash + 1) + "cluster.conf";
}
// creating template ID display to avoid conflicts
map<size_t, size_t> templateIdMapping = createTemplateIdMapping(parallelRegions);
// Precomputing parameters of directive functions from libpredict
PrecomputedLibpredictParams precomputedParams = precomputeLibpredictParams(
project, parallelRegions, loopGraph, templateIdMapping);
// iterating through topologies to find most optimal one
topologies = vector<vector<size_t>>();
if (maxSizeDist) {
if (maxSizeDist > 4) {
maxSizeDist = 4;
}
// Initialize cluster
int procCount = 0;
libpredict::RetInitCluster retInitCluster = libpredict::InitCluster(clusterConfStr, procCount);
if (retInitCluster != libpredict::INIT_CLUSTER_SUCCESS) {
__spf_print(1, "ERROR: Failed to initialize libpredict cluster with config: %s, return code: %d\n", clusterConfStr.c_str(), (int)retInitCluster);
std::wstring messageR, messageE;
__spf_printToLongBuf(messageE, L"Failed to initialize libpredict cluster with config: %s, return code: %d",
to_wstring(clusterConfStr).c_str(), (int)retInitCluster);
__spf_printToLongBuf(messageR, R206);
getObjectForFileFromMap(clusterConfStr.c_str(), SPF_messages).push_back(Messages(ERROR, 1, messageR, messageE, 1063));
return;
}
for (size_t n1 = 2; n1 <= procCount; ++n1) {
for (size_t n2 = 1; n2 <= n1 && n1 * n2 <= procCount; ++n2) {
if (n2 != 1 && maxSizeDist < 2 || n2 == 1 && maxSizeDist == 2) {
continue;
}
for (size_t n3 = 1; n3 <= n2 && n1 * n2 * n3 <= procCount; ++n3) {
if (n3 != 1 && maxSizeDist < 3 || n3 == 1 && maxSizeDist == 3) {
continue;
}
for (size_t n4 = 1; n4 <= n3 && n1 * n2 * n3 * n4 <= procCount; ++n4) {
if (n4 != 1 && maxSizeDist < 4 || n4 == 1 && maxSizeDist == 4) {
continue;
}
topologies.push_back(vector<size_t>{n1, n2, n3, n4});
}
}
}
}
vector<size_t> best;
double bestTime = std::numeric_limits<double>::max();
for (auto& topology : topologies) {
double currTime = runLibpredictCalc(topology, clusterConfStr, precomputedParams, SPF_messages);
string outStr = "";
for (const auto& elem : topology) {
outStr += std::to_string(elem) + " ";
}
__spf_print(1, "topology %s has time %f\n", outStr.c_str(), currTime);
if (currTime == -1) {
return;
}
if (currTime < bestTime) {
bestTime = currTime;
best = topology;
}
}
string outStr;
for (const auto& elem : best) {
outStr += std::to_string(elem) + " ";
}
__spf_print(1, "best topology %s with time %f\n", outStr.c_str(), bestTime);
} else {
__spf_print(1, "impossible to calculate best topology: project does not contain distribution directives\n");
}
}

57
src/Predictor/PredictSchemeWithLibrary.h
View File

@@ -1,57 +0,0 @@
#pragma once
#include <vector>
#include <map>
#include <string>
#include "dvm.h"
#include "graph_calls.h"
#include "../../projects/libpredictor/include/libpredict/predictor.h"
struct PrecomputedDistributeParams {
size_t arrayId;
size_t elemSize;
std::vector<libpredict::DistributeAxisRule> axisDistributions;
std::vector<std::pair<size_t, size_t>> shadowEdges;
DIST::Array* array;
};
struct PrecomputedAlignParams {
size_t arrayId;
size_t distributedArrayId;
size_t elemSize;
std::vector<size_t> dimensions;
std::vector<libpredict::AlignDisplay> distributionExpressions;
std::vector<std::pair<size_t, size_t>> shadowEdges;
DIST::Array* alignArray;
DIST::Array* alignWithArray;
};
struct PrecomputedShadowRenewParams {
size_t arrayId;
std::vector<std::pair<size_t, size_t>> shadow_renew;
bool corner;
size_t number_loop_iterations;
DIST::Array* shadowArray;
};
struct PrecomputedLibpredictParams {
std::vector<PrecomputedDistributeParams> distributeParams;
std::vector<PrecomputedAlignParams> alignParams;
std::vector<PrecomputedShadowRenewParams> shadowRenewParams;
};
PrecomputedLibpredictParams precomputeLibpredictParams(
SgProject& project,
const std::vector<ParallelRegion*>& parallelRegions,
const std::map<std::string, std::vector<LoopGraph*>>& loopGraph,
const std::map<size_t, size_t>& templateIdMapping);
void runPredictScheme(SgProject& project,
std::vector<std::vector<size_t>>& topologies,
const std::vector<ParallelRegion*>& parallelRegions,
std::map<std::string, std::vector<LoopGraph*>>& loopGraph,
std::map<std::string, std::vector<Messages>>& SPF_messages);
double runLibpredictCalc(const std::vector<size_t>& topology,
const std::string& clusterConfStr,
const PrecomputedLibpredictParams& precomputedParams,
std::map<std::string, std::vector<Messages>>& SPF_messages);

6
src/PrivateAnalyzer/private_analyzer.cpp
View File

@@ -1,5 +1,5 @@
#define _LEAK_
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstring>
@@ -9,10 +9,10 @@
#include <vector>
#include <fstream>
#include "graph_calls.h"
#include "../GraphCall/graph_calls.h"
#include "private_analyzer.h"
#include "dvm.h"
#include "CFGraph/CFGraph.h"
#include "../CFGraph/CFGraph.h"
using std::vector;

2
src/PrivateAnalyzer/private_analyzer.h
View File

@@ -3,7 +3,7 @@
#include <vector>
#include "dvm.h"
#include "graph_calls.h"
#include "../GraphCall/graph_calls.h"
extern void Private_Vars_Analyzer(SgStatement* start);
void PrivateAnalyzer(SgFile *file, std::vector<FuncInfo*> &funcs);

141
src/PrivateAnalyzer/private_arrays_search.cpp
View File

@@ -1,141 +0,0 @@
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <vector>
#include <queue>
#include <numeric>
#include <iostream>
#include "private_arrays_search.h"
#include "range_structures.h"
#include "region.h"
#include "SgUtils.h"
#include "graph_loops.h"
#include "CFGraph/CFGraph.h"
using namespace std;
static void Collapse(Region* region)
{
if (region->getBasickBlocks().empty())
return;
for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out)
{
for (Region* byBlock : region->getBasickBlocks())
{
AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges);
region->array_def[arrayName] = region->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]);
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())
prevBlock->replaceInNextRegions(region, region->getHeader());
for (Region* nextBlock : region->getHeader()->getNextRegions())
nextBlock->replaceInPrevRegions(region, region->getHeader());
}
static void SolveDataFlowIteratively(Region* DFG)
{
unordered_set<Region*> worklist(DFG->getBasickBlocks());
do
{
Region* b = *worklist.begin();
ArrayAccessingIndexes newIn;
bool flagFirst = true;
for (Region* prevBlock : b->getPrevRegions())
{
if (flagFirst)
{
newIn = prevBlock->array_out;
flagFirst = false;
}
else
{
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 */
if (newOut != b->array_out)
b->array_out = newOut;
else
worklist.erase(b);
}
while (!worklist.empty());
}
static void SolveDataFlow(Region* DFG)
{
if (!DFG)
return;
SolveDataFlowIteratively(DFG);
for (Region* subRegion : DFG->getSubRegions())
SolveDataFlow(subRegion);
Collapse(DFG);
}
map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
{
map<LoopGraph*, ArrayAccessingIndexes> result;
for (const auto& [loopName, loops] : loopGraph)
{
for (const auto& loop : loops)
{
for (const auto& [funcInfo, blocks]: FullIR)
{
Region* loopRegion = new Region(loop, blocks);
SolveDataFlow(loopRegion);
result[loop] = loopRegion->array_priv;
delete(loopRegion);
}
}
}
return result;
}

12
src/PrivateAnalyzer/private_arrays_search.h
View File

@@ -1,12 +0,0 @@
#pragma once
#include <vector>
#include <map>
#include <unordered_set>
#include "range_structures.h"
#include "graph_loops.h"
#include "CFGraph/CFGraph.h"
std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);

293
src/PrivateAnalyzer/range_structures.cpp
View File

@@ -1,293 +0,0 @@
#include <vector>
#include <map>
#include <unordered_set>
#include <string>
#include "utils.h"
#include "range_structures.h"
using namespace std;
static vector<uint64_t> FindParticularSolution(const ArrayDimension& dim1, const ArrayDimension& dim2)
{
for (uint64_t i = 0; i < dim1.tripCount; i++)
{
uint64_t leftPart = dim1.start + i * dim1.step;
for (uint64_t j = 0; j < dim2.tripCount; j++)
{
uint64_t rightPart = dim2.start + j * dim2.step;
if (leftPart == rightPart)
return { i, j };
}
}
return {};
}
/* dim1 /\ dim2 */
static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const ArrayDimension& dim2)
{
vector<uint64_t> partSolution = FindParticularSolution(dim1, dim2);
if (partSolution.empty())
return NULL;
int64_t x0 = partSolution[0], y0 = partSolution[1];
/* x = x_0 + c * t */
/* y = y_0 + d * t */
int64_t c = dim2.step / gcd(dim1.step, dim2.step);
int64_t d = dim1.step / gcd(dim1.step, dim2.step);
int64_t tXMin, tXMax, tYMin, tYMax;
tXMin = -x0 / c;
tXMax = (dim1.tripCount - 1 - x0) / c;
tYMin = -y0 / d;
tYMax = (dim2.tripCount - 1 - y0) / d;
int64_t tMin = max(tXMin, tYMin);
uint64_t tMax = min(tXMax, tYMax);
if (tMin > tMax)
return NULL;
uint64_t start3 = dim1.start + x0 * dim1.step;
uint64_t step3 = c * dim1.step;
ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 };
return result;
}
/* dim1 / dim2 */
static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, const ArrayDimension& dim2)
{
ArrayDimension* intersection = DimensionIntersection(dim1, dim2);
if (!intersection)
return { dim1 };
vector<ArrayDimension> result;
/* add the part before intersection */
if (dim1.start < intersection->start)
result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step });
/* add the parts between intersection steps */
uint64_t start = (intersection->start - dim1.start) / dim1.step;
uint64_t interValue = intersection->start;
for (int64_t i = start; dim1.start + i * dim1.step <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
{
uint64_t centerValue = dim1.start + i * dim1.step;
if (centerValue == interValue)
{
if (i - start > 1)
{
result.push_back({ dim1.start + (start + 1) * dim1.step, dim1.step, i - start - 1 });
start = i;
}
interValue += intersection->step;
}
}
/* add the part after intersection */
if (intersection->start + intersection->step * (intersection->tripCount - 1) < dim1.start + dim1.step * (dim1.tripCount - 1))
{
/* first value after intersection */
uint64_t right_start = intersection->start + intersection->step * (intersection->tripCount - 1) + dim1.step;
uint64_t tripCount = (dim1.start + dim1.step * dim1.tripCount - right_start) / dim1.step;
result.push_back({ right_start, dim1.step, tripCount });
}
delete(intersection);
return result;
}
static vector<ArrayDimension> DimensionUnion(const ArrayDimension& dim1, const ArrayDimension& dim2)
{
vector<ArrayDimension> res;
ArrayDimension* inter = DimensionIntersection(dim1, dim2);
if (!inter)
return { dim1, dim2 };
res.push_back(*inter);
delete(inter);
vector<ArrayDimension> diff1, diff2;
diff1 = DimensionDifference(dim1, dim2);
diff2 = DimensionDifference(dim2, dim1);
res.insert(res.end(), diff1.begin(), diff1.end());
res.insert(res.end(), diff2.begin(), diff2.end());
return res;
}
static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>& firstElement, const vector<ArrayDimension>& secondElement)
{
if (firstElement.empty() || secondElement.empty())
return {};
size_t dimAmount = firstElement.size();
/* check if there is no intersecction */
for (size_t i = 0; i < dimAmount; i++)
if (FindParticularSolution(firstElement[i], secondElement[i]).empty())
return {};
vector<ArrayDimension> result(dimAmount);
for (size_t i = 0; i < dimAmount; i++)
{
ArrayDimension* resPtr = DimensionIntersection(firstElement[i], secondElement[i]);
if (resPtr)
result[i] = *resPtr;
else
return {};
}
return result;
}
static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimension>& firstElement,
const vector<ArrayDimension>& secondElement)
{
if (firstElement.empty() || secondElement.empty())
return {};
vector<ArrayDimension> intersection = ElementsIntersection(firstElement, secondElement);
vector<vector<ArrayDimension>> result;
if (intersection.empty())
return { firstElement };
for (int i = 0; i < firstElement.size(); i++)
{
auto dimDiff = DimensionDifference(firstElement[i], secondElement[i]);
if (!dimDiff.empty())
{
vector<ArrayDimension> firstCopy = firstElement;
for (const auto& range : dimDiff)
{
firstCopy[i] = range;
result.push_back(firstCopy);
}
}
}
return result;
}
static void ElementsUnion(const vector<ArrayDimension>& firstElement, const vector<ArrayDimension>& secondElement,
vector<vector<ArrayDimension>>& lc, vector<vector<ArrayDimension>>& rc,
vector<ArrayDimension>& intersection)
{
/* lc(rc) is a set of ranges, which only exist in first(second) element*/
intersection = ElementsIntersection(firstElement, secondElement);
lc = ElementsDifference(firstElement, intersection);
rc = ElementsDifference(secondElement, intersection);
}
void AccessingSet::FindUncovered(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const {
vector<vector<ArrayDimension>> newTails;
result.push_back(element);
for (const auto& currentElement : allElements)
{
for (const auto& tailLoc : result)
{
auto intersection = ElementsIntersection(tailLoc, currentElement);
auto diff = ElementsDifference(tailLoc, intersection);
if (!diff.empty()) {
newTails.insert(newTails.end(), diff.begin(), diff.end());
}
}
result = newTails;
newTails.clear();
}
}
bool AccessingSet::ContainsElement(const vector<ArrayDimension>& element) const
{
vector<vector<ArrayDimension>> tails;
FindUncovered(element, tails);
return !tails.empty();
}
void AccessingSet::FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const
{
for (const auto& currentElement : allElements)
{
auto intersection = ElementsIntersection(element, currentElement);
if (!intersection.empty())
result.push_back(intersection);
}
}
vector<vector<ArrayDimension>> AccessingSet::GetElements() const { return allElements; }
void AccessingSet::Insert(const vector<ArrayDimension>& element)
{
vector<vector<ArrayDimension>> tails;
FindUncovered(element, tails);
allElements.insert(allElements.end(), tails.begin(), tails.end());
}
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<vector<ArrayDimension>> 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<vector<ArrayDimension>> coveredBy;
secondSet.FindCoveredBy(element, coveredBy);
if (!coveredBy.empty())
result.insert(result.end(), coveredBy.begin(), coveredBy.end());
}
}
return AccessingSet(result);
}
AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const
{
if (secondSet.GetElements().empty() || allElements.empty())
return *this;
AccessingSet intersection = this->Intersect(secondSet);
AccessingSet uncovered = *this;
vector<vector<ArrayDimension>> result;
for (const auto& element : intersection.GetElements())
{
vector<vector<ArrayDimension>> current_uncovered;
uncovered.FindUncovered(element, current_uncovered);
uncovered = AccessingSet(current_uncovered);
}
return uncovered;
}
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;
}

37
src/PrivateAnalyzer/range_structures.h
View File

@@ -1,37 +0,0 @@
#pragma once
#include <vector>
#include <map>
#include <unordered_set>
#include <string>
#include <cstdint>
struct ArrayDimension
{
uint64_t start, step, tripCount;
};
class AccessingSet {
private:
std::vector<std::vector<ArrayDimension>> allElements;
public:
AccessingSet(std::vector<std::vector<ArrayDimension>> input) : allElements(input) {};
AccessingSet() {};
AccessingSet(const AccessingSet& a) { allElements = a.GetElements(); };
std::vector<std::vector<ArrayDimension>> GetElements() const;
void Insert(const std::vector<ArrayDimension>& element);
AccessingSet Union(const AccessingSet& source);
AccessingSet Intersect(const AccessingSet& secondSet) const;
AccessingSet Diff(const AccessingSet& secondSet) const;
bool ContainsElement(const std::vector<ArrayDimension>& element) const;
void FindCoveredBy(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
void FindUncovered(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs);
};
using ArrayAccessingIndexes = std::map<std::string, AccessingSet>;
bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs);
bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs);
bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs);

251
src/PrivateAnalyzer/region.cpp
View File

@@ -1,251 +0,0 @@
#include<vector>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<string>
#include <numeric>
#include "range_structures.h"
#include "region.h"
#include "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<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const vector<SAPFOR::BasicBlock*> blocks)
{
unordered_set<SAPFOR::BasicBlock*> block_loop;
SAPFOR::BasicBlock* head_block = nullptr;
auto loop_operator = loop->loop->GetOriginal();
for (const auto& block : blocks)
{
if (!block || (block->getInstructions().size() == 0))
continue;
SgStatement* first = block->getInstructions().front()->getInstruction()->getOperator();
SgStatement* last = block->getInstructions().back()->getInstruction()->getOperator();
if (isParentStmt(first, loop_operator) && isParentStmt(last, loop_operator))
{
block_loop.insert(block);
if ((!head_block) && (first == loop_operator) && (last == loop_operator) &&
(block->getInstructions().size() == 2) &&
(block->getInstructions().back()->getInstruction()->getOperation() == SAPFOR::CFG_OP::JUMP_IF))
{
head_block = block;
}
}
}
return { head_block, block_loop };
}
static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
string index = loop->loopSymbol();
loopForIndex[index] = loop;
for (const auto& childLoop : loop->children)
BuildLoopIndex(loopForIndex, childLoop);
}
static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, LoopGraph*>& loopForIndex) {
unordered_set<SAPFOR::Argument*> args = { block->getInstructions()[pos]->getInstruction()->getArg1() };
for (int i = pos - 1; i >= 0; i--)
{
SAPFOR::Argument* res = block->getInstructions()[i]->getInstruction()->getResult();
if (res && args.find(res) != args.end())
{
SAPFOR::Argument* arg1 = block->getInstructions()[i]->getInstruction()->getArg1();
SAPFOR::Argument* arg2 = block->getInstructions()[i]->getInstruction()->getArg2();
if (arg1)
{
string name = arg1->getValue();
int idx = name.find('%');
if (idx != -1 && loopForIndex.find(name.substr(idx + 1)) != loopForIndex.end())
return name.substr(idx + 1);
else
args.insert(arg1);
}
if (arg2)
{
string name = arg2->getValue();
int idx = name.find('%');
if (idx != -1 && loopForIndex.find(name.substr(idx + 1)) != loopForIndex.end())
return name.substr(idx + 1);
else
args.insert(arg2);
}
}
}
return "";
}
static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use) {
auto instructions = block->getInstructions();
map<string, LoopGraph*> loopForIndex;
BuildLoopIndex(loopForIndex, loop);
for (int i = 0; i < instructions.size(); i++)
{
auto instruction = instructions[i];
if (!instruction->getInstruction()->getArg1())
continue;
auto operation = instruction->getInstruction()->getOperation();
auto type = instruction->getInstruction()->getArg1()->getType();
if ((operation == SAPFOR::CFG_OP::STORE || operation == SAPFOR::CFG_OP::LOAD) && type == SAPFOR::CFG_ARG_TYPE::ARRAY)
{
vector<SAPFOR::Argument*> index_vars;
vector<int> refPos;
string array_name;
if (operation == SAPFOR::CFG_OP::STORE)
array_name = instruction->getInstruction()->getArg1()->getValue();
else
array_name = instruction->getInstruction()->getArg2()->getValue();
int j = i - 1;
while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
{
index_vars.push_back(instructions[j]->getInstruction()->getArg1());
refPos.push_back(j);
j--;
}
/*to choose correct dimension*/
int n = index_vars.size();
vector<ArrayDimension> accessPoint(n);
auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
vector<pair<int, int>> coefsForDims;
for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
{
const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
if (coefs.size() == 1)
{
const pair<int, int> coef(coefs[0][0], coefs[0][1]);
coefsForDims.push_back(coef);
}
}
if(coefsForDims.empty())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
while (!index_vars.empty())
{
auto var = index_vars.back();
int currentVarPos = refPos.back();
pair<int, int> 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<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& 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<SAPFOR::BasicBlock*>& Blocks, const unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
{
Region* region = new Region;
auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
if (bbToRegion.find(header) != bbToRegion.end())
region->setHeader(bbToRegion.at(header));
else
{
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
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));
return region;
}
Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
{
auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
unordered_map<SAPFOR::BasicBlock*, Region*> bbToRegion;
for (auto poiner : blockSet)
{
bbToRegion[poiner] = new Region(*poiner);
this->basickBlocks.insert(bbToRegion[poiner]);
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));
}

60
src/PrivateAnalyzer/region.h
View File

@@ -1,60 +0,0 @@
#pragma once
#include <vector>
#include <map>
#include <unordered_set>
#include <string>
#include "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<SAPFOR::BasicBlock*>& Blocks);
Region* getHeader() { return header; }
void setHeader(Region* region) { header = region; }
std::unordered_set<Region*>& getBasickBlocks() { return basickBlocks; }
void addBasickBlocks(Region* region) { basickBlocks.insert(region); }
const std::unordered_set<Region*>& getPrevRegions() { return prevRegions; }
std::unordered_set<Region*> 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<Region*> 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<Region*> subRegions, basickBlocks;
/*next Region which is BB for current BB Region*/
std::unordered_set<Region*> nextRegions;
/*prev Regions which is BBs for current BB Region*/
std::unordered_set<Region*> prevRegions;
Region* header;
};

10
src/ProjectManipulation/ConvertFiles.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -6,9 +6,9 @@
#include <string>
#include <vector>
#include "errors.h"
#include "SgUtils.h"
#include "utils.h"
#include "../Utils/errors.h"
#include "../Utils/SgUtils.h"
#include "../Utils/utils.h"
#include "../VerificationCode/verifications.h"
@@ -403,7 +403,7 @@ static int convertFile(int argc, char* argv[], const set<string>& filesInProj, c
fprintf(stderr, "<<<<< Unparsing %s >>>>>\n", fout_name);
if (mod_gpu) /*ACC*/
UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info, fout_name);
UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info);
const string fileN = file->filename();
set<SgStatement*> toRemove;

6
src/ProjectManipulation/FileInfo.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -7,8 +7,8 @@
#include <vector>
#include "FileInfo.h"
#include "utils.h"
#include "errors.h"
#include "../Utils/utils.h"
#include "../Utils/errors.h"
using namespace std;

119
src/ProjectManipulation/ParseFiles.cpp
View File

@@ -1,4 +1,4 @@
#include "leak_detector.h"
#include "../Utils/leak_detector.h"
#include <cstdio>
#include <cstdlib>
@@ -22,8 +22,8 @@
#include <thread>
#include <stack>
#include "errors.h"
#include "SgUtils.h"
#include "../Utils/errors.h"
#include "../Utils/SgUtils.h"
#include "../VisualizerCalls/get_information.h"
#include "../VisualizerCalls/SendMessage.h"
@@ -34,7 +34,6 @@
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<string>& files, map<string, string>& modDecls)
{
@@ -294,8 +293,11 @@ static vector<string> parseList(vector<FileInfo>& listOfProject,
}
}
sendMessage_2lvl(3, file);
#ifdef _WIN32
sendMessage_2lvl(L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> '" + to_wstring(file) + L"'");
#else
sendMessage_2lvl(L" processing file '" + to_wstring(file) + L"'");
#endif
StdCapture::Init();
string errorMessage = "";
try
@@ -385,50 +387,7 @@ static string shiftLines(const string &in, const map<string, const FileInfo*> &m
return newStr;
}
static void addMessage(const string& in, const map<string, const FileInfo*>& mapOfFiles,
const FileInfo* currF, map<string, vector<Messages>>& messages, typeMessage type)
{
int byNum = 0;
auto it = in.find("on line ");
if (it != string::npos)
it += strlen("on line ");
int line = 0;
sscanf(in.c_str() + it, "%d", &line);
auto it1 = in.find("of", it + 1);
if (it1 == string::npos)
return;
it1 += 3;
string fileN = in.substr(it1, in.find(':', it1) - it1);
auto itF = mapOfFiles.find(fileN);
if (itF != mapOfFiles.end() && itF->second != currF)
{
byNum = itF->second->includesAdded;
if (byNum != 0)
{
if (line - byNum <= 0)
{
//return in;
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
}
else
line -= byNum;
}
}
const string newStr = in.substr(0, it) + std::to_string(line) + in.substr(in.find(' ', it + 1));
wstring messageE, messageR;
__spf_printToLongBuf(messageE, L"%s", to_wstring(newStr).c_str());
__spf_printToLongBuf(messageR, L"%s", to_wstring(newStr).c_str());
messages[fileN].push_back(Messages(type, line, messageR, messageE, 6000));
}
static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string>& errors, map<string, vector<Messages>>& messages)
static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string>& errors)
{
int errorsCount = 0;
map<string, const FileInfo*> mapOfFiles;
@@ -441,46 +400,41 @@ static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string
if (errors[z] == "")
{
FILE* ferr = fopen(file.errPath.c_str(), "w");
if (ferr)
fclose(ferr);
if (!ferr)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
fclose(ferr);
++z;
continue;
}
FILE* ferr = fopen(file.errPath.c_str(), "w");
FILE* fout = fopen(file.outPath.c_str(), "w");
if (!ferr)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
if (!fout)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
string errS = "", outS = "";
vector<string> splited;
splitString(errors[z], '\n', splited);
for (auto& elem : splited)
{
if (elem.find("Warning 308") != string::npos)
{
addMessage(elem, mapOfFiles, &file, messages, WARR);
outS += shiftLines(elem, mapOfFiles, &file) + "\n";
}
else if (elem.find("Error") != string::npos)
{
addMessage(elem, mapOfFiles, &file, messages, ERROR);
errS += shiftLines(elem, mapOfFiles, &file) + "\n";
errorsCount++;
}
}
FILE* ferr = fopen(file.errPath.c_str(), "w");
FILE* fout = fopen(file.outPath.c_str(), "w");
if (ferr)
{
fprintf(ferr, "%s", errS.c_str());
fclose(ferr);
}
if (fout)
{
fprintf(fout, "%s", outS.c_str());
fclose(fout);
}
fprintf(fout, "%s", outS.c_str());
fprintf(ferr, "%s", errS.c_str());
fflush(NULL);
fclose(fout);
fclose(ferr);
++z;
}
@@ -575,8 +529,11 @@ static void parseFiles(int& iters, vector<string>& errors, vector<FileInfo>& lis
do
{
sendMessage_1lvl(0, iters + 1);
#ifdef _WIN32
sendMessage_1lvl(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + std::to_wstring((iters + 1)) + L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
#else
sendMessage_1lvl(L"running " + std::to_wstring((iters + 1)) + L" iteration of syntax analisys");
#endif
errors = parseList(listOfProject, iters != 0, parseForInlining, mapModuleDeps, moduleDelc, modDirectOrder, isFromConsole);
changed = createMapOfUse(errors, listOfProject, mapModuleDeps);
if (iters != 0)
@@ -695,7 +652,7 @@ static int parseFiles(vector<string>& errors, vector<FileInfo>& listOfProject, v
return rethrow;
}
int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int parseForInlining, map<string, vector<Messages>>& messages)
int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int parseForInlining)
{
FILE* list = fopen(proj, "r");
if (!list)
@@ -709,7 +666,7 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
if (pathSplit.size() < 2)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
if (pathSplit[pathSplit.size() - 2] != VISUALIZER_DATA_PATH)
if (pathSplit[pathSplit.size() - 2] != "visualiser_data")
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
string fullPath = "";
for (int z = 0; z < pathSplit.size() - 2; ++z)
@@ -741,9 +698,9 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
else
fileNameFixed = (toAdd.substr(0, 2) == "./") ? toAdd.substr(2) : toAdd;
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 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 fileText = readFileToStr(toAdd);
@@ -766,7 +723,7 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
vector<string> errors;
int rethrow = parseFiles(errors, listOfProject, filesCompilationOrder, parseForInlining);
int errCount = dumpErrors(listOfProject, errors, messages);
int errCount = dumpErrors(listOfProject, errors);
if (rethrow != 0)
throw rethrow;
@@ -775,8 +732,6 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
void parseFiles(int argc, char** argv)
{
map<string, vector<Messages>> messages;
bool isInline = false;
auto result = splitCommandLineForParse(argv, argc, isInline);
if (result.second.size() == 0)
@@ -805,8 +760,6 @@ void parseFiles(int argc, char** argv)
printf(" run parsing for inlining\n");
int rethrow = parseFiles(errors, listOfProject, filesCompilationOrder, isInline, true);
int errCount = dumpErrors(listOfProject, errors, messages);
if (rethrow == 0)
{
for (auto& err : errors)
@@ -836,7 +789,5 @@ void parseFiles(int argc, char** argv)
}
else
printf("Parsing was completed with errors, throw code %d, errors count %d\n", rethrow, code);
dumpMessages(false, messages, VISUALIZER_DATA_PATH);
exit(0);
}

Some files were not shown because too many files have changed in this diff Show More