/* Copyright (c) 2005-2021 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 #include "common/config.h" #include "tbb/flow_graph.h" #include "common/test.h" #include "common/utils.h" #include "common/graph_utils.h" #include "common/spin_barrier.h" //! \file test_flow_graph.cpp //! \brief Test for [flow_graph.continue_msg flow_graph.graph_node flow_graph.input_port flow_graph.output_port flow_graph.join_node flow_graph.split_node flow_graph.limiter_node flow_graph.write_once_node flow_graph.overwrite_node flow_graph.make_edge flow_graph.graph flow_graph.buffer_node flow_graph.function_node flow_graph.multifunction_node flow_graph.continue_node flow_graph.input_node] specification const int T = 4; const int W = 4; struct decrement_wait : utils::NoAssign { tbb::flow::graph * const my_graph; bool * const my_done_flag; decrement_wait( tbb::flow::graph &h, bool *done_flag ) : my_graph(&h), my_done_flag(done_flag) {} void operator()(int i) const { utils::Sleep(10 * i); my_done_flag[i] = true; my_graph->release_wait(); } }; static void test_wait_count() { tbb::flow::graph h; for (int i = 0; i < T; ++i ) { bool done_flag[W]; for (int j = 0; j < W; ++j ) { for ( int w = 0; w < W; ++w ) done_flag[w] = false; for ( int w = 0; w < j; ++w ) h.reserve_wait(); utils::NativeParallelFor( j, decrement_wait(h, done_flag) ); h.wait_for_all(); for ( int w = 0; w < W; ++w ) { if ( w < j ) CHECK_MESSAGE( done_flag[w] == true, "" ); else CHECK_MESSAGE( done_flag[w] == false, "" ); } } } } // Encapsulate object we want to store in vector (because contained type must have // copy constructor and assignment operator class my_int_buffer { tbb::flow::buffer_node *b; tbb::flow::graph& my_graph; public: my_int_buffer(tbb::flow::graph &g) : my_graph(g) { b = new tbb::flow::buffer_node(my_graph); } my_int_buffer(const my_int_buffer& other) : my_graph(other.my_graph) { b = new tbb::flow::buffer_node(my_graph); } ~my_int_buffer() { delete b; } my_int_buffer& operator=(const my_int_buffer& /*other*/) { return *this; } }; // test the graph iterator, delete nodes from graph, test again void test_iterator() { tbb::flow::graph g; my_int_buffer a_buffer(g); my_int_buffer b_buffer(g); my_int_buffer c_buffer(g); my_int_buffer *d_buffer = new my_int_buffer(g); my_int_buffer e_buffer(g); std::vector< my_int_buffer > my_buffer_vector(10, c_buffer); int count = 0; for (tbb::flow::graph::iterator it = g.begin(); it != g.end(); ++it) { count++; } CHECK_MESSAGE( (count==15), "error in iterator count"); delete d_buffer; count = 0; for (tbb::flow::graph::iterator it = g.begin(); it != g.end(); ++it) { count++; } CHECK_MESSAGE( (count==14), "error in iterator count"); my_buffer_vector.clear(); count = 0; for (tbb::flow::graph::iterator it = g.begin(); it != g.end(); ++it) { count++; } CHECK_MESSAGE( (count==4), "error in iterator count"); } class AddRemoveBody : utils::NoAssign { tbb::flow::graph& g; int nThreads; utils::SpinBarrier &barrier; public: AddRemoveBody(int nthr, utils::SpinBarrier &barrier_, tbb::flow::graph& _g) : g(_g), nThreads(nthr), barrier(barrier_) {} void operator()(const int /*threadID*/) const { my_int_buffer b(g); { std::vector my_buffer_vector(100, b); barrier.wait(); // wait until all nodes are created // now test that the proper number of nodes were created int count = 0; for (tbb::flow::graph::iterator it = g.begin(); it != g.end(); ++it) { count++; } CHECK_MESSAGE( (count==101*nThreads), "error in iterator count"); barrier.wait(); // wait until all threads are done counting } // all nodes but for the initial node on this thread are deleted barrier.wait(); // wait until all threads have deleted all nodes in their vectors // now test that all the nodes were deleted except for the initial node int count = 0; for (tbb::flow::graph::iterator it = g.begin(); it != g.end(); ++it) { count++; } CHECK_MESSAGE( (count==nThreads), "error in iterator count"); barrier.wait(); // wait until all threads are done counting } // initial node gets deleted }; void test_parallel(int nThreads) { tbb::flow::graph g; utils::SpinBarrier barrier(nThreads); AddRemoveBody body(nThreads, barrier, g); NativeParallelFor(nThreads, body); } /* * Functors for graph arena spawn tests */ inline void check_arena(tbb::task_arena* midway_arena) { CHECK_MESSAGE(midway_arena->max_concurrency() == 2, ""); CHECK_MESSAGE(tbb::this_task_arena::max_concurrency() == 1, ""); } struct run_functor { tbb::task_arena* midway_arena; int return_value; run_functor(tbb::task_arena* a) : midway_arena(a), return_value(1) {} int operator()() { check_arena(midway_arena); return return_value; } }; template < typename T > struct function_body { tbb::task_arena* midway_arena; function_body(tbb::task_arena* a) : midway_arena(a) {} tbb::flow::continue_msg operator()(const T& /*arg*/) { check_arena(midway_arena); return tbb::flow::continue_msg(); } }; typedef tbb::flow::multifunction_node< int, std::tuple< int > > mf_node; struct multifunction_body { tbb::task_arena* midway_arena; multifunction_body(tbb::task_arena* a) : midway_arena(a) {} void operator()(const int& /*arg*/, mf_node::output_ports_type& /*outports*/) { check_arena(midway_arena); } }; struct input_body { tbb::task_arena* midway_arena; int counter; input_body(tbb::task_arena* a) : midway_arena(a), counter(0) {} int operator()(tbb::flow_control &fc) { check_arena(midway_arena); if (counter++ >= 1) { fc.stop(); } return int(); } }; struct nodes_test_functor : utils::NoAssign { tbb::task_arena* midway_arena; tbb::flow::graph& my_graph; nodes_test_functor(tbb::task_arena* a, tbb::flow::graph& g) : midway_arena(a), my_graph(g) {} void operator()() const { // Define test nodes // Continue, function, source nodes tbb::flow::continue_node< tbb::flow::continue_msg > c_n(my_graph, function_body(midway_arena)); tbb::flow::function_node< int > f_n(my_graph, tbb::flow::unlimited, function_body(midway_arena)); tbb::flow::input_node< int > s_n(my_graph, input_body(midway_arena)); // Multifunction node mf_node m_n(my_graph, tbb::flow::unlimited, multifunction_body(midway_arena)); // Join node tbb::flow::function_node< std::tuple< int, int > > join_f_n( my_graph, tbb::flow::unlimited, function_body< std::tuple< int, int > >(midway_arena) ); tbb::flow::join_node< std::tuple< int, int > > j_n(my_graph); make_edge(j_n, join_f_n); // Split node tbb::flow::function_node< int > split_f_n1 = f_n; tbb::flow::function_node< int > split_f_n2 = f_n; tbb::flow::split_node< std::tuple< int, int > > sp_n(my_graph); make_edge(tbb::flow::output_port<0>(sp_n), split_f_n1); make_edge(tbb::flow::output_port<1>(sp_n), split_f_n2); // Overwrite node tbb::flow::function_node< int > ow_f_n = f_n; tbb::flow::overwrite_node< int > ow_n(my_graph); make_edge(ow_n, ow_f_n); // Write once node tbb::flow::function_node< int > w_f_n = f_n; tbb::flow::write_once_node< int > w_n(my_graph); make_edge(w_n, w_f_n); // Buffer node tbb::flow::function_node< int > buf_f_n = f_n; tbb::flow::buffer_node< int > buf_n(my_graph); make_edge(w_n, buf_f_n); // Limiter node tbb::flow::function_node< int > l_f_n = f_n; tbb::flow::limiter_node< int > l_n(my_graph, 1); make_edge(l_n, l_f_n); // Execute nodes c_n.try_put( tbb::flow::continue_msg() ); f_n.try_put(1); m_n.try_put(1); s_n.activate(); tbb::flow::input_port<0>(j_n).try_put(1); tbb::flow::input_port<1>(j_n).try_put(1); std::tuple< int, int > sp_tuple(1, 1); sp_n.try_put(sp_tuple); ow_n.try_put(1); w_n.try_put(1); buf_n.try_put(1); l_n.try_put(1); my_graph.wait_for_all(); } }; void test_graph_arena() { // There is only one thread for execution (external thread). // So, if graph's tasks get spawned in different arena // external thread won't be able to find them in its own arena. // In this case test should hang. tbb::task_arena arena(1); arena.execute( [&]() { tbb::flow::graph g; tbb::task_arena midway_arena; midway_arena.initialize(2); midway_arena.execute(nodes_test_functor(&midway_arena, g)); } ); } //! Test wait counts //! \brief error_guessing TEST_CASE("Test wait_count"){ for(unsigned int p=utils::MinThread; p<=utils::MaxThread; ++p ) { tbb::task_arena arena(p); arena.execute( [&]() { test_wait_count(); } ); } } //! Test graph iterators //! \brief interface TEST_CASE("Test graph::iterator"){ for(unsigned int p=utils::MinThread; p<=utils::MaxThread; ++p ) { tbb::task_arena arena(p); arena.execute( [&]() { test_iterator(); } ); } } //! Test parallel for body //! \brief \ref error_guessing TEST_CASE("Test parallel"){ for(unsigned int p=utils::MinThread; p<=utils::MaxThread; ++p ) { tbb::task_arena arena(p); arena.execute( [&]() { test_parallel(p); } ); } } //! Test separate arena isn't used //! \brief \ref error_guessing TEST_CASE("Test graph_arena"){ test_graph_arena(); } //! Graph iterator //! \brief \ref error_guessing TEST_CASE("graph iterator") { using namespace tbb::flow; graph g; auto past_end = g.end(); ++past_end; continue_node n(g, [](const continue_msg &){return 1;}); size_t item_count = 0; for(auto it = g.cbegin(); it != g.cend(); it++) ++item_count; CHECK_MESSAGE((item_count == 1), "Should find 1 item"); item_count = 0; auto jt(g.begin()); for(; jt != g.end(); jt++) ++item_count; CHECK_MESSAGE((item_count == 1), "Should find 1 item"); graph g2; continue_node n2(g, [](const continue_msg &){return 1;}); CHECK_MESSAGE((g.begin() != g2.begin()), "Different graphs should have different iterators"); }