#859

Committed 05 Jan 2023 05:50PM UTC coverage: 85.881% (-0.6%) from 86.496%

Build # #859

Build Type

push

Committed by StellarBot

Commit Message

Merge #6116

6116: Add new command line argument --hpx:loopback_network r=hkaiser a=JiakunYan

Option `--hpx:loopback_network=0|1`. If set to 1, the network (at least the initialization phase) will be enabled even if the locality number is 1.

It is useful for debugging networks.

Co-authored-by: Jiakun Yan <jiakunyan1998@gmail.com>

Run Details

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

173321 of 201815 relevant lines covered (85.88%)

1844045.06 hits per line

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

10.81

/libs/full/actions/tests/unit/serialize_buffer.cpp

//  Copyright (c) 2014-2022 Hartmut Kaiser
//  Copyright (c) 2015 Andreas Schaefer
//
//  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.hpp>
#include <hpx/hpx_init.hpp>
#include <hpx/include/actions.hpp>
#include <hpx/include/lcos.hpp>
#include <hpx/modules/testing.hpp>
#include <hpx/serialization/serialize_buffer.hpp>

#include <cstddef>
#include <memory>
#include <vector>

///////////////////////////////////////////////////////////////////////////////
typedef hpx::serialization::serialize_buffer<char> buffer_plain_type;

buffer_plain_type bounce_plain(buffer_plain_type const& receive_buffer)
{
    return receive_buffer;
}
HPX_PLAIN_ACTION(bounce_plain)

HPX_REGISTER_BASE_LCO_WITH_VALUE_DECLARATION(
    buffer_plain_type, serialization_buffer_char)
HPX_REGISTER_BASE_LCO_WITH_VALUE(buffer_plain_type, serialization_buffer_char)

///////////////////////////////////////////////////////////////////////////////
template <typename Buffer, typename Action>
void test(hpx::id_type dest, char* send_buffer, std::size_t size)
{
    using buffer_type = Buffer;
    buffer_type recv_buffer;

    std::vector<hpx::future<buffer_type>> recv_buffers;
    recv_buffers.reserve(10);

    Action act;
    for (std::size_t j = 0; j != 10; ++j)
    {
        recv_buffers.push_back(hpx::async(
            act, dest, buffer_type(send_buffer, size, buffer_type::reference)));
    }
    hpx::wait_all(recv_buffers);

    for (hpx::future<buffer_type>& f : recv_buffers)
    {
        buffer_type b = f.get();
        HPX_TEST_EQ(b.size(), size);
        HPX_TEST_EQ(0, memcmp(b.data(), send_buffer, size));
    }
}

template <typename Allocator>
void test_stateful_allocator(hpx::id_type dest, char* send_buffer,
    std::size_t size, Allocator const& alloc)
{
    using buffer_type = buffer_plain_type;
    buffer_type recv_buffer;

    std::vector<hpx::future<buffer_type>> recv_buffers;
    recv_buffers.reserve(10);

    bounce_plain_action act;
    for (std::size_t j = 0; j != 10; ++j)
    {
        recv_buffers.push_back(hpx::async(act, dest,
            buffer_type(send_buffer, size, buffer_type::reference, alloc)));
    }
    hpx::wait_all(recv_buffers);

    for (hpx::future<buffer_type>& f : recv_buffers)
    {
        buffer_type b = f.get();
        HPX_TEST_EQ(b.size(), size);
        HPX_TEST_EQ(0, memcmp(b.data(), send_buffer, size));
    }
}

template <typename T>
void test_fixed_size_initialization_for_persistent_buffers(std::size_t max_size)
{
    for (std::size_t size = 1; size <= max_size; size *= 2)
    {
        std::vector<T> send_vec;
        std::vector<T> recv_vec;
        send_vec.reserve(size);
        for (std::size_t i = 0; i < size; ++i)
        {
            send_vec.push_back(static_cast<int>(size - i));
        }

        hpx::serialization::serialize_buffer<T> send_buffer(size);
        hpx::serialization::serialize_buffer<T> recv_buffer;
        std::copy(send_vec.begin(), send_vec.end(), send_buffer.begin());
        recv_buffer = send_buffer;

        std::copy(recv_buffer.begin(), recv_buffer.end(),
            std::back_inserter(recv_vec));
        HPX_TEST(send_vec == recv_vec);
    }
}

template <typename T>
void test_initialization_from_vector(std::size_t max_size)
{
    for (std::size_t size = 1; size <= max_size; size *= 2)
    {
        std::vector<T> send_vec;
        std::vector<T> recv_vec;
        send_vec.reserve(size);
        for (std::size_t i = 0; i < size; ++i)
        {
            send_vec.push_back(size - i);
        }

        // default init mode is "copy"
        hpx::serialization::serialize_buffer<T> send_buffer(
            send_vec[0], send_vec.size());
        hpx::serialization::serialize_buffer<T> recv_buffer;
        std::copy(send_vec.begin(), send_vec.end(), send_buffer.begin());
        recv_buffer = send_buffer;

        std::copy(recv_buffer.begin(), recv_buffer.end(),
            std::back_inserter(recv_vec));
        HPX_TEST(send_vec == recv_vec);
    }
}

///////////////////////////////////////////////////////////////////////////////
int hpx_main()
{
#if defined(HPX_DEBUG)
    std::size_t const max_size = 1 << 10;
#else
    std::size_t const max_size = 1 << 20;
#endif

    std::unique_ptr<char[]> send_buffer(new char[max_size]);

    for (hpx::id_type const& loc : hpx::find_all_localities())
    {
        for (std::size_t size = 1; size <= max_size; size *= 2)
        {
            test<buffer_plain_type, bounce_plain_action>(
                loc, send_buffer.get(), size);
            test_stateful_allocator(
                loc, send_buffer.get(), size, std::allocator<char>());
        }
    }

    for (std::size_t size = 1; size <= max_size; size *= 2)
    {
        test_fixed_size_initialization_for_persistent_buffers<int>(size);
        test_fixed_size_initialization_for_persistent_buffers<char>(size);
        test_fixed_size_initialization_for_persistent_buffers<float>(size);
        test_fixed_size_initialization_for_persistent_buffers<double>(size);
    }

    return hpx::finalize();
}

///////////////////////////////////////////////////////////////////////////////
int main(int argc, char* argv[])
{
    HPX_TEST_EQ(hpx::init(argc, argv), 0);
    return 0;
}
#endif

