swap operators in AST

Use more complex algorythm for building new order of statements
update in new order
2025-06-02 08:28:49 +03:00 · 2025-06-02 08:28:49 +03:00 · 2025-06-02 08:28:49 +03:00 · 2025-06-02 08:28:49 +03:00 · 2025-06-02 08:28:49 +03:00 · 2025-06-02 08:28:49 +03:00
166 changed files with 2430 additions and 3588 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -78,3 +78,4 @@ Sapfor/Sapc++/x64/

 Sapfor/out/
 Sapfor/_bin/*
+_bin/*
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,7 +12,6 @@ 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/)
@@ -28,14 +27,6 @@ set(libpred_sources projects/libpredictor/src/)
 set(libpred_include projects/libpredictor/include/)

 include_directories(src)
-include_directories(src/Utils)
-include_directories(src/SgUtils)
-include_directories(src/Distribution)
-include_directories(src/GraphCall)
-include_directories(src/GraphLoop)
-include_directories(src/Transformations/ExpressionSubstitution)
-include_directories(src/Transformations)
-
 #Sage lib includes
 include_directories(${fdvm_include})
 include_directories(${sage_include_1})
@@ -163,47 +154,42 @@ 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(SWAP_OPERATORS src/SwapOperators/swapOperators.cpp
+        src/SwapOperators/swapOperators.h)

 set(TRANSFORMS 
        ${TR_DEAD_CODE}
@@ -223,15 +209,10 @@ set(TRANSFORMS
        ${TR_CONV}
        ${TR_PRIV_DEL}
        ${TR_IMPLICIT_NONE}
-        ${TR_REPLACE_ARRAYS_IN_IO}
-        ${TR_EXPR_TRANSFORM}
-        ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS})
+        ${TR_REPLACE_ARRAYS_IN_IO})
        
 set(CFG src/CFGraph/IR.cpp
        src/CFGraph/IR.h
-        src/CFGraph/IR_domTree.cpp
-        src/CFGraph/IR_domTree.h
        src/CFGraph/CFGraph.cpp
        src/CFGraph/CFGraph.h
        src/CFGraph/RD_subst.cpp
@@ -310,6 +291,10 @@ set(DYNA src/DynamicAnalysis/createParallelRegions.cpp
        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
        src/GraphCall/graph_calls_base.cpp
@@ -320,20 +305,25 @@ set(GR_LOOP src/GraphLoop/graph_loops_base.cpp
        src/GraphLoop/graph_loops.h
        src/GraphLoop/graph_loops_func.h)
        
+set(INLINER src/Inliner/inliner.cpp
+        src/Inliner/inliner.h)
+        
 set(LOOP_ANALYZER  src/LoopAnalyzer/allocations_prepoc.cpp
        src/LoopAnalyzer/dep_analyzer.cpp        
        src/LoopAnalyzer/loop_analyzer.cpp
        src/LoopAnalyzer/loop_analyzer.h)

+set(RENAME_SYMBOLS  src/RenameSymbols/rename_symbols.cpp
+                    src/RenameSymbols/rename_symbols.h)
+
+
 set(MAIN src/Sapfor.cpp
        src/Sapfor.h
        src/SapforData.h
        src/Utils/PassManager.h)

 set(PREDICTOR src/Predictor/PredictScheme.cpp
-              src/Predictor/PredictScheme.h
-              src/Predictor/PredictSchemeWithLibrary.cpp
-              src/Predictor/PredictSchemeWithLibrary.h)
+              src/Predictor/PredictScheme.h)
              
 set(LIBPREDICTOR  ${libpred_sources}/cluster.cpp
                  ${libpred_sources}/predictor.cpp
@@ -416,9 +406,12 @@ set(SOURCE_EXE
    ${DISTR}
    ${DVMH_REG}
    ${DYNA}
+    ${EXPR_TRANSFORM}
    ${GR_CALL}
    ${GR_LOOP}
+    ${INLINER}
    ${LOOP_ANALYZER}
+    ${RENAME_SYMBOLS}
    ${TRANSFORMS}
    ${PARALLEL_REG}
    ${PRIV}
@@ -435,14 +428,15 @@ set(SOURCE_EXE
    ${ZLIB}
    ${GR_LAYOUT}
    ${PR_PARAM}
-    ${PROJ_MAN})
+    ${PROJ_MAN}
+    ${SWAP_OPERATORS})

 add_executable(Sapfor_F ${SOURCE_EXE})
 source_group (CFGraph FILES ${CFG})
 source_group (CFGraph\\DataFlow FILES ${DATA_FLOW})

 source_group (Transformations\\DeadCodeRemoving FILES ${TR_DEAD_CODE})
-source_group (Transformations\\ExpressionSubstitution FILES ${TR_EXPR_TRANSFORM})
+source_group (Transformations\\ExpressionSubstitution FILES ${EXPR_TRANSFORM})
 source_group (Transformations\\CheckPoints FILES ${TR_CP})
 source_group (Transformations\\LoopEndDoConverter FILES ${TR_ENDDO_LOOP})
 source_group (Transformations\\LoopNesting FILES ${TR_LOOP_NEST})
@@ -450,13 +444,13 @@ source_group (Transformations\\LoopCombining FILES ${TR_LOOP_COMB})
 source_group (Transformations\\LoopSplitting FILES ${TR_LOOP_SPLIT})
 source_group (Transformations\\LoopUnrolling FILES ${TR_LOOP_UNROLL})
 source_group (Transformations\\FunctionDuplication FILES ${TR_FUNC_DUP})
-source_group (Transformations\\FunctionInlining FILES ${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})
@@ -479,6 +473,7 @@ source_group (Utils FILES ${UTILS})
 source_group (VerificationCode FILES ${VERIF})       
 source_group (ProjectParameters FILES ${PR_PARAM})
 source_group (ProjectManipulation FILES ${PROJ_MAN})
+source_group (SwapOperators FILES ${SWAP_OPERATORS})

 source_group (VisualizerCalls FILES ${VS_CALLS})
 source_group (VisualizerCalls\\GraphLayout FILES ${GR_LAYOUT})
@@ -498,9 +493,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)
--- a/projects/dvm
+++ b/projects/dvm
--- a/projects/libpredictor
+++ b/projects/libpredictor
--- a/src/CFGraph/CFGraph.cpp
+++ b/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"
@@ -1149,22 +1149,9 @@ map<FuncInfo*, vector<BBlock*>> buildCFG(const map<string, CommonBlock*>& common
    if (settings.withRD)
        buildReachingDefs(result, settings);

-    if (settings.withDominators)
-    {
-        auto t = high_resolution_clock::now();
-        for (auto& [func, bblocks] : result)
-            SAPFOR::buildDominatorTree(bblocks);
-
-        auto msec = duration_cast<milliseconds>(high_resolution_clock::now() - t).count();
-        __spf_print(1, "    dominator build time is %.3f sec\n", msec / 1000.);
-    }
-
    if (SgFile::switchToFile(oldFile) == -1)
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

-    for (auto& [func, blocks] : result)
-        removedUnreachableBlocks(blocks);
-
    return result;
 }

@@ -1240,48 +1227,3 @@ map<FuncInfo*, vector<SAPFOR::BasicBlock*>>

    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());
-}
--- a/src/CFGraph/CFGraph.h
+++ b/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,7 +34,6 @@ namespace SAPFOR
        bool addLive(const std::map<SAPFOR::Argument*, std::vector<SAPFOR::BasicBlock*>>& to_add, bool in);
        std::map<SAPFOR::Argument*, std::vector<SAPFOR::BasicBlock*>> getLive(bool in) const;
        bool removeLive(SAPFOR::Argument* to_remove, bool in);
-
    public:
        BasicBlock() { num = lastNumBlock++; }
        BasicBlock(IR_Block* item);
@@ -44,7 +42,6 @@ namespace SAPFOR
        void addInstruction(IR_Block* item);
        void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
        void addNext(BasicBlock* next_) { next.push_back(next_); }
-        void setDom(BasicBlock* dom) { directDominator = dom; }

        int removePrev(BasicBlock* removed);
        int removeNext(BasicBlock* removed);
@@ -72,10 +69,6 @@ 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 +105,13 @@ namespace SAPFOR
        bool withDVM = false;
        bool withCallsInBlocks = false; // separate each F_CALL to own BasicBlock
        bool withCallFrom = true;
-        bool withDominators = true;

        explicit CFG_Settings(int) { }

        explicit CFG_Settings(bool atLeastOneIterInLoop = false, bool withRD = true, bool withRegisters = false, 
-                              bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, 
-                              bool withCallFrom = true, bool withDominators = true) :
+                              bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, bool withCallFrom = true) :
            atLeastOneIterInLoop(atLeastOneIterInLoop), withRD(withRD), withRegisters(withRegisters), withDVM(withDVM), withSPF(withSPF), 
-            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom), withDominators(withDominators)
+            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom)
        { }
    };
 }
@@ -156,5 +147,3 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
    }
    cfg.clear();
 }
-
-void removedUnreachableBlocks(std::vector<SAPFOR::BasicBlock*>& blocks);
--- a/src/CFGraph/DataFlow/backward_data_flow.h
+++ b/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"

--- a/src/CFGraph/DataFlow/backward_data_flow_impl.h
+++ b/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"
--- a/src/CFGraph/DataFlow/data_flow.h
+++ b/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"

--- a/src/CFGraph/DataFlow/data_flow_impl.h
+++ b/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"

--- a/src/CFGraph/IR.cpp
+++ b/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"
--- a/src/CFGraph/IR.h
+++ b/src/CFGraph/IR.h
@@ -6,7 +6,7 @@
 #include <algorithm>

 #include "CFGraph.h"
-#include "CommonBlock.h"
+#include "../Utils/CommonBlock.h"

 namespace SAPFOR
 {
--- a/src/CFGraph/IR_domTree.cpp
+++ b/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);
-    }
-}
--- a/src/CFGraph/IR_domTree.h
+++ b/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);
-}
--- a/src/CFGraph/RD_subst.cpp
+++ b/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
--- a/src/CFGraph/RD_subst.h
+++ b/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"
--- a/src/CFGraph/live_variable_analysis.h
+++ b/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
--- a/src/CFGraph/private_variables_analysis.cpp
+++ b/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);
--- a/src/CFGraph/private_variables_analysis.h
+++ b/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>
--- a/src/CreateInterTree/CreateInterTree.cpp
+++ b/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;
--- a/src/CreateInterTree/CreateInterTree.h
+++ b/src/CreateInterTree/CreateInterTree.h
@@ -8,7 +8,7 @@

 #include "dvm.h"

-#include "graph_loops_func.h"
+#include "../GraphLoop/graph_loops_func.h"

 struct SpfInterval
 {
--- a/src/DirectiveProcessing/directive_analyzer.cpp
+++ b/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;
--- a/src/DirectiveProcessing/directive_analyzer.h
+++ b/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);
--- a/src/DirectiveProcessing/directive_creator.cpp
+++ b/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

--- a/src/DirectiveProcessing/directive_creator.h
+++ b/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, 
--- a/src/DirectiveProcessing/directive_creator_base.cpp
+++ b/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)));
        }
@@ -122,7 +122,6 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
                if (found == false)
                {
                    directive->shadowRenew.push_back(make_pair(key, vector<pair<int, int>>()));
-                    directive->shadowRenewCorner.push_back(false);

                    const DIST::Array *arrayRef = read;
                    for (int i = 0; i < arrayRef->GetDimSize(); ++i)
@@ -809,7 +808,7 @@ void createParallelDirectives(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*
                            for (int i = 0; i < mainArrayOfLoop->GetDimSize(); ++i)
                            {
                                if (i == dimPos)
-                                    parDir->on2.push_back(make_pair(currLoop->loopSymbol(), mainAccess));
+                                    parDir->on2.push_back(make_pair(currLoop->loopSymbol, mainAccess));
                                else
                                    parDir->on2.push_back(make_pair("*", make_pair(0, 0)));
                            }
@@ -1101,7 +1100,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
    LoopGraph* tmpL = loop;
    for (int z = 0; z < nested; ++z)
    {
-        deprecateToMatch.insert(tmpL->loopSymbol());
+        deprecateToMatch.insert(tmpL->loopSymbol);
        if (tmpL->children.size())
            tmpL = tmpL->children[0];
        else if (z != nested - 1)
@@ -1114,7 +1113,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
    tmpL = loop->parent;
    while (tmpL)
    {
-        if (tmpL->isWhile()) // TODO: need to add all inductive variables!
+        if (!tmpL->isFor) // TODO: need to add all inductive variables!
        {
            SgWhileStmt* dow = isSgWhileStmt(tmpL->loop->GetOriginal());
            if (dow->conditional())
@@ -1125,7 +1124,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
            }
        }
        else
-            deprecateToMatch.insert(tmpL->loopSymbol());
+            deprecateToMatch.insert(tmpL->loopSymbol);
        tmpL = tmpL->parent;
    }

--- a/src/DirectiveProcessing/directive_omp_parser.cpp
+++ b/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;
--- a/src/DirectiveProcessing/directive_omp_parser.h
+++ b/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
--- a/src/DirectiveProcessing/directive_parser.cpp
+++ b/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;
--- a/src/DirectiveProcessing/directive_parser.h
+++ b/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
--- a/src/DirectiveProcessing/insert_directive.cpp
+++ b/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"
--- a/src/DirectiveProcessing/remote_access.cpp
+++ b/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;
--- a/src/DirectiveProcessing/remote_access_base.cpp
+++ b/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"

--- a/src/DirectiveProcessing/shadow.cpp
+++ b/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"
--- a/src/DirectiveProcessing/spf_directive_preproc.cpp
+++ b/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"

--- a/src/Distribution/Array.cpp
+++ b/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;

--- a/src/Distribution/Array.h
+++ b/src/Distribution/Array.h
@@ -7,9 +7,9 @@
 #include <algorithm>
 #include <climits>
 #include "DvmhDirectiveBase.h"
-#include "utils.h"
-#include "errors.h"
-#include "json.hpp"
+#include "../Utils/utils.h"
+#include "../Utils/errors.h"
+#include "../Utils/json.hpp"

 class Symbol;
 class Expression;
--- a/src/Distribution/ArrayAnalysis.cpp
+++ b/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
--- a/src/Distribution/CreateDistributionDirs.cpp
+++ b/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;
--- a/src/Distribution/CreateDistributionDirs.h
+++ b/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, 
--- a/src/Distribution/Cycle.cpp
+++ b/src/Distribution/Cycle.cpp
@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"

 #include <vector>
 #include <algorithm>
--- a/src/Distribution/Cycle.h
+++ b/src/Distribution/Cycle.h
@@ -3,7 +3,7 @@
 #include <vector>
 #include <algorithm>

-#include "types.h"
+#include "../Utils/types.h"

 namespace Distribution
 {
--- a/src/Distribution/Distribution.cpp
+++ b/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
        {
--- a/src/Distribution/DvmhDirective.cpp
+++ b/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"

@@ -346,7 +346,7 @@ static vector<SgExpression*>
                            {
                                needToAdd = true;
                                dim_found = true;
-                                subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol()));
+                                subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol));
                                break;
                            }
                        }
@@ -857,11 +857,6 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
                shadowRenewShifts[i].resize(shadowRenew[i].second.size());
        }

-        if (shadowRenewCorner.size() == 0)
-        {
-            shadowRenewCorner.resize(shadowRenew.size(), false);
-        }
-
        string shadowAdd = ", SHADOW_RENEW(";
        int inserted = 0;

@@ -904,10 +899,7 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
                for (auto& elem : genSubscripts(shadowRenew[i1].second, shadowRenewShifts[i1]))
                    newArrayRef->addSubscript(*elem);

-                bool needCornerFlag = shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop);
-                shadowRenewCorner[i1] = needCornerFlag;
-
-                if (needCornerFlag)
+                if (shadowRenew[i1].second.size() > 1 && needCorner(shadowArray, shiftsByAccess, loop))
                {
                    SgExpression* tmp = new SgExpression(ARRAY_OP, newArrayRef, NULL, NULL);
                    p->setLhs(*tmp);
--- a/src/Distribution/DvmhDirective.h
+++ b/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;

@@ -102,7 +102,6 @@ public:
    //                               origin_Name   uniqName                   bounds
    std::vector<std::pair<std::pair<std::string, std::string>, std::vector<std::pair<int, int>>>> shadowRenew;
    std::vector<std::vector<std::pair<int, int>>> shadowRenewShifts;
-    std::vector<bool> shadowRenewCorner;

    //                               origin_Name   uniqName                   bounds
    std::vector<std::pair<std::pair<std::string, std::string>, std::vector<std::pair<int, int>>>> across;
@@ -126,7 +125,6 @@ public:
        privates = copyFrom.privates;
        shadowRenew = copyFrom.shadowRenew;
        shadowRenewShifts = copyFrom.shadowRenewShifts;
-        shadowRenewCorner = copyFrom.shadowRenewCorner;
        across = copyFrom.across;
        acrossShifts = copyFrom.acrossShifts;
        remoteAccess = copyFrom.remoteAccess;
@@ -153,7 +151,6 @@ public:
        on.clear();
        privates.clear();
        shadowRenew.clear();
-        shadowRenewCorner.clear();
        across.clear();
        acrossShifts.clear();
        reduction.clear();
--- a/src/Distribution/DvmhDirectiveBase.cpp
+++ b/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,11 @@
 #include "../Distribution/Array.h"
 #include "../Distribution/Arrays.h"
 #include "../Distribution/GraphCSR.h"
-#include "errors.h"
-#include "utils.h"
-#include "json.hpp"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../Utils/json.hpp"

-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"

 using std::vector;
 using std::tuple;
--- a/src/Distribution/DvmhDirectiveBase.h
+++ b/src/Distribution/DvmhDirectiveBase.h
@@ -3,7 +3,7 @@
 #include <vector>
 #include <string>

-#include "json.hpp"
+#include "../Utils/json.hpp"

 typedef enum lang : int { LANG_C, LANG_F } language;
 typedef enum dist : int { BLOCK, NONE } distType;
--- a/src/Distribution/DvmhDirective_func.h
+++ b/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);
--- a/src/Distribution/GraphCSR.cpp
+++ b/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)
        {
--- a/src/Distribution/GraphCSR.h
+++ b/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;

--- a/src/DvmhRegions/DvmhRegion.h
+++ b/src/DvmhRegions/DvmhRegion.h
@@ -1,6 +1,6 @@
 #pragma once

-#include "graph_loops_func.h"
+#include "../GraphLoop/graph_loops_func.h"

 #include <string>

--- a/src/DvmhRegions/DvmhRegionInserter.cpp
+++ b/src/DvmhRegions/DvmhRegionInserter.cpp
@@ -11,9 +11,9 @@
 #include "DvmhRegionInserter.h"
 #include "DvmhRegions/RegionsMerger.h"
 #include "../VerificationCode/verifications.h"
+#include "../Transformations/function_purifying.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "FunctionPurifying/function_purifying.h"

 using namespace std;

@@ -794,6 +794,154 @@ 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());
+
+    bool need = (func->symbol()->identifier() == string("bl182"));
+
+    //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)
+            {
+                toExtract.push_back(st);
+                st = st->lexNext();
+            }
+            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)
+            {
+                toExtract.push_back(st);
+                st = st->lexNext();
+                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 +1172,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)
@@ -1298,9 +1446,6 @@ 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 +1457,7 @@ static set<DIST::Array*>
                    }
                    else
                    {
-                        declStat = getFuncStat(declStat, { BLOCK_DATA });
+                        declStat = getFuncStat(declStat);
                        if (declStat != main)
                        {
                            declStat = NULL;
--- a/src/DvmhRegions/DvmhRegionInserter.h
+++ b/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"

--- a/src/DvmhRegions/LoopChecker.h
+++ b/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>
--- a/src/DvmhRegions/ReadWriteAnalyzer.h
+++ b/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>
--- a/src/DvmhRegions/TypedSymbol.h
+++ b/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 };
--- a/src/DynamicAnalysis/createParallelRegions.cpp
+++ b/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>
--- a/src/DynamicAnalysis/createParallelRegions.h
+++ b/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>
--- a/src/DynamicAnalysis/gCov_parser.cpp
+++ b/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;

--- a/src/DynamicAnalysis/gCov_parser_func.h
+++ b/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"

--- a/src/DynamicAnalysis/gcov_info.cpp
+++ b/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"

--- a/src/DynamicAnalysis/gcov_info.h
+++ b/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
--- a/src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp
+++ b/src/Transformations/ExpressionSubstitution/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"
--- a/src/Transformations/ExpressionSubstitution/expr_transform.cpp
+++ b/src/Transformations/ExpressionSubstitution/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());
--- a/src/Transformations/ExpressionSubstitution/expr_transform.h
+++ b/src/Transformations/ExpressionSubstitution/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"

--- a/src/GraphCall/graph_calls.cpp
+++ b/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,14 @@
 #include "dvm.h"
 #include "graph_calls_func.h"

-#include "CFGraph/CFGraph.h"
-#include "graph_loops_func.h"
+#include "../CFGraph/CFGraph.h"
+#include "../GraphLoop/graph_loops_func.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "SgUtils.h"
-#include "json.hpp"
+#include "../Utils/SgUtils.h"
+#include "../Utils/json.hpp"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../VerificationCode/verifications.h"

@@ -779,20 +779,6 @@ static void checkSpecList(SgExpression *spec, FuncInfo* currF, const map<string,
    }
 }

-static void checkInTypeDescription(SgExpression *ex, FuncInfo* currF, const map<string, int>& parNames)
-{
-    if (ex)
-    {
-        if (ex->variant() == ARRAY_REF)
-            fillIn(currF, ex->lhs(), parNames, false);
-        else
-        {
-            checkInTypeDescription(ex->lhs(), currF, parNames);
-            checkInTypeDescription(ex->rhs(), currF, parNames);
-        }
-    }
-}
-
 static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, const set<SgStatement*>& activeOps)
 {
    if (currF->funcParams.countOfPars == 0)
@@ -813,12 +799,7 @@ 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())
--- a/src/GraphCall/graph_calls.h
+++ b/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",
--- a/src/GraphCall/graph_calls_base.cpp
+++ b/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;
--- a/src/GraphCall/graph_calls_func.h
+++ b/src/GraphCall/graph_calls_func.h
@@ -5,7 +5,7 @@
 #include <set>

 #include "graph_calls.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../ParallelizationRegions/ParRegions.h"
 #include "Utils/json.hpp"

--- a/src/GraphLoop/graph_loops.cpp
+++ b/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 "../Utils/json.hpp"

 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"

-#include "VectorAssignToLoop/array_assign_to_loop.h"
+#include "../Transformations/array_assign_to_loop.h"

 using std::vector;
 using std::map;
@@ -520,7 +520,7 @@ static void findArrayRef(SgExpression *exp, bool isWirte, set<DIST::Array*>& use
 {
    if (exp)
    {
-        if (isArrayRef(exp))
+        if (exp->variant() == ARRAY_REF)
        {
            DIST::Array *arrayRef = NULL;
            SgSymbol *symbS = OriginalSymbol(exp->symbol());
@@ -699,12 +699,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
                newLoop->hasPrints = hasThisIds(st, newLoop->linesOfIO, { WRITE_STAT, READ_STAT, OPEN_STAT, CLOSE_STAT, PRINT_STAT } ); // FORMAT_STAT
                newLoop->hasStops = hasThisIds(st, newLoop->linesOfStop, { STOP_STAT, PAUSE_NODE });
                newLoop->hasDvmIntervals = hasThisIds(st, tmpLines, { DVM_INTERVAL_DIR, DVM_ENDINTERVAL_DIR, DVM_EXIT_INTERVAL_DIR });
-                if (isSgForStmt(st))
-                    newLoop->loopType = LoopType::FOR;
-                else if (isSgWhileStmt(st))
-                    newLoop->loopType = LoopType::WHILE;
-                else 
-                    newLoop->loopType = LoopType::NONE;
+                newLoop->isFor = isSgForStmt(st) ? true : false;
                newLoop->inCanonicalFrom = isSgForStmt(st) ? true : false;
                newLoop->hasSubstringRefs = hasSubstringRef(st);

@@ -782,7 +777,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
                    newLoop->startEndExpr = std::make_pair((Expression*)NULL, (Expression*)NULL);

                newLoop->loop = new Statement(st);
-                newLoop->loopSymbols.addMainVar(st->symbol() ? st->symbol()->identifier() : "unknown");
+                newLoop->loopSymbol = st->symbol() ? st->symbol()->identifier() : "unknown";
                findArrayRefs(newLoop);

                SgStatement *lexPrev = st->lexPrev();
--- a/src/GraphLoop/graph_loops.h
+++ b/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;
    
--- a/src/GraphLoop/graph_loops_base.cpp
+++ b/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", 
--- a/src/Transformations/FunctionInlining/inliner.cpp
+++ b/src/Transformations/FunctionInlining/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");
--- a/src/Transformations/FunctionInlining/inliner.h
+++ b/src/Transformations/FunctionInlining/inliner.h
--- a/src/LoopAnalyzer/allocations_prepoc.cpp
+++ b/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;
--- a/src/LoopAnalyzer/dep_analyzer.cpp
+++ b/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"
--- a/src/LoopAnalyzer/loop_analyzer.cpp
+++ b/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"обработка функции '") + wstring(fName.begin(), fName.end()) + L"'");
+        else
+            sendMessage_2lvl(wstring(L"обработка модуля '") + 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;
@@ -2178,8 +2188,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"обработка цикла ") + 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 +2212,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 +2340,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)
        {
--- a/src/LoopAnalyzer/loop_analyzer.h
+++ b/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"

--- a/src/ParallelizationRegions/ParRegions.cpp
+++ b/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;
--- a/src/ParallelizationRegions/ParRegions.h
+++ b/src/ParallelizationRegions/ParRegions.h
@@ -9,12 +9,12 @@
 #include "../Distribution/DvmhDirective.h"
 #include "../Distribution/GraphCSR.h"
 #include "../Distribution/Distribution.h"
-#include "AstWrapper.h"
+#include "../Utils/AstWrapper.h"

-#include "json.hpp"
+#include "../Utils/json.hpp"

 #if __SPF
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #endif

 struct ParallelRegionLines
--- a/src/ParallelizationRegions/ParRegions_func.h
+++ b/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);
--- a/src/ParallelizationRegions/expand_extract_reg.cpp
+++ b/src/ParallelizationRegions/expand_extract_reg.cpp
@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"

 #include <map>
 #include <string>
--- a/src/ParallelizationRegions/expand_extract_reg.h
+++ b/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);
--- a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
+++ b/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;
--- a/src/ParallelizationRegions/resolve_par_reg_conflicts.h
+++ b/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);
--- a/src/Predictor/PredictScheme.cpp
+++ b/src/Predictor/PredictScheme.cpp
@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"

 #include <cstdio>
 #include <cstdlib>
@@ -16,14 +16,13 @@
 #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 "../LoopAnalyzer/loop_analyzer.h"
-#include "CFGraph/CFGraph.h"
-#include "../Utils/utils.h"
+#include "../CFGraph/CFGraph.h"

 #include "json.hpp"

@@ -37,109 +36,6 @@ using std::tuple;

 using json = nlohmann::json;

-void runPredictSchemeOld(SgProject &project,
-                      vector<vector<size_t>> &topologies,
-                      vector<ParallelRegion*> &parallelRegions,
-                      map<string, vector<LoopGraph*>> &loopGraph,
-                      map<string, vector<SpfInterval*>> &intervals,
-                      map<string, vector<Messages>> &SPF_messages)
-{
-        int maxSizeDist = 0;
-        for (int z = 0; z < parallelRegions.size(); ++z)
-        {
-            const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
-            const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
-
-            auto &tmp = dataDirectives.distrRules;
-            vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
-            for (int z1 = 0; z1 < currentVariant.size(); ++z1)
-                currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
-
-            for (auto &elem : currentVar)
-            {
-                DIST::Array *array = elem.first;
-                const DistrVariant *var = elem.second;
-
-                int countBlock = 0;
-                for (int z = 0; z < var->distRule.size(); ++z)
-                    if (var->distRule[z] == dist::BLOCK)
-                        ++countBlock;
-                maxSizeDist = std::max(maxSizeDist, countBlock);
-            }
-        }
-                        
-        SpfInterval *mainIterval = getMainInterval(&project, intervals, SPF_messages);
-        topologies.clear();
-        if (maxSizeDist)
-        {
-            const int procNum = 8;
-            //TODO:
-            //topologies = getTopologies(procNum, maxSizeDist);
-            throw -10;
-
-            const int countOfTop = topologies.size();
-            if (countOfTop < 0)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            for (auto &inter : intervals)
-                initTimeForIntervalTree(countOfTop, inter.second);
-
-            for (int z = 0; z < parallelRegions.size(); ++z)
-            {
-                const DataDirective &dataDirectives = parallelRegions[z]->GetDataDir();
-                const vector<int> &currentVariant = parallelRegions[z]->GetCurrentVariant();
-                DIST::Arrays<int> &allArrays = parallelRegions[z]->GetAllArraysToModify();
-
-                auto &tmp = dataDirectives.distrRules;
-                vector<pair<DIST::Array*, const DistrVariant*>> currentVar;
-                for (int z1 = 0; z1 < currentVariant.size(); ++z1)
-                    currentVar.push_back(std::make_pair(tmp[z1].first, &tmp[z1].second[currentVariant[z1]]));
-
-                map<LoopGraph*, ParallelDirective*> parallelDirs;
-                vector<std::tuple<DIST::Array*, vector<long>, pair<string, int>>> allSingleRemotes;
-                for (int i = project.numberOfFiles() - 1; i >= 0; --i)
-                {
-                    SgFile *file = &(project.file(i));
-                    auto fountInfo = findAllDirectives(file, getObjectForFileFromMap(file->filename(), loopGraph), parallelRegions[z]->GetId());
-                    parallelDirs.insert(fountInfo.begin(), fountInfo.end());
-
-                    auto fountRem = findAllSingleRemotes(file, parallelRegions[z]->GetId(), parallelRegions);
-                    allSingleRemotes.insert(allSingleRemotes.end(), fountRem.begin(), fountRem.end());
-                }
-                //TODO!
-                //int err = predictScheme(parallelRegions[z], currentVar, allArrays.GetArrays(), parallelDirs, intervals, SPF_messages, allSingleRemotes, maxSizeDist, procNum);                
-                /*if (err != 0)
-                    internalExit = err;*/
-            }
-
-            vector<SpfInterval*> tmp = { mainIterval };
-            aggregatePredictedTimes(tmp);
-
-            int idx = 0;
-            int best = -1;
-            double bestSpeedUp = 0;
-            for (auto &top : topologies)
-            {
-                string outStr = "";
-                for (auto &elem : top)
-                    outStr += std::to_string(elem) + " ";
-                double currS = mainIterval->exec_time / mainIterval->predictedTimes[idx];
-                __spf_print(1, "%d: speed up %f for top. %s\n", idx, currS, outStr.c_str());
-                
-                if (best == -1 || bestSpeedUp < currS)
-                {
-                    bestSpeedUp = currS;
-                    best = idx;
-                }
-                ++idx;
-            }
-            __spf_print(1, "best topology %d with speed up %f\n", best, bestSpeedUp);
-        }
-        else
-            for (auto &inter : intervals)
-                initTimeForIntervalTree(0, inter.second);
-}
-
 static void fillParallel(SgExpression *exp, ParallelStats &parStats, int &totalScoreComm)
 {
    if (exp)
--- a/src/Predictor/PredictScheme.h
+++ b/src/Predictor/PredictScheme.h
@@ -1,8 +1,8 @@
 #pragma once
 #include <vector>
 #include "dvm.h"
-#include "graph_calls.h"
-#include "json.hpp"
+#include "../GraphCall/graph_calls.h"
+#include "../Utils/json.hpp"

 class ParallelStats
 {
@@ -61,5 +61,3 @@ void processFileToPredict(SgFile *file, PredictorStats &predictorCounts);

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

--- a/src/PrivateAnalyzer/private_analyzer.h
+++ b/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);
--- a/src/PrivateAnalyzer/private_arrays_search.cpp
+++ b/src/PrivateAnalyzer/private_arrays_search.cpp
@@ -9,13 +9,13 @@
 #include "private_arrays_search.h"
 #include "range_structures.h"
 #include "region.h"
-#include "SgUtils.h"
-#include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../Utils/SgUtils.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../CFGraph/CFGraph.h"

 using namespace std;

-static void Collapse(Region* region)
+void Collapse(Region* region)
 {
    if (region->getBasickBlocks().empty())
        return;
--- a/src/PrivateAnalyzer/private_arrays_search.h
+++ b/src/PrivateAnalyzer/private_arrays_search.h
@@ -5,8 +5,10 @@
 #include <unordered_set>

 #include "range_structures.h"
-#include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "region.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../CFGraph/CFGraph.h"

+void Collapse(Region* region);
 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);
--- a/src/PrivateAnalyzer/range_structures.cpp
+++ b/src/PrivateAnalyzer/range_structures.cpp
@@ -2,8 +2,8 @@
 #include <map>
 #include <unordered_set>
 #include <string>
+#include <numeric>

-#include "utils.h"
 #include "range_structures.h"

 using namespace std;
--- a/src/PrivateAnalyzer/region.cpp
+++ b/src/PrivateAnalyzer/region.cpp
@@ -8,7 +8,7 @@
 #include "range_structures.h"
 #include "region.h"

-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"

 using namespace std;

@@ -51,7 +51,7 @@ pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForL
 }

 static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
-    string index = loop->loopSymbol();
+    string index = loop->loopSymbol;
    loopForIndex[index] = loop;

    for (const auto& childLoop : loop->children)
@@ -146,7 +146,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
            {
                auto var = index_vars.back();
                int currentVarPos = refPos.back();
-                pair<int, int> currentCoefs = coefsForDims.back();
+                pair currentCoefs = coefsForDims.back();
                ArrayDimension current_dim;
                if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
                    current_dim = { stoul(var->getValue()), 1, 1 };
--- a/src/PrivateAnalyzer/region.h
+++ b/src/PrivateAnalyzer/region.h
@@ -5,8 +5,8 @@
 #include <unordered_set>
 #include <string>

-#include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../CFGraph/CFGraph.h"

 class Region : public SAPFOR::BasicBlock {
 public:
--- a/src/ProjectManipulation/ConvertFiles.cpp
+++ b/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;
--- a/src/ProjectManipulation/FileInfo.cpp
+++ b/src/ProjectManipulation/FileInfo.cpp
@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"

 #include <cstdio>
 #include <cstdlib>
@@ -7,8 +7,8 @@
 #include <vector>

 #include "FileInfo.h"
-#include "utils.h"
-#include "errors.h"
+#include "../Utils/utils.h"
+#include "../Utils/errors.h"

 using namespace std;

--- a/src/ProjectManipulation/ParseFiles.cpp
+++ b/src/ProjectManipulation/ParseFiles.cpp
@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"

 #include <cstdio>
 #include <cstdlib>
@@ -22,8 +22,8 @@
 #include <thread>
 #include <stack>

-#include "errors.h"
-#include "SgUtils.h"
+#include "../Utils/errors.h"
+#include "../Utils/SgUtils.h"
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"

@@ -34,7 +34,6 @@
 using namespace std;

 extern "C" int parse_file(int argc, char* argv[], char* proj_name);
-extern const char* VISUALIZER_DATA_PATH;

 static void findModuleDeclInProject(const string& name, const vector<string>& files, map<string, string>& modDecls)
 {
@@ -294,8 +293,11 @@ static vector<string> parseList(vector<FileInfo>& listOfProject,
            }
        }

-        sendMessage_2lvl(3, file);
-
+#ifdef _WIN32
+        sendMessage_2lvl(L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> '" + to_wstring(file) + L"'");
+#else 
+        sendMessage_2lvl(L" processing file '" + to_wstring(file) + L"'");
+#endif        
        StdCapture::Init();
        string errorMessage = "";
        try
@@ -441,12 +443,20 @@ static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string
        if (errors[z] == "")
        {
            FILE* ferr = fopen(file.errPath.c_str(), "w");
-            if (ferr)
+            if (!ferr)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
            fclose(ferr);
            ++z;
            continue;
        }

+        FILE* ferr = fopen(file.errPath.c_str(), "w");
+        FILE* fout = fopen(file.outPath.c_str(), "w");
+        if (!ferr)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+        if (!fout)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
        string errS = "", outS = "";
        vector<string> splited;
        splitString(errors[z], '\n', splited);
@@ -465,22 +475,13 @@ static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string
            }
        }

-
-        FILE* ferr = fopen(file.errPath.c_str(), "w");
-        FILE* fout = fopen(file.outPath.c_str(), "w");
-        if (ferr)
-        {
-            fprintf(ferr, "%s", errS.c_str());
-            fclose(ferr);
-        }
-
-        if (fout)
-        {
        fprintf(fout, "%s", outS.c_str());
-            fclose(fout);
-        }
+        fprintf(ferr, "%s", errS.c_str());

        fflush(NULL);
+
+        fclose(fout);
+        fclose(ferr);
        ++z;
    }

@@ -575,8 +576,11 @@ static void parseFiles(int& iters, vector<string>& errors, vector<FileInfo>& lis

    do
    {
-        sendMessage_1lvl(0, iters + 1);
-
+#ifdef _WIN32
+        sendMessage_1lvl(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + std::to_wstring((iters + 1)) + L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
+#else
+        sendMessage_1lvl(L"running " + std::to_wstring((iters + 1)) + L" iteration of syntax analisys");
+#endif
        errors = parseList(listOfProject, iters != 0, parseForInlining, mapModuleDeps, moduleDelc, modDirectOrder, isFromConsole);
        changed = createMapOfUse(errors, listOfProject, mapModuleDeps);
        if (iters != 0)
@@ -709,7 +713,7 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars

    if (pathSplit.size() < 2)
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-    if (pathSplit[pathSplit.size() - 2] != VISUALIZER_DATA_PATH)
+    if (pathSplit[pathSplit.size() - 2] != "visualiser_data")
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
    string fullPath = "";
    for (int z = 0; z < pathSplit.size() - 2; ++z)
@@ -741,9 +745,9 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
        else
            fileNameFixed = (toAdd.substr(0, 2) == "./") ? toAdd.substr(2) : toAdd;

-        const string optPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".opt";
-        const string errPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".err";
-        const string outPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".out";
+        const string optPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".opt";
+        const string errPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".err";
+        const string outPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".out";

        const string fileText = readFileToStr(toAdd);

@@ -805,8 +809,6 @@ void parseFiles(int argc, char** argv)
        printf("  run parsing for inlining\n");

    int rethrow = parseFiles(errors, listOfProject, filesCompilationOrder, isInline, true);
-    int errCount = dumpErrors(listOfProject, errors, messages);
-
    if (rethrow == 0)
    {
        for (auto& err : errors)
@@ -836,7 +838,5 @@ void parseFiles(int argc, char** argv)
    }
    else
        printf("Parsing was completed with errors, throw code %d, errors count %d\n", rethrow, code);
-
-    dumpMessages(false, messages, VISUALIZER_DATA_PATH);
    exit(0);
 }
--- a/src/ProjectManipulation/PerfAnalyzer.cpp
+++ b/src/ProjectManipulation/PerfAnalyzer.cpp
@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"

 #include <cstdio>
 #include <cstdlib>
@@ -6,8 +6,8 @@
 #include <string>
 #include <vector>

-#include "errors.h"
-#include "SgUtils.h"
+#include "../Utils/errors.h"
+#include "../Utils/SgUtils.h"

 #include "StdCapture.h"

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Egor Mayorov	18b2666c0e	swap operators in AST	2025-06-02 08:28:49 +03:00
Egor Mayorov	edc19e4e9b	Use more complex algorythm for building new order of statements	2025-06-02 08:28:49 +03:00
Egor Mayorov	6a50d83b33	update in new order	2025-06-02 08:28:49 +03:00
Egor Mayorov	caf4d8da0d	biulding new order	2025-06-02 08:28:49 +03:00
Egor Mayorov	adbd9c64e8	some loop analysis done	2025-06-02 08:28:49 +03:00
Egor Mayorov	703f21405d	Add _bin to gitignore	2025-06-02 08:28:49 +03:00
Egor Mayorov	9fe2f0fe25	Some actions simplify analyzing IR	2025-06-02 08:28:49 +03:00
Egor Mayorov	2edc10f7dc	Pass with output file added	2025-06-02 08:28:48 +03:00
Egor Mayorov	7f131d577e	change pass deps	2025-06-02 08:28:48 +03:00
Egor Mayorov	3ab6eb50f5	New pass	2025-06-02 08:28:48 +03:00