#868

Committed 16 Jan 2023 08:21PM UTC coverage: 86.487%. Remained the same

Build # #868

Build Type

push

Committed by StellarBot

Commit Message

Merge #6137

6137: Adding example of a simple master/slave distributed application r=hkaiser a=hkaiser

The purpose of this example is to demonstrate how HPX actions can be used to build a simple master-slave application. The master (locality 0) assigns work to the slaves (all other localities). Note that if this application is run on one locality only it uses the same locality for the master and the slave functionalities.

The slaves receive a message that encodes how many sub-tasks of a certain type they should spawn locally.


Co-authored-by: Hartmut Kaiser <hartmut.kaiser@gmail.com>

Run Details

72 of 72 new or added lines in 1 file covered. (100.0%)

174663 of 201952 relevant lines covered (86.49%)

1849169.69 hits per line

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

1.18

/libs/full/segmented_algorithms/tests/unit/partitioned_vector_inclusive_scan.cpp

//  Copyright (c) 2016 Minh-Khanh Do
//
//  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)

#include <hpx/config.hpp>
#if !defined(HPX_COMPUTE_DEVICE_CODE)
#include <hpx/hpx_main.hpp>
#include <hpx/include/parallel_scan.hpp>
#include <hpx/include/partitioned_vector_predef.hpp>
#include <hpx/include/runtime.hpp>
#include <hpx/modules/testing.hpp>
#include <hpx/modules/timing.hpp>

#include "partitioned_vector_scan.hpp"

#include <cstddef>
#include <iomanip>
#include <iostream>
#include <type_traits>
#include <vector>

///////////////////////////////////////////////////////////////////////////////
#define msg7(a, b, c, d, e, f, g)                                              \
    std::cout << std::setw(60) << a << std::setw(40) << b << std::setw(10)     \
              << c << std::setw(6) << " " << #d << " " << e << " " << f << " " \
              << g << " ";
#define msg9(a, b, c, d, e, f, g, h, i)                                        \
    std::cout << std::setw(60) << a << std::setw(40) << b << std::setw(10)     \
              << c << std::setw(6) << " " << #d << " " << e << " " << f << " " \
              << g << " " << h << " " << i << " ";

///////////////////////////////////////////////////////////////////////////////

template <typename T>
struct opt
{
    T operator()(T v1, T v2) const
    {
        return v1 + v2;
    }
};

///////////////////////////////////////////////////////////////////////////////
template <typename T, typename DistPolicy, typename ExPolicy>
void inclusive_scan_algo_tests_with_policy(std::size_t size,
    DistPolicy const& dist_policy, hpx::partitioned_vector<T>& in,
    std::vector<T> ver, ExPolicy const& policy)
{
    msg7(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),
        regular, size, dist_policy.get_num_partitions(),
        dist_policy.get_localities().size());
    hpx::chrono::high_resolution_timer t1;

    std::vector<T> out(in.size());
    T val(0);

    double e1 = t1.elapsed();
    t1.restart();

    hpx::inclusive_scan(
        policy, in.begin(), in.end(), out.begin(), opt<T>(), val);

    double e2 = t1.elapsed();
    t1.restart();

    HPX_TEST(std::equal(out.begin(), out.end(), ver.begin()));

    double e3 = t1.elapsed();
    std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3
              << "\n";
}

template <typename T, typename DistPolicy, typename ExPolicy>
void inclusive_scan_algo_tests_segmented_out_with_policy(std::size_t size,
    DistPolicy const& in_dist_policy, DistPolicy const& out_dist_policy,
    hpx::partitioned_vector<T>& in, hpx::partitioned_vector<T> out,
    std::vector<T> ver, ExPolicy const& policy)
{
    msg9(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),
        segmented, size, in_dist_policy.get_num_partitions(),
        in_dist_policy.get_localities().size(),
        out_dist_policy.get_num_partitions(),
        out_dist_policy.get_localities().size());
    hpx::chrono::high_resolution_timer t1;

    T val(0);

    double e1 = t1.elapsed();
    t1.restart();

    hpx::inclusive_scan(
        policy, in.begin(), in.end(), out.begin(), opt<T>(), val);

    double e2 = t1.elapsed();
    t1.restart();

    verify_values(out, ver);

    double e3 = t1.elapsed();
    std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3
              << "\n";
}

