[NB] adjacency: remove skips in conditions (#12271)

kabdelhak · web-flow · commit 4974278c2954 · 2024-04-18T13:18:30.000+02:00
- remove skips in full adjacency matrix for variables in conditions
 - create utility function for conditions
 - update debugging information for adjacency creation
diff --git a/OMCompiler/Compiler/NBackEnd/Util/NBAdjacency.mo b/OMCompiler/Compiler/NBackEnd/Util/NBAdjacency.mo
@@ -501,7 +501,7 @@ public
                 for name in UnorderedMap.keyList(eqns_map) loop
                   index := UnorderedMap.getSafe(name, eqns_map, sourceInfo());
                   filtered := Solvability.filter(UnorderedSet.toList(occ[index]), sol[index], vars_map, min, max);
-                  // now run the normal createPseudo pipeline but use dependencies
+                  // upgrade the row and all meta data
                   upgradeRow(EquationPointers.getEqnAt(eqns, index), index, filtered, dep[index], rep[index], vars_map, adj.m, adj.mapping, adj.modes);
                 end for;
                 adj.mT := transposeScalar(adj.m, arrayLength(adj.mapping.var_StA));
@@ -1085,18 +1085,23 @@ public
       Iterator iter = Equation.getForIterator(eqn);
       Type ty = Equation.getType(eqn, true);
     algorithm
-      // don't do this for if equations as soon as we properly split them
-      if Equation.isAlgorithm(eqn_ptr) or Equation.isIfEquation(eqn_ptr) then
-        // algorithm full dependency
-        (eqn_scal_idx, eqn_size) := mapping.eqn_AtS[eqn_arr_idx];
-        row := Slice.upgradeRowFull(dependencies, map, mapping);
-        for i in 0:eqn_size-1 loop
-          updateIntegerRow(m, eqn_scal_idx+i, row);
-        end for;
+      try
+        // don't do this for if equations as soon as we properly split them
+        if Equation.isAlgorithm(eqn_ptr) or Equation.isIfEquation(eqn_ptr) then
+          // algorithm full dependency
+          (eqn_scal_idx, eqn_size) := mapping.eqn_AtS[eqn_arr_idx];
+          row := Slice.upgradeRowFull(dependencies, map, mapping);
+          for i in 0:eqn_size-1 loop
+            updateIntegerRow(m, eqn_scal_idx+i, row);
+          end for;
+        else
+          // todo: if, when single equation (needs to be updated for if)
+          Slice.upgradeRow(Equation.getEqnName(eqn_ptr), eqn_arr_idx, iter, ty, dependencies, dep, rep, map, m, mapping, modes);
+        end if;
       else
-        // todo: if, when single equation (needs to be updated for if)
-        Slice.upgradeRow(Equation.getEqnName(eqn_ptr), eqn_arr_idx, iter, ty, dependencies, dep, rep, map, m, mapping, modes);
-      end if;
+        Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed for:\n" + Equation.pointerToString(eqn_ptr)});
+        fail();
+      end try;
     end upgradeRow;
 
     function updateIntegerRow
@@ -1212,6 +1217,24 @@ public
       end if;
     end skip;
 
+    function removeSkips
+      input ComponentRef cref;
+      input UnorderedMap<ComponentRef, Dependency> map;
+    protected
+      Option<Dependency> opt_dep = UnorderedMap.get(cref, map);
+      Dependency dep;
+    algorithm
+      if Util.isSome(opt_dep) then
+        SOME(dep) := opt_dep;
+        dep.skips := {};
+        UnorderedMap.add(cref, dep, map);
+      else
+        Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because cref "
+         + ComponentRef.toString(cref) + " was not found in the map."});
+        fail();
+      end if;
+    end removeSkips;
+
     function updateList
       input list<ComponentRef> lst;
       input Integer num;
@@ -1233,6 +1256,15 @@ public
       end for;
     end skipList;
 
+    function removeSkipsList
+      input list<ComponentRef> lst;
+      input UnorderedMap<ComponentRef, Dependency> map;
+    algorithm
+      for cref in lst loop
+        removeSkips(cref, map);
+      end for;
+    end removeSkipsList;
+
     function addListFull
       "adds a list and applies full dependency"
       input list<ComponentRef> lst;
