Preliminary support for scheduling enclaves in the C target

.github/workflows/c-zephyr-tests.yml

@@ -39,7 +39,7 @@ jobs:
           path: core/src/main/resources/lib/c/reactor-c
           ref: ${{ inputs.runtime-ref }}
         if: ${{ inputs.runtime-ref }}
-      - name: Run Zephyr smoke tests
+      - name: Run integration tests on the Zephyr platform
         run: |
           ./gradlew core:integrationTest \
             --tests org.lflang.tests.runtime.CZephyrTest.buildZephyrUnthreaded* \

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

@@ -60,6 +60,11 @@ protected boolean supportsDockerOption() {
     return true;
   }
 
+  @Override
+  protected boolean supportsEnclaves() {
+    return true;
+  }
+
   @Test
   @Override
   public void runBasicTests() {
@@ -72,6 +77,12 @@ public void runGenericsTests() {
     super.runGenericsTests();
   }
 
+  @Test
+  @Override
+  public void runEnclaveTests() {
+    super.runEnclaveTests();
+  }
+
   @Test
   @Override
   public void runTargetSpecificTests() {

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

@@ -25,8 +25,6 @@
 
 package org.lflang;
 
-import static org.lflang.ast.ASTUtils.factory;
-
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -48,6 +46,7 @@
 import org.lflang.lf.StateVar;
 import org.lflang.lf.Timer;
 import org.lflang.util.StringUtil;
+import org.lflang.validation.AttributeSpec;
 
 /**
  * A helper class for processing attributes in the AST.
@@ -290,15 +289,26 @@ public static boolean isEnclave(Instantiation node) {
   }
 
   /**
-   * Annotate @{code node} with enclave @attribute
+   * Retrieve the number of worker parameter from an enclave attribute. Returns 1 if not specified
+   * or has illegal value
    *
    * @param node
+   * @return
    */
-  public static void setEnclaveAttribute(Instantiation node) {
-    if (!isEnclave(node)) {
-      Attribute enclaveAttr = factory.createAttribute();
-      enclaveAttr.setAttrName("enclave");
-      node.getAttributes().add(enclaveAttr);
+  public static int getEnclaveNumWorkersFromAttribute(Instantiation node) {
+    Attribute enclaveAttr = getEnclaveAttribute(node);
+    if (enclaveAttr != null) {
+      for (AttrParm attrParm : enclaveAttr.getAttrParms()) {
+        if (attrParm.getName().equals(AttributeSpec.WORKERS_ATTR)) {
+          int value = Integer.valueOf(attrParm.getValue());
+          if (value > 0) {
+            return value;
+          } else {
+            return 1;
+          }
+        }
+      }
     }
+    return 1; // Not specified
   }
 }

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

@@ -37,6 +37,10 @@ public final class TimeValue implements Comparable<TimeValue> {
   public static final TimeValue MAX_VALUE = new TimeValue(Long.MAX_VALUE, TimeUnit.NANO);
   /** A time value equal to zero. */
   public static final TimeValue ZERO = new TimeValue(0, null);
+  /** A time value representing NEVER, which is less than any other time value. */
+  public static final TimeValue NEVER = new TimeValue(Long.MIN_VALUE, TimeUnit.NANO);
+  /** A time value representing FOREVER which is greater than any other time value. */
+  public static final TimeValue FOREVER = new TimeValue(Long.MAX_VALUE, TimeUnit.NANO);
 
   /**
    * Primitive numerical representation of this time value, to be interpreted in terms the

core/src/main/java/org/lflang/ast/ASTUtils.java

@@ -25,6 +25,8 @@
 
 package org.lflang.ast;
 
+import static org.lflang.AttributeUtils.isEnclave;
+
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Iterators;
@@ -33,9 +35,11 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Queue;
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.regex.Matcher;
@@ -65,10 +69,12 @@
 import org.lflang.generator.CodeMap;
 import org.lflang.generator.InvalidSourceException;
 import org.lflang.generator.NamedInstance;
+import org.lflang.generator.ParameterInstance;
 import org.lflang.generator.ReactorInstance;
 import org.lflang.lf.Action;
 import org.lflang.lf.Assignment;
 import org.lflang.lf.Code;
+import org.lflang.lf.CodeExpr;
 import org.lflang.lf.Connection;
 import org.lflang.lf.Element;
 import org.lflang.lf.Expression;
@@ -626,14 +632,12 @@ public static ReactorInstance createMainReactorInstance(
         return null;
       }
       // Inform the run-time of the breadth/parallelism of the reaction graph
-      var breadth = reactionInstanceGraph.getBreadth();
+      var breadth = reactionInstanceGraph.getBreadth(main);
       if (breadth == 0) {
         messageReporter.nowhere().warning("The program has no reactions");
       } else {
         CompileDefinitionsProperty.INSTANCE.update(
-            targetConfig,
-            Map.of(
-                "LF_REACTION_GRAPH_BREADTH", String.valueOf(reactionInstanceGraph.getBreadth())));
+            targetConfig, Map.of("LF_REACTION_GRAPH_BREADTH", String.valueOf(breadth)));
       }
       return main;
     }
@@ -1953,4 +1957,82 @@ public static void addReactionAttribute(Reaction reaction, String name) {
     fedAttr.setAttrName(name);
     reaction.getAttributes().add(fedAttr);
   }
+
+  /**
+   * Given a reactor definition, e.g. the main reactor, returns a list of all reactor instantiations
+   * which are enclaves. The same Instantiation might appear multiple times.
+   *
+   * @param top
+   * @return
+   */
+  public static List<Instantiation> getEnclaves(Reactor top) {
+    List<Instantiation> enclaves = new ArrayList<>();
+    Queue<Reactor> queue = new LinkedList<>();
+    queue.add(top);
+
+    while (!queue.isEmpty()) {
+      Reactor inst = queue.poll();
+      for (Instantiation child : ASTUtils.allInstantiations(inst)) {
+        if (isEnclave(child)) {
+          enclaves.add(child);
+        }
+        queue.add(ASTUtils.toDefinition(child.getReactorClass()));
+      }
+    }
+    return enclaves;
+  }
+
+  /**
+   * Given an old connection and an instantiation. Reroute that old connection via the
+   * instantiation. This is used when code-generating after-delay reactors and enclaved connections.
+   * It returns a list to new connections to substitute the original one.
+   *
+   * @param connection
+   * @param inst
+   * @return
+   */
+  public static List<Connection> rerouteViaInstance(Connection connection, Instantiation inst) {
+    List<Connection> connections = new ArrayList<>();
+    Connection upstream = factory.createConnection();
+    Connection downstream = factory.createConnection();
+    VarRef input = factory.createVarRef();
+    VarRef output = factory.createVarRef();
+
+    Reactor delayClass = ASTUtils.toDefinition(inst.getReactorClass());
+
+    // Establish references to the involved ports.
+    input.setContainer(inst);
+    input.setVariable(delayClass.getInputs().get(0));
+    output.setContainer(inst);
+    output.setVariable(delayClass.getOutputs().get(0));
+    upstream.getLeftPorts().addAll(connection.getLeftPorts());
+    upstream.getRightPorts().add(input);
+    downstream.getLeftPorts().add(output);
+    downstream.getRightPorts().addAll(connection.getRightPorts());
+    downstream.setIterated(connection.isIterated());
+    connections.add(upstream);
+    connections.add(downstream);
+    return connections;
+  }
+
+  /**
+   * Override the parameter initializer with a code expression.
+   *
+   * @param param
+   * @param expr
+   */
+  public static void overrideParameter(ParameterInstance param, CodeExpr expr) {
+    Assignment existing = param.getOverride();
+    Initializer init = factory.createInitializer();
+    init.setBraces(true);
+    init.getExprs().add(expr);
+    if (existing != null) {
+      existing.setRhs(init);
+    } else {
+      Assignment a = factory.createAssignment();
+      a.setLhs(param.getDefinition());
+      a.setRhs(init);
+      param.getParent().getDefinition().getParameters().add(a);
+    }
+  }
 }

core/src/main/java/org/lflang/ast/DelayedConnectionTransformation.java

@@ -121,7 +121,7 @@ private void insertGeneratedDelays(List<Reactor> reactors) {
           // Stage the new connections for insertion into the tree.
           List<Connection> connections =
               ASTUtils.convertToEmptyListIfNull(newConnections.get(parent));
-          connections.addAll(rerouteViaDelay(connection, delayInstance));
+          connections.addAll(ASTUtils.rerouteViaInstance(connection, delayInstance));
           newConnections.put(parent, connections);
           // Stage the original connection for deletion from the tree.
           oldConnections.add(connection);
@@ -170,38 +170,6 @@ private void insertGeneratedDelays(List<Reactor> reactors) {
                 }));
   }
 
-  /**
-   * Take a connection and reroute it via an instance of a generated delay reactor. This method
-   * returns a list to new connections to substitute the original one.
-   *
-   * @param connection The connection to reroute.
-   * @param delayInstance The delay instance to route the connection through.
-   */
-  private static List<Connection> rerouteViaDelay(
-      Connection connection, Instantiation delayInstance) {
-    List<Connection> connections = new ArrayList<>();
-    Connection upstream = factory.createConnection();
-    Connection downstream = factory.createConnection();
-    VarRef input = factory.createVarRef();
-    VarRef output = factory.createVarRef();
-
-    Reactor delayClass = ASTUtils.toDefinition(delayInstance.getReactorClass());
-
-    // Establish references to the involved ports.
-    input.setContainer(delayInstance);
-    input.setVariable(delayClass.getInputs().get(0));
-    output.setContainer(delayInstance);
-    output.setVariable(delayClass.getOutputs().get(0));
-    upstream.getLeftPorts().addAll(connection.getLeftPorts());
-    upstream.getRightPorts().add(input);
-    downstream.getLeftPorts().add(output);
-    downstream.getRightPorts().addAll(connection.getRightPorts());
-    downstream.setIterated(connection.isIterated());
-    connections.add(upstream);
-    connections.add(downstream);
-    return connections;
-  }
-
   /**
    * Create a new instance delay instances using the given reactor class. The supplied time value is
    * used to override the default interval (which is zero). If the target supports parametric

core/src/main/java/org/lflang/generator/ReactionInstance.java

@@ -312,7 +312,7 @@ public Set<Integer> getLevels() {
 
   /**
    * Return a set of deadlines that runtime instances of this reaction have. A ReactionInstance may
-   * have more than one deadline if it lies within.
+   * have more than one deadline if it lies within a bank.
    */
   public Set<TimeValue> getInferredDeadlines() {
     Set<TimeValue> result = new LinkedHashSet<>();
@@ -342,7 +342,7 @@ public List<Integer> getLevelsList() {
   /**
    * Return a list of the deadlines that runtime instances of this reaction have. The size of this
    * list is the total number of runtime instances. A ReactionInstance may have more than one
-   * deadline if it lies within
+   * deadline if it lies within a bank.
    */
   public List<TimeValue> getInferredDeadlinesList() {
     List<TimeValue> result = new LinkedList<>();
@@ -407,65 +407,6 @@ public String toString() {
     return getName() + " of " + parent.getFullName();
   }
 
-  /**
-   * Determine logical execution time for each reaction during compile time based on immediate
-   * downstream logical delays (after delays and actions) and label each reaction with the minimum
-   * of all such delays.
-   */
-  public TimeValue assignLogicalExecutionTime() {
-    if (this.let != null) {
-      return this.let;
-    }
-
-    if (this.parent.isGeneratedDelay()) {
-      return this.let = TimeValue.ZERO;
-    }
-
-    TimeValue let = null;
-
-    // Iterate over effect and find minimum delay.
-    for (TriggerInstance<? extends Variable> effect : effects) {
-      if (effect instanceof PortInstance) {
-        var afters =
-            this.parent.getParent().children.stream()
-                .filter(
-                    c -> {
-                      if (c.isGeneratedDelay()) {
-                        return c.inputs
-                            .get(0)
-                            .getDependsOnPorts()
-                            .get(0)
-                            .instance
-                            .equals((PortInstance) effect);
-                      }
-                      return false;
-                    })
-                .map(c -> c.actions.get(0).getMinDelay())
-                .min(TimeValue::compare);
-
-        if (afters.isPresent()) {
-          if (let == null) {
-            let = afters.get();
-          } else {
-            let = TimeValue.min(afters.get(), let);
-          }
-        }
-      } else if (effect instanceof ActionInstance) {
-        var action = ((ActionInstance) effect).getMinDelay();
-        if (let == null) {
-          let = action;
-        } else {
-          let = TimeValue.min(action, let);
-        }
-      }
-    }
-
-    if (let == null) {
-      let = TimeValue.ZERO;
-    }
-    return this.let = let;
-  }
-
   //////////////////////////////////////////////////////
   //// Private variables.