ports build integration and spiner install cleanup (#22)

* cmake looks for ports-of-call with find_package first

* update ports of call to main

* add ports-of-call to spack repo

* update spiner spackage to depend on ports-of-call spackage

* some tweaks

* change to only one target, spiner::spiner, and export it

* add integration test testing install

* update docs

* final update docs

* fix naming bug in ports of call package

* pass hdf5 through spack and also update cmake arguments appropriately

* address comments

Co-authored-by: Jonah Maxwell Miller <jonahm@lanl.gov>

Author: Yurlungur

.github/workflows/install.yml

@@ -0,0 +1,36 @@
+name: Install
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+    tests:
+      name: Test installation
+      runs-on: ubuntu-latest
+
+      steps:
+        - name: Checkout code
+          uses: actions/checkout@v2
+          with:
+            submodules: recursive
+        - name: Set system to non-interactive mode
+          run: export DEBIAN_FRONTEND=noninteractive
+        - name: install dependencies
+          run: |
+            sudo apt-get install -y --force-yes -qq build-essential
+        - name: build and install
+          run: |
+            echo "Build"
+            mkdir -p ${HOME}/install
+            cmake -DCMAKE_INSTALL_PREFIX=${HOME}/install -B build .
+            cmake --build build
+            cmake --install build
+            echo "Now try find package from a separate directory"
+            rm -rf build
+            cmake -DCMAKE_PREFIX_PATH=${HOME}/install -B build installtest
+            echo "Now try and build with includes..."
+            cmake --build build
+            echo "Done"

.gitignore

@@ -1,3 +1,4 @@
+build
 bin
 CMakeFiles
 CMakeCache.txt

CMakeLists.txt

@@ -15,9 +15,11 @@
 cmake_minimum_required(VERSION 3.14)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
-option (SPINER_USE_HDF "Pull in hdf5" OFF)
+option (SPINER_USE_HDF
+  "Pull in hdf5" OFF)
 option (SPINER_USE_KOKKOS "Pull in Kokkos" OFF)
 option (SPINER_USE_CUDA "Use the Kokkos cuda backend" OFF)
+option (SPINER_FORCE_INTERNAL_PORTS "Force use of internal ports of call" OFF)
 
 if (SPINER_USE_CUDA AND NOT SPINER_USE_KOKKOS)
   message(FATAL_ERROR "Currently cuda requires Kokkos")
@@ -26,7 +28,14 @@ endif()
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_EXPORT_COMPILE_COMMANDS On)
 
-project(spiner VERSION 1.4.0)
+set(SPINER_VERSION 1.4.0)
+project(spiner VERSION ${SPINER_VERSION})
+
+# bring in some helpful CMake scripts 
+# make cache variables for install destinations
+include(GNUInstallDirs)
+# package config file
+include(CMakePackageConfigHelpers)
 
 # Don't allow in-source builds
 file(TO_CMAKE_PATH "${PROJECT_BINARY_DIR}/CMakeLists.txt" LOC_PATH)
@@ -54,16 +63,9 @@ include(CTest)
 include(cmake/Format.cmake)
 
 # Add a library
-# mostly includes
-add_library(spiner::flags INTERFACE IMPORTED GLOBAL)
-# mostly just contains automated linker connections
-add_library(spiner::libs INTERFACE IMPORTED)
-
-# xl fix
-target_compile_options(spiner::flags INTERFACE
-  $<$<COMPILE_LANG_AND_ID:CXX,XL>:-std=c++1y;-qxflag=disable__cplusplusOverride>)
-target_link_options(spiner::flags INTERFACE
-  $<$<COMPILE_LANG_AND_ID:CXX,XL>:-std=c++1y;-qxflag=disable__cplusplusOverride>)
+set(SPLIB "spiner")
+add_library(${SPLIB} INTERFACE)
+add_library(${SPLIB}::${SPLIB} ALIAS ${SPLIB})
 
 # HDF5
 if(SPINER_USE_HDF)
