Add compiler support for RTI-driven transient federate launch

.github/workflows/only-cpp.yml

@@ -24,7 +24,3 @@ jobs:
     uses: ./.github/workflows/cpp-tests.yml
     with:
       all-platforms: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
-
-  # Run the C++ integration tests on ROS2.
-  cpp-ros2-tests:
-    uses: ./.github/workflows/cpp-ros2-tests.yml

.github/workflows/trace-plugin-tests.yml

@@ -0,0 +1,19 @@
+name: Trace plugin tests
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [synchronize, opened, reopened, ready_for_review, converted_to_draft]
+  workflow_dispatch:
+
+concurrency:
+  group: trace-plugin-${{ github.ref }}-${{ github.run_id }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
+
+jobs:
+  trace-plugin-tests:
+    uses: lf-lang/lf-trace-xronos/.github/workflows/ci.yml@main
+    with:
+      lf-ref: ${{ github.event.pull_request.head.sha || github.sha }}

core/src/integrationTest/java/org/lflang/tests/runtime/CCliTest.java

@@ -0,0 +1,137 @@
+package org.lflang.tests.runtime;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.lflang.target.Target;
+import org.lflang.tests.LFTest;
+import org.lflang.tests.LFTest.Result;
+import org.lflang.tests.TestBase;
+import org.lflang.tests.TestError;
+import org.lflang.util.LFCommand;
+
+/**
+ * Integration tests for command-line parameter override functionality.
+ *
+ * <p>Verifies that main reactor parameters can be overridden via command-line arguments and that
+ * the overridden values propagate correctly to child reactors, including timers and deadlines.
+ *
+ * <p>Uses a ThreadLocal so that the CLI arguments set in each test method are visible to the
+ * runner instance created reflectively by {@link TestBase#runSingleTestAndPrintResults}, which
+ * executes on the same thread.  This is safe for concurrent test execution.
+ *
+ * @author Edward A. Lee
+ */
+public class CCliTest extends TestBase {
+
+  private static final ThreadLocal<List<String>> cliArgs = ThreadLocal.withInitial(List::of);
+
+  @AfterEach
+  void resetCliArgs() {
+    cliArgs.remove();
+  }
+
+  public CCliTest() {
+    super(Target.C);
+  }
+
+  @Override
+  protected ProcessBuilder getExecCommand(LFTest test) throws TestError {
+    LFCommand command = test.getFileConfig().getCommand();
+    if (command == null) {
+      throw new TestError("File: " + test.getFileConfig().getExecutable(), Result.NO_EXEC_FAIL);
+    }
+    List<String> cmdList = new ArrayList<>(command.command());
+    cmdList.addAll(cliArgs.get());
+    return new ProcessBuilder(cmdList).directory(command.directory());
+  }
+
+  /**
+   * Test that --period, --expected, and --value override timer behavior and double parameter.
+   * With defaults (period=1s, expected=6, value=3.14159), overriding to period=500ms changes
+   * the firing count to 11, and overriding value=2.71828 changes the double sent on each output.
+   */
+  @Test
+  public void testCommandLineParameterOverride() {
+    cliArgs.set(List.of("--period", "500", "msec", "--expected", "11", "--value", "2.71828"));
+    Path testFile = Path.of("test/C/src/CommandLineParam.lf").toAbsolutePath();
+    LFTest test = new LFTest(testFile);
+    runSingleTestAndPrintResults(test, CCliTest.class, TestLevel.EXECUTION);
+  }
+
+  /**
+   * Test that --min_delay and --min_spacing override action timing. With defaults (min_delay=1ns,
+   * min_spacing=10ns), overriding to min_delay=10us and min_spacing=100us changes when the action
+   * fires. The test verifies that elapsed times match the overridden values.
+   */
+  @Test
+  public void testCommandLineActionOverride() {
+    cliArgs.set(List.of("--min_delay", "10", "us", "--min_spacing", "100", "us"));
+    Path testFile = Path.of("test/C/src/CommandLineAction.lf").toAbsolutePath();
+    LFTest test = new LFTest(testFile);
+    runSingleTestAndPrintResults(test, CCliTest.class, TestLevel.EXECUTION);
+  }
+
+  /**
+   * Test that --deadline_time and --execution_time override deadline behavior. With defaults
+   * (execution_time=100ms, deadline_time=50ms) a deadline violation occurs. The CLI override
+   * sets execution_time=10ms and deadline_time=200ms, so NO violation occurs, proving both
+   * overrides took effect.
+   */
+  @Test
+  public void testCommandLineDeadlineOverride() {
+    cliArgs.set(
+        List.of(
+            "--execution_time",
+            "10",
+            "msec",
+            "--deadline_time",
+            "500",
+            "msec",
+            "--expect_violation",
+            "0"));
+    Path testFile = Path.of("test/C/src/CommandLineDeadline.lf").toAbsolutePath();
+    LFTest test = new LFTest(testFile);
+    runSingleTestAndPrintResults(test, CCliTest.class, TestLevel.EXECUTION);
+  }
+
+  /**
+   * Test that --value and --use_default override string and bool parameters.
+   * With default use_default=false and value="Hello, world!", overriding value to "Goodbye!"
+   * should cause the Print reactor to expect "Goodbye!".
+   * Running with --use_default true should ignore the value parameter and use the hardcoded default.
+   */
+  @Test
+  public void testCommandLineStringBoolOverride() {
+    cliArgs.set(List.of("--value", "Goodbye!", "--use_default", "false"));
+    Path testFile = Path.of("test/C/src/CommandLineStringBool.lf").toAbsolutePath();
+    LFTest test = new LFTest(testFile);
+    runSingleTestAndPrintResults(test, CCliTest.class, TestLevel.EXECUTION);
+  }
+
+  /**
+   * Test that CLI overrides propagate through the launch script in federated execution. With
+   * defaults (execution_time=100ms, deadline_time=50ms) a deadline violation occurs. The CLI
+   * override sets execution_time=10ms and deadline_time=500ms with expect_violation=0, so
+   * NO violation occurs, proving the launch script forwards arguments to federates.
+   */
+  @Test
+  public void testCommandLineDeadlineFederatedOverride() {
+    cliArgs.set(
+        List.of(
+            "--execution_time",
+            "10",
+            "msec",
+            "--deadline_time",
+            "500",
+            "msec",
+            "--expect_violation",
+            "0"));
+    Path testFile =
+        Path.of("test/C/src/federated/CommandLineDeadlineFederated.lf").toAbsolutePath();
+    LFTest test = new LFTest(testFile);
+    runSingleTestAndPrintResults(test, CCliTest.class, TestLevel.EXECUTION);
+  }
+}

core/src/main/java/org/lflang/AttributeUtils.java

@@ -187,6 +187,11 @@ public static boolean isSparse(EObject node) {
     return findAttributeByName(node, "sparse") != null;
   }
 
+  /** Return true if the node has an {@code @transient} attribute. */
+  public static boolean isTransient(Instantiation node) {
+    return findAttributeByName(node, "transient") != null;
+  }
+
   /**
    * Return true if the reactor is marked to be a federate.
    *

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

@@ -467,7 +467,7 @@ public String generatePortAbsentReactionBody(
                 + receivingPortID
                 + ", "
                 + connection.getDstFederate().id
-                + ", (long long) lf_time_logical_elapsed());",
+                + ", lf_time_logical_elapsed());",
             "if (" + sendRef + " == NULL || !" + sendRef + "->is_present) {",
             "LF_PRINT_LOG(\"The output port is NULL or it is not present.\");",
             "    lf_send_port_absent_to_federate("
@@ -556,15 +556,33 @@ protected String makePreamble(
     // that handles incoming network messages destined to the specified
     // port. This will only be used if there are federates.
     int numOfNetworkActions = federate.networkMessageActions.size();
+    int numZDCNetworkActions = federate.zeroDelayCycleNetworkMessageActions.size();
     code.pr(
         """
         interval_t _lf_action_delay_table[%1$s];
         lf_action_base_t* _lf_action_table[%1$s];
         size_t _lf_action_table_size = %1$s;
-        lf_action_base_t* _lf_zero_delay_cycle_action_table[%2$s];
-        size_t _lf_zero_delay_cycle_action_table_size = %2$s;
         """
-            .formatted(numOfNetworkActions, federate.zeroDelayCycleNetworkMessageActions.size()));
+            .formatted(numOfNetworkActions));
+    if (numZDCNetworkActions > 0) {
+      code.pr(
+          """
+          lf_action_base_t* _lf_zero_delay_cycle_action_table[%1$s];
+          size_t _lf_zero_delay_cycle_action_table_size = %1$s;
+          uint16_t _lf_zero_delay_cycle_upstream_ids[%1$s];
+          bool _lf_zero_delay_cycle_upstream_disconnected[%1$s] = { false };
+          """
+              .formatted(numZDCNetworkActions));
+    } else {
+      // Make sure these symbols are defined, even though only size will be used.
+      code.pr(
+          """
+          lf_action_base_t** _lf_zero_delay_cycle_action_table = NULL;
+          size_t _lf_zero_delay_cycle_action_table_size = 0;
+          uint16_t* _lf_zero_delay_cycle_upstream_ids = NULL;
+          bool* _lf_zero_delay_cycle_upstream_disconnected = NULL;
+          """);
+    }
 
     int numOfNetworkReactions = federate.networkReceiverReactions.size();
     code.pr(
@@ -732,6 +750,25 @@ else if (globalSTP instanceof CodeExprImpl)
     }
     // Set global variable identifying the federate.
     code.pr("_lf_my_fed_id = " + federate.id + ";");
+    // Set indicator variable that specifies whether the federate is transient or not.
+    code.pr("_fed.is_transient = " + federate.isTransient + ";");
+
+    // Emit initialization code for _fed.port_to_transient_feds_mapping: for each output port,
+    // record the IDs of transient downstream federates so the runtime can look them up. 
+    int keyCount = 0;
+    for (String portName: federate.portNameTransientFedIdsMapping.keySet()) {
+      code.pr(String.format("_fed.port_to_transient_feds_mapping[%d].port_name = \"%s\" ;", keyCount, portName));
+      int numTransients = federate.portNameTransientFedIdsMapping.get(portName).size();
+      code.pr(String.format("_fed.port_to_transient_feds_mapping[%d].transient_fed_id = (uint16_t*)malloc(sizeof(uint16_t) * %d);", keyCount, numTransients));
+      int idCount = 0;
+      for(int fedId: federate.portNameTransientFedIdsMapping.get(portName)) {
+        code.pr(String.format("_fed.port_to_transient_feds_mapping[%d].transient_fed_id[%d] = %d;", keyCount, idCount, fedId));
+        idCount += 1;
+      }
+      code.pr(String.format("_fed.port_to_transient_feds_mapping[%d].num_of_transients = %d;", keyCount, idCount));
+      keyCount += 1;
+    }
+    code.pr(String.format("_fed.port_map_size = %d;",keyCount));
 
     // We keep separate record for incoming and outgoing p2p connections to allow incoming traffic
     // to be processed in a separate

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

@@ -60,7 +60,6 @@ public static String initializeTriggersForNetworkActions(
     CodeBuilder code = new CodeBuilder();
     if (!federate.networkMessageActions.isEmpty()) {
       var actionTableCount = 0;
-      var zeroDelayActionTableCount = 0;
       for (int i = 0; i < federate.networkMessageActions.size(); ++i) {
         // Find the corresponding ActionInstance.
         Action action = federate.networkMessageActions.get(i);
@@ -83,10 +82,17 @@ public static String initializeTriggersForNetworkActions(
         // Set the ID of the source federate.
         code.pr(
             trigger + ".source_id = " + federate.networkMessageSourceFederate.get(i).id + "; \\");
-        if (federate.zeroDelayCycleNetworkMessageActions.contains(action)) {
+        int j = federate.zeroDelayCycleNetworkMessageActions.indexOf(action);
+        if (j >= 0) {
+          var upstream = federate.zeroDelayCycleNetworkUpstreamFeds.get(j);
+          code.pr("_lf_zero_delay_cycle_upstream_ids[" + j + "] = " + upstream.id + "; \\");
+          if (upstream.isTransient) {
+            // Transient federates are assumed to be initially disconnected.
+            code.pr("_lf_zero_delay_cycle_upstream_disconnected[" + j + "] = true; \\");
+          }
           code.pr(
               "_lf_zero_delay_cycle_action_table["
-                  + zeroDelayActionTableCount++
+                  + j
                   + "] = (lf_action_base_t*)&"
                   + trigger
                   + "; \\");
@@ -152,7 +158,8 @@ public static String stpStructs(FederateInstance federate) {
    */
   public static String createPortStatusFieldForInput(Input input) {
     StringBuilder builder = new StringBuilder();
-    // If it is not a multiport, then we could re-use the port trigger, and nothing needs to be done
+    // If it is not a multiport, then we could re-use the port trigger, and nothing
+    // needs to be done
     if (ASTUtils.isMultiport(input)) {
       // If it is a multiport, then create an auxiliary list of port
       // triggers for each channel of
@@ -241,12 +248,13 @@ static boolean clockSyncIsOn(FederateInstance federate, RtiConfig rtiConfig) {
    *
    * <p>Clock synchronization can be enabled using the clock-sync target property.
    *
-   * @see <a
-   *     href="https://github.com/icyphy/lingua-franca/wiki/Distributed-Execution#clock-synchronization">Documentation</a>
+   * @see <a href=
+   *     "https://github.com/icyphy/lingua-franca/wiki/Distributed-Execution#clock-synchronization">Documentation</a>
    */
   public static void initializeClockSynchronization(
       FederateInstance federate, RtiConfig rtiConfig, MessageReporter messageReporter) {
-    // Check if clock synchronization should be enabled for this federate in the first place
+    // Check if clock synchronization should be enabled for this federate in the
+    // first place
     if (clockSyncIsOn(federate, rtiConfig)) {
       messageReporter
           .nowhere()
@@ -272,8 +280,8 @@ public static void initializeClockSynchronization(
    *
    * <p>Clock synchronization can be enabled using the clock-sync target property.
    *
-   * @see <a
-   *     href="https://github.com/icyphy/lingua-franca/wiki/Distributed-Execution#clock-synchronization">Documentation</a>
+   * @see <a href=
+   *     "https://github.com/icyphy/lingua-franca/wiki/Distributed-Execution#clock-synchronization">Documentation</a>
    */
   public static void addClockSyncCompileDefinitions(FederateInstance federate) {
 
@@ -316,8 +324,15 @@ public static void generateCMakeInclude(
         "add_compile_definitions(LF_SOURCE_DIRECTORY=\"" + fileConfig.srcPath + "\")");
     cmakeIncludeCode.pr(
         "add_compile_definitions(LF_PACKAGE_DIRECTORY=\"" + fileConfig.srcPkgPath + "\")");
+    // After federates have been divided, their root package directory is different.
     cmakeIncludeCode.pr(
-        "add_compile_definitions(LF_SOURCE_GEN_DIRECTORY=\"" + fileConfig.getSrcGenPath() + "\")");
+        "add_compile_definitions(LF_FED_PACKAGE_DIRECTORY=\""
+            + fileConfig.srcPkgPath
+            + File.separator
+            + "fed-gen"
+            + File.separator
+            + fileConfig.name
+            + "\")");
     cmakeIncludeCode.pr("add_compile_definitions(LF_FILE_SEPARATOR=\"" + File.separator + "\")");
     try (var srcWriter = Files.newBufferedWriter(cmakeIncludePath)) {
       srcWriter.write(cmakeIncludeCode.getCode());

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

@@ -306,9 +306,10 @@ private static void addNetworkReceiverReactor(
     connection.dstFederate.networkMessageSourceFederate.add(connection.srcFederate);
     connection.dstFederate.networkMessageActionDelays.add(connection.getDefinition().getDelay());
     if (connection.srcFederate.isInZeroDelayCycle()
-        && connection.getDefinition().getDelay() == null)
+        && connection.getDefinition().getDelay() == null) {
       connection.dstFederate.zeroDelayCycleNetworkMessageActions.add(networkAction);
-
+      connection.dstFederate.zeroDelayCycleNetworkUpstreamFeds.add(connection.srcFederate);
+    }
     // Get the largest STAA for any reaction triggered by the destination port.
     TimeValue maxSTAA = findMaxSTAA(connection, coordination);