1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/*
Copyright (c) 2020-2023 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#if __INTEL_COMPILER && _MSC_VER
#pragma warning(disable : 2586) // decorated name length exceeded, name was truncated
#endif
#define CONFORMANCE_MULTIFUNCTION_NODE
#include "conformance_flowgraph.h"
#include "common/test_invoke.h"
//! \file conformance_multifunction_node.cpp
//! \brief Test for [flow_graph.function_node] specification
using input_msg = conformance::message</*default_ctor*/true, /*copy_ctor*/true, /*copy_assign*/false>;
using output_msg = conformance::message</*default_ctor*/false, /*copy_ctor*/false, /*copy_assign*/false>;
/*
Test function_node is a graph_node, receiver<Input>, and sender<Output>
*/
template<typename I, typename O>
void test_inheritance(){
using namespace oneapi::tbb::flow;
CHECK_MESSAGE((std::is_base_of<graph_node, multifunction_node<I, O>>::value), "multifunction_node should be derived from graph_node");
CHECK_MESSAGE((std::is_base_of<receiver<I>, multifunction_node<I, O>>::value), "multifunction_node should be derived from receiver<Input>");
}
//! Test node reject the incoming message if the concurrency limit achieved.
//! \brief \ref interface
TEST_CASE("multifunction_node with rejecting policy"){
conformance::test_rejecting<oneapi::tbb::flow::multifunction_node<int, std::tuple<int>, oneapi::tbb::flow::rejecting>>();
}
//! Test nodes for execution with priority in single-threaded configuration
//! \brief \ref interface
TEST_CASE("multifunction_node priority"){
conformance::test_priority<oneapi::tbb::flow::multifunction_node<input_msg, std::tuple<int>>, input_msg>(oneapi::tbb::flow::unlimited);
}
//! Test function_node has a user-settable concurrency limit. It can be set to one of predefined values.
//! The user can also provide a value of type std::size_t to limit concurrency.
//! Test that not more than limited threads works in parallel.
//! \brief \ref interface
TEST_CASE("multifunction_node concurrency"){
conformance::test_concurrency<oneapi::tbb::flow::multifunction_node<int, std::tuple<int>>>();
}
//! Test all node constructors
//! \brief \ref interface
TEST_CASE("multifunction_node constructors"){
using namespace oneapi::tbb::flow;
graph g;
conformance::counting_functor<int> fun;
multifunction_node<int, std::tuple<int>> fn1(g, unlimited, fun);
multifunction_node<int, std::tuple<int>> fn2(g, unlimited, fun, oneapi::tbb::flow::node_priority_t(1));
multifunction_node<int, std::tuple<int>, lightweight> lw_node1(g, serial, fun, lightweight());
multifunction_node<int, std::tuple<int>, lightweight> lw_node2(g, serial, fun, lightweight(), oneapi::tbb::flow::node_priority_t(1));
}
//! The node that is constructed has a reference to the same graph object as src, has a copy of the initial body used by src, and has the same concurrency threshold as src.
//! The predecessors and successors of src are not copied.
//! \brief \ref interface
TEST_CASE("multifunction_node copy constructor"){
conformance::test_copy_ctor<oneapi::tbb::flow::multifunction_node<int, std::tuple<int>>>();
}
//! Test node not buffered unsuccessful message, and try_get after rejection should not succeed.
//! \brief \ref requirement
TEST_CASE("multifunction_node buffering"){
conformance::dummy_functor<int> fun;
conformance::test_buffering<oneapi::tbb::flow::multifunction_node<input_msg, std::tuple<int>,
oneapi::tbb::flow::rejecting>, input_msg>(oneapi::tbb::flow::unlimited, fun);
}
//! Test multifunction_node broadcasting
//! \brief \ref requirement
TEST_CASE("multifunction_node broadcast"){
conformance::counting_functor<int> fun(conformance::expected);
conformance::test_forwarding<oneapi::tbb::flow::multifunction_node<input_msg, std::tuple<int>>, input_msg, int>(1, oneapi::tbb::flow::unlimited, fun);
}
//! Test the body object passed to a node is copied
//! \brief \ref interface
TEST_CASE("multifunction_node copy body"){
conformance::test_copy_body_function<oneapi::tbb::flow::multifunction_node<int, std::tuple<int>>, conformance::copy_counting_object<int>>(oneapi::tbb::flow::unlimited);
}
//! Test execution of node body
//! Test node can do try_put call
//! \brief \ref interface \ref requirement
TEST_CASE("multifunction_node body") {
conformance::test_body_exec<oneapi::tbb::flow::multifunction_node<input_msg, std::tuple<output_msg>, oneapi::tbb::flow::rejecting>, input_msg, output_msg>(oneapi::tbb::flow::unlimited);
}
//! Test multifunction_node output_ports() returns a tuple of output ports.
//! \brief \ref interface \ref requirement
TEST_CASE("multifunction_node output_ports") {
using namespace oneapi::tbb::flow;
graph g;
conformance::dummy_functor<int> fun;
oneapi::tbb::flow::multifunction_node <int, std::tuple<int>> node(g, unlimited, fun);
CHECK_MESSAGE((std::is_same<oneapi::tbb::flow::multifunction_node<int, std::tuple<int>>::output_ports_type&,
decltype(node.output_ports())>::value), "multifunction_node output_ports should returns a tuple of output ports");
}
//! Test inheritance relations
//! \brief \ref interface
TEST_CASE("multifunction_node superclasses"){
test_inheritance<int, std::tuple<int>>();
test_inheritance<void*, std::tuple<float>>();
test_inheritance<input_msg, std::tuple<output_msg>>();
}
//! Test node Input class meet the DefaultConstructible and CopyConstructible requirements and Output class meet the CopyConstructible requirements.
//! \brief \ref interface \ref requirement
TEST_CASE("Test function_node Output and Input class") {
using Body = conformance::copy_counting_object<int>;
conformance::test_output_input_class<oneapi::tbb::flow::multifunction_node<Body, std::tuple<Body>>, Body>();
}
#if __TBB_CPP17_INVOKE_PRESENT
//! Test that multifunction_node uses std::invoke to execute the body
//! \brief \ref interface \ref requirement
TEST_CASE("Test multifunction_node and std::invoke") {
using namespace oneapi::tbb::flow;
using output_type1 = test_invoke::SmartID<std::size_t>;
using input_type = test_invoke::SmartID<output_type1>;
using output_tuple1 = std::tuple<output_type1, output_type1>;
using output_tuple2 = std::tuple<std::size_t>;
using first_mf_node_type = multifunction_node<input_type, output_tuple1>;
using second_mf_node_type = multifunction_node<output_type1, output_tuple2>;
using first_ports_type = typename first_mf_node_type::output_ports_type;
using second_ports_type = typename second_mf_node_type::output_ports_type;
graph g;
auto first_body = &input_type::template send_id<first_ports_type>;
auto second_body = &output_type1::template send_id<second_ports_type>;
first_mf_node_type mf1(g, unlimited, first_body);
second_mf_node_type mf21(g, unlimited, second_body);
second_mf_node_type mf22(g, unlimited, second_body);
buffer_node<std::size_t> buf(g);
make_edge(output_port<0>(mf1), mf21);
make_edge(output_port<1>(mf1), mf22);
make_edge(output_port<0>(mf21), buf);
make_edge(output_port<0>(mf22), buf);
mf1.try_put(input_type{output_type1{1}});
g.wait_for_all();
std::size_t buf_size = 0;
std::size_t tmp = 0;
while(buf.try_get(tmp)) {
++buf_size;
CHECK(tmp == 1);
}
CHECK(buf_size == 2);
}
#endif
|
