Static scheduler

.github/workflows/c-verifier-tests.yml → .github/workflows/c-verifier-and-static-scheduler-tests.yml

@@ -1,4 +1,4 @@
-name: Uclid5-based Verifier Tests
+name: Uclid5-based Verifier Tests and Static Scheduler Tests
 
 on:
   # Trigger this workflow also on workflow_call events.
@@ -66,6 +66,11 @@ jobs:
           echo "$pwd"
           ls -la
           ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CVerifierTest.* core:integrationTestCodeCoverageReport
+      - name: Run static scheduler tests
+        run: |
+          echo "$pwd"
+          ls -la
+          ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CStaticSchedulerTest.* core:integrationTestCodeCoverageReport
       - name: Report to CodeCov
         uses: ./.github/actions/report-code-coverage
         with:

.github/workflows/only-c.yml

@@ -32,6 +32,6 @@ jobs:
       use-cpp: true
       all-platforms: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
 
-  # Run the Uclid-based LF Verifier benchmarks.
-  verifier:
-    uses: ./.github/workflows/c-verifier-tests.yml
+  # Run the Uclid-based LF Verifier tests.
+  verifier-and-static-scheduler:
+    uses: ./.github/workflows/c-verifier-and-static-scheduler-tests.yml

build.gradle

@@ -24,7 +24,7 @@ spotless {
     format 'linguaFranca', {
         addStep(LfFormatStep.create())
         target 'test/*/src/**/*.lf' // you have to set the target manually
-        targetExclude 'test/**/failing/**'
+        targetExclude 'test/**/failing/**', 'test/*/src/static/*.lf' // FIXME: Spotless does not know how to check static LF tests.
     }
 }
 

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

@@ -17,13 +17,16 @@
 import org.lflang.generator.MainContext;
 import org.lflang.target.property.BuildTypeProperty;
 import org.lflang.target.property.CompilerProperty;
+import org.lflang.target.property.DashProperty;
 import org.lflang.target.property.LoggingProperty;
 import org.lflang.target.property.NoCompileProperty;
 import org.lflang.target.property.NoSourceMappingProperty;
 import org.lflang.target.property.PrintStatisticsProperty;
 import org.lflang.target.property.RuntimeVersionProperty;
 import org.lflang.target.property.SchedulerProperty;
+import org.lflang.target.property.SchedulerProperty.SchedulerOptions;
 import org.lflang.target.property.SingleThreadedProperty;
+import org.lflang.target.property.StaticSchedulerProperty;
 import org.lflang.target.property.TracingProperty;
 import org.lflang.target.property.TracingProperty.TracingOptions;
 import org.lflang.target.property.VerifyProperty;
@@ -34,6 +37,8 @@
 import org.lflang.target.property.type.LoggingType.LogLevel;
 import org.lflang.target.property.type.SchedulerType;
 import org.lflang.target.property.type.SchedulerType.Scheduler;
+import org.lflang.target.property.type.StaticSchedulerType;
+import org.lflang.target.property.type.StaticSchedulerType.StaticScheduler;
 import picocli.CommandLine.ArgGroup;
 import picocli.CommandLine.Command;
 import picocli.CommandLine.Option;
@@ -141,6 +146,20 @@ public class Lfc extends CliBase {
       description = "Specify the runtime scheduler (if supported).")
   private String scheduler;
 