template <typename T, typename DistPolicy, typename ExPolicy>
void inclusive_scan_algo_tests_inplace_with_policy(std::size_t size,
    DistPolicy const& dist_policy, std::vector<T> ver, ExPolicy const& policy)
{
    msg7(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),
        inplace, size, dist_policy.get_num_partitions(),
        dist_policy.get_localities().size());
    hpx::chrono::high_resolution_timer t1;

    hpx::partitioned_vector<T> in(size, dist_policy);
    iota_vector(in, T(1));

    T val(0);

    double e1 = t1.elapsed();
    t1.restart();

    hpx::inclusive_scan(
        policy, in.begin(), in.end(), in.begin(), opt<T>(), val);

    double e2 = t1.elapsed();
    t1.restart();

    verify_values(in, ver);

    double e3 = t1.elapsed();
    std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3
              << "\n";
}

///////////////////////////////////////////////////////////////////////////////

template <typename T, typename DistPolicy, typename ExPolicy>
void inclusive_scan_algo_tests_with_policy_async(std::size_t size,
    DistPolicy const& dist_policy, hpx::partitioned_vector<T>& in,
    std::vector<T> ver, ExPolicy const& policy)
{
    msg7(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),
        async, size, dist_policy.get_num_partitions(),
        dist_policy.get_localities().size());
    hpx::chrono::high_resolution_timer t1;

    std::vector<T> out(in.size());
    T val(0);

    double e1 = t1.elapsed();
    t1.restart();

    auto res = hpx::inclusive_scan(
        policy, in.begin(), in.end(), out.begin(), opt<T>(), val);
    res.get();

    double e2 = t1.elapsed();
    t1.restart();

    HPX_TEST(std::equal(out.begin(), out.end(), ver.begin()));

    double e3 = t1.elapsed();
    std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3
              << "\n";
}

template <typename T, typename DistPolicy, typename ExPolicy>
void inclusive_scan_algo_tests_segmented_out_with_policy_async(std::size_t size,
    DistPolicy const& in_dist_policy, DistPolicy const& out_dist_policy,
    hpx::partitioned_vector<T>& in, hpx::partitioned_vector<T> out,
    std::vector<T> ver, ExPolicy const& policy)
{
    msg9(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),
        async_segmented, size, in_dist_policy.get_num_partitions(),
        in_dist_policy.get_localities().size(),
        out_dist_policy.get_num_partitions(),
        out_dist_policy.get_localities().size());
    hpx::chrono::high_resolution_timer t1;

    T val(0);

    double e1 = t1.elapsed();
    t1.restart();

    auto res = hpx::inclusive_scan(
        policy, in.begin(), in.end(), out.begin(), opt<T>(), val);
    res.get();

    double e2 = t1.elapsed();
    t1.restart();

    verify_values(out, ver);

    double e3 = t1.elapsed();
    std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3
              << "\n";
}

template <typename T, typename DistPolicy, typename ExPolicy>
void inclusive_scan_algo_tests_inplace_with_policy_async(std::size_t size,
    DistPolicy const& dist_policy, std::vector<T> ver, ExPolicy const& policy)
{
    msg7(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),
        async_inplace, size, dist_policy.get_num_partitions(),
        dist_policy.get_localities().size());
    hpx::chrono::high_resolution_timer t1;

    hpx::partitioned_vector<T> in(size, dist_policy);
    iota_vector(in, T(1));

    T val(0);

    double e1 = t1.elapsed();
    t1.restart();

    auto res = hpx::inclusive_scan(
        policy, in.begin(), in.end(), in.begin(), opt<T>(), val);
    res.get();

    double e2 = t1.elapsed();
    t1.restart();

    verify_values(in, ver);

    double e3 = t1.elapsed();
    std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3
              << "\n";
}

