#863

Committed 11 Jan 2023 05:02PM UTC coverage: 86.533% (-0.05%) from 86.582%

Build # #863

Build Type

push

Committed by StellarBot

Commit Message

Merge #6126

6126: Deprecate hpx::parallel::task_block in favor of hpx::experimental::ta… r=hkaiser a=dimitraka



Co-authored-by: kadimitra <kadimitra@ece.auth.gr>

Run Details

174614 of 201789 relevant lines covered (86.53%)

1954694.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.5

/libs/core/execution/include/hpx/execution/algorithms/just.hpp

//  Copyright (c) 2020 ETH Zurich
//  Copyright (c) 2022 Hartmut Kaiser
//
//  SPDX-License-Identifier: BSL-1.0
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#pragma once

#include <hpx/config.hpp>
#include <hpx/datastructures/member_pack.hpp>
#include <hpx/errors/try_catch_exception_ptr.hpp>
#include <hpx/execution_base/completion_signatures.hpp>
#include <hpx/execution_base/receiver.hpp>
#include <hpx/execution_base/sender.hpp>
#include <hpx/type_support/pack.hpp>

#include <cstddef>
#include <exception>
#include <stdexcept>
#include <type_traits>
#include <utility>

namespace hpx::execution::experimental {

    namespace detail {

        template <typename CPO, typename Is, typename... Ts>
        struct just_sender;

        template <typename CPO, std::size_t... Is, typename... Ts>
        struct just_sender<CPO, hpx::util::index_pack<Is...>, Ts...>
        {
            HPX_NO_UNIQUE_ADDRESS util::member_pack_for<std::decay_t<Ts>...> ts;

            constexpr just_sender() = default;

            template <typename T,
                typename = std::enable_if_t<
                    !std::is_same_v<std::decay_t<T>, just_sender>>>
            explicit constexpr just_sender(T&& t)
              : ts(std::piecewise_construct, HPX_FORWARD(T, t))
            {
            }

            template <typename T0, typename T1, typename... Ts_>
            explicit constexpr just_sender(T0&& t0, T1&& t1, Ts_&&... ts)
              : ts(std::piecewise_construct, HPX_FORWARD(T0, t0),
                    HPX_FORWARD(T1, t1), HPX_FORWARD(Ts_, ts)...)
            {
            }

            just_sender(just_sender&&) = default;
            just_sender(just_sender const&) = default;
            just_sender& operator=(just_sender&&) = default;
            just_sender& operator=(just_sender const&) = default;

            template <typename Receiver>
            struct operation_state
            {
                using data_type =
                    hpx::util::member_pack_for<std::decay_t<Ts>...>;

                HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
                HPX_NO_UNIQUE_ADDRESS
                data_type ts;

                template <typename Receiver_>
                operation_state(Receiver_&& receiver, data_type ts)
                  : receiver(HPX_FORWARD(Receiver_, receiver))
                  , ts(HPX_MOVE(ts))
                {
                }

                operation_state(operation_state&&) = delete;
                operation_state& operator=(operation_state&&) = delete;
                operation_state(operation_state const&) = delete;
                operation_state& operator=(operation_state const&) = delete;

                friend void tag_invoke(start_t, operation_state& os) noexcept
                {
                    hpx::detail::try_catch_exception_ptr(
                        [&]() {
                            CPO{}(HPX_MOVE(os.receiver),
                                HPX_MOVE(os.ts).template get<Is>()...);
                        },
                        [&](std::exception_ptr ep) {
                            hpx::execution::experimental::set_error(
                                HPX_MOVE(os.receiver), HPX_MOVE(ep));
                        });
                }
            };

            template <typename Receiver>
            friend auto tag_invoke(
                connect_t, just_sender&& s, Receiver&& receiver) noexcept(util::
                    all_of_v<std::is_nothrow_move_constructible<Ts>...>)
            {
                return operation_state<Receiver>{
                    HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.ts)};
            }

            template <typename Receiver>
            friend auto
            tag_invoke(connect_t, just_sender& s, Receiver&& receiver) noexcept(
                util::all_of_v<std::is_nothrow_copy_constructible<Ts>...>)
            {
                return operation_state<Receiver>{
                    HPX_FORWARD(Receiver, receiver), s.ts};
            }
        };

        template <typename Pack, typename... Ts, typename Env>
        auto tag_invoke(get_completion_signatures_t,
            just_sender<set_value_t, Pack, Ts...> const&, Env) noexcept
            -> hpx::execution::experimental::completion_signatures<
                set_value_t(Ts...), set_error_t(std::exception_ptr)>;

        // different versions of clang-format disagree
        // clang-format off
        template <typename Pack, typename Error, typename Env>
        auto tag_invoke(get_completion_signatures_t,
            just_sender<set_error_t, Pack, Error> const&, Env) noexcept
            -> hpx::execution::experimental::completion_signatures<
                set_error_t(std::exception_ptr), set_error_t(Error)>;
        // clang-format on

        template <typename Pack, typename... Ts, typename Env>
        auto tag_invoke(get_completion_signatures_t,
            just_sender<set_stopped_t, Pack, Ts...> const&, Env) noexcept
            -> hpx::execution::experimental::completion_signatures<
                set_stopped_t(), set_error_t(std::exception_ptr)>;
    }    // namespace detail

    // Returns a sender with no completion schedulers, which sends the provided
    // values. The input values are decay-copied into the returned sender. When
    // the returned sender is connected to a receiver, the values are moved into
    // the operation state if the sender is an rvalue; otherwise, they are
    // copied. Then xvalues referencing the values in the operation state are
    // passed to the receiver's set_value.
    inline constexpr struct just_t final
    {
        template <typename... Ts>
        constexpr HPX_FORCEINLINE auto operator()(Ts&&... ts) const
        {
            return detail::just_sender<
                hpx::execution::experimental::set_value_t,
                hpx::util::make_index_pack_t<sizeof...(Ts)>, Ts...>{
                HPX_FORWARD(Ts, ts)...};
        }
    } just{};

    // Returns a sender with no completion schedulers, which completes with the
    // specified error. If the provided error is an lvalue reference, a copy is
    // made inside the returned sender and a non-const lvalue reference to the
    // copy is sent to the receiver's set_error. If the provided value is an
    // rvalue reference, it is moved into the returned sender and an rvalue
    // reference to it is sent to the receiver's set_error.
    inline constexpr struct just_error_t final
    {
        template <typename Error>
        constexpr HPX_FORCEINLINE auto operator()(Error&& error) const
        {
            return detail::just_sender<
                hpx::execution::experimental::set_error_t,
                hpx::util::make_index_pack_t<std::size_t(1)>, Error>{
                HPX_FORWARD(Error, error)};
        }
    } just_error{};

    // Returns a sender with no completion schedulers, which completes
    // immediately by calling the receiver's set_stopped.
    inline constexpr struct just_stopped_t final
    {
        template <typename... Ts>
        constexpr HPX_FORCEINLINE auto operator()(Ts&&... ts) const
        {
            return detail::just_sender<
                hpx::execution::experimental::set_stopped_t,
                hpx::util::make_index_pack_t<sizeof...(Ts)>, Ts...>{
                HPX_FORWARD(Ts, ts)...};
        }
    } just_stopped{};
}    // namespace hpx::execution::experimental

1	// Copyright (c) 2020 ETH Zurich
2	// Copyright (c) 2022 Hartmut Kaiser
3	//
4	// SPDX-License-Identifier: BSL-1.0
5	// Distributed under the Boost Software License, Version 1.0. (See accompanying
6	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7
8	#pragma once
9
10	#include <hpx/config.hpp>
11	#include <hpx/datastructures/member_pack.hpp>
12	#include <hpx/errors/try_catch_exception_ptr.hpp>
13	#include <hpx/execution_base/completion_signatures.hpp>
14	#include <hpx/execution_base/receiver.hpp>
15	#include <hpx/execution_base/sender.hpp>
16	#include <hpx/type_support/pack.hpp>
17
18	#include <cstddef>
19	#include <exception>
20	#include <stdexcept>
21	#include <type_traits>
22	#include <utility>
23
24	namespace hpx::execution::experimental {
25
26	namespace detail {
27
28	template <typename CPO, typename Is, typename... Ts>
29	struct just_sender;
30
31	template <typename CPO, std::size_t... Is, typename... Ts>
32	struct just_sender<CPO, hpx::util::index_pack<Is...>, Ts...>	123✔
33	{
34	HPX_NO_UNIQUE_ADDRESS util::member_pack_for<std::decay_t<Ts>...> ts;
35
36	constexpr just_sender() = default;
37
38	template <typename T,
39	typename = std::enable_if_t<
40	!std::is_same_v<std::decay_t<T>, just_sender>>>
41	explicit constexpr just_sender(T&& t)	1,212✔
42	: ts(std::piecewise_construct, HPX_FORWARD(T, t))	1,212✔
43	{
44	}	1,212✔
45
46	template <typename T0, typename T1, typename... Ts_>
47	explicit constexpr just_sender(T0&& t0, T1&& t1, Ts_&&... ts)	102✔
48	: ts(std::piecewise_construct, HPX_FORWARD(T0, t0),	204✔
49	HPX_FORWARD(T1, t1), HPX_FORWARD(Ts_, ts)...)	102✔
50	{
51	}	102✔
52
53	just_sender(just_sender&&) = default;	70✔
54	just_sender(just_sender const&) = default;	7✔
55	just_sender& operator=(just_sender&&) = default;
56	just_sender& operator=(just_sender const&) = default;
57
58	template <typename Receiver>
59	struct operation_state	1,084✔
60	{
61	using data_type =
62	hpx::util::member_pack_for<std::decay_t<Ts>...>;
63
64	HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
65	HPX_NO_UNIQUE_ADDRESS
66	data_type ts;
67
68	template <typename Receiver_>
69	operation_state(Receiver_&& receiver, data_type ts)	1,385✔
70	: receiver(HPX_FORWARD(Receiver_, receiver))	1,385✔
71	, ts(HPX_MOVE(ts))	1,385✔
72	{
73	}	1,385✔
74
75	operation_state(operation_state&&) = delete;
76	operation_state& operator=(operation_state&&) = delete;
77	operation_state(operation_state const&) = delete;
78	operation_state& operator=(operation_state const&) = delete;
79
80	friend void tag_invoke(start_t, operation_state& os) noexcept	1,385✔
81	{
82	hpx::detail::try_catch_exception_ptr(	1,385✔
83	[&]() {	2,770✔
84	CPO{}(HPX_MOVE(os.receiver),	2,702✔
85	HPX_MOVE(os.ts).template get<Is>()...);	1,317✔
86	},	1,385✔
87	[&](std::exception_ptr ep) {	1,385✔
88	hpx::execution::experimental::set_error(	×
89	HPX_MOVE(os.receiver), HPX_MOVE(ep));	×
90	});	×
91	}	1,385✔
92	};
93
94	template <typename Receiver>
95	friend auto tag_invoke(	1,369✔
96	connect_t, just_sender&& s, Receiver&& receiver) noexcept(util::
97	all_of_v<std::is_nothrow_move_constructible<Ts>...>)
98	{
99	return operation_state<Receiver>{	1,369✔
100	HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.ts)};	1,369✔
101	}	×
102
103	template <typename Receiver>
104	friend auto
105	tag_invoke(connect_t, just_sender& s, Receiver&& receiver) noexcept(	16✔
106	util::all_of_v<std::is_nothrow_copy_constructible<Ts>...>)
107	{
108	return operation_state<Receiver>{	16✔
109	HPX_FORWARD(Receiver, receiver), s.ts};	16✔
110	}	×
111	};
112
113	template <typename Pack, typename... Ts, typename Env>
114	auto tag_invoke(get_completion_signatures_t,
115	just_sender<set_value_t, Pack, Ts...> const&, Env) noexcept
116	-> hpx::execution::experimental::completion_signatures<
117	set_value_t(Ts...), set_error_t(std::exception_ptr)>;
118
119	// different versions of clang-format disagree
120	// clang-format off
121	template <typename Pack, typename Error, typename Env>
122	auto tag_invoke(get_completion_signatures_t,
123	just_sender<set_error_t, Pack, Error> const&, Env) noexcept
124	-> hpx::execution::experimental::completion_signatures<
125	set_error_t(std::exception_ptr), set_error_t(Error)>;
126	// clang-format on
127
128	template <typename Pack, typename... Ts, typename Env>
129	auto tag_invoke(get_completion_signatures_t,
130	just_sender<set_stopped_t, Pack, Ts...> const&, Env) noexcept
131	-> hpx::execution::experimental::completion_signatures<
132	set_stopped_t(), set_error_t(std::exception_ptr)>;
133	} // namespace detail
134
135	// Returns a sender with no completion schedulers, which sends the provided
136	// values. The input values are decay-copied into the returned sender. When
137	// the returned sender is connected to a receiver, the values are moved into
138	// the operation state if the sender is an rvalue; otherwise, they are
139	// copied. Then xvalues referencing the values in the operation state are
140	// passed to the receiver's set_value.
141	inline constexpr struct just_t final
142	{
143	template <typename... Ts>
144	constexpr HPX_FORCEINLINE auto operator()(Ts&&... ts) const	1,377✔
145	{
146	return detail::just_sender<	1,377✔
147	hpx::execution::experimental::set_value_t,
148	hpx::util::make_index_pack_t<sizeof...(Ts)>, Ts...>{
149	HPX_FORWARD(Ts, ts)...};	1,313✔
150	}
151	} just{};
152
153	// Returns a sender with no completion schedulers, which completes with the
154	// specified error. If the provided error is an lvalue reference, a copy is
155	// made inside the returned sender and a non-const lvalue reference to the
156	// copy is sent to the receiver's set_error. If the provided value is an
157	// rvalue reference, it is moved into the returned sender and an rvalue
158	// reference to it is sent to the receiver's set_error.
159	inline constexpr struct just_error_t final
160	{
161	template <typename Error>
162	constexpr HPX_FORCEINLINE auto operator()(Error&& error) const	1✔
163	{
164	return detail::just_sender<	1✔
165	hpx::execution::experimental::set_error_t,
166	hpx::util::make_index_pack_t<std::size_t(1)>, Error>{
167	HPX_FORWARD(Error, error)};	1✔
168	}
169	} just_error{};
170
171	// Returns a sender with no completion schedulers, which completes
172	// immediately by calling the receiver's set_stopped.
173	inline constexpr struct just_stopped_t final
174	{
175	template <typename... Ts>
176	constexpr HPX_FORCEINLINE auto operator()(Ts&&... ts) const
177	{
178	return detail::just_sender<
179	hpx::execution::experimental::set_stopped_t,
180	hpx::util::make_index_pack_t<sizeof...(Ts)>, Ts...>{
181	HPX_FORWARD(Ts, ts)...};
182	}
183	} just_stopped{};
184	} // namespace hpx::execution::experimental

STEllAR-GROUP / hpx / #863

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous