added TRANSFORM_ASSUMED_SIZE_PARAMETERS pass, fixed shared memory parallelization

src/Sapfor.cpp

@@ -1914,6 +1914,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         calculateStatsForPredictor(allFuncInfo, gCovInfo);
         parseDvmDirForPredictor(declaredArrays, commonBlocks, allFuncInfo, gCovInfo);
     }
+    else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
+        transformAssumedSizeParameters(allFuncInfo);
 
     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.;
@@ -2149,6 +2151,8 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
         runAnalysis(*project, REMOVE_COPIES, false);
         runAnalysis(*project, SWAP_LOOPS, false);
 
+        runPass(TRANSFORM_ASSUMED_SIZE_PARAMETERS, proj_name, folderName);
+
         if (folderName || consoleMode)
             runAnalysis(*project, UNPARSE_FILE, true, additionalName.c_str(), folderName);
     }

src/Sapfor.h

@@ -185,6 +185,8 @@ enum passes {
 
     FIND_PRIVATE_ARRAYS,
 
+    TRANSFORM_ASSUMED_SIZE_PARAMETERS,
+
     TEST_PASS,
     EMPTY_PASS
 };
@@ -371,6 +373,8 @@ static void setPassValues()
     passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
     passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";
 
+    passNames[TRANSFORM_ASSUMED_SIZE_PARAMETERS] = "TRANSFORM_ASSUMED_SIZE_PARAMETERS";
+
     passNames[TEST_PASS] = "TEST_PASS";
 }
 

src/Transformations/FunctionPurifying/function_purifying.cpp

@@ -136,33 +136,41 @@ void createInterfacesForOutCalls(FuncInfo* func)
     }
 }
 
-static bool changeIfHasStarRange(SgExpression* arrayDecl, bool doReplace = false)
+static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, vector<SgSymbol*>& parNames)
 {
     SgExpression* list = arrayDecl->lhs();
-    bool has = doReplace;
+    string varN = arrayDecl->symbol()->identifier() + string("_sz");
+    bool has = false;
 
+    SgExpression* allDimsBefore = NULL;
     while (list)
     {
         const int var = list->lhs()->variant();
         if (var == STAR_RANGE)
+        {
             has = true;
-        list = list->rhs();
+
+            parNames.push_back(new SgSymbol(VARIABLE_NAME, varN.c_str(), SgTypeInt(), scope));
+            SgExpression* par = allDimsBefore ? &(*new SgVarRefExp(parNames.back()) / *allDimsBefore) : (new SgVarRefExp(parNames.back()));
+
+            list->setLhs(par);
+            break;
+        }
+        else
+        {
+            if (allDimsBefore == NULL)
+                allDimsBefore = list->lhs();
+            else
+                allDimsBefore = &(*allDimsBefore * *list->lhs()->copyPtr());
         }
 
-    if (has)
-    {
-        list = arrayDecl->lhs();
-        while (list)
-        {
-            list->setLhs(new SgExpression(DDOT));
         list = list->rhs();
     }
-    }
 
     return has;
 }
 
-static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
+/*static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
 {
     vector<SgStatement*> toRem;
     for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
@@ -197,7 +205,7 @@ static void removeExternalStat(SgStatement* func, const set<string>& addedInterf
 
     for (auto& rem : toRem)
         rem->deleteStmt();
-}
+}*/
 
 template<typename T>
 static vector<FuncInfo*> sortByName(const T &funcs)
@@ -210,10 +218,25 @@ static vector<FuncInfo*> sortByName(const T &funcs)
     return funcList;
 }
 
