- Added optimization that converts match-expressions (for-loop searching for matching pattern) to switch (jumps to the correct case at once)

  - Works for records
  - Seems to be broken for strings so I disabled it (it uses string hashing, and DAE.SCONST is a bit weird at times so it needs more debugging)


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

Author: sjoelund

Compiler/FrontEnd/DAE.mo

@@ -1139,7 +1139,7 @@ uniontype Exp "Expressions
   end METARECORDCALL;
 
   record MATCHEXPRESSION
-    Absyn.MatchType matchType;
+    MatchType matchType;
     list<Exp> inputs;
     list<Element> localDecls;
     list<MatchCase> cases;
@@ -1183,6 +1183,13 @@ public uniontype MatchCase
   end CASE;
 end MatchCase;
 
+public uniontype MatchType
+  record MATCHCONTINUE end MATCHCONTINUE;
+  record MATCH
+    Option<tuple<Integer,ExpType,Integer>> switch "The index of the pattern to switch over, its type and an the value to divide string hashes with";
+  end MATCH;
+end MatchType;
+
 public uniontype Pattern "Patterns deconstruct expressions"
   record PAT_WILD "_"
   end PAT_WILD;

Compiler/FrontEnd/Expression.mo

@@ -3509,7 +3509,7 @@ algorithm
       list<String> fieldNames;
       DAE.InlineType  inl;
       list<DAE.MatchCase> cases;
-      Absyn.MatchType matchTy;
+      DAE.MatchType matchTy;
 
     case ((e as DAE.ICONST(_)),rel,ext_arg)
       equation

Compiler/FrontEnd/ExpressionDump.mo

@@ -563,7 +563,7 @@ algorithm
       Boolean b;
       list<DAE.Exp> aexpl;
       list<list<tuple<DAE.Exp,Boolean>>> lstes;
-      Absyn.MatchType matchTy;
+      DAE.MatchType matchTy;
       DAE.ExpType et;
       list<DAE.MatchCase> cases;
       DAE.Pattern pat;
@@ -893,7 +893,7 @@ algorithm
 
     case (DAE.MATCHEXPRESSION(matchType=matchTy,inputs=es,cases=cases), _, _, _)
       equation
-        s1 = Dump.printMatchType(matchTy);
+        s1 = printMatchType(matchTy);
         s2 = printExp2Str(DAE.TUPLE(es), stringDelimiter, opcreffunc, opcallfunc);
         s3 = stringAppendList(Util.listMap(cases,printCase2Str));
         s = stringAppendList({s1,s2,"\n",s3,"  end ",s1});
@@ -917,6 +917,17 @@ algorithm
   end matchcontinue;
 end printExp2Str;
 
+protected function printMatchType
+  input DAE.MatchType ty;
+  output String str;
+algorithm
+  str := match ty
+    case DAE.MATCHCONTINUE() then "matchcontinue";
+    case DAE.MATCH(NONE()) then "match";
+    case DAE.MATCH(SOME(_)) then "match /* switch */";
+  end match;
+end printMatchType;
+
 protected function printCase2Str
   "Prints a matchcase as string"
   input DAE.MatchCase matchCase;
@@ -1776,7 +1787,7 @@ algorithm
       list<list<tuple<DAE.Exp, Boolean>>> lstes;
       DAE.Exp ae1;
       Boolean b;
-      Absyn.MatchType matchTy;
+      DAE.MatchType matchTy;
       list<DAE.MatchCase> cases;
       DAE.Pattern pat;
 
@@ -2100,13 +2111,13 @@ algorithm
 
     case (DAE.MATCHEXPRESSION(matchType=matchTy,inputs=es,cases=cases), _)
       equation
-        Print.printBuf(Dump.printMatchType(matchTy));
+        Print.printBuf(printMatchType(matchTy));
         Print.printBuf(" (");
         printList(es, printExp, ",");
         Print.printBuf(") \n");
         Print.printBuf(stringAppendList(Util.listMap(cases,printCase2Str)));
         Print.printBuf("  end ");
-        Print.printBuf(Dump.printMatchType(matchTy));
+        Print.printBuf(printMatchType(matchTy));
       then ();
 
     case (DAE.BOX(e),_)

Compiler/FrontEnd/ExpressionSimplify.mo

