Merge pull request #1293 from lf-lang/ts-tan

Added advance-message-interval option and more federated tests for TypeScript

org.lflang/src/org/lflang/TargetProperty.java

@@ -247,7 +247,7 @@ public enum TargetProperty {
      * Key-value pairs giving options for clock synchronization.
      */
     COORDINATION_OPTIONS("coordination-options",
-            DictionaryType.COORDINATION_OPTION_DICT, Arrays.asList(Target.C, Target.CCPP, Target.Python),
+            DictionaryType.COORDINATION_OPTION_DICT, Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS),
             (config, value, err) -> {
                 for (KeyValuePair entry : value.getKeyvalue().getPairs()) {
                     CoordinationOption option = (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT

org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt

@@ -1,6 +1,7 @@
 package org.lflang.generator.ts
 
 import org.lflang.ErrorReporter
+import org.lflang.TargetConfig
 import org.lflang.federated.FederateInstance
 import org.lflang.generator.PrependOperator
 import org.lflang.lf.Action
@@ -20,7 +21,8 @@ class TSConstructorGenerator (
     private val tsGenerator: TSGenerator,
     private val errorReporter: ErrorReporter,
     private val reactor : Reactor,
-    private val federate: FederateInstance
+    private val federate: FederateInstance,
+    private val targetConfig: TargetConfig
 ) {
     private fun getInitializerList(param: Parameter): List<String> =
         tsGenerator.getInitializerListW(param)
@@ -105,6 +107,17 @@ class TSConstructorGenerator (
         return connectionInstantiations.joinToString("\n")
     }
 
+    // Generate code for setting target configurations.
+    private fun generateTargetConfigurations(): String {
+        val targetConfigurations = LinkedList<String>()
+        if ((reactor.isMain || reactor.isFederated) &&
+            targetConfig.coordinationOptions.advance_message_interval != null) {
+            targetConfigurations.add(
+                "this.setAdvanceMessageInterval(${timeInTargetLanguage(targetConfig.coordinationOptions.advance_message_interval)})")
+        }
+        return targetConfigurations.joinToString("\n")
+    }
+
     // Generate code for registering Fed IDs that are connected to
     // this federate via ports in the TypeScript's FederatedApp.
     // These Fed IDs are used to let the RTI know about the connections
@@ -140,6 +153,7 @@ class TSConstructorGenerator (
             ${" |    "..generateConstructorArguments(reactor)}
                 |) {
             ${" |    "..generateSuperConstructorCall(reactor, federate)}
+            ${" |    "..generateTargetConfigurations()}
             ${" |    "..generateFederateConfigurations()}
             ${" |    "..instances.generateInstantiations()}
             ${" |    "..timers.generateInstantiations()}

org.lflang/src/org/lflang/generator/ts/TSExtensions.kt

@@ -1,5 +1,6 @@
 package org.lflang.generator.ts
 
+import org.lflang.TimeValue
 import org.lflang.isBank
 import org.lflang.isMultiport
 import org.lflang.lf.Action
@@ -64,3 +65,12 @@ fun getActionType(action: Action): String {
         return "Present"
     }
 }
+
+fun timeInTargetLanguage(value: TimeValue): String {
+    return if (value.unit != null) {
+        "TimeValue.${value.unit.canonicalName}(${value.time})"
+    } else {
+        // The value must be zero.
+        "TimeValue.zero()"
+    }
+}

org.lflang/src/org/lflang/generator/ts/TSGenerator.kt

@@ -313,7 +313,7 @@ class TSGenerator(
         val (mainParameters, parameterCode) = parameterGenerator.generateParameters()
         tsCode.append(parameterCode)
 
-        val reactorGenerator = TSReactorGenerator(this, errorReporter)
+        val reactorGenerator = TSReactorGenerator(this, errorReporter, targetConfig)
         for (reactor in reactors) {
             tsCode.append(reactorGenerator.generateReactor(reactor, federate))
         }

org.lflang/src/org/lflang/generator/ts/TSParameterPreambleGenerator.kt

@@ -31,7 +31,6 @@ import org.lflang.TimeValue
 import org.lflang.generator.PrependOperator
 import org.lflang.lf.Parameter
 import org.lflang.lf.Reactor
-import org.lflang.TimeUnit
 import java.util.StringJoiner
 
 /**
@@ -60,15 +59,6 @@ class TSParameterPreambleGenerator(
         }
     }
 
-    private fun timeInTargetLanguage(value: TimeValue): String {
-        return if (value.unit != null) {
-            "TimeValue.${value.unit.canonicalName}(${value.time})"
-        } else {
-            // The value must be zero.
-            "TimeValue.zero()"
-        }
-    }
-
     private fun getParameters(): List<Parameter> {
         var mainReactor: Reactor? = null
         for (reactor in reactors) {

org.lflang/src/org/lflang/generator/ts/TSReactorGenerator.kt

@@ -18,7 +18,8 @@ import java.util.*
  */
 class TSReactorGenerator(
     private val tsGenerator: TSGenerator,
-    private val errorReporter: ErrorReporter
+    private val errorReporter: ErrorReporter,
+    private val targetConfig: TargetConfig
 ) {
     // Initializer functions
     fun getTargetInitializerHelper(param: Parameter,
@@ -93,6 +94,22 @@ class TSReactorGenerator(
             }
         }
 
+        if (minOutputDelay != TimeValue.MAX_VALUE && targetConfig.coordinationOptions.advance_message_interval == null) {
+            // There is a path from a physical action to output for reactor but advance message interval is not set.
+            // Report a warning.
+            errorReporter.reportWarning(
+                """
+                    Found a path from a physical action to output for reactor ${defn.name}.
+                    The amount of delay is $minOutputDelay.
+                    With centralized coordination, this can result in a large number of messages to the RTI.
+                    Consider refactoring the code so that the output does not depend on the physical action,
+                    or consider using decentralized coordination. To silence this warning, set the target
+                    parameter coordination-options with a value like {advance-message-interval: 10 msec}
+                """.trimIndent()
+            )
+
+        }
+
         return with(PrependOperator) {
                 """
             |// ************* Starting Runtime for ${defn.name} + of class ${defn.reactorClass.name}.
@@ -143,7 +160,7 @@ class TSReactorGenerator(
         val actionGenerator = TSActionGenerator(tsGenerator, reactor.actions, federate)
         val portGenerator = TSPortGenerator(reactor.inputs, reactor.outputs)
 
-        val constructorGenerator = TSConstructorGenerator(tsGenerator, errorReporter, reactor, federate)
+        val constructorGenerator = TSConstructorGenerator(tsGenerator, errorReporter, reactor, federate, targetConfig)
         return with(PrependOperator) {
             """
                 |// =============== START reactor class ${reactor.name}

test/TypeScript/src/federated/DistributedDoublePort.lf

@@ -0,0 +1,56 @@
+/**
+ * Test the case for when two upstream federates
+ * send messages to a downstream federte on two
+ * different ports. One message should carry a
+ * microstep delay relative to the other
+ * message.
+ *
+ * @author Soroush Bateni
+ * @author Hokeun Kim
+ */
+target TypeScript {
+    timeout: 900 msec,
+    coordination-options: {advance-message-interval: 100 msec},
+    logging: DEBUG
+};
+
+import Count from "../lib/Count.lf";
+
+reactor CountMicrostep {
+    state count:number(1);
+    output out:number;
+    logical action act:number;
+    timer t(0, 1 sec);
+    reaction(t) -> act {=
+        actions.act.schedule(0, count++);
+    =}
+
+    reaction(act) -> out {=
+        out = act;
+    =}
+}
+
+reactor Print {
+    input inp:number;
+    input inp2:number;
+    reaction(inp, inp2) {=
+        const elapsedTime = util.getElapsedLogicalTime();
+        console.log("At tag " + elapsedTime + ", microstep:" + util.getCurrentTag().microstep +
+            ", received inp = " + inp + " and inp2 = " + inp2 + ".");
+        if (inp !== undefined && inp2 !== undefined) {
+            util.requestErrorStop("ERROR: invalid logical simultaneity.");
+        }
+    =}
+
+    reaction(shutdown) {=
+        console.log("SUCCESS: messages were at least one microstep apart.");
+    =}
+}
+
+federated reactor DistributedDoublePort {
+    c = new Count();
+    cm = new CountMicrostep();
+    p = new Print();
+    c.out -> p.inp;    // Indicating a 'logical' connection.
+    cm.out -> p.inp2;
+}

test/TypeScript/src/federated/LoopDistributedDouble.lf

@@ -6,7 +6,8 @@
  * @author Hokeun Kim
  */
 target TypeScript {
-    timeout: 5 sec
+    timeout: 5 sec,
+    coordination-options: {advance-message-interval: 100 msec}
 }
 
 reactor Looper(incr:number(1), delay:time(0 msec)) {

test/TypeScript/src/federated/SimpleFederated.lf

@@ -0,0 +1,14 @@
+target TypeScript {
+    timeout: 2 secs
+};
+reactor Fed {
+    input inp:number;
+    output out:number;
+}
+federated reactor {
+    fed1 = new Fed();
+    fed2 = new Fed();
+
+    fed1.out -> fed2.inp;
+    fed2.out -> fed1.inp;
+}