Implement checkpoint/restart for RBC

CMake/HemeLbOptions.cmake

@@ -17,7 +17,7 @@ pass_group_declare(HEMELB)
 pass_option(HEMELB HEMELB_CALLGRIND "Compile unit tests that use callgrind" OFF)
 pass_option(HEMELB HEMELB_USE_KRUEGER_ORDERING "Use Krueger's LB-IBM algorithm reodering" ON)
 pass_option(HEMELB HEMELB_BUILD_DEBUGGER "Build the built in debugger" ON)
-pass_option(HEMELB HEMELB_BUILD_COLLOIDS "Build the colloids option" OFF)
+pass_option(HEMELB HEMELB_BUILD_COLLOIDS "Build the UNMAINTAINED colloids option" OFF)
 # pass_option(HEMELB HEMELB_DEBUGGER_IMPLEMENTATION "Which implementation to use for the debugger" none)
 # mark_as_advanced(HEMELB_DEBUGGER_IMPLEMENTATION)
 pass_option(HEMELB HEMELB_VALIDATE_GEOMETRY "Validate geometry" OFF)
@@ -99,5 +99,5 @@ pass_var(HEMELB METIS_INCLUDE_DIR)
 pass_var(HEMELB METIS_LIBRARY)
 pass_var(HEMELB ParMETIS_INCLUDE_DIR)
 pass_var(HEMELB ParMETIS_LIBRARY)
-pass_var(HEMELB TINYXML_INCLUDE_DIR)
-pass_var(HEMELB TINYXML_LIBRARIES)
+pass_var(HEMELB TINYXML2_INCLUDE_DIR)
+pass_var(HEMELB TINYXML2_LIBRARIES)

CMake/PassOptions.cmake

@@ -32,23 +32,54 @@ function(pass_option GROUP NAME DESC DEFAULT)
 endfunction()
 
 
+# Types for the cachevar functions below are the allowed CMake types
+# (BOOL, FILEPATH, PATH, STRING, INTERNAL) plus INT.
+# These helpers convert from these to supported types in CMake/C++.
+
+# Note that std::filesystem::path is not constexpr so use ct_string for those
+function(_pass_type_to_cpp type out_type out_val)
+  if (type STREQUAL "INT")
+    set(${out_type} "int" PARENT_SCOPE)
+    set(${out_val} "\${${NAME}}" PARENT_SCOPE)
+  elseif (type STREQUAL "BOOL")
+    set(${out_type} "bool" PARENT_SCOPE)
+    set(${out_val} "\${${NAME}}" PARENT_SCOPE)
+  else()
+    set(${out_type} "ct_string" PARENT_SCOPE)
+    set(${out_val} "\"\${${NAME}}\"" PARENT_SCOPE)
+  endif()
+endfunction()
+
+# CMake doesn't do numbers, use string
+function(_pass_type_to_cachevar type outvar)
+  if (type STREQUAL "INT")
+    set(${outvar} "STRING" PARENT_SCOPE)
+  else()
+    set(${outvar} ${type} PARENT_SCOPE)
+  endif()
+endfunction()
+
 #
 # Declare a cache variable
 #
 function(pass_cachevar GROUP NAME DEFAULT TYPE DESC)
-  set(${NAME} ${DEFAULT} CACHE ${TYPE} ${DESC})
+  _pass_type_to_cachevar(${TYPE} cache_type)
+  set(${NAME} ${DEFAULT} CACHE ${cache_type} ${DESC})
   set(_${GROUP}_CACHEVARS "${_${GROUP}_CACHEVARS};${NAME}" PARENT_SCOPE)
   string(REPLACE "HEMELB_" "" BASENAME "${NAME}")
-  set(_${GROUP}_CLSDEFN "${_${GROUP}_CLSDEFN}        static constexpr ct_string ${BASENAME} = \"\${${NAME}}\";
+  _pass_type_to_cpp(${TYPE} cpp_type cpp_val)
+  set(_${GROUP}_CLSDEFN "${_${GROUP}_CLSDEFN}        static constexpr ${cpp_type} ${BASENAME} = ${cpp_val};
 " PARENT_SCOPE)
 endfunction()
 
 function(pass_cachevar_choice GROUP NAME DEFAULT TYPE DESC)
   # ${ARGN} holds the choices
-  set(${NAME} ${DEFAULT} CACHE ${TYPE} ${DESC})
+  _pass_type_to_cachevar(${TYPE} cache_type)
+  set(${NAME} ${DEFAULT} CACHE ${cache_type} ${DESC})
   set(_${GROUP}_CACHEVARS "${_${GROUP}_CACHEVARS};${NAME}" PARENT_SCOPE)
   string(REPLACE "HEMELB_" "" BASENAME "${NAME}")
-  set(_${GROUP}_CLSDEFN "${_${GROUP}_CLSDEFN}        static constexpr ct_string ${BASENAME} = \"\${${NAME}}\";
+  _pass_type_to_cpp(${TYPE} cpp_type cpp_val)
+  set(_${GROUP}_CLSDEFN "${_${GROUP}_CLSDEFN}        static constexpr ${cpp_type} ${BASENAME} = ${cpp_val};
 " PARENT_SCOPE)
   set_property(CACHE ${NAME} PROPERTY STRINGS ${ARGN})
 endfunction()

Code/CMakeLists.txt

@@ -23,16 +23,11 @@ include(HemeLbOptions)
 
 # Add warnings flags to development build types
 if (HEMELB_USE_ALL_WARNINGS_GNU)
-  set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
   set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall")
 endif()
 
+# Definitions that are should be globally available
 add_definitions(-DHEMELB_CODE)
-add_definitions(-DHEMELB_COMPUTE_ARCHITECTURE=${HEMELB_COMPUTE_ARCHITECTURE})
-
-if(HEMELB_VALIDATE_GEOMETRY)
-  add_definitions(-DHEMELB_VALIDATE_GEOMETRY)
-endif()
 
 if (HEMELB_USE_SSE3)
   add_definitions(-DHEMELB_USE_SSE3)
@@ -47,33 +42,27 @@ if (HEMELB_CALLGRIND)
   add_definitions(-DHEMELB_CALLGRIND)
 endif()
 
-if (HEMELB_USE_VELOCITY_WEIGHTS_FILE)
-  add_definitions(-DHEMELB_USE_VELOCITY_WEIGHTS_FILE)
-endif()
-
-if (HEMELB_USE_KRUEGER_ORDERING)
-  add_definitions(-DHEMELB_USE_KRUEGER_ORDERING)
-endif()
-
 list(APPEND CMAKE_PREFIX_PATH ${HEMELB_DEPENDENCIES_INSTALL_PREFIX})
-# list(APPEND CMAKE_INCLUDE_PATH ${HEMELB_DEPENDENCIES_INSTALL_PREFIX}/include)
-# list(APPEND CMAKE_LIBRARY_PATH ${HEMELB_DEPENDENCIES_INSTALL_PREFIX}/lib)
 
 #--- Set up runtime search path for DLLs -----
 if(HEMELB_DEPENDENCIES_SET_RPATH)
-  SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-  SET(CMAKE_INSTALL_RPATH "${HEMELB_DEPENDENCIES_INSTALL_PREFIX}/lib")
+  set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+  set(CMAKE_INSTALL_RPATH "${HEMELB_DEPENDENCIES_INSTALL_PREFIX}/lib")
 endif()
 
 include(build_environment)
 include(platform_checks)
 include(codesign)
-include(mpi)
 include(HemeLbDependency)
 
-find_hemelb_dependency(Boost REQUIRED)
-find_hemelb_dependency(TinyXML REQUIRED)
+# We do NOT want the removed MPI 2 C++ bindings
+# Requesting MPI 3 should be enough, but some configurations of
+# e.g. OpenMPI enable them for C++ by default to be "helpful".
+set(MPI_CXX_SKIP_MPICXX ON)
+find_package(MPI 3 REQUIRED CXX)
 
+find_hemelb_dependency(Boost REQUIRED)
+find_hemelb_dependency(tinyxml2 REQUIRED)
 find_hemelb_dependency(ParMETIS REQUIRED)
 find_hemelb_dependency(CTemplate REQUIRED)
 find_hemelb_dependency(ZLIB REQUIRED)
@@ -129,14 +118,13 @@ configure_file(build_info.h.in build_info.h)
 include_directories("${PROJECT_BINARY_DIR}")
 
 # ----------- HemeLB ------------------
-if (APPLE)
-  add_definitions(-DHEMELB_CFG_ON_BSD -DHEMELB_CFG_ON_OSX)
-endif()
 if (HEMELB_USE_DEBUGGER)
   # Force a debug build, because the debugger makes no sense without debug symbols
   set(CMAKE_BUILD_TYPE Debug)
 endif()
 
+add_library(hemelb_sim OBJECT SimulationController.cc)
+list(APPEND heme_libraries hemelb_sim)
 add_executable(${HEMELB_EXECUTABLE} main.cc)
 codesign(${HEMELB_EXECUTABLE})