fixed removeDvmSpfDirectives

.gitignore

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

.gitmodules

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

CMakeLists.txt

@@ -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)
@@ -67,7 +54,7 @@ set(VS_CALLS src/VisualizerCalls/get_information.cpp
         src/VisualizerCalls/SendMessage.h
         src/VisualizerCalls/BuildGraph.cpp
         src/VisualizerCalls/BuildGraph.h)
-
+    
 set(VERIF src/VerificationCode/CorrectVarDecl.cpp
         src/VerificationCode/IncludeChecker.cpp
         src/VerificationCode/StructureChecker.cpp
@@ -89,8 +76,7 @@ set(UTILS src/Utils/AstWrapper.h
         src/Utils/utils.h
         src/Utils/version.h
         src/Utils/module_utils.h
-        src/Utils/module_utils.cpp
-        src/Utils/json.hpp)
+        src/Utils/module_utils.cpp)
         
 set(OMEGA src/SageAnalysisTool/OmegaForSage/add-assert.cpp
         src/SageAnalysisTool/OmegaForSage/affine.cpp
@@ -122,13 +108,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 +143,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 +196,24 @@ 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})
         
+<<<<<<< HEAD
+set(CFG _src/CFGraph/IR.cpp
+        _src/CFGraph/IR.h
+        _src/CFGraph/CFGraph.cpp
+        _src/CFGraph/CFGraph.h
+        _src/CFGraph/RD_subst.cpp
+        _src/CFGraph/RD_subst.h
+        _src/CFGraph/live_variable_analysis.cpp
+        _src/CFGraph/live_variable_analysis.h
+        _src/CFGraph/private_variables_analysis.cpp
+        _src/CFGraph/private_variables_analysis.h
+	_src/CFGraph/IRSSAForm.cpp
+	_src/CFGraph/IRSSAForm.h
+=======
 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
@@ -240,6 +222,7 @@ set(CFG src/CFGraph/IR.cpp
         src/CFGraph/live_variable_analysis.h
         src/CFGraph/private_variables_analysis.cpp
         src/CFGraph/private_variables_analysis.h
+>>>>>>> 18f5619 (fixed paths)
         )
         
 set(DATA_FLOW
@@ -309,6 +292,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,11 +307,18 @@ 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
@@ -332,15 +326,6 @@ set(MAIN src/Sapfor.cpp
 
 set(PREDICTOR src/Predictor/PredictScheme.cpp
               src/Predictor/PredictScheme.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)
 
 set(PROJ_MAN src/ProjectManipulation/ParseFiles.cpp
              src/ProjectManipulation/ParseFiles.h
@@ -414,9 +399,12 @@ set(SOURCE_EXE
     ${DISTR}
     ${DVMH_REG}
     ${DYNA}
+    ${EXPR_TRANSFORM}
     ${GR_CALL}
     ${GR_LOOP}
+    ${INLINER}
     ${LOOP_ANALYZER}
+    ${RENAME_SYMBOLS}
     ${TRANSFORMS}
     ${PARALLEL_REG}
     ${PRIV}
@@ -427,7 +415,6 @@ set(SOURCE_EXE
     ${VS_CALLS}
     ${MAIN}
     ${PREDICTOR}
-    ${LIBPREDICTOR}
     ${PARSER}
     ${PPPA}
     ${ZLIB}
@@ -440,7 +427,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})
@@ -448,13 +435,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})
@@ -482,12 +469,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()
@@ -496,9 +482,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)

src/CFGraph/CFGraph.cpp

@@ -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"
@@ -56,6 +56,23 @@ void BBlock::addInstruction(IR_Block* item)
     item->setBasicBlock(this);
 }
 
+void BBlock::addInstructionInFront(IR_Block* item)
+{
+    instructions.insert(instructions.begin(), item);
+    item->setBasicBlock(this);
+}
+
+void BBlock::addInstructionBeforeInstruction(IR_Block* item, Instruction* instruction)
+{
+    for (auto it = instructions.begin(); it != instructions.end(); ++it) {
+        if ((*it)->getInstruction() == instruction) {
+            instructions.insert(instructions.begin(), item);
+            item->setBasicBlock(this);
+            return;
+        }
+    }
+}
+
 int BBlock::removePrev(BBlock* removed)
 {
     auto it = std::remove(prev.begin(), prev.end(), removed);
@@ -512,7 +529,7 @@ static int buildReachingDefs(const vector<BBlock*>& CFG, const FuncInfo* currF,
     return iter;
 }
 
-//Kosaraju<6A>Sharir algorithm
+//Kosaraju<6A>Sharir algorithm
 static vector<int> getStronglyConnectedComps(vector<vector<int>>& g) {
     // 1. For each vertex u of the graph, mark u as unvisited. Let l be empty.
     auto size = g.size();
@@ -1149,22 +1166,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 +1243,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());
 }

src/CFGraph/CFGraph.h

@@ -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;
+        
         //reaching definition
         std::map<SAPFOR::Argument*, std::set<int>> RD_in, RD_out;
 
@@ -35,16 +34,16 @@ 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);
         BasicBlock(const BasicBlock& copyFrom);
 
+        void addInstructionBeforeInstruction(IR_Block* item, Instruction* istruction);
+        void addInstructionInFront(IR_Block* item);
         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; }
 
         int removePrev(BasicBlock* removed);
         int removeNext(BasicBlock* removed);
