testing.yml

name: Build and Test
on:
  pull_request:
    types: [opened, synchronize, reopened]
  push:
    branches: [master]

concurrency:
  group: ${{ github.event.number || github.run_id }}
  cancel-in-progress: true

jobs:
  check_files:
    name: Check files
    outputs:
      run_job: ${{ steps.check_files.outputs.run_job }}
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
        with:
          fetch-depth: 2

      - name: check modified files
        id: check_files
        run: |
          echo "Concurrency group: ${{ github.event.number || github.run_id }}"
          echo "=============== list modified files ==============="
          git diff --name-only @^

          chore_files=( LICENSE CONTRIBUTING.md README.md netlify.toml )
          chore_dirs=( docs )
          run_job=false

          for file in $(git diff --name-only @^); do
            is_chore=false

            for chore_file in ${chore_files[*]}; do
              [[ ${file} == ${chore_file} ]] && is_chore=true && break
            done

            for chore_dir in ${chore_dirs[*]}; do
              [[ ${file} == ${chore_dir}/* ]] && is_chore=true && break
            done

            if ! ${is_chore}; then
              run_job=true
              break
            fi
          done

          if ${run_job}; then
            echo "::set-output name=run_job::true"
          else
            echo "::set-output name=run_job::false"
          fi

  check_code_format:
    name: Check Code Format
    runs-on: ubuntu-latest
    needs: check_files
    # This job will be required to pass before merging to master branch.
    steps:
      - uses: actions/checkout@v2
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v2
        with:
          python-version: 3.9

      - name: Setup git & clang-format
        run: |
          git config user.email "taichigardener@gmail.com"
          git config user.name "Taichi Gardener"
          git checkout -b _fake_squash
          git remote add upstream https://github.com/taichi-dev/taichi.git
          git fetch upstream master
          sudo apt install clang-format-10

      - name: Cache PIP
        uses: actions/cache@v2
        with:
          path: ~/.cache/pip
          key: ${{ hashFiles('setup.py') }}-${{ hashFiles('requirements_dev.txt') }}

      - name: Install requirements
        run: |
          python3 -m pip install --user -r requirements_dev.txt

      - name: Check code format
        run: |
          python3 misc/code_format.py
          git checkout -b _enforced_format
          git commit -am "enforce code format" || true
          # exit with 1 if there were differences:
          git diff _fake_squash _enforced_format --exit-code

  check_static_analyzer:
    name: Check Static Analyzer
    runs-on: ubuntu-latest
    needs: check_files
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: "recursive"

      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v2
        with:
          python-version: 3.9

      - name: Pylint
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          python3 -m pip install --user pylint
          # Make sure pylint doesn't regress
          pylint python/taichi/ --disable=all --enable=$(python scripts/generate_pylint_tags.py)
          if [ $? -eq 0 ]
          then
            echo "PASSED: pylint is happy"
            exit 0
          else
            echo "FAILED: please run the pylint command above and make sure it passes"
            exit 1
          fi

      - name: clang-tidy
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          # https://docs.github.com/en/packages/managing-github-packages-using-github-actions-workflows/publishing-and-installing-a-package-with-github-actions#upgrading-a-workflow-that-accesses-ghcrio
          echo $CR_PAT | docker login ghcr.io -u ${{ github.actor }} --password-stdin
          docker pull ghcr.io/taichi-dev/taichidev-cpu-ubuntu18.04:v0.1.0
          docker run -id --user dev --name check_clang_tidy ghcr.io/taichi-dev/taichidev-cpu-ubuntu18.04:v0.1.0 /bin/bash
          tar -cf - ../${{ github.event.repository.name }} --mode u=+rwx,g=+rwx,o=+rwx --owner 1000 --group 1000 | docker cp - check_clang_tidy:/home/dev/
          docker exec --user root check_clang_tidy apt install -y clang-tidy-10
          docker exec --user dev check_clang_tidy /home/dev/taichi/.github/workflows/scripts/check_clang_tidy.sh "$CI_SETUP_CMAKE_ARGS"
        env:
          CR_PAT: ${{ secrets.GITHUB_TOKEN }}
          CI_SETUP_CMAKE_ARGS: -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DTI_WITH_OPENGL:BOOL=OFF -DTI_WITH_CC:BOOL=ON -DTI_WITH_VULKAN:BOOL=OFF -DTI_BUILD_TESTS:BOOL=OFF

  build_and_test_cpu_linux:
    name: Build and Test linux (CPU)
    needs: [check_code_format, check_files]
    timeout-minutes: 60
    strategy:
      matrix:
        include:
          - os: ubuntu-latest
            python: py36
            with_cc: OFF
            wanted_archs: "cpu"
          - os: ubuntu-latest
            python: py39
            with_cc: ON
            wanted_archs: "cpu,cc"
    runs-on: ${{ matrix.os }}
    permissions:
      packages: read
      contents: read
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: "recursive"

      - name: Get sccache cache
        uses: actions/cache@v2
        with:
          path: sccache_cache
          key: sccache-linux-${{matrix.with_cc}}-${{ github.sha }}
          restore-keys: |
            sccache-linux-${{matrix.with_cc}}-

      - name: Get docker images
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          # https://docs.github.com/en/packages/managing-github-packages-using-github-actions-workflows/publishing-and-installing-a-package-with-github-actions#upgrading-a-workflow-that-accesses-ghcrio
          echo $CR_PAT | docker login ghcr.io -u ${{ github.actor }} --password-stdin
          docker pull ghcr.io/taichi-dev/taichidev-cpu-ubuntu18.04:v0.1.0
        env:
          CR_PAT: ${{ secrets.GITHUB_TOKEN }}

      - name: Build
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          mkdir -m777 shared
          docker create --user dev --name taichi_build \
            -e PY -e PROJECT_NAME -e TAICHI_CMAKE_ARGS \
            ghcr.io/taichi-dev/taichidev-cpu-ubuntu18.04:v0.1.0 \
            /home/dev/taichi/.github/workflows/scripts/unix_build.sh
          # A tarball is needed because sccache needs some permissions that only the file owner has.
          # 1000 is the uid and gid of user "dev" in the container.
          # If the uid or gid of the user inside the docker changes, please change the uid and gid in the following line.
          tar -cf - ../${{ github.event.repository.name }} --mode u=+rwx,g=+rwx,o=+rwx --owner 1000 --group 1000 | docker cp - taichi_build:/home/dev/
          docker start -a taichi_build
          rm -rf sccache_cache
          docker cp taichi_build:/home/dev/taichi/sccache_cache sccache_cache
          docker cp taichi_build:/home/dev/taichi/dist shared/dist
          docker cp taichi_build:/home/dev/taichi/build shared/build
        env:
          PY: ${{ matrix.python }}
          PROJECT_NAME: taichi
          TAICHI_CMAKE_ARGS: -DTI_WITH_OPENGL:BOOL=OFF -DTI_WITH_CC:BOOL=${{ matrix.with_cc }} -DTI_WITH_VULKAN:BOOL=OFF -DTI_BUILD_TESTS:BOOL=ON -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache

      - name: Test
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          docker create --user dev --name taichi_test -e PY -e TI_WANTED_ARCHS ghcr.io/taichi-dev/taichidev-cpu-ubuntu18.04:v0.1.0 /home/dev/unix_test.sh
          docker cp .github/workflows/scripts/unix_test.sh taichi_test:/home/dev/unix_test.sh
          docker cp shared/dist/ taichi_test:/home/dev/
          docker cp shared/build/ taichi_test:/home/dev/
          docker cp ./requirements_test.txt taichi_test:/home/dev/requirements_test.txt
          docker cp tests/ taichi_test:/home/dev/
          docker start -a taichi_test
        env:
          PY: ${{ matrix.python }}
          TI_WANTED_ARCHS: ${{ matrix.wanted_archs }}

      - name: clean docker container
        if: always()
        run: |
          docker rm taichi_build taichi_test -f

  build_and_test_cpu_mac:
    name: Build and Test macos (CPU)
    needs: [check_code_format, check_files]
    timeout-minutes: 60
    strategy:
      matrix:
        include:
          - os: macos-10.15
            python: 3.7
            with_cc: OFF
            with_cpp_tests: ON
            wanted_archs: "cpu"
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: "recursive"

      - uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}

      - name: Get sccache cache
        uses: actions/cache@v2
        with:
          path: sccache_cache
          key: sccache-mac-${{ github.sha }}
          restore-keys: |
            sccache-mac-

      - name: Download Pre-Built LLVM 10.0.0
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          python misc/ci_download.py
        env:
          CI_PLATFORM: ${{ matrix.os }}

      - name: Build & Install
        run: |
          brew install molten-vk
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          mkdir -p sccache_cache
          export PATH=`pwd`/taichi-llvm/bin/:$PATH
          .github/workflows/scripts/unix_build.sh
          brew uninstall molten-vk
        env:
          TAICHI_CMAKE_ARGS: -DTI_WITH_OPENGL:BOOL=OFF -DTI_WITH_CC:BOOL=${{ matrix.with_cc }} -DTI_WITH_VULKAN:BOOL=ON -DTI_BUILD_TESTS:BOOL=${{ matrix.with_cpp_tests }} -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
          CXX: clang++
      # [DEBUG] Copy this step around to enable debugging inside Github Action instances.
      #- name: Setup tmate session
      #  uses: mxschmitt/action-tmate@v3
      #  with:
      #    limit-access-to-actor: true

      - name: Test
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          .github/workflows/scripts/unix_test.sh
        env:
          TI_WANTED_ARCHS: ${{ matrix.wanted_archs }}

  build_and_test_gpu_linux:
    name: Build and Test (GPU)
    needs: [check_code_format, check_files]
    runs-on: [self-hosted, cuda, vulkan, cn]
    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: "recursive"

      - name: Get sccache cache
        uses: actions/cache@v2
        with:
          path: sccache_cache
          key: sccache-linux-gpu-${{ github.sha }}
          restore-keys: |
            sccache-linux-gpu-

      - name: Build & Install
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          mkdir -m777 shared
          docker create --user dev --name taichi_build --gpus all -v /tmp/.X11-unix:/tmp/.X11-unix \
            -e PY -e GPU_BUILD -e PROJECT_NAME -e TAICHI_CMAKE_ARGS -e DISPLAY \
            registry.taichigraphics.com/taichidev-ubuntu18.04:v0.1.1 \
            /home/dev/taichi/.github/workflows/scripts/unix_build.sh
          # A tarball is needed because sccache needs some permissions that only the file owner has.
          # 1000 is the uid and gid of user "dev" in the container.
          # If the uid or gid of the user inside the docker changes, please change the uid and gid in the following line.
          tar -cf - ../${{ github.event.repository.name }} --mode u=+rwx,g=+rwx,o=+rwx --owner 1000 --group 1000 | docker cp - taichi_build:/home/dev/
          docker start -a taichi_build
          rm -rf sccache_cache
          docker cp taichi_build:/home/dev/taichi/sccache_cache sccache_cache
          docker cp taichi_build:/home/dev/taichi/dist shared/dist
          docker cp taichi_build:/home/dev/taichi/build shared/build
        env:
          PY: py38
          GPU_BUILD: ON
          PROJECT_NAME: taichi
          TAICHI_CMAKE_ARGS: -DTI_WITH_OPENGL:BOOL=ON -DTI_WITH_CC:BOOL=OFF -DTI_WITH_VULKAN:BOOL=ON -DTI_BUILD_TESTS:BOOL=ON -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
          DISPLAY: :1

      - name: Test
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          docker create --user dev --name taichi_test --gpus all -v /tmp/.X11-unix:/tmp/.X11-unix \
            -e DISPLAY -e PY -e GPU_TEST -e TI_WANTED_ARCHS \
             registry.taichigraphics.com/taichidev-ubuntu18.04:v0.1.1 \
             /home/dev/unix_test.sh
          docker cp .github/workflows/scripts/unix_test.sh taichi_test:/home/dev/unix_test.sh
          docker cp shared/dist/ taichi_test:/home/dev/
          docker cp shared/build/ taichi_test:/home/dev/
          docker cp tests/ taichi_test:/home/dev/
          docker start -a taichi_test
        env:
          PY: py38
          GPU_TEST: ON
          DISPLAY: :1
          TI_WANTED_ARCHS: "cpu,cuda,vulkan,opengl"

      - name: clean docker container
        if: always()
        run: |
          docker rm taichi_build taichi_test -f

  build_and_test_windows:
    name: Build and Test Windows
    needs: [check_code_format, check_files]
    runs-on: [self-hosted, windows, gpu]
    timeout-minutes: 90
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: "recursive"

      - uses: actions/setup-python@v2
        with:
          python-version: 3.7

      - name: Add Visual Studio Shell to ENV
        uses: egor-tensin/vs-shell@v2
        with:
          arch: x64

      - name: Get sccache cache
        uses: actions/cache@v2
        with:
          path: ccache_cache
          key: ccache-win64-${{ github.sha }}
          restore-keys: |
            ccache-win64-

      - name: Build
        shell: powershell
        run: |
          if ( "${{needs.check_files.outputs.run_job}}" -eq "false" ) {
            exit 0
          }
          .\.github\workflows\scripts\win_build.ps1 -installVulkan -install -libsDir C:\

      - name: Test
        shell: powershell
        run: |
          if ( "${{needs.check_files.outputs.run_job}}" -eq "false" ) {
            exit 0
          }
          .\.github\workflows\scripts\win_test.ps1
        env:
          TI_WANTED_ARCHS: cpu,cuda,opengl
          TAICHI_CMAKE_ARGS: -DTI_WITH_OPENGL:BOOL=ON -DTI_WITH_CC:BOOL=OFF
          TI_SKIP_VERSION_CHECK: ON

  build_and_test_m1:
    name: Build and Test (Apple M1)
    needs: [check_code_format, check_files]
    timeout-minutes: 60
    strategy:
      matrix:
        include:
          - os: macos-latest
            python: 3.8
    defaults:
      run:
        # https://github.com/actions/runner/issues/805#issuecomment-844426478
        shell: "/usr/bin/arch -arch arm64e /bin/bash --noprofile --norc -eo pipefail {0}"
    runs-on: [self-hosted, m1]
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: "recursive"

      - name: Get sccache cache
        uses: actions/cache@v2
        with:
          path: sccache_cache
          key: sccache-m1-${{ github.sha }}
          restore-keys: |
            sccache-m1-

      - name: Build
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          rm -rf $HOME/Library/Python/3.8/lib/python/site-packages/taichi
          brew install molten-vk
          .github/workflows/scripts/unix_build.sh
        env:
          TAICHI_CMAKE_ARGS: -DTI_WITH_OPENGL:BOOL=OFF -DTI_WITH_CUDA:BOOL=OFF -DTI_WITH_CC:BOOL=OFF -DTI_WITH_VULKAN:BOOL=ON -DTI_BUILD_TESTS:BOOL=ON -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
          CXX: clang++

      - name: Test
        run: |
          if [[ ${{needs.check_files.outputs.run_job}} == false ]]; then
            exit 0
          fi
          export PATH=$PATH:$HOME/Library/Python/3.8/bin
          .github/workflows/scripts/unix_test.sh
        env:
          TI_WANTED_ARCHS: "metal,vulkan,cpu"