Adapting HPX CUDA modules to C++ modules

-flyby: remove support for HPX::auto_wrap_main for MSVC

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

Author: hkaiser

CMakeLists.txt

@@ -1407,6 +1407,9 @@ if((HPX_WITH_NETWORKING AND HPX_WITH_PARCELPORT_MPI)
     # hpx_add_compile_flag() below does not add the extra options to the top
     # level directory
     hpx_add_config_define(OMPI_IMPORTS)
+    if(HPX_WITH_CUDA)
+      hpx_add_config_cond_define(NOMINMAX)
+    endif()
   endif()
 endif()
 

cmake/templates/std_headers.hpp.in

@@ -92,8 +92,19 @@
 // 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
+
+#if defined(HPX_HAVE_MODULE_THRUST)
+# include <hpx/thrust/thrust_headers.hpp>
+#endif
 
+#if defined(HPX_HAVE_MM_PREFETCH)
+# if defined(HPX_MSVC)
+#  include <intrin.h>
+# endif
+# if defined(HPX_GCC_VERSION)
+#  include <emmintrin.h>
+# endif
 #endif

components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_segmented_iterator.hpp

@@ -15,7 +15,7 @@
 
 #include <hpx/config.hpp>
 #include <hpx/assert.hpp>
-#include #include < hpx / modules / algorithms.hpp>
+#include <hpx/modules/algorithms.hpp>
 #include <hpx/modules/async_base.hpp>
 #include <hpx/modules/iterator_support.hpp>
 #include <hpx/naming_base/id_type.hpp>

docs/sphinx/manual/creating_hpx_projects.rst

@@ -265,7 +265,12 @@ implicitly using ``main()`` as the entry point. If you want the same wrapping
 behavior without including :hpx-header:`wrap/include,hpx/hpx_main.hpp`, link to
 the ``HPX::auto_wrap_main`` target instead. This enables the runtime
 initialization around ``main()`` unconditionally and is useful for codebases
-where adding the header to ``main.cpp`` is impractical.
+where adding the header to ``main.cpp`` is impractical
+
+.. note::
+
+    The use of ``HPX::auto_wrap_main`` is not supported when using the
+    native Windows MSVC toolchain.
 
 If you want to use the facilities exposed by ``hpx::runtime_manager`` in binaries
 that were not linked as executables (e.g., in shared libraries), you will need

docs/sphinx/manual/starting_the_hpx_runtime.rst

@@ -59,6 +59,10 @@ you cannot or do not want to include ``hpx/hpx_main.hpp`` in ``main.cpp``, you
 can instead link against ``HPX::auto_wrap_main``. That target enables the same
 runtime startup path without needing the header-triggered opt-in.
 
+.. note::
+
+    The use of ``HPX::auto_wrap_main`` is not supported when using the
+    native Windows MSVC toolchain.
 
 .. note::
 

libs/CMakeLists.txt

@@ -184,21 +184,30 @@ add_library(hpx_interface_wrap_main INTERFACE)
 target_link_libraries(
   hpx_interface_wrap_main INTERFACE $<${_is_executable}:HPXInternal::hpx_wrap>
 )
-add_library(hpx_interface_auto_wrap_main INTERFACE)
-target_link_libraries(
-  hpx_interface_auto_wrap_main
-  INTERFACE $<${_is_executable}:HPXInternal::hpx_auto_wrap>
-)
 
 target_link_libraries(wrap_main INTERFACE hpx_interface_wrap_main)
-target_link_libraries(auto_wrap_main INTERFACE hpx_interface_auto_wrap_main)
 target_link_libraries(init INTERFACE HPXInternal::hpx_init)
 target_link_libraries(hpx INTERFACE hpx_interface)
 
-# HPX::component is to be linked privately to all HPX components NOTE: The
-# _is_library guard only prevents simple mistakes of linking HPX::component to
-# executables. It does not prevent linking it to libraries that are not
-# components.
+set(hpx_targets hpx wrap_main init plugin component)
+set(hpx_internal_targets hpx_full hpx_interface hpx_interface_wrap_main)
+
+if(NOT MSVC)
+  add_library(hpx_interface_auto_wrap_main INTERFACE)
+  target_link_libraries(
+    hpx_interface_auto_wrap_main
+    INTERFACE $<${_is_executable}:HPXInternal::hpx_auto_wrap>
+  )
+  target_link_libraries(auto_wrap_main INTERFACE hpx_interface_auto_wrap_main)
+  set(hpx_targets ${hpx_targets} auto_wrap_main)
+  set(hpx_internal_targets ${hpx_internal_targets} hpx_interface_auto_wrap_main)
+endif()
+
+# HPX::component is to be linked privately to all HPX components
+#
+# NOTE: The _is_library guard only prevents simple mistakes of linking
+# HPX::component to executables. It does not prevent linking it to libraries
+# that are not components.
 add_library(component INTERFACE)
 target_compile_definitions(
   component
@@ -219,11 +228,6 @@ target_compile_definitions(
     "$<${_is_library}:HPX_PLUGIN_NAME_DEFAULT=hpx_$<TARGET_PROPERTY:NAME>>"
 )
 
-set(hpx_targets hpx wrap_main auto_wrap_main init plugin component)
-set(hpx_internal_targets hpx_full hpx_interface hpx_interface_wrap_main
-                         hpx_interface_auto_wrap_main
-)
-
 # cmake-format: off
 install(
   TARGETS ${hpx_targets}

libs/core/algorithms/include/hpx/parallel/algorithms/detail/parallel_stable_sort.hpp

@@ -60,7 +60,7 @@ namespace hpx::parallel::detail {
     /// \param [in] first : range of elements to sort
     /// \param [in] last : range of elements to sort
     /// \param [in] comp : object for to compare two elements
-    HPX_CXX_EXPORT template <typename Iter, typename Sent, typename Compare>
+    template <typename Iter, typename Sent, typename Compare>
     parallel_stable_sort_helper<Iter, Sent,
         Compare>::parallel_stable_sort_helper(Iter first, Sent last,
         Compare comp)
@@ -72,7 +72,7 @@ namespace hpx::parallel::detail {
         HPX_ASSERT(range_initial.size() >= 0);
     }
 
-    HPX_CXX_EXPORT template <typename Iter, typename Sent, typename Compare>
+    template <typename Iter, typename Sent, typename Compare>
     template <typename Exec>
     Iter parallel_stable_sort_helper<Iter, Sent, Compare>::operator()(
         Exec&& exec, std::uint32_t nthreads, std::size_t chunk_size)

libs/core/algorithms/include/hpx/parallel/algorithms/detail/sample_sort.hpp

@@ -30,7 +30,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 namespace hpx::parallel::detail {
 
-    HPX_CXX_EXPORT static constexpr std::uint32_t sample_sort_limit_per_task = 1
+    HPX_CXX_EXPORT inline constexpr std::uint32_t sample_sort_limit_per_task = 1
         << 16;
 
     /// \struct sample_sort

libs/core/algorithms/include/hpx/parallel/algorithms/exclusive_scan.hpp

@@ -322,7 +322,7 @@ namespace hpx::parallel {
         // Our own version of the sequential exclusive_scan.
         HPX_CXX_EXPORT template <typename InIter, typename Sent,
             typename OutIter, typename T, typename Op>
-        static constexpr util::in_out_result<InIter, OutIter>
+        constexpr util::in_out_result<InIter, OutIter>
         sequential_exclusive_scan(
             InIter first, Sent last, OutIter dest, T init, Op&& op)
         {
@@ -338,7 +338,7 @@ namespace hpx::parallel {
 
         HPX_CXX_EXPORT template <typename InIter, typename OutIter, typename T,
             typename Op>
-        static constexpr T sequential_exclusive_scan_n(
+        constexpr T sequential_exclusive_scan_n(
             InIter first, std::size_t count, OutIter dest, T init, Op&& op)
         {
             T temp = init;

libs/core/algorithms/include/hpx/parallel/algorithms/inclusive_scan.hpp

@@ -456,7 +456,7 @@ namespace hpx::parallel {
         // Our own version of the sequential inclusive_scan.
         HPX_CXX_EXPORT template <typename InIter, typename Sent,
             typename OutIter, typename T, typename Op>
-        static constexpr util::in_out_result<InIter, OutIter>
+        constexpr util::in_out_result<InIter, OutIter>
         sequential_inclusive_scan(
             InIter first, Sent last, OutIter dest, T init, Op&& op)
         {
@@ -470,7 +470,7 @@ namespace hpx::parallel {
 
         HPX_CXX_EXPORT template <typename InIter, typename Sent,
             typename OutIter, typename Op>
-        static constexpr util::in_out_result<InIter, OutIter>
+        constexpr util::in_out_result<InIter, OutIter>
         sequential_inclusive_scan_noinit(
             InIter first, Sent last, OutIter dest, Op&& op)
         {
@@ -486,7 +486,7 @@ namespace hpx::parallel {
 
         HPX_CXX_EXPORT template <typename InIter, typename OutIter, typename T,
             typename Op>
-        static constexpr T sequential_inclusive_scan_n(
+        constexpr T sequential_inclusive_scan_n(
             InIter first, std::size_t count, OutIter dest, T init, Op&& op)
         {
             for (/* */; count-- != 0; (void) ++first, ++dest)