run-evaluation-leviathan.yml

name: Run evaluation on Leviathan

on:
  schedule:
    # 1am PT.
    - cron: '0 8 * * *'
  workflow_dispatch:

env:
  # Configure the number of tasks to run in parallel. Please see the
  # documentation in [run-evaluation.sh](../../run-evaluation.sh) for more
  # details.
  NUM_JOBS_VIVADO_TASKS: 50
  NUM_JOBS_LAKEROAD_TASKS: 20
  NUM_JOBS_OTHER_TASKS: 100
  # Interval at which to print uptime. See run-evaluation.sh script.
  PRINT_UPTIME_INTERVAL: 60

  # Number of jobs when building something with make. This is a separate task
  # from the above as each job generally uses one thread.
  MAKE_JOBS: 128

jobs:

  # TODO(@gussmith23) It would be nice if this wasn't necessary
  cleaner:
    runs-on: [self-hosted, leviathan]
    steps:
      - name: Clean up previous runs
        run: rm -rf "${{ github.workspace }}"

  build-docker-image:
    # Make sure we clean first.
    needs: cleaner
    runs-on: [self-hosted, leviathan]

    outputs:
      tag: ${{ steps.generate-tag.outputs.tag }}

    steps:
    - uses: actions/checkout@v3
    
    - name: Checkout specific submodules
      run: |
        git submodule init
        git submodule update lakeroad
        cd lakeroad
        git submodule init
        git submodule update lakeroad-private/
    
    - name: Zip up artifact for Zenodo
      run: |
        mkdir lakeroad-evaluation
        rsync -r . --exclude lakeroad-evaluation/ lakeroad-evaluation/
        zip -9 -r lakeroad-evaluation.zip lakeroad-evaluation/
    
    - name: Upload Zenodo artifact
      uses: actions/upload-artifact@v3
      with:
        name: lakeroad-evaluation
        path: lakeroad-evaluation.zip

    - name: Clean up intermediate files
      run: rm -rf lakeroad-evaluation lakeroad-evaluation.zip

    - name: Generate Docker image tag
      id: generate-tag
      run: |
        export TAG=lakeroad-evaluation:$(date +%s)
        echo "Docker image tag: $TAG"
        echo "tag=$TAG" >> $GITHUB_OUTPUT

    - name: Build Docker image
      run: |
        docker build \
          . \
          --file Dockerfile \
          --tag ${{ steps.generate-tag.outputs.tag }} \
          --build-arg VIVADO_BIN_DIR=/tools/Xilinx/Vivado/2023.1/bin \
          --build-arg QUARTUS_BIN_DIR=/tools/intel/quartus/bin/ \
          --build-arg DIAMOND_BINDIR=/usr/local/diamond/3.12/bin/lin64 \
          --build-arg MAKE_JOBS=${{ env.MAKE_JOBS }}

  run-evaluation:
    # TODO(@gussmith23): Figure out what's taking so long. (probs Verilator)
    timeout-minutes: 480
    needs: build-docker-image
    runs-on: [self-hosted, leviathan]
    outputs:
      container-name: ${{ steps.run-evaluation.outputs.container-name }}
    steps:
    - id: run-evaluation
      # NOTE: -n argument for doit controls # simultaneous processes. I have to
      # set it manually -- if it's too high, too many Vivados running at once
      # will cause out-of-memory errors.
      run: |
        CONTAINER_NAME=lakeroad-evaluation-run-$(date +%s)
        echo "Docker container name: $CONTAINER_NAME"
        echo "container-name=$CONTAINER_NAME" >> $GITHUB_OUTPUT
        docker run \
          --name $CONTAINER_NAME \
          -v /tools/Xilinx:/tools/Xilinx \
          -v /usr/local/diamond:/usr/local/diamond \
          -v /tools/intel:/tools/intel \
          --env LOGLEVEL=INFO \
          --env LRE_OUTPUT_DIR=/root/results \
          --env NUM_JOBS_VIVADO_TASKS=${{ env.NUM_JOBS_VIVADO_TASKS }} \
          --env NUM_JOBS_LAKEROAD_TASKS=${{ env.NUM_JOBS_LAKEROAD_TASKS }} \
          --env NUM_JOBS_OTHER_TASKS=${{ env.NUM_JOBS_OTHER_TASKS }} \
          --env PRINT_UPTIME_INTERVAL=${{ env.PRINT_UPTIME_INTERVAL }} \
          ${{ needs.build-docker-image.outputs.tag }} \
          bash /root/run-evaluation.sh

  # send-results-to-slack:
  #   needs: run-evaluation
  #   runs-on: [self-hosted, leviathan]
  #   steps:
  #   - run: docker cp ${{ needs.run-evaluation.outputs.container-name }}:/root/results results/
  #   - run: |
  #       # Send initial message to start the thread.
  #       THREAD_TS=$(curl -F "channel=${{ secrets.LAKEROAD_CHANNEL_ID }}" \
  #           -F "token=${{ secrets.SLACK_OAUTH_TOKEN }}" \
  #           -F "text=Results from CI run" \
  #           -X POST https://slack.com/api/chat.postMessage \
  #           | jq .ts)

  #       curl -F "channels=${{ secrets.LAKEROAD_CHANNEL_ID }}" \
  #           -F "token=${{ secrets.SLACK_OAUTH_TOKEN }}" \
  #           -F "file=@results/figures/sofa_figure.png" \
  #           -F "thread_ts=$THREAD_TS" \
  #           -X POST https://slack.com/api/files.upload 
  #       curl -F "channels=${{ secrets.LAKEROAD_CHANNEL_ID }}" \
  #           -F "token=${{ secrets.SLACK_OAUTH_TOKEN }}" \
  #           -F "file=@results/figures/lattice_ecp5_figure.png" \
  #           -F "thread_ts=$THREAD_TS" \
  #           -X POST https://slack.com/api/files.upload 
  #       curl -F "channels=${{ secrets.LAKEROAD_CHANNEL_ID }}" \
  #           -F "token=${{ secrets.SLACK_OAUTH_TOKEN }}" \
  #           -F "file=@results/figures/xilinx_ultrascale_plus_figure.png" \
  #           -F "thread_ts=$THREAD_TS" \
  #           -X POST https://slack.com/api/files.upload 

  upload-artifact:
    # Runs even if evaluation failed. Lets us inspect partial results and logs.
    if: always()
    needs: run-evaluation
    runs-on: [self-hosted, leviathan]
    steps:
    - run: docker cp ${{ needs.run-evaluation.outputs.container-name }}:/root/results results/
    - run: zip -r results.zip results/
    - uses: actions/upload-artifact@v3
      with:
        name: evaluation-results
        path: results.zip