- SimCode.getCalledFunctionsInFunction now uses a HashTable; this is a lot faster for large functions

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@7619 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Author: sjoelund

Compiler/BackEnd/SimCode.mo

@@ -62,6 +62,7 @@ public import Env;
 public import Dependency;
 public import Interactive;
 public import HashTableExpToIndex;
+public import HashTableStringToPath;
 public import Absyn;
 public import Ceval;
 public import Tpl;
@@ -7634,92 +7635,85 @@ protected function getCalledFunctionsInFunctions
   Goes through the given DAE, finds the given functions and collects
   the names of the functions called from within those functions"
   input list<Absyn.Path> paths;
-  input list<Absyn.Path> accumulated;
+  input HashTableStringToPath.HashTable ht;
   input DAE.FunctionTree funcs;
-  output list<Absyn.Path> res;
-protected
-  list<list<Absyn.Path>> pathslist;
+  output HashTableStringToPath.HashTable outHt;
 algorithm
-  res := matchcontinue(paths,accumulated,funcs)
+  outHt := match (paths,ht,funcs)
     local
-      list<Absyn.Path> acc,rest;
+      list<Absyn.Path> rest;
       Absyn.Path path;
-    case ({},accumulated,funcs) then accumulated;
-    case (path::rest,accumulated,funcs)
+    case ({},ht,funcs) then ht;
+    case (path::rest,ht,funcs)
       equation
-        acc = getCalledFunctionsInFunction(path, accumulated, funcs);
-        res = getCalledFunctionsInFunctions(rest, acc, funcs);
-      then res;
-  end matchcontinue;
+        ht = getCalledFunctionsInFunction2(path, Absyn.pathString(path), ht, funcs);
+        ht = getCalledFunctionsInFunctions(rest, ht, funcs);
+      then ht;
+  end match;
 end getCalledFunctionsInFunctions;
 
 public function getCalledFunctionsInFunction
+"function: getCalledFunctionsInFunction
+  Goes through the given DAE, finds the given function and collects
+  the names of the functions called from within those functions"
+  input Absyn.Path path;
+  input DAE.FunctionTree funcs;
+  output list<Absyn.Path> outPaths;
+protected
+  HashTableStringToPath.HashTable ht;
+algorithm
+  ht := HashTableStringToPath.emptyHashTable();
+  ht := getCalledFunctionsInFunction2(path,Absyn.pathString(path),ht,funcs);
+  outPaths := BaseHashTable.hashTableValueList(ht);
+end getCalledFunctionsInFunction;
+
+protected function getCalledFunctionsInFunction2
 "function: getCalledFunctionsInFunction
   Goes through the given DAE, finds the given function and collects
   the names of the functions called from within those functions"
   input Absyn.Path inPath;
-  input list<Absyn.Path> accumulated;
+  input String pathstr;
+  input HashTableStringToPath.HashTable ht "paths to not add";
   input DAE.FunctionTree funcs;
-  output list<Absyn.Path> outAbsynPathLst;
+  output HashTableStringToPath.HashTable outHt "paths to not add";
 algorithm
-  outAbsynPathLst := matchcontinue (inPath,accumulated,funcs)
+  outHt := matchcontinue (inPath,pathstr,ht,funcs)
     local
-      String pathstr,debugpathstr;
+      String debugpathstr,str;
       Absyn.Path path;
       DAE.Function funcelem;
-      list<DAE.Function> funcelems;
-      list<DAE.Function> elements;
-      list<DAE.Exp> explist,fcallexps,fcallexps_1, fnrefs;
-      list<Absyn.ComponentRef> crefs;
-      list<Absyn.Path> calledfuncs, res1, res2, res, acc, varfuncs, fnpaths, fns, referencedFuncs, reffuncs;
+      list<DAE.Function> funcelems,elements;
+      list<Absyn.Path> calledfuncs, varfuncs, fnpaths, fns;
       list<String> debugpathstrs;
       DAE.DAElist dae;
       list<DAE.Element> els;
-      String str;
-      list<DAE.Element> varlist;
-      list<list<DAE.Element>> varlistlist;
 
-    case (path,acc,_)
+    case (path,pathstr,ht,_)
       equation
-        true = listMember(path,acc);
-      then acc;
+        _ = BaseHashTable.get(Absyn.pathString(path), ht);
+      then ht;
 
-    case (path,acc,funcs)
+    case (path,pathstr,ht,funcs)
       equation
