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