Support for FlexPRET platform

.github/actions/setup-flexpret/action.yml

@@ -0,0 +1,48 @@
+name: Install FlexPRET and dependencies (Linux only)
+description: Install FlexPRET and dependencies (Linux only)
+runs:
+  using: "composite"
+  steps:
+    - name: Setup
+      run: |
+        # Clone the FlexPRET repository
+        git clone --recurse-submodules https://github.com/pretis/flexpret
+
+        # This rest is copied directly from FlexPRET's `azure-pipelines.yml`
+
+        # Ubuntu 20.04 only has Verilator 4.028 but we neeed a more modern version
+        # so we do not use 'sudo apt-get install -y -qq verilator' here.
+        wget -q https://github.com/sifive/verilator/releases/download/4.036-0sifive2/verilator_4.036-0sifive2_amd64.deb -O verilator.deb
+        sudo dpkg -i verilator.deb
+
+        # Install riscv compiler
+        wget -q https://github.com/xpack-dev-tools/riscv-none-embed-gcc-xpack/releases/download/v8.3.0-2.3/xpack-riscv-none-embed-gcc-8.3.0-2.3-linux-x64.tar.gz -O riscv.tgz
+        tar zxf riscv.tgz
+        mv xpack-riscv-none-embed-gcc-8.3.0-2.3 ~/riscv-embed-gcc
+        ln -s ~/riscv-embed-gcc/bin/riscv-none-embed-as ~/riscv-embed-gcc/bin/riscv32-unknown-elf-as
+        ln -s ~/riscv-embed-gcc/bin/riscv-none-embed-ar ~/riscv-embed-gcc/bin/riscv32-unknown-elf-ar
+        ln -s ~/riscv-embed-gcc/bin/riscv-none-embed-gcc ~/riscv-embed-gcc/bin/riscv32-unknown-elf-gcc
+        ln -s ~/riscv-embed-gcc/bin/riscv-none-embed-ld ~/riscv-embed-gcc/bin/riscv32-unknown-elf-ld
+        ln -s ~/riscv-embed-gcc/bin/riscv-none-embed-objdump ~/riscv-embed-gcc/bin/riscv32-unknown-elf-objdump
+        ln -s ~/riscv-embed-gcc/bin/riscv-none-embed-objcopy ~/riscv-embed-gcc/bin/riscv32-unknown-elf-objcopy
+
+        # Update submodules
+        git submodule update --init --recursive
+
+        # Save location of RISC-V compiler to reuse later
+        echo "FP_RISCV_COMPILER=~/riscv-embed-gcc" >> "$GITHUB_ENV"
+      shell: bash
+    - name: Build FlexPRET and install to SDK
+      run: |
+        # Step into cloned directory
+        cd flexpret
+
+        # Save pwd to environment variable so we can find `env.bash` in later steps
+        echo "FP_DIR=$(pwd)" >> "$GITHUB_ENV"
+
+        # Source environment
+        source env.bash
+
+        # Build FlexPRET's high memory configuration and install it to SDK
+        cd $FP_PATH && cmake -DFP_CONFIG=highmem -B build && cd build && make all install
+      shell: bash

.github/workflows/all-embedded.yml