@@ -1625,16 +1657,16 @@ public
         Solvability.updateList(UnorderedSet.toList(set), Solvability.UNSOLVABLE(), sol_map);
       then set;
 
-      // variables in conditions and not occuring in both branches are unsolvable
+      // variables in conditions are unsolvable and variables not occuring in both branches are implicit
       case Expression.IF() algorithm
         set1  := collectDependencies(exp.trueBranch, map, dep_map, sol_map, rep_set);
         set2  := collectDependencies(exp.falseBranch, map, dep_map, sol_map, rep_set);
-        // variables not occuring in both branches will be tagged unsolvable
+        // variables not occuring in both branches will be tagged implicit
         diff  := UnorderedSet.sym_difference(set1, set2);
-        Solvability.updateList(UnorderedSet.toList(diff), Solvability.UNSOLVABLE(), sol_map);
-        // variables in conditions are unsolvable
+        Solvability.updateList(UnorderedSet.toList(diff), Solvability.IMPLICIT(), sol_map);
+        // variables in conditions are unsolvable and their skips have to be removed
         set   := collectDependencies(exp.condition, map, dep_map, sol_map, rep_set);
-        Solvability.updateList(UnorderedSet.toList(set), Solvability.UNSOLVABLE(), sol_map);
+        updateConditionCrefs(UnorderedSet.toList(set), dep_map, sol_map);
       then UnorderedSet.union_list({set, set1, set2}, ComponentRef.hash, ComponentRef.isEqual);
 
       // for array constructors replace all iterators (temporarily)
@@ -1753,10 +1785,9 @@ public
     list<UnorderedSet<ComponentRef>> sets1 = {};
     UnorderedSet<ComponentRef> set1, set2, diff;
   algorithm
-    // variables in conditions are unsolvable and reduced
+    // variables in conditions are unsolvable, reduced and get their skips removed
     set := collectDependencies(body.condition, map, dep_map, sol_map, rep_set);
-    Dependency.updateList(UnorderedSet.toList(set), -1, false, dep_map);
-    Solvability.updateList(UnorderedSet.toList(set), Solvability.UNSOLVABLE(), sol_map);
+    updateConditionCrefs(UnorderedSet.toList(set), dep_map, sol_map);
 
     // get variables from 'then' branch
     for eqn in body.then_eqns loop
@@ -1793,10 +1824,9 @@ public
     list<UnorderedSet<ComponentRef>> lst = {}, lst1, lst2;
     list<tuple<UnorderedSet<ComponentRef>, UnorderedSet<ComponentRef>>> tpl_lst = {};
   algorithm
-    // variables in conditions are unsolvable and reduced
+    // variables in conditions are unsolvable, reduced and get their skips removed
     set := collectDependencies(body.condition, map, dep_map, sol_map, rep_set);
-    Dependency.updateList(UnorderedSet.toList(set), -1, false, dep_map);
-    Solvability.updateList(UnorderedSet.toList(set), Solvability.UNSOLVABLE(), sol_map);
+    updateConditionCrefs(UnorderedSet.toList(set), dep_map, sol_map);
 
     // make condition repeat if the body is larger than 1
     if sum(WhenStatement.size(stmt) for stmt in body.when_stmts) > 1 then
@@ -1853,6 +1883,7 @@ public
       case WhenStatement.ASSERT() algorithm
         set1 := UnorderedSet.new(ComponentRef.hash, ComponentRef.isEqual);
         set2 := collectDependencies(stmt.condition, map, dep_map, sol_map, rep_set);
+        updateConditionCrefs(UnorderedSet.toList(set2), dep_map, sol_map);
       then (set1, set2);
 
       else algorithm
@@ -1862,5 +1893,16 @@ public
     end match;
   end collectDependenciesStmt;
 