-        false = listMember(path,acc);
         funcelem = DAEUtil.getNamedFunction(path, funcs);
         els = DAEUtil.getFunctionElements(funcelem);
         // Function reference variables are filtered out
         varfuncs = Util.listFold(els, DAEUtil.collectFunctionRefVarPaths, {});
         (_,(_,varfuncs)) = DAEUtil.traverseDAE2(Util.if_(RTOpts.acceptMetaModelicaGrammar(), els, {}),Expression.traverseSubexpressionsHelper,(DAEUtil.collectValueblockFunctionRefVars,varfuncs));
-        //print("varfuncs: " +& Util.stringDelimitList(Util.listMap(varfuncs,Absyn.pathString),",") +& "\n");
-        // print("Got expressions in " +& Absyn.pathString(path) +& ": " +& ExpressionDump.printExpStr(DAE.TUPLE(explist)) +& "\n");
         (_,(_,(calledfuncs,_))) = DAEUtil.traverseDAE2(els,Expression.traverseSubexpressionsHelper,(matchNonBuiltinCallsAndFnRefPaths,({},varfuncs)));
-        //print("calledfuncs: " +& Util.stringDelimitList(Util.listMap(calledfuncs,Absyn.pathString),",") +& "\n");
-        res = getCalledFunctionsInFunctions(calledfuncs, path::acc, funcs);
-        /*Debug.fprintln("info", "getCalledFunctionsInFunction: " +& Absyn.pathString(path)) "debug" ;
-         Debug.fprint("info", "Found variable function refs to ignore: ") "debug" ;
-         debugpathstrs = Util.listMap(varfuncs, Absyn.pathString) "debug" ;
-         debugpathstr = Util.stringDelimitList(debugpathstrs, ", ") "debug" ;
-         Debug.fprintln("info", debugpathstr) "debug" ;
-         Debug.fprint("info", "Found called functions: ") "debug" ;
-         debugpathstrs = Util.listMap(res, Absyn.pathString) "debug" ;
-         debugpathstr = Util.stringDelimitList(debugpathstrs, ", ") "debug" ;
-         Debug.fprintln("info", debugpathstr) "debug" ;*/
-      then
-        res;
+        ht = BaseHashTable.add((pathstr,path),ht);
+        ht = getCalledFunctionsInFunctions(calledfuncs, ht, funcs);
+      then ht;
 
-    case (path,acc,funcs)
+    case (path,pathstr,ht,funcs)
       equation
-        false = listMember(path,acc);
         failure(_ = DAEUtil.getNamedFunction(path, funcs));
-        pathstr = Absyn.pathString(path);
-        str = "SimCode.getCalledFunctionsInFunction: Class " +& pathstr +& " not found in global scope.";
+        str = "SimCode.getCalledFunctionsInFunction2: Class " +& pathstr +& " not found in global scope.";
         Error.addMessage(Error.INTERNAL_ERROR,{str});
       then
         fail();
   end matchcontinue;
-end getCalledFunctionsInFunction;
+end getCalledFunctionsInFunction2;
 
 protected function getCallPath
 "function: getCallPath

Compiler/Script/CevalScript.mo

@@ -4637,7 +4637,7 @@ algorithm
         // First check if the main function exists... If it does not it might be an interactive function...
         mainFunction = DAEUtil.getNamedFunction(path, funcs);
         pathstr = generateFunctionName(path);
-        paths = cevalGenerateFunctionDAEs(funcs, path,  {});
+        paths = SimCode.getCalledFunctionsInFunction(path,funcs);
 
         // The list of functions is not ordered, so we need to filter out the main function...
         funcs = Env.getFunctionTree(cache);
@@ -4687,101 +4687,4 @@ algorithm
   end matchcontinue;
 end cevalGenerateFunction;
 