@@ -0,0 +1,33 @@
+# Tests for embedded platforms
+name: CI (embedded platforms)
+
+on:
+  schedule:
+    # * is a special character in YAML so you have to quote this string
+    - cron: '0 8 * * 6'
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [synchronize, opened, reopened, ready_for_review, converted_to_draft]
+  merge_group:
+
+env:
+  # 2020.11
+  vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0
+
+concurrency:
+  group: all-embedded-${{ github.ref }}-${{ github.event_path }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
+
+jobs:
+  check-diff:
+    uses: ./.github/workflows/check-diff.yml
+
+  c-embedded:
+    uses: ./.github/workflows/c-embedded.yml
+    needs: check-diff
+    if: ${{ needs.check-diff.outputs.run_c == 'true' }}
+
+  # Add more languages if supported

.github/workflows/c-embedded.yml

@@ -0,0 +1,28 @@
+name: C embedded
+
+on:
+  workflow_dispatch:
+  workflow_call:
+
+env:
+  # 2020.11
+  vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0
+
+concurrency:
+  group: c-embedded-${{ github.ref }}-${{ github.event_path }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
+
+jobs:
+  # Run the C Arduino integration tests.
+  arduino:
+    uses: ./.github/workflows/c-arduino-tests.yml
+    with:
+      all-platforms: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
+
+  # Run the C Zephyr integration tests.
+  zephyr:
+    uses: ./.github/workflows/c-zephyr-tests.yml
+
+  # Run the C FlexPRET integration tests.
+  flexpret:
+    uses: ./.github/workflows/c-flexpret-tests.yml

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

@@ -0,0 +1,58 @@
+name: C FlexPRET tests
+
+on:
+  workflow_call:
+    inputs:
+      compiler-ref:
+        required: false
+        type: string
+      runtime-ref:
+        required: false
+        type: string
+      use-cpp:
+        required: false
+        type: boolean
+        default: false
+      scheduler:
+        required: false
+        type: string
+      all-platforms:
+        required: false
+        default: true
+        type: boolean
+
+jobs:
+  flexpret-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out lingua-franca repository
+        uses: actions/checkout@v3
+        with:
+          repository: lf-lang/lingua-franca
+          submodules: true
+          ref: ${{ inputs.compiler-ref }}
+          fetch-depth: 0
+      - name: Prepare build environment
+        uses: ./.github/actions/prepare-build-env
+      - name: Setup and build FlexPRET
+        uses: ./.github/actions/setup-flexpret
+      - name: Check out specific ref of reactor-c
+        uses: actions/checkout@v3
+        with:
+          repository: lf-lang/reactor-c
+          path: core/src/main/resources/lib/c/reactor-c
+          ref: ${{ inputs.runtime-ref }}
+        if: ${{ inputs.runtime-ref }}
+      - name: Run FlexPRET smoke tests
+        run: |
+          cd "$FP_DIR" && source env.bash && cd -
+          export RISCV_TOOL_PATH_PREFIX=$FP_RISCV_COMPILER
+          ./gradlew core:integrationTest \
+            --tests org.lflang.tests.runtime.CFlexPRETTest.* \
+            core:integrationTestCodeCoverageReport
+          rm -rf test/C/src-gen
+      - name: Report to CodeCov
+        uses: ./.github/actions/report-code-coverage
+        with:
+          files: core/build/reports/jacoco/integrationTestCodeCoverageReport/integrationTestCodeCoverageReport.xml
+        if: ${{ github.repository == 'lf-lang/lingua-franca' }}

.github/workflows/only-c.yml

@@ -25,16 +25,6 @@ jobs:
     with:
       target: "C"
 
-  # Run the C Arduino integration tests.
-  arduino:
-    uses: ./.github/workflows/c-arduino-tests.yml
-    with:
-      all-platforms: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
-
-  # Run the C Zephyr integration tests.
-  zephyr:
-    uses: ./.github/workflows/c-zephyr-tests.yml
-
   # Run the CCpp integration tests.
   ccpp:
     uses: ./.github/workflows/c-tests.yml

core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java

@@ -232,7 +232,7 @@ public static boolean compatibleWithThreadingOff(TestCategory category) {
 
     // CONCURRENT, FEDERATED, DOCKER_FEDERATED, DOCKER
     // are not compatible with single-threaded execution.
-    // ARDUINO and ZEPHYR have their own test suites, so we don't need to rerun.
+    // ARDUINO, ZEPHYR and FLEXPRET have their own test suites, so we don't need to rerun.
     boolean excluded =
         category == TestCategory.CONCURRENT
             || category == TestCategory.SERIALIZATION
@@ -244,7 +244,8 @@ public static boolean compatibleWithThreadingOff(TestCategory category) {
             || category == TestCategory.VERIFIER
             || category == TestCategory.ZEPHYR_UNTHREADED
             || category == TestCategory.ZEPHYR_BOARDS
-            || category == TestCategory.ZEPHYR_THREADED;
+            || category == TestCategory.ZEPHYR_THREADED
+            || category == TestCategory.FLEXPRET;
 
     // SERIALIZATION and TARGET tests are excluded on Windows.
     excluded |= isWindows() && category == TestCategory.TARGET;

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

@@ -0,0 +1,80 @@
+/*************
+ * Copyright (c) 2023, The University of California at Berkeley.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***************/
+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.tests.Configurators;
+import org.lflang.tests.TestBase;
+import org.lflang.tests.TestRegistry.TestCategory;
+import org.lflang.tests.Transformers;
+
+public class CFlexPRETTest extends TestBase {
+
+  public CFlexPRETTest() {
+    super(Target.C);
+  }
+
+  @Test
+  public void buildFlexPRETConcurrent() {
+    Assumptions.assumeTrue(isLinux(), "FlexPRET tests only supported on Linux");
+    super.runTestsFor(
+        List.of(Target.C),
+        "Build concurrent tests for FlexPRET.",
+        TestCategory.CONCURRENT::equals,
+        Transformers::noChanges,
+        Configurators::makeFlexPRETCompatible,
+        TestLevel.BUILD,
+        false);
+  }
+
+  @Test
+  public void buildFlexPRETBasicTestsUnthreaded() {
+    Assumptions.assumeTrue(isLinux(), "FlexPRET tests only supported on Linux");
+    super.runTestsFor(
+        List.of(Target.C),
+        "Build basic tests for FlexPRET in single threaded mode.",
+        TestCategory.BASIC::equals,
+        Transformers::noChanges,
+        Configurators::makeFlexPRETCompatibleUnthreaded,
+        TestLevel.BUILD,
+        false);
+  }
+
+  @Test
+  public void buildFlexPRETBasicTests() {
+    Assumptions.assumeTrue(isLinux(), "FlexPRET tests only supported on Linux");
+    super.runTestsFor(
+        List.of(Target.C),
+        "Build basic tests for FlexPRET.",
+        TestCategory.BASIC::equals,
+        Transformers::noChanges,
+        Configurators::makeFlexPRETCompatible,
+        TestLevel.BUILD,
+        false);
+  }
+}

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

@@ -452,6 +452,21 @@ public static String generateFederateNeighborStructure(FederateInstance federate
     return code.toString();
   }
 
+  public static String surroundWithIfElseFederated(String insideIf, String insideElse) {
+    if (insideElse == null) {
+      return surroundWithIfFederated(insideIf);
+    } else {
+      return """
+              #ifdef FEDERATED
+              %s
+              #else
+              %s
+              #endif // FEDERATED
+              """
+          .formatted(insideIf, insideElse);
+    }
+  }
+
   /**
    * Surround {@code code} with blocks to ensure that code only executes if the program is
    * federated.
@@ -465,6 +480,21 @@ public static String surroundWithIfFederated(String code) {
         .formatted(code);
   }
 
+  public static String surroundWithIfElseFederatedCentralized(String insideIf, String insideElse) {
+    if (insideElse == null) {
+      return surroundWithIfFederatedCentralized(insideIf);
+    } else {
+      return """
+              #ifdef FEDERATED_CENTRALIZED
+              %s
+              #else
+              %s
+              #endif // FEDERATED_CENTRALIZED
+             """
+          .formatted(insideIf, insideElse);
+    }
+  }
+
   /**
    * Surround {@code code} with blocks to ensure that code only executes if the program is federated
    * and has a centralized coordination.