#865

Committed 13 Jan 2023 11:46PM UTC coverage: 86.431% (+0.08%) from 86.354%

Build # #865

Build Type

push

Committed by StellarBot

Commit Message

Merge #6132

6132: Fixing to_non_par() for parallel simd policies r=hkaiser a=hkaiser



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

Run Details

64 of 64 new or added lines in 3 files covered. (100.0%)

174506 of 201901 relevant lines covered (86.43%)

1999640.87 hits per line

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

97.3

/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)	664✔
29
30	HPX_REGISTER_BASE_LCO_WITH_VALUE_DECLARATION(	×
31	buffer_plain_type, serialization_buffer_char)
32	HPX_REGISTER_BASE_LCO_WITH_VALUE(buffer_plain_type, serialization_buffer_char)	227✔
33
34	///////////////////////////////////////////////////////////////////////////////
35	template <typename Buffer, typename Action>
36	void test(hpx::id_type dest, char* send_buffer, std::size_t size)	22✔
37	{
38	using buffer_type = Buffer;
39	buffer_type recv_buffer;	22✔
40
41	std::vector<hpx::future<buffer_type>> recv_buffers;	22✔
42	recv_buffers.reserve(10);	22✔
43
44	Action act;
45	for (std::size_t j = 0; j != 10; ++j)	242✔
46	{
47	recv_buffers.push_back(hpx::async(	220✔
48	act, dest, buffer_type(send_buffer, size, buffer_type::reference)));	220✔
49	}	220✔
50	hpx::wait_all(recv_buffers);	22✔
51
52	for (hpx::future<buffer_type>& f : recv_buffers)	242✔
53	{
54	buffer_type b = f.get();	220✔
55	HPX_TEST_EQ(b.size(), size);	220✔
56	HPX_TEST_EQ(0, memcmp(b.data(), send_buffer, size));	220✔
57	}	220✔
58	}	22✔
59
60	template <typename Allocator>
61	void test_stateful_allocator(hpx::id_type dest, char* send_buffer,	22✔
62	std::size_t size, Allocator const& alloc)
63	{
64	using buffer_type = buffer_plain_type;
65	buffer_type recv_buffer;	22✔
66
67	std::vector<hpx::future<buffer_type>> recv_buffers;	22✔
68	recv_buffers.reserve(10);	22✔
69
70	bounce_plain_action act;
71	for (std::size_t j = 0; j != 10; ++j)	242✔
72	{
73	recv_buffers.push_back(hpx::async(act, dest,	220✔
74	buffer_type(send_buffer, size, buffer_type::reference, alloc)));	220✔
75	}	220✔
76	hpx::wait_all(recv_buffers);	22✔
77
78	for (hpx::future<buffer_type>& f : recv_buffers)	242✔
79	{
80	buffer_type b = f.get();	220✔
81	HPX_TEST_EQ(b.size(), size);	220✔
82	HPX_TEST_EQ(0, memcmp(b.data(), send_buffer, size));	220✔
83	}	220✔
84	}	22✔
85
86	template <typename T>
87	void test_fixed_size_initialization_for_persistent_buffers(std::size_t max_size)	44✔
88	{
89	for (std::size_t size = 1; size <= max_size; size *= 2)	308✔
90	{
91	std::vector<T> send_vec;	264✔
92	std::vector<T> recv_vec;	264✔
93	send_vec.reserve(size);	264✔
94	for (std::size_t i = 0; i < size; ++i)	16,596✔
95	{
96	send_vec.push_back(static_cast<int>(size - i));	16,332✔
97	}	16,332✔
98
99	hpx::serialization::serialize_buffer<T> send_buffer(size);	264✔
100	hpx::serialization::serialize_buffer<T> recv_buffer;	264✔
101	std::copy(send_vec.begin(), send_vec.end(), send_buffer.begin());	264✔
102	recv_buffer = send_buffer;	264✔
103
104	std::copy(recv_buffer.begin(), recv_buffer.end(),	264✔
105	std::back_inserter(recv_vec));	264✔
106	HPX_TEST(send_vec == recv_vec);	264✔
107	}	264✔
108	}	44✔
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()	1✔
138	{
139	#if defined(HPX_DEBUG)
140	std::size_t const max_size = 1 << 10;	1✔
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]);	1✔
146
147	for (hpx::id_type const& loc : hpx::find_all_localities())	3✔
148	{
149	for (std::size_t size = 1; size <= max_size; size *= 2)	24✔
150	{
151	test<buffer_plain_type, bounce_plain_action>(	22✔
152	loc, send_buffer.get(), size);	22✔
153	test_stateful_allocator(	22✔
154	loc, send_buffer.get(), size, std::allocator<char>());	22✔
155	}	22✔
156	}
157
158	for (std::size_t size = 1; size <= max_size; size *= 2)	12✔
159	{
160	test_fixed_size_initialization_for_persistent_buffers<int>(size);	11✔
161	test_fixed_size_initialization_for_persistent_buffers<char>(size);	11✔
162	test_fixed_size_initialization_for_persistent_buffers<float>(size);	11✔
163	test_fixed_size_initialization_for_persistent_buffers<double>(size);	11✔
164	}	11✔
165
166	return hpx::finalize();	1✔
167	}	1✔
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 / #865

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