@@ -72,11 +71,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; 
-        }
-
+        
         /*
         *  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)
         { }
     };
 }
@@ -155,6 +148,4 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
         byFunc.second.clear();
     }
     cfg.clear();
-}
-
-void removedUnreachableBlocks(std::vector<SAPFOR::BasicBlock*>& blocks);
+}

src/CFGraph/DataFlow/backward_data_flow.h

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

src/CFGraph/DataFlow/backward_data_flow_impl.h

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

src/CFGraph/DataFlow/data_flow.h

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

src/CFGraph/DataFlow/data_flow_impl.h

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

src/CFGraph/IR.cpp

@@ -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()) // обращение к переменной
         {
             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
+    // добавление связей по GOTO и переходам
     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
+                // заменим метку на номер инструкции
                 arg->setValue(to_string(it->second->getNumber())); 
                 arg->setType(CFG_ARG_TYPE::INSTR);
             }
@@ -1613,3 +1613,140 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
 
     return blocks;
 }
+
+void dfs(SAPFOR::BasicBlock* block, vector<int>& visit, vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>>& startAndEnd, SAPFOR::BasicBlock* prev) {
+    if (visit[block->getNumber()] == 2) {
+        cout << "error";
+        return;
+    }
+
+    if (visit[block->getNumber()] == 1) {
+        visit[block->getNumber()] = 2;
+        startAndEnd.push_back(make_pair(prev, block));
+        return;
+    }
+
+    visit[block->getNumber()] = 1;
+    for (auto i : block->getNext()) {
+        dfs(i, visit, startAndEnd, block);
+    }
+}
+
+void printBlock(SAPFOR::BasicBlock* block) {
+    cout << "block - " << block->getNumber() << endl;
+    cout << "next -";
+    for (auto i : block->getNext())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl << "prev -";
+    for (auto i : block->getPrev())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl;
+    
+    for (auto i : block->getInstructions())
+    {
+        cout << i->getNumber() << " " << i->getInstruction()->dump() << endl;
+    }
+
+    cout << endl;
+}
+
+void testIR(map<FuncInfo*, vector<SAPFOR::BasicBlock*>> fullIR) {
+    for (auto& i : fullIR)
+    {
+        for (auto j : i.second)
+            printBlock(j);
+
+        vector<IR_Block*> all;
+        for (auto j : i.second)
+            for (auto k : j->getInstructions())
+                all.push_back(k);
+
+        vector<int> visited(i.second.size(), 0);
+        vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>> startAndEnd;
+        dfs(i.second[0], visited, startAndEnd, NULL);
+
+
+        vector<LoopGraph*> loops;
+        for (auto j : startAndEnd)
+        {
+            auto firstInstruction = j.second->getInstructions()[0]->getInstruction();
+            auto lastInstruction = j.first->getInstructions().back()->getInstruction();
+            Instruction* instructionAfterLoop;
+            for (auto a : fullIR)
+                for(auto b : a.second)
+                    for (auto c : b->getInstructions())
+                        if (c->getInstruction()->getNumber() == lastInstruction->getNumber() + 1)
+                        {
+                            instructionAfterLoop = c->getInstruction();
+                            break;
+                        }
+
+            //auto instructionAfterLoop = getInstructionByNumber(all, lastInstruction->getNumber() + 1);
+            cout << "first - " << firstInstruction->getNumber() << " last - " << lastInstruction->getNumber() << " after - " << instructionAfterLoop->getNumber() << endl;
+
+            if (firstInstruction->getOperator()->variant() == FOR_NODE) {
+                SgForStmt* stmt = isSgForStmt(firstInstruction->getOperator());
+
+                auto tmpLoop = new LoopGraph();
+                tmpLoop->isFor = true;
+                tmpLoop->lineNum = firstInstruction->getOperator()->lineNumber();
+                tmpLoop->lineNumAfterLoop = instructionAfterLoop->getOperator()->lineNumber();
+
+                cout << "for" << endl << stmt->sunparse() << endl;
+                cout << "loop start line " << tmpLoop->lineNum << endl;
+                cout << "after loop line " << tmpLoop->lineNumAfterLoop << endl << endl;
+                loops.push_back(tmpLoop);
+            } else if (firstInstruction->getOperator()->variant() == WHILE_NODE) {
+                SgWhileStmt* stmt = isSgWhileStmt(firstInstruction->getOperator());
+
+                auto tmpLoop = new LoopGraph();
+                tmpLoop->lineNum = firstInstruction->getOperator()->lineNumber();
+                tmpLoop->lineNumAfterLoop = instructionAfterLoop->getOperator()->lineNumber();
+
+                if (stmt->conditional() == NULL)
+                {
+                    //infinit loop
+                    cout << "infinit loop " << endl << stmt->sunparse() << endl;
+                }
+                else
+                {
+                    //while
+                    cout << "while " << endl << stmt->sunparse();
+                }
+
+                cout << "loop start line " << tmpLoop->lineNum << endl;
+                cout << "after loop line " << tmpLoop->lineNumAfterLoop << endl << endl;
+
+                loops.push_back(tmpLoop);
+            } else if (firstInstruction->getOperator()->variant() == LOOP_NODE) {
+                cout << "not known loop" << endl << firstInstruction->getOperator()->sunparse() << endl;
+            }
+            else { 
+                cout << "goto loop - " << firstInstruction->getOperator()->sunparse() << endl;
+            }
+        }
+
+
+        /*for (auto j : i.second) {
+            cout << j->getNumber() << endl << "in" << endl;
+            for (auto k : j->getRD_In()) {
+                cout << k.first->getMemTypeStr() << " - ";
+                for (auto h : k.second) {
+                    cout << h << " ";
+                }
+                cout << endl;
+            }
+            cout << "out" << endl;
+            for (auto k : j->getRD_Out()) {
+                cout << k.first->getMemTypeStr() << " - ";
+                for (auto h : k.second) {
+                    cout << h << " ";
+                }
+                cout << endl;
+            }*/        
+    }
+}

src/CFGraph/IR.h

@@ -6,7 +6,7 @@
 #include <algorithm>
 
 #include "CFGraph.h"
-#include "CommonBlock.h"
+#include "../Utils/CommonBlock.h"
 
 namespace SAPFOR
 {
@@ -42,6 +42,7 @@ namespace SAPFOR
         Argument() : number(lastNumArg++), type(CFG_ARG_TYPE::NONE), value(""), mType(CFG_MEM_TYPE::NONE_) { }
         Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType) : number(lastNumArg++), type(type), mType(mType), value("") { }
         Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType, const std::string& value) : number(lastNumArg++), type(type), mType(mType), value(value) { }
+        Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType, const std::string& value, int num) : number(num), type(type), mType(mType), value(value) { }
         Argument(CFG_ARG_TYPE type, const std::string& value) : number(lastNumArg++), type(type), mType(CFG_MEM_TYPE::NONE_), value(value) 
         {
             if (type != CFG_ARG_TYPE::INSTR && type == CFG_ARG_TYPE::LAB &&
@@ -130,7 +131,7 @@ namespace SAPFOR
         {
             if (arg == NULL)
                 return "";
-            return arg->getValue();
+            return arg->getValue(); 
         }
     public:
 
@@ -198,7 +199,7 @@ namespace SAPFOR
         {
             std::string res = "";
 
-            std::string resultVal = getArgValue(result);
+            std::string resultVal = getArgValue(result); 
             std::string arg1Val = getArgValue(arg1);
             std::string arg2Val = getArgValue(arg2);
 
@@ -343,4 +344,6 @@ std::vector<SAPFOR::IR_Block*> buildIR(SgStatement* function, const FuncInfo* fu
 SAPFOR::Instruction* getInstructionByNumber(const std::vector<SAPFOR::IR_Block*>& blocks, int num);
 std::pair<SAPFOR::Instruction*, SAPFOR::BasicBlock*> getInstructionAndBlockByNumber(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& CFGraph, int num);
 std::pair<SAPFOR::Instruction*, SAPFOR::BasicBlock*> getInstructionAndBlockByStatement(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& CFGraph, SgStatement* stmt);
-int getParamIndex(SAPFOR::Argument* func_param, int max_index);
+int getParamIndex(SAPFOR::Argument* func_param, int max_index);
+
+void testIR(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>> fullIR);

src/CFGraph/IRSSAForm.cpp

@@ -0,0 +1,588 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <vector>
+#include <set>
+
+#include "../Utils/SgUtils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.h"
+#include "../ExpressionTransform/expr_transform.h"
+
+#include "dvm.h"
+#include "IR.h"
+#include "CFGraph.h"
+
+using namespace std;
+using namespace SAPFOR;
+
+typedef SAPFOR::BasicBlock BBlock;
+typedef SAPFOR::Argument BArgument;
+
+static void printBlock(BBlock* block) {
+    cout << "block - " << block->getNumber() << endl;
+    cout << "next -";
+    for (auto i : block->getNext())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl << "prev -";
+    for (auto i : block->getPrev())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl;
+
+    for (auto i : block->getInstructions())
+    {
+        string resValue = "";
+        string arg1Value = "";
+        string arg2Value = "";
+        if (i->getInstruction()->getResult() != nullptr && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            resValue = i->getInstruction()->getResult()->getValue();
+            i->getInstruction()->getResult()->setValue(i->getInstruction()->getResult()->getValue() + to_string(i->getInstruction()->getResult()->getNumber()));
+        } 
+        if (i->getInstruction()->getArg1() != nullptr && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            arg1Value = i->getInstruction()->getArg1()->getValue();
+            i->getInstruction()->getArg1()->setValue(i->getInstruction()->getArg1()->getValue() + to_string(i->getInstruction()->getArg1()->getNumber()));
+        }
+        if (i->getInstruction()->getArg2() != nullptr && i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            arg2Value = i->getInstruction()->getArg2()->getValue();
+            i->getInstruction()->getArg2()->setValue(i->getInstruction()->getArg2()->getValue() + to_string(i->getInstruction()->getArg2()->getNumber()));
+        }
+
+        cout << i->getNumber() << " " << i->getInstruction()->dump() << endl;// << (i->getInstruction()->getResult() != nullptr ? "   1 " : "   0 ") << (i->getInstruction()->getArg1() != nullptr ? "1 " : "0 ") << (i->getInstruction()->getArg2() != nullptr ? "1 " : "0 ") << endl;
+
+        /*if (i->getInstruction()->getResult() != nullptr) {
+            cout << "num - " << i->getInstruction()->getResult()->getNumber() << endl;
+        })*/
+
+        /*if (i->getInstruction()->getOperation() == CFG_OP::F_CALL) {
+            cout << endl;
+            cout << "arg1 - " << (i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::FUNC ? "1" : "0") << "arg2 - " << (i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::CONST ? "1" : "0") << "res - " << i->getInstruction()->getResult() << endl;
+        }*/
+        
+        if (i->getInstruction()->getResult() != nullptr && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getResult()->setValue(resValue);
+        }
+        if (i->getInstruction()->getArg1() != nullptr && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getArg1()->setValue(arg1Value);
+        }
+        if (i->getInstruction()->getArg2() != nullptr && i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getArg2()->setValue(arg2Value);
+        }
+    }
+
+    cout << endl;
+}
+template <typename T>
+static bool compareVectors(const vector<T>* vec1, const vector<T>* vec2) {
+    if (vec1 == vec2) {
+        return true;
+    }
+
+    if (!vec1 || !vec2) {
+        return false;
+    }
+
+    vector<T> sortedVec1 = *vec1;
+    vector<T> sortedVec2 = *vec2;
+
+    sort(sortedVec1.begin(), sortedVec1.end());
+    sort(sortedVec2.begin(), sortedVec2.end());
+
+    return sortedVec1 == sortedVec2;
+}
+
+template <typename T>
+static vector<T>* getCommonElements(const vector<vector<T>>* vectors) {
+    if (!vectors || vectors->empty()) {
+        return new vector<T>(); // Return an empty vector if input is null or empty
+    }
+
+    // Start with the first vector
+    vector<T>* commonElements = new vector<T>((*vectors)[0]);
+
+    for (size_t i = 1; i < vectors->size(); ++i) {
+        vector<T> tempCommon;
+
+        // Sort the current vector and common result for intersection
+        vector<T> sortedVec = (*vectors)[i];
+        sort(commonElements->begin(), commonElements->end());
+        sort(sortedVec.begin(), sortedVec.end());
+
+        // Find the intersection
+        set_intersection(
+            commonElements->begin(), commonElements->end(),
+            sortedVec.begin(), sortedVec.end(),
+            back_inserter(tempCommon)
+        );
+
+        // Update common result
+        *commonElements = tempCommon;
+
+        // If no common elements left, break early
+        if (commonElements->empty()) {
+            break;
+        }
+    }
+
+    return commonElements;
+}
+
+
+static map<BBlock*, vector<BBlock*>> findDominators(vector<BBlock*> blocks) {
+    map<BBlock*, vector<BBlock*>> result;
+
+    bool changed = true;
+    while (changed) {
+        changed = false;
+
+        for (auto currentBlock : blocks) {
+            auto pred = currentBlock->getPrev();
+            auto prevDominators = new vector<vector<BBlock*>>();
+
+            for (auto predBlock : pred)
+                prevDominators->push_back(result.find(predBlock) != result.end() ? result[predBlock] : blocks);
+
+            auto currentBlockResult = getCommonElements(prevDominators);
+            currentBlockResult->push_back(currentBlock);
+
+            if (result.find(currentBlock) == result.end() || !compareVectors(currentBlockResult, &result[currentBlock])) {
+                result[currentBlock] = *currentBlockResult;
+                changed = true;
+            }
+        }
+    }
+
+    return result;
+}
+
+static void RenumberBlocks(BBlock* current, int* n, map<int, int>* res, set<BBlock*>* visited) {
+    if (visited->find(current) != visited->end()) {
+        return;
+    }
+
+    visited->insert(current);
+
+    vector<BBlock*> nextBlocks = current->getNext();
+
+    sort(nextBlocks.begin(), nextBlocks.end(), [](BBlock* a, BBlock* b) {
+        return a->getInstructions()[0]->getInstruction()->getOperator()->lineNumber() > b->getInstructions()[0]->getInstruction()->getOperator()->lineNumber();
+    });
+
+    for (auto i : nextBlocks) {
+        RenumberBlocks(i, n, res, visited);
+    }
+
+    (*res)[current->getNumber()] = *n;
+    *n -= 1;
+}
+
+static map<BBlock*, vector<BBlock*>> findDominatorBorders(vector<BBlock*>& blocks, map<BBlock*, BBlock*>& iDominators) {
+    map<BBlock*, vector<BBlock*>> result;
+
+    for (auto block : blocks) {
+        result[block] = *(new vector<BBlock*>());
+    }
+
+    for (auto block : blocks) {
+        if (block->getPrev().size() > 1) {
+            for (auto prev : block->getPrev()) {
+                auto tmpBlock = prev;
+
+                while (tmpBlock != iDominators[block]) {
+                    result[tmpBlock].push_back(block);
+                    tmpBlock = iDominators[tmpBlock];
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+static BBlock* findImmediateDominatorsDfsHelper(BBlock* block, BBlock* currentBlock, BBlock* currentImmediateDominator, vector<BBlock*> &visited, map<BBlock*, vector<BBlock*>>& dominators) {
+    if (block == currentBlock) {
+        return currentImmediateDominator;
+    }
+    
+    if (find(visited.begin(), visited.end(), currentBlock) != visited.end()) {
+        return nullptr;
+    }
+    
+    visited.push_back(currentBlock);
+
+    if (find(dominators[block].begin(), dominators[block].end(), currentBlock) != dominators[block].end()) {
+        currentImmediateDominator = currentBlock;
+    }
+
+    for (auto nextBlock : currentBlock->getNext()) {
+        auto result = findImmediateDominatorsDfsHelper(block, nextBlock, currentImmediateDominator, visited, dominators);
+
+        if (result) {
+            return result;
+        }
+    }
+
+    return nullptr;
+}
+
+static map<BBlock*, BBlock*> findImmediateDominators(map<BBlock*, vector<BBlock*>>& dominators, BBlock* fistBlock) {
+    map<BBlock*, BBlock*> iDominators;
+
+    for (const auto& domPair : dominators) {
+        BBlock* block = domPair.first;
+        const vector<BBlock*>& domBlocks = domPair.second;
+        vector<BBlock*> visited;
+
+        if (block == fistBlock) {
+            continue;
+        }
+
+        iDominators[block] = findImmediateDominatorsDfsHelper(block, fistBlock, fistBlock, visited, dominators);
+    }
+
+    return iDominators;
+}
+
+static vector<BArgument*> getDefForBlock(const BBlock& block) {
+    vector<BArgument*> def;
+    const auto& instructions = block.getInstructions();
+
+    for (const auto& irBlock : instructions) {
+        if (irBlock) {
+            Instruction* instr = irBlock->getInstruction();
+
+            if (instr) {
+                BArgument* result = instr->getResult();
+                if (result) {
+                    def.push_back(result);
+                }
+            }
+        }
+    }
+
+    return def;
+}
+
+static pair<set<BArgument*>, map<BArgument*, set<BBlock*>>> getGlobalsAndVarBlocks(vector<BBlock*> blocks) {
+    set<BArgument*> globals;
+    map<BArgument*, set<BBlock*>> varBlocks;
+
+    for (auto block : blocks) {
+        set<BArgument*> def;
+        const auto& instructions = block->getInstructions();
+
+        for (const auto& irBlock : instructions) {
+            if (irBlock) {
+                Instruction* instr = irBlock->getInstruction();
+
+                if (instr) {
+                    auto arg1 = instr->getArg1();
+                    auto arg2 = instr->getArg2();
+                    auto res = instr->getResult();
+
+                    if (arg1 && arg1->getType() == CFG_ARG_TYPE::VAR && find(def.begin(), def.end(), arg1) == def.end()) {
+                        globals.insert(arg1);
+                    }
+                    if (arg2 && arg2->getType() == CFG_ARG_TYPE::VAR && find(def.begin(), def.end(), arg2) == def.end()) {
+                        globals.insert(arg2);
+                    }
+
+                    if (res && res->getType() == CFG_ARG_TYPE::VAR) {
+                        def.insert(res);
+                        varBlocks[res].insert(block);
+                    }
+                }
+            }
+        }
+    }
+
+    return make_pair(globals, varBlocks);
+}
+
+static vector<BBlock*> getBlocksWithFiFunctions(vector<BBlock*> blocks, set<BArgument*> globals, map<BArgument*, set<BBlock*>> varBlocks, map<BBlock*, vector<BBlock*>> dominatorBorders) {
+    vector<BBlock*> blocksWithFiFunctions;
+    auto fiFunc = new BArgument(CFG_ARG_TYPE::FUNC, CFG_MEM_TYPE::NONE_, "FI_FUNCTION");
+    auto paramCount = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::LOCAL_, "0");
+
+    for (auto var : globals) {
+        auto worklist = varBlocks[var];
+        set<BBlock*> hasFiFunction;
+
+        while (!worklist.empty()) {
+            auto block = *worklist.begin();
+            worklist.erase(block);
+
+            for (auto dfBlock : dominatorBorders[block]) {
+                if (hasFiFunction.find(dfBlock) == hasFiFunction.end()) {
+                    hasFiFunction.insert(dfBlock);
+
+                    Instruction* phiInstruction = new Instruction(CFG_OP::F_CALL, fiFunc, paramCount, var);
+
+                    //cout << "insert fi functio9n in " << dfBlock->getNumber() << " with var " << var->getValue() << endl;
+
+                    IR_Block* phiBlock = new IR_Block(phiInstruction);
+                    dfBlock->addInstructionInFront(phiBlock);
+
+                    blocksWithFiFunctions.push_back(dfBlock);
+                }
+            }
+        }
+    }
+
+    return blocksWithFiFunctions;
+}
+
+
+
+
+string ToString(CFG_ARG_TYPE type) {
+    switch (type) {
+    case CFG_ARG_TYPE::NONE: return "NONE";
+    case CFG_ARG_TYPE::REG: return "REG";
+    case CFG_ARG_TYPE::VAR: return "VAR";
+    case CFG_ARG_TYPE::ARRAY: return "ARRAY";
+    case CFG_ARG_TYPE::CONST: return "CONST";
+    case CFG_ARG_TYPE::FUNC: return "FUNC";
+    case CFG_ARG_TYPE::LAB: return "LAB";
+    case CFG_ARG_TYPE::INSTR: return "INSTR";
+    case CFG_ARG_TYPE::CONST_STR: return "CONST_STR";
+    case CFG_ARG_TYPE::RECORD: return "RECORD";
+    case CFG_ARG_TYPE::CONSTR_REF: return "CONSTR_REF";
+    default: return "UNKNOWN";
+    }
+}
+
+void restoreConnections(const vector<BBlock*>& originalBlocks, vector<BBlock*>& copiedBlocks) {
+    // Создаем отображение оригинальных блоков в их копии
+    map<BBlock*, BBlock*> blockMapping;
+    for (size_t i = 0; i < originalBlocks.size(); ++i) {
+        blockMapping[originalBlocks[i]] = copiedBlocks[i];
+    }
+
+    // Восстанавливаем связи между копиями
+    for (size_t i = 0; i < originalBlocks.size(); ++i) {
+        BBlock* originalBlock = originalBlocks[i];
+        BBlock* copiedBlock = copiedBlocks[i];
+
+        for (auto j : copiedBlock->getPrev()) {
+            copiedBlock->removePrev(j);
+        }
+        for (auto j : copiedBlock->getNext()) {
+            copiedBlock->removeNext(j);
+        }
+
+        // Восстанавливаем связи succ (следующих блоков)
+        for (auto* succ : originalBlock->getNext()) {
+            copiedBlock->addNext(blockMapping[succ]);
+        }
+
+        // Восстанавливаем связи prev (предыдущих блоков)
+        for (auto* prev : originalBlock->getPrev()) {
+            copiedBlock->addPrev(blockMapping[prev]);
+        }
+    }
+}
+
+
+BArgument* NewName(BArgument* var, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+    int index = counter[var->getValue()];
+    counter[var->getValue()]++;
+
+    BArgument* newName = new BArgument(var->getType(), var->getMemType(), var->getValue(), index + 1);
+    stack[var->getValue()].push(newName);
+    return newName;
+}
+
+void RenameFiFunctionResultVar(BBlock* block, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+    for (auto irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr) {
+            instruction->setResult(NewName(instruction->getResult(), counter, stack));
+        }
+    }
+}
+
+void RenameInstructionVars(BBlock* block, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+    for (auto irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+
+        if (instruction->getArg1() != nullptr && instruction->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setArg1(stack[instruction->getArg1()->getValue()].top());
+        }
+
+        if (instruction->getArg2() != nullptr && instruction->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setArg2(stack[instruction->getArg2()->getValue()].top());
+        }
+
+        if (instruction->getResult() != nullptr && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setResult(NewName(instruction->getResult(), counter, stack));
+        }
+    }
+}
+
+void RenameFiFunctionArgsVar(BBlock* block, map<string, stack<BArgument*>>& stack) {
+    cout << "test" << endl;
+    auto size = block->getInstructions().size();
+    for (auto i = 0; i < size; i++) {
+        auto irBlock = block->getInstructions()[i];
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr) {
+            //cout << "test" << endl;
+
+            auto paramInstruction = new Instruction(CFG_OP::PARAM, stack[instruction->getResult()->getValue()].top());
+            block->addInstructionBeforeInstruction(new IR_Block(paramInstruction), instruction);
+
+            i++;
+        }
+    }
+}
+
+vector<BBlock*> findBlocksWithValue(map<BBlock*, BBlock*>& iDominators, BBlock* x) {
+    vector<BBlock*> result;
+
+    // Проходим по всем элементам map
+    for (auto& pair : iDominators) {
+        // Если значение равно x, добавляем ключ в результат
+        if (pair.second == x) {
+            result.push_back(pair.first);
+        }
+    }
+
+    return result;
+}
+
+void RenameIR(BBlock* block, map<BBlock*, BBlock*>& iDominators, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+
+    RenameFiFunctionResultVar(block, counter, stack);
+
+    RenameInstructionVars(block, counter, stack);
+
+    for (auto* successor : block->getNext()) {
+        RenameFiFunctionArgsVar(successor, stack);
+    }
+
+    for (auto* child : findBlocksWithValue(iDominators, block)) {
+        cout << "sec" << endl;
+        RenameIR(child, iDominators, counter, stack);
+    }
+
+    for (auto& irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getResult() != nullptr && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            string varName = instruction->getResult()->getValue();
+            stack[varName].pop();
+        }
+    }
+
+    for (auto& irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr) {
+            string varName = instruction->getResult()->getValue();
+            stack[varName].pop();
+        }
+    }
+}
+
+map<FuncInfo*, vector<BBlock*>> buildIRSSAForm(map<FuncInfo*, vector<BBlock*>> fullIR) {
+
+    map<FuncInfo*, vector<BBlock*>> result;
+
+    for (auto item : fullIR) {
+        auto funcinfo = item.first;
+        auto funcIRConst = item.second;
+
+        vector<BBlock*> funcIR;
+        vector<BBlock*> funcResult;
+
+        for (auto i : funcIRConst) {
+            funcIR.push_back(new BBlock(*i));
+        }
+        restoreConnections(funcIRConst, funcIR);
+
+        for (auto i : funcIR) {
+            //printBlock(i);
+        }
+
+        auto dominators = findDominators(funcIR);
+
+        /*cout << endl << endl << endl << "DOMINATORS" << endl << endl << endl;
+
+        for (auto i : dominators) {
+            cout << "block - " << i.first->getNumber() << endl;
+            for (auto j : i.second) {
+                cout << "dominators - " << j->getNumber() << endl;
+            }
+
+            cout << endl;
+        }*/
+
+        auto iDominators = findImmediateDominators(dominators, funcIR[0]);
+
+        /*for (auto i : iDominators) {
+            cout << "block - " << i.first->getNumber() << endl;
+            cout << "Idominators - " << i.second->getNumber() << endl;
+            cout << endl;
+        }
+        */
+        auto dominatorBorders = findDominatorBorders(funcIR, iDominators);
+        
+
+        /*for (auto i : dominatorBorders) {
+            cout << "block - " << i.first->getNumber() << endl;
+            for (auto j : i.second) {
+                cout << "border - " << j->getNumber() << endl;
+            }
+
+            cout << endl;
+        }*/
+
+
+        auto globalsAndVarBlocks = getGlobalsAndVarBlocks(funcIR);
+        auto globals = globalsAndVarBlocks.first;
+        auto varBlocks = globalsAndVarBlocks.second;
+
+        /*for (auto i : globals) {
+            cout << i->getValue() << " " << ToString(i->getType()) << " " << i->getNumber() << endl;
+
+        }
+        cout << endl;
+        for (auto i : varBlocks) {
+            cout << i.first->getValue() << " - ";
+            for (auto j : i.second) {
+                cout << j->getNumber() << ", ";
+            }
+            cout << endl;
+        }
+        cout << endl;
+        */
+
+        funcResult = getBlocksWithFiFunctions(funcIR, globals, varBlocks, dominatorBorders);
+
+        map<string, int> count;
+        map<string, stack<BArgument*>> varStack;
+
+        for (auto var : globals) {
+            count[var->getValue()] = 0;
+
+            stack<BArgument*> tmp;
+            varStack[var->getValue()] = tmp;
+        }
+
+        RenameIR(funcIR[0], iDominators, count, varStack);
+
+        for (auto i : funcIR) {
+            printBlock(i);
+        }
+        cout << endl << endl << endl << endl << endl;
+        for (auto i : funcIRConst) {
+            printBlock(i);
+        }
+
+
+        result[funcinfo] = funcResult;
+    }
+
+    return result;
+}

src/CFGraph/IRSSAForm.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "CFGraph.h"
+#include "IR.h"
+
+std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>> buildIRSSAForm(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>> fullIR);

src/CFGraph/IR_domTree.cpp

@@ -1,102 +0,0 @@
-#include "dvm.h"
-#include "IR_domTree.h"
-
-namespace SAPFOR {
-    void DominatorFinder::DFS(BasicBlock* v, int parent_num) {
-        dfs_num[v] = n;
-        vertex[n] = n;
-        semi[n] = n;
-        label[n] = n;
-        ancestor[n] = -1;
-        parent[n] = parent_num;
-        vertices[n++] = v;
-
-        for (const auto& w : v->getNext()) {
-            if (dfs_num[w] == -1)
-                DFS(w, dfs_num[v]);
-        }
-    }
-
-    void DominatorFinder::Compress(int v) {
-        if (ancestor[ancestor[v]] != -1) {
-            Compress(ancestor[v]);
-
-            if (semi[label[ancestor[v]]] < semi[label[v]])
-                label[v] = label[ancestor[v]];
-            ancestor[v] = ancestor[ancestor[v]];
-        }
-    }
-
-    int DominatorFinder::Eval(int v) {
-        if (ancestor[v] == -1) 
-            return v;
-
-        Compress(v);
-        return label[v];
-    }
-
-    void DominatorFinder::Link(int v, int w) {
-        ancestor[w] = v;
-    }
-
-    DominatorFinder::DominatorFinder(std::vector<BasicBlock*>& blocks) {
-        if (blocks.empty()) 
-            return;
-
-        entry = blocks[0];
-        n = 0;
-
-        for (auto block : blocks) 
-            dfs_num[block] = -1;
-
-        int max_size = blocks.size();
-        vertices.resize(max_size);
-        parent.assign(max_size, -1);
-        semi.assign(max_size, -1);
-        vertex.assign(max_size, -1);
-        ancestor.assign(max_size, -1);
-        label.assign(max_size, -1);
-        bucket.resize(max_size);
-
-        DFS(entry, -1);
-
-        for (int i = n - 1; i > 0; --i) {
-            int w = vertex[i];
-
-            for (BasicBlock* v : vertices[w]->getPrev()) {
-                if (dfs_num[v] == -1)
-                    continue;
-                int u = Eval(dfs_num[v]);
-
-                if (semi[u] < semi[w])
-                    semi[w] = semi[u];
-            }
-
-            bucket[vertex[semi[w]]].push_back(w);
-            Link(parent[w], w);
-
-            for (int v : bucket[parent[w]])
-            {
-                int u = Eval(v);
-                if (semi[u] < semi[v])
-                    vertices[v]->setDom(vertices[u]);
-                else
-                    vertices[v]->setDom(vertices[parent[w]]);
-            }
-            bucket[parent[w]].clear();
-        }
-
-        for (int i = 1; i < n; ++i) {
-            int w = vertex[i];
-
-            if (vertices[w]->getDom() != vertices[vertex[semi[w]]])
-                vertices[w]->setDom(vertices[w]->getDom()->getDom());
-        }
-
-        entry->setDom(nullptr);
-    }
-
-    void buildDominatorTree(std::vector<BasicBlock*>& blocks) {
-        DominatorFinder finder(blocks);
-    }
-}

src/CFGraph/IR_domTree.h

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

src/CFGraph/RD_subst.cpp

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

src/CFGraph/RD_subst.h

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

src/CFGraph/live_variable_analysis.h

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

src/CFGraph/private_variables_analysis.cpp

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

src/CFGraph/private_variables_analysis.h

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

src/CreateInterTree/CreateInterTree.cpp

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

src/CreateInterTree/CreateInterTree.h

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

src/DirectiveProcessing/directive_analyzer.cpp

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

src/DirectiveProcessing/directive_analyzer.h

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

src/DirectiveProcessing/directive_creator.cpp

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

src/DirectiveProcessing/directive_creator.h

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

src/DirectiveProcessing/directive_creator_base.cpp

@@ -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)));
         }
@@ -808,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)));
                             }
@@ -1100,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)
@@ -1113,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())
@@ -1124,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;
     }
 
@@ -1601,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)

src/DirectiveProcessing/directive_omp_parser.cpp

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

src/DirectiveProcessing/directive_omp_parser.h

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

src/DirectiveProcessing/directive_parser.cpp

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

src/DirectiveProcessing/directive_parser.h

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

src/DirectiveProcessing/insert_directive.cpp

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

src/DirectiveProcessing/remote_access.cpp

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

src/DirectiveProcessing/remote_access_base.cpp

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

src/DirectiveProcessing/shadow.cpp

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

src/DirectiveProcessing/spf_directive_preproc.cpp

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

src/Distribution/Array.cpp

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

src/Distribution/Array.h

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

src/Distribution/ArrayAnalysis.cpp

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

src/Distribution/CreateDistributionDirs.cpp

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

src/Distribution/CreateDistributionDirs.h

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

src/Distribution/Cycle.cpp

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

src/Distribution/Cycle.h

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

src/Distribution/Distribution.cpp

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

src/Distribution/DvmhDirective.cpp

@@ -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;
                             }
                         }
@@ -950,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);
 
@@ -1008,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);
 

src/Distribution/DvmhDirective.h

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

src/Distribution/DvmhDirectiveBase.cpp

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

src/Distribution/DvmhDirectiveBase.h

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

src/Distribution/DvmhDirective_func.h

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

src/Distribution/GraphCSR.cpp

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

src/Distribution/GraphCSR.h

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

src/DvmhRegions/DvmhRegion.h

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

src/DvmhRegions/DvmhRegionInserter.cpp

@@ -11,12 +11,13 @@
 #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;
 
+
 #define DVMH_REG_RD 0
 #define DVMH_REG_WT 1
 
@@ -794,6 +795,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 +1171,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)
@@ -1281,15 +1428,21 @@ static set<DIST::Array*>
 
         for (auto& realArray : realRef)
         {
-            if (added.count(realArray) != 0)
-                continue;
-
-            if (!realArray->IsNotDistribute())
+            if (added.count(realArray) != 0 || !realArray->IsNotDistribute())
                 continue;
 
             SgStatement* declStat = NULL;
 
-            if (realArray->GetLocation().first == DIST::l_COMMON)
+            if (realArray->GetLocation().first != DIST::l_COMMON)
+            {
+                if (std::count(usedAll.begin(), usedAll.end(), realArray) == 0)
+                {
+                    auto declInfo = *realArray->GetDeclInfo().begin();
+                    declStat = SgStatement::getStatementByFileAndLine(declInfo.first, declInfo.second);
+                    checkNull(declStat, convertFileName(__FILE__).c_str(), __LINE__);
+                }
+            }
+            else
             {
                 commonArrays.insert(realArray);
                 auto decls = realArray->GetDeclInfo();
@@ -1297,10 +1450,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 +1462,7 @@ static set<DIST::Array*>
                     }
                     else
                     {
-                        declStat = getFuncStat(declStat, { BLOCK_DATA });
+                        declStat = getFuncStat(declStat);
                         if (declStat != main)
                         {
                             declStat = NULL;
@@ -1321,19 +1471,6 @@ static set<DIST::Array*>
                     }
                 }
             }
-            else if (realArray->GetLocation().first == DIST::l_MODULE)
-            {
-               //TODO
-            }
-            else
-            {
-                if (std::count(usedAll.begin(), usedAll.end(), realArray) == 0)
-                {
-                    auto declInfo = *realArray->GetDeclInfo().begin();
-                    declStat = SgStatement::getStatementByFileAndLine(declInfo.first, declInfo.second);
-                    checkNull(declStat, convertFileName(__FILE__).c_str(), __LINE__);
-                }
-            }
 
             if (declStat)
             {

src/DvmhRegions/DvmhRegionInserter.h

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

src/DvmhRegions/LoopChecker.h

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

src/DvmhRegions/ReadWriteAnalyzer.h

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

src/DvmhRegions/TypedSymbol.h

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

src/DynamicAnalysis/createParallelRegions.cpp

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

src/DynamicAnalysis/createParallelRegions.h

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

src/DynamicAnalysis/gCov_parser.cpp

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

src/DynamicAnalysis/gCov_parser_func.h

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

src/DynamicAnalysis/gcov_info.cpp

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

src/DynamicAnalysis/gcov_info.h

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

src/ExpressionTransform/control_flow_graph_part.cpp

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

src/ExpressionTransform/expr_transform.cpp

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

src/ExpressionTransform/expr_transform.h

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

src/GraphCall/graph_calls.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -14,14 +14,13 @@
 #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 "../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"
 
@@ -38,8 +37,6 @@ using std::cout;
 using std::endl;
 using std::stack;
 
-using json = nlohmann::json;
-
 #define DEBUG 0
 
 //TODO: improve parameter checking 
@@ -779,20 +776,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 +795,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())
@@ -2614,71 +2592,4 @@ void setInlineAttributeToCalls(const map<string, FuncInfo*>& allFunctions,
     }
 }
 
-static json convertToJson(const FuncInfo* currFunc) {
-    json func;
-
-    if (currFunc)
-    {
-        func["funcName"] = currFunc->funcName;
-        func["line"] = currFunc->linesNum.first;
-        func["lineEnd"] = currFunc->linesNum.second;
-        func["isMain"] = (int)currFunc->isMain;
-        func["needToInline"] = (int)currFunc->needToInline;
-        func["doNotInline"] = (int)currFunc->doNotInline;
-        func["doNotAnalyze"] = (int)currFunc->doNotAnalyze;
-
-        json func_pars = json::array();
-
-        for (int z = 0; z < currFunc->funcParams.countOfPars; ++z)
-        {
-            json par;
-            par["inoutType"] = currFunc->funcParams.inout_types[z];
-            par["identificator"] = currFunc->funcParams.identificators[z];
-            par["parameterT"] = string(paramNames[currFunc->funcParams.parametersT[z]]);
-
-            func_pars.push_back(par);
-        }
-
-        func["params"] = func_pars;
-
-        json calls_from = json::array();
-        for (const auto& call_from : currFunc->callsFromDetailed)
-        {
-            json call;
-            call["line"] = call_from.detailCallsFrom.second;
-            call["funcName"] = call_from.detailCallsFrom.first;
-
-            calls_from.push_back(call);
-        }
-        func["callsFrom"] = calls_from;
-    }
-    return func;
-}
-
-json convertToJson(const map<string, vector<FuncInfo*>>& funcsByFileMap) {
-    json loopsByFile = json::array();
-
-    for (auto& byFile : funcsByFileMap)
-    {
-        json func;
-        const string& file = byFile.first;
-
-        json func_array = json::array();
-        for (auto& func : byFile.second)
-        {
-            auto conv = convertToJson(func);
-            if (!conv.empty())
-                func_array.push_back(conv);
-        }
-
-        func["file"] = file;
-        func["functions"] = func_array;
-
-        loopsByFile.push_back(func);
-    }
-
-    json allFuncs;
-    allFuncs["allFunctions"] = loopsByFile;
-    return allFuncs;
-}
 #undef DEBUG