-protected function cevalGenerateFunctionDAEs "function: cevalGenerateFunctionStr
-  Generates a function with the given path, and all functions that are called
-  within that function. The two string lists contains names of functions and
-  records already generated, which won\'t be generated again."
-  input DAE.FunctionTree funcs;
-  input Absyn.Path inPath;
-  input list<Absyn.Path> inAbsynPathLst;
-  output list<Absyn.Path> outAbsynPathLst;
-algorithm
-  outAbsynPathLst := matchcontinue (funcs,inPath,inAbsynPathLst)
-    local
-      Absyn.Path gfmember,path;
-      list<Env.Frame> env,env_1,env_2;
-      list<Absyn.Path> gflist,calledfuncs,gflist_1;
-      SCode.Class cls;
-      DAE.DAElist d,d1,d2,d_1;
-      list<String> debugfuncs,calledfuncsstrs,libs,libs_2,calledfuncsstrs_1,rt,rt_1,rt_2;
-      String debugfuncsstr,funcname,funccom,thisfuncstr,resstr,ss1;
-      Env.Cache cache;
-
-    // If getmember succeeds, path is in generated functions list, so do nothing
-    case (funcs,path,gflist)
-      equation
-        gfmember = Util.listGetMemberOnTrue(path, gflist, ModUtil.pathEqual);
-      then
-        gflist;
-
-    // If getmember fails, path is not in generated functions list, hence generate it
-    case (funcs,path,gflist)
-      equation
-        false = RTOpts.debugFlag("nogen");
-        failure(_ = Util.listGetMemberOnTrue(path, gflist, ModUtil.pathEqual));
-        Debug.fprintln("ceval", "/*- CevalScript.cevalGenerateFunctionDAEs starting*/");
-        Debug.fprintln("ceval", "/*- CevalScript.cevalGenerateFunctionDAEs instantiating*/");
-        Debug.fprint("ceval", "/*- CevalScript.cevalGenerateFunctionDAEs getting functions: ");
-        calledfuncs = SimCode.getCalledFunctionsInFunction(path, gflist, funcs);
-        gflist = path :: gflist; // In case the function is recursive
-        calledfuncs = Util.listSetDifference(calledfuncs, gflist); // Filter out things we already know will be ignored...
-        debugfuncs = Util.listMap(calledfuncs, Absyn.pathString);
-        debugfuncsstr = Util.stringDelimitList(debugfuncs, ", ");
-        Debug.fprint("ceval", debugfuncsstr);
-        Debug.fprintln("ceval", "*/");
-        gflist = cevalGenerateFunctionDAEsList(funcs,calledfuncs,gflist);
-        Debug.fprint("ceval", "/*- CevalScript.cevalGenerateFunctionDAEs prefixing dae */");
-      then
-        gflist;
-    
-    // failure
-    case (funcs,path,_)
-      equation
-        true = RTOpts.debugFlag("nogen");
-        ss1 = Absyn.pathString(path);
-        ss1 = stringAppendList({"/*- CevalScript.cevalGenerateFunctionDAEs failed( ",ss1," ) set \"nogen\" flag to false */\n"});
-        Debug.fprint("failtrace", ss1);
-      then
-        fail();
-
-    // failtrace
-    case (_,path,_)
-      equation
-        true = RTOpts.debugFlag("failtrace");
-        false = RTOpts.debugFlag("nogen");
-        ss1 = Absyn.pathString(path);
-        ss1 = stringAppendList({"/*- CevalScript.cevalGenerateFunctionDAEs failed( ",ss1," )*/\n"});
-        Debug.fprint("failtrace", ss1);
-      then
-        fail();
-  end matchcontinue;
-end cevalGenerateFunctionDAEs;
-
-protected function cevalGenerateFunctionDAEsList "function: cevalGenerateFunctionStrList
-  Generates code for several functions."
-  input DAE.FunctionTree funcs;
-  input list<Absyn.Path> inAbsynPathLst1;
-  input list<Absyn.Path> inAbsynPathLst3;
-  output list<Absyn.Path> outAbsynPathLst;
-algorithm
-  outAbsynPathLst := matchcontinue (funcs,inAbsynPathLst1,inAbsynPathLst3)
-    local
-      list<Env.Frame> env;
-      list<Absyn.Path> gflist,gflist_1,gflist_2,rest;
-      String firststr;
-      list<String> reststr, rt, rt_1, rt_2;
-      Absyn.Path first;
-      Env.Cache cache;
-      list<String> libs_1,libs_2;
-      DAE.DAElist d,d1,d2;
-    case (funcs,{},gflist) then gflist;
-    case (funcs,(first :: rest),gflist)
-      equation
-        gflist_1 = cevalGenerateFunctionDAEs(funcs,first,gflist);
-        gflist_2 = cevalGenerateFunctionDAEsList(funcs,rest,gflist_1);
-      then
-        gflist_2;
-  end matchcontinue;
-end cevalGenerateFunctionDAEsList;
-
 end CevalScript;