@@ -72,22 +74,16 @@ if(SPINER_USE_HDF)
   endif()
   find_package(HDF5 COMPONENTS C HL)
   if (HDF5_FOUND)
-    add_library(spiner::hdf5 INTERFACE IMPORTED GLOBAL)
-    target_compile_definitions(spiner::flags
-      INTERFACE
-      SPINER_USE_HDF)
-    set_target_properties(spiner::hdf5 PROPERTIES
-      INTERFACE_LINK_LIBRARIES "${HDF5_LIBRARIES};${HDF5_HL_LIBRARIES}"
-      INTERFACE_COMPILE_DEFINITIONS "SPINER_USE_HDF"
-      INTERFACE_INCLUDE_DIRECTORIES "${HDF5_INCLUDE_DIRS}")
+    target_compile_definitions(${SPLIB} INTERFACE SPINER_USE_HDF)
+    target_link_libraries(${SPLIB} INTERFACE ${HDF5_LIBRARIES} ${HDF5_HL_LIBRARIES})
+    target_include_directories(${SPLIB} INTERFACE ${HDF5_INCLUDE_DIRS})
   else()
     message(FATAL_ERROR "HDF5 was requested but not found. Can be disabled with -SPINER_USE_HDF=OFF")
   endif()
-  target_link_libraries(spiner::libs INTERFACE spiner::hdf5)
 endif()
 
 if (SPINER_USE_KOKKOS)
-  target_compile_definitions(spiner::flags INTERFACE
+  target_compile_definitions(${SPLIB} INTERFACE
     PORTABILITY_STRATEGY_KOKKOS)
   # Import Kokkos if not already available as a build target
   if (NOT TARGET Kokkos::kokkos)
@@ -102,38 +98,88 @@ if (SPINER_USE_KOKKOS)
   endif()
   if(SPINER_USE_CUDA)
     target_compile_options(
-      spiner::flags
+      ${SPLIB}
       INTERFACE # Generator expression shamelessly copied from EAP
       "$<$<COMPILE_LANGUAGE:CXX>:--expt-relaxed-constexpr;>"
       )
   endif()
-  target_link_libraries(spiner::libs INTERFACE Kokkos::kokkos)
+  target_link_libraries(${SPLIB} INTERFACE Kokkos::kokkos)
 endif ()
 
 # ports of call
 # TODO: Integrate with find-package
 if (NOT TARGET ports-of-call::ports-of-call)
-  add_subdirectory(ports-of-call)
+  message(STATUS "Looking for ports-of-call")
+  if (SPINER_FORCE_INTERNAL_PORTS)
+    message(STATUS "Using in-system ports-of-call")
+    add_subdirectory(ports-of-call)
+  else()
+    find_package(ports-of-call CONFIG)
+    if (NOT ports-of-call_FOUND)
+      message(STATUS "Ports of call not available in-system. Using submodule.")
+      add_subdirectory(ports-of-call)
+    else()
+      message(STATUS "Ports of call is available. Using in-system installation.")
+    endif()
+  endif()
+else()
+  message(STATUS "Ports of call already in environment")
 endif()
-target_link_libraries(spiner::flags INTERFACE ports-of-call::ports-of-call)
-
-# parent library
-# so the user can just import `spiner::spiner` rather than flags or libs.
-add_library(spiner::spiner INTERFACE IMPORTED GLOBAL)
-target_link_libraries(spiner::spiner INTERFACE spiner::flags spiner::libs)
+target_link_libraries(${SPLIB} INTERFACE ports-of-call::ports-of-call)
 
 # Enables
 # #include <spiner>
-target_include_directories(spiner::flags
+target_include_directories(${SPLIB}
   INTERFACE
   $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>)
 
-# Enables includes
+# Coordinate external CMAKE export with targets
+install(TARGETS ${SPLIB}
+  EXPORT ${SPLIB}Targets
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  )
+
+configure_package_config_file(${SPLIB}Config.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/${SPLIB}Config.cmake
+  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${SPLIB}
+)
+
+# ...and the version file
+write_basic_package_version_file(
+  ${CMAKE_CURRENT_BINARY_DIR}/${SPLIB}ConfigVersion.cmake
+  VERSION ${SPINER_VERSION}
+  COMPATIBILITY SameMajorVersion )
+
+# Install the cmake configuration files
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${SPLIB}Config.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/${SPLIB}ConfigVersion.cmake
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${SPLIB} )
+
+# Install header files
 install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/spiner"
-  DESTINATION "include"
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
   FILES_MATCHING PATTERN "*.hpp"
   )
 
