[NF] Implement evaluation of cardinality.

Belonging to [master]:
  - #2549
  - OpenModelica/OpenModelica-testsuite#994

Author: perost

Compiler/NFFrontEnd/NFBuiltinCall.mo

@@ -60,6 +60,7 @@ protected
   import Util;
   import ExpandExp = NFExpandExp;
   import Operator = NFOperator;
+  import NFComponent.Component;
 
 public
   function needSpecialHandling
@@ -1259,6 +1260,7 @@ protected
     list<NamedArg> named_args;
     Expression arg;
     Function fn;
+    InstNode node;
   algorithm
     Call.UNTYPED_CALL(ref = fn_ref, arguments = args, named_args = named_args) := call;
     assertNoNamedParams("cardinality", named_args, info);
@@ -1280,7 +1282,9 @@ protected
         {"First", ComponentRef.toString(fn_ref), "<REMOVE ME>"}, info);
     end if;
 
-    if not Type.isConnector(ty) then
+    node := ComponentRef.node(Expression.toCref(arg));
+
+    if not (Type.isScalar(ty) and InstNode.isComponent(node) and Component.isConnector(InstNode.component(node))) then
       Error.addSourceMessageAndFail(Error.ARG_TYPE_MISMATCH,
         {"1", ComponentRef.toString(fn_ref), "",
          Expression.toString(arg), Type.toString(ty), "connector"}, info);

Compiler/NFFrontEnd/NFCardinalityTable.mo

@@ -0,0 +1,141 @@
+/*
+ * This file is part of OpenModelica.
+ *
+ * Copyright (c) 1998-2014, Open Source Modelica Consortium (OSMC),
+ * c/o Linköpings universitet, Department of Computer and Information Science,
+ * SE-58183 Linköping, Sweden.
+ *
+ * All rights reserved.
+ *
+ * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF GPL VERSION 3 LICENSE OR
+ * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.2.
+ * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES
+ * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GPL VERSION 3,
+ * ACCORDING TO RECIPIENTS CHOICE.
+ *
+ * The OpenModelica software and the Open Source Modelica
+ * Consortium (OSMC) Public License (OSMC-PL) are obtained
+ * from OSMC, either from the above address,
+ * from the URLs: http://www.ida.liu.se/projects/OpenModelica or
+ * http://www.openmodelica.org, and in the OpenModelica distribution.
+ * GNU version 3 is obtained from: http://www.gnu.org/copyleft/gpl.html.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without
+ * even the implied warranty of  MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY SET FORTH
+ * IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF OSMC-PL.
+ *
+ * See the full OSMC Public License conditions for more details.
+ *
+ */
+
+encapsulated package NFCardinalityTable
+  import BaseHashTable;
+  import System;
+  import Connections = NFConnections;
+  import Connection = NFConnection;
+  import Connector = NFConnector;
+  import Expression = NFExpression;
+  import Util;
+
+  type Key = String;
+  type Value = Integer;
+  type Table = tuple<
+    array<list<tuple<Key, Integer>>>,
+    tuple<Integer, Integer, array<Option<tuple<Key, Value>>>>,
+    Integer,
+    tuple<FuncHash, FuncEq, FuncKeyStr, FuncValueStr>>;
+
+  partial function FuncHash
+    input Key key;
+    input Integer mod;
+    output Integer res;
+  end FuncHash;
+
+  partial function FuncEq
+    input Key key1;
+    input Key key2;
+    output Boolean res;
+  end FuncEq;
+
+  partial function FuncKeyStr
+    input Key key;
+    output String res;
+  end FuncKeyStr;
+
+  partial function FuncValueStr
+    input Value value;
+    output String res;
+  end FuncValueStr;
+
+  function emptyCardinalityTable
+    input Integer size;
+    output Table table;
+  algorithm
+    table := BaseHashTable.emptyHashTableWork(size, (System.stringHashDjb2Mod, stringEq, Util.id, intString));
+  end emptyCardinalityTable;
+
+  function fromConnections
+    input Connections conns;
+    output Table table;
+  algorithm
+    if System.getUsesCardinality() then
+      // Use the number of connections as the bucket size. The worst case is
+      // that each connector in the connections is unique, which would result in
+      // twice as many entries in the hash table as buckets. That should be
+      // fine, and real models usually have a higher degree of connectivity.
+      table := emptyCardinalityTable(max(1, Util.nextPrime(listLength(conns.connections))));
+
+      for conn in conns.connections loop
+        table := addConnector(conn.lhs, table);
+        table := addConnector(conn.rhs, table);
+      end for;
+    else
+      table := emptyCardinalityTable(1);
+    end if;
+  end fromConnections;
+
+  function addConnector
+    input Connector conn;
+    input output Table table;
+  protected
+    String conn_str;
+    Integer count;
+  algorithm
+    conn_str := Connector.toString(conn);
+
+    try
+      count := BaseHashTable.get(conn_str, table);
+      BaseHashTable.update((conn_str, count + 1), table);
+    else
+      table := BaseHashTable.add((conn_str, 1), table);
+    end try;
+  end addConnector;
+
+  function evaluateCardinality
+    input Expression arg;
+    input Table table;
+    output Expression res;
+  protected
+    Integer count;
+  algorithm
+    try
+      count := BaseHashTable.get(Expression.toString(arg), table);
+    else
+      count := 0;
+    end try;
+
+    res := Expression.INTEGER(count);
+  end evaluateCardinality;
+
+  function print
+    input Table table;
+  algorithm
+    for e in BaseHashTable.hashTableList(table) loop
+      print(Util.tuple21(e) + ": " + String(Util.tuple22(e)) + "\n");
+    end for;
+  end print;
+
+  annotation(__OpenModelica_Interface="frontend");
+end NFCardinalityTable;
+

Compiler/NFFrontEnd/NFConnectEquations.mo

@@ -41,6 +41,7 @@ import Connector = NFConnector;
 import DAE;
 import ConnectionSets = NFConnectionSets.ConnectionSets;
 import Equation = NFEquation;
+import CardinalityTable = NFCardinalityTable;
 
 protected
 import ComponentReference;
@@ -102,8 +103,10 @@ function evaluateOperators
   input output Expression exp;
   input ConnectionSets.Sets sets;
   input array<list<Connector>> setsArray;
+  input CardinalityTable.Table ctable;
 algorithm
-  exp := Expression.map(exp, function evaluateOperatorExp(sets = sets, setsArray = setsArray));
+  exp := Expression.map(exp,
+    function evaluateOperatorExp(sets = sets, setsArray = setsArray, ctable = ctable));
 end evaluateOperators;
 
 protected
@@ -545,6 +548,7 @@ function evaluateOperatorExp
   input Expression exp;
   input ConnectionSets.Sets sets;
   input array<list<Connector>> setsArray;
+  input CardinalityTable.Table ctable;
   output Expression evalExp;
 algorithm
   evalExp := match exp
@@ -554,9 +558,11 @@ algorithm
     case Expression.CALL(call = call as Call.TYPED_CALL())
       then match Function.name(call.fn)
         case Absyn.IDENT("inStream")
-          then evaluateInStream(Expression.toCref(listHead(call.arguments)), sets, setsArray);
+          then evaluateInStream(Expression.toCref(listHead(call.arguments)), sets, setsArray, ctable);
         //case Absyn.IDENT("actualStream")
         //  then evaluateActualStream(Expression.toCref(listHead(call.arguments)), sets, setsArray);
+        case Absyn.IDENT("cardinality")
+          then CardinalityTable.evaluateCardinality(listHead(call.arguments), ctable);
         else exp;
       end match;
 
@@ -569,6 +575,7 @@ function evaluateInStream
   input ComponentRef cref;
   input ConnectionSets.Sets sets;
   input array<list<Connector>> setsArray;
+  input CardinalityTable.Table ctable;
   output Expression exp;
 protected
   Connector c;
@@ -585,7 +592,7 @@ algorithm
     sl := {c};
   end try;
 
