Draft: CMake improvements

CMakeLists.txt

@@ -6,139 +6,215 @@ project(codes LANGUAGES C CXX VERSION 2.0)
 include(CMakePrintHelpers)
 cmake_print_variables(CMAKE_CURRENT_SOURCE_DIR)
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/src/cmake/")
-cmake_print_variables(CMAKE_MODULE_PATH)
-
 set(CMAKE_INSTALL_PREFIX "${PROJECT_BINARY_DIR}" CACHE PATH "Where to install CODES")
 
-set(CMAKE_CXX_STANDARD 11)
+# C++17 is the project-wide baseline (was previously only enabled when Torch
+# was found). Required, no compiler extensions, so the build is portable
+# across gcc/clang/AppleClang.
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_CXX_EXTENSIONS OFF)
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED True)
 
+# Build CODES's own targets with -Wundef so the generated config-header feature
+# macros (CODES_HAVE_<X>, always 0/1 — see codes_config.h.cmake.in) flag a
+# forgotten `#include "codes_config.h"` or a typo'd name as a warning instead of
+# a silently-disabled feature. Applies only to this project's compiles, not to
+# consumers; ROSS/MPI headers arrive via -isystem and are exempt.
+add_compile_options(-Wundef)
+
+# Optional gcov/--coverage instrumentation, applied to the `codes` target (and
+# propagated to the binaries/tests that link it) in src/CMakeLists.txt. Off by
+# default; the coverage CI job turns it on. gcc/clang only.
+option(CODES_ENABLE_COVERAGE "Instrument the codes library with --coverage (gcov)" OFF)
+
 #prevent cmake from stripping the runtime path (important if shared libraries are imported)
 SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
 
-set(ROSS_PKG_CONFIG_PATH "" CACHE PATH "Where is ROSS PKG_CONFIG is installed?")
 set(SWM_PKG_CONFIG_PATH "" CACHE PATH "Where is the SWM PKG_CONFIG installed?")
 set(UNION_PKG_CONFIG_PATH "" CACHE PATH "Where is the Union PKG_CONFIG installed?")
 set(ARGOBOTS_PKG_CONFIG_PATH "" CACHE PATH "Where is argobots PKG_COPNFIG installed? Necessary for SWM")
-set(DAMARIS_PKG_CONFIG_PATH "" CACHE PATH "Where is the damaris PKG_CONFIG installed?")
 
 
+# ROSS — modern CMake-config discovery. find_package(ROSS) resolves
+# <prefix>/lib/cmake/ROSS/ROSSConfig.cmake; point CMAKE_PREFIX_PATH at the
+# ROSS install prefix. The ROSS::ROSS imported target carries the include
+# dirs, the MPI dependency, and link libraries (linked in src/CMakeLists.txt).
+find_package(ROSS CONFIG REQUIRED)
+
+# PkgConfig still discovers the optional SWM/UNION/ARGOBOTS deps below
+# (modernized to imported targets in a later step); their *_PKG_CONFIG_PATH
+# cache vars feed PKG_CONFIG_PATH here.
 find_package(PkgConfig REQUIRED)
