.gitlab-ci.yml

###
### Variables
###

# Global variables (will be set in every job):
variables:
  WARN_AS_ERROR: "1"
  # MAKEFLAGS: "-s"
  REALM_BACKTRACE: "1"
  REALM_SYNTHETIC_CORE_MAP: "" # Disable Realm thread pinning.

# Local variables (included on a case-by-case basis in each job):
.gcc48: &gcc48
  CXX: "g++-4.8"
.gcc49: &gcc49
  CXX: "g++-4.9"
.gcc5: &gcc5
  CXX: "g++-5"
.gcc6: &gcc6
  CXX: "g++-6"
.gcc7: &gcc7
  CXX: "g++-7"

.clang35: &clang35
  CXX: "clang++-3.5"
.clang38: &clang38
  CXX: "clang++-3.8"

.terra35: &terra35
  LLVM_CONFIG: "llvm-config-3.5"
  TERRA_DIR: "/usr/local/terra35"
.terra38: &terra38
  LLVM_CONFIG: "llvm-config-3.8"
  TERRA_DIR: "/usr/local/terra38"

.debug: &debug
  DEBUG: "1"
.release: &release
  DEBUG: "0"

.max_dim4: &max_dim4
  MAX_DIM: "4"

.cxx98_normal: &cxx98_normal
  CC_FLAGS: "-std=c++98"
.cxx98_checks: &cxx98_checks
  CC_FLAGS: "-std=c++98 -DPRIVILEGE_CHECKS -DBOUNDS_CHECKS"
.cxx98_spy: &cxx98_spy
  CC_FLAGS: "-std=c++98 -DLEGION_SPY"
  USE_SPY: "1"
.cxx11_normal: &cxx11_normal
  CC_FLAGS: "-std=c++11"
.cxx14_normal: &cxx14_normal
  CC_FLAGS: "-std=c++14"
.cxx14_checks: &cxx14_checks
  CC_FLAGS: "-std=c++14 -DPRIVILEGE_CHECKS -DBOUNDS_CHECKS"
.cxx98_32bit_normal: &cxx98_32bit_normal
  CC_FLAGS: "-std=c++98 -m32"
  LD_FLAGS: "-m32"
  MARCH: "i686"

.openmp: &openmp
  USE_OPENMP: "1"
.python2: &python2
  USE_PYTHON: "1"
.python3: &python3
  USE_PYTHON: "1"
  # FIXME: It would be nice to find a better way to do this,
  # but the alternatives look scary
  PYTHON_LIB: "/usr/lib/x86_64-linux-gnu/libpython3.4m.so"
  PYTHON_VERSION_MAJOR: "3"
.hdf5: &hdf5
  USE_HDF: "1"
.llvm: &llvm
  USE_LLVM: "1"
.cuda: &cuda
  USE_CUDA: "1"
.gasnet: &gasnet
  USE_GASNET: "1"
.gasnetex: &gasnetex
  USE_GASNET: "1"
  GASNET_VERSION: "GASNet-EX-snapshot"
  # source URL is set by a GitLab CI variable as the GASNet-EX team prefers
  #  it not to be public at this time
  #GASNETEX_SNAPSHOT_SOURCE_URL: ...
.cmake: &cmake
  USE_CMAKE: "1"

.prof: &prof
  USE_PROF: "1"

.legion: &legion
  TEST_REGENT: "0"

.ctest: &ctest
  TEST_CTEST: "1"

.regent: &regent
  TEST_LEGION_CXX: "0"
  TEST_REALM: "0"
  TEST_FUZZER: "0"
.parallel: &parallel
  REGENT_JOBS: "2"
.incremental: &incremental
  REGENT_INCREMENTAL: "1"

###
### Setup
###