-//XXX: incorrect!!
+static bool hasDvmParallel(SgStatement *func)
-/*void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
 {
-    set<FuncInfo*> hasAssumedSizeArrays;
+    for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
+    {
+        const int var = st->variant();
+        if (var == DVM_PARALLEL_ON_DIR || var == ACC_REGION_DIR ||
+            var == ACC_ACTUAL_DIR || var == ACC_GET_ACTUAL_DIR)
+            return true;
+
+        if (st->variant() == CONTAINS_STMT)
+            break;
+    }
+
+    return false;
+}
+
+void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFuncInfo)
+{
+    map<string, vector<int>> assumedSizeArraysByFunc;
 
     for (auto& funcByFile : allFuncInfo)
     {
@@ -226,6 +249,12 @@ static vector<FuncInfo*> sortByName(const T &funcs)
             if (prog == NULL)
                 continue;
 
+            if (!hasDvmParallel(prog))
+                continue;
+
+            vector<SgSymbol*> parNames;
+            SgStatement* scope = prog->getScopeForDeclare();
+
             vector<SgExpression*> arrayRefs;
             bool hasRefs = false;
             for (int z = 0; z < func->funcParams.countOfPars; ++z)
@@ -245,13 +274,8 @@ static vector<FuncInfo*> sortByName(const T &funcs)
                         {
                             if (list->lhs() && list->lhs()->symbol()->identifier() == name)
                             {
-                                if (changeIfHasStarRange(list->lhs()))
+                                if (changeIfHasStarRange(list->lhs(), scope, parNames))
-                                {
+                                    assumedSizeArraysByFunc[func->funcName].push_back(z);
-                                    hasRefs = true;
-                                    hasAssumedSizeArrays.insert(func);
-                                }
-                                else
-                                    arrayRefs.push_back(list->lhs());
                                 break;
                             }
                             list = list->rhs();
@@ -260,13 +284,33 @@ static vector<FuncInfo*> sortByName(const T &funcs)
                 }
             }
 
-            if (hasRefs)
+            if (parNames.size())
-                for (auto& ref : arrayRefs)
+            {
-                    changeIfHasStarRange(ref, true);
+                SgProcHedrStmt* proc = isSgProcHedrStmt(func->funcPointer->GetOriginal());
+                checkNull(proc, convertFileName(__FILE__).c_str(), __LINE__);
+
+                makeDeclaration(parNames, scope);
+
+                for (auto& newPar : parNames)
+                {
+                    auto arg = new SgVarRefExp(newPar);
+                    BIF_LL1(proc->thebif) = addToExprList(BIF_LL1(proc->thebif), arg->thellnd);
+
+                    PTR_LLND ll;
+                    PTR_SYMB symb;
+                    ll = giveLlSymbInDeclList(arg->thellnd);
+                    if (ll && (symb = NODE_SYMB(ll)))
+                    {
+                        appendSymbToArgList(BIF_SYMB(proc->thebif), symb);
+                        SYMB_SCOPE(symb) = proc->thebif;
+                    }
+                    //proc->AddArg(*new SgVarRefExp(newPar));
+                }
+            }
         }
     }
 
-    if (hasAssumedSizeArrays.size() == 0)
+    if (assumedSizeArraysByFunc.size() == 0)
         return;
 
     for (auto& funcByFile : allFuncInfo)
@@ -274,29 +318,58 @@ static vector<FuncInfo*> sortByName(const T &funcs)
         if (SgFile::switchToFile(funcByFile.first) == -1)
             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
+        SgSymbol* funcSize = new SgSymbol(FUNCTION_NAME, "size");
+
         for (auto& func : sortByName(funcByFile.second))
         {
             SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
             if (prog == NULL)
                 continue;
 
-            set<string> addedInterfaceFor;
+            for (auto& detailedCall : func->callsFromDetailed)
-            for (auto& elem : sortByName(func->callsFromV))
             {
-                auto it = hasAssumedSizeArrays.find(elem);
+                auto it = assumedSizeArraysByFunc.find(detailedCall.detailCallsFrom.first);
-                if (it != hasAssumedSizeArrays.end())
+                if (it != assumedSizeArraysByFunc.end())
                 {
-                    auto callFrom = *it;
+                    auto pointer = detailedCall.pointerDetailCallsFrom;
-                    DvmhRegionInserter::createInterfaceBlockForOutCall(func, callFrom);
+
-                    addedInterfaceFor.insert(callFrom->funcName);
+                    SgExpression* list = NULL;
+                    if (pointer.second == FUNC_CALL)
+                    {
+                        SgExpression* p = (SgExpression*)pointer.first;
+                        list = p->lhs();
                     }
+                    else
+                    {
+                        SgStatement* p = (SgStatement*)pointer.first;
+                        list = p->expr(0);
                     }
 
-            if (addedInterfaceFor.size())
+                    SgExpression* last = list;
-                removeExternalStat(prog, addedInterfaceFor);
+                    vector<SgExpression*> pars;
+                    while (list)
+                    {
+                        last = list;
+                        pars.push_back(list->lhs());
+                        list = list->rhs();
+                    }
+
+                    for (int z = 0; z < it->second.size(); ++z)
+                    {
+                        int parNum = it->second[z];
+                        if (parNum >= pars.size())
+                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+                        SgFunctionCallExp* call = new SgFunctionCallExp(*funcSize, *pars[parNum]);
+
+                        last->setRhs(new SgExpression(EXPR_LIST, call));
+                        last = last->rhs();
+                    }
+                }
+            }
+        }
     }
 }
-}*/
 
 static void setPureStatus(FuncInfo* func)
 {

src/Transformations/FunctionPurifying/function_purifying.h

@@ -15,3 +15,5 @@ void saveTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncIn
 void moduleTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
 
 void insertInterface(SgStatement* func, const FuncInfo* callFrom);
+
+void transformAssumedSizeParameters(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2436"
+#define VERSION_SPF "2437"