Adding support of transient federates

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

@@ -234,6 +234,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. */
   public static boolean isFederate(Reactor reactor) {
     return findAttributeByName(reactor, "_fed_config") != null;

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

@@ -713,6 +713,8 @@ private String generateCodeToInitializeFederate(FederateInstance federate, RtiCo
     }
     // 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 + ";");
 
     // 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/generator/FederateInstance.java

@@ -36,6 +36,7 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import org.lflang.AttributeUtils;
 import org.lflang.MessageReporter;
 import org.lflang.TimeValue;
 import org.lflang.ast.ASTUtils;
@@ -95,6 +96,7 @@ public FederateInstance(
     this.bankWidth = bankWidth;
     this.messageReporter = messageReporter;
     this.targetConfig = targetConfig;
+    this.isTransient = AttributeUtils.isTransient(instantiation);
 
     // If the instantiation is in a bank, then we have to append
     // the bank index to the name.
@@ -156,6 +158,9 @@ public Instantiation getInstantiation() {
   /** The integer ID of this federate. */
   public int id;
 
+  /** Type of the federate: transient if true, and peristent if false . */
+  public boolean isTransient = false;
+
   /**
    * The name of this federate instance. This will be the instantiation name, possibly appended with
    * "__n", where n is the bank position of this instance if the instantiation is of a bank of

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

@@ -323,9 +323,17 @@ private String getRtiCommand(List<FederateInstance> federates, boolean isRemote)
     if (targetConfig.getOrDefault(TracingProperty.INSTANCE).isEnabled()) {
       commands.add("                        -t \\");
     }
+    // Identify the transient federates number
+    int transientFederatesNumber = 0;
+    for (FederateInstance federate : federates) {
+      if (federate.isTransient) {
+        transientFederatesNumber++;
+      }
+    }
     commands.addAll(
         List.of(
             "                        -n " + federates.size() + " \\",
+            "                        -nt " + transientFederatesNumber + " \\",
             "                        -c "
                 + targetConfig.getOrDefault(ClockSyncModeProperty.INSTANCE).toString()
                 + " \\"));

core/src/main/java/org/lflang/generator/c/CCompiler.java

@@ -219,13 +219,15 @@ private static List<String> cmakeOptions(TargetConfig targetConfig, FileConfig f
     String maybeQuote = ""; // Windows seems to require extra level of quoting.
     String srcPath = fileConfig.srcPath.toString(); // Windows requires escaping the backslashes.
     String rootPath = fileConfig.srcPkgPath.toString();
+    String binPath = fileConfig.binPath.toString();
     String srcGenPath = fileConfig.getSrcGenPath().toString();
     if (separator.equals("\\")) {
       separator = "\\\\\\\\";
       maybeQuote = "\\\"";
       srcPath = srcPath.replaceAll("\\\\", "\\\\\\\\");
       rootPath = rootPath.replaceAll("\\\\", "\\\\\\\\");
       srcGenPath = srcGenPath.replaceAll("\\\\", "\\\\\\\\");
+      binPath = binPath.replaceAll("\\\\", "\\\\\\\\");
     }
     arguments.addAll(
         List.of(
@@ -245,6 +247,8 @@ private static List<String> cmakeOptions(TargetConfig targetConfig, FileConfig f
       arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + srcPath + maybeQuote + "\"");
       arguments.add("-DLF_PACKAGE_DIRECTORY=\"" + maybeQuote + rootPath + maybeQuote + "\"");
       arguments.add("-DLF_SOURCE_GEN_DIRECTORY=\"" + maybeQuote + srcGenPath + maybeQuote + "\"");
+    } else {
+      arguments.add("-DLF_FEDERATES_BIN_DIRECTORY=\"" + maybeQuote + binPath + maybeQuote + "\"");
     }
     arguments.add(FileUtil.toUnixString(fileConfig.getSrcGenPath()));
 

core/src/main/java/org/lflang/validation/AttributeSpec.java

@@ -205,6 +205,8 @@ enum AttrParamType {
         new AttributeSpec(List.of(new AttrParamSpec(VALUE_ATTR, AttrParamType.STRING, false))));
     // @sparse
     ATTRIBUTE_SPECS_BY_NAME.put("sparse", new AttributeSpec(null));
+    // @transient
+    ATTRIBUTE_SPECS_BY_NAME.put("transient", new AttributeSpec(null));
     // @icon("value")
     ATTRIBUTE_SPECS_BY_NAME.put(
         "icon",

core/src/main/java/org/lflang/validation/LFValidator.java

@@ -534,6 +534,21 @@ public void checkInstantiation(Instantiation instantiation) {
         error("Variable-width banks are not supported.", Literals.INSTANTIATION__WIDTH_SPEC);
       }
     }
+
+    // If the Instantiation is annotated as '@transient', then:
+    // - The container has to be a federated reactor,
+    // - The coordination is centralized,
+    // - And the target is C.
+    // FIXME: Conditions 2 and 3 need to be checked
+    // FIXME: Add support of transients in decentralized coordination.
+    if (AttributeUtils.isTransient(instantiation)) {
+      Reactor container = (Reactor) instantiation.eContainer();
+      if (!container.isFederated()) {
+        error(
+            "Only federates can be transients: " + instantiation.getReactorClass().getName(),
+            Literals.INSTANTIATION__REACTOR_CLASS);
+      }
+    }
   }
 
   @Check(CheckType.FAST)

test/C/src/federated/transient/TransientDownstreamWithTimer.lf

@@ -0,0 +1,158 @@
+/**
+ * This LF program tests if a transient federate corretly leaves then joins the federation. It also
+ * tests if the transient's downstream executes as expected, that is it received correct TAGs,
+ * regardless of the transient being absent or present. In this test:
+ * - the transient federate spontaneously leaves the federation after 2 reactions to input port
+ * `in`,
+ * - the downstream of the transient federate has only one transient as upstream.
+ */
+target C {
+  timeout: 2 s
+}
+
+preamble {=
+  #include <stdlib.h>
+  #include <string.h>
+=}
+
+/** Persistent federate that is responsible for lauching the transient federate */
+reactor TransientExec(offset: time = 0, period: time = 0, fed_instance_name: char* = "instance") {
+  timer t(offset, period)
+
+  reaction(t) {=
+    // Construct the command to launch the transient federate
+    char mid_launch_cmd[512];
+    sprintf(mid_launch_cmd,
+        "%s/federate__%s -i %s",
+        lf_get_federates_bin_directory(),
+        self->fed_instance_name,
+        lf_get_federation_id()
+    );
+
+    lf_print("Launching federate federate__%s at physical time " PRINTF_TIME ".",
+        mid_launch_cmd,
+        lf_time_physical());
+
+    int status = system(mid_launch_cmd);
+
+    // Exit if error
+    if (status == 0) {
+        lf_print("Successfully launched federate__%s.", self->fed_instance_name);
+    } else {
+        lf_print_error_and_exit("Unable to launch federate__%s. Abort!", self->fed_instance_name);
+    }
+  =}
+}
+
+/**
+ * Persistent federate, upstream of the transient. It reacts to its timer by sending increments to
+ * output port out.
+ */
+reactor Up(period: time = 500 ms) {
+  output out: int
+  timer t(0, period)
+  state count: int = 0
+
+  reaction(t) -> out {=
+    lf_set(out, self->count);
+    self->count++;
+  =}
+}
+
+/**
+ * Transient federate that forwards whatever it receives from `Up` to `Down`. It reacts twice to
+ * input port `in`, then stops. It will execute twice during the lifetime of the federation. The
+ * second launch is done by `TransientExec` at logical time 1 s. Each time `Middle` joins, it
+ * notifies `Down`.
+ */
+reactor Middle {
+  input in: int
+  output out: int
+  output join: int
+  state count: int = 0
+
+  // Middle notifies its downstream that he joined, but make sure first that the effective start
+  // tag is correct
+  reaction(startup) -> join {=
+    if(lf_get_effective_start_time() < lf_get_start_time()) {
+      lf_print_error_and_exit("Fatal error: the transient's effective start time is less than the federation start time");
+    }
+
+    lf_set(join, 0);
+  =}
+
+  // Pass the input value to the output port and stop spontaneously after two reactions to in
+  reaction(in) -> out {=
+    self->count++;
+    lf_set(out, in->value);
+
+    if (self->count == 2) {
+      lf_stop();
+    }
+  =}
+}
+
+/**
+ * Persistent federate, which is downstream of the transient. It has to keep reacting to its
+ * internal timer and also to inputs from the tansient, if any.
+ */
+reactor Down {
+  timer t(0, 500 ms)
+
+  input in: int
+  input join: int
+
+  state count_timer: int = 0
+  state count_join: int = 0
+  state count_in_mid_reactions: int = 0
+
+  reaction(t) {=
+    self->count_timer++;
+  =}
+
+  reaction(in) {=
+    self->count_in_mid_reactions++;
+  =}
+
+  reaction(join) {=
+    self->count_join++;
+  =}
+
+  reaction(shutdown) {=
+    // Check that the TAG has been successfully issued to Down
+    if (self->count_timer != 5) {
+      lf_print_error_and_exit("Federate's timer reacted %d times, while it had to react %d times.",
+          self->count_timer,
+          5);
+    }
+
+    // Check that `Middle` have joined 2 times
+    if (self->count_join != 2) {
+      lf_print_error_and_exit("Transient federate did not join twice, but %d times!", self->count_join);
+    }
+
+    // Check that `Middle` have reacted correctly
+    if (self->count_in_mid_reactions < 4) {
+      lf_print_error_and_exit("Transient federate Mid did not execute and pass values from up corretly! Expected >= 4, but had: %d.",
+          self->count_in_mid_reactions);
+    }
+  =}
+}
+
+federated reactor {
+  // Persistent federate that is responsible for lauching the transient once, after 1s
+  midExec = new TransientExec(offset = 1 s, fed_instance_name="mid")
+
+  // Persistent downstream and upstream federates of the transient
+  up = new Up()
+  down = new Down()
+
+  // Transient federate
+  @transient
+  mid = new Middle()
+
+  // Connections
+  up.out -> mid.in
+  mid.join -> down.join
+  mid.out -> down.in
+}