# These commands will run before each job.
before_script:
  - uname -a
  - |
    if [[ "$(uname)" = "Linux" ]]; then
      export THREADS=$(nproc --all)
    elif [[ "$(uname)" = "Darwin" ]]; then
      export THREADS=$(sysctl -n hw.ncpu)
    else
      echo "Unknown platform. Setting THREADS to 1."
      export THREADS=1
    fi
  # - |
  #   if [[ "$(uname)" = "Darwin" ]]; then
  #     brew update
  #     brew install pypy homebrew/versions/llvm35
  #   fi
  - |
    if [[ "$USE_GASNET" -eq 1 && "$(hostname)" != n0003 ]]; then
      export CONDUIT=mpi
      export GASNET_ROOT="$PWD/gasnet/release"
      # OpenMPI:
      # export LAUNCHER="mpirun -n 2 -x TERRA_PATH -x INCLUDE_PATH -x LD_LIBRARY_PATH -x LG_RT_DIR -x USE_RDIR"
      # MPICH:
      export LAUNCHER="mpirun -n 2"
      unset WARN_AS_ERROR
      git clone https://github.com/StanfordLegion/gasnet.git gasnet
      make -C gasnet -j$THREADS
    fi
  - |
    if [[ "$(hostname)" = n0003 ]]; then
      source /usr/local/modules-3.2.10/init/bash
      module load cmake/3.8.2
      module load mpi/openmpi/1.10.4
      module load cuda/8.0

      if [[ "$USE_GASNET" -eq 1 ]]; then
        module load gasnet/1.30.0-openmpi
        export LAUNCHER="mpirun -n 2 -x TERRA_PATH -x INCLUDE_PATH -x LD_LIBRARY_PATH -x LG_RT_DIR -x USE_RDIR"
      fi
    fi

###
### Tags
###

.linux: &linux
  tags:
    - linux
.macos: &macos
  tags:
    - macos

# For compute-heavy tests:
.linux_compute: &linux_compute
  tags:
    - linux
    - compute

# For performance tests, always use specific machines:
.linux_n0004: &linux_n0004
  tags:
    - linux
    - n0004

# For CUDA tests, always use a specific machine:
.n0003: &n0003
  tags:
    - n0003

###
### Docker Image
###

# Each job will run in a fresh container with this image.
.image: &image
  image: stanfordlegion/gitlab-ci # i.e. https://hub.docker.com/r/stanfordlegion/gitlab-ci/
.image_clang: &image_clang
  image: stanfordlegion/gitlab-ci:clang # i.e. https://hub.docker.com/r/stanfordlegion/gitlab-ci/

###
### Tests
###

# Each job will run this set of tests.
.tests: &tests
  script:
    - ./tools/add_github_host_key.sh
    - grep 'model name' /proc/cpuinfo | uniq -c
    - free
    - ./test.py
  retry:
    max: 2
    when:
      - runner_system_failure
      - unknown_failure

# Some additional tests are only run on certain configurations.
.external_tests: &external_tests
  script:
    - ./tools/add_github_host_key.sh
    - |
      if [[ -n $GITLAB_DEPLOY_KEY ]]; then
        eval $(ssh-agent -s)
        ssh-add <(echo "$GITLAB_DEPLOY_KEY")
      fi
    - ./test.py --test=external --test=private
  retry:
    max: 2
    when:
      - runner_system_failure
      - unknown_failure

# For performance tests, run these commands:
.perf_tests: &perf_tests
  script:
    - ./tools/add_github_host_key.sh
    - |
      if [[ -n $GITLAB_DEPLOY_KEY ]]; then
        eval $(ssh-agent -s)
        ssh-add <(echo "$GITLAB_DEPLOY_KEY")
      fi
    - git config --global user.name "Legion Testing Automation"
    - git config --global user.email "legion-testing@googlegroups.com"
    - export PERF_MIN_NODES=1
    - export PERF_MAX_NODES=1
    - ./test.py --test=perf
  retry:
    max: 2
    when:
      - runner_system_failure
      - unknown_failure

###
### Jobs
###

# Each item below defines a job.

# There are two tiers of tests.
#  1. Full test suite (small number of compilers).
#  2. Minimal test suite (other compilers).

# Run the full test suite on GCC 4.9 and Clang 3.5.

