Merge pull request #2400 from lf-lang/rti-DNET

A target property for handling `downstream next event tag` (`DNET`) signal

.github/workflows/ts-tests.yml

@@ -38,8 +38,7 @@ jobs:
         if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }}
       - name: Perform TypeScript tests
         run: |
-          ./gradlew targetTest -Ptarget=TypeScript
-        # -Druntime="git://github.com/lf-lang/reactor-ts.git#master"
+          ./gradlew targetTest -Ptarget=TypeScript -Druntime="git://github.com/lf-lang/reactor-ts.git#master"
       - name: Report to CodeCov
         uses: ./.github/actions/report-code-coverage
         with:

core/src/main/java/org/lflang/federated/extensions/CExtension.java

@@ -43,6 +43,7 @@
 import org.lflang.federated.generator.FederationFileConfig;
 import org.lflang.federated.launcher.RtiConfig;
 import org.lflang.federated.serialization.FedROS2CPPSerialization;
+import org.lflang.generator.ActionInstance;
 import org.lflang.generator.CodeBuilder;
 import org.lflang.generator.LFGeneratorContext;
 import org.lflang.generator.ReactorInstance;
@@ -60,6 +61,7 @@
 import org.lflang.target.property.ClockSyncOptionsProperty;
 import org.lflang.target.property.CoordinationOptionsProperty;
 import org.lflang.target.property.CoordinationProperty;
+import org.lflang.target.property.DNETProperty;
 import org.lflang.target.property.FedSetupProperty;
 import org.lflang.target.property.KeepaliveProperty;
 import org.lflang.target.property.SingleThreadedProperty;
@@ -833,6 +835,22 @@ private String generateCodeForPhysicalActions(
           outputFound = output;
         }
       }
+      if (federate.targetConfig.getOrDefault(DNETProperty.INSTANCE)) {
+        ActionInstance found = federate.findPhysicalAction(instance);
+        if (found != null) {
+          String warning =
+              String.join(
+                  "\n",
+                  "Found a physical action inside the federate "
+                      + addDoubleQuotes(instance.getName()),
+                  "and a signal downstream next event tag (DNET) will be used.",
+                  "The signal DNET may increase the lag, the time difference between ",
+                  "the time this physical action is scheduled and the time it is executed, ",
+                  "specifically when this federate has multiple upstream reactors.",
+                  "Consider disabling the signal DNET with a property {DNET: false}.");
+          messageReporter.at(found.getDefinition()).warning(warning);
+        }
+      }
       if (minDelay != TimeValue.MAX_VALUE) {
         // Unless silenced, issue a warning.
         if (coordinationOptions.advanceMessageInterval == null) {

core/src/main/java/org/lflang/federated/generator/FederateInstance.java

@@ -647,6 +647,27 @@ private boolean containsAllVarRefs(Iterable<VarRef> varRefs) {
     return inFederate;
   }
 
+  /**
+   * Return the first found physical action or null if there is no physical action in this federate.
+   *
+   * @param instance The reactor instance to check whether there is a physical action.
+   */
+  public ActionInstance findPhysicalAction(ReactorInstance instance) {
+    for (ActionInstance action : instance.actions) {
+      if (action.isPhysical()) {
+        return action;
+      }
+    }
+    for (ReactorInstance child : instance.children) {
+      for (ActionInstance action : child.actions) {
+        if (action.isPhysical()) {
+          return action;
+        }
+      }
+    }
+    return null;
+  }
+
   /**
    * Find output ports that are connected to a physical action trigger upstream in the same reactor.
    * Return a list of such outputs paired with the minimum delay from the nearest physical action.

core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java

@@ -40,6 +40,7 @@
 import org.lflang.target.property.AuthProperty;
 import org.lflang.target.property.ClockSyncModeProperty;
 import org.lflang.target.property.ClockSyncOptionsProperty;
+import org.lflang.target.property.DNETProperty;
 import org.lflang.target.property.TracingProperty;
 import org.lflang.target.property.type.ClockSyncModeType.ClockSyncMode;
 
@@ -323,6 +324,9 @@ private String getRtiCommand(List<FederateInstance> federates, boolean isRemote)
     if (targetConfig.getOrDefault(TracingProperty.INSTANCE).isEnabled()) {
       commands.add("                        -t \\");
     }
+    if (!targetConfig.getOrDefault(DNETProperty.INSTANCE)) {
+      commands.add("                        -d \\");
+    }
     commands.addAll(
         List.of(
             "                        -n " + federates.size() + " \\",

core/src/main/java/org/lflang/target/Target.java

@@ -560,6 +560,7 @@ public void initialize(TargetConfig config) {
               CompilerProperty.INSTANCE,
               CoordinationOptionsProperty.INSTANCE,
               CoordinationProperty.INSTANCE,
+              DNETProperty.INSTANCE,
               DockerProperty.INSTANCE,
               FilesProperty.INSTANCE,
               KeepaliveProperty.INSTANCE,

core/src/main/java/org/lflang/target/property/DNETProperty.java

@@ -0,0 +1,27 @@
+package org.lflang.target.property;
+
+/**
+ * @brief Target property turning on or off the DNET signal optimization.
+ *     <p>If this target property is true, the RTI sends DNET (downstream next event tag) signals to
+ *     an upstream federate to tell the federate that sending LTC and NET signals with tags less
+ *     than the specified value is unnecessary. The default is true.
+ */
+public final class DNETProperty extends BooleanProperty {
+
+  /** Singleton target property instance. */
+  public static final DNETProperty INSTANCE = new DNETProperty();
+
+  private DNETProperty() {
+    super();
+  }
+
+  @Override
+  public Boolean initialValue() {
+    return true;
+  }
+
+  @Override
+  public String name() {
+    return "DNET";
+  }
+}