Add libenvpp integration and improve thread/environment handling

Integrated libenvpp library to enhance environment variable parsing and validation. Refactored thread control logic with libenvpp and adjusted related tests and CMake configurations to support the new library. Removed outdated util test files and added necessary dependencies in build scripts.

Author: allnes

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "3rdparty/json"]
 	path = 3rdparty/json
 	url = https://github.com/nlohmann/json
+[submodule "3rdparty/libenvpp"]
+	path = 3rdparty/libenvpp
+	url = https://github.com/ph3at/libenvpp

3rdparty/libenvpp

@@ -30,6 +30,7 @@ include(cmake/configure.cmake)
 include(cmake/modes.cmake)
 include(cmake/sanitizers.cmake)
 include(cmake/json.cmake)
+include(cmake/libenvpp.cmake)
 
 ################# Parallel programming technologies #################
 

CMakeLists.txt

@@ -0,0 +1,14 @@
+include_directories(${CMAKE_SOURCE_DIR}/3rdparty/libenvpp/include)
+include_directories(${CMAKE_SOURCE_DIR}/3rdparty/libenvpp/external/fmt/include)
+
+include(ExternalProject)
+ExternalProject_Add(ppc_libenvpp
+        SOURCE_DIR        "${CMAKE_SOURCE_DIR}/3rdparty/libenvpp"
+        PREFIX            "${CMAKE_CURRENT_BINARY_DIR}/ppc_libenvpp"
+        BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/ppc_libenvpp/build"
+        INSTALL_DIR       "${CMAKE_CURRENT_BINARY_DIR}/ppc_libenvpp/install"
+        CONFIGURE_COMMAND "${CMAKE_COMMAND}" -S "${CMAKE_SOURCE_DIR}/3rdparty/libenvpp/" -B "${CMAKE_CURRENT_BINARY_DIR}/ppc_libenvpp/build/"
+        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} -G${CMAKE_GENERATOR} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -D CMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER} -D CMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
+        BUILD_COMMAND     "${CMAKE_COMMAND}" --build "${CMAKE_CURRENT_BINARY_DIR}/ppc_libenvpp/build" --config ${CMAKE_BUILD_TYPE} --parallel
+        INSTALL_COMMAND   "${CMAKE_COMMAND}" --install "${CMAKE_CURRENT_BINARY_DIR}/ppc_libenvpp/build" --prefix "${CMAKE_CURRENT_BINARY_DIR}/ppc_libenvpp/install")

cmake/libenvpp.cmake

@@ -23,10 +23,17 @@ project(${exec_func_lib})
 add_library(${exec_func_lib} STATIC ${LIB_SOURCE_FILES})
 set_target_properties(${exec_func_lib} PROPERTIES LINKER_LANGUAGE CXX)
 
+add_dependencies(${exec_func_lib} ppc_libenvpp)
+target_link_directories(${exec_func_lib} PUBLIC "${CMAKE_BINARY_DIR}/ppc_libenvpp/install/lib")
+target_link_directories(${exec_func_lib} PUBLIC "${CMAKE_BINARY_DIR}/ppc_libenvpp/build")
+target_link_libraries(${exec_func_lib} PUBLIC fmt envpp)
+
 add_executable(${exec_func_tests} ${FUNC_TESTS_SOURCE_FILES})
+
 add_dependencies(${exec_func_tests} ppc_googletest)
 target_link_directories(${exec_func_tests} PUBLIC ${CMAKE_BINARY_DIR}/ppc_googletest/install/lib)
 target_link_libraries(${exec_func_tests} PUBLIC gtest gtest_main)
+
 if( MPI_COMPILE_FLAGS )
   set_target_properties(${exec_func_tests} PROPERTIES COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
 endif( MPI_COMPILE_FLAGS )

modules/core/CMakeLists.txt

@@ -61,4 +61,9 @@ static_assert(false, "Unsupported compiler");
   return kFunc.substr(start, end - start);
 }
 
+#include <stdbool.h>
+#include <stdlib.h>
+
+bool IsUnderMpirun();
+
 }  // namespace ppc::util

modules/core/util/func_tests/util_tests.cpp

@@ -1,33 +1,77 @@
 #include "core/util/include/util.hpp"
 
 #include <cstdlib>
-#ifdef _WIN32
 #include <cstdint>
 #include <iostream>
 #include <memory>
 #include <vector>
-#endif
-
+#include <algorithm>
+#include <array>
 #include <filesystem>
+#include <ranges>
 #include <string>
+#include <iostream>
+#include <libenvpp/env.hpp>
+
+//namespace {
+//
+//struct MpiEnvVar {
+//  std::string_view name;
+//  const char* description;
+//};
+//
+//}  // namespace
 
-std::string ppc::util::GetAbsolutePath(const std::string &relative_path) {
+std::string ppc::util::GetAbsolutePath(const std::string& relative_path) {
   const std::filesystem::path path = std::string(PPC_PATH_TO_PROJECT) + "/tasks/" + relative_path;
   return path.string();
 }
 
 int ppc::util::GetNumThreads() {
-#ifdef _WIN32
-  size_t len;
-  char omp_env[100];
-  errno_t err = getenv_s(&len, omp_env, sizeof(omp_env), "PPC_NUM_THREADS");
-  if (err != 0 || len == 0) {
-    omp_env[0] = '\0';
+  env::prefix pre("PPC");
+
+  const auto num_threads_id = pre.register_variable<unsigned>("NUM_THREADS");
+
+  auto validated = std::move(pre).parse_and_validate();
+
+  if (!validated.ok()) {
+    std::cerr << validated.warning_message() << "\n";
+//    throw validated.error_message();
   }
-  int num_threads = std::atoi(omp_env);
-#else
-  const char *omp_env = std::getenv("PPC_NUM_THREADS");  // NOLINT(concurrency-mt-unsafe)
-  int num_threads = (omp_env != nullptr) ? std::atoi(omp_env) : 1;
-#endif
-  return num_threads;
+
+  const auto num_threads = validated.get(num_threads_id);
+  return num_threads ? static_cast<int>(*num_threads) : 1;
 }
+
+//const std::array<MpiEnvVar, 13> kMpiEnvVars = {{{.name = "OMPI_COMM_WORLD_SIZE", .description = "OpenMPI"},
+//                                                {.name = "OMPI_UNIVERSE_SIZE", .description = "OpenMPI"},
+//                                                {.name = "PMI_SIZE", .description = "MPICH/Intel MPI"},
+//                                                {.name = "PMI_RANK", .description = "MPICH/Intel MPI"},
+//                                                {.name = "PMI_FD", .description = "MPICH/Intel MPI"},
+//                                                {.name = "HYDRA_CONTROL_FD", .description = "Hydra"},
+//                                                {.name = "PMIX_RANK", .description = "Cray PMI/PMIx"},
+//                                                {.name = "PMIX_NAMESPACE", .description = "Cray PMI/PMIx"},
+//                                                {.name = "SLURM_PROCID", .description = "SLURM"},
+//                                                {.name = "MPI_LOCALRANKID", .description = "IBM Spectrum MPI"},
+//                                                {.name = "MSMPI_RANK", .description = "Microsoft MPI"},
+//                                                {.name = "MSMPI_NODE_ID", .description = "Microsoft MPI"},
+//                                                {.name = "MSMPI_LOCALRANK", .description = "Microsoft MPI"}}};
+
+//bool ppc::util::IsUnderMpirun() {
+//  auto pre = env::prefix("");
+//  const auto parsed_and_validated_pre = pre.parse_and_validate();
+//  return std::ranges::any_of(kMpiEnvVars, [&](const auto& env_var) {
+//    const auto mpi_env_id = pre.register_variable<std::string>(env_var.name);
+//
+//    if (!parsed_and_validated_pre.ok()) {
+//      std::cerr << parsed_and_validated_pre.warning_message();
+//      throw parsed_and_validated_pre.error_message();
+//    }
+//
+//    if (parsed_and_validated_pre.get(mpi_env_id)) {
+//      return true;
+//    } else {
+//      return false;
+//    }
+//  });
+//}

modules/core/util/include/util.hpp

@@ -87,6 +87,8 @@ def run_threads(self):
             self.__run_exec(f"{self.work_dir / 'ppc_func_tests'} {self.__get_gtest_settings(3, '_' + task_type + '_')}")
 
     def run_core(self):
+        self.__run_exec(f"{self.work_dir / 'ppc_func_tests'} {self.__get_gtest_settings(1, '_common')}")
+
         if platform.system() == "Linux" and not self.__ppc_env.get("PPC_ASAN_RUN"):
             self.__run_exec(f"{self.valgrind_cmd} {self.work_dir / 'core_func_tests'} "
                             f"{self.__get_gtest_settings(1, '*')} --gtest_filter=*:-*_death_test")
@@ -123,8 +125,8 @@ def run_performance_list(self):
     ppc_runner = PPCRunner()
     ppc_runner.setup_env(os.environ.copy())
 
-    # if args_dict["running_type"] in ["threads", "processes"]:
-    #     ppc_runner.run_core()
+    if args_dict["running_type"] in ["threads", "processes"]:
+        ppc_runner.run_core()
 
     if args_dict["running_type"] == "threads":
         ppc_runner.run_threads()

modules/core/util/src/util.cpp

@@ -7,7 +7,8 @@ set(exec_perf_tests "ppc_perf_tests")
 # Init func tests executable files
 set(list_of_exec_tests "")
 if (USE_FUNC_TESTS)
-    add_executable(${exec_func_tests} "${CMAKE_CURRENT_SOURCE_DIR}/common/runners/functional.cpp")
+    add_executable(${exec_func_tests} "${CMAKE_CURRENT_SOURCE_DIR}/common/runners/functional.cpp"
+            "${CMAKE_CURRENT_SOURCE_DIR}/common/tests/util.cpp")
     list(APPEND list_of_exec_tests ${exec_func_tests})
 endif (USE_FUNC_TESTS)
 
@@ -38,7 +39,10 @@ add_library(stb_image INTERFACE)
 
 foreach (exec_func ${list_of_exec_tests})
     target_link_libraries(${exec_func} PUBLIC Threads::Threads)
-    target_link_libraries(${exec_func} PUBLIC ${OpenMP_libomp_LIBRARY})
+
+    find_package(OpenMP REQUIRED)
+    target_link_libraries(${exec_func} PUBLIC ${OpenMP_libomp_LIBRARY} OpenMP::OpenMP_CXX)
+
     if( MPI_COMPILE_FLAGS )
         set_target_properties(${exec_func} PROPERTIES COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
     endif( MPI_COMPILE_FLAGS )
@@ -51,7 +55,11 @@ foreach (exec_func ${list_of_exec_tests})
     add_dependencies(${exec_func} ppc_onetbb)
     target_link_directories(${exec_func} PUBLIC ${CMAKE_BINARY_DIR}/ppc_onetbb/install/lib)
     if(NOT MSVC)
-        target_link_libraries(${exec_func} PUBLIC tbb)
+        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+            target_link_libraries(${exec_func} PUBLIC tbb_debug)
+        else()
+            target_link_libraries(${exec_func} PUBLIC tbb)
+        endif()
     endif()
 
     target_link_directories(stb_image INTERFACE ${CMAKE_SOURCE_DIR}/3rdparty/stb)
@@ -64,6 +72,11 @@ foreach (exec_func ${list_of_exec_tests})
     add_dependencies(${exec_func} ppc_json)
     target_link_directories(${exec_func} INTERFACE "${CMAKE_BINARY_DIR}/ppc_json/install/include")
 
+    add_dependencies(${exec_func} ppc_libenvpp)
+    target_link_directories(${exec_func} PUBLIC "${CMAKE_BINARY_DIR}/ppc_libenvpp/install/lib")
+    target_link_directories(${exec_func} PUBLIC "${CMAKE_BINARY_DIR}/ppc_libenvpp/build")
+    target_link_libraries(${exec_func} PUBLIC fmt envpp)
+
     enable_testing()
     add_test(NAME ${exec_func} COMMAND ${exec_func})