REMOVE_DIST_ARRAYS_FROM_IO: remove debug prints

CMakeLists.txt

@@ -487,7 +487,7 @@ source_group (Predictor\\Library FILES ${LIBPREDICTOR})
 source_group (Parser FILES ${PARSER})
 source_group (PPPA\\PPPA FILES ${PPPA})
 source_group (PPPA\\ZLib FILES ${ZLIB})
-
+   
 if (MSVC_IDE)   
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /Zc:__cplusplus")
 else()
@@ -496,9 +496,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} -O2")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
-    endif()
 endif()
 
 add_subdirectory(projects/Fdvm)

src/DirectiveProcessing/shadow.cpp

@@ -15,7 +15,7 @@
 #include "SgUtils.h"
 #include "expr_transform.h"
 
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 #include "shadow.h"
 #include "dvm.h"

src/Distribution/ArrayAnalysis.cpp

@@ -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())
+                else if (privates.find(symb->identifier()) != privates.end() || isarrayInModule)
-                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
-                else if (isArrayInModule || privates.find(symb->identifier()) != privates.end())
                 {
                     //check in module
                     if (itNew->second.first->GetLocation().first == DIST::l_MODULE)
@@ -276,6 +274,8 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
                     else
                         itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                 }
+                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
+                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
                 else if (isSgConstantSymb(symb) || inDataStat)
                     itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                 else

src/GraphCall/graph_calls.cpp

@@ -14,7 +14,7 @@
 #include "dvm.h"
 #include "graph_calls_func.h"
 
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 #include "graph_loops_func.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "SgUtils.h"

src/Predictor/PredictScheme.cpp

@@ -22,7 +22,7 @@
 #include "graph_loops_func.h"
 #include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 #include "json.hpp"
 

src/PrivateAnalyzer/private_analyzer.cpp

@@ -12,7 +12,7 @@
 #include "graph_calls.h"
 #include "private_analyzer.h"
 #include "dvm.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 using std::vector;
 

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -11,11 +11,11 @@
 #include "region.h"
 #include "SgUtils.h"
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 using namespace std;
 
-static void Collapse(Region* region)
+void Collapse(Region* region)
 {
     if (region->getBasickBlocks().empty())
         return;
@@ -124,30 +124,16 @@ static void SolveDataFlow(Region* DFG)
 map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
-    for (const auto& [fileName, loops] : loopGraph)
+    for (const auto& [loopName, loops] : loopGraph)
     {
-        SgFile::switchToFile(fileName);
         for (const auto& loop : loops)
         {
-            SgStatement* search_func = loop->loop->GetOriginal();
-
-            while (search_func && (!isSgProgHedrStmt(search_func)))
-                search_func = search_func->controlParent();
-
             for (const auto& [funcInfo, blocks]: FullIR)
             {   
-                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
+                Region* loopRegion = new Region(loop, blocks);
-                {
+                SolveDataFlow(loopRegion);
-                    Region* loopRegion = new Region(loop, blocks);
+                result[loop] = loopRegion->array_priv;
-                    if (loopRegion->getBasickBlocks().size() <= 1)
+                delete(loopRegion);
-                    {
-                        delete(loopRegion);
-                        continue;
-                    }
-                    SolveDataFlow(loopRegion);
-                    result[loop] = loopRegion->array_priv;
-                    delete(loopRegion);
-                }
             }
         }
     }

src/PrivateAnalyzer/private_arrays_search.h

@@ -5,8 +5,10 @@
 #include <unordered_set>
 
 #include "range_structures.h"
+#include "region.h"
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.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);

src/PrivateAnalyzer/region.h

@@ -6,7 +6,7 @@
 #include <string>
 
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 class Region : public SAPFOR::BasicBlock {
 public:

src/ProjectManipulation/ConvertFiles.cpp

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

src/Sapfor.cpp

@@ -1019,6 +1019,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                 if(func->funcPointer->variant() != ENTRY_STAT)
                     countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks);
         }
+        else if (curr_regime == FIND_PRIVATE_ARRAYS)
+            FindPrivateArrays(loopGraph, fullIR);
         else if (curr_regime == TEST_PASS)
         {
         //test pass
@@ -1914,8 +1916,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
     }
     else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
         transformAssumedSizeParameters(allFuncInfo);
-    else if (curr_regime == FIND_PRIVATE_ARRAYS) 
-        auto result = FindPrivateArrays(loopGraph, fullIR);
 
     const float elapsed = duration_cast<milliseconds>(high_resolution_clock::now() - timeForPass).count() / 1000.;
     const float elapsedGlobal = duration_cast<milliseconds>(high_resolution_clock::now() - globalTime).count() / 1000.;

src/Transformations/DeadCodeRemoving/dead_code.cpp

@@ -6,7 +6,7 @@
 #include <set>
 #include <algorithm>
 
-#include "../CFGraph/CFGraph.h"
+#include "../../CFGraph/CFGraph.h"
 
 using std::map;
 using std::string;

src/Transformations/DeadCodeRemoving/dead_code.h

@@ -4,10 +4,10 @@
 #include<vector>
 
 #include "SgUtils.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
-#include "CFGraph/live_variable_analysis.h"
+#include "../CFGraph/live_variable_analysis.h"
-#include "CFGraph/DataFlow/data_flow.h"
+#include "../CFGraph/DataFlow/data_flow.h"
-#include "CFGraph/DataFlow/backward_data_flow.h"
+#include "../CFGraph/DataFlow/backward_data_flow.h"
 
 int removeDeadCode(SgStatement* func, 
                    const std::map<std::string, std::vector<FuncInfo*>>&allFuncs,

src/Transformations/ExpressionSubstitution/expr_transform.cpp

@@ -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)
+        if (ret->variant() == UNARY_ADD_OP)
-            toCalc = toCalc->lhs();
+            toCalc = ret->lhs();
-
+        if (ret->variant() == MINUS_OP)
-        if (toCalc->variant() == MINUS_OP)
         {
-            toCalc = toCalc->lhs();
+            toCalc = ret->lhs();
             sign = -1;
         }
-
         if (toCalc->isInteger())
         {
             exp = new SgValueExp(sign * toCalc->valueInteger());

src/Transformations/FunctionPurifying/function_purifying.cpp

@@ -103,7 +103,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
             if (line <= 0)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            intr->setlineNumber(getNextNegativeLineNumber());
+            intr->setlineNumber(line);
             st->insertStmtBefore(*intr, *func->funcPointer);
         }
         else
@@ -525,7 +525,7 @@ static void insertIntents(set<string>& identificators, SgStatement* header, cons
     if (args.size())
     {
         SgIntentStmt* intent = new SgIntentStmt(*makeExprList(args), *attr);
-        intent->setlineNumber(getNextNegativeLineNumber());
+        intent->setlineNumber(lastDecl->lineNumber());
 
         lastDecl->insertStmtAfter(*intent, (header == lastDecl) ? *header : *lastDecl->controlParent());
     }

src/Transformations/LoopSplitting/loops_splitter.cpp

@@ -6,7 +6,7 @@
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "expr_transform.h"
 #include "errors.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"

src/Transformations/PrivateArrayRemoving/private_removing.h

@@ -2,8 +2,8 @@
 
 #include "dvm.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
-#include "CFGraph/RD_subst.h"
+#include "../CFGraph/RD_subst.h"
 
 // Regime defines the regime of private removing
 enum class Regime { DEFLT = 1, REGULAR_INDEXES };

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -17,17 +17,27 @@ using std::pair;
 
 #define DEBUG_TRACE 0
 
-static bool hasArrayRef(SgExpression* ex)
+static bool findAlloatableKeyword(SgExpression* exp)
 {
-    if (ex)
+    if (exp)
-        return isArrayRef(ex) || hasArrayRef(ex->lhs()) || hasArrayRef(ex->rhs());
+    {
+        if (exp->variant() == ALLOCATABLE_OP)
+            return true;
+
+        return findAlloatableKeyword(exp->lhs()) || findAlloatableKeyword(exp->rhs());
+    }
 
     return false;
 }
 
-static inline bool isArrayDeclaration(SgStatement* st)
+
+static bool checkDynamicArray(DIST::Array *array)
 {
-    return isSgDeclarationStatement(st) || isSgVarListDeclStmt(st) || isSgNestedVarListDeclStmt(st);
+    for (const auto &bounds : array->GetSizes())
+        if (bounds.first == -1 || bounds.second == -1)
+            return true;
+
+    return false;
 }
 
 static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
@@ -49,110 +59,27 @@ static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
     return NULL;
 }
 