# Linux with GCC 4.9
# * Basic configurations
#   * Release
gcc49_cxx98_release_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *release, *cxx98_normal, *legion]
gcc49_cxx98_release_cmake_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *release, *cxx98_normal, *cmake, *regent, *incremental]
#   * Debug (Privilege and Bounds Checks)
gcc49_cxx98_debug_checks_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_checks, *legion]
#   * Spy
gcc49_cxx98_debug_spy_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_spy, *legion]
gcc49_cxx98_debug_spy_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_spy, *regent, *parallel]
#   * Prof
gcc49_cxx98_release_prof_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *release, *cxx98_normal, *prof, *regent, *parallel]
#   * C++11
gcc49_cxx11_release_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *release, *cxx11_normal, *legion]
# * Features: one test per feature
#   * OpenMP
gcc49_cxx98_debug_openmp_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *openmp, *legion]
gcc49_cxx98_debug_openmp_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *openmp, *regent]
#   * Python
gcc49_cxx98_debug_python2_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *python2, *legion]
gcc49_cxx98_debug_python3_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *python3, *legion]
#   * LLVM
gcc49_cxx98_debug_llvm_cmake_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *llvm, *cmake, *legion, *ctest]
gcc49_cxx98_debug_llvm_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *llvm, *regent]
#   * HDF5
gcc49_cxx98_debug_hdf5_cmake_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *hdf5, *cmake, *legion, *ctest]
gcc49_cxx98_debug_hdf5_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *hdf5, *regent]
#   * GASNet
gcc49_cxx98_debug_gasnet_cmake_legion:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *gasnet, *cmake, *legion, *ctest]
gcc49_cxx98_debug_gasnet_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *gasnet, *regent, *incremental]
gcc49_cxx98_debug_gasnetex_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *gasnetex, *regent, *incremental]
# * Integration: Python + Regent
gcc49_cxx98_debug_python2_regent:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *python2, *regent]
gcc49_cxx98_debug_python3_regent:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *python3, *regent]
# * Integration: LLVM + GASNet
gcc49_cxx98_debug_llvm_gasnet_legion:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *llvm, *gasnet, *legion]
gcc49_cxx98_debug_llvm_gasnet_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *llvm, *gasnet, *regent, *incremental]
# * Integration: HDF5 + GASNet
gcc49_cxx98_debug_hdf5_gasnet_legion:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *hdf5, *gasnet, *legion]
gcc49_cxx98_debug_hdf5_gasnet_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_normal, *hdf5, *gasnet, *regent]
### GASNet + Legion Spy disabled until issue #247 is resolved
###gcc49_cxx98_debug_spy_gasnet_regent:
###  <<: [*linux_compute, *image, *tests]
###  variables:
###    <<: [*gcc49, *terra38, *debug, *cxx98_spy, *gasnet, *regent]
# * Different architectures
gcc49_cxx98_32bit_debug_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx98_32bit_normal, *legion]
# * External tests
gcc49_cxx11_debug_external:
  <<: [*linux_compute, *image, *external_tests]
  variables:
    <<: [*gcc49, *terra38, *debug, *cxx11_normal, *hdf5]

# Linux with Clang 3.8
# * Basic configurations
#   * Release
clang38_cxx98_release_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *release, *cxx98_normal, *legion]
clang38_cxx98_release_cmake_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *release, *cxx98_normal, *cmake, *regent, *incremental]
#   * Debug (Privilege and Bounds Checks)
clang38_cxx98_debug_checks_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_checks, *legion]
#   * Spy
clang38_cxx98_debug_spy_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_spy, *legion]
clang38_cxx98_debug_spy_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_spy, *regent, *parallel]
#   * Prof
clang38_cxx98_release_prof_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *release, *cxx98_normal, *prof, *regent, *parallel]
#   * C++11
clang38_cxx11_release_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *release, *cxx11_normal, *legion]
# * Features: one test per feature
#   * OpenMP
clang38_cxx98_debug_openmp_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *openmp, *legion]
clang38_cxx98_debug_openmp_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *openmp, *regent]
#   * Python
clang38_cxx98_debug_python2_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *python2, *legion]
clang38_cxx98_debug_python3_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *python3, *legion]
#   * LLVM
clang38_cxx98_debug_llvm_cmake_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *llvm, *cmake, *legion, *ctest]
clang38_cxx98_debug_llvm_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *llvm, *regent]
#   * HDF5
clang38_cxx98_debug_hdf5_cmake_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *hdf5, *cmake, *legion, *ctest]
clang38_cxx98_debug_hdf5_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *hdf5, *regent]
#   * GASNet
clang38_cxx98_debug_gasnet_cmake_legion:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *gasnet, *cmake, *legion, *ctest]
clang38_cxx98_debug_gasnet_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *gasnet, *regent, *incremental]
# * Integration: Python + Regent
clang38_cxx98_debug_python2_regent:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *python2, *regent]
clang38_cxx98_debug_python3_regent:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *python3, *regent]
# * Integration: LLVM + GASNet
clang38_cxx98_debug_llvm_gasnet_legion:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *llvm, *gasnet, *legion]
clang38_cxx98_debug_llvm_gasnet_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *llvm, *gasnet, *regent, *incremental]
# * Integration: HDF5 + GASNet
clang38_cxx98_debug_hdf5_gasnet_legion:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *hdf5, *gasnet, *legion]
clang38_cxx98_debug_hdf5_gasnet_regent:
  <<: [*linux_compute, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_normal, *hdf5, *gasnet, *regent, *incremental]
