1 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _ITTNOTIFY_H_ 11 #define _ITTNOTIFY_H_ 12 13 /** 14 @file 15 @brief Public User API functions and types 16 @mainpage 17 18 The Instrumentation and Tracing Technology API (ITT API) is used to 19 annotate a user's program with additional information 20 that can be used by correctness and performance tools. The user inserts 21 calls in their program. Those calls generate information that is collected 22 at runtime, and used by Intel(R) Threading Tools. 23 24 @section API Concepts 25 The following general concepts are used throughout the API. 26 27 @subsection Unicode Support 28 Many API functions take character string arguments. On Windows, there 29 are two versions of each such function. The function name is suffixed 30 by W if Unicode support is enabled, and by A otherwise. Any API function 31 that takes a character string argument adheres to this convention. 32 33 @subsection Conditional Compilation 34 Many users prefer having an option to modify ITT API code when linking it 35 inside their runtimes. ITT API header file provides a mechanism to replace 36 ITT API function names inside your code with empty strings. To do this, 37 define the macros INTEL_NO_ITTNOTIFY_API during compilation and remove the 38 static library from the linker script. 39 40 @subsection Domains 41 [see domains] 42 Domains provide a way to separate notification for different modules or 43 libraries in a program. Domains are specified by dotted character strings, 44 e.g. TBB.Internal.Control. 45 46 A mechanism (to be specified) is provided to enable and disable 47 domains. By default, all domains are enabled. 48 @subsection Named Entities and Instances 49 Named entities (frames, regions, tasks, and markers) communicate 50 information about the program to the analysis tools. A named entity often 51 refers to a section of program code, or to some set of logical concepts 52 that the programmer wants to group together. 53 54 Named entities relate to the programmer's static view of the program. When 55 the program actually executes, many instances of a given named entity 56 may be created. 57 58 The API annotations denote instances of named entities. The actual 59 named entities are displayed using the analysis tools. In other words, 60 the named entities come into existence when instances are created. 61 62 Instances of named entities may have instance identifiers (IDs). Some 63 API calls use instance identifiers to create relationships between 64 different instances of named entities. Other API calls associate data 65 with instances of named entities. 66 67 Some named entities must always have instance IDs. In particular, regions 68 and frames always have IDs. Task and markers need IDs only if the ID is 69 needed in another API call (such as adding a relation or metadata). 70 71 The lifetime of instance IDs is distinct from the lifetime of 72 instances. This allows various relationships to be specified separate 73 from the actual execution of instances. This flexibility comes at the 74 expense of extra API calls. 75 76 The same ID may not be reused for different instances, unless a previous 77 [ref] __itt_id_destroy call for that ID has been issued. 78 */ 79 80 /** @cond exclude_from_documentation */ 81 #ifndef ITT_OS_WIN 82 #define ITT_OS_WIN 1 83 #endif /* ITT_OS_WIN */ 84 85 #ifndef ITT_OS_LINUX 86 #define ITT_OS_LINUX 2 87 #endif /* ITT_OS_LINUX */ 88 89 #ifndef ITT_OS_MAC 90 #define ITT_OS_MAC 3 91 #endif /* ITT_OS_MAC */ 92 93 #ifndef ITT_OS_FREEBSD 94 #define ITT_OS_FREEBSD 4 95 #endif /* ITT_OS_FREEBSD */ 96 97 #ifndef ITT_OS 98 #if defined WIN32 || defined _WIN32 99 #define ITT_OS ITT_OS_WIN 100 #elif defined(__APPLE__) && defined(__MACH__) 101 #define ITT_OS ITT_OS_MAC 102 #elif defined(__FreeBSD__) 103 #define ITT_OS ITT_OS_FREEBSD 104 #else 105 #define ITT_OS ITT_OS_LINUX 106 #endif 107 #endif /* ITT_OS */ 108 109 #ifndef ITT_PLATFORM_WIN 110 #define ITT_PLATFORM_WIN 1 111 #endif /* ITT_PLATFORM_WIN */ 112 113 #ifndef ITT_PLATFORM_POSIX 114 #define ITT_PLATFORM_POSIX 2 115 #endif /* ITT_PLATFORM_POSIX */ 116 117 #ifndef ITT_PLATFORM_MAC 118 #define ITT_PLATFORM_MAC 3 119 #endif /* ITT_PLATFORM_MAC */ 120 121 #ifndef ITT_PLATFORM_FREEBSD 122 #define ITT_PLATFORM_FREEBSD 4 123 #endif /* ITT_PLATFORM_FREEBSD */ 124 125 #ifndef ITT_PLATFORM 126 #if ITT_OS == ITT_OS_WIN 127 #define ITT_PLATFORM ITT_PLATFORM_WIN 128 #elif ITT_OS == ITT_OS_MAC 129 #define ITT_PLATFORM ITT_PLATFORM_MAC 130 #elif ITT_OS == ITT_OS_FREEBSD 131 #define ITT_PLATFORM ITT_PLATFORM_FREEBSD 132 #else 133 #define ITT_PLATFORM ITT_PLATFORM_POSIX 134 #endif 135 #endif /* ITT_PLATFORM */ 136 137 #if defined(_UNICODE) && !defined(UNICODE) 138 #define UNICODE 139 #endif 140 141 #include <stddef.h> 142 #if ITT_PLATFORM == ITT_PLATFORM_WIN 143 #include <tchar.h> 144 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 145 #include <stdint.h> 146 #if defined(UNICODE) || defined(_UNICODE) 147 #include <wchar.h> 148 #endif /* UNICODE || _UNICODE */ 149 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 150 151 #ifndef ITTAPI_CDECL 152 #if ITT_PLATFORM == ITT_PLATFORM_WIN 153 #define ITTAPI_CDECL __cdecl 154 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 155 #if defined _M_IX86 || defined __i386__ 156 #define ITTAPI_CDECL __attribute__((cdecl)) 157 #else /* _M_IX86 || __i386__ */ 158 #define ITTAPI_CDECL /* actual only on x86 platform */ 159 #endif /* _M_IX86 || __i386__ */ 160 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 161 #endif /* ITTAPI_CDECL */ 162 163 #ifndef STDCALL 164 #if ITT_PLATFORM == ITT_PLATFORM_WIN 165 #define STDCALL __stdcall 166 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 167 #if defined _M_IX86 || defined __i386__ 168 #define STDCALL __attribute__((stdcall)) 169 #else /* _M_IX86 || __i386__ */ 170 #define STDCALL /* supported only on x86 platform */ 171 #endif /* _M_IX86 || __i386__ */ 172 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 173 #endif /* STDCALL */ 174 175 #define ITTAPI ITTAPI_CDECL 176 #define LIBITTAPI ITTAPI_CDECL 177 178 /* TODO: Temporary for compatibility! */ 179 #define ITTAPI_CALL ITTAPI_CDECL 180 #define LIBITTAPI_CALL ITTAPI_CDECL 181 182 #if ITT_PLATFORM == ITT_PLATFORM_WIN 183 /* use __forceinline (VC++ specific) */ 184 #if defined(__MINGW32__) && !defined(__cplusplus) 185 #define ITT_INLINE \ 186 static __inline__ __attribute__((__always_inline__, __gnu_inline__)) 187 #else 188 #define ITT_INLINE static __forceinline 189 #endif /* __MINGW32__ */ 190 191 #define ITT_INLINE_ATTRIBUTE /* nothing */ 192 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 193 /* 194 * Generally, functions are not inlined unless optimization is specified. 195 * For functions declared inline, this attribute inlines the function even 196 * if no optimization level was specified. 197 */ 198 #ifdef __STRICT_ANSI__ 199 #define ITT_INLINE static 200 #define ITT_INLINE_ATTRIBUTE __attribute__((unused)) 201 #else /* __STRICT_ANSI__ */ 202 #define ITT_INLINE static inline 203 #define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused)) 204 #endif /* __STRICT_ANSI__ */ 205 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 206 /** @endcond */ 207 208 #ifdef INTEL_ITTNOTIFY_ENABLE_LEGACY 209 #if ITT_PLATFORM == ITT_PLATFORM_WIN 210 #pragma message( \ 211 "WARNING!!! Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro") 212 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 213 #warning \ 214 "Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro" 215 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 216 #include "legacy/ittnotify.h" 217 #endif /* INTEL_ITTNOTIFY_ENABLE_LEGACY */ 218 219 /** @cond exclude_from_documentation */ 220 /* Helper macro for joining tokens */ 221 #define ITT_JOIN_AUX(p, n) p##n 222 #define ITT_JOIN(p, n) ITT_JOIN_AUX(p, n) 223 224 #ifdef ITT_MAJOR 225 #undef ITT_MAJOR 226 #endif 227 #ifdef ITT_MINOR 228 #undef ITT_MINOR 229 #endif 230 #define ITT_MAJOR 3 231 #define ITT_MINOR 0 232 233 /* Standard versioning of a token with major and minor version numbers */ 234 #define ITT_VERSIONIZE(x) \ 235 ITT_JOIN(x, ITT_JOIN(_, ITT_JOIN(ITT_MAJOR, ITT_JOIN(_, ITT_MINOR)))) 236 237 #ifndef INTEL_ITTNOTIFY_PREFIX 238 #define INTEL_ITTNOTIFY_PREFIX __itt_ 239 #endif /* INTEL_ITTNOTIFY_PREFIX */ 240 #ifndef INTEL_ITTNOTIFY_POSTFIX 241 #define INTEL_ITTNOTIFY_POSTFIX _ptr_ 242 #endif /* INTEL_ITTNOTIFY_POSTFIX */ 243 244 #define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n) 245 #define ITTNOTIFY_NAME(n) \ 246 ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n, INTEL_ITTNOTIFY_POSTFIX))) 247 248 #define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n) 249 #define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n) 250 251 #define ITTNOTIFY_VOID_D0(n, d) \ 252 (!(d)->flags) ? (void)0 \ 253 : (!ITTNOTIFY_NAME(n)) ? (void)0 \ 254 : ITTNOTIFY_NAME(n)(d) 255 #define ITTNOTIFY_VOID_D1(n, d, x) \ 256 (!(d)->flags) ? (void)0 \ 257 : (!ITTNOTIFY_NAME(n)) ? (void)0 \ 258 : ITTNOTIFY_NAME(n)(d, x) 259 #define ITTNOTIFY_VOID_D2(n, d, x, y) \ 260 (!(d)->flags) ? (void)0 \ 261 : (!ITTNOTIFY_NAME(n)) ? (void)0 \ 262 : ITTNOTIFY_NAME(n)(d, x, y) 263 #define ITTNOTIFY_VOID_D3(n, d, x, y, z) \ 264 (!(d)->flags) ? (void)0 \ 265 : (!ITTNOTIFY_NAME(n)) ? (void)0 \ 266 : ITTNOTIFY_NAME(n)(d, x, y, z) 267 #define ITTNOTIFY_VOID_D4(n, d, x, y, z, a) \ 268 (!(d)->flags) ? (void)0 \ 269 : (!ITTNOTIFY_NAME(n)) ? (void)0 \ 270 : ITTNOTIFY_NAME(n)(d, x, y, z, a) 271 #define ITTNOTIFY_VOID_D5(n, d, x, y, z, a, b) \ 272 (!(d)->flags) ? (void)0 \ 273 : (!ITTNOTIFY_NAME(n)) ? (void)0 \ 274 : ITTNOTIFY_NAME(n)(d, x, y, z, a, b) 275 #define ITTNOTIFY_VOID_D6(n, d, x, y, z, a, b, c) \ 276 (!(d)->flags) ? (void)0 \ 277 : (!ITTNOTIFY_NAME(n)) ? (void)0 \ 278 : ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c) 279 #define ITTNOTIFY_DATA_D0(n, d) \ 280 (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d) 281 #define ITTNOTIFY_DATA_D1(n, d, x) \ 282 (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x) 283 #define ITTNOTIFY_DATA_D2(n, d, x, y) \ 284 (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y) 285 #define ITTNOTIFY_DATA_D3(n, d, x, y, z) \ 286 (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y, z) 287 #define ITTNOTIFY_DATA_D4(n, d, x, y, z, a) \ 288 (!(d)->flags) ? 0 \ 289 : (!ITTNOTIFY_NAME(n)) ? 0 \ 290 : ITTNOTIFY_NAME(n)(d, x, y, z, a) 291 #define ITTNOTIFY_DATA_D5(n, d, x, y, z, a, b) \ 292 (!(d)->flags) ? 0 \ 293 : (!ITTNOTIFY_NAME(n)) ? 0 \ 294 : ITTNOTIFY_NAME(n)(d, x, y, z, a, b) 295 #define ITTNOTIFY_DATA_D6(n, d, x, y, z, a, b, c) \ 296 (!(d)->flags) ? 0 \ 297 : (!ITTNOTIFY_NAME(n)) ? 0 \ 298 : ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c) 299 300 #ifdef ITT_STUB 301 #undef ITT_STUB 302 #endif 303 #ifdef ITT_STUBV 304 #undef ITT_STUBV 305 #endif 306 #define ITT_STUBV(api, type, name, args) \ 307 typedef type(api *ITT_JOIN(ITTNOTIFY_NAME(name), _t)) args; \ 308 extern ITT_JOIN(ITTNOTIFY_NAME(name), _t) ITTNOTIFY_NAME(name); 309 #define ITT_STUB ITT_STUBV 310 /** @endcond */ 311 312 #ifdef __cplusplus 313 extern "C" { 314 #endif /* __cplusplus */ 315 316 /** @cond exclude_from_gpa_documentation */ 317 /** 318 * @defgroup public Public API 319 * @{ 320 * @} 321 */ 322 323 /** 324 * @defgroup control Collection Control 325 * @ingroup public 326 * General behavior: application continues to run, but no profiling information 327 * is being collected 328 * 329 * Pausing occurs not only for the current thread but for all process as well as 330 * spawned processes 331 * - Intel(R) Parallel Inspector and Intel(R) Inspector XE: 332 * - Does not analyze or report errors that involve memory access. 333 * - Other errors are reported as usual. Pausing data collection in 334 * Intel(R) Parallel Inspector and Intel(R) Inspector XE 335 * only pauses tracing and analyzing memory access. 336 * It does not pause tracing or analyzing threading APIs. 337 * . 338 * - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE: 339 * - Does continue to record when new threads are started. 340 * . 341 * - Other effects: 342 * - Possible reduction of runtime overhead. 343 * . 344 * @{ 345 */ 346 /** @brief Pause collection */ 347 void ITTAPI __itt_pause(void); 348 /** @brief Resume collection */ 349 void ITTAPI __itt_resume(void); 350 /** @brief Detach collection */ 351 void ITTAPI __itt_detach(void); 352 353 /** @cond exclude_from_documentation */ 354 #ifndef INTEL_NO_MACRO_BODY 355 #ifndef INTEL_NO_ITTNOTIFY_API 356 ITT_STUBV(ITTAPI, void, pause, (void)) 357 ITT_STUBV(ITTAPI, void, resume, (void)) 358 ITT_STUBV(ITTAPI, void, detach, (void)) 359 #define __itt_pause ITTNOTIFY_VOID(pause) 360 #define __itt_pause_ptr ITTNOTIFY_NAME(pause) 361 #define __itt_resume ITTNOTIFY_VOID(resume) 362 #define __itt_resume_ptr ITTNOTIFY_NAME(resume) 363 #define __itt_detach ITTNOTIFY_VOID(detach) 364 #define __itt_detach_ptr ITTNOTIFY_NAME(detach) 365 #else /* INTEL_NO_ITTNOTIFY_API */ 366 #define __itt_pause() 367 #define __itt_pause_ptr 0 368 #define __itt_resume() 369 #define __itt_resume_ptr 0 370 #define __itt_detach() 371 #define __itt_detach_ptr 0 372 #endif /* INTEL_NO_ITTNOTIFY_API */ 373 #else /* INTEL_NO_MACRO_BODY */ 374 #define __itt_pause_ptr 0 375 #define __itt_resume_ptr 0 376 #define __itt_detach_ptr 0 377 #endif /* INTEL_NO_MACRO_BODY */ 378 /** @endcond */ 379 /** @} control group */ 380 /** @endcond */ 381 382 /** 383 * @defgroup Intel Processor Trace control 384 * API from this group provides control over collection and analysis of Intel 385 * Processor Trace (Intel PT) data Information about Intel Processor Trace 386 * technology can be found here (Volume 3 chapter 35): 387 * https://software.intel.com/sites/default/files/managed/39/c5/325462-sdm-vol-1-2abcd-3abcd.pdf 388 * Use this API to mark particular code regions for loading detailed performance 389 * statistics. This mode makes your analysis faster and more accurate. 390 * @{ 391 */ 392 typedef unsigned char __itt_pt_region; 393 394 /** 395 * @brief function saves a region name marked with Intel PT API and returns a 396 * region id. Only 7 names can be registered. Attempts to register more names 397 * will be ignored and a region id with auto names will be returned. For 398 * automatic naming of regions pass NULL as function parameter 399 */ 400 #if ITT_PLATFORM == ITT_PLATFORM_WIN 401 __itt_pt_region ITTAPI __itt_pt_region_createA(const char *name); 402 __itt_pt_region ITTAPI __itt_pt_region_createW(const wchar_t *name); 403 #if defined(UNICODE) || defined(_UNICODE) 404 #define __itt_pt_region_create __itt_pt_region_createW 405 #else /* UNICODE */ 406 #define __itt_pt_region_create __itt_pt_region_createA 407 #endif /* UNICODE */ 408 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 409 __itt_pt_region ITTAPI __itt_pt_region_create(const char *name); 410 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 411 412 /** @cond exclude_from_documentation */ 413 #ifndef INTEL_NO_MACRO_BODY 414 #ifndef INTEL_NO_ITTNOTIFY_API 415 #if ITT_PLATFORM == ITT_PLATFORM_WIN 416 ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createA, (const char *name)) 417 ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createW, (const wchar_t *name)) 418 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 419 ITT_STUB(ITTAPI, __itt_pt_region, pt_region_create, (const char *name)) 420 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 421 #if ITT_PLATFORM == ITT_PLATFORM_WIN 422 #define __itt_pt_region_createA ITTNOTIFY_DATA(pt_region_createA) 423 #define __itt_pt_region_createA_ptr ITTNOTIFY_NAME(pt_region_createA) 424 #define __itt_pt_region_createW ITTNOTIFY_DATA(pt_region_createW) 425 #define __itt_pt_region_createW_ptr ITTNOTIFY_NAME(pt_region_createW) 426 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 427 #define __itt_pt_region_create ITTNOTIFY_DATA(pt_region_create) 428 #define __itt_pt_region_create_ptr ITTNOTIFY_NAME(pt_region_create) 429 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 430 #else /* INTEL_NO_ITTNOTIFY_API */ 431 #if ITT_PLATFORM == ITT_PLATFORM_WIN 432 #define __itt_pt_region_createA(name) (__itt_pt_region)0 433 #define __itt_pt_region_createA_ptr 0 434 #define __itt_pt_region_createW(name) (__itt_pt_region)0 435 #define __itt_pt_region_createW_ptr 0 436 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 437 #define __itt_pt_region_create(name) (__itt_pt_region)0 438 #define __itt_pt_region_create_ptr 0 439 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 440 #endif /* INTEL_NO_ITTNOTIFY_API */ 441 #else /* INTEL_NO_MACRO_BODY */ 442 #if ITT_PLATFORM == ITT_PLATFORM_WIN 443 #define __itt_pt_region_createA_ptr 0 444 #define __itt_pt_region_createW_ptr 0 445 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 446 #define __itt_pt_region_create_ptr 0 447 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 448 #endif /* INTEL_NO_MACRO_BODY */ 449 /** @endcond */ 450 451 /** 452 * @brief function contains a special code pattern identified on the 453 * post-processing stage and marks the beginning of a code region targeted for 454 * Intel PT analysis 455 * @param[in] region - region id, 0 <= region < 8 456 */ 457 void __itt_mark_pt_region_begin(__itt_pt_region region); 458 /** 459 * @brief function contains a special code pattern identified on the 460 * post-processing stage and marks the end of a code region targeted for Intel 461 * PT analysis 462 * @param[in] region - region id, 0 <= region < 8 463 */ 464 void __itt_mark_pt_region_end(__itt_pt_region region); 465 /** @} Intel PT control group*/ 466 467 /** 468 * @defgroup threads Threads 469 * @ingroup public 470 * Give names to threads 471 * @{ 472 */ 473 /** 474 * @brief Sets thread name of calling thread 475 * @param[in] name - name of thread 476 */ 477 #if ITT_PLATFORM == ITT_PLATFORM_WIN 478 void ITTAPI __itt_thread_set_nameA(const char *name); 479 void ITTAPI __itt_thread_set_nameW(const wchar_t *name); 480 #if defined(UNICODE) || defined(_UNICODE) 481 #define __itt_thread_set_name __itt_thread_set_nameW 482 #define __itt_thread_set_name_ptr __itt_thread_set_nameW_ptr 483 #else /* UNICODE */ 484 #define __itt_thread_set_name __itt_thread_set_nameA 485 #define __itt_thread_set_name_ptr __itt_thread_set_nameA_ptr 486 #endif /* UNICODE */ 487 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 488 void ITTAPI __itt_thread_set_name(const char *name); 489 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 490 491 /** @cond exclude_from_documentation */ 492 #ifndef INTEL_NO_MACRO_BODY 493 #ifndef INTEL_NO_ITTNOTIFY_API 494 #if ITT_PLATFORM == ITT_PLATFORM_WIN 495 ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name)) 496 ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name)) 497 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 498 ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name)) 499 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 500 #if ITT_PLATFORM == ITT_PLATFORM_WIN 501 #define __itt_thread_set_nameA ITTNOTIFY_VOID(thread_set_nameA) 502 #define __itt_thread_set_nameA_ptr ITTNOTIFY_NAME(thread_set_nameA) 503 #define __itt_thread_set_nameW ITTNOTIFY_VOID(thread_set_nameW) 504 #define __itt_thread_set_nameW_ptr ITTNOTIFY_NAME(thread_set_nameW) 505 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 506 #define __itt_thread_set_name ITTNOTIFY_VOID(thread_set_name) 507 #define __itt_thread_set_name_ptr ITTNOTIFY_NAME(thread_set_name) 508 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 509 #else /* INTEL_NO_ITTNOTIFY_API */ 510 #if ITT_PLATFORM == ITT_PLATFORM_WIN 511 #define __itt_thread_set_nameA(name) 512 #define __itt_thread_set_nameA_ptr 0 513 #define __itt_thread_set_nameW(name) 514 #define __itt_thread_set_nameW_ptr 0 515 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 516 #define __itt_thread_set_name(name) 517 #define __itt_thread_set_name_ptr 0 518 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 519 #endif /* INTEL_NO_ITTNOTIFY_API */ 520 #else /* INTEL_NO_MACRO_BODY */ 521 #if ITT_PLATFORM == ITT_PLATFORM_WIN 522 #define __itt_thread_set_nameA_ptr 0 523 #define __itt_thread_set_nameW_ptr 0 524 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 525 #define __itt_thread_set_name_ptr 0 526 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 527 #endif /* INTEL_NO_MACRO_BODY */ 528 /** @endcond */ 529 530 /** @cond exclude_from_gpa_documentation */ 531 532 /** 533 * @brief Mark current thread as ignored from this point on, for the duration of 534 * its existence. 535 */ 536 void ITTAPI __itt_thread_ignore(void); 537 538 /** @cond exclude_from_documentation */ 539 #ifndef INTEL_NO_MACRO_BODY 540 #ifndef INTEL_NO_ITTNOTIFY_API 541 ITT_STUBV(ITTAPI, void, thread_ignore, (void)) 542 #define __itt_thread_ignore ITTNOTIFY_VOID(thread_ignore) 543 #define __itt_thread_ignore_ptr ITTNOTIFY_NAME(thread_ignore) 544 #else /* INTEL_NO_ITTNOTIFY_API */ 545 #define __itt_thread_ignore() 546 #define __itt_thread_ignore_ptr 0 547 #endif /* INTEL_NO_ITTNOTIFY_API */ 548 #else /* INTEL_NO_MACRO_BODY */ 549 #define __itt_thread_ignore_ptr 0 550 #endif /* INTEL_NO_MACRO_BODY */ 551 /** @endcond */ 552 /** @} threads group */ 553 554 /** 555 * @defgroup suppress Error suppression 556 * @ingroup public 557 * General behavior: application continues to run, but errors are suppressed 558 * 559 * @{ 560 */ 561 562 /********************************************************************* 563 * @name group of functions used for error suppression in correctness tools 564 *********************************************************************/ 565 /** @{ */ 566 /** 567 * @hideinitializer 568 * @brief possible value for suppression mask 569 */ 570 #define __itt_suppress_all_errors 0x7fffffff 571 572 /** 573 * @hideinitializer 574 * @brief possible value for suppression mask (suppresses errors from threading 575 * analysis) 576 */ 577 #define __itt_suppress_threading_errors 0x000000ff 578 579 /** 580 * @hideinitializer 581 * @brief possible value for suppression mask (suppresses errors from memory 582 * analysis) 583 */ 584 #define __itt_suppress_memory_errors 0x0000ff00 585 586 /** 587 * @brief Start suppressing errors identified in mask on this thread 588 */ 589 void ITTAPI __itt_suppress_push(unsigned int mask); 590 591 /** @cond exclude_from_documentation */ 592 #ifndef INTEL_NO_MACRO_BODY 593 #ifndef INTEL_NO_ITTNOTIFY_API 594 ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask)) 595 #define __itt_suppress_push ITTNOTIFY_VOID(suppress_push) 596 #define __itt_suppress_push_ptr ITTNOTIFY_NAME(suppress_push) 597 #else /* INTEL_NO_ITTNOTIFY_API */ 598 #define __itt_suppress_push(mask) 599 #define __itt_suppress_push_ptr 0 600 #endif /* INTEL_NO_ITTNOTIFY_API */ 601 #else /* INTEL_NO_MACRO_BODY */ 602 #define __itt_suppress_push_ptr 0 603 #endif /* INTEL_NO_MACRO_BODY */ 604 /** @endcond */ 605 606 /** 607 * @brief Undo the effects of the matching call to __itt_suppress_push 608 */ 609 void ITTAPI __itt_suppress_pop(void); 610 611 /** @cond exclude_from_documentation */ 612 #ifndef INTEL_NO_MACRO_BODY 613 #ifndef INTEL_NO_ITTNOTIFY_API 614 ITT_STUBV(ITTAPI, void, suppress_pop, (void)) 615 #define __itt_suppress_pop ITTNOTIFY_VOID(suppress_pop) 616 #define __itt_suppress_pop_ptr ITTNOTIFY_NAME(suppress_pop) 617 #else /* INTEL_NO_ITTNOTIFY_API */ 618 #define __itt_suppress_pop() 619 #define __itt_suppress_pop_ptr 0 620 #endif /* INTEL_NO_ITTNOTIFY_API */ 621 #else /* INTEL_NO_MACRO_BODY */ 622 #define __itt_suppress_pop_ptr 0 623 #endif /* INTEL_NO_MACRO_BODY */ 624 /** @endcond */ 625 626 /** 627 * @enum __itt_model_disable 628 * @brief Enumerator for the disable methods 629 */ 630 typedef enum __itt_suppress_mode { 631 __itt_unsuppress_range, 632 __itt_suppress_range 633 } __itt_suppress_mode_t; 634 635 /** 636 * @brief Mark a range of memory for error suppression or unsuppression for 637 * error types included in mask 638 */ 639 void ITTAPI __itt_suppress_mark_range(__itt_suppress_mode_t mode, 640 unsigned int mask, void *address, 641 size_t size); 642 643 /** @cond exclude_from_documentation */ 644 #ifndef INTEL_NO_MACRO_BODY 645 #ifndef INTEL_NO_ITTNOTIFY_API 646 ITT_STUBV(ITTAPI, void, suppress_mark_range, 647 (__itt_suppress_mode_t mode, unsigned int mask, void *address, 648 size_t size)) 649 #define __itt_suppress_mark_range ITTNOTIFY_VOID(suppress_mark_range) 650 #define __itt_suppress_mark_range_ptr ITTNOTIFY_NAME(suppress_mark_range) 651 #else /* INTEL_NO_ITTNOTIFY_API */ 652 #define __itt_suppress_mark_range(mask) 653 #define __itt_suppress_mark_range_ptr 0 654 #endif /* INTEL_NO_ITTNOTIFY_API */ 655 #else /* INTEL_NO_MACRO_BODY */ 656 #define __itt_suppress_mark_range_ptr 0 657 #endif /* INTEL_NO_MACRO_BODY */ 658 /** @endcond */ 659 660 /** 661 * @brief Undo the effect of a matching call to __itt_suppress_mark_range. If 662 * not matching call is found, nothing is changed. 663 */ 664 void ITTAPI __itt_suppress_clear_range(__itt_suppress_mode_t mode, 665 unsigned int mask, void *address, 666 size_t size); 667 668 /** @cond exclude_from_documentation */ 669 #ifndef INTEL_NO_MACRO_BODY 670 #ifndef INTEL_NO_ITTNOTIFY_API 671 ITT_STUBV(ITTAPI, void, suppress_clear_range, 672 (__itt_suppress_mode_t mode, unsigned int mask, void *address, 673 size_t size)) 674 #define __itt_suppress_clear_range ITTNOTIFY_VOID(suppress_clear_range) 675 #define __itt_suppress_clear_range_ptr ITTNOTIFY_NAME(suppress_clear_range) 676 #else /* INTEL_NO_ITTNOTIFY_API */ 677 #define __itt_suppress_clear_range(mask) 678 #define __itt_suppress_clear_range_ptr 0 679 #endif /* INTEL_NO_ITTNOTIFY_API */ 680 #else /* INTEL_NO_MACRO_BODY */ 681 #define __itt_suppress_clear_range_ptr 0 682 #endif /* INTEL_NO_MACRO_BODY */ 683 /** @endcond */ 684 /** @} */ 685 /** @} suppress group */ 686 687 /** 688 * @defgroup sync Synchronization 689 * @ingroup public 690 * Indicate user-written synchronization code 691 * @{ 692 */ 693 /** 694 * @hideinitializer 695 * @brief possible value of attribute argument for sync object type 696 */ 697 #define __itt_attr_barrier 1 698 699 /** 700 * @hideinitializer 701 * @brief possible value of attribute argument for sync object type 702 */ 703 #define __itt_attr_mutex 2 704 705 /** 706 @brief Name a synchronization object 707 @param[in] addr Handle for the synchronization object. You should 708 use a real address to uniquely identify the synchronization object. 709 @param[in] objtype null-terminated object type string. If NULL is 710 passed, the name will be "User Synchronization". 711 @param[in] objname null-terminated object name string. If NULL, 712 no name will be assigned to the object. 713 @param[in] attribute one of [#__itt_attr_barrier, #__itt_attr_mutex] 714 */ 715 716 #if ITT_PLATFORM == ITT_PLATFORM_WIN 717 void ITTAPI __itt_sync_createA(void *addr, const char *objtype, 718 const char *objname, int attribute); 719 void ITTAPI __itt_sync_createW(void *addr, const wchar_t *objtype, 720 const wchar_t *objname, int attribute); 721 #if defined(UNICODE) || defined(_UNICODE) 722 #define __itt_sync_create __itt_sync_createW 723 #define __itt_sync_create_ptr __itt_sync_createW_ptr 724 #else /* UNICODE */ 725 #define __itt_sync_create __itt_sync_createA 726 #define __itt_sync_create_ptr __itt_sync_createA_ptr 727 #endif /* UNICODE */ 728 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 729 void ITTAPI __itt_sync_create(void *addr, const char *objtype, 730 const char *objname, int attribute); 731 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 732 733 /** @cond exclude_from_documentation */ 734 #ifndef INTEL_NO_MACRO_BODY 735 #ifndef INTEL_NO_ITTNOTIFY_API 736 #if ITT_PLATFORM == ITT_PLATFORM_WIN 737 ITT_STUBV(ITTAPI, void, sync_createA, 738 (void *addr, const char *objtype, const char *objname, int attribute)) 739 ITT_STUBV(ITTAPI, void, sync_createW, 740 (void *addr, const wchar_t *objtype, const wchar_t *objname, 741 int attribute)) 742 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 743 ITT_STUBV(ITTAPI, void, sync_create, 744 (void *addr, const char *objtype, const char *objname, int attribute)) 745 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 746 #if ITT_PLATFORM == ITT_PLATFORM_WIN 747 #define __itt_sync_createA ITTNOTIFY_VOID(sync_createA) 748 #define __itt_sync_createA_ptr ITTNOTIFY_NAME(sync_createA) 749 #define __itt_sync_createW ITTNOTIFY_VOID(sync_createW) 750 #define __itt_sync_createW_ptr ITTNOTIFY_NAME(sync_createW) 751 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 752 #define __itt_sync_create ITTNOTIFY_VOID(sync_create) 753 #define __itt_sync_create_ptr ITTNOTIFY_NAME(sync_create) 754 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 755 #else /* INTEL_NO_ITTNOTIFY_API */ 756 #if ITT_PLATFORM == ITT_PLATFORM_WIN 757 #define __itt_sync_createA(addr, objtype, objname, attribute) 758 #define __itt_sync_createA_ptr 0 759 #define __itt_sync_createW(addr, objtype, objname, attribute) 760 #define __itt_sync_createW_ptr 0 761 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 762 #define __itt_sync_create(addr, objtype, objname, attribute) 763 #define __itt_sync_create_ptr 0 764 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 765 #endif /* INTEL_NO_ITTNOTIFY_API */ 766 #else /* INTEL_NO_MACRO_BODY */ 767 #if ITT_PLATFORM == ITT_PLATFORM_WIN 768 #define __itt_sync_createA_ptr 0 769 #define __itt_sync_createW_ptr 0 770 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 771 #define __itt_sync_create_ptr 0 772 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 773 #endif /* INTEL_NO_MACRO_BODY */ 774 /** @endcond */ 775 776 /** 777 @brief Rename a synchronization object 778 779 You can use the rename call to assign or reassign a name to a given 780 synchronization object. 781 @param[in] addr handle for the synchronization object. 782 @param[in] name null-terminated object name string. 783 */ 784 #if ITT_PLATFORM == ITT_PLATFORM_WIN 785 void ITTAPI __itt_sync_renameA(void *addr, const char *name); 786 void ITTAPI __itt_sync_renameW(void *addr, const wchar_t *name); 787 #if defined(UNICODE) || defined(_UNICODE) 788 #define __itt_sync_rename __itt_sync_renameW 789 #define __itt_sync_rename_ptr __itt_sync_renameW_ptr 790 #else /* UNICODE */ 791 #define __itt_sync_rename __itt_sync_renameA 792 #define __itt_sync_rename_ptr __itt_sync_renameA_ptr 793 #endif /* UNICODE */ 794 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 795 void ITTAPI __itt_sync_rename(void *addr, const char *name); 796 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 797 798 /** @cond exclude_from_documentation */ 799 #ifndef INTEL_NO_MACRO_BODY 800 #ifndef INTEL_NO_ITTNOTIFY_API 801 #if ITT_PLATFORM == ITT_PLATFORM_WIN 802 ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name)) 803 ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name)) 804 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 805 ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name)) 806 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 807 #if ITT_PLATFORM == ITT_PLATFORM_WIN 808 #define __itt_sync_renameA ITTNOTIFY_VOID(sync_renameA) 809 #define __itt_sync_renameA_ptr ITTNOTIFY_NAME(sync_renameA) 810 #define __itt_sync_renameW ITTNOTIFY_VOID(sync_renameW) 811 #define __itt_sync_renameW_ptr ITTNOTIFY_NAME(sync_renameW) 812 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 813 #define __itt_sync_rename ITTNOTIFY_VOID(sync_rename) 814 #define __itt_sync_rename_ptr ITTNOTIFY_NAME(sync_rename) 815 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 816 #else /* INTEL_NO_ITTNOTIFY_API */ 817 #if ITT_PLATFORM == ITT_PLATFORM_WIN 818 #define __itt_sync_renameA(addr, name) 819 #define __itt_sync_renameA_ptr 0 820 #define __itt_sync_renameW(addr, name) 821 #define __itt_sync_renameW_ptr 0 822 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 823 #define __itt_sync_rename(addr, name) 824 #define __itt_sync_rename_ptr 0 825 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 826 #endif /* INTEL_NO_ITTNOTIFY_API */ 827 #else /* INTEL_NO_MACRO_BODY */ 828 #if ITT_PLATFORM == ITT_PLATFORM_WIN 829 #define __itt_sync_renameA_ptr 0 830 #define __itt_sync_renameW_ptr 0 831 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 832 #define __itt_sync_rename_ptr 0 833 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 834 #endif /* INTEL_NO_MACRO_BODY */ 835 /** @endcond */ 836 837 /** 838 @brief Destroy a synchronization object. 839 @param addr Handle for the synchronization object. 840 */ 841 void ITTAPI __itt_sync_destroy(void *addr); 842 843 /** @cond exclude_from_documentation */ 844 #ifndef INTEL_NO_MACRO_BODY 845 #ifndef INTEL_NO_ITTNOTIFY_API 846 ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr)) 847 #define __itt_sync_destroy ITTNOTIFY_VOID(sync_destroy) 848 #define __itt_sync_destroy_ptr ITTNOTIFY_NAME(sync_destroy) 849 #else /* INTEL_NO_ITTNOTIFY_API */ 850 #define __itt_sync_destroy(addr) 851 #define __itt_sync_destroy_ptr 0 852 #endif /* INTEL_NO_ITTNOTIFY_API */ 853 #else /* INTEL_NO_MACRO_BODY */ 854 #define __itt_sync_destroy_ptr 0 855 #endif /* INTEL_NO_MACRO_BODY */ 856 /** @endcond */ 857 858 /********************************************************************* 859 * @name group of functions is used for performance measurement tools 860 *********************************************************************/ 861 /** @{ */ 862 /** 863 * @brief Enter spin loop on user-defined sync object 864 */ 865 void ITTAPI __itt_sync_prepare(void *addr); 866 867 /** @cond exclude_from_documentation */ 868 #ifndef INTEL_NO_MACRO_BODY 869 #ifndef INTEL_NO_ITTNOTIFY_API 870 ITT_STUBV(ITTAPI, void, sync_prepare, (void *addr)) 871 #define __itt_sync_prepare ITTNOTIFY_VOID(sync_prepare) 872 #define __itt_sync_prepare_ptr ITTNOTIFY_NAME(sync_prepare) 873 #else /* INTEL_NO_ITTNOTIFY_API */ 874 #define __itt_sync_prepare(addr) 875 #define __itt_sync_prepare_ptr 0 876 #endif /* INTEL_NO_ITTNOTIFY_API */ 877 #else /* INTEL_NO_MACRO_BODY */ 878 #define __itt_sync_prepare_ptr 0 879 #endif /* INTEL_NO_MACRO_BODY */ 880 /** @endcond */ 881 882 /** 883 * @brief Quit spin loop without acquiring spin object 884 */ 885 void ITTAPI __itt_sync_cancel(void *addr); 886 887 /** @cond exclude_from_documentation */ 888 #ifndef INTEL_NO_MACRO_BODY 889 #ifndef INTEL_NO_ITTNOTIFY_API 890 ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr)) 891 #define __itt_sync_cancel ITTNOTIFY_VOID(sync_cancel) 892 #define __itt_sync_cancel_ptr ITTNOTIFY_NAME(sync_cancel) 893 #else /* INTEL_NO_ITTNOTIFY_API */ 894 #define __itt_sync_cancel(addr) 895 #define __itt_sync_cancel_ptr 0 896 #endif /* INTEL_NO_ITTNOTIFY_API */ 897 #else /* INTEL_NO_MACRO_BODY */ 898 #define __itt_sync_cancel_ptr 0 899 #endif /* INTEL_NO_MACRO_BODY */ 900 /** @endcond */ 901 902 /** 903 * @brief Successful spin loop completion (sync object acquired) 904 */ 905 void ITTAPI __itt_sync_acquired(void *addr); 906 907 /** @cond exclude_from_documentation */ 908 #ifndef INTEL_NO_MACRO_BODY 909 #ifndef INTEL_NO_ITTNOTIFY_API 910 ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr)) 911 #define __itt_sync_acquired ITTNOTIFY_VOID(sync_acquired) 912 #define __itt_sync_acquired_ptr ITTNOTIFY_NAME(sync_acquired) 913 #else /* INTEL_NO_ITTNOTIFY_API */ 914 #define __itt_sync_acquired(addr) 915 #define __itt_sync_acquired_ptr 0 916 #endif /* INTEL_NO_ITTNOTIFY_API */ 917 #else /* INTEL_NO_MACRO_BODY */ 918 #define __itt_sync_acquired_ptr 0 919 #endif /* INTEL_NO_MACRO_BODY */ 920 /** @endcond */ 921 922 /** 923 * @brief Start sync object releasing code. Is called before the lock release 924 * call. 925 */ 926 void ITTAPI __itt_sync_releasing(void *addr); 927 928 /** @cond exclude_from_documentation */ 929 #ifndef INTEL_NO_MACRO_BODY 930 #ifndef INTEL_NO_ITTNOTIFY_API 931 ITT_STUBV(ITTAPI, void, sync_releasing, (void *addr)) 932 #define __itt_sync_releasing ITTNOTIFY_VOID(sync_releasing) 933 #define __itt_sync_releasing_ptr ITTNOTIFY_NAME(sync_releasing) 934 #else /* INTEL_NO_ITTNOTIFY_API */ 935 #define __itt_sync_releasing(addr) 936 #define __itt_sync_releasing_ptr 0 937 #endif /* INTEL_NO_ITTNOTIFY_API */ 938 #else /* INTEL_NO_MACRO_BODY */ 939 #define __itt_sync_releasing_ptr 0 940 #endif /* INTEL_NO_MACRO_BODY */ 941 /** @endcond */ 942 /** @} */ 943 944 /** @} sync group */ 945 946 /****************************************************************** 947 * @name group of functions is used for correctness checking tools 948 ******************************************************************/ 949 /** @{ */ 950 /** 951 * @ingroup legacy 952 * @deprecated Legacy API 953 * @brief Fast synchronization which does no require spinning. 954 * - This special function is to be used by TBB and OpenMP libraries only when 955 * they know there is no spin but they need to suppress TC warnings about shared 956 * variable modifications. 957 * - It only has corresponding pointers in static library and does not have 958 * corresponding function in dynamic library. 959 * @see void __itt_sync_prepare(void* addr); 960 */ 961 void ITTAPI __itt_fsync_prepare(void *addr); 962 963 /** @cond exclude_from_documentation */ 964 #ifndef INTEL_NO_MACRO_BODY 965 #ifndef INTEL_NO_ITTNOTIFY_API 966 ITT_STUBV(ITTAPI, void, fsync_prepare, (void *addr)) 967 #define __itt_fsync_prepare ITTNOTIFY_VOID(fsync_prepare) 968 #define __itt_fsync_prepare_ptr ITTNOTIFY_NAME(fsync_prepare) 969 #else /* INTEL_NO_ITTNOTIFY_API */ 970 #define __itt_fsync_prepare(addr) 971 #define __itt_fsync_prepare_ptr 0 972 #endif /* INTEL_NO_ITTNOTIFY_API */ 973 #else /* INTEL_NO_MACRO_BODY */ 974 #define __itt_fsync_prepare_ptr 0 975 #endif /* INTEL_NO_MACRO_BODY */ 976 /** @endcond */ 977 978 /** 979 * @ingroup legacy 980 * @deprecated Legacy API 981 * @brief Fast synchronization which does no require spinning. 982 * - This special function is to be used by TBB and OpenMP libraries only when 983 * they know there is no spin but they need to suppress TC warnings about shared 984 * variable modifications. 985 * - It only has corresponding pointers in static library and does not have 986 * corresponding function in dynamic library. 987 * @see void __itt_sync_cancel(void *addr); 988 */ 989 void ITTAPI __itt_fsync_cancel(void *addr); 990 991 /** @cond exclude_from_documentation */ 992 #ifndef INTEL_NO_MACRO_BODY 993 #ifndef INTEL_NO_ITTNOTIFY_API 994 ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr)) 995 #define __itt_fsync_cancel ITTNOTIFY_VOID(fsync_cancel) 996 #define __itt_fsync_cancel_ptr ITTNOTIFY_NAME(fsync_cancel) 997 #else /* INTEL_NO_ITTNOTIFY_API */ 998 #define __itt_fsync_cancel(addr) 999 #define __itt_fsync_cancel_ptr 0 1000 #endif /* INTEL_NO_ITTNOTIFY_API */ 1001 #else /* INTEL_NO_MACRO_BODY */ 1002 #define __itt_fsync_cancel_ptr 0 1003 #endif /* INTEL_NO_MACRO_BODY */ 1004 /** @endcond */ 1005 1006 /** 1007 * @ingroup legacy 1008 * @deprecated Legacy API 1009 * @brief Fast synchronization which does no require spinning. 1010 * - This special function is to be used by TBB and OpenMP libraries only when 1011 * they know there is no spin but they need to suppress TC warnings about shared 1012 * variable modifications. 1013 * - It only has corresponding pointers in static library and does not have 1014 * corresponding function in dynamic library. 1015 * @see void __itt_sync_acquired(void *addr); 1016 */ 1017 void ITTAPI __itt_fsync_acquired(void *addr); 1018 1019 /** @cond exclude_from_documentation */ 1020 #ifndef INTEL_NO_MACRO_BODY 1021 #ifndef INTEL_NO_ITTNOTIFY_API 1022 ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr)) 1023 #define __itt_fsync_acquired ITTNOTIFY_VOID(fsync_acquired) 1024 #define __itt_fsync_acquired_ptr ITTNOTIFY_NAME(fsync_acquired) 1025 #else /* INTEL_NO_ITTNOTIFY_API */ 1026 #define __itt_fsync_acquired(addr) 1027 #define __itt_fsync_acquired_ptr 0 1028 #endif /* INTEL_NO_ITTNOTIFY_API */ 1029 #else /* INTEL_NO_MACRO_BODY */ 1030 #define __itt_fsync_acquired_ptr 0 1031 #endif /* INTEL_NO_MACRO_BODY */ 1032 /** @endcond */ 1033 1034 /** 1035 * @ingroup legacy 1036 * @deprecated Legacy API 1037 * @brief Fast synchronization which does no require spinning. 1038 * - This special function is to be used by TBB and OpenMP libraries only when 1039 * they know there is no spin but they need to suppress TC warnings about shared 1040 * variable modifications. 1041 * - It only has corresponding pointers in static library and does not have 1042 * corresponding function in dynamic library. 1043 * @see void __itt_sync_releasing(void* addr); 1044 */ 1045 void ITTAPI __itt_fsync_releasing(void *addr); 1046 1047 /** @cond exclude_from_documentation */ 1048 #ifndef INTEL_NO_MACRO_BODY 1049 #ifndef INTEL_NO_ITTNOTIFY_API 1050 ITT_STUBV(ITTAPI, void, fsync_releasing, (void *addr)) 1051 #define __itt_fsync_releasing ITTNOTIFY_VOID(fsync_releasing) 1052 #define __itt_fsync_releasing_ptr ITTNOTIFY_NAME(fsync_releasing) 1053 #else /* INTEL_NO_ITTNOTIFY_API */ 1054 #define __itt_fsync_releasing(addr) 1055 #define __itt_fsync_releasing_ptr 0 1056 #endif /* INTEL_NO_ITTNOTIFY_API */ 1057 #else /* INTEL_NO_MACRO_BODY */ 1058 #define __itt_fsync_releasing_ptr 0 1059 #endif /* INTEL_NO_MACRO_BODY */ 1060 /** @endcond */ 1061 /** @} */ 1062 1063 /** 1064 * @defgroup model Modeling by Intel(R) Parallel Advisor 1065 * @ingroup public 1066 * This is the subset of itt used for modeling by Intel(R) Parallel Advisor. 1067 * This API is called ONLY using annotate.h, by "Annotation" macros 1068 * the user places in their sources during the parallelism modeling steps. 1069 * 1070 * site_begin/end and task_begin/end take the address of handle variables, 1071 * which are writeable by the API. Handles must be 0 initialized prior 1072 * to the first call to begin, or may cause a run-time failure. 1073 * The handles are initialized in a multi-thread safe way by the API if 1074 * the handle is 0. The commonly expected idiom is one static handle to 1075 * identify a site or task. If a site or task of the same name has already 1076 * been started during this collection, the same handle MAY be returned, 1077 * but is not required to be - it is unspecified if data merging is done 1078 * based on name. These routines also take an instance variable. Like 1079 * the lexical instance, these must be 0 initialized. Unlike the lexical 1080 * instance, this is used to track a single dynamic instance. 1081 * 1082 * API used by the Intel(R) Parallel Advisor to describe potential concurrency 1083 * and related activities. User-added source annotations expand to calls 1084 * to these procedures to enable modeling of a hypothetical concurrent 1085 * execution serially. 1086 * @{ 1087 */ 1088 #if !defined(_ADVISOR_ANNOTATE_H_) || defined(ANNOTATE_EXPAND_NULL) 1089 1090 typedef void *__itt_model_site; /*!< @brief handle for lexical site */ 1091 typedef void 1092 *__itt_model_site_instance; /*!< @brief handle for dynamic instance */ 1093 typedef void *__itt_model_task; /*!< @brief handle for lexical site */ 1094 typedef void 1095 *__itt_model_task_instance; /*!< @brief handle for dynamic instance */ 1096 1097 /** 1098 * @enum __itt_model_disable 1099 * @brief Enumerator for the disable methods 1100 */ 1101 typedef enum { 1102 __itt_model_disable_observation, 1103 __itt_model_disable_collection 1104 } __itt_model_disable; 1105 1106 #endif /* !_ADVISOR_ANNOTATE_H_ || ANNOTATE_EXPAND_NULL */ 1107 1108 /** 1109 * @brief ANNOTATE_SITE_BEGIN/ANNOTATE_SITE_END support. 1110 * 1111 * site_begin/end model a potential concurrency site. 1112 * site instances may be recursively nested with themselves. 1113 * site_end exits the most recently started but unended site for the current 1114 * thread. The handle passed to end may be used to validate structure. 1115 * Instances of a site encountered on different threads concurrently 1116 * are considered completely distinct. If the site name for two different 1117 * lexical sites match, it is unspecified whether they are treated as the 1118 * same or different for data presentation. 1119 */ 1120 void ITTAPI __itt_model_site_begin(__itt_model_site *site, 1121 __itt_model_site_instance *instance, 1122 const char *name); 1123 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1124 void ITTAPI __itt_model_site_beginW(const wchar_t *name); 1125 #endif 1126 void ITTAPI __itt_model_site_beginA(const char *name); 1127 void ITTAPI __itt_model_site_beginAL(const char *name, size_t siteNameLen); 1128 void ITTAPI __itt_model_site_end(__itt_model_site *site, 1129 __itt_model_site_instance *instance); 1130 void ITTAPI __itt_model_site_end_2(void); 1131 1132 /** @cond exclude_from_documentation */ 1133 #ifndef INTEL_NO_MACRO_BODY 1134 #ifndef INTEL_NO_ITTNOTIFY_API 1135 ITT_STUBV(ITTAPI, void, model_site_begin, 1136 (__itt_model_site * site, __itt_model_site_instance *instance, 1137 const char *name)) 1138 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1139 ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name)) 1140 #endif 1141 ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name)) 1142 ITT_STUBV(ITTAPI, void, model_site_beginAL, 1143 (const char *name, size_t siteNameLen)) 1144 ITT_STUBV(ITTAPI, void, model_site_end, 1145 (__itt_model_site * site, __itt_model_site_instance *instance)) 1146 ITT_STUBV(ITTAPI, void, model_site_end_2, (void)) 1147 #define __itt_model_site_begin ITTNOTIFY_VOID(model_site_begin) 1148 #define __itt_model_site_begin_ptr ITTNOTIFY_NAME(model_site_begin) 1149 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1150 #define __itt_model_site_beginW ITTNOTIFY_VOID(model_site_beginW) 1151 #define __itt_model_site_beginW_ptr ITTNOTIFY_NAME(model_site_beginW) 1152 #endif 1153 #define __itt_model_site_beginA ITTNOTIFY_VOID(model_site_beginA) 1154 #define __itt_model_site_beginA_ptr ITTNOTIFY_NAME(model_site_beginA) 1155 #define __itt_model_site_beginAL ITTNOTIFY_VOID(model_site_beginAL) 1156 #define __itt_model_site_beginAL_ptr ITTNOTIFY_NAME(model_site_beginAL) 1157 #define __itt_model_site_end ITTNOTIFY_VOID(model_site_end) 1158 #define __itt_model_site_end_ptr ITTNOTIFY_NAME(model_site_end) 1159 #define __itt_model_site_end_2 ITTNOTIFY_VOID(model_site_end_2) 1160 #define __itt_model_site_end_2_ptr ITTNOTIFY_NAME(model_site_end_2) 1161 #else /* INTEL_NO_ITTNOTIFY_API */ 1162 #define __itt_model_site_begin(site, instance, name) 1163 #define __itt_model_site_begin_ptr 0 1164 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1165 #define __itt_model_site_beginW(name) 1166 #define __itt_model_site_beginW_ptr 0 1167 #endif 1168 #define __itt_model_site_beginA(name) 1169 #define __itt_model_site_beginA_ptr 0 1170 #define __itt_model_site_beginAL(name, siteNameLen) 1171 #define __itt_model_site_beginAL_ptr 0 1172 #define __itt_model_site_end(site, instance) 1173 #define __itt_model_site_end_ptr 0 1174 #define __itt_model_site_end_2() 1175 #define __itt_model_site_end_2_ptr 0 1176 #endif /* INTEL_NO_ITTNOTIFY_API */ 1177 #else /* INTEL_NO_MACRO_BODY */ 1178 #define __itt_model_site_begin_ptr 0 1179 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1180 #define __itt_model_site_beginW_ptr 0 1181 #endif 1182 #define __itt_model_site_beginA_ptr 0 1183 #define __itt_model_site_beginAL_ptr 0 1184 #define __itt_model_site_end_ptr 0 1185 #define __itt_model_site_end_2_ptr 0 1186 #endif /* INTEL_NO_MACRO_BODY */ 1187 /** @endcond */ 1188 1189 /** 1190 * @brief ANNOTATE_TASK_BEGIN/ANNOTATE_TASK_END support 1191 * 1192 * task_begin/end model a potential task, which is contained within the most 1193 * closely enclosing dynamic site. task_end exits the most recently started 1194 * but unended task. The handle passed to end may be used to validate 1195 * structure. It is unspecified if bad dynamic nesting is detected. If it 1196 * is, it should be encoded in the resulting data collection. The collector 1197 * should not fail due to construct nesting issues, nor attempt to directly 1198 * indicate the problem. 1199 */ 1200 void ITTAPI __itt_model_task_begin(__itt_model_task *task, 1201 __itt_model_task_instance *instance, 1202 const char *name); 1203 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1204 void ITTAPI __itt_model_task_beginW(const wchar_t *name); 1205 void ITTAPI __itt_model_iteration_taskW(const wchar_t *name); 1206 #endif 1207 void ITTAPI __itt_model_task_beginA(const char *name); 1208 void ITTAPI __itt_model_task_beginAL(const char *name, size_t taskNameLen); 1209 void ITTAPI __itt_model_iteration_taskA(const char *name); 1210 void ITTAPI __itt_model_iteration_taskAL(const char *name, size_t taskNameLen); 1211 void ITTAPI __itt_model_task_end(__itt_model_task *task, 1212 __itt_model_task_instance *instance); 1213 void ITTAPI __itt_model_task_end_2(void); 1214 1215 /** @cond exclude_from_documentation */ 1216 #ifndef INTEL_NO_MACRO_BODY 1217 #ifndef INTEL_NO_ITTNOTIFY_API 1218 ITT_STUBV(ITTAPI, void, model_task_begin, 1219 (__itt_model_task * task, __itt_model_task_instance *instance, 1220 const char *name)) 1221 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1222 ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name)) 1223 ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name)) 1224 #endif 1225 ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name)) 1226 ITT_STUBV(ITTAPI, void, model_task_beginAL, 1227 (const char *name, size_t taskNameLen)) 1228 ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name)) 1229 ITT_STUBV(ITTAPI, void, model_iteration_taskAL, 1230 (const char *name, size_t taskNameLen)) 1231 ITT_STUBV(ITTAPI, void, model_task_end, 1232 (__itt_model_task * task, __itt_model_task_instance *instance)) 1233 ITT_STUBV(ITTAPI, void, model_task_end_2, (void)) 1234 #define __itt_model_task_begin ITTNOTIFY_VOID(model_task_begin) 1235 #define __itt_model_task_begin_ptr ITTNOTIFY_NAME(model_task_begin) 1236 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1237 #define __itt_model_task_beginW ITTNOTIFY_VOID(model_task_beginW) 1238 #define __itt_model_task_beginW_ptr ITTNOTIFY_NAME(model_task_beginW) 1239 #define __itt_model_iteration_taskW ITTNOTIFY_VOID(model_iteration_taskW) 1240 #define __itt_model_iteration_taskW_ptr ITTNOTIFY_NAME(model_iteration_taskW) 1241 #endif 1242 #define __itt_model_task_beginA ITTNOTIFY_VOID(model_task_beginA) 1243 #define __itt_model_task_beginA_ptr ITTNOTIFY_NAME(model_task_beginA) 1244 #define __itt_model_task_beginAL ITTNOTIFY_VOID(model_task_beginAL) 1245 #define __itt_model_task_beginAL_ptr ITTNOTIFY_NAME(model_task_beginAL) 1246 #define __itt_model_iteration_taskA ITTNOTIFY_VOID(model_iteration_taskA) 1247 #define __itt_model_iteration_taskA_ptr ITTNOTIFY_NAME(model_iteration_taskA) 1248 #define __itt_model_iteration_taskAL ITTNOTIFY_VOID(model_iteration_taskAL) 1249 #define __itt_model_iteration_taskAL_ptr ITTNOTIFY_NAME(model_iteration_taskAL) 1250 #define __itt_model_task_end ITTNOTIFY_VOID(model_task_end) 1251 #define __itt_model_task_end_ptr ITTNOTIFY_NAME(model_task_end) 1252 #define __itt_model_task_end_2 ITTNOTIFY_VOID(model_task_end_2) 1253 #define __itt_model_task_end_2_ptr ITTNOTIFY_NAME(model_task_end_2) 1254 #else /* INTEL_NO_ITTNOTIFY_API */ 1255 #define __itt_model_task_begin(task, instance, name) 1256 #define __itt_model_task_begin_ptr 0 1257 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1258 #define __itt_model_task_beginW(name) 1259 #define __itt_model_task_beginW_ptr 0 1260 #endif 1261 #define __itt_model_task_beginA(name) 1262 #define __itt_model_task_beginA_ptr 0 1263 #define __itt_model_task_beginAL(name, siteNameLen) 1264 #define __itt_model_task_beginAL_ptr 0 1265 #define __itt_model_iteration_taskA(name) 1266 #define __itt_model_iteration_taskA_ptr 0 1267 #define __itt_model_iteration_taskAL(name, siteNameLen) 1268 #define __itt_model_iteration_taskAL_ptr 0 1269 #define __itt_model_task_end(task, instance) 1270 #define __itt_model_task_end_ptr 0 1271 #define __itt_model_task_end_2() 1272 #define __itt_model_task_end_2_ptr 0 1273 #endif /* INTEL_NO_ITTNOTIFY_API */ 1274 #else /* INTEL_NO_MACRO_BODY */ 1275 #define __itt_model_task_begin_ptr 0 1276 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1277 #define __itt_model_task_beginW_ptr 0 1278 #endif 1279 #define __itt_model_task_beginA_ptr 0 1280 #define __itt_model_task_beginAL_ptr 0 1281 #define __itt_model_iteration_taskA_ptr 0 1282 #define __itt_model_iteration_taskAL_ptr 0 1283 #define __itt_model_task_end_ptr 0 1284 #define __itt_model_task_end_2_ptr 0 1285 #endif /* INTEL_NO_MACRO_BODY */ 1286 /** @endcond */ 1287 1288 /** 1289 * @brief ANNOTATE_LOCK_ACQUIRE/ANNOTATE_LOCK_RELEASE support 1290 * 1291 * lock_acquire/release model a potential lock for both lockset and 1292 * performance modeling. Each unique address is modeled as a separate 1293 * lock, with invalid addresses being valid lock IDs. Specifically: 1294 * no storage is accessed by the API at the specified address - it is only 1295 * used for lock identification. Lock acquires may be self-nested and are 1296 * unlocked by a corresponding number of releases. 1297 * (These closely correspond to __itt_sync_acquired/__itt_sync_releasing, 1298 * but may not have identical semantics.) 1299 */ 1300 void ITTAPI __itt_model_lock_acquire(void *lock); 1301 void ITTAPI __itt_model_lock_acquire_2(void *lock); 1302 void ITTAPI __itt_model_lock_release(void *lock); 1303 void ITTAPI __itt_model_lock_release_2(void *lock); 1304 1305 /** @cond exclude_from_documentation */ 1306 #ifndef INTEL_NO_MACRO_BODY 1307 #ifndef INTEL_NO_ITTNOTIFY_API 1308 ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock)) 1309 ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock)) 1310 ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock)) 1311 ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock)) 1312 #define __itt_model_lock_acquire ITTNOTIFY_VOID(model_lock_acquire) 1313 #define __itt_model_lock_acquire_ptr ITTNOTIFY_NAME(model_lock_acquire) 1314 #define __itt_model_lock_acquire_2 ITTNOTIFY_VOID(model_lock_acquire_2) 1315 #define __itt_model_lock_acquire_2_ptr ITTNOTIFY_NAME(model_lock_acquire_2) 1316 #define __itt_model_lock_release ITTNOTIFY_VOID(model_lock_release) 1317 #define __itt_model_lock_release_ptr ITTNOTIFY_NAME(model_lock_release) 1318 #define __itt_model_lock_release_2 ITTNOTIFY_VOID(model_lock_release_2) 1319 #define __itt_model_lock_release_2_ptr ITTNOTIFY_NAME(model_lock_release_2) 1320 #else /* INTEL_NO_ITTNOTIFY_API */ 1321 #define __itt_model_lock_acquire(lock) 1322 #define __itt_model_lock_acquire_ptr 0 1323 #define __itt_model_lock_acquire_2(lock) 1324 #define __itt_model_lock_acquire_2_ptr 0 1325 #define __itt_model_lock_release(lock) 1326 #define __itt_model_lock_release_ptr 0 1327 #define __itt_model_lock_release_2(lock) 1328 #define __itt_model_lock_release_2_ptr 0 1329 #endif /* INTEL_NO_ITTNOTIFY_API */ 1330 #else /* INTEL_NO_MACRO_BODY */ 1331 #define __itt_model_lock_acquire_ptr 0 1332 #define __itt_model_lock_acquire_2_ptr 0 1333 #define __itt_model_lock_release_ptr 0 1334 #define __itt_model_lock_release_2_ptr 0 1335 #endif /* INTEL_NO_MACRO_BODY */ 1336 /** @endcond */ 1337 1338 /** 1339 * @brief ANNOTATE_RECORD_ALLOCATION/ANNOTATE_RECORD_DEALLOCATION support 1340 * 1341 * record_allocation/deallocation describe user-defined memory allocator 1342 * behavior, which may be required for correctness modeling to understand 1343 * when storage is not expected to be actually reused across threads. 1344 */ 1345 void ITTAPI __itt_model_record_allocation(void *addr, size_t size); 1346 void ITTAPI __itt_model_record_deallocation(void *addr); 1347 1348 /** @cond exclude_from_documentation */ 1349 #ifndef INTEL_NO_MACRO_BODY 1350 #ifndef INTEL_NO_ITTNOTIFY_API 1351 ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size)) 1352 ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr)) 1353 #define __itt_model_record_allocation ITTNOTIFY_VOID(model_record_allocation) 1354 #define __itt_model_record_allocation_ptr \ 1355 ITTNOTIFY_NAME(model_record_allocation) 1356 #define __itt_model_record_deallocation \ 1357 ITTNOTIFY_VOID(model_record_deallocation) 1358 #define __itt_model_record_deallocation_ptr \ 1359 ITTNOTIFY_NAME(model_record_deallocation) 1360 #else /* INTEL_NO_ITTNOTIFY_API */ 1361 #define __itt_model_record_allocation(addr, size) 1362 #define __itt_model_record_allocation_ptr 0 1363 #define __itt_model_record_deallocation(addr) 1364 #define __itt_model_record_deallocation_ptr 0 1365 #endif /* INTEL_NO_ITTNOTIFY_API */ 1366 #else /* INTEL_NO_MACRO_BODY */ 1367 #define __itt_model_record_allocation_ptr 0 1368 #define __itt_model_record_deallocation_ptr 0 1369 #endif /* INTEL_NO_MACRO_BODY */ 1370 /** @endcond */ 1371 1372 /** 1373 * @brief ANNOTATE_INDUCTION_USES support 1374 * 1375 * Note particular storage is inductive through the end of the current site 1376 */ 1377 void ITTAPI __itt_model_induction_uses(void *addr, size_t size); 1378 1379 /** @cond exclude_from_documentation */ 1380 #ifndef INTEL_NO_MACRO_BODY 1381 #ifndef INTEL_NO_ITTNOTIFY_API 1382 ITT_STUBV(ITTAPI, void, model_induction_uses, (void *addr, size_t size)) 1383 #define __itt_model_induction_uses ITTNOTIFY_VOID(model_induction_uses) 1384 #define __itt_model_induction_uses_ptr ITTNOTIFY_NAME(model_induction_uses) 1385 #else /* INTEL_NO_ITTNOTIFY_API */ 1386 #define __itt_model_induction_uses(addr, size) 1387 #define __itt_model_induction_uses_ptr 0 1388 #endif /* INTEL_NO_ITTNOTIFY_API */ 1389 #else /* INTEL_NO_MACRO_BODY */ 1390 #define __itt_model_induction_uses_ptr 0 1391 #endif /* INTEL_NO_MACRO_BODY */ 1392 /** @endcond */ 1393 1394 /** 1395 * @brief ANNOTATE_REDUCTION_USES support 1396 * 1397 * Note particular storage is used for reduction through the end 1398 * of the current site 1399 */ 1400 void ITTAPI __itt_model_reduction_uses(void *addr, size_t size); 1401 1402 /** @cond exclude_from_documentation */ 1403 #ifndef INTEL_NO_MACRO_BODY 1404 #ifndef INTEL_NO_ITTNOTIFY_API 1405 ITT_STUBV(ITTAPI, void, model_reduction_uses, (void *addr, size_t size)) 1406 #define __itt_model_reduction_uses ITTNOTIFY_VOID(model_reduction_uses) 1407 #define __itt_model_reduction_uses_ptr ITTNOTIFY_NAME(model_reduction_uses) 1408 #else /* INTEL_NO_ITTNOTIFY_API */ 1409 #define __itt_model_reduction_uses(addr, size) 1410 #define __itt_model_reduction_uses_ptr 0 1411 #endif /* INTEL_NO_ITTNOTIFY_API */ 1412 #else /* INTEL_NO_MACRO_BODY */ 1413 #define __itt_model_reduction_uses_ptr 0 1414 #endif /* INTEL_NO_MACRO_BODY */ 1415 /** @endcond */ 1416 1417 /** 1418 * @brief ANNOTATE_OBSERVE_USES support 1419 * 1420 * Have correctness modeling record observations about uses of storage 1421 * through the end of the current site 1422 */ 1423 void ITTAPI __itt_model_observe_uses(void *addr, size_t size); 1424 1425 /** @cond exclude_from_documentation */ 1426 #ifndef INTEL_NO_MACRO_BODY 1427 #ifndef INTEL_NO_ITTNOTIFY_API 1428 ITT_STUBV(ITTAPI, void, model_observe_uses, (void *addr, size_t size)) 1429 #define __itt_model_observe_uses ITTNOTIFY_VOID(model_observe_uses) 1430 #define __itt_model_observe_uses_ptr ITTNOTIFY_NAME(model_observe_uses) 1431 #else /* INTEL_NO_ITTNOTIFY_API */ 1432 #define __itt_model_observe_uses(addr, size) 1433 #define __itt_model_observe_uses_ptr 0 1434 #endif /* INTEL_NO_ITTNOTIFY_API */ 1435 #else /* INTEL_NO_MACRO_BODY */ 1436 #define __itt_model_observe_uses_ptr 0 1437 #endif /* INTEL_NO_MACRO_BODY */ 1438 /** @endcond */ 1439 1440 /** 1441 * @brief ANNOTATE_CLEAR_USES support 1442 * 1443 * Clear the special handling of a piece of storage related to induction, 1444 * reduction or observe_uses 1445 */ 1446 void ITTAPI __itt_model_clear_uses(void *addr); 1447 1448 /** @cond exclude_from_documentation */ 1449 #ifndef INTEL_NO_MACRO_BODY 1450 #ifndef INTEL_NO_ITTNOTIFY_API 1451 ITT_STUBV(ITTAPI, void, model_clear_uses, (void *addr)) 1452 #define __itt_model_clear_uses ITTNOTIFY_VOID(model_clear_uses) 1453 #define __itt_model_clear_uses_ptr ITTNOTIFY_NAME(model_clear_uses) 1454 #else /* INTEL_NO_ITTNOTIFY_API */ 1455 #define __itt_model_clear_uses(addr) 1456 #define __itt_model_clear_uses_ptr 0 1457 #endif /* INTEL_NO_ITTNOTIFY_API */ 1458 #else /* INTEL_NO_MACRO_BODY */ 1459 #define __itt_model_clear_uses_ptr 0 1460 #endif /* INTEL_NO_MACRO_BODY */ 1461 /** @endcond */ 1462 1463 /** 1464 * @brief ANNOTATE_DISABLE_*_PUSH/ANNOTATE_DISABLE_*_POP support 1465 * 1466 * disable_push/disable_pop push and pop disabling based on a parameter. 1467 * Disabling observations stops processing of memory references during 1468 * correctness modeling, and all annotations that occur in the disabled 1469 * region. This allows description of code that is expected to be handled 1470 * specially during conversion to parallelism or that is not recognized 1471 * by tools (e.g. some kinds of synchronization operations.) 1472 * This mechanism causes all annotations in the disabled region, other 1473 * than disable_push and disable_pop, to be ignored. (For example, this 1474 * might validly be used to disable an entire parallel site and the contained 1475 * tasks and locking in it for data collection purposes.) 1476 * The disable for collection is a more expensive operation, but reduces 1477 * collector overhead significantly. This applies to BOTH correctness data 1478 * collection and performance data collection. For example, a site 1479 * containing a task might only enable data collection for the first 10 1480 * iterations. Both performance and correctness data should reflect this, 1481 * and the program should run as close to full speed as possible when 1482 * collection is disabled. 1483 */ 1484 void ITTAPI __itt_model_disable_push(__itt_model_disable x); 1485 void ITTAPI __itt_model_disable_pop(void); 1486 void ITTAPI __itt_model_aggregate_task(size_t x); 1487 1488 /** @cond exclude_from_documentation */ 1489 #ifndef INTEL_NO_MACRO_BODY 1490 #ifndef INTEL_NO_ITTNOTIFY_API 1491 ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x)) 1492 ITT_STUBV(ITTAPI, void, model_disable_pop, (void)) 1493 ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t x)) 1494 #define __itt_model_disable_push ITTNOTIFY_VOID(model_disable_push) 1495 #define __itt_model_disable_push_ptr ITTNOTIFY_NAME(model_disable_push) 1496 #define __itt_model_disable_pop ITTNOTIFY_VOID(model_disable_pop) 1497 #define __itt_model_disable_pop_ptr ITTNOTIFY_NAME(model_disable_pop) 1498 #define __itt_model_aggregate_task ITTNOTIFY_VOID(model_aggregate_task) 1499 #define __itt_model_aggregate_task_ptr ITTNOTIFY_NAME(model_aggregate_task) 1500 #else /* INTEL_NO_ITTNOTIFY_API */ 1501 #define __itt_model_disable_push(x) 1502 #define __itt_model_disable_push_ptr 0 1503 #define __itt_model_disable_pop() 1504 #define __itt_model_disable_pop_ptr 0 1505 #define __itt_model_aggregate_task(x) 1506 #define __itt_model_aggregate_task_ptr 0 1507 #endif /* INTEL_NO_ITTNOTIFY_API */ 1508 #else /* INTEL_NO_MACRO_BODY */ 1509 #define __itt_model_disable_push_ptr 0 1510 #define __itt_model_disable_pop_ptr 0 1511 #define __itt_model_aggregate_task_ptr 0 1512 #endif /* INTEL_NO_MACRO_BODY */ 1513 /** @endcond */ 1514 /** @} model group */ 1515 1516 /** 1517 * @defgroup heap Heap 1518 * @ingroup public 1519 * Heap group 1520 * @{ 1521 */ 1522 1523 typedef void *__itt_heap_function; 1524 1525 /** 1526 * @brief Create an identification for heap function 1527 * @return non-zero identifier or NULL 1528 */ 1529 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1530 __itt_heap_function ITTAPI __itt_heap_function_createA(const char *name, 1531 const char *domain); 1532 __itt_heap_function ITTAPI __itt_heap_function_createW(const wchar_t *name, 1533 const wchar_t *domain); 1534 #if defined(UNICODE) || defined(_UNICODE) 1535 #define __itt_heap_function_create __itt_heap_function_createW 1536 #define __itt_heap_function_create_ptr __itt_heap_function_createW_ptr 1537 #else 1538 #define __itt_heap_function_create __itt_heap_function_createA 1539 #define __itt_heap_function_create_ptr __itt_heap_function_createA_ptr 1540 #endif /* UNICODE */ 1541 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1542 __itt_heap_function ITTAPI __itt_heap_function_create(const char *name, 1543 const char *domain); 1544 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1545 1546 /** @cond exclude_from_documentation */ 1547 #ifndef INTEL_NO_MACRO_BODY 1548 #ifndef INTEL_NO_ITTNOTIFY_API 1549 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1550 ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA, 1551 (const char *name, const char *domain)) 1552 ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW, 1553 (const wchar_t *name, const wchar_t *domain)) 1554 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1555 ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create, 1556 (const char *name, const char *domain)) 1557 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1558 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1559 #define __itt_heap_function_createA ITTNOTIFY_DATA(heap_function_createA) 1560 #define __itt_heap_function_createA_ptr ITTNOTIFY_NAME(heap_function_createA) 1561 #define __itt_heap_function_createW ITTNOTIFY_DATA(heap_function_createW) 1562 #define __itt_heap_function_createW_ptr ITTNOTIFY_NAME(heap_function_createW) 1563 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1564 #define __itt_heap_function_create ITTNOTIFY_DATA(heap_function_create) 1565 #define __itt_heap_function_create_ptr ITTNOTIFY_NAME(heap_function_create) 1566 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1567 #else /* INTEL_NO_ITTNOTIFY_API */ 1568 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1569 #define __itt_heap_function_createA(name, domain) (__itt_heap_function)0 1570 #define __itt_heap_function_createA_ptr 0 1571 #define __itt_heap_function_createW(name, domain) (__itt_heap_function)0 1572 #define __itt_heap_function_createW_ptr 0 1573 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1574 #define __itt_heap_function_create(name, domain) (__itt_heap_function)0 1575 #define __itt_heap_function_create_ptr 0 1576 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1577 #endif /* INTEL_NO_ITTNOTIFY_API */ 1578 #else /* INTEL_NO_MACRO_BODY */ 1579 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1580 #define __itt_heap_function_createA_ptr 0 1581 #define __itt_heap_function_createW_ptr 0 1582 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1583 #define __itt_heap_function_create_ptr 0 1584 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1585 #endif /* INTEL_NO_MACRO_BODY */ 1586 /** @endcond */ 1587 1588 /** 1589 * @brief Record an allocation begin occurrence. 1590 */ 1591 void ITTAPI __itt_heap_allocate_begin(__itt_heap_function h, size_t size, 1592 int initialized); 1593 1594 /** @cond exclude_from_documentation */ 1595 #ifndef INTEL_NO_MACRO_BODY 1596 #ifndef INTEL_NO_ITTNOTIFY_API 1597 ITT_STUBV(ITTAPI, void, heap_allocate_begin, 1598 (__itt_heap_function h, size_t size, int initialized)) 1599 #define __itt_heap_allocate_begin ITTNOTIFY_VOID(heap_allocate_begin) 1600 #define __itt_heap_allocate_begin_ptr ITTNOTIFY_NAME(heap_allocate_begin) 1601 #else /* INTEL_NO_ITTNOTIFY_API */ 1602 #define __itt_heap_allocate_begin(h, size, initialized) 1603 #define __itt_heap_allocate_begin_ptr 0 1604 #endif /* INTEL_NO_ITTNOTIFY_API */ 1605 #else /* INTEL_NO_MACRO_BODY */ 1606 #define __itt_heap_allocate_begin_ptr 0 1607 #endif /* INTEL_NO_MACRO_BODY */ 1608 /** @endcond */ 1609 1610 /** 1611 * @brief Record an allocation end occurrence. 1612 */ 1613 void ITTAPI __itt_heap_allocate_end(__itt_heap_function h, void **addr, 1614 size_t size, int initialized); 1615 1616 /** @cond exclude_from_documentation */ 1617 #ifndef INTEL_NO_MACRO_BODY 1618 #ifndef INTEL_NO_ITTNOTIFY_API 1619 ITT_STUBV(ITTAPI, void, heap_allocate_end, 1620 (__itt_heap_function h, void **addr, size_t size, int initialized)) 1621 #define __itt_heap_allocate_end ITTNOTIFY_VOID(heap_allocate_end) 1622 #define __itt_heap_allocate_end_ptr ITTNOTIFY_NAME(heap_allocate_end) 1623 #else /* INTEL_NO_ITTNOTIFY_API */ 1624 #define __itt_heap_allocate_end(h, addr, size, initialized) 1625 #define __itt_heap_allocate_end_ptr 0 1626 #endif /* INTEL_NO_ITTNOTIFY_API */ 1627 #else /* INTEL_NO_MACRO_BODY */ 1628 #define __itt_heap_allocate_end_ptr 0 1629 #endif /* INTEL_NO_MACRO_BODY */ 1630 /** @endcond */ 1631 1632 /** 1633 * @brief Record a free begin occurrence. 1634 */ 1635 void ITTAPI __itt_heap_free_begin(__itt_heap_function h, void *addr); 1636 1637 /** @cond exclude_from_documentation */ 1638 #ifndef INTEL_NO_MACRO_BODY 1639 #ifndef INTEL_NO_ITTNOTIFY_API 1640 ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void *addr)) 1641 #define __itt_heap_free_begin ITTNOTIFY_VOID(heap_free_begin) 1642 #define __itt_heap_free_begin_ptr ITTNOTIFY_NAME(heap_free_begin) 1643 #else /* INTEL_NO_ITTNOTIFY_API */ 1644 #define __itt_heap_free_begin(h, addr) 1645 #define __itt_heap_free_begin_ptr 0 1646 #endif /* INTEL_NO_ITTNOTIFY_API */ 1647 #else /* INTEL_NO_MACRO_BODY */ 1648 #define __itt_heap_free_begin_ptr 0 1649 #endif /* INTEL_NO_MACRO_BODY */ 1650 /** @endcond */ 1651 1652 /** 1653 * @brief Record a free end occurrence. 1654 */ 1655 void ITTAPI __itt_heap_free_end(__itt_heap_function h, void *addr); 1656 1657 /** @cond exclude_from_documentation */ 1658 #ifndef INTEL_NO_MACRO_BODY 1659 #ifndef INTEL_NO_ITTNOTIFY_API 1660 ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void *addr)) 1661 #define __itt_heap_free_end ITTNOTIFY_VOID(heap_free_end) 1662 #define __itt_heap_free_end_ptr ITTNOTIFY_NAME(heap_free_end) 1663 #else /* INTEL_NO_ITTNOTIFY_API */ 1664 #define __itt_heap_free_end(h, addr) 1665 #define __itt_heap_free_end_ptr 0 1666 #endif /* INTEL_NO_ITTNOTIFY_API */ 1667 #else /* INTEL_NO_MACRO_BODY */ 1668 #define __itt_heap_free_end_ptr 0 1669 #endif /* INTEL_NO_MACRO_BODY */ 1670 /** @endcond */ 1671 1672 /** 1673 * @brief Record a reallocation begin occurrence. 1674 */ 1675 void ITTAPI __itt_heap_reallocate_begin(__itt_heap_function h, void *addr, 1676 size_t new_size, int initialized); 1677 1678 /** @cond exclude_from_documentation */ 1679 #ifndef INTEL_NO_MACRO_BODY 1680 #ifndef INTEL_NO_ITTNOTIFY_API 1681 ITT_STUBV(ITTAPI, void, heap_reallocate_begin, 1682 (__itt_heap_function h, void *addr, size_t new_size, int initialized)) 1683 #define __itt_heap_reallocate_begin ITTNOTIFY_VOID(heap_reallocate_begin) 1684 #define __itt_heap_reallocate_begin_ptr ITTNOTIFY_NAME(heap_reallocate_begin) 1685 #else /* INTEL_NO_ITTNOTIFY_API */ 1686 #define __itt_heap_reallocate_begin(h, addr, new_size, initialized) 1687 #define __itt_heap_reallocate_begin_ptr 0 1688 #endif /* INTEL_NO_ITTNOTIFY_API */ 1689 #else /* INTEL_NO_MACRO_BODY */ 1690 #define __itt_heap_reallocate_begin_ptr 0 1691 #endif /* INTEL_NO_MACRO_BODY */ 1692 /** @endcond */ 1693 1694 /** 1695 * @brief Record a reallocation end occurrence. 1696 */ 1697 void ITTAPI __itt_heap_reallocate_end(__itt_heap_function h, void *addr, 1698 void **new_addr, size_t new_size, 1699 int initialized); 1700 1701 /** @cond exclude_from_documentation */ 1702 #ifndef INTEL_NO_MACRO_BODY 1703 #ifndef INTEL_NO_ITTNOTIFY_API 1704 ITT_STUBV(ITTAPI, void, heap_reallocate_end, 1705 (__itt_heap_function h, void *addr, void **new_addr, size_t new_size, 1706 int initialized)) 1707 #define __itt_heap_reallocate_end ITTNOTIFY_VOID(heap_reallocate_end) 1708 #define __itt_heap_reallocate_end_ptr ITTNOTIFY_NAME(heap_reallocate_end) 1709 #else /* INTEL_NO_ITTNOTIFY_API */ 1710 #define __itt_heap_reallocate_end(h, addr, new_addr, new_size, initialized) 1711 #define __itt_heap_reallocate_end_ptr 0 1712 #endif /* INTEL_NO_ITTNOTIFY_API */ 1713 #else /* INTEL_NO_MACRO_BODY */ 1714 #define __itt_heap_reallocate_end_ptr 0 1715 #endif /* INTEL_NO_MACRO_BODY */ 1716 /** @endcond */ 1717 1718 /** @brief internal access begin */ 1719 void ITTAPI __itt_heap_internal_access_begin(void); 1720 1721 /** @cond exclude_from_documentation */ 1722 #ifndef INTEL_NO_MACRO_BODY 1723 #ifndef INTEL_NO_ITTNOTIFY_API 1724 ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void)) 1725 #define __itt_heap_internal_access_begin \ 1726 ITTNOTIFY_VOID(heap_internal_access_begin) 1727 #define __itt_heap_internal_access_begin_ptr \ 1728 ITTNOTIFY_NAME(heap_internal_access_begin) 1729 #else /* INTEL_NO_ITTNOTIFY_API */ 1730 #define __itt_heap_internal_access_begin() 1731 #define __itt_heap_internal_access_begin_ptr 0 1732 #endif /* INTEL_NO_ITTNOTIFY_API */ 1733 #else /* INTEL_NO_MACRO_BODY */ 1734 #define __itt_heap_internal_access_begin_ptr 0 1735 #endif /* INTEL_NO_MACRO_BODY */ 1736 /** @endcond */ 1737 1738 /** @brief internal access end */ 1739 void ITTAPI __itt_heap_internal_access_end(void); 1740 1741 /** @cond exclude_from_documentation */ 1742 #ifndef INTEL_NO_MACRO_BODY 1743 #ifndef INTEL_NO_ITTNOTIFY_API 1744 ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void)) 1745 #define __itt_heap_internal_access_end ITTNOTIFY_VOID(heap_internal_access_end) 1746 #define __itt_heap_internal_access_end_ptr \ 1747 ITTNOTIFY_NAME(heap_internal_access_end) 1748 #else /* INTEL_NO_ITTNOTIFY_API */ 1749 #define __itt_heap_internal_access_end() 1750 #define __itt_heap_internal_access_end_ptr 0 1751 #endif /* INTEL_NO_ITTNOTIFY_API */ 1752 #else /* INTEL_NO_MACRO_BODY */ 1753 #define __itt_heap_internal_access_end_ptr 0 1754 #endif /* INTEL_NO_MACRO_BODY */ 1755 /** @endcond */ 1756 1757 /** @brief record memory growth begin */ 1758 void ITTAPI __itt_heap_record_memory_growth_begin(void); 1759 1760 /** @cond exclude_from_documentation */ 1761 #ifndef INTEL_NO_MACRO_BODY 1762 #ifndef INTEL_NO_ITTNOTIFY_API 1763 ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void)) 1764 #define __itt_heap_record_memory_growth_begin \ 1765 ITTNOTIFY_VOID(heap_record_memory_growth_begin) 1766 #define __itt_heap_record_memory_growth_begin_ptr \ 1767 ITTNOTIFY_NAME(heap_record_memory_growth_begin) 1768 #else /* INTEL_NO_ITTNOTIFY_API */ 1769 #define __itt_heap_record_memory_growth_begin() 1770 #define __itt_heap_record_memory_growth_begin_ptr 0 1771 #endif /* INTEL_NO_ITTNOTIFY_API */ 1772 #else /* INTEL_NO_MACRO_BODY */ 1773 #define __itt_heap_record_memory_growth_begin_ptr 0 1774 #endif /* INTEL_NO_MACRO_BODY */ 1775 /** @endcond */ 1776 1777 /** @brief record memory growth end */ 1778 void ITTAPI __itt_heap_record_memory_growth_end(void); 1779 1780 /** @cond exclude_from_documentation */ 1781 #ifndef INTEL_NO_MACRO_BODY 1782 #ifndef INTEL_NO_ITTNOTIFY_API 1783 ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void)) 1784 #define __itt_heap_record_memory_growth_end \ 1785 ITTNOTIFY_VOID(heap_record_memory_growth_end) 1786 #define __itt_heap_record_memory_growth_end_ptr \ 1787 ITTNOTIFY_NAME(heap_record_memory_growth_end) 1788 #else /* INTEL_NO_ITTNOTIFY_API */ 1789 #define __itt_heap_record_memory_growth_end() 1790 #define __itt_heap_record_memory_growth_end_ptr 0 1791 #endif /* INTEL_NO_ITTNOTIFY_API */ 1792 #else /* INTEL_NO_MACRO_BODY */ 1793 #define __itt_heap_record_memory_growth_end_ptr 0 1794 #endif /* INTEL_NO_MACRO_BODY */ 1795 /** @endcond */ 1796 1797 /** 1798 * @brief Specify the type of heap detection/reporting to modify. 1799 */ 1800 /** 1801 * @hideinitializer 1802 * @brief Report on memory leaks. 1803 */ 1804 #define __itt_heap_leaks 0x00000001 1805 1806 /** 1807 * @hideinitializer 1808 * @brief Report on memory growth. 1809 */ 1810 #define __itt_heap_growth 0x00000002 1811 1812 /** @brief heap reset detection */ 1813 void ITTAPI __itt_heap_reset_detection(unsigned int reset_mask); 1814 1815 /** @cond exclude_from_documentation */ 1816 #ifndef INTEL_NO_MACRO_BODY 1817 #ifndef INTEL_NO_ITTNOTIFY_API 1818 ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask)) 1819 #define __itt_heap_reset_detection ITTNOTIFY_VOID(heap_reset_detection) 1820 #define __itt_heap_reset_detection_ptr ITTNOTIFY_NAME(heap_reset_detection) 1821 #else /* INTEL_NO_ITTNOTIFY_API */ 1822 #define __itt_heap_reset_detection() 1823 #define __itt_heap_reset_detection_ptr 0 1824 #endif /* INTEL_NO_ITTNOTIFY_API */ 1825 #else /* INTEL_NO_MACRO_BODY */ 1826 #define __itt_heap_reset_detection_ptr 0 1827 #endif /* INTEL_NO_MACRO_BODY */ 1828 /** @endcond */ 1829 1830 /** @brief report */ 1831 void ITTAPI __itt_heap_record(unsigned int record_mask); 1832 1833 /** @cond exclude_from_documentation */ 1834 #ifndef INTEL_NO_MACRO_BODY 1835 #ifndef INTEL_NO_ITTNOTIFY_API 1836 ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask)) 1837 #define __itt_heap_record ITTNOTIFY_VOID(heap_record) 1838 #define __itt_heap_record_ptr ITTNOTIFY_NAME(heap_record) 1839 #else /* INTEL_NO_ITTNOTIFY_API */ 1840 #define __itt_heap_record() 1841 #define __itt_heap_record_ptr 0 1842 #endif /* INTEL_NO_ITTNOTIFY_API */ 1843 #else /* INTEL_NO_MACRO_BODY */ 1844 #define __itt_heap_record_ptr 0 1845 #endif /* INTEL_NO_MACRO_BODY */ 1846 /** @endcond */ 1847 1848 /** @} heap group */ 1849 /** @endcond */ 1850 /* ========================================================================== */ 1851 1852 /** 1853 * @defgroup domains Domains 1854 * @ingroup public 1855 * Domains group 1856 * @{ 1857 */ 1858 1859 /** @cond exclude_from_documentation */ 1860 #pragma pack(push, 8) 1861 1862 typedef struct ___itt_domain { 1863 volatile int flags; /*!< Zero if disabled, non-zero if enabled. The meaning of 1864 different non-zero values is reserved to the runtime */ 1865 const char *nameA; /*!< Copy of original name in ASCII. */ 1866 #if defined(UNICODE) || defined(_UNICODE) 1867 const wchar_t *nameW; /*!< Copy of original name in UNICODE. */ 1868 #else /* UNICODE || _UNICODE */ 1869 void *nameW; 1870 #endif /* UNICODE || _UNICODE */ 1871 int extra1; /*!< Reserved to the runtime */ 1872 void *extra2; /*!< Reserved to the runtime */ 1873 struct ___itt_domain *next; 1874 } __itt_domain; 1875 1876 #pragma pack(pop) 1877 /** @endcond */ 1878 1879 /** 1880 * @ingroup domains 1881 * @brief Create a domain. 1882 * Create domain using some domain name: the URI naming style is recommended. 1883 * Because the set of domains is expected to be static over the application's 1884 * execution time, there is no mechanism to destroy a domain. 1885 * Any domain can be accessed by any thread in the process, regardless of 1886 * which thread created the domain. This call is thread-safe. 1887 * @param[in] name name of domain 1888 */ 1889 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1890 __itt_domain *ITTAPI __itt_domain_createA(const char *name); 1891 __itt_domain *ITTAPI __itt_domain_createW(const wchar_t *name); 1892 #if defined(UNICODE) || defined(_UNICODE) 1893 #define __itt_domain_create __itt_domain_createW 1894 #define __itt_domain_create_ptr __itt_domain_createW_ptr 1895 #else /* UNICODE */ 1896 #define __itt_domain_create __itt_domain_createA 1897 #define __itt_domain_create_ptr __itt_domain_createA_ptr 1898 #endif /* UNICODE */ 1899 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1900 __itt_domain *ITTAPI __itt_domain_create(const char *name); 1901 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1902 1903 /** @cond exclude_from_documentation */ 1904 #ifndef INTEL_NO_MACRO_BODY 1905 #ifndef INTEL_NO_ITTNOTIFY_API 1906 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1907 ITT_STUB(ITTAPI, __itt_domain *, domain_createA, (const char *name)) 1908 ITT_STUB(ITTAPI, __itt_domain *, domain_createW, (const wchar_t *name)) 1909 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1910 ITT_STUB(ITTAPI, __itt_domain *, domain_create, (const char *name)) 1911 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1912 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1913 #define __itt_domain_createA ITTNOTIFY_DATA(domain_createA) 1914 #define __itt_domain_createA_ptr ITTNOTIFY_NAME(domain_createA) 1915 #define __itt_domain_createW ITTNOTIFY_DATA(domain_createW) 1916 #define __itt_domain_createW_ptr ITTNOTIFY_NAME(domain_createW) 1917 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1918 #define __itt_domain_create ITTNOTIFY_DATA(domain_create) 1919 #define __itt_domain_create_ptr ITTNOTIFY_NAME(domain_create) 1920 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1921 #else /* INTEL_NO_ITTNOTIFY_API */ 1922 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1923 #define __itt_domain_createA(name) (__itt_domain *)0 1924 #define __itt_domain_createA_ptr 0 1925 #define __itt_domain_createW(name) (__itt_domain *)0 1926 #define __itt_domain_createW_ptr 0 1927 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1928 #define __itt_domain_create(name) (__itt_domain *)0 1929 #define __itt_domain_create_ptr 0 1930 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1931 #endif /* INTEL_NO_ITTNOTIFY_API */ 1932 #else /* INTEL_NO_MACRO_BODY */ 1933 #if ITT_PLATFORM == ITT_PLATFORM_WIN 1934 #define __itt_domain_createA_ptr 0 1935 #define __itt_domain_createW_ptr 0 1936 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1937 #define __itt_domain_create_ptr 0 1938 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 1939 #endif /* INTEL_NO_MACRO_BODY */ 1940 /** @endcond */ 1941 /** @} domains group */ 1942 1943 /** 1944 * @defgroup ids IDs 1945 * @ingroup public 1946 * IDs group 1947 * @{ 1948 */ 1949 1950 /** @cond exclude_from_documentation */ 1951 #pragma pack(push, 8) 1952 1953 typedef struct ___itt_id { 1954 unsigned long long d1, d2, d3; 1955 } __itt_id; 1956 1957 #pragma pack(pop) 1958 /** @endcond */ 1959 1960 static const __itt_id __itt_null = {0, 0, 0}; 1961 1962 /** 1963 * @ingroup ids 1964 * @brief A convenience function is provided to create an ID without domain 1965 * control. 1966 * @brief This is a convenience function to initialize an __itt_id structure. 1967 * This function does not affect the collector runtime in any way. After you 1968 * make the ID with this function, you still must create it with the 1969 * __itt_id_create function before using the ID to identify a named entity. 1970 * @param[in] addr The address of object; high QWORD of the ID value. 1971 * @param[in] extra The extra data to unique identify object; low QWORD of the 1972 * ID value. 1973 */ 1974 1975 ITT_INLINE __itt_id ITTAPI __itt_id_make(void *addr, unsigned long long extra) 1976 ITT_INLINE_ATTRIBUTE; 1977 ITT_INLINE __itt_id ITTAPI __itt_id_make(void *addr, unsigned long long extra) { 1978 __itt_id id = __itt_null; 1979 id.d1 = (unsigned long long)((uintptr_t)addr); 1980 id.d2 = (unsigned long long)extra; 1981 id.d3 = (unsigned long long)0; /* Reserved. Must be zero */ 1982 return id; 1983 } 1984 1985 /** 1986 * @ingroup ids 1987 * @brief Create an instance of identifier. 1988 * This establishes the beginning of the lifetime of an instance of 1989 * the given ID in the trace. Once this lifetime starts, the ID 1990 * can be used to tag named entity instances in calls such as 1991 * __itt_task_begin, and to specify relationships among 1992 * identified named entity instances, using the \ref relations APIs. 1993 * Instance IDs are not domain specific! 1994 * @param[in] domain The domain controlling the execution of this call. 1995 * @param[in] id The ID to create. 1996 */ 1997 void ITTAPI __itt_id_create(const __itt_domain *domain, __itt_id id); 1998 1999 /** @cond exclude_from_documentation */ 2000 #ifndef INTEL_NO_MACRO_BODY 2001 #ifndef INTEL_NO_ITTNOTIFY_API 2002 ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id)) 2003 #define __itt_id_create(d, x) ITTNOTIFY_VOID_D1(id_create, d, x) 2004 #define __itt_id_create_ptr ITTNOTIFY_NAME(id_create) 2005 #else /* INTEL_NO_ITTNOTIFY_API */ 2006 #define __itt_id_create(domain, id) 2007 #define __itt_id_create_ptr 0 2008 #endif /* INTEL_NO_ITTNOTIFY_API */ 2009 #else /* INTEL_NO_MACRO_BODY */ 2010 #define __itt_id_create_ptr 0 2011 #endif /* INTEL_NO_MACRO_BODY */ 2012 /** @endcond */ 2013 2014 /** 2015 * @ingroup ids 2016 * @brief Destroy an instance of identifier. 2017 * This ends the lifetime of the current instance of the given ID value in the 2018 * trace. Any relationships that are established after this lifetime ends are 2019 * invalid. This call must be performed before the given ID value can be reused 2020 * for a different named entity instance. 2021 * @param[in] domain The domain controlling the execution of this call. 2022 * @param[in] id The ID to destroy. 2023 */ 2024 void ITTAPI __itt_id_destroy(const __itt_domain *domain, __itt_id id); 2025 2026 /** @cond exclude_from_documentation */ 2027 #ifndef INTEL_NO_MACRO_BODY 2028 #ifndef INTEL_NO_ITTNOTIFY_API 2029 ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id)) 2030 #define __itt_id_destroy(d, x) ITTNOTIFY_VOID_D1(id_destroy, d, x) 2031 #define __itt_id_destroy_ptr ITTNOTIFY_NAME(id_destroy) 2032 #else /* INTEL_NO_ITTNOTIFY_API */ 2033 #define __itt_id_destroy(domain, id) 2034 #define __itt_id_destroy_ptr 0 2035 #endif /* INTEL_NO_ITTNOTIFY_API */ 2036 #else /* INTEL_NO_MACRO_BODY */ 2037 #define __itt_id_destroy_ptr 0 2038 #endif /* INTEL_NO_MACRO_BODY */ 2039 /** @endcond */ 2040 /** @} ids group */ 2041 2042 /** 2043 * @defgroup handless String Handles 2044 * @ingroup public 2045 * String Handles group 2046 * @{ 2047 */ 2048 2049 /** @cond exclude_from_documentation */ 2050 #pragma pack(push, 8) 2051 2052 typedef struct ___itt_string_handle { 2053 const char *strA; /*!< Copy of original string in ASCII. */ 2054 #if defined(UNICODE) || defined(_UNICODE) 2055 const wchar_t *strW; /*!< Copy of original string in UNICODE. */ 2056 #else /* UNICODE || _UNICODE */ 2057 void *strW; 2058 #endif /* UNICODE || _UNICODE */ 2059 int extra1; /*!< Reserved. Must be zero */ 2060 void *extra2; /*!< Reserved. Must be zero */ 2061 struct ___itt_string_handle *next; 2062 } __itt_string_handle; 2063 2064 #pragma pack(pop) 2065 /** @endcond */ 2066 2067 /** 2068 * @ingroup handles 2069 * @brief Create a string handle. 2070 * Create and return handle value that can be associated with a string. 2071 * Consecutive calls to __itt_string_handle_create with the same name 2072 * return the same value. Because the set of string handles is expected to 2073 * remain static during the application's execution time, there is no mechanism 2074 * to destroy a string handle. Any string handle can be accessed by any thread 2075 * in the process, regardless of which thread created the string handle. This 2076 * call is thread-safe. 2077 * @param[in] name The input string 2078 */ 2079 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2080 __itt_string_handle *ITTAPI __itt_string_handle_createA(const char *name); 2081 __itt_string_handle *ITTAPI __itt_string_handle_createW(const wchar_t *name); 2082 #if defined(UNICODE) || defined(_UNICODE) 2083 #define __itt_string_handle_create __itt_string_handle_createW 2084 #define __itt_string_handle_create_ptr __itt_string_handle_createW_ptr 2085 #else /* UNICODE */ 2086 #define __itt_string_handle_create __itt_string_handle_createA 2087 #define __itt_string_handle_create_ptr __itt_string_handle_createA_ptr 2088 #endif /* UNICODE */ 2089 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2090 __itt_string_handle *ITTAPI __itt_string_handle_create(const char *name); 2091 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2092 2093 /** @cond exclude_from_documentation */ 2094 #ifndef INTEL_NO_MACRO_BODY 2095 #ifndef INTEL_NO_ITTNOTIFY_API 2096 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2097 ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createA, 2098 (const char *name)) 2099 ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createW, 2100 (const wchar_t *name)) 2101 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2102 ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_create, 2103 (const char *name)) 2104 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2105 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2106 #define __itt_string_handle_createA ITTNOTIFY_DATA(string_handle_createA) 2107 #define __itt_string_handle_createA_ptr ITTNOTIFY_NAME(string_handle_createA) 2108 #define __itt_string_handle_createW ITTNOTIFY_DATA(string_handle_createW) 2109 #define __itt_string_handle_createW_ptr ITTNOTIFY_NAME(string_handle_createW) 2110 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2111 #define __itt_string_handle_create ITTNOTIFY_DATA(string_handle_create) 2112 #define __itt_string_handle_create_ptr ITTNOTIFY_NAME(string_handle_create) 2113 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2114 #else /* INTEL_NO_ITTNOTIFY_API */ 2115 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2116 #define __itt_string_handle_createA(name) (__itt_string_handle *)0 2117 #define __itt_string_handle_createA_ptr 0 2118 #define __itt_string_handle_createW(name) (__itt_string_handle *)0 2119 #define __itt_string_handle_createW_ptr 0 2120 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2121 #define __itt_string_handle_create(name) (__itt_string_handle *)0 2122 #define __itt_string_handle_create_ptr 0 2123 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2124 #endif /* INTEL_NO_ITTNOTIFY_API */ 2125 #else /* INTEL_NO_MACRO_BODY */ 2126 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2127 #define __itt_string_handle_createA_ptr 0 2128 #define __itt_string_handle_createW_ptr 0 2129 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2130 #define __itt_string_handle_create_ptr 0 2131 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2132 #endif /* INTEL_NO_MACRO_BODY */ 2133 /** @endcond */ 2134 /** @} handles group */ 2135 2136 /** @cond exclude_from_documentation */ 2137 typedef unsigned long long __itt_timestamp; 2138 /** @endcond */ 2139 2140 #define __itt_timestamp_none ((__itt_timestamp)-1LL) 2141 2142 /** @cond exclude_from_gpa_documentation */ 2143 2144 /** 2145 * @ingroup timestamps 2146 * @brief Return timestamp corresponding to the current moment. 2147 * This returns the timestamp in the format that is the most relevant for the 2148 * current host or platform (RDTSC, QPC, and others). You can use the "<" 2149 * operator to compare __itt_timestamp values. 2150 */ 2151 __itt_timestamp ITTAPI __itt_get_timestamp(void); 2152 2153 /** @cond exclude_from_documentation */ 2154 #ifndef INTEL_NO_MACRO_BODY 2155 #ifndef INTEL_NO_ITTNOTIFY_API 2156 ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void)) 2157 #define __itt_get_timestamp ITTNOTIFY_DATA(get_timestamp) 2158 #define __itt_get_timestamp_ptr ITTNOTIFY_NAME(get_timestamp) 2159 #else /* INTEL_NO_ITTNOTIFY_API */ 2160 #define __itt_get_timestamp() 2161 #define __itt_get_timestamp_ptr 0 2162 #endif /* INTEL_NO_ITTNOTIFY_API */ 2163 #else /* INTEL_NO_MACRO_BODY */ 2164 #define __itt_get_timestamp_ptr 0 2165 #endif /* INTEL_NO_MACRO_BODY */ 2166 /** @endcond */ 2167 /** @} timestamps */ 2168 /** @endcond */ 2169 2170 /** @cond exclude_from_gpa_documentation */ 2171 2172 /** 2173 * @defgroup regions Regions 2174 * @ingroup public 2175 * Regions group 2176 * @{ 2177 */ 2178 /** 2179 * @ingroup regions 2180 * @brief Begin of region instance. 2181 * Successive calls to __itt_region_begin with the same ID are ignored 2182 * until a call to __itt_region_end with the same ID 2183 * @param[in] domain The domain for this region instance 2184 * @param[in] id The instance ID for this region instance. Must not be 2185 * __itt_null 2186 * @param[in] parentid The instance ID for the parent of this region instance, 2187 * or __itt_null 2188 * @param[in] name The name of this region 2189 */ 2190 void ITTAPI __itt_region_begin(const __itt_domain *domain, __itt_id id, 2191 __itt_id parentid, __itt_string_handle *name); 2192 2193 /** 2194 * @ingroup regions 2195 * @brief End of region instance. 2196 * The first call to __itt_region_end with a given ID ends the 2197 * region. Successive calls with the same ID are ignored, as are 2198 * calls that do not have a matching __itt_region_begin call. 2199 * @param[in] domain The domain for this region instance 2200 * @param[in] id The instance ID for this region instance 2201 */ 2202 void ITTAPI __itt_region_end(const __itt_domain *domain, __itt_id id); 2203 2204 /** @cond exclude_from_documentation */ 2205 #ifndef INTEL_NO_MACRO_BODY 2206 #ifndef INTEL_NO_ITTNOTIFY_API 2207 ITT_STUBV(ITTAPI, void, region_begin, 2208 (const __itt_domain *domain, __itt_id id, __itt_id parentid, 2209 __itt_string_handle *name)) 2210 ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id)) 2211 #define __itt_region_begin(d, x, y, z) \ 2212 ITTNOTIFY_VOID_D3(region_begin, d, x, y, z) 2213 #define __itt_region_begin_ptr ITTNOTIFY_NAME(region_begin) 2214 #define __itt_region_end(d, x) ITTNOTIFY_VOID_D1(region_end, d, x) 2215 #define __itt_region_end_ptr ITTNOTIFY_NAME(region_end) 2216 #else /* INTEL_NO_ITTNOTIFY_API */ 2217 #define __itt_region_begin(d, x, y, z) 2218 #define __itt_region_begin_ptr 0 2219 #define __itt_region_end(d, x) 2220 #define __itt_region_end_ptr 0 2221 #endif /* INTEL_NO_ITTNOTIFY_API */ 2222 #else /* INTEL_NO_MACRO_BODY */ 2223 #define __itt_region_begin_ptr 0 2224 #define __itt_region_end_ptr 0 2225 #endif /* INTEL_NO_MACRO_BODY */ 2226 /** @endcond */ 2227 /** @} regions group */ 2228 2229 /** 2230 * @defgroup frames Frames 2231 * @ingroup public 2232 * Frames are similar to regions, but are intended to be easier to use and to 2233 * implement. In particular: 2234 * - Frames always represent periods of elapsed time 2235 * - By default, frames have no nesting relationships 2236 * @{ 2237 */ 2238 2239 /** 2240 * @ingroup frames 2241 * @brief Begin a frame instance. 2242 * Successive calls to __itt_frame_begin with the 2243 * same ID are ignored until a call to __itt_frame_end with the same ID. 2244 * @param[in] domain The domain for this frame instance 2245 * @param[in] id The instance ID for this frame instance or NULL 2246 */ 2247 void ITTAPI __itt_frame_begin_v3(const __itt_domain *domain, __itt_id *id); 2248 2249 /** 2250 * @ingroup frames 2251 * @brief End a frame instance. 2252 * The first call to __itt_frame_end with a given ID 2253 * ends the frame. Successive calls with the same ID are ignored, as are 2254 * calls that do not have a matching __itt_frame_begin call. 2255 * @param[in] domain The domain for this frame instance 2256 * @param[in] id The instance ID for this frame instance or NULL for current 2257 */ 2258 void ITTAPI __itt_frame_end_v3(const __itt_domain *domain, __itt_id *id); 2259 2260 /** 2261 * @ingroup frames 2262 * @brief Submits a frame instance. 2263 * Successive calls to __itt_frame_begin or __itt_frame_submit with the 2264 * same ID are ignored until a call to __itt_frame_end or __itt_frame_submit 2265 * with the same ID. 2266 * Passing special __itt_timestamp_none value as "end" argument means 2267 * take the current timestamp as the end timestamp. 2268 * @param[in] domain The domain for this frame instance 2269 * @param[in] id The instance ID for this frame instance or NULL 2270 * @param[in] begin Timestamp of the beginning of the frame 2271 * @param[in] end Timestamp of the end of the frame 2272 */ 2273 void ITTAPI __itt_frame_submit_v3(const __itt_domain *domain, __itt_id *id, 2274 __itt_timestamp begin, __itt_timestamp end); 2275 2276 /** @cond exclude_from_documentation */ 2277 #ifndef INTEL_NO_MACRO_BODY 2278 #ifndef INTEL_NO_ITTNOTIFY_API 2279 ITT_STUBV(ITTAPI, void, frame_begin_v3, 2280 (const __itt_domain *domain, __itt_id *id)) 2281 ITT_STUBV(ITTAPI, void, frame_end_v3, 2282 (const __itt_domain *domain, __itt_id *id)) 2283 ITT_STUBV(ITTAPI, void, frame_submit_v3, 2284 (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin, 2285 __itt_timestamp end)) 2286 #define __itt_frame_begin_v3(d, x) ITTNOTIFY_VOID_D1(frame_begin_v3, d, x) 2287 #define __itt_frame_begin_v3_ptr ITTNOTIFY_NAME(frame_begin_v3) 2288 #define __itt_frame_end_v3(d, x) ITTNOTIFY_VOID_D1(frame_end_v3, d, x) 2289 #define __itt_frame_end_v3_ptr ITTNOTIFY_NAME(frame_end_v3) 2290 #define __itt_frame_submit_v3(d, x, b, e) \ 2291 ITTNOTIFY_VOID_D3(frame_submit_v3, d, x, b, e) 2292 #define __itt_frame_submit_v3_ptr ITTNOTIFY_NAME(frame_submit_v3) 2293 #else /* INTEL_NO_ITTNOTIFY_API */ 2294 #define __itt_frame_begin_v3(domain, id) 2295 #define __itt_frame_begin_v3_ptr 0 2296 #define __itt_frame_end_v3(domain, id) 2297 #define __itt_frame_end_v3_ptr 0 2298 #define __itt_frame_submit_v3(domain, id, begin, end) 2299 #define __itt_frame_submit_v3_ptr 0 2300 #endif /* INTEL_NO_ITTNOTIFY_API */ 2301 #else /* INTEL_NO_MACRO_BODY */ 2302 #define __itt_frame_begin_v3_ptr 0 2303 #define __itt_frame_end_v3_ptr 0 2304 #define __itt_frame_submit_v3_ptr 0 2305 #endif /* INTEL_NO_MACRO_BODY */ 2306 /** @endcond */ 2307 /** @} frames group */ 2308 /** @endcond */ 2309 2310 /** 2311 * @defgroup taskgroup Task Group 2312 * @ingroup public 2313 * Task Group 2314 * @{ 2315 */ 2316 /** 2317 * @ingroup task_groups 2318 * @brief Denotes a task_group instance. 2319 * Successive calls to __itt_task_group with the same ID are ignored. 2320 * @param[in] domain The domain for this task_group instance 2321 * @param[in] id The instance ID for this task_group instance. Must not be 2322 * __itt_null. 2323 * @param[in] parentid The instance ID for the parent of this task_group 2324 * instance, or __itt_null. 2325 * @param[in] name The name of this task_group 2326 */ 2327 void ITTAPI __itt_task_group(const __itt_domain *domain, __itt_id id, 2328 __itt_id parentid, __itt_string_handle *name); 2329 2330 /** @cond exclude_from_documentation */ 2331 #ifndef INTEL_NO_MACRO_BODY 2332 #ifndef INTEL_NO_ITTNOTIFY_API 2333 ITT_STUBV(ITTAPI, void, task_group, 2334 (const __itt_domain *domain, __itt_id id, __itt_id parentid, 2335 __itt_string_handle *name)) 2336 #define __itt_task_group(d, x, y, z) ITTNOTIFY_VOID_D3(task_group, d, x, y, z) 2337 #define __itt_task_group_ptr ITTNOTIFY_NAME(task_group) 2338 #else /* INTEL_NO_ITTNOTIFY_API */ 2339 #define __itt_task_group(d, x, y, z) 2340 #define __itt_task_group_ptr 0 2341 #endif /* INTEL_NO_ITTNOTIFY_API */ 2342 #else /* INTEL_NO_MACRO_BODY */ 2343 #define __itt_task_group_ptr 0 2344 #endif /* INTEL_NO_MACRO_BODY */ 2345 /** @endcond */ 2346 /** @} taskgroup group */ 2347 2348 /** 2349 * @defgroup tasks Tasks 2350 * @ingroup public 2351 * A task instance represents a piece of work performed by a particular 2352 * thread for a period of time. A call to __itt_task_begin creates a 2353 * task instance. This becomes the current instance for that task on that 2354 * thread. A following call to __itt_task_end on the same thread ends the 2355 * instance. There may be multiple simultaneous instances of tasks with the 2356 * same name on different threads. If an ID is specified, the task instance 2357 * receives that ID. Nested tasks are allowed. 2358 * 2359 * Note: The task is defined by the bracketing of __itt_task_begin and 2360 * __itt_task_end on the same thread. If some scheduling mechanism causes 2361 * task switching (the thread executes a different user task) or task 2362 * switching (the user task switches to a different thread) then this breaks 2363 * the notion of current instance. Additional API calls are required to 2364 * deal with that possibility. 2365 * @{ 2366 */ 2367 2368 /** 2369 * @ingroup tasks 2370 * @brief Begin a task instance. 2371 * @param[in] domain The domain for this task 2372 * @param[in] taskid The instance ID for this task instance, or __itt_null 2373 * @param[in] parentid The parent instance to which this task instance belongs, 2374 * or __itt_null 2375 * @param[in] name The name of this task 2376 */ 2377 void ITTAPI __itt_task_begin(const __itt_domain *domain, __itt_id taskid, 2378 __itt_id parentid, __itt_string_handle *name); 2379 2380 /** 2381 * @ingroup tasks 2382 * @brief Begin a task instance. 2383 * @param[in] domain The domain for this task 2384 * @param[in] taskid The identifier for this task instance (may be 0) 2385 * @param[in] parentid The parent of this task (may be 0) 2386 * @param[in] fn The pointer to the function you are tracing 2387 */ 2388 void ITTAPI __itt_task_begin_fn(const __itt_domain *domain, __itt_id taskid, 2389 __itt_id parentid, void *fn); 2390 2391 /** 2392 * @ingroup tasks 2393 * @brief End the current task instance. 2394 * @param[in] domain The domain for this task 2395 */ 2396 void ITTAPI __itt_task_end(const __itt_domain *domain); 2397 2398 /** 2399 * @ingroup tasks 2400 * @brief Begin an overlapped task instance. 2401 * @param[in] domain The domain for this task. 2402 * @param[in] taskid The identifier for this task instance, *cannot* be 2403 * __itt_null. 2404 * @param[in] parentid The parent of this task, or __itt_null. 2405 * @param[in] name The name of this task. 2406 */ 2407 void ITTAPI __itt_task_begin_overlapped(const __itt_domain *domain, 2408 __itt_id taskid, __itt_id parentid, 2409 __itt_string_handle *name); 2410 2411 /** 2412 * @ingroup tasks 2413 * @brief End an overlapped task instance. 2414 * @param[in] domain The domain for this task 2415 * @param[in] taskid Explicit ID of finished task 2416 */ 2417 void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain, 2418 __itt_id taskid); 2419 2420 /** @cond exclude_from_documentation */ 2421 #ifndef INTEL_NO_MACRO_BODY 2422 #ifndef INTEL_NO_ITTNOTIFY_API 2423 ITT_STUBV(ITTAPI, void, task_begin, 2424 (const __itt_domain *domain, __itt_id id, __itt_id parentid, 2425 __itt_string_handle *name)) 2426 ITT_STUBV(ITTAPI, void, task_begin_fn, 2427 (const __itt_domain *domain, __itt_id id, __itt_id parentid, 2428 void *fn)) 2429 ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain)) 2430 ITT_STUBV(ITTAPI, void, task_begin_overlapped, 2431 (const __itt_domain *domain, __itt_id taskid, __itt_id parentid, 2432 __itt_string_handle *name)) 2433 ITT_STUBV(ITTAPI, void, task_end_overlapped, 2434 (const __itt_domain *domain, __itt_id taskid)) 2435 #define __itt_task_begin(d, x, y, z) ITTNOTIFY_VOID_D3(task_begin, d, x, y, z) 2436 #define __itt_task_begin_ptr ITTNOTIFY_NAME(task_begin) 2437 #define __itt_task_begin_fn(d, x, y, z) \ 2438 ITTNOTIFY_VOID_D3(task_begin_fn, d, x, y, z) 2439 #define __itt_task_begin_fn_ptr ITTNOTIFY_NAME(task_begin_fn) 2440 #define __itt_task_end(d) ITTNOTIFY_VOID_D0(task_end, d) 2441 #define __itt_task_end_ptr ITTNOTIFY_NAME(task_end) 2442 #define __itt_task_begin_overlapped(d, x, y, z) \ 2443 ITTNOTIFY_VOID_D3(task_begin_overlapped, d, x, y, z) 2444 #define __itt_task_begin_overlapped_ptr ITTNOTIFY_NAME(task_begin_overlapped) 2445 #define __itt_task_end_overlapped(d, x) \ 2446 ITTNOTIFY_VOID_D1(task_end_overlapped, d, x) 2447 #define __itt_task_end_overlapped_ptr ITTNOTIFY_NAME(task_end_overlapped) 2448 #else /* INTEL_NO_ITTNOTIFY_API */ 2449 #define __itt_task_begin(domain, id, parentid, name) 2450 #define __itt_task_begin_ptr 0 2451 #define __itt_task_begin_fn(domain, id, parentid, fn) 2452 #define __itt_task_begin_fn_ptr 0 2453 #define __itt_task_end(domain) 2454 #define __itt_task_end_ptr 0 2455 #define __itt_task_begin_overlapped(domain, taskid, parentid, name) 2456 #define __itt_task_begin_overlapped_ptr 0 2457 #define __itt_task_end_overlapped(domain, taskid) 2458 #define __itt_task_end_overlapped_ptr 0 2459 #endif /* INTEL_NO_ITTNOTIFY_API */ 2460 #else /* INTEL_NO_MACRO_BODY */ 2461 #define __itt_task_begin_ptr 0 2462 #define __itt_task_begin_fn_ptr 0 2463 #define __itt_task_end_ptr 0 2464 #define __itt_task_begin_overlapped_ptr 0 2465 #define __itt_task_end_overlapped_ptr 0 2466 #endif /* INTEL_NO_MACRO_BODY */ 2467 /** @endcond */ 2468 /** @} tasks group */ 2469 2470 /** 2471 * @defgroup markers Markers 2472 * Markers represent a single discreet event in time. Markers have a scope, 2473 * described by an enumerated type __itt_scope. Markers are created by 2474 * the API call __itt_marker. A marker instance can be given an ID for use in 2475 * adding metadata. 2476 * @{ 2477 */ 2478 2479 /** 2480 * @brief Describes the scope of an event object in the trace. 2481 */ 2482 typedef enum { 2483 __itt_scope_unknown = 0, 2484 __itt_scope_global, 2485 __itt_scope_track_group, 2486 __itt_scope_track, 2487 __itt_scope_task, 2488 __itt_scope_marker 2489 } __itt_scope; 2490 2491 /** @cond exclude_from_documentation */ 2492 #define __itt_marker_scope_unknown __itt_scope_unknown 2493 #define __itt_marker_scope_global __itt_scope_global 2494 #define __itt_marker_scope_process __itt_scope_track_group 2495 #define __itt_marker_scope_thread __itt_scope_track 2496 #define __itt_marker_scope_task __itt_scope_task 2497 /** @endcond */ 2498 2499 /** 2500 * @ingroup markers 2501 * @brief Create a marker instance 2502 * @param[in] domain The domain for this marker 2503 * @param[in] id The instance ID for this marker or __itt_null 2504 * @param[in] name The name for this marker 2505 * @param[in] scope The scope for this marker 2506 */ 2507 void ITTAPI __itt_marker(const __itt_domain *domain, __itt_id id, 2508 __itt_string_handle *name, __itt_scope scope); 2509 2510 /** @cond exclude_from_documentation */ 2511 #ifndef INTEL_NO_MACRO_BODY 2512 #ifndef INTEL_NO_ITTNOTIFY_API 2513 ITT_STUBV(ITTAPI, void, marker, 2514 (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, 2515 __itt_scope scope)) 2516 #define __itt_marker(d, x, y, z) ITTNOTIFY_VOID_D3(marker, d, x, y, z) 2517 #define __itt_marker_ptr ITTNOTIFY_NAME(marker) 2518 #else /* INTEL_NO_ITTNOTIFY_API */ 2519 #define __itt_marker(domain, id, name, scope) 2520 #define __itt_marker_ptr 0 2521 #endif /* INTEL_NO_ITTNOTIFY_API */ 2522 #else /* INTEL_NO_MACRO_BODY */ 2523 #define __itt_marker_ptr 0 2524 #endif /* INTEL_NO_MACRO_BODY */ 2525 /** @endcond */ 2526 /** @} markers group */ 2527 2528 /** 2529 * @defgroup metadata Metadata 2530 * The metadata API is used to attach extra information to named 2531 * entities. Metadata can be attached to an identified named entity by ID, 2532 * or to the current entity (which is always a task). 2533 * 2534 * Conceptually metadata has a type (what kind of metadata), a key (the 2535 * name of the metadata), and a value (the actual data). The encoding of 2536 * the value depends on the type of the metadata. 2537 * 2538 * The type of metadata is specified by an enumerated type __itt_metdata_type. 2539 * @{ 2540 */ 2541 2542 /** 2543 * @ingroup parameters 2544 * @brief describes the type of metadata 2545 */ 2546 typedef enum { 2547 __itt_metadata_unknown = 0, 2548 __itt_metadata_u64, /**< Unsigned 64-bit integer */ 2549 __itt_metadata_s64, /**< Signed 64-bit integer */ 2550 __itt_metadata_u32, /**< Unsigned 32-bit integer */ 2551 __itt_metadata_s32, /**< Signed 32-bit integer */ 2552 __itt_metadata_u16, /**< Unsigned 16-bit integer */ 2553 __itt_metadata_s16, /**< Signed 16-bit integer */ 2554 __itt_metadata_float, /**< Signed 32-bit floating-point */ 2555 __itt_metadata_double /**< SIgned 64-bit floating-point */ 2556 } __itt_metadata_type; 2557 2558 /** 2559 * @ingroup parameters 2560 * @brief Add metadata to an instance of a named entity. 2561 * @param[in] domain The domain controlling the call 2562 * @param[in] id The identifier of the instance to which the metadata is to be 2563 * added, or __itt_null to add to the current task 2564 * @param[in] key The name of the metadata 2565 * @param[in] type The type of the metadata 2566 * @param[in] count The number of elements of the given type. If count == 0, no 2567 * metadata will be added. 2568 * @param[in] data The metadata itself 2569 */ 2570 void ITTAPI __itt_metadata_add(const __itt_domain *domain, __itt_id id, 2571 __itt_string_handle *key, 2572 __itt_metadata_type type, size_t count, 2573 void *data); 2574 2575 /** @cond exclude_from_documentation */ 2576 #ifndef INTEL_NO_MACRO_BODY 2577 #ifndef INTEL_NO_ITTNOTIFY_API 2578 ITT_STUBV(ITTAPI, void, metadata_add, 2579 (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, 2580 __itt_metadata_type type, size_t count, void *data)) 2581 #define __itt_metadata_add(d, x, y, z, a, b) \ 2582 ITTNOTIFY_VOID_D5(metadata_add, d, x, y, z, a, b) 2583 #define __itt_metadata_add_ptr ITTNOTIFY_NAME(metadata_add) 2584 #else /* INTEL_NO_ITTNOTIFY_API */ 2585 #define __itt_metadata_add(d, x, y, z, a, b) 2586 #define __itt_metadata_add_ptr 0 2587 #endif /* INTEL_NO_ITTNOTIFY_API */ 2588 #else /* INTEL_NO_MACRO_BODY */ 2589 #define __itt_metadata_add_ptr 0 2590 #endif /* INTEL_NO_MACRO_BODY */ 2591 /** @endcond */ 2592 2593 /** 2594 * @ingroup parameters 2595 * @brief Add string metadata to an instance of a named entity. 2596 * @param[in] domain The domain controlling the call 2597 * @param[in] id The identifier of the instance to which the metadata is to be 2598 * added, or __itt_null to add to the current task 2599 * @param[in] key The name of the metadata 2600 * @param[in] data The metadata itself 2601 * @param[in] length The number of characters in the string, or -1 if the length 2602 * is unknown but the string is null-terminated 2603 */ 2604 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2605 void ITTAPI __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id, 2606 __itt_string_handle *key, const char *data, 2607 size_t length); 2608 void ITTAPI __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id, 2609 __itt_string_handle *key, 2610 const wchar_t *data, size_t length); 2611 #if defined(UNICODE) || defined(_UNICODE) 2612 #define __itt_metadata_str_add __itt_metadata_str_addW 2613 #define __itt_metadata_str_add_ptr __itt_metadata_str_addW_ptr 2614 #else /* UNICODE */ 2615 #define __itt_metadata_str_add __itt_metadata_str_addA 2616 #define __itt_metadata_str_add_ptr __itt_metadata_str_addA_ptr 2617 #endif /* UNICODE */ 2618 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2619 void ITTAPI __itt_metadata_str_add(const __itt_domain *domain, __itt_id id, 2620 __itt_string_handle *key, const char *data, 2621 size_t length); 2622 #endif 2623 2624 /** @cond exclude_from_documentation */ 2625 #ifndef INTEL_NO_MACRO_BODY 2626 #ifndef INTEL_NO_ITTNOTIFY_API 2627 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2628 ITT_STUBV(ITTAPI, void, metadata_str_addA, 2629 (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, 2630 const char *data, size_t length)) 2631 ITT_STUBV(ITTAPI, void, metadata_str_addW, 2632 (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, 2633 const wchar_t *data, size_t length)) 2634 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2635 ITT_STUBV(ITTAPI, void, metadata_str_add, 2636 (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, 2637 const char *data, size_t length)) 2638 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2639 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2640 #define __itt_metadata_str_addA(d, x, y, z, a) \ 2641 ITTNOTIFY_VOID_D4(metadata_str_addA, d, x, y, z, a) 2642 #define __itt_metadata_str_addA_ptr ITTNOTIFY_NAME(metadata_str_addA) 2643 #define __itt_metadata_str_addW(d, x, y, z, a) \ 2644 ITTNOTIFY_VOID_D4(metadata_str_addW, d, x, y, z, a) 2645 #define __itt_metadata_str_addW_ptr ITTNOTIFY_NAME(metadata_str_addW) 2646 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2647 #define __itt_metadata_str_add(d, x, y, z, a) \ 2648 ITTNOTIFY_VOID_D4(metadata_str_add, d, x, y, z, a) 2649 #define __itt_metadata_str_add_ptr ITTNOTIFY_NAME(metadata_str_add) 2650 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2651 #else /* INTEL_NO_ITTNOTIFY_API */ 2652 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2653 #define __itt_metadata_str_addA(d, x, y, z, a) 2654 #define __itt_metadata_str_addA_ptr 0 2655 #define __itt_metadata_str_addW(d, x, y, z, a) 2656 #define __itt_metadata_str_addW_ptr 0 2657 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2658 #define __itt_metadata_str_add(d, x, y, z, a) 2659 #define __itt_metadata_str_add_ptr 0 2660 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2661 #endif /* INTEL_NO_ITTNOTIFY_API */ 2662 #else /* INTEL_NO_MACRO_BODY */ 2663 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2664 #define __itt_metadata_str_addA_ptr 0 2665 #define __itt_metadata_str_addW_ptr 0 2666 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2667 #define __itt_metadata_str_add_ptr 0 2668 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2669 #endif /* INTEL_NO_MACRO_BODY */ 2670 /** @endcond */ 2671 2672 /** 2673 * @ingroup parameters 2674 * @brief Add metadata to an instance of a named entity. 2675 * @param[in] domain The domain controlling the call 2676 * @param[in] scope The scope of the instance to which the metadata is to be 2677 added 2678 2679 * @param[in] id The identifier of the instance to which the metadata is to be 2680 added, or __itt_null to add to the current task 2681 2682 * @param[in] key The name of the metadata 2683 * @param[in] type The type of the metadata 2684 * @param[in] count The number of elements of the given type. If count == 0, no 2685 metadata will be added. 2686 * @param[in] data The metadata itself 2687 */ 2688 void ITTAPI __itt_metadata_add_with_scope(const __itt_domain *domain, 2689 __itt_scope scope, 2690 __itt_string_handle *key, 2691 __itt_metadata_type type, 2692 size_t count, void *data); 2693 2694 /** @cond exclude_from_documentation */ 2695 #ifndef INTEL_NO_MACRO_BODY 2696 #ifndef INTEL_NO_ITTNOTIFY_API 2697 ITT_STUBV(ITTAPI, void, metadata_add_with_scope, 2698 (const __itt_domain *domain, __itt_scope scope, 2699 __itt_string_handle *key, __itt_metadata_type type, size_t count, 2700 void *data)) 2701 #define __itt_metadata_add_with_scope(d, x, y, z, a, b) \ 2702 ITTNOTIFY_VOID_D5(metadata_add_with_scope, d, x, y, z, a, b) 2703 #define __itt_metadata_add_with_scope_ptr \ 2704 ITTNOTIFY_NAME(metadata_add_with_scope) 2705 #else /* INTEL_NO_ITTNOTIFY_API */ 2706 #define __itt_metadata_add_with_scope(d, x, y, z, a, b) 2707 #define __itt_metadata_add_with_scope_ptr 0 2708 #endif /* INTEL_NO_ITTNOTIFY_API */ 2709 #else /* INTEL_NO_MACRO_BODY */ 2710 #define __itt_metadata_add_with_scope_ptr 0 2711 #endif /* INTEL_NO_MACRO_BODY */ 2712 /** @endcond */ 2713 2714 /** 2715 * @ingroup parameters 2716 * @brief Add string metadata to an instance of a named entity. 2717 * @param[in] domain The domain controlling the call 2718 * @param[in] scope The scope of the instance to which the metadata is to be 2719 added 2720 2721 * @param[in] id The identifier of the instance to which the metadata is to be 2722 added, or __itt_null to add to the current task 2723 2724 * @param[in] key The name of the metadata 2725 * @param[in] data The metadata itself 2726 * @param[in] length The number of characters in the string, or -1 if the length 2727 is unknown but the string is null-terminated 2728 */ 2729 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2730 void ITTAPI __itt_metadata_str_add_with_scopeA(const __itt_domain *domain, 2731 __itt_scope scope, 2732 __itt_string_handle *key, 2733 const char *data, size_t length); 2734 void ITTAPI __itt_metadata_str_add_with_scopeW(const __itt_domain *domain, 2735 __itt_scope scope, 2736 __itt_string_handle *key, 2737 const wchar_t *data, 2738 size_t length); 2739 #if defined(UNICODE) || defined(_UNICODE) 2740 #define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeW 2741 #define __itt_metadata_str_add_with_scope_ptr \ 2742 __itt_metadata_str_add_with_scopeW_ptr 2743 #else /* UNICODE */ 2744 #define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeA 2745 #define __itt_metadata_str_add_with_scope_ptr \ 2746 __itt_metadata_str_add_with_scopeA_ptr 2747 #endif /* UNICODE */ 2748 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2749 void ITTAPI __itt_metadata_str_add_with_scope(const __itt_domain *domain, 2750 __itt_scope scope, 2751 __itt_string_handle *key, 2752 const char *data, size_t length); 2753 #endif 2754 2755 /** @cond exclude_from_documentation */ 2756 #ifndef INTEL_NO_MACRO_BODY 2757 #ifndef INTEL_NO_ITTNOTIFY_API 2758 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2759 ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA, 2760 (const __itt_domain *domain, __itt_scope scope, 2761 __itt_string_handle *key, const char *data, size_t length)) 2762 ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW, 2763 (const __itt_domain *domain, __itt_scope scope, 2764 __itt_string_handle *key, const wchar_t *data, size_t length)) 2765 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2766 ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope, 2767 (const __itt_domain *domain, __itt_scope scope, 2768 __itt_string_handle *key, const char *data, size_t length)) 2769 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2770 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2771 #define __itt_metadata_str_add_with_scopeA(d, x, y, z, a) \ 2772 ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeA, d, x, y, z, a) 2773 #define __itt_metadata_str_add_with_scopeA_ptr \ 2774 ITTNOTIFY_NAME(metadata_str_add_with_scopeA) 2775 #define __itt_metadata_str_add_with_scopeW(d, x, y, z, a) \ 2776 ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeW, d, x, y, z, a) 2777 #define __itt_metadata_str_add_with_scopeW_ptr \ 2778 ITTNOTIFY_NAME(metadata_str_add_with_scopeW) 2779 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2780 #define __itt_metadata_str_add_with_scope(d, x, y, z, a) \ 2781 ITTNOTIFY_VOID_D4(metadata_str_add_with_scope, d, x, y, z, a) 2782 #define __itt_metadata_str_add_with_scope_ptr \ 2783 ITTNOTIFY_NAME(metadata_str_add_with_scope) 2784 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2785 #else /* INTEL_NO_ITTNOTIFY_API */ 2786 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2787 #define __itt_metadata_str_add_with_scopeA(d, x, y, z, a) 2788 #define __itt_metadata_str_add_with_scopeA_ptr 0 2789 #define __itt_metadata_str_add_with_scopeW(d, x, y, z, a) 2790 #define __itt_metadata_str_add_with_scopeW_ptr 0 2791 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2792 #define __itt_metadata_str_add_with_scope(d, x, y, z, a) 2793 #define __itt_metadata_str_add_with_scope_ptr 0 2794 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2795 #endif /* INTEL_NO_ITTNOTIFY_API */ 2796 #else /* INTEL_NO_MACRO_BODY */ 2797 #if ITT_PLATFORM == ITT_PLATFORM_WIN 2798 #define __itt_metadata_str_add_with_scopeA_ptr 0 2799 #define __itt_metadata_str_add_with_scopeW_ptr 0 2800 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2801 #define __itt_metadata_str_add_with_scope_ptr 0 2802 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 2803 #endif /* INTEL_NO_MACRO_BODY */ 2804 /** @endcond */ 2805 2806 /** @} metadata group */ 2807 2808 /** 2809 * @defgroup relations Relations 2810 * Instances of named entities can be explicitly associated with other 2811 * instances using instance IDs and the relationship API calls. 2812 * 2813 * @{ 2814 */ 2815 2816 /** 2817 * @ingroup relations 2818 * @brief The kind of relation between two instances is specified by the 2819 * enumerated type __itt_relation. Relations between instances can be added with 2820 * an API call. The relation API uses instance IDs. Relations can be added 2821 * before or after the actual instances are created and persist independently of 2822 * the instances. This is the motivation for having different lifetimes for 2823 * instance IDs and the actual instances. 2824 */ 2825 typedef enum { 2826 __itt_relation_is_unknown = 0, 2827 __itt_relation_is_dependent_on, /**< "A is dependent on B" means that A cannot 2828 start until B completes */ 2829 __itt_relation_is_sibling_of, /**< "A is sibling of B" means that A and B were 2830 created as a group */ 2831 __itt_relation_is_parent_of, /**< "A is parent of B" means that A created B */ 2832 __itt_relation_is_continuation_of, /**< "A is continuation of B" means that A 2833 assumes the dependencies of B */ 2834 __itt_relation_is_child_of, /**< "A is child of B" means that A was created by 2835 B (inverse of is_parent_of) */ 2836 __itt_relation_is_continued_by, /**< "A is continued by B" means that B 2837 assumes the dependencies of A (inverse of 2838 is_continuation_of) */ 2839 __itt_relation_is_predecessor_to /**< "A is predecessor to B" means that B 2840 cannot start until A completes (inverse of 2841 is_dependent_on) */ 2842 } __itt_relation; 2843 2844 /** 2845 * @ingroup relations 2846 * @brief Add a relation to the current task instance. 2847 * The current task instance is the head of the relation. 2848 * @param[in] domain The domain controlling this call 2849 * @param[in] relation The kind of relation 2850 * @param[in] tail The ID for the tail of the relation 2851 */ 2852 void ITTAPI __itt_relation_add_to_current(const __itt_domain *domain, 2853 __itt_relation relation, 2854 __itt_id tail); 2855 2856 /** 2857 * @ingroup relations 2858 * @brief Add a relation between two instance identifiers. 2859 * @param[in] domain The domain controlling this call 2860 * @param[in] head The ID for the head of the relation 2861 * @param[in] relation The kind of relation 2862 * @param[in] tail The ID for the tail of the relation 2863 */ 2864 void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head, 2865 __itt_relation relation, __itt_id tail); 2866 2867 /** @cond exclude_from_documentation */ 2868 #ifndef INTEL_NO_MACRO_BODY 2869 #ifndef INTEL_NO_ITTNOTIFY_API 2870 ITT_STUBV(ITTAPI, void, relation_add_to_current, 2871 (const __itt_domain *domain, __itt_relation relation, __itt_id tail)) 2872 ITT_STUBV(ITTAPI, void, relation_add, 2873 (const __itt_domain *domain, __itt_id head, __itt_relation relation, 2874 __itt_id tail)) 2875 #define __itt_relation_add_to_current(d, x, y) \ 2876 ITTNOTIFY_VOID_D2(relation_add_to_current, d, x, y) 2877 #define __itt_relation_add_to_current_ptr \ 2878 ITTNOTIFY_NAME(relation_add_to_current) 2879 #define __itt_relation_add(d, x, y, z) \ 2880 ITTNOTIFY_VOID_D3(relation_add, d, x, y, z) 2881 #define __itt_relation_add_ptr ITTNOTIFY_NAME(relation_add) 2882 #else /* INTEL_NO_ITTNOTIFY_API */ 2883 #define __itt_relation_add_to_current(d, x, y) 2884 #define __itt_relation_add_to_current_ptr 0 2885 #define __itt_relation_add(d, x, y, z) 2886 #define __itt_relation_add_ptr 0 2887 #endif /* INTEL_NO_ITTNOTIFY_API */ 2888 #else /* INTEL_NO_MACRO_BODY */ 2889 #define __itt_relation_add_to_current_ptr 0 2890 #define __itt_relation_add_ptr 0 2891 #endif /* INTEL_NO_MACRO_BODY */ 2892 /** @endcond */ 2893 /** @} relations group */ 2894 2895 /** @cond exclude_from_documentation */ 2896 #pragma pack(push, 8) 2897 2898 typedef struct ___itt_clock_info { 2899 unsigned long long clock_freq; /*!< Clock domain frequency */ 2900 unsigned long long clock_base; /*!< Clock domain base timestamp */ 2901 } __itt_clock_info; 2902 2903 #pragma pack(pop) 2904 /** @endcond */ 2905 2906 /** @cond exclude_from_documentation */ 2907 typedef void(ITTAPI *__itt_get_clock_info_fn)(__itt_clock_info *clock_info, 2908 void *data); 2909 /** @endcond */ 2910 2911 /** @cond exclude_from_documentation */ 2912 #pragma pack(push, 8) 2913 2914 typedef struct ___itt_clock_domain { 2915 __itt_clock_info info; /*!< Most recent clock domain info */ 2916 __itt_get_clock_info_fn fn; /*!< Callback function pointer */ 2917 void *fn_data; /*!< Input argument for the callback function */ 2918 int extra1; /*!< Reserved. Must be zero */ 2919 void *extra2; /*!< Reserved. Must be zero */ 2920 struct ___itt_clock_domain *next; 2921 } __itt_clock_domain; 2922 2923 #pragma pack(pop) 2924 /** @endcond */ 2925 2926 /** 2927 * @ingroup clockdomains 2928 * @brief Create a clock domain. 2929 * Certain applications require the capability to trace their application using 2930 * a clock domain different than the CPU, for instance the instrumentation of 2931 * events that occur on a GPU. Because the set of domains is expected to be 2932 * static over the application's execution time, there is no mechanism to 2933 * destroy a domain. Any domain can be accessed by any thread in the process, 2934 * regardless of which thread created the domain. This call is thread-safe. 2935 * @param[in] fn A pointer to a callback function which retrieves alternative 2936 * CPU timestamps 2937 * @param[in] fn_data Argument for a callback function; may be NULL 2938 */ 2939 __itt_clock_domain *ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn, 2940 void *fn_data); 2941 2942 /** @cond exclude_from_documentation */ 2943 #ifndef INTEL_NO_MACRO_BODY 2944 #ifndef INTEL_NO_ITTNOTIFY_API 2945 ITT_STUB(ITTAPI, __itt_clock_domain *, clock_domain_create, 2946 (__itt_get_clock_info_fn fn, void *fn_data)) 2947 #define __itt_clock_domain_create ITTNOTIFY_DATA(clock_domain_create) 2948 #define __itt_clock_domain_create_ptr ITTNOTIFY_NAME(clock_domain_create) 2949 #else /* INTEL_NO_ITTNOTIFY_API */ 2950 #define __itt_clock_domain_create(fn, fn_data) (__itt_clock_domain *)0 2951 #define __itt_clock_domain_create_ptr 0 2952 #endif /* INTEL_NO_ITTNOTIFY_API */ 2953 #else /* INTEL_NO_MACRO_BODY */ 2954 #define __itt_clock_domain_create_ptr 0 2955 #endif /* INTEL_NO_MACRO_BODY */ 2956 /** @endcond */ 2957 2958 /** 2959 * @ingroup clockdomains 2960 * @brief Recalculate clock domains frequencies and clock base timestamps. 2961 */ 2962 void ITTAPI __itt_clock_domain_reset(void); 2963 2964 /** @cond exclude_from_documentation */ 2965 #ifndef INTEL_NO_MACRO_BODY 2966 #ifndef INTEL_NO_ITTNOTIFY_API 2967 ITT_STUBV(ITTAPI, void, clock_domain_reset, (void)) 2968 #define __itt_clock_domain_reset ITTNOTIFY_VOID(clock_domain_reset) 2969 #define __itt_clock_domain_reset_ptr ITTNOTIFY_NAME(clock_domain_reset) 2970 #else /* INTEL_NO_ITTNOTIFY_API */ 2971 #define __itt_clock_domain_reset() 2972 #define __itt_clock_domain_reset_ptr 0 2973 #endif /* INTEL_NO_ITTNOTIFY_API */ 2974 #else /* INTEL_NO_MACRO_BODY */ 2975 #define __itt_clock_domain_reset_ptr 0 2976 #endif /* INTEL_NO_MACRO_BODY */ 2977 /** @endcond */ 2978 2979 /** 2980 * @ingroup clockdomain 2981 * @brief Create an instance of identifier. This establishes the beginning of 2982 * the lifetime of an instance of the given ID in the trace. Once this lifetime 2983 * starts, the ID can be used to tag named entity instances in calls such as 2984 * __itt_task_begin, and to specify relationships among identified named entity 2985 * instances, using the \ref relations APIs. 2986 * @param[in] domain The domain controlling the execution of this call. 2987 * @param[in] clock_domain The clock domain controlling the execution of this 2988 * call. 2989 * @param[in] timestamp The user defined timestamp. 2990 * @param[in] id The ID to create. 2991 */ 2992 void ITTAPI __itt_id_create_ex(const __itt_domain *domain, 2993 __itt_clock_domain *clock_domain, 2994 unsigned long long timestamp, __itt_id id); 2995 2996 /** 2997 * @ingroup clockdomain 2998 * @brief Destroy an instance of identifier. This ends the lifetime of the 2999 * current instance of the given ID value in the trace. Any relationships that 3000 * are established after this lifetime ends are invalid. This call must be 3001 * performed before the given ID value can be reused for a different named 3002 * entity instance. 3003 * @param[in] domain The domain controlling the execution of this call. 3004 * @param[in] clock_domain The clock domain controlling the execution of this 3005 * call. 3006 * @param[in] timestamp The user defined timestamp. 3007 * @param[in] id The ID to destroy. 3008 */ 3009 void ITTAPI __itt_id_destroy_ex(const __itt_domain *domain, 3010 __itt_clock_domain *clock_domain, 3011 unsigned long long timestamp, __itt_id id); 3012 3013 /** @cond exclude_from_documentation */ 3014 #ifndef INTEL_NO_MACRO_BODY 3015 #ifndef INTEL_NO_ITTNOTIFY_API 3016 ITT_STUBV(ITTAPI, void, id_create_ex, 3017 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 3018 unsigned long long timestamp, __itt_id id)) 3019 ITT_STUBV(ITTAPI, void, id_destroy_ex, 3020 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 3021 unsigned long long timestamp, __itt_id id)) 3022 #define __itt_id_create_ex(d, x, y, z) \ 3023 ITTNOTIFY_VOID_D3(id_create_ex, d, x, y, z) 3024 #define __itt_id_create_ex_ptr ITTNOTIFY_NAME(id_create_ex) 3025 #define __itt_id_destroy_ex(d, x, y, z) \ 3026 ITTNOTIFY_VOID_D3(id_destroy_ex, d, x, y, z) 3027 #define __itt_id_destroy_ex_ptr ITTNOTIFY_NAME(id_destroy_ex) 3028 #else /* INTEL_NO_ITTNOTIFY_API */ 3029 #define __itt_id_create_ex(domain, clock_domain, timestamp, id) 3030 #define __itt_id_create_ex_ptr 0 3031 #define __itt_id_destroy_ex(domain, clock_domain, timestamp, id) 3032 #define __itt_id_destroy_ex_ptr 0 3033 #endif /* INTEL_NO_ITTNOTIFY_API */ 3034 #else /* INTEL_NO_MACRO_BODY */ 3035 #define __itt_id_create_ex_ptr 0 3036 #define __itt_id_destroy_ex_ptr 0 3037 #endif /* INTEL_NO_MACRO_BODY */ 3038 /** @endcond */ 3039 3040 /** 3041 * @ingroup clockdomain 3042 * @brief Begin a task instance. 3043 * @param[in] domain The domain for this task 3044 * @param[in] clock_domain The clock domain controlling the execution of this 3045 * call. 3046 * @param[in] timestamp The user defined timestamp. 3047 * @param[in] taskid The instance ID for this task instance, or __itt_null 3048 * @param[in] parentid The parent instance to which this task instance belongs, 3049 * or __itt_null 3050 * @param[in] name The name of this task 3051 */ 3052 void ITTAPI __itt_task_begin_ex(const __itt_domain *domain, 3053 __itt_clock_domain *clock_domain, 3054 unsigned long long timestamp, __itt_id taskid, 3055 __itt_id parentid, __itt_string_handle *name); 3056 3057 /** 3058 * @ingroup clockdomain 3059 * @brief Begin a task instance. 3060 * @param[in] domain The domain for this task 3061 * @param[in] clock_domain The clock domain controlling the execution of this 3062 * call. 3063 * @param[in] timestamp The user defined timestamp. 3064 * @param[in] taskid The identifier for this task instance, or __itt_null 3065 * @param[in] parentid The parent of this task, or __itt_null 3066 * @param[in] fn The pointer to the function you are tracing 3067 */ 3068 void ITTAPI __itt_task_begin_fn_ex(const __itt_domain *domain, 3069 __itt_clock_domain *clock_domain, 3070 unsigned long long timestamp, 3071 __itt_id taskid, __itt_id parentid, 3072 void *fn); 3073 3074 /** 3075 * @ingroup clockdomain 3076 * @brief End the current task instance. 3077 * @param[in] domain The domain for this task 3078 * @param[in] clock_domain The clock domain controlling the execution of this 3079 * call. 3080 * @param[in] timestamp The user defined timestamp. 3081 */ 3082 void ITTAPI __itt_task_end_ex(const __itt_domain *domain, 3083 __itt_clock_domain *clock_domain, 3084 unsigned long long timestamp); 3085 3086 /** @cond exclude_from_documentation */ 3087 #ifndef INTEL_NO_MACRO_BODY 3088 #ifndef INTEL_NO_ITTNOTIFY_API 3089 ITT_STUBV(ITTAPI, void, task_begin_ex, 3090 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 3091 unsigned long long timestamp, __itt_id id, __itt_id parentid, 3092 __itt_string_handle *name)) 3093 ITT_STUBV(ITTAPI, void, task_begin_fn_ex, 3094 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 3095 unsigned long long timestamp, __itt_id id, __itt_id parentid, 3096 void *fn)) 3097 ITT_STUBV(ITTAPI, void, task_end_ex, 3098 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 3099 unsigned long long timestamp)) 3100 #define __itt_task_begin_ex(d, x, y, z, a, b) \ 3101 ITTNOTIFY_VOID_D5(task_begin_ex, d, x, y, z, a, b) 3102 #define __itt_task_begin_ex_ptr ITTNOTIFY_NAME(task_begin_ex) 3103 #define __itt_task_begin_fn_ex(d, x, y, z, a, b) \ 3104 ITTNOTIFY_VOID_D5(task_begin_fn_ex, d, x, y, z, a, b) 3105 #define __itt_task_begin_fn_ex_ptr ITTNOTIFY_NAME(task_begin_fn_ex) 3106 #define __itt_task_end_ex(d, x, y) ITTNOTIFY_VOID_D2(task_end_ex, d, x, y) 3107 #define __itt_task_end_ex_ptr ITTNOTIFY_NAME(task_end_ex) 3108 #else /* INTEL_NO_ITTNOTIFY_API */ 3109 #define __itt_task_begin_ex(domain, clock_domain, timestamp, id, parentid, name) 3110 #define __itt_task_begin_ex_ptr 0 3111 #define __itt_task_begin_fn_ex(domain, clock_domain, timestamp, id, parentid, \ 3112 fn) 3113 #define __itt_task_begin_fn_ex_ptr 0 3114 #define __itt_task_end_ex(domain, clock_domain, timestamp) 3115 #define __itt_task_end_ex_ptr 0 3116 #endif /* INTEL_NO_ITTNOTIFY_API */ 3117 #else /* INTEL_NO_MACRO_BODY */ 3118 #define __itt_task_begin_ex_ptr 0 3119 #define __itt_task_begin_fn_ex_ptr 0 3120 #define __itt_task_end_ex_ptr 0 3121 #endif /* INTEL_NO_MACRO_BODY */ 3122 /** @endcond */ 3123 3124 /** 3125 * @defgroup counters Counters 3126 * @ingroup public 3127 * Counters are user-defined objects with a monotonically increasing 3128 * value. Counter values are 64-bit unsigned integers. 3129 * Counters have names that can be displayed in 3130 * the tools. 3131 * @{ 3132 */ 3133 3134 /** 3135 * @brief opaque structure for counter identification 3136 */ 3137 /** @cond exclude_from_documentation */ 3138 3139 typedef struct ___itt_counter *__itt_counter; 3140 3141 /** 3142 * @brief Create an unsigned 64 bits integer counter with given name/domain 3143 * 3144 * After __itt_counter_create() is called, __itt_counter_inc(id), 3145 * __itt_counter_inc_delta(id, delta), 3146 * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, 3147 * clock_domain, timestamp, value_ptr) can be used to change the value of the 3148 * counter, where value_ptr is a pointer to an unsigned 64 bits integer 3149 * 3150 * The call is equal to __itt_counter_create_typed(name, domain, 3151 * __itt_metadata_u64) 3152 */ 3153 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3154 __itt_counter ITTAPI __itt_counter_createA(const char *name, 3155 const char *domain); 3156 __itt_counter ITTAPI __itt_counter_createW(const wchar_t *name, 3157 const wchar_t *domain); 3158 #if defined(UNICODE) || defined(_UNICODE) 3159 #define __itt_counter_create __itt_counter_createW 3160 #define __itt_counter_create_ptr __itt_counter_createW_ptr 3161 #else /* UNICODE */ 3162 #define __itt_counter_create __itt_counter_createA 3163 #define __itt_counter_create_ptr __itt_counter_createA_ptr 3164 #endif /* UNICODE */ 3165 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3166 __itt_counter ITTAPI __itt_counter_create(const char *name, const char *domain); 3167 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3168 3169 #ifndef INTEL_NO_MACRO_BODY 3170 #ifndef INTEL_NO_ITTNOTIFY_API 3171 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3172 ITT_STUB(ITTAPI, __itt_counter, counter_createA, 3173 (const char *name, const char *domain)) 3174 ITT_STUB(ITTAPI, __itt_counter, counter_createW, 3175 (const wchar_t *name, const wchar_t *domain)) 3176 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3177 ITT_STUB(ITTAPI, __itt_counter, counter_create, 3178 (const char *name, const char *domain)) 3179 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3180 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3181 #define __itt_counter_createA ITTNOTIFY_DATA(counter_createA) 3182 #define __itt_counter_createA_ptr ITTNOTIFY_NAME(counter_createA) 3183 #define __itt_counter_createW ITTNOTIFY_DATA(counter_createW) 3184 #define __itt_counter_createW_ptr ITTNOTIFY_NAME(counter_createW) 3185 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3186 #define __itt_counter_create ITTNOTIFY_DATA(counter_create) 3187 #define __itt_counter_create_ptr ITTNOTIFY_NAME(counter_create) 3188 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3189 #else /* INTEL_NO_ITTNOTIFY_API */ 3190 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3191 #define __itt_counter_createA(name, domain) 3192 #define __itt_counter_createA_ptr 0 3193 #define __itt_counter_createW(name, domain) 3194 #define __itt_counter_createW_ptr 0 3195 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3196 #define __itt_counter_create(name, domain) 3197 #define __itt_counter_create_ptr 0 3198 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3199 #endif /* INTEL_NO_ITTNOTIFY_API */ 3200 #else /* INTEL_NO_MACRO_BODY */ 3201 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3202 #define __itt_counter_createA_ptr 0 3203 #define __itt_counter_createW_ptr 0 3204 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3205 #define __itt_counter_create_ptr 0 3206 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3207 #endif /* INTEL_NO_MACRO_BODY */ 3208 /** @endcond */ 3209 3210 /** 3211 * @brief Increment the unsigned 64 bits integer counter value 3212 * 3213 * Calling this function to non-unsigned 64 bits integer counters has no effect 3214 */ 3215 void ITTAPI __itt_counter_inc(__itt_counter id); 3216 3217 #ifndef INTEL_NO_MACRO_BODY 3218 #ifndef INTEL_NO_ITTNOTIFY_API 3219 ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id)) 3220 #define __itt_counter_inc ITTNOTIFY_VOID(counter_inc) 3221 #define __itt_counter_inc_ptr ITTNOTIFY_NAME(counter_inc) 3222 #else /* INTEL_NO_ITTNOTIFY_API */ 3223 #define __itt_counter_inc(id) 3224 #define __itt_counter_inc_ptr 0 3225 #endif /* INTEL_NO_ITTNOTIFY_API */ 3226 #else /* INTEL_NO_MACRO_BODY */ 3227 #define __itt_counter_inc_ptr 0 3228 #endif /* INTEL_NO_MACRO_BODY */ 3229 /** @endcond */ 3230 /** 3231 * @brief Increment the unsigned 64 bits integer counter value with x 3232 * 3233 * Calling this function to non-unsigned 64 bits integer counters has no effect 3234 */ 3235 void ITTAPI __itt_counter_inc_delta(__itt_counter id, unsigned long long value); 3236 3237 #ifndef INTEL_NO_MACRO_BODY 3238 #ifndef INTEL_NO_ITTNOTIFY_API 3239 ITT_STUBV(ITTAPI, void, counter_inc_delta, 3240 (__itt_counter id, unsigned long long value)) 3241 #define __itt_counter_inc_delta ITTNOTIFY_VOID(counter_inc_delta) 3242 #define __itt_counter_inc_delta_ptr ITTNOTIFY_NAME(counter_inc_delta) 3243 #else /* INTEL_NO_ITTNOTIFY_API */ 3244 #define __itt_counter_inc_delta(id, value) 3245 #define __itt_counter_inc_delta_ptr 0 3246 #endif /* INTEL_NO_ITTNOTIFY_API */ 3247 #else /* INTEL_NO_MACRO_BODY */ 3248 #define __itt_counter_inc_delta_ptr 0 3249 #endif /* INTEL_NO_MACRO_BODY */ 3250 /** @endcond */ 3251 3252 /** 3253 * @brief Decrement the unsigned 64 bits integer counter value 3254 * 3255 * Calling this function to non-unsigned 64 bits integer counters has no effect 3256 */ 3257 void ITTAPI __itt_counter_dec(__itt_counter id); 3258 3259 #ifndef INTEL_NO_MACRO_BODY 3260 #ifndef INTEL_NO_ITTNOTIFY_API 3261 ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id)) 3262 #define __itt_counter_dec ITTNOTIFY_VOID(counter_dec) 3263 #define __itt_counter_dec_ptr ITTNOTIFY_NAME(counter_dec) 3264 #else /* INTEL_NO_ITTNOTIFY_API */ 3265 #define __itt_counter_dec(id) 3266 #define __itt_counter_dec_ptr 0 3267 #endif /* INTEL_NO_ITTNOTIFY_API */ 3268 #else /* INTEL_NO_MACRO_BODY */ 3269 #define __itt_counter_dec_ptr 0 3270 #endif /* INTEL_NO_MACRO_BODY */ 3271 /** @endcond */ 3272 /** 3273 * @brief Decrement the unsigned 64 bits integer counter value with x 3274 * 3275 * Calling this function to non-unsigned 64 bits integer counters has no effect 3276 */ 3277 void ITTAPI __itt_counter_dec_delta(__itt_counter id, unsigned long long value); 3278 3279 #ifndef INTEL_NO_MACRO_BODY 3280 #ifndef INTEL_NO_ITTNOTIFY_API 3281 ITT_STUBV(ITTAPI, void, counter_dec_delta, 3282 (__itt_counter id, unsigned long long value)) 3283 #define __itt_counter_dec_delta ITTNOTIFY_VOID(counter_dec_delta) 3284 #define __itt_counter_dec_delta_ptr ITTNOTIFY_NAME(counter_dec_delta) 3285 #else /* INTEL_NO_ITTNOTIFY_API */ 3286 #define __itt_counter_dec_delta(id, value) 3287 #define __itt_counter_dec_delta_ptr 0 3288 #endif /* INTEL_NO_ITTNOTIFY_API */ 3289 #else /* INTEL_NO_MACRO_BODY */ 3290 #define __itt_counter_dec_delta_ptr 0 3291 #endif /* INTEL_NO_MACRO_BODY */ 3292 /** @endcond */ 3293 3294 /** 3295 * @ingroup counters 3296 * @brief Increment a counter by one. 3297 * The first call with a given name creates a counter by that name and sets its 3298 * value to zero. Successive calls increment the counter value. 3299 * @param[in] domain The domain controlling the call. Counter names are not 3300 * domain specific. The domain argument is used only to enable or disable the 3301 * API calls. 3302 * @param[in] name The name of the counter 3303 */ 3304 void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain, 3305 __itt_string_handle *name); 3306 3307 /** 3308 * @ingroup counters 3309 * @brief Increment a counter by the value specified in delta. 3310 * @param[in] domain The domain controlling the call. Counter names are not 3311 * domain specific. The domain argument is used only to enable or disable the 3312 * API calls. 3313 * @param[in] name The name of the counter 3314 * @param[in] delta The amount by which to increment the counter 3315 */ 3316 void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain, 3317 __itt_string_handle *name, 3318 unsigned long long delta); 3319 3320 #ifndef INTEL_NO_MACRO_BODY 3321 #ifndef INTEL_NO_ITTNOTIFY_API 3322 ITT_STUBV(ITTAPI, void, counter_inc_v3, 3323 (const __itt_domain *domain, __itt_string_handle *name)) 3324 ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, 3325 (const __itt_domain *domain, __itt_string_handle *name, 3326 unsigned long long delta)) 3327 #define __itt_counter_inc_v3(d, x) ITTNOTIFY_VOID_D1(counter_inc_v3, d, x) 3328 #define __itt_counter_inc_v3_ptr ITTNOTIFY_NAME(counter_inc_v3) 3329 #define __itt_counter_inc_delta_v3(d, x, y) \ 3330 ITTNOTIFY_VOID_D2(counter_inc_delta_v3, d, x, y) 3331 #define __itt_counter_inc_delta_v3_ptr ITTNOTIFY_NAME(counter_inc_delta_v3) 3332 #else /* INTEL_NO_ITTNOTIFY_API */ 3333 #define __itt_counter_inc_v3(domain, name) 3334 #define __itt_counter_inc_v3_ptr 0 3335 #define __itt_counter_inc_delta_v3(domain, name, delta) 3336 #define __itt_counter_inc_delta_v3_ptr 0 3337 #endif /* INTEL_NO_ITTNOTIFY_API */ 3338 #else /* INTEL_NO_MACRO_BODY */ 3339 #define __itt_counter_inc_v3_ptr 0 3340 #define __itt_counter_inc_delta_v3_ptr 0 3341 #endif /* INTEL_NO_MACRO_BODY */ 3342 /** @endcond */ 3343 3344 /** 3345 * @ingroup counters 3346 * @brief Decrement a counter by one. 3347 * The first call with a given name creates a counter by that name and sets its 3348 * value to zero. Successive calls decrement the counter value. 3349 * @param[in] domain The domain controlling the call. Counter names are not 3350 * domain specific. The domain argument is used only to enable or disable the 3351 * API calls. 3352 * @param[in] name The name of the counter 3353 */ 3354 void ITTAPI __itt_counter_dec_v3(const __itt_domain *domain, 3355 __itt_string_handle *name); 3356 3357 /** 3358 * @ingroup counters 3359 * @brief Decrement a counter by the value specified in delta. 3360 * @param[in] domain The domain controlling the call. Counter names are not 3361 * domain specific. The domain argument is used only to enable or disable the 3362 * API calls. 3363 * @param[in] name The name of the counter 3364 * @param[in] delta The amount by which to decrement the counter 3365 */ 3366 void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain *domain, 3367 __itt_string_handle *name, 3368 unsigned long long delta); 3369 3370 #ifndef INTEL_NO_MACRO_BODY 3371 #ifndef INTEL_NO_ITTNOTIFY_API 3372 ITT_STUBV(ITTAPI, void, counter_dec_v3, 3373 (const __itt_domain *domain, __itt_string_handle *name)) 3374 ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, 3375 (const __itt_domain *domain, __itt_string_handle *name, 3376 unsigned long long delta)) 3377 #define __itt_counter_dec_v3(d, x) ITTNOTIFY_VOID_D1(counter_dec_v3, d, x) 3378 #define __itt_counter_dec_v3_ptr ITTNOTIFY_NAME(counter_dec_v3) 3379 #define __itt_counter_dec_delta_v3(d, x, y) \ 3380 ITTNOTIFY_VOID_D2(counter_dec_delta_v3, d, x, y) 3381 #define __itt_counter_dec_delta_v3_ptr ITTNOTIFY_NAME(counter_dec_delta_v3) 3382 #else /* INTEL_NO_ITTNOTIFY_API */ 3383 #define __itt_counter_dec_v3(domain, name) 3384 #define __itt_counter_dec_v3_ptr 0 3385 #define __itt_counter_dec_delta_v3(domain, name, delta) 3386 #define __itt_counter_dec_delta_v3_ptr 0 3387 #endif /* INTEL_NO_ITTNOTIFY_API */ 3388 #else /* INTEL_NO_MACRO_BODY */ 3389 #define __itt_counter_dec_v3_ptr 0 3390 #define __itt_counter_dec_delta_v3_ptr 0 3391 #endif /* INTEL_NO_MACRO_BODY */ 3392 /** @endcond */ 3393 3394 /** @} counters group */ 3395 3396 /** 3397 * @brief Set the counter value 3398 */ 3399 void ITTAPI __itt_counter_set_value(__itt_counter id, void *value_ptr); 3400 3401 #ifndef INTEL_NO_MACRO_BODY 3402 #ifndef INTEL_NO_ITTNOTIFY_API 3403 ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr)) 3404 #define __itt_counter_set_value ITTNOTIFY_VOID(counter_set_value) 3405 #define __itt_counter_set_value_ptr ITTNOTIFY_NAME(counter_set_value) 3406 #else /* INTEL_NO_ITTNOTIFY_API */ 3407 #define __itt_counter_set_value(id, value_ptr) 3408 #define __itt_counter_set_value_ptr 0 3409 #endif /* INTEL_NO_ITTNOTIFY_API */ 3410 #else /* INTEL_NO_MACRO_BODY */ 3411 #define __itt_counter_set_value_ptr 0 3412 #endif /* INTEL_NO_MACRO_BODY */ 3413 /** @endcond */ 3414 3415 /** 3416 * @brief Set the counter value 3417 */ 3418 void ITTAPI __itt_counter_set_value_ex(__itt_counter id, 3419 __itt_clock_domain *clock_domain, 3420 unsigned long long timestamp, 3421 void *value_ptr); 3422 3423 /** @cond exclude_from_documentation */ 3424 #ifndef INTEL_NO_MACRO_BODY 3425 #ifndef INTEL_NO_ITTNOTIFY_API 3426 ITT_STUBV(ITTAPI, void, counter_set_value_ex, 3427 (__itt_counter id, __itt_clock_domain *clock_domain, 3428 unsigned long long timestamp, void *value_ptr)) 3429 #define __itt_counter_set_value_ex ITTNOTIFY_VOID(counter_set_value_ex) 3430 #define __itt_counter_set_value_ex_ptr ITTNOTIFY_NAME(counter_set_value_ex) 3431 #else /* INTEL_NO_ITTNOTIFY_API */ 3432 #define __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr) 3433 #define __itt_counter_set_value_ex_ptr 0 3434 #endif /* INTEL_NO_ITTNOTIFY_API */ 3435 #else /* INTEL_NO_MACRO_BODY */ 3436 #define __itt_counter_set_value_ex_ptr 0 3437 #endif /* INTEL_NO_MACRO_BODY */ 3438 /** @endcond */ 3439 3440 /** 3441 * @brief Create a typed counter with given name/domain 3442 * 3443 * After __itt_counter_create_typed() is called, __itt_counter_inc(id), 3444 * __itt_counter_inc_delta(id, delta), 3445 * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, 3446 * clock_domain, timestamp, value_ptr) can be used to change the value of the 3447 * counter 3448 */ 3449 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3450 __itt_counter ITTAPI __itt_counter_create_typedA(const char *name, 3451 const char *domain, 3452 __itt_metadata_type type); 3453 __itt_counter ITTAPI __itt_counter_create_typedW(const wchar_t *name, 3454 const wchar_t *domain, 3455 __itt_metadata_type type); 3456 #if defined(UNICODE) || defined(_UNICODE) 3457 #define __itt_counter_create_typed __itt_counter_create_typedW 3458 #define __itt_counter_create_typed_ptr __itt_counter_create_typedW_ptr 3459 #else /* UNICODE */ 3460 #define __itt_counter_create_typed __itt_counter_create_typedA 3461 #define __itt_counter_create_typed_ptr __itt_counter_create_typedA_ptr 3462 #endif /* UNICODE */ 3463 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3464 __itt_counter ITTAPI __itt_counter_create_typed(const char *name, 3465 const char *domain, 3466 __itt_metadata_type type); 3467 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3468 3469 #ifndef INTEL_NO_MACRO_BODY 3470 #ifndef INTEL_NO_ITTNOTIFY_API 3471 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3472 ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, 3473 (const char *name, const char *domain, __itt_metadata_type type)) 3474 ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, 3475 (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)) 3476 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3477 ITT_STUB(ITTAPI, __itt_counter, counter_create_typed, 3478 (const char *name, const char *domain, __itt_metadata_type type)) 3479 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3480 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3481 #define __itt_counter_create_typedA ITTNOTIFY_DATA(counter_create_typedA) 3482 #define __itt_counter_create_typedA_ptr ITTNOTIFY_NAME(counter_create_typedA) 3483 #define __itt_counter_create_typedW ITTNOTIFY_DATA(counter_create_typedW) 3484 #define __itt_counter_create_typedW_ptr ITTNOTIFY_NAME(counter_create_typedW) 3485 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3486 #define __itt_counter_create_typed ITTNOTIFY_DATA(counter_create_typed) 3487 #define __itt_counter_create_typed_ptr ITTNOTIFY_NAME(counter_create_typed) 3488 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3489 #else /* INTEL_NO_ITTNOTIFY_API */ 3490 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3491 #define __itt_counter_create_typedA(name, domain, type) 3492 #define __itt_counter_create_typedA_ptr 0 3493 #define __itt_counter_create_typedW(name, domain, type) 3494 #define __itt_counter_create_typedW_ptr 0 3495 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3496 #define __itt_counter_create_typed(name, domain, type) 3497 #define __itt_counter_create_typed_ptr 0 3498 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3499 #endif /* INTEL_NO_ITTNOTIFY_API */ 3500 #else /* INTEL_NO_MACRO_BODY */ 3501 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3502 #define __itt_counter_create_typedA_ptr 0 3503 #define __itt_counter_create_typedW_ptr 0 3504 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3505 #define __itt_counter_create_typed_ptr 0 3506 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3507 #endif /* INTEL_NO_MACRO_BODY */ 3508 /** @endcond */ 3509 3510 /** 3511 * @brief Destroy the counter identified by the pointer previously returned by 3512 * __itt_counter_create() or 3513 * __itt_counter_create_typed() 3514 */ 3515 void ITTAPI __itt_counter_destroy(__itt_counter id); 3516 3517 #ifndef INTEL_NO_MACRO_BODY 3518 #ifndef INTEL_NO_ITTNOTIFY_API 3519 ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id)) 3520 #define __itt_counter_destroy ITTNOTIFY_VOID(counter_destroy) 3521 #define __itt_counter_destroy_ptr ITTNOTIFY_NAME(counter_destroy) 3522 #else /* INTEL_NO_ITTNOTIFY_API */ 3523 #define __itt_counter_destroy(id) 3524 #define __itt_counter_destroy_ptr 0 3525 #endif /* INTEL_NO_ITTNOTIFY_API */ 3526 #else /* INTEL_NO_MACRO_BODY */ 3527 #define __itt_counter_destroy_ptr 0 3528 #endif /* INTEL_NO_MACRO_BODY */ 3529 /** @endcond */ 3530 /** @} counters group */ 3531 3532 /** 3533 * @ingroup markers 3534 * @brief Create a marker instance. 3535 * @param[in] domain The domain for this marker 3536 * @param[in] clock_domain The clock domain controlling the execution of this 3537 * call. 3538 * @param[in] timestamp The user defined timestamp. 3539 * @param[in] id The instance ID for this marker, or __itt_null 3540 * @param[in] name The name for this marker 3541 * @param[in] scope The scope for this marker 3542 */ 3543 void ITTAPI __itt_marker_ex(const __itt_domain *domain, 3544 __itt_clock_domain *clock_domain, 3545 unsigned long long timestamp, __itt_id id, 3546 __itt_string_handle *name, __itt_scope scope); 3547 3548 /** @cond exclude_from_documentation */ 3549 #ifndef INTEL_NO_MACRO_BODY 3550 #ifndef INTEL_NO_ITTNOTIFY_API 3551 ITT_STUBV(ITTAPI, void, marker_ex, 3552 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 3553 unsigned long long timestamp, __itt_id id, __itt_string_handle *name, 3554 __itt_scope scope)) 3555 #define __itt_marker_ex(d, x, y, z, a, b) \ 3556 ITTNOTIFY_VOID_D5(marker_ex, d, x, y, z, a, b) 3557 #define __itt_marker_ex_ptr ITTNOTIFY_NAME(marker_ex) 3558 #else /* INTEL_NO_ITTNOTIFY_API */ 3559 #define __itt_marker_ex(domain, clock_domain, timestamp, id, name, scope) 3560 #define __itt_marker_ex_ptr 0 3561 #endif /* INTEL_NO_ITTNOTIFY_API */ 3562 #else /* INTEL_NO_MACRO_BODY */ 3563 #define __itt_marker_ex_ptr 0 3564 #endif /* INTEL_NO_MACRO_BODY */ 3565 /** @endcond */ 3566 3567 /** 3568 * @ingroup clockdomain 3569 * @brief Add a relation to the current task instance. 3570 * The current task instance is the head of the relation. 3571 * @param[in] domain The domain controlling this call 3572 * @param[in] clock_domain The clock domain controlling the execution of this 3573 * call. 3574 * @param[in] timestamp The user defined timestamp. 3575 * @param[in] relation The kind of relation 3576 * @param[in] tail The ID for the tail of the relation 3577 */ 3578 void ITTAPI __itt_relation_add_to_current_ex(const __itt_domain *domain, 3579 __itt_clock_domain *clock_domain, 3580 unsigned long long timestamp, 3581 __itt_relation relation, 3582 __itt_id tail); 3583 3584 /** 3585 * @ingroup clockdomain 3586 * @brief Add a relation between two instance identifiers. 3587 * @param[in] domain The domain controlling this call 3588 * @param[in] clock_domain The clock domain controlling the execution of this 3589 * call. 3590 * @param[in] timestamp The user defined timestamp. 3591 * @param[in] head The ID for the head of the relation 3592 * @param[in] relation The kind of relation 3593 * @param[in] tail The ID for the tail of the relation 3594 */ 3595 void ITTAPI __itt_relation_add_ex(const __itt_domain *domain, 3596 __itt_clock_domain *clock_domain, 3597 unsigned long long timestamp, __itt_id head, 3598 __itt_relation relation, __itt_id tail); 3599 3600 /** @cond exclude_from_documentation */ 3601 #ifndef INTEL_NO_MACRO_BODY 3602 #ifndef INTEL_NO_ITTNOTIFY_API 3603 ITT_STUBV(ITTAPI, void, relation_add_to_current_ex, 3604 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 3605 unsigned long long timestamp, __itt_relation relation, 3606 __itt_id tail)) 3607 ITT_STUBV(ITTAPI, void, relation_add_ex, 3608 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 3609 unsigned long long timestamp, __itt_id head, __itt_relation relation, 3610 __itt_id tail)) 3611 #define __itt_relation_add_to_current_ex(d, x, y, z, a) \ 3612 ITTNOTIFY_VOID_D4(relation_add_to_current_ex, d, x, y, z, a) 3613 #define __itt_relation_add_to_current_ex_ptr \ 3614 ITTNOTIFY_NAME(relation_add_to_current_ex) 3615 #define __itt_relation_add_ex(d, x, y, z, a, b) \ 3616 ITTNOTIFY_VOID_D5(relation_add_ex, d, x, y, z, a, b) 3617 #define __itt_relation_add_ex_ptr ITTNOTIFY_NAME(relation_add_ex) 3618 #else /* INTEL_NO_ITTNOTIFY_API */ 3619 #define __itt_relation_add_to_current_ex(domain, clock_domain, timestame, \ 3620 relation, tail) 3621 #define __itt_relation_add_to_current_ex_ptr 0 3622 #define __itt_relation_add_ex(domain, clock_domain, timestamp, head, relation, \ 3623 tail) 3624 #define __itt_relation_add_ex_ptr 0 3625 #endif /* INTEL_NO_ITTNOTIFY_API */ 3626 #else /* INTEL_NO_MACRO_BODY */ 3627 #define __itt_relation_add_to_current_ex_ptr 0 3628 #define __itt_relation_add_ex_ptr 0 3629 #endif /* INTEL_NO_MACRO_BODY */ 3630 /** @endcond */ 3631 3632 /** @cond exclude_from_documentation */ 3633 typedef enum ___itt_track_group_type { 3634 __itt_track_group_type_normal = 0 3635 } __itt_track_group_type; 3636 /** @endcond */ 3637 3638 /** @cond exclude_from_documentation */ 3639 #pragma pack(push, 8) 3640 3641 typedef struct ___itt_track_group { 3642 __itt_string_handle *name; /*!< Name of the track group */ 3643 struct ___itt_track *track; /*!< List of child tracks */ 3644 __itt_track_group_type tgtype; /*!< Type of the track group */ 3645 int extra1; /*!< Reserved. Must be zero */ 3646 void *extra2; /*!< Reserved. Must be zero */ 3647 struct ___itt_track_group *next; 3648 } __itt_track_group; 3649 3650 #pragma pack(pop) 3651 /** @endcond */ 3652 3653 /** 3654 * @brief Placeholder for custom track types. Currently, "normal" custom track 3655 * is the only available track type. 3656 */ 3657 typedef enum ___itt_track_type { 3658 __itt_track_type_normal = 0 3659 #ifdef INTEL_ITTNOTIFY_API_PRIVATE 3660 , 3661 __itt_track_type_queue 3662 #endif /* INTEL_ITTNOTIFY_API_PRIVATE */ 3663 } __itt_track_type; 3664 3665 /** @cond exclude_from_documentation */ 3666 #pragma pack(push, 8) 3667 3668 typedef struct ___itt_track { 3669 __itt_string_handle *name; /*!< Name of the track group */ 3670 __itt_track_group *group; /*!< Parent group to a track */ 3671 __itt_track_type ttype; /*!< Type of the track */ 3672 int extra1; /*!< Reserved. Must be zero */ 3673 void *extra2; /*!< Reserved. Must be zero */ 3674 struct ___itt_track *next; 3675 } __itt_track; 3676 3677 #pragma pack(pop) 3678 /** @endcond */ 3679 3680 /** 3681 * @brief Create logical track group. 3682 */ 3683 __itt_track_group *ITTAPI __itt_track_group_create( 3684 __itt_string_handle *name, __itt_track_group_type track_group_type); 3685 3686 /** @cond exclude_from_documentation */ 3687 #ifndef INTEL_NO_MACRO_BODY 3688 #ifndef INTEL_NO_ITTNOTIFY_API 3689 ITT_STUB(ITTAPI, __itt_track_group *, track_group_create, 3690 (__itt_string_handle * name, __itt_track_group_type track_group_type)) 3691 #define __itt_track_group_create ITTNOTIFY_DATA(track_group_create) 3692 #define __itt_track_group_create_ptr ITTNOTIFY_NAME(track_group_create) 3693 #else /* INTEL_NO_ITTNOTIFY_API */ 3694 #define __itt_track_group_create(name) (__itt_track_group *)0 3695 #define __itt_track_group_create_ptr 0 3696 #endif /* INTEL_NO_ITTNOTIFY_API */ 3697 #else /* INTEL_NO_MACRO_BODY */ 3698 #define __itt_track_group_create_ptr 0 3699 #endif /* INTEL_NO_MACRO_BODY */ 3700 /** @endcond */ 3701 3702 /** 3703 * @brief Create logical track. 3704 */ 3705 __itt_track *ITTAPI __itt_track_create(__itt_track_group *track_group, 3706 __itt_string_handle *name, 3707 __itt_track_type track_type); 3708 3709 /** @cond exclude_from_documentation */ 3710 #ifndef INTEL_NO_MACRO_BODY 3711 #ifndef INTEL_NO_ITTNOTIFY_API 3712 ITT_STUB(ITTAPI, __itt_track *, track_create, 3713 (__itt_track_group * track_group, __itt_string_handle *name, 3714 __itt_track_type track_type)) 3715 #define __itt_track_create ITTNOTIFY_DATA(track_create) 3716 #define __itt_track_create_ptr ITTNOTIFY_NAME(track_create) 3717 #else /* INTEL_NO_ITTNOTIFY_API */ 3718 #define __itt_track_create(track_group, name, track_type) (__itt_track *)0 3719 #define __itt_track_create_ptr 0 3720 #endif /* INTEL_NO_ITTNOTIFY_API */ 3721 #else /* INTEL_NO_MACRO_BODY */ 3722 #define __itt_track_create_ptr 0 3723 #endif /* INTEL_NO_MACRO_BODY */ 3724 /** @endcond */ 3725 3726 /** 3727 * @brief Set the logical track. 3728 */ 3729 void ITTAPI __itt_set_track(__itt_track *track); 3730 3731 /** @cond exclude_from_documentation */ 3732 #ifndef INTEL_NO_MACRO_BODY 3733 #ifndef INTEL_NO_ITTNOTIFY_API 3734 ITT_STUBV(ITTAPI, void, set_track, (__itt_track * track)) 3735 #define __itt_set_track ITTNOTIFY_VOID(set_track) 3736 #define __itt_set_track_ptr ITTNOTIFY_NAME(set_track) 3737 #else /* INTEL_NO_ITTNOTIFY_API */ 3738 #define __itt_set_track(track) 3739 #define __itt_set_track_ptr 0 3740 #endif /* INTEL_NO_ITTNOTIFY_API */ 3741 #else /* INTEL_NO_MACRO_BODY */ 3742 #define __itt_set_track_ptr 0 3743 #endif /* INTEL_NO_MACRO_BODY */ 3744 /** @endcond */ 3745 3746 /* ========================================================================== */ 3747 /** @cond exclude_from_gpa_documentation */ 3748 /** 3749 * @defgroup events Events 3750 * @ingroup public 3751 * Events group 3752 * @{ 3753 */ 3754 /** @brief user event type */ 3755 typedef int __itt_event; 3756 3757 /** 3758 * @brief Create an event notification 3759 * @note name or namelen being null/name and namelen not matching, user event 3760 * feature not enabled 3761 * @return non-zero event identifier upon success and __itt_err otherwise 3762 */ 3763 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3764 __itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen); 3765 __itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen); 3766 #if defined(UNICODE) || defined(_UNICODE) 3767 #define __itt_event_create __itt_event_createW 3768 #define __itt_event_create_ptr __itt_event_createW_ptr 3769 #else 3770 #define __itt_event_create __itt_event_createA 3771 #define __itt_event_create_ptr __itt_event_createA_ptr 3772 #endif /* UNICODE */ 3773 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3774 __itt_event LIBITTAPI __itt_event_create(const char *name, int namelen); 3775 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3776 3777 /** @cond exclude_from_documentation */ 3778 #ifndef INTEL_NO_MACRO_BODY 3779 #ifndef INTEL_NO_ITTNOTIFY_API 3780 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3781 ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen)) 3782 ITT_STUB(LIBITTAPI, __itt_event, event_createW, 3783 (const wchar_t *name, int namelen)) 3784 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3785 ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen)) 3786 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3787 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3788 #define __itt_event_createA ITTNOTIFY_DATA(event_createA) 3789 #define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA) 3790 #define __itt_event_createW ITTNOTIFY_DATA(event_createW) 3791 #define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW) 3792 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3793 #define __itt_event_create ITTNOTIFY_DATA(event_create) 3794 #define __itt_event_create_ptr ITTNOTIFY_NAME(event_create) 3795 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3796 #else /* INTEL_NO_ITTNOTIFY_API */ 3797 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3798 #define __itt_event_createA(name, namelen) (__itt_event)0 3799 #define __itt_event_createA_ptr 0 3800 #define __itt_event_createW(name, namelen) (__itt_event)0 3801 #define __itt_event_createW_ptr 0 3802 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3803 #define __itt_event_create(name, namelen) (__itt_event)0 3804 #define __itt_event_create_ptr 0 3805 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3806 #endif /* INTEL_NO_ITTNOTIFY_API */ 3807 #else /* INTEL_NO_MACRO_BODY */ 3808 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3809 #define __itt_event_createA_ptr 0 3810 #define __itt_event_createW_ptr 0 3811 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3812 #define __itt_event_create_ptr 0 3813 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3814 #endif /* INTEL_NO_MACRO_BODY */ 3815 /** @endcond */ 3816 3817 /** 3818 * @brief Record an event occurrence. 3819 * @return __itt_err upon failure (invalid event id/user event feature not 3820 * enabled) 3821 */ 3822 int LIBITTAPI __itt_event_start(__itt_event event); 3823 3824 /** @cond exclude_from_documentation */ 3825 #ifndef INTEL_NO_MACRO_BODY 3826 #ifndef INTEL_NO_ITTNOTIFY_API 3827 ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event)) 3828 #define __itt_event_start ITTNOTIFY_DATA(event_start) 3829 #define __itt_event_start_ptr ITTNOTIFY_NAME(event_start) 3830 #else /* INTEL_NO_ITTNOTIFY_API */ 3831 #define __itt_event_start(event) (int)0 3832 #define __itt_event_start_ptr 0 3833 #endif /* INTEL_NO_ITTNOTIFY_API */ 3834 #else /* INTEL_NO_MACRO_BODY */ 3835 #define __itt_event_start_ptr 0 3836 #endif /* INTEL_NO_MACRO_BODY */ 3837 /** @endcond */ 3838 3839 /** 3840 * @brief Record an event end occurrence. 3841 * @note It is optional if events do not have durations. 3842 * @return __itt_err upon failure (invalid event id/user event feature not 3843 * enabled) 3844 */ 3845 int LIBITTAPI __itt_event_end(__itt_event event); 3846 3847 /** @cond exclude_from_documentation */ 3848 #ifndef INTEL_NO_MACRO_BODY 3849 #ifndef INTEL_NO_ITTNOTIFY_API 3850 ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event)) 3851 #define __itt_event_end ITTNOTIFY_DATA(event_end) 3852 #define __itt_event_end_ptr ITTNOTIFY_NAME(event_end) 3853 #else /* INTEL_NO_ITTNOTIFY_API */ 3854 #define __itt_event_end(event) (int)0 3855 #define __itt_event_end_ptr 0 3856 #endif /* INTEL_NO_ITTNOTIFY_API */ 3857 #else /* INTEL_NO_MACRO_BODY */ 3858 #define __itt_event_end_ptr 0 3859 #endif /* INTEL_NO_MACRO_BODY */ 3860 /** @endcond */ 3861 /** @} events group */ 3862 3863 /** 3864 * @defgroup arrays Arrays Visualizer 3865 * @ingroup public 3866 * Visualize arrays 3867 * @{ 3868 */ 3869 3870 /** 3871 * @enum __itt_av_data_type 3872 * @brief Defines types of arrays data (for C/C++ intrinsic types) 3873 */ 3874 typedef enum { 3875 __itt_e_first = 0, 3876 __itt_e_char = 0, /* 1-byte integer */ 3877 __itt_e_uchar, /* 1-byte unsigned integer */ 3878 __itt_e_int16, /* 2-byte integer */ 3879 __itt_e_uint16, /* 2-byte unsigned integer */ 3880 __itt_e_int32, /* 4-byte integer */ 3881 __itt_e_uint32, /* 4-byte unsigned integer */ 3882 __itt_e_int64, /* 8-byte integer */ 3883 __itt_e_uint64, /* 8-byte unsigned integer */ 3884 __itt_e_float, /* 4-byte floating */ 3885 __itt_e_double, /* 8-byte floating */ 3886 __itt_e_last = __itt_e_double 3887 } __itt_av_data_type; 3888 3889 /** 3890 * @brief Save an array data to a file. 3891 * Output format is defined by the file extension. The csv and bmp formats are 3892 * supported (bmp - for 2-dimensional array only). 3893 * @param[in] data - pointer to the array data 3894 * @param[in] rank - the rank of the array 3895 * @param[in] dimensions - pointer to an array of integers, which specifies the 3896 * array dimensions. The size of dimensions must be equal to the rank 3897 * @param[in] type - the type of the array, specified as one of the 3898 * __itt_av_data_type values (for intrinsic types) 3899 * @param[in] filePath - the file path; the output format is defined by the file 3900 * extension 3901 * @param[in] columnOrder - defines how the array is stored in the linear 3902 * memory. It should be 1 for column-major order (e.g. in FORTRAN) or 0 - for 3903 * row-major order (e.g. in C). 3904 */ 3905 3906 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3907 int ITTAPI __itt_av_saveA(void *data, int rank, const int *dimensions, int type, 3908 const char *filePath, int columnOrder); 3909 int ITTAPI __itt_av_saveW(void *data, int rank, const int *dimensions, int type, 3910 const wchar_t *filePath, int columnOrder); 3911 #if defined(UNICODE) || defined(_UNICODE) 3912 #define __itt_av_save __itt_av_saveW 3913 #define __itt_av_save_ptr __itt_av_saveW_ptr 3914 #else /* UNICODE */ 3915 #define __itt_av_save __itt_av_saveA 3916 #define __itt_av_save_ptr __itt_av_saveA_ptr 3917 #endif /* UNICODE */ 3918 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3919 int ITTAPI __itt_av_save(void *data, int rank, const int *dimensions, int type, 3920 const char *filePath, int columnOrder); 3921 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3922 3923 /** @cond exclude_from_documentation */ 3924 #ifndef INTEL_NO_MACRO_BODY 3925 #ifndef INTEL_NO_ITTNOTIFY_API 3926 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3927 ITT_STUB(ITTAPI, int, av_saveA, 3928 (void *data, int rank, const int *dimensions, int type, 3929 const char *filePath, int columnOrder)) 3930 ITT_STUB(ITTAPI, int, av_saveW, 3931 (void *data, int rank, const int *dimensions, int type, 3932 const wchar_t *filePath, int columnOrder)) 3933 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3934 ITT_STUB(ITTAPI, int, av_save, 3935 (void *data, int rank, const int *dimensions, int type, 3936 const char *filePath, int columnOrder)) 3937 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3938 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3939 #define __itt_av_saveA ITTNOTIFY_DATA(av_saveA) 3940 #define __itt_av_saveA_ptr ITTNOTIFY_NAME(av_saveA) 3941 #define __itt_av_saveW ITTNOTIFY_DATA(av_saveW) 3942 #define __itt_av_saveW_ptr ITTNOTIFY_NAME(av_saveW) 3943 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3944 #define __itt_av_save ITTNOTIFY_DATA(av_save) 3945 #define __itt_av_save_ptr ITTNOTIFY_NAME(av_save) 3946 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3947 #else /* INTEL_NO_ITTNOTIFY_API */ 3948 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3949 #define __itt_av_saveA(name) 3950 #define __itt_av_saveA_ptr 0 3951 #define __itt_av_saveW(name) 3952 #define __itt_av_saveW_ptr 0 3953 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3954 #define __itt_av_save(name) 3955 #define __itt_av_save_ptr 0 3956 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3957 #endif /* INTEL_NO_ITTNOTIFY_API */ 3958 #else /* INTEL_NO_MACRO_BODY */ 3959 #if ITT_PLATFORM == ITT_PLATFORM_WIN 3960 #define __itt_av_saveA_ptr 0 3961 #define __itt_av_saveW_ptr 0 3962 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3963 #define __itt_av_save_ptr 0 3964 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 3965 #endif /* INTEL_NO_MACRO_BODY */ 3966 /** @endcond */ 3967 3968 void ITTAPI __itt_enable_attach(void); 3969 3970 /** @cond exclude_from_documentation */ 3971 #ifndef INTEL_NO_MACRO_BODY 3972 #ifndef INTEL_NO_ITTNOTIFY_API 3973 ITT_STUBV(ITTAPI, void, enable_attach, (void)) 3974 #define __itt_enable_attach ITTNOTIFY_VOID(enable_attach) 3975 #define __itt_enable_attach_ptr ITTNOTIFY_NAME(enable_attach) 3976 #else /* INTEL_NO_ITTNOTIFY_API */ 3977 #define __itt_enable_attach() 3978 #define __itt_enable_attach_ptr 0 3979 #endif /* INTEL_NO_ITTNOTIFY_API */ 3980 #else /* INTEL_NO_MACRO_BODY */ 3981 #define __itt_enable_attach_ptr 0 3982 #endif /* INTEL_NO_MACRO_BODY */ 3983 /** @endcond */ 3984 3985 /** @cond exclude_from_gpa_documentation */ 3986 3987 /** @} arrays group */ 3988 3989 /** @endcond */ 3990 3991 /** 3992 * @brief Module load notification 3993 * This API is used to report necessary information in case of bypassing default 3994 * system loader. Notification should be done immidiatelly after this module is 3995 * loaded to process memory. 3996 * @param[in] start_addr - module start address 3997 * @param[in] end_addr - module end address 3998 * @param[in] path - file system full path to the module 3999 */ 4000 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4001 void ITTAPI __itt_module_loadA(void *start_addr, void *end_addr, 4002 const char *path); 4003 void ITTAPI __itt_module_loadW(void *start_addr, void *end_addr, 4004 const wchar_t *path); 4005 #if defined(UNICODE) || defined(_UNICODE) 4006 #define __itt_module_load __itt_module_loadW 4007 #define __itt_module_load_ptr __itt_module_loadW_ptr 4008 #else /* UNICODE */ 4009 #define __itt_module_load __itt_module_loadA 4010 #define __itt_module_load_ptr __itt_module_loadA_ptr 4011 #endif /* UNICODE */ 4012 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4013 void ITTAPI __itt_module_load(void *start_addr, void *end_addr, 4014 const char *path); 4015 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4016 4017 /** @cond exclude_from_documentation */ 4018 #ifndef INTEL_NO_MACRO_BODY 4019 #ifndef INTEL_NO_ITTNOTIFY_API 4020 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4021 ITT_STUB(ITTAPI, void, module_loadA, 4022 (void *start_addr, void *end_addr, const char *path)) 4023 ITT_STUB(ITTAPI, void, module_loadW, 4024 (void *start_addr, void *end_addr, const wchar_t *path)) 4025 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4026 ITT_STUB(ITTAPI, void, module_load, 4027 (void *start_addr, void *end_addr, const char *path)) 4028 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4029 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4030 #define __itt_module_loadA ITTNOTIFY_VOID(module_loadA) 4031 #define __itt_module_loadA_ptr ITTNOTIFY_NAME(module_loadA) 4032 #define __itt_module_loadW ITTNOTIFY_VOID(module_loadW) 4033 #define __itt_module_loadW_ptr ITTNOTIFY_NAME(module_loadW) 4034 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4035 #define __itt_module_load ITTNOTIFY_VOID(module_load) 4036 #define __itt_module_load_ptr ITTNOTIFY_NAME(module_load) 4037 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4038 #else /* INTEL_NO_ITTNOTIFY_API */ 4039 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4040 #define __itt_module_loadA(start_addr, end_addr, path) 4041 #define __itt_module_loadA_ptr 0 4042 #define __itt_module_loadW(start_addr, end_addr, path) 4043 #define __itt_module_loadW_ptr 0 4044 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4045 #define __itt_module_load(start_addr, end_addr, path) 4046 #define __itt_module_load_ptr 0 4047 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4048 #endif /* INTEL_NO_ITTNOTIFY_API */ 4049 #else /* INTEL_NO_MACRO_BODY */ 4050 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4051 #define __itt_module_loadA_ptr 0 4052 #define __itt_module_loadW_ptr 0 4053 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4054 #define __itt_module_load_ptr 0 4055 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4056 #endif /* INTEL_NO_MACRO_BODY */ 4057 /** @endcond */ 4058 4059 /** 4060 * @brief Report module unload 4061 * This API is used to report necessary information in case of bypassing default 4062 * system loader. Notification should be done just before the module is unloaded 4063 * from process memory. 4064 * @param[in] addr - base address of loaded module 4065 */ 4066 void ITTAPI __itt_module_unload(void *addr); 4067 4068 /** @cond exclude_from_documentation */ 4069 #ifndef INTEL_NO_MACRO_BODY 4070 #ifndef INTEL_NO_ITTNOTIFY_API 4071 ITT_STUBV(ITTAPI, void, module_unload, (void *addr)) 4072 #define __itt_module_unload ITTNOTIFY_VOID(module_unload) 4073 #define __itt_module_unload_ptr ITTNOTIFY_NAME(module_unload) 4074 #else /* INTEL_NO_ITTNOTIFY_API */ 4075 #define __itt_module_unload(addr) 4076 #define __itt_module_unload_ptr 0 4077 #endif /* INTEL_NO_ITTNOTIFY_API */ 4078 #else /* INTEL_NO_MACRO_BODY */ 4079 #define __itt_module_unload_ptr 0 4080 #endif /* INTEL_NO_MACRO_BODY */ 4081 /** @endcond */ 4082 4083 /** @cond exclude_from_documentation */ 4084 typedef enum { 4085 __itt_module_type_unknown = 0, 4086 __itt_module_type_elf, 4087 __itt_module_type_coff 4088 } __itt_module_type; 4089 /** @endcond */ 4090 4091 /** @cond exclude_from_documentation */ 4092 typedef enum { 4093 itt_section_type_unknown, 4094 itt_section_type_bss, /* notifies that the section contains uninitialized 4095 * data. These are the relevant section types and the 4096 * modules that contain them: ELF module: SHT_NOBITS 4097 * section type COFF module: 4098 * IMAGE_SCN_CNT_UNINITIALIZED_DATA section type 4099 */ 4100 itt_section_type_data, /* notifies that section contains initialized data. 4101 * These are the relevant section types and the modules 4102 * that contain them: ELF module: SHT_PROGBITS section 4103 * type COFF module: IMAGE_SCN_CNT_INITIALIZED_DATA 4104 * section type 4105 */ 4106 itt_section_type_text /* notifies that the section contains executable code. 4107 * These are the relevant section types and the modules 4108 * that contain them: ELF module: SHT_PROGBITS section 4109 * type COFF module: IMAGE_SCN_CNT_CODE section type 4110 */ 4111 } __itt_section_type; 4112 /** @endcond */ 4113 4114 /** 4115 * @hideinitializer 4116 * @brief bit-mask, detects a section attribute that indicates whether a section 4117 * can be executed as code: These are the relevant section attributes and the 4118 * modules that contain them: ELF module: PF_X section attribute COFF module: 4119 * IMAGE_SCN_MEM_EXECUTE attribute 4120 */ 4121 #define __itt_section_exec 0x20000000 4122 4123 /** 4124 * @hideinitializer 4125 * @brief bit-mask, detects a section attribute that indicates whether a section 4126 * can be read. These are the relevant section attributes and the modules that 4127 * contain them: ELF module: PF_R attribute COFF module: IMAGE_SCN_MEM_READ 4128 * attribute 4129 */ 4130 #define __itt_section_read 0x40000000 4131 4132 /** 4133 * @hideinitializer 4134 * @brief bit-mask, detects a section attribute that indicates whether a section 4135 * can be written to. These are the relevant section attributes and the modules 4136 * that contain them: ELF module: PF_W attribute COFF module: 4137 * IMAGE_SCN_MEM_WRITE attribute 4138 */ 4139 #define __itt_section_write 0x80000000 4140 4141 /** @cond exclude_from_documentation */ 4142 #pragma pack(push, 8) 4143 4144 typedef struct ___itt_section_info { 4145 const char *name; /*!< Section name in UTF8 */ 4146 __itt_section_type type; /*!< Section content and semantics description */ 4147 size_t flags; /*!< Section bit flags that describe attributes using bit mask 4148 * Zero if disabled, non-zero if enabled 4149 */ 4150 void *start_addr; /*!< Section load(relocated) start address */ 4151 size_t size; /*!< Section file offset */ 4152 size_t file_offset; /*!< Section size */ 4153 } __itt_section_info; 4154 4155 #pragma pack(pop) 4156 /** @endcond */ 4157 4158 /** @cond exclude_from_documentation */ 4159 #pragma pack(push, 8) 4160 4161 typedef struct ___itt_module_object { 4162 unsigned int version; /*!< API version*/ 4163 __itt_id module_id; /*!< Unique identifier. This is unchanged for sections 4164 that belong to the same module */ 4165 __itt_module_type module_type; /*!< Binary module format */ 4166 const char *module_name; /*!< Unique module name or path to module in UTF8 4167 * Contains module name when module_bufer and 4168 * module_size exist Contains module path when 4169 * module_bufer and module_size absent module_name 4170 * remains the same for the certain module_id 4171 */ 4172 void *module_buffer; /*!< Module buffer content */ 4173 size_t module_size; /*!< Module buffer size */ 4174 /*!< If module_buffer and module_size exist, the binary module is dumped onto 4175 * the system. If module_buffer and module_size do not exist, the binary 4176 * module exists on the system already. The module_name parameter contains the 4177 * path to the module. 4178 */ 4179 __itt_section_info *section_array; /*!< Reference to section information */ 4180 size_t section_number; 4181 } __itt_module_object; 4182 4183 #pragma pack(pop) 4184 /** @endcond */ 4185 4186 /** 4187 * @brief Load module content and its loaded(relocated) sections. 4188 * This API is useful to save a module, or specify its location on the system 4189 * and report information about loaded sections. The target module is saved on 4190 * the system if module buffer content and size are available. If module buffer 4191 * content and size are unavailable, the module name contains the path to the 4192 * existing binary module. 4193 * @param[in] module_obj - provides module and section information, along with 4194 * unique module identifiers (name,module ID) which bind the binary module to 4195 * particular sections. 4196 */ 4197 void ITTAPI __itt_module_load_with_sections(__itt_module_object *module_obj); 4198 4199 /** @cond exclude_from_documentation */ 4200 #ifndef INTEL_NO_MACRO_BODY 4201 #ifndef INTEL_NO_ITTNOTIFY_API 4202 ITT_STUBV(ITTAPI, void, module_load_with_sections, 4203 (__itt_module_object * module_obj)) 4204 #define __itt_module_load_with_sections \ 4205 ITTNOTIFY_VOID(module_load_with_sections) 4206 #define __itt_module_load_with_sections_ptr \ 4207 ITTNOTIFY_NAME(module_load_with_sections) 4208 #else /* INTEL_NO_ITTNOTIFY_API */ 4209 #define __itt_module_load_with_sections(module_obj) 4210 #define __itt_module_load_with_sections_ptr 0 4211 #endif /* INTEL_NO_ITTNOTIFY_API */ 4212 #else /* INTEL_NO_MACRO_BODY */ 4213 #define __itt_module_load_with_sections_ptr 0 4214 #endif /* INTEL_NO_MACRO_BODY */ 4215 /** @endcond */ 4216 4217 /** 4218 * @brief Unload a module and its loaded(relocated) sections. 4219 * This API notifies that the module and its sections were unloaded. 4220 * @param[in] module_obj - provides module and sections information, along with 4221 * unique module identifiers (name,module ID) which bind the binary module to 4222 * particular sections. 4223 */ 4224 void ITTAPI __itt_module_unload_with_sections(__itt_module_object *module_obj); 4225 4226 /** @cond exclude_from_documentation */ 4227 #ifndef INTEL_NO_MACRO_BODY 4228 #ifndef INTEL_NO_ITTNOTIFY_API 4229 ITT_STUBV(ITTAPI, void, module_unload_with_sections, 4230 (__itt_module_object * module_obj)) 4231 #define __itt_module_unload_with_sections \ 4232 ITTNOTIFY_VOID(module_unload_with_sections) 4233 #define __itt_module_unload_with_sections_ptr \ 4234 ITTNOTIFY_NAME(module_unload_with_sections) 4235 #else /* INTEL_NO_ITTNOTIFY_API */ 4236 #define __itt_module_unload_with_sections(module_obj) 4237 #define __itt_module_unload_with_sections_ptr 0 4238 #endif /* INTEL_NO_ITTNOTIFY_API */ 4239 #else /* INTEL_NO_MACRO_BODY */ 4240 #define __itt_module_unload_with_sections_ptr 0 4241 #endif /* INTEL_NO_MACRO_BODY */ 4242 /** @endcond */ 4243 4244 /** @cond exclude_from_documentation */ 4245 #pragma pack(push, 8) 4246 4247 typedef struct ___itt_histogram { 4248 const __itt_domain *domain; /*!< Domain of the histogram*/ 4249 const char *nameA; /*!< Name of the histogram */ 4250 #if defined(UNICODE) || defined(_UNICODE) 4251 const wchar_t *nameW; 4252 #else /* UNICODE || _UNICODE */ 4253 void *nameW; 4254 #endif /* UNICODE || _UNICODE */ 4255 __itt_metadata_type x_type; /*!< Type of the histogram X axis */ 4256 __itt_metadata_type y_type; /*!< Type of the histogram Y axis */ 4257 int extra1; /*!< Reserved to the runtime */ 4258 void *extra2; /*!< Reserved to the runtime */ 4259 struct ___itt_histogram *next; 4260 } __itt_histogram; 4261 4262 #pragma pack(pop) 4263 /** @endcond */ 4264 4265 /** 4266 * @brief Create a typed histogram instance with given name/domain. 4267 * @param[in] domain The domain controlling the call. 4268 * @param[in] name The name of the histogram. 4269 * @param[in] x_type The type of the X axis in histogram (may be 0 to calculate 4270 * batch statistics). 4271 * @param[in] y_type The type of the Y axis in histogram. 4272 */ 4273 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4274 __itt_histogram *ITTAPI __itt_histogram_createA(const __itt_domain *domain, 4275 const char *name, 4276 __itt_metadata_type x_type, 4277 __itt_metadata_type y_type); 4278 __itt_histogram *ITTAPI __itt_histogram_createW(const __itt_domain *domain, 4279 const wchar_t *name, 4280 __itt_metadata_type x_type, 4281 __itt_metadata_type y_type); 4282 #if defined(UNICODE) || defined(_UNICODE) 4283 #define __itt_histogram_create __itt_histogram_createW 4284 #define __itt_histogram_create_ptr __itt_histogram_createW_ptr 4285 #else /* UNICODE */ 4286 #define __itt_histogram_create __itt_histogram_createA 4287 #define __itt_histogram_create_ptr __itt_histogram_createA_ptr 4288 #endif /* UNICODE */ 4289 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4290 __itt_histogram *ITTAPI __itt_histogram_create(const __itt_domain *domain, 4291 const char *name, 4292 __itt_metadata_type x_type, 4293 __itt_metadata_type y_type); 4294 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4295 4296 /** @cond exclude_from_documentation */ 4297 #ifndef INTEL_NO_MACRO_BODY 4298 #ifndef INTEL_NO_ITTNOTIFY_API 4299 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4300 ITT_STUB(ITTAPI, __itt_histogram *, histogram_createA, 4301 (const __itt_domain *domain, const char *name, 4302 __itt_metadata_type x_type, __itt_metadata_type y_type)) 4303 ITT_STUB(ITTAPI, __itt_histogram *, histogram_createW, 4304 (const __itt_domain *domain, const wchar_t *name, 4305 __itt_metadata_type x_type, __itt_metadata_type y_type)) 4306 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4307 ITT_STUB(ITTAPI, __itt_histogram *, histogram_create, 4308 (const __itt_domain *domain, const char *name, 4309 __itt_metadata_type x_type, __itt_metadata_type y_type)) 4310 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4311 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4312 #define __itt_histogram_createA ITTNOTIFY_DATA(histogram_createA) 4313 #define __itt_histogram_createA_ptr ITTNOTIFY_NAME(histogram_createA) 4314 #define __itt_histogram_createW ITTNOTIFY_DATA(histogram_createW) 4315 #define __itt_histogram_createW_ptr ITTNOTIFY_NAME(histogram_createW) 4316 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4317 #define __itt_histogram_create ITTNOTIFY_DATA(histogram_create) 4318 #define __itt_histogram_create_ptr ITTNOTIFY_NAME(histogram_create) 4319 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4320 #else /* INTEL_NO_ITTNOTIFY_API */ 4321 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4322 #define __itt_histogram_createA(domain, name, x_type, y_type) \ 4323 (__itt_histogram *)0 4324 #define __itt_histogram_createA_ptr 0 4325 #define __itt_histogram_createW(domain, name, x_type, y_type) \ 4326 (__itt_histogram *)0 4327 #define __itt_histogram_createW_ptr 0 4328 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4329 #define __itt_histogram_create(domain, name, x_type, y_type) \ 4330 (__itt_histogram *)0 4331 #define __itt_histogram_create_ptr 0 4332 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4333 #endif /* INTEL_NO_ITTNOTIFY_API */ 4334 #else /* INTEL_NO_MACRO_BODY */ 4335 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4336 #define __itt_histogram_createA_ptr 0 4337 #define __itt_histogram_createW_ptr 0 4338 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4339 #define __itt_histogram_create_ptr 0 4340 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4341 #endif /* INTEL_NO_MACRO_BODY */ 4342 /** @endcond */ 4343 4344 /** 4345 * @brief Submit statistics for a histogram instance. 4346 * @param[in] hist Pointer to the histogram instance to which the histogram 4347 * statistic is to be dumped. 4348 * @param[in] length The number of elements in dumped axis data array. 4349 * @param[in] x_data The X axis dumped data itself (may be NULL to calculate 4350 * batch statistics). 4351 * @param[in] y_data The Y axis dumped data itself. 4352 */ 4353 void ITTAPI __itt_histogram_submit(__itt_histogram *hist, size_t length, 4354 void *x_data, void *y_data); 4355 4356 /** @cond exclude_from_documentation */ 4357 #ifndef INTEL_NO_MACRO_BODY 4358 #ifndef INTEL_NO_ITTNOTIFY_API 4359 ITT_STUBV(ITTAPI, void, histogram_submit, 4360 (__itt_histogram * hist, size_t length, void *x_data, void *y_data)) 4361 #define __itt_histogram_submit ITTNOTIFY_VOID(histogram_submit) 4362 #define __itt_histogram_submit_ptr ITTNOTIFY_NAME(histogram_submit) 4363 #else /* INTEL_NO_ITTNOTIFY_API */ 4364 #define __itt_histogram_submit(hist, length, x_data, y_data) 4365 #define __itt_histogram_submit_ptr 0 4366 #endif /* INTEL_NO_ITTNOTIFY_API */ 4367 #else /* INTEL_NO_MACRO_BODY */ 4368 #define __itt_histogram_submit_ptr 0 4369 #endif /* INTEL_NO_MACRO_BODY */ 4370 /** @endcond */ 4371 4372 #ifdef __cplusplus 4373 } 4374 #endif /* __cplusplus */ 4375 4376 #endif /* _ITTNOTIFY_H_ */ 4377 4378 #ifdef INTEL_ITTNOTIFY_API_PRIVATE 4379 4380 #ifndef _ITTNOTIFY_PRIVATE_ 4381 #define _ITTNOTIFY_PRIVATE_ 4382 4383 #ifdef __cplusplus 4384 extern "C" { 4385 #endif /* __cplusplus */ 4386 4387 /** 4388 * @ingroup clockdomain 4389 * @brief Begin an overlapped task instance. 4390 * @param[in] domain The domain for this task 4391 * @param[in] clock_domain The clock domain controlling the execution of this 4392 * call. 4393 * @param[in] timestamp The user defined timestamp. 4394 * @param[in] taskid The identifier for this task instance, *cannot* be 4395 * __itt_null. 4396 * @param[in] parentid The parent of this task, or __itt_null. 4397 * @param[in] name The name of this task. 4398 */ 4399 void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain *domain, 4400 __itt_clock_domain *clock_domain, 4401 unsigned long long timestamp, 4402 __itt_id taskid, __itt_id parentid, 4403 __itt_string_handle *name); 4404 4405 /** 4406 * @ingroup clockdomain 4407 * @brief End an overlapped task instance. 4408 * @param[in] domain The domain for this task 4409 * @param[in] clock_domain The clock domain controlling the execution of this 4410 * call. 4411 * @param[in] timestamp The user defined timestamp. 4412 * @param[in] taskid Explicit ID of finished task 4413 */ 4414 void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain *domain, 4415 __itt_clock_domain *clock_domain, 4416 unsigned long long timestamp, 4417 __itt_id taskid); 4418 4419 /** @cond exclude_from_documentation */ 4420 #ifndef INTEL_NO_MACRO_BODY 4421 #ifndef INTEL_NO_ITTNOTIFY_API 4422 ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex, 4423 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 4424 unsigned long long timestamp, __itt_id taskid, __itt_id parentid, 4425 __itt_string_handle *name)) 4426 ITT_STUBV(ITTAPI, void, task_end_overlapped_ex, 4427 (const __itt_domain *domain, __itt_clock_domain *clock_domain, 4428 unsigned long long timestamp, __itt_id taskid)) 4429 #define __itt_task_begin_overlapped_ex(d, x, y, z, a, b) \ 4430 ITTNOTIFY_VOID_D5(task_begin_overlapped_ex, d, x, y, z, a, b) 4431 #define __itt_task_begin_overlapped_ex_ptr \ 4432 ITTNOTIFY_NAME(task_begin_overlapped_ex) 4433 #define __itt_task_end_overlapped_ex(d, x, y, z) \ 4434 ITTNOTIFY_VOID_D3(task_end_overlapped_ex, d, x, y, z) 4435 #define __itt_task_end_overlapped_ex_ptr ITTNOTIFY_NAME(task_end_overlapped_ex) 4436 #else /* INTEL_NO_ITTNOTIFY_API */ 4437 #define __itt_task_begin_overlapped_ex(domain, clock_domain, timestamp, \ 4438 taskid, parentid, name) 4439 #define __itt_task_begin_overlapped_ex_ptr 0 4440 #define __itt_task_end_overlapped_ex(domain, clock_domain, timestamp, taskid) 4441 #define __itt_task_end_overlapped_ex_ptr 0 4442 #endif /* INTEL_NO_ITTNOTIFY_API */ 4443 #else /* INTEL_NO_MACRO_BODY */ 4444 #define __itt_task_begin_overlapped_ex_ptr 0 4445 #define __itt_task_end_overlapped_ptr 0 4446 #define __itt_task_end_overlapped_ex_ptr 0 4447 #endif /* INTEL_NO_MACRO_BODY */ 4448 /** @endcond */ 4449 4450 /** 4451 * @defgroup makrs_internal Marks 4452 * @ingroup internal 4453 * Marks group 4454 * @warning Internal API: 4455 * - It is not shipped to outside of Intel 4456 * - It is delivered to internal Intel teams using e-mail or SVN access only 4457 * @{ 4458 */ 4459 /** @brief user mark type */ 4460 typedef int __itt_mark_type; 4461 4462 /** 4463 * @brief Creates a user mark type with the specified name using char or Unicode 4464 * string. 4465 * @param[in] name - name of mark to create 4466 * @return Returns a handle to the mark type 4467 */ 4468 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4469 __itt_mark_type ITTAPI __itt_mark_createA(const char *name); 4470 __itt_mark_type ITTAPI __itt_mark_createW(const wchar_t *name); 4471 #if defined(UNICODE) || defined(_UNICODE) 4472 #define __itt_mark_create __itt_mark_createW 4473 #define __itt_mark_create_ptr __itt_mark_createW_ptr 4474 #else /* UNICODE */ 4475 #define __itt_mark_create __itt_mark_createA 4476 #define __itt_mark_create_ptr __itt_mark_createA_ptr 4477 #endif /* UNICODE */ 4478 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4479 __itt_mark_type ITTAPI __itt_mark_create(const char *name); 4480 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4481 4482 /** @cond exclude_from_documentation */ 4483 #ifndef INTEL_NO_MACRO_BODY 4484 #ifndef INTEL_NO_ITTNOTIFY_API 4485 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4486 ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name)) 4487 ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name)) 4488 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4489 ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name)) 4490 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4491 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4492 #define __itt_mark_createA ITTNOTIFY_DATA(mark_createA) 4493 #define __itt_mark_createA_ptr ITTNOTIFY_NAME(mark_createA) 4494 #define __itt_mark_createW ITTNOTIFY_DATA(mark_createW) 4495 #define __itt_mark_createW_ptr ITTNOTIFY_NAME(mark_createW) 4496 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4497 #define __itt_mark_create ITTNOTIFY_DATA(mark_create) 4498 #define __itt_mark_create_ptr ITTNOTIFY_NAME(mark_create) 4499 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4500 #else /* INTEL_NO_ITTNOTIFY_API */ 4501 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4502 #define __itt_mark_createA(name) (__itt_mark_type)0 4503 #define __itt_mark_createA_ptr 0 4504 #define __itt_mark_createW(name) (__itt_mark_type)0 4505 #define __itt_mark_createW_ptr 0 4506 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4507 #define __itt_mark_create(name) (__itt_mark_type)0 4508 #define __itt_mark_create_ptr 0 4509 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4510 #endif /* INTEL_NO_ITTNOTIFY_API */ 4511 #else /* INTEL_NO_MACRO_BODY */ 4512 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4513 #define __itt_mark_createA_ptr 0 4514 #define __itt_mark_createW_ptr 0 4515 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4516 #define __itt_mark_create_ptr 0 4517 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4518 #endif /* INTEL_NO_MACRO_BODY */ 4519 /** @endcond */ 4520 4521 /** 4522 * @brief Creates a "discrete" user mark type of the specified type and an 4523 * optional parameter using char or Unicode string. 4524 * 4525 * - The mark of "discrete" type is placed to collection results in case of 4526 * success. It appears in overtime view(s) as a special tick sign. 4527 * - The call is "synchronous" - function returns after mark is actually added 4528 * to results. 4529 * - This function is useful, for example, to mark different phases of 4530 * application (beginning of the next mark automatically meand end of current 4531 * region). 4532 * - Can be used together with "continuous" marks (see below) at the same 4533 * collection session 4534 * @param[in] mt - mark, created by __itt_mark_create(const char* name) function 4535 * @param[in] parameter - string parameter of mark 4536 * @return Returns zero value in case of success, non-zero value otherwise. 4537 */ 4538 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4539 int ITTAPI __itt_markA(__itt_mark_type mt, const char *parameter); 4540 int ITTAPI __itt_markW(__itt_mark_type mt, const wchar_t *parameter); 4541 #if defined(UNICODE) || defined(_UNICODE) 4542 #define __itt_mark __itt_markW 4543 #define __itt_mark_ptr __itt_markW_ptr 4544 #else /* UNICODE */ 4545 #define __itt_mark __itt_markA 4546 #define __itt_mark_ptr __itt_markA_ptr 4547 #endif /* UNICODE */ 4548 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4549 int ITTAPI __itt_mark(__itt_mark_type mt, const char *parameter); 4550 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4551 4552 /** @cond exclude_from_documentation */ 4553 #ifndef INTEL_NO_MACRO_BODY 4554 #ifndef INTEL_NO_ITTNOTIFY_API 4555 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4556 ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter)) 4557 ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter)) 4558 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4559 ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter)) 4560 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4561 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4562 #define __itt_markA ITTNOTIFY_DATA(markA) 4563 #define __itt_markA_ptr ITTNOTIFY_NAME(markA) 4564 #define __itt_markW ITTNOTIFY_DATA(markW) 4565 #define __itt_markW_ptr ITTNOTIFY_NAME(markW) 4566 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4567 #define __itt_mark ITTNOTIFY_DATA(mark) 4568 #define __itt_mark_ptr ITTNOTIFY_NAME(mark) 4569 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4570 #else /* INTEL_NO_ITTNOTIFY_API */ 4571 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4572 #define __itt_markA(mt, parameter) (int)0 4573 #define __itt_markA_ptr 0 4574 #define __itt_markW(mt, parameter) (int)0 4575 #define __itt_markW_ptr 0 4576 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4577 #define __itt_mark(mt, parameter) (int)0 4578 #define __itt_mark_ptr 0 4579 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4580 #endif /* INTEL_NO_ITTNOTIFY_API */ 4581 #else /* INTEL_NO_MACRO_BODY */ 4582 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4583 #define __itt_markA_ptr 0 4584 #define __itt_markW_ptr 0 4585 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4586 #define __itt_mark_ptr 0 4587 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4588 #endif /* INTEL_NO_MACRO_BODY */ 4589 /** @endcond */ 4590 4591 /** 4592 * @brief Use this if necessary to create a "discrete" user event type (mark) 4593 * for process rather then for one thread 4594 * @see int __itt_mark(__itt_mark_type mt, const char* parameter); 4595 */ 4596 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4597 int ITTAPI __itt_mark_globalA(__itt_mark_type mt, const char *parameter); 4598 int ITTAPI __itt_mark_globalW(__itt_mark_type mt, const wchar_t *parameter); 4599 #if defined(UNICODE) || defined(_UNICODE) 4600 #define __itt_mark_global __itt_mark_globalW 4601 #define __itt_mark_global_ptr __itt_mark_globalW_ptr 4602 #else /* UNICODE */ 4603 #define __itt_mark_global __itt_mark_globalA 4604 #define __itt_mark_global_ptr __itt_mark_globalA_ptr 4605 #endif /* UNICODE */ 4606 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4607 int ITTAPI __itt_mark_global(__itt_mark_type mt, const char *parameter); 4608 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4609 4610 /** @cond exclude_from_documentation */ 4611 #ifndef INTEL_NO_MACRO_BODY 4612 #ifndef INTEL_NO_ITTNOTIFY_API 4613 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4614 ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter)) 4615 ITT_STUB(ITTAPI, int, mark_globalW, 4616 (__itt_mark_type mt, const wchar_t *parameter)) 4617 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4618 ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter)) 4619 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4620 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4621 #define __itt_mark_globalA ITTNOTIFY_DATA(mark_globalA) 4622 #define __itt_mark_globalA_ptr ITTNOTIFY_NAME(mark_globalA) 4623 #define __itt_mark_globalW ITTNOTIFY_DATA(mark_globalW) 4624 #define __itt_mark_globalW_ptr ITTNOTIFY_NAME(mark_globalW) 4625 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4626 #define __itt_mark_global ITTNOTIFY_DATA(mark_global) 4627 #define __itt_mark_global_ptr ITTNOTIFY_NAME(mark_global) 4628 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4629 #else /* INTEL_NO_ITTNOTIFY_API */ 4630 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4631 #define __itt_mark_globalA(mt, parameter) (int)0 4632 #define __itt_mark_globalA_ptr 0 4633 #define __itt_mark_globalW(mt, parameter) (int)0 4634 #define __itt_mark_globalW_ptr 0 4635 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4636 #define __itt_mark_global(mt, parameter) (int)0 4637 #define __itt_mark_global_ptr 0 4638 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4639 #endif /* INTEL_NO_ITTNOTIFY_API */ 4640 #else /* INTEL_NO_MACRO_BODY */ 4641 #if ITT_PLATFORM == ITT_PLATFORM_WIN 4642 #define __itt_mark_globalA_ptr 0 4643 #define __itt_mark_globalW_ptr 0 4644 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4645 #define __itt_mark_global_ptr 0 4646 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ 4647 #endif /* INTEL_NO_MACRO_BODY */ 4648 /** @endcond */ 4649 4650 /** 4651 * @brief Creates an "end" point for "continuous" mark with specified name. 4652 * 4653 * - Returns zero value in case of success, non-zero value otherwise. 4654 * Also returns non-zero value when preceding "begin" point for the 4655 * mark with the same name failed to be created or not created. 4656 * - The mark of "continuous" type is placed to collection results in 4657 * case of success. It appears in overtime view(s) as a special tick 4658 * sign (different from "discrete" mark) together with line from 4659 * corresponding "begin" mark to "end" mark. 4660 * @note Continuous marks can overlap and be nested inside each other. 4661 * Discrete mark can be nested inside marked region 4662 * @param[in] mt - mark, created by __itt_mark_create(const char* name) function 4663 * @return Returns zero value in case of success, non-zero value otherwise. 4664 */ 4665 int ITTAPI __itt_mark_off(__itt_mark_type mt); 4666 4667 /** @cond exclude_from_documentation */ 4668 #ifndef INTEL_NO_MACRO_BODY 4669 #ifndef INTEL_NO_ITTNOTIFY_API 4670 ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt)) 4671 #define __itt_mark_off ITTNOTIFY_DATA(mark_off) 4672 #define __itt_mark_off_ptr ITTNOTIFY_NAME(mark_off) 4673 #else /* INTEL_NO_ITTNOTIFY_API */ 4674 #define __itt_mark_off(mt) (int)0 4675 #define __itt_mark_off_ptr 0 4676 #endif /* INTEL_NO_ITTNOTIFY_API */ 4677 #else /* INTEL_NO_MACRO_BODY */ 4678 #define __itt_mark_off_ptr 0 4679 #endif /* INTEL_NO_MACRO_BODY */ 4680 /** @endcond */ 4681 4682 /** 4683 * @brief Use this if necessary to create an "end" point for mark of process 4684 * @see int __itt_mark_off(__itt_mark_type mt); 4685 */ 4686 int ITTAPI __itt_mark_global_off(__itt_mark_type mt); 4687 4688 /** @cond exclude_from_documentation */ 4689 #ifndef INTEL_NO_MACRO_BODY 4690 #ifndef INTEL_NO_ITTNOTIFY_API 4691 ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt)) 4692 #define __itt_mark_global_off ITTNOTIFY_DATA(mark_global_off) 4693 #define __itt_mark_global_off_ptr ITTNOTIFY_NAME(mark_global_off) 4694 #else /* INTEL_NO_ITTNOTIFY_API */ 4695 #define __itt_mark_global_off(mt) (int)0 4696 #define __itt_mark_global_off_ptr 0 4697 #endif /* INTEL_NO_ITTNOTIFY_API */ 4698 #else /* INTEL_NO_MACRO_BODY */ 4699 #define __itt_mark_global_off_ptr 0 4700 #endif /* INTEL_NO_MACRO_BODY */ 4701 /** @endcond */ 4702 /** @} marks group */ 4703 4704 /** 4705 * @defgroup counters_internal Counters 4706 * @ingroup internal 4707 * Counters group 4708 * @{ 4709 */ 4710 4711 /** 4712 * @defgroup stitch Stack Stitching 4713 * @ingroup internal 4714 * Stack Stitching group 4715 * @{ 4716 */ 4717 /** 4718 * @brief opaque structure for counter identification 4719 */ 4720 typedef struct ___itt_caller *__itt_caller; 4721 4722 /** 4723 * @brief Create the stitch point e.g. a point in call stack where other stacks 4724 * should be stitched to. The function returns a unique identifier which is used 4725 * to match the cut points with corresponding stitch points. 4726 */ 4727 __itt_caller ITTAPI __itt_stack_caller_create(void); 4728 4729 /** @cond exclude_from_documentation */ 4730 #ifndef INTEL_NO_MACRO_BODY 4731 #ifndef INTEL_NO_ITTNOTIFY_API 4732 ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void)) 4733 #define __itt_stack_caller_create ITTNOTIFY_DATA(stack_caller_create) 4734 #define __itt_stack_caller_create_ptr ITTNOTIFY_NAME(stack_caller_create) 4735 #else /* INTEL_NO_ITTNOTIFY_API */ 4736 #define __itt_stack_caller_create() (__itt_caller)0 4737 #define __itt_stack_caller_create_ptr 0 4738 #endif /* INTEL_NO_ITTNOTIFY_API */ 4739 #else /* INTEL_NO_MACRO_BODY */ 4740 #define __itt_stack_caller_create_ptr 0 4741 #endif /* INTEL_NO_MACRO_BODY */ 4742 /** @endcond */ 4743 4744 /** 4745 * @brief Destroy the information about stitch point identified by the pointer 4746 * previously returned by __itt_stack_caller_create() 4747 */ 4748 void ITTAPI __itt_stack_caller_destroy(__itt_caller id); 4749 4750 /** @cond exclude_from_documentation */ 4751 #ifndef INTEL_NO_MACRO_BODY 4752 #ifndef INTEL_NO_ITTNOTIFY_API 4753 ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id)) 4754 #define __itt_stack_caller_destroy ITTNOTIFY_VOID(stack_caller_destroy) 4755 #define __itt_stack_caller_destroy_ptr ITTNOTIFY_NAME(stack_caller_destroy) 4756 #else /* INTEL_NO_ITTNOTIFY_API */ 4757 #define __itt_stack_caller_destroy(id) 4758 #define __itt_stack_caller_destroy_ptr 0 4759 #endif /* INTEL_NO_ITTNOTIFY_API */ 4760 #else /* INTEL_NO_MACRO_BODY */ 4761 #define __itt_stack_caller_destroy_ptr 0 4762 #endif /* INTEL_NO_MACRO_BODY */ 4763 /** @endcond */ 4764 4765 /** 4766 * @brief Sets the cut point. Stack from each event which occurs after this call 4767 * will be cut at the same stack level the function was called and stitched to 4768 * the corresponding stitch point. 4769 */ 4770 void ITTAPI __itt_stack_callee_enter(__itt_caller id); 4771 4772 /** @cond exclude_from_documentation */ 4773 #ifndef INTEL_NO_MACRO_BODY 4774 #ifndef INTEL_NO_ITTNOTIFY_API 4775 ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id)) 4776 #define __itt_stack_callee_enter ITTNOTIFY_VOID(stack_callee_enter) 4777 #define __itt_stack_callee_enter_ptr ITTNOTIFY_NAME(stack_callee_enter) 4778 #else /* INTEL_NO_ITTNOTIFY_API */ 4779 #define __itt_stack_callee_enter(id) 4780 #define __itt_stack_callee_enter_ptr 0 4781 #endif /* INTEL_NO_ITTNOTIFY_API */ 4782 #else /* INTEL_NO_MACRO_BODY */ 4783 #define __itt_stack_callee_enter_ptr 0 4784 #endif /* INTEL_NO_MACRO_BODY */ 4785 /** @endcond */ 4786 4787 /** 4788 * @brief This function eliminates the cut point which was set by latest 4789 * __itt_stack_callee_enter(). 4790 */ 4791 void ITTAPI __itt_stack_callee_leave(__itt_caller id); 4792 4793 /** @cond exclude_from_documentation */ 4794 #ifndef INTEL_NO_MACRO_BODY 4795 #ifndef INTEL_NO_ITTNOTIFY_API 4796 ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id)) 4797 #define __itt_stack_callee_leave ITTNOTIFY_VOID(stack_callee_leave) 4798 #define __itt_stack_callee_leave_ptr ITTNOTIFY_NAME(stack_callee_leave) 4799 #else /* INTEL_NO_ITTNOTIFY_API */ 4800 #define __itt_stack_callee_leave(id) 4801 #define __itt_stack_callee_leave_ptr 0 4802 #endif /* INTEL_NO_ITTNOTIFY_API */ 4803 #else /* INTEL_NO_MACRO_BODY */ 4804 #define __itt_stack_callee_leave_ptr 0 4805 #endif /* INTEL_NO_MACRO_BODY */ 4806 /** @endcond */ 4807 4808 /** @} stitch group */ 4809 4810 /* ***************************************************************************************************************************** 4811 */ 4812 4813 #include <stdarg.h> 4814 4815 /** @cond exclude_from_documentation */ 4816 typedef enum __itt_error_code { 4817 __itt_error_success = 0, /*!< no error */ 4818 __itt_error_no_module = 1, /*!< module can't be loaded */ 4819 /* %1$s -- library name; win: %2$d -- system error code; unx: %2$s -- system 4820 error message. */ 4821 __itt_error_no_symbol = 2, /*!< symbol not found */ 4822 /* %1$s -- library name, %2$s -- symbol name. */ 4823 __itt_error_unknown_group = 3, /*!< unknown group specified */ 4824 /* %1$s -- env var name, %2$s -- group name. */ 4825 __itt_error_cant_read_env = 4, /*!< GetEnvironmentVariable() failed */ 4826 /* %1$s -- env var name, %2$d -- system error. */ 4827 __itt_error_env_too_long = 5, /*!< variable value too long */ 4828 /* %1$s -- env var name, %2$d -- actual length of the var, %3$d -- max allowed 4829 length. */ 4830 __itt_error_system = 4831 6 /*!< pthread_mutexattr_init or pthread_mutex_init failed */ 4832 /* %1$s -- function name, %2$d -- errno. */ 4833 } __itt_error_code; 4834 4835 typedef void(__itt_error_handler_t)(__itt_error_code code, va_list); 4836 __itt_error_handler_t *__itt_set_error_handler(__itt_error_handler_t *); 4837 4838 const char *ITTAPI __itt_api_version(void); 4839 /** @endcond */ 4840 4841 /** @cond exclude_from_documentation */ 4842 #ifndef INTEL_NO_MACRO_BODY 4843 #ifndef INTEL_NO_ITTNOTIFY_API 4844 #define __itt_error_handler ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, error_handler) 4845 void __itt_error_handler(__itt_error_code code, va_list args); 4846 extern const int ITTNOTIFY_NAME(err); 4847 #define __itt_err ITTNOTIFY_NAME(err) 4848 ITT_STUB(ITTAPI, const char *, api_version, (void)) 4849 #define __itt_api_version ITTNOTIFY_DATA(api_version) 4850 #define __itt_api_version_ptr ITTNOTIFY_NAME(api_version) 4851 #else /* INTEL_NO_ITTNOTIFY_API */ 4852 #define __itt_api_version() (const char *)0 4853 #define __itt_api_version_ptr 0 4854 #endif /* INTEL_NO_ITTNOTIFY_API */ 4855 #else /* INTEL_NO_MACRO_BODY */ 4856 #define __itt_api_version_ptr 0 4857 #endif /* INTEL_NO_MACRO_BODY */ 4858 /** @endcond */ 4859 4860 #ifdef __cplusplus 4861 } 4862 #endif /* __cplusplus */ 4863 4864 #endif /* _ITTNOTIFY_PRIVATE_ */ 4865 4866 #endif /* INTEL_ITTNOTIFY_API_PRIVATE */ 4867