config.yml

version: 2.1

parameters:
  nightly-version:
    type: string
    default: "nightly-2020-11-20"

#orbs:
#  codecov: codecov/codecov@1.1.4

executors:
  default:
    machine:
      image: ubuntu-1604-cuda-10.1:201909-23
    working_directory: ~/gpuci
    resource_class: gpu.nvidia.medium

restore-workspace: &restore-workspace
  attach_workspace:
    at: ~/

restore-cache: &restore-cache
  restore_cache:
    keys:
      - cargo-v1-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
      - repo-source-{{ .Branch }}-{{ .Revision }}

commands:
  set-env-path:
    steps:
      - run:
          name: Set the PATH env variable
          command: |
            # Also put the Rust LLVM tools into the PATH.
            echo 'export PATH="$HOME:~/.cargo/bin:~/.rustup/toolchains/<< pipeline.parameters.nightly-version >>-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/bin:$PATH"' | tee --append $BASH_ENV
            source $BASH_ENV

  install-gpu-deps:
    steps:
      - run:
          name: Install libraries for GPU tests
          command: |
            sudo apt-get update -y
            sudo apt install -y ocl-icd-opencl-dev

  test_target_pairing:
    parameters:
      target:
        type: string
    steps:
      - *restore-workspace
      - *restore-cache
      - run:
          name: Test pairing (<< parameters.target >>)
          command: TARGET=<< parameters.target >> cargo test --no-default-features --features pairing
          no_output_timeout: 15m

  test_target_pairing_gpu:
    parameters:
      target:
        type: string
    steps:
      - *restore-workspace
      - *restore-cache
      - run:
          name: Test pairing (GPU) (<< parameters.target >>)
          command: TARGET=<< parameters.target >> cargo test --release --no-default-features --features gpu,pairing
          no_output_timeout: 30m

  test_target_blst:
    parameters:
      target:
        type: string
    steps:
      - *restore-workspace
      - *restore-cache
      - run:
          name: Test blst (<< parameters.target >>)
          command: TARGET=<< parameters.target >> cargo test --no-default-features --features blst
          no_output_timeout: 15m

  test_target_blst_gpu:
    parameters:
      target:
        type: string
    steps:
      - *restore-workspace
      - *restore-cache
      - run:
          name: Test blst (GPU) (<< parameters.target >>)
          command: TARGET=<< parameters.target >> cargo test --release --no-default-features --features gpu,blst
          no_output_timeout: 30m

jobs:

  cargo_fetch:
    executor: default
    steps:
      - checkout
      - run: curl https://sh.rustup.rs -sSf | sh -s -- -y
      - set-env-path
      - run: echo $HOME
      - run: cargo --version
      - run: rustc --version
      - run:
          name: Update submodules
          command: git submodule update --init --recursive
      - run:
          name: Calculate dependencies
          command: cargo generate-lockfile
      - restore_cache:
          keys:
            - cargo-v1-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
      - run: cargo update
      - run: cargo fetch
      - run: rustup install $(cat rust-toolchain)
      - run: rustup default $(cat rust-toolchain)
      # A nightly build is needed for code coverage reporting
      - run: rustup toolchain install --profile minimal << pipeline.parameters.nightly-version >>
      - run: rustup component add --toolchain << pipeline.parameters.nightly-version >> llvm-tools-preview
      - run: rustc --version
      - run: rm -rf .git
      - persist_to_workspace:
          root: ~/
          paths:
            - gpuci
      - save_cache:
          key: cargo-v1-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
          paths:
            - "~/.cargo"
            - "~/.rustup"

  test_pairing_x86_64-unknown-linux-gnu:
    executor: default
    steps:
      - set-env-path
      - install-gpu-deps
      - test_target_pairing:
          target: "x86_64-unknown-linux-gnu"

  test_pairing_gpu_x86_64-unknown-linux-gnu:
    executor: default
    steps:
      - set-env-path
      - install-gpu-deps
      - test_target_pairing_gpu:
          target: "x86_64-unknown-linux-gnu"


  test_blst_x86_64-unknown-linux-gnu:
    executor: default
    steps:
      - set-env-path
      - install-gpu-deps
      - test_target_blst:
          target: "x86_64-unknown-linux-gnu"

  test_blst_gpu_x86_64-unknown-linux-gnu:
    executor: default
    steps:
      - set-env-path
      - install-gpu-deps
      - test_target_blst_gpu:
          target: "x86_64-unknown-linux-gnu"

  rustfmt:
    executor: default
    steps:
      - *restore-workspace
      - *restore-cache
      - set-env-path
      - run:
          name: Run cargo fmt
          command: cargo fmt --all -- --check

  clippy:
    executor: default
    steps:
      - *restore-workspace
      - *restore-cache
      - set-env-path
      - run:
          name: Run cargo clippy (default features (pairing))
          command: cargo clippy --all-targets --features gpu -- -D warnings
      - run:
          name: Run cargo clippy (pairing)
          command: cargo clippy --all-targets --no-default-features --features pairing -- -D warnings
      - run:
          name: Run cargo clippy (blst)
          command: cargo clippy --all-targets --no-default-features --features blst -- -D warnings
      - run:
          name: Run cargo clippy (pairing,gpu)
          command: cargo clippy --all-targets --no-default-features --features pairing,gpu -- -D warnings
      - run:
          name: Run cargo clippy (blst,gpu)
          command: cargo clippy --all-targets --no-default-features --features blst,gpu -- -D warnings

  coverage_run:
    executor: default
    parameters:
      cargo-args:
        description: Addtional arguments for the cargo command
        type: string
        default: ""
      test-args:
        description: Additional arguments for the test executable (after the `--`)
        type: string
        default: ""
    environment:
      # Incremental build is not supported when profiling
      CARGO_INCREMENTAL: 0
      # -Zinstrument-coverage: enable llvm coverage instrumentation
      # -Ccodegen-units=1: building in parallel is not supported when profiling
      # -Copt-level=0: disable optimizations for more accurate coverage
      # -Clink-dead-code: dead code should be considered as not covered code
      # -Coverflow-checks=off: checking for overflow is not needed for coverage reporting
      # -Cinline-threshold=0: do not inline
      RUSTFLAGS: -Zinstrument-coverage -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Cinline-threshold=0
      # Make sure that each run of an executable creates a new profile file, with the default
      # name they would override each other
      LLVM_PROFILE_FILE: "%m.profraw"
    steps:
      - *restore-workspace
      - *restore-cache
      - set-env-path
      - install-gpu-deps
      - run:
          name: Generate coverage report
          command: |
            RUST_LOG=info cargo +<< pipeline.parameters.nightly-version >> test --features _coverage << parameters.cargo-args >> -- --nocapture << parameters.test-args >>

            # Do *not* use sparse output. It leads to more lines that are not
            # taken into account at all
            llvm-profdata merge --output=default.profdata ./*.profraw

            # The compiled files contain the coverage information. From running the tests we don't
            # know what those files are called, hence use all files from the `./target/debug/deps`
            # directory which don't have an extension.
            OBJECT_FILES=$(find ./target/debug/deps/* -name '*' -not -name '*\.*' -printf '%p,'|head --bytes -1)
            # Only export the coverage of this project, we don't care about coverage of
            # dependencies
            llvm-cov export --ignore-filename-regex=".cargo|.rustup" --format=lcov -instr-profile=default.profdata --object=${OBJECT_FILES} > lcov.info
      ## Codecov automatically merges the reports in case there are several ones uploaded
      #- codecov/upload:
      #    file: lcov.info

workflows:
  version: 2.1

  test:
    jobs:
      - cargo_fetch
      - rustfmt:
          requires:
            - cargo_fetch
      - clippy:
          requires:
            - cargo_fetch
            
      - test_pairing_x86_64-unknown-linux-gnu:
          requires:
            - cargo_fetch
      - test_pairing_gpu_x86_64-unknown-linux-gnu:
          requires:
            - cargo_fetch

      - test_blst_x86_64-unknown-linux-gnu:
          requires:
            - cargo_fetch
      - test_blst_gpu_x86_64-unknown-linux-gnu:
          requires:
            - cargo_fetch

      #- coverage_run:
      #    name: coverage_default_features
      #    requires:
      #      - cargo_fetch
      #- coverage_run:
      #    name: coverage_gpu_feature_lib
      #    cargo-args: "--features gpu --lib"
      #    # If run in parallel the GPU tests will block and hence fail
      #    test-args: "--test-threads=1"
      #    requires:
      #      - cargo_fetch
      #- coverage_run:
      #    name: coverage_gpu_feature_integration
      #    cargo-args: "--features gpu --test '*'"
      #    # If run in parallel the GPU tests will block and hence fail
      #    test-args: "--test-threads=1"
      #    requires:
      #      - cargo_fetch