Adapt last HPX modules of the HPX core library to C++ modules

Signed-off-by: Hartmut Kaiser <hartmut.kaiser@gmail.com>

Author: hkaiser

libs/CMakeLists.txt

@@ -152,7 +152,9 @@ set(_is_library "$<IN_LIST:$<TARGET_PROPERTY:TYPE>,${_library_types}>")
 add_library(hpx INTERFACE)
 add_library(init INTERFACE)
 add_library(wrap_main INTERFACE)
-add_library(auto_wrap_main INTERFACE)
+if(NOT MSVC)
+  add_library(auto_wrap_main INTERFACE)
+endif()
 
 target_link_libraries(hpx INTERFACE hpx_full)
 

libs/core/async_mpi/include/hpx/async_mpi/mpi_future.hpp

@@ -44,22 +44,25 @@ namespace hpx::mpi::experimental {
 
     // by convention the title is 7 chars (for alignment)
     HPX_CXX_EXPORT using print_on = debug::enable_print<false>;
-    HPX_CXX_EXPORT static constexpr print_on mpi_debug("MPI_FUT");
+    HPX_CXX_EXPORT inline constexpr print_on mpi_debug("MPI_FUT");
 
     namespace detail {
 
         HPX_CXX_EXPORT using mutex_type = hpx::spinlock;
 
         // mutex needed to protect mpi request vector, note that the
         // mpi poll function takes place inside the main scheduling loop
-        // of hpx and not on an hpx worker thread, so we must use std:mutex
+        // of hpx and not on a hpx worker thread, so we must use std:mutex
         HPX_CXX_EXPORT HPX_CORE_EXPORT mutex_type& get_vector_mtx();
 
         // -----------------------------------------------------------------
         // An implementation of future_data for MPI
         HPX_CXX_EXPORT struct future_data : hpx::lcos::detail::future_data<int>
         {
-            HPX_NON_COPYABLE(future_data);
+            future_data(future_data const&) = delete;
+            future_data(future_data&&) = delete;
+            future_data& operator=(future_data const&) = delete;
+            future_data& operator=(future_data&&) = delete;
 
             using init_no_addref =
                 typename hpx::lcos::detail::future_data<int>::init_no_addref;
@@ -111,8 +114,8 @@ namespace hpx::mpi::experimental {
         HPX_CXX_EXPORT using future_data_ptr = hpx::intrusive_ptr<future_data>;
 
         // -----------------------------------------------------------------
-        // a convenience structure to hold state vars
-        // used extensivey with debug::print to display rank etc
+        // a convenience structure to hold state vars used extensively with
+        // debug::print to display rank etc
         HPX_CXX_EXPORT struct mpi_info
         {
             bool error_handler_initialized_ = false;
@@ -132,20 +135,20 @@ namespace hpx::mpi::experimental {
             std::ostream& os, mpi_info const& i);
 
         // -----------------------------------------------------------------
-        // an MPI error handling type that we can use to intercept
-        // MPI errors is we enable the error handler
+        // an MPI error handling type that we can use to intercept MPI errors is
+        // we enable the error handler
         HPX_CXX_EXPORT HPX_CORE_EXPORT extern MPI_Errhandler hpx_mpi_errhandler;
 
         // function that converts an MPI error into an exception
         HPX_CXX_EXPORT HPX_CORE_EXPORT void hpx_MPI_Handler(
             MPI_Comm*, int* errorcode, ...);
 
         // -----------------------------------------------------------------
-        // we track requests and callbacks in two vectors even though
-        // we have the request stored in the request_callback vector already
-        // the reason for this is because we can use MPI_Testany
-        // with a vector of requests to save overheads compared
-        // to testing one by one every item (using a list)
+        // we track requests and callbacks in two vectors even though we have
+        // the request stored in the request_callback vector already the reason
+        // for this is because we can use MPI_Testany with a vector of requests
+        // to save overheads compared to testing one by one every item (using a
+        // list)
         HPX_CXX_EXPORT HPX_CORE_EXPORT std::vector<MPI_Request>&
         get_requests_vector();
 
@@ -158,16 +161,16 @@ namespace hpx::mpi::experimental {
             concurrency::ConcurrentQueue<future_data_ptr>;
 
         // -----------------------------------------------------------------
-        // used internally to query how many requests are 'in flight'
-        // these are requests that are being polled for actively
-        // and not the same as the requests enqueued
+        // used internally to query how many requests are 'in flight' these are
+        // requests that are being polled for actively and not the same as the
+        // requests enqueued
         HPX_CXX_EXPORT HPX_CORE_EXPORT std::size_t
         get_number_of_active_requests();
     }    // namespace detail
 
     // -----------------------------------------------------------------
-    // set an error handler for communicators that will be called
-    // on any error instead of the default behavior of program termination
+    // set an error handler for communicators that will be called on any error
+    // instead of the default behavior of program termination
     HPX_CXX_EXPORT HPX_CORE_EXPORT void set_error_handler();
 
     // -----------------------------------------------------------------
@@ -200,9 +203,9 @@ namespace hpx::mpi::experimental {
     }    // namespace detail
 
     // -----------------------------------------------------------------
-    // Background progress function for MPI async operations
-    // Checks for completed MPI_Requests and sets mpi::experimental::future ready
-    // when found
+    // Background progress function for MPI async operations. Checks for
+    // completed MPI_Requests and sets mpi::experimental::future ready when
+    // found
     HPX_CXX_EXPORT HPX_CORE_EXPORT
         hpx::threads::policies::detail::polling_status
         poll();
@@ -238,9 +241,8 @@ namespace hpx::mpi::experimental {
         });
     }
 
-    // initialize the hpx::mpi background request handler
-    // All ranks should call this function,
-    // but only one thread per rank needs to do so
+    // initialize the hpx::mpi background request handler All ranks should call
+    // this function, but only one thread per rank needs to do so
     HPX_CXX_EXPORT HPX_CORE_EXPORT void init(bool init_mpi = false,
         std::string const& pool_name = "", bool init_errorhandler = false);
 

libs/core/compute_local/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2022 The STE||AR-Group
+# Copyright (c) 2019-2025 The STE||AR-Group
 #
 # SPDX-License-Identifier: BSL-1.0
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -41,6 +41,7 @@ include(HPX_AddModule)
 add_hpx_module(
   core compute_local
   GLOBAL_HEADER_GEN ON
+  GLOBAL_HEADER_MODULE_GEN ON
   SOURCES ${compute_local_sources}
   HEADERS ${compute_local_headers}
   COMPAT_HEADERS ${compute_local_compat_headers}

libs/core/compute_local/include/hpx/compute_local/detail/get_proxy_type.hpp

@@ -14,20 +14,20 @@
 
 namespace hpx::compute::detail {
 
-    template <typename T, typename Enable = void>
+    HPX_CXX_EXPORT template <typename T, typename Enable = void>
     struct get_proxy_type_impl
     {
         using type = T;
     };
 
-    template <typename T>
+    HPX_CXX_EXPORT template <typename T>
     struct get_proxy_type_impl<T,
         std::void_t<typename std::decay_t<T>::proxy_type>>
     {
         using proxy_type = typename std::decay_t<T>::proxy_type;
     };
 
-    template <typename T, typename Enable = void>
+    HPX_CXX_EXPORT template <typename T, typename Enable = void>
     struct get_proxy_type : get_proxy_type_impl<T>
     {
     };

libs/core/compute_local/include/hpx/compute_local/detail/iterator.hpp

@@ -18,7 +18,7 @@
 
 namespace hpx::compute::detail {
 
-    template <typename T, typename Allocator>
+    HPX_CXX_EXPORT template <typename T, typename Allocator>
     struct iterator
       : hpx::util::iterator_adaptor<iterator<T, Allocator>,
             typename traits::allocator_traits<Allocator>::pointer,
@@ -78,12 +78,12 @@ namespace hpx::compute::detail {
         target_type const* target_;
     };
 
-    template <typename T, typename Allocator>
+    HPX_CXX_EXPORT template <typename T, typename Allocator>
     struct reverse_iterator
     {
     };
 
-    template <typename T, typename Allocator>
+    HPX_CXX_EXPORT template <typename T, typename Allocator>
     struct const_reverse_iterator
     {
     };

libs/core/compute_local/include/hpx/compute_local/host/block_allocator.hpp

@@ -34,7 +34,7 @@ namespace hpx::compute::host {
 
         /// The policy_allocator allocates blocks of memory touched according to
         /// the distribution policy of the given executor.
-        template <typename T, typename Policy,
+        HPX_CXX_EXPORT template <typename T, typename Policy,
             typename Enable =
                 std::enable_if_t<hpx::is_execution_policy_v<Policy>>>
         struct policy_allocator
@@ -253,7 +253,7 @@ namespace hpx::compute::host {
     /// std::size_t N = 2048;
     /// vector_type v(N, allocator_type(numa_nodes));
     ///
-    template <typename T,
+    HPX_CXX_EXPORT template <typename T,
         typename Executor =
             hpx::execution::experimental::restricted_thread_pool_executor>
     struct block_allocator

libs/core/compute_local/include/hpx/compute_local/host/block_executor.hpp

@@ -31,8 +31,9 @@ namespace hpx::compute::host {
     /// It will distribute work evenly across the passed targets
     ///
     /// \tparam Executor The underlying executor to use
-    template <typename Executor =
-                  hpx::execution::experimental::restricted_thread_pool_executor>
+    HPX_CXX_EXPORT template <
+        typename Executor =
+            hpx::execution::experimental::restricted_thread_pool_executor>
     struct block_executor
     {
     public:
@@ -319,31 +320,31 @@ namespace hpx::compute::host {
 
 namespace hpx::execution::experimental {
 
-    template <typename Executor>
+    HPX_CXX_EXPORT template <typename Executor>
     struct executor_execution_category<compute::host::block_executor<Executor>>
     {
         using type = hpx::execution::parallel_execution_tag;
     };
 
-    template <typename Executor>
+    HPX_CXX_EXPORT template <typename Executor>
     struct is_one_way_executor<compute::host::block_executor<Executor>>
       : std::true_type
     {
     };
 
-    template <typename Executor>
+    HPX_CXX_EXPORT template <typename Executor>
     struct is_two_way_executor<compute::host::block_executor<Executor>>
       : std::true_type
     {
     };
 
-    template <typename Executor>
+    HPX_CXX_EXPORT template <typename Executor>
     struct is_bulk_one_way_executor<compute::host::block_executor<Executor>>
       : std::true_type
     {
     };
 
-    template <typename Executor>
+    HPX_CXX_EXPORT template <typename Executor>
     struct is_bulk_two_way_executor<compute::host::block_executor<Executor>>
       : std::true_type
     {

libs/core/compute_local/include/hpx/compute_local/host/block_fork_join_executor.hpp

@@ -52,7 +52,7 @@ namespace hpx::execution::experimental {
     /// This behaviour is similar to the plain \a fork_join_executor except that
     /// the block_fork_join_executor creates a hierarchy of fork_join_executors,
     /// one for each target used to initialize it.
-    class block_fork_join_executor
+    HPX_CXX_EXPORT class block_fork_join_executor
     {
         static hpx::threads::mask_type cores_for_targets(
             std::vector<compute::host::target> const& targets)

libs/core/compute_local/include/hpx/compute_local/host/get_targets.hpp

@@ -12,7 +12,7 @@
 
 namespace hpx::compute::host {
 
-    struct HPX_CORE_EXPORT target;
+    HPX_CXX_EXPORT struct HPX_CORE_EXPORT target;
 
-    HPX_CORE_EXPORT std::vector<target> get_local_targets();
+    HPX_CXX_EXPORT HPX_CORE_EXPORT std::vector<target> get_local_targets();
 }    // namespace hpx::compute::host

libs/core/compute_local/include/hpx/compute_local/host/numa_allocator.hpp

@@ -31,7 +31,7 @@
 namespace hpx::parallel::util {
 
     ///////////////////////////////////////////////////////////////////////////
-    template <typename T, typename Executors>
+    HPX_CXX_EXPORT template <typename T, typename Executors>
     class numa_allocator
     {
         using executor_type = typename Executors::value_type;