+  // FIXME: Add LfcCliTest for this.
+  @Option(
+      names = {"--mapper"},
+      description =
+          "Select a specific mapper (i.e., static scheduler) if scheduler is set to STATIC."
+              + " Options: LB (default), EGS, MOCASIN")
+  private String staticScheduler;
+
+  // FIXME: Add LfcCliTest for this.
+  @Option(
+      names = {"--dash"},
+      description = "Execute non-real-time reactions fast whenever possible.")
+  private Boolean dashMode;
+
   @Option(
       names = {"--tracing"},
       arity = "0",
@@ -309,14 +328,31 @@ private URI getRtiUri() {
   }
 
   /** Return a scheduler one has been specified via the CLI arguments, or {@code null} otherwise. */
-  private Scheduler getScheduler() {
+  private SchedulerOptions getScheduler() {
     Scheduler resolved = null;
     if (scheduler != null) {
       // Validate scheduler.
       resolved = new SchedulerType().forName(scheduler);
       if (resolved == null) {
         reporter.printFatalErrorAndExit(scheduler + ": Invalid scheduler.");
       }
+      return new SchedulerOptions(resolved);
+    }
+    return null;
+  }
+
+  /**
+   * Return a static scheduler one has been specified via the CLI arguments, or {@code null}
+   * otherwise.
+   */
+  private StaticScheduler getStaticScheduler() {
+    StaticScheduler resolved = null;
+    if (staticScheduler != null) {
+      // Validate scheduler.
+      resolved = new StaticSchedulerType().forName(staticScheduler);
+      if (resolved == null) {
+        reporter.printFatalErrorAndExit(staticScheduler + ": Invalid scheduler.");
+      }
     }
     return resolved;
   }
@@ -379,13 +415,15 @@ public GeneratorArguments getArgs() {
         List.of(
             new Argument<>(BuildTypeProperty.INSTANCE, getBuildType()),
             new Argument<>(CompilerProperty.INSTANCE, targetCompiler),
+            new Argument<>(DashProperty.INSTANCE, dashMode),
             new Argument<>(LoggingProperty.INSTANCE, getLogging()),
             new Argument<>(PrintStatisticsProperty.INSTANCE, printStatistics),
             new Argument<>(NoCompileProperty.INSTANCE, noCompile),
             new Argument<>(NoSourceMappingProperty.INSTANCE, noSourceMapping),
             new Argument<>(VerifyProperty.INSTANCE, verify),
             new Argument<>(RuntimeVersionProperty.INSTANCE, runtimeVersion),
             new Argument<>(SchedulerProperty.INSTANCE, getScheduler()),
+            new Argument<>(StaticSchedulerProperty.INSTANCE, getStaticScheduler()),
             new Argument<>(SingleThreadedProperty.INSTANCE, getSingleThreaded()),
             new Argument<>(TracingProperty.INSTANCE, getTracingOptions()),
             new Argument<>(WorkersProperty.INSTANCE, getWorkers())));

core/src/integrationTest/java/org/lflang/tests/lsp/MockCancelIndicator.java

@@ -5,7 +5,7 @@
 /**
  * Mock the CancelIndicator interface for testing.
  *
- * @author Erling Jellum
+ * 
  */
 public class MockCancelIndicator implements CancelIndicator {
   @Override

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

@@ -4,6 +4,7 @@
 import org.junit.jupiter.api.Test;
 import org.lflang.target.Target;
 import org.lflang.target.property.SchedulerProperty;
+import org.lflang.target.property.SchedulerProperty.SchedulerOptions;
 import org.lflang.target.property.type.SchedulerType.Scheduler;
 import org.lflang.tests.TestBase;
 import org.lflang.tests.TestRegistry.TestCategory;
@@ -56,7 +57,7 @@ private void runTest(Scheduler scheduler, EnumSet<TestCategory> categories) {
         categories::contains,
         Transformers::noChanges,
         config -> {
-          SchedulerProperty.INSTANCE.override(config, scheduler);
+          SchedulerProperty.INSTANCE.override(config, new SchedulerOptions(scheduler));
           return true;
         },
         TestLevel.EXECUTION,

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

@@ -0,0 +1,48 @@
+package org.lflang.tests.runtime;
+
+import java.util.List;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.Test;
+import org.lflang.target.Target;
+import org.lflang.target.property.LoggingProperty;
+import org.lflang.target.property.SchedulerProperty;
+import org.lflang.target.property.SchedulerProperty.SchedulerOptions;
+import org.lflang.target.property.type.LoggingType.LogLevel;
+import org.lflang.target.property.type.SchedulerType.Scheduler;
+import org.lflang.target.property.type.StaticSchedulerType;
+import org.lflang.tests.TestBase;
+import org.lflang.tests.TestRegistry;
+import org.lflang.tests.Transformers;
+
+public class CStaticSchedulerTest extends TestBase {
+  protected CStaticSchedulerTest() {
+    super(Target.C);
+  }
+
+  @Test
+  public void runStaticSchedulerTests() {
+    Assumptions.assumeTrue(
+        isLinux() || isMac(), "Static scheduler tests only run on Linux or macOS");
+
+    super.runTestsFor(
+        List.of(Target.C),
+        Message.DESC_STATIC_SCHEDULER,
+        TestRegistry.TestCategory.STATIC_SCHEDULER::equals,
+        Transformers::noChanges,
+        config -> {
+          // Execute all static tests using STATIC and LB.
+          // FIXME: How to respect the config specified in the LF code?
+          SchedulerProperty.INSTANCE.override(
+              config,
+              new SchedulerOptions(Scheduler.STATIC)
+                  .update(StaticSchedulerType.StaticScheduler.LB));
+          // Keep the logging level at INFO because logs from the long
+          // running tests (e.g., RaceConditionCheck.lf) could overflow
+          // the buffer and stall the process.
+          LoggingProperty.INSTANCE.override(config, LogLevel.INFO);
+          return true;
+        },
+        TestLevel.EXECUTION,
+        false);
+  }
+}

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

@@ -27,6 +27,7 @@
 
 import static org.lflang.ast.ASTUtils.factory;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -42,7 +43,7 @@
 /**
  * A helper class for processing attributes in the AST.
  *
- * @author Shaokai Lin
+ * 
  * @author Clément Fournier
  * @author Alexander Schulz-Rosengarten
  */
@@ -142,6 +143,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);
+  }
+
   /**
    * Search for an attribute with the given name on the given AST node and return its first argument
    * as a String.
@@ -241,6 +269,35 @@ 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 List<TimeValue> getWCETs(Reaction reaction) {
+    List<TimeValue> wcets = new ArrayList<>();
+    String wcetStr = getAttributeValue(reaction, "wcet");
+
+    if (wcetStr == null) {
+      wcets.add(TimeValue.MAX_VALUE);
+      return wcets;
+    }
+
+    // Split by comma.
+    String[] wcetArr = wcetStr.split(",");
+
+    // Trim white space.
+    for (int i = 0; i < wcetArr.length; i++) {
+      wcetArr[i] = wcetArr[i].trim();
+
+      // Split by inner space.
+      String[] valueAndUnit = wcetArr[i].split(" ");
+
+      long value = Long.parseLong(valueAndUnit[0]);
+      TimeUnit unit = TimeUnit.fromName(valueAndUnit[1]);
+      TimeValue wcet = new TimeValue(value, unit);
+      wcets.add(wcet);
+    }
+
+    return wcets;
+  }
+
   /** 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

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

core/src/main/java/org/lflang/analyses/c/AbstractAstVisitor.java

@@ -2,7 +2,11 @@
 
 import java.util.List;
 
-/** Modeled after {@link AbstractParseTreeVisitor}. */
+/**
+ * Modeled after {@link AbstractParseTreeVisitor}.
+ *
+ * 
+ */
 public abstract class AbstractAstVisitor<T> implements AstVisitor<T> {
 
   @Override

core/src/main/java/org/lflang/analyses/c/AstUtils.java

@@ -4,6 +4,11 @@
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.misc.Interval;
 
+/**
+ * A utility class for C ASTs
+ *
+ * 
+ */
 public class AstUtils {
 
   public static CAst.AstNode takeConjunction(List<CAst.AstNode> conditions) {

core/src/main/java/org/lflang/analyses/c/AstVisitor.java

@@ -2,7 +2,11 @@
 
 import java.util.List;
 
-/** Modeled after ParseTreeVisitor.class */
+/**
+ * Modeled after ParseTreeVisitor.class
+ *
+ * 
+ */
 public interface AstVisitor<T> {
 
   /**

core/src/main/java/org/lflang/analyses/c/BuildAstParseTreeVisitor.java

@@ -7,7 +7,11 @@
 import org.lflang.dsl.CBaseVisitor;
 import org.lflang.dsl.CParser.*;
 
-/** This visitor class builds an AST from the parse tree of a C program */
+/**
+ * This visitor class builds an AST from the parse tree of a C program
+ *
+ * 
+ */
 public class BuildAstParseTreeVisitor extends CBaseVisitor<CAst.AstNode> {
 
   /** Message reporter for reporting warnings and errors */

core/src/main/java/org/lflang/analyses/c/CAst.java

@@ -3,6 +3,11 @@
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * C AST class that contains definitions for AST nodes
+ *
+ * 
+ */
 public class CAst {
 
   public static class AstNode implements Visitable {

core/src/main/java/org/lflang/analyses/c/CAstVisitor.java

@@ -2,7 +2,11 @@
 
 import java.util.List;
 
-/** Modeled after CVisitor.java */
+/**
+ * Modeled after CVisitor.java
+ *
+ * 
+ */
 public interface CAstVisitor<T> extends AstVisitor<T> {
 
   T visitAstNode(CAst.AstNode node);

core/src/main/java/org/lflang/analyses/c/CBaseAstVisitor.java

@@ -5,6 +5,8 @@
 /**
  * A base class that provides default implementations of the visit functions. Other C AST visitors
  * extend this class.
+ *
+ * 
  */
 public class CBaseAstVisitor<T> extends AbstractAstVisitor<T> implements CAstVisitor<T> {