1 /* 2 Copyright (c) 2005-2020 Intel Corporation 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 #define DOCTEST_CONFIG_SUPER_FAST_ASSERTS 18 #include "common/test.h" 19 20 #include "tbb/spin_mutex.h" 21 #include "tbb/spin_rw_mutex.h" 22 #include "tbb/queuing_mutex.h" 23 #include "tbb/queuing_rw_mutex.h" 24 25 //! \file test_profiling.cpp 26 //! \brief Test for [internal] functionality 27 28 //! Test for mutexes set_name 29 //! \brief \ref interface 30 TEST_CASE_TEMPLATE("Mutexes set_name", Mutex, tbb::spin_mutex, 31 tbb::spin_rw_mutex, 32 tbb::speculative_spin_mutex, 33 tbb::speculative_spin_rw_mutex, 34 tbb::queuing_mutex, 35 tbb::queuing_rw_mutex) { 36 Mutex mutex; 37 tbb::profiling::set_name(mutex, "mutex"); 38 } 39 40 41 #if (_WIN32||_WIN64) && !__MINGW32__ 42 //! Test for mutexes set_name with wchar 43 //! \brief \ref interface 44 TEST_CASE_TEMPLATE("Mutexes set_name wchar", Mutex, tbb::spin_mutex, 45 tbb::spin_rw_mutex, 46 tbb::speculative_spin_mutex, 47 tbb::speculative_spin_rw_mutex, 48 tbb::queuing_mutex, 49 tbb::queuing_rw_mutex) { 50 Mutex mutex; 51 tbb::profiling::set_name(mutex, L"mutex"); 52 } 53 #endif //WIN 54 55 #include "tbb/flow_graph.h" 56 57 struct Body { 58 template<typename... Args> 59 int operator()(Args...) { return 0; } 60 }; 61 62 //! Test for flow graph set_name 63 //! \brief \ref interface 64 TEST_CASE("Flow Graph set_name") { 65 tbb::flow::graph g; 66 tbb::profiling::set_name(g, "graph"); 67 } 68 69 struct async_body 70 { 71 template<typename T> 72 void operator()(int, T&) {}; 73 }; 74 75 //! Test for async_node set_name 76 //! \brief \ref interface 77 TEST_CASE("async_node set_name") { 78 tbb::flow::graph g; 79 tbb::flow::async_node<int, int> node(g, 1, async_body{}); 80 tbb::profiling::set_name(node, "async_node"); 81 } 82 83 //! Test for broadcast_node set_name 84 //! \brief \ref interface 85 TEST_CASE("broadcast_node set_name") { 86 tbb::flow::graph g; 87 tbb::flow::broadcast_node<int> node(g); 88 tbb::profiling::set_name(node, "broadcast_node"); 89 } 90 91 //! Test for buffer_node set_name 92 //! \brief \ref interface 93 TEST_CASE("buffer_node set_name") { 94 tbb::flow::graph g; 95 tbb::flow::buffer_node<int> node(g); 96 tbb::profiling::set_name(node, "buffer_node"); 97 } 98 99 //! Test for composite_node set_name 100 //! \brief \ref interface 101 TEST_CASE("composite_node set_name") { 102 tbb::flow::graph g; 103 tbb::flow::composite_node<std::tuple<int>, std::tuple<int>> node(g); 104 tbb::profiling::set_name(node, "composite_node"); 105 } 106 107 //! Test for continue_node set_name 108 //! \brief \ref interface 109 TEST_CASE("continue_node set_name") { 110 tbb::flow::graph g; 111 tbb::flow::continue_node<tbb::flow::continue_msg> node(g, 112 [](const tbb::flow::continue_msg& val) -> const tbb::flow::continue_msg& 113 { 114 return val; 115 }); 116 tbb::profiling::set_name(node, "continue_node"); 117 } 118 119 //! Test for function_node set_name 120 //! \brief \ref interface 121 TEST_CASE("function_node set_name") { 122 tbb::flow::graph g; 123 tbb::flow::function_node<int, int> node(g, 1, [](const int& val) -> int {return val; }); 124 tbb::profiling::set_name(node, "function_node"); 125 } 126 127 //! Test for indexer_node set_name 128 //! \brief \ref interface 129 TEST_CASE("indexer_node set_name") { 130 tbb::flow::graph g; 131 tbb::flow::indexer_node<int> node1(g); 132 tbb::profiling::set_name(node1, "indexer_node"); 133 tbb::flow::indexer_node<int, int> node2(g); 134 tbb::profiling::set_name(node2, "indexer_node"); 135 tbb::flow::indexer_node<int, int, int> node3(g); 136 tbb::profiling::set_name(node3, "indexer_node"); 137 tbb::flow::indexer_node<int, int, int, int> node4(g); 138 tbb::profiling::set_name(node4, "indexer_node"); 139 tbb::flow::indexer_node<int, int, int, int, int> node5(g); 140 tbb::profiling::set_name(node5, "indexer_node"); 141 tbb::flow::indexer_node<int, int, int, int, int, int> node6(g); 142 tbb::profiling::set_name(node6, "indexer_node"); 143 tbb::flow::indexer_node<int, int, int, int, int, int, int> node7(g); 144 tbb::profiling::set_name(node7, "indexer_node"); 145 tbb::flow::indexer_node<int, int, int, int, int, int, int, int> node8(g); 146 tbb::profiling::set_name(node8, "indexer_node"); 147 tbb::flow::indexer_node<int, int, int, int, int, int, int, int, int> node9(g); 148 tbb::profiling::set_name(node9, "indexer_node"); 149 tbb::flow::indexer_node<int, int, int, int, int, int, int, int, int, int> node10(g); 150 tbb::profiling::set_name(node10, "indexer_node"); 151 } 152 153 //! Test for input_node set_name 154 //! \brief \ref interface 155 TEST_CASE("input_node set_name") { 156 tbb::flow::graph g; 157 tbb::flow::input_node<int> node(g, [](tbb::flow_control& ) -> int { return 0;}); 158 tbb::profiling::set_name(node, "input_node"); 159 } 160 161 //! Test for join_node set_name 162 //! \brief \ref interface 163 TEST_CASE("join_node set_name") { 164 tbb::flow::graph g; 165 tbb::flow::join_node<std::tuple<int>> node(g); 166 tbb::profiling::set_name(node, "join_node"); 167 } 168 169 //! Test for limiter_node set_name 170 //! \brief \ref interface 171 TEST_CASE("limiter_node set_name") { 172 tbb::flow::graph g; 173 tbb::flow::limiter_node<int> node(g, 1); 174 tbb::profiling::set_name(node, "limiter_node"); 175 } 176 177 struct mf_body 178 { 179 template<typename T> 180 void operator()(int, T&) {}; 181 }; 182 183 //! Test for multifunction_node set_name 184 //! \brief \ref interface 185 TEST_CASE("multifunction_node set_name") { 186 tbb::flow::graph g; 187 tbb::flow::multifunction_node<int, std::tuple<int>> node(g, 1, mf_body{}); 188 tbb::profiling::set_name(node, "multifunction_node"); 189 } 190 191 //! Test for overwrite_node set_name 192 //! \brief \ref interface 193 TEST_CASE("overwrite_node set_name") { 194 tbb::flow::graph g; 195 tbb::flow::overwrite_node<int> node(g); 196 tbb::profiling::set_name(node, "overwrite_node"); 197 } 198 199 //! Test for priority_queue_node set_name 200 //! \brief \ref interface 201 TEST_CASE("priority_queue_node set_name") { 202 tbb::flow::graph g; 203 tbb::flow::priority_queue_node<int> node(g); 204 tbb::profiling::set_name(node, "priority_queue_node"); 205 } 206 207 //! Test for queue_node set_name 208 //! \brief \ref interface 209 TEST_CASE("queue_node set_name") { 210 tbb::flow::graph g; 211 tbb::flow::queue_node<int> node(g); 212 tbb::profiling::set_name(node, "queue_node"); 213 } 214 215 struct seq_inspector { 216 int operator()(const int& v) const { return v; } 217 }; 218 219 //! Test for sequencer_node set_name 220 //! \brief \ref interface 221 TEST_CASE("sequencer_node set_name") { 222 tbb::flow::graph g; 223 tbb::flow::sequencer_node<int> node(g, seq_inspector{}); 224 tbb::profiling::set_name(node, "sequencer_node"); 225 } 226 227 //! Test for split_node set_name 228 //! \brief \ref interface 229 TEST_CASE("split_node set_name") { 230 tbb::flow::graph g; 231 tbb::flow::split_node<std::tuple<int>> node(g); 232 tbb::profiling::set_name(node, "split_node"); 233 } 234 235 //! Test for write_once_node set_name 236 //! \brief \ref interface 237 TEST_CASE("write_once_node set_name") { 238 tbb::flow::graph g; 239 tbb::flow::write_once_node<int> node(g); 240 tbb::profiling::set_name(node, "write_once_node"); 241 } 242 243 #include "tbb/profiling.h" 244 245 //! Test for event 246 //! \brief \ref interface 247 TEST_CASE("event class") { 248 tbb::profiling::event e("event"); 249 e.emit(); 250 tbb::profiling::event::emit("emit"); 251 } 252