GTBench as a Library + Python Bindings (GridTools#69)

- Reorganizes source and header tree.
- Provides CMake install targets (and basic, untested export).
- Provides Python bindings to core solver functionality.

Author: fthaler

.dockerignore

@@ -0,0 +1,2 @@
+.*
+build*

.github/workflows/python.yml

@@ -0,0 +1,40 @@
+name: Python
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+env:
+  DOCKER_BUILDKIT: 1
+  OMP_NUM_THREADS: 1
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      name: checkout
+    - name: build
+      run: >
+        docker build
+        --cache-from fthaler/gtbench:python-test
+        --progress=plain
+        --build-arg BUILD_FROM=python:3.9.0
+        --build-arg GTBENCH_BACKEND=cpu_ifirst
+        --build-arg GTBENCH_RUNTIME=single_node
+        --build-arg GTBENCH_PYTHON_BINDINGS=ON
+        --build-arg BUILDKIT_INLINE_CACHE=1
+        -t fthaler/gtbench:python-test
+        .
+    - name: test
+      run: >
+        docker run --rm fthaler/gtbench:python-test bash -c 'pip install numpy pytest && pytest /gtbench/python/test.py'
+    - name: push
+      if: ${{ github.event_name == 'push' && github.repository == 'GridTools/gtbench' }}
+      run: >
+        echo ${{ secrets.DOCKER_TOKEN }} | docker login -u fthaler --password-stdin &&
+        docker push fthaler/gtbench:python-test &&
+        docker logout
+

.github/workflows/tests.yml

@@ -43,8 +43,8 @@ jobs:
     - name: test
       if: ${{ matrix.backend != 'cuda' && matrix.backend != 'hip' }}
       run: >
-        docker run --rm fthaler/gtbench:${{ matrix.backend }}-${{ matrix.runtime }} /usr/bin/benchmark --domain-size 11 13 17 --runs 1 &&
-        docker run --rm fthaler/gtbench:${{ matrix.backend }}-${{ matrix.runtime }} /usr/bin/convergence_tests
+        docker run --rm fthaler/gtbench:${{ matrix.backend }}-${{ matrix.runtime }} benchmark --domain-size 11 13 17 --runs 1 &&
+        docker run --rm fthaler/gtbench:${{ matrix.backend }}-${{ matrix.runtime }} convergence_tests
     - name: push
       if: ${{ github.event_name == 'push' && github.repository == 'GridTools/gtbench' }}
       run: >

.gitignore

@@ -0,0 +1,6 @@
+.*
+!.gitignore
+!.github
+!.dockerignore
+build
+__pycache__

CMakeLists.txt

@@ -1,5 +1,8 @@
 cmake_minimum_required(VERSION 3.14.5)
-project(GTBench LANGUAGES CXX)
+
+file(STRINGS "version.txt" _gtbench_version)
+project(GTBench VERSION ${_gtbench_version} LANGUAGES CXX)
+unset(_gtbench_version)
 
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE "Release" CACHE STRING
@@ -22,6 +25,9 @@ set(GTBENCH_BPARAMS_VDIFF "" CACHE STRING "Parameters for GridTools backend for
 set(GTBENCH_BPARAMS_HADV "" CACHE STRING "Parameters for GridTools backend for horizontal advection")
 set(GTBENCH_BPARAMS_VADV "" CACHE STRING "Parameters for GridTools backend for vertical advection")
 
+option(GTBENCH_PYTHON_BINDINGS "Build Python bindings" OFF)
+
+set(_gtbench_cuda_enabled OFF)
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND GTBENCH_BACKEND STREQUAL "gpu")
   set(GT_CLANG_CUDA_MODE "Clang-CUDA" CACHE STRING "Clang-CUDA or NVCC-CUDA")
   set_property(CACHE GT_CLANG_CUDA_MODE PROPERTY STRINGS "Clang-CUDA" "NVCC-CUDA")
@@ -32,6 +38,7 @@ else()
     enable_language(CUDA)
     set(CMAKE_CUDA_STANDARD 14)
     set(CMAKE_CUDA_EXTENSIONS OFF)
+    set(_gtbench_cuda_enabled ON)
   endif()
 endif()
 
@@ -40,65 +47,56 @@ if(NOT _gridtools_already_fetched)
     find_package(GridTools "2" QUIET)
 endif()
 if(NOT GridTools_FOUND)
-    set(_gridtools_repository "https://github.com/GridTools/gridtools.git")
-    set(_gridtools_tag        "release_v2.0")
-    if(NOT _gridtools_already_fetched)
-        message(STATUS "Fetching GridTools ${_gridtools_tag} from ${_gridtools_repository}")
-    endif()
-    include(FetchContent)
-    FetchContent_Declare(
-        gridtools
-        GIT_REPOSITORY ${_gridtools_repository}
-        GIT_TAG        ${_gridtools_tag}
-    )
-    FetchContent_MakeAvailable(gridtools)
-    set(_gridtools_already_fetched ON CACHE INTERNAL "")
+  set(_gridtools_repository "https://github.com/GridTools/gridtools.git")
+  set(_gridtools_tag        "release_v2.0")
+  if(NOT _gridtools_already_fetched)
+    message(STATUS "Fetching GridTools ${_gridtools_tag} from ${_gridtools_repository}")
+  endif()
+  include(FetchContent)
+  FetchContent_Declare(
+    gridtools
+    GIT_REPOSITORY ${_gridtools_repository}
+    GIT_TAG        ${_gridtools_tag}
+  )
+  FetchContent_MakeAvailable(gridtools)
+  set(_gridtools_already_fetched ON CACHE INTERNAL "")
 endif()
 
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
 # Helper functions
 function(compile_as_cuda)
-  get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
-  if("CUDA" IN_LIST languages)
+  if(_gtbench_cuda_enabled)
     set_source_files_properties(${ARGN} PROPERTIES LANGUAGE CUDA)
   endif()
 endfunction()
 
-add_library(common INTERFACE)
-target_compile_options(common INTERFACE "$<$<COMPILE_LANGUAGE:CUDA>:SHELL:--default-stream per-thread>")
-
-target_compile_definitions(common INTERFACE
+add_library(gtbench_common INTERFACE)
+target_include_directories(gtbench_common INTERFACE
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include/>
+  $<INSTALL_INTERFACE:include>
+)
+target_compile_definitions(gtbench_common INTERFACE
   GTBENCH_BACKEND=${GTBENCH_BACKEND}
   GTBENCH_BACKEND_$<UPPER_CASE:${GTBENCH_BACKEND}>
   GTBENCH_FLOAT=${GTBENCH_FLOAT}
   )
-target_link_libraries(common INTERFACE
+target_link_libraries(gtbench_common INTERFACE
   GridTools::gridtools
   GridTools::stencil_${GTBENCH_BACKEND}
   GridTools::storage_${GTBENCH_BACKEND}
-  )
+)
+set_target_properties(
+  gtbench_common
+  PROPERTIES
+    INTERFACE_POSITION_INDEPENDENT_CODE ON)
 
-add_library(common_runtime INTERFACE)
-target_compile_definitions(common_runtime INTERFACE
-  GTBENCH_RUNTIME=${GTBENCH_RUNTIME}
-  )
-target_link_libraries(common_runtime INTERFACE
-  common
-  )
+add_library(gtbench)
+add_library(GTBench::gtbench ALIAS gtbench)
+target_link_libraries(gtbench PUBLIC gtbench_common)
 
-# Subdirectories
-add_subdirectory(common)
-add_subdirectory(io)
-add_subdirectory(runtime)
-add_subdirectory(numerics)
+add_subdirectory(src)
 
-# Current directory
-compile_as_cuda(convergence_tests.cpp benchmark.cpp)
+include(${CMAKE_CURRENT_LIST_DIR}/cmake/export.cmake)
 
-add_executable(convergence_tests convergence_tests.cpp)
-target_link_libraries(convergence_tests advection diffusion options runtime device io)
-
-add_executable(benchmark benchmark.cpp)
-target_link_libraries(benchmark advection diffusion options runtime device io)
+if(GTBENCH_PYTHON_BINDINGS)
+  add_subdirectory(python)
+endif()

Dockerfile

@@ -20,15 +20,16 @@ RUN wget -q https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}
     rm -rf cmake-${CMAKE_VERSION}-Linux-x86_64*
 
 ARG BOOST_VERSION=1.67.0
-RUN export BOOST_VERSION_UNERLINE=$(echo ${BOOST_VERSION} | sed 's/\./_/g') && \
-    wget -q https://dl.bintray.com/boostorg/release/${BOOST_VERSION}/source/boost_${BOOST_VERSION_UNERLINE}.tar.gz && \
-    tar xzf boost_${BOOST_VERSION_UNERLINE}.tar.gz && \
-    cp -r boost_${BOOST_VERSION_UNERLINE}/boost /usr/local/include/ && \
-    rm -rf boost_${BOOST_VERSION_UNERLINE}*
+RUN export BOOST_VERSION_UNDERLINE=$(echo ${BOOST_VERSION} | sed 's/\./_/g') && \
+    wget -q https://dl.bintray.com/boostorg/release/${BOOST_VERSION}/source/boost_${BOOST_VERSION_UNDERLINE}.tar.gz && \
+    tar xzf boost_${BOOST_VERSION_UNDERLINE}.tar.gz && \
+    cp -r boost_${BOOST_VERSION_UNDERLINE}/boost /usr/local/include/ && \
+    rm -rf boost_${BOOST_VERSION_UNDERLINE}*
 
 FROM base
 ARG GTBENCH_BACKEND=cpu_ifirst
 ARG GTBENCH_RUNTIME=ghex_comm
+ARG GTBENCH_PYTHON_BINDINGS=OFF
 COPY . /gtbench
 RUN cd /gtbench && \
     mkdir -p build && \
@@ -38,9 +39,9 @@ RUN cd /gtbench && \
     -DCMAKE_BUILD_TYPE=Release \
     -DGTBENCH_BACKEND=${GTBENCH_BACKEND} \
     -DGTBENCH_RUNTIME=${GTBENCH_RUNTIME} \
+    -DGTBENCH_PYTHON_BINDINGS=${GTBENCH_PYTHON_BINDINGS} \
     .. && \
-    make -j $(nproc) && \
-    cp benchmark convergence_tests /usr/bin/ && \
+    make -j $(nproc) install && \
     rm -rf /gtbench/build
 
-CMD ["/usr/bin/convergence_tests"]
+CMD ["convergence_tests"]

cmake/GTBenchConfig.cmake.in

@@ -0,0 +1,10 @@
+set(GTBench_VERSION @GTBench_Version@)
+
+@PACKAGE_INIT@
+
+if(NOT @PROJECT_NAME@_BINARY_DIR AND NOT TARGET GTBench::gtbench)
+  include("${GTBENCH_CONFIG_CMAKE_DIR}/GTBenchTargets.cmake")
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(GTBench REQUIRED_VARS GTBench_VERSION VERSION_VAR GTBench_VERSION)

cmake/export.cmake

@@ -0,0 +1,43 @@
+set(GTBENCH_MODULE_PATH lib/cmake/GTBench)
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+configure_package_config_file(
+  cmake/GTBenchConfig.cmake.in
+  "${CMAKE_CURRENT_BINARY_DIR}/install/GTBenchConfig.cmake"
+  PATH_VARS GTBENCH_MODULE_PATH
+  INSTALL_DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}/cmake/GTBench"
+)
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/install/GTBenchConfigVersion.cmake"
+  COMPATIBILITY SameMajorVersion
+)
+
+install(
+  TARGETS gtbench
+  EXPORT GTBenchTargets
+  INCLUDES DESTINATION include
+)
+install(TARGETS benchmark convergence_tests)
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+# Workaround for GT export strategy
+install(
+  TARGETS stencil_${GTBENCH_BACKEND} storage_${GTBENCH_BACKEND}
+  EXPORT GTBenchTargets
+)
+
+include(GNUInstallDirs)
+install(
+  FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/install/GTBenchConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/install/GTBenchConfigVersion.cmake"
+  DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}/cmake/${PROJECT_NAME}"
+)
+
+# Currently disabled due to GT dependency issues
+# install(
+#   EXPORT GTBenchTargets
+#   FILE GTBenchTargets.cmake
+#   NAMESPACE GTBench::
+#   DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}/cmake/${PROJECT_NAME}"
+# )

common/CMakeLists.txt

@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 
+namespace gtbench {
 namespace options_impl {
 
 void abort(std::string const &message);
@@ -124,3 +125,5 @@ class options {
 
   std::vector<option> m_options;
 };
+
+} // namespace gtbench

common/options.hpp include/gtbench/common/options.hpp

@@ -27,6 +27,8 @@
 #include <gridtools/storage/gpu.hpp>
 #endif
 
+namespace gtbench {
+
 namespace gt = gridtools;
 
 using real_t = GTBENCH_FLOAT;
@@ -56,3 +58,5 @@ inline auto storage_builder(vec<std::size_t, 3> const &resolution) {
 
 using storage_t =
     decltype(storage_builder(std::declval<vec<std::size_t, 3>>())());
+
+} // namespace gtbench

common/types.hpp include/gtbench/common/types.hpp

@@ -12,6 +12,7 @@
 #include <cstdint>
 #include <ostream>
 
+namespace gtbench {
 namespace io {
 class base64_encoder {
   std::ostream &m_out;
@@ -47,3 +48,4 @@ class base64_encoder {
   }
 };
 } // namespace io
+} // namespace gtbench

io/base64.hpp include/gtbench/io/base64.hpp

@@ -15,6 +15,7 @@
 #include "../common/types.hpp"
 #include "../numerics/solver.hpp"
 
+namespace gtbench {
 namespace io {
 
 std::function<void(real_t, numerics::solver_state const &state)>
@@ -24,3 +25,4 @@ write_time_series(std::string const &filename,
                   vec<std::size_t, 3> const &local_offset);
 
 } // namespace io
+} // namespace gtbench

io/io.hpp include/gtbench/io/io.hpp

@@ -11,6 +11,7 @@
 
 #include "./io.hpp"
 
+namespace gtbench {
 namespace io {
 namespace numpy {
 
@@ -22,3 +23,4 @@ write_time_series(std::string const &filename,
 
 } // namespace numpy
 } // namespace io
+} // namespace gtbench

io/numpy.hpp include/gtbench/io/numpy.hpp

@@ -11,11 +11,13 @@
 
 #include "../common/types.hpp"
 
+namespace gtbench {
 namespace io {
 std::size_t rank(vec<std::size_t, 3> const &global_resolution,
                  vec<std::size_t, 3> const &local_resolution,
                  vec<std::size_t, 3> const &local_offset);
 
 std::size_t ranks(vec<std::size_t, 3> const &global_resolution,
                   vec<std::size_t, 3> const &local_resolution);
-} // namespace io
+} // namespace io
+} // namespace gtbench

io/util.hpp include/gtbench/io/util.hpp

@@ -13,6 +13,7 @@
 
 #include "./io.hpp"
 
+namespace gtbench {
 namespace io {
 namespace vtk {
 
@@ -25,3 +26,4 @@ write_time_series(std::string const &filename,
 } // namespace vtk
 
 } // namespace io
+} // namespace gtbench

io/vtk.hpp include/gtbench/io/vtk.hpp

@@ -11,6 +11,7 @@
 
 #include "./computation.hpp"
 
+namespace gtbench {
 namespace numerics {
 namespace advection {
 
@@ -23,3 +24,4 @@ vertical(vec<std::size_t, 3> const &resolution, vec<real_t, 3> const &delta);
 
 } // namespace advection
 } // namespace numerics
+} // namespace gtbench