-set(ENV{PKG_CONFIG_PATH} "${ROSS_PKG_CONFIG_PATH}:${SWM_PKG_CONFIG_PATH}:${UNION_PKG_CONFIG_PATH}:${ARGOBOTS_PKG_CONFIG_PATH}")
-pkg_check_modules(ROSS REQUIRED IMPORTED_TARGET ross)
-
-# MPI
-include(SetupMPI)
-if(MPI_C_FOUND)
-        include_directories(${MPI_C_INCLUDE_PATH})
-        list(APPEND CODES_EXTERNAL_LIBS ${MPI_C_LIBRARIES})
-else(MPI_C_FOUND)
-        message("WARNING: Could not find MPI!")
-        message("         Either add an MPI compiler to your path (using modules)")
-        message("         Or force CMake to build using the correct compiler (`export CC=mpicc`)")
-endif(MPI_C_FOUND)
-
-
-## DUMPI
+set(ENV{PKG_CONFIG_PATH} "${SWM_PKG_CONFIG_PATH}:${UNION_PKG_CONFIG_PATH}:${ARGOBOTS_PKG_CONFIG_PATH}")
+
+# MPI — modern imported-target discovery. find_package(MPI) provides the
+# MPI::MPI_C / MPI::MPI_CXX imported targets, which carry the include dirs,
+# compile flags, and link libraries; targets link them directly (see
+# src/CMakeLists.txt). No need to set CC=mpicc — FindMPI locates the wrapper
+# compiler automatically and derives the flags from it.
+find_package(MPI REQUIRED)
+
+
+# ============================================================================
+# Optional dependencies — tri-state CODES_USE_<X> (AUTO / ON / OFF)
+# ----------------------------------------------------------------------------
+#   AUTO : probe; enable if found, disable quietly if not.
+#   ON   : probe; hard error if not found.
+#   OFF  : don't probe; feature disabled.
+# Each resolves to an internal USE_<X> bool (names unchanged) consumed by
+# src/CMakeLists.txt and the C sources' #if sites.
+# ============================================================================
+
 set(DUMPI_BUILD_PATH "" CACHE PATH "Directory where dumpi include and lib are installed")
-find_library(DUMPI_LIB undumpi PATHS ${DUMPI_BUILD_PATH}/lib)
-if(NOT DUMPI_LIB)
-        message(STATUS "Undumpi library not found, DUMPI trace workloads disabled")
-        unset(USE_DUMPI)
-else(DUMPI_LIB)
-        message(STATUS "Undumpi library found ${DUMPI_LIB}")
-        set(DUMPI_INCLUDE "${DUMPI_BUILD_PATH}/include" CACHE PATH "Dumpi library include")
-        set(DUMPI_CFLAGS "-I${DUMPI_INCLUDE}")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DUMPI_CFLAGS}")
-        add_definitions(-DUSE_DUMPI=1)
-        set(USE_DUMPI true)
-endif()
+set(ZEROMQ_BUILD_PATH "" CACHE PATH "Directory containing libzmqmlrequester.so (for CODES_USE_ZEROMQ)")
+
+set(CODES_USE_DUMPI    AUTO CACHE STRING "DUMPI trace workloads (AUTO/ON/OFF)")
+set(CODES_USE_SWM      AUTO CACHE STRING "SWM online workloads; requires argobots (AUTO/ON/OFF)")
+set(CODES_USE_UNION    AUTO CACHE STRING "UNION online workloads; implies SWM (AUTO/ON/OFF)")
+set(CODES_USE_RECORDER AUTO CACHE STRING "Recorder I/O workload, no external dep (AUTO/ON/OFF)")
+set(CODES_USE_TORCH    AUTO CACHE STRING "Torch ML models (AUTO/ON/OFF)")
+set(CODES_USE_DARSHAN  OFF  CACHE STRING "Darshan I/O workload — not yet wired (AUTO/ON/OFF)")
+set(CODES_USE_ZEROMQ   AUTO CACHE STRING "ZeroMQ director-client surrogate; needs ZEROMQ_BUILD_PATH (AUTO/ON/OFF)")
+foreach(_dep DUMPI SWM UNION RECORDER TORCH DARSHAN ZEROMQ)
+    set_property(CACHE CODES_USE_${_dep} PROPERTY STRINGS AUTO ON OFF)
+endforeach()
+
+# Back-compat: the pre-rename option names map onto CODES_USE_* for one
+# deprecation cycle. Remove once downstream invocations have migrated.
+foreach(_old TORCH RECORDER)
+    if(DEFINED USE_${_old})
+        message(WARNING "USE_${_old} is deprecated; use CODES_USE_${_old} (AUTO/ON/OFF).")
+        if(USE_${_old})
+            set(CODES_USE_${_old} ON CACHE STRING "" FORCE)
+        else()
+            set(CODES_USE_${_old} OFF CACHE STRING "" FORCE)
+        endif()
+    endif()
+endforeach()
+
+# Resolve a tri-state CODES_USE_<name> against a probe result (found = a path,
+# a *_FOUND var, or a bool). Sets the internal ${out_var} bool in the caller.
+function(codes_resolve_dep name found out_var)
+    if(CODES_USE_${name} STREQUAL "OFF")
+        set(${out_var} FALSE PARENT_SCOPE)
+    elseif(found)
+        set(${out_var} TRUE PARENT_SCOPE)
+    elseif(CODES_USE_${name} STREQUAL "ON")
+        message(FATAL_ERROR "CODES_USE_${name}=ON but ${name} could not be found/enabled.")
+    else()
+        set(${out_var} FALSE PARENT_SCOPE)
+    endif()
+endfunction()
 