-static bool switchToDeclarationFile(DIST::Array* array_p, 
+static bool checkAssumedSize(SgStatement *st, const string &arrayName, const string &currentFile)
-                                    pair<string, int>& decl_place, 
-                                    const string &current_file_name,
-                                    FuncInfo *current_func)
 {
-    if (!array_p)
-        return false;
-
-    // try to find declaration from current function
-    for (const auto &p : array_p->GetDeclInfo())
-    {
-        if (p.first == current_file_name && 
-            current_func->linesNum.first <= p.second && 
-            p.second <= current_func->linesNum.second)
-        {
-            decl_place = p;
-            return true;
-        }
-    }
-
-    for (const auto &p : array_p->GetDeclInfo())
-    {
-        if (SgFile::switchToFile(p.first) != -1)
-        {
-            decl_place = p;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static bool checkAssumedShape(SgStatement* decl, const string& array_name)
-{
-    SgExpression* list = decl->expr(0);
-    SgExpression* dim_list = NULL;
-
-    while (list)
-    {
-        auto *arr_ref = list->lhs();
-
-        if (arr_ref && 
-            arr_ref->symbol() && 
-            arr_ref->symbol()->identifier() && 
-            arr_ref->symbol()->identifier() == array_name)
-        {
-            dim_list = arr_ref->lhs();
-            break;
-        }
-
-        list = list->rhs();
-    }
-
-    if (!dim_list)
-    {
-        auto *dim_expr = findExprWithVariant(decl->expr(2), DIMENSION_OP);
-        if (dim_expr)
-            dim_list = dim_expr->lhs();
-    }
-
-    while (dim_list)
-    {
-        auto *lhs = dim_list->lhs();
-
-        if (lhs && lhs->variant() == DDOT && (!lhs->lhs() || !lhs->rhs()))
-            return true;
-
-        dim_list = dim_list->rhs();
-    }
-
-    return false;
-}
-
-static bool checkAssumedSize(const string &array_name, DIST::Array* array_p, const string &current_file_name, FuncInfo *current_func)
-{
-    if (!array_p)
-        return true; // raise true to prevent array from copying
-
     bool found = false;
 
-    pair<string, int> decl_place;
+    DIST::Array* array_p = getArrayFromDeclarated(st, arrayName);
 
-    if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func))
+    auto place = *array_p->GetDeclInfo().begin();
-        return true;
+    auto decl_file_name = place.first;
 
-    auto *st = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
+    SgFile::switchToFile(decl_file_name);
-    checkNull(st, convertFileName(__FILE__).c_str(), __LINE__);
+
-    
+    SgExpression* list = st->expr(0);
-    SgExpression* list = st->expr(0);    
     while (list)
     {
-        if (list->lhs() && 
+        if (list->lhs() && list->lhs()->symbol()->identifier() == arrayName)
-            list->lhs()->symbol() && 
-            list->lhs()->symbol()->identifier() && 
-            list->lhs()->symbol()->identifier() == array_name
-        )
         {
             if(findExprWithVariant(list->lhs(), STAR_RANGE))
                 found = true;
 
             break;
         }
-
-        list = list->rhs();
     }
 
     if (!found)
@@ -162,8 +89,7 @@ static bool checkAssumedSize(const string &array_name, DIST::Array* array_p, con
             found = true;
     }
 
-    if (SgFile::switchToFile(current_file_name) == -1)
+    SgFile::switchToFile(currentFile);
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__); // can't switch back to file with array usage
 
     return found;
 }
@@ -180,15 +106,12 @@ static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
     }
 }
 
-static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, 
+static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, SgStatement* stat, const string& current_file)
-                                        SgStatement* stat, 
-                                        const string& current_file_name,
-                                        FuncInfo *current_func)
 {
     auto var = stat->variant();
 
     if (var != READ_STAT && var != PRINT_STAT && var != WRITE_STAT)
-        return false;
+        return;
 
     // check if such IO allowed in dvm: 
     // list should consist only of single array and format string should be *
@@ -198,26 +121,22 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     SgExpression* ioList = stat->expr(0);
 
     if (!ioList)
-        return false;
+        return;
 
     if (ioList->variant() != EXPR_LIST)
-        return false;
+        return;
 
     if (ioList->rhs() == NULL)
     {
         SgExpression* arg = ioList->lhs();
         if (!arg)
-            return false;
+            return;
 
-        if (hasArrayRef(arg))
+        if (!isArrayRef(arg))
-        {
+            return;
-            if (isArrayRef(arg) && arg->lhs())
+
-                need_replace = true;
+        if (arg->lhs())
-        }
+            need_replace = true;
-        else
-        {
-            return false;
-        }
     }
     else
     {
@@ -237,6 +156,7 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
             if (fmt->rhs()->variant() != KEYWORD_VAL || fmt->rhs()->sunparse() != "*")
                 need_replace = true;
 
+
             break;
         }
         case READ_STAT:
@@ -269,7 +189,6 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                     spec = spec->rhs();
                 }
             }
-            break;
         }
         default:
             break;
@@ -277,9 +196,7 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     }
 
     if (!need_replace)
-        return false;
+        return;
-
-    bool ret = false;
 
     set<SgSymbol*> found_arrays;
 
@@ -292,19 +209,15 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
         DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(by_symb), array_name);
         if (array_p && 
             array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && 
-            !checkAssumedSize(array_name, array_p, current_file_name, current_func))
+            !checkAssumedSize(declaratedInStmt(by_symb), array_name, current_file) &&
+            arrays[by_symb].insert(stat).second
+        )
         {
-            auto inserted = arrays[by_symb].insert(stat).second;
+            __spf_print(DEBUG_TRACE, "[%d]: add array %s\n", stat->lineNumber(), array_p->GetName().c_str());
-
-            if (inserted)
-                __spf_print(DEBUG_TRACE, "[%d]: add array %s %p\n", stat->lineNumber(), array_p->GetName().c_str(), by_symb);
-
-            ret = true;
         }
     }
 
     __spf_print(DEBUG_TRACE, "[replace]\n");
-    return ret;
 }
 
 static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgExpression* exp, bool& has_read, bool& has_write, bool from_read, bool from_write)
@@ -398,7 +311,6 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb,
         auto* parent = start_is_scope ? start : start->controlParent();
         if (parent && parent->lastNodeOfStmt() == start)
             parent = parent->controlParent();
-        checkNull(parent, convertFileName(__FILE__).c_str(), __LINE__);
 
         start->insertStmtAfter(*assign, *parent);
     }
@@ -430,7 +342,8 @@ static void replaceArrayInFragment(SgSymbol* replace_symb,
                                    SgSymbol* replace_by, 
                                    SgStatement* start, 
                                    SgStatement* last, 
-                                   FuncInfo *func_info)
+                                   FuncInfo *func_info, 
+                                   const string& filename)
 {
     while (start->lexNext() && (!isSgExecutableStatement(start->lexNext()) || start->lexNext()->variant() == ALLOCATE_STMT))
         start = start->lexNext();
@@ -522,16 +435,12 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
         STOP_STAT,
         STOP_NODE,
         EXIT_STMT,
-        EXIT_NODE,
+        EXIT_NODE
-        GOTO_NODE
     };
 
     if (border_stats.find(var) != border_stats.end())
         return true;
 
-    if (stat->hasLabel())
-        return true;
-
     if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
         return true;
 
@@ -544,9 +453,9 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
 }
 
 void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
-                                  const map<string, vector<FuncInfo*>>& allFuncInfo,
+    const map<string, vector<FuncInfo*>>& allFuncInfo,
-                                  map<string, vector<Messages>>& SPF_messages,
+    map<string, vector<Messages>>& SPF_messages,
-                                  map<string, map<int, set<string>>>& newDeclsToInclude)
+    map<string, map<int, set<string>>>& newDeclsToInclude)
 {
     map<SgSymbol*, SgSymbol*> created_copies;
     map<string, map<int, set<string>>> copied_syms;
@@ -555,23 +464,26 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
     {
         __spf_print(DEBUG_TRACE, "[%s]: enter region\n", region->GetName().c_str());
 
-        for (auto& lines_by_file : region->GetAllLinesToModify())
+        for (auto& linesByFile : region->GetAllLinesToModify())
         {
-            const auto& current_file_name = lines_by_file.first;
+            const auto& filename = linesByFile.first;
 
-            if (SgFile::switchToFile(current_file_name) == -1)
+            if (SgFile::switchToFile(filename) == -1)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            auto func_info_it = allFuncInfo.find(current_file_name);
+            auto func_info_it = allFuncInfo.find(filename);
             if (func_info_it == allFuncInfo.end())
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            auto *lbound_symb = new SgSymbol(FUNCTION_NAME, "lbound");
-            auto *ubound_symb = new SgSymbol(FUNCTION_NAME, "ubound");
-
-            for (auto& lines : lines_by_file.second)
             {
-                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", current_file_name.c_str(), lines.lines.first,
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                return;
+            }
+
+            auto *lbound_symb = new SgSymbol(PROCEDURE_NAME, "lbound");
+            auto *ubound_symb = new SgSymbol(PROCEDURE_NAME, "ubound");
+
+            for (auto& lines : linesByFile.second)
+            {
+                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", filename.c_str(), lines.lines.first,
                     lines.lines.second, lines.isImplicit());
 
                 SgStatement* curr_stmt, * end;
@@ -615,7 +527,10 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                         }
 
                         if (!current_func_info)
+                        {
                             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                            return;
+                        }    
 
                         curr_stmt = curr_stmt->lexNext();
                         while (curr_stmt && !isSgExecutableStatement(curr_stmt))
@@ -640,86 +555,90 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                 string array_name = string(array_to_copy->identifier());
                                 DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(array_to_copy), array_name);
 
-                                // at this point all considered arrays must have DIST::Array* references
+                                bool fromModule = (array_p->GetLocation().first == DIST::l_MODULE);
-                                if (!array_p)
+                                const string locationName = array_p->GetLocation().second;
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-                                // ... and be declared in switchable files (not in headers)
-                                pair<string, int> decl_place;
-                                if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func_info))
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
+                                auto place = *array_p->GetDeclInfo().begin();
+                                auto decl_file_name = place.first;
                                 string suffix = "_io_l";
 
-                                switch (array_p->GetLocation().first)
+                                if (fromModule)
+                                    suffix = "_io_m";
+
+                                pair<SgSymbol*, SgSymbol*> copied;
+                                copied.first = array_to_copy;
+
+                                if (SgFile::switchToFile(decl_file_name) == -1)
                                 {
-                                    case DIST::l_MODULE:
+                                    auto* func_stmt = curr_stmt->getScopeForDeclare();
-                                        suffix = "_io_m";
-                                        break;
-                                    case DIST::l_COMMON:
-                                        suffix = "_io_c";
-                                        break;
-                                }
-                                
-                                auto copied_symbol = copyArray(decl_place, 
-                                                               array_p, 
-                                                               lines_by_file.second, 
-                                                               suffix + to_string(region->GetId()), 
-                                                               decl_place.first, 
-                                                               newDeclsToInclude, 
-                                                               copied_syms);
-                            
-                                // original declaration statement
-                                auto *decl_stmt = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
 