-  exp := generateInStreamExp(cref, sl, sets, setsArray,
+  exp := generateInStreamExp(cref, sl, sets, setsArray, ctable,
     Flags.getConfigReal(Flags.FLOW_THRESHOLD));
 end evaluateInStream;
 
@@ -596,6 +603,7 @@ function generateInStreamExp
   input list<Connector> streams;
   input ConnectionSets.Sets sets;
   input array<list<Connector>> setsArray;
+  input CardinalityTable.Table ctable;
   input Real flowThreshold;
   output Expression exp;
 protected
@@ -630,7 +638,7 @@ algorithm
         {Connector.CONNECTOR(name = cr)} :=
           removeStreamSetElement(streamCref, reducedStreams);
       then
-        evaluateInStream(cr, sets, setsArray);
+        evaluateInStream(cr, sets, setsArray, ctable);
 
     // The general case:
     else
@@ -639,7 +647,7 @@ algorithm
         inside := removeStreamSetElement(streamCref, inside);
         exp := streamSumEquationExp(outside, inside, Expression.REAL(flowThreshold));
         // Evaluate any inStream calls that were generated.
-        exp := evaluateOperatorExp(exp, sets, setsArray);
+        exp := evaluateOperatorExp(exp, sets, setsArray, ctable);
       then
         exp;
 

Compiler/NFFrontEnd/NFFlatten.mo

@@ -46,6 +46,7 @@ import Statement = NFStatement;
 import FlatModel = NFFlatModel;
 import Prefix;
 import Algorithm = NFAlgorithm;
+import CardinalityTable = NFCardinalityTable;
 
 protected
 import ComponentRef = NFComponentRef;
@@ -876,17 +877,19 @@ protected
   list<Equation> conn_eql;
   ConnectionSets.Sets csets;
   array<list<Connector>> csets_array;
+  CardinalityTable.Table ctable;
 algorithm
   // Generate the connect equations and add them to the equation list.
   (flatModel, conns) := Connections.collect(flatModel);
   csets := ConnectionSets.fromConnections(conns);
   csets_array := ConnectionSets.extractSets(csets);
   conn_eql := ConnectEquations.generateEquations(csets_array);
   flatModel.equations := listAppend(conn_eql, flatModel.equations);
+  ctable := CardinalityTable.fromConnections(conns);
 
   // Evaluate any connection operators if they're used.
   if System.getHasStreamConnectors() or System.getUsesCardinality() then
-    flatModel := evaluateConnectionOperators(flatModel, csets, csets_array);
+    flatModel := evaluateConnectionOperators(flatModel, csets, csets_array, ctable);
   end if;
 
   execStat(getInstanceName() + "(" + name + ")");
@@ -896,25 +899,27 @@ function evaluateConnectionOperators
   input output FlatModel flatModel;
   input ConnectionSets.Sets sets;
   input array<list<Connector>> setsArray;
+  input CardinalityTable.Table ctable;
 algorithm
-  flatModel.variables := list(evaluateBindingConnOp(c, sets, setsArray) for c in flatModel.variables);
-  flatModel.equations := evaluateEquationsConnOp(flatModel.equations, sets, setsArray);
-  flatModel.initialEquations := evaluateEquationsConnOp(flatModel.initialEquations, sets, setsArray);
+  flatModel.variables := list(evaluateBindingConnOp(c, sets, setsArray, ctable) for c in flatModel.variables);
+  flatModel.equations := evaluateEquationsConnOp(flatModel.equations, sets, setsArray, ctable);
+  flatModel.initialEquations := evaluateEquationsConnOp(flatModel.initialEquations, sets, setsArray, ctable);
   // TODO: Implement evaluation for algorithm sections.
 end evaluateConnectionOperators;
 
 function evaluateBindingConnOp
   input output Variable var;
   input ConnectionSets.Sets sets;
   input array<list<Connector>> setsArray;
+  input CardinalityTable.Table ctable;
 protected
   Binding binding;
   Expression exp, eval_exp;
 algorithm
   () := match var
     case Variable.VARIABLE(binding = binding as Binding.TYPED_BINDING(bindingExp = exp))
       algorithm
-        eval_exp := ConnectEquations.evaluateOperators(exp, sets, setsArray);
+        eval_exp := ConnectEquations.evaluateOperators(exp, sets, setsArray, ctable);
 
         if not referenceEq(exp, eval_exp) then
           binding.bindingExp := eval_exp;
@@ -931,9 +936,11 @@ function evaluateEquationsConnOp
   input output list<Equation> equations;
   input ConnectionSets.Sets sets;
   input array<list<Connector>> setsArray;
+  input CardinalityTable.Table ctable;
 algorithm
   equations := list(
-      Equation.mapExp(eq, function ConnectEquations.evaluateOperators(sets = sets, setsArray = setsArray))
+      Equation.mapExp(eq,
+        function ConnectEquations.evaluateOperators(sets = sets, setsArray = setsArray, ctable = ctable))
     for eq in equations);
 end evaluateEquationsConnOp;
 

Compiler/boot/LoadCompilerSources.mos

@@ -294,6 +294,7 @@ if true then /* Suppress output */
     "../NFFrontEnd/NFBuiltinCall.mo",
     "../NFFrontEnd/NFBuiltinFuncs.mo",
     "../NFFrontEnd/NFCall.mo",
+    "../NFFrontEnd/NFCardinalityTable.mo",
     "../NFFrontEnd/NFCeval.mo",
     "../NFFrontEnd/NFComplexType.mo",
     "../NFFrontEnd/NFComponent.mo",