+  function updateConditionCrefs
+    "variables in conditions are unsolvable, reduced and get their skips removed"
+    input list<ComponentRef> crefs;
+    input UnorderedMap<ComponentRef, Dependency> dep_map;
+    input UnorderedMap<ComponentRef, Solvability> sol_map;
+  algorithm
+    Dependency.removeSkipsList(crefs, dep_map);
+    Dependency.updateList(crefs, -1, false, dep_map);
+    Solvability.updateList(crefs, Solvability.UNSOLVABLE(), sol_map);
+  end updateConditionCrefs;
+
   annotation(__OpenModelica_Interface="backend");
 end NBAdjacency;
diff --git a/OMCompiler/Compiler/NBackEnd/Util/NBSlice.mo b/OMCompiler/Compiler/NBackEnd/Util/NBSlice.mo
@@ -1197,108 +1197,113 @@ protected
     Boolean repeated;
     Mode mode;
   algorithm
-    // I. resolve the skips
-    d                   := UnorderedMap.getSafe(cref, dep, sourceInfo());
-    (start, _)          := mapping.eqn_AtS[eqn_arr_idx];
-    (skip_idx, skip_ty) := resolveSkips(start, ty, d.skips);
-
-    // get equation and iterator sizes and frames
-    body_size       := Type.sizeOf(skip_ty);
-    iter_size       := Iterator.size(iter);
-    size            := body_size * iter_size;
-    (names, ranges) := Iterator.getFrames(iter);
-    frames          := List.zip(names, ranges);
-
-    // II. check for regular vs. reduced dimensions
-    regulars := Dependency.toBoolean(d);
-    if List.all(regulars, Util.id) then
-      // II.1 all regular - single dependency per row.
-      mode := Mode.create(eqn_name, {cref}, false);
-      scalarized  := listReverse(ComponentRef.scalarizeAll(cref));
-      map3        := UnorderedMap.new<Val2>(ComponentRef.hash, ComponentRef.isEqual);
-      for scal in scalarized loop
-        UnorderedMap.add(scal, getCrefInFrameIndices(scal, frames, mapping, map), map3);
-      end for;
-      scal_size   := listLength(List.flatten(UnorderedMap.valueList(map3)));
-      // either the scalarized list has to be equal in length to the equation or it can be repeated enough times to fit
-      if size == scal_size or (UnorderedSet.contains(cref, rep) and intMod(size, scal_size) == 0) then
-        for i in 1:size/scal_size loop
-          for scal in scalarized loop
-            for scal_idx in UnorderedMap.getSafe(scal, map3, sourceInfo()) loop
-              addMatrixEntry(m, modes, skip_idx + shift, scal_idx, mode);
-              shift := shift + 1;
+    try
+      // I. resolve the skips
+      d                   := UnorderedMap.getSafe(cref, dep, sourceInfo());
+      (start, _)          := mapping.eqn_AtS[eqn_arr_idx];
+      (skip_idx, skip_ty) := resolveSkips(start, ty, d.skips);
+
+      // get equation and iterator sizes and frames
+      body_size       := Type.sizeOf(skip_ty);
+      iter_size       := Iterator.size(iter);
+      size            := body_size * iter_size;
+      (names, ranges) := Iterator.getFrames(iter);
+      frames          := List.zip(names, ranges);
+
+      // II. check for regular vs. reduced dimensions
+      regulars := Dependency.toBoolean(d);
+      if List.all(regulars, Util.id) then
+        // II.1 all regular - single dependency per row.
+        mode := Mode.create(eqn_name, {cref}, false);
+        scalarized  := listReverse(ComponentRef.scalarizeAll(cref));
+        map3        := UnorderedMap.new<Val2>(ComponentRef.hash, ComponentRef.isEqual);
+        for scal in scalarized loop
+          UnorderedMap.add(scal, getCrefInFrameIndices(scal, frames, mapping, map), map3);
+        end for;
+        scal_size   := listLength(List.flatten(UnorderedMap.valueList(map3)));
+        // either the scalarized list has to be equal in length to the equation or it can be repeated enough times to fit
+        if size == scal_size or (UnorderedSet.contains(cref, rep) and intMod(size, scal_size) == 0) then
+          for i in 1:size/scal_size loop
+            for scal in scalarized loop
+              for scal_idx in UnorderedMap.getSafe(scal, map3, sourceInfo()) loop
+                addMatrixEntry(m, modes, skip_idx + shift, scal_idx, mode);
+                shift := shift + 1;
+              end for;
             end for;
           end for;