-# SWM and UNION (both require ARGOBOTS to function)
-pkg_check_modules(SWM IMPORTED_TARGET swm)
-if(NOT SWM_FOUND)
-    message(STATUS "SWM Library Not Found, Online workloads disabled")
 
-else(SWM_FOUND)
-    message(STATUS "SWM Library Found: ${SWM_LIBRARIES}")
-    pkg_check_modules(ARGOBOTS REQUIRED IMPORTED_TARGET argobots)
-    if(NOT ARGOBOTS_FOUND)
-        message(STATUS "Argobots Library Not Found, Online workloads disabled")
+## DUMPI — trace workloads
+if(NOT CODES_USE_DUMPI STREQUAL "OFF")
+    find_library(DUMPI_LIB undumpi PATHS ${DUMPI_BUILD_PATH}/lib)
+endif()
+codes_resolve_dep(DUMPI "${DUMPI_LIB}" USE_DUMPI)
+if(USE_DUMPI)
+    message(STATUS "DUMPI trace workloads enabled (${DUMPI_LIB})")
+    set(DUMPI_INCLUDE "${DUMPI_BUILD_PATH}/include" CACHE PATH "Dumpi library include")
+else()
+    message(STATUS "DUMPI trace workloads disabled")
+endif()
 
-    else(ARGOBOTS_FOUND)
-        message(STATUS "Argobots Library Found: ${ARGOBOTS_LIBRARIES}")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARGOBOTS_CFLAGS} -I${ARGOBOTS_INCLUDE}")
 
-        pkg_get_variable(SWM_DATAROOTDIR swm datarootdir)
-        cmake_print_variables(SWM_DATAROOTDIR)
+## SWM / UNION — online workloads (UNION ⇒ SWM ⇒ argobots)
+set(_swm_ok FALSE)
+if(NOT CODES_USE_SWM STREQUAL "OFF")
+    pkg_check_modules(SWM IMPORTED_TARGET swm)
+    if(SWM_FOUND)
+        pkg_check_modules(ARGOBOTS IMPORTED_TARGET argobots)
+        if(ARGOBOTS_FOUND)
+            set(_swm_ok TRUE)
+        endif()
+    endif()
+endif()
+codes_resolve_dep(SWM "${_swm_ok}" USE_ONLINE)
 
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SWM_CFLAGS} -I${SWM_INCLUDE}")
-        add_definitions(-DUSE_ONLINE=1)
-        set(USE_ONLINE true)
+if(USE_ONLINE)
+    message(STATUS "SWM online workloads enabled (${SWM_LIBRARIES})")
+    pkg_get_variable(SWM_DATAROOTDIR swm datarootdir)
 
+    set(_union_found FALSE)
+    if(NOT CODES_USE_UNION STREQUAL "OFF")
         pkg_check_modules(UNION IMPORTED_TARGET union)
-        if(NOT UNION_FOUND)
-            message(STATUS "UNION Library Not Found, SWM-only online workloads enabled")
-            add_definitions(-DUSE_SWM=1)
-            set(USE_SWM true)
-        else(UNION_FOUND)
-            message(STATUS "UNION Library Found: ${UNION_LIBRARIES}")
-            pkg_get_variable(UNION_DATAROOTDIR union datarootdir)
-            cmake_print_variables(UNION_DATAROOTDIR)
-
-            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${UNION_INCLUDE}")
-            foreach(INCLUDE_OPT ${UNION_CFLAGS})
-                set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${INCLUDE_OPT}")
-            endforeach()
-
-            add_definitions(-DUSE_UNION=1)
-            set(USE_UNION true)
-        endif()
+        set(_union_found ${UNION_FOUND})
+    endif()
+    codes_resolve_dep(UNION "${_union_found}" USE_UNION)
+    if(USE_UNION)
+        message(STATUS "UNION online workloads enabled (${UNION_LIBRARIES})")
+        pkg_get_variable(UNION_DATAROOTDIR union datarootdir)
+    else()
+        set(USE_SWM TRUE)
+    endif()
+else()
+    message(STATUS "SWM/UNION online workloads disabled")
+    if(CODES_USE_UNION STREQUAL "ON")
+        message(FATAL_ERROR "CODES_USE_UNION=ON requires SWM/online (set CODES_USE_SWM and provide SWM+argobots).")
     endif()
 endif()
 
 
