Move Chipyard CI to Github Actions

- As similar as possible to the circle ci code.
- The `.github/README.md` file has a fair amount of documentation for this.
- Creates a worfklow file
  - re-uses most of the circleci/scipts unchanged
  - defines a number of *Composite Actions* which are like YML subroutines
- Removes the circle-ci code
- Points the CI badge in the top level README to use the GA test result

.circleci/README.md

@@ -1,75 +0,0 @@
-Chipyard CI
-===========
-
-Website: https://circleci.com/gh/ucb-bar/chipyard
-
-CircleCI Brief Explanation
----------------------------
-
-CircleCI is controlled by the `config.yml` script.
-It consists of a *workflow* which has a series of *jobs* within it that do particular tasks.
-All jobs in the workflow must pass for the CI run to be successful.
-
-At the bottom of the `config.yml` there is a `workflows:` section that specifies the order in which the jobs of the workflow should run.
-For example:
-
-    - prepare-rocketchip:
-        requires:
-            - install-riscv-toolchain
-
-This specifies that the `prepare-rocketchip` job needs the `install-riscv-toolchain` steps to run before it can run.
-
-All jobs in the CI workflow are specified at the top of `config.yml`
-They specify a docker image to use (in this case a riscv-boom image since that is already available and works nicely) and an environment.
-Finally, in the `steps:` section, the steps are run sequentially and state persists throughout a job.
-So when you run something like `checkout` the next step has the checked out code.
-Caching in the job is done by giving a file to cache on.
-`restore_cache:` loads the cache into the environment if the key matches while `save_cache:` writes to the cache with the key IF IT IS NOT PRESENT.
-Note, if the cache is already present for that key, the write to it is ignored.
-Here the key is built from a string where the `checksum` portion converts the file given into a hash.
-
-.circleci directory
--------------------
-
-This directory contains all the collateral for the Chipyard CI to work.
-The following is included:
-
-    `build-toolchains.sh`        # build either riscv-tools or esp-tools
-    `create-hash.sh`             # create hashes of riscv-tools/esp-tools so circleci caching can work
-    `do-rtl-build.sh`            # use verilator to build a sim executable (remotely)
-    `config.yml`                 # main circleci config script to enumerate jobs/workflows
-    `defaults.sh`                # default variables used
-    `check-commit.sh`            # check that submodule commits are valid
-    `build-extra-tests.sh`       # build default chipyard tests located in tests/
-    `clean-old-files.sh`         # clean up build server files
-    `do-fpga-rtl-build.sh`       # similar to `do-rtl-build` but using fpga/
-    `install-verilator.sh`       # install verilator on build server
-    `run-firesim-scala-tests.sh` # run firesim scala tests
-    `run-tests.sh                # run tests for a specific set of designs
-    `images/`                    # docker image used in CI
-
-How things are setup for Chipyard
----------------------------------
-
-The steps for CI to run are as follows.
-1st, build the toolchains in parallel (note: `esp-tools` is currently not used in the run).
-The docker image sets up the `PATH` and `RISCV` variable so that `riscv-tools` is the default (currently the `env.sh` script that is created at tool build is unused).
-2nd, create the simulator binary.
-This requires the `riscv-tools` for `fesvr` and `verilator` to be able to build the binary.
-This stores all collateral for the tests (srcs, generated-srcs, sim binary, etc) to run "out of the gate" in the next job (make needs everything or else it will run again).
-3rd, finally run the desired tests.
-
-Other CI Setup
---------------
-
-To get the CI to work correctly you need to setup CircleCI environment variables to point to the remote directory to build files and the server user/ip.
-In the project settings, you can find this under "Build Settings" "Environment Variables".
-You need to add two variables like the following:
-
-CI\_DIR = /path/to/where/you/want/to/store/remote/files
-SERVER = username@myserver.coolmachine.berkeley.edu
-
-Additionally, you need to add under the "PERMISSIONS" "SSH Permissions" section a private key that is on the build server that you are using.
-After adding a private key, it will show a fingerprint that should be added under the jobs that need to be run.
-
-Note: On the remote server you need to have the `*.pub` key file added to the `authorized_keys` file.

.circleci/config.yml

@@ -1,524 +0,0 @@
-# CircleCI Configuration File
-
-# version of circleci
-version: 2.1
-
-parameters:
-    tools-cache-version:
-        type: string
-        default: "v12"
-
-# default execution env.s
-executors:
-    main-env:
-        docker:
-            - image: ucbbar/chipyard-ci-image:554b436
-        environment:
-            JVM_OPTS: -Xmx3200m # Customize the JVM maximum heap limit
-
-# re-usable commands
-commands:
-    toolchain-build:
-        description: "Build a toolchain"
-        parameters:
-            tools-version:
-                type: string
-                default: "riscv-tools"
-        steps:
-            - checkout
-            - run:
-                name: Create hash of toolchains
-                command: |
-                    .circleci/create-hash.sh
-            - restore_cache:
-                keys:
-                    - << parameters.tools-version >>-installed-<< pipeline.parameters.tools-cache-version >>-{{ checksum "../<< parameters.tools-version >>.hash" }}
-            - run:
-                name: Building << parameters.tools-version >>
-                command: |
-                    .circleci/build-toolchains.sh << parameters.tools-version >>
-                no_output_timeout: 120m
-            - save_cache:
-                key: << parameters.tools-version >>-installed-<< pipeline.parameters.tools-cache-version >>-{{ checksum "../<< parameters.tools-version >>.hash" }}
-                paths:
-                    - "/root/<< parameters.tools-version >>-install"
-
-    ssh-checkout:
-        description: "Add SSH key and checkout code"
-        steps:
-            - add_ssh_keys:
-                fingerprints:
-                    - "3e:c3:02:5b:ed:64:8c:b7:b0:04:43:bc:83:43:73:1e"
-                    - "32:d6:89:d2:97:fa:db:de:a8:2d:2a:f2:70:dd:80:89"
-            - checkout
-
-    setup-tools:
-        description: "Get toolchain"
-        parameters:
-            tools-version:
-                type: string
-                default: "riscv-tools"
-        steps:
-            - ssh-checkout
-            - run:
-                name: Create hash of toolchains
-                command: |
-                    .circleci/create-hash.sh
-            - restore_cache:
-                keys:
-                    - << parameters.tools-version >>-installed-<< pipeline.parameters.tools-cache-version >>-{{ checksum "../<< parameters.tools-version >>.hash" }}
-
-    prepare-rtl:
-        description: "Run the prepare step of RTL"
-        parameters:
-            tools-version:
-                type: string
-                default: "riscv-tools"
-            group-key:
-                type: string
-            timeout:
-                type: string
-                default: "120m"
-            build-script:
-                type: string
-                default: "do-rtl-build.sh"
-            build-type:
-                type: string
-                default: "sim"
-        steps:
-            - setup-tools:
-                tools-version: "<< parameters.tools-version >>"
-            - run:
-                name: Building << parameters.group-key >> subproject using Verilator
-                command: .circleci/<< parameters.build-script >> << parameters.group-key >> << parameters.build-type >>
-                no_output_timeout: << parameters.timeout >>
-            - save_cache:
-                key: << parameters.group-key >>-{{ .Branch }}-{{ .Revision }}
-                paths:
-                    - "/root/project"
-
-    run-tests:
-        description: "Run a set of tests"
-        parameters:
-            tools-version:
-                type: string
-                default: "riscv-tools"
-            group-key:
-                type: string
-            project-key:
-                type: string
-            run-script:
-                type: string
-                default: "run-tests.sh"
-            timeout:
-                type: string
-                default: "25m"
-        steps:
-            - setup-tools:
-                tools-version: "<< parameters.tools-version >>"
-            - restore_cache:
-                keys:
-                    - << parameters.group-key >>-{{ .Branch }}-{{ .Revision }}
-            - run:
-                name: Run << parameters.project-key >> subproject tests
-                command: .circleci/<< parameters.run-script >> << parameters.project-key >>
-                no_output_timeout: << parameters.timeout >>
-
-# set of jobs to run
-jobs:
-    commit-on-master-check:
-        executor: main-env
-        steps:
-            - checkout
-            - run:
-                name: Check commits of each submodule
-                command: |
-                    .circleci/check-commit.sh
-    tutorial-setup-check:
-        executor: main-env
-        steps:
-            - checkout
-            - run:
-                name: Check that the tutorial-setup patches apply
-                command: |
-                    scripts/tutorial-setup.sh
-    documentation-check:
-        executor: main-env
-        steps:
-            - checkout
-            - run:
-                name: Check that documentation builds with no warnings/errors
-                command: |
-                    sudo apt-get update -y
-                    sudo apt-get install -y python3-pip
-                    sudo pip3 install -r docs/requirements.txt
-                    make -C docs html
-
-    install-riscv-toolchain:
-        executor: main-env
-        steps:
-            - toolchain-build:
-                tools-version: "riscv-tools"
-    install-esp-toolchain:
-        executor: main-env
-        steps:
-            - toolchain-build:
-                tools-version: "esp-tools"
-    install-verilator:
-        executor: main-env
-        steps:
-            - ssh-checkout
-            - run:
-                name: Install Verilator to remote
-                command: |
-                    .circleci/install-verilator.sh
-    build-extra-tests:
-        executor: main-env
-        steps:
-            - ssh-checkout
-            - run:
-                name: Create hash of toolchains
-                command: |
-                    .circleci/create-hash.sh
-            - restore_cache:
-                keys:
-                    - riscv-tools-installed-<< pipeline.parameters.tools-cache-version >>-{{ checksum "../riscv-tools.hash" }}
-            - run:
-                name: Build extra tests
-                command: .circleci/build-extra-tests.sh
-                no_output_timeout: 120m
-            - save_cache:
-                key: extra-tests-{{ .Branch }}-{{ .Revision }}
-                paths:
-                    - "/root/project/tests"
-
-    prepare-chipyard-cores:
-        executor: main-env
-        steps:
-            - prepare-rtl:
-                group-key: "group-cores"
-    prepare-chipyard-peripherals:
-        executor: main-env
-        steps:
-            - prepare-rtl:
-                group-key: "group-peripherals"
-    prepare-chipyard-accels:
-        executor: main-env
-        steps:
-            - prepare-rtl:
-                tools-version: "esp-tools"
-                group-key: "group-accels"
-    prepare-chipyard-tracegen:
-        executor: main-env
-        steps:
-            - prepare-rtl:
-                group-key: "group-tracegen"
-    prepare-chipyard-other:
-        executor: main-env
-        steps:
-            - prepare-rtl:
-                group-key: "group-other"
-
-    chipyard-rocket-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-cores"
-                project-key: "chipyard-rocket"
-    chipyard-hetero-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-cores"
-                project-key: "chipyard-hetero"
-                timeout: "20m"
-    chipyard-boom-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-cores"
-                project-key: "chipyard-boom"
-    chipyard-cva6-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-cores"
-                project-key: "chipyard-cva6"
-                timeout: "30m"
-    chipyard-sodor-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-cores"
-                project-key: "chipyard-sodor"
-                timeout: "30m"
-    chipyard-multiclock-rocket-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-cores"
-                project-key: "chipyard-multiclock-rocket"
-    chipyard-dmirocket-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-peripherals"
-                project-key: "chipyard-dmirocket"
-    chipyard-spiflashwrite-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-peripherals"
-                project-key: "chipyard-spiflashwrite"
-    chipyard-spiflashread-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-peripherals"
-                project-key: "chipyard-spiflashread"
-    chipyard-lbwif-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-peripherals"
-                project-key: "chipyard-lbwif"
-
-    chipyard-sha3-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                tools-version: "esp-tools"
-                group-key: "group-accels"
-                project-key: "chipyard-sha3"
-    chipyard-streaming-fir-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-accels"
-                project-key: "chipyard-streaming-fir"
-    chipyard-streaming-passthrough-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-accels"
-                project-key: "chipyard-streaming-passthrough"
-    chipyard-hwacha-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                tools-version: "esp-tools"
-                group-key: "group-accels"
-                project-key: "chipyard-hwacha"
-                timeout: "30m"
-    chipyard-gemmini-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                tools-version: "esp-tools"
-                group-key: "group-accels"
-                project-key: "chipyard-gemmini"
-    chipyard-nvdla-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-accels"
-                project-key: "chipyard-nvdla"
-    tracegen-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-tracegen"
-                project-key: "tracegen"
-    tracegen-boom-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-tracegen"
-                project-key: "tracegen-boom"
-    icenet-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-other"
-                project-key: "icenet"
-                timeout: "30m"
-    testchipip-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "group-other"
-                project-key: "testchipip"
-                timeout: "30m"
-    firesim-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "extra-tests"
-                project-key: "firesim"
-                run-script: "run-firesim-scala-tests.sh"
-                timeout: "20m"
-    fireboom-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "extra-tests"
-                project-key: "fireboom"
-                run-script: "run-firesim-scala-tests.sh"
-                timeout: "45m"
-    firesim-multiclock-run-tests:
-        executor: main-env
-        steps:
-            - run-tests:
-                group-key: "extra-tests"
-                project-key: "firesim-multiclock"
-                run-script: "run-firesim-scala-tests.sh"
-                timeout: "20m"
-    prepare-chipyard-fpga:
-        executor: main-env
-        steps:
-            - prepare-rtl:
-                group-key: "group-fpga"
-                build-type: "fpga"
-
-# Order and dependencies of jobs to run
-workflows:
-    version: 2
-    submodules-on-master:
-        jobs:
-            # Check to make sure submodule commits are on master branches
-            - commit-on-master-check
-        triggers:
-            - schedule:
-                cron: "0 0 * * *"
-                filters:
-                    branches:
-                        only:
-                            - master
-
-    build-and-test-chipyard-integration:
-        jobs:
-            # Make the toolchains
-            - install-riscv-toolchain
-
-            - install-esp-toolchain
-
-            - install-verilator
-
-            - commit-on-master-check
-
-            # Attempt to apply the tutorial patches
-            - tutorial-setup-check
-
-            # Check that documentation builds
-            - documentation-check
-
-            # Build extra tests
-            - build-extra-tests:
-                requires:
-                    - install-riscv-toolchain
-
-            # Prepare the verilator builds
-            - prepare-chipyard-cores:
-                requires:
-                    - install-riscv-toolchain
-                    - install-verilator
-            - prepare-chipyard-peripherals:
-                requires:
-                    - install-riscv-toolchain
-                    - install-verilator
-            - prepare-chipyard-accels:
-                requires:
-                    - install-esp-toolchain
-                    - install-verilator
-            - prepare-chipyard-tracegen:
-                requires:
-                    - install-riscv-toolchain
-                    - install-verilator
-            - prepare-chipyard-other:
-                requires:
-                    - install-riscv-toolchain
-                    - install-verilator
-
-            # Run the example tests
-            - chipyard-rocket-run-tests:
-                requires:
-                    - prepare-chipyard-cores
-            - chipyard-hetero-run-tests:
-                requires:
-                    - prepare-chipyard-cores
-            - chipyard-boom-run-tests:
-                requires:
-                    - prepare-chipyard-cores
-            - chipyard-cva6-run-tests:
-                requires:
-                    - prepare-chipyard-cores
-            - chipyard-sodor-run-tests:
-                requires:
-                    - prepare-chipyard-cores
-            - chipyard-dmirocket-run-tests:
-                requires:
-                    - prepare-chipyard-peripherals
-            - chipyard-spiflashwrite-run-tests:
-                requires:
-                    - prepare-chipyard-peripherals
-            - chipyard-spiflashread-run-tests:
-                requires:
-                    - prepare-chipyard-peripherals
-            - chipyard-lbwif-run-tests:
-                requires:
-                    - prepare-chipyard-peripherals
-
-            - chipyard-sha3-run-tests:
-                requires:
-                    - prepare-chipyard-accels
-            - chipyard-streaming-fir-run-tests:
-                requires:
-                    - prepare-chipyard-accels
-            - chipyard-streaming-passthrough-run-tests:
-                requires:
-                    - prepare-chipyard-accels
-            - chipyard-hwacha-run-tests:
-                requires:
-                    - prepare-chipyard-accels
-            - chipyard-gemmini-run-tests:
-                requires:
-                    - prepare-chipyard-accels
-            - chipyard-nvdla-run-tests:
-                requires:
-                    - prepare-chipyard-accels
-
-            - tracegen-run-tests:
-                requires:
-                    - prepare-chipyard-tracegen
-            - tracegen-boom-run-tests:
-                requires:
-                    - prepare-chipyard-tracegen
-
-            - icenet-run-tests:
-                requires:
-                    - prepare-chipyard-other
-            - testchipip-run-tests:
-                requires:
-                    - prepare-chipyard-other
-
-            # Run the firesim tests
-            - firesim-run-tests:
-                requires:
-                    - install-riscv-toolchain
-                    - install-verilator
-                    - build-extra-tests
-            - firesim-multiclock-run-tests:
-                requires:
-                    - install-riscv-toolchain
-                    - install-verilator
-                    - build-extra-tests
-            - fireboom-run-tests:
-                requires:
-                    - install-riscv-toolchain
-                    - install-verilator
-                    - build-extra-tests
-
-            # Prepare the fpga builds (just Verilog)
-            - prepare-chipyard-fpga:
-                requires:
-                    - install-riscv-toolchain

.github/README.md

@@ -0,0 +1,137 @@
+Chipyard Continuous Integration (CI)
+===========
+
+Website: https://gihub.com/gh/ucb-bar/chipyard/actions
+
+GitHub Actions Brief Explanation
+---------------------------
+
+CI is executed by Github Actions (GA). GA is controlled by `.yml` files in the `.github/workflows/` directory. 
+In our case we have just one workflow named `chipyard-rocket-run-tests.yml`.
+It defines a number of `jobs` within it that do particular tasks.
+All jobs in the workflow must pass for the CI run to be successful.
+In general, a job is run in parallel with others unless it depends on some other job.  
+The dependency of one job on the completion of another is specified via the `needs` field.
+
+For example:
+```yaml
+  prepare-chipyard-cores:
+    name: prepare-chipyard-cores
+    needs: [make-keys, setup-complete]
+```
+This specifies that the `prepare-chipyard-cores` job needs the both the `make-keys` and the `setup-complete` steps to
+be completed before it can run.
+
+Chipyard runs its CI using a docker image created from `dockerfiles/Dockerfile`.
+See its [README](../dockerfiles/README.md) for more details.
+
+Finally, within each job's `steps:` section, the steps are run sequentially and state persists throughout a job.
+So when you run something like `checkout` the next step has the checked out code.
+
+[Composite Actions](https://docs.github.com/en/actions/creating-actions) (CA) allow for limited subroutine like code re-use within GA.
+We use both community created and our own Composite Actions in our CI process. CA capabilities are changing rapidly.
+Nesting of composite actions was only recently unveiled. There is a lot of room for more code reuse, in particular
+we specify things over and over like docker image tag and checkout commands.
+
+One use of CA: our process relies on caching to avoid running time-consuming and intensive tasks more often than necessary.
+
+The following is an example of using the cache@v2 composite action. A step `uses: actions/cache@v2` which take as parameters the
+path that contains the data to be cached and a key. Paths can have multiple targets. 
+The following step can look at the result of the cache operation, if there was cache miss, then we run the command that
+will generate the data to be cached. The caching of the generated data is implicit.
+>Note: GA cache documentation suggests using the yml level `if: steps.cache-primes.outputs.cache-hit != 'true'` to
+> determine whether to run the data generation command.
+> At the time of this writing the if construct has a bug and will not run correctly within a composite action. The use
+> of a bash based if is a hack found on stackoverflow
+```yaml
+    - uses: actions/cache@v2
+      id: rtl-build-id
+      with:
+        path: |
+          sims/verilator
+          sims/firesim/sim
+          generators/gemmini/software/gemmini-rocc-tests
+        key: ${{ inputs.group-key }}-${{ github.ref }}-${{ github.sha }}
+    - name: run rtl build script if not cached
+      run: |
+        if [[ "${{ steps.rtl-build-id.outputs.cache-hit }}" != 'true' ]]; then
+          echo "Cache miss on ${{ inputs.group-key }}-${{ github.ref }}-${{ github.sha }}"
+          ./.github/scripts/${{ inputs.build-script }} ${{ inputs.group-key }} ${{ inputs.build-type }}
+        else
+          echo "cache hit do not prepare rtl"
+        fi
+      shell: bash
+```
+
+Our own composite actions are defined in the `.github/actions/<ActionName>/action.yml`
+
+.github/scripts directory
+-------------------
+
+This directory contains most the collateral for the Chipyard CI to work.
+The following is included in `.github/scripts/: directory
+
+    `build-toolchains.sh`        # build either riscv-tools or esp-tools
+    `create-hash.sh`             # create hashes of riscv-tools/esp-tools to use as hash keys
+    `do-rtl-build.sh`            # use verilator to build a sim executable (remotely)
+    `defaults.sh`                # default variables used
+    `check-commit.sh`            # check that submodule commits are valid
+    `build-extra-tests.sh`       # build default chipyard tests located in tests/
+    `clean-old-files.sh`         # clean up build server files
+    `do-fpga-rtl-build.sh`       # similar to `do-rtl-build` but using fpga/
+    `install-verilator.sh`       # install verilator on build server
+    `run-firesim-scala-tests.sh` # run firesim scala tests
+    `run-tests.sh                # run tests for a specific set of designs
+
+How things are set up for Chipyard
+---------------------------------
+
+The steps for CI to run are as follows.
+1. Build the toolchains in parallel (note: `esp-tools` is currently not used in the run).
+The docker image sets up the `PATH` and `RISCV` variable so that `riscv-tools` is the default (currently the `env.sh` script that is created at tool build is unused).
+2. Create the simulator binary.
+This requires the `riscv-tools` for `fesvr` and `verilator` to be able to build the binary.
+This stores all collateral for the tests (srcs, generated-srcs, sim binary, etc) to run "out of the gate" in the next job (make needs everything or else it will run again).
+3. Finally, run the desired tests.
+
+Other CI Setup
+--------------
+
+To get the CI to work correctly you need to create the following GH Repository Secrets
+
+| Secret | Value |
+| -------| ------------- |
+| BUILDSERVER | the hostname of the remote build server (likely be a millennium machine) |
+| BUILDUSER | the login to use on the build server |
+| BUILDDIR | the directory to use on the build server |
+| SERVERKEY | a private key to access the build server |
+
+The default.sh script defines the following,
+```bash
+CI_DIR = /path/to/where/you/want/to/store/remote/files
+```` 
+but in the future this should likely be a GH Secret too.
+
+The scripts also construct (repeatedly) a SERVER env using the above secrets 
+```bash
+SERVER = ${{ secrets.BUILDUSER }}@${{ secrets.BUILDSERVER }}
+```
+
+Additionally, you need to add under the "PERMISSIONS" "SSH Permissions" section a private key that is on the build server that you are using.
+After adding a private key, it will show a fingerprint that should be added under the jobs that need to be run.
+
+Note: On the remote server you need to have the `*.pub` key file added to the `authorized_keys` file.
+
+Additional Work
+---------------
+- It would be nice to add the ability to re-run just parts of the workflow. [See Workflows Hacks](https://github.com/jaredpalmer/razzle/blob/f8305c26997bae8ef0f5dfa52540d842451b4090/.github/workflows/examples.yml)
+
+
+Notes on CIRCLE CI
+------------------
+This code is heavily based on the origin [CircleCI]() work. There a quite a few differences
+- CCI supports workflow level variables, in GA we must define thiing like `BUILDSERVER: ${{ secrets.BUILDSERVER }}` in every job
+- CCI allows a much larger cache. The entire CY directory with toolchains and RTL could be cached, with GA there is a 5Gb total cache limit
+- GA support more parallel jobs 20 vs 4
+- GA seems to allow much longer run times
+- 

.github/actions/build-extra-tests/action.yml

@@ -0,0 +1,28 @@
+name: build-extra-tests
+description: 'Builds extra test required for some flows'
+
+inputs:
+  tools-version:
+    description: Which toolchain to build
+    required: false
+    default: 'riscv-tools'
+  cache-key:
+    description: Use this for caching
+    required: true
+runs:
+  using: "composite"
+  steps:
+    - uses: actions/cache@v2
+      id: build-extra-tools-cache
+      with:
+        path: extra-tests-install
+        key: ${{ needs.make-keys.outputs.extra-tests-cache-key }}
+        restore-keys: ${{ needs.make-keys.outputs.extra-tests-cache-key }}
+    - name: Build extra tests if not cached
+      run: |
+        export RISCV="/__w/chipyard/chipyard/riscv-tools-install"
+        export LD_LIBRARY_PATH="$RISCV/lib"
+        export PATH="$RISCV/bin:$PATH"
+        .github/scripts/build-extra-tests.sh
+      shell: bash
+

.github/actions/prepare-rtl/action.yml

@@ -0,0 +1,41 @@
+name: prepare-rtl
+description: 'Builds RTL based on parameters, caches the entire chipyard root dir when done'
+
+inputs:
+  tools-version:
+    description: Which toolchain to build
+    required: false
+    default: 'riscv-tools'
+  group-key:
+    description: group key
+    required: true
+  build-script:
+    description: rtl build script to use
+    required: false
+    default: "do-rtl-build.sh"
+  build-type:
+    description: type of build
+    required: false
+    default: "sim"
+
+runs:
+  using: "composite"
+  steps:
+    - uses: actions/cache@v2
+      id: rtl-build-id
+      with:
+        path: |
+          sims/verilator
+          sims/firesim/sim
+          generators/gemmini/software/gemmini-rocc-tests
+        key: ${{ inputs.group-key }}-${{ github.ref }}-${{ github.sha }}
+    - name: run rtl build script if not cached
+      run: |
+        if [[ "${{ steps.rtl-build-id.outputs.cache-hit }}" != 'true' ]]; then
+          echo "Cache miss on ${{ inputs.group-key }}-${{ github.ref }}-${{ github.sha }}"
+          ./.github/scripts/${{ inputs.build-script }} ${{ inputs.group-key }} ${{ inputs.build-type }}
+        else
+          echo "cache hit do not prepare rtl"
+        fi
+      shell: bash
+

.github/actions/run-tests/action.yml

@@ -0,0 +1,30 @@
+name: run-tests
+description: 'Runs tests according to input parameters'
+
+inputs:
+  tools-version:
+    description: Which toolchain to build
+    required: false
+    default: 'riscv-tools'
+  group-key:
+    description: group key
+    required: true
+  project-key:
+    description: project key
+    required: true
+  run-script:
+    description: rtl build script to use
+    required: false
+    default: "run-tests.sh"
+
+runs:
+  using: "composite"
+  steps:
+    - name: run rtl build script cache of chipyard root should have been loaded by prepare-rtl
+      run: |
+        export RISCV="/__w/chipyard/chipyard/riscv-tools-install"
+        export LD_LIBRARY_PATH="$RISCV/lib"
+        export PATH="$RISCV/bin:$PATH"
+        ./.github/scripts/${{ inputs.run-script }} ${{ inputs.project-key }}
+      shell: bash
+

.github/actions/toolchain-build/action.yml

@@ -0,0 +1,29 @@
+name: toolchain-build
+description: 'Builds the selected toolchain'
+
+inputs:
+  tools-version:
+    description: Which toolchain to build
+    required: false
+    default: 'riscv-tools'
+  cache-key:
+    description: Use this for caching
+    required: true
+runs:
+  using: "composite"
+  steps:
+    - uses: actions/cache@v2
+      id: toolchain-build-id
+      with:
+        path: ${{ inputs.tools-version }}-install
+        key: ${{ inputs.cache-key }}
+    - name: run build toolchain if not cached
+      run: |
+        if [[ "${{ steps.toolchain-build-id.outputs.cache-hit }}" != 'true' ]]; then
+          echo "Cache miss on ${{ inputs.tools-version }}-install"
+          ./.github/scripts/build-toolchains.sh ${{ inputs.tools-version }}
+        else
+          echo "cache hit do not generate build ${{ inputs.tools-version }}"
+        fi
+      shell: bash
+

.github/scripts/create-hash.sh

@@ -10,14 +10,11 @@ set -o pipefail
 SCRIPT_DIR="$( cd "$( dirname "$0" )" && pwd )"
 source $SCRIPT_DIR/defaults.sh
 
-# enter bhd repo
-cd $LOCAL_CHIPYARD_DIR
-
 # Use normalized output of git-submodule status as hashfile
 for tools in 'riscv-tools' 'esp-tools' ; do
     git submodule status "toolchains/${tools}" 'toolchains/libgloss' 'toolchains/qemu' |
     while read -r line ; do
         echo "${line#[!0-9a-f]}"
-    done > "${HOME}/${tools}.hash"
+    done > "${tools}.hash"
 done
 echo "Hashfile for riscv-tools and esp-tools created in $HOME"

.github/scripts/defaults.sh

@@ -1,15 +1,15 @@
 #!/bin/bash
 
 copy () {
-    rsync -avzp -e 'ssh' --exclude '.git' $1 $2
+    rsync -azp -e 'ssh' --exclude '.git' $1 $2
 }
 
 run () {
-    ssh -o "StrictHostKeyChecking no" -t $SERVER $@
+    ssh -o "ServerAliveInterval=60" -o "StrictHostKeyChecking no" -t $SERVER $@
 }
 
 run_script () {
-    ssh -o "StrictHostKeyChecking no" -t $SERVER 'bash -s' < $1 "$2"
+    ssh -o "ServerAliveInterval=60" -o "StrictHostKeyChecking no" -t $SERVER 'bash -s' < $1 "$2"
 }
 
 clean () {
@@ -18,7 +18,7 @@ clean () {
 }
 
 # make parallelism
-CI_MAKE_NPROC=8
+CI_MAKE_NPROC=4
 # chosen based on a 24c system shared with 1 other project
 REMOTE_MAKE_NPROC=4
 
@@ -26,8 +26,14 @@ REMOTE_MAKE_NPROC=4
 VERILATOR_VERSION=v4.034
 
 # remote variables
-REMOTE_PREFIX=$CI_DIR/$CIRCLE_PROJECT_REPONAME-$CIRCLE_BRANCH
-REMOTE_WORK_DIR=$REMOTE_PREFIX-$CIRCLE_SHA1-$CIRCLE_JOB
+
+CURRENT_BRANCH=$(git branch --show-current)
+
+# CI_DIR is defined externally based on the GH repository secret BUILDDIR
+
+HOME=`pwd`
+REMOTE_PREFIX=$CI_DIR/${GITHUB_REPOSITORY#*/}-$CURRENT_BRANCH
+REMOTE_WORK_DIR=$REMOTE_PREFIX-$GITHUB_SHA-$GITHUB_JOB
 REMOTE_RISCV_DIR=$REMOTE_WORK_DIR/riscv-tools-install
 REMOTE_ESP_DIR=$REMOTE_WORK_DIR/esp-tools-install
 REMOTE_CHIPYARD_DIR=$REMOTE_WORK_DIR/chipyard
@@ -37,13 +43,13 @@ REMOTE_FPGA_DIR=$REMOTE_CHIPYARD_DIR/fpga
 REMOTE_JAVA_OPTS="-Xmx10G -Xss8M"
 # Disable the supershell to greatly improve the readability of SBT output when captured by Circle CI
 REMOTE_SBT_OPTS="-Dsbt.ivy.home=$REMOTE_WORK_DIR/.ivy2 -Dsbt.supershell=false -Dsbt.global.base=$REMOTE_WORK_DIR/.sbt -Dsbt.boot.directory=$REMOTE_WORK_DIR/.sbt/boot"
-REMOTE_VERILATOR_DIR=$REMOTE_PREFIX-$CIRCLE_SHA1-verilator-install
+REMOTE_VERILATOR_DIR=$REMOTE_PREFIX-$GITHUB_SHA-verilator-install
 
 # local variables (aka within the docker container)
 LOCAL_CHECKOUT_DIR=$HOME/project
 LOCAL_RISCV_DIR=$HOME/riscv-tools-install
 LOCAL_ESP_DIR=$HOME/esp-tools-install
-LOCAL_CHIPYARD_DIR=$LOCAL_CHECKOUT_DIR
+LOCAL_CHIPYARD_DIR=$HOME
 LOCAL_SIM_DIR=$LOCAL_CHIPYARD_DIR/sims/verilator
 LOCAL_FIRESIM_DIR=$LOCAL_CHIPYARD_DIR/sims/firesim/sim
 

.github/scripts/do-rtl-build.sh

@@ -59,6 +59,7 @@ else
 fi
 
 # choose what make dir to use
+
 case $2 in
     "sim")
         REMOTE_MAKE_DIR=$REMOTE_SIM_DIR

.github/scripts/install-verilator.sh

@@ -10,7 +10,7 @@ SCRIPT_DIR="$( cd "$( dirname "$0" )" && pwd )"
 source $SCRIPT_DIR/defaults.sh
 
 # clean older directories (delete prior directories related to this branch also)
-run_script $LOCAL_CHIPYARD_DIR/.circleci/clean-old-files.sh $CI_DIR
+run_script $LOCAL_CHIPYARD_DIR/.github/scripts/clean-old-files.sh $CI_DIR
 run "rm -rf $REMOTE_PREFIX*"
 
 # set stricthostkeychecking to no (must happen before rsync)

README.md

@@ -1,7 +1,6 @@
 ![CHIPYARD](https://github.com/ucb-bar/chipyard/raw/master/docs/_static/images/chipyard-logo-full.png)
 
-# Chipyard Framework [![CircleCI](https://circleci.com/gh/ucb-bar/chipyard/tree/master.svg?style=svg)](https://circleci.com/gh/ucb-bar/chipyard/tree/master)
-
+# Chipyard Framework [![Test](https://github.com/ucb-bar/chipyard/workflows/chipyard-ci-process/badge.svg?style=svg)](https://github.com/ucb-bar/chipyard/actions)
 ## Using Chipyard
 
 To get started using Chipyard, see the documentation on the Chipyard documentation site: https://chipyard.readthedocs.io/