-        end for;
-      else
-        Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " (single dependency) failed because list of scalar variables("
-         + intString(scal_size) + ") " + List.toString(scalarized, ComponentRef.toString)
-         + ", does not fit the equation size " + intString(size) + ".\n"});
-        fail();
-      end if;
+        else
+          Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " (single dependency) failed because list of scalar variables("
+          + intString(scal_size) + ") " + List.toString(scalarized, ComponentRef.toString)
+          + ", does not fit the equation size " + intString(size) + ".\n"});
+          fail();
+        end if;
 
-    elseif List.any(regulars, Util.id) then
-      // II.2 mixed regularity - find all necessary configurations and add them to a map with a proper key
-      // 1. get the cref subscripts and dimensions as well as the equation dimensions (they have to match in length)
-      subs    := ComponentRef.subscriptsAllWithWholeFlat(cref);
-      dims    := Type.arrayDims(ComponentRef.getSubscriptedType(cref));
-      eq_dims := Type.arrayDims(ty);
-      if listLength(subs) == listLength(dims) and listLength(subs) == listLength(regulars) and listLength(subs) == listLength(eq_dims) then
-        // 2. create a map that maps a configuration key to the corresponding scalar crefs
-        stripped  := ComponentRef.stripSubscriptsAll(cref);
-        key       := arrayCreate(listLength(subs), 0);
-        map1      := UnorderedMap.new<Val1>(keyHash, keyEqual);
-        resolveReductions(List.zip3(subs, dims, regulars), map1, key, stripped);
-
-        // 3. create a map that maps a configuration key to the final variable indices
-        map2      := UnorderedMap.new<Val2>(keyHash, keyEqual);
-        for k in UnorderedMap.keyList(map1) loop
-          scalarized := UnorderedMap.getSafe(k, map1, sourceInfo());
-          scal_lst := List.flatten(list(getCrefInFrameIndices(scal, frames, mapping, map) for scal in scalarized));
-          UnorderedMap.add(k, scal_lst, map2);
-        end for;
+      elseif List.any(regulars, Util.id) then
+        // II.2 mixed regularity - find all necessary configurations and add them to a map with a proper key
+        // 1. get the cref subscripts and dimensions as well as the equation dimensions (they have to match in length)
+        subs    := ComponentRef.subscriptsAllWithWholeFlat(cref);
+        dims    := Type.arrayDims(ComponentRef.getSubscriptedType(cref));
+        eq_dims := Type.arrayDims(ty);
+        if listLength(subs) == listLength(dims) and listLength(subs) == listLength(regulars) and listLength(subs) == listLength(eq_dims) then
+          // 2. create a map that maps a configuration key to the corresponding scalar crefs
+          stripped  := ComponentRef.stripSubscriptsAll(cref);
+          key       := arrayCreate(listLength(subs), 0);
+          map1      := UnorderedMap.new<Val1>(keyHash, keyEqual);
+          resolveReductions(List.zip3(subs, dims, regulars), map1, key, stripped);
+
+          // 3. create a map that maps a configuration key to the final variable indices
+          map2      := UnorderedMap.new<Val2>(keyHash, keyEqual);
+          for k in UnorderedMap.keyList(map1) loop
+            scalarized := UnorderedMap.getSafe(k, map1, sourceInfo());
+            scal_lst := List.flatten(list(getCrefInFrameIndices(scal, frames, mapping, map) for scal in scalarized));
+            UnorderedMap.add(k, scal_lst, map2);
+          end for;
 
