1 /* 2 Copyright (c) 2005-2021 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 #if __INTEL_COMPILER && _MSC_VER 18 #pragma warning(disable : 2586) // decorated name length exceeded, name was truncated 19 #endif 20 21 #define DOCTEST_CONFIG_SUPER_FAST_ASSERTS 22 #include "common/test.h" 23 24 #include "tbb/spin_mutex.h" 25 #include "tbb/spin_rw_mutex.h" 26 #include "tbb/queuing_mutex.h" 27 #include "tbb/queuing_rw_mutex.h" 28 29 //! \file test_profiling.cpp 30 //! \brief Test for [internal] functionality 31 32 //! Test for mutexes set_name 33 //! \brief \ref interface 34 TEST_CASE_TEMPLATE("Mutexes set_name", Mutex, tbb::spin_mutex, 35 tbb::spin_rw_mutex, 36 tbb::speculative_spin_mutex, 37 tbb::speculative_spin_rw_mutex, 38 tbb::queuing_mutex, 39 tbb::queuing_rw_mutex) { 40 Mutex mutex; 41 tbb::profiling::set_name(mutex, "mutex"); 42 } 43 44 45 #if (_WIN32||_WIN64) && !__MINGW32__ 46 //! Test for mutexes set_name with wchar 47 //! \brief \ref interface 48 TEST_CASE_TEMPLATE("Mutexes set_name wchar", Mutex, tbb::spin_mutex, 49 tbb::spin_rw_mutex, 50 tbb::speculative_spin_mutex, 51 tbb::speculative_spin_rw_mutex, 52 tbb::queuing_mutex, 53 tbb::queuing_rw_mutex) { 54 Mutex mutex; 55 tbb::profiling::set_name(mutex, L"mutex"); 56 } 57 #endif //WIN 58 59 #include "tbb/flow_graph.h" 60 61 struct Body { 62 template<typename... Args> 63 int operator()(Args...) { return 0; } 64 }; 65 66 //! Test for flow graph set_name 67 //! \brief \ref interface 68 TEST_CASE("Flow Graph set_name") { 69 tbb::flow::graph g; 70 tbb::profiling::set_name(g, "graph"); 71 } 72 73 struct async_body 74 { 75 template<typename T> 76 void operator()(int, T&) {}; 77 }; 78 79 //! Test for async_node set_name 80 //! \brief \ref interface 81 TEST_CASE("async_node set_name") { 82 tbb::flow::graph g; 83 tbb::flow::async_node<int, int> node(g, 1, async_body{}); 84 tbb::profiling::set_name(node, "async_node"); 85 } 86 87 //! Test for broadcast_node set_name 88 //! \brief \ref interface 89 TEST_CASE("broadcast_node set_name") { 90 tbb::flow::graph g; 91 tbb::flow::broadcast_node<int> node(g); 92 tbb::profiling::set_name(node, "broadcast_node"); 93 } 94 95 //! Test for buffer_node set_name 96 //! \brief \ref interface 97 TEST_CASE("buffer_node set_name") { 98 tbb::flow::graph g; 99 tbb::flow::buffer_node<int> node(g); 100 tbb::profiling::set_name(node, "buffer_node"); 101 } 102 103 //! Test for composite_node set_name 104 //! \brief \ref interface 105 TEST_CASE("composite_node set_name") { 106 tbb::flow::graph g; 107 tbb::flow::composite_node<std::tuple<int>, std::tuple<int>> node(g); 108 tbb::profiling::set_name(node, "composite_node"); 109 } 110 111 //! Test for continue_node set_name 112 //! \brief \ref interface 113 TEST_CASE("continue_node set_name") { 114 tbb::flow::graph g; 115 tbb::flow::continue_node<tbb::flow::continue_msg> node(g, 116 [](const tbb::flow::continue_msg& val) -> const tbb::flow::continue_msg& 117 { 118 return val; 119 }); 120 tbb::profiling::set_name(node, "continue_node"); 121 } 122 123 //! Test for function_node set_name 124 //! \brief \ref interface 125 TEST_CASE("function_node set_name") { 126 tbb::flow::graph g; 127 tbb::flow::function_node<int, int> node(g, 1, [](const int& val) -> int {return val; }); 128 tbb::profiling::set_name(node, "function_node"); 129 } 130 131 //! Test for indexer_node set_name 132 //! \brief \ref interface 133 TEST_CASE("indexer_node set_name") { 134 tbb::flow::graph g; 135 tbb::flow::indexer_node<int> node1(g); 136 tbb::profiling::set_name(node1, "indexer_node"); 137 tbb::flow::indexer_node<int, int> node2(g); 138 tbb::profiling::set_name(node2, "indexer_node"); 139 tbb::flow::indexer_node<int, int, int> node3(g); 140 tbb::profiling::set_name(node3, "indexer_node"); 141 tbb::flow::indexer_node<int, int, int, int> node4(g); 142 tbb::profiling::set_name(node4, "indexer_node"); 143 tbb::flow::indexer_node<int, int, int, int, int> node5(g); 144 tbb::profiling::set_name(node5, "indexer_node"); 145 tbb::flow::indexer_node<int, int, int, int, int, int> node6(g); 146 tbb::profiling::set_name(node6, "indexer_node"); 147 tbb::flow::indexer_node<int, int, int, int, int, int, int> node7(g); 148 tbb::profiling::set_name(node7, "indexer_node"); 149 tbb::flow::indexer_node<int, int, int, int, int, int, int, int> node8(g); 150 tbb::profiling::set_name(node8, "indexer_node"); 151 tbb::flow::indexer_node<int, int, int, int, int, int, int, int, int> node9(g); 152 tbb::profiling::set_name(node9, "indexer_node"); 153 tbb::flow::indexer_node<int, int, int, int, int, int, int, int, int, int> node10(g); 154 tbb::profiling::set_name(node10, "indexer_node"); 155 } 156 157 //! Test for input_node set_name 158 //! \brief \ref interface 159 TEST_CASE("input_node set_name") { 160 tbb::flow::graph g; 161 tbb::flow::input_node<int> node(g, [](tbb::flow_control& ) -> int { return 0;}); 162 tbb::profiling::set_name(node, "input_node"); 163 } 164 165 //! Test for join_node set_name 166 //! \brief \ref interface 167 TEST_CASE("join_node set_name") { 168 tbb::flow::graph g; 169 tbb::flow::join_node<std::tuple<int>> node(g); 170 tbb::profiling::set_name(node, "join_node"); 171 } 172 173 //! Test for limiter_node set_name 174 //! \brief \ref interface 175 TEST_CASE("limiter_node set_name") { 176 tbb::flow::graph g; 177 tbb::flow::limiter_node<int> node(g, 1); 178 tbb::profiling::set_name(node, "limiter_node"); 179 } 180 181 struct mf_body 182 { 183 template<typename T> 184 void operator()(int, T&) {}; 185 }; 186 187 //! Test for multifunction_node set_name 188 //! \brief \ref interface 189 TEST_CASE("multifunction_node set_name") { 190 tbb::flow::graph g; 191 tbb::flow::multifunction_node<int, std::tuple<int>> node(g, 1, mf_body{}); 192 tbb::profiling::set_name(node, "multifunction_node"); 193 } 194 195 //! Test for overwrite_node set_name 196 //! \brief \ref interface 197 TEST_CASE("overwrite_node set_name") { 198 tbb::flow::graph g; 199 tbb::flow::overwrite_node<int> node(g); 200 tbb::profiling::set_name(node, "overwrite_node"); 201 } 202 203 //! Test for priority_queue_node set_name 204 //! \brief \ref interface 205 TEST_CASE("priority_queue_node set_name") { 206 tbb::flow::graph g; 207 tbb::flow::priority_queue_node<int> node(g); 208 tbb::profiling::set_name(node, "priority_queue_node"); 209 } 210 211 //! Test for queue_node set_name 212 //! \brief \ref interface 213 TEST_CASE("queue_node set_name") { 214 tbb::flow::graph g; 215 tbb::flow::queue_node<int> node(g); 216 tbb::profiling::set_name(node, "queue_node"); 217 } 218 219 struct seq_inspector { 220 int operator()(const int& v) const { return v; } 221 }; 222 223 //! Test for sequencer_node set_name 224 //! \brief \ref interface 225 TEST_CASE("sequencer_node set_name") { 226 tbb::flow::graph g; 227 tbb::flow::sequencer_node<int> node(g, seq_inspector{}); 228 tbb::profiling::set_name(node, "sequencer_node"); 229 } 230 231 //! Test for split_node set_name 232 //! \brief \ref interface 233 TEST_CASE("split_node set_name") { 234 tbb::flow::graph g; 235 tbb::flow::split_node<std::tuple<int>> node(g); 236 tbb::profiling::set_name(node, "split_node"); 237 } 238 239 //! Test for write_once_node set_name 240 //! \brief \ref interface 241 TEST_CASE("write_once_node set_name") { 242 tbb::flow::graph g; 243 tbb::flow::write_once_node<int> node(g); 244 tbb::profiling::set_name(node, "write_once_node"); 245 } 246 247 #include "tbb/profiling.h" 248 249 //! Test for event 250 //! \brief \ref interface 251 TEST_CASE("event class") { 252 tbb::profiling::event e("event"); 253 e.emit(); 254 tbb::profiling::event::emit("emit"); 255 } 256