Static scheduler

cli/lfc/src/main/java/org/lflang/cli/Lfc.java

@@ -107,6 +107,12 @@ public class Lfc extends CliBase {
       description = "Specify the runtime scheduler (if supported).")
   private String scheduler;
 
+  // FIXME: Add LfcCliTest for this.
+  @Option(
+      names = {"--static-scheduler"},
+      description = "Select a specific static scheduler if scheduler is set to FS (fully static).")
+  private String staticScheduler;
+
   @Option(
       names = {"-t", "--threading"},
       paramLabel = "<true/false>",

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

@@ -44,6 +44,7 @@
 import org.lflang.lf.Reaction;
 import org.lflang.lf.Reactor;
 import org.lflang.lf.StateVar;
+import org.lflang.lf.Time;
 import org.lflang.lf.Timer;
 import org.lflang.util.StringUtil;
 
@@ -133,6 +134,33 @@ public static String getAttributeValue(EObject node, String attrName) {
     return value;
   }
 
+  /**
+   * Return the first argument, which has the type Time, specified for the attribute.
+   *
+   * <p>This should be used if the attribute is expected to have a single argument whose type is
+   * Time. If there is no argument, null is returned.
+   */
+  public static Time getFirstArgumentTime(Attribute attr) {
+    if (attr == null || attr.getAttrParms().isEmpty()) {
+      return null;
+    }
+    return attr.getAttrParms().get(0).getTime();
+  }
+
+  /**
+   * Search for an attribute with the given name on the given AST node and return its first argument
+   * as Time.
+   *
+   * <p>This should only be used on attributes that are expected to have a single argument with type
+   * Time.
+   *
+   * <p>Returns null if the attribute is not found or if it does not have any arguments.
+   */
+  public static Time getAttributeTime(EObject node, String attrName) {
+    final var attr = findAttributeByName(node, attrName);
+    return getFirstArgumentTime(attr);
+  }
+
   /**
    * Retrieve a specific annotation in a comment associated with the given model element in the AST.
    *
@@ -223,6 +251,14 @@ public static boolean hasCBody(Reaction reaction) {
     return findAttributeByName(reaction, "_c_body") != null;
   }
 
+  /** Return a time value that represents the WCET of a reaction. */
+  public static TimeValue getWCET(Reaction reaction) {
+    Time t = getAttributeTime(reaction, "wcet");
+    if (t == null) return TimeValue.MAX_VALUE;
+    TimeUnit unit = TimeUnit.fromName(t.getUnit());
+    return new TimeValue(t.getInterval(), unit);
+  }
+
   /** Return the declared label of the node, as given by the @label annotation. */
   public static String getLabel(EObject node) {
     return getAttributeValue(node, "label");

core/src/main/java/org/lflang/LinguaFranca.xtext

@@ -255,7 +255,7 @@ Attribute:
 ;
 
 AttrParm:
-    (name=ID '=')? value=Literal;
+    (name=ID '=')? (value=Literal | time=Time);
 
 /////////// For target parameters
 

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

@@ -38,6 +38,7 @@
 import org.lflang.TargetProperty.LogLevel;
 import org.lflang.TargetProperty.Platform;
 import org.lflang.TargetProperty.SchedulerOption;
+import org.lflang.TargetProperty.StaticSchedulerOption;
 import org.lflang.TargetProperty.UnionType;
 import org.lflang.generator.LFGeneratorContext.BuildParm;
 import org.lflang.generator.rust.RustTargetConfig;
@@ -120,6 +121,10 @@ public TargetConfig(Properties cliArgs, TargetDecl target, ErrorReporter errorRe
       this.schedulerType = SchedulerOption.valueOf(cliArgs.getProperty("scheduler"));
       this.setByUser.add(TargetProperty.SCHEDULER);
     }
+    if (cliArgs.containsKey("static-scheduler")) {
+      this.staticScheduler = StaticSchedulerOption.valueOf(cliArgs.getProperty("static-scheduler"));
+      this.setByUser.add(TargetProperty.STATIC_SCHEDULER);
+    }
     if (cliArgs.containsKey("target-flags")) {
       this.compilerFlags.clear();
       if (!cliArgs.getProperty("target-flags").isEmpty()) {
@@ -262,6 +267,9 @@ public TargetConfig(Properties cliArgs, TargetDecl target, ErrorReporter errorRe
   /** What runtime scheduler to use. */
   public SchedulerOption schedulerType = SchedulerOption.getDefault();
 
+  /** What static schedule generator to use. */
+  public StaticSchedulerOption staticScheduler = StaticSchedulerOption.getDefault();
+
   /**
    * The number of worker threads to deploy. The default is zero, which indicates that the runtime
    * is allowed to freely choose the number of workers.

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

@@ -563,6 +563,18 @@ public enum TargetProperty {
                 UnionType.SCHEDULER_UNION.forName(ASTUtils.elementToSingleString(value));
       }),
 
+  /** Directive for specifying a specific runtime scheduler, if supported. */
+  STATIC_SCHEDULER(
+      "static-scheduler",
+      UnionType.STATIC_SCHEDULER_UNION,
+      Arrays.asList(Target.C),
+      (config) -> ASTUtils.toElement(config.staticScheduler.toString()),
+      (config, value, err) -> {
+        config.staticScheduler =
+            (StaticSchedulerOption)
+                UnionType.STATIC_SCHEDULER_UNION.forName(ASTUtils.elementToSingleString(value));
+      }),
+
   /** Directive to specify that all code is generated in a single file. */
   SINGLE_FILE_PROJECT(
       "single-file-project",
@@ -1202,6 +1214,8 @@ public enum UnionType implements TargetPropertyType {
     BUILD_TYPE_UNION(Arrays.asList(BuildType.values()), null),
     COORDINATION_UNION(Arrays.asList(CoordinationType.values()), CoordinationType.CENTRALIZED),
     SCHEDULER_UNION(Arrays.asList(SchedulerOption.values()), SchedulerOption.getDefault()),
+    STATIC_SCHEDULER_UNION(
+        Arrays.asList(StaticSchedulerOption.values()), StaticSchedulerOption.getDefault()),
     LOGGING_UNION(Arrays.asList(LogLevel.values()), LogLevel.INFO),
     PLATFORM_UNION(Arrays.asList(Platform.values()), Platform.AUTO),
     CLOCK_SYNC_UNION(Arrays.asList(ClockSyncMode.values()), ClockSyncMode.INIT),
@@ -1769,7 +1783,8 @@ public enum SchedulerOption {
             Path.of("worker_states.h"),
             Path.of("data_collection.h"))),
     GEDF_NP(true), // Global EDF non-preemptive
-    GEDF_NP_CI(true); // Global EDF non-preemptive with chain ID
+    GEDF_NP_CI(true), // Global EDF non-preemptive with chain ID
+    FS(true); // Fully static
     // PEDF_NP(true);    // Partitioned EDF non-preemptive (FIXME: To be re-added in a future PR)
 
     /** Indicate whether or not the scheduler prioritizes reactions by deadline. */
@@ -1803,6 +1818,20 @@ public static SchedulerOption getDefault() {
     }
   }
 
+  /**
+   * Supported schedule generators.
+   *
+   * @author Shaokai Lin
+   */
+  public enum StaticSchedulerOption {
+    BASELINE,
+    RL;
+
+    public static StaticSchedulerOption getDefault() {
+      return BASELINE;
+    }
+  }
+
   /**
    * Tracing options.
    *

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

@@ -137,6 +137,34 @@ public long toNanoSeconds() {
     return makeNanosecs(time, unit);
   }
 
+  /** Return a TimeValue based on a nanosecond value. */
+  public static TimeValue fromNanoSeconds(long ns) {
+    if (ns == 0) return ZERO;
+    long time;
+    if ((time = ns / 604_800_016_558_522L) > 0 && ns % 604_800_016_558_522L == 0) {
+      return new TimeValue(time, TimeUnit.WEEK);
+    }
+    if ((time = ns / 86_400_000_000_000L) > 0 && ns % 86_400_000_000_000L == 0) {
+      return new TimeValue(time, TimeUnit.DAY);
+    }
+    if ((time = ns / 3_600_000_000_000L) > 0 && ns % 3_600_000_000_000L == 0) {
+      return new TimeValue(time, TimeUnit.HOUR);
+    }
+    if ((time = ns / 60_000_000_000L) > 0 && ns % 60_000_000_000L == 0) {
+      return new TimeValue(time, TimeUnit.MINUTE);
+    }
+    if ((time = ns / 1_000_000_000) > 0 && ns % 1_000_000_000 == 0) {
+      return new TimeValue(time, TimeUnit.SECOND);
+    }
+    if ((time = ns / 1_000_000) > 0 && ns % 1_000_000 == 0) {
+      return new TimeValue(time, TimeUnit.MILLI);
+    }
+    if ((time = ns / 1000) > 0 && ns % 1000 == 0) {
+      return new TimeValue(time, TimeUnit.MICRO);
+    }
+    return new TimeValue(ns, TimeUnit.NANO);
+  }
+
   /** Return a string representation of this time value. */
   public String toString() {
     return unit != null ? time + " " + unit.getCanonicalName() : Long.toString(time);
@@ -181,4 +209,35 @@ public TimeValue add(TimeValue b) {
     var unitDivider = makeNanosecs(1, smallestUnit);
     return new TimeValue(sumOfNumbers / unitDivider, smallestUnit);
   }
+
+  /**
+   * Return the substraction of this duration from the one represented by b.
+   *
+   * <p>The unit of the returned TimeValue will be the minimum of the units of both operands except
+   * if only one of the units is TimeUnit.NONE. In that case, the unit of the other input is used.
+   *
+   * @param b The right operand
+   * @return A new TimeValue (the current value will not be affected)
+   */
+  public TimeValue sub(TimeValue b) {
+    // Figure out the actual sub
+    final long subOfNumbers;
+    try {
+      subOfNumbers = Math.subtractExact(this.toNanoSeconds(), b.toNanoSeconds());
+    } catch (ArithmeticException overflow) {
+      return MAX_VALUE;
+    }
+
+    if (this.unit == null || b.unit == null) {
+      // A time value with no unit is necessarily zero. So
+      // if this is null, (this + b) == b, if b is none, (this+b) == this.
+      return b.unit == null ? this : b;
+    }
+    boolean isThisUnitSmallerThanBUnit = this.unit.compareTo(b.unit) <= 0;
+    TimeUnit smallestUnit = isThisUnitSmallerThanBUnit ? this.unit : b.unit;
+    // Find the appropriate divider to bring sumOfNumbers from nanoseconds to
+    // returnUnit
+    var unitDivider = makeNanosecs(1, smallestUnit);
+    return new TimeValue(subOfNumbers / unitDivider, smallestUnit);
+  }
 }