@@ -346,7 +346,7 @@ algorithm
         e = DAE.IFEXP(e, e1_1, e2_1);
       then simplify(e);
 
-    case DAE.MATCHEXPRESSION(matchType=Absyn.MATCH(), inputs={e}, localDecls={}, cases={
+    case DAE.MATCHEXPRESSION(matchType=DAE.MATCH(switch=_), inputs={e}, localDecls={}, cases={
         DAE.CASE(patterns={DAE.PAT_CONSTANT(exp=DAE.BCONST(b1))},localDecls={},body={},result=SOME(e1)),
         DAE.CASE(patterns={DAE.PAT_WILD()},localDecls={},body={},result=SOME(e2))
       })

Compiler/FrontEnd/Patternm.mo

@@ -545,6 +545,7 @@ algorithm
       String str;
       DAE.Exp exp;
       HashTableStringToPath.HashTable ht;
+      DAE.MatchType elabMatchTy;
     case (cache,env,Absyn.MATCHEXP(matchTy=matchTy,inputExp=inExp,localDecls=decls,cases=cases),impl,st,performVectorization,pre,info,numError)
       equation
         (cache,SOME((env,DAE.DAE(matchDecls)))) = addLocalDecls(cache,env,decls,Env.matchScopeName,impl,info);
@@ -559,11 +560,12 @@ algorithm
         // Do DCE before converting mc to m
         matchTy = optimizeContinueToMatch(matchTy,elabCases,info);
         elabCases = optimizeContinueJumps(matchTy, elabCases);
-        ht = getUsedLocalCrefs(RTOpts.debugFlag("patternmSkipFilterUnusedAsBindings"),DAE.MATCHEXPRESSION(matchTy,elabExps,matchDecls,elabCases,et));
+        ht = getUsedLocalCrefs(RTOpts.debugFlag("patternmSkipFilterUnusedAsBindings"),DAE.MATCHEXPRESSION(DAE.MATCHCONTINUE(),elabExps,matchDecls,elabCases,et));
         (matchDecls,ht) = filterUnusedDecls(matchDecls,ht,{},HashTableStringToPath.emptyHashTable());
         elabCases = filterUnusedAsBindings(elabCases,ht);
         (elabExps,elabCases) = filterUnusedPatterns(elabExps,elabCases) "filterUnusedPatterns() Then again to filter out the last parts.";
-        exp = DAE.MATCHEXPRESSION(matchTy,elabExps,matchDecls,elabCases,et);
+        elabMatchTy = optimizeMatchToSwitch(matchTy,elabCases,info);
+        exp = DAE.MATCHEXPRESSION(elabMatchTy,elabExps,matchDecls,elabCases,et);
       then (cache,exp,prop,st);
     else
       equation
@@ -574,6 +576,111 @@ algorithm
   end matchcontinue;
 end elabMatchExpression;
 
+protected function optimizeMatchToSwitch
+  "match str case 'str1' ... case 'str2' case 'str3' => switch hash(str)...
+  match ut case UT1 ... case UT2 ... case UT3 => switch valueConstructor(ut)...
+  Works if all values are unique. Also works if there is one 'default' case at the end of the list.
+  
+  NOT YET WORKING CODE! Code generation does not know about this.
+  We need DAE.MATCH/CONTINUE/SWITCH instead of Absyn.MATCH/CONTINUE
+  "
+  input Absyn.MatchType matchTy;
+  input list<DAE.MatchCase> cases;
+  input Absyn.Info info;
+  output DAE.MatchType outType;
+algorithm
+  outType := matchcontinue (matchTy,cases,info)
+    local
+      tuple<Integer,DAE.ExpType,Integer> tpl;
+      list<list<DAE.Pattern>> patternMatrix;
+      String str;
+    case (Absyn.MATCHCONTINUE(),_,_) then DAE.MATCHCONTINUE();
+    case (_,cases,_)
+      equation
+        true = listLength(cases) > 2;
+        patternMatrix = Util.transposeList(Util.listMap(cases,getCasePatterns));
+        tpl = findPatternToConvertToSwitch(patternMatrix,0,info);
+        Error.assertionOrAddSourceMessage(not RTOpts.debugFlag("patternmAllInfo"),Error.MATCH_TO_SWITCH_OPTIMIZATION, {}, info);
+      then DAE.MATCH(SOME(tpl));
+    else DAE.MATCH(NONE());
+  end matchcontinue;
+end optimizeMatchToSwitch;
+
+protected function findPatternToConvertToSwitch
+  input list<list<DAE.Pattern>> patternMatrix;
+  input Integer index;
+  input Absyn.Info info;
+  output tuple<Integer,DAE.ExpType,Integer> tpl;
+algorithm
+  tpl := matchcontinue  (patternMatrix,index,info)
+    local
+      list<DAE.Pattern> pats;
+      String str;
+      DAE.ExpType ty;
+      Integer extraarg;
+    case (pats::patternMatrix,index,info)
+      equation
+        (ty,extraarg) = findPatternToConvertToSwitch2(pats, {}, DAE.ET_OTHER());
+      then ((index,ty,extraarg));
+    case (_::patternMatrix,index,info)
+      then findPatternToConvertToSwitch(patternMatrix,index+1,info);
+  end matchcontinue;
+end findPatternToConvertToSwitch;
+
+protected function findPatternToConvertToSwitch2
+  input list<DAE.Pattern> pats;
+  input list<Integer> ixs;
+  input DAE.ExpType ty;
+  output DAE.ExpType outTy;
+  output Integer extraarg;
+algorithm
+  (outTy,extraarg) := match (pats,ixs,ty)
+    local
+      Integer ix;
+      String str;
+      // Always jump to the last pattern as a default case? Seems reasonable, but requires knowledge about the other patterns...
+      /* Disable strings...
+    case ({},ixs,DAE.ET_STRING())
+      equation
+        // Should probably start at realCeil(log2(listLength(ixs))), but we don't have log2 in RML :)
+        ix = findMinMod(ixs,1);
+      then (DAE.ET_STRING(),ix);
+    case (DAE.PAT_CONSTANT(exp=DAE.SCONST(str))::pats,ixs,_)
+      equation
+        ix = stringHashDjb2(str);
+        false = listMember(ix,ixs);
+        (ty,extraarg) = findPatternToConvertToSwitch2(pats,ix::ixs,DAE.ET_STRING());
+      then (ty,extraarg);
+      */
+    case ({},_,DAE.ET_METATYPE()) then (ty,0);
+    case (DAE.PAT_CALL(index=ix)::pats,ixs,_)
+      equation
+        false = listMember(ix,ixs);
+        (ty,extraarg) = findPatternToConvertToSwitch2(pats,ix::ixs,DAE.ET_METATYPE());
+      then (ty,extraarg);
+  end match;
+end findPatternToConvertToSwitch2;
+
+protected function findMinMod
+  input list<Integer> ixs;
+  input Integer mod;
+  output Integer outMod;
+algorithm
+  outMod := matchcontinue (ixs,mod)
+    case (ixs,mod)
+      equation
+        ixs = Util.listMap1(ixs, intMod, mod);
+        ixs = Util.sort(ixs, intLt);
+        (_,{}) = Util.splitUniqueOnBool(ixs, intEq);
+        // This mod was high enough that all values were distinct
+      then mod;
+    else
+      equation
+        true = mod < 65536;
+      then findMinMod(ixs,mod*2);
+  end matchcontinue;
+end findMinMod;
+
 protected function filterUnusedPatterns
   "case (1,_,_) then ...; case (2,_,_) then ...; =>"
   input list<DAE.Exp> inputs "We can only remove inputs that are free from side-effects";
@@ -1670,5 +1777,13 @@ algorithm
       then DAE.CASE(pats,localDecls,body,result,jump,info);
   end match;
 end setCasePatterns;
+
+public function getValueCtor
+  "Get the constructor index of a uniontype record based on its index in the uniontype"
+  input Integer ix;
+  output Integer ctor;
+algorithm
+  ctor := ix+3;
+end getValueCtor;
 
 end Patternm;

Compiler/FrontEnd/Types.mo

@@ -3985,7 +3985,7 @@ algorithm
       list<DAE.ExpType> expTypes;
       DAE.ExpType et,ety1;
       list<DAE.MatchCase> cases;
-      Absyn.MatchType matchTy;
+      DAE.MatchType matchTy;
       list<DAE.Element> localDecls;
 
       /* Array expressions: expression dimension [dim1], expected dimension [dim2] */