[NB] introduce inlining of array constructors (#13035)

* [NB] introduce inlining of array constructors

* [NB] fix inlining of record constructors

 - use correct equation and not auxiliary variable index
 - update how nesting is handled
 - dumping updates for equations

* [NB] small fix

Author: kabdelhak

OMCompiler/Compiler/NBackEnd/Classes/NBEquation.mo

@@ -157,6 +157,20 @@ public
       end if;
     end fromFrames;
 
+    function addFrames
+      input output Iterator iter;
+      input list<Frame> frames;
+    protected
+      list<ComponentRef> names1, names2;
+      list<Expression> ranges1, ranges2;
+    algorithm
+      if not listEmpty(frames) then
+        (names1, ranges1) := getFrames(iter);
+        (names2, ranges2) := List.unzip(frames);
+        iter := fromFrames(List.zip(listAppend(names1, names2), listAppend(ranges1, ranges2)));
+      end if;
+    end addFrames;
+
     function getFrames
       input Iterator iter;
       output list<ComponentRef> names;
@@ -855,8 +869,12 @@ public
     protected
       Pointer<Variable> residualVar;
     algorithm
-      residualVar := getResidualVar(eqn);
-      name := BVariable.getVarName(residualVar);
+      if isDummy(Pointer.access(eqn)) then
+        name := ComponentRef.EMPTY();
+      else
+        residualVar := getResidualVar(eqn);
+        name := BVariable.getVarName(residualVar);
+      end if;
     end getEqnName;
 
     function getResidualVar
@@ -3646,7 +3664,9 @@ public
           new_eq := func(eq);
           if not referenceEq(eq, new_eq) then
             // Do not update the expandable array entry, but the pointer itself
-            if debug and UnorderedSet.contains(ComponentRef.toString(Equation.getEqnName(eq_ptr)), debug_eqns) and not Equation.equalName(Pointer.create(eq), Pointer.create(new_eq)) then
+            if debug and (UnorderedSet.contains(ComponentRef.toString(Equation.getEqnName(eq_ptr)), debug_eqns)
+              or UnorderedSet.contains(ComponentRef.toString(Equation.getEqnName(Pointer.create(new_eq))), debug_eqns))
+              and not Equation.equalName(Pointer.create(eq), Pointer.create(new_eq)) then
               print("[debugFollowEquations] The equation:\n" + Equation.toString(eq) + "\nGets replaced by:\n"  + Equation.toString(new_eq) + "\n");
             end if;
             Pointer.update(eq_ptr, new_eq);

OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBFunctionAlias.mo

@@ -190,21 +190,21 @@ protected
     function createName
       input Type ty;
       input Iterator iter;
-      input Pointer<Integer> index;
+      input Pointer<Integer> aux_index;
       input Boolean init;
       output ComponentRef name;
     protected
       Type new_ty = ty;
     algorithm
       if not Iterator.isEmpty(iter) then
         new_ty := Type.liftArrayRightList(ty, list(Dimension.fromInteger(i) for i in Iterator.sizes(iter)));
-        (_, name) := BVariable.makeAuxVar(NBVariable.FUNCTION_STR, Pointer.access(index), new_ty, init);
+        (_, name) := BVariable.makeAuxVar(NBVariable.FUNCTION_STR, Pointer.access(aux_index), new_ty, init);
         // add iterators to subscripts of auxilliary variable
         name      := ComponentRef.mergeSubscripts(Iterator.normalizedSubscripts(iter), name, true, true);
       else
-        (_, name) := BVariable.makeAuxVar(NBVariable.FUNCTION_STR, Pointer.access(index), new_ty, init);
+        (_, name) := BVariable.makeAuxVar(NBVariable.FUNCTION_STR, Pointer.access(aux_index), new_ty, init);
       end if;
-      Pointer.update(index, Pointer.access(index) + 1);
+      Pointer.update(aux_index, Pointer.access(aux_index) + 1);
     end createName;
   end Call_Aux;
 
@@ -220,8 +220,9 @@ protected
     extends Module.functionAliasInterface;
   protected
     UnorderedMap<Call_Id, Call_Aux> map = UnorderedMap.new<Call_Aux>(Call_Id.hash, Call_Id.isEqual);
+    VariablePointers variables = VarData.getVariables(varData);
     UnorderedMap<BClock, ComponentRef> clock_map;
-    Pointer<Integer> index = Pointer.create(1);
+    Pointer<Integer> aux_index = Pointer.create(1);
     list<Pointer<Variable>> new_vars_disc = {}, new_vars_cont = {}, new_vars_init = {}, new_vars_recd = {}, new_vars_clck;
     list<Pointer<Equation>> new_eqns_disc = {}, new_eqns_cont = {}, new_eqns_init = {}, new_eqns_clck;
     list<tuple<Call_Id, Call_Aux>> debug_lst_sim, debug_lst_ini;
@@ -238,7 +239,8 @@ protected
 
       case EqData.EQ_DATA_SIM() algorithm
         // first collect all new functions from simulation equations
-        eqData.simulation := EquationPointers.map(eqData.simulation, function introduceFunctionAliasEquation(map = map, index = index, init = false));
+        eqData.simulation := EquationPointers.map(eqData.simulation,
+          function introduceFunctionAliasEquation(map = map, variables = variables, aux_index = aux_index, eqn_index = eqData.uniqueIndex, init = false));
 
         // create new simulation variables and corresponding equations for the function alias
         for tpl in listReverse(UnorderedMap.toList(map)) loop
@@ -268,7 +270,8 @@ protected
         end if;
 
         // afterwards collect all functions from initial equations
-        eqData.initials := EquationPointers.map(eqData.initials, function introduceFunctionAliasEquation(map = map, index = index, init = true));
+        eqData.initials := EquationPointers.map(eqData.initials,
+          function introduceFunctionAliasEquation(map = map, variables = variables, aux_index = aux_index, eqn_index = eqData.uniqueIndex, init = true));
 
         // create new initialization variables and corresponding equations for the function alias
         for tpl in listReverse(UnorderedMap.toList(map)) loop
@@ -328,26 +331,34 @@ protected
 
   function introduceFunctionAliasEquation
     "creates auxilliary variables for all not inlineable function calls in the equation"
-    input output Equation eq;
+    input output Equation eqn;
     input UnorderedMap<Call_Id, Call_Aux> map;
-    input Pointer<Integer> index;
+    input VariablePointers variables;
+    input Pointer<Integer> aux_index;
+    input Pointer<Integer> eqn_index;
     input Boolean init;
   protected
     Iterator iter;
     Boolean stop;
   algorithm
-    (iter, stop) := match eq
+    // inline trivial array constructors first
+    eqn := Inline.inlineArrayConstructorSingle(eqn, Iterator.EMPTY(), variables, eqn_index);
+
+    // get iterator and determine if it needs to be checked further
+    (iter, stop) := match eqn
       local
         Equation body;
-      case Equation.FOR_EQUATION(body = {body}) then (eq.iter, Equation.isWhenEquation(Pointer.create(body))
+      case Equation.FOR_EQUATION(body = {body}) then (eqn.iter, Equation.isWhenEquation(Pointer.create(body))
                                                             or Equation.isIfEquation(Pointer.create(body)));
       case Equation.WHEN_EQUATION()             then (Iterator.EMPTY(), true);
       case Equation.IF_EQUATION()               then (Iterator.EMPTY(), true);
       case Equation.ALGORITHM()                 then (Iterator.EMPTY(), true);
                                                 else (Iterator.EMPTY(), false);
     end match;
+
+    // do the function alias replacement
     if not stop then
-      eq := Equation.map(eq, function introduceFunctionAlias(map = map, index = index, iter = iter, init = init));
+      eqn := Equation.map(eqn, function introduceFunctionAlias(map = map, aux_index = aux_index, iter = iter, init = init));
     end if;
   end introduceFunctionAliasEquation;
 
@@ -357,7 +368,7 @@ protected
     ToDo: also exclude special functions der(), pre(), ..."
     input output Expression exp;
     input UnorderedMap<Call_Id, Call_Aux> map;
-    input Pointer<Integer> index;
+    input Pointer<Integer> aux_index;
     input Iterator iter;
     input Boolean init;
   algorithm
@@ -395,11 +406,11 @@ protected
           ty := Expression.typeOf(exp);
           new_exp := match ty
             case Type.TUPLE() algorithm
-              names   := list(Call_Aux.createName(sub_ty, new_iter, index, init) for sub_ty in ty.types);
+              names   := list(Call_Aux.createName(sub_ty, new_iter, aux_index, init) for sub_ty in ty.types);
               tpl_lst := list(if ComponentRef.size(cref, true) == 0 then Expression.fromCref(ComponentRef.WILD()) else Expression.fromCref(cref) for cref in names);
             then Expression.TUPLE(ty, tpl_lst);
             else algorithm
-              name := Call_Aux.createName(ty, new_iter, index, init);
+              name := Call_Aux.createName(ty, new_iter, aux_index, init);
             then Expression.fromCref(name);
           end match;
         end if;

OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBInline.mo

@@ -50,6 +50,7 @@ protected
   import Expression = NFExpression;
   import NFFunction.Function;
   import NFFlatten.FunctionTree;
+  import InstNode = NFInstNode.InstNode;
   import Statement = NFStatement;
   import Subscript = NFSubscript;
   import Type = NFType;
@@ -169,6 +170,47 @@ public
     slices := list(Slice.SLICE(eqn, {}) for eqn in Pointer.access(record_eqns));
   end inlineRecordSliceEquation;
 
+  function inlineArrayConstructorSingle
+    input output Equation eqn;
+    input Iterator iter;
+    input VariablePointers variables;
+    input Pointer<Integer> index;
+    input Pointer<list<Pointer<Equation>>> new_eqns = Pointer.create({});
+    output Boolean changed;
+  algorithm
+    try
+      (eqn, changed) := match eqn
+        local
+          Equation new_eqn, body;
+          Expression lhs, rhs;
+          Call call;
+
+        // CREF = {... for i in []} array constructor equation
+        case Equation.ARRAY_EQUATION(lhs = lhs as Expression.CREF(), rhs = rhs as Expression.CALL(call = call as Call.TYPED_ARRAY_CONSTRUCTOR())) algorithm
+        then (inlineArrayConstructor(eqn, lhs.cref, call.exp, call.iters, eqn.attr, iter, variables, new_eqns, index), true);
+
+        // {... for i in []} = CREF array constructor equation
+        case Equation.ARRAY_EQUATION(lhs = lhs as Expression.CALL(call = call as Call.TYPED_ARRAY_CONSTRUCTOR()), rhs = rhs as Expression.CREF()) algorithm
+        then (inlineArrayConstructor(eqn, rhs.cref, call.exp, call.iters, eqn.attr, iter, variables, new_eqns, index), true);
+
+        // apply on for-equation. assumed to be split up
+        case Equation.FOR_EQUATION(body = {body}) algorithm
+          (new_eqn, changed) := inlineArrayConstructorSingle(body, eqn.iter, variables, index, new_eqns);
+          new_eqn := if changed then new_eqn else eqn;
+        then (new_eqn, changed);
+
+        // nothing happens
+        else (eqn, false);
+      end match;
+      // unpack the equation
+      eqn := if Equation.isDummy(eqn) then Pointer.access(List.first(Pointer.access(new_eqns))) else eqn;
+    else
+      if Flags.isSet(Flags.FAILTRACE) then
+        Error.addCompilerWarning("Failed to inline following equation:\n" + Equation.toString(eqn));
+      end if;
+    end try;
+  end inlineArrayConstructorSingle;
+
 protected
   function inline extends Module.inlineInterface;
   protected
@@ -238,7 +280,6 @@ protected
     end if;
   end inlineRecordsTuplesArrays;
 
-protected
   function inlineRecordTupleArrayEquation
     input output Equation eqn;
     input Iterator iter;
@@ -252,6 +293,7 @@ protected
         local
           Equation new_eqn, body;
           Expression lhs, rhs;
+          Call call;
           list<Expression> elements;
           Integer size;
 
@@ -282,6 +324,14 @@ protected
           elements := list(NFExpression.applySubscripts({Subscript.INDEX(Expression.INTEGER(i))}, rhs) for i in 1:arrayLength(lhs.elements));
         then inlineArrayEquation(eqn, lhs.elements, listArray(elements), eqn.attr, iter, variables, new_eqns, index);
 
+        // CREF = {... for i in []} array constructor equation
+        case Equation.ARRAY_EQUATION(lhs = lhs as Expression.CREF(), rhs = rhs as Expression.CALL(call = call as Call.TYPED_ARRAY_CONSTRUCTOR())) algorithm
+        then inlineArrayConstructor(eqn, lhs.cref, call.exp, call.iters, eqn.attr, iter, variables, new_eqns, index);
+
+        // {... for i in []} = CREF array constructor equation
+        case Equation.ARRAY_EQUATION(lhs = lhs as Expression.CALL(call = call as Call.TYPED_ARRAY_CONSTRUCTOR()), rhs = rhs as Expression.CREF()) algorithm
+        then inlineArrayConstructor(eqn, rhs.cref, call.exp, call.iters, eqn.attr, iter, variables, new_eqns, index);
+
         // apply on for-equation. assumed to be split up
         case Equation.FOR_EQUATION(body = {body}) algorithm
           new_eqn := inlineRecordTupleArrayEquation(body, eqn.iter, variables, new_eqns, index, inlineSimple);
@@ -393,6 +443,35 @@ protected
     eqn := Equation.DUMMY_EQUATION();
   end inlineArrayEquation;
 
+  function inlineArrayConstructor
+    input output Equation eqn;
+    input ComponentRef cref;
+    input Expression rhs;
+    input list<tuple<InstNode, Expression>> iters;
+    input EquationAttributes attr;
+    input Iterator iter;
+    input VariablePointers variables;
+    input Pointer<list<Pointer<Equation>>> new_eqns;
+    input Pointer<Integer> index;
+  protected
+    list<tuple<ComponentRef, Expression>> frames
+      = list((ComponentRef.makeIterator(Util.tuple21(tpl), Type.INTEGER()), Util.tuple22(tpl)) for tpl in iters);
+    list<Subscript> subs;
+    Expression cref_exp;
+    list<Pointer<Equation>> eqns;
+  algorithm
+    if Flags.isSet(Flags.DUMPBACKENDINLINE) then
+      print("[" + getInstanceName() + "] Inlining: " + Equation.toString(eqn) + "\n");
+    end if;
+    eqns := Pointer.access(new_eqns);
+    // add the iterators to the cref
+    subs      := list(Subscript.INDEX(Expression.CREF(Type.INTEGER(), Util.tuple21(tpl))) for tpl in frames);
+    cref_exp  := Expression.fromCref(ComponentRef.mergeSubscripts(subs, cref, true));
+    eqns      := createInlinedEquation(eqns, cref_exp, rhs, attr, Iterator.addFrames(iter, frames), variables, index);
+    Pointer.update(new_eqns, eqns);
+    eqn := Equation.DUMMY_EQUATION();
+  end inlineArrayConstructor;
+
   function createInlinedEquation
     "used for inlining record, tuple and array equations.
     tries to create new equation from lhs and rhs and applying