src/GraphCall/graph_calls.h

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

src/GraphCall/graph_calls_base.cpp

@@ -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;
@@ -378,6 +378,33 @@ FuncInfo* isUserFunctionInProject(const string &func)
     return ret;
 }
 
+string convertToString(const FuncInfo *currFunc)
+{
+    string result = "";
+    if (currFunc)
+    {
+        result += "|" + currFunc->funcName + "|" + to_string(currFunc->linesNum.first) +
+            "#" + to_string(currFunc->linesNum.second) +
+            "#" + to_string(currFunc->callsFromDetailed.size()) +
+            "#" + to_string(currFunc->needToInline) + "#" + to_string(currFunc->doNotInline) +
+            "#" + to_string(currFunc->doNotAnalyze) + "#" + to_string((int)currFunc->isMain);
+
+        result += "#" + to_string(currFunc->funcParams.countOfPars);
+        if (currFunc->funcParams.countOfPars)
+        {
+            for (int z = 0; z < currFunc->funcParams.countOfPars; ++z)
+            {
+                result += "#" + currFunc->funcParams.identificators[z] + "#" + to_string(currFunc->funcParams.inout_types[z]);
+                result += "#" + string(paramNames[currFunc->funcParams.parametersT[z]]);
+            }
+        }
+
+        for (int i = 0; i < currFunc->callsFromDetailed.size(); ++i)
+            result += "|" + currFunc->callsFromDetailed[i].detailCallsFrom.first + "|" + to_string(currFunc->callsFromDetailed[i].detailCallsFrom.second);
+    }
+    return result;
+}
+
 // Find dead functions and fill callTo / callFrom information
 void findDeadFunctionsAndFillCalls(map<string, vector<FuncInfo*>> &allFuncInfo, map<string, vector<Messages>> &allMessages, bool noPrint)
 {

src/GraphCall/graph_calls_func.h

@@ -5,9 +5,8 @@
 #include <set>
 
 #include "graph_calls.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../ParallelizationRegions/ParRegions.h"
-#include "Utils/json.hpp"
 
 namespace Distribution
 {
@@ -24,6 +23,7 @@ int CreateCallGraphViz(const char *fileName, const std::map<std::string, std::ve
 int CreateFuncInfo(const char *fileName, const std::map<std::string, std::vector<FuncInfo*>> &funcByFile);
 std::string removeString(const std::string &toRemove, const std::string &inStr);
 FuncInfo* isUserFunctionInProject(const std::string &func);
+std::string convertToString(const FuncInfo *currFunc);
 void findDeadFunctionsAndFillCalls(std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo, std::map<std::string, std::vector<Messages>> &allMessages, bool noPrint = false);
 void createLinksBetweenFormalAndActualParams(std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo, std::map<DIST::Array*, std::set<DIST::Array*>> &arrayLinksByFuncCalls,
                                              const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>> &declaredArrays, 
@@ -53,6 +53,5 @@ void findContainsFunctions(SgStatement *st, std::vector<SgStatement*> &found, co
 void correctNameIfContains(SgStatement* call, SgExpression* exCall, std::string& name, const std::vector<SgStatement*>& containsFunctions, const std::string& prefix);
 int countPerfectLoopNest(SgStatement* st);
 void setInlineAttributeToCalls(const std::map<std::string, FuncInfo*>& allFunctions, const std::map<std::string, std::set<std::pair<std::string, int>>>& inDataChains, const std::map<std::string, std::vector<SgStatement*>>& hiddenData);
-nlohmann::json convertToJson(const std::map<std::string, std::vector<FuncInfo*>>& funcsByFile);
 #endif
 

src/GraphLoop/graph_loops.cpp

@@ -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 "../DirectiveProcessing/directive_parser.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "VectorAssignToLoop/array_assign_to_loop.h"
+#include "../GraphCall/graph_calls_func.h"
+#include "../Transformations/array_assign_to_loop.h"
 
 using std::vector;
 using std::map;
@@ -40,8 +40,6 @@ using std::string;
 using std::wstring;
 using std::pair;
 
-using json = nlohmann::json;
-
 #define DEBUG 0
 static inline void insertLabels(SgExpression *lb, map<int, vector<int>> &gotoLabels, const int line)
 {
@@ -520,7 +518,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 +697,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 +775,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();
@@ -925,7 +918,7 @@ void* LoopGraph::getRealStat(const char* file) const
 }
 
 extern int PASSES_DONE[EMPTY_PASS];
-static int getLoopState(const LoopGraph* currLoop)
+static void printToBuffer(const LoopGraph *currLoop, const int childSize, char buf[512])
 {
     int loopState = 0; // 0 - unknown, 1 - good, 2 - bad
     if (PASSES_DONE[CREATE_TEMPLATE_LINKS] ||
@@ -941,92 +934,49 @@ static int getLoopState(const LoopGraph* currLoop)
         if (currLoop->hasLimitsToParallel())
             loopState = 2;
     }
-
-    return loopState;
+    sprintf(buf, "#%d#%d#%d#%d#%d#%d#%d#%d",
+        currLoop->lineNum, currLoop->lineNumAfterLoop, currLoop->perfectLoop, currLoop->hasGoto, currLoop->hasPrints, childSize, loopState, 
+        currLoop->hasNonRectangularBounds);
 }
 
-static json convertToJson(const LoopGraph* currLoop)
+static int calculateNormalChildSize(const LoopGraph *currLoop)
 {
-    json loop;
+    int count = 0;
+    for (auto &elem : currLoop->children)
+        count += (elem->lineNum > 0) ? 1 : 0;
+    return count;
+}
 
+void convertToString(const LoopGraph *currLoop, string &result)
+{
     if (currLoop && currLoop->lineNum > 0)
     {
-        loop["file"] = currLoop->fileName;
-        loop["line"] = currLoop->lineNum;
-        loop["lineNumAfterLoop"] = currLoop->lineNumAfterLoop;
-        loop["perfectLoop"] = currLoop->perfectLoop;
-        loop["loopState"] = getLoopState(currLoop);
-        loop["hasNonRectangularBounds"] = (int)currLoop->hasNonRectangularBounds;
+        char buf[512];
+        result += "#" + std::to_string(currLoop->calls.size());
+        for (int i = 0; i < currLoop->calls.size(); ++i)
+            result += "#" + currLoop->calls[i].first + "#" + std::to_string(currLoop->calls[i].second);
+        printToBuffer(currLoop, calculateNormalChildSize(currLoop), buf);
+        result += string(buf);
 
-        json calls = json::array();
-        for (auto& [func, line] : currLoop->calls) 
-        {
-            json call;
-            call["line"] = line;
-            call["funcName"] = func;
+        result += "#" + std::to_string(currLoop->linesOfExternalGoTo.size());
+        for (int i = 0; i < currLoop->linesOfExternalGoTo.size(); ++i)
+            result += "#" + std::to_string(currLoop->linesOfExternalGoTo[i]);
 
-            calls.push_back(call);
-        }
-        loop["funcCalls"] = calls;
+        result += "#" + std::to_string(currLoop->linesOfInternalGoTo.size());
+        for (int i = 0; i < currLoop->linesOfInternalGoTo.size(); ++i)
+            result += "#" + std::to_string(currLoop->linesOfInternalGoTo[i]);
 
-        json e_gotos = json::array();
-        for (auto& line : currLoop->linesOfExternalGoTo)
-            e_gotos.push_back(line);
-        loop["extGotos"] = e_gotos;
+        result += "#" + std::to_string(currLoop->linesOfIO.size());
+        for (auto& i : currLoop->linesOfIO)
+            result += "#" + std::to_string(i);
 
-        json i_gotos = json::array();
-        for (auto& line : currLoop->linesOfInternalGoTo)
-            i_gotos.push_back(line);
-        loop["intGotos"] = i_gotos;
+        result += "#" + std::to_string(currLoop->linesOfStop.size());
+        for (auto& i : currLoop->linesOfStop)
+            result += "#" + std::to_string(i);
 
-        json ios = json::array();
-        for (auto& line : currLoop->linesOfIO)
-            ios.push_back(line);
-        loop["ios"] = ios;
-
-        json stops = json::array();
-        for (auto& line : currLoop->linesOfStop)
-            stops.push_back(line);
-        loop["stops"] = stops;
-
-        json children = json::array();
-        for (const auto& ch : currLoop->children) 
-        {
-            auto conv = convertToJson(ch);
-            if (!conv.empty())
-                children.push_back(conv);
-        }
-        loop["children"] = children;
+        for (int i = 0; i < (int)currLoop->children.size(); ++i)
+            convertToString(currLoop->children[i], result);
     }
-    return loop;
-}
-
-json convertToJson(const map<string, vector<LoopGraph*>>& loopsByFileMap)
-{
-    json loopsByFile = json::array();
-
-    for (auto& byFile : loopsByFileMap)
-    {
-        json loop;
-        const string& file = byFile.first;
-
-        json loops_array = json::array();
-        for (auto& loop : byFile.second)
-        {
-            auto conv = convertToJson(loop);
-            if (!conv.empty())
-                loops_array.push_back(conv);
-        }
-
-        loop["file"] = file;
-        loop["loops"] = loops_array;
-
-        loopsByFile.push_back(loop);
-    }
-    
-    json allLoops;
-    allLoops["allLoops"] = loopsByFile;
-    return allLoops;
 }
 
 void createMapLoopGraph(const vector<LoopGraph*> &loops, map<int, LoopGraph*> &mapGraph)

src/GraphLoop/graph_loops.h

@@ -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;
     
@@ -535,6 +497,7 @@ void processLoopInformationForFunction(std::map<LoopGraph*, std::map<DIST::Array
 void addToDistributionGraph(const std::map<LoopGraph*, std::map<DIST::Array*, ArrayInfo*>>& loopInfo, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
 void selectFreeLoopsForParallelization(const std::vector<LoopGraph*>& loops, const std::string& funcName, bool isDistribute, const std::vector<ParallelRegion*>& regions, std::vector<Messages>& messagesForFile);
 
+void convertToString(const LoopGraph* currLoop, std::string& result);
 int printLoopGraph(const char* fileName, const std::map<std::string, std::vector<LoopGraph*>>& loopGraph, bool withRegs = false);
 void checkCountOfIter(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, std::map<std::string, std::vector<Messages>>& SPF_messages);
 

src/GraphLoop/graph_loops_base.cpp

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

src/GraphLoop/graph_loops_func.h

@@ -2,10 +2,8 @@
 
 #include <vector>
 #include <map>
-#include <string>
 #include "graph_loops.h"
 #include "../Distribution/DvmhDirective.h"
-#include "Utils/json.hpp"
 
 struct SpfInterval;
 
@@ -19,6 +17,4 @@ bool checkRegionEntries(SgStatement *begin, SgStatement *end, const std::map<std
 bool recSymbolFind(SgExpression *ex, const std::string &symb, const int var);
 void completeFillOfArrayUsageBetweenProc(const std::map<std::string, std::vector<LoopGraph*>>& loopGraph, const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
 bool detectMpiCalls(SgProject* proj, std::map<std::string, std::vector<Messages>>& SPF_messages);
-int calculateLoopIters(SgExpression* start, SgExpression* end, SgExpression* step, std::tuple<int, int, int>& result);
-
-nlohmann::json convertToJson(const std::map<std::string, std::vector<LoopGraph*>>& loopsByFile);
+int calculateLoopIters(SgExpression* start, SgExpression* end, SgExpression* step, std::tuple<int, int, int>& result);

src/Inliner/inliner.cpp

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

src/LoopAnalyzer/allocations_prepoc.cpp

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

src/LoopAnalyzer/dep_analyzer.cpp

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

src/LoopAnalyzer/loop_analyzer.cpp

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

src/LoopAnalyzer/loop_analyzer.h

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

src/ParallelizationRegions/ParRegions.cpp

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

src/ParallelizationRegions/ParRegions.h

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

src/ParallelizationRegions/ParRegions_func.h

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

src/ParallelizationRegions/expand_extract_reg.cpp

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

src/ParallelizationRegions/expand_extract_reg.h

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

src/ParallelizationRegions/resolve_par_reg_conflicts.cpp

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

src/ParallelizationRegions/resolve_par_reg_conflicts.h

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

src/Predictor/PredictScheme.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -14,15 +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 "../CFGraph/CFGraph.h"
 
 #include "json.hpp"
 
@@ -208,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();
@@ -432,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();
@@ -449,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;
 
@@ -508,6 +501,8 @@ static void parallelDir(const map<DIST::Array*, int>& byPos, SgExpression* spec,
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
     auto cfg = buildCFGforCurrentFunc(func, SAPFOR::CFG_Settings(true, false, false, true, false, false, true), commonBlocks, allFuncInfo);
+    if (cfg.size() != 1)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
     //TODO IP analysis
         
     unsigned countOfAccess = 0;
@@ -594,9 +589,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;
@@ -604,10 +596,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
                 {
@@ -626,8 +615,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();
                         }
                     }
@@ -639,9 +627,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;

src/Predictor/PredictScheme.h

@@ -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,32 +27,28 @@ 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;
     }
 };
 

src/PrivateAnalyzer/private_analyzer.cpp

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

src/PrivateAnalyzer/private_analyzer.h

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

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -1,155 +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& [fileName, loops] : loopGraph)
-    {
-        SgFile::switchToFile(fileName);
-        for (const auto& loop : loops)
-        {
-            SgStatement* search_func = loop->loop->GetOriginal();
-
-            while (search_func && (!isSgProgHedrStmt(search_func)))
-                search_func = search_func->controlParent();
-
-            for (const auto& [funcInfo, blocks]: FullIR)
-            {   
-                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
-                {
-                    Region* loopRegion = new Region(loop, blocks);
-                    if (loopRegion->getBasickBlocks().size() <= 1)
-                    {
-                        delete(loopRegion);
-                        continue;
-                    }
-                    SolveDataFlow(loopRegion);
-                    result[loop] = loopRegion->array_priv;
-                    delete(loopRegion);
-                }
-            }
-        }
-    }
-    return result;
-}

src/PrivateAnalyzer/private_arrays_search.h

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

src/PrivateAnalyzer/range_structures.cpp

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

src/PrivateAnalyzer/range_structures.h

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

src/PrivateAnalyzer/region.cpp

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

src/PrivateAnalyzer/region.h

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

src/ProjectManipulation/ConvertFiles.cpp

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