Environments in the C target

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

@@ -39,10 +39,21 @@ jobs:
           path: core/src/main/resources/lib/c/reactor-c
           ref: ${{ inputs.runtime-ref }}
         if: ${{ inputs.runtime-ref }}
-      - name: Perform Zephyr tests for C target with default scheduler
+      - name: Run Zephyr smoke tests
         run: |
-          ./gradlew targetTest -Ptarget=CZephyr
+          ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CZephyrTest.buildZephyr*
           util/RunZephyrTests.sh test/C/src-gen
+          rm -r test/C/src-gen
+      - name: Run basic tests
+        run: |
+          ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CZephyrTest.buildBasic*
+          util/RunZephyrTests.sh test/C/src-gen
+          rm -r test/C/src-gen
+      - name: Run concurrent tests
+        run: |
+          ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CZephyrTest.buildConcurrent*
+          util/RunZephyrTests.sh test/C/src-gen
+          rm -r test/C/src-gen
       - name: Collect code coverage
         run: ./gradlew jacocoTestReport
       - name: Report to CodeCov

.gitignore

@@ -157,4 +157,8 @@ gradle-app.setting
 
 ### xtext artifaccts
 *.jar
-core/model/
+core/model/
+org.lflang/model/generated
+
+#### Zephyr/west
+.west/

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

