1 // Copyright (c) 2007-2017 Hartmut Kaiser
2 //
3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6 #include <hpx/config.hpp>
7 #include <hpx/runtime.hpp>
8 #include <hpx/util/itt_notify.hpp>
9 #include <hpx/util/thread_description.hpp>
10 #include <hpx/util/thread_specific_ptr.hpp>
11
12 #if HPX_HAVE_ITTNOTIFY != 0
13
14 #define INTEL_ITTNOTIFY_API_PRIVATE
15
16 #include <ittnotify.h>
17 #include <legacy/ittnotify.h>
18
19 #include <cstddef>
20 #include <cstdint>
21
22 ///////////////////////////////////////////////////////////////////////////////
23 // decide whether to use the ITT notify API if it's available
24 bool use_ittnotify_api = false;
25
26 ///////////////////////////////////////////////////////////////////////////////
27 #define HPX_INTERNAL_ITT_SYNC_CREATE(obj, type, name) \
28 if (use_ittnotify_api && __itt_sync_create_ptr) { \
29 __itt_sync_create_ptr( \
30 const_cast<void*>(static_cast<volatile void*>(obj)), \
31 type, name, __itt_attr_mutex); \
32 } \
33 /**/
34 #define HPX_INTERNAL_ITT_SYNC(fname, obj) \
35 if (use_ittnotify_api && __itt_ ## fname ## _ptr) { \
36 __itt_ ## fname ## _ptr( \
37 const_cast<void*>(static_cast<volatile void*>(obj))); \
38 } \
39 /**/
40 #define HPX_INTERNAL_ITT_SYNC_RENAME(obj, name) \
41 if (use_ittnotify_api && __itt_sync_rename_ptr) { \
42 __itt_sync_rename_ptr( \
43 const_cast<void*>(static_cast<volatile void*>(obj)), name); \
44 } \
45 /**/
46
47 ///////////////////////////////////////////////////////////////////////////////
48 #define HPX_INTERNAL_ITT_STACK_CREATE() \
49 (use_ittnotify_api && __itt_stack_caller_create_ptr) ? \
50 __itt_stack_caller_create_ptr() : (__itt_caller)nullptr \
51 /**/
52 #define HPX_INTERNAL_ITT_STACK_ENTER(ctx) \
53 if (use_ittnotify_api && __itt_stack_callee_enter_ptr) \
54 __itt_stack_callee_enter_ptr(ctx); \
55 /**/
56 #define HPX_INTERNAL_ITT_STACK_LEAVE(ctx) \
57 if (use_ittnotify_api && __itt_stack_callee_leave_ptr) \
58 __itt_stack_callee_leave_ptr(ctx); \
59 /**/
60 #define HPX_INTERNAL_ITT_STACK_DESTROY(ctx) \
61 if (use_ittnotify_api && __itt_stack_caller_destroy_ptr && \
62 ctx != (__itt_caller)nullptr) \
63 __itt_stack_caller_destroy_ptr(ctx); \
64 /**/
65
66 ///////////////////////////////////////////////////////////////////////////////
67 #define HPX_INTERNAL_ITT_FRAME_BEGIN(domain, id) \
68 if (use_ittnotify_api && __itt_frame_begin_v3_ptr) \
69 __itt_frame_begin_v3_ptr(domain, id); \
70 /**/
71 #define HPX_INTERNAL_ITT_FRAME_END(domain, id) \
72 if (use_ittnotify_api && __itt_frame_end_v3_ptr) \
73 __itt_frame_end_v3_ptr(domain, id); \
74 /**/
75
76 ///////////////////////////////////////////////////////////////////////////////
77 #define HPX_INTERNAL_ITT_MARK_CREATE(name) \
78 (use_ittnotify_api && __itt_mark_create_ptr) ? \
79 __itt_mark_create_ptr(name) : 0 \
80 /**/
81 #define HPX_INTERNAL_ITT_MARK_OFF(mark) \
82 if (use_ittnotify_api && __itt_mark_off_ptr) __itt_mark_off_ptr(mark); \
83 /**/
84 #define HPX_INTERNAL_ITT_MARK(mark, parameter) \
85 if (use_ittnotify_api && __itt_mark_ptr) __itt_mark_ptr(mark, parameter); \
86 /**/
87
88 ///////////////////////////////////////////////////////////////////////////////
89 #define HPX_INTERNAL_ITT_THREAD_SET_NAME(name) \
90 if (use_ittnotify_api && __itt_thread_set_name_ptr) \
91 __itt_thread_set_name_ptr(name); \
92 /**/
93 #define HPX_INTERNAL_ITT_THREAD_IGNORE() \
94 if (use_ittnotify_api && __itt_thread_ignore_ptr) \
95 __itt_thread_ignore_ptr(); \
96 /**/
97
98 ///////////////////////////////////////////////////////////////////////////////
99 #define HPX_INTERNAL_ITT_TASK_BEGIN(domain, name) \
100 if (use_ittnotify_api && __itt_task_begin_ptr) \
101 __itt_task_begin_ptr(domain, __itt_null, __itt_null, name); \
102 /**/
103 #define HPX_INTERNAL_ITT_TASK_BEGIN_ID(domain, id, name) \
104 if (use_ittnotify_api && __itt_task_begin_ptr) \
105 __itt_task_begin_ptr(domain, id, __itt_null, name); \
106 /**/
107 #define HPX_INTERNAL_ITT_TASK_END(domain) \
108 if (use_ittnotify_api && __itt_task_end_ptr) \
109 __itt_task_end_ptr(domain); \
110 /**/
111
112 #define HPX_INTERNAL_ITT_DOMAIN_CREATE(name) \
113 (use_ittnotify_api && __itt_domain_create_ptr) ? \
114 __itt_domain_create_ptr(name) : nullptr \
115 /**/
116
117 #define HPX_INTERNAL_ITT_STRING_HANDLE_CREATE(name) \
118 (use_ittnotify_api && __itt_string_handle_create_ptr) ? \
119 __itt_string_handle_create_ptr(name) : nullptr \
120 /**/
121
122 #define HPX_INTERNAL_ITT_MAKE_ID(addr, extra) \
123 use_ittnotify_api ? __itt_id_make(addr, extra) : __itt_null \
124 /**/
125
126 #define HPX_INTERNAL_ITT_ID_CREATE(domain, id) \
127 if (use_ittnotify_api && __itt_id_create_ptr) \
128 __itt_id_create_ptr(domain, id); \
129 /**/
130 #define HPX_INTERNAL_ITT_ID_DESTROY(id) delete id
131
132 ///////////////////////////////////////////////////////////////////////////////
133 #define HPX_INTERNAL_ITT_HEAP_FUNCTION_CREATE(name, domain) \
134 (use_ittnotify_api && __itt_heap_function_create_ptr) ? \
135 __itt_heap_function_create_ptr(name, domain) : nullptr \
136 /**/
137
138 #define HPX_INTERNAL_HEAP_ALLOCATE_BEGIN(f, size, init) \
139 if (use_ittnotify_api && __itt_heap_allocate_begin_ptr) \
140 __itt_heap_allocate_begin_ptr(f, size, init); \
141 /**/
142 #define HPX_INTERNAL_HEAP_ALLOCATE_END(f, addr, size, init) \
143 if (use_ittnotify_api && __itt_heap_allocate_end_ptr) \
144 __itt_heap_allocate_end_ptr(f, addr, size, init); \
145 /**/
146
147 #define HPX_INTERNAL_HEAP_FREE_BEGIN(f, addr) \
148 if (use_ittnotify_api && __itt_heap_free_begin_ptr) \
149 __itt_heap_free_begin_ptr(f, addr); \
150 /**/
151 #define HPX_INTERNAL_HEAP_FREE_END(f, addr) \
152 if (use_ittnotify_api && __itt_heap_free_end_ptr) \
153 __itt_heap_free_end_ptr(f, addr); \
154 /**/
155
156 #define HPX_INTERNAL_HEAP_REALLOCATE_BEGIN(f, addr, size, init) \
157 if (use_ittnotify_api && __itt_heap_reallocate_begin_ptr) \
158 __itt_heap_reallocate_begin_ptr(f, addr, size, init); \
159 /**/
160 #define HPX_INTERNAL_HEAP_REALLOCATE_END(f, addr, new_addr, size, init) \
161 if (use_ittnotify_api && __itt_heap_reallocate_end_ptr) \
162 __itt_heap_reallocate_end_ptr(f, addr, new_addr, size, init); \
163 /**/
164
165 #define HPX_INTERNAL_INTERNAL_ACCESS_BEGIN() \
166 if (use_ittnotify_api && __itt_heap_internal_access_begin_ptr) \
167 __itt_heap_internal_access_begin_ptr(); \
168 /**/
169 #define HPX_INTERNAL_INTERNAL_ACCESS_END() \
170 if (use_ittnotify_api && __itt_heap_internal_access_end_ptr) \
171 __itt_heap_internal_access_end_ptr(); \
172 /**/
173
174 ///////////////////////////////////////////////////////////////////////////////
175 #if defined(__itt_counter_create_typed_ptr) && defined(__itt_counter_set_value_ptr)
176 #define HPX_INTERNAL_COUNTER_CREATE(name, domain) \
177 (use_ittnotify_api && __itt_counter_create_ptr) ? \
178 __itt_counter_create_ptr(name, domain) : (__itt_counter)nullptr \
179 /**/
180 #define HPX_INTERNAL_COUNTER_CREATE_TYPED(name, domain, type) \
181 (use_ittnotify_api && __itt_counter_create_typed_ptr) ? \
182 __itt_counter_create_typed_ptr(name, domain, type) : \
183 (__itt_counter)nullptr \
184 /**/
185 #define HPX_INTERNAL_COUNTER_SET_VALUE(id, value_ptr) \
186 if (use_ittnotify_api && __itt_counter_set_value_ptr) \
187 __itt_counter_set_value_ptr(id, value_ptr); \
188 /**/
189 #define HPX_INTERNAL_COUNTER_DESTROY(id) \
190 if (use_ittnotify_api && __itt_counter_destroy_ptr) \
191 __itt_counter_destroy_ptr(id); \
192 /**/
193 #else
194 // older itt-notify implementations don't support the typed counter API
195 #define HPX_INTERNAL_COUNTER_CREATE(name, domain) \
196 (__itt_counter)nullptr \
197 /**/
198 #define HPX_INTERNAL_COUNTER_CREATE_TYPED(name, domain, type) \
199 (__itt_counter)nullptr \
200 /**/
201 #define HPX_INTERNAL_COUNTER_SET_VALUE(id, value_ptr) \
202 /**/
203 #define HPX_INTERNAL_COUNTER_DESTROY(id) \
204 /**/
205 #endif
206
207 ///////////////////////////////////////////////////////////////////////////////
208 #define HPX_INTERNAL_EVENT_CREATE(name, len) \
209 (use_ittnotify_api && __itt_event_create_ptr) ? \
210 __itt_event_create_ptr(name, len) : 0; \
211 /**/
212 #define HPX_INTERNAL_EVENT_START(e) \
213 (use_ittnotify_api && __itt_event_start_ptr) ? \
214 __itt_event_start_ptr(e) : 0 \
215 /**/
216 #define HPX_INTERNAL_EVENT_END(e) \
217 (use_ittnotify_api && __itt_event_end_ptr) ? \
218 __itt_event_end_ptr(e) : 0 \
219 /**/
220
221 ///////////////////////////////////////////////////////////////////////////////
222 #define HPX_INTERNAL_METADATA_ADD(domain, id, key, type, count, data) \
223 if (use_ittnotify_api && __itt_metadata_add_ptr) \
224 __itt_metadata_add_ptr(domain, id, key, type, count, data) \
225 /**/
226 #define HPX_INTERNAL_METADATA_STR_ADD(domain, id, key, data) \
227 if (use_ittnotify_api && __itt_metadata_str_add_ptr) \
228 __itt_metadata_str_add_ptr(domain, id, key, data, 0) \
229 /**/
230
231 ///////////////////////////////////////////////////////////////////////////////
232 #if defined(HPX_MSVC) \
233 || defined(__BORLANDC__) \
234 || (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \
235 || (defined(__ICL) && defined(_MSC_EXTENSIONS) && (HPX_MSVC >= 1200))
236
237 #pragma comment(lib, "libittnotify.lib")
238 #endif
239
240 ///////////////////////////////////////////////////////////////////////////////
241 #define HPX_INTERNAL_ITT_SYNC_PREPARE(obj)\
242 HPX_INTERNAL_ITT_SYNC(sync_prepare, obj)
243 #define HPX_INTERNAL_ITT_SYNC_CANCEL(obj)\
244 HPX_INTERNAL_ITT_SYNC(sync_cancel, obj)
245 #define HPX_INTERNAL_ITT_SYNC_ACQUIRED(obj)\
246 HPX_INTERNAL_ITT_SYNC(sync_acquired, obj)
247 #define HPX_INTERNAL_ITT_SYNC_RELEASING(obj)\
248 HPX_INTERNAL_ITT_SYNC(sync_releasing, obj)
249 #define HPX_INTERNAL_ITT_SYNC_RELEASED(obj)\
250 ((void)0) //HPX_INTERNAL_ITT_SYNC(sync_released, obj)
251 #define HPX_INTERNAL_ITT_SYNC_DESTROY(obj)\
252 HPX_INTERNAL_ITT_SYNC(sync_destroy, obj)
253
254 ///////////////////////////////////////////////////////////////////////////////
255 namespace hpx { namespace util { namespace itt
256 {
domain(char const * name)257 domain::domain(char const* name)
258 : domain_(HPX_ITT_DOMAIN_CREATE(name))
259 {
260 if (domain_ != nullptr)
261 {
262 domain_->flags = 1;
263 }
264 }
265
domain()266 domain::domain()
267 : domain_(nullptr) {}
268
269 struct thread_domain_tag;
270 hpx::util::thread_specific_ptr<___itt_domain, thread_domain_tag>
271 thread_domain_;
272
thread_domain()273 thread_domain::thread_domain() : domain()
274 {
275 if (thread_domain_.get() == nullptr)
276 {
277 thread_domain_.reset(
278 HPX_ITT_DOMAIN_CREATE(get_thread_name().c_str()));
279 }
280
281 domain_ = thread_domain_.get();
282
283 if (domain_ != nullptr)
284 {
285 domain_->flags = 1;
286 }
287 }
288
task(domain const & domain,util::thread_description const & name)289 task::task(domain const& domain, util::thread_description const& name)
290 : domain_(domain), id_(0), sh_()
291 {
292 if (name.kind() == util::thread_description::data_type_description)
293 {
294 sh_ = name.get_description_itt();
295 }
296 else
297 {
298 sh_ = HPX_ITT_STRING_HANDLE_CREATE("address");
299 }
300
301 id_ = HPX_ITT_MAKE_ID(domain_.domain_,
302 reinterpret_cast<std::size_t>(sh_.handle_));
303
304 HPX_ITT_TASK_BEGIN_ID(domain_.domain_, id_, sh_.handle_);
305
306 if (name.kind() == util::thread_description::data_type_address)
307 {
308 add_metadata(sh_.handle_, name.get_address());
309 }
310 }
311
task(domain const & domain,string_handle const & name)312 task::task(domain const& domain, string_handle const& name)
313 : domain_(domain), id_(0), sh_(name)
314 {
315 id_ = HPX_ITT_MAKE_ID(domain_.domain_,
316 reinterpret_cast<std::size_t>(sh_.handle_));
317
318 HPX_ITT_TASK_BEGIN_ID(domain_.domain_, id_, sh_.handle_);
319 }
320
~task()321 task::~task()
322 {
323 HPX_ITT_TASK_END(domain_.domain_);
324
325 delete id_;
326 }
327 }}}
328
329 ///////////////////////////////////////////////////////////////////////////////
itt_sync_create(void * addr,const char * objtype,const char * objname)330 void itt_sync_create(void *addr, const char* objtype, const char* objname)
331 {
332 HPX_INTERNAL_ITT_SYNC_CREATE(addr, objtype, objname);
333 }
334
itt_sync_rename(void * addr,const char * objname)335 void itt_sync_rename(void* addr, const char* objname)
336 {
337 HPX_INTERNAL_ITT_SYNC_RENAME(addr, objname);
338 }
339
itt_sync_prepare(void * addr)340 void itt_sync_prepare(void* addr)
341 {
342 HPX_INTERNAL_ITT_SYNC_PREPARE(addr);
343 }
344
itt_sync_acquired(void * addr)345 void itt_sync_acquired(void* addr)
346 {
347 HPX_INTERNAL_ITT_SYNC_ACQUIRED(addr);
348 }
349
itt_sync_cancel(void * addr)350 void itt_sync_cancel(void* addr)
351 {
352 HPX_INTERNAL_ITT_SYNC_CANCEL(addr);
353 }
354
itt_sync_releasing(void * addr)355 void itt_sync_releasing(void* addr)
356 {
357 HPX_INTERNAL_ITT_SYNC_RELEASING(addr);
358 }
359
itt_sync_released(void * addr)360 void itt_sync_released(void* addr)
361 {
362 HPX_INTERNAL_ITT_SYNC_RELEASED(addr);
363 }
364
itt_sync_destroy(void * addr)365 void itt_sync_destroy(void* addr)
366 {
367 HPX_INTERNAL_ITT_SYNC_DESTROY(addr);
368 }
369
370 ///////////////////////////////////////////////////////////////////////////////
itt_stack_create()371 __itt_caller itt_stack_create()
372 {
373 return HPX_INTERNAL_ITT_STACK_CREATE();
374 }
375
itt_stack_enter(__itt_caller ctx)376 void itt_stack_enter(__itt_caller ctx)
377 {
378 HPX_INTERNAL_ITT_STACK_ENTER(ctx);
379 }
380
itt_stack_leave(__itt_caller ctx)381 void itt_stack_leave(__itt_caller ctx)
382 {
383 HPX_INTERNAL_ITT_STACK_LEAVE(ctx);
384 }
385
itt_stack_destroy(__itt_caller ctx)386 void itt_stack_destroy(__itt_caller ctx)
387 {
388 HPX_INTERNAL_ITT_STACK_DESTROY(ctx);
389 }
390
391 ///////////////////////////////////////////////////////////////////////////////
itt_frame_begin(___itt_domain const * domain,___itt_id * id)392 void itt_frame_begin(___itt_domain const* domain, ___itt_id* id)
393 {
394 HPX_INTERNAL_ITT_FRAME_BEGIN(domain, id);
395 }
396
itt_frame_end(___itt_domain const * domain,___itt_id * id)397 void itt_frame_end(___itt_domain const* domain, ___itt_id* id)
398 {
399 HPX_INTERNAL_ITT_FRAME_END(domain, id);
400 }
401
402 ///////////////////////////////////////////////////////////////////////////////
itt_mark_create(char const * name)403 int itt_mark_create(char const* name)
404 {
405 return HPX_INTERNAL_ITT_MARK_CREATE(name);
406 }
407
itt_mark_off(int mark)408 void itt_mark_off(int mark)
409 {
410 HPX_INTERNAL_ITT_MARK_OFF(mark);
411 }
412
itt_mark(int mark,char const * par)413 void itt_mark(int mark, char const* par)
414 {
415 HPX_INTERNAL_ITT_MARK(mark, par);
416 }
417
418 ///////////////////////////////////////////////////////////////////////////////
itt_thread_set_name(char const * name)419 void itt_thread_set_name(char const* name)
420 {
421 HPX_INTERNAL_ITT_THREAD_SET_NAME(name);
422 }
423
itt_thread_ignore()424 void itt_thread_ignore()
425 {
426 HPX_INTERNAL_ITT_THREAD_IGNORE();
427 }
428
429 ///////////////////////////////////////////////////////////////////////////////
itt_task_begin(___itt_domain const * domain,___itt_string_handle * name)430 void itt_task_begin(___itt_domain const* domain, ___itt_string_handle* name)
431 {
432 HPX_INTERNAL_ITT_TASK_BEGIN(domain, name);
433 }
434
itt_task_begin(___itt_domain const * domain,___itt_id * id,___itt_string_handle * name)435 void itt_task_begin(___itt_domain const* domain, ___itt_id* id,
436 ___itt_string_handle* name)
437 {
438 HPX_INTERNAL_ITT_TASK_BEGIN_ID(domain, *id, name);
439 }
440
itt_task_end(___itt_domain const * domain)441 void itt_task_end(___itt_domain const* domain)
442 {
443 HPX_INTERNAL_ITT_TASK_END(domain);
444 }
445
itt_domain_create(char const * name)446 ___itt_domain* itt_domain_create(char const* name)
447 {
448 return HPX_INTERNAL_ITT_DOMAIN_CREATE(name);
449 }
450
itt_string_handle_create(char const * name)451 ___itt_string_handle* itt_string_handle_create(char const* name)
452 {
453 return HPX_INTERNAL_ITT_STRING_HANDLE_CREATE(name);
454 }
455
itt_make_id(void * addr,std::size_t extra)456 ___itt_id* itt_make_id(void* addr, std::size_t extra)
457 {
458 return new ___itt_id(HPX_INTERNAL_ITT_MAKE_ID(addr, extra));
459 }
460
itt_id_create(___itt_domain const * domain,___itt_id * id)461 void itt_id_create(___itt_domain const* domain, ___itt_id* id)
462 {
463 HPX_INTERNAL_ITT_ID_CREATE(domain, *id);
464 }
465
itt_id_destroy(___itt_id * id)466 void itt_id_destroy(___itt_id* id)
467 {
468 HPX_INTERNAL_ITT_ID_DESTROY(id);
469 }
470
471 ///////////////////////////////////////////////////////////////////////////////
itt_heap_function_create(const char * name,const char * domain)472 __itt_heap_function itt_heap_function_create(const char* name, const char* domain)
473 {
474 return HPX_INTERNAL_ITT_HEAP_FUNCTION_CREATE(name, domain);
475 }
476
itt_heap_allocate_begin(__itt_heap_function f,std::size_t size,int init)477 void itt_heap_allocate_begin(__itt_heap_function f, std::size_t size, int init)
478 {
479 HPX_INTERNAL_HEAP_ALLOCATE_BEGIN(f, size, init);
480 }
481
itt_heap_allocate_end(__itt_heap_function f,void ** addr,std::size_t size,int init)482 void itt_heap_allocate_end(__itt_heap_function f, void** addr,
483 std::size_t size, int init)
484 {
485 HPX_INTERNAL_HEAP_ALLOCATE_END(f, addr, size, init);
486 }
487
itt_heap_free_begin(__itt_heap_function f,void * addr)488 void itt_heap_free_begin(__itt_heap_function f, void* addr)
489 {
490 HPX_INTERNAL_HEAP_FREE_BEGIN(f, addr);
491 }
492
itt_heap_free_end(__itt_heap_function f,void * addr)493 void itt_heap_free_end(__itt_heap_function f, void* addr)
494 {
495 HPX_INTERNAL_HEAP_FREE_END(f, addr);
496 }
497
itt_heap_reallocate_begin(__itt_heap_function f,void * addr,std::size_t new_size,int init)498 void itt_heap_reallocate_begin(__itt_heap_function f, void* addr,
499 std::size_t new_size, int init)
500 {
501 HPX_INTERNAL_HEAP_REALLOCATE_BEGIN(f, addr, new_size, init);
502 }
503
itt_heap_reallocate_end(__itt_heap_function f,void * addr,void ** new_addr,std::size_t new_size,int init)504 void itt_heap_reallocate_end(__itt_heap_function f, void* addr,
505 void** new_addr, std::size_t new_size, int init)
506 {
507 HPX_INTERNAL_HEAP_REALLOCATE_END(f, addr, new_addr, new_size, init);
508 }
509
itt_heap_internal_access_begin()510 void itt_heap_internal_access_begin()
511 {
512 HPX_INTERNAL_INTERNAL_ACCESS_BEGIN();
513 }
514
itt_heap_internal_access_end()515 void itt_heap_internal_access_end()
516 {
517 HPX_INTERNAL_INTERNAL_ACCESS_END();
518 }
519
520 ///////////////////////////////////////////////////////////////////////////////
itt_counter_create(char const * name,char const * domain)521 __itt_counter itt_counter_create(char const* name, char const* domain)
522 {
523 return HPX_INTERNAL_COUNTER_CREATE(name, domain);
524 }
525
itt_counter_create_typed(char const * name,char const * domain,int type)526 __itt_counter itt_counter_create_typed(char const* name, char const* domain,
527 int type)
528 {
529 return HPX_INTERNAL_COUNTER_CREATE_TYPED(name, domain,
530 (__itt_metadata_type)type);
531 }
532
itt_counter_destroy(__itt_counter id)533 void itt_counter_destroy(__itt_counter id)
534 {
535 HPX_INTERNAL_COUNTER_DESTROY(id);
536 }
537
itt_counter_set_value(__itt_counter id,void * value_ptr)538 void itt_counter_set_value(__itt_counter id, void *value_ptr)
539 {
540 HPX_INTERNAL_COUNTER_SET_VALUE(id, value_ptr);
541 }
542
543 ///////////////////////////////////////////////////////////////////////////////
itt_event_create(char const * name,int namelen)544 __itt_event itt_event_create(char const *name, int namelen)
545 {
546 return HPX_INTERNAL_EVENT_CREATE(name, namelen);
547 }
548
itt_event_start(__itt_event evnt)549 int itt_event_start(__itt_event evnt)
550 {
551 return HPX_INTERNAL_EVENT_START(evnt);
552 }
553
itt_event_end(__itt_event evnt)554 int itt_event_end(__itt_event evnt)
555 {
556 return HPX_INTERNAL_EVENT_END(evnt);
557 }
558
559 ///////////////////////////////////////////////////////////////////////////////
itt_metadata_add(___itt_domain * domain,___itt_id * id,___itt_string_handle * key,std::uint64_t const & data)560 void itt_metadata_add(___itt_domain* domain, ___itt_id* id,
561 ___itt_string_handle* key, std::uint64_t const& data)
562 {
563 HPX_INTERNAL_METADATA_ADD(domain, *id, key, __itt_metadata_u64, 1,
564 const_cast<std::uint64_t*>(&data));
565 }
566
itt_metadata_add(___itt_domain * domain,___itt_id * id,___itt_string_handle * key,double const & data)567 void itt_metadata_add(___itt_domain* domain, ___itt_id* id,
568 ___itt_string_handle* key, double const& data)
569 {
570 HPX_INTERNAL_METADATA_ADD(domain, *id, key, __itt_metadata_double, 1,
571 const_cast<double*>(&data));
572 }
573
itt_metadata_add(___itt_domain * domain,___itt_id * id,___itt_string_handle * key,char const * data)574 void itt_metadata_add(___itt_domain* domain, ___itt_id* id,
575 ___itt_string_handle* key, char const* data)
576 {
577 HPX_INTERNAL_METADATA_STR_ADD(domain, *id, key, data);
578 }
579
itt_metadata_add(___itt_domain * domain,___itt_id * id,___itt_string_handle * key,void const * data)580 void itt_metadata_add(___itt_domain* domain, ___itt_id* id,
581 ___itt_string_handle* key, void const* data)
582 {
583 HPX_INTERNAL_METADATA_ADD(domain, *id, key, __itt_metadata_unknown, 1,
584 const_cast<void*>(data));
585 }
586
587 #endif // HPX_HAVE_ITTNOTIFY
588
589