Merge branch 'STEllAR-GROUP:master' into master

Author: charan-003

cmake/templates/std_headers.hpp.in

@@ -11,6 +11,7 @@
 
 #include <hpx/config/defines.hpp>
 #include <hpx/config/compiler_specific.hpp>
+#include <hpx/config/modules_enabled.hpp>
 
 @cxx_standard_headers@
 // Some standard headers include the following headers.
@@ -57,14 +58,45 @@
 # include <generator>
 #endif
 
-#if defined(__GNUG__)
+#if defined(HPX_GCC_VERSION)
 # include <cxxabi.h>
 #endif
 
 #if defined(HPX_WINDOWS)
-#include <excpt.h>
-#undef exception_info
+# include <excpt.h>
+# undef exception_info
 #endif
 
 #include <asio.hpp>
 #include <hwloc.h>
+
+// Include MPI headers if required
+#if (defined(HPX_HAVE_NETWORKING) && defined(HPX_HAVE_PARCELPORT_MPI)) ||      \
+    defined(HPX_HAVE_MODULE_MPI_BASE)
+
+# if defined(HPX_CLANG_VERSION)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wcast-qual"
+# elif defined(HPX_GCC_VERSION)
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wcast-qual"
+# endif
+
+# include <mpi.h>
+
+# if defined(HPX_GCC_VERSION)
+#  pragma GCC diagnostic pop
+# elif defined(HPX_CLANG_VERSION)
+#  pragma clang diagnostic pop
+# endif
+
+#endif
+
+// Include LCI headers if required
+#if (defined(HPX_HAVE_NETWORKING) && defined(HPX_HAVE_PARCELPORT_LCI)) ||      \
+    defined(HPX_HAVE_MODULE_LCI_BASE)
+
+# include "lci.hpp"
+# include "lct.h"
+
+#endif

libs/core/async_mpi/CMakeLists.txt