@@ -42,7 +42,8 @@ private static boolean isExcludedFromCCpp(TestCategory category) {
     excluded |= isWindows() && (category == TestCategory.DOCKER_FEDERATED);
     excluded |=
         isMac() && (category == TestCategory.DOCKER_FEDERATED || category == TestCategory.DOCKER);
-    excluded |= category == TestCategory.ZEPHYR;
+    excluded |= category == TestCategory.ZEPHYR_UNTHREADED;
+    excluded |= category == TestCategory.ZEPHYR_THREADED;
     excluded |= category == TestCategory.ARDUINO;
     excluded |= category == TestCategory.NO_INLINING;
     return !excluded;

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

@@ -44,12 +44,24 @@ public CZephyrTest() {
   }
 
   @Test
-  public void buildZephyrTests() {
+  public void buildZephyrUnthreadedTests() {
     Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux");
     super.runTestsFor(
         List.of(Target.C),
         Message.DESC_ZEPHYR,
-        TestCategory.ZEPHYR::equals,
+        TestCategory.ZEPHYR_UNTHREADED::equals,
+        Configurators::makeZephyrCompatibleUnthreaded,
+        TestLevel.BUILD,
+        false);
+  }
+
+  @Test
+  public void buildZephyrThreadedTests() {
+    Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux");
+    super.runTestsFor(
+        List.of(Target.C),
+        Message.DESC_ZEPHYR,
+        TestCategory.ZEPHYR_THREADED::equals,
         Configurators::makeZephyrCompatible,
         TestLevel.BUILD,
         false);

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

@@ -25,6 +25,8 @@
 
 package org.lflang;
 
+import static org.lflang.ast.ASTUtils.factory;
+
 import java.util.List;
 import java.util.Objects;
 import org.eclipse.emf.ecore.EObject;
@@ -244,4 +246,17 @@ public static Attribute getEnclaveAttribute(Instantiation node) {
   public static boolean isEnclave(Instantiation node) {
     return getEnclaveAttribute(node) != null;
   }
+
+  /**
+   * Annotate @{code node} with enclave @attribute
+   *
+   * @param node
+   */
+  public static void setEnclaveAttribute(Instantiation node) {
+    if (!isEnclave(node)) {
+      Attribute enclaveAttr = factory.createAttribute();
+      enclaveAttr.setAttrName("enclave");
+      node.getAttributes().add(enclaveAttr);
+    }
+  }
 }

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

@@ -309,6 +309,7 @@ public String generateNetworkSenderBody(
     String commonArgs =
         String.join(
             ", ",
+            "self->base.environment",
             additionalDelayString,
             messageType,
             receivingPortID + "",
@@ -446,7 +447,8 @@ public String generateNetworkInputControlReactionBody(
       result.pr("max_STP = " + CTypes.getInstance().getTargetTimeExpr(maxSTP) + ";");
     }
     result.pr("// Wait until the port status is known");
-    result.pr("wait_until_port_status_known(" + receivingPortID + ", max_STP);");
+    result.pr(
+        "wait_until_port_status_known(self->base.environment, " + receivingPortID + ", max_STP);");
     return result.toString();
   }
 
@@ -484,6 +486,7 @@ public String generateNetworkOutputControlReactionBody(
             "if (" + sendRef + " == NULL || !" + sendRef + "->is_present) {",
             "    // The output port is NULL or it is not present.",
             "    send_port_absent_to_federate("
+                + "self->base.environment, "
                 + additionalDelayString
                 + ", "
                 + receivingPortID
@@ -620,7 +623,7 @@ private String generateExecutablePreamble(
     code.pr(CExtensionUtils.allocateTriggersForFederate(federate));
 
     return """
-            void _lf_executable_preamble() {
+            void _lf_executable_preamble(environment_t* env) {
             %s
             }
             """
@@ -641,7 +644,7 @@ private String generateCodeToInitializeFederate(FederateInstance federate, RtiCo
             "\n",
             "// Initialize the socket mutex",
             "lf_mutex_init(&outbound_socket_mutex);",
-            "lf_cond_init(&port_status_changed, &mutex);"));
+            "lf_cond_init(&port_status_changed, &env->mutex);"));
 
     // Find the STA (A.K.A. the global STP offset) for this federate.
     if (federate.targetConfig.coordination == CoordinationType.DECENTRALIZED) {
@@ -746,7 +749,7 @@ private String generateCodeToInitializeFederate(FederateInstance federate, RtiCo
               "// physical connections. The thread will live until all connections",
               "// have been established.",
               "lf_thread_create(&_fed.inbound_p2p_handling_thread_id,"
-                  + " handle_p2p_connections_from_federates, NULL);"));
+                  + " handle_p2p_connections_from_federates, env);"));
     }
 
     for (FederateInstance remoteFederate : federate.outboundP2PConnections) {

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

@@ -0,0 +1,19 @@
+package org.lflang.generator;
+
+public class EnclaveInfo {
+  public int numIsPresentFields = 0;
+  public int numStartupReactions = 0;
+  public int numShutdownReactions = 0;
+  public int numTimerTriggers = 0;
+  public int numResetReactions = 0;
+  public int numWorkers = 1;
+  public int numModalReactors = 0;
+  public int numModalResetStates = 0;
+
+  public String traceFileName = null;
+  private ReactorInstance instance;
+
+  public EnclaveInfo(ReactorInstance inst) {
+    instance = inst;
+  }
+}

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

@@ -24,6 +24,7 @@
 
 package org.lflang.generator;
 
+import static org.lflang.AttributeUtils.isEnclave;
 import static org.lflang.ast.ASTUtils.getLiteralTimeValue;
 
 import java.util.ArrayList;
@@ -171,6 +172,8 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re
   /** Indicator that this reactor has itself as a parent, an error condition. */
   public final boolean recursive;
 
+  // An enclave object if this ReactorInstance is an enclave. null if not
+  public EnclaveInfo enclaveInfo = null;
   public TypeParameterizedReactor tpr;
 
   //////////////////////////////////////////////////////
@@ -813,6 +816,13 @@ public ReactorInstance(
             ? new TypeParameterizedReactor(definition, reactors)
             : new TypeParameterizedReactor(definition, parent.tpr);
 
+    // If this instance is an enclave (or the main reactor). Create an
+    // enclaveInfo object to track information about the enclave needed for
+    // later code-generation
+    if (isEnclave(definition) || this.isMainOrFederated()) {
+      enclaveInfo = new EnclaveInfo(this);
+    }
+
     // check for recursive instantiation
     var currentParent = parent;
     var foundSelfAsParent = false;

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

@@ -309,7 +309,7 @@ public LFCommand buildWestFlashCommand() {
     Path buildPath = fileConfig.getSrcGenPath().resolve("build");
     String board = targetConfig.platformOptions.board;
     LFCommand cmd;
-    if (board == null || board.startsWith("qemu")) {
+    if (board == null || board.startsWith("qemu") || board.equals("native_posix")) {
       cmd = commandFactory.createCommand("west", List.of("build", "-t", "run"), buildPath);
     } else {
       cmd = commandFactory.createCommand("west", List.of("flash"), buildPath);

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

@@ -0,0 +1,138 @@
+package org.lflang.generator.c;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.lflang.TargetConfig;
+import org.lflang.generator.CodeBuilder;
+import org.lflang.generator.ReactorInstance;
+
+/**
+ * This class is in charge of code generating functions and global variables related to the
+ * environments
+ */
+public class CEnvironmentFunctionGenerator {
+
+  /**
+   * @param main The top-level reactor instance of the program
+   * @param targetConfig The target config of the program
+   * @param lfModuleName The lfModuleName of the program
+   */
+  public CEnvironmentFunctionGenerator(
+      ReactorInstance main, TargetConfig targetConfig, String lfModuleName) {
+    this.enclaves = CUtil.getEnclaves(main);
+    this.targetConfig = targetConfig;
+    this.lfModuleName = lfModuleName;
+  }
+
+  public String generateDeclarations() {
+    CodeBuilder code = new CodeBuilder();
+    code.pr(generateEnvironmentEnum());
+    code.pr(generateEnvironmentArray());
+    return code.toString();
+  }
+
+  public String generateDefinitions() {
+    CodeBuilder code = new CodeBuilder();
+    code.pr(generateCreateEnvironments());
+    code.pr(generateGetEnvironments());
+    return code.toString();
+  }
+
+  private List<ReactorInstance> enclaves = new ArrayList<>();
+  private TargetConfig targetConfig;
+  private String lfModuleName;
+
+  private String generateEnvironmentArray() {
+    return String.join(
+        "\n",
+        "// The global array of environments associated with each enclave",
+        "environment_t envs[_num_enclaves];");
+  }
+
+  private String generateGetEnvironments() {
+    return String.join(
+        "\n",
+        "// Update the pointer argument to point to the beginning of the environment array",
+        "// and return the size of that array",
+        "int _lf_get_environments(environment_t ** return_envs) {",
+        "   (*return_envs) = (environment_t *) envs;",
+        "   return _num_enclaves;",
+        "}");
+  }
+
+  private String generateEnvironmentEnum() {
+    CodeBuilder code = new CodeBuilder();
+    code.pr("typedef enum {");
+    code.indent();
+    for (ReactorInstance enclave : enclaves) {
+      code.pr(CUtil.getEnvironmentId(enclave) + ",");
+    }
+    code.pr("_num_enclaves");
+    code.unindent();
+    code.pr("} _enclave_id;");
+
+    return code.toString();
+  }
+
+  private String generateCreateEnvironments() {
+    CodeBuilder code = new CodeBuilder();
+    code.pr("// 'Create' and initialize the environments in the program");
+    code.pr("void _lf_create_environments() {");
+    code.indent();
+    for (ReactorInstance enclave : enclaves) {
+      // Decide the number of workers to use. If this is the top-level
+      // use the global variable _lf_number_of_workers which accounts for federation etc.
+      String numWorkers = String.valueOf(enclave.enclaveInfo.numWorkers);
+      if (enclave.isMainOrFederated()) {
+        numWorkers = "_lf_number_of_workers";
+      }
+
+      // Figure out the name of the trace file
+      String traceFileName = "NULL";
+      if (targetConfig.tracing != null) {
+        if (targetConfig.tracing.traceFileName != null) {
+          if (enclave.isMainOrFederated()) {
+            traceFileName = "\"" + targetConfig.tracing.traceFileName + ".lft\"";
+          } else {
+            traceFileName =
+                "\"" + targetConfig.tracing.traceFileName + enclave.getName() + ".lft\"";
+          }
+        } else {
+          if (enclave.isMainOrFederated()) {
+            traceFileName = "\"" + lfModuleName + ".lft\"";
+          } else {
+            traceFileName = "\"" + lfModuleName + enclave.getName() + ".lft\"";
+          }
+        }
+      }
+
+      code.pr(
+          "environment_init(&"
+              + CUtil.getEnvironmentStruct(enclave)
+              + ","
+              + CUtil.getEnvironmentId(enclave)
+              + ","
+              + numWorkers
+              + ","
+              + enclave.enclaveInfo.numTimerTriggers
+              + ","
+              + enclave.enclaveInfo.numStartupReactions
+              + ","
+              + enclave.enclaveInfo.numShutdownReactions
+              + ","
+              + enclave.enclaveInfo.numResetReactions
+              + ","
+              + enclave.enclaveInfo.numIsPresentFields
+              + ","
+              + enclave.enclaveInfo.numModalReactors
+              + ","
+              + enclave.enclaveInfo.numModalResetStates
+              + ","
+              + traceFileName
+              + ");");
+    }
+    code.unindent();
+    code.pr("}");
+    return code.toString();
+  }
+}