version: 2.1


# We constantly run out of memory so please do not use parallelism (-j, -j4).

# Reusable image / compiler definitions
executors:
  gcc8:
    docker:
      - image: conanio/gcc8
        environment:
          CXX: g++-8
          CC: gcc-8
          CMAKE_BUILD_FLAGS:
          CTEST_FLAGS: --output-on-failure

  gcc9:
    docker:
      - image: conanio/gcc9
        environment:
          CXX: g++-9
          CC: gcc-9
          CMAKE_BUILD_FLAGS:
          CTEST_FLAGS: --output-on-failure

  gcc10:
    docker:
      - image: conanio/gcc10
        environment:
          CXX: g++-10
          CC: gcc-10
          CMAKE_BUILD_FLAGS:
          CTEST_FLAGS: --output-on-failure

  clang10:
    docker:
      - image: conanio/clang10
        environment:
          CXX: clang++-10
          CC: clang-10
          CMAKE_BUILD_FLAGS:
          CTEST_FLAGS: --output-on-failure

  clang9:
    docker:
      - image: conanio/clang9
        environment:
          CXX: clang++-9
          CC: clang-9
          CMAKE_BUILD_FLAGS:
          CTEST_FLAGS: --output-on-failure

  clang6:
    docker:
      - image: conanio/clang60
        environment:
          CXX: clang++-6.0
          CC: clang-6.0
          CMAKE_BUILD_FLAGS:
          CTEST_FLAGS: --output-on-failure

# Reusable test commands (and initializer for clang 6)
commands:
  dependency_restore:
    steps:
      - restore_cache:
          keys:
            - cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}

  dependency_cache:
    steps:
      - save_cache:
          key: cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
          paths:
            - dependencies/.cache

  install_cmake:
    steps:
      - run: apt-get update -qq
      - run: apt-get install -y cmake

  cmake_prep:
    steps:
      - checkout
      - run: mkdir -p build

  cmake_build_cache:
    steps:
      - cmake_prep
      - dependency_restore
      - run: cmake  -DSIMDJSON_DEVELOPER_MODE=ON $CMAKE_FLAGS -DCMAKE_INSTALL_PREFIX:PATH=destination -B build .
      - dependency_cache # dependencies are produced in the configure step

  cmake_build:
    steps:
      - cmake_build_cache
      - run: cmake  --build build

  cmake_test:
    steps:
      - cmake_build
      - run: |
          cd build &&
          tools/json2json -h &&
          ctest $CTEST_FLAGS -L acceptance &&
          ctest $CTEST_FLAGS -LE acceptance -LE explicitonly

  cmake_assert_test:
    steps:
      - run: |
          cd build &&
          tools/json2json -h &&
          ctest $CTEST_FLAGS -L assert

  cmake_test_all:
    steps:
      - cmake_build
      - run: |
          cd build &&
          tools/json2json -h &&
          ctest $CTEST_FLAGS -DSIMDJSON_IMPLEMENTATION="haswell;westmere;fallback" -L acceptance -LE per_implementation &&
          SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
          SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
          SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
          ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.


  cmake_perftest:
    steps:
      - cmake_build_cache
      - run: |
          cmake -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON --build  build --target checkperf &&
          cd build &&
          ctest --output-on-failure -R checkperf

  # we not only want cmake to build and run tests, but we want also a successful installation from which we can build, link and run programs
  cmake_install_test: # this version builds, install, test and then verify from the installation
    steps:
      - run: cd build && make install
      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++17 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json

  cmake_installed_test_cxx20: # assuming that it was installed, this tries to build using C++20
    steps:
      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++20 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json

jobs:

  # static
  justlib-gcc10:
    description: Build just the library, install it and do a basic test
    executor: gcc10
    environment: { CMAKE_FLAGS: -DSIMDJSON_JUST_LIBRARY=ON }
    steps: [ cmake_build, cmake_install_test, cmake_installed_test_cxx20 ]
  assert-gcc10:
    description: Build the library with asserts on, install it and run tests
    executor: gcc10
    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
    steps: [ cmake_test, cmake_assert_test ]
  assert-clang10:
    description: Build just the library, install it and do a basic test
    executor: clang10
    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
    steps: [ cmake_test, cmake_assert_test ]
  gcc10-perftest:
    description: Build and run performance tests on GCC 10 and AVX 2 with a cmake static build, this test performance regression
    executor: gcc10
    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DBUILD_SHARED_LIBS=OFF }
    steps: [ cmake_perftest ]
  gcc10:
    description: Build and run tests on GCC 10 and AVX 2 with a cmake static build
    executor: gcc10
    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
  clang6:
    description: Build and run tests on clang 6 and AVX 2 with a cmake static build
    executor: clang6
    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
    steps: [ cmake_test, cmake_install_test ]
  clang10:
    description: Build and run tests on clang 10 and AVX 2 with a cmake static build
    executor: clang10
    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON  -DBUILD_SHARED_LIBS=OFF }
    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
  # libcpp
  libcpp-clang10:
    description: Build and run tests on clang 10 and AVX 2 with a cmake static build and libc++
    executor: clang10
    environment: { CMAKE_FLAGS: -DSIMDJSON_USE_LIBCPP=ON  -DBUILD_SHARED_LIBS=OFF }
    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
  # sanitize
  sanitize-gcc10:
    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
    executor: gcc10
    environment: { CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
    steps: [ cmake_test ]
  sanitize-clang10:
    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
    executor: clang10
    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
    steps: [ cmake_test ]
  threadsanitize-gcc10:
    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
    executor: gcc10
    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
    steps: [ cmake_test ]
  threadsanitize-clang10:
    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
    executor: clang10
    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
    steps: [ cmake_test ]
  # dynamic
  dynamic-gcc10:
    description: Build and run tests on GCC 10 and AVX 2 with a cmake dynamic build
    executor: gcc10
    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
    steps: [ cmake_test, cmake_install_test ]
  dynamic-clang10:
    description: Build and run tests on clang 10 and AVX 2 with a cmake dynamic build
    executor: clang10
    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
    steps: [ cmake_test, cmake_install_test ]

  # unthreaded
  unthreaded-gcc10:
    description: Build and run tests on GCC 10 and AVX 2 *without* threads
    executor: gcc10
    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
    steps: [ cmake_test, cmake_install_test ]
  unthreaded-clang10:
    description: Build and run tests on Clang 10 and AVX 2 *without* threads
    executor: clang10
    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
    steps: [ cmake_test, cmake_install_test ]

  # noexcept
  noexcept-gcc10:
    description: Build and run tests on GCC 10 and AVX 2 with exceptions off
    executor: gcc10
    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
    steps: [ cmake_test, cmake_install_test ]
  noexcept-clang10:
    description: Build and run tests on Clang 10 and AVX 2 with exceptions off
    executor: clang10
    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
    steps: [ cmake_test, cmake_install_test ]

  #
  # Misc.
  #

  # make (test and checkperf)
  arch-haswell-gcc10:
    description: Build, run tests and check performance on GCC 10 with -march=haswell
    executor: gcc10
    environment: { CXXFLAGS: -march=haswell }
    steps: [ cmake_test ]
  arch-nehalem-gcc10:
    description: Build, run tests and check performance on GCC 10 with -march=nehalem
    executor: gcc10
    environment: { CXXFLAGS: -march=nehalem }
    steps: [ cmake_test ]
  sanitize-haswell-gcc10:
    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
    executor: gcc10
    environment: {  CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
    steps: [ cmake_test ]
  sanitize-haswell-clang10:
    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
    executor: clang10
    environment: { CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
    steps: [ cmake_test ]

workflows:
  version: 2.1
  build_and_test:
    jobs:
      # full multi-implementation tests
      #- gcc7 tested on GitHub actions
      - gcc10 # do not delete this as it tests our performance
      - clang6
      #- clang10 # this gets tested a lot below

      # libc++
      - libcpp-clang10

      # full single-implementation tests
      - sanitize-gcc10
      - sanitize-clang10
      - threadsanitize-gcc10
      - threadsanitize-clang10
      - dynamic-gcc10
      - dynamic-clang10
      - unthreaded-gcc10
      - unthreaded-clang10

      # no exceptions
      - noexcept-gcc10
      - noexcept-clang10

      # quicker make single-implementation tests
      - arch-haswell-gcc10
      - arch-nehalem-gcc10


      # sanitized single-implementation tests
      - sanitize-haswell-gcc10
      - sanitize-haswell-clang10

      # testing "just the library"
      - justlib-gcc10

      # testing asserts
      - assert-gcc10
      - assert-clang10

      # TODO add windows: https://circleci.com/docs/2.0/configuration-reference/#windows