-                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
+                                    SgStatement* insertPlace = NULL;
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                                    for (auto iterator = func_stmt->lexNext();
-
+                                        !isSgExecutableStatement(iterator) || isSPF_stat(iterator) &&
-                                auto dynamic_array = checkAssumedShape(decl_stmt, array_name);  
+                                        !(iterator->variant() == SPF_PARALLEL_REG_DIR || iterator->variant() == SPF_END_PARALLEL_REG_DIR);
-
+                                        iterator = iterator->lexNext())
-                                while (decl_stmt && !isSgExecutableStatement(decl_stmt))
-                                {
-                                    if (isArrayDeclaration(decl_stmt) &&
-                                        decl_stmt->expr(0) &&
-                                        decl_stmt->expr(0)->lhs() &&
-                                        decl_stmt->expr(0)->lhs()->symbol() == copied_symbol.second)
                                     {
-                                        break;
+                                        insertPlace = iterator;
                                     }
 
-                                    decl_stmt = decl_stmt->lexNext();
+                                    //NULL - no decl stats in function!
-                                }
+                                    if (!insertPlace)
-                                
+                                        insertPlace = func_stmt;
-                                // created declaration statement
-                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-                                // insert !$SPF ANALYSIS(PROCESS_PRIVATE(array)) directive before declaration statement
+                                    auto st = insertPlace->controlParent();
-                                
+                                    if (st->variant() == GLOBAL)
-                                string dir_str;
+                                        st = insertPlace;
-                                if (decl_stmt->comments())
+
+                                    auto& copied_symb = array_to_copy->copy();
+                                    copied.second = &copied_symb;
+
+                                    auto new_name = string(array_to_copy->identifier()) + "_io_c";
+                                    copied_symb.changeName(new_name.c_str());
+
+                                    auto stat = array_to_copy->makeVarDeclStmt();
+                                    auto res = CalculateInteger(stat->expr(0)->copyPtr());
+                                    res->lhs()->setSymbol(copied_symb);
+                                    stat->setExpression(0, res);
+
+                                    insertPlace->insertStmtAfter(*stat, *st);
+                                }
+                                else
                                 {
-                                    auto str_comment = string(decl_stmt->comments());
+                                    copied = copyArray(place, array_p, linesByFile.second, suffix + to_string(region->GetId()), decl_file_name, newDeclsToInclude, copied_syms);
-                                    if (str_comment.size() && str_comment.back() != '\n')
-                                        dir_str += "\n";
                                 }
 
-                                dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied_symbol.second->identifier()) + "))\n";
+                                SgStatement* decl = SgStatement::getStatementByFileAndLine(place.first, place.second);
-                                decl_stmt->addComment(dir_str.c_str());
-                            
-                                created_copies.insert({ array_to_copy, copied_symbol.second });
 