1	// Copyright (c) 2014-2022 Hartmut Kaiser
2	// Copyright (c) 2015 Andreas Schaefer
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	#include <hpx/config.hpp>
9	#if !defined(HPX_COMPUTE_DEVICE_CODE)
10	#include <hpx/hpx.hpp>
11	#include <hpx/hpx_init.hpp>
12	#include <hpx/include/actions.hpp>
13	#include <hpx/include/lcos.hpp>
14	#include <hpx/modules/testing.hpp>
15	#include <hpx/serialization/serialize_buffer.hpp>
16
17	#include <cstddef>
18	#include <memory>
19	#include <vector>
20
21	///////////////////////////////////////////////////////////////////////////////
22	typedef hpx::serialization::serialize_buffer<char> buffer_plain_type;
23
24	buffer_plain_type bounce_plain(buffer_plain_type const& receive_buffer)	220✔
25	{
26	return receive_buffer;	220✔
27	}
28	HPX_PLAIN_ACTION(bounce_plain)	223✔
29
30	HPX_REGISTER_BASE_LCO_WITH_VALUE_DECLARATION(	220✔
31	buffer_plain_type, serialization_buffer_char)
32	HPX_REGISTER_BASE_LCO_WITH_VALUE(buffer_plain_type, serialization_buffer_char)	448✔
33
34	///////////////////////////////////////////////////////////////////////////////
35	template <typename Buffer, typename Action>
36	void test(hpx::id_type dest, char* send_buffer, std::size_t size)	×
37	{
38	using buffer_type = Buffer;
39	buffer_type recv_buffer;	×
40
41	std::vector<hpx::future<buffer_type>> recv_buffers;	×
42	recv_buffers.reserve(10);	×
43
44	Action act;
45	for (std::size_t j = 0; j != 10; ++j)	×
46	{
47	recv_buffers.push_back(hpx::async(	×
48	act, dest, buffer_type(send_buffer, size, buffer_type::reference)));	×
49	}	×
50	hpx::wait_all(recv_buffers);	×
51
52	for (hpx::future<buffer_type>& f : recv_buffers)	×
53	{
54	buffer_type b = f.get();	×
55	HPX_TEST_EQ(b.size(), size);	×
56	HPX_TEST_EQ(0, memcmp(b.data(), send_buffer, size));	×
57	}	×
58	}	×
59
60	template <typename Allocator>
61	void test_stateful_allocator(hpx::id_type dest, char* send_buffer,	×
62	std::size_t size, Allocator const& alloc)
63	{
64	using buffer_type = buffer_plain_type;
65	buffer_type recv_buffer;	×
66
67	std::vector<hpx::future<buffer_type>> recv_buffers;	×
68	recv_buffers.reserve(10);	×
69
70	bounce_plain_action act;
71	for (std::size_t j = 0; j != 10; ++j)	×
72	{
73	recv_buffers.push_back(hpx::async(act, dest,	×
74	buffer_type(send_buffer, size, buffer_type::reference, alloc)));	×
75	}	×
76	hpx::wait_all(recv_buffers);	×
77
78	for (hpx::future<buffer_type>& f : recv_buffers)	×
79	{
80	buffer_type b = f.get();	×
81	HPX_TEST_EQ(b.size(), size);	×
82	HPX_TEST_EQ(0, memcmp(b.data(), send_buffer, size));	×
83	}	×
84	}	×
85
86	template <typename T>
87	void test_fixed_size_initialization_for_persistent_buffers(std::size_t max_size)	×
88	{
89	for (std::size_t size = 1; size <= max_size; size *= 2)	×
90	{
91	std::vector<T> send_vec;	×
92	std::vector<T> recv_vec;	×
93	send_vec.reserve(size);	×
94	for (std::size_t i = 0; i < size; ++i)	×
95	{
96	send_vec.push_back(static_cast<int>(size - i));	×
97	}	×
98
99	hpx::serialization::serialize_buffer<T> send_buffer(size);	×
100	hpx::serialization::serialize_buffer<T> recv_buffer;	×
101	std::copy(send_vec.begin(), send_vec.end(), send_buffer.begin());	×
102	recv_buffer = send_buffer;	×
103
104	std::copy(recv_buffer.begin(), recv_buffer.end(),	×
105	std::back_inserter(recv_vec));	×
106	HPX_TEST(send_vec == recv_vec);	×
107	}	×
108	}	×
109
110	template <typename T>
111	void test_initialization_from_vector(std::size_t max_size)
112	{
113	for (std::size_t size = 1; size <= max_size; size *= 2)
114	{
115	std::vector<T> send_vec;
116	std::vector<T> recv_vec;
117	send_vec.reserve(size);
118	for (std::size_t i = 0; i < size; ++i)
119	{
120	send_vec.push_back(size - i);
121	}
122
123	// default init mode is "copy"
124	hpx::serialization::serialize_buffer<T> send_buffer(
125	send_vec[0], send_vec.size());
126	hpx::serialization::serialize_buffer<T> recv_buffer;
127	std::copy(send_vec.begin(), send_vec.end(), send_buffer.begin());
128	recv_buffer = send_buffer;
129
130	std::copy(recv_buffer.begin(), recv_buffer.end(),
131	std::back_inserter(recv_vec));
132	HPX_TEST(send_vec == recv_vec);
133	}
134	}
135
136	///////////////////////////////////////////////////////////////////////////////
137	int hpx_main()	×
138	{
139	#if defined(HPX_DEBUG)
140	std::size_t const max_size = 1 << 10;	×
141	#else
142	std::size_t const max_size = 1 << 20;
143	#endif
144
145	std::unique_ptr<char[]> send_buffer(new char[max_size]);	×
146
147	for (hpx::id_type const& loc : hpx::find_all_localities())	×
148	{
149	for (std::size_t size = 1; size <= max_size; size *= 2)	×
150	{
151	test<buffer_plain_type, bounce_plain_action>(	×
152	loc, send_buffer.get(), size);	×
153	test_stateful_allocator(	×
154	loc, send_buffer.get(), size, std::allocator<char>());	×
155	}	×
156	}
157
158	for (std::size_t size = 1; size <= max_size; size *= 2)	×
159	{
160	test_fixed_size_initialization_for_persistent_buffers<int>(size);	×
161	test_fixed_size_initialization_for_persistent_buffers<char>(size);	×
162	test_fixed_size_initialization_for_persistent_buffers<float>(size);	×
163	test_fixed_size_initialization_for_persistent_buffers<double>(size);	×
164	}	×
165
166	return hpx::finalize();	×
167	}	×
168
169	///////////////////////////////////////////////////////////////////////////////
170	int main(int argc, char* argv[])	1✔
171	{
172	HPX_TEST_EQ(hpx::init(argc, argv), 0);	1✔
173	return 0;	1✔
174	}	×
175	#endif

STEllAR-GROUP / hpx / #859

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