-## RECORDER
-option(USE_RECORDER "use recorder io workload" ON)
-if(USE_RECORDER)
-        add_definitions(-DUSE_RECORDER=1)
-endif()
+## RECORDER — built-in I/O workload, no external dependency
+codes_resolve_dep(RECORDER TRUE USE_RECORDER)
 
-## DARSHAN
-
-
-## DAMARIS
-# pkg_check_modules(DAMARIS IMPORTED_TARGET)
-# if(NOT DAMARIS_FOUND)
-#         message(STATUS "DAMARIS Library not found, Damaris disabled")
-# else(DAMARIS_FOUND)
-#         set(USE_DAMARIS true)
-# endif()
-
-## TORCH loading ML models
-if((NOT DEFINED USE_TORCH) OR USE_TORCH)
-    find_package(Torch)
-    if(Torch_FOUND)
-        set(CMAKE_CXX_STANDARD 17)
-        add_definitions(-DUSE_TORCH)
-        set(USE_TORCH true)
-        message(STATUS "Loading TORCH models enabled.")
-    else()
-        set(USE_TORCH false)
-        message(STATUS "Torch library not found. Loading TORCH models disabled.")
-    endif()
+
+## DARSHAN — stub: the probe + the commented darshan source in src/ aren't
+## wired up yet, so this resolves OFF today (CODES_USE_DARSHAN=ON errors).
+codes_resolve_dep(DARSHAN FALSE USE_DARSHAN)
+
+
+## TORCH — ML models
+if(NOT CODES_USE_TORCH STREQUAL "OFF")
+    find_package(Torch QUIET)
+endif()
+codes_resolve_dep(TORCH "${Torch_FOUND}" USE_TORCH)
+if(USE_TORCH)
+    message(STATUS "Torch ML models enabled")
 else()
-    message(STATUS "Loading TORCH models NOT enabled.")
+    message(STATUS "Torch ML models disabled")
+endif()
+
+
+## ZeroMQ — director-client surrogate (opt-in; needs ZEROMQ_BUILD_PATH).
+## "found" = a build path was provided; the imported target + linkage live in
+## src/CMakeLists.txt, gated on the internal USE_ZEROMQ bool.
+if(CODES_USE_ZEROMQ STREQUAL "ON" AND NOT ZEROMQ_BUILD_PATH)
+    message(FATAL_ERROR
+        "CODES_USE_ZEROMQ=ON requires ZEROMQ_BUILD_PATH. Build "
+        "src/surrogate/zmqml/libzmqmlrequester.so first, then reconfigure with "
+        "-DZEROMQ_BUILD_PATH=<dir containing the .so>.")
+endif()
+set(_zeromq_found FALSE)
+if(ZEROMQ_BUILD_PATH)
+    set(_zeromq_found TRUE)
+endif()
+codes_resolve_dep(ZEROMQ "${_zeromq_found}" USE_ZEROMQ)
+if(USE_ZEROMQ)
+    message(STATUS "ZeroMQ director-client surrogate enabled (${ZEROMQ_BUILD_PATH})")
 endif()
 
-cmake_print_variables(CMAKE_C_FLAGS)
 add_subdirectory(src)
 
 
+# Feature-availability macros consumed by codes_config.h.cmake.in. CODES_HAVE_<X>
+# mirrors the resolved USE_<X> bool; #cmakedefine emits the #define only when set.
+# This replaces the old -DUSE_<X> command-line defines: feature state now lives in
+# the namespaced, installed codes_config.h instead of leaking onto compile lines.
+set(CODES_HAVE_DUMPI    ${USE_DUMPI})
+set(CODES_HAVE_ONLINE   ${USE_ONLINE})
+set(CODES_HAVE_SWM      ${USE_SWM})
+set(CODES_HAVE_UNION    ${USE_UNION})
+set(CODES_HAVE_RECORDER ${USE_RECORDER})
+set(CODES_HAVE_TORCH    ${USE_TORCH})
+set(CODES_HAVE_ZEROMQ   ${USE_ZEROMQ})
+set(CODES_HAVE_DARSHAN  ${USE_DARSHAN})
+
 configure_file(codes_config.h.cmake.in codes_config.h)
 
 add_subdirectory(doc/example)

CODES-compile-instructions.sh

@@ -133,8 +133,8 @@ else
 fi
 # ---- end CODES CUDA arch autodetection ----
 
-cmake .. -DCMAKE_C_COMPILER=mpicc -DCMAKE_CXX_COMPILER=mpicxx -DROSS_BUILD_MODELS=ON -DCMAKE_INSTALL_PREFIX="$(realpath ./bin)" \
-  -DCMAKE_C_COMPILER=mpicc -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_FLAGS="-g -Wall"
+cmake .. -DROSS_BUILD_MODELS=ON -DCMAKE_INSTALL_PREFIX="$(realpath ./bin)" \
+  -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_FLAGS="-g -Wall"
 #make VERBOSE=1
 make install -j4
 err=$?
@@ -358,7 +358,6 @@ fi
 
 make_args_codes=(
     -DCMAKE_PREFIX_PATH="${cmake_prefix_path}"
-    -DCMAKE_CXX_COMPILER=mpicxx -DCMAKE_C_COMPILER=mpicc
     -DCMAKE_C_FLAGS="-g -Wall"
     -DCMAKE_CXX_FLAGS="-g -Wall"
     -DTHREADS_PREFER_PTHREAD_FLAG=ON
@@ -368,7 +367,7 @@ make_args_codes=(
     -DCMAKE_USE_WIN32_THREADS_INIT=0
     -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=ON
     -DCMAKE_INSTALL_PREFIX="$(realpath bin)"
-    -DZMQML_BUILD_PATH="$(realpath "$CUR_DIR/codes/src/surrogate/zmqml")"
+    -DZEROMQ_BUILD_PATH="$(realpath "$CUR_DIR/codes/src/surrogate/zmqml")"
     -DZeroMQ_INCLUDE_DIR=/usr/include
     -DZeroMQ_LIBRARY=/usr/lib/x86_64-linux-gnu/libzmq.so
 )
@@ -388,7 +387,7 @@ fi
 if [ "$torch_enable" = 1 ]; then
     make_args_codes=(
         "${make_args_codes[@]}"
-        -DUSE_TORCH=true
+        -DCODES_USE_TORCH=ON
         -DTorch_DIR="${torch_dir}"
     )
 
@@ -412,7 +411,7 @@ if [ "$torch_enable" = 1 ]; then
         )
     fi
 else
-    make_args_codes=("${make_args_codes[@]}" -DUSE_TORCH=false)
+    make_args_codes=("${make_args_codes[@]}" -DCODES_USE_TORCH=OFF)
 fi
 
 cmake .. "${make_args_codes[@]}"

README.md

@@ -53,8 +53,6 @@ cd codes && mkdir build && cd build
 # 3. Configure with CMake
 cmake .. \
   -DCMAKE_PREFIX_PATH=$HOME/ross \
-  -DCMAKE_C_COMPILER=mpicc \
-  -DCMAKE_CXX_COMPILER=mpicxx \
   -DCMAKE_BUILD_TYPE=Debug \
   -DBUILD_TESTING=ON
 
@@ -63,6 +61,11 @@ make -j
 ctest
 ```
 
+MPI is auto-discovered via `find_package(MPI)` — do **not** set `CC=mpicc` or
+`-DCMAKE_C_COMPILER=mpicc`. Just make sure an MPI implementation is installed and
+its wrapper (`mpicc`) is on your `PATH` (e.g. `module load mpich`). For a
+non-standard install, hint with `-DMPI_HOME=/path/to/mpi`.
+
 ## Testing
 
 Check your installation with: