diff --git a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/export_definitions.hpp b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/export_definitions.hpp index 7b4b2c251f34..f5db645ab2be 100644 --- a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/export_definitions.hpp +++ b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/export_definitions.hpp @@ -9,16 +9,14 @@ #include #if defined(HPX_PARTITIONED_VECTOR_MODULE_EXPORTS) -# define HPX_PARTITIONED_VECTOR_EXPORT HPX_SYMBOL_EXPORT +#define HPX_PARTITIONED_VECTOR_EXPORT HPX_SYMBOL_EXPORT #else -# define HPX_PARTITIONED_VECTOR_EXPORT HPX_SYMBOL_IMPORT +#define HPX_PARTITIONED_VECTOR_EXPORT HPX_SYMBOL_IMPORT #endif #if defined(HPX_GCC_VERSION) && !defined(HPX_CLANG_VERSION) -#define HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT HPX_PARTITIONED_VECTOR_EXPORT +#define HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT \ + HPX_PARTITIONED_VECTOR_EXPORT #else #define HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT #endif - - - diff --git a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_component_decl.hpp b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_component_decl.hpp index 2c4baabd8d53..9d3f7ea7daf5 100644 --- a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_component_decl.hpp +++ b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_component_decl.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2014 Anuj R. Sharma -// Copyright (c) 2014-2017 Hartmut Kaiser +// Copyright (c) 2014-2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -9,11 +9,12 @@ #pragma once -/// \brief The partitioned_vector_partition as the hpx component is defined here. +/// \brief The partitioned_vector_partition as the hpx component is defined +/// here. /// -/// The partitioned_vector_partition is the wrapper to the stl vector class except all API's -/// are defined as component action. All the API's in stubs classes are -/// asynchronous API which return the futures. +/// The partitioned_vector_partition is the wrapper to the stl vector class +/// except all APIs are defined as component action. All the APIs in stubs +/// classes are asynchronous API which return the futures. #include #include @@ -38,10 +39,11 @@ #include -namespace hpx { namespace server { +namespace hpx::server { + /// \brief This is the basic wrapper class for stl vector. /// - /// This contain the implementation of the partitioned_vector_partition's + /// This contains the implementation of the partitioned_vector_partition's /// component functionality. template class partitioned_vector @@ -49,16 +51,15 @@ namespace hpx { namespace server { components::component_base>> { public: - typedef Data data_type; + using data_type = Data; - typedef typename data_type::allocator_type allocator_type; - typedef typename data_type::size_type size_type; - typedef typename data_type::iterator iterator_type; - typedef typename data_type::const_iterator const_iterator_type; + using allocator_type = typename data_type::allocator_type; + using size_type = typename data_type::size_type; + using iterator_type = typename data_type::iterator; + using const_iterator_type = typename data_type::const_iterator; - typedef components::locking_hook< - components::component_base>> - base_type; + using base_type = components::locking_hook< + components::component_base>>; data_type partitioned_vector_partition_; @@ -110,7 +111,7 @@ namespace hpx { namespace server { const_iterator_type cend() const; /////////////////////////////////////////////////////////////////////// - // Capacity Related API's in the server class + // Capacity Related APIs in the server class /////////////////////////////////////////////////////////////////////// /// Returns the number of elements @@ -143,9 +144,8 @@ namespace hpx { namespace server { /// partitioned_vector_partition capacity, the function causes the /// partitioned_vector_partition to /// reallocate its storage increasing its capacity to n (or greater). - /// In other cases the partitioned_vector_partition capacity does not - /// got affected. - /// It does not change the partitioned_vector_partition size. + /// In other cases the partitioned_vector_partition capacity is not + /// affected. It does not change the partitioned_vector_partition size. /// /// \param n minimum capacity of partitioned_vector_partition /// @@ -153,7 +153,7 @@ namespace hpx { namespace server { void reserve(size_type n); /////////////////////////////////////////////////////////////////////// - // Element access API's + // Element access APIs /////////////////////////////////////////////////////////////////////// /// Return the element at the position \a pos in the @@ -196,7 +196,7 @@ namespace hpx { namespace server { T back() const; /////////////////////////////////////////////////////////////////////// - // Modifiers API's in server class + // Modifiers APIs in server class /////////////////////////////////////////////////////////////////////// /// Assigns new contents to the partitioned_vector_partition, replacing @@ -275,7 +275,7 @@ namespace hpx { namespace server { HPX_DEFINE_COMPONENT_DIRECT_ACTION(partitioned_vector, get_copied_data) HPX_DEFINE_COMPONENT_DIRECT_ACTION(partitioned_vector, set_data) }; -}} // namespace hpx::server +} // namespace hpx::server /////////////////////////////////////////////////////////////////////////////// #define HPX_REGISTER_PARTITIONED_VECTOR_DECLARATION(...) \ @@ -319,17 +319,16 @@ namespace hpx { namespace server { /**/ namespace hpx { + template class partitioned_vector_partition : public components::client_base, server::partitioned_vector> { - private: - typedef hpx::server::partitioned_vector server_type; - typedef hpx::components::client_base< - partitioned_vector_partition, - server::partitioned_vector> - base_type; + using server_type = hpx::server::partitioned_vector; + using base_type = + hpx::components::client_base, + server::partitioned_vector>; public: partitioned_vector_partition() = default; @@ -343,7 +342,7 @@ namespace hpx { std::shared_ptr> get_ptr() const; /////////////////////////////////////////////////////////////////////// - // Capacity related API's in partitioned_vector_partition client class + // Capacity related APIs in partitioned_vector_partition client class /// Asynchronously return the size of the partitioned_vector_partition /// component. @@ -415,7 +414,7 @@ namespace hpx { // this->base_type::reserve_async(this->get_id(), n).get(); // } - // Element Access API's in Client class + // Element Access APIs in Client class /// Returns the value at position \a pos in the partitioned_vector_partition /// component. @@ -478,7 +477,7 @@ namespace hpx { // return back_async().get(); // } - // Modifiers API's in client class + // Modifiers APIs in client class // void assign(std::size_t n, T const& val) // { // HPX_ASSERT(this->get_id()); @@ -556,7 +555,7 @@ namespace hpx { /// Returns a copy of the data owned by the partitioned_vector_partition /// component. /// - /// \return This returns the data as an hpx::future + /// \return This returns the data as a hpx::future /// hpx::future get_copied_data() const; diff --git a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_component_impl.hpp b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_component_impl.hpp index a2c139ca5dab..dd011ba4738f 100644 --- a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_component_impl.hpp +++ b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_component_impl.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2014 Anuj R. Sharma -// Copyright (c) 2014-2022 Hartmut Kaiser +// Copyright (c) 2014-2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -10,16 +10,11 @@ #include #include #include -#include #include -#include -#include -#include #include #include #include #include -#include #include @@ -30,7 +25,8 @@ #include #include -namespace hpx { namespace server { +namespace hpx::server { + /////////////////////////////////////////////////////////////////////////// template HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT @@ -270,7 +266,7 @@ namespace hpx { namespace server { { partitioned_vector_partition_.clear(); } -}} // namespace hpx::server +} // namespace hpx::server /////////////////////////////////////////////////////////////////////////////// #define HPX_REGISTER_PARTITIONED_VECTOR(...) \ @@ -317,6 +313,7 @@ namespace hpx { namespace server { /**/ namespace hpx { + template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT partitioned_vector_partition::partitioned_vector_partition( @@ -374,7 +371,7 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT hpx::future partitioned_vector_partition::resize_async( - std::size_t n, T const& val /*= T()*/) + [[maybe_unused]] std::size_t n, [[maybe_unused]] T const& val /*= T()*/) { #if !defined(HPX_COMPUTE_DEVICE_CODE) HPX_ASSERT(this->get_id()); @@ -382,8 +379,6 @@ namespace hpx { this->get_id(), n, val); #else HPX_ASSERT(false); - HPX_UNUSED(n); - HPX_UNUSED(val); return hpx::make_ready_future(); #endif } @@ -398,7 +393,8 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT hpx::future - partitioned_vector_partition::get_value(std::size_t pos) const + partitioned_vector_partition::get_value( + [[maybe_unused]] std::size_t pos) const { #if !defined(HPX_COMPUTE_DEVICE_CODE) HPX_ASSERT(this->get_id()); @@ -406,7 +402,6 @@ namespace hpx { this->get_id(), pos); #else HPX_ASSERT(false); - HPX_UNUSED(pos); return hpx::future{}; #endif } @@ -422,7 +417,7 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT hpx::future> partitioned_vector_partition::get_values( - std::vector const& pos) const + [[maybe_unused]] std::vector const& pos) const { #if !defined(HPX_COMPUTE_DEVICE_CODE) HPX_ASSERT(this->get_id()); @@ -430,7 +425,6 @@ namespace hpx { this->get_id(), pos); #else HPX_ASSERT(false); - HPX_UNUSED(pos); return hpx::make_ready_future(std::vector{}); #endif } @@ -453,7 +447,8 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT hpx::future - partitioned_vector_partition::set_value(std::size_t pos, T&& val) + partitioned_vector_partition::set_value( + [[maybe_unused]] std::size_t pos, [[maybe_unused]] T&& val) { #if !defined(HPX_COMPUTE_DEVICE_CODE) HPX_ASSERT(this->get_id()); @@ -461,8 +456,6 @@ namespace hpx { this->get_id(), pos, HPX_MOVE(val)); #else HPX_ASSERT(false); - HPX_UNUSED(pos); - HPX_UNUSED(val); return hpx::make_ready_future(); #endif } @@ -470,7 +463,7 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT hpx::future partitioned_vector_partition::set_value( - std::size_t pos, T const& val) + [[maybe_unused]] std::size_t pos, [[maybe_unused]] T const& val) { #if !defined(HPX_COMPUTE_DEVICE_CODE) HPX_ASSERT(this->get_id()); @@ -478,8 +471,6 @@ namespace hpx { this->get_id(), pos, val); #else HPX_ASSERT(false); - HPX_UNUSED(pos); - HPX_UNUSED(val); return hpx::make_ready_future(); #endif } @@ -495,7 +486,8 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT hpx::future partitioned_vector_partition::set_values( - std::vector const& pos, std::vector const& val) + [[maybe_unused]] std::vector const& pos, + [[maybe_unused]] std::vector const& val) { #if !defined(HPX_COMPUTE_DEVICE_CODE) HPX_ASSERT(this->get_id()); @@ -503,8 +495,6 @@ namespace hpx { this->get_id(), pos, val); #else HPX_ASSERT(false); - HPX_UNUSED(pos); - HPX_UNUSED(val); return hpx::make_ready_future(); #endif } @@ -512,8 +502,8 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT typename partitioned_vector_partition::server_type::data_type - partitioned_vector_partition::get_copied_data( - launch::sync_policy) const + partitioned_vector_partition::get_copied_data( + launch::sync_policy) const { return get_copied_data().get(); } @@ -545,7 +535,7 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT hpx::future partitioned_vector_partition::set_data( - typename server_type::data_type&& other) const + [[maybe_unused]] typename server_type::data_type&& other) const { #if !defined(HPX_COMPUTE_DEVICE_CODE) HPX_ASSERT(this->get_id()); @@ -553,7 +543,6 @@ namespace hpx { this->get_id(), HPX_MOVE(other)); #else HPX_ASSERT(false); - HPX_UNUSED(other); return hpx::make_ready_future(); #endif } diff --git a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_decl.hpp b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_decl.hpp index 929ca1edcd49..c4e582c086c4 100644 --- a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_decl.hpp +++ b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_decl.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2014 Anuj R. Sharma -// Copyright (c) 2014-2022 Hartmut Kaiser +// Copyright (c) 2014-2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -13,12 +13,9 @@ #include #include #include -#include #include #include -#include #include -#include #include #include #include @@ -47,15 +44,11 @@ namespace hpx::server { /////////////////////////////////////////////////////////////////////////// struct partitioned_vector_config_data { - // Each partition is described by it's corresponding client object, its + // Each partition is described by its corresponding client object, its // size, and locality id. struct partition_data { - partition_data() - : size_(0) - , locality_id_(naming::invalid_locality_id) - { - } + partition_data() = default; partition_data(id_type const& part, std::size_t size, std::uint32_t locality_id) @@ -71,8 +64,8 @@ namespace hpx::server { } hpx::id_type partition_; - std::size_t size_; - std::uint32_t locality_id_; + std::size_t size_ = 0; + std::uint32_t locality_id_ = naming::invalid_locality_id; private: friend class hpx::serialization::access; @@ -80,14 +73,11 @@ namespace hpx::server { template void serialize(Archive& ar, unsigned) { - ar& partition_& size_& locality_id_; + ar & partition_ & size_ & locality_id_; } }; - partitioned_vector_config_data() - : size_(0) - { - } + partitioned_vector_config_data() = default; partitioned_vector_config_data( std::size_t size, std::vector&& partitions) @@ -96,7 +86,7 @@ namespace hpx::server { { } - std::size_t size_; + std::size_t size_ = 0; std::vector partitions_; private: @@ -105,7 +95,7 @@ namespace hpx::server { template void serialize(Archive& ar, unsigned) { - ar& size_& partitions_; + ar & size_ & partitions_; } }; } // namespace hpx::server @@ -120,7 +110,7 @@ namespace hpx { /// hpx::partitioned_vector is a sequence container that encapsulates /// dynamic size arrays. /// - /// \note A hpx::partitioned_vector does not stores all elements in a + /// \note A hpx::partitioned_vector does not store all elements in a /// contiguous block of memory. Memory is contiguous inside each of /// the segmented partitions only. /// @@ -139,7 +129,7 @@ namespace hpx { /// /// This contains the client side implementation of the /// hpx::partitioned_vector. This - /// class defines the synchronous and asynchronous API's for each of the + /// class defines the synchronous and asynchronous APIs for each of the /// exposed functionalities. /// /// \tparam T The type of the elements. The requirements that are imposed @@ -155,45 +145,41 @@ namespace hpx { server::partitioned_vector_config_data>> { public: - typedef typename Data::allocator_type allocator_type; + using allocator_type = typename Data::allocator_type; - typedef typename Data::size_type size_type; - typedef typename Data::difference_type difference_type; + using size_type = typename Data::size_type; + using difference_type = typename Data::difference_type; - typedef T value_type; - typedef T reference; - typedef T const const_reference; + using value_type = T; + using reference = T; + using const_reference = T const; #if defined(HPX_NATIVE_MIC) typedef T* pointer; typedef T const* const_pointer; #else - typedef typename std::allocator_traits::pointer pointer; - typedef typename std::allocator_traits::const_pointer - const_pointer; + using pointer = typename std::allocator_traits::pointer; + using const_pointer = + typename std::allocator_traits::const_pointer; #endif private: - typedef hpx::components::client_base> - base_type; + server::partitioned_vector_config_data>>; - typedef hpx::server::partitioned_vector - partitioned_vector_partition_server; - typedef hpx::partitioned_vector_partition - partitioned_vector_partition_client; + using partitioned_vector_partition_server = + hpx::server::partitioned_vector; + using partitioned_vector_partition_client = + hpx::partitioned_vector_partition; struct partition_data : server::partitioned_vector_config_data::partition_data { - typedef server::partitioned_vector_config_data::partition_data - base_type; + using base_type = + server::partitioned_vector_config_data::partition_data; - partition_data() - : base_type() - { - } + partition_data() = default; partition_data(id_type const& part, std::size_t size, std::uint32_t locality_id) @@ -201,7 +187,7 @@ namespace hpx { { } - partition_data(base_type&& base) + partition_data(base_type&& base) noexcept : base_type(HPX_MOVE(base)) { } @@ -210,9 +196,9 @@ namespace hpx { }; // The list of partitions belonging to this vector. - // Each partition is described by it's corresponding client object, its + // Each partition is described by its corresponding client object, its // size, and locality id. - typedef std::vector partitions_vector_type; + using partitions_vector_type = std::vector; size_type size_; // overall size of the vector size_type partition_size_; // cached partition size @@ -222,28 +208,27 @@ namespace hpx { partitions_vector_type partitions_; public: - typedef segmented::vector_iterator iterator; - typedef segmented::const_vector_iterator const_iterator; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; - - typedef segmented::local_vector_iterator local_iterator; - typedef segmented::const_local_vector_iterator - const_local_iterator; - - typedef segmented::segment_vector_iterator - segment_iterator; - typedef segmented::const_segment_vector_iterator - const_segment_iterator; - - typedef segmented::local_segment_vector_iterator - local_segment_iterator; - typedef segmented::local_segment_vector_iterator - const_local_segment_iterator; + using iterator = segmented::vector_iterator; + using const_iterator = segmented::const_vector_iterator; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + + using local_iterator = segmented::local_vector_iterator; + using const_local_iterator = + segmented::const_local_vector_iterator; + + using segment_iterator = segmented::segment_vector_iterator; + using const_segment_iterator = + segmented::const_segment_vector_iterator; + + using local_segment_iterator = + segmented::local_segment_vector_iterator; + using const_local_segment_iterator = + segmented::local_segment_vector_iterator; private: friend class segmented::vector_iterator; @@ -301,7 +286,7 @@ namespace hpx { SegmentIter const& it, size_type local_index) const { std::size_t part_size = partition_size_; - if (part_size == std::size_t(-1) || part_size == 0) + if (part_size == static_cast(-1) || part_size == 0) return size_; std::size_t segment = it.base() - partitions_.cbegin(); @@ -331,8 +316,8 @@ namespace hpx { protected: /// \cond NOINTERNAL - typedef std::pair> - bulk_locality_result; + using bulk_locality_result = + std::pair>; /// \endcond template @@ -362,8 +347,8 @@ namespace hpx { public: /// Default Constructor which create hpx::partitioned_vector with - /// \a num_partitions = 0 and \a partition_size = 0. Hence overall size - /// of the vector is 0. + /// \a num_partitions = 0 and \a partition_size = 0. Hence, the overall + /// size of the vector is 0. /// partitioned_vector(); @@ -372,10 +357,10 @@ namespace hpx { /// /// \param size The overall size of the vector /// - partitioned_vector(size_type size); + explicit partitioned_vector(size_type size); - /// Constructor which create and initialize vector with the - /// given \a where all elements are initialized with \a val. + /// Constructor which create and initialize vector with the given + /// \a where all elements are initialized with \a val. /// /// \param size The overall size of the vector /// \param val Default value for the elements in vector @@ -384,8 +369,8 @@ namespace hpx { /// partitioned_vector(size_type size, T const& val); - /// Constructor which create and initialize vector of size - /// \a size using the given distribution policy. + /// Constructor which create and initialize vector of \a size using the + /// given distribution policy. /// /// \param size The overall size of the vector /// \param policy The distribution policy to use @@ -394,9 +379,8 @@ namespace hpx { /// template partitioned_vector(size_type size, DistPolicy const& policy, - typename std::enable_if< - traits::is_distribution_policy::value>::type* = - nullptr); + std::enable_if_t< + traits::is_distribution_policy::value>* = nullptr); /// Constructor which create and initialize vector with the /// given \a where all elements are initialized with \a val and @@ -411,9 +395,8 @@ namespace hpx { template partitioned_vector(size_type size, T const& val, DistPolicy const& policy, - typename std::enable_if< - traits::is_distribution_policy::value>::type* = - nullptr); + std::enable_if_t< + traits::is_distribution_policy::value>* = nullptr); /// Copy construction performs a deep copy of the right hand side /// vector. @@ -432,7 +415,7 @@ namespace hpx { , partitions_(HPX_MOVE(rhs.partitions_)) { rhs.size_ = 0; - rhs.partition_size_ = std::size_t(-1); + rhs.partition_size_ = static_cast(-1); } public: @@ -490,13 +473,13 @@ namespace hpx { partitions_ = HPX_MOVE(rhs.partitions_); rhs.size_ = 0; - rhs.partition_size_ = std::size_t(-1); + rhs.partition_size_ = static_cast(-1); } return *this; } /////////////////////////////////////////////////////////////////////// - // Capacity related API's in vector class + // Capacity related APIs in vector class /// \brief Compute the size as the number of elements it contains. /// @@ -508,7 +491,7 @@ namespace hpx { } // - // Element access API's in vector class + // Element access APIs in vector class // /// Returns the element at position \a pos in the vector container. @@ -618,8 +601,8 @@ namespace hpx { .get_values(pos); } - /// Returns the elements at the positions \a pos - /// in the vector container. + /// Returns the elements at the positions \a pos in the vector + /// container. /// /// \param pos Global position of the element in the vector /// @@ -627,25 +610,22 @@ namespace hpx { /// \a pos. /// future> get_values( - std::vector const& pos_vec) const + std::vector const& pos) const { // check if position vector is empty // the following code needs at least one element. - if (pos_vec.empty()) + if (pos.empty()) return make_ready_future(std::vector()); // current partition index of the block - size_type part_cur = get_partition(pos_vec[0]); + size_type part_cur = get_partition(pos[0]); // iterator to the begin of current block - typename std::vector::const_iterator part_begin = - pos_vec.begin(); + auto part_begin = pos.begin(); // vector holding futures of the values for all blocks std::vector>> part_values_future; - for (typename std::vector::const_iterator it = - pos_vec.begin(); - it != pos_vec.end(); ++it) + for (auto it = pos.begin(); it != pos.end(); ++it) { // get the partition of the current position size_type part = get_partition(*it); @@ -657,34 +637,31 @@ namespace hpx { // if the partition of the current position is NOT the same // as the positions before the block ends here - else - { - // this is the end of a block containing indexes ('pos') - // of the same partition ('part'). - // get async values for this block - part_values_future.push_back(get_values(part_cur, - get_local_indices( - std::vector(part_begin, it)))); - // reset block variables to start a new one from here - part_cur = part; - part_begin = it; - } + // this is the end of a block containing indexes ('pos') + // of the same partition ('part'). + // get async values for this block + part_values_future.push_back(get_values(part_cur, + get_local_indices(std::vector(part_begin, it)))); + + // reset block variables to start a new one from here + part_cur = part; + part_begin = it; } // the end of the vector is also an end of a block // get async values for this block part_values_future.push_back(get_values(part_cur, get_local_indices( - std::vector(part_begin, pos_vec.end())))); + std::vector(part_begin, pos.end())))); // This helper function unwraps the vectors from each partition // and merge them to one vector auto merge_func = - [&pos_vec](std::vector>>&& part_values_f) + [&pos](std::vector>>&& part_values_f) -> std::vector { std::vector values; - values.reserve(pos_vec.size()); + values.reserve(pos.size()); for (future>& part_f : part_values_f) { @@ -710,9 +687,9 @@ namespace hpx { /// \a pos. /// std::vector get_values( - launch::sync_policy, std::vector const& pos_vec) const + launch::sync_policy, std::vector const& pos) const { - return get_values(pos_vec).get(); + return get_values(pos).get(); } // //FRONT (never throws exception) @@ -1047,8 +1024,8 @@ namespace hpx { } // //CLEAR - // //TODO if number of partitions is kept constant every time then - // // clear should modified (clear each partitioned_vector_partition + // // TODO if number of partitions is kept constant every time then + // // clear should modify (clear each partitioned_vector_partition // // one by one). // void clear() // { diff --git a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_fwd.hpp b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_fwd.hpp index feefa1896fcd..728d42404ddf 100644 --- a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_fwd.hpp +++ b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_fwd.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2014 Anuj R. Sharma -// Copyright (c) 2014-2016 Hartmut Kaiser +// Copyright (c) 2014-2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -12,24 +12,28 @@ #include -namespace hpx -{ +namespace hpx { + /////////////////////////////////////////////////////////////////////////// template > class partitioned_vector; namespace segmented { - template class local_vector_iterator; - template class const_local_vector_iterator; + template + class local_vector_iterator; + template + class const_local_vector_iterator; template class local_raw_vector_iterator; template class const_local_raw_vector_iterator; - template class vector_iterator; - template class const_vector_iterator; + template + class vector_iterator; + template + class const_vector_iterator; template class segment_vector_iterator; @@ -38,15 +42,14 @@ namespace hpx template class local_segment_vector_iterator; - } + } // namespace segmented + + namespace server { - namespace server - { template > class partitioned_vector; template > class partitioned_vector_partition; - } -} - + } // namespace server +} // namespace hpx diff --git a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_impl.hpp b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_impl.hpp index bce6ca1d2229..74eea0a28318 100644 --- a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_impl.hpp +++ b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_impl.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2014 Anuj R. Sharma -// Copyright (c) 2014-2022 Hartmut Kaiser +// Copyright (c) 2014-2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -12,7 +12,6 @@ #include #include #include -#include #include #include #include @@ -22,7 +21,6 @@ #include #include #include -#include #include #include @@ -74,7 +72,7 @@ namespace hpx { std::vector> ptrs; ptrs.reserve(partitions_.size()); - typedef typename partitions_vector_type::const_iterator const_iterator; + using const_iterator = typename partitions_vector_type::const_iterator; std::size_t l = 0; const_iterator end = partitions_.cend(); @@ -95,11 +93,11 @@ namespace hpx { template */> HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT hpx::future - partitioned_vector::connect_to_helper(id_type id) + partitioned_vector::connect_to_helper([[maybe_unused]] id_type id) { #if !defined(HPX_COMPUTE_DEVICE_CODE) - typedef typename components::server::distributed_metadata_base< - server::partitioned_vector_config_data>::get_action act; + using act = components::server::distributed_metadata_base< + server::partitioned_vector_config_data>::get_action; return async(act(), id).then( [HPX_CXX20_CAPTURE_THIS(=)]( @@ -108,7 +106,6 @@ namespace hpx { }); #else HPX_ASSERT(false); - HPX_UNUSED(id); return hpx::make_ready_future(); #endif } @@ -168,8 +165,8 @@ namespace hpx { partitioned_vector::partitioned_vector(future&& f) { f.share().then([HPX_CXX20_CAPTURE_THIS(=)]( - shared_future&& f) -> hpx::future { - return connect_to_helper(f.get()); + shared_future&& fut) -> hpx::future { + return connect_to_helper(fut.get()); }); } @@ -192,10 +189,11 @@ namespace hpx { HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT std::size_t partitioned_vector::get_local_index(size_type global_index) const { - if (global_index == size_ || partition_size_ == std::size_t(-1) || + if (global_index == size_ || + partition_size_ == static_cast(-1) || partition_size_ == 0) { - return std::size_t(-1); + return static_cast(-1); } return (partition_size_ != size_) ? (global_index % partition_size_) : @@ -219,7 +217,7 @@ namespace hpx { partitioned_vector::get_local_iterator( size_type global_index) const { - HPX_ASSERT(global_index != std::size_t(-1)); + HPX_ASSERT(global_index != static_cast(-1)); std::size_t part = get_partition(global_index); if (part == partitions_.size()) @@ -231,7 +229,7 @@ namespace hpx { } std::size_t local_index = get_local_index(global_index); - HPX_ASSERT(local_index != std::size_t(-1)); + HPX_ASSERT(local_index != static_cast(-1)); return local_iterator(partitions_[part].partition_, local_index, partitions_[part].local_data_); @@ -243,7 +241,7 @@ namespace hpx { partitioned_vector::get_const_local_iterator( size_type global_index) const { - HPX_ASSERT(global_index != std::size_t(-1)); + HPX_ASSERT(global_index != static_cast(-1)); std::size_t part = get_partition(global_index); if (part == partitions_.size()) @@ -255,7 +253,7 @@ namespace hpx { } std::size_t local_index = get_local_index(global_index); - HPX_ASSERT(local_index != std::size_t(-1)); + HPX_ASSERT(local_index != static_cast(-1)); return const_local_iterator(partitions_[part].partition_, local_index, partitions_[part].local_data_); @@ -295,9 +293,8 @@ namespace hpx { partitioned_vector::create_helper1( DistPolicy const& policy, std::size_t count, std::size_t size) { - typedef - typename partitioned_vector_partition_client::server_component_type - component_type; + using component_type = + typename partitioned_vector_partition_client::server_component_type; return policy.template bulk_create(count, size); } @@ -309,9 +306,8 @@ namespace hpx { partitioned_vector::create_helper2(DistPolicy const& policy, std::size_t count, std::size_t size, T const& val) { - typedef - typename partitioned_vector_partition_client::server_component_type - component_type; + using component_type = + typename partitioned_vector_partition_client::server_component_type; return policy.template bulk_create(count, size, val); } @@ -426,14 +422,15 @@ namespace hpx { HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT void partitioned_vector::copy_from(partitioned_vector const& rhs) { - typedef typename partitions_vector_type::const_iterator const_iterator; + using const_iterator = typename partitions_vector_type::const_iterator; std::vector> objs; const_iterator end = rhs.partitions_.end(); for (const_iterator it = rhs.partitions_.begin(); it != end; ++it) { - typedef typename partitioned_vector_partition_client:: - server_component_type component_type; + using component_type = + typename partitioned_vector_partition_client:: + server_component_type; objs.push_back( hpx::components::copy(it->partition_)); } @@ -475,7 +472,7 @@ namespace hpx { HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT partitioned_vector::partitioned_vector() : size_(0) - , partition_size_(std::size_t(-1)) + , partition_size_(static_cast(-1)) { } @@ -483,7 +480,7 @@ namespace hpx { HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT partitioned_vector::partitioned_vector(size_type size) : size_(size) - , partition_size_(std::size_t(-1)) + , partition_size_(static_cast(-1)) { if (size != 0) create(hpx::container_layout); @@ -494,7 +491,7 @@ namespace hpx { partitioned_vector::partitioned_vector( size_type size, T const& val) : size_(size) - , partition_size_(std::size_t(-1)) + , partition_size_(static_cast(-1)) { if (size != 0) create(val, hpx::container_layout); @@ -505,10 +502,9 @@ namespace hpx { HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT partitioned_vector::partitioned_vector(size_type size, DistPolicy const& policy, - typename std::enable_if< - traits::is_distribution_policy::value>::type*) + std::enable_if_t::value>*) : size_(size) - , partition_size_(std::size_t(-1)) + , partition_size_(static_cast(-1)) { if (size != 0) create(policy); @@ -519,10 +515,10 @@ namespace hpx { HPX_PARTITIONED_VECTOR_SPECIALIZATION_EXPORT partitioned_vector::partitioned_vector(size_type size, T const& val, DistPolicy const& policy, - typename std::enable_if::value>::type* /*= nullptr*/) + std::enable_if_t< + traits::is_distribution_policy::value>* /*= nullptr*/) : size_(size) - , partition_size_(std::size_t(-1)) + , partition_size_(static_cast(-1)) { if (size != 0) create(val, policy); diff --git a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_predef.hpp b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_predef.hpp index 5fdcef40de5b..7a821d7d777d 100644 --- a/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_predef.hpp +++ b/components/containers/partitioned_vector/include/hpx/components/containers/partitioned_vector/partitioned_vector_predef.hpp @@ -10,8 +10,8 @@ #include #include -#include #include +#include #include #include @@ -54,10 +54,12 @@ extern template hpx::partitioned_vector>; +extern template class hpx::server::partitioned_vector>; extern template class hpx::partitioned_vector_partition>; -extern template class hpx::partitioned_vector>; +extern template class hpx::partitioned_vector>; extern template hpx::partitioned_vector>::partitioned_vector(size_type, hpx::container_distribution_policy const&, void*); @@ -85,4 +87,3 @@ extern template hpx::partitioned_vector #include #include -#include #include #include #include -#include -namespace hpx { namespace segmented { +namespace hpx::segmented { + /////////////////////////////////////////////////////////////////////////// // This class wraps plain a partitioned_vector<>::iterator or // partitioned_vector<>::const_iterator @@ -43,16 +42,14 @@ namespace hpx { namespace segmented { : public hpx::util::iterator_adaptor< local_raw_vector_iterator, BaseIter> { - private: - typedef hpx::util::iterator_adaptor< - segmented::local_raw_vector_iterator, BaseIter> - base_type; - typedef BaseIter base_iterator; + using base_type = hpx::util::iterator_adaptor< + segmented::local_raw_vector_iterator, BaseIter>; + using base_iterator = BaseIter; public: - typedef segmented::local_vector_iterator local_iterator; - typedef segmented::const_local_vector_iterator - local_const_iterator; + using local_iterator = segmented::local_vector_iterator; + using local_const_iterator = + segmented::const_local_vector_iterator; local_raw_vector_iterator() = default; @@ -92,17 +89,15 @@ namespace hpx { namespace segmented { segmented::const_local_raw_vector_iterator, BaseIter> { - private: - typedef hpx::util::iterator_adaptor< + using base_type = hpx::util::iterator_adaptor< segmented::const_local_raw_vector_iterator, - BaseIter> - base_type; - typedef BaseIter base_iterator; + BaseIter>; + using base_iterator = BaseIter; public: - typedef segmented::const_local_vector_iterator local_iterator; - typedef segmented::const_local_vector_iterator - local_const_iterator; + using local_iterator = segmented::const_local_vector_iterator; + using local_const_iterator = + segmented::const_local_vector_iterator; const_local_raw_vector_iterator() = default; @@ -138,6 +133,7 @@ namespace hpx { namespace segmented { /////////////////////////////////////////////////////////////////////////// namespace detail { + /////////////////////////////////////////////////////////////////////// template struct local_vector_value_proxy @@ -241,20 +237,18 @@ namespace hpx { namespace segmented { std::random_access_iterator_tag, segmented::detail::local_vector_value_proxy> { - private: - typedef hpx::util::iterator_facade< + using base_type = hpx::util::iterator_facade< segmented::local_vector_iterator, T, std::random_access_iterator_tag, - segmented::detail::local_vector_value_proxy> - base_type; + segmented::detail::local_vector_value_proxy>; public: - typedef std::size_t size_type; + using size_type = std::size_t; // constructors local_vector_iterator() : partition_() - , local_index_(size_type(-1)) + , local_index_(static_cast(-1)) { } @@ -276,12 +270,11 @@ namespace hpx { namespace segmented { { } - typedef segmented::local_raw_vector_iterator - local_raw_iterator; - typedef segmented::const_local_raw_vector_iterator - local_raw_const_iterator; + using local_raw_iterator = segmented::local_raw_vector_iterator; + using local_raw_const_iterator = + segmented::const_local_raw_vector_iterator; /////////////////////////////////////////////////////////////////////// local_raw_iterator local() @@ -305,12 +298,12 @@ namespace hpx { namespace segmented { template void load(Archive& ar, unsigned /* version */) { - ar& partition_& local_index_; + ar & partition_ & local_index_; } template void save(Archive& ar, unsigned /* version */) const { - ar& partition_& local_index_; + ar & partition_ & local_index_; } HPX_SERIALIZATION_SPLIT_MEMBER() @@ -397,18 +390,18 @@ namespace hpx { namespace segmented { segmented::detail::const_local_vector_value_proxy> { private: - typedef hpx::util::iterator_facade, - T const, std::random_access_iterator_tag, - segmented::detail::const_local_vector_value_proxy> - base_type; + using base_type = + hpx::util::iterator_facade, + T const, std::random_access_iterator_tag, + segmented::detail::const_local_vector_value_proxy>; public: - typedef std::size_t size_type; + using size_type = std::size_t; // constructors const_local_vector_iterator() : partition_() - , local_index_(size_type(-1)) + , local_index_(static_cast(-1)) { } @@ -438,10 +431,9 @@ namespace hpx { namespace segmented { { } - typedef segmented::const_local_raw_vector_iterator - local_raw_iterator; - typedef local_raw_iterator local_raw_const_iterator; + using local_raw_iterator = segmented::const_local_raw_vector_iterator; + using local_raw_const_iterator = local_raw_iterator; /////////////////////////////////////////////////////////////////////// local_raw_iterator local() @@ -465,12 +457,12 @@ namespace hpx { namespace segmented { template void load(Archive& ar, unsigned /* version */) { - ar& partition_& local_index_; + ar & partition_ & local_index_; } template void save(Archive& ar, unsigned /* version */) const { - ar& partition_& local_index_; + ar & partition_ & local_index_; } HPX_SERIALIZATION_SPLIT_MEMBER() @@ -556,9 +548,8 @@ namespace hpx { namespace segmented { segment_vector_iterator, BaseIter> { private: - typedef hpx::util::iterator_adaptor< - segment_vector_iterator, BaseIter> - base_type; + using base_type = hpx::util::iterator_adaptor< + segment_vector_iterator, BaseIter>; public: segment_vector_iterator() @@ -598,9 +589,8 @@ namespace hpx { namespace segmented { const_segment_vector_iterator, BaseIter> { private: - typedef hpx::util::iterator_adaptor< - const_segment_vector_iterator, BaseIter> - base_type; + using base_type = hpx::util::iterator_adaptor< + const_segment_vector_iterator, BaseIter>; public: const_segment_vector_iterator() @@ -643,8 +633,8 @@ namespace hpx { namespace segmented { template struct is_requested_locality { - typedef typename std::iterator_traits::reference - reference; + using reference = + typename std::iterator_traits::reference; explicit is_requested_locality( std::uint32_t locality_id = naming::invalid_locality_id) @@ -671,11 +661,10 @@ namespace hpx { namespace segmented { std::forward_iterator_tag> { private: - typedef hpx::util::iterator_adaptor< + using base_type = hpx::util::iterator_adaptor< local_segment_vector_iterator, BaseIter, Data, - std::forward_iterator_tag> - base_type; - typedef detail::is_requested_locality predicate; + std::forward_iterator_tag>; + using predicate = detail::is_requested_locality; public: local_segment_vector_iterator() = default; @@ -701,7 +690,7 @@ namespace hpx { namespace segmented { return !data_ || this->base() == end_; } - // increment until predicate is not satisfied any more + // increment until predicate is not satisfied anymore void unsatisfy_predicate() { while (this->base() != end_ && predicate_(*this->base())) @@ -743,7 +732,6 @@ namespace hpx { namespace segmented { data_.reset(); } - private: std::shared_ptr> data_; predicate predicate_; BaseIter end_; @@ -758,25 +746,23 @@ namespace hpx { namespace segmented { std::random_access_iterator_tag, detail::vector_value_proxy> { - private: - typedef hpx::util::iterator_facade, T, - std::random_access_iterator_tag, - detail::vector_value_proxy> - base_type; + using base_type = hpx::util::iterator_facade, + T, std::random_access_iterator_tag, + detail::vector_value_proxy>; public: - typedef std::size_t size_type; - typedef typename partitioned_vector::segment_iterator - segment_iterator; - typedef typename partitioned_vector::local_segment_iterator - local_segment_iterator; - typedef - typename partitioned_vector::local_iterator local_iterator; + using size_type = std::size_t; + using segment_iterator = + typename partitioned_vector::segment_iterator; + using local_segment_iterator = + typename partitioned_vector::local_segment_iterator; + using local_iterator = + typename partitioned_vector::local_iterator; // constructors vector_iterator() : data_(nullptr) - , global_index_(size_type(-1)) + , global_index_(static_cast(-1)) { } @@ -841,7 +827,6 @@ namespace hpx { namespace segmented { return other.global_index_ - global_index_; } - protected: // refer to the vector partitioned_vector* data_; @@ -855,25 +840,23 @@ namespace hpx { namespace segmented { : public hpx::util::iterator_facade, T const, std::random_access_iterator_tag, T const> { - private: - typedef hpx::util::iterator_facade, - T const, std::random_access_iterator_tag, T const> - base_type; + using base_type = + hpx::util::iterator_facade, T const, + std::random_access_iterator_tag, T const>; public: - typedef std::size_t size_type; - typedef typename partitioned_vector::const_segment_iterator - segment_iterator; - typedef - typename partitioned_vector::const_local_segment_iterator - local_segment_iterator; - typedef typename partitioned_vector::const_local_iterator - local_iterator; + using size_type = std::size_t; + using segment_iterator = + typename partitioned_vector::const_segment_iterator; + using local_segment_iterator = + typename partitioned_vector::const_local_segment_iterator; + using local_iterator = + typename partitioned_vector::const_local_iterator; // constructors const_vector_iterator() - : data_(0) - , global_index_(size_type(-1)) + : data_(nullptr) + , global_index_(static_cast(-1)) { } @@ -932,29 +915,29 @@ namespace hpx { namespace segmented { return other.global_index_ - global_index_; } - protected: // refer to the vector partitioned_vector const* data_; // global position in the referenced vector size_type global_index_; }; -}} // namespace hpx::segmented +} // namespace hpx::segmented /////////////////////////////////////////////////////////////////////////////// -namespace hpx { namespace traits { +namespace hpx::traits { + template struct segmented_iterator_traits> { - typedef std::true_type is_segmented_iterator; + using is_segmented_iterator = std::true_type; - typedef segmented::vector_iterator iterator; - typedef typename iterator::segment_iterator segment_iterator; - typedef - typename iterator::local_segment_iterator local_segment_iterator; - typedef typename iterator::local_iterator local_iterator; + using iterator = segmented::vector_iterator; + using segment_iterator = typename iterator::segment_iterator; + using local_segment_iterator = + typename iterator::local_segment_iterator; + using local_iterator = typename iterator::local_iterator; - typedef typename local_iterator::local_raw_iterator local_raw_iterator; + using local_raw_iterator = typename local_iterator::local_raw_iterator; // Conceptually this function is supposed to denote which segment // the iterator is currently pointing to (i.e. just global iterator). @@ -1036,15 +1019,15 @@ namespace hpx { namespace traits { template struct segmented_iterator_traits> { - typedef std::true_type is_segmented_iterator; + using is_segmented_iterator = std::true_type; - typedef segmented::const_vector_iterator iterator; - typedef typename iterator::segment_iterator segment_iterator; - typedef - typename iterator::local_segment_iterator local_segment_iterator; - typedef typename iterator::local_iterator local_iterator; + using iterator = segmented::const_vector_iterator; + using segment_iterator = typename iterator::segment_iterator; + using local_segment_iterator = + typename iterator::local_segment_iterator; + using local_iterator = typename iterator::local_iterator; - typedef typename local_iterator::local_raw_iterator local_raw_iterator; + using local_raw_iterator = typename local_iterator::local_raw_iterator; // Conceptually this function is supposed to denote which segment // the iterator is currently pointing to (i.e. just global iterator). @@ -1131,11 +1114,11 @@ namespace hpx { namespace traits { struct segmented_local_iterator_traits< segmented::local_vector_iterator> { - typedef std::true_type is_segmented_local_iterator; + using is_segmented_local_iterator = std::true_type; - typedef segmented::vector_iterator iterator; - typedef segmented::local_vector_iterator local_iterator; - typedef typename local_iterator::local_raw_iterator local_raw_iterator; + using iterator = segmented::vector_iterator; + using local_iterator = segmented::local_vector_iterator; + using local_raw_iterator = typename local_iterator::local_raw_iterator; // Extract base iterator from local_iterator static local_raw_iterator local(local_iterator it) @@ -1154,11 +1137,11 @@ namespace hpx { namespace traits { struct segmented_local_iterator_traits< segmented::const_local_vector_iterator> { - typedef std::true_type is_segmented_local_iterator; + using is_segmented_local_iterator = std::true_type; - typedef segmented::const_vector_iterator iterator; - typedef segmented::const_local_vector_iterator local_iterator; - typedef typename local_iterator::local_raw_iterator local_raw_iterator; + using iterator = segmented::const_vector_iterator; + using local_iterator = segmented::const_local_vector_iterator; + using local_raw_iterator = typename local_iterator::local_raw_iterator; // Extract base iterator from local_iterator static local_raw_iterator local(local_iterator it) @@ -1199,4 +1182,4 @@ namespace hpx { namespace traits { { using type = T; }; -}} // namespace hpx::traits +} // namespace hpx::traits diff --git a/components/containers/partitioned_vector/include/hpx/runtime/serialization/partitioned_vector.hpp b/components/containers/partitioned_vector/include/hpx/runtime/serialization/partitioned_vector.hpp index 4476897109e4..0e940b5ec974 100644 --- a/components/containers/partitioned_vector/include/hpx/runtime/serialization/partitioned_vector.hpp +++ b/components/containers/partitioned_vector/include/hpx/runtime/serialization/partitioned_vector.hpp @@ -8,13 +8,13 @@ #include #include -#include #include +#include #include -namespace hpx { namespace serialization -{ +namespace hpx::serialization { + template void serialize(input_archive& ar, hpx::partitioned_vector& v, unsigned) { @@ -30,12 +30,10 @@ namespace hpx { namespace serialization std::string pvec_registered_name = v.registered_name(); if (pvec_registered_name.empty()) { - HPX_THROW_EXCEPTION( - hpx::error::invalid_status, + HPX_THROW_EXCEPTION(hpx::error::invalid_status, "hpx::serialization::serialize", "partitioned_vector is not registered"); } ar << pvec_registered_name; } -}} - +} // namespace hpx::serialization diff --git a/components/containers/partitioned_vector/src/partitioned_vector_component.cpp b/components/containers/partitioned_vector/src/partitioned_vector_component.cpp index 9b453c9322bf..26775410107b 100644 --- a/components/containers/partitioned_vector/src/partitioned_vector_component.cpp +++ b/components/containers/partitioned_vector/src/partitioned_vector_component.cpp @@ -14,11 +14,10 @@ #include #include -#include #include +#include HPX_DISTRIBUTED_METADATA(hpx::server::partitioned_vector_config_data, hpx_server_partitioned_vector_config_data) HPX_REGISTER_COMPONENT_MODULE() - diff --git a/components/containers/partitioned_vector/src/partitioned_vector_component_int.cpp b/components/containers/partitioned_vector/src/partitioned_vector_component_int.cpp index 5c4f4b31e2f6..1dc775086ee3 100644 --- a/components/containers/partitioned_vector/src/partitioned_vector_component_int.cpp +++ b/components/containers/partitioned_vector/src/partitioned_vector_component_int.cpp @@ -16,7 +16,7 @@ #include HPX_REGISTER_PARTITIONED_VECTOR(int) -typedef long long long_long; +using long_long = long long; HPX_REGISTER_PARTITIONED_VECTOR(long_long) // an out-of-line definition of a member of a class template cannot have default diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/adjacent_difference.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/adjacent_difference.hpp index bae1f5945d86..8e6a2f38d42a 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/adjacent_difference.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/adjacent_difference.hpp @@ -1,5 +1,6 @@ // Copyright (c) 2017 Ajai V George // Copyright (c) 2021 Karame M.Shokooh +// Copyright (c) 2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -13,7 +14,6 @@ #include #include -#include #include #include #include @@ -23,16 +23,16 @@ #include #include #include -#include #include #include #include -namespace hpx { namespace parallel { +namespace hpx::parallel { /////////////////////////////////////////////////////////////////////////// // segmented_adjacent_difference namespace detail { + /////////////////////////////////////////////////////////////////////// /// \cond NOINTERNAL @@ -87,7 +87,7 @@ namespace hpx { namespace parallel { std::true_type(), beg, end, ldest, op); } - // handle all of the full partitions + // handle all full partitions for (++sit, ++sdest; sit != send; ++sit, ++sdest) { beg = traits1::begin(sit); @@ -195,7 +195,7 @@ namespace hpx { namespace parallel { algo, policy, forced_seq(), beg, end, ldest, op)); } - // handle all of the full partitions + // handle all full partitions for (++sit, ++sdest; sit != send; ++sit, ++sdest) { beg = traits1::begin(sit); @@ -245,10 +245,10 @@ namespace hpx { namespace parallel { } /// \endcond } // namespace detail -}} // namespace hpx::parallel +} // namespace hpx::parallel // The segmented iterators we support all live in namespace hpx::segmented -namespace hpx { namespace segmented { +namespace hpx::segmented { // clang-format off template #include -namespace hpx { namespace parallel { +namespace hpx::parallel { + /////////////////////////////////////////////////////////////////////////// // segmented_adjacent_find namespace detail { + /////////////////////////////////////////////////////////////////////// /// \cond NOINTERNAL // sequential remote implementation template - static typename util::detail::algorithm_result::type + static util::detail::algorithm_result_t segmented_adjacent_find(Algo&& algo, ExPolicy const& policy, FwdIter first, FwdIter last, Pred&& pred, Proj&& proj, std::true_type) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator1; - typedef typename traits::local_iterator local_iterator_type; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator1 = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; - typedef util::detail::algorithm_result result; + using result = util::detail::algorithm_result; segment_iterator1 sit = traits::segment(first); segment_iterator1 send = traits::segment(last); @@ -142,25 +144,24 @@ namespace hpx { namespace parallel { // parallel remote implementation template - static typename util::detail::algorithm_result::type + static util::detail::algorithm_result_t segmented_adjacent_find(Algo&& algo, ExPolicy const& policy, FwdIter first, FwdIter last, Pred&& pred, Proj&& proj, std::false_type) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator1; - typedef typename traits::local_iterator local_iterator_type; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator1 = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; - typedef util::detail::algorithm_result result; + using result = util::detail::algorithm_result; - typedef std::integral_constant::value> - forced_seq; + using forced_seq = std::integral_constant::value>; segment_iterator1 sit = traits::segment(first); segment_iterator1 send = traits::segment(last); - typedef std::vector> segment_type; + using segment_type = std::vector>; segment_type segments; segments.reserve(std::distance(sit, send)); @@ -276,10 +277,10 @@ namespace hpx { namespace parallel { } /// \endcond } // namespace detail -}} // namespace hpx::parallel +} // namespace hpx::parallel // The segmented iterators we support all live in namespace hpx::segmented -namespace hpx { namespace segmented { +namespace hpx::segmented { // clang-format off template::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on typename hpx::parallel::util::detail::algorithm_result - static typename util::detail::algorithm_result::type + static util::detail::algorithm_result_t segmented_none_of(Algo&& algo, ExPolicy const& policy, FwdIter first, FwdIter last, F&& f, Proj&& proj, std::true_type) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; - typedef util::detail::algorithm_result result; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; + using result = util::detail::algorithm_result; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); @@ -98,18 +99,17 @@ namespace hpx { namespace parallel { // parallel remote implementation template - static typename util::detail::algorithm_result::type + static util::detail::algorithm_result_t segmented_none_of(Algo&& algo, ExPolicy const& policy, FwdIter first, FwdIter last, F&& f, Proj&& proj, std::false_type) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; - typedef util::detail::algorithm_result result; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; + using result = util::detail::algorithm_result; - typedef std::integral_constant::value> - forced_seq; + using forced_seq = std::integral_constant::value>; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); @@ -184,14 +184,14 @@ namespace hpx { namespace parallel { // sequential remote implementation template - static typename util::detail::algorithm_result::type + static util::detail::algorithm_result_t segmented_any_of(Algo&& algo, ExPolicy const& policy, FwdIter first, FwdIter last, F&& f, Proj&& proj, std::true_type) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; - typedef util::detail::algorithm_result result; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; + using result = util::detail::algorithm_result; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); @@ -248,18 +248,17 @@ namespace hpx { namespace parallel { // parallel remote implementation template - static typename util::detail::algorithm_result::type + static util::detail::algorithm_result_t segmented_any_of(Algo&& algo, ExPolicy const& policy, FwdIter first, FwdIter last, F&& f, Proj&& proj, std::false_type) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; - typedef util::detail::algorithm_result result; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; + using result = util::detail::algorithm_result; - typedef std::integral_constant::value> - forced_seq; + using forced_seq = std::integral_constant::value>; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); @@ -334,14 +333,14 @@ namespace hpx { namespace parallel { // sequential remote implementation template - static typename util::detail::algorithm_result::type + static util::detail::algorithm_result_t segmented_all_of(Algo&& algo, ExPolicy const& policy, FwdIter first, FwdIter last, F&& f, Proj&& proj, std::true_type) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; - typedef util::detail::algorithm_result result; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; + using result = util::detail::algorithm_result; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); @@ -398,18 +397,17 @@ namespace hpx { namespace parallel { // parallel remote implementation template - static typename util::detail::algorithm_result::type + static util::detail::algorithm_result_t segmented_all_of(Algo&& algo, ExPolicy const& policy, FwdIter first, FwdIter last, F&& f, Proj&& proj, std::false_type) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; - typedef util::detail::algorithm_result result; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; + using result = util::detail::algorithm_result; - typedef std::integral_constant::value> - forced_seq; + using forced_seq = std::integral_constant::value>; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); @@ -481,7 +479,7 @@ namespace hpx { namespace parallel { } /// \endcond } // namespace detail -}} // namespace hpx::parallel +}} // namespace hpx::parallel // The segmented iterators we support all live in namespace hpx::segmented namespace hpx { namespace segmented { @@ -508,13 +506,12 @@ namespace hpx { namespace segmented { template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on - typename hpx::parallel::util::detail::algorithm_result::type - tag_invoke( + hpx::parallel::util::detail::algorithm_result_t tag_invoke( hpx::none_of_t, ExPolicy&& policy, SegIter first, SegIter last, F&& f) { static_assert(hpx::traits::is_forward_iterator::value, @@ -549,13 +546,12 @@ namespace hpx { namespace segmented { template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on - typename hpx::parallel::util::detail::algorithm_result::type - tag_invoke( + hpx::parallel::util::detail::algorithm_result_t tag_invoke( hpx::any_of_t, ExPolicy&& policy, SegIter first, SegIter last, F&& f) { static_assert(hpx::traits::is_forward_iterator::value, @@ -590,13 +586,12 @@ namespace hpx { namespace segmented { template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on - typename hpx::parallel::util::detail::algorithm_result::type - tag_invoke( + hpx::parallel::util::detail::algorithm_result_t tag_invoke( hpx::all_of_t, ExPolicy&& policy, SegIter first, SegIter last, F&& f) { static_assert(hpx::traits::is_forward_iterator::value, diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/count.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/count.hpp index 93acb3c73a70..c26ab0b129a6 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/count.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/count.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2007-2016 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 @@ -385,9 +385,9 @@ namespace hpx { namespace segmented { template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on typename hpx::parallel::util::detail::algorithm_result::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on typename hpx::parallel::util::detail::algorithm_result #include #include -#include -#include #include #include @@ -27,7 +25,7 @@ #include #include -namespace hpx { namespace parallel { namespace detail { +namespace hpx::parallel::detail { /////////////////////////////////////////////////////////////////////////// template @@ -87,7 +85,7 @@ namespace hpx { namespace parallel { namespace detail { struct algorithm_result_helper, std::enable_if_t>> { - typedef hpx::traits::segmented_local_iterator_traits traits1; + using traits1 = hpx::traits::segmented_local_iterator_traits; static HPX_FORCEINLINE util::min_max_result @@ -341,4 +339,4 @@ namespace hpx { namespace parallel { namespace detail { } return f.get(); } -}}} // namespace hpx::parallel::detail +} // namespace hpx::parallel::detail diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/reduce.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/reduce.hpp index f2210e7e444f..ac2b792fc31e 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/reduce.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/reduce.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2017 Ajai V George -// Copyright (c) 2022 Hartmut Kaiser +// Copyright (c) 2022-2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -20,20 +20,18 @@ #include #include -#include #include -#include -#include #include #include #include -namespace hpx { namespace parallel { namespace detail { +namespace hpx::parallel::detail { + template - struct seg_reduce : public detail::algorithm, T> + struct seg_reduce : algorithm, T> { seg_reduce() - : seg_reduce::algorithm("reduce") + : algorithm, T>("reduce") { } @@ -64,11 +62,10 @@ namespace hpx { namespace parallel { namespace detail { }; template - struct seg_transform_reduce - : public detail::algorithm, T> + struct seg_transform_reduce : algorithm, T> { seg_transform_reduce() - : seg_transform_reduce::algorithm("transform_reduce") + : algorithm, T>("transform_reduce") { } @@ -112,10 +109,10 @@ namespace hpx { namespace parallel { namespace detail { template struct seg_transform_reduce_binary - : public detail::algorithm, T> + : algorithm, T> { seg_transform_reduce_binary() - : seg_transform_reduce_binary::algorithm("transform_reduce_binary") + : algorithm("transform_reduce_binary") { } @@ -134,7 +131,8 @@ namespace hpx { namespace parallel { namespace detail { parallel(ExPolicy&& policy, FwdIter1 first1, FwdIter1 last1, FwdIter2 first2, Reduce&& r, Convert&& conv) { - typedef hpx::util::zip_iterator zip_iterator; + using zip_iterator = hpx::util::zip_iterator; + return util::partitioner::call( HPX_FORWARD(ExPolicy, policy), zip_iterator(first1, first2), std::distance(first1, last1), @@ -155,4 +153,4 @@ namespace hpx { namespace parallel { namespace detail { })); } }; -}}} // namespace hpx::parallel::detail +} // namespace hpx::parallel::detail diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/scan.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/scan.hpp index bb74035da0e5..0c0ca477a1d2 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/scan.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/scan.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2016 Minh-Khanh Do -// Copyright (c) 2020-2023 Hartmut Kaiser +// Copyright (c) 2020-2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -34,7 +34,8 @@ #include #include -namespace hpx { namespace parallel { +namespace hpx::parallel { + /////////////////////////////////////////////////////////////////////////// // segmented scan namespace detail { @@ -60,13 +61,12 @@ namespace hpx { namespace parallel { // does a scan and returns last value of the scan template - struct segmented_scan_T - : public detail::algorithm, Value> + struct segmented_scan_T : algorithm, Value> { - typedef Value T; + using T = Value; segmented_scan_T() - : segmented_scan_T::algorithm("segmented_scan_T") + : algorithm, Value>("segmented_scan_T") { } @@ -126,11 +126,10 @@ namespace hpx { namespace parallel { // do the scan (exclusive/inclusive) // does not return anything template - struct segmented_scan_void - : public detail::algorithm> + struct segmented_scan_void : algorithm> { segmented_scan_void() - : segmented_scan_void::algorithm("segmented_scan_void") + : algorithm>("segmented_scan_void") { } @@ -153,8 +152,8 @@ namespace hpx { namespace parallel { parallel(ExPolicy&& policy, InIter first, InIter last, OutIter dest, T&& init, Op&& op, Conv&& conv) { - typedef typename util::detail::algorithm_result::type - result_type; + using result_type = + typename util::detail::algorithm_result::type; if (first == last) return util::detail::algorithm_result::get(); @@ -179,13 +178,13 @@ namespace hpx { namespace parallel { static bool is_segmented_the_same( SegIter first, SegIter last, OutIter dest, std::true_type) { - typedef hpx::traits::segmented_iterator_traits traits_in; - typedef typename traits_in::segment_iterator segment_iterator_in; - typedef typename traits_in::local_iterator local_iterator_type_in; + using traits_in = hpx::traits::segmented_iterator_traits; + using segment_iterator_in = typename traits_in::segment_iterator; + using local_iterator_type_in = typename traits_in::local_iterator; - typedef hpx::traits::segmented_iterator_traits traits_out; - typedef typename traits_out::segment_iterator segment_iterator_out; - typedef typename traits_out::local_iterator local_iterator_type_out; + using traits_out = hpx::traits::segmented_iterator_traits; + using segment_iterator_out = typename traits_out::segment_iterator; + using local_iterator_type_out = typename traits_out::local_iterator; segment_iterator_in sit_in = traits_in::segment(first); segment_iterator_in send_in = traits_in::segment(last); @@ -205,16 +204,17 @@ namespace hpx { namespace parallel { if (beg_in != end_in) { - id_type in_id = + id_type const in_id = get_locality_from_id(traits_in::get_id(sit_in)); - id_type out_id = + id_type const out_id = get_locality_from_id(traits_out::get_id(sit_out)); if (in_id != out_id) return false; - std::size_t in_dist = std::distance(beg_in, end_in); - std::size_t out_dist = std::distance(beg_out, end_out); + std::size_t const in_dist = std::distance(beg_in, end_in); + std::size_t const out_dist = + std::distance(beg_out, end_out); if (in_dist != out_dist) return false; @@ -231,16 +231,17 @@ namespace hpx { namespace parallel { if (beg_in != end_in) { - id_type in_id = + id_type const in_id = get_locality_from_id(traits_in::get_id(sit_in)); - id_type out_id = + id_type const out_id = get_locality_from_id(traits_out::get_id(sit_out)); if (in_id != out_id) return false; - std::size_t in_dist = std::distance(beg_in, end_in); - std::size_t out_dist = std::distance(beg_out, end_out); + std::size_t const in_dist = std::distance(beg_in, end_in); + std::size_t const out_dist = + std::distance(beg_out, end_out); if (in_dist != out_dist) return false; @@ -266,8 +267,10 @@ namespace hpx { namespace parallel { if (in_id != out_id) return false; - std::size_t in_dist = std::distance(beg_in, end_in); - std::size_t out_dist = std::distance(beg_out, end_out); + std::size_t const in_dist = + std::distance(beg_in, end_in); + std::size_t const out_dist = + std::distance(beg_out, end_out); if (in_dist != out_dist) return false; @@ -283,16 +286,17 @@ namespace hpx { namespace parallel { if (beg_in != end_in) { - id_type in_id = + id_type const in_id = get_locality_from_id(traits_in::get_id(sit_in)); - id_type out_id = + id_type const out_id = get_locality_from_id(traits_out::get_id(sit_out)); if (in_id != out_id) return false; - std::size_t in_dist = std::distance(beg_in, end_in); - std::size_t out_dist = std::distance(beg_out, end_out); + std::size_t const in_dist = std::distance(beg_in, end_in); + std::size_t const out_dist = + std::distance(beg_out, end_out); if (in_dist != out_dist) return false; @@ -311,22 +315,21 @@ namespace hpx { namespace parallel { segmented_scan_seq(ExPolicy const& policy, SegIter first, SegIter last, OutIter dest, Conv&& conv, T const& init, Op&& op, std::true_type) { - typedef util::detail::algorithm_result result; + using result = util::detail::algorithm_result; if (first == last) return result::get(HPX_MOVE(dest)); - typedef hpx::traits::segmented_iterator_traits traits_in; - typedef typename traits_in::segment_iterator segment_iterator_in; - typedef typename traits_in::local_iterator local_iterator_type_in; + using traits_in = hpx::traits::segmented_iterator_traits; + using segment_iterator_in = typename traits_in::segment_iterator; + using local_iterator_type_in = typename traits_in::local_iterator; - typedef hpx::traits::segmented_iterator_traits traits_out; - typedef typename traits_out::segment_iterator segment_iterator_out; - typedef typename traits_out::local_iterator local_iterator_type_out; + using traits_out = hpx::traits::segmented_iterator_traits; + using segment_iterator_out = typename traits_out::segment_iterator; + using local_iterator_type_out = typename traits_out::local_iterator; - typedef typename hpx::tuple - local_iterator_in_tuple; + using local_iterator_in_tuple = + hpx::tuple; segment_iterator_in sit_in = traits_in::segment(first); segment_iterator_in send_in = traits_in::segment(last); @@ -428,19 +431,19 @@ namespace hpx { namespace parallel { SegIter last, OutIter dest, T const& init, Op&& op, F1&& f1, F2&& f2) { - typedef util::detail::algorithm_result result; + using result = util::detail::algorithm_result; if (first == last) return result::get(HPX_MOVE(dest)); - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); - typedef typename std::vector vector_type; + using vector_type = std::vector; std::vector results; @@ -518,29 +521,27 @@ namespace hpx { namespace parallel { segmented_scan_par(ExPolicy const& policy, SegIter first, SegIter last, OutIter dest, Conv&& conv, T const& init, Op&& op, std::true_type) { - typedef util::detail::algorithm_result result; + using result = util::detail::algorithm_result; if (first == last) return result::get(HPX_MOVE(dest)); - typedef hpx::traits::segmented_iterator_traits traits_in; - typedef typename traits_in::segment_iterator segment_iterator_in; - typedef typename traits_in::local_iterator local_iterator_type_in; + using traits_in = hpx::traits::segmented_iterator_traits; + using segment_iterator_in = typename traits_in::segment_iterator; + using local_iterator_type_in = typename traits_in::local_iterator; - typedef hpx::traits::segmented_iterator_traits traits_out; - typedef typename traits_out::segment_iterator segment_iterator_out; - typedef typename traits_out::local_iterator local_iterator_type_out; + using traits_out = hpx::traits::segmented_iterator_traits; + using segment_iterator_out = typename traits_out::segment_iterator; + using local_iterator_type_out = typename traits_out::local_iterator; - typedef typename std::iterator_traits< - segment_iterator_in>::difference_type difference_type; + using difference_type = typename std::iterator_traits< + segment_iterator_in>::difference_type; - typedef std::integral_constant::value> - forced_seq; + using forced_seq = std::integral_constant::value>; - typedef typename hpx::tuple - local_iterator_in_tuple; + using local_iterator_in_tuple = + hpx::tuple; segment_iterator_in sit_in = traits_in::segment(first); segment_iterator_in send_in = traits_in::segment(last); @@ -675,28 +676,26 @@ namespace hpx { namespace parallel { SegIter last, OutIter dest, T const& init, Op&& op, F1&& f1, F2&& f2) { - typedef util::detail::algorithm_result result; + using result = util::detail::algorithm_result; if (first == last) return result::get(HPX_MOVE(dest)); - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; - typedef - typename std::iterator_traits::difference_type - difference_type; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; + using difference_type = typename std::iterator_traits< + segment_iterator>::difference_type; - typedef std::integral_constant::value> - forced_seq; + using forced_seq = std::integral_constant::value>; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); difference_type count = std::distance(sit, send); - typedef typename std::vector vector_type; + using vector_type = std::vector; std::vector> results; results.reserve(count); @@ -797,4 +796,4 @@ namespace hpx { namespace parallel { } /// \endcond } // namespace detail -}} // namespace hpx::parallel +} // namespace hpx::parallel diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/transfer.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/transfer.hpp index 4914cd90881e..2f00ed2be3d0 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/transfer.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/detail/transfer.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2007-2020 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 @@ -26,10 +26,12 @@ #include #include -namespace hpx { namespace parallel { +namespace hpx::parallel { + /////////////////////////////////////////////////////////////////////////// // segmented transfer namespace detail { + /////////////////////////////////////////////////////////////////////// /// \cond NOINTERNAL @@ -41,20 +43,19 @@ namespace hpx { namespace parallel { segmented_transfer(Algo&& algo, ExPolicy const& policy, std::true_type, SegIter first, SegIter last, SegOutIter dest) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; - typedef hpx::traits::segmented_iterator_traits - output_traits; - typedef typename output_traits::segment_iterator - segment_output_iterator; - typedef typename output_traits::local_iterator - local_output_iterator_type; + using output_traits = + hpx::traits::segmented_iterator_traits; + using segment_output_iterator = + typename output_traits::segment_iterator; + using local_output_iterator_type = + typename output_traits::local_iterator; - typedef util::in_out_result - local_iterator_pair; + using local_iterator_pair = util::in_out_result; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); @@ -90,7 +91,7 @@ namespace hpx { namespace parallel { out = p.out; } - // handle all of the full partitions + // handle all full partitions for ((void) ++sit, ++sdest; sit != send; (void) ++sit, ++sdest) { beg = traits::begin(sit); @@ -133,24 +134,22 @@ namespace hpx { namespace parallel { segmented_transfer(Algo&& algo, ExPolicy const& policy, std::false_type, SegIter first, SegIter last, SegOutIter dest) { - typedef hpx::traits::segmented_iterator_traits traits; - typedef typename traits::segment_iterator segment_iterator; - typedef typename traits::local_iterator local_iterator_type; + using traits = hpx::traits::segmented_iterator_traits; + using segment_iterator = typename traits::segment_iterator; + using local_iterator_type = typename traits::local_iterator; - typedef hpx::traits::segmented_iterator_traits - output_traits; - typedef typename output_traits::segment_iterator - segment_output_iterator; - typedef typename output_traits::local_iterator - local_output_iterator_type; + using output_traits = + hpx::traits::segmented_iterator_traits; + using segment_output_iterator = + typename output_traits::segment_iterator; + using local_output_iterator_type = + typename output_traits::local_iterator; - typedef util::in_out_result - local_iterator_pair; + using local_iterator_pair = util::in_out_result; - typedef std::integral_constant::value> - forced_seq; + using forced_seq = std::integral_constant::value>; segment_iterator sit = traits::segment(first); segment_iterator send = traits::segment(last); @@ -185,7 +184,7 @@ namespace hpx { namespace parallel { policy, forced_seq(), beg, end, out)); } - // handle all of the full partitions + // handle all full partitions for ((void) ++sit, ++sdest; sit != send; (void) ++sit, ++sdest) { beg = traits::begin(sit); @@ -250,7 +249,7 @@ namespace hpx { namespace parallel { result_type>::get(result_type{last, dest}); } - typedef hpx::is_sequenced_execution_policy is_seq; + using is_seq = hpx::is_sequenced_execution_policy; return segmented_transfer(Algo(), HPX_FORWARD(ExPolicy, policy), is_seq(), first, last, dest); } @@ -265,4 +264,4 @@ namespace hpx { namespace parallel { /// \endcond } // namespace detail -}} // namespace hpx::parallel +} // namespace hpx::parallel diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/exclusive_scan.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/exclusive_scan.hpp index 029dfcd1a54c..ce51dc94f3c9 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/exclusive_scan.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/exclusive_scan.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2016 Minh-Khanh Do -// Copyright (c) 2020 Hartmut Kaiser +// Copyright (c) 2020-2024 Hartmut Kaiser // Copyright (c) 2021 Akhil J Nair // // SPDX-License-Identifier: BSL-1.0 @@ -281,7 +281,7 @@ namespace hpx { namespace segmented { template , HPX_CONCEPT_REQUIRES_( - hpx::is_execution_policy::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator_v && hpx::traits::is_segmented_iterator_v && hpx::traits::is_iterator_v && diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/fill.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/fill.hpp index cf99e1eb8e21..41738b7c2f00 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/fill.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/fill.hpp @@ -1,4 +1,5 @@ // Copyright (c) 2016 Minh-Khanh Do +// Copyright (c) 2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -62,8 +63,8 @@ namespace hpx { namespace segmented { // clang-format off template::value && - hpx::traits::is_segmented_iterator::value + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on SegIter tag_invoke(hpx::fill_t, SegIter first, SegIter last, T const& value) @@ -90,9 +91,9 @@ namespace hpx { namespace segmented { // clang-format off template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on static typename hpx::parallel::util::detail::algorithm_result::value && - hpx::traits::is_segmented_iterator::value + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on SegIter tag_invoke(hpx::find_t, SegIter first, SegIter last, T const& val) @@ -257,9 +258,9 @@ namespace hpx { namespace segmented { // clang-format off template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on typename parallel::util::detail::algorithm_result::type @@ -314,7 +315,7 @@ namespace hpx { namespace segmented { // clang-format off template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value )> @@ -372,7 +373,7 @@ namespace hpx { namespace segmented { // clang-format off template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value )> diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/for_each.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/for_each.hpp index ab170623a44f..9b009de6d56e 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/for_each.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/for_each.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2007-2021 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 @@ -217,9 +217,9 @@ namespace hpx { namespace segmented { template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on typename hpx::parallel::util::detail::algorithm_result::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on typename hpx::parallel::util::detail::algorithm_result #include -namespace hpx { namespace util { namespace functional { +namespace hpx::util::functional { /////////////////////////////////////////////////////////////////////////// struct segmented_iterator_segment @@ -108,4 +108,4 @@ namespace hpx { namespace util { namespace functional { } }; }; -}}} // namespace hpx::util::functional +} // namespace hpx::util::functional diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/generate.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/generate.hpp index 0b16a16cd4d6..cd582e561b48 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/generate.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/generate.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2007-2020 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 @@ -184,8 +184,8 @@ namespace hpx { namespace segmented { // clang-format off template ::value && - hpx::traits::is_segmented_iterator::value + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on SegIter tag_invoke(hpx::generate_t, SegIter first, SegIter last, F&& f) @@ -210,9 +210,9 @@ namespace hpx { namespace segmented { // clang-format off template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on typename parallel::util::detail::algorithm_result::type diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/inclusive_scan.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/inclusive_scan.hpp index e59afc6b9c29..216aee2820fe 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/inclusive_scan.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/inclusive_scan.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2016 Minh-Khanh Do -// Copyright (c) 2020 Hartmut Kaiser +// Copyright (c) 2020-2024 Hartmut Kaiser // Copyright (c) 2021 Akhil J Nair // // SPDX-License-Identifier: BSL-1.0 @@ -283,7 +283,7 @@ namespace hpx { namespace segmented { template ::value_type>, HPX_CONCEPT_REQUIRES_( - hpx::is_execution_policy::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator_v && hpx::traits::is_segmented_iterator_v && hpx::traits::is_iterator_v && @@ -343,7 +343,7 @@ namespace hpx { namespace segmented { template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator_v && hpx::traits::is_segmented_iterator_v && hpx::traits::is_iterator_v && diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/reduce.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/reduce.hpp index 0a0a70b48933..b7c2971abfe4 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/reduce.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/reduce.hpp @@ -1,5 +1,5 @@ // Copyright (c) 2017 Ajai V George -// Copyright (c) 2022 Hartmut Kaiser +// Copyright (c) 2022-2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -226,7 +226,7 @@ namespace hpx { namespace segmented { template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value && hpx::traits::is_iterator::value && diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/traits/zip_iterator.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/traits/zip_iterator.hpp index b21e738f6ed0..d7934fecd357 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/traits/zip_iterator.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/traits/zip_iterator.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2007-2021 Hartmut Kaiser +// Copyright (c) 2007-2024 Hartmut Kaiser // Copyright (c) 2014 Agustin Berge // // SPDX-License-Identifier: BSL-1.0 @@ -15,12 +15,11 @@ #include #include -#include #include #include /////////////////////////////////////////////////////////////////////////////// -namespace hpx { namespace traits { +namespace hpx::traits { /////////////////////////////////////////////////////////////////////////// namespace functional { @@ -55,28 +54,24 @@ namespace hpx { namespace traits { } // namespace functional /////////////////////////////////////////////////////////////////////////// - // A zip_iterator represents a segmented iterator if all of the zipped - // iterators are segmented iterators themselves. + // A zip_iterator represents a segmented iterator if all zipped iterators + // are segmented iterators themselves. template struct segmented_iterator_traits, - typename std::enable_if::is_segmented_iterator...>::value>::type> + std::enable_if_t::is_segmented_iterator...>>> { - typedef std::true_type is_segmented_iterator; - - typedef util::zip_iterator iterator; - typedef util::zip_iterator< - typename segmented_iterator_traits::segment_iterator...> - segment_iterator; - typedef util::zip_iterator< - typename segmented_iterator_traits::local_segment_iterator...> - local_segment_iterator; - typedef util::zip_iterator< - typename segmented_iterator_traits::local_iterator...> - local_iterator; - typedef util::zip_iterator< - typename segmented_iterator_traits::local_raw_iterator...> - local_raw_iterator; + using is_segmented_iterator = std::true_type; + + using iterator = util::zip_iterator; + using segment_iterator = util::zip_iterator< + typename segmented_iterator_traits::segment_iterator...>; + using local_segment_iterator = util::zip_iterator< + typename segmented_iterator_traits::local_segment_iterator...>; + using local_iterator = util::zip_iterator< + typename segmented_iterator_traits::local_iterator...>; + using local_raw_iterator = util::zip_iterator< + typename segmented_iterator_traits::local_raw_iterator...>; // Conceptually this function is supposed to denote which segment // the iterator is currently pointing to (i.e. just global iterator). @@ -136,10 +131,9 @@ namespace hpx { namespace traits { // iterator. static hpx::id_type get_id(segment_iterator const& iter) { - typedef typename hpx::tuple_element<0, - typename iterator::iterator_tuple_type>::type - first_base_iterator; - typedef segmented_iterator_traits traits; + using first_base_iterator = typename hpx::tuple_element<0, + typename iterator::iterator_tuple_type>::type; + using traits = segmented_iterator_traits; return traits::get_id(hpx::get<0>(iter.get_iterator_tuple())); } @@ -148,19 +142,18 @@ namespace hpx { namespace traits { /////////////////////////////////////////////////////////////////////////// template struct segmented_local_iterator_traits, - typename std::enable_if< - util::all_of::is_segmented_local_iterator...>::value>::type> + std::enable_if_t< + util::all_of_v::is_segmented_local_iterator...>>> { - typedef std::true_type is_segmented_local_iterator; + using is_segmented_local_iterator = std::true_type; - typedef util::zip_iterator< - typename segmented_local_iterator_traits::iterator...> - iterator; - typedef util::zip_iterator local_iterator; - typedef util::zip_iterator< - typename segmented_local_iterator_traits::local_raw_iterator...> - local_raw_iterator; + using iterator = util::zip_iterator< + typename segmented_local_iterator_traits::iterator...>; + using local_iterator = util::zip_iterator; + using local_raw_iterator = + util::zip_iterator::local_raw_iterator...>; // Extract base iterator from local_iterator static local_raw_iterator local(local_iterator const& iter) @@ -177,4 +170,4 @@ namespace hpx { namespace traits { functional::get_remote_iterator, iterator>::call(iter)); } }; -}} // namespace hpx::traits +} // namespace hpx::traits diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform.hpp index f0fbb1d3e419..cea7b8b68764 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform.hpp @@ -1,4 +1,5 @@ // Copyright (c) 2017 Ajai V George +// Copyright (c) 2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -675,8 +676,8 @@ namespace hpx { namespace segmented { // clang-format off template ::value && - hpx::traits::is_segmented_iterator::value && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value )> @@ -710,9 +711,9 @@ namespace hpx { namespace segmented { template ::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value && + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value )> @@ -800,7 +801,7 @@ namespace hpx { namespace segmented { template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value && hpx::traits::is_iterator::value && @@ -898,7 +899,7 @@ namespace hpx { namespace segmented { template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value && hpx::traits::is_iterator::value && diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_exclusive_scan.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_exclusive_scan.hpp index d98509dfe423..7a698ad9e034 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_exclusive_scan.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_exclusive_scan.hpp @@ -1,5 +1,6 @@ // Copyright (c) 2017 Ajai V George // Copyright (c) 2021 Akhil J Nair +// Copyright (c) 2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -58,7 +59,7 @@ namespace hpx { namespace segmented { template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value && hpx::traits::is_iterator::value && diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_inclusive_scan.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_inclusive_scan.hpp index 11e6decf7a10..92f11a203a4b 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_inclusive_scan.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_inclusive_scan.hpp @@ -1,5 +1,6 @@ // Copyright (c) 2017 Ajai V George // Copyright (c) 2021 Akhil J Nair +// Copyright (c) 2024 Hartmut Kaiser // // SPDX-License-Identifier: BSL-1.0 // Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -60,7 +61,7 @@ namespace hpx { namespace segmented { template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value && hpx::traits::is_iterator::value && @@ -120,7 +121,7 @@ namespace hpx { namespace segmented { template ::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value && hpx::traits::is_iterator::value && diff --git a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_reduce.hpp b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_reduce.hpp index d71c1ad4dc7d..9b6aaad7dab9 100644 --- a/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_reduce.hpp +++ b/libs/full/segmented_algorithms/include/hpx/parallel/segmented_algorithms/transform_reduce.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2007-2020 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 @@ -382,8 +382,8 @@ namespace hpx { namespace segmented { typename Reduce, typename Convert, HPX_CONCEPT_REQUIRES_( - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on std::decay tag_invoke(hpx::transform_reduce_t, SegIter first, @@ -411,9 +411,9 @@ namespace hpx { namespace segmented { typename Reduce, typename Convert, HPX_CONCEPT_REQUIRES_( - hpx::is_execution_policy::value && - hpx::traits::is_iterator::value && - hpx::traits::is_segmented_iterator::value + hpx::is_execution_policy_v && + hpx::traits::is_iterator_v && + hpx::traits::is_segmented_iterator_v )> // clang-format on typename parallel::util::detail::algorithm_result::value && + hpx::is_execution_policy_v && hpx::traits::is_iterator::value && hpx::traits::is_segmented_iterator::value && hpx::traits::is_iterator::value && diff --git a/libs/full/segmented_algorithms/tests/unit/partitioned_vector_for_each.cpp b/libs/full/segmented_algorithms/tests/unit/partitioned_vector_for_each.cpp index e60837ed1cbc..dcc549ee4b64 100644 --- a/libs/full/segmented_algorithms/tests/unit/partitioned_vector_for_each.cpp +++ b/libs/full/segmented_algorithms/tests/unit/partitioned_vector_for_each.cpp @@ -32,7 +32,7 @@ struct pfo template struct cmp { - cmp(T const& val = T()) + explicit cmp(T const& val = T()) : value_(val) { } @@ -77,9 +77,10 @@ void verify_values_count( ExPolicy&& policy, hpx::partitioned_vector const& v, T const& val) { HPX_TEST_EQ( - std::size_t(hpx::count(policy, v.begin(), v.end(), val)), v.size()); - HPX_TEST_EQ( - std::size_t(hpx::count_if(policy, v.begin(), v.end(), cmp(val))), + static_cast(hpx::count(policy, v.begin(), v.end(), val)), + v.size()); + HPX_TEST_EQ(static_cast( + hpx::count_if(policy, v.begin(), v.end(), cmp(val))), v.size()); } @@ -111,10 +112,11 @@ template void verify_values_count_async( ExPolicy&& policy, hpx::partitioned_vector const& v, T const& val) { - HPX_TEST_EQ(std::size_t(hpx::count(policy, v.begin(), v.end(), val).get()), + HPX_TEST_EQ(static_cast( + hpx::count(policy, v.begin(), v.end(), val).get()), v.size()); HPX_TEST_EQ( - std::size_t( + static_cast( hpx::count_if(policy, v.begin(), v.end(), cmp(val)).get()), v.size()); } @@ -136,8 +138,6 @@ void test_for_each_async( template void for_each_tests(std::vector& localities) { - std::size_t const length = 12; - { hpx::partitioned_vector v; hpx::for_each(v.begin(), v.end(), pfo()); @@ -152,6 +152,7 @@ void for_each_tests(std::vector& localities) } { + constexpr std::size_t length = 12; hpx::partitioned_vector v( length, T(0), hpx::container_layout(localities)); test_for_each(v, T(0)); @@ -169,4 +170,5 @@ int main() for_each_tests(localities); return hpx::util::report_errors(); } + #endif