Moving most of APIs from hpx::parallel::execution to hpx::execution::…

…experimental

docs/sphinx/manual/writing_single_node_hpx_applications.rst

@@ -1202,7 +1202,7 @@ With ``executor_parameter_traits``, clients access all types of executor
 parameters uniformly, e.g.::
 
     std::size_t chunk_size =
-        hpx::execution::get_chunk_size(my_parameter, my_executor,
+        hpx::execution::experimental::get_chunk_size(my_parameter, my_executor,
             num_cores, num_tasks);
 
 This call synchronously retrieves the size of a single chunk of loop iterations

docs/sphinx/releases.rst

@@ -1,5 +1,5 @@
 ..
-    Copyright (C) 2018-2023 STE||AR Group
+    Copyright (C) 2018-2024 STE||AR Group
 
     SPDX-License-Identifier: BSL-1.0
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -17,6 +17,7 @@ List of releases
 .. toctree::
    :maxdepth: 1
 
+   releases/whats_new_1_11_0
    releases/whats_new_1_10_0
    releases/whats_new_1_9_1
    releases/whats_new_1_9_0

docs/sphinx/releases/whats_new_1_11_0.rst

@@ -0,0 +1,31 @@
+..
+    Copyright (C) 2007-2024 Hartmut Kaiser
+
+    SPDX-License-Identifier: BSL-1.0
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+.. _hpx_1_11_0:
+
+============================
+|hpx| V1.11.0 (TBA)
+============================
+
+General changes
+===============
+
+Breaking changes
+================
+
+- We have moved most of the APIs that were defined in the namespace
+  ``hpx::parallel::execution`` to the namespace ``hpx::execution::experimental``.
+  It was not possible to add compatibility facilities that will allow to continue
+  using the old APIs, applications will have to be changed in order to
+  continue functioning correctly.
+
+Closed issues
+=============
+
+Closed pull requests
+====================
+

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

@@ -1,4 +1,4 @@
-//  Copyright (c) 2007-2023 Hartmut Kaiser
+//  Copyright (c) 2007-2024 Hartmut Kaiser
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -114,9 +114,10 @@ namespace hpx::parallel::detail {
 
         using buffer_type = typename set_operations_buffer<Iter3>::type;
 
-        std::size_t cores = execution::processing_units_count(
-            policy.parameters(), policy.executor(), hpx::chrono::null_duration,
-            (std::min)(len1, len2));
+        std::size_t cores =
+            hpx::execution::experimental::processing_units_count(
+                policy.parameters(), policy.executor(),
+                hpx::chrono::null_duration, (std::min)(len1, len2));
 
         std::size_t const step = (len1 + cores - 1) / cores;
 

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

@@ -369,22 +369,25 @@ namespace hpx::parallel {
                 };
 
                 std::size_t const cores =
-                    execution::processing_units_count(policy.parameters(),
-                        policy.executor(), hpx::chrono::null_duration, n);
+                    hpx::execution::experimental::processing_units_count(
+                        policy.parameters(), policy.executor(),
+                        hpx::chrono::null_duration, n);
 
                 // Take a standard chunk size (amount of work / cores), and only
                 // take a quarter of that. If our chunk size is too large a LOT
                 // of the work will be done sequentially due to the level
                 // barrier of heap parallelism. 1/4 of the standard chunk size
                 // is an estimate to lower the average number of levels done
                 // sequentially
-                std::size_t chunk_size = execution::get_chunk_size(
-                    policy.parameters(), policy.executor(),
-                    hpx::chrono::null_duration, cores, n);
+                std::size_t chunk_size =
+                    hpx::execution::experimental::get_chunk_size(
+                        policy.parameters(), policy.executor(),
+                        hpx::chrono::null_duration, cores, n);
                 chunk_size /= 4;
 
-                std::size_t max_chunks = execution::maximal_number_of_chunks(
-                    policy.parameters(), policy.executor(), cores, n);
+                std::size_t max_chunks =
+                    hpx::execution::experimental::maximal_number_of_chunks(
+                        policy.parameters(), policy.executor(), cores, n);
 
                 util::detail::adjust_chunk_size_and_max_chunks(
                     cores, n, chunk_size, max_chunks);

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

@@ -390,13 +390,15 @@ namespace hpx::parallel {
             {
                 // figure out the chunk size to use
                 std::size_t const cores =
-                    execution::processing_units_count(policy.parameters(),
-                        policy.executor(), hpx::chrono::null_duration, nelem);
+                    hpx::execution::experimental::processing_units_count(
+                        policy.parameters(), policy.executor(),
+                        hpx::chrono::null_duration, nelem);
 
                 // number of elements to sort
-                std::size_t chunk_size = execution::get_chunk_size(
-                    policy.parameters(), policy.executor(),
-                    hpx::chrono::null_duration, cores, nelem);
+                std::size_t chunk_size =
+                    hpx::execution::experimental::get_chunk_size(
+                        policy.parameters(), policy.executor(),
+                        hpx::chrono::null_duration, cores, nelem);
 
                 hpx::future<Iter> left = execution::async_execute(
                     policy.executor(), sort_thread_helper(), policy, first,

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

@@ -670,19 +670,19 @@ namespace hpx::parallel {
                     }
                     else
                     {
-                        std::size_t const cores =
-                            execution::processing_units_count(
-                                policy.parameters(), policy.executor(),
-                                hpx::chrono::null_duration, size);
+                        std::size_t const cores = hpx::execution::experimental::
+                            processing_units_count(policy.parameters(),
+                                policy.executor(), hpx::chrono::null_duration,
+                                size);
 
-                        std::size_t chunk_size = execution::get_chunk_size(
-                            policy.parameters(), policy.executor(),
-                            hpx::chrono::null_duration, cores, size);
+                        std::size_t chunk_size =
+                            hpx::execution::experimental::get_chunk_size(
+                                policy.parameters(), policy.executor(),
+                                hpx::chrono::null_duration, cores, size);
 
-                        std::size_t max_chunks =
-                            execution::maximal_number_of_chunks(
-                                policy.parameters(), policy.executor(), cores,
-                                size);
+                        std::size_t max_chunks = hpx::execution::experimental::
+                            maximal_number_of_chunks(policy.parameters(),
+                                policy.executor(), cores, size);
 
                         util::detail::adjust_chunk_size_and_max_chunks(
                             cores, size, chunk_size, max_chunks);
@@ -1341,9 +1341,10 @@ namespace hpx::parallel {
                 if (first == last)
                     return first;
 
-                std::size_t const cores = execution::processing_units_count(
-                    policy.parameters(), policy.executor(),
-                    hpx::chrono::null_duration, std::distance(first, last));
+                std::size_t const cores =
+                    hpx::execution::experimental::processing_units_count(
+                        policy.parameters(), policy.executor(),
+                        hpx::chrono::null_duration, std::distance(first, last));
 
                 // TODO: Find better block size.
                 constexpr std::size_t block_size =

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

@@ -1,4 +1,4 @@
-//  Copyright (c) 2007-2023 Hartmut Kaiser
+//  Copyright (c) 2007-2024 Hartmut Kaiser
 //  Copyright (c) 2021-2022 Chuanqiu He
 //
 //  SPDX-License-Identifier: BSL-1.0
@@ -225,9 +225,9 @@ namespace hpx::parallel {
 
             // get number of cores currently used
             std::size_t const cores =
-                parallel::execution::processing_units_count(policy.parameters(),
-                    policy.executor(), hpx::chrono::null_duration,
-                    size_left + size_right);
+                hpx::execution::experimental::processing_units_count(
+                    policy.parameters(), policy.executor(),
+                    hpx::chrono::null_duration, size_left + size_right);
 
             // get currently used first core
             std::size_t first_core =
@@ -257,11 +257,13 @@ namespace hpx::parallel {
             auto p = policy(hpx::execution::task);
 
             auto left_policy =
-                execution::with_processing_units_count(p, cores_left);
-            auto right_policy = execution::with_processing_units_count(
-                hpx::execution::experimental::with_first_core(
-                    p, cores == 1 ? first_core : first_core + cores_left),
-                cores_right);
+                hpx::execution::experimental::with_processing_units_count(
+                    p, cores_left);
+            auto right_policy =
+                hpx::execution::experimental::with_processing_units_count(
+                    hpx::execution::experimental::with_first_core(
+                        p, cores == 1 ? first_core : first_core + cores_left),
+                    cores_right);
 
             detail::reverse<FwdIter> r;
 

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

@@ -289,15 +289,18 @@ namespace hpx::parallel {
 
             // figure out the chunk size to use
             std::size_t const cores =
-                execution::processing_units_count(policy.parameters(),
-                    policy.executor(), hpx::chrono::null_duration, count);
-
-            std::size_t max_chunks = execution::maximal_number_of_chunks(
-                policy.parameters(), policy.executor(), cores, count);
-
-            std::size_t chunk_size = execution::get_chunk_size(
-                policy.parameters(), policy.executor(),
-                hpx::chrono::null_duration, cores, count);
+                hpx::execution::experimental::processing_units_count(
+                    policy.parameters(), policy.executor(),
+                    hpx::chrono::null_duration, count);
+
+            std::size_t max_chunks =
+                hpx::execution::experimental::maximal_number_of_chunks(
+                    policy.parameters(), policy.executor(), cores, count);
+
+            std::size_t chunk_size =
+                hpx::execution::experimental::get_chunk_size(
+                    policy.parameters(), policy.executor(),
+                    hpx::chrono::null_duration, cores, count);
 
             util::detail::adjust_chunk_size_and_max_chunks(
                 cores, count, max_chunks, chunk_size);

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

@@ -222,15 +222,18 @@ namespace hpx::parallel {
 
                 // figure out the chunk size to use
                 std::size_t cores =
-                    execution::processing_units_count(policy.parameters(),
-                        policy.executor(), hpx::chrono::null_duration, count);
-
-                std::size_t max_chunks = execution::maximal_number_of_chunks(
-                    policy.parameters(), policy.executor(), cores, count);
-
-                std::size_t chunk_size = execution::get_chunk_size(
-                    policy.parameters(), policy.executor(),
-                    hpx::chrono::null_duration, cores, count);
+                    hpx::execution::experimental::processing_units_count(
+                        policy.parameters(), policy.executor(),
+                        hpx::chrono::null_duration, count);
+
+                std::size_t max_chunks =
+                    hpx::execution::experimental::maximal_number_of_chunks(
+                        policy.parameters(), policy.executor(), cores, count);
+
+                std::size_t chunk_size =
+                    hpx::execution::experimental::get_chunk_size(
+                        policy.parameters(), policy.executor(),
+                        hpx::chrono::null_duration, cores, count);
 
                 util::detail::adjust_chunk_size_and_max_chunks(
                     cores, count, max_chunks, chunk_size);