///////////////////////////////////////////////////////////////////////////////

template <typename T, typename DistPolicy>
void inclusive_scan_tests_with_policy(
    std::size_t size, DistPolicy const& policy)
{
    using namespace hpx::execution;

    // setup partitioned vector to test
    hpx::partitioned_vector<T> in(size, policy);
    iota_vector(in, T(1));

    std::vector<T> ver(in.size());
    std::iota(ver.begin(), ver.end(), T(1));
    T val(0);

    hpx::parallel::v1::detail::sequential_inclusive_scan(
        ver.begin(), ver.end(), ver.begin(), val, opt<T>());

    //sync
    inclusive_scan_algo_tests_with_policy<T>(size, policy, in, ver, seq);
    inclusive_scan_algo_tests_with_policy<T>(size, policy, in, ver, par);

    //async
    inclusive_scan_algo_tests_with_policy_async<T>(
        size, policy, in, ver, seq(task));
    inclusive_scan_algo_tests_with_policy_async<T>(
        size, policy, in, ver, par(task));
}

template <typename T, typename DistPolicy>
void inclusive_scan_tests_segmented_out_with_policy(
    std::size_t size, DistPolicy const& in_policy, DistPolicy const& out_policy)
{
    using namespace hpx::execution;

    // setup partitioned vector to test
    hpx::partitioned_vector<T> in(size, in_policy);
    iota_vector(in, T(1));

    hpx::partitioned_vector<T> out(size, out_policy);

    std::vector<T> ver(in.size());
    std::iota(ver.begin(), ver.end(), T(1));
    T val(0);

    hpx::parallel::v1::detail::sequential_inclusive_scan(
        ver.begin(), ver.end(), ver.begin(), val, opt<T>());

    //sync
    inclusive_scan_algo_tests_segmented_out_with_policy<T>(
        size, in_policy, out_policy, in, out, ver, seq);
    inclusive_scan_algo_tests_segmented_out_with_policy<T>(
        size, in_policy, out_policy, in, out, ver, par);

    //async
    inclusive_scan_algo_tests_segmented_out_with_policy_async<T>(
        size, in_policy, out_policy, in, out, ver, seq(task));
    inclusive_scan_algo_tests_segmented_out_with_policy_async<T>(
        size, in_policy, out_policy, in, out, ver, par(task));
}

template <typename T, typename DistPolicy>
void inclusive_scan_tests_inplace_with_policy(
    std::size_t size, DistPolicy const& policy)
{
    using namespace hpx::execution;

    // setup verification vector
    std::vector<T> ver(size);
    std::iota(ver.begin(), ver.end(), T(1));
    T val(0);

    hpx::parallel::v1::detail::sequential_inclusive_scan(
        ver.begin(), ver.end(), ver.begin(), val, opt<T>());

    // sync
    inclusive_scan_algo_tests_inplace_with_policy<T>(size, policy, ver, seq);
    inclusive_scan_algo_tests_inplace_with_policy<T>(size, policy, ver, par);

    // async
    inclusive_scan_algo_tests_inplace_with_policy_async<T>(
        size, policy, ver, seq(task));
    inclusive_scan_algo_tests_inplace_with_policy_async<T>(
        size, policy, ver, par(task));
}

///////////////////////////////////////////////////////////////////////////////

template <typename T>
void inclusive_scan_tests(std::vector<hpx::id_type>& localities)
{
#if defined(HPX_DEBUG)
    std::size_t const length = 10000;
#else
    std::size_t const length = 100000;
#endif

    inclusive_scan_tests_with_policy<T>(length, hpx::container_layout);
    inclusive_scan_tests_with_policy<T>(length, hpx::container_layout(3));
    inclusive_scan_tests_with_policy<T>(
        length, hpx::container_layout(3, localities));
    inclusive_scan_tests_with_policy<T>(
        length, hpx::container_layout(localities));

    inclusive_scan_tests_with_policy<T>(1000, hpx::container_layout(1000));

    // multiple localities needed for the following tests
    inclusive_scan_tests_segmented_out_with_policy<T>(length,
        hpx::container_layout(localities), hpx::container_layout(localities));

    inclusive_scan_tests_segmented_out_with_policy<T>(
        length, hpx::container_layout(localities), hpx::container_layout(3));

    inclusive_scan_tests_segmented_out_with_policy<T>(
        length, hpx::container_layout(localities), hpx::container_layout(10));

    inclusive_scan_tests_inplace_with_policy<T>(
        length, hpx::container_layout(localities));
}

///////////////////////////////////////////////////////////////////////////////
int main()
{
    std::vector<hpx::id_type> localities = hpx::find_all_localities();
    inclusive_scan_tests<long long>(localities);
    return hpx::util::report_errors();
}
#endif