@@ -33,6 +33,7 @@ include(HPX_AddModule)
 add_hpx_module(
   core async_mpi
   GLOBAL_HEADER_GEN ON
+  GLOBAL_HEADER_MODULE_GEN ON
   SOURCES ${mpi_sources}
   HEADERS ${async_mpi_headers}
   DEPENDENCIES Mpi::mpi

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

@@ -8,7 +8,7 @@
 
 #include <hpx/config.hpp>
 #include <hpx/modules/errors.hpp>
-#include <hpx/mpi_base/mpi.hpp>
+#include <hpx/modules/mpi_base.hpp>
 
 #include <cstddef>
 #include <memory>
@@ -19,7 +19,7 @@ namespace hpx::mpi::experimental {
     namespace detail {
 
         // extract MPI error message
-        inline std::string error_message(int code)
+        HPX_CXX_EXPORT inline std::string error_message(int code)
         {
             int N = 1023;
             std::unique_ptr<char[]> err_buff =
@@ -30,16 +30,15 @@ namespace hpx::mpi::experimental {
 
             return err_buff.get();
         }
-
     }    // namespace detail
 
     // -------------------------------------------------------------------------
     // exception type for failed launch of MPI functions
-    struct mpi_exception : hpx::exception
+    HPX_CXX_EXPORT struct HPX_ALWAYS_EXPORT mpi_exception : hpx::exception
     {
         explicit mpi_exception(int err_code, std::string const& msg = "")
           : hpx::exception(hpx::error::bad_function_call,
-                msg + std::string(" MPI returned with error: ") +
+                msg + std::string("MPI returned with error: ") +
                     detail::error_message(err_code))
           , err_code_(err_code)
         {    //-V1067
@@ -53,5 +52,4 @@ namespace hpx::mpi::experimental {
     protected:
         int err_code_;
     };
-
 }    // namespace hpx::mpi::experimental

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

@@ -18,7 +18,7 @@
 
 namespace hpx::mpi::experimental {
 
-    struct executor
+    HPX_CXX_EXPORT struct executor
     {
         // Associate the parallel_execution_tag executor tag type as a default
         // with this executor.
@@ -70,7 +70,6 @@ namespace hpx::mpi::experimental {
         MPI_Comm communicator_;
     };
 }    // namespace hpx::mpi::experimental
-// namespace hpx::mpi::experimental
 
 /// \cond NOINTERNAL
 template <>

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

@@ -13,9 +13,9 @@
 #include <hpx/modules/functional.hpp>
 #include <hpx/modules/futures.hpp>
 #include <hpx/modules/memory.hpp>
+#include <hpx/modules/mpi_base.hpp>
 #include <hpx/modules/runtime_local.hpp>
 #include <hpx/modules/threading_base.hpp>
-#include <hpx/mpi_base/mpi.hpp>
 
 #include <atomic>
 #include <cstddef>
@@ -25,38 +25,39 @@
 #include <utility>
 #include <vector>
 
-namespace hpx { namespace mpi { namespace experimental {
+namespace hpx::mpi::experimental {
 
     // -----------------------------------------------------------------
     namespace detail {
 
-        using request_callback_function_type =
+        HPX_CXX_EXPORT using request_callback_function_type =
             hpx::move_only_function<void(int)>;
 
-        HPX_CORE_EXPORT void add_request_callback(
+        HPX_CXX_EXPORT HPX_CORE_EXPORT void add_request_callback(
             request_callback_function_type&& f, MPI_Request req);
-        HPX_CORE_EXPORT void register_polling(hpx::threads::thread_pool_base&);
-        HPX_CORE_EXPORT void unregister_polling(
+        HPX_CXX_EXPORT HPX_CORE_EXPORT void register_polling(
+            hpx::threads::thread_pool_base&);
+        HPX_CXX_EXPORT HPX_CORE_EXPORT void unregister_polling(
             hpx::threads::thread_pool_base&);
 
     }    // namespace detail
 
     // by convention the title is 7 chars (for alignment)
-    using print_on = debug::enable_print<false>;
-    static constexpr print_on mpi_debug("MPI_FUT");
+    HPX_CXX_EXPORT using print_on = debug::enable_print<false>;
+    HPX_CXX_EXPORT static constexpr print_on mpi_debug("MPI_FUT");
 
     namespace detail {
 
-        using mutex_type = hpx::spinlock;
+        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
-        HPX_CORE_EXPORT mutex_type& get_vector_mtx();
+        HPX_CXX_EXPORT HPX_CORE_EXPORT mutex_type& get_vector_mtx();
 
         // -----------------------------------------------------------------
         // An implementation of future_data for MPI
-        struct future_data : hpx::lcos::detail::future_data<int>
+        HPX_CXX_EXPORT struct future_data : hpx::lcos::detail::future_data<int>
         {
             HPX_NON_COPYABLE(future_data);
 
@@ -107,12 +108,12 @@ namespace hpx { namespace mpi { namespace experimental {
 
         // -----------------------------------------------------------------
         // intrusive pointer for future_data
-        using future_data_ptr = hpx::intrusive_ptr<future_data>;
+        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
-        struct mpi_info
+        HPX_CXX_EXPORT struct mpi_info
         {
             bool error_handler_initialized_ = false;
             int rank_ = -1;
@@ -124,66 +125,70 @@ namespace hpx { namespace mpi { namespace experimental {
         };
 
         // an instance of mpi_info that we store data in
-        HPX_CORE_EXPORT mpi_info& get_mpi_info();
+        HPX_CXX_EXPORT HPX_CORE_EXPORT mpi_info& get_mpi_info();
 
         // stream operator to display debug mpi_info
-        HPX_CORE_EXPORT std::ostream& operator<<(
+        HPX_CXX_EXPORT HPX_CORE_EXPORT std::ostream& operator<<(
             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
-        HPX_CORE_EXPORT extern MPI_Errhandler hpx_mpi_errhandler;
+        HPX_CXX_EXPORT HPX_CORE_EXPORT extern MPI_Errhandler hpx_mpi_errhandler;
 
         // function that converts an MPI error into an exception
-        HPX_CORE_EXPORT void hpx_MPI_Handler(MPI_Comm*, int* errorcode, ...);
+        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)
-        HPX_CORE_EXPORT std::vector<MPI_Request>& get_requests_vector();
+        HPX_CXX_EXPORT HPX_CORE_EXPORT std::vector<MPI_Request>&
+        get_requests_vector();
 
         // -----------------------------------------------------------------
         // define a lockfree queue type to place requests in prior to handling
         // this is done only to avoid taking a lock every time a request is
         // returned from MPI. Instead the requests are placed into a queue
         // and the polling code pops them prior to calling Testany
-        using queue_type = concurrency::ConcurrentQueue<future_data_ptr>;
+        HPX_CXX_EXPORT using queue_type =
+            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
-        HPX_CORE_EXPORT std::size_t get_number_of_active_requests();
-
+        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
-    HPX_CORE_EXPORT void set_error_handler();
+    HPX_CXX_EXPORT HPX_CORE_EXPORT void set_error_handler();
 
     // -----------------------------------------------------------------
     // return a future object from a user supplied MPI_Request
-    HPX_CORE_EXPORT hpx::future<void> get_future(MPI_Request request);
+    HPX_CXX_EXPORT HPX_CORE_EXPORT hpx::future<void> get_future(
+        MPI_Request request);
 
     // -----------------------------------------------------------------
     // return a future from an async call to MPI_Ixxx function
     namespace detail {
 
-        template <typename F, typename... Ts>
+        HPX_CXX_EXPORT template <typename F, typename... Ts>
         hpx::future<int> async(F f, Ts&&... ts)
         {
             // create a future data shared state
             detail::future_data_ptr data =
                 new detail::future_data(detail::future_data::init_no_addref{});
 
             // invoke the call to MPI_Ixxx, ignore the returned result for now
-            int result = f(HPX_FORWARD(Ts, ts)..., &data->request_);
-            HPX_UNUSED(result);
+            [[maybe_unused]] int result =
+                f(HPX_FORWARD(Ts, ts)..., &data->request_);
 
             // Add callback after the request has been filled
             data->add_callback();
@@ -198,13 +203,15 @@ namespace hpx { namespace mpi { namespace experimental {
     // Background progress function for MPI async operations
     // Checks for completed MPI_Requests and sets mpi::experimental::future ready
     // when found
-    HPX_CORE_EXPORT hpx::threads::policies::detail::polling_status poll();
+    HPX_CXX_EXPORT HPX_CORE_EXPORT
+        hpx::threads::policies::detail::polling_status
+        poll();
 
     // -----------------------------------------------------------------
     // This is not completely safe as it will return when the request vector is
     // empty, but cannot guarantee that other communications are not about
     // to be launched in outstanding continuations etc.
-    inline void wait()
+    HPX_CXX_EXPORT inline void wait()
     {
         hpx::util::yield_while([]() {
             std::unique_lock<detail::mutex_type> lk(
@@ -217,7 +224,7 @@ namespace hpx { namespace mpi { namespace experimental {
         });
     }
 
-    template <typename F>
+    HPX_CXX_EXPORT template <typename F>
     inline void wait(F&& f)
     {
         hpx::util::yield_while([&]() {
@@ -234,16 +241,17 @@ namespace hpx { namespace mpi { namespace experimental {
     // initialize the hpx::mpi background request handler
     // All ranks should call this function,
     // but only one thread per rank needs to do so
-    HPX_CORE_EXPORT void init(bool init_mpi = false,
+    HPX_CXX_EXPORT HPX_CORE_EXPORT void init(bool init_mpi = false,
         std::string const& pool_name = "", bool init_errorhandler = false);
 
     // -----------------------------------------------------------------
-    HPX_CORE_EXPORT void finalize(std::string const& pool_name = "");
+    HPX_CXX_EXPORT HPX_CORE_EXPORT void finalize(
+        std::string const& pool_name = "");
 
     // -----------------------------------------------------------------
     // This RAII helper class assumes that MPI initialization/finalization is
     // handled elsewhere
-    struct [[nodiscard]] enable_user_polling
+    HPX_CXX_EXPORT struct [[nodiscard]] enable_user_polling
     {
         enable_user_polling(
             std::string const& pool_name = "", bool init_errorhandler = false)
@@ -262,9 +270,9 @@ namespace hpx { namespace mpi { namespace experimental {
     };
 
     // -----------------------------------------------------------------
-    template <typename... Args>
+    HPX_CXX_EXPORT template <typename... Args>
     inline void debug(Args&&... args)
     {
         mpi_debug.debug(detail::get_mpi_info(), HPX_FORWARD(Args, args)...);
     }
-}}}    // namespace hpx::mpi::experimental
+}    // namespace hpx::mpi::experimental