# * Integration: HDF5 + GASNet
# clang38_cxx98_debug_spy_gasnet_regent:
#   <<: [*linux_compute, *image_clang, *tests]
#   variables:
#     <<: [*clang38, *terra38, *debug, *cxx98_spy, *gasnet, *regent]
# * Different architectures
clang38_cxx98_32bit_debug_legion:
  <<: [*linux, *image_clang, *tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx98_32bit_normal, *legion]
# * External tests
clang38_cxx11_debug_external:
  <<: [*linux_compute, *image_clang, *external_tests]
  variables:
    <<: [*clang38, *terra38, *debug, *cxx11_normal, *hdf5]

# # macOS with Clang 3.5
# macos_clang38_cxx98_debug:
#   <<: [*macos, *tests]
#   variables:
#     <<: [*clang38, *debug, *cxx98_normal]

# Run minimal tests on other compilers.

# Linux with GCC 4.8, 5, 6, 7
gcc48_cxx98_debug_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc48, *terra38, *debug, *cxx98_normal, *legion]
gcc48_cxx98_debug_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc48, *terra38, *debug, *cxx98_normal, *regent]
gcc5_cxx98_debug_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc5, *terra38, *debug, *cxx98_normal, *legion]
gcc5_cxx98_debug_normal_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc5, *terra38, *debug, *cxx98_normal, *regent]
gcc6_cxx98_debug_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc6, *terra38, *debug, *cxx98_normal, *legion]
gcc6_cxx98_debug_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc6, *terra38, *debug, *cxx98_normal, *regent]
gcc6_cxx14_debug_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc6, *terra38, *debug, *cxx14_checks, *legion]
gcc6_cxx14_debug_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc6, *terra38, *debug, *cxx14_normal, *regent]
gcc7_cxx14_debug_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*gcc7, *terra38, *debug, *cxx14_checks, *legion]
gcc7_cxx14_debug_regent:
  <<: [*linux_compute, *image, *tests]
  variables:
    <<: [*gcc7, *terra38, *debug, *cxx14_normal, *regent]

# Linux with Clang 3.5
clang35_cxx98_debug_legion:
  <<: [*linux, *image, *tests]
  variables:
    <<: [*clang35, *terra35, *debug, *cxx98_normal, *llvm, *legion]
# FIXME: Breaks on attempting to split vector-op
# clang35_cxx98_debug_regent:
#   <<: [*linux_compute, *image, *tests]
#   variables:
#     <<: [*clang35, *terra35, *debug, *cxx98_normal, *regent]

# Performance tests:
# n0004_gcc49_cxx98_release_perf:
#   <<: [*linux_n0004, *image, *perf_tests]
#   variables:
#     <<: [*gcc49, *terra38, *release, *cxx98_normal]

# Performance tests:
# n0004_gcc49_cxx98_release_perf:
#   <<: [*linux_n0004, *image, *perf_tests]
#   variables:
#     <<: [*gcc49, *terra38, *release, *cxx98_normal]

# CUDA tests:
n0003_gcc48_cxx98_release_legion_cuda:
  <<: [*n0003, *image, *tests]
  variables:
    <<: [*gcc48, *terra38, *release, *cxx98_normal, *cuda, *legion]
# n0003_gcc48_cxx98_release_regent_cuda:
#   <<: [*n0003, *image, *tests]
#   variables:
#     <<: [*gcc48, *terra38, *release, *cxx98_normal, *cuda, *regent]