diff --git a/.github/workflows/build-and-test-macos.yml b/.github/workflows/build-and-test-macos.yml new file mode 100644 index 000000000..4f34f3fe8 --- /dev/null +++ b/.github/workflows/build-and-test-macos.yml @@ -0,0 +1,411 @@ +name: Build and Test macOS + +# This file defines a workflow parameterized by OS and GHC version, +# that is called from the top-level CI workflow + +on: + workflow_call: + inputs: + os: + required: true + type: string + ghc_version: + required: true + type: string + hls_version: + required: true + type: string + +jobs: + build-macOS: + name: "Build: ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + steps: + - uses: actions/checkout@v3 + - name: Checkout submodules + shell: bash + run: | + auth_header="$(git config --local --get http.https://github.com/.extraheader)" + git submodule sync --recursive + git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1 + - name: Install dependencies + shell: bash + run: | + .github/workflows/install_dependencies_macos.sh + # If the runner doesn't have 'ghcup', install it + if ! [ -x "$(command -v ghcup)" ]; then + curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh + echo "$HOME/.ghcup/bin" >> $GITHUB_PATH + export PATH=$HOME/.ghcup/bin:$PATH + fi + # Don't rely on the VM to pick the GHC version + ghcup install ghc ${{ inputs.ghc_version }} + ghcup set ghc ${{ inputs.ghc_version }} + # Until BSC uses cabal to build, pre-install these packages + - name: Install Haskell dependencies + shell: bash + run: | + cabal update + cabal v1-install old-time regex-compat split syb + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every build, + # and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: build-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + build-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + - name: Build + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + ccache --zero-stats --max-size 250M + export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH + + # Hack: Remove incompatible TCL header that something has installed + # in /usr/local/include in the GitHub CI image. This dir is at the + # start of the compiler's default search path, and overrides the + # system tcl.h, and causes a linker failure (because of a macro that + # renames Tcl_Main to Tcl_MainEx). We want to build against the + # system TCL so we don't introduce any extra deps for the bluetcl + # binary. + rm -f /usr/local/include/tcl.h + + make -j3 GHCJOBS=2 GHCRTSFLAGS='+RTS -M4500M -A128m -RTS' install-src + tar czf inst.tar.gz inst + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + - name: Smoketest + run: "make check-smoke" + # if this step fails, it may mean you need to update + # util/haskell-language-server/gen_hie.py to + # reflect the locations of any new haskell sources + - name: Test Haskell Language Server + run: | + ghcup install hls ${{ inputs.hls_version }} + pip3 install pyyaml + python3 util/haskell-language-server/gen_hie.py + pushd src/comp + haskell-language-server-${{ inputs.ghc_version }} bsc.hs + popd + # Check that .ghci has all the right flags to load the source. + # This is important for text editor integration & tools like ghcid + # NB stp, yices and htcl must be built first, so do this after Build. + - name: Check GHCI :load + run: | + cd src/comp + export NOGIT=0 + export NOUPDATEBUILDVERSION=0 + ./update-build-version.sh + ./update-build-system.sh + echo ':load bsc.hs' | ghci 2>&1 | tee ghci.log + if grep '\(Failed\|error:\)' ghci.log + then + echo "GHCi reported errors." + exit 1 + else + echo "GHCi loaded successfully." + exit 0 + fi + - name: Upload artifact + uses: actions/upload-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + path: inst.tar.gz + + test-macOS: + name: "Test ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + needs: build-macos + steps: + - uses: actions/checkout@v3 + + - name: Install dependencies + shell: bash + run: ".github/workflows/install_dependencies_testsuite_macos.sh" + + - name: Download bsc + uses: actions/download-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + - name: Install bsc + run: "tar xzf inst.tar.gz" + + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every + # successful build, and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: test-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + test-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + + - name: Run testsuite + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + # Use ccache to avoid recompiling generated .cxx every run. + ccache --zero-stats --max-size 500M + export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH + + # Use -O0 for significantly faster C++ compiles (which more + # than make up for slower simulations) + export CXXFLAGS="-O0" + + # Always archive logs, even if make fails (and terminates this script + # because it's invoked with :set -eo pipefile) + trap ./testsuite/archive_logs.sh EXIT + + make -C testsuite \ + TEST_SYSTEMC_INC=$(brew --prefix systemc)/include \ + TEST_SYSTEMC_LIB=$(brew --prefix systemc)/lib \ + TEST_SYSTEMC_CXXFLAGS=-std=c++11 + + # Show ccache stats so we can see what the hit-rate is like. + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + + # Save test logs on failure so we can diagnose + - name: Archive test logs + if: failure() + uses: actions/upload-artifact@v3 + with: + name: test-logs-${{ inputs.os }}-ghc-${{ inputs.ghc_version }} + path: logs.tar.gz + + test-toooba-macOS: + name: "Test Toooba ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + needs: build-macos + steps: + - uses: actions/checkout@v3 + + - name: Install dependencies + run: | + brew install ccache libelf + + - name: Download bsc + uses: actions/download-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + - name: Install bsc + run: "tar xzf inst.tar.gz" + + - name: Download Toooba + run: | + git clone --recursive https://github.com/bluespec/Toooba ../Toooba + + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every + # successful build, and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: test-toooba-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + test-toooba-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + + - name: Compile and link Toooba + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + # Use ccache to avoid recompiling generated .cxx every run. + ccache --zero-stats --max-size 500M + export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH + + export PATH=$PWD/../bsc/inst/bin:$PATH + + cd ../Toooba/builds/RV64ACDFIMSU_Toooba_bluesim/ + + # Use -O0 for significantly faster C++ compiles (which more + # than make up for slower simulations) + export CXXFLAGS="-O0" + + # Workaround hardcoded parallelism + sed -i -e 's/-parallel-sim-link 8/-parallel-sim-link 2/' ../Resources/Include_bluesim.mk + + # For ccache to be effective, the output needs to be reproducible + make BSC_C_FLAGS="-no-show-version -no-show-timestamps" all + + - name: Test Toooba + run: | + export PATH=$PWD/../bsc/inst/bin:$PATH + + cd ../Toooba/Tests/elf_to_hex + + make CPATH=/usr/local/include/libelf + + cd ../../builds/RV64ACDFIMSU_Toooba_bluesim/ + + # Workaround bugs in the regression script + #make isa_tests | tee isa_tests.log + #grep -q 'FAIL: 0 tests' isa_tests.log + make test | tee test.log + grep -q 'PASS' test.log + + # Show ccache stats so we can see what the hit-rate is like. + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + + test-contrib-macOS: + name: "Test bsc-contrib ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + needs: build-macos + steps: + - uses: actions/checkout@v3 + + - name: Install dependencies + shell: bash + run: ".github/workflows/install_dependencies_testsuite_macos.sh" + + - name: Download bsc + uses: actions/download-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + - name: Install bsc + run: "tar xzf inst.tar.gz" + + - name: Download bsc-contrib + run: | + git clone --recursive https://github.com/B-Lang-org/bsc-contrib ../bsc-contrib + + - name: Build and install bsc-contrib + run: | + export PATH=$PWD/../bsc/inst/bin:$PATH + make -C ../bsc-contrib/ + + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every + # successful build, and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: test-contrib-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + test-contrib-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + + - name: Run bsc-contrib tests + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + # Use ccache to avoid recompiling generated .cxx every run. + ccache --zero-stats --max-size 500M + export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH + + # Use -O0 for significantly faster C++ compiles (which more + # than make up for slower simulations) + export CXXFLAGS="-O0" + + # Copy the bsc-contrib tests into place + cp -r ../bsc-contrib/testing/bsc.contrib testsuite/ + + # Inform the tests of the path to the bsc-contrib libraries + export BSCCONTRIBDIR=$PWD/../bsc-contrib/inst + + # Always archive logs, even if make fails (and terminates this script + # because it's invoked with :set -eo pipefile) + trap ./testsuite/archive_logs.sh EXIT + + make -C testsuite/bsc.contrib check + + # Show ccache stats so we can see what the hit-rate is like. + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + + # Save test logs on failure so we can diagnose + - name: Archive test logs + if: failure() + uses: actions/upload-artifact@v3 + with: + name: test-contrib-logs-${{ inputs.os }}-ghc-${{ inputs.ghc_version }} + path: logs.tar.gz + + test-bdw-macOS: + name: "Test bdw ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + needs: build-macos + steps: + - uses: actions/checkout@v3 + + - name: Download bsc + uses: actions/download-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + - name: Install bsc + run: "tar xzf inst.tar.gz" + + - name: Download bdw + run: | + git clone --recursive https://github.com/B-Lang-org/bdw ../bdw + + - name: Build and install bdw + run: | + export PATH=$PWD/../bsc/inst/bin:$PATH + make -C ../bdw/ + + - name: Install dependencies + shell: bash + run: "../bdw/.github/workflows/install_dependencies_testsuite_macos.sh" + + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every + # successful build, and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: test-bdw-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + test-bdw-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + + - name: Run bdw tests + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + # Use ccache to avoid recompiling generated .cxx every run. + ccache --zero-stats --max-size 500M + export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH + + # Use -O0 for significantly faster C++ compiles (which more + # than make up for slower simulations) + export CXXFLAGS="-O0" + + # Copy the bdw tests into place + cp -r ../bdw/testing/bsc.bdw testsuite/ + + # Inform the tests of the path to bdw + export BDW=$PWD/../bdw/inst/bin/bdw + + # Always archive logs, even if make fails (and terminates this script + # because it's invoked with :set -eo pipefile) + trap ./testsuite/archive_logs.sh EXIT + + make -C testsuite/bsc.bdw check + + # Show ccache stats so we can see what the hit-rate is like. + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + + # Save test logs on failure so we can diagnose + - name: Archive test logs + if: failure() + uses: actions/upload-artifact@v3 + with: + name: test-bdw-logs-${{ inputs.os }}-ghc-${{ inputs.ghc_version }} + path: logs.tar.gz diff --git a/.github/workflows/build-and-test-ubuntu.yml b/.github/workflows/build-and-test-ubuntu.yml new file mode 100644 index 000000000..ac667d2bd --- /dev/null +++ b/.github/workflows/build-and-test-ubuntu.yml @@ -0,0 +1,413 @@ +name: Build and Test Ubuntu + +# This file defines a workflow parameterized by OS and GHC version, +# that is called from the top-level CI workflow + +on: + workflow_call: + inputs: + os: + required: true + type: string + ghc_version: + required: true + type: string + hls_version: + required: true + type: string + +jobs: + build-ubuntu: + name: "Build: ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + steps: + - uses: actions/checkout@v3 + - name: Checkout submodules + shell: bash + run: | + auth_header="$(git config --local --get http.https://github.com/.extraheader)" + git submodule sync --recursive + git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1 + - name: Install dependencies + shell: bash + run: | + sudo .github/workflows/install_dependencies_ubuntu.sh + # Don't rely on the VM to pick the GHC version + ghcup install ghc ${{ inputs.ghc_version }} + ghcup set ghc ${{ inputs.ghc_version }} + # Until BSC uses cabal to build, pre-install these packages + - name: Install Haskell dependencies + shell: bash + run: | + cabal update + cabal v1-install old-time regex-compat split syb + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every build, + # and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: build-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + build-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + - name: Build + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + ccache --zero-stats --max-size 250M + export PATH=/usr/lib/ccache:$PATH + make -j3 GHCJOBS=2 GHCRTSFLAGS='+RTS -M5G -A128m -RTS' install-src + tar czf inst.tar.gz inst + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + - name: Smoketest + run: "make check-smoke" + # if this step fails, it may mean you need to update + # util/haskell-language-server/gen_hie.py to + # reflect the locations of any new haskell sources + - name: Test Haskell Language Server + run: | + ghcup install hls ${{ inputs.hls_version }} + pip3 install pyyaml + python3 util/haskell-language-server/gen_hie.py + pushd src/comp + haskell-language-server-${{ inputs.ghc_version }} bsc.hs + popd + # Check that .ghci has all the right flags to load the source. + # This is important for text editor integration & tools like ghcid + # NB stp, yices and htcl must be built first, so do this after Build. + - name: Check GHCI :load + run: | + cd src/comp + export NOGIT=0 + export NOUPDATEBUILDVERSION=0 + ./update-build-version.sh + ./update-build-system.sh + echo ':load bsc.hs' | ghci 2>&1 | tee ghci.log + if grep '\(Failed\|error:\)' ghci.log + then + echo "GHCi reported errors." + exit 1 + else + echo "GHCi loaded successfully." + exit 0 + fi + - name: Upload artifact + uses: actions/upload-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + path: inst.tar.gz + + test-ubuntu: + name: "Test ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + needs: build-ubuntu + steps: + - uses: actions/checkout@v3 + + - name: Install dependencies + shell: bash + run: "sudo .github/workflows/install_dependencies_testsuite_ubuntu.sh" + + - name: Download bsc + uses: actions/download-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + - name: Install bsc + run: "tar xzf inst.tar.gz" + + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every + # successful build, and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: test-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + test-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + + - name: Run testsuite + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + # Use ccache to avoid recompiling generated .cxx every run. + ccache --zero-stats --max-size 500M + export PATH=/usr/lib/ccache:$PATH + + # Use the LLVM linker as the C++ linker + # for a moderate build-time speedup over ld.bfd + export LINKER=lld + export LDFLAGS="-Wl,-fuse-ld=$LINKER" + + # Use -O0 for significantly faster C++ compiles (which more + # than make up for slower simulations) + export CXXFLAGS="-O0" + + # Always archive logs, even if make fails (and terminates this script + # because it's invoked with :set -eo pipefile) + trap ./testsuite/archive_logs.sh EXIT + + make -C testsuite + + # Show ccache stats so we can see what the hit-rate is like. + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + + # Save test logs on failure so we can diagnose + - name: Archive test logs + if: failure() + uses: actions/upload-artifact@v3 + with: + name: test-logs-${{ inputs.os }}-ghc-${{ inputs.ghc_version }} + path: logs.tar.gz + + test-toooba-ubuntu: + name: "Test Toooba ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + needs: build-ubuntu + steps: + - uses: actions/checkout@v3 + + - name: Install dependencies + run: | + sudo apt-get install -y ccache libelf-dev + + - name: Download bsc + uses: actions/download-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + - name: Install bsc + run: "tar xzf inst.tar.gz" + + - name: Download Toooba + run: | + git clone --recursive https://github.com/bluespec/Toooba ../Toooba + + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every + # successful build, and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: test-toooba-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + test-toooba-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + + - name: Compile and link Toooba + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + # Use ccache to avoid recompiling generated .cxx every run. + ccache --zero-stats --max-size 500M + export PATH=/usr/lib/ccache:$PATH + + export PATH=$PWD/../bsc/inst/bin:$PATH + + cd ../Toooba/builds/RV64ACDFIMSU_Toooba_bluesim/ + + # Use -O0 for significantly faster C++ compiles (which more + # than make up for slower simulations) + export CXXFLAGS="-O0" + + # Workaround hardcoded parallelism + sed -i 's/-parallel-sim-link 8/-parallel-sim-link 2/' ../Resources/Include_bluesim.mk + + # For ccache to be effective, the output needs to be reproducible + make BSC_C_FLAGS="-no-show-version -no-show-timestamps" all + + - name: Test Toooba + run: | + export PATH=$PWD/../bsc/inst/bin:$PATH + + cd ../Toooba/Tests/elf_to_hex + + # Workaround a build failure on Ubuntu 22.04 + REL=$(lsb_release -rs | tr -d .) + if [ $REL -lt 2204 ]; then + make + else + gcc -g -o elf_to_hex elf_to_hex.c -lelf -mcmodel=medium + fi + + cd ../../builds/RV64ACDFIMSU_Toooba_bluesim/ + + # Workaround bugs in the regression script + #make isa_tests | tee isa_tests.log + #grep -q 'FAIL: 0 tests' isa_tests.log + make test | tee test.log + grep -q 'PASS' test.log + + # Show ccache stats so we can see what the hit-rate is like. + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + + test-contrib-ubuntu: + name: "Test bsc-contrib ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + needs: build-ubuntu + steps: + - uses: actions/checkout@v3 + + - name: Install dependencies + shell: bash + run: "sudo .github/workflows/install_dependencies_testsuite_ubuntu.sh" + + - name: Download bsc + uses: actions/download-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + - name: Install bsc + run: "tar xzf inst.tar.gz" + + - name: Download bsc-contrib + run: | + git clone --recursive https://github.com/B-Lang-org/bsc-contrib ../bsc-contrib + + - name: Build and install bsc-contrib + run: | + export PATH=$PWD/../bsc/inst/bin:$PATH + make -C ../bsc-contrib/ + + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every + # successful build, and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: test-contrib-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + test-contrib-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + + - name: Run bsc-contrib tests + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + # Use ccache to avoid recompiling generated .cxx every run. + ccache --zero-stats --max-size 500M + export PATH=/usr/lib/ccache:$PATH + + # Use the LLVM linker as the C++ linker + # for a moderate build-time speedup over ld.bfd + export LINKER=lld + export LDFLAGS="-Wl,-fuse-ld=$LINKER" + + # Use -O0 for significantly faster C++ compiles (which more + # than make up for slower simulations) + export CXXFLAGS="-O0" + + # Copy the bsc-contrib tests into place + cp -r ../bsc-contrib/testing/bsc.contrib testsuite/ + + # Inform the tests of the path to the bsc-contrib libraries + export BSCCONTRIBDIR=$PWD/../bsc-contrib/inst + + # Always archive logs, even if make fails (and terminates this script + # because it's invoked with :set -eo pipefile) + trap ./testsuite/archive_logs.sh EXIT + + make -C testsuite/bsc.contrib check + + # Show ccache stats so we can see what the hit-rate is like. + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + + # Save test logs on failure so we can diagnose + - name: Archive test logs + if: failure() + uses: actions/upload-artifact@v3 + with: + name: test-contrib-logs-${{ inputs.os }}-ghc-${{ inputs.ghc_version }} + path: logs.tar.gz + + test-bdw-ubuntu: + name: "Test bdw ${{ inputs.os }} ghc-${{ inputs.ghc_version }}" + runs-on: ${{ inputs.os }} + needs: build-ubuntu + steps: + - uses: actions/checkout@v3 + + - name: Download bsc + uses: actions/download-artifact@v3 + with: + name: ${{ inputs.os }} ghc-${{ inputs.ghc_version }} build + - name: Install bsc + run: "tar xzf inst.tar.gz" + + - name: Download bdw + run: | + git clone --recursive https://github.com/B-Lang-org/bdw ../bdw + + - name: Build and install bdw + run: | + export PATH=$PWD/../bsc/inst/bin:$PATH + make -C ../bdw/ + + - name: Install dependencies + shell: bash + run: "sudo ../bdw/.github/workflows/install_dependencies_testsuite_ubuntu.sh" + + # Restore previous ccache cache of compiled object files. Use a SHA + # in the key so that a new cache file is generated after every + # successful build, and have the restore-key use the most recent. + - name: CCache cache files + uses: actions/cache@v3 + with: + path: ${{ GITHUB.WORKSPACE }}/ccache + key: test-bdw-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache-${{ github.sha }} + restore-keys: | + test-bdw-${{ inputs.os }}-ghc-${{ inputs.ghc_version }}-ccache- + + - name: Run bdw tests + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: | + # Use ccache to avoid recompiling generated .cxx every run. + ccache --zero-stats --max-size 500M + export PATH=/usr/lib/ccache:$PATH + + # Use the LLVM linker as the C++ linker + # for a moderate build-time speedup over ld.bfd + export LINKER=lld + export LDFLAGS="-Wl,-fuse-ld=$LINKER" + + # Use -O0 for significantly faster C++ compiles (which more + # than make up for slower simulations) + export CXXFLAGS="-O0" + + # Copy the bdw tests into place + cp -r ../bdw/testing/bsc.bdw testsuite/ + + # Inform the tests of the path to bdw + export BDW=$PWD/../bdw/inst/bin/bdw + + # Always archive logs, even if make fails (and terminates this script + # because it's invoked with :set -eo pipefile) + trap ./testsuite/archive_logs.sh EXIT + + xvfb-run -a make -C testsuite/bsc.bdw check + + # Show ccache stats so we can see what the hit-rate is like. + - name: CCache stats + env: + CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache + run: ccache --show-stats + + # Save test logs on failure so we can diagnose + - name: Archive test logs + if: failure() + uses: actions/upload-artifact@v3 + with: + name: test-bdw-logs-${{ inputs.os }}-ghc-${{ inputs.ghc_version }} + path: logs.tar.gz diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml deleted file mode 100644 index e45257ded..000000000 --- a/.github/workflows/build.yml +++ /dev/null @@ -1,953 +0,0 @@ -name: CI - -# Trigger the workflow on push or pull request -on: [ push, pull_request ] - -jobs: - build-check-src: - name: "Check: code cleanliness" - runs-on: ubuntu-20.04 - steps: - - uses: actions/checkout@v3 - - name: Check tabs and whitespace - shell: bash - run: ".github/workflows/check_whitespace.sh" - - build-check-testsuite: - name: "Check: testsuite lint" - runs-on: ubuntu-20.04 - steps: - - uses: actions/checkout@v3 - - name: Check CONFDIR - run: | - cd testsuite - ../.github/workflows/check_confdir.py - ../.github/workflows/check_symlinks.py - - build-ubuntu: - strategy: - matrix: - os: [ ubuntu-20.04, ubuntu-22.04 ] - fail-fast: false - name: "Build: ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - steps: - - uses: actions/checkout@v3 - - name: Checkout submodules - shell: bash - run: | - auth_header="$(git config --local --get http.https://github.com/.extraheader)" - git submodule sync --recursive - git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1 - - name: Install dependencies - shell: bash - run: | - sudo .github/workflows/install_dependencies_ubuntu.sh - # Don't rely on the VM to pick the GHC version - ghcup install ghc 9.4.8 - ghcup set ghc 9.4.8 - # Until BSC uses cabal to build, pre-install these packages - - name: Install Haskell dependencies - shell: bash - run: | - cabal update - cabal v1-install old-time regex-compat split syb - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every build, - # and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: build-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - build-${{ matrix.os }}-ccache- - - name: Build - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - ccache --zero-stats --max-size 250M - export PATH=/usr/lib/ccache:$PATH - make -j3 GHCJOBS=2 GHCRTSFLAGS='+RTS -M5G -A128m -RTS' install-src - tar czf inst.tar.gz inst - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - name: Smoketest - run: "make check-smoke" - # if this step fails, it may mean you need to update - # util/haskell-language-server/gen_hie.py to - # reflect the locations of any new haskell sources - - name: Test Haskell Language Server - run: | - ghcup install hls 2.5.0.0 - pip3 install pyyaml - python3 util/haskell-language-server/gen_hie.py - pushd src/comp - haskell-language-server-9.4.8 bsc.hs - popd - # Check that .ghci has all the right flags to load the source. - # This is important for text editor integration & tools like ghcid - # NB stp, yices and htcl must be built first, so do this after Build. - - name: Check GHCI :load - run: | - cd src/comp - export NOGIT=0 - export NOUPDATEBUILDVERSION=0 - ./update-build-version.sh - ./update-build-system.sh - echo ':load bsc.hs' | ghci 2>&1 | tee ghci.log - if grep '\(Failed\|error:\)' ghci.log - then - echo "GHCi reported errors." - exit 1 - else - echo "GHCi loaded successfully." - exit 0 - fi - - name: Upload artifact - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.os }} build - path: inst.tar.gz - - build-macOS: - strategy: - matrix: - os: [ macos-11, macos-12, macos-13 ] - fail-fast: false - name: "Build: ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - steps: - - uses: actions/checkout@v3 - - name: Checkout submodules - shell: bash - run: | - auth_header="$(git config --local --get http.https://github.com/.extraheader)" - git submodule sync --recursive - git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1 - - name: Install dependencies - shell: bash - run: | - .github/workflows/install_dependencies_macos.sh - # If the runner doesn't have 'ghcup', install it - if ! [ -x "$(command -v ghcup)" ]; then - curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh - echo "$HOME/.ghcup/bin" >> $GITHUB_PATH - export PATH=$HOME/.ghcup/bin:$PATH - fi - # Don't rely on the VM to pick the GHC version - ghcup install ghc 9.4.8 - ghcup set ghc 9.4.8 - # Until BSC uses cabal to build, pre-install these packages - - name: Install Haskell dependencies - shell: bash - run: | - cabal update - cabal v1-install old-time regex-compat split syb - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every build, - # and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: build-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - build-${{ matrix.os }}-ccache- - - name: Build - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - ccache --zero-stats --max-size 250M - export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH - - # Hack: Remove incompatible TCL header that something has installed - # in /usr/local/include in the GitHub CI image. This dir is at the - # start of the compiler's default search path, and overrides the - # system tcl.h, and causes a linker failure (because of a macro that - # renames Tcl_Main to Tcl_MainEx). We want to build against the - # system TCL so we don't introduce any extra deps for the bluetcl - # binary. - rm -f /usr/local/include/tcl.h - - make -j3 GHCJOBS=2 GHCRTSFLAGS='+RTS -M4500M -A128m -RTS' install-src - tar czf inst.tar.gz inst - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - name: Smoketest - run: "make check-smoke" - # if this step fails, it may mean you need to update - # util/haskell-language-server/gen_hie.py to - # reflect the locations of any new haskell sources - - name: Test Haskell Language Server - run: | - ghcup install hls 2.5.0.0 - pip3 install pyyaml - python3 util/haskell-language-server/gen_hie.py - pushd src/comp - haskell-language-server-9.4.8 bsc.hs - popd - # Check that .ghci has all the right flags to load the source. - # This is important for text editor integration & tools like ghcid - # NB stp, yices and htcl must be built first, so do this after Build. - - name: Check GHCI :load - run: | - cd src/comp - export NOGIT=0 - export NOUPDATEBUILDVERSION=0 - ./update-build-version.sh - ./update-build-system.sh - echo ':load bsc.hs' | ghci 2>&1 | tee ghci.log - if grep '\(Failed\|error:\)' ghci.log - then - echo "GHCi reported errors." - exit 1 - else - echo "GHCi loaded successfully." - exit 0 - fi - - name: Upload artifact - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.os }} build - path: inst.tar.gz - - build-doc-ubuntu: - strategy: - matrix: - os: [ ubuntu-20.04, ubuntu-22.04 ] - fail-fast: false - name: "Build doc: ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - steps: - - uses: actions/checkout@v3 - - name: Install dependencies - shell: bash - run: "sudo .github/workflows/install_dependencies_doc_ubuntu.sh" - - name: Build - run: | - make -j3 install-doc - tar czf inst.tar.gz inst - # The next two actions upload the PDFs as an artifact that can be downloaded. - # We provide two versions: one for release packaging and one for users. - # This is because the GitHub download will provide the artifact as a zip-file, - # even if the artifact itself is just one file: - # https://github.com/actions/upload-artifact/issues/3 - # https://github.com/actions/upload-artifact/issues/14 - # It is inconvenient for users to access PDFs inside a tarfile inside a zipfile, - # therefore we provide an option without the tarfile layer. - - name: Upload artifact - # This artifact (PDFs inside inst.tar.gz inside artifact.zip) is for release packaging. - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.os }} build doc - path: inst.tar.gz - - name: Upload doc not tar - # This artifact (PDFs inside artifact.zip) is for viewing the built documents. - uses: actions/upload-artifact@v3 - with: - name: ${{matrix.os}}-doc-not-tar - path: inst/doc - - build-doc-macOS: - strategy: - matrix: - os: [ macos-11, macos-12, macos-13 ] - fail-fast: false - name: "Build doc: ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - steps: - - uses: actions/checkout@v3 - - name: Install dependencies - shell: bash - run: ".github/workflows/install_dependencies_doc_macos.sh" - - name: Build - run: | - # Brew install of mactex doesn't update the path until a new shell is opened - export PATH=/Library/TeX/texbin/:$PATH - - make -j3 install-doc - tar czf inst.tar.gz inst - # The next two actions upload the PDFs as an artifact that can be downloaded. - # We provide two versions: one for release packaging and one for users. - # This is because the GitHub download will provide the artifact as a zip-file, - # even if the artifact itself is just one file: - # https://github.com/actions/upload-artifact/issues/3 - # https://github.com/actions/upload-artifact/issues/14 - # It is inconvenient for users to access PDFs inside a tarfile inside a zipfile, - # therefore we provide an option without the tarfile layer. - - name: Upload artifact - # This artifact (PDFs inside inst.tar.gz inside artifact.zip) is for release packaging. - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.os }} build doc - path: inst.tar.gz - - name: Upload doc not tar - # This artifact (PDFs inside artifact.zip) is for viewing the built documents. - uses: actions/upload-artifact@v3 - with: - name: ${{matrix.os}}-doc-not-tar - path: inst/doc - - build-releasenotes-ubuntu: - # Release Notes only need to be built once, so we build on recent - # Ubuntu, not Mac OS. Later, the release script will copy the - # generated release notes to all release tarballs. - strategy: - matrix: - os: [ ubuntu-22.04 ] - fail-fast: false - name: "Build releasenotes: ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - steps: - - uses: actions/checkout@v3 - - name: Install dependencies - shell: bash - run: "sudo .github/workflows/install_dependencies_releasenotes_ubuntu.sh" - - name: Build - run: | - make install-release - tar czf inst.tar.gz inst - - name: Upload artifact - uses: actions/upload-artifact@v3 - with: - name: ${{ matrix.os }} releasenotes - path: inst.tar.gz - - test-ubuntu: - strategy: - matrix: - os: [ ubuntu-20.04, ubuntu-22.04 ] - fail-fast: false - name: "Test ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - needs: build-ubuntu - steps: - - uses: actions/checkout@v3 - - name: Install dependencies - shell: bash - run: "sudo .github/workflows/install_dependencies_testsuite_ubuntu.sh" - - - name: Download bsc - uses: actions/download-artifact@v3 - with: - name: ${{ matrix.os }} build - - name: Install bsc - run: "tar xzf inst.tar.gz" - - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every - # successful build, and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: test-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - test-${{ matrix.os }}-ccache- - - # Finally, after all this setup, run the testsuite! - - name: Run testsuite - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - # Use ccache to avoid recompiling generated .cxx every run. - ccache --zero-stats --max-size 500M - export PATH=/usr/lib/ccache:$PATH - - # Use the LLVM linker as the C++ linker - # for a moderate build-time speedup over ld.bfd - export LINKER=lld - export LDFLAGS="-Wl,-fuse-ld=$LINKER" - - # Use -O0 for significantly faster C++ compiles (which more - # than make up for slower simulations) - export CXXFLAGS="-O0" - - # Always archive logs, even if make fails (and terminates this script - # because it's invoked with :set -eo pipefile) - trap ./testsuite/archive_logs.sh EXIT - - make -C testsuite - - # Show ccache stats so we can see what the hit-rate is like. - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - # Save test logs on failure so we can diagnose - - name: Archive test logs - if: failure() - uses: actions/upload-artifact@v3 - with: - name: test-logs-${{ matrix.os }} - path: logs.tar.gz - - test-macOS: - strategy: - matrix: - os: [ macos-11, macos-12, macos-13 ] - fail-fast: false - name: "Test ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - needs: build-macos - steps: - - uses: actions/checkout@v3 - - name: Install dependencies - shell: bash - run: ".github/workflows/install_dependencies_testsuite_macos.sh" - - - name: Download bsc - uses: actions/download-artifact@v3 - with: - name: ${{ matrix.os }} build - - name: Install bsc - run: "tar xzf inst.tar.gz" - - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every - # successful build, and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: test-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - test-${{ matrix.os }}-ccache- - - - name: Run testsuite - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - # Use ccache to avoid recompiling generated .cxx every run. - ccache --zero-stats --max-size 500M - export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH - - # Use -O0 for significantly faster C++ compiles (which more - # than make up for slower simulations). - export CXXFLAGS="-O0" - - # Always archive logs, even if make fails (and terminates this script - # because it's invoked with :set -eo pipefile) - trap ./testsuite/archive_logs.sh EXIT - - make -C testsuite \ - TEST_SYSTEMC_INC=$(brew --prefix systemc)/include \ - TEST_SYSTEMC_LIB=$(brew --prefix systemc)/lib \ - TEST_SYSTEMC_CXXFLAGS=-std=c++11 - - # Show ccache stats so we can see what the hit-rate is like. - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - # Save test logs on failure so we can diagnose - - name: Archive test logs - if: failure() - uses: actions/upload-artifact@v3 - with: - name: test-logs-${{ matrix.os }} - path: logs.tar.gz - - test-toooba-ubuntu: - strategy: - matrix: - os: [ ubuntu-20.04, ubuntu-22.04 ] - fail-fast: false - name: "Test Toooba ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - needs: build-ubuntu - steps: - - uses: actions/checkout@v3 - - - name: Install dependencies - run: | - sudo apt-get install -y ccache libelf-dev - - - name: Download bsc - uses: actions/download-artifact@v3 - with: - name: ${{ matrix.os }} build - - name: Install bsc - run: "tar xzf inst.tar.gz" - - - name: Download Toooba - run: | - git clone --recursive https://github.com/bluespec/Toooba ../Toooba - - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every - # successful build, and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: test-toooba-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - test-toooba-${{ matrix.os }}-ccache- - - - name: Compile and link Toooba - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - # Use ccache to avoid recompiling generated .cxx every run. - ccache --zero-stats --max-size 500M - export PATH=/usr/lib/ccache:$PATH - - export PATH=$PWD/../bsc/inst/bin:$PATH - - cd ../Toooba/builds/RV64ACDFIMSU_Toooba_bluesim/ - - # Use -O0 for significantly faster C++ compiles (which more - # than make up for slower simulations) - export CXXFLAGS="-O0" - - # Workaround hardcoded parallelism - sed -i 's/-parallel-sim-link 8/-parallel-sim-link 2/' ../Resources/Include_bluesim.mk - - # For ccache to be effective, the output needs to be reproducible - make BSC_C_FLAGS="-no-show-version -no-show-timestamps" all - - - name: Test Toooba - run: | - export PATH=$PWD/../bsc/inst/bin:$PATH - - cd ../Toooba/Tests/elf_to_hex - - # Workaround a build failure on Ubuntu 22.04 - REL=$(lsb_release -rs | tr -d .) - if [ $REL -lt 2204 ]; then - make - else - gcc -g -o elf_to_hex elf_to_hex.c -lelf -mcmodel=medium - fi - - cd ../../builds/RV64ACDFIMSU_Toooba_bluesim/ - - # Workaround bugs in the regression script - #make isa_tests | tee isa_tests.log - #grep -q 'FAIL: 0 tests' isa_tests.log - make test | tee test.log - grep -q 'PASS' test.log - - # Show ccache stats so we can see what the hit-rate is like. - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - test-toooba-macOS: - strategy: - matrix: - os: [ macos-11, macos-12, macos-13 ] - fail-fast: false - name: "Test Toooba ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - needs: build-macos - steps: - - uses: actions/checkout@v3 - - - name: Install dependencies - run: | - brew install ccache libelf - - - name: Download bsc - uses: actions/download-artifact@v3 - with: - name: ${{ matrix.os }} build - - name: Install bsc - run: "tar xzf inst.tar.gz" - - - name: Download Toooba - run: | - git clone --recursive https://github.com/bluespec/Toooba ../Toooba - - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every - # successful build, and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: test-toooba-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - test-toooba-${{ matrix.os }}-ccache- - - - name: Compile and link Toooba - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - # Use ccache to avoid recompiling generated .cxx every run. - ccache --zero-stats --max-size 500M - export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH - - export PATH=$PWD/../bsc/inst/bin:$PATH - - cd ../Toooba/builds/RV64ACDFIMSU_Toooba_bluesim/ - - # Use -O0 for significantly faster C++ compiles (which more - # than make up for slower simulations) - export CXXFLAGS="-O0" - - # Workaround hardcoded parallelism - sed -i -e 's/-parallel-sim-link 8/-parallel-sim-link 2/' ../Resources/Include_bluesim.mk - - # For ccache to be effective, the output needs to be reproducible - make BSC_C_FLAGS="-no-show-version -no-show-timestamps" all - - - name: Test Toooba - run: | - export PATH=$PWD/../bsc/inst/bin:$PATH - - cd ../Toooba/Tests/elf_to_hex - - make CPATH=/usr/local/include/libelf - - cd ../../builds/RV64ACDFIMSU_Toooba_bluesim/ - - # Workaround bugs in the regression script - #make isa_tests | tee isa_tests.log - #grep -q 'FAIL: 0 tests' isa_tests.log - make test | tee test.log - grep -q 'PASS' test.log - - # Show ccache stats so we can see what the hit-rate is like. - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - test-contrib-ubuntu: - strategy: - matrix: - os: [ ubuntu-20.04, ubuntu-22.04 ] - fail-fast: false - name: "Test bsc-contrib ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - needs: build-ubuntu - steps: - - uses: actions/checkout@v3 - - - name: Install dependencies - shell: bash - run: "sudo .github/workflows/install_dependencies_testsuite_ubuntu.sh" - - - name: Download bsc - uses: actions/download-artifact@v3 - with: - name: ${{ matrix.os }} build - - name: Install bsc - run: "tar xzf inst.tar.gz" - - - name: Download bsc-contrib - run: | - git clone --recursive https://github.com/B-Lang-org/bsc-contrib ../bsc-contrib - - - name: Build and install bsc-contrib - run: | - export PATH=$PWD/../bsc/inst/bin:$PATH - make -C ../bsc-contrib/ - - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every - # successful build, and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: test-contrib-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - test-contrib-${{ matrix.os }}-ccache- - - - name: Run bsc-contrib tests - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - # Use ccache to avoid recompiling generated .cxx every run. - ccache --zero-stats --max-size 500M - export PATH=/usr/lib/ccache:$PATH - - # Use the LLVM linker as the C++ linker - # for a moderate build-time speedup over ld.bfd - export LINKER=lld - export LDFLAGS="-Wl,-fuse-ld=$LINKER" - - # Use -O0 for significantly faster C++ compiles (which more - # than make up for slower simulations). - export CXXFLAGS="-O0" - - # Copy the bsc-contrib tests into place - cp -r ../bsc-contrib/testing/bsc.contrib testsuite/ - - # Inform the tests of the path to the bsc-contrib libraries - export BSCCONTRIBDIR=$PWD/../bsc-contrib/inst - - # Always archive logs, even if make fails (and terminates this script - # because it's invoked with :set -eo pipefile) - trap ./testsuite/archive_logs.sh EXIT - - make -C testsuite/bsc.contrib check - - # Show ccache stats so we can see what the hit-rate is like. - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - # Save test logs on failure so we can diagnose - - name: Archive test logs - if: failure() - uses: actions/upload-artifact@v3 - with: - name: test-contrib-logs-${{ matrix.os }} - path: logs.tar.gz - - test-contrib-macOS: - strategy: - matrix: - os: [ macos-11, macos-12, macos-13 ] - fail-fast: false - name: "Test bsc-contrib ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - needs: build-macos - steps: - - uses: actions/checkout@v3 - - name: Install dependencies - shell: bash - run: ".github/workflows/install_dependencies_testsuite_macos.sh" - - - name: Download bsc - uses: actions/download-artifact@v3 - with: - name: ${{ matrix.os }} build - - name: Install bsc - run: "tar xzf inst.tar.gz" - - - name: Download bsc-contrib - run: | - git clone --recursive https://github.com/B-Lang-org/bsc-contrib ../bsc-contrib - - - name: Build and install bsc-contrib - run: | - export PATH=$PWD/../bsc/inst/bin:$PATH - make -C ../bsc-contrib/ - - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every - # successful build, and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: test-contrib-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - test-contrib-${{ matrix.os }}-ccache- - - - name: Run bsc-contrib tests - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - # Use ccache to avoid recompiling generated .cxx every run. - ccache --zero-stats --max-size 500M - export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH - - # Use -O0 for significantly faster C++ compiles (which more - # than make up for slower simulations). - export CXXFLAGS="-O0" - - # Copy the bsc-contrib tests into place - cp -r ../bsc-contrib/testing/bsc.contrib testsuite/ - - # Inform the tests of the path to the bsc-contrib libraries - export BSCCONTRIBDIR=$PWD/../bsc-contrib/inst - - # Always archive logs, even if make fails (and terminates this script - # because it's invoked with :set -eo pipefile) - trap ./testsuite/archive_logs.sh EXIT - - make -C testsuite/bsc.contrib check - - # Show ccache stats so we can see what the hit-rate is like. - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - # Save test logs on failure so we can diagnose - - name: Archive test logs - if: failure() - uses: actions/upload-artifact@v3 - with: - name: test-contrib-logs-${{ matrix.os }} - path: logs.tar.gz - - test-bdw-ubuntu: - strategy: - matrix: - os: [ ubuntu-20.04, ubuntu-22.04 ] - fail-fast: false - name: "Test bdw ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - needs: build-ubuntu - steps: - - uses: actions/checkout@v3 - - - name: Download bsc - uses: actions/download-artifact@v3 - with: - name: ${{ matrix.os }} build - - name: Install bsc - run: "tar xzf inst.tar.gz" - - - name: Download bdw - run: | - git clone --recursive https://github.com/B-Lang-org/bdw ../bdw - - - name: Build and install bdw - run: | - export PATH=$PWD/../bsc/inst/bin:$PATH - make -C ../bdw/ - - - name: Install dependencies - shell: bash - run: "sudo ../bdw/.github/workflows/install_dependencies_testsuite_ubuntu.sh" - - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every - # successful build, and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: test-bdw-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - test-bdw-${{ matrix.os }}-ccache- - - - name: Run bdw tests - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - # Use ccache to avoid recompiling generated .cxx every run. - ccache --zero-stats --max-size 500M - export PATH=/usr/lib/ccache:$PATH - - # Use the LLVM linker as the C++ linker - # for a moderate build-time speedup over ld.bfd - export LINKER=lld - export LDFLAGS="-Wl,-fuse-ld=$LINKER" - - # Use -O0 for significantly faster C++ compiles (which more - # than make up for slower simulations). - export CXXFLAGS="-O0" - - # Copy the bdw tests into place - cp -r ../bdw/testing/bsc.bdw testsuite/ - - # Inform the tests of the path to bdw - export BDW=$PWD/../bdw/inst/bin/bdw - - # Always archive logs, even if make fails (and terminates this script - # because it's invoked with :set -eo pipefile) - trap ./testsuite/archive_logs.sh EXIT - - xvfb-run -a make -C testsuite/bsc.bdw check - - # Show ccache stats so we can see what the hit-rate is like. - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - # Save test logs on failure so we can diagnose - - name: Archive test logs - if: failure() - uses: actions/upload-artifact@v3 - with: - name: test-bdw-logs-${{ matrix.os }} - path: logs.tar.gz - - test-bdw-macOS: - strategy: - matrix: - os: [ macos-11, macos-12, macos-13 ] - fail-fast: false - name: "Test bdw ${{ matrix.os }}" - runs-on: ${{ matrix.os }} - needs: build-macos - steps: - - uses: actions/checkout@v3 - - - name: Download bsc - uses: actions/download-artifact@v3 - with: - name: ${{ matrix.os }} build - - name: Install bsc - run: "tar xzf inst.tar.gz" - - - name: Download bdw - run: | - git clone --recursive https://github.com/B-Lang-org/bdw ../bdw - - - name: Build and install bdw - run: | - export PATH=$PWD/../bsc/inst/bin:$PATH - make -C ../bdw/ - - - name: Install dependencies - shell: bash - run: "../bdw/.github/workflows/install_dependencies_testsuite_macos.sh" - - # Restore previous ccache cache of compiled object files. Use a SHA - # in the key so that a new cache file is generated after every - # successful build, and have the restore-key use the most recent. - - name: CCache cache files - uses: actions/cache@v3 - with: - path: ${{ GITHUB.WORKSPACE }}/ccache - key: test-bdw-${{ matrix.os }}-ccache-${{ github.sha }} - restore-keys: | - test-bdw-${{ matrix.os }}-ccache- - - - name: Run bdw tests - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: | - # Use ccache to avoid recompiling generated .cxx every run. - ccache --zero-stats --max-size 500M - export PATH=$(brew --prefix)/opt/ccache/libexec:$PATH - - # Use -O0 for significantly faster C++ compiles (which more - # than make up for slower simulations). - export CXXFLAGS="-O0" - - # Copy the bdw tests into place - cp -r ../bdw/testing/bsc.bdw testsuite/ - - # Inform the tests of the path to bdw - export BDW=$PWD/../bdw/inst/bin/bdw - - # Always archive logs, even if make fails (and terminates this script - # because it's invoked with :set -eo pipefile) - trap ./testsuite/archive_logs.sh EXIT - - make -C testsuite/bsc.bdw check - - # Show ccache stats so we can see what the hit-rate is like. - - name: CCache stats - env: - CCACHE_DIR: ${{ GITHUB.WORKSPACE }}/ccache - run: ccache --show-stats - - # Save test logs on failure so we can diagnose - - name: Archive test logs - if: failure() - uses: actions/upload-artifact@v3 - with: - name: test-bdw-logs-${{ matrix.os }} - path: logs.tar.gz diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 000000000..881028d7f --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,171 @@ +name: CI + +# Trigger the workflow on push or pull request +on: [ push, pull_request ] + +jobs: + build-check-src: + name: "Check: code cleanliness" + runs-on: ubuntu-20.04 + steps: + - uses: actions/checkout@v3 + - name: Check tabs and whitespace + shell: bash + run: ".github/workflows/check_whitespace.sh" + + build-check-testsuite: + name: "Check: testsuite lint" + runs-on: ubuntu-20.04 + steps: + - uses: actions/checkout@v3 + - name: Check CONFDIR + run: | + cd testsuite + ../.github/workflows/check_confdir.py + ../.github/workflows/check_symlinks.py + + build-and-test-ubuntu: + strategy: + matrix: + os: [ ubuntu-20.04, ubuntu-22.04 ] + fail-fast: false + name: "Build/Test: ${{ matrix.os }}" + uses: ./.github/workflows/build-and-test-ubuntu.yml + with: + os: ${{ matrix.os }} + ghc_version: 9.4.8 + hls_version: 2.5.0.0 + secrets: inherit + + build-and-test-macos: + strategy: + matrix: + os: [ macos-11, macos-12, macos-13 ] + fail-fast: false + name: "Build/Test: ${{ matrix.os }}" + uses: ./.github/workflows/build-and-test-macos.yml + with: + os: ${{ matrix.os }} + ghc_version: 9.4.8 + hls_version: 2.5.0.0 + secrets: inherit + + build-and-test-ghc-latest-ubuntu: + name: "Build/Test: GHC latest Ubuntu" + uses: ./.github/workflows/build-and-test-ubuntu.yml + with: + os: ubuntu-22.04 + ghc_version: 9.8.1 + hls_version: 2.5.0.0 + secrets: inherit + + build-and-test-ghc-latest-macos: + name: "Build/Test: GHC latest macOS" + uses: ./.github/workflows/build-and-test-macos.yml + with: + os: macos-12 + ghc_version: 9.8.1 + hls_version: 2.5.0.0 + secrets: inherit + + build-doc-ubuntu: + strategy: + matrix: + os: [ ubuntu-20.04, ubuntu-22.04 ] + fail-fast: false + name: "Build doc: ${{ matrix.os }}" + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v3 + - name: Install dependencies + shell: bash + run: "sudo .github/workflows/install_dependencies_doc_ubuntu.sh" + - name: Build + run: | + make -j3 install-doc + tar czf inst.tar.gz inst + # The next two actions upload the PDFs as an artifact that can be downloaded. + # We provide two versions: one for release packaging and one for users. + # This is because the GitHub download will provide the artifact as a zip-file, + # even if the artifact itself is just one file: + # https://github.com/actions/upload-artifact/issues/3 + # https://github.com/actions/upload-artifact/issues/14 + # It is inconvenient for users to access PDFs inside a tarfile inside a zipfile, + # therefore we provide an option without the tarfile layer. + - name: Upload artifact + # This artifact (PDFs inside inst.tar.gz inside artifact.zip) is for release packaging. + uses: actions/upload-artifact@v3 + with: + name: ${{ matrix.os }} build doc + path: inst.tar.gz + - name: Upload doc not tar + # This artifact (PDFs inside artifact.zip) is for viewing the built documents. + uses: actions/upload-artifact@v3 + with: + name: ${{matrix.os}}-doc-not-tar + path: inst/doc + + build-doc-macOS: + strategy: + matrix: + os: [ macos-11, macos-12, macos-13 ] + fail-fast: false + name: "Build doc: ${{ matrix.os }}" + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v3 + - name: Install dependencies + shell: bash + run: ".github/workflows/install_dependencies_doc_macos.sh" + - name: Build + run: | + # Brew install of mactex doesn't update the path until a new shell is opened + export PATH=/Library/TeX/texbin/:$PATH + + make -j3 install-doc + tar czf inst.tar.gz inst + # The next two actions upload the PDFs as an artifact that can be downloaded. + # We provide two versions: one for release packaging and one for users. + # This is because the GitHub download will provide the artifact as a zip-file, + # even if the artifact itself is just one file: + # https://github.com/actions/upload-artifact/issues/3 + # https://github.com/actions/upload-artifact/issues/14 + # It is inconvenient for users to access PDFs inside a tarfile inside a zipfile, + # therefore we provide an option without the tarfile layer. + - name: Upload artifact + # This artifact (PDFs inside inst.tar.gz inside artifact.zip) is for release packaging. + uses: actions/upload-artifact@v3 + with: + name: ${{ matrix.os }} build doc + path: inst.tar.gz + - name: Upload doc not tar + # This artifact (PDFs inside artifact.zip) is for viewing the built documents. + uses: actions/upload-artifact@v3 + with: + name: ${{matrix.os}}-doc-not-tar + path: inst/doc + + build-releasenotes-ubuntu: + # Release Notes only need to be built once, so we build on recent + # Ubuntu, not Mac OS. Later, the release script will copy the + # generated release notes to all release tarballs. + strategy: + matrix: + os: [ ubuntu-22.04 ] + fail-fast: false + name: "Build releasenotes: ${{ matrix.os }}" + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v3 + - name: Install dependencies + shell: bash + run: "sudo .github/workflows/install_dependencies_releasenotes_ubuntu.sh" + - name: Build + run: | + make install-release + tar czf inst.tar.gz inst + - name: Upload artifact + uses: actions/upload-artifact@v3 + with: + name: ${{ matrix.os }} releasenotes + path: inst.tar.gz diff --git a/src/comp/bluetcl.hs b/src/comp/bluetcl.hs index 4a729593e..08dd18155 100644 --- a/src/comp/bluetcl.hs +++ b/src/comp/bluetcl.hs @@ -349,6 +349,8 @@ helpCmd interp [_,cmd] = do isArg _ = False isKW (Just (Keyword _ _ _)) = True isKW _ = False + isKWorNone Nothing = True + isKWorNone e = isKW e matched' = dropWhile isArg matched cmd_words = map fst (reverse matched') let cmd_objs = take (length cmd_words) os @@ -373,7 +375,7 @@ helpCmd interp [_,cmd] = do else [ "", ld ] subtopics = case g' of (ChooseFrom gs) -> - if (all isKW (map htclFirstCmdElem gs)) + if (all isKWorNone (map htclFirstCmdElem gs)) then [ "", "Subcommands: " ] ++ [ " " ++ name ++ descr | gr <- gs @@ -400,11 +402,20 @@ helpCmd interp objs = htclCheckCmd helpGrammar fn interp objs -------------------------------------------------------------------------------- versionGrammar :: HTclCmdGrammar -versionGrammar = tclcmd "version" namespace helpStr "" +versionGrammar = (tclcmd "version" namespace helpStr longHelpStr) .+. + (optional $ oneOf [ kw "bsc" bscHelpStr "" + , kw "ghc" ghcHelpStr "" + ]) where helpStr = "Returns version information for Bluespec software" - -versionNum :: [String] -> IO [String] -versionNum [] = return $ [versionname, buildVersion] + longHelpStr = init $ unlines + [ "If no argument is provided, the subcommand 'bsc' is assumed." ] + bscHelpStr = "Show BSC version information" + ghcHelpStr = "Show the GHC version used to compile BSC" + +versionNum :: [String] -> IO HTclObj +versionNum [] = versionNum ["bsc"] +versionNum ["bsc"] = return $ TLst [TStr versionname, TStr buildVersion] +versionNum ["ghc"] = return $ TStr __GLASGOW_HASKELL_FULL_VERSION__ versionNum xs = internalError $ "versionNum: grammar mismatch: " ++ (show xs) -------------------------------------------------------------------------------- diff --git a/testsuite/bsc.bugs/bluespec_inc/b1490/b1490.exp b/testsuite/bsc.bugs/bluespec_inc/b1490/b1490.exp index f1be61708..3e0bb1f19 100644 --- a/testsuite/bsc.bugs/bluespec_inc/b1490/b1490.exp +++ b/testsuite/bsc.bugs/bluespec_inc/b1490/b1490.exp @@ -1,17 +1,36 @@ + +set rtsflags {+RTS -M256M -Sstderr -RTS} + +# GHC 9.8.1 has regressions +set is_ghc_9_8 [ expr [regexp {^\d+\.\d+} $ghc_version majmin] && \ + $majmin == "9.8" ] +set rtsflags_9_8 {+RTS -M265M -Sstderr -RTS} + +proc compile_verilog_pass_except { filename except rtsflags rtsflags_except} { + if { $except } { + compile_verilog_fail $filename {} $rtsflags + copy [make_bsc_vcomp_output_name $filename] \ + [make_bsc_vcomp_output_name $filename.try1] + compile_verilog_pass $filename {} $rtsflags_except + } else { + compile_verilog_pass $filename {} $rtsflags + } +} + # ----- -compile_verilog_pass Bug1490Bool.bsv "" "+RTS -M256M -Sstderr -RTS" -compile_verilog_pass Bug1490MyBool.bsv "" "+RTS -M256M -Sstderr -RTS" -compile_verilog_pass Bug1490MyUnion.bsv "" "+RTS -M256M -Sstderr -RTS" -compile_verilog_pass Bug1490MyEnum.bsv "" "+RTS -M256M -Sstderr -RTS" +compile_verilog_pass Bug1490Bool.bsv {} $rtsflags +compile_verilog_pass Bug1490MyBool.bsv {} $rtsflags +compile_verilog_pass_except Bug1490MyUnion.bsv $is_ghc_9_8 $rtsflags $rtsflags_9_8 +compile_verilog_pass Bug1490MyEnum.bsv {} $rtsflags # ----- # There has been a regression and this example now exhausts the heap -compile_verilog_fail VsortOriginal.bsv "" "+RTS -M256M -Sstderr -RTS" +compile_verilog_fail VsortOriginal.bsv {} $rtsflags # Confirm that the test failed in the way we expect find_n_strings [make_bsc_vcomp_output_name VsortOriginal.bsv] "Heap exhausted" 1 -compile_verilog_pass VsortWorkaround.bsv "" "+RTS -M256M -Sstderr -RTS" +compile_verilog_pass_except VsortWorkaround.bsv $is_ghc_9_8 $rtsflags $rtsflags_9_8 # ----- diff --git a/testsuite/config/unix.exp b/testsuite/config/unix.exp index 5c93b94b7..6a456ab71 100644 --- a/testsuite/config/unix.exp +++ b/testsuite/config/unix.exp @@ -446,18 +446,33 @@ proc get_default_bsdir {} { } proc get_bsc_version {} { - global bsc + global bluetcl - if {$bsc != 0} then { - set helloworld [exec $bsc -v] - regexp "version .*" $helloworld version - if {![info exists version]} then { - #warning "Couldn't determine version of $bsc from `$helloworld'" - set version "unknown version" - } - } else { # this should have been detected - warning "Can't find bsc to determine version" - set version "unknown version" + bluetcl_initialize + + if { [catch "exec echo \"puts \\\[::Bluetcl::version bsc\\\]\" | $bluetcl" version] } { + perror "failed to execute bluetcl to get BSC version: $version" + exit 1 + } + if { $version == "" } { + perror "BSC version is empty" + exit 1 + } + return $version +} + +proc get_ghc_version {} { + global bluetcl + + bluetcl_initialize + + if { [catch "exec echo \"puts \\\[::Bluetcl::version ghc\\\]\" | $bluetcl" version] } { + perror "failed to execute bluetcl to get GHC version: $version" + exit 1 + } + if { $version == "" } { + perror "GHC version is empty" + exit 1 } return $version } @@ -3177,6 +3192,12 @@ set_warning_threshold 0 set bsdir [get_bsdir] verbose -log "Bluespec dir: $bsdir" 1 +set bsc_version [get_bsc_version] +verbose -log "Bluespec version: $bsc_version" 1 + +set ghc_version [get_ghc_version] +verbose -log "Bluespec tools compiled with GHC version: $ghc_version" 1 + get_test_options verbose -log "Do verilog backend tests is $vtest" 1 verbose -log "Do c backend tests is $ctest" 1 @@ -3235,6 +3256,8 @@ proc bsc_initialize {} { global bsc_initialized global env global bsc + global bsc_version + global ghc_version global bsdir global showrules @@ -3251,7 +3274,6 @@ proc bsc_initialize {} { # find bsc and version and bs prelude set bsc [which_bsc] - set bsc_version [get_bsc_version] # These functions insist that the binaries be available. # Since they are only used for internal tests, we should only insist on @@ -3275,6 +3297,7 @@ proc bsc_initialize {} { } verbose -log "Using $bsc ($bsc_version) for tests." 1 + verbose -log "BSC was compiled with GHC version $ghc_version." 1 verbose -log "Compiler options: $::env(BSC_OPTIONS)" 1 if [do_internal_checks] { verbose -log "Path to dumpbo: $dumpbo" 1