+# Install the export target. This will define the CMake target
+# for external projects when used with `find_package`
+install(EXPORT ${SPLIB}Targets
+  NAMESPACE ${SPLIB}::
+  FILE "${SPLIB}Targets.cmake"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${SPLIB}"
+  COMPONENT dev)
+
+# Export configuration for external projects that reference
+# just our build-tree; e.g. for submodules. To use, ensure 
+# `CMAKE_PREFIX_PATH` points to this source directory.
+# NOTE: This config will not be relocatable!
+export(TARGETS ${SPLIB} NAMESPACE ${SPLIB}::
+  FILE "${CMAKE_CURRENT_BINARY_DIR}/${SPLIB}Targets.cmake")
+export(PACKAGE ${SPLIB})
+
 # Option imported from `CTest`
 if (BUILD_TESTING)
   message("\nConfiguring tests")

README.md

@@ -51,16 +51,7 @@ after configuring and building.
 
 You can build `spiner` in-line with your project, or pre-install
 it. It's header-only and the include directories should have the
-expected structure. If you build inline, add the following targets to your `cmake`:
-```cmake
-target_link_libraries(my_project PRIVATE spiner::flags spiner::libs)
-```
-`spiner::flags` contains compile and include flags, to be included at
-compile lines. `spiner::libs` contains linker flags. Since `spiner` is
-header-only, `spiner::libs` only contains link flags for dependencies,
-such as `HDF5` or `Kokkos`.
-
-For access to both, use
+expected structure. If you build inline, add the following target to your `cmake`:
 ```cmake
 target_link_libraries(my_project PRIVATE spiner::spiner)
 ```

doc/sphinx/src/building.rst

@@ -32,11 +32,14 @@ Spiner supports a few ``cmake`` configuration options:
 * ``SPINER_USE_CUDA`` enables the Kokkos cuda backend
 * ``CMAKE_INSTALL_PREFIX`` sets the install location
 * ``CMAKE_BUILD_TYPE`` sets the build type
+* ``SPINER_FORCE_INTERNAL_PORTS`` forces use of a `ports-of-call`_ submodule rather than a system install
 
 .. _`hdf5`: https://www.hdfgroup.org/solutions/hdf5
 
 .. _`Kokkos`: https://github.com/kokkos/kokkos
 
+.. _`ports-of-call`: https://lanl.github.io/ports-of-call/main/index.html
+
 HDF5 is searched for and configured via the usual `cmake`_ machinery.
 
 .. _`cmake`: https://cmake.org/
@@ -72,6 +75,8 @@ The spack repo supports a few variants:
 
 * ``+kokkos`` enables the Kokkos backend
 * ``+cuda`` enables the cuda backend. A ``cuda_arch`` must be specified.
+* ``+hdf5`` enables HDF5 file support.
+* ``+mpi`` enables parallel hdf5 support
 * ``+python`` installs python, numpy, and matplotlib support
 * ``+doc`` adds tooling for building the docs
 * ``+format`` adds support for clang-format
@@ -80,7 +85,5 @@ Including Spiner in your Project
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Spiner can be included into a cmake project, either in-tree as a
-submodule or after installation. The cmake system provides
-``spiner::flags`` and ``spiner::libs`` cmake targets. The former adds
-appropriate compilation flags, the latter adds link flags for
-dependencies such as hdf5.
+submodule or after installation via ``find_package``.
+The cmake system provides the ``spiner::spiner`` cmake target.

installtest/.gitignore

@@ -0,0 +1 @@
+build

installtest/CMakeLists.txt

@@ -0,0 +1,47 @@
+#------------------------------------------------------------------------------#
+# © 2021-2022. Triad National Security, LLC. All rights reserved.  This
+# program was produced under U.S. Government contract 89233218CNA000001
+# for Los Alamos National Laboratory (LANL), which is operated by Triad
+# National Security, LLC for the U.S.  Department of Energy/National
+# Nuclear Security Administration. All rights in the program are
+# reserved by Triad National Security, LLC, and the U.S. Department of
+# Energy/National Nuclear Security Administration. The Government is
+# granted for itself and others acting on its behalf a nonexclusive,
+# paid-up, irrevocable worldwide license in this material to reproduce,
+# prepare derivative works, distribute copies to the public, perform
+# publicly and display publicly, and to permit others to do so.
+#------------------------------------------------------------------------------#
+
+cmake_minimum_required(VERSION 3.14)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_EXPORT_COMPILE_COMMANDS On)
+
+project(spiner-cmake-test)
+
+# Don't allow in-source builds
+file(TO_CMAKE_PATH "${PROJECT_BINARY_DIR}/CMakeLists.txt" LOC_PATH)
+if(EXISTS "${LOC_PATH}")
+  message(FATAL_ERROR
+    "You cannot build in a source directory (or any directory with a CMakeLists.txt file). "
+    "Please make a build subdirectory. Feel free to remove CMakeCache.txt and CMakeFiles.")
+endif()
+
+find_package(spiner CONFIG REQUIRED)
+if (NOT spiner_FOUND)
+  message(FATAL_ERROR "Spiner not found.")
+endif()
+
+if (TARGET spiner::spiner)
+  message(STATUS "The spiner library was succesfully provided")
+  get_target_property(_sp_incdir spiner::spiner INTERFACE_INCLUDE_DIRECTORIES)
+  message(STATUS "ports of call include directory: ${_sp_incdir}")
+else()
+  message(FATAL_ERROR "The spiner library is missing!")
+endif()
+
+add_library(mytest libtest.cpp)
+target_link_libraries(mytest
+  PRIVATE
+  spiner::spiner
+  )

installtest/libtest.cpp

@@ -0,0 +1,7 @@
+// checks if compiler can find the poc header files
+#include <spiner/databox.hpp>
+
+int main(){
+  // TODO: add some library checks
+  return 0;
+}

ports-of-call

@@ -0,0 +1,30 @@
+# Spackage for Ports of Call
+
+from spack import *
+
+class PortsOfCall(CMakePackage, CudaPackage):
+    """ports-of-call"""
+
+    homepage    = "https://github.com/lanl/ports-of-call"
+    url         = "https://github.com/lanl/ports-of-call/archive/refs/heads/main.zip"
+    git         = "git@github.com:lanl/ports-of-call.git"
+
+    version("main", branch="main")
+    variant("doc", default=False, description="Sphinx Documentation Support")
+    variant("portability_strategy", description="Portability strategy backend",
+            values=("Kokkos","Cuda","None"),multi=False,default="Kokkos",
+            when="^kokkos")
+    variant("portability_strategy", description="Portability strategy backend",
+            values=("Kokkos","Cuda","None"),multi=False,default="None")
+
+    depends_on("cmake@3.12:")
+
+    depends_on("py-sphinx", when="+doc")
+    depends_on("py-sphinx-rtd-theme@0.4.3", when="+doc")
+    depends_on("py-sphinx-multiversion", when="+doc")
+
+    def cmake_args(self):
+        args = [
+            self.define_from_variant("PORTABILITY_STRATEGY", "portability_strategy")
+        ]
+        return args