-        // 4. iterate over all equation dimensions and use the map to get the correct dependencies
-        key := arrayCreate(listLength(subs), 0);
-        resolveEquationDimensions(List.zip(eq_dims, regulars), map2, key, m, modes, Mode.create(eqn_name, {cref}, false), Pointer.create(skip_idx));
-      else
-        Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because subscripts, dimensions and dependencies were not of equal length.\n"
-          + "variable subscripts(" + intString(listLength(subs)) + "): " + List.toString(subs, Subscript.toString) + "\n"
-          + "variable dimensions(" + intString(listLength(dims)) + "): " + List.toString(dims, Dimension.toString) + "\n"
-          + "equation dimensions(" + intString(listLength(eq_dims)) + "): " + List.toString(eq_dims, Dimension.toString) + "\n"
-          + "variable dependencies(" + intString(listLength(regulars)) + "): " + List.toString(regulars, boolString) + "\n"});
-        fail();
-      end if;
+          // 4. iterate over all equation dimensions and use the map to get the correct dependencies
+          key := arrayCreate(listLength(subs), 0);
+          resolveEquationDimensions(List.zip(eq_dims, regulars), map2, key, m, modes, Mode.create(eqn_name, {cref}, false), Pointer.create(skip_idx));
+        else
+          Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because subscripts, dimensions and dependencies were not of equal length.\n"
+            + "variable subscripts(" + intString(listLength(subs)) + "): " + List.toString(subs, Subscript.toString) + "\n"
+            + "variable dimensions(" + intString(listLength(dims)) + "): " + List.toString(dims, Dimension.toString) + "\n"
+            + "equation dimensions(" + intString(listLength(eq_dims)) + "): " + List.toString(eq_dims, Dimension.toString) + "\n"
+            + "variable dependencies(" + intString(listLength(regulars)) + "): " + List.toString(regulars, boolString) + "\n"});
+          fail();
+        end if;
 
-    else
-      // II.3 all reduced - full dependency per row. scalarize and add to all rows of the equation
-      repeated    := UnorderedSet.contains(cref, rep);
-      scalarized  := listReverse(ComponentRef.scalarizeAll(cref));
-      map3        := UnorderedMap.new<Val2>(ComponentRef.hash, ComponentRef.isEqual);
-      for scal in scalarized loop
-        UnorderedMap.add(scal, getCrefInFrameIndices(scal, frames, mapping, map), map3);
-      end for;
+      else
+        // II.3 all reduced - full dependency per row. scalarize and add to all rows of the equation
+        repeated    := UnorderedSet.contains(cref, rep);
+        scalarized  := listReverse(ComponentRef.scalarizeAll(cref));
+        map3        := UnorderedMap.new<Val2>(ComponentRef.hash, ComponentRef.isEqual);
+        for scal in scalarized loop
+          UnorderedMap.add(scal, getCrefInFrameIndices(scal, frames, mapping, map), map3);
+        end for;
 
-      // if its repeated, use the same cref always
-      if repeated then
-        mode := Mode.create(eqn_name, {cref}, false);
-      end if;
+        // if its repeated, use the same cref always
+        if repeated then
+          mode := Mode.create(eqn_name, {cref}, false);
+        end if;
 
-      for i in skip_idx:iter_size:skip_idx+size-iter_size loop
-        shift := 0;
-        for scal in scalarized loop
-          // if its not repeated use local cref
-          if not repeated then
-            mode := Mode.create(eqn_name, {scal}, true);
-          end if;
-          for scal_idx in UnorderedMap.getSafe(scal, map3, sourceInfo()) loop
-            if intMod(shift, iter_size) == 0 then shift := 0; end if;
-            addMatrixEntry(m, modes, i + shift, scal_idx, mode);
-            shift := shift + 1;
+        for i in skip_idx:iter_size:skip_idx+size-iter_size loop
+          shift := 0;
+          for scal in scalarized loop
+            // if its not repeated use local cref
+            if not repeated then
+              mode := Mode.create(eqn_name, {scal}, true);
+            end if;
+            for scal_idx in UnorderedMap.getSafe(scal, map3, sourceInfo()) loop
+              if intMod(shift, iter_size) == 0 then shift := 0; end if;
+              addMatrixEntry(m, modes, i + shift, scal_idx, mode);
+              shift := shift + 1;
+            end for;
           end for;
         end for;
-      end for;
-    end if;
+      end if;
+    else
+      Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed for: " + ComponentRef.toString(cref) + "."});
+      fail();
+    end try;
   end resolveDependency;
 
   function resolveEquationDimensions