-                                // make array copy allocatable in case of assumed-shape array
+                                if (decl)
-                                if(dynamic_array)
+                                    decl = decl->lexNext();
+
+                                if (decl)
+                                {
+                                    string dir_str;
+                                    if (decl->comments())
+                                    {
+                                        string str_comment = string(decl->comments());
+                                        if (str_comment.size() && str_comment.back() != '\n')
+                                            dir_str += "\n";
+                                    }
+
+                                    dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied.second->identifier()) + "))\n";
+                                    decl->addComment(dir_str.c_str());
+                                }
+                                
+                                created_copies.insert({ array_to_copy, copied.second });
+
+                                // make array-copy allocatable in case of main array shape not constant
+                                if(checkDynamicArray(array_p))
                                 {
                                     // insert allocatable keyword in declaration
-                                    auto *kword_list = decl_stmt->expr(2);
+                                    auto *kword_list = decl->expr(2);
-                                    if (!findExprWithVariant(kword_list, ALLOCATABLE_OP))
+                                    if (!findAlloatableKeyword(kword_list))
                                     {
                                         if (!kword_list)
                                         {
                                             kword_list = new SgExprListExp();
-                                            decl_stmt->setExpression(2, *kword_list);
+                                            decl->setExpression(2, *kword_list);
                                         }
                                         
                                         while (kword_list->rhs())
@@ -734,30 +653,29 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                         kword_list->setLhs(new SgExpression(ALLOCATABLE_OP));
                                     }
 
-                                    // can't switch back to file with array usage
-                                    if (SgFile::switchToFile(current_file_name) == -1)
-                                        printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
-                                        
                                     // insert allocate(a_l(lbound(a, 1):ubound(a,1),...)) statement
-                                    SgStatement* allocate_stmt_place = NULL;
+                                    SgFile::switchToFile(filename);
+                                    SgStatement* insertPlace = NULL;
 
                                     auto* func_stmt = curr_stmt->getScopeForDeclare();
                                     for (auto iterator = func_stmt->lexNext();
-                                        iterator && !isSgExecutableStatement(iterator);
+                                        !isSgExecutableStatement(iterator) || isSPF_stat(iterator) &&
+                                        !(iterator->variant() == SPF_PARALLEL_REG_DIR || iterator->variant() == SPF_END_PARALLEL_REG_DIR);
                                         iterator = iterator->lexNext())
                                     {
-                                            allocate_stmt_place = iterator;
+                                            insertPlace = iterator;
                                     }
 
                                     //NULL - no decl stats in function!
-                                    if (!allocate_stmt_place)
+                                    if (!insertPlace)
-                                        allocate_stmt_place = func_stmt;
+                                        insertPlace = func_stmt;
 
-                                    auto *allocate_stmt_parent = allocate_stmt_place->controlParent();
+                                    auto st = insertPlace->controlParent();
-                                    if (allocate_stmt_parent->variant() == GLOBAL)
+                                    if (st->variant() == GLOBAL)
-                                        allocate_stmt_parent = allocate_stmt_place;
+                                        st = insertPlace;
                                     
-                                    auto *created_array_ref = new SgArrayRefExp(*copied_symbol.second);
+                                    auto *stat = new SgStatement(ALLOCATE_STMT);
+                                    auto *created_array_ref = new SgArrayRefExp(*copied.second);
 
                                     auto* dim_list = new SgExprListExp();
                                     created_array_ref->setLhs(dim_list);
@@ -790,10 +708,9 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                         }
                                     }
 
-                                    auto *allocate_stmt = new SgStatement(ALLOCATE_STMT);
+                                    stat->setExpression(0, created_array_ref);
-                                    allocate_stmt->setExpression(0, created_array_ref);
 
-                                    allocate_stmt_place->insertStmtAfter(*allocate_stmt, *allocate_stmt_parent);
+                                    insertPlace->insertStmtAfter(*stat, *st);
 
                                     // insert deallocate statemens before all returns
                                     auto *find_return_stmt = func_stmt;
@@ -811,7 +728,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                             auto *dealloc_stmt = new SgStatement(DEALLOCATE_STMT);
 
                                             dealloc_stmt->setExpression(0, new SgExprListExp());
-                                            dealloc_stmt->expr(0)->setLhs(new SgArrayRefExp(*copied_symbol.second));
+                                            dealloc_stmt->expr(0)->setLhs(new SgArrayRefExp(*copied.second));
 
                                             find_return_stmt->insertStmtAfter(*dealloc_stmt, *next->controlParent());
 
@@ -823,9 +740,9 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                     }
                                 }
 
-                                // can't switch back to file with array usage
+                                SgFile::switchToFile(filename);
-                                if (SgFile::switchToFile(current_file_name) == -1)
+                                
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
+
                             }
                         }
 
@@ -837,7 +754,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                             {
                                 auto it = created_copies.find(p.first);
                                 if (it != created_copies.end())
-                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, current_func_info);
+                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, current_func_info, filename);
                                 else
                                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                             }
@@ -857,17 +774,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                         }
                     }
 
-                    auto need_fix_io = populateDistributedIoArrays(need_replace, curr_stmt, current_file_name, current_func_info);
+                    populateDistributedIoArrays(need_replace, curr_stmt, filename);
-                    
-                    // incorrect IO statement with label
-                    // move label to dummy statement and insert copy statements between dummy statement and IO
-                    if (need_fix_io && curr_stmt->hasLabel())
-                    {
-                        moveLabelBefore(curr_stmt);
-                        if (last_io_bound == curr_stmt) // always true
-                            last_io_bound = curr_stmt->lexPrev();
-                    }
-
                     curr_stmt = curr_stmt->lexNext();
                 }
             }

src/Utils/utils.cpp

@@ -390,15 +390,32 @@ void clearGlobalBuffer() { globalOutputBuffer = ""; }
 const string& getGlobalBuffer() { return globalOutputBuffer; }
 
 set<short*> allocated;
+set<int*> allocatedInt;
+static void convertGlobalBuffer(short *&result, int *&resultSize)
+{
+    const unsigned len = (unsigned)globalOutputBuffer.size();
+    result = new short[len + 1];
+    allocated.insert(result);
+
+    result[len] = '\0';
+    for (unsigned i = 0; i < len; ++i)
+        result[i] = globalOutputBuffer[i];
+
+    resultSize = new int[1];
+    resultSize[0] = (int)len;
+}
+
 extern map<string, vector<Messages>> SPF_messages; //file ->messages
 void clearGlobalMessagesBuffer()
 {
     //clear allocated memory
     for (auto& elem : allocated)
-        delete []elem;    
+        delete[]elem;
+    for (auto& elem : allocatedInt)
+        delete[]elem;
     allocated.clear();
-    
+    allocatedInt.clear();
-    
+
     SPF_messages.clear();
 }
 
@@ -434,7 +451,7 @@ static map<string, vector<Messages>> removeCopies(map<string, vector<Messages>>
     return out;
 }
 
-static string convertGlobalMessagesBuffer()
+static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
 {
     auto copySPF_messages = removeCopies(SPF_messages);
     for (auto &byFile : copySPF_messages)
@@ -472,13 +489,21 @@ static string convertGlobalMessagesBuffer()
     json all;
     all["allMessages"] = allMessages;
 
-    return all.dump();    
+    const string str = all.dump();    
+    const unsigned len = (unsigned)str.size();
+
+    copyStringToShort(result, str);
+    allocated.insert(result);
+
+    resultSize = new int[1];
+    resultSize[0] = (int)len;
 }
 
-void convertBuffers(string &resultM, string &result)
+
+void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize)
 {
-    resultM = convertGlobalMessagesBuffer();
+    convertGlobalMessagesBuffer(resultM, resultSizeM);
-    result = getGlobalBuffer();
+    convertGlobalBuffer(result, resultSize);
 }
 
 bool isSPF_comment(const string &bufStr)

src/Utils/utils.h

@@ -33,7 +33,7 @@ void addToGlobalBufferAndPrint(const std::string &toPrint);
 void clearGlobalBuffer();
 const std::string& getGlobalBuffer();
 std::wstring to_wstring(const std::string);
-void convertBuffers(std::string& resultM, std::string& result);
+void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize);
 void clearGlobalMessagesBuffer();
 std::string renameInclude(const std::string& inc);
 void copyIncludes(const std::set<std::string> &allIncludeFiles, const std::map<std::string, std::map<int, std::set<std::string>>> &commentsToInclude, const std::map<std::string, std::map<int, std::set<std::string>>>& newCopyDeclToIncl, const char *folderName, bool keepSpfDirs, bool isFreeStyle, bool isRename, int removeDirs = 0);

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2447"
+#define VERSION_SPF "2440"