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;
@@ -53,8 +57,6 @@
 import org.eclipse.xtext.nodemodel.INode;
 import org.eclipse.xtext.nodemodel.impl.HiddenLeafNode;
 import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
-import org.eclipse.xtext.util.Pair;
-import org.eclipse.xtext.util.Tuples;
 import org.eclipse.xtext.xbase.lib.IterableExtensions;
 import org.eclipse.xtext.xbase.lib.IteratorExtensions;
 import org.eclipse.xtext.xbase.lib.StringExtensions;
@@ -65,10 +67,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;
@@ -103,6 +107,7 @@
 import org.lflang.target.Target;
 import org.lflang.target.TargetConfig;
 import org.lflang.target.property.CompileDefinitionsProperty;
+import org.lflang.util.Pair;
 import org.lflang.util.StringUtil;
 
 /**
@@ -199,15 +204,15 @@ public static Collection<Connection> findConflictingConnectionsInModalReactors(
         for (var rea : allReactions(reactor)) {
           for (var eff : rea.getEffects()) {
             if (eff.getVariable() instanceof Port) {
-              allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea);
+              allWriters.put(new Pair<>(eff.getContainer(), eff.getVariable()), rea);
             }
           }
         }
         for (var con :
             ASTUtils.<Connection>collectElements(
                 reactor, featurePackage.getReactor_Connections(), false, true)) {
           for (var port : con.getRightPorts()) {
-            allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con);
+            allWriters.put(new Pair<>(port.getContainer(), port.getVariable()), con);
           }
         }
 
@@ -626,14 +631,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 +1956,127 @@ 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 the set of reactor instantiations
+   * contained in this definition.
+   *
+   * @param top The reactor definition to search in.
+   * @return The set of reactor instantiations within top.
+   */
+  public static Set<Instantiation> getEnclaves(Reactor top) {
+    Set<Instantiation> enclaves = new HashSet<>();
+    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 a list of pairs of an old connection and a newly created instantiation. For eac pair,
+   * create two connections to reroute specified connection to instead go through the specified
+   * instantiation. This is used when code-generating after-delay reactors and enclave connections.
+   * This assumes that the specified instantiation has at least one input port and at least one
+   * output port and uses the first of such ports. This returns a list of the two created
+   * connections. instantiation. This is used when code-generating after-delay reactors and enclaved
+   * connections. It inserts the added connections and the instantiations into the AST and removes
+   * the old connection.
+   *
+   * @param conns The list of pairs to reroute.
+   */
+  public static void rerouteViaInstance(List<Pair<Connection, Instantiation>> conns) {
+
+    List<Pair<EObject, Connection>> newConnections = new ArrayList<>();
+    List<Pair<EObject, Connection>> oldConnections = new ArrayList<>();
+
+    for (var pair : conns) {
+      Connection connection = pair.first();
+      EObject parent = connection.eContainer();
+      Instantiation inst = pair.second();
+      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());
+      newConnections.add(new Pair<>(parent, upstream));
+      newConnections.add(new Pair<>(parent, downstream));
+      oldConnections.add(new Pair<>(parent, connection));
+    }
+
+    // Insert the instances which we rerouted through.
+    conns.forEach(
+        (pair) -> {
+          Instantiation instantiation = pair.second();
+          EObject container = pair.first().eContainer();
+          if (container instanceof Reactor) {
+            ((Reactor) container).getInstantiations().add(instantiation);
+          } else if (container instanceof Mode) {
+            ((Mode) container).getInstantiations().add(instantiation);
+          }
+        });
+
+    // Remove old connections; insert new ones.
+    oldConnections.forEach(
+        (pair) -> {
+          EObject container = pair.first();
+          Connection connection = pair.second();
+          if (container instanceof Reactor) {
+            ((Reactor) container).getConnections().remove(connection);
+          } else if (container instanceof Mode) {
+            ((Mode) container).getConnections().remove(connection);
+          }
+        });
+    newConnections.forEach(
+        pair -> {
+          EObject container = pair.first();
+          Connection connection = pair.second();
+          if (container instanceof Reactor) {
+            ((Reactor) container).getConnections().add(connection);
+          } else if (container instanceof Mode) {
+            ((Mode) container).getConnections().add(connection);
+          }
+        });
+  }
+
+  /**
+   * 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);
+    }
+  }
 }