1	// Copyright (c) 2016 Minh-Khanh Do
2	//
3	// SPDX-License-Identifier: BSL-1.0
4	// Distributed under the Boost Software License, Version 1.0. (See accompanying
5	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6
7	#include <hpx/config.hpp>
8	#if !defined(HPX_COMPUTE_DEVICE_CODE)
9	#include <hpx/hpx_main.hpp>
10	#include <hpx/include/parallel_scan.hpp>
11	#include <hpx/include/partitioned_vector_predef.hpp>
12	#include <hpx/include/runtime.hpp>
13	#include <hpx/modules/testing.hpp>
14	#include <hpx/modules/timing.hpp>
15
16	#include "partitioned_vector_scan.hpp"
17
18	#include <cstddef>
19	#include <iomanip>
20	#include <iostream>
21	#include <type_traits>
22	#include <vector>
23
24	///////////////////////////////////////////////////////////////////////////////
25	#define msg7(a, b, c, d, e, f, g) \
26	std::cout << std::setw(60) << a << std::setw(40) << b << std::setw(10) \
27	<< c << std::setw(6) << " " << #d << " " << e << " " << f << " " \
28	<< g << " ";
29	#define msg9(a, b, c, d, e, f, g, h, i) \
30	std::cout << std::setw(60) << a << std::setw(40) << b << std::setw(10) \
31	<< c << std::setw(6) << " " << #d << " " << e << " " << f << " " \
32	<< g << " " << h << " " << i << " ";
33
34	///////////////////////////////////////////////////////////////////////////////
35
36	template <typename T>
37	struct opt
38	{
39	T operator()(T v1, T v2) const	136,182✔
40	{
41	return v1 + v2;	136,195✔
42	}
43	};
44
45	///////////////////////////////////////////////////////////////////////////////
46	template <typename T, typename DistPolicy, typename ExPolicy>
47	void inclusive_scan_algo_tests_with_policy(std::size_t size,	×
48	DistPolicy const& dist_policy, hpx::partitioned_vector<T>& in,
49	std::vector<T> ver, ExPolicy const& policy)
50	{
51	msg7(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),	×
52	regular, size, dist_policy.get_num_partitions(),
53	dist_policy.get_localities().size());
54	hpx::chrono::high_resolution_timer t1;	×
55
56	std::vector<T> out(in.size());	×
57	T val(0);	×
58
59	double e1 = t1.elapsed();	×
60	t1.restart();	×
61
62	hpx::inclusive_scan(	×
63	policy, in.begin(), in.end(), out.begin(), opt<T>(), val);	×
64
65	double e2 = t1.elapsed();	×
66	t1.restart();	×
67
68	HPX_TEST(std::equal(out.begin(), out.end(), ver.begin()));	×
69
70	double e3 = t1.elapsed();	×
71	std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3	×
72	<< "\n";	×
73	}	×
74
75	template <typename T, typename DistPolicy, typename ExPolicy>
76	void inclusive_scan_algo_tests_segmented_out_with_policy(std::size_t size,	×
77	DistPolicy const& in_dist_policy, DistPolicy const& out_dist_policy,
78	hpx::partitioned_vector<T>& in, hpx::partitioned_vector<T> out,
79	std::vector<T> ver, ExPolicy const& policy)
80	{
81	msg9(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),	×
82	segmented, size, in_dist_policy.get_num_partitions(),
83	in_dist_policy.get_localities().size(),
84	out_dist_policy.get_num_partitions(),
85	out_dist_policy.get_localities().size());
86	hpx::chrono::high_resolution_timer t1;	×
87
88	T val(0);	×
89
90	double e1 = t1.elapsed();	×
91	t1.restart();	×
92
93	hpx::inclusive_scan(	×
94	policy, in.begin(), in.end(), out.begin(), opt<T>(), val);	×
95
96	double e2 = t1.elapsed();	×
97	t1.restart();	×
98
99	verify_values(out, ver);	×
100
101	double e3 = t1.elapsed();	×
102	std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3	×
103	<< "\n";	×
104	}	×
105
106	template <typename T, typename DistPolicy, typename ExPolicy>
107	void inclusive_scan_algo_tests_inplace_with_policy(std::size_t size,	×
108	DistPolicy const& dist_policy, std::vector<T> ver, ExPolicy const& policy)
109	{
110	msg7(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),	×
111	inplace, size, dist_policy.get_num_partitions(),
112	dist_policy.get_localities().size());
113	hpx::chrono::high_resolution_timer t1;	×
114
115	hpx::partitioned_vector<T> in(size, dist_policy);	×
116	iota_vector(in, T(1));	×
117
118	T val(0);	×
119
120	double e1 = t1.elapsed();	×
121	t1.restart();	×
122
123	hpx::inclusive_scan(	×
124	policy, in.begin(), in.end(), in.begin(), opt<T>(), val);	×
125
126	double e2 = t1.elapsed();	×
127	t1.restart();	×
128
129	verify_values(in, ver);	×
130
131	double e3 = t1.elapsed();	×
132	std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3	×
133	<< "\n";	×
134	}	×
135
136	///////////////////////////////////////////////////////////////////////////////
137
138	template <typename T, typename DistPolicy, typename ExPolicy>
139	void inclusive_scan_algo_tests_with_policy_async(std::size_t size,	×
140	DistPolicy const& dist_policy, hpx::partitioned_vector<T>& in,
141	std::vector<T> ver, ExPolicy const& policy)
142	{
143	msg7(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),	×
144	async, size, dist_policy.get_num_partitions(),
145	dist_policy.get_localities().size());
146	hpx::chrono::high_resolution_timer t1;	×
147
148	std::vector<T> out(in.size());	×
149	T val(0);	×
150
151	double e1 = t1.elapsed();	×
152	t1.restart();	×
153
154	auto res = hpx::inclusive_scan(	×
155	policy, in.begin(), in.end(), out.begin(), opt<T>(), val);	×
156	res.get();	×
157
158	double e2 = t1.elapsed();	×
159	t1.restart();	×
160
161	HPX_TEST(std::equal(out.begin(), out.end(), ver.begin()));	×
162
163	double e3 = t1.elapsed();	×
164	std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3	×
165	<< "\n";	×
166	}	×
167
168	template <typename T, typename DistPolicy, typename ExPolicy>
169	void inclusive_scan_algo_tests_segmented_out_with_policy_async(std::size_t size,	×
170	DistPolicy const& in_dist_policy, DistPolicy const& out_dist_policy,
171	hpx::partitioned_vector<T>& in, hpx::partitioned_vector<T> out,
172	std::vector<T> ver, ExPolicy const& policy)
173	{
174	msg9(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),	×
175	async_segmented, size, in_dist_policy.get_num_partitions(),
176	in_dist_policy.get_localities().size(),
177	out_dist_policy.get_num_partitions(),
178	out_dist_policy.get_localities().size());
179	hpx::chrono::high_resolution_timer t1;	×
180
181	T val(0);	×
182
183	double e1 = t1.elapsed();	×
184	t1.restart();	×
185
186	auto res = hpx::inclusive_scan(	×
187	policy, in.begin(), in.end(), out.begin(), opt<T>(), val);	×
188	res.get();	×
189
190	double e2 = t1.elapsed();	×
191	t1.restart();	×
192
193	verify_values(out, ver);	×
194
195	double e3 = t1.elapsed();	×
196	std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3	×
197	<< "\n";	×
198	}	×
199
200	template <typename T, typename DistPolicy, typename ExPolicy>
201	void inclusive_scan_algo_tests_inplace_with_policy_async(std::size_t size,	×
202	DistPolicy const& dist_policy, std::vector<T> ver, ExPolicy const& policy)
203	{
204	msg7(typeid(ExPolicy).name(), typeid(DistPolicy).name(), typeid(T).name(),	×
205	async_inplace, size, dist_policy.get_num_partitions(),
206	dist_policy.get_localities().size());
207	hpx::chrono::high_resolution_timer t1;	×
208
209	hpx::partitioned_vector<T> in(size, dist_policy);	×
210	iota_vector(in, T(1));	×
211
212	T val(0);	×
213
214	double e1 = t1.elapsed();	×
215	t1.restart();	×
216
217	auto res = hpx::inclusive_scan(	×
218	policy, in.begin(), in.end(), in.begin(), opt<T>(), val);	×
219	res.get();	×
220
221	double e2 = t1.elapsed();	×
222	t1.restart();	×
223
224	verify_values(in, ver);	×
225
226	double e3 = t1.elapsed();	×
227	std::cout << std::setprecision(4) << "\t" << e1 << " " << e2 << " " << e3	×
228	<< "\n";	×
229	}	×
230
231	///////////////////////////////////////////////////////////////////////////////
232
233	template <typename T, typename DistPolicy>
234	void inclusive_scan_tests_with_policy(	×
235	std::size_t size, DistPolicy const& policy)
236	{
237	using namespace hpx::execution;
238
239	// setup partitioned vector to test
240	hpx::partitioned_vector<T> in(size, policy);	×
241	iota_vector(in, T(1));	×
242
243	std::vector<T> ver(in.size());	×
244	std::iota(ver.begin(), ver.end(), T(1));	×
245	T val(0);	×
246
247	hpx::parallel::v1::detail::sequential_inclusive_scan(	×
248	ver.begin(), ver.end(), ver.begin(), val, opt<T>());	×
249
250	//sync
251	inclusive_scan_algo_tests_with_policy<T>(size, policy, in, ver, seq);	×
252	inclusive_scan_algo_tests_with_policy<T>(size, policy, in, ver, par);	×
253
254	//async
255	inclusive_scan_algo_tests_with_policy_async<T>(	×
256	size, policy, in, ver, seq(task));	×
257	inclusive_scan_algo_tests_with_policy_async<T>(	×
258	size, policy, in, ver, par(task));	×
259	}	×
260
261	template <typename T, typename DistPolicy>
262	void inclusive_scan_tests_segmented_out_with_policy(	×
263	std::size_t size, DistPolicy const& in_policy, DistPolicy const& out_policy)
264	{
265	using namespace hpx::execution;
266
267	// setup partitioned vector to test
268	hpx::partitioned_vector<T> in(size, in_policy);	×
269	iota_vector(in, T(1));	×
270
271	hpx::partitioned_vector<T> out(size, out_policy);	×
272
273	std::vector<T> ver(in.size());	×
274	std::iota(ver.begin(), ver.end(), T(1));	×
275	T val(0);	×
276
277	hpx::parallel::v1::detail::sequential_inclusive_scan(	×
278	ver.begin(), ver.end(), ver.begin(), val, opt<T>());	×
279
280	//sync
281	inclusive_scan_algo_tests_segmented_out_with_policy<T>(	×
282	size, in_policy, out_policy, in, out, ver, seq);	×
283	inclusive_scan_algo_tests_segmented_out_with_policy<T>(	×
284	size, in_policy, out_policy, in, out, ver, par);	×
285
286	//async
287	inclusive_scan_algo_tests_segmented_out_with_policy_async<T>(	×
288	size, in_policy, out_policy, in, out, ver, seq(task));	×
289	inclusive_scan_algo_tests_segmented_out_with_policy_async<T>(	×
290	size, in_policy, out_policy, in, out, ver, par(task));	×
291	}	×
292
293	template <typename T, typename DistPolicy>
294	void inclusive_scan_tests_inplace_with_policy(	×
295	std::size_t size, DistPolicy const& policy)
296	{
297	using namespace hpx::execution;
298
299	// setup verification vector
300	std::vector<T> ver(size);	×
301	std::iota(ver.begin(), ver.end(), T(1));	×
302	T val(0);	×
303
304	hpx::parallel::v1::detail::sequential_inclusive_scan(	×
305	ver.begin(), ver.end(), ver.begin(), val, opt<T>());	×
306
307	// sync
308	inclusive_scan_algo_tests_inplace_with_policy<T>(size, policy, ver, seq);	×
309	inclusive_scan_algo_tests_inplace_with_policy<T>(size, policy, ver, par);	×
310
311	// async
312	inclusive_scan_algo_tests_inplace_with_policy_async<T>(	×
313	size, policy, ver, seq(task));	×
314	inclusive_scan_algo_tests_inplace_with_policy_async<T>(	×
315	size, policy, ver, par(task));	×
316	}	×
317
318	///////////////////////////////////////////////////////////////////////////////
319
320	template <typename T>
321	void inclusive_scan_tests(std::vector<hpx::id_type>& localities)	×
322	{
323	#if defined(HPX_DEBUG)
324	std::size_t const length = 10000;	×
325	#else
326	std::size_t const length = 100000;
327	#endif
328
329	inclusive_scan_tests_with_policy<T>(length, hpx::container_layout);	×
330	inclusive_scan_tests_with_policy<T>(length, hpx::container_layout(3));	×
331	inclusive_scan_tests_with_policy<T>(	×
332	length, hpx::container_layout(3, localities));	×
333	inclusive_scan_tests_with_policy<T>(	×
334	length, hpx::container_layout(localities));	×
335
336	inclusive_scan_tests_with_policy<T>(1000, hpx::container_layout(1000));	×
337
338	// multiple localities needed for the following tests
339	inclusive_scan_tests_segmented_out_with_policy<T>(length,	×
340	hpx::container_layout(localities), hpx::container_layout(localities));	×
341
342	inclusive_scan_tests_segmented_out_with_policy<T>(	×
343	length, hpx::container_layout(localities), hpx::container_layout(3));	×
344
345	inclusive_scan_tests_segmented_out_with_policy<T>(	×
346	length, hpx::container_layout(localities), hpx::container_layout(10));	×
347
348	inclusive_scan_tests_inplace_with_policy<T>(	×
349	length, hpx::container_layout(localities));	×
350	}	×
351
352	///////////////////////////////////////////////////////////////////////////////
353	int main()	×
354	{
355	std::vector<hpx::id_type> localities = hpx::find_all_localities();	×
356	inclusive_scan_tests<long long>(localities);	×
357	return hpx::util::report_errors();	×
358	}	×
359	#endif

STEllAR-GROUP / hpx / #868

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