HPX implementation of scan

CMakePresets.json

@@ -76,6 +76,7 @@
         "THRUST_MULTICONFIG_ENABLE_DIALECT_CPP20": true,
         "THRUST_MULTICONFIG_ENABLE_SYSTEM_CPP": true,
         "THRUST_MULTICONFIG_ENABLE_SYSTEM_CUDA": true,
+        "THRUST_MULTICONFIG_ENABLE_SYSTEM_HPX": true,
         "THRUST_MULTICONFIG_ENABLE_SYSTEM_OMP": true,
         "THRUST_MULTICONFIG_ENABLE_SYSTEM_TBB": true,
         "cudax_ENABLE_HEADER_TESTING": true,
@@ -212,6 +213,7 @@
         "THRUST_ENABLE_MULTICONFIG": true,
         "THRUST_MULTICONFIG_ENABLE_SYSTEM_CPP": true,
         "THRUST_MULTICONFIG_ENABLE_SYSTEM_CUDA": true,
+        "THRUST_MULTICONFIG_ENABLE_SYSTEM_HPX": false,
         "THRUST_MULTICONFIG_ENABLE_SYSTEM_OMP": true,
         "THRUST_MULTICONFIG_ENABLE_SYSTEM_TBB": true,
         "THRUST_MULTICONFIG_ENABLE_DIALECT_CPP17": false,

docs/cpp.rst

@@ -40,8 +40,8 @@ be better served by unifying them into a single repository.
   parallel algorithms to the C++ Standard Library. Thrust's high-level
   interface greatly enhances programmer productivity while enabling performance
   portability between GPUs and multicore CPUs via configurable backends that
-  allow using multiple parallel programming frameworks (such as CUDA, TBB, and
-  OpenMP).
+  allow using multiple parallel programming frameworks (such as CUDA, TBB, HPX
+  and OpenMP).
 
 - `Cuda Experimental <https://nvidia.github.io/cccl/cudax/>`__
   is a library of experimental features that are still in the design process.

docs/cub/index.rst

@@ -439,7 +439,7 @@ CUB and `Thrust <https://nvidia.github.io/cccl/thrust/>`_ share some
 similarities in that they both provide similar device-wide primitives for CUDA.
 However, they target different abstraction layers for parallel computing.
 Thrust abstractions are agnostic of any particular parallel framework (e.g.,
-CUDA, TBB, OpenMP, sequential  CPU, etc.).  While Thrust has a "backend"
+CUDA, TBB, OpenMP, HPX, sequential  CPU, etc.).  While Thrust has a "backend"
 for CUDA devices, Thrust interfaces themselves are not CUDA-specific and
 do not explicitly expose CUDA-specific details (e.g., ``cudaStream_t`` parameters).
 

docs/repo.toml

@@ -236,6 +236,7 @@ doxygen_input = [
     "../../thrust/thrust/random/*.h",
     "../../thrust/thrust/system/*.h",
     "../../thrust/thrust/system/cpp/pointer.h",
+    "../../thrust/thrust/system/hpx/pointer.h",
     "../../thrust/thrust/system/omp/pointer.h",
     "../../thrust/thrust/system/tbb/pointer.h",
     "../../thrust/thrust/type_traits/*.h",

docs/thrust/cmake_options.rst

@@ -34,6 +34,9 @@ The CMake options are divided into these categories:
 5. `TBB Specific CMake Options <#tbb-specific-cmake-options>`__ Options
    that control TBB compilation. Only available when one or more
    configurations targets the TBB system.
+5. `HPX Specific CMake Options <#hpx-specific-cmake-options>`__ Options
+   that control HPX compilation. Only available when one or more
+   configurations targets the HPX system.
 
 Generic CMake Options
 ---------------------
@@ -85,11 +88,11 @@ Generic CMake Options
 Single Config CMake Options
 ---------------------------
 
--  ``THRUST_HOST_SYSTEM={CPP, TBB, OMP}``
+-  ``THRUST_HOST_SYSTEM={CPP, TBB, OMP, HPX}``
 
    -  Selects the host system. Default: ``CPP``
 
--  ``THRUST_DEVICE_SYSTEM={CUDA, TBB, OMP, CPP}``
+-  ``THRUST_DEVICE_SYSTEM={CUDA, TBB, OMP, HPX, CPP}``
 
    -  Selects the device system. Default: ``CUDA``
 
@@ -112,7 +115,7 @@ Multi Config CMake Options
 -  ``THRUST_MULTICONFIG_ENABLE_SYSTEM_XXXX={ON, OFF}``
 
    -  Toggle whether a specific system will be targeted.
-   -  Possible values of ``XXXX`` are ``{CPP, CUDA, TBB, OMP}``
+   -  Possible values of ``XXXX`` are ``{CPP, CUDA, TBB, HPX, OMP}``
    -  By default, only ``CPP`` and ``CUDA`` are enabled.
 
 -  ``THRUST_MULTICONFIG_WORKLOAD={SMALL, MEDIUM, LARGE, FULL}``
@@ -134,9 +137,11 @@ Multi Config CMake Options
 Config   Workloads   Value      Expense   Note
 ======== =========== ========== ========= ============================
 CPP/CUDA ``F L M S`` Essential  Expensive Validates CUDA against CPP
+CPP/HPX  ``F L M S`` Essential  Cheap     Validates HPX against CPP
 CPP/OMP  ``F L M S`` Essential  Cheap     Validates OMP against CPP
 CPP/TBB  ``F L M S`` Essential  Cheap     Validates TBB against CPP
 CPP/CPP  ``F L M``   Important  Cheap     Tests CPP as device
+HPX/HPX  ``F L M``   Important  Cheap     Tests HPX as host
 OMP/OMP  ``F L M``   Important  Cheap     Tests OMP as host
 TBB/TBB  ``F L M``   Important  Cheap     Tests TBB as host
 TBB/CUDA ``F L``     Important  Expensive Validates TBB/CUDA interop

lib/cmake/thrust/README.md

@@ -229,8 +229,8 @@ on-demand by calls to `create_thrust_target`, or when explicitly requested via
 As mentioned, the basic Thrust interface is described by the `Thrust::Thrust`
 target.
 
-Each backend system (`CPP`, `CUDA`, `TBB`, `OMP`) is described by multiple
-targets:
+Each backend system (`CPP`, `CUDA`, `TBB`, `OMP`, `HPX`) is described by
+multiple targets:
 
 - `Thrust::${system}`
   - Specifies an interface configured to build against all

lib/cmake/thrust/thrust-config.cmake

@@ -39,16 +39,18 @@
 #   [GLOBAL]                         # Optionally mark the target as GLOBAL
 # )
 #
-# # Use a custom TBB, CUB, and/or OMP
+# # Use a custom TBB, CUB, OMP, and/or HPX
 # # (Note that once set, these cannot be changed. This includes COMPONENT
 # # preloading and lazy lookups in thrust_create_target)
 # find_package(Thrust REQUIRED)
 # thrust_set_CUB_target(MyCUBTarget)  # MyXXXTarget contains an existing
 # thrust_set_TBB_target(MyTBBTarget)  # interface to XXX for Thrust to use.
 # thrust_set_OMP_target(MyOMPTarget)
+# thrust_set_HPX_target(MyHPXTarget)
 # thrust_create_target(ThrustWithMyCUB DEVICE CUDA)
 # thrust_create_target(ThrustWithMyTBB DEVICE TBB)
 # thrust_create_target(ThrustWithMyOMP DEVICE OMP)
+# thrust_create_target(ThrustWithMyHPX DEVICE HPX)
 #
 # # Create target with HOST=CPP DEVICE=CUDA and some advanced flags set
 # thrust_create_target(TargetName
@@ -71,6 +73,7 @@
 # thrust_is_cuda_system_found(<var_name>)
 # thrust_is_tbb_system_found(<var_name>)
 # thrust_is_omp_system_found(<var_name>)
+# thrust_is_hpx_system_found(<var_name>)
 # thrust_is_cpp_system_found(<var_name>)
 #
 # # Define / update THRUST_${system}_FOUND flags in current scope
@@ -97,12 +100,12 @@ set(thrust_libcudacxx_version "${Thrust_VERSION}")
 
 # Advertise system options:
 set(THRUST_HOST_SYSTEM_OPTIONS
-  CPP OMP TBB
+  CPP HPX OMP TBB
   CACHE INTERNAL "Valid Thrust host systems."
   FORCE
 )
 set(THRUST_DEVICE_SYSTEM_OPTIONS
-  CUDA CPP OMP TBB
+  CUDA CPP HPX OMP TBB
   CACHE INTERNAL "Valid Thrust device systems"
   FORCE
 )
@@ -290,6 +293,11 @@ function(thrust_is_omp_system_found var_name)
   set(${var_name} ${${var_name}} PARENT_SCOPE)
 endfunction()
 
+function(thrust_is_hpx_system_found var_name)
+  thrust_is_system_found(HPX ${var_name})
+  set(${var_name} ${${var_name}} PARENT_SCOPE)
+endfunction()
+
 # Since components are loaded lazily, this will refresh the
 # THRUST_${component}_FOUND flags in the current scope.
 # Alternatively, check system states individually using the
@@ -300,6 +308,7 @@ macro(thrust_update_system_found_flags)
   thrust_is_system_found(CUDA THRUST_CUDA_FOUND)
   thrust_is_system_found(TBB  THRUST_TBB_FOUND)
   thrust_is_system_found(OMP  THRUST_OMP_FOUND)
+  thrust_is_system_found(HPX  THRUST_HPX_FOUND)
 endmacro()
 
 function(thrust_debug msg)
@@ -390,6 +399,9 @@ function(thrust_debug_internal_targets)
   _thrust_debug_backend_targets(CUDA "CUB ${THRUST_CUB_VERSION}")
   thrust_debug_target(CUB::CUB "${THRUST_CUB_VERSION}")
   thrust_debug_target(libcudacxx::libcudacxx "${THRUST_libcudacxx_VERSION}")
+
+  _thrust_debug_backend_targets(HPX "${THRUST_HPX_VERSION}")
+  thrust_debug_target(HPX::hpx "${THRUST_HPX_VERSION}")
 endfunction()
 
 ################################################################################
@@ -544,6 +556,24 @@ function(thrust_set_OMP_target omp_target)
   endif()
 endfunction()
 
+# Use the provided hpx_target for the HPX backend. If Thrust::HPX already
+# exists, this call has no effect.
+function(thrust_set_HPX_target hpx_target)
+  if (NOT TARGET Thrust::HPX)
+    thrust_debug("Setting HPX target to ${hpx_target}" internal)
+    # Workaround cmake issue #20670 https://gitlab.kitware.com/cmake/cmake/-/issues/20670
+    set(THRUST_HPX_VERSION ${HPX_VERSION} CACHE INTERNAL
+      "HPX version used by Thrust"
+      FORCE
+    )
+    _thrust_declare_interface_alias(Thrust::HPX _Thrust_HPX)
+    target_link_libraries(_Thrust_HPX INTERFACE Thrust::Thrust ${hpx_target})
+    thrust_debug_target(${hpx_target} "${THRUST_HPX_VERSION}" internal)
+    thrust_debug_target(Thrust::HPX "${THRUST_HPX_VERSION}" internal)
+    _thrust_setup_system(HPX)
+  endif()
+endfunction()
+
 function(_thrust_find_CPP required)
   if (NOT TARGET Thrust::CPP)
     thrust_debug("Generating CPP targets." internal)
@@ -667,6 +697,28 @@ macro(_thrust_find_OMP required)
   endif()
 endmacro()
 
+# This must be a macro instead of a function to ensure that backends passed to
+# find_package(Thrust COMPONENTS [...]) have their full configuration loaded
+# into the current scope. This provides at least some remedy for CMake issue
+# #20670 -- otherwise variables like HPX_VERSION, etc won't be in the caller's
+# scope.
+macro(_thrust_find_HPX required)
+  if(NOT TARGET Thrust::HPX)
+    thrust_debug("Searching for HPX ${required}" internal)
+
+    # Try to find the CMake package that newer versions of HPX install themselves:
+    if (NOT TARGET HPX::hpx)
+      find_package(HPX CONFIG ${_THRUST_QUIET_FLAG})
+    endif()
+
+    if (TARGET HPX::hpx)
+      thrust_set_HPX_target(HPX::hpx)
+    else()
+      thrust_debug("HPX not found!" internal)
+    endif()
+  endif()
+endmacro()
+
 # This must be a macro instead of a function to ensure that backends passed to
 # find_package(Thrust COMPONENTS [...]) have their full configuration loaded
 # into the current scope. This provides at least some remedy for CMake issue
@@ -683,6 +735,8 @@ macro(_thrust_find_backend backend required)
     _thrust_find_TBB("${required}")
   elseif ("${backend}" STREQUAL "OMP")
     _thrust_find_OMP("${required}")
+  elseif ("${backend}" STREQUAL "HPX")
+    _thrust_find_HPX("${required}")
   else()
     message(FATAL_ERROR "_thrust_find_backend: Invalid system: ${backend}")
   endif()

thrust/CMakeLists.txt

@@ -77,6 +77,7 @@ message(STATUS "CPP system found?  ${THRUST_CPP_FOUND}")
 message(STATUS "CUDA system found? ${THRUST_CUDA_FOUND}")
 message(STATUS "TBB system found?  ${THRUST_TBB_FOUND}")
 message(STATUS "OMP system found?  ${THRUST_OMP_FOUND}")
+message(STATUS "HPX system found?  ${THRUST_HPX_FOUND}")
 
 if (THRUST_ENABLE_HEADER_TESTING)
   include(cmake/ThrustHeaderTesting.cmake)

thrust/cmake/ThrustBuildTargetList.cmake

@@ -17,8 +17,8 @@
 #   - <prop_var> is any valid cmake identifier.
 #   - <target_name> is the name of a thrust target.
 #   - <prop> is one of the following:
-#     - HOST: The host system. Valid values: CPP, OMP, TBB.
-#     - DEVICE: The device system. Valid values: CUDA, CPP, OMP, TBB.
+#     - HOST: The host system. Valid values: CPP, HPX, OMP, TBB.
+#     - DEVICE: The device system. Valid values: CUDA, CPP, HPX, OMP, TBB.
 #     - DIALECT: The C++ dialect. Valid values: 11, 14, 17, 20.
 #     - PREFIX: A unique prefix that should be used to name all
 #       targets/tests/examples that use this configuration.
@@ -35,12 +35,12 @@
 #     `thrust_clone_target_properties(${my_thrust_test} ${some_thrust_target})`
 
 define_property(TARGET PROPERTY _THRUST_HOST
-  BRIEF_DOCS "A target's host system: CPP, TBB, or OMP."
-  FULL_DOCS "A target's host system: CPP, TBB, or OMP."
+  BRIEF_DOCS "A target's host system: CPP, TBB, OMP, or HPX."
+  FULL_DOCS "A target's host system: CPP, TBB, OMP, or HPX."
 )
 define_property(TARGET PROPERTY _THRUST_DEVICE
-  BRIEF_DOCS "A target's device system: CUDA, CPP, TBB, or OMP."
-  FULL_DOCS "A target's device system: CUDA, CPP, TBB, or OMP."
+  BRIEF_DOCS "A target's device system: CUDA, CPP, TBB, OMP, or HPX."
+  FULL_DOCS "A target's device system: CUDA, CPP, TBB, OMP, or HPX."
 )
 define_property(TARGET PROPERTY _THRUST_DIALECT
   BRIEF_DOCS "A target's C++ dialect: 11, 14, or 17."

thrust/cmake/ThrustFindThrust.cmake

@@ -13,6 +13,9 @@ function(_thrust_find_thrust_multiconfig)
   if (THRUST_MULTICONFIG_ENABLE_SYSTEM_OMP)
     list(APPEND req_systems OMP)
   endif()
+  if (THRUST_MULTICONFIG_ENABLE_SYSTEM_HPX)
+    list(APPEND req_systems HPX)
+  endif()
 
   find_package(Thrust REQUIRED CONFIG
     NO_DEFAULT_PATH # Only check the explicit path in HINTS:

thrust/cmake/ThrustMultiConfig.cmake

@@ -39,6 +39,7 @@ function(thrust_configure_multiconfig)
     # Systems:
     option(THRUST_MULTICONFIG_ENABLE_SYSTEM_CPP "Generate build configurations that use CPP." ON)
     option(THRUST_MULTICONFIG_ENABLE_SYSTEM_CUDA "Generate build configurations that use CUDA." ON)
+    option(THRUST_MULTICONFIG_ENABLE_SYSTEM_HPX "Generate build configurations that use HPX." OFF)
     option(THRUST_MULTICONFIG_ENABLE_SYSTEM_OMP "Generate build configurations that use OpenMP." OFF)
     option(THRUST_MULTICONFIG_ENABLE_SYSTEM_TBB "Generate build configurations that use TBB." OFF)
 
@@ -57,9 +58,11 @@ function(thrust_configure_multiconfig)
     # Config   | Workloads | Value      | Expense   | Note
     # ---------|-----------|------------|-----------|-----------------------------
     # CPP/CUDA | F L M S   | Essential  | Expensive | Validates CUDA against CPP
+    # CPP/HPX  | F L M S   | Essential  | Cheap     | Validates HPX against CPP
     # CPP/OMP  | F L M S   | Essential  | Cheap     | Validates OMP against CPP
     # CPP/TBB  | F L M S   | Essential  | Cheap     | Validates TBB against CPP
     # CPP/CPP  | F L M     | Important  | Cheap     | Tests CPP as device
+    # HPX/HPX  | F L M     | Important  | Cheap     | Tests HPX as host
     # OMP/OMP  | F L M     | Important  | Cheap     | Tests OMP as host
     # TBB/TBB  | F L M     | Important  | Cheap     | Tests TBB as host
     # TBB/CUDA | F L       | Important  | Expensive | Validates TBB/CUDA interop
@@ -76,12 +79,12 @@ function(thrust_configure_multiconfig)
       SMALL MEDIUM LARGE FULL
     )
     set(THRUST_MULTICONFIG_WORKLOAD_SMALL_CONFIGS
-      CPP_OMP CPP_TBB CPP_CUDA
+      CPP_OMP CPP_TBB CPP_CUDA CPP_HPX
       CACHE INTERNAL "Host/device combos enabled for SMALL workloads." FORCE
     )
     set(THRUST_MULTICONFIG_WORKLOAD_MEDIUM_CONFIGS
       ${THRUST_MULTICONFIG_WORKLOAD_SMALL_CONFIGS}
-      CPP_CPP TBB_TBB OMP_OMP
+      CPP_CPP TBB_TBB OMP_OMP HPX_HPX
       CACHE INTERNAL "Host/device combos enabled for MEDIUM workloads." FORCE
     )
     set(THRUST_MULTICONFIG_WORKLOAD_LARGE_CONFIGS

thrust/testing/CMakeLists.txt

@@ -156,4 +156,5 @@ endforeach()
 add_subdirectory(cmake)
 add_subdirectory(cpp)
 add_subdirectory(cuda)
+add_subdirectory(hpx)
 add_subdirectory(omp)

thrust/testing/hpx/CMakeLists.txt

@@ -0,0 +1,18 @@
+file(GLOB test_srcs
+  RELATIVE "${CMAKE_CURRENT_LIST_DIR}}"
+  CONFIGURE_DEPENDS
+  *.cu *.cpp
+)
+
+foreach(thrust_target IN LISTS THRUST_TARGETS)
+  thrust_get_target_property(config_device ${thrust_target} DEVICE)
+  if (NOT config_device STREQUAL "HPX")
+    continue()
+  endif()
+
+  foreach(test_src IN LISTS test_srcs)
+    get_filename_component(test_name "${test_src}" NAME_WLE)
+    string(PREPEND test_name "hpx.")
+    thrust_add_test(test_target ${test_name} "${test_src}" ${thrust_target})
+  endforeach()
+endforeach()