This is an archive of the discontinued LLVM Phabricator instance.

Differential D97088

[OpenMP][NFC] clang-format the whole openmp project
ClosedPublic

Authored by tianshilei1992 on Feb 19 2021, 2:10 PM.

Details

Reviewers
jdoerfert
JonChesterfield
AndreyChurbanov
Commits
rG309b00a42e90: [OpenMP][NFC] clang-format the whole openmp project
Summary

Same script as D95318. Test files are excluded.

Diff Detail

Event Timeline

tianshilei1992 created this revision.Feb 19 2021, 2:10 PM
Herald added subscribers: s.egerton, jfb, guansong and 5 others. · View Herald TranscriptFeb 19 2021, 2:10 PM
tianshilei1992 requested review of this revision.Feb 19 2021, 2:10 PM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 19 2021, 2:10 PM
Herald added subscribers: openmp-commits, sstefan1. · View Herald Transcript
tianshilei1992 added inline comments.Feb 19 2021, 2:21 PM
openmp/libomptarget/deviceRTLs/interface.h
182–183

The latest version of clang-format can surprisingly handle this type of comments so well!

openmp/runtime/doc/doxygen/libomp_interface.h
4

This file should be filtered out.

openmp/runtime/src/thirdparty/ittnotify/disable_warnings.h
15

The tailing \ is unnecessary. Probably because clang-format takes it part of the pragma.

openmp/runtime/src/thirdparty/ittnotify/ittnotify_static.cpp
1049–1052

Here as well

jdoerfert added a comment.Feb 19 2021, 2:34 PM

I scrolled through all of it. 3 nits. LGTM otherwise, wait for @AndreyChurbanov though.

openmp/runtime/src/thirdparty/ittnotify/ittnotify.h
483

This needs to be fixed. Change the comment style or sth

780

same.

868

same.

Harbormaster completed remote builds in B89979: Diff 325086.Feb 19 2021, 2:40 PM
tianshilei1992 updated this revision to Diff 325128.Feb 19 2021, 6:32 PM
tianshilei1992 marked 2 inline comments as done.

Fixed comments

tianshilei1992 marked an inline comment as done.Feb 19 2021, 6:34 PM
Harbormaster completed remote builds in B90007: Diff 325128.Feb 19 2021, 7:01 PM
AndreyChurbanov accepted this revision.Feb 20 2021, 9:44 AM

LGTM

This revision is now accepted and ready to land.Feb 20 2021, 9:44 AM
This revision was landed with ongoing or failed builds.Feb 20 2021, 9:46 AM
Closed by commit rG309b00a42e90: [OpenMP][NFC] clang-format the whole openmp project (authored by tianshilei1992). · Explain Why
This revision was automatically updated to reflect the committed changes.
tianshilei1992 added a commit: rG309b00a42e90: [OpenMP][NFC] clang-format the whole openmp project.

Revision Contents

PathSize
openmp/
libomptarget/
deviceRTLs/
amdgcn/
src/
5 lines
common/
5 lines
8 lines
src/
2 lines
2 lines
8 lines
34 lines
3 lines
15 lines
30 lines
10 lines
2 lines
3 lines
4 lines
34 lines
nvptx/
src/
4 lines
2 lines
runtime/
doc/
doxygen/
77 lines
src/
46 lines
8 lines
151 lines
18 lines
10 lines
20 lines
21 lines
36 lines
25 lines
19 lines
19 lines
24 lines
24 lines
27 lines
16 lines
20 lines
10 lines
5 lines
11 lines
32 lines
13 lines
85 lines
10 lines
60 lines
12 lines
44 lines
27 lines
2 lines
16 lines
35 lines
2 lines
2 lines
2 lines
2 lines
3 lines
19 lines
10 lines
14 lines
thirdparty/
ittnotify/
23 lines
3060 lines
774 lines
927 lines
1809 lines
85 lines
legacy/
677 lines
75 lines
tools/
archer/
2 lines
multiplex/
2 lines

Diff 325213

openmp/libomptarget/deviceRTLs/amdgcn/src/amdgcn_locks.hip

Show All 20 Lines
static DEVICE void warn() { static DEVICE void warn() {
PRINT0(LD_ALL, "Locks are not supported in this thread mapping model"); PRINT0(LD_ALL, "Locks are not supported in this thread mapping model");
} }
DEVICE void __kmpc_impl_init_lock(omp_lock_t *) { warn(); } DEVICE void __kmpc_impl_init_lock(omp_lock_t *) { warn(); }
DEVICE void __kmpc_impl_destroy_lock(omp_lock_t *) { warn(); } DEVICE void __kmpc_impl_destroy_lock(omp_lock_t *) { warn(); }
DEVICE void __kmpc_impl_set_lock(omp_lock_t *) { warn(); } DEVICE void __kmpc_impl_set_lock(omp_lock_t *) { warn(); }
DEVICE void __kmpc_impl_unset_lock(omp_lock_t *) { warn(); } DEVICE void __kmpc_impl_unset_lock(omp_lock_t *) { warn(); }
DEVICE int __kmpc_impl_test_lock(omp_lock_t *lock) { warn(); return 0;} DEVICE int __kmpc_impl_test_lock(omp_lock_t *lock) {
warn();
return 0;
}
#pragma omp end declare target #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/omptarget.h

Show All 34 Lines
#define BARRIER_COUNTER 0 #define BARRIER_COUNTER 0
#define ORDERED_COUNTER 1 #define ORDERED_COUNTER 1
// arguments needed for L0 parallelism only. // arguments needed for L0 parallelism only.
class omptarget_nvptx_SharedArgs { class omptarget_nvptx_SharedArgs {
public: public:
// All these methods must be called by the master thread only. // All these methods must be called by the master thread only.
INLINE void Init() { INLINE void Init() {
args = buffer; args = buffer;
nArgs = MAX_SHARED_ARGS; nArgs = MAX_SHARED_ARGS;
} }
INLINE void DeInit() { INLINE void DeInit() {
// Free any memory allocated for outlined parallel function with a large // Free any memory allocated for outlined parallel function with a large
// number of arguments. // number of arguments.
if (nArgs > MAX_SHARED_ARGS) { if (nArgs > MAX_SHARED_ARGS) {
SafeFree(args, "new extended args"); SafeFree(args, "new extended args");
Init(); Init();
} }
} }
INLINE void EnsureSize(size_t size) { INLINE void EnsureSize(size_t size) {
if (size > nArgs) { if (size > nArgs) {
if (nArgs > MAX_SHARED_ARGS) { if (nArgs > MAX_SHARED_ARGS) {
SafeFree(args, "new extended args"); SafeFree(args, "new extended args");
} }
args = (void **)SafeMalloc(size * sizeof(void *), "new extended args"); args = (void **)SafeMalloc(size * sizeof(void *), "new extended args");
nArgs = size; nArgs = size;
} }
} }
// Called by all threads. // Called by all threads.
INLINE void **GetArgs() const { return args; }; INLINE void **GetArgs() const { return args; };
private: private:
// buffer of pre-allocated arguments. // buffer of pre-allocated arguments.
void *buffer[MAX_SHARED_ARGS]; void *buffer[MAX_SHARED_ARGS];
// pointer to arguments buffer. // pointer to arguments buffer.
// starts off as a pointer to 'buffer' but can be dynamically allocated. // starts off as a pointer to 'buffer' but can be dynamically allocated.
void **args; void **args;
// starts off as MAX_SHARED_ARGS but can increase in size. // starts off as MAX_SHARED_ARGS but can increase in size.
uint32_t nArgs; uint32_t nArgs;
Show All 13 Lines
}; };
// Data structure to keep in shared memory that traces the current slot, stack, // Data structure to keep in shared memory that traces the current slot, stack,
// and frame pointer as well as the active threads that didn't exit the current // and frame pointer as well as the active threads that didn't exit the current
// environment. // environment.
struct DataSharingStateTy { struct DataSharingStateTy {
__kmpc_data_sharing_slot *SlotPtr[DS_Max_Warp_Number]; __kmpc_data_sharing_slot *SlotPtr[DS_Max_Warp_Number];
void *StackPtr[DS_Max_Warp_Number]; void *StackPtr[DS_Max_Warp_Number];
void * volatile FramePtr[DS_Max_Warp_Number]; void *volatile FramePtr[DS_Max_Warp_Number];
__kmpc_impl_lanemask_t ActiveThreads[DS_Max_Warp_Number]; __kmpc_impl_lanemask_t ActiveThreads[DS_Max_Warp_Number];
}; };
extern DEVICE DataSharingStateTy EXTERN_SHARED(DataSharingState); extern DEVICE DataSharingStateTy EXTERN_SHARED(DataSharingState);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// task ICV and (implicit & explicit) task state // task ICV and (implicit & explicit) task state
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

openmp/libomptarget/deviceRTLs/common/omptargeti.h

Show All 24 LinesINLINE void omptarget_nvptx_TaskDescr::SetRuntimeSched(omp_sched_t sched) {
// sched starts from 1..4; encode it as 0..3; so sub 1 here // sched starts from 1..4; encode it as 0..3; so sub 1 here
uint8_t val = ((uint8_t)sched) - 1; uint8_t val = ((uint8_t)sched) - 1;
// clear current sched // clear current sched
items.flags &= ~TaskDescr_SchedMask; items.flags &= ~TaskDescr_SchedMask;
// set new sched // set new sched
items.flags |= val; items.flags |= val;
} }
INLINE void INLINE void omptarget_nvptx_TaskDescr::InitLevelZeroTaskDescr() {
omptarget_nvptx_TaskDescr::InitLevelZeroTaskDescr() {
// slow method // slow method
// flag: // flag:
// default sched is static, // default sched is static,
// dyn is off (unused now anyway, but may need to sample from host ?) // dyn is off (unused now anyway, but may need to sample from host ?)
// not in parallel // not in parallel
items.flags = 0; items.flags = 0;
items.threadId = 0; // is master items.threadId = 0; // is master
items.runtimeChunkSize = 1; // preferred chunking statik with chunk 1 items.runtimeChunkSize = 1; // preferred chunking statik with chunk 1
} }
// This is called when all threads are started together in SPMD mode. // This is called when all threads are started together in SPMD mode.
// OMP directives include target parallel, target distribute parallel for, etc. // OMP directives include target parallel, target distribute parallel for, etc.
INLINE void omptarget_nvptx_TaskDescr::InitLevelOneTaskDescr( INLINE void omptarget_nvptx_TaskDescr::InitLevelOneTaskDescr(
omptarget_nvptx_TaskDescr *parentTaskDescr) { omptarget_nvptx_TaskDescr *parentTaskDescr) {
// slow method // slow method
// flag: // flag:
// default sched is static, // default sched is static,
// dyn is off (unused now anyway, but may need to sample from host ?) // dyn is off (unused now anyway, but may need to sample from host ?)
// in L1 parallel // in L1 parallel
items.flags = items.flags = TaskDescr_InPar | TaskDescr_IsParConstr; // set flag to parallel
TaskDescr_InPar | TaskDescr_IsParConstr; // set flag to parallel
items.threadId = items.threadId =
GetThreadIdInBlock(); // get ids from cuda (only called for 1st level) GetThreadIdInBlock(); // get ids from cuda (only called for 1st level)
items.runtimeChunkSize = 1; // preferred chunking statik with chunk 1 items.runtimeChunkSize = 1; // preferred chunking statik with chunk 1
prev = parentTaskDescr; prev = parentTaskDescr;
} }
INLINE void omptarget_nvptx_TaskDescr::CopyData( INLINE void omptarget_nvptx_TaskDescr::CopyData(
omptarget_nvptx_TaskDescr *sourceTaskDescr) { omptarget_nvptx_TaskDescr *sourceTaskDescr) {
items = sourceTaskDescr->items; items = sourceTaskDescr->items;
} }
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

openmp/libomptarget/deviceRTLs/common/src/cancel.cu

//===------ cancel.cu - NVPTX OpenMP cancel interface ------------ CUDA -*-===// //===------ cancel.cu - NVPTX OpenMP cancel interface ------------ CUDA -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Interface to be used in the implementation of OpenMP cancel. // Interface to be used in the implementation of OpenMP cancel.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#pragma omp declare target #pragma omp declare target
#include "interface.h"
#include "common/debug.h" #include "common/debug.h"
#include "interface.h"
EXTERN int32_t __kmpc_cancellationpoint(kmp_Ident *loc, int32_t global_tid, EXTERN int32_t __kmpc_cancellationpoint(kmp_Ident *loc, int32_t global_tid,
int32_t cancelVal) { int32_t cancelVal) {
PRINT(LD_IO, "call kmpc_cancellationpoint(cancel val %d)\n", (int)cancelVal); PRINT(LD_IO, "call kmpc_cancellationpoint(cancel val %d)\n", (int)cancelVal);
// disabled // disabled
return 0; return 0;
} }
EXTERN int32_t __kmpc_cancel(kmp_Ident *loc, int32_t global_tid, EXTERN int32_t __kmpc_cancel(kmp_Ident *loc, int32_t global_tid,
int32_t cancelVal) { int32_t cancelVal) {
PRINT(LD_IO, "call kmpc_cancel(cancel val %d)\n", (int)cancelVal); PRINT(LD_IO, "call kmpc_cancel(cancel val %d)\n", (int)cancelVal);
// disabled // disabled
return 0; return 0;
} }
#pragma omp end declare target #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/src/critical.cu

//===------ critical.cu - NVPTX OpenMP critical ------------------ CUDA -*-===// //===------ critical.cu - NVPTX OpenMP critical ------------------ CUDA -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains the implementation of critical with KMPC interface // This file contains the implementation of critical with KMPC interface
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#pragma omp declare target #pragma omp declare target
#include "interface.h"
#include "common/debug.h" #include "common/debug.h"
#include "interface.h"
EXTERN EXTERN
void __kmpc_critical(kmp_Ident *loc, int32_t global_tid, void __kmpc_critical(kmp_Ident *loc, int32_t global_tid,
kmp_CriticalName *lck) { kmp_CriticalName *lck) {
PRINT0(LD_IO, "call to kmpc_critical()\n"); PRINT0(LD_IO, "call to kmpc_critical()\n");
omp_set_lock((omp_lock_t *)lck); omp_set_lock((omp_lock_t *)lck);
} }
EXTERN EXTERN
void __kmpc_end_critical(kmp_Ident *loc, int32_t global_tid, void __kmpc_end_critical(kmp_Ident *loc, int32_t global_tid,
kmp_CriticalName *lck) { kmp_CriticalName *lck) {
PRINT0(LD_IO, "call to kmpc_end_critical()\n"); PRINT0(LD_IO, "call to kmpc_end_critical()\n");
omp_unset_lock((omp_lock_t *)lck); omp_unset_lock((omp_lock_t *)lck);
} }
#pragma omp end declare target #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/src/data_sharing.cu

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 LinesEXTERN void __kmpc_data_sharing_init_stack_spmd() {
// statically allocated shared memory slots. The size of a shared memory // statically allocated shared memory slots. The size of a shared memory
// slot is pre-determined to be 256 bytes. // slot is pre-determined to be 256 bytes.
if (GetThreadIdInBlock() == 0) if (GetThreadIdInBlock() == 0)
data_sharing_init_stack_common(); data_sharing_init_stack_common();
__kmpc_impl_threadfence_block(); __kmpc_impl_threadfence_block();
} }
INLINE static void* data_sharing_push_stack_common(size_t PushSize) { INLINE static void *data_sharing_push_stack_common(size_t PushSize) {
ASSERT0(LT_FUSSY, isRuntimeInitialized(), "Expected initialized runtime."); ASSERT0(LT_FUSSY, isRuntimeInitialized(), "Expected initialized runtime.");
// Only warp active master threads manage the stack. // Only warp active master threads manage the stack.
bool IsWarpMaster = (GetThreadIdInBlock() % WARPSIZE) == 0; bool IsWarpMaster = (GetThreadIdInBlock() % WARPSIZE) == 0;
// Add worst-case padding to DataSize so that future stack allocations are // Add worst-case padding to DataSize so that future stack allocations are
// correctly aligned. // correctly aligned.
const size_t Alignment = 8; const size_t Alignment = 8;
Show All 24 Lines if (EndAddress < RequestedEndAddress) {
// Allocate at least the default size for each type of slot. // Allocate at least the default size for each type of slot.
// Master is a special case and even though there is only one thread, // Master is a special case and even though there is only one thread,
// it can share more things with the workers. For uniformity, it uses // it can share more things with the workers. For uniformity, it uses
// the full size of a worker warp slot. // the full size of a worker warp slot.
size_t DefaultSlotSize = DS_Worker_Warp_Slot_Size; size_t DefaultSlotSize = DS_Worker_Warp_Slot_Size;
if (DefaultSlotSize > NewSize) if (DefaultSlotSize > NewSize)
NewSize = DefaultSlotSize; NewSize = DefaultSlotSize;
NewSlot = (__kmpc_data_sharing_slot *) SafeMalloc( NewSlot = (__kmpc_data_sharing_slot *)SafeMalloc(
sizeof(__kmpc_data_sharing_slot) + NewSize, sizeof(__kmpc_data_sharing_slot) + NewSize,
"Global memory slot allocation."); "Global memory slot allocation.");
NewSlot->Next = 0; NewSlot->Next = 0;
NewSlot->Prev = SlotP; NewSlot->Prev = SlotP;
NewSlot->PrevSlotStackPtr = StackP; NewSlot->PrevSlotStackPtr = StackP;
NewSlot->DataEnd = &NewSlot->Data[0] + NewSize; NewSlot->DataEnd = &NewSlot->Data[0] + NewSize;
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 LinesEXTERN void *__kmpc_data_sharing_push_stack(size_t DataSize,
// i.e. one DataSize chunk per warp lane. // i.e. one DataSize chunk per warp lane.
// TODO: change WARPSIZE to the number of active threads in the warp. // TODO: change WARPSIZE to the number of active threads in the warp.
size_t PushSize = (isRuntimeUninitialized() || IsMasterThread(isSPMDMode())) size_t PushSize = (isRuntimeUninitialized() || IsMasterThread(isSPMDMode()))
? DataSize ? DataSize
: WARPSIZE * DataSize; : WARPSIZE * DataSize;
// Compute the start address of the frame of each thread in the warp. // Compute the start address of the frame of each thread in the warp.
uintptr_t FrameStartAddress = uintptr_t FrameStartAddress =
(uintptr_t) data_sharing_push_stack_common(PushSize); (uintptr_t)data_sharing_push_stack_common(PushSize);
FrameStartAddress += (uintptr_t) (GetLaneId() * DataSize); FrameStartAddress += (uintptr_t)(GetLaneId() * DataSize);
return (void *)FrameStartAddress; return (void *)FrameStartAddress;
} }
// Pop the stack and free any memory which can be reclaimed. // Pop the stack and free any memory which can be reclaimed.
// //
// When the pop operation removes the last global memory slot, // When the pop operation removes the last global memory slot,
// reclaim all outstanding global memory slots since it is // reclaim all outstanding global memory slots since it is
// likely we have reached the end of the kernel. // likely we have reached the end of the kernel.
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

openmp/libomptarget/deviceRTLs/common/src/loop.cu

Show First 20 Lines • Show All 404 Lines • ▼ Show 20 Lines INLINE static uint64_t NextIter() {
warp_res = Shuffle(active, warp_res, leader); warp_res = Shuffle(active, warp_res, leader);
return warp_res + rank; return warp_res + rank;
} }
INLINE static int DynamicNextChunk(T &lb, T &ub, T chunkSize, INLINE static int DynamicNextChunk(T &lb, T &ub, T chunkSize,
T loopLowerBound, T loopUpperBound) { T loopLowerBound, T loopUpperBound) {
T N = NextIter(); T N = NextIter();
lb = loopLowerBound + N * chunkSize; lb = loopLowerBound + N * chunkSize;
ub = lb + chunkSize - 1; // Clang uses i <= ub ub = lb + chunkSize - 1; // Clang uses i <= ub
// 3 result cases: // 3 result cases:
// a. lb and ub < loopUpperBound --> NOT_FINISHED // a. lb and ub < loopUpperBound --> NOT_FINISHED
// b. lb < loopUpperBound and ub >= loopUpperBound: last chunk --> // b. lb < loopUpperBound and ub >= loopUpperBound: last chunk -->
// NOT_FINISHED // NOT_FINISHED
// c. lb and ub >= loopUpperBound: empty chunk --> FINISHED // c. lb and ub >= loopUpperBound: empty chunk --> FINISHED
// a. // a.
if (lb <= loopUpperBound && ub < loopUpperBound) { if (lb <= loopUpperBound && ub < loopUpperBound) {
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines
// next // next
EXTERN int __kmpc_dispatch_next_4(kmp_Ident *loc, int32_t tid, int32_t *p_last, EXTERN int __kmpc_dispatch_next_4(kmp_Ident *loc, int32_t tid, int32_t *p_last,
int32_t *p_lb, int32_t *p_ub, int32_t *p_st) { int32_t *p_lb, int32_t *p_ub, int32_t *p_st) {
PRINT0(LD_IO, "call kmpc_dispatch_next_4\n"); PRINT0(LD_IO, "call kmpc_dispatch_next_4\n");
return omptarget_nvptx_LoopSupport<int32_t, int32_t>::dispatch_next( return omptarget_nvptx_LoopSupport<int32_t, int32_t>::dispatch_next(
loc, tid, p_last, p_lb, p_ub, p_st); loc, tid, p_last, p_lb, p_ub, p_st);
} }
EXTERN int __kmpc_dispatch_next_4u(kmp_Ident *loc, int32_t tid, EXTERN int __kmpc_dispatch_next_4u(kmp_Ident *loc, int32_t tid, int32_t *p_last,
int32_t *p_last, uint32_t *p_lb, uint32_t *p_lb, uint32_t *p_ub,
uint32_t *p_ub, int32_t *p_st) { int32_t *p_st) {
PRINT0(LD_IO, "call kmpc_dispatch_next_4u\n"); PRINT0(LD_IO, "call kmpc_dispatch_next_4u\n");
return omptarget_nvptx_LoopSupport<uint32_t, int32_t>::dispatch_next( return omptarget_nvptx_LoopSupport<uint32_t, int32_t>::dispatch_next(
loc, tid, p_last, p_lb, p_ub, p_st); loc, tid, p_last, p_lb, p_ub, p_st);
} }
EXTERN int __kmpc_dispatch_next_8(kmp_Ident *loc, int32_t tid, int32_t *p_last, EXTERN int __kmpc_dispatch_next_8(kmp_Ident *loc, int32_t tid, int32_t *p_last,
int64_t *p_lb, int64_t *p_ub, int64_t *p_st) { int64_t *p_lb, int64_t *p_ub, int64_t *p_st) {
PRINT0(LD_IO, "call kmpc_dispatch_next_8\n"); PRINT0(LD_IO, "call kmpc_dispatch_next_8\n");
return omptarget_nvptx_LoopSupport<int64_t, int64_t>::dispatch_next( return omptarget_nvptx_LoopSupport<int64_t, int64_t>::dispatch_next(
loc, tid, p_last, p_lb, p_ub, p_st); loc, tid, p_last, p_lb, p_ub, p_st);
} }
EXTERN int __kmpc_dispatch_next_8u(kmp_Ident *loc, int32_t tid, EXTERN int __kmpc_dispatch_next_8u(kmp_Ident *loc, int32_t tid, int32_t *p_last,
int32_t *p_last, uint64_t *p_lb, uint64_t *p_lb, uint64_t *p_ub,
uint64_t *p_ub, int64_t *p_st) { int64_t *p_st) {
PRINT0(LD_IO, "call kmpc_dispatch_next_8u\n"); PRINT0(LD_IO, "call kmpc_dispatch_next_8u\n");
return omptarget_nvptx_LoopSupport<uint64_t, int64_t>::dispatch_next( return omptarget_nvptx_LoopSupport<uint64_t, int64_t>::dispatch_next(
loc, tid, p_last, p_lb, p_ub, p_st); loc, tid, p_last, p_lb, p_ub, p_st);
} }
// fini // fini
EXTERN void __kmpc_dispatch_fini_4(kmp_Ident *loc, int32_t tid) { EXTERN void __kmpc_dispatch_fini_4(kmp_Ident *loc, int32_t tid) {
PRINT0(LD_IO, "call kmpc_dispatch_fini_4\n"); PRINT0(LD_IO, "call kmpc_dispatch_fini_4\n");
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Linesvoid __kmpc_for_static_init_8u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
int64_t incr, int64_t chunk) { int64_t incr, int64_t chunk) {
PRINT0(LD_IO, "call kmpc_for_static_init_8u_simple_spmd\n"); PRINT0(LD_IO, "call kmpc_for_static_init_8u_simple_spmd\n");
omptarget_nvptx_LoopSupport<uint64_t, int64_t>::for_static_init( omptarget_nvptx_LoopSupport<uint64_t, int64_t>::for_static_init(
global_tid, schedtype, plastiter, plower, pupper, pstride, chunk, global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
/*IsSPMDExecutionMode=*/true); /*IsSPMDExecutionMode=*/true);
} }
EXTERN EXTERN
void __kmpc_for_static_init_4_simple_generic( void __kmpc_for_static_init_4_simple_generic(kmp_Ident *loc, int32_t global_tid,
kmp_Ident *loc, int32_t global_tid, int32_t schedtype, int32_t *plastiter, int32_t schedtype,
int32_t *plower, int32_t *pupper, int32_t *pstride, int32_t incr, int32_t *plastiter,
int32_t *plower, int32_t *pupper,
int32_t *pstride, int32_t incr,
int32_t chunk) { int32_t chunk) {
PRINT0(LD_IO, "call kmpc_for_static_init_4_simple_generic\n"); PRINT0(LD_IO, "call kmpc_for_static_init_4_simple_generic\n");
omptarget_nvptx_LoopSupport<int32_t, int32_t>::for_static_init( omptarget_nvptx_LoopSupport<int32_t, int32_t>::for_static_init(
global_tid, schedtype, plastiter, plower, pupper, pstride, chunk, global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
/*IsSPMDExecutionMode=*/false); /*IsSPMDExecutionMode=*/false);
} }
EXTERN EXTERN
void __kmpc_for_static_init_4u_simple_generic( void __kmpc_for_static_init_4u_simple_generic(
kmp_Ident *loc, int32_t global_tid, int32_t schedtype, int32_t *plastiter, kmp_Ident *loc, int32_t global_tid, int32_t schedtype, int32_t *plastiter,
uint32_t *plower, uint32_t *pupper, int32_t *pstride, int32_t incr, uint32_t *plower, uint32_t *pupper, int32_t *pstride, int32_t incr,
int32_t chunk) { int32_t chunk) {
PRINT0(LD_IO, "call kmpc_for_static_init_4u_simple_generic\n"); PRINT0(LD_IO, "call kmpc_for_static_init_4u_simple_generic\n");
omptarget_nvptx_LoopSupport<uint32_t, int32_t>::for_static_init( omptarget_nvptx_LoopSupport<uint32_t, int32_t>::for_static_init(
global_tid, schedtype, plastiter, plower, pupper, pstride, chunk, global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
/*IsSPMDExecutionMode=*/false); /*IsSPMDExecutionMode=*/false);
} }
EXTERN EXTERN
void __kmpc_for_static_init_8_simple_generic( void __kmpc_for_static_init_8_simple_generic(kmp_Ident *loc, int32_t global_tid,
kmp_Ident *loc, int32_t global_tid, int32_t schedtype, int32_t *plastiter, int32_t schedtype,
int64_t *plower, int64_t *pupper, int64_t *pstride, int64_t incr, int32_t *plastiter,
int64_t *plower, int64_t *pupper,
int64_t *pstride, int64_t incr,
int64_t chunk) { int64_t chunk) {
PRINT0(LD_IO, "call kmpc_for_static_init_8_simple_generic\n"); PRINT0(LD_IO, "call kmpc_for_static_init_8_simple_generic\n");
omptarget_nvptx_LoopSupport<int64_t, int64_t>::for_static_init( omptarget_nvptx_LoopSupport<int64_t, int64_t>::for_static_init(
global_tid, schedtype, plastiter, plower, pupper, pstride, chunk, global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
/*IsSPMDExecutionMode=*/false); /*IsSPMDExecutionMode=*/false);
} }
EXTERN EXTERN
void __kmpc_for_static_init_8u_simple_generic( void __kmpc_for_static_init_8u_simple_generic(
Show All 14 Lines

openmp/libomptarget/deviceRTLs/common/src/omptarget.cu

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 LinesEXTERN void __kmpc_kernel_deinit(int16_t IsOMPRuntimeInitialized) {
// Enqueue omp state object for use by another team. // Enqueue omp state object for use by another team.
int slot = usedSlotIdx; int slot = usedSlotIdx;
omptarget_nvptx_device_State[slot].Enqueue( omptarget_nvptx_device_State[slot].Enqueue(
omptarget_nvptx_threadPrivateContext); omptarget_nvptx_threadPrivateContext);
// Done with work. Kill the workers. // Done with work. Kill the workers.
omptarget_nvptx_workFn = 0; omptarget_nvptx_workFn = 0;
} }
EXTERN void __kmpc_spmd_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime) { EXTERN void __kmpc_spmd_kernel_init(int ThreadLimit,
int16_t RequiresOMPRuntime) {
PRINT0(LD_IO, "call to __kmpc_spmd_kernel_init\n"); PRINT0(LD_IO, "call to __kmpc_spmd_kernel_init\n");
setExecutionParameters(Spmd, RequiresOMPRuntime ? RuntimeInitialized setExecutionParameters(Spmd, RequiresOMPRuntime ? RuntimeInitialized
: RuntimeUninitialized); : RuntimeUninitialized);
int threadId = GetThreadIdInBlock(); int threadId = GetThreadIdInBlock();
if (threadId == 0) { if (threadId == 0) {
usedSlotIdx = __kmpc_impl_smid() % MAX_SM; usedSlotIdx = __kmpc_impl_smid() % MAX_SM;
parallelLevel[0] = parallelLevel[0] =
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

openmp/libomptarget/deviceRTLs/common/src/parallel.cu

Show First 20 Lines • Show All 182 Lines • ▼ Show 20 LinesEXTERN void __kmpc_kernel_end_parallel() {
// Reconverge the threads at the end of the parallel region to correctly // Reconverge the threads at the end of the parallel region to correctly
// handle parallel levels. // handle parallel levels.
// In Cuda9+ in non-SPMD mode we have either 1 worker thread or the whole // In Cuda9+ in non-SPMD mode we have either 1 worker thread or the whole
// warp. If only 1 thread is active, not need to reconverge the threads. // warp. If only 1 thread is active, not need to reconverge the threads.
// If we have the whole warp, reconverge all the threads in the warp before // If we have the whole warp, reconverge all the threads in the warp before
// actually trying to change the parallel level. Otherwise, parallel level can // actually trying to change the parallel level. Otherwise, parallel level can
// be changed incorrectly because of threads divergence. // be changed incorrectly because of threads divergence.
bool IsActiveParallelRegion = threadsInTeam != 1; bool IsActiveParallelRegion = threadsInTeam != 1;
DecParallelLevel(IsActiveParallelRegion, DecParallelLevel(IsActiveParallelRegion,
IsActiveParallelRegion ? __kmpc_impl_all_lanes : 1u); IsActiveParallelRegion ? __kmpc_impl_all_lanes : 1u);
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// support for parallel that goes sequential // support for parallel that goes sequential
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid) { EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid) {
PRINT0(LD_IO, "call to __kmpc_serialized_parallel\n"); PRINT0(LD_IO, "call to __kmpc_serialized_parallel\n");
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// push params // push params
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
EXTERN void __kmpc_push_num_threads(kmp_Ident *loc, int32_t tid, EXTERN void __kmpc_push_num_threads(kmp_Ident *loc, int32_t tid,
int32_t num_threads) { int32_t num_threads) {
PRINT(LD_IO, "call kmpc_push_num_threads %d\n", num_threads); PRINT(LD_IO, "call kmpc_push_num_threads %d\n", num_threads);
ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc), "Runtime must be initialized."); ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc),
"Runtime must be initialized.");
tid = GetLogicalThreadIdInBlock(checkSPMDMode(loc)); tid = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
omptarget_nvptx_threadPrivateContext->NumThreadsForNextParallel(tid) = omptarget_nvptx_threadPrivateContext->NumThreadsForNextParallel(tid) =
num_threads; num_threads;
} }
// Do nothing. The host guarantees we started the requested number of // Do nothing. The host guarantees we started the requested number of
// teams and we only need inspection of gridDim. // teams and we only need inspection of gridDim.
EXTERN void __kmpc_push_num_teams(kmp_Ident *loc, int32_t tid, EXTERN void __kmpc_push_num_teams(kmp_Ident *loc, int32_t tid,
int32_t num_teams, int32_t thread_limit) { int32_t num_teams, int32_t thread_limit) {
PRINT(LD_IO, "call kmpc_push_num_teams %d\n", (int)num_teams); PRINT(LD_IO, "call kmpc_push_num_teams %d\n", (int)num_teams);
ASSERT0(LT_FUSSY, 0, ASSERT0(LT_FUSSY, 0, "should never have anything with new teams on device");
"should never have anything with new teams on device");
} }
EXTERN void __kmpc_push_proc_bind(kmp_Ident *loc, uint32_t tid, EXTERN void __kmpc_push_proc_bind(kmp_Ident *loc, uint32_t tid, int proc_bind) {
int proc_bind) {
PRINT(LD_IO, "call kmpc_push_proc_bind %d\n", (int)proc_bind); PRINT(LD_IO, "call kmpc_push_proc_bind %d\n", (int)proc_bind);
} }
#pragma omp end declare target #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/src/reduction.cu

Show All 19 Lines
EXTERN EXTERN
void __kmpc_nvptx_end_reduce_nowait(int32_t global_tid) {} void __kmpc_nvptx_end_reduce_nowait(int32_t global_tid) {}
EXTERN int32_t __kmpc_shuffle_int32(int32_t val, int16_t delta, int16_t size) { EXTERN int32_t __kmpc_shuffle_int32(int32_t val, int16_t delta, int16_t size) {
return __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, val, delta, size); return __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, val, delta, size);
} }
EXTERN int64_t __kmpc_shuffle_int64(int64_t val, int16_t delta, int16_t size) { EXTERN int64_t __kmpc_shuffle_int64(int64_t val, int16_t delta, int16_t size) {
uint32_t lo, hi; uint32_t lo, hi;
__kmpc_impl_unpack(val, lo, hi); __kmpc_impl_unpack(val, lo, hi);
hi = __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, hi, delta, size); hi = __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, hi, delta, size);
lo = __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, lo, delta, size); lo = __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, lo, delta, size);
return __kmpc_impl_pack(lo, hi); return __kmpc_impl_pack(lo, hi);
} }
INLINE static void gpu_regular_warp_reduce(void *reduce_data, INLINE static void gpu_regular_warp_reduce(void *reduce_data,
kmp_ShuffleReductFctPtr shflFct) { kmp_ShuffleReductFctPtr shflFct) {
for (uint32_t mask = WARPSIZE / 2; mask > 0; mask /= 2) { for (uint32_t mask = WARPSIZE / 2; mask > 0; mask /= 2) {
shflFct(reduce_data, /*LaneId - not used= */ 0, shflFct(reduce_data, /*LaneId - not used= */ 0,
/*Offset = */ mask, /*AlgoVersion=*/0); /*Offset = */ mask, /*AlgoVersion=*/0);
} }
Show All 38 Lines
static int32_t nvptx_parallel_reduce_nowait( static int32_t nvptx_parallel_reduce_nowait(
int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data, int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data,
kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct, kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct,
bool isSPMDExecutionMode, bool isRuntimeUninitialized) { bool isSPMDExecutionMode, bool isRuntimeUninitialized) {
uint32_t BlockThreadId = GetLogicalThreadIdInBlock(isSPMDExecutionMode); uint32_t BlockThreadId = GetLogicalThreadIdInBlock(isSPMDExecutionMode);
uint32_t NumThreads = GetNumberOfOmpThreads(isSPMDExecutionMode); uint32_t NumThreads = GetNumberOfOmpThreads(isSPMDExecutionMode);
if (NumThreads == 1) if (NumThreads == 1)
return 1; return 1;
/* /*
* This reduce function handles reduction within a team. It handles * This reduce function handles reduction within a team. It handles
* parallel regions in both L1 and L2 parallelism levels. It also * parallel regions in both L1 and L2 parallelism levels. It also
* supports Generic, SPMD, and NoOMP modes. * supports Generic, SPMD, and NoOMP modes.
* *
* 1. Reduce within a warp. * 1. Reduce within a warp.
* 2. Warp master copies value to warp 0 via shared memory. * 2. Warp master copies value to warp 0 via shared memory.
* 3. Warp 0 reduces to a single value. * 3. Warp 0 reduces to a single value.
* 4. The reduced value is available in the thread that returns 1. * 4. The reduced value is available in the thread that returns 1.
*/ */
#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 700 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 700
uint32_t WarpsNeeded = (NumThreads + WARPSIZE - 1) / WARPSIZE; uint32_t WarpsNeeded = (NumThreads + WARPSIZE - 1) / WARPSIZE;
uint32_t WarpId = BlockThreadId / WARPSIZE; uint32_t WarpId = BlockThreadId / WARPSIZE;
// Volta execution model: // Volta execution model:
// For the Generic execution mode a parallel region either has 1 thread and // For the Generic execution mode a parallel region either has 1 thread and
// beyond that, always a multiple of 32. For the SPMD execution mode we may // beyond that, always a multiple of 32. For the SPMD execution mode we may
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

openmp/libomptarget/deviceRTLs/common/src/support.cu

//===--------- support.cu - GPU OpenMP support functions --------- CUDA -*-===// //===--------- support.cu - GPU OpenMP support functions --------- CUDA -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Wrapper implementation to some functions natively supported by the GPU. // Wrapper implementation to some functions natively supported by the GPU.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#pragma omp declare target #pragma omp declare target
#include "common/support.h"
#include "common/debug.h" #include "common/debug.h"
#include "common/omptarget.h" #include "common/omptarget.h"
#include "common/support.h"
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Execution Parameters // Execution Parameters
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
DEVICE void setExecutionParameters(ExecutionMode EMode, RuntimeMode RMode) { DEVICE void setExecutionParameters(ExecutionMode EMode, RuntimeMode RMode) {
execution_param = EMode; execution_param = EMode;
execution_param |= RMode; execution_param |= RMode;
Show All 28 LinesDEVICE bool checkSPMDMode(kmp_Ident *loc) {
// combination of flags so we can return immediately. // combination of flags so we can return immediately.
if (!(loc->reserved_2 & KMP_IDENT_SIMPLE_RT_MODE)) if (!(loc->reserved_2 & KMP_IDENT_SIMPLE_RT_MODE))
return false; return false;
// We are in underfined state. // We are in underfined state.
return isSPMDMode(); return isSPMDMode();
} }
DEVICE bool checkGenericMode(kmp_Ident *loc) { DEVICE bool checkGenericMode(kmp_Ident *loc) { return !checkSPMDMode(loc); }
return !checkSPMDMode(loc);
}
DEVICE bool checkRuntimeUninitialized(kmp_Ident *loc) { DEVICE bool checkRuntimeUninitialized(kmp_Ident *loc) {
if (!loc) if (!loc)
return isRuntimeUninitialized(); return isRuntimeUninitialized();
// If runtime is required then we know we can't be // If runtime is required then we know we can't be
// in the undefined mode. We can return immediately. // in the undefined mode. We can return immediately.
if (!(loc->reserved_2 & KMP_IDENT_SIMPLE_RT_MODE)) if (!(loc->reserved_2 & KMP_IDENT_SIMPLE_RT_MODE))
Show All 30 Lines
// The master thread id is the first thread (lane) of the last warp. // The master thread id is the first thread (lane) of the last warp.
// Thread id is 0 indexed. // Thread id is 0 indexed.
// E.g: If NumThreads is 33, master id is 32. // E.g: If NumThreads is 33, master id is 32.
// If NumThreads is 64, master id is 32. // If NumThreads is 64, master id is 32.
// If NumThreads is 97, master id is 96. // If NumThreads is 97, master id is 96.
// If NumThreads is 1024, master id is 992. // If NumThreads is 1024, master id is 992.
// //
// Called in Generic Execution Mode only. // Called in Generic Execution Mode only.
DEVICE int GetMasterThreadID() { return (GetNumberOfThreadsInBlock() - 1) & ~(WARPSIZE - 1); } DEVICE int GetMasterThreadID() {
return (GetNumberOfThreadsInBlock() - 1) & ~(WARPSIZE - 1);
}
// The last warp is reserved for the master; other warps are workers. // The last warp is reserved for the master; other warps are workers.
// Called in Generic Execution Mode only. // Called in Generic Execution Mode only.
DEVICE int GetNumberOfWorkersInTeam() { return GetMasterThreadID(); } DEVICE int GetNumberOfWorkersInTeam() { return GetMasterThreadID(); }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// get thread id in team // get thread id in team
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

openmp/libomptarget/deviceRTLs/common/src/task.cu

Show All 25 Lines
// - end // - end
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#pragma omp declare target #pragma omp declare target
#include "common/omptarget.h" #include "common/omptarget.h"
EXTERN kmp_TaskDescr *__kmpc_omp_task_alloc( EXTERN kmp_TaskDescr *__kmpc_omp_task_alloc(
kmp_Ident *loc, // unused kmp_Ident *loc, // unused
uint32_t global_tid, // unused uint32_t global_tid, // unused
int32_t flag, // unused (because in our impl, all are immediately exec int32_t flag, // unused (because in our impl, all are immediately exec
size_t sizeOfTaskInclPrivate, size_t sizeOfSharedTable, size_t sizeOfTaskInclPrivate, size_t sizeOfSharedTable,
kmp_TaskFctPtr taskSub) { kmp_TaskFctPtr taskSub) {
PRINT(LD_IO, PRINT(LD_IO,
"call __kmpc_omp_task_alloc(size priv&struct %lld, shared %lld, " "call __kmpc_omp_task_alloc(size priv&struct %lld, shared %lld, "
"fct 0x%llx)\n", "fct 0x%llx)\n",
(long long)sizeOfTaskInclPrivate, (long long)sizeOfSharedTable, (long long)sizeOfTaskInclPrivate, (long long)sizeOfSharedTable,
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

openmp/libomptarget/deviceRTLs/common/state-queuei.h

Show All 23 Lines
} }
template <typename ElementType, uint32_t SIZE> template <typename ElementType, uint32_t SIZE>
INLINE uint32_t omptarget_nvptx_Queue<ElementType, SIZE>::DEQUEUE_TICKET() { INLINE uint32_t omptarget_nvptx_Queue<ElementType, SIZE>::DEQUEUE_TICKET() {
return __kmpc_atomic_add((unsigned int *)&head, 1u); return __kmpc_atomic_add((unsigned int *)&head, 1u);
} }
template <typename ElementType, uint32_t SIZE> template <typename ElementType, uint32_t SIZE>
INLINE uint32_t INLINE uint32_t omptarget_nvptx_Queue<ElementType, SIZE>::ID(uint32_t ticket) {
omptarget_nvptx_Queue<ElementType, SIZE>::ID(uint32_t ticket) {
return (ticket / SIZE) * 2; return (ticket / SIZE) * 2;
} }
template <typename ElementType, uint32_t SIZE> template <typename ElementType, uint32_t SIZE>
INLINE bool omptarget_nvptx_Queue<ElementType, SIZE>::IsServing(uint32_t slot, INLINE bool omptarget_nvptx_Queue<ElementType, SIZE>::IsServing(uint32_t slot,
uint32_t id) { uint32_t id) {
return __kmpc_atomic_add((unsigned int *)&ids[slot], 0u) == id; return __kmpc_atomic_add((unsigned int *)&ids[slot], 0u) == id;
} }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

openmp/libomptarget/deviceRTLs/common/support.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
// get global ids to locate tread/team info (constant regardless of OMP) // get global ids to locate tread/team info (constant regardless of OMP)
DEVICE int GetLogicalThreadIdInBlock(bool isSPMDExecutionMode); DEVICE int GetLogicalThreadIdInBlock(bool isSPMDExecutionMode);
DEVICE int GetMasterThreadID(); DEVICE int GetMasterThreadID();
DEVICE int GetNumberOfWorkersInTeam(); DEVICE int GetNumberOfWorkersInTeam();
// get OpenMP thread and team ids // get OpenMP thread and team ids
DEVICE int GetOmpThreadId(int threadId, DEVICE int GetOmpThreadId(int threadId,
bool isSPMDExecutionMode); // omp_thread_num bool isSPMDExecutionMode); // omp_thread_num
DEVICE int GetOmpTeamId(); // omp_team_num DEVICE int GetOmpTeamId(); // omp_team_num
// get OpenMP number of threads and team // get OpenMP number of threads and team
DEVICE int GetNumberOfOmpThreads(bool isSPMDExecutionMode); // omp_num_threads DEVICE int GetNumberOfOmpThreads(bool isSPMDExecutionMode); // omp_num_threads
DEVICE int GetNumberOfOmpTeams(); // omp_num_teams DEVICE int GetNumberOfOmpTeams(); // omp_num_teams
// get OpenMP number of procs // get OpenMP number of procs
DEVICE int GetNumberOfProcsInTeam(bool isSPMDExecutionMode); DEVICE int GetNumberOfProcsInTeam(bool isSPMDExecutionMode);
DEVICE int GetNumberOfProcsInDevice(bool isSPMDExecutionMode); DEVICE int GetNumberOfProcsInDevice(bool isSPMDExecutionMode);
Show All 29 Lines

openmp/libomptarget/deviceRTLs/interface.h

Show First 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
/*! /*!
* The ident structure that describes a source location. * The ident structure that describes a source location.
* The struct is identical to the one in the kmp.h file. * The struct is identical to the one in the kmp.h file.
* We maintain the same data structure for compatibility. * We maintain the same data structure for compatibility.
*/ */
typedef int kmp_int32; typedef int kmp_int32;
typedef struct ident { typedef struct ident {
kmp_int32 reserved_1; /**< might be used in Fortran; see above */ kmp_int32 reserved_1; /**< might be used in Fortran; see above */
kmp_int32 flags; /**< also f.flags; KMP_IDENT_xxx flags; KMP_IDENT_KMPC kmp_int32 flags; /**< also f.flags; KMP_IDENT_xxx flags; KMP_IDENT_KMPC
tianshilei1992AuthorUnsubmitted
Done
ReplyInline Actions

The latest version of clang-format can surprisingly handle this type of comments so well!

tianshilei1992: The latest version of `clang-format` can surprisingly handle this type of comments so well!
identifies this union member */ identifies this union member */
kmp_int32 reserved_2; /**< not really used in Fortran any more; see above */ kmp_int32 reserved_2; /**< not really used in Fortran any more; see above */
kmp_int32 reserved_3; /**< source[4] in Fortran, do not use for C++ */ kmp_int32 reserved_3; /**< source[4] in Fortran, do not use for C++ */
char const *psource; /**< String describing the source location. char const *psource; /**< String describing the source location.
The string is composed of semi-colon separated fields The string is composed of semi-colon separated fields
which describe the source file, the function and a pair which describe the source file, the function and a pair
of line numbers that delimit the construct. */ of line numbers that delimit the construct. */
} ident_t; } ident_t;
// parallel defs // parallel defs
typedef ident_t kmp_Ident; typedef ident_t kmp_Ident;
typedef void (*kmp_InterWarpCopyFctPtr)(void *src, int32_t warp_num); typedef void (*kmp_InterWarpCopyFctPtr)(void *src, int32_t warp_num);
typedef void (*kmp_ShuffleReductFctPtr)(void *rhsData, int16_t lane_id, typedef void (*kmp_ShuffleReductFctPtr)(void *rhsData, int16_t lane_id,
int16_t lane_offset, int16_t lane_offset,
int16_t shortCircuit); int16_t shortCircuit);
Show All 16 Lines
// external interface // external interface
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// parallel // parallel
EXTERN int32_t __kmpc_global_thread_num(kmp_Ident *loc); EXTERN int32_t __kmpc_global_thread_num(kmp_Ident *loc);
EXTERN void __kmpc_push_num_threads(kmp_Ident *loc, int32_t global_tid, EXTERN void __kmpc_push_num_threads(kmp_Ident *loc, int32_t global_tid,
int32_t num_threads); int32_t num_threads);
EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid); EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid);
EXTERN void __kmpc_end_serialized_parallel(kmp_Ident *loc, EXTERN void __kmpc_end_serialized_parallel(kmp_Ident *loc, uint32_t global_tid);
uint32_t global_tid);
EXTERN uint16_t __kmpc_parallel_level(kmp_Ident *loc, uint32_t global_tid); EXTERN uint16_t __kmpc_parallel_level(kmp_Ident *loc, uint32_t global_tid);
// proc bind // proc bind
EXTERN void __kmpc_push_proc_bind(kmp_Ident *loc, uint32_t global_tid, EXTERN void __kmpc_push_proc_bind(kmp_Ident *loc, uint32_t global_tid,
int proc_bind); int proc_bind);
EXTERN int omp_get_num_places(void); EXTERN int omp_get_num_places(void);
EXTERN int omp_get_place_num_procs(int place_num); EXTERN int omp_get_place_num_procs(int place_num);
EXTERN void omp_get_place_proc_ids(int place_num, int *ids); EXTERN void omp_get_place_proc_ids(int place_num, int *ids);
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesvoid __kmpc_for_static_init_8_simple_spmd(kmp_Ident *loc, int32_t global_tid,
int64_t chunk); int64_t chunk);
EXTERN EXTERN
void __kmpc_for_static_init_8u_simple_spmd(kmp_Ident *loc, int32_t global_tid, void __kmpc_for_static_init_8u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
int32_t sched, int32_t *plastiter1, int32_t sched, int32_t *plastiter1,
uint64_t *plower, uint64_t *pupper, uint64_t *plower, uint64_t *pupper,
int64_t *pstride, int64_t incr, int64_t *pstride, int64_t incr,
int64_t chunk); int64_t chunk);
EXTERN EXTERN
void __kmpc_for_static_init_4_simple_generic(kmp_Ident *loc, void __kmpc_for_static_init_4_simple_generic(kmp_Ident *loc, int32_t global_tid,
int32_t global_tid, int32_t sched, int32_t sched, int32_t *plastiter,
int32_t *plastiter,
int32_t *plower, int32_t *pupper, int32_t *plower, int32_t *pupper,
int32_t *pstride, int32_t incr, int32_t *pstride, int32_t incr,
int32_t chunk); int32_t chunk);
EXTERN EXTERN
void __kmpc_for_static_init_4u_simple_generic( void __kmpc_for_static_init_4u_simple_generic(
kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter, kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter,
uint32_t *plower, uint32_t *pupper, int32_t *pstride, int32_t incr, uint32_t *plower, uint32_t *pupper, int32_t *pstride, int32_t incr,
int32_t chunk); int32_t chunk);
EXTERN EXTERN
void __kmpc_for_static_init_8_simple_generic(kmp_Ident *loc, void __kmpc_for_static_init_8_simple_generic(kmp_Ident *loc, int32_t global_tid,
int32_t global_tid, int32_t sched, int32_t sched, int32_t *plastiter,
int32_t *plastiter,
int64_t *plower, int64_t *pupper, int64_t *plower, int64_t *pupper,
int64_t *pstride, int64_t incr, int64_t *pstride, int64_t incr,
int64_t chunk); int64_t chunk);
EXTERN EXTERN
void __kmpc_for_static_init_8u_simple_generic( void __kmpc_for_static_init_8u_simple_generic(
kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter1, kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter1,
uint64_t *plower, uint64_t *pupper, int64_t *pstride, int64_t incr, uint64_t *plower, uint64_t *pupper, int64_t *pstride, int64_t incr,
int64_t chunk); int64_t chunk);
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
EXTERN void __kmpc_flush(kmp_Ident *loc); EXTERN void __kmpc_flush(kmp_Ident *loc);
// vote // vote
EXTERN __kmpc_impl_lanemask_t __kmpc_warp_active_thread_mask(); EXTERN __kmpc_impl_lanemask_t __kmpc_warp_active_thread_mask();
// syncwarp // syncwarp
EXTERN void __kmpc_syncwarp(__kmpc_impl_lanemask_t); EXTERN void __kmpc_syncwarp(__kmpc_impl_lanemask_t);
// tasks // tasks
EXTERN kmp_TaskDescr *__kmpc_omp_task_alloc(kmp_Ident *loc, EXTERN kmp_TaskDescr *__kmpc_omp_task_alloc(kmp_Ident *loc, uint32_t global_tid,
uint32_t global_tid, int32_t flag, int32_t flag,
size_t sizeOfTaskInclPrivate, size_t sizeOfTaskInclPrivate,
size_t sizeOfSharedTable, size_t sizeOfSharedTable,
kmp_TaskFctPtr sub); kmp_TaskFctPtr sub);
EXTERN int32_t __kmpc_omp_task(kmp_Ident *loc, uint32_t global_tid, EXTERN int32_t __kmpc_omp_task(kmp_Ident *loc, uint32_t global_tid,
kmp_TaskDescr *newLegacyTaskDescr); kmp_TaskDescr *newLegacyTaskDescr);
EXTERN int32_t __kmpc_omp_task_with_deps(kmp_Ident *loc, uint32_t global_tid, EXTERN int32_t __kmpc_omp_task_with_deps(kmp_Ident *loc, uint32_t global_tid,
kmp_TaskDescr *newLegacyTaskDescr, kmp_TaskDescr *newLegacyTaskDescr,
int32_t depNum, void *depList, int32_t depNum, void *depList,
Show All 30 Lines
EXTERN void __kmpc_spmd_kernel_deinit_v2(int16_t RequiresOMPRuntime); EXTERN void __kmpc_spmd_kernel_deinit_v2(int16_t RequiresOMPRuntime);
EXTERN void __kmpc_kernel_prepare_parallel(void *WorkFn); EXTERN void __kmpc_kernel_prepare_parallel(void *WorkFn);
EXTERN bool __kmpc_kernel_parallel(void **WorkFn); EXTERN bool __kmpc_kernel_parallel(void **WorkFn);
EXTERN void __kmpc_kernel_end_parallel(); EXTERN void __kmpc_kernel_end_parallel();
EXTERN void __kmpc_data_sharing_init_stack(); EXTERN void __kmpc_data_sharing_init_stack();
EXTERN void __kmpc_data_sharing_init_stack_spmd(); EXTERN void __kmpc_data_sharing_init_stack_spmd();
EXTERN void *__kmpc_data_sharing_coalesced_push_stack(size_t size, EXTERN void *__kmpc_data_sharing_coalesced_push_stack(size_t size,
int16_t UseSharedMemory); int16_t UseSharedMemory);
EXTERN void *__kmpc_data_sharing_push_stack(size_t size, int16_t UseSharedMemory); EXTERN void *__kmpc_data_sharing_push_stack(size_t size,
int16_t UseSharedMemory);
EXTERN void __kmpc_data_sharing_pop_stack(void *a); EXTERN void __kmpc_data_sharing_pop_stack(void *a);
EXTERN void __kmpc_begin_sharing_variables(void ***GlobalArgs, size_t nArgs); EXTERN void __kmpc_begin_sharing_variables(void ***GlobalArgs, size_t nArgs);
EXTERN void __kmpc_end_sharing_variables(); EXTERN void __kmpc_end_sharing_variables();
EXTERN void __kmpc_get_shared_variables(void ***GlobalArgs); EXTERN void __kmpc_get_shared_variables(void ***GlobalArgs);
// SPMD execution mode interrogation function. // SPMD execution mode interrogation function.
EXTERN int8_t __kmpc_is_spmd_exec_mode(); EXTERN int8_t __kmpc_is_spmd_exec_mode();
EXTERN void __kmpc_get_team_static_memory(int16_t isSPMDExecutionMode, EXTERN void __kmpc_get_team_static_memory(int16_t isSPMDExecutionMode,
const void *buf, size_t size, const void *buf, size_t size,
int16_t is_shared, const void **res); int16_t is_shared, const void **res);
EXTERN void __kmpc_restore_team_static_memory(int16_t isSPMDExecutionMode, EXTERN void __kmpc_restore_team_static_memory(int16_t isSPMDExecutionMode,
int16_t is_shared); int16_t is_shared);
#endif #endif

openmp/libomptarget/deviceRTLs/nvptx/src/target_impl.h

Show All 28 Lines
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// The following def must match the absolute limit hardwired in the host RTL // The following def must match the absolute limit hardwired in the host RTL
// max number of threads per team // max number of threads per team
#define MAX_THREADS_PER_TEAM 1024 #define MAX_THREADS_PER_TEAM 1024
#define WARPSIZE 32 #define WARPSIZE 32
// Maximum number of preallocated arguments to an outlined parallel/simd function. // Maximum number of preallocated arguments to an outlined parallel/simd
// Anything more requires dynamic memory allocation. // function. Anything more requires dynamic memory allocation.
#define MAX_SHARED_ARGS 20 #define MAX_SHARED_ARGS 20
// Maximum number of omp state objects per SM allocated statically in global // Maximum number of omp state objects per SM allocated statically in global
// memory. // memory.
#if __CUDA_ARCH__ >= 600 #if __CUDA_ARCH__ >= 600
#define OMP_STATE_COUNT 32 #define OMP_STATE_COUNT 32
#else #else
#define OMP_STATE_COUNT 16 #define OMP_STATE_COUNT 16
Show All 39 Lines

openmp/libomptarget/deviceRTLs/nvptx/src/target_impl.cu

//===---------- target_impl.cu - NVPTX OpenMP GPU options ------- CUDA -*-===// //===---------- target_impl.cu - NVPTX OpenMP GPU options ------- CUDA -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Definitions of target specific functions // Definitions of target specific functions
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#pragma omp declare target #pragma omp declare target
#include "target_impl.h"
#include "common/debug.h" #include "common/debug.h"
#include "target_impl.h"
DEVICE void __kmpc_impl_unpack(uint64_t val, uint32_t &lo, uint32_t &hi) { DEVICE void __kmpc_impl_unpack(uint64_t val, uint32_t &lo, uint32_t &hi) {
asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(val)); asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(val));
} }
DEVICE uint64_t __kmpc_impl_pack(uint32_t lo, uint32_t hi) { DEVICE uint64_t __kmpc_impl_pack(uint32_t lo, uint32_t hi) {
uint64_t val; uint64_t val;
asm volatile("mov.b64 %0, {%1,%2};" : "=l"(val) : "r"(lo), "r"(hi)); asm volatile("mov.b64 %0, {%1,%2};" : "=l"(val) : "r"(lo), "r"(hi));
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

openmp/runtime/doc/doxygen/libomp_interface.h

// clang-format off
// This file does not contain any code; it just contains additional text and formatting // This file does not contain any code; it just contains additional text and formatting
// for doxygen. // for doxygen.
tianshilei1992AuthorUnsubmitted
Done
ReplyInline Actions

This file should be filtered out.

tianshilei1992: This file should be filtered out.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
<table border=1> <table border=1>
<tr><th> <th>icc/icl<th>gcc<th>clang <tr><th> <th>icc/icl<th>gcc<th>clang
<tr><td>Linux\other OS<td>Yes(1,5)<td>Yes(2,4)<td>Yes(4,6,7) <tr><td>Linux\other OS<td>Yes(1,5)<td>Yes(2,4)<td>Yes(4,6,7)
<tr><td>FreeBSD\other<td>Yes(1,5)<td>Yes(2,4)<td>Yes(4,6,7,8) <tr><td>FreeBSD\other<td>Yes(1,5)<td>Yes(2,4)<td>Yes(4,6,7,8)
<tr><td>OS X\other<td>Yes(1,3,4)<td>No<td>Yes(4,6,7) <tr><td>OS X\other<td>Yes(1,3,4)<td>No<td>Yes(4,6,7)
<tr><td>Windows\other OS<td>Yes(1,4)<td>No<td>No <tr><td>Windows\other OS<td>Yes(1,4)<td>No<td>No
</table> </table>
(1) On IA-32 architecture and Intel&reg;&nbsp; 64, icc/icl versions 12.x (1) On IA-32 architecture and Intel&reg;&nbsp; 64, icc/icl versions 12.x
are supported (12.1 is recommended).<br> are supported (12.1 is recommended).<br>
(2) gcc version 4.7 is supported.<br> (2) gcc version 4.7 is supported.<br>
(3) For icc on OS X\other, OS X\other version 10.5.8 is supported.<br> (3) For icc on OS X\other, OS X\other version 10.5.8 is supported.<br>
(4) Intel&reg;&nbsp; Many Integrated Core Architecture not supported.<br> (4) Intel&reg;&nbsp; Many Integrated Core Architecture not supported.<br>
(5) On Intel&reg;&nbsp; Many Integrated Core Architecture, icc/icl versions 13.0 or later are required.<br> (5) On Intel&reg;&nbsp; Many Integrated Core Architecture, icc/icl versions 13.0 or later are required.<br>
(6) Clang\other version 3.3 is supported.<br> (6) Clang\other version 3.3 is supported.<br>
(7) Clang\other currently does not offer a software-implemented 128 bit extended (7) Clang\other currently does not offer a software-implemented 128 bit extended
precision type. Thus, all entry points reliant on this type are removed precision type. Thus, all entry points reliant on this type are removed
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
void foo() void foo()
{ {
__OMP_runtime_fork(outlinedFooBody, (void*)0); // Not the real function name! __OMP_runtime_fork(outlinedFooBody, (void*)0); // Not the real function name!
} }
@endcode @endcode
@subsection SEC_SHAREDVARS Addressing shared variables @subsection SEC_SHAREDVARS Addressing shared variables
In real uses of the OpenMP\other API there are normally references In real uses of the OpenMP\other API there are normally references
from the outlined code to shared variables that are in scope in the containing function. from the outlined code to shared variables that are in scope in the containing function.
Therefore the containing function must be able to address Therefore the containing function must be able to address
these variables. The runtime supports two alternate ways of doing these variables. The runtime supports two alternate ways of doing
this. this.
@subsubsection SEC_SEC_OT Current Technique @subsubsection SEC_SEC_OT Current Technique
The technique currently supported by the runtime library is to receive The technique currently supported by the runtime library is to receive
a separate pointer to each shared variable that can be accessed from a separate pointer to each shared variable that can be accessed from
the outlined function. This is what is shown in the example below. the outlined function. This is what is shown in the example below.
Show All 23 Lines
If it is hard to determine the stack layout of the parent while generating the If it is hard to determine the stack layout of the parent while generating the
outlined code, it is still possible to use this approach by collecting all of outlined code, it is still possible to use this approach by collecting all of
the variables in the parent that are accessed from outlined functions into the variables in the parent that are accessed from outlined functions into
a single `struct` which is placed on the stack, and whose address is passed a single `struct` which is placed on the stack, and whose address is passed
to the outlined functions. In this way the offsets of the shared variables to the outlined functions. In this way the offsets of the shared variables
are known (since they are inside the struct) without needing to know are known (since they are inside the struct) without needing to know
the complete layout of the parent stack-frame. From the point of view the complete layout of the parent stack-frame. From the point of view
of the runtime either of these techniques is equivalent, since in either of the runtime either of these techniques is equivalent, since in either
case it only has to pass a single argument to the outlined function to allow case it only has to pass a single argument to the outlined function to allow
it to access shared variables. it to access shared variables.
A scheme like this is how gcc\other generates outlined functions. A scheme like this is how gcc\other generates outlined functions.
@section SEC_INTERFACES Library Interfaces @section SEC_INTERFACES Library Interfaces
The library functions used for specific parts of the OpenMP\other language implementation The library functions used for specific parts of the OpenMP\other language implementation
are documented in different modules. are documented in different modules.
Show All 12 Lines
@section SEC_EXAMPLES Examples @section SEC_EXAMPLES Examples
@subsection SEC_WORKSHARING_EXAMPLE Work Sharing Example @subsection SEC_WORKSHARING_EXAMPLE Work Sharing Example
This example shows the code generated for a parallel for with reduction and dynamic scheduling. This example shows the code generated for a parallel for with reduction and dynamic scheduling.
@code @code
extern float foo( void ); extern float foo( void );
int main () { int main () {
int i; int i;
float r = 0.0; float r = 0.0;
#pragma omp parallel for schedule(dynamic) reduction(+:r) #pragma omp parallel for schedule(dynamic) reduction(+:r)
for ( i = 0; i < 10; i ++ ) { for ( i = 0; i < 10; i ++ ) {
r += foo(); r += foo();
} }
} }
@endcode @endcode
The transformed code looks like this. The transformed code looks like this.
@code @code
extern float foo( void ); extern float foo( void );
int main () { int main () {
static int zero = 0; static int zero = 0;
auto int gtid; auto int gtid;
auto float r = 0.0; auto float r = 0.0;
__kmpc_begin( & loc3, 0 ); __kmpc_begin( & loc3, 0 );
// The gtid is not actually required in this example so could be omitted; // The gtid is not actually required in this example so could be omitted;
// We show its initialization here because it is often required for calls into // We show its initialization here because it is often required for calls into
// the runtime and should be locally cached like this. // the runtime and should be locally cached like this.
gtid = __kmpc_global thread num( & loc3 ); gtid = __kmpc_global thread num( & loc3 );
__kmpc_fork call( & loc7, 1, main_7_parallel_3, & r ); __kmpc_fork call( & loc7, 1, main_7_parallel_3, & r );
__kmpc_end( & loc0 ); __kmpc_end( & loc0 );
return 0; return 0;
} }
struct main_10_reduction_t_5 { float r_10_rpr; }; struct main_10_reduction_t_5 { float r_10_rpr; };
static kmp_critical_name lck = { 0 }; static kmp_critical_name lck = { 0 };
static ident_t loc10; // loc10.flags should contain KMP_IDENT_ATOMIC_REDUCE bit set static ident_t loc10; // loc10.flags should contain KMP_IDENT_ATOMIC_REDUCE bit set
// if compiler has generated an atomic reduction. // if compiler has generated an atomic reduction.
void main_7_parallel_3( int *gtid, int *btid, float *r_7_shp ) { void main_7_parallel_3( int *gtid, int *btid, float *r_7_shp ) {
auto int i_7_pr; auto int i_7_pr;
auto int lower, upper, liter, incr; auto int lower, upper, liter, incr;
auto struct main_10_reduction_t_5 reduce; auto struct main_10_reduction_t_5 reduce;
reduce.r_10_rpr = 0.F; reduce.r_10_rpr = 0.F;
liter = 0; liter = 0;
__kmpc_dispatch_init_4( & loc7,*gtid, 35, 0, 9, 1, 1 ); __kmpc_dispatch_init_4( & loc7,*gtid, 35, 0, 9, 1, 1 );
while ( __kmpc_dispatch_next_4( & loc7, *gtid, & liter, & lower, & upper, & incr ) ) { while ( __kmpc_dispatch_next_4( & loc7, *gtid, & liter, & lower, & upper, & incr ) ) {
for( i_7_pr = lower; upper >= i_7_pr; i_7_pr ++ ) for( i_7_pr = lower; upper >= i_7_pr; i_7_pr ++ )
reduce.r_10_rpr += foo(); reduce.r_10_rpr += foo();
} }
switch( __kmpc_reduce_nowait( & loc10, *gtid, 1, 4, & reduce, main_10_reduce_5, & lck ) ) { switch( __kmpc_reduce_nowait( & loc10, *gtid, 1, 4, & reduce, main_10_reduce_5, & lck ) ) {
case 1: case 1:
*r_7_shp += reduce.r_10_rpr; *r_7_shp += reduce.r_10_rpr;
__kmpc_end_reduce_nowait( & loc10, *gtid, & lck ); __kmpc_end_reduce_nowait( & loc10, *gtid, & lck );
break; break;
case 2: case 2:
__kmpc_atomic_float4_add( & loc10, *gtid, r_7_shp, reduce.r_10_rpr ); __kmpc_atomic_float4_add( & loc10, *gtid, r_7_shp, reduce.r_10_rpr );
break; break;
default:; default:;
} }
} }
void main_10_reduce_5( struct main_10_reduction_t_5 *reduce_lhs, void main_10_reduce_5( struct main_10_reduction_t_5 *reduce_lhs,
struct main_10_reduction_t_5 *reduce_rhs ) struct main_10_reduction_t_5 *reduce_rhs )
{ {
reduce_lhs->r_10_rpr += reduce_rhs->r_10_rpr; reduce_lhs->r_10_rpr += reduce_rhs->r_10_rpr;
} }
@endcode @endcode
@defgroup BASIC_TYPES Basic Types @defgroup BASIC_TYPES Basic Types
Types that are used throughout the runtime. Types that are used throughout the runtime.
@defgroup DEPRECATED Deprecated Functions @defgroup DEPRECATED Deprecated Functions
Functions in this group are for backwards compatibility only, and Functions in this group are for backwards compatibility only, and
should not be used in new code. should not be used in new code.
@defgroup STARTUP_SHUTDOWN Startup and Shutdown @defgroup STARTUP_SHUTDOWN Startup and Shutdown
These functions are for library initialization and shutdown. These functions are for library initialization and shutdown.
@defgroup PARALLEL Parallel (fork/join) @defgroup PARALLEL Parallel (fork/join)
These functions are used for implementing <tt>\#pragma omp parallel</tt>. These functions are used for implementing <tt>\#pragma omp parallel</tt>.
@defgroup THREAD_STATES Thread Information @defgroup THREAD_STATES Thread Information
These functions return information about the currently executing thread. These functions return information about the currently executing thread.
@defgroup WORK_SHARING Work Sharing @defgroup WORK_SHARING Work Sharing
These functions are used for implementing These functions are used for implementing
<tt>\#pragma omp for</tt>, <tt>\#pragma omp sections</tt>, <tt>\#pragma omp single</tt> and <tt>\#pragma omp for</tt>, <tt>\#pragma omp sections</tt>, <tt>\#pragma omp single</tt> and
<tt>\#pragma omp master</tt> constructs. <tt>\#pragma omp master</tt> constructs.
When handling loops, there are different functions for each of the signed and unsigned 32 and 64 bit integer types When handling loops, there are different functions for each of the signed and unsigned 32 and 64 bit integer types
which have the name suffixes `_4`, `_4u`, `_8` and `_8u`. The semantics of each of the functions is the same, which have the name suffixes `_4`, `_4u`, `_8` and `_8u`. The semantics of each of the functions is the same,
so they are only described once. so they are only described once.
Static loop scheduling is handled by @ref __kmpc_for_static_init_4 and friends. Only a single call is needed, Static loop scheduling is handled by @ref __kmpc_for_static_init_4 and friends. Only a single call is needed,
since the iterations to be executed by any give thread can be determined as soon as the loop parameters are known. since the iterations to be executed by any give thread can be determined as soon as the loop parameters are known.
Dynamic scheduling is handled by the @ref __kmpc_dispatch_init_4 and @ref __kmpc_dispatch_next_4 functions. Dynamic scheduling is handled by the @ref __kmpc_dispatch_init_4 and @ref __kmpc_dispatch_next_4 functions.
The init function is called once in each thread outside the loop, while the next function is called each The init function is called once in each thread outside the loop, while the next function is called each
time that the previous chunk of work has been exhausted. time that the previous chunk of work has been exhausted.
@defgroup SYNCHRONIZATION Synchronization @defgroup SYNCHRONIZATION Synchronization
These functions are used for implementing barriers. These functions are used for implementing barriers.
@defgroup THREADPRIVATE Thread private data support @defgroup THREADPRIVATE Thread private data support
These functions support copyin/out and thread private data. These functions support copyin/out and thread private data.
@defgroup STATS_GATHERING Statistics Gathering from OMPTB @defgroup STATS_GATHERING Statistics Gathering from OMPTB
Show All 25 Lines

openmp/runtime/src/kmp.h

Show First 20 Lines • Show All 1,069 Lines • ▼ Show 20 Lines
#if KMP_USE_MONITOR #if KMP_USE_MONITOR
#define KMP_DEFAULT_MONITOR_STKSIZE ((size_t)(64 * 1024)) #define KMP_DEFAULT_MONITOR_STKSIZE ((size_t)(64 * 1024))
#define KMP_MIN_MONITOR_WAKEUPS (1) // min times monitor wakes up per second #define KMP_MIN_MONITOR_WAKEUPS (1) // min times monitor wakes up per second
#define KMP_MAX_MONITOR_WAKEUPS (1000) // max times monitor can wake up per sec #define KMP_MAX_MONITOR_WAKEUPS (1000) // max times monitor can wake up per sec
/* Calculate new number of monitor wakeups for a specific block time based on /* Calculate new number of monitor wakeups for a specific block time based on
previous monitor_wakeups. Only allow increasing number of wakeups */ previous monitor_wakeups. Only allow increasing number of wakeups */
#define KMP_WAKEUPS_FROM_BLOCKTIME(blocktime, monitor_wakeups) \ #define KMP_WAKEUPS_FROM_BLOCKTIME(blocktime, monitor_wakeups) \
(((blocktime) == KMP_MAX_BLOCKTIME) \ (((blocktime) == KMP_MAX_BLOCKTIME) ? (monitor_wakeups) \
? (monitor_wakeups) \ : ((blocktime) == KMP_MIN_BLOCKTIME) ? KMP_MAX_MONITOR_WAKEUPS \
: ((blocktime) == KMP_MIN_BLOCKTIME) \
? KMP_MAX_MONITOR_WAKEUPS \
: ((monitor_wakeups) > (KMP_BLOCKTIME_MULTIPLIER / (blocktime))) \ : ((monitor_wakeups) > (KMP_BLOCKTIME_MULTIPLIER / (blocktime))) \
? (monitor_wakeups) \ ? (monitor_wakeups) \
: (KMP_BLOCKTIME_MULTIPLIER) / (blocktime)) : (KMP_BLOCKTIME_MULTIPLIER) / (blocktime))
/* Calculate number of intervals for a specific block time based on /* Calculate number of intervals for a specific block time based on
monitor_wakeups */ monitor_wakeups */
#define KMP_INTERVALS_FROM_BLOCKTIME(blocktime, monitor_wakeups) \ #define KMP_INTERVALS_FROM_BLOCKTIME(blocktime, monitor_wakeups) \
(((blocktime) + (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)) - 1) / \ (((blocktime) + (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)) - 1) / \
(KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups))) (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)))
#else #else
#define KMP_BLOCKTIME(team, tid) \ #define KMP_BLOCKTIME(team, tid) \
▲ Show 20 Lines • Show All 270 Lines • ▼ Show 20 Lines
#if KMP_HAVE_WAITPKG_INTRINSICS #if KMP_HAVE_WAITPKG_INTRINSICS
#if KMP_HAVE_IMMINTRIN_H #if KMP_HAVE_IMMINTRIN_H
#include <immintrin.h> #include <immintrin.h>
#elif KMP_HAVE_INTRIN_H #elif KMP_HAVE_INTRIN_H
#include <intrin.h> #include <intrin.h>
#endif #endif
#endif // KMP_HAVE_WAITPKG_INTRINSICS #endif // KMP_HAVE_WAITPKG_INTRINSICS
KMP_ATTRIBUTE_TARGET_WAITPKG KMP_ATTRIBUTE_TARGET_WAITPKG
static inline int static inline int __kmp_tpause(uint32_t hint, uint64_t counter) {
__kmp_tpause(uint32_t hint, uint64_t counter) {
#if !KMP_HAVE_WAITPKG_INTRINSICS #if !KMP_HAVE_WAITPKG_INTRINSICS
uint32_t timeHi = uint32_t(counter >> 32); uint32_t timeHi = uint32_t(counter >> 32);
uint32_t timeLo = uint32_t(counter & 0xffffffff); uint32_t timeLo = uint32_t(counter & 0xffffffff);
char flag; char flag;
__asm__ volatile("#tpause\n.byte 0x66, 0x0F, 0xAE, 0xF1\n" __asm__ volatile("#tpause\n.byte 0x66, 0x0F, 0xAE, 0xF1\n"
"setb %0" "setb %0"
: "=r"(flag) : "=r"(flag)
: "a"(timeLo), "d"(timeHi), "c"(hint) : "a"(timeLo), "d"(timeHi), "c"(hint)
:); :);
return flag; return flag;
#else #else
return _tpause(hint, counter); return _tpause(hint, counter);
#endif #endif
} }
KMP_ATTRIBUTE_TARGET_WAITPKG KMP_ATTRIBUTE_TARGET_WAITPKG
static inline void static inline void __kmp_umonitor(void *cacheline) {
__kmp_umonitor(void *cacheline) {
#if !KMP_HAVE_WAITPKG_INTRINSICS #if !KMP_HAVE_WAITPKG_INTRINSICS
__asm__ volatile("# umonitor\n.byte 0xF3, 0x0F, 0xAE, 0x01 " __asm__ volatile("# umonitor\n.byte 0xF3, 0x0F, 0xAE, 0x01 "
: :
: "a"(cacheline) : "a"(cacheline)
:); :);
#else #else
_umonitor(cacheline); _umonitor(cacheline);
#endif #endif
} }
KMP_ATTRIBUTE_TARGET_WAITPKG KMP_ATTRIBUTE_TARGET_WAITPKG
static inline int static inline int __kmp_umwait(uint32_t hint, uint64_t counter) {
__kmp_umwait(uint32_t hint, uint64_t counter) {
#if !KMP_HAVE_WAITPKG_INTRINSICS #if !KMP_HAVE_WAITPKG_INTRINSICS
uint32_t timeHi = uint32_t(counter >> 32); uint32_t timeHi = uint32_t(counter >> 32);
uint32_t timeLo = uint32_t(counter & 0xffffffff); uint32_t timeLo = uint32_t(counter & 0xffffffff);
char flag; char flag;
__asm__ volatile("#umwait\n.byte 0xF2, 0x0F, 0xAE, 0xF1\n" __asm__ volatile("#umwait\n.byte 0xF2, 0x0F, 0xAE, 0xF1\n"
"setb %0" "setb %0"
: "=r"(flag) : "=r"(flag)
: "a"(timeLo), "d"(timeHi), "c"(hint) : "a"(timeLo), "d"(timeHi), "c"(hint)
▲ Show 20 Lines • Show All 496 Lines • ▼ Show 20 Lines
#define bs_reduction_barrier bs_plain_barrier #define bs_reduction_barrier bs_plain_barrier
#endif // KMP_FAST_REDUCTION_BARRIER #endif // KMP_FAST_REDUCTION_BARRIER
typedef enum kmp_bar_pat { /* Barrier communication patterns */ typedef enum kmp_bar_pat { /* Barrier communication patterns */
bp_linear_bar = bp_linear_bar =
0, /* Single level (degenerate) tree */ 0, /* Single level (degenerate) tree */
bp_tree_bar = bp_tree_bar =
1, /* Balanced tree with branching factor 2^n */ 1, /* Balanced tree with branching factor 2^n */
bp_hyper_bar = bp_hyper_bar = 2, /* Hypercube-embedded tree with min
2, /* Hypercube-embedded tree with min branching branching factor 2^n */
factor 2^n */
bp_hierarchical_bar = 3, /* Machine hierarchy tree */ bp_hierarchical_bar = 3, /* Machine hierarchy tree */
bp_last_bar /* Placeholder to mark the end */ bp_last_bar /* Placeholder to mark the end */
} kmp_bar_pat_e; } kmp_bar_pat_e;
#define KMP_BARRIER_ICV_PUSH 1 #define KMP_BARRIER_ICV_PUSH 1
/* Record for holding the values of the internal controls stack records */ /* Record for holding the values of the internal controls stack records */
typedef struct kmp_internal_control { typedef struct kmp_internal_control {
▲ Show 20 Lines • Show All 768 Lines • ▼ Show 20 Lines
typedef union KMP_ALIGN_CACHE kmp_info { typedef union KMP_ALIGN_CACHE kmp_info {
double th_align; /* use worst case alignment */ double th_align; /* use worst case alignment */
char th_pad[KMP_PAD(kmp_base_info_t, CACHE_LINE)]; char th_pad[KMP_PAD(kmp_base_info_t, CACHE_LINE)];
kmp_base_info_t th; kmp_base_info_t th;
} kmp_info_t; } kmp_info_t;
// OpenMP thread team data structures // OpenMP thread team data structures
typedef struct kmp_base_data { volatile kmp_uint32 t_value; } kmp_base_data_t; typedef struct kmp_base_data {
volatile kmp_uint32 t_value;
} kmp_base_data_t;
typedef union KMP_ALIGN_CACHE kmp_sleep_team { typedef union KMP_ALIGN_CACHE kmp_sleep_team {
double dt_align; /* use worst case alignment */ double dt_align; /* use worst case alignment */
char dt_pad[KMP_PAD(kmp_base_data_t, CACHE_LINE)]; char dt_pad[KMP_PAD(kmp_base_data_t, CACHE_LINE)];
kmp_base_data_t dt; kmp_base_data_t dt;
} kmp_sleep_team_t; } kmp_sleep_team_t;
typedef union KMP_ALIGN_CACHE kmp_ordered_team { typedef union KMP_ALIGN_CACHE kmp_ordered_team {
▲ Show 20 Lines • Show All 358 Lines • ▼ Show 20 Lines
#endif /* KMP_ADJUST_BLOCKTIME */ #endif /* KMP_ADJUST_BLOCKTIME */
#ifdef KMP_DFLT_NTH_CORES #ifdef KMP_DFLT_NTH_CORES
extern int __kmp_ncores; /* Total number of cores for threads placement */ extern int __kmp_ncores; /* Total number of cores for threads placement */
#endif #endif
/* Number of millisecs to delay on abort for Intel(R) VTune(TM) tools */ /* Number of millisecs to delay on abort for Intel(R) VTune(TM) tools */
extern int __kmp_abort_delay; extern int __kmp_abort_delay;
extern int __kmp_need_register_atfork_specified; extern int __kmp_need_register_atfork_specified;
extern int extern int __kmp_need_register_atfork; /* At initialization, call pthread_atfork
__kmp_need_register_atfork; /* At initialization, call pthread_atfork to to install fork handler */
install fork handler */
extern int __kmp_gtid_mode; /* Method of getting gtid, values: extern int __kmp_gtid_mode; /* Method of getting gtid, values:
0 - not set, will be set at runtime 0 - not set, will be set at runtime
1 - using stack search 1 - using stack search
2 - dynamic TLS (pthread_getspecific(Linux* OS/OS 2 - dynamic TLS (pthread_getspecific(Linux* OS/OS
X*) or TlsGetValue(Windows* OS)) X*) or TlsGetValue(Windows* OS))
3 - static TLS (__declspec(thread) __kmp_gtid), 3 - static TLS (__declspec(thread) __kmp_gtid),
Linux* OS .so only. */ Linux* OS .so only. */
extern int extern int
▲ Show 20 Lines • Show All 351 Lines • ▼ Show 20 Linesextern void __kmp_wait_4_ptr(void *spinner, kmp_uint32 checker,
kmp_uint32 (*pred)(void *, kmp_uint32), void *obj); kmp_uint32 (*pred)(void *, kmp_uint32), void *obj);
extern void __kmp_wait_64(kmp_info_t *this_thr, kmp_flag_64<> *flag, extern void __kmp_wait_64(kmp_info_t *this_thr, kmp_flag_64<> *flag,
int final_spin int final_spin
#if USE_ITT_BUILD #if USE_ITT_BUILD
, ,
void *itt_sync_obj void *itt_sync_obj
#endif #endif
); );
extern void __kmp_release_64(kmp_flag_64<> *flag); extern void __kmp_release_64(kmp_flag_64<> *flag);
extern void __kmp_infinite_loop(void); extern void __kmp_infinite_loop(void);
extern void __kmp_cleanup(void); extern void __kmp_cleanup(void);
#if KMP_HANDLE_SIGNALS #if KMP_HANDLE_SIGNALS
extern int __kmp_handle_signals; extern int __kmp_handle_signals;
▲ Show 20 Lines • Show All 241 Lines • ▼ Show 20 Lines
// //
extern int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int npr, int argc, extern int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int npr, int argc,
void *argv[] void *argv[]
#if OMPT_SUPPORT #if OMPT_SUPPORT
, ,
void **exit_frame_ptr void **exit_frame_ptr
#endif #endif
); );
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
KMP_EXPORT void __kmpc_begin(ident_t *, kmp_int32 flags); KMP_EXPORT void __kmpc_begin(ident_t *, kmp_int32 flags);
KMP_EXPORT void __kmpc_end(ident_t *); KMP_EXPORT void __kmpc_end(ident_t *);
KMP_EXPORT void __kmpc_threadprivate_register_vec(ident_t *, void *data, KMP_EXPORT void __kmpc_threadprivate_register_vec(ident_t *, void *data,
kmpc_ctor_vec ctor, kmpc_ctor_vec ctor,
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
/* OMP 3.0 tasking interface routines */ /* OMP 3.0 tasking interface routines */
KMP_EXPORT kmp_int32 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid, KMP_EXPORT kmp_int32 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid,
kmp_task_t *new_task); kmp_task_t *new_task);
KMP_EXPORT kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, KMP_EXPORT kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
kmp_int32 flags, kmp_int32 flags,
size_t sizeof_kmp_task_t, size_t sizeof_kmp_task_t,
size_t sizeof_shareds, size_t sizeof_shareds,
kmp_routine_entry_t task_entry); kmp_routine_entry_t task_entry);
KMP_EXPORT kmp_task_t *__kmpc_omp_target_task_alloc(ident_t *loc_ref, kmp_int32 gtid, KMP_EXPORT kmp_task_t *__kmpc_omp_target_task_alloc(
kmp_int32 flags, ident_t *loc_ref, kmp_int32 gtid, kmp_int32 flags, size_t sizeof_kmp_task_t,
size_t sizeof_kmp_task_t, size_t sizeof_shareds, kmp_routine_entry_t task_entry, kmp_int64 device_id);
size_t sizeof_shareds,
kmp_routine_entry_t task_entry,
kmp_int64 device_id);
KMP_EXPORT void __kmpc_omp_task_begin_if0(ident_t *loc_ref, kmp_int32 gtid, KMP_EXPORT void __kmpc_omp_task_begin_if0(ident_t *loc_ref, kmp_int32 gtid,
kmp_task_t *task); kmp_task_t *task);
KMP_EXPORT void __kmpc_omp_task_complete_if0(ident_t *loc_ref, kmp_int32 gtid, KMP_EXPORT void __kmpc_omp_task_complete_if0(ident_t *loc_ref, kmp_int32 gtid,
kmp_task_t *task); kmp_task_t *task);
KMP_EXPORT kmp_int32 __kmpc_omp_task_parts(ident_t *loc_ref, kmp_int32 gtid, KMP_EXPORT kmp_int32 __kmpc_omp_task_parts(ident_t *loc_ref, kmp_int32 gtid,
kmp_task_t *new_task); kmp_task_t *new_task);
KMP_EXPORT kmp_int32 __kmpc_omp_taskwait(ident_t *loc_ref, kmp_int32 gtid); KMP_EXPORT kmp_int32 __kmpc_omp_taskwait(ident_t *loc_ref, kmp_int32 gtid);
▲ Show 20 Lines • Show All 501 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_affinity.h

Show First 20 Lines • Show All 331 Lines • ▼ Show 20 Lines public:
} }
int get_system_affinity(bool abort_on_error) override { int get_system_affinity(bool abort_on_error) override {
KMP_ASSERT2(KMP_AFFINITY_CAPABLE(), KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
"Illegal get affinity operation when not capable"); "Illegal get affinity operation when not capable");
#if KMP_OS_LINUX #if KMP_OS_LINUX
long retval = long retval =
syscall(__NR_sched_getaffinity, 0, __kmp_affin_mask_size, mask); syscall(__NR_sched_getaffinity, 0, __kmp_affin_mask_size, mask);
#elif KMP_OS_FREEBSD #elif KMP_OS_FREEBSD
int r = int r = pthread_getaffinity_np(pthread_self(), __kmp_affin_mask_size,
pthread_getaffinity_np(pthread_self(), __kmp_affin_mask_size, reinterpret_cast<cpuset_t *>(mask)); reinterpret_cast<cpuset_t *>(mask));
int retval = (r == 0 ? 0 : -1); int retval = (r == 0 ? 0 : -1);
#endif #endif
if (retval >= 0) { if (retval >= 0) {
return 0; return 0;
} }
int error = errno; int error = errno;
if (abort_on_error) { if (abort_on_error) {
__kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null); __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
} }
return error; return error;
} }
int set_system_affinity(bool abort_on_error) const override { int set_system_affinity(bool abort_on_error) const override {
KMP_ASSERT2(KMP_AFFINITY_CAPABLE(), KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
"Illegal set affinity operation when not capable"); "Illegal set affinity operation when not capable");
#if KMP_OS_LINUX #if KMP_OS_LINUX
long retval = long retval =
syscall(__NR_sched_setaffinity, 0, __kmp_affin_mask_size, mask); syscall(__NR_sched_setaffinity, 0, __kmp_affin_mask_size, mask);
#elif KMP_OS_FREEBSD #elif KMP_OS_FREEBSD
int r = int r = pthread_setaffinity_np(pthread_self(), __kmp_affin_mask_size,
pthread_setaffinity_np(pthread_self(), __kmp_affin_mask_size, reinterpret_cast<cpuset_t *>(mask)); reinterpret_cast<cpuset_t *>(mask));
int retval = (r == 0 ? 0 : -1); int retval = (r == 0 ? 0 : -1);
#endif #endif
if (retval >= 0) { if (retval >= 0) {
return 0; return 0;
} }
int error = errno; int error = errno;
if (abort_on_error) { if (abort_on_error) {
__kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null); __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
▲ Show 20 Lines • Show All 522 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_affinity.cpp

Show First 20 Lines • Show All 591 Lines • ▼ Show 20 Lines
// HWLOC_OBJ_PU, then this will return the number of PU's under the SOCKET // HWLOC_OBJ_PU, then this will return the number of PU's under the SOCKET
// object. // object.
static int __kmp_hwloc_get_nobjs_under_obj(hwloc_obj_t obj, static int __kmp_hwloc_get_nobjs_under_obj(hwloc_obj_t obj,
hwloc_obj_type_t type) { hwloc_obj_type_t type) {
int retval = 0; int retval = 0;
hwloc_obj_t first; hwloc_obj_t first;
for (first = hwloc_get_obj_below_by_type(__kmp_hwloc_topology, obj->type, for (first = hwloc_get_obj_below_by_type(__kmp_hwloc_topology, obj->type,
obj->logical_index, type, 0); obj->logical_index, type, 0);
first != NULL && first != NULL && hwloc_get_ancestor_obj_by_type(__kmp_hwloc_topology,
hwloc_get_ancestor_obj_by_type(__kmp_hwloc_topology, obj->type, first) == obj->type, first) == obj;
obj;
first = hwloc_get_next_obj_by_type(__kmp_hwloc_topology, first->type, first = hwloc_get_next_obj_by_type(__kmp_hwloc_topology, first->type,
first)) { first)) {
++retval; ++retval;
} }
return retval; return retval;
} }
static int __kmp_hwloc_count_children_by_depth(hwloc_topology_t t, static int __kmp_hwloc_count_children_by_depth(hwloc_topology_t t,
▲ Show 20 Lines • Show All 310 Lines • ▼ Show 20 Lines if (__kmp_affinity_verbose) {
denominator_type = KMP_HW_UNKNOWN; denominator_type = KMP_HW_UNKNOWN;
for (int level = 0; level < depth; ++level) { for (int level = 0; level < depth; ++level) {
int c; int c;
bool plural; bool plural;
numerator_type = types[level]; numerator_type = types[level];
c = ratio[level]; c = ratio[level];
plural = (c > 1); plural = (c > 1);
if (level == 0) { if (level == 0) {
__kmp_str_buf_print(&buf, "%d %s", c, __kmp_hw_get_catalog_string( __kmp_str_buf_print(
numerator_type, plural)); &buf, "%d %s", c,
__kmp_hw_get_catalog_string(numerator_type, plural));
} else { } else {
__kmp_str_buf_print(&buf, " x %d %s/%s", c, __kmp_str_buf_print(&buf, " x %d %s/%s", c,
__kmp_hw_get_catalog_string(numerator_type, plural), __kmp_hw_get_catalog_string(numerator_type, plural),
__kmp_hw_get_catalog_string(denominator_type)); __kmp_hw_get_catalog_string(denominator_type));
} }
denominator_type = numerator_type; denominator_type = numerator_type;
} }
KMP_INFORM(TopologyGeneric, "KMP_AFFINITY", buf.str, ncores); KMP_INFORM(TopologyGeneric, "KMP_AFFINITY", buf.str, ncores);
▲ Show 20 Lines • Show All 1,025 Lines • ▼ Show 20 Lines if (__kmp_affinity_verbose) {
denominator_type = KMP_HW_UNKNOWN; denominator_type = KMP_HW_UNKNOWN;
for (int level = 0; level < depth; ++level) { for (int level = 0; level < depth; ++level) {
int c; int c;
bool plural; bool plural;
numerator_type = types[level]; numerator_type = types[level];
c = ratio[level]; c = ratio[level];
plural = (c > 1); plural = (c > 1);
if (level == 0) { if (level == 0) {
__kmp_str_buf_print(&buf, "%d %s", c, __kmp_hw_get_catalog_string( __kmp_str_buf_print(
numerator_type, plural)); &buf, "%d %s", c,
__kmp_hw_get_catalog_string(numerator_type, plural));
} else { } else {
__kmp_str_buf_print(&buf, " x %d %s/%s", c, __kmp_str_buf_print(&buf, " x %d %s/%s", c,
__kmp_hw_get_catalog_string(numerator_type, plural), __kmp_hw_get_catalog_string(numerator_type, plural),
__kmp_hw_get_catalog_string(denominator_type)); __kmp_hw_get_catalog_string(denominator_type));
} }
denominator_type = numerator_type; denominator_type = numerator_type;
} }
KMP_INFORM(TopologyGeneric, "KMP_AFFINITY", buf.str, ncores); KMP_INFORM(TopologyGeneric, "KMP_AFFINITY", buf.str, ncores);
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linesstatic void __kmp_dispatch_set_hierarchy_values() {
// Set the maximum number of L1's to number of cores // Set the maximum number of L1's to number of cores
// Set the maximum number of L2's to to either number of cores / 2 for // Set the maximum number of L2's to to either number of cores / 2 for
// Intel(R) Xeon Phi(TM) coprocessor formally codenamed Knights Landing // Intel(R) Xeon Phi(TM) coprocessor formally codenamed Knights Landing
// Or the number of cores for Intel(R) Xeon(R) processors // Or the number of cores for Intel(R) Xeon(R) processors
// Set the maximum number of NUMA nodes and L3's to number of packages // Set the maximum number of NUMA nodes and L3's to number of packages
__kmp_hier_max_units[kmp_hier_layer_e::LAYER_THREAD + 1] = __kmp_hier_max_units[kmp_hier_layer_e::LAYER_THREAD + 1] =
nPackages * nCoresPerPkg * __kmp_nThreadsPerCore; nPackages * nCoresPerPkg * __kmp_nThreadsPerCore;
__kmp_hier_max_units[kmp_hier_layer_e::LAYER_L1 + 1] = __kmp_ncores; __kmp_hier_max_units[kmp_hier_layer_e::LAYER_L1 + 1] = __kmp_ncores;
#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS) && \ #if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS) && \
KMP_MIC_SUPPORTED KMP_MIC_SUPPORTED
if (__kmp_mic_type >= mic3) if (__kmp_mic_type >= mic3)
__kmp_hier_max_units[kmp_hier_layer_e::LAYER_L2 + 1] = __kmp_ncores / 2; __kmp_hier_max_units[kmp_hier_layer_e::LAYER_L2 + 1] = __kmp_ncores / 2;
else else
#endif // KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS) #endif // KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
__kmp_hier_max_units[kmp_hier_layer_e::LAYER_L2 + 1] = __kmp_ncores; __kmp_hier_max_units[kmp_hier_layer_e::LAYER_L2 + 1] = __kmp_ncores;
__kmp_hier_max_units[kmp_hier_layer_e::LAYER_L3 + 1] = nPackages; __kmp_hier_max_units[kmp_hier_layer_e::LAYER_L3 + 1] = nPackages;
__kmp_hier_max_units[kmp_hier_layer_e::LAYER_NUMA + 1] = nPackages; __kmp_hier_max_units[kmp_hier_layer_e::LAYER_NUMA + 1] = nPackages;
__kmp_hier_max_units[kmp_hier_layer_e::LAYER_LOOP + 1] = 1; __kmp_hier_max_units[kmp_hier_layer_e::LAYER_LOOP + 1] = 1;
// Set the number of threads per unit // Set the number of threads per unit
// Number of hardware threads per L1/L2/L3/NUMA/LOOP // Number of hardware threads per L1/L2/L3/NUMA/LOOP
__kmp_hier_threads_per[kmp_hier_layer_e::LAYER_THREAD + 1] = 1; __kmp_hier_threads_per[kmp_hier_layer_e::LAYER_THREAD + 1] = 1;
__kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L1 + 1] = __kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L1 + 1] =
__kmp_nThreadsPerCore; __kmp_nThreadsPerCore;
#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS) && \ #if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS) && \
KMP_MIC_SUPPORTED KMP_MIC_SUPPORTED
if (__kmp_mic_type >= mic3) if (__kmp_mic_type >= mic3)
__kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L2 + 1] = __kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L2 + 1] =
2 * __kmp_nThreadsPerCore; 2 * __kmp_nThreadsPerCore;
else else
#endif // KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS) #endif // KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
__kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L2 + 1] = __kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L2 + 1] =
__kmp_nThreadsPerCore; __kmp_nThreadsPerCore;
▲ Show 20 Lines • Show All 1,972 Lines • ▼ Show 20 Lines for (int i = 0; i < nPackages; ++i) {
++proc_num; ++proc_num;
} }
} }
} }
} }
} }
} }
} }
KMP_DEBUG_ASSERT(n_old == KMP_DEBUG_ASSERT(n_old == nPackages * nDiesPerPkg * nCoresPerPkg *
nPackages * nDiesPerPkg * nCoresPerPkg *
__kmp_nThreadsPerCore); __kmp_nThreadsPerCore);
KMP_DEBUG_ASSERT(n_new == KMP_DEBUG_ASSERT(n_new == __kmp_hws_socket.num * __kmp_hws_die.num *
__kmp_hws_socket.num * __kmp_hws_die.num *
__kmp_hws_core.num * __kmp_hws_proc.num); __kmp_hws_core.num * __kmp_hws_proc.num);
nPackages = __kmp_hws_socket.num; // correct nPackages nPackages = __kmp_hws_socket.num; // correct nPackages
nCoresPerPkg = __kmp_hws_core.num; // correct nCoresPerPkg nCoresPerPkg = __kmp_hws_core.num; // correct nCoresPerPkg
nDiesPerPkg = __kmp_hws_die.num; // correct nDiesPerPkg nDiesPerPkg = __kmp_hws_die.num; // correct nDiesPerPkg
__kmp_nThreadsPerCore = __kmp_hws_proc.num; // correct __kmp_nThreadsPerCore __kmp_nThreadsPerCore = __kmp_hws_proc.num; // correct __kmp_nThreadsPerCore
__kmp_avail_proc = n_new; // correct avail_proc __kmp_avail_proc = n_new; // correct avail_proc
__kmp_ncores = __kmp_ncores =
nPackages * nDiesPerPkg * __kmp_hws_core.num; // correct ncores nPackages * nDiesPerPkg * __kmp_hws_core.num; // correct ncores
} // non-hwloc topology method } // non-hwloc topology method
▲ Show 20 Lines • Show All 350 Lines • ▼ Show 20 Lines else if (__kmp_affinity_top_method == affinity_top_method_hwloc) {
} }
depth = __kmp_affinity_create_hwloc_map(&address2os, &msg_id); depth = __kmp_affinity_create_hwloc_map(&address2os, &msg_id);
if (depth == 0) { if (depth == 0) {
KMP_EXIT_AFF_NONE; KMP_EXIT_AFF_NONE;
} }
} }
#endif // KMP_USE_HWLOC #endif // KMP_USE_HWLOC
// If the user has specified that a particular topology discovery method is to be // If the user has specified that a particular topology discovery method is to
// used, then we abort if that method fails. The exception is group affinity, // be used, then we abort if that method fails. The exception is group
// which might have been implicitly set. // affinity, which might have been implicitly set.
#if KMP_ARCH_X86 || KMP_ARCH_X86_64 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
else if (__kmp_affinity_top_method == affinity_top_method_x2apicid || else if (__kmp_affinity_top_method == affinity_top_method_x2apicid ||
__kmp_affinity_top_method == affinity_top_method_x2apicid_1f) { __kmp_affinity_top_method == affinity_top_method_x2apicid_1f) {
if (__kmp_affinity_verbose) { if (__kmp_affinity_verbose) {
KMP_INFORM(AffInfoStr, "KMP_AFFINITY", KMP_I18N_STR(Decodingx2APIC)); KMP_INFORM(AffInfoStr, "KMP_AFFINITY", KMP_I18N_STR(Decodingx2APIC));
} }
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines if (address2os == NULL) {
KMP_AFFINITY_DISABLE(); KMP_AFFINITY_DISABLE();
return; return;
} }
if (__kmp_affinity_gran == affinity_gran_tile if (__kmp_affinity_gran == affinity_gran_tile
#if KMP_USE_HWLOC #if KMP_USE_HWLOC
&& __kmp_tile_depth == 0 && __kmp_tile_depth == 0
#endif #endif
) { ) {
// tiles requested but not detected, warn user on this // tiles requested but not detected, warn user on this
KMP_WARNING(AffTilesNoTiles, "KMP_AFFINITY"); KMP_WARNING(AffTilesNoTiles, "KMP_AFFINITY");
} }
__kmp_apply_thread_places(&address2os, depth); __kmp_apply_thread_places(&address2os, depth);
// Create the table of masks, indexed by thread Id. // Create the table of masks, indexed by thread Id.
unsigned maxIndex; unsigned maxIndex;
Show All 28 Lines if (__kmp_affinity_num_masks == 0) {
KMP_WARNING(AffNoValidProcID); KMP_WARNING(AffNoValidProcID);
} }
__kmp_affinity_type = affinity_none; __kmp_affinity_type = affinity_none;
__kmp_create_affinity_none_places(); __kmp_create_affinity_none_places();
return; return;
} }
break; break;
// The other affinity types rely on sorting the Addresses according to some // The other affinity types rely on sorting the Addresses according to some
// permutation of the machine topology tree. Set __kmp_affinity_compact and // permutation of the machine topology tree. Set __kmp_affinity_compact and
// __kmp_affinity_offset appropriately, then jump to a common code fragment // __kmp_affinity_offset appropriately, then jump to a common code fragment
// to do the sort and create the array of affinity masks. // to do the sort and create the array of affinity masks.
case affinity_logical: case affinity_logical:
__kmp_affinity_compact = 0; __kmp_affinity_compact = 0;
if (__kmp_affinity_offset) { if (__kmp_affinity_offset) {
__kmp_affinity_offset = __kmp_affinity_offset =
__kmp_nThreadsPerCore * __kmp_affinity_offset % __kmp_avail_proc; __kmp_nThreadsPerCore * __kmp_affinity_offset % __kmp_avail_proc;
} }
goto sortAddresses; goto sortAddresses;
▲ Show 20 Lines • Show All 329 Lines • ▼ Show 20 Linesint __kmp_aux_set_affinity(void **mask) {
kmp_info_t *th; kmp_info_t *th;
int retval; int retval;
if (!KMP_AFFINITY_CAPABLE()) { if (!KMP_AFFINITY_CAPABLE()) {
return -1; return -1;
} }
gtid = __kmp_entry_gtid(); gtid = __kmp_entry_gtid();
KA_TRACE(1000, (""); { KA_TRACE(
1000, (""); {
char buf[KMP_AFFIN_MASK_PRINT_LEN]; char buf[KMP_AFFIN_MASK_PRINT_LEN];
__kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
(kmp_affin_mask_t *)(*mask)); (kmp_affin_mask_t *)(*mask));
__kmp_debug_printf( __kmp_debug_printf(
"kmp_set_affinity: setting affinity mask for thread %d = %s\n", gtid, "kmp_set_affinity: setting affinity mask for thread %d = %s\n",
buf); gtid, buf);
}); });
if (__kmp_env_consistency_check) { if (__kmp_env_consistency_check) {
if ((mask == NULL) || (*mask == NULL)) { if ((mask == NULL) || (*mask == NULL)) {
KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity"); KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity");
} else { } else {
unsigned proc; unsigned proc;
int num_procs = 0; int num_procs = 0;
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesint __kmp_aux_get_affinity(void **mask) {
if (!KMP_AFFINITY_CAPABLE()) { if (!KMP_AFFINITY_CAPABLE()) {
return -1; return -1;
} }
gtid = __kmp_entry_gtid(); gtid = __kmp_entry_gtid();
th = __kmp_threads[gtid]; th = __kmp_threads[gtid];
KMP_DEBUG_ASSERT(th->th.th_affin_mask != NULL); KMP_DEBUG_ASSERT(th->th.th_affin_mask != NULL);
KA_TRACE(1000, (""); { KA_TRACE(
1000, (""); {
char buf[KMP_AFFIN_MASK_PRINT_LEN]; char buf[KMP_AFFIN_MASK_PRINT_LEN];
__kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
th->th.th_affin_mask); th->th.th_affin_mask);
__kmp_printf("kmp_get_affinity: stored affinity mask for thread %d = %s\n", __kmp_printf(
gtid, buf); "kmp_get_affinity: stored affinity mask for thread %d = %s\n", gtid,
buf);
}); });
if (__kmp_env_consistency_check) { if (__kmp_env_consistency_check) {
if ((mask == NULL) || (*mask == NULL)) { if ((mask == NULL) || (*mask == NULL)) {
KMP_FATAL(AffinityInvalidMask, "kmp_get_affinity"); KMP_FATAL(AffinityInvalidMask, "kmp_get_affinity");
} }
} }
#if !KMP_OS_WINDOWS #if !KMP_OS_WINDOWS
retval = __kmp_get_system_affinity((kmp_affin_mask_t *)(*mask), FALSE); retval = __kmp_get_system_affinity((kmp_affin_mask_t *)(*mask), FALSE);
KA_TRACE(1000, (""); { KA_TRACE(
1000, (""); {
char buf[KMP_AFFIN_MASK_PRINT_LEN]; char buf[KMP_AFFIN_MASK_PRINT_LEN];
__kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
(kmp_affin_mask_t *)(*mask)); (kmp_affin_mask_t *)(*mask));
__kmp_printf("kmp_get_affinity: system affinity mask for thread %d = %s\n", __kmp_printf(
gtid, buf); "kmp_get_affinity: system affinity mask for thread %d = %s\n", gtid,
buf);
}); });
return retval; return retval;
#else #else
(void)retval; (void)retval;
KMP_CPU_COPY((kmp_affin_mask_t *)(*mask), th->th.th_affin_mask); KMP_CPU_COPY((kmp_affin_mask_t *)(*mask), th->th.th_affin_mask);
return 0; return 0;
Show All 12 Lines#endif
return __kmp_xproc; return __kmp_xproc;
} }
int __kmp_aux_set_affinity_mask_proc(int proc, void **mask) { int __kmp_aux_set_affinity_mask_proc(int proc, void **mask) {
if (!KMP_AFFINITY_CAPABLE()) { if (!KMP_AFFINITY_CAPABLE()) {
return -1; return -1;
} }
KA_TRACE(1000, (""); { KA_TRACE(
1000, (""); {
int gtid = __kmp_entry_gtid(); int gtid = __kmp_entry_gtid();
char buf[KMP_AFFIN_MASK_PRINT_LEN]; char buf[KMP_AFFIN_MASK_PRINT_LEN];
__kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
(kmp_affin_mask_t *)(*mask)); (kmp_affin_mask_t *)(*mask));
__kmp_debug_printf("kmp_set_affinity_mask_proc: setting proc %d in " __kmp_debug_printf("kmp_set_affinity_mask_proc: setting proc %d in "
"affinity mask for thread %d = %s\n", "affinity mask for thread %d = %s\n",
proc, gtid, buf); proc, gtid, buf);
}); });
if (__kmp_env_consistency_check) { if (__kmp_env_consistency_check) {
if ((mask == NULL) || (*mask == NULL)) { if ((mask == NULL) || (*mask == NULL)) {
KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity_mask_proc"); KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity_mask_proc");
} }
} }
if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) { if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) {
return -1; return -1;
} }
if (!KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) { if (!KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
return -2; return -2;
} }
KMP_CPU_SET(proc, (kmp_affin_mask_t *)(*mask)); KMP_CPU_SET(proc, (kmp_affin_mask_t *)(*mask));
return 0; return 0;
} }
int __kmp_aux_unset_affinity_mask_proc(int proc, void **mask) { int __kmp_aux_unset_affinity_mask_proc(int proc, void **mask) {
if (!KMP_AFFINITY_CAPABLE()) { if (!KMP_AFFINITY_CAPABLE()) {
return -1; return -1;
} }
KA_TRACE(1000, (""); { KA_TRACE(
1000, (""); {
int gtid = __kmp_entry_gtid(); int gtid = __kmp_entry_gtid();
char buf[KMP_AFFIN_MASK_PRINT_LEN]; char buf[KMP_AFFIN_MASK_PRINT_LEN];
__kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
(kmp_affin_mask_t *)(*mask)); (kmp_affin_mask_t *)(*mask));
__kmp_debug_printf("kmp_unset_affinity_mask_proc: unsetting proc %d in " __kmp_debug_printf("kmp_unset_affinity_mask_proc: unsetting proc %d in "
"affinity mask for thread %d = %s\n", "affinity mask for thread %d = %s\n",
proc, gtid, buf); proc, gtid, buf);
}); });
if (__kmp_env_consistency_check) { if (__kmp_env_consistency_check) {
if ((mask == NULL) || (*mask == NULL)) { if ((mask == NULL) || (*mask == NULL)) {
KMP_FATAL(AffinityInvalidMask, "kmp_unset_affinity_mask_proc"); KMP_FATAL(AffinityInvalidMask, "kmp_unset_affinity_mask_proc");
} }
} }
if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) { if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) {
return -1; return -1;
} }
if (!KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) { if (!KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
return -2; return -2;
} }
KMP_CPU_CLR(proc, (kmp_affin_mask_t *)(*mask)); KMP_CPU_CLR(proc, (kmp_affin_mask_t *)(*mask));
return 0; return 0;
} }
int __kmp_aux_get_affinity_mask_proc(int proc, void **mask) { int __kmp_aux_get_affinity_mask_proc(int proc, void **mask) {
if (!KMP_AFFINITY_CAPABLE()) { if (!KMP_AFFINITY_CAPABLE()) {
return -1; return -1;
} }
KA_TRACE(1000, (""); { KA_TRACE(
1000, (""); {
int gtid = __kmp_entry_gtid(); int gtid = __kmp_entry_gtid();
char buf[KMP_AFFIN_MASK_PRINT_LEN]; char buf[KMP_AFFIN_MASK_PRINT_LEN];
__kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
(kmp_affin_mask_t *)(*mask)); (kmp_affin_mask_t *)(*mask));
__kmp_debug_printf("kmp_get_affinity_mask_proc: getting proc %d in " __kmp_debug_printf("kmp_get_affinity_mask_proc: getting proc %d in "
"affinity mask for thread %d = %s\n", "affinity mask for thread %d = %s\n",
proc, gtid, buf); proc, gtid, buf);
}); });
if (__kmp_env_consistency_check) { if (__kmp_env_consistency_check) {
if ((mask == NULL) || (*mask == NULL)) { if ((mask == NULL) || (*mask == NULL)) {
KMP_FATAL(AffinityInvalidMask, "kmp_get_affinity_mask_proc"); KMP_FATAL(AffinityInvalidMask, "kmp_get_affinity_mask_proc");
} }
} }
if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) { if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) {
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_alloc.cpp

Show First 20 Lines • Show All 309 Lines • ▼ Show 20 Lines
} }
/* Chain together the free buffers by using the thread owner field */ /* Chain together the free buffers by using the thread owner field */
static void __kmp_bget_enqueue(kmp_info_t *th, void *buf static void __kmp_bget_enqueue(kmp_info_t *th, void *buf
#ifdef USE_QUEUING_LOCK_FOR_BGET #ifdef USE_QUEUING_LOCK_FOR_BGET
, ,
kmp_int32 rel_gtid kmp_int32 rel_gtid
#endif #endif
) { ) {
bfhead_t *b = BFH(((char *)buf) - sizeof(bhead_t)); bfhead_t *b = BFH(((char *)buf) - sizeof(bhead_t));
KMP_DEBUG_ASSERT(b->bh.bb.bsize != 0); KMP_DEBUG_ASSERT(b->bh.bb.bsize != 0);
KMP_DEBUG_ASSERT(((kmp_uintptr_t)TCR_PTR(b->bh.bb.bthr) & ~1) == KMP_DEBUG_ASSERT(((kmp_uintptr_t)TCR_PTR(b->bh.bb.bthr) & ~1) ==
(kmp_uintptr_t)th); // clear possible mark (kmp_uintptr_t)th); // clear possible mark
b->ql.blink = 0; b->ql.blink = 0;
▲ Show 20 Lines • Show All 406 Lines • ▼ Show 20 Lines bth = (kmp_info_t *)((kmp_uintptr_t)TCR_PTR(b->bh.bb.bthr) &
~1); // clear possible mark before comparison ~1); // clear possible mark before comparison
if (bth != th) { if (bth != th) {
/* Add this buffer to be released by the owning thread later */ /* Add this buffer to be released by the owning thread later */
__kmp_bget_enqueue(bth, buf __kmp_bget_enqueue(bth, buf
#ifdef USE_QUEUING_LOCK_FOR_BGET #ifdef USE_QUEUING_LOCK_FOR_BGET
, ,
__kmp_gtid_from_thread(th) __kmp_gtid_from_thread(th)
#endif #endif
); );
return; return;
} }
/* Buffer size must be negative, indicating that the buffer is allocated. */ /* Buffer size must be negative, indicating that the buffer is allocated. */
if (b->bh.bb.bsize >= 0) { if (b->bh.bb.bsize >= 0) {
bn = NULL; bn = NULL;
} }
KMP_DEBUG_ASSERT(b->bh.bb.bsize < 0); KMP_DEBUG_ASSERT(b->bh.bb.bsize < 0);
▲ Show 20 Lines • Show All 1,190 Lines • ▼ Show 20 Linesvoid *___kmp_fast_allocate(kmp_info_t *this_thr, size_t size KMP_SRC_LOC_DECL) {
} else { } else {
goto alloc_call; // 65 or more cache lines ( > 8KB ), don't use free lists goto alloc_call; // 65 or more cache lines ( > 8KB ), don't use free lists
} }
ptr = this_thr->th.th_free_lists[index].th_free_list_self; ptr = this_thr->th.th_free_lists[index].th_free_list_self;
if (ptr != NULL) { if (ptr != NULL) {
// pop the head of no-sync free list // pop the head of no-sync free list
this_thr->th.th_free_lists[index].th_free_list_self = *((void **)ptr); this_thr->th.th_free_lists[index].th_free_list_self = *((void **)ptr);
KMP_DEBUG_ASSERT( KMP_DEBUG_ASSERT(this_thr == ((kmp_mem_descr_t *)((kmp_uintptr_t)ptr -
this_thr == sizeof(kmp_mem_descr_t)))
((kmp_mem_descr_t *)((kmp_uintptr_t)ptr - sizeof(kmp_mem_descr_t)))
->ptr_aligned); ->ptr_aligned);
goto end; goto end;
} }
ptr = TCR_SYNC_PTR(this_thr->th.th_free_lists[index].th_free_list_sync); ptr = TCR_SYNC_PTR(this_thr->th.th_free_lists[index].th_free_list_sync);
if (ptr != NULL) { if (ptr != NULL) {
// no-sync free list is empty, use sync free list (filled in by other // no-sync free list is empty, use sync free list (filled in by other
// threads only) // threads only)
// pop the head of the sync free list, push NULL instead // pop the head of the sync free list, push NULL instead
while (!KMP_COMPARE_AND_STORE_PTR( while (!KMP_COMPARE_AND_STORE_PTR(
&this_thr->th.th_free_lists[index].th_free_list_sync, ptr, nullptr)) { &this_thr->th.th_free_lists[index].th_free_list_sync, ptr, nullptr)) {
KMP_CPU_PAUSE(); KMP_CPU_PAUSE();
ptr = TCR_SYNC_PTR(this_thr->th.th_free_lists[index].th_free_list_sync); ptr = TCR_SYNC_PTR(this_thr->th.th_free_lists[index].th_free_list_sync);
} }
// push the rest of chain into no-sync free list (can be NULL if there was // push the rest of chain into no-sync free list (can be NULL if there was
// the only block) // the only block)
this_thr->th.th_free_lists[index].th_free_list_self = *((void **)ptr); this_thr->th.th_free_lists[index].th_free_list_self = *((void **)ptr);
KMP_DEBUG_ASSERT( KMP_DEBUG_ASSERT(this_thr == ((kmp_mem_descr_t *)((kmp_uintptr_t)ptr -
this_thr == sizeof(kmp_mem_descr_t)))
((kmp_mem_descr_t *)((kmp_uintptr_t)ptr - sizeof(kmp_mem_descr_t)))
->ptr_aligned); ->ptr_aligned);
goto end; goto end;
} }
alloc_call: alloc_call:
// haven't found block in the free lists, thus allocate it // haven't found block in the free lists, thus allocate it
size = num_lines * DCACHE_LINE; size = num_lines * DCACHE_LINE;
alloc_size = size + sizeof(kmp_mem_descr_t) + DCACHE_LINE; alloc_size = size + sizeof(kmp_mem_descr_t) + DCACHE_LINE;
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_atomic.h

Show First 20 Lines • Show All 357 Lines • ▼ Show 20 Lines
// Atomic locks can easily become contended, so we use queuing locks for them. // Atomic locks can easily become contended, so we use queuing locks for them.
typedef kmp_queuing_lock_t kmp_atomic_lock_t; typedef kmp_queuing_lock_t kmp_atomic_lock_t;
static inline void __kmp_acquire_atomic_lock(kmp_atomic_lock_t *lck, static inline void __kmp_acquire_atomic_lock(kmp_atomic_lock_t *lck,
kmp_int32 gtid) { kmp_int32 gtid) {
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
if (ompt_enabled.ompt_callback_mutex_acquire) { if (ompt_enabled.ompt_callback_mutex_acquire) {
ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)( ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
ompt_mutex_atomic, 0, kmp_mutex_impl_queuing, (ompt_wait_id_t)(uintptr_t)lck, ompt_mutex_atomic, 0, kmp_mutex_impl_queuing,
OMPT_GET_RETURN_ADDRESS(0)); (ompt_wait_id_t)(uintptr_t)lck, OMPT_GET_RETURN_ADDRESS(0));
} }
#endif #endif
__kmp_acquire_queuing_lock(lck, gtid); __kmp_acquire_queuing_lock(lck, gtid);
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
if (ompt_enabled.ompt_callback_mutex_acquired) { if (ompt_enabled.ompt_callback_mutex_acquired) {
ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)( ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
ompt_mutex_atomic, (ompt_wait_id_t)(uintptr_t)lck, OMPT_GET_RETURN_ADDRESS(0)); ompt_mutex_atomic, (ompt_wait_id_t)(uintptr_t)lck,
OMPT_GET_RETURN_ADDRESS(0));
} }
#endif #endif
} }
static inline int __kmp_test_atomic_lock(kmp_atomic_lock_t *lck, static inline int __kmp_test_atomic_lock(kmp_atomic_lock_t *lck,
kmp_int32 gtid) { kmp_int32 gtid) {
return __kmp_test_queuing_lock(lck, gtid); return __kmp_test_queuing_lock(lck, gtid);
} }
static inline void __kmp_release_atomic_lock(kmp_atomic_lock_t *lck, static inline void __kmp_release_atomic_lock(kmp_atomic_lock_t *lck,
kmp_int32 gtid) { kmp_int32 gtid) {
__kmp_release_queuing_lock(lck, gtid); __kmp_release_queuing_lock(lck, gtid);
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
if (ompt_enabled.ompt_callback_mutex_released) { if (ompt_enabled.ompt_callback_mutex_released) {
ompt_callbacks.ompt_callback(ompt_callback_mutex_released)( ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
ompt_mutex_atomic, (ompt_wait_id_t)(uintptr_t)lck, OMPT_GET_RETURN_ADDRESS(0)); ompt_mutex_atomic, (ompt_wait_id_t)(uintptr_t)lck,
OMPT_GET_RETURN_ADDRESS(0));
} }
#endif #endif
} }
static inline void __kmp_init_atomic_lock(kmp_atomic_lock_t *lck) { static inline void __kmp_init_atomic_lock(kmp_atomic_lock_t *lck) {
__kmp_init_queuing_lock(lck); __kmp_init_queuing_lock(lck);
} }
▲ Show 20 Lines • Show All 1,367 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_atomic.cpp

Show First 20 Lines • Show All 3,375 Lines • ▼ Show 20 Linesvoid __kmpc_atomic_1(ident_t *id_ref, int gtid, void *lhs, void *rhs,
KMP_DEBUG_ASSERT(__kmp_init_serial); KMP_DEBUG_ASSERT(__kmp_init_serial);
if ( if (
#if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT) #if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
FALSE /* must use lock */ FALSE /* must use lock */
#else #else
TRUE TRUE
#endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT) #endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
) { ) {
kmp_int8 old_value, new_value; kmp_int8 old_value, new_value;
old_value = *(kmp_int8 *)lhs; old_value = *(kmp_int8 *)lhs;
(*f)(&new_value, &old_value, rhs); (*f)(&new_value, &old_value, rhs);
/* TODO: Should this be acquire or release? */ /* TODO: Should this be acquire or release? */
while (!KMP_COMPARE_AND_STORE_ACQ8((kmp_int8 *)lhs, *(kmp_int8 *)&old_value, while (!KMP_COMPARE_AND_STORE_ACQ8((kmp_int8 *)lhs, *(kmp_int8 *)&old_value,
*(kmp_int8 *)&new_value)) { *(kmp_int8 *)&new_value)) {
KMP_CPU_PAUSE(); KMP_CPU_PAUSE();
old_value = *(kmp_int8 *)lhs; old_value = *(kmp_int8 *)lhs;
(*f)(&new_value, &old_value, rhs); (*f)(&new_value, &old_value, rhs);
} }
return; return;
} else { } else {
// All 1-byte data is of integer data type. // All 1-byte data is of integer data type.
#ifdef KMP_GOMP_COMPAT #ifdef KMP_GOMP_COMPAT
if (__kmp_atomic_mode == 2) { if (__kmp_atomic_mode == 2) {
__kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid); __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
} else } else
#endif /* KMP_GOMP_COMPAT */ #endif /* KMP_GOMP_COMPAT */
__kmp_acquire_atomic_lock(&__kmp_atomic_lock_1i, gtid); __kmp_acquire_atomic_lock(&__kmp_atomic_lock_1i, gtid);
Show All 13 Linesvoid __kmpc_atomic_2(ident_t *id_ref, int gtid, void *lhs, void *rhs,
if ( if (
#if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT) #if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
FALSE /* must use lock */ FALSE /* must use lock */
#elif KMP_ARCH_X86 || KMP_ARCH_X86_64 #elif KMP_ARCH_X86 || KMP_ARCH_X86_64
TRUE /* no alignment problems */ TRUE /* no alignment problems */
#else #else
!((kmp_uintptr_t)lhs & 0x1) /* make sure address is 2-byte aligned */ !((kmp_uintptr_t)lhs & 0x1) /* make sure address is 2-byte aligned */
#endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT) #endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
) { ) {
kmp_int16 old_value, new_value; kmp_int16 old_value, new_value;
old_value = *(kmp_int16 *)lhs; old_value = *(kmp_int16 *)lhs;
(*f)(&new_value, &old_value, rhs); (*f)(&new_value, &old_value, rhs);
/* TODO: Should this be acquire or release? */ /* TODO: Should this be acquire or release? */
while (!KMP_COMPARE_AND_STORE_ACQ16( while (!KMP_COMPARE_AND_STORE_ACQ16(
(kmp_int16 *)lhs, *(kmp_int16 *)&old_value, *(kmp_int16 *)&new_value)) { (kmp_int16 *)lhs, *(kmp_int16 *)&old_value, *(kmp_int16 *)&new_value)) {
KMP_CPU_PAUSE(); KMP_CPU_PAUSE();
old_value = *(kmp_int16 *)lhs; old_value = *(kmp_int16 *)lhs;
(*f)(&new_value, &old_value, rhs); (*f)(&new_value, &old_value, rhs);
} }
return; return;
} else { } else {
// All 2-byte data is of integer data type. // All 2-byte data is of integer data type.
#ifdef KMP_GOMP_COMPAT #ifdef KMP_GOMP_COMPAT
if (__kmp_atomic_mode == 2) { if (__kmp_atomic_mode == 2) {
__kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid); __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
} else } else
#endif /* KMP_GOMP_COMPAT */ #endif /* KMP_GOMP_COMPAT */
__kmp_acquire_atomic_lock(&__kmp_atomic_lock_2i, gtid); __kmp_acquire_atomic_lock(&__kmp_atomic_lock_2i, gtid);
Show All 15 Linesvoid __kmpc_atomic_4(ident_t *id_ref, int gtid, void *lhs, void *rhs,
if ( if (
// FIXME: On IA-32 architecture, gcc uses cmpxchg only for 4-byte ints. // FIXME: On IA-32 architecture, gcc uses cmpxchg only for 4-byte ints.
// Gomp compatibility is broken if this routine is called for floats. // Gomp compatibility is broken if this routine is called for floats.
#if KMP_ARCH_X86 || KMP_ARCH_X86_64 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
TRUE /* no alignment problems */ TRUE /* no alignment problems */
#else #else
!((kmp_uintptr_t)lhs & 0x3) /* make sure address is 4-byte aligned */ !((kmp_uintptr_t)lhs & 0x3) /* make sure address is 4-byte aligned */
#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64 #endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
) { ) {
kmp_int32 old_value, new_value; kmp_int32 old_value, new_value;
old_value = *(kmp_int32 *)lhs; old_value = *(kmp_int32 *)lhs;
(*f)(&new_value, &old_value, rhs); (*f)(&new_value, &old_value, rhs);
/* TODO: Should this be acquire or release? */ /* TODO: Should this be acquire or release? */
while (!KMP_COMPARE_AND_STORE_ACQ32( while (!KMP_COMPARE_AND_STORE_ACQ32(
(kmp_int32 *)lhs, *(kmp_int32 *)&old_value, *(kmp_int32 *)&new_value)) { (kmp_int32 *)lhs, *(kmp_int32 *)&old_value, *(kmp_int32 *)&new_value)) {
KMP_CPU_PAUSE(); KMP_CPU_PAUSE();
old_value = *(kmp_int32 *)lhs; old_value = *(kmp_int32 *)lhs;
(*f)(&new_value, &old_value, rhs); (*f)(&new_value, &old_value, rhs);
} }
return; return;
} else { } else {
// Use __kmp_atomic_lock_4i for all 4-byte data, // Use __kmp_atomic_lock_4i for all 4-byte data,
// even if it isn't of integer data type. // even if it isn't of integer data type.
#ifdef KMP_GOMP_COMPAT #ifdef KMP_GOMP_COMPAT
if (__kmp_atomic_mode == 2) { if (__kmp_atomic_mode == 2) {
__kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid); __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
} else } else
#endif /* KMP_GOMP_COMPAT */ #endif /* KMP_GOMP_COMPAT */
__kmp_acquire_atomic_lock(&__kmp_atomic_lock_4i, gtid); __kmp_acquire_atomic_lock(&__kmp_atomic_lock_4i, gtid);
Show All 15 Lines
#if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT) #if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
FALSE /* must use lock */ FALSE /* must use lock */
#elif KMP_ARCH_X86 || KMP_ARCH_X86_64 #elif KMP_ARCH_X86 || KMP_ARCH_X86_64
TRUE /* no alignment problems */ TRUE /* no alignment problems */
#else #else
!((kmp_uintptr_t)lhs & 0x7) /* make sure address is 8-byte aligned */ !((kmp_uintptr_t)lhs & 0x7) /* make sure address is 8-byte aligned */
#endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT) #endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
) { ) {
kmp_int64 old_value, new_value; kmp_int64 old_value, new_value;
old_value = *(kmp_int64 *)lhs; old_value = *(kmp_int64 *)lhs;
(*f)(&new_value, &old_value, rhs); (*f)(&new_value, &old_value, rhs);
/* TODO: Should this be acquire or release? */ /* TODO: Should this be acquire or release? */
while (!KMP_COMPARE_AND_STORE_ACQ64( while (!KMP_COMPARE_AND_STORE_ACQ64(
(kmp_int64 *)lhs, *(kmp_int64 *)&old_value, *(kmp_int64 *)&new_value)) { (kmp_int64 *)lhs, *(kmp_int64 *)&old_value, *(kmp_int64 *)&new_value)) {
KMP_CPU_PAUSE(); KMP_CPU_PAUSE();
old_value = *(kmp_int64 *)lhs; old_value = *(kmp_int64 *)lhs;
(*f)(&new_value, &old_value, rhs); (*f)(&new_value, &old_value, rhs);
} }
return; return;
} else { } else {
// Use __kmp_atomic_lock_8i for all 8-byte data, // Use __kmp_atomic_lock_8i for all 8-byte data,
// even if it isn't of integer data type. // even if it isn't of integer data type.
#ifdef KMP_GOMP_COMPAT #ifdef KMP_GOMP_COMPAT
if (__kmp_atomic_mode == 2) { if (__kmp_atomic_mode == 2) {
__kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid); __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
} else } else
#endif /* KMP_GOMP_COMPAT */ #endif /* KMP_GOMP_COMPAT */
__kmp_acquire_atomic_lock(&__kmp_atomic_lock_8i, gtid); __kmp_acquire_atomic_lock(&__kmp_atomic_lock_8i, gtid);
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_barrier.cpp

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lines#endif /* KMP_CACHE_MANAGE */
("__kmp_linear_barrier_release: T#%d(%d:%d) releasing T#%d(%d:%d) " ("__kmp_linear_barrier_release: T#%d(%d:%d) releasing T#%d(%d:%d) "
"go(%p): %u => %u\n", "go(%p): %u => %u\n",
gtid, team->t.t_id, tid, other_threads[i]->th.th_info.ds.ds_gtid, gtid, team->t.t_id, tid, other_threads[i]->th.th_info.ds.ds_gtid,
team->t.t_id, i, &other_threads[i]->th.th_bar[bt].bb.b_go, team->t.t_id, i, &other_threads[i]->th.th_bar[bt].bb.b_go,
other_threads[i]->th.th_bar[bt].bb.b_go, other_threads[i]->th.th_bar[bt].bb.b_go,
other_threads[i]->th.th_bar[bt].bb.b_go + KMP_BARRIER_STATE_BUMP)); other_threads[i]->th.th_bar[bt].bb.b_go + KMP_BARRIER_STATE_BUMP));
ANNOTATE_BARRIER_BEGIN(other_threads[i]); ANNOTATE_BARRIER_BEGIN(other_threads[i]);
kmp_flag_64<> flag(&other_threads[i]->th.th_bar[bt].bb.b_go, kmp_flag_64<> flag(&other_threads[i]->th.th_bar[bt].bb.b_go,
other_threads[i]); other_threads[i]);
flag.release(); flag.release();
} }
} }
} else { // Wait for the MASTER thread to release us } else { // Wait for the MASTER thread to release us
KA_TRACE(20, ("__kmp_linear_barrier_release: T#%d wait go(%p) == %u\n", KA_TRACE(20, ("__kmp_linear_barrier_release: T#%d wait go(%p) == %u\n",
gtid, &thr_bar->b_go, KMP_BARRIER_STATE_BUMP)); gtid, &thr_bar->b_go, KMP_BARRIER_STATE_BUMP));
if (cancellable) { if (cancellable) {
kmp_flag_64<true, false> flag(&thr_bar->b_go, KMP_BARRIER_STATE_BUMP); kmp_flag_64<true, false> flag(&thr_bar->b_go, KMP_BARRIER_STATE_BUMP);
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
static bool __kmp_linear_barrier_release_cancellable( static bool __kmp_linear_barrier_release_cancellable(
enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid, enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
int propagate_icvs USE_ITT_BUILD_ARG(void *itt_sync_obj)) { int propagate_icvs USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
return __kmp_linear_barrier_release_template<true>( return __kmp_linear_barrier_release_template<true>(
bt, this_thr, gtid, tid, propagate_icvs USE_ITT_BUILD_ARG(itt_sync_obj)); bt, this_thr, gtid, tid, propagate_icvs USE_ITT_BUILD_ARG(itt_sync_obj));
} }
// Tree barrier // Tree barrier
static void static void __kmp_tree_barrier_gather(
__kmp_tree_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr, int gtid, enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
int tid, void (*reduce)(void *, void *) void (*reduce)(void *, void *) USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_tree_gather); KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_tree_gather);
kmp_team_t *team = this_thr->th.th_team; kmp_team_t *team = this_thr->th.th_team;
kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb; kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
kmp_info_t **other_threads = team->t.t_threads; kmp_info_t **other_threads = team->t.t_threads;
kmp_uint32 nproc = this_thr->th.th_team_nproc; kmp_uint32 nproc = this_thr->th.th_team_nproc;
kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt]; kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
kmp_uint32 branch_factor = 1 << branch_bits; kmp_uint32 branch_factor = 1 << branch_bits;
kmp_uint32 child; kmp_uint32 child;
▲ Show 20 Lines • Show All 200 Lines • ▼ Show 20 Lines#endif // KMP_BARRIER_ICV_PUSH
} while (child <= branch_factor && child_tid < nproc); } while (child <= branch_factor && child_tid < nproc);
} }
KA_TRACE( KA_TRACE(
20, ("__kmp_tree_barrier_release: T#%d(%d:%d) exit for barrier type %d\n", 20, ("__kmp_tree_barrier_release: T#%d(%d:%d) exit for barrier type %d\n",
gtid, team->t.t_id, tid, bt)); gtid, team->t.t_id, tid, bt));
} }
// Hyper Barrier // Hyper Barrier
static void static void __kmp_hyper_barrier_gather(
__kmp_hyper_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr, int gtid, enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
int tid, void (*reduce)(void *, void *) void (*reduce)(void *, void *) USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_hyper_gather); KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_hyper_gather);
kmp_team_t *team = this_thr->th.th_team; kmp_team_t *team = this_thr->th.th_team;
kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb; kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
kmp_info_t **other_threads = team->t.t_threads; kmp_info_t **other_threads = team->t.t_threads;
kmp_uint64 new_state = KMP_BARRIER_UNUSED_STATE; kmp_uint64 new_state = KMP_BARRIER_UNUSED_STATE;
kmp_uint32 num_threads = this_thr->th.th_team_nproc; kmp_uint32 num_threads = this_thr->th.th_team_nproc;
kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt]; kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
kmp_uint32 branch_factor = 1 << branch_bits; kmp_uint32 branch_factor = 1 << branch_bits;
▲ Show 20 Lines • Show All 1,499 Lines • ▼ Show 20 Lines#if OMPT_OPTIONAL
if (ompt_enabled.ompt_callback_sync_region) { if (ompt_enabled.ompt_callback_sync_region) {
ompt_callbacks.ompt_callback(ompt_callback_sync_region)( ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
ompt_sync_region_barrier_implicit, ompt_scope_end, NULL, task_data, ompt_sync_region_barrier_implicit, ompt_scope_end, NULL, task_data,
codeptr); codeptr);
} }
#endif #endif
if (!KMP_MASTER_TID(ds_tid) && ompt_enabled.ompt_callback_implicit_task) { if (!KMP_MASTER_TID(ds_tid) && ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_end, NULL, task_data, 0, ds_tid, ompt_task_implicit); // TODO: Can this be ompt_task_initial? ompt_scope_end, NULL, task_data, 0, ds_tid,
ompt_task_implicit); // TODO: Can this be ompt_task_initial?
} }
} }
#endif #endif
// Early exit for reaping threads releasing forkjoin barrier // Early exit for reaping threads releasing forkjoin barrier
if (TCR_4(__kmp_global.g.g_done)) { if (TCR_4(__kmp_global.g.g_done)) {
this_thr->th.th_task_team = NULL; this_thr->th.th_task_team = NULL;
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines#if KMP_AFFINITY_SUPPORTED
} }
#endif // KMP_AFFINITY_SUPPORTED #endif // KMP_AFFINITY_SUPPORTED
// Perform the display affinity functionality // Perform the display affinity functionality
if (__kmp_display_affinity) { if (__kmp_display_affinity) {
if (team->t.t_display_affinity if (team->t.t_display_affinity
#if KMP_AFFINITY_SUPPORTED #if KMP_AFFINITY_SUPPORTED
|| (__kmp_affinity_type == affinity_balanced && team->t.t_size_changed) || (__kmp_affinity_type == affinity_balanced && team->t.t_size_changed)
#endif #endif
) { ) {
// NULL means use the affinity-format-var ICV // NULL means use the affinity-format-var ICV
__kmp_aux_display_affinity(gtid, NULL); __kmp_aux_display_affinity(gtid, NULL);
this_thr->th.th_prev_num_threads = team->t.t_nproc; this_thr->th.th_prev_num_threads = team->t.t_nproc;
this_thr->th.th_prev_level = team->t.t_level; this_thr->th.th_prev_level = team->t.t_level;
} }
} }
if (!KMP_MASTER_TID(tid)) if (!KMP_MASTER_TID(tid))
KMP_CHECK_UPDATE(this_thr->th.th_def_allocator, team->t.t_def_allocator); KMP_CHECK_UPDATE(this_thr->th.th_def_allocator, team->t.t_def_allocator);
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_csupport.cpp

Show First 20 Lines • Show All 310 Lines • ▼ Show 20 Lines
#if INCLUDE_SSC_MARKS #if INCLUDE_SSC_MARKS
SSC_MARK_JOINING(); SSC_MARK_JOINING();
#endif #endif
__kmp_join_call(loc, gtid __kmp_join_call(loc, gtid
#if OMPT_SUPPORT #if OMPT_SUPPORT
, ,
fork_context_intel fork_context_intel
#endif #endif
); );
va_end(ap); va_end(ap);
} }
#if KMP_STATS_ENABLED #if KMP_STATS_ENABLED
if (previous_state == stats_state_e::SERIAL_REGION) { if (previous_state == stats_state_e::SERIAL_REGION) {
KMP_EXCHANGE_PARTITIONED_TIMER(OMP_serial); KMP_EXCHANGE_PARTITIONED_TIMER(OMP_serial);
KMP_SET_THREAD_STATE(previous_state); KMP_SET_THREAD_STATE(previous_state);
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines __kmp_fork_call(
loc, gtid, fork_context_intel, argc, loc, gtid, fork_context_intel, argc,
VOLATILE_CAST(microtask_t) __kmp_teams_master, // "wrapped" task VOLATILE_CAST(microtask_t) __kmp_teams_master, // "wrapped" task
VOLATILE_CAST(launch_t) __kmp_invoke_teams_master, kmp_va_addr_of(ap)); VOLATILE_CAST(launch_t) __kmp_invoke_teams_master, kmp_va_addr_of(ap));
__kmp_join_call(loc, gtid __kmp_join_call(loc, gtid
#if OMPT_SUPPORT #if OMPT_SUPPORT
, ,
fork_context_intel fork_context_intel
#endif #endif
); );
// Pop current CG root off list // Pop current CG root off list
KMP_DEBUG_ASSERT(this_thr->th.th_cg_roots); KMP_DEBUG_ASSERT(this_thr->th.th_cg_roots);
kmp_cg_root_t *tmp = this_thr->th.th_cg_roots; kmp_cg_root_t *tmp = this_thr->th.th_cg_roots;
this_thr->th.th_cg_roots = tmp->up; this_thr->th.th_cg_roots = tmp->up;
KA_TRACE(100, ("__kmpc_fork_teams: Thread %p popping node %p and moving up" KA_TRACE(100, ("__kmpc_fork_teams: Thread %p popping node %p and moving up"
" to node %p. cg_nthreads was %d\n", " to node %p. cg_nthreads was %d\n",
this_thr, tmp, this_thr->th.th_cg_roots, tmp->cg_nthreads)); this_thr, tmp, this_thr->th.th_cg_roots, tmp->cg_nthreads));
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Lines serial_team->t.t_dispatch->th_disp_buffer =
serial_team->t.t_dispatch->th_disp_buffer->next; serial_team->t.t_dispatch->th_disp_buffer->next;
__kmp_free(disp_buffer); __kmp_free(disp_buffer);
} }
this_thr->th.th_def_allocator = serial_team->t.t_def_allocator; // restore this_thr->th.th_def_allocator = serial_team->t.t_def_allocator; // restore
--serial_team->t.t_serialized; --serial_team->t.t_serialized;
if (serial_team->t.t_serialized == 0) { if (serial_team->t.t_serialized == 0) {
/* return to the parallel section */ /* return to the parallel section */
#if KMP_ARCH_X86 || KMP_ARCH_X86_64 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
if (__kmp_inherit_fp_control && serial_team->t.t_fp_control_saved) { if (__kmp_inherit_fp_control && serial_team->t.t_fp_control_saved) {
__kmp_clear_x87_fpu_status_word(); __kmp_clear_x87_fpu_status_word();
__kmp_load_x87_fpu_control_word(&serial_team->t.t_x87_fpu_control_word); __kmp_load_x87_fpu_control_word(&serial_team->t.t_x87_fpu_control_word);
__kmp_load_mxcsr(&serial_team->t.t_mxcsr); __kmp_load_mxcsr(&serial_team->t.t_mxcsr);
} }
#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */ #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
▲ Show 20 Lines • Show All 591 Lines • ▼ Show 20 Lines
#endif #endif
else { // ticket, queuing or drdpa else { // ticket, queuing or drdpa
lck = __kmp_get_critical_section_ptr(crit, loc, global_tid); lck = __kmp_get_critical_section_ptr(crit, loc, global_tid);
} }
if (__kmp_env_consistency_check) if (__kmp_env_consistency_check)
__kmp_push_sync(global_tid, ct_critical, loc, lck); __kmp_push_sync(global_tid, ct_critical, loc, lck);
// since the critical directive binds to all threads, not just the current // since the critical directive binds to all threads, not just the current
// team we have to check this even if we are in a serialized team. // team we have to check this even if we are in a serialized team.
// also, even if we are the uber thread, we still have to conduct the lock, // also, even if we are the uber thread, we still have to conduct the lock,
// as we have to contend with sibling threads. // as we have to contend with sibling threads.
#if USE_ITT_BUILD #if USE_ITT_BUILD
__kmp_itt_critical_acquiring(lck); __kmp_itt_critical_acquiring(lck);
#endif /* USE_ITT_BUILD */ #endif /* USE_ITT_BUILD */
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
void *codeptr_ra = NULL; void *codeptr_ra = NULL;
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
▲ Show 20 Lines • Show All 888 Lines • ▼ Show 20 Lines
#if USE_ITT_NOTIFY #if USE_ITT_NOTIFY
__kmp_threads[gtid]->th.th_ident = loc; __kmp_threads[gtid]->th.th_ident = loc;
#endif #endif
__kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL); __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
if (!didit) if (!didit)
(*cpy_func)(cpy_data, *data_ptr); (*cpy_func)(cpy_data, *data_ptr);
// Consider next barrier a user-visible barrier for barrier region boundaries // Consider next barrier a user-visible barrier for barrier region boundaries
// Nesting checks are already handled by the single construct checks // Nesting checks are already handled by the single construct checks
{ {
#if OMPT_SUPPORT #if OMPT_SUPPORT
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
#endif #endif
#if USE_ITT_NOTIFY #if USE_ITT_NOTIFY
__kmp_threads[gtid]->th.th_ident = loc; // TODO: check if it is needed (e.g. __kmp_threads[gtid]->th.th_ident = loc; // TODO: check if it is needed (e.g.
// tasks can overwrite the location) // tasks can overwrite the location)
#endif #endif
__kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL); __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
ompt_frame->enter_frame = ompt_data_none; ompt_frame->enter_frame = ompt_data_none;
} }
#endif #endif
} }
} }
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
#define INIT_LOCK __kmp_init_user_lock_with_checks #define INIT_LOCK __kmp_init_user_lock_with_checks
#define INIT_NESTED_LOCK __kmp_init_nested_user_lock_with_checks #define INIT_NESTED_LOCK __kmp_init_nested_user_lock_with_checks
▲ Show 20 Lines • Show All 528 Lines • ▼ Show 20 Lines if (ompt_enabled.ompt_callback_mutex_acquire) {
ompt_mutex_nest_lock, omp_lock_hint_none, ompt_mutex_nest_lock, omp_lock_hint_none,
__ompt_get_mutex_impl_type(user_lock), __ompt_get_mutex_impl_type(user_lock),
(ompt_wait_id_t)(uintptr_t)user_lock, codeptr); (ompt_wait_id_t)(uintptr_t)user_lock, codeptr);
} }
} }
#endif #endif
int acquire_status = int acquire_status =
KMP_D_LOCK_FUNC(user_lock, set)((kmp_dyna_lock_t *)user_lock, gtid); KMP_D_LOCK_FUNC(user_lock, set)((kmp_dyna_lock_t *)user_lock, gtid);
(void) acquire_status; (void)acquire_status;
#if USE_ITT_BUILD #if USE_ITT_BUILD
__kmp_itt_lock_acquired((kmp_user_lock_p)user_lock); __kmp_itt_lock_acquired((kmp_user_lock_p)user_lock);
#endif #endif
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
if (acquire_status == KMP_LOCK_ACQUIRED_FIRST) { if (acquire_status == KMP_LOCK_ACQUIRED_FIRST) {
if (ompt_enabled.ompt_callback_mutex_acquired) { if (ompt_enabled.ompt_callback_mutex_acquired) {
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Lines
void __kmpc_unset_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) { void __kmpc_unset_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) {
#if KMP_USE_DYNAMIC_LOCK #if KMP_USE_DYNAMIC_LOCK
#if USE_ITT_BUILD #if USE_ITT_BUILD
__kmp_itt_lock_releasing((kmp_user_lock_p)user_lock); __kmp_itt_lock_releasing((kmp_user_lock_p)user_lock);
#endif #endif
int release_status = int release_status =
KMP_D_LOCK_FUNC(user_lock, unset)((kmp_dyna_lock_t *)user_lock, gtid); KMP_D_LOCK_FUNC(user_lock, unset)((kmp_dyna_lock_t *)user_lock, gtid);
(void) release_status; (void)release_status;
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
// This is the case, if called from omp_init_lock_with_hint: // This is the case, if called from omp_init_lock_with_hint:
void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid); void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
if (!codeptr) if (!codeptr)
codeptr = OMPT_GET_RETURN_ADDRESS(0); codeptr = OMPT_GET_RETURN_ADDRESS(0);
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
if (release_status == KMP_LOCK_RELEASED) { if (release_status == KMP_LOCK_RELEASED) {
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Lines#if OMPT_SUPPORT && OMPT_OPTIONAL
if (rc && ompt_enabled.ompt_callback_mutex_acquired) { if (rc && ompt_enabled.ompt_callback_mutex_acquired) {
ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)( ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
ompt_mutex_lock, (ompt_wait_id_t)(uintptr_t)lck, codeptr); ompt_mutex_lock, (ompt_wait_id_t)(uintptr_t)lck, codeptr);
} }
#endif #endif
return (rc ? FTN_TRUE : FTN_FALSE); return (rc ? FTN_TRUE : FTN_FALSE);
/* Can't use serial interval since not block structured */ /* Can't use serial interval since not block structured */
#endif // KMP_USE_DYNAMIC_LOCK #endif // KMP_USE_DYNAMIC_LOCK
} }
/* try to acquire the lock */ /* try to acquire the lock */
int __kmpc_test_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) { int __kmpc_test_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) {
#if KMP_USE_DYNAMIC_LOCK #if KMP_USE_DYNAMIC_LOCK
int rc; int rc;
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines if (rc == 1) {
ompt_callbacks.ompt_callback(ompt_callback_nest_lock)( ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
ompt_mutex_scope_begin, (ompt_wait_id_t)(uintptr_t)lck, codeptr); ompt_mutex_scope_begin, (ompt_wait_id_t)(uintptr_t)lck, codeptr);
} }
} }
} }
#endif #endif
return rc; return rc;
/* Can't use serial interval since not block structured */ /* Can't use serial interval since not block structured */
#endif // KMP_USE_DYNAMIC_LOCK #endif // KMP_USE_DYNAMIC_LOCK
} }
// Interface to fast scalable reduce methods routines // Interface to fast scalable reduce methods routines
// keep the selected method in a thread local structure for cross-function // keep the selected method in a thread local structure for cross-function
// usage: will be used in __kmpc_end_reduce* functions; // usage: will be used in __kmpc_end_reduce* functions;
▲ Show 20 Lines • Show All 1,060 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_dispatch.cpp

Show First 20 Lines • Show All 385 Lines • ▼ Show 20 Lines if (nproc > 1 && ntc >= nproc) {
__kmp_init_lock(pr->u.p.th_steal_lock); __kmp_init_lock(pr->u.p.th_steal_lock);
} }
break; break;
} else { } else {
/* too few chunks: switching to kmp_sch_dynamic_chunked */ /* too few chunks: switching to kmp_sch_dynamic_chunked */
schedule = kmp_sch_dynamic_chunked; schedule = kmp_sch_dynamic_chunked;
KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d switching to " KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d switching to "
"kmp_sch_dynamic_chunked\n", "kmp_sch_dynamic_chunked\n",
gtid)); gtid));
if (pr->u.p.parm1 <= 0) if (pr->u.p.parm1 <= 0)
pr->u.p.parm1 = KMP_DEFAULT_CHUNK; pr->u.p.parm1 = KMP_DEFAULT_CHUNK;
break; break;
} // if } // if
} // case } // case
#endif #endif
case kmp_sch_static_balanced: { case kmp_sch_static_balanced: {
T init, limit; T init, limit;
▲ Show 20 Lines • Show All 207 Lines • ▼ Show 20 Lines
// C75803 // C75803
#if ((KMP_OS_LINUX || KMP_OS_WINDOWS) && KMP_ARCH_X86) && (!defined(KMP_I8)) #if ((KMP_OS_LINUX || KMP_OS_WINDOWS) && KMP_ARCH_X86) && (!defined(KMP_I8))
#define GUIDED_ANALYTICAL_WORKAROUND (*(DBL *)&pr->u.p.parm3) #define GUIDED_ANALYTICAL_WORKAROUND (*(DBL *)&pr->u.p.parm3)
#else #else
#define GUIDED_ANALYTICAL_WORKAROUND (x) #define GUIDED_ANALYTICAL_WORKAROUND (x)
#endif #endif
/* dynamic-style scheduling offset */ /* dynamic-style scheduling offset */
pr->u.p.count = tc - __kmp_dispatch_guided_remaining( pr->u.p.count = tc -
__kmp_dispatch_guided_remaining(
tc, GUIDED_ANALYTICAL_WORKAROUND, cross) - tc, GUIDED_ANALYTICAL_WORKAROUND, cross) -
cross * chunk; cross * chunk;
#if KMP_USE_X87CONTROL #if KMP_USE_X87CONTROL
// restore FPCW // restore FPCW
_control87(oldFpcw, _MCW_PC); _control87(oldFpcw, _MCW_PC);
#endif #endif
} // if } // if
} else { } else {
KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d falling-through to " KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d falling-through to "
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines case kmp_sch_trapezoidal: {
pr->u.p.parm4 = parm4; pr->u.p.parm4 = parm4;
} // case } // case
break; break;
default: { default: {
__kmp_fatal(KMP_MSG(UnknownSchedTypeDetected), // Primary message __kmp_fatal(KMP_MSG(UnknownSchedTypeDetected), // Primary message
KMP_HNT(GetNewerLibrary), // Hint KMP_HNT(GetNewerLibrary), // Hint
__kmp_msg_null // Variadic argument list terminator __kmp_msg_null // Variadic argument list terminator
); );
} break; } break;
} // switch } // switch
pr->schedule = schedule; pr->schedule = schedule;
} }
#if KMP_USE_HIER_SCHED #if KMP_USE_HIER_SCHED
template <typename T> template <typename T>
inline void __kmp_dispatch_init_hier_runtime(ident_t *loc, T lb, T ub, inline void __kmp_dispatch_init_hier_runtime(ident_t *loc, T lb, T ub,
▲ Show 20 Lines • Show All 1,095 Lines • ▼ Show 20 Lines case kmp_sch_trapezoidal: {
} // if } // if
} // case } // case
break; break;
default: { default: {
status = 0; // to avoid complaints on uninitialized variable use status = 0; // to avoid complaints on uninitialized variable use
__kmp_fatal(KMP_MSG(UnknownSchedTypeDetected), // Primary message __kmp_fatal(KMP_MSG(UnknownSchedTypeDetected), // Primary message
KMP_HNT(GetNewerLibrary), // Hint KMP_HNT(GetNewerLibrary), // Hint
__kmp_msg_null // Variadic argument list terminator __kmp_msg_null // Variadic argument list terminator
); );
} break; } break;
} // switch } // switch
if (p_last) if (p_last)
*p_last = last; *p_last = last;
#ifdef KMP_DEBUG #ifdef KMP_DEBUG
if (pr->flags.ordered) { if (pr->flags.ordered) {
char *buff; char *buff;
// create format specifiers before the debug output // create format specifiers before the debug output
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
template <typename T> template <typename T>
static int __kmp_dispatch_next(ident_t *loc, int gtid, kmp_int32 *p_last, static int __kmp_dispatch_next(ident_t *loc, int gtid, kmp_int32 *p_last,
T *p_lb, T *p_ub, T *p_lb, T *p_ub,
typename traits_t<T>::signed_t *p_st typename traits_t<T>::signed_t *p_st
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
void *codeptr void *codeptr
#endif #endif
) { ) {
typedef typename traits_t<T>::unsigned_t UT; typedef typename traits_t<T>::unsigned_t UT;
typedef typename traits_t<T>::signed_t ST; typedef typename traits_t<T>::signed_t ST;
// This is potentially slightly misleading, schedule(runtime) will appear here // This is potentially slightly misleading, schedule(runtime) will appear here
// even if the actual runtime schedule is static. (Which points out a // even if the actual runtime schedule is static. (Which points out a
// disadvantage of schedule(runtime): even when static scheduling is used it // disadvantage of schedule(runtime): even when static scheduling is used it
// costs more than a compile time choice to use static scheduling would.) // costs more than a compile time choice to use static scheduling would.)
KMP_TIME_PARTITIONED_BLOCK(OMP_loop_dynamic_scheduling); KMP_TIME_PARTITIONED_BLOCK(OMP_loop_dynamic_scheduling);
▲ Show 20 Lines • Show All 510 Lines • ▼ Show 20 Lines
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
#endif #endif
return __kmp_dispatch_next<kmp_int32>(loc, gtid, p_last, p_lb, p_ub, p_st return __kmp_dispatch_next<kmp_int32>(loc, gtid, p_last, p_lb, p_ub, p_st
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
OMPT_LOAD_RETURN_ADDRESS(gtid) OMPT_LOAD_RETURN_ADDRESS(gtid)
#endif #endif
); );
} }
/*! /*!
See @ref __kmpc_dispatch_next_4 See @ref __kmpc_dispatch_next_4
*/ */
int __kmpc_dispatch_next_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last, int __kmpc_dispatch_next_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
kmp_uint32 *p_lb, kmp_uint32 *p_ub, kmp_uint32 *p_lb, kmp_uint32 *p_ub,
kmp_int32 *p_st) { kmp_int32 *p_st) {
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
#endif #endif
return __kmp_dispatch_next<kmp_uint32>(loc, gtid, p_last, p_lb, p_ub, p_st return __kmp_dispatch_next<kmp_uint32>(loc, gtid, p_last, p_lb, p_ub, p_st
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
OMPT_LOAD_RETURN_ADDRESS(gtid) OMPT_LOAD_RETURN_ADDRESS(gtid)
#endif #endif
); );
} }
/*! /*!
See @ref __kmpc_dispatch_next_4 See @ref __kmpc_dispatch_next_4
*/ */
int __kmpc_dispatch_next_8(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last, int __kmpc_dispatch_next_8(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
kmp_int64 *p_lb, kmp_int64 *p_ub, kmp_int64 *p_st) { kmp_int64 *p_lb, kmp_int64 *p_ub, kmp_int64 *p_st) {
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
#endif #endif
return __kmp_dispatch_next<kmp_int64>(loc, gtid, p_last, p_lb, p_ub, p_st return __kmp_dispatch_next<kmp_int64>(loc, gtid, p_last, p_lb, p_ub, p_st
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
OMPT_LOAD_RETURN_ADDRESS(gtid) OMPT_LOAD_RETURN_ADDRESS(gtid)
#endif #endif
); );
} }
/*! /*!
See @ref __kmpc_dispatch_next_4 See @ref __kmpc_dispatch_next_4
*/ */
int __kmpc_dispatch_next_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last, int __kmpc_dispatch_next_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
kmp_uint64 *p_lb, kmp_uint64 *p_ub, kmp_uint64 *p_lb, kmp_uint64 *p_ub,
kmp_int64 *p_st) { kmp_int64 *p_st) {
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
#endif #endif
return __kmp_dispatch_next<kmp_uint64>(loc, gtid, p_last, p_lb, p_ub, p_st return __kmp_dispatch_next<kmp_uint64>(loc, gtid, p_last, p_lb, p_ub, p_st
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
OMPT_LOAD_RETURN_ADDRESS(gtid) OMPT_LOAD_RETURN_ADDRESS(gtid)
#endif #endif
); );
} }
/*! /*!
@param loc Source code location @param loc Source code location
@param gtid Global thread id @param gtid Global thread id
Mark the end of a dynamic loop. Mark the end of a dynamic loop.
*/ */
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
kmp_uint32 __kmp_le_4(kmp_uint32 value, kmp_uint32 checker) { kmp_uint32 __kmp_le_4(kmp_uint32 value, kmp_uint32 checker) {
return value <= checker; return value <= checker;
} }
kmp_uint32 kmp_uint32
__kmp_wait_4(volatile kmp_uint32 *spinner, kmp_uint32 checker, __kmp_wait_4(volatile kmp_uint32 *spinner, kmp_uint32 checker,
kmp_uint32 (*pred)(kmp_uint32, kmp_uint32), kmp_uint32 (*pred)(kmp_uint32, kmp_uint32),
void *obj // Higher-level synchronization object, or NULL. void *obj // Higher-level synchronization object, or NULL.
) { ) {
// note: we may not belong to a team at this point // note: we may not belong to a team at this point
volatile kmp_uint32 *spin = spinner; volatile kmp_uint32 *spin = spinner;
kmp_uint32 check = checker; kmp_uint32 check = checker;
kmp_uint32 spins; kmp_uint32 spins;
kmp_uint32 (*f)(kmp_uint32, kmp_uint32) = pred; kmp_uint32 (*f)(kmp_uint32, kmp_uint32) = pred;
kmp_uint32 r; kmp_uint32 r;
KMP_FSYNC_SPIN_INIT(obj, CCAST(kmp_uint32 *, spin)); KMP_FSYNC_SPIN_INIT(obj, CCAST(kmp_uint32 *, spin));
Show All 9 Lines) {
} }
KMP_FSYNC_SPIN_ACQUIRED(obj); KMP_FSYNC_SPIN_ACQUIRED(obj);
return r; return r;
} }
void __kmp_wait_4_ptr(void *spinner, kmp_uint32 checker, void __kmp_wait_4_ptr(void *spinner, kmp_uint32 checker,
kmp_uint32 (*pred)(void *, kmp_uint32), kmp_uint32 (*pred)(void *, kmp_uint32),
void *obj // Higher-level synchronization object, or NULL. void *obj // Higher-level synchronization object, or NULL.
) { ) {
// note: we may not belong to a team at this point // note: we may not belong to a team at this point
void *spin = spinner; void *spin = spinner;
kmp_uint32 check = checker; kmp_uint32 check = checker;
kmp_uint32 spins; kmp_uint32 spins;
kmp_uint32 (*f)(void *, kmp_uint32) = pred; kmp_uint32 (*f)(void *, kmp_uint32) = pred;
KMP_FSYNC_SPIN_INIT(obj, spin); KMP_FSYNC_SPIN_INIT(obj, spin);
KMP_INIT_YIELD(spins); KMP_INIT_YIELD(spins);
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_environment.cpp

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Lines characters, variables are separated with vertical bars, e. g.:
Empty variables are allowed and ignored: Empty variables are allowed and ignored:
"||KMP_WARNINGS=1||" "||KMP_WARNINGS=1||"
*/ */
static void static void
___kmp_env_blk_parse_string(kmp_env_blk_t *block, // M: Env block to fill. ___kmp_env_blk_parse_string(kmp_env_blk_t *block, // M: Env block to fill.
char const *env // I: String to parse. char const *env // I: String to parse.
) { ) {
char const chr_delimiter = '|'; char const chr_delimiter = '|';
char const str_delimiter[] = {chr_delimiter, 0}; char const str_delimiter[] = {chr_delimiter, 0};
char *bulk = NULL; char *bulk = NULL;
kmp_env_var_t *vars = NULL; kmp_env_var_t *vars = NULL;
int count = 0; // Number of used elements in vars array. int count = 0; // Number of used elements in vars array.
int delimiters = 0; // Number of delimiters in input string. int delimiters = 0; // Number of delimiters in input string.
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines the end of environment block, e. g.:
It is not clear how empty environment is represented. "\x00\x00"? It is not clear how empty environment is represented. "\x00\x00"?
*/ */
#if KMP_OS_WINDOWS #if KMP_OS_WINDOWS
static void ___kmp_env_blk_parse_windows( static void ___kmp_env_blk_parse_windows(
kmp_env_blk_t *block, // M: Env block to fill. kmp_env_blk_t *block, // M: Env block to fill.
char const *env // I: Pointer to Windows* OS (DOS) environment block. char const *env // I: Pointer to Windows* OS (DOS) environment block.
) { ) {
char *bulk = NULL; char *bulk = NULL;
kmp_env_var_t *vars = NULL; kmp_env_var_t *vars = NULL;
int count = 0; // Number of used elements in vars array. int count = 0; // Number of used elements in vars array.
int size = 0; // Size of bulk. int size = 0; // Size of bulk.
char *name; // Pointer to name of variable. char *name; // Pointer to name of variable.
char *value; // Pointer to value. char *value; // Pointer to value.
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines array is NULL:
{ "HOME=/home/lev", "TERM=xterm", NULL } { "HOME=/home/lev", "TERM=xterm", NULL }
*/ */
#if KMP_OS_UNIX #if KMP_OS_UNIX
static void static void
___kmp_env_blk_parse_unix(kmp_env_blk_t *block, // M: Env block to fill. ___kmp_env_blk_parse_unix(kmp_env_blk_t *block, // M: Env block to fill.
char **env // I: Unix environment to parse. char **env // I: Unix environment to parse.
) { ) {
char *bulk = NULL; char *bulk = NULL;
kmp_env_var_t *vars = NULL; kmp_env_var_t *vars = NULL;
int count = 0; int count = 0;
size_t size = 0; // Size of bulk. size_t size = 0; // Size of bulk.
// Count number of variables and length of required bulk. // Count number of variables and length of required bulk.
{ {
while (env[count] != NULL) { while (env[count] != NULL) {
Show All 31 Lines) {
block->bulk = bulk; block->bulk = bulk;
block->vars = vars; block->vars = vars;
block->count = count; block->count = count;
} }
#endif #endif
void __kmp_env_blk_init(kmp_env_blk_t *block, // M: Block to initialize. void __kmp_env_blk_init(kmp_env_blk_t *block, // M: Block to initialize.
char const *bulk // I: Initialization string, or NULL. char const *bulk // I: Initialization string, or NULL.
) { ) {
if (bulk != NULL) { if (bulk != NULL) {
___kmp_env_blk_parse_string(block, bulk); ___kmp_env_blk_parse_string(block, bulk);
} else { } else {
#if KMP_OS_UNIX #if KMP_OS_UNIX
___kmp_env_blk_parse_unix(block, environ); ___kmp_env_blk_parse_unix(block, environ);
#elif KMP_OS_WINDOWS #elif KMP_OS_WINDOWS
{ {
Show All 15 Lines
static int ___kmp_env_var_cmp( // Comparison function for qsort(). static int ___kmp_env_var_cmp( // Comparison function for qsort().
kmp_env_var_t const *lhs, kmp_env_var_t const *rhs) { kmp_env_var_t const *lhs, kmp_env_var_t const *rhs) {
return strcmp(lhs->name, rhs->name); return strcmp(lhs->name, rhs->name);
} }
void __kmp_env_blk_sort( void __kmp_env_blk_sort(
kmp_env_blk_t *block // M: Block of environment variables to sort. kmp_env_blk_t *block // M: Block of environment variables to sort.
) { ) {
qsort(CCAST(kmp_env_var_t *, block->vars), block->count, qsort(CCAST(kmp_env_var_t *, block->vars), block->count,
sizeof(kmp_env_var_t), sizeof(kmp_env_var_t),
(int (*)(void const *, void const *)) & ___kmp_env_var_cmp); (int (*)(void const *, void const *)) & ___kmp_env_var_cmp);
} // __kmp_env_block_sort } // __kmp_env_block_sort
void __kmp_env_blk_free( void __kmp_env_blk_free(
kmp_env_blk_t *block // M: Block of environment variables to free. kmp_env_blk_t *block // M: Block of environment variables to free.
) { ) {
KMP_INTERNAL_FREE(CCAST(kmp_env_var_t *, block->vars)); KMP_INTERNAL_FREE(CCAST(kmp_env_var_t *, block->vars));
__kmp_str_free(&(block->bulk)); __kmp_str_free(&(block->bulk));
block->count = 0; block->count = 0;
block->vars = NULL; block->vars = NULL;
} // __kmp_env_blk_free } // __kmp_env_blk_free
char const * // R: Value of variable or NULL if variable does not exist. char const * // R: Value of variable or NULL if variable does not exist.
__kmp_env_blk_var( __kmp_env_blk_var(kmp_env_blk_t *block, // I: Block of environment variables.
kmp_env_blk_t *block, // I: Block of environment variables.
char const *name // I: Name of variable to find. char const *name // I: Name of variable to find.
) { ) {
int i; int i;
for (i = 0; i < block->count; ++i) { for (i = 0; i < block->count; ++i) {
if (strcmp(block->vars[i].name, name) == 0) { if (strcmp(block->vars[i].name, name) == 0) {
return block->vars[i].value; return block->vars[i].value;
} }
} }
return NULL; return NULL;
} // __kmp_env_block_var } // __kmp_env_block_var
// end of file // // end of file //

openmp/runtime/src/kmp_error.cpp

Show All 14 Lines
#include "kmp_i18n.h" #include "kmp_i18n.h"
#include "kmp_str.h" #include "kmp_str.h"
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
#define MIN_STACK 100 #define MIN_STACK 100
static char const *cons_text_c[] = { static char const *cons_text_c[] = {
"(none)", "\"parallel\"", "work-sharing", /* this is not called "for" "(none)",
"\"parallel\"",
"work-sharing", /* this is not called "for"
because of lowering of because of lowering of
"sections" pragmas */ "sections" pragmas */
"\"ordered\" work-sharing", /* this is not called "for ordered" because of "\"ordered\" work-sharing", /* this is not called "for ordered" because of
lowering of "sections" pragmas */ lowering of "sections" pragmas */
"\"sections\"", "\"sections\"",
"work-sharing", /* this is not called "single" because of lowering of "work-sharing", /* this is not called "single" because of lowering of
"sections" pragmas */ "sections" pragmas */
"\"critical\"", "\"ordered\"", /* in PARALLEL */ "\"critical\"",
"\"ordered\"", /* in PARALLEL */
"\"ordered\"", /* in PDO */ "\"ordered\"", /* in PDO */
"\"master\"", "\"reduce\"", "\"barrier\""}; "\"master\"",
"\"reduce\"",
"\"barrier\""};
#define get_src(ident) ((ident) == NULL ? NULL : (ident)->psource) #define get_src(ident) ((ident) == NULL ? NULL : (ident)->psource)
#define PUSH_MSG(ct, ident) \ #define PUSH_MSG(ct, ident) \
"\tpushing on stack: %s (%s)\n", cons_text_c[(ct)], get_src((ident)) "\tpushing on stack: %s (%s)\n", cons_text_c[(ct)], get_src((ident))
#define POP_MSG(p) \ #define POP_MSG(p) \
"\tpopping off stack: %s (%s)\n", cons_text_c[(p)->stack_data[tos].type], \ "\tpopping off stack: %s (%s)\n", cons_text_c[(p)->stack_data[tos].type], \
get_src((p)->stack_data[tos].ident) get_src((p)->stack_data[tos].ident)
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesstatic char *__kmp_pragma(int ct, ident_t const *ident) {
return prgm.str; return prgm.str;
} // __kmp_pragma } // __kmp_pragma
/* ----------------- END OF STATIC LOCAL ROUTINES ------------------------- */ /* ----------------- END OF STATIC LOCAL ROUTINES ------------------------- */
void __kmp_error_construct(kmp_i18n_id_t id, // Message identifier. void __kmp_error_construct(kmp_i18n_id_t id, // Message identifier.
enum cons_type ct, // Construct type. enum cons_type ct, // Construct type.
ident_t const *ident // Construct ident. ident_t const *ident // Construct ident.
) { ) {
char *construct = __kmp_pragma(ct, ident); char *construct = __kmp_pragma(ct, ident);
__kmp_fatal(__kmp_msg_format(id, construct), __kmp_msg_null); __kmp_fatal(__kmp_msg_format(id, construct), __kmp_msg_null);
KMP_INTERNAL_FREE(construct); KMP_INTERNAL_FREE(construct);
} }
void __kmp_error_construct2(kmp_i18n_id_t id, // Message identifier. void __kmp_error_construct2(kmp_i18n_id_t id, // Message identifier.
enum cons_type ct, // First construct type. enum cons_type ct, // First construct type.
ident_t const *ident, // First construct ident. ident_t const *ident, // First construct ident.
struct cons_data const *cons // Second construct. struct cons_data const *cons // Second construct.
) { ) {
char *construct1 = __kmp_pragma(ct, ident); char *construct1 = __kmp_pragma(ct, ident);
char *construct2 = __kmp_pragma(cons->type, cons->ident); char *construct2 = __kmp_pragma(cons->type, cons->ident);
__kmp_fatal(__kmp_msg_format(id, construct1, construct2), __kmp_msg_null); __kmp_fatal(__kmp_msg_format(id, construct1, construct2), __kmp_msg_null);
KMP_INTERNAL_FREE(construct1); KMP_INTERNAL_FREE(construct1);
KMP_INTERNAL_FREE(construct2); KMP_INTERNAL_FREE(construct2);
} }
struct cons_header *__kmp_allocate_cons_stack(int gtid) { struct cons_header *__kmp_allocate_cons_stack(int gtid) {
▲ Show 20 Lines • Show All 318 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_ftn_entry.h

Show First 20 Lines • Show All 426 Lines • ▼ Show 20 Linespublic:
~ConvertedString() { __kmp_thread_free(th, buf); } ~ConvertedString() { __kmp_thread_free(th, buf); }
const char *get() const { return buf; } const char *get() const { return buf; }
}; };
#endif // KMP_STUB #endif // KMP_STUB
/* /*
* Set the value of the affinity-format-var ICV on the current device to the * Set the value of the affinity-format-var ICV on the current device to the
* format specified in the argument. * format specified in the argument.
*/ */
void FTN_STDCALL FTN_SET_AFFINITY_FORMAT(char const *format, size_t size) { void FTN_STDCALL FTN_SET_AFFINITY_FORMAT(char const *format, size_t size) {
#ifdef KMP_STUB #ifdef KMP_STUB
return; return;
#else #else
if (!__kmp_init_serial) { if (!__kmp_init_serial) {
__kmp_serial_initialize(); __kmp_serial_initialize();
} }
ConvertedString cformat(format, size); ConvertedString cformat(format, size);
// Since the __kmp_affinity_format variable is a C string, do not // Since the __kmp_affinity_format variable is a C string, do not
// use the fortran strncpy function // use the fortran strncpy function
__kmp_strncpy_truncate(__kmp_affinity_format, KMP_AFFINITY_FORMAT_SIZE, __kmp_strncpy_truncate(__kmp_affinity_format, KMP_AFFINITY_FORMAT_SIZE,
cformat.get(), KMP_STRLEN(cformat.get())); cformat.get(), KMP_STRLEN(cformat.get()));
#endif #endif
} }
/* /*
* Returns the number of characters required to hold the entire affinity format * Returns the number of characters required to hold the entire affinity format
* specification (not including null byte character) and writes the value of the * specification (not including null byte character) and writes the value of the
* affinity-format-var ICV on the current device to buffer. If the return value * affinity-format-var ICV on the current device to buffer. If the return value
* is larger than size, the affinity format specification is truncated. * is larger than size, the affinity format specification is truncated.
*/ */
size_t FTN_STDCALL FTN_GET_AFFINITY_FORMAT(char *buffer, size_t size) { size_t FTN_STDCALL FTN_GET_AFFINITY_FORMAT(char *buffer, size_t size) {
#ifdef KMP_STUB #ifdef KMP_STUB
return 0; return 0;
#else #else
size_t format_size; size_t format_size;
if (!__kmp_init_serial) { if (!__kmp_init_serial) {
__kmp_serial_initialize(); __kmp_serial_initialize();
} }
format_size = KMP_STRLEN(__kmp_affinity_format); format_size = KMP_STRLEN(__kmp_affinity_format);
if (buffer && size) { if (buffer && size) {
__kmp_fortran_strncpy_truncate(buffer, size, __kmp_affinity_format, __kmp_fortran_strncpy_truncate(buffer, size, __kmp_affinity_format,
format_size); format_size);
} }
return format_size; return format_size;
#endif #endif
} }
/* /*
* Prints the thread affinity information of the current thread in the format * Prints the thread affinity information of the current thread in the format
* specified by the format argument. If the format is NULL or a zero-length * specified by the format argument. If the format is NULL or a zero-length
* string, the value of the affinity-format-var ICV is used. * string, the value of the affinity-format-var ICV is used.
*/ */
void FTN_STDCALL FTN_DISPLAY_AFFINITY(char const *format, size_t size) { void FTN_STDCALL FTN_DISPLAY_AFFINITY(char const *format, size_t size) {
#ifdef KMP_STUB #ifdef KMP_STUB
return; return;
#else #else
int gtid; int gtid;
if (!TCR_4(__kmp_init_middle)) { if (!TCR_4(__kmp_init_middle)) {
__kmp_middle_initialize(); __kmp_middle_initialize();
} }
gtid = __kmp_get_gtid(); gtid = __kmp_get_gtid();
ConvertedString cformat(format, size); ConvertedString cformat(format, size);
__kmp_aux_display_affinity(gtid, cformat.get()); __kmp_aux_display_affinity(gtid, cformat.get());
#endif #endif
} }
/* /*
* Returns the number of characters required to hold the entire affinity format * Returns the number of characters required to hold the entire affinity format
* specification (not including null byte) and prints the thread affinity * specification (not including null byte) and prints the thread affinity
* information of the current thread into the character string buffer with the * information of the current thread into the character string buffer with the
* size of size in the format specified by the format argument. If the format is * size of size in the format specified by the format argument. If the format is
* NULL or a zero-length string, the value of the affinity-format-var ICV is * NULL or a zero-length string, the value of the affinity-format-var ICV is
* used. The buffer must be allocated prior to calling the routine. If the * used. The buffer must be allocated prior to calling the routine. If the
* return value is larger than size, the affinity format specification is * return value is larger than size, the affinity format specification is
* truncated. * truncated.
*/ */
size_t FTN_STDCALL FTN_CAPTURE_AFFINITY(char *buffer, char const *format, size_t FTN_STDCALL FTN_CAPTURE_AFFINITY(char *buffer, char const *format,
size_t buf_size, size_t for_size) { size_t buf_size, size_t for_size) {
#if defined(KMP_STUB) #if defined(KMP_STUB)
return 0; return 0;
#else #else
int gtid; int gtid;
size_t num_required; size_t num_required;
kmp_str_buf_t capture_buf; kmp_str_buf_t capture_buf;
Show All 15 Lines
int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_THREAD_NUM)(void) { int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_THREAD_NUM)(void) {
#ifdef KMP_STUB #ifdef KMP_STUB
return 0; return 0;
#else #else
int gtid; int gtid;
#if KMP_OS_DARWIN || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \ #if KMP_OS_DARWIN || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \
KMP_OS_HURD|| KMP_OS_OPENBSD KMP_OS_HURD || KMP_OS_OPENBSD
gtid = __kmp_entry_gtid(); gtid = __kmp_entry_gtid();
#elif KMP_OS_WINDOWS #elif KMP_OS_WINDOWS
if (!__kmp_init_parallel || if (!__kmp_init_parallel ||
(gtid = (int)((kmp_intptr_t)TlsGetValue(__kmp_gtid_threadprivate_key))) == (gtid = (int)((kmp_intptr_t)TlsGetValue(__kmp_gtid_threadprivate_key))) ==
0) { 0) {
// Either library isn't initialized or thread is not registered // Either library isn't initialized or thread is not registered
// 0 is the correct TID in this case // 0 is the correct TID in this case
return 0; return 0;
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines#ifdef KMP_STUB
return 0; // returns 0 if it is called from the sequential part of the program return 0; // returns 0 if it is called from the sequential part of the program
#else #else
/* TO DO: For the per-task implementation of the internal controls */ /* TO DO: For the per-task implementation of the internal controls */
return __kmp_entry_thread()->th.th_team->t.t_level; return __kmp_entry_thread()->th.th_team->t.t_level;
#endif #endif
} }
int FTN_STDCALL int FTN_STDCALL
KMP_EXPAND_NAME(FTN_GET_ANCESTOR_THREAD_NUM)(int KMP_DEREF level) { KMP_EXPAND_NAME(FTN_GET_ANCESTOR_THREAD_NUM)(int KMP_DEREF level) {
#ifdef KMP_STUB #ifdef KMP_STUB
return (KMP_DEREF level) ? (-1) : (0); return (KMP_DEREF level) ? (-1) : (0);
#else #else
return __kmp_get_ancestor_thread_num(__kmp_entry_gtid(), KMP_DEREF level); return __kmp_get_ancestor_thread_num(__kmp_entry_gtid(), KMP_DEREF level);
#endif #endif
} }
int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_TEAM_SIZE)(int KMP_DEREF level) { int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_TEAM_SIZE)(int KMP_DEREF level) {
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines#else
if (first_place <= last_place) if (first_place <= last_place)
num_places = last_place - first_place + 1; num_places = last_place - first_place + 1;
else else
num_places = __kmp_affinity_num_masks - first_place + last_place + 1; num_places = __kmp_affinity_num_masks - first_place + last_place + 1;
return num_places; return num_places;
#endif #endif
} }
void void FTN_STDCALL
FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_PARTITION_PLACE_NUMS)(int *place_nums) { KMP_EXPAND_NAME(FTN_GET_PARTITION_PLACE_NUMS)(int *place_nums) {
#if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
// Nothing. // Nothing.
#else #else
int i, gtid, place_num, first_place, last_place, start, end; int i, gtid, place_num, first_place, last_place, start, end;
kmp_info_t *thread; kmp_info_t *thread;
if (!TCR_4(__kmp_init_middle)) { if (!TCR_4(__kmp_init_middle)) {
__kmp_middle_initialize(); __kmp_middle_initialize();
} }
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
#else #else
__kmp_entry_thread()->th.th_current_task->td_icvs.default_device = __kmp_entry_thread()->th.th_current_task->td_icvs.default_device =
KMP_DEREF arg; KMP_DEREF arg;
#endif #endif
} }
// Get number of NON-HOST devices. // Get number of NON-HOST devices.
// libomptarget, if loaded, provides this function in api.cpp. // libomptarget, if loaded, provides this function in api.cpp.
int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void) KMP_WEAK_ATTRIBUTE_EXTERNAL; int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void)
KMP_WEAK_ATTRIBUTE_EXTERNAL;
int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void) { int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void) {
#if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB) #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
return 0; return 0;
#else #else
int (*fptr)(); int (*fptr)();
if ((*(void **)(&fptr) = KMP_DLSYM("__tgt_get_num_devices"))) { if ((*(void **)(&fptr) = KMP_DLSYM("__tgt_get_num_devices"))) {
return (*fptr)(); return (*fptr)();
} else if ((*(void **)(&fptr) = KMP_DLSYM_NEXT("omp_get_num_devices"))) { } else if ((*(void **)(&fptr) = KMP_DLSYM_NEXT("omp_get_num_devices"))) {
return (*fptr)(); return (*fptr)();
} else if ((*(void **)(&fptr) = KMP_DLSYM("_Offload_number_of_devices"))) { } else if ((*(void **)(&fptr) = KMP_DLSYM("_Offload_number_of_devices"))) {
return (*fptr)(); return (*fptr)();
} else { // liboffload & libomptarget don't exist } else { // liboffload & libomptarget don't exist
return 0; return 0;
} }
#endif // KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB) #endif // KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB)
} }
// This function always returns true when called on host device. // This function always returns true when called on host device.
// Compiler/libomptarget should handle when it is called inside target region. // Compiler/libomptarget should handle when it is called inside target region.
int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) KMP_WEAK_ATTRIBUTE_EXTERNAL; int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void)
KMP_WEAK_ATTRIBUTE_EXTERNAL;
int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) { int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) {
return 1; // This is the host return 1; // This is the host
} }
// libomptarget, if loaded, provides this function // libomptarget, if loaded, provides this function
int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_INITIAL_DEVICE)(void) int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_INITIAL_DEVICE)(void)
KMP_WEAK_ATTRIBUTE_EXTERNAL; KMP_WEAK_ATTRIBUTE_EXTERNAL;
int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_INITIAL_DEVICE)(void) { int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_INITIAL_DEVICE)(void) {
▲ Show 20 Lines • Show All 290 Lines • ▼ Show 20 Lines
#endif #endif
} }
void FTN_STDCALL FTN_SET_DEFAULTS(char const *str void FTN_STDCALL FTN_SET_DEFAULTS(char const *str
#ifndef PASS_ARGS_BY_VALUE #ifndef PASS_ARGS_BY_VALUE
, ,
int len int len
#endif #endif
) { ) {
#ifndef KMP_STUB #ifndef KMP_STUB
#ifdef PASS_ARGS_BY_VALUE #ifdef PASS_ARGS_BY_VALUE
int len = (int)KMP_STRLEN(str); int len = (int)KMP_STRLEN(str);
#endif #endif
__kmp_aux_set_defaults(str, len); __kmp_aux_set_defaults(str, len);
#endif #endif
} }
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_gsupport.cpp

Show First 20 Lines • Show All 236 Lines • ▼ Show 20 Linesvoid *KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_COPY_START)(void) {
__kmp_resume_if_soft_paused(); __kmp_resume_if_soft_paused();
// If this is the first thread to enter, return NULL. The generated code will // If this is the first thread to enter, return NULL. The generated code will
// then call GOMP_single_copy_end() for this thread only, with the // then call GOMP_single_copy_end() for this thread only, with the
// copyprivate data pointer as an argument. // copyprivate data pointer as an argument.
if (__kmp_enter_single(gtid, &loc, FALSE)) if (__kmp_enter_single(gtid, &loc, FALSE))
return NULL; return NULL;
// Wait for the first thread to set the copyprivate data pointer, // Wait for the first thread to set the copyprivate data pointer,
// and for all other threads to reach this point. // and for all other threads to reach this point.
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
ompt_frame_t *ompt_frame; ompt_frame_t *ompt_frame;
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
__ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL); __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0); ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
} }
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Lines if (ompt_enabled.enabled) {
ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL); ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
ompt_task_info_t *task_info = __ompt_get_task_info_object(0); ompt_task_info_t *task_info = __ompt_get_task_info_object(0);
// implicit task callback // implicit task callback
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_team_size = __kmp_team_from_gtid(gtid)->t.t_nproc; ompt_team_size = __kmp_team_from_gtid(gtid)->t.t_nproc;
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_begin, &(team_info->parallel_data), ompt_scope_begin, &(team_info->parallel_data),
&(task_info->task_data), ompt_team_size, __kmp_tid_from_gtid(gtid), ompt_task_implicit); // TODO: Can this be ompt_task_initial? &(task_info->task_data), ompt_team_size, __kmp_tid_from_gtid(gtid),
ompt_task_implicit); // TODO: Can this be ompt_task_initial?
task_info->thread_num = __kmp_tid_from_gtid(gtid); task_info->thread_num = __kmp_tid_from_gtid(gtid);
} }
thr->th.ompt_thread_info.state = ompt_state_work_parallel; thr->th.ompt_thread_info.state = ompt_state_work_parallel;
} }
#endif #endif
} }
void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *), void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *),
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines#if OMPT_SUPPORT
} }
#endif #endif
__kmp_join_call(&loc, gtid __kmp_join_call(&loc, gtid
#if OMPT_SUPPORT #if OMPT_SUPPORT
, ,
fork_context_gnu fork_context_gnu
#endif #endif
); );
} }
// Loop worksharing constructs // Loop worksharing constructs
// The Gnu codegen passes in an exclusive upper bound for the overall range, // The Gnu codegen passes in an exclusive upper bound for the overall range,
// but the libguide dispatch code expects an inclusive upper bound, hence the // but the libguide dispatch code expects an inclusive upper bound, hence the
// "end - incr" 5th argument to KMP_DISPATCH_INIT (and the " ub - str" 11th // "end - incr" 5th argument to KMP_DISPATCH_INIT (and the " ub - str" 11th
// argument to __kmp_GOMP_fork_call). // argument to __kmp_GOMP_fork_call).
▲ Show 20 Lines • Show All 417 Lines • ▼ Show 20 Lines
LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START), LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START),
kmp_sch_dynamic_chunked) kmp_sch_dynamic_chunked)
LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT), {}) LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT), {})
LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START), LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START),
kmp_sch_guided_chunked) kmp_sch_guided_chunked)
LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT), {}) LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT), {})
LOOP_START_ULL( LOOP_START_ULL(
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_START), KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_START),
kmp_sch_dynamic_chunked) kmp_sch_dynamic_chunked)
LOOP_NEXT_ULL( LOOP_NEXT_ULL(
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_NEXT), {}) KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_NEXT), {})
LOOP_START_ULL( LOOP_START_ULL(
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_START), KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_START),
kmp_sch_guided_chunked) kmp_sch_guided_chunked)
LOOP_NEXT_ULL( LOOP_NEXT_ULL(
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_NEXT), {}) KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_NEXT), {})
LOOP_RUNTIME_START_ULL( LOOP_RUNTIME_START_ULL(
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START), kmp_sch_runtime) KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START), kmp_sch_runtime)
LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT), {}) LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT), {})
LOOP_RUNTIME_START_ULL( LOOP_RUNTIME_START_ULL(
KMP_EXPAND_NAME( KMP_EXPAND_NAME(
KMP_API_NAME_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_START), KMP_API_NAME_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_START),
▲ Show 20 Lines • Show All 250 Lines • ▼ Show 20 Lines if (copy_func) {
KMP_MEMCPY(task->shareds, data, arg_size); KMP_MEMCPY(task->shareds, data, arg_size);
} }
} }
#if OMPT_SUPPORT #if OMPT_SUPPORT
kmp_taskdata_t *current_task; kmp_taskdata_t *current_task;
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
current_task = __kmp_threads[gtid]->th.th_current_task; current_task = __kmp_threads[gtid]->th.th_current_task;
current_task->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0); current_task->ompt_task_info.frame.enter_frame.ptr =
OMPT_GET_FRAME_ADDRESS(0);
} }
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
#endif #endif
if (if_cond) { if (if_cond) {
if (gomp_flags & KMP_GOMP_TASK_DEPENDS_FLAG) { if (gomp_flags & KMP_GOMP_TASK_DEPENDS_FLAG) {
KMP_ASSERT(depend); KMP_ASSERT(depend);
kmp_gomp_depends_info_t gomp_depends(depend); kmp_gomp_depends_info_t gomp_depends(depend);
▲ Show 20 Lines • Show All 245 Lines • ▼ Show 20 Lines#endif
__kmp_GOMP_fork_call(&loc, gtid, num_threads, flags, task, __kmp_GOMP_fork_call(&loc, gtid, num_threads, flags, task,
(microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9, (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,
task, data, num_threads, &loc, kmp_nm_dynamic_chunked, task, data, num_threads, &loc, kmp_nm_dynamic_chunked,
(kmp_int)1, (kmp_int)count, (kmp_int)1, (kmp_int)1); (kmp_int)1, (kmp_int)count, (kmp_int)1, (kmp_int)1);
{ {
#if OMPT_SUPPORT #if OMPT_SUPPORT
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
#endif #endif
KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE); KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
} }
task(data); task(data);
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)(); KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)();
KA_TRACE(20, ("GOMP_parallel_sections exit: T#%d\n", gtid)); KA_TRACE(20, ("GOMP_parallel_sections exit: T#%d\n", gtid));
} }
#define PARALLEL_LOOP(func, schedule, ompt_pre, ompt_post) \ #define PARALLEL_LOOP(func, schedule, ompt_pre, ompt_post) \
void func(void (*task)(void *), void *data, unsigned num_threads, long lb, \ void func(void (*task)(void *), void *data, unsigned num_threads, long lb, \
Show All 27 Lines#define PARALLEL_LOOP(func, schedule, ompt_pre, ompt_post) \
} }
PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC), PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC),
kmp_sch_static, OMPT_LOOP_PRE, OMPT_LOOP_POST) kmp_sch_static, OMPT_LOOP_PRE, OMPT_LOOP_POST)
PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC), PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC),
kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST) kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
PARALLEL_LOOP( PARALLEL_LOOP(
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_NONMONOTONIC_GUIDED), KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_NONMONOTONIC_GUIDED),
kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST) kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
PARALLEL_LOOP( PARALLEL_LOOP(
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_NONMONOTONIC_DYNAMIC), KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_NONMONOTONIC_DYNAMIC),
kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST) kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED), PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED),
kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST) kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME), PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME),
kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST) kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST)
PARALLEL_LOOP( PARALLEL_LOOP(
KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_MAYBE_NONMONOTONIC_RUNTIME), KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_MAYBE_NONMONOTONIC_RUNTIME),
kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST) kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST)
PARALLEL_LOOP( PARALLEL_LOOP(
▲ Show 20 Lines • Show All 536 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_i18n.cpp

Show First 20 Lines • Show All 358 Lines • ▼ Show 20 Lines if (__kmp_generate_warnings > kmp_warnings_low) {
OMP: Warning #2: Cannot open message catalog "1041\libompui.dll": OMP: Warning #2: Cannot open message catalog "1041\libompui.dll":
OMP: System error #193: (No system error message available) OMP: System error #193: (No system error message available)
OMP: Info #3: Default messages will be used. OMP: Info #3: Default messages will be used.
Issue hint in this case so cause of trouble is more understandable. */ Issue hint in this case so cause of trouble is more understandable. */
kmp_msg_t err_code = KMP_SYSERRCODE(error); kmp_msg_t err_code = KMP_SYSERRCODE(error);
__kmp_msg(kmp_ms_warning, KMP_MSG(CantOpenMessageCatalog, path.str), __kmp_msg(kmp_ms_warning, KMP_MSG(CantOpenMessageCatalog, path.str),
err_code, (error == ERROR_BAD_EXE_FORMAT err_code,
(error == ERROR_BAD_EXE_FORMAT
? KMP_HNT(BadExeFormat, path.str, KMP_ARCH_STR) ? KMP_HNT(BadExeFormat, path.str, KMP_ARCH_STR)
: __kmp_msg_null), : __kmp_msg_null),
__kmp_msg_null); __kmp_msg_null);
if (__kmp_generate_warnings == kmp_warnings_off) { if (__kmp_generate_warnings == kmp_warnings_off) {
__kmp_str_free(&err_code.str); __kmp_str_free(&err_code.str);
} }
KMP_INFORM(WillUseDefaultMessages); KMP_INFORM(WillUseDefaultMessages);
} }
} else { // status == KMP_I18N_OPENED } else { // status == KMP_I18N_OPENED
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Linesstatic char const *___catgets(kmp_i18n_id_t id) {
// Calculate length of multibyte message. // Calculate length of multibyte message.
// Since wlen does not include terminating null, len does not include it also. // Since wlen does not include terminating null, len does not include it also.
len = WideCharToMultiByte(code_page, len = WideCharToMultiByte(code_page,
0, // Flags. 0, // Flags.
wmsg, wlen, // Wide buffer and size. wmsg, wlen, // Wide buffer and size.
NULL, 0, // Buffer and size. NULL, 0, // Buffer and size.
NULL, NULL // Default char and used default char. NULL, NULL // Default char and used default char.
); );
if (len <= 0) { if (len <= 0) {
goto end; goto end;
} }
// Allocate memory. // Allocate memory.
msg = (char *)KMP_INTERNAL_MALLOC(len + 1); msg = (char *)KMP_INTERNAL_MALLOC(len + 1);
// Convert wide message to multibyte one. // Convert wide message to multibyte one.
rc = WideCharToMultiByte(code_page, rc = WideCharToMultiByte(code_page,
0, // Flags. 0, // Flags.
wmsg, wlen, // Wide buffer and size. wmsg, wlen, // Wide buffer and size.
msg, len, // Buffer and size. msg, len, // Buffer and size.
NULL, NULL // Default char and used default char. NULL, NULL // Default char and used default char.
); );
if (rc <= 0 || rc > len) { if (rc <= 0 || rc > len) {
goto end; goto end;
} }
KMP_DEBUG_ASSERT(rc == len); KMP_DEBUG_ASSERT(rc == len);
len = rc; len = rc;
msg[len] = 0; // Put terminating null to the end. msg[len] = 0; // Put terminating null to the end.
// Stripping all "\r" before stripping last end-of-line simplifies the task. // Stripping all "\r" before stripping last end-of-line simplifies the task.
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines if (rc > 0) {
// even start it. // even start it.
} }
if (buffer != NULL) { if (buffer != NULL) {
LocalFree(buffer); LocalFree(buffer);
} }
#else // Non-Windows* OS: Linux* OS or OS X* #else // Non-Windows* OS: Linux* OS or OS X*
/* There are 2 incompatible versions of strerror_r: /* There are 2 incompatible versions of strerror_r:
char * strerror_r( int, char *, size_t ); // GNU version char * strerror_r( int, char *, size_t ); // GNU version
int strerror_r( int, char *, size_t ); // XSI version int strerror_r( int, char *, size_t ); // XSI version
*/ */
#if (defined(__GLIBC__) && defined(_GNU_SOURCE)) || \ #if (defined(__GLIBC__) && defined(_GNU_SOURCE)) || \
(defined(__BIONIC__) && defined(_GNU_SOURCE) && \ (defined(__BIONIC__) && defined(_GNU_SOURCE) && \
__ANDROID_API__ >= __ANDROID_API_M__) __ANDROID_API__ >= __ANDROID_API_M__)
// GNU version of strerror_r. // GNU version of strerror_r.
char buffer[2048]; char buffer[2048];
char *const err_msg = strerror_r(err, buffer, sizeof(buffer)); char *const err_msg = strerror_r(err, buffer, sizeof(buffer));
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines case kmp_ms_inform: {
format = kmp_i18n_fmt_Info; format = kmp_i18n_fmt_Info;
} break; } break;
case kmp_ms_warning: { case kmp_ms_warning: {
format = kmp_i18n_fmt_Warning; format = kmp_i18n_fmt_Warning;
} break; } break;
case kmp_ms_fatal: { case kmp_ms_fatal: {
format = kmp_i18n_fmt_Fatal; format = kmp_i18n_fmt_Fatal;
} break; } break;
default: { KMP_DEBUG_ASSERT(0); } default: {
KMP_DEBUG_ASSERT(0);
}
} }
fmsg = __kmp_msg_format(format, message.num, message.str); fmsg = __kmp_msg_format(format, message.num, message.str);
__kmp_str_free(&message.str); __kmp_str_free(&message.str);
__kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len); __kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len);
__kmp_str_free(&fmsg.str); __kmp_str_free(&fmsg.str);
// Format other messages. // Format other messages.
for (;;) { for (;;) {
message = va_arg(args, kmp_msg_t); message = va_arg(args, kmp_msg_t);
if (message.type == kmp_mt_dummy && message.str == NULL) { if (message.type == kmp_mt_dummy && message.str == NULL) {
break; break;
} }
switch (message.type) { switch (message.type) {
case kmp_mt_hint: { case kmp_mt_hint: {
format = kmp_i18n_fmt_Hint; format = kmp_i18n_fmt_Hint;
// we cannot skip %1$ and only use %2$ to print the message without the // we cannot skip %1$ and only use %2$ to print the message without the
// number // number
fmsg = __kmp_msg_format(format, message.str); fmsg = __kmp_msg_format(format, message.str);
} break; } break;
case kmp_mt_syserr: { case kmp_mt_syserr: {
format = kmp_i18n_fmt_SysErr; format = kmp_i18n_fmt_SysErr;
fmsg = __kmp_msg_format(format, message.num, message.str); fmsg = __kmp_msg_format(format, message.num, message.str);
} break; } break;
default: { KMP_DEBUG_ASSERT(0); } default: {
KMP_DEBUG_ASSERT(0);
}
} }
__kmp_str_free(&message.str); __kmp_str_free(&message.str);
__kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len); __kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len);
__kmp_str_free(&fmsg.str); __kmp_str_free(&fmsg.str);
} }
// Print formatted messages. // Print formatted messages.
// This lock prevents multiple fatal errors on the same problem. // This lock prevents multiple fatal errors on the same problem.
Show All 30 Lines

openmp/runtime/src/kmp_io.cpp

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 Lines#endif /* KMP_OS_WINDOWS */
if (__kmp_debug_buf && __kmp_debug_buffer != NULL) { if (__kmp_debug_buf && __kmp_debug_buffer != NULL) {
int dc = __kmp_debug_count++ % __kmp_debug_buf_lines; int dc = __kmp_debug_count++ % __kmp_debug_buf_lines;
char *db = &__kmp_debug_buffer[dc * __kmp_debug_buf_chars]; char *db = &__kmp_debug_buffer[dc * __kmp_debug_buf_chars];
int chars = 0; int chars = 0;
#ifdef KMP_DEBUG_PIDS #ifdef KMP_DEBUG_PIDS
chars = KMP_SNPRINTF(db, __kmp_debug_buf_chars, "pid=%d: ", chars = KMP_SNPRINTF(db, __kmp_debug_buf_chars,
(kmp_int32)getpid()); "pid=%d: ", (kmp_int32)getpid());
#endif #endif
chars += KMP_VSNPRINTF(db, __kmp_debug_buf_chars, format, ap); chars += KMP_VSNPRINTF(db, __kmp_debug_buf_chars, format, ap);
if (chars + 1 > __kmp_debug_buf_chars) { if (chars + 1 > __kmp_debug_buf_chars) {
if (chars + 1 > __kmp_debug_buf_warn_chars) { if (chars + 1 > __kmp_debug_buf_warn_chars) {
#if KMP_OS_WINDOWS #if KMP_OS_WINDOWS
DWORD count; DWORD count;
__kmp_str_buf_print(&__kmp_console_buf, "OMP warning: Debugging buffer " __kmp_str_buf_print(&__kmp_console_buf,
"OMP warning: Debugging buffer "
"overflow; increase " "overflow; increase "
"KMP_DEBUG_BUF_CHARS to %d\n", "KMP_DEBUG_BUF_CHARS to %d\n",
chars + 1); chars + 1);
WriteFile(stream, __kmp_console_buf.str, __kmp_console_buf.used, &count, WriteFile(stream, __kmp_console_buf.str, __kmp_console_buf.used, &count,
NULL); NULL);
__kmp_str_buf_clear(&__kmp_console_buf); __kmp_str_buf_clear(&__kmp_console_buf);
#else #else
fprintf(stream, "OMP warning: Debugging buffer overflow; " fprintf(stream,
"OMP warning: Debugging buffer overflow; "
"increase KMP_DEBUG_BUF_CHARS to %d\n", "increase KMP_DEBUG_BUF_CHARS to %d\n",
chars + 1); chars + 1);
fflush(stream); fflush(stream);
#endif #endif
__kmp_debug_buf_warn_chars = chars + 1; __kmp_debug_buf_warn_chars = chars + 1;
} }
/* terminate string if overflow occurred */ /* terminate string if overflow occurred */
db[__kmp_debug_buf_chars - 2] = '\n'; db[__kmp_debug_buf_chars - 2] = '\n';
db[__kmp_debug_buf_chars - 1] = '\0'; db[__kmp_debug_buf_chars - 1] = '\0';
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_itt.h

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
__kmp_inline void __kmp_itt_barrier_starting(int gtid, void *object); __kmp_inline void __kmp_itt_barrier_starting(int gtid, void *object);
__kmp_inline void __kmp_itt_barrier_middle(int gtid, void *object); __kmp_inline void __kmp_itt_barrier_middle(int gtid, void *object);
__kmp_inline void __kmp_itt_barrier_finished(int gtid, void *object); __kmp_inline void __kmp_itt_barrier_finished(int gtid, void *object);
// --- Taskwait reporting --- // --- Taskwait reporting ---
__kmp_inline void *__kmp_itt_taskwait_object(int gtid); __kmp_inline void *__kmp_itt_taskwait_object(int gtid);
__kmp_inline void __kmp_itt_taskwait_starting(int gtid, void *object); __kmp_inline void __kmp_itt_taskwait_starting(int gtid, void *object);
__kmp_inline void __kmp_itt_taskwait_finished(int gtid, void *object); __kmp_inline void __kmp_itt_taskwait_finished(int gtid, void *object);
#define KMP_ITT_TASKWAIT_STARTING(obj) \ #define KMP_ITT_TASKWAIT_STARTING(obj) \
if (UNLIKELY(__itt_sync_create_ptr)) { \ if (UNLIKELY(__itt_sync_create_ptr)) { \
obj = __kmp_itt_taskwait_object(gtid); \ obj = __kmp_itt_taskwait_object(gtid); \
if (obj != NULL) { \ if (obj != NULL) { \
__kmp_itt_taskwait_starting(gtid, obj); \ __kmp_itt_taskwait_starting(gtid, obj); \
} \ } \
} }
#define KMP_ITT_TASKWAIT_FINISHED(obj) \ #define KMP_ITT_TASKWAIT_FINISHED(obj) \
if (UNLIKELY(obj != NULL)) \ if (UNLIKELY(obj != NULL)) \
__kmp_itt_taskwait_finished(gtid, obj); __kmp_itt_taskwait_finished(gtid, obj);
// --- Task reporting --- // --- Task reporting ---
__kmp_inline void __kmp_itt_task_starting(void *object); __kmp_inline void __kmp_itt_task_starting(void *object);
__kmp_inline void __kmp_itt_task_finished(void *object); __kmp_inline void __kmp_itt_task_finished(void *object);
// --- Lock reporting --- // --- Lock reporting ---
#if KMP_USE_DYNAMIC_LOCK #if KMP_USE_DYNAMIC_LOCK
__kmp_inline void __kmp_itt_lock_creating(kmp_user_lock_p lock, __kmp_inline void __kmp_itt_lock_creating(kmp_user_lock_p lock,
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_itt.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
void __kmp_itt_reset() { void __kmp_itt_reset() {
#if USE_ITT_NOTIFY #if USE_ITT_NOTIFY
__kmp_itt__ittapi_global = __kmp_ittapi_clean_global; __kmp_itt__ittapi_global = __kmp_ittapi_clean_global;
#endif #endif
} }
void __kmp_itt_initialize() { void __kmp_itt_initialize() {
// ITTNotify library is loaded and initialized at first call to any ittnotify // ITTNotify library is loaded and initialized at first call to any ittnotify
// function, so we do not need to explicitly load it any more. Just report OMP // function, so we do not need to explicitly load it any more. Just report OMP
// RTL version to ITTNotify. // RTL version to ITTNotify.
#if USE_ITT_NOTIFY #if USE_ITT_NOTIFY
// Backup a clean global state // Backup a clean global state
__kmp_ittapi_clean_global = __kmp_itt__ittapi_global; __kmp_ittapi_clean_global = __kmp_itt__ittapi_global;
// Report OpenMP RTL version. // Report OpenMP RTL version.
kmp_str_buf_t buf; kmp_str_buf_t buf;
__itt_mark_type version; __itt_mark_type version;
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines case __itt_error_system: {
int sys_err = va_arg(args, int); int sys_err = va_arg(args, int);
kmp_msg_t err_code = KMP_SYSERRCODE(sys_err); kmp_msg_t err_code = KMP_SYSERRCODE(sys_err);
__kmp_msg(kmp_ms_warning, KMP_MSG(IttFunctionError, func), err_code, __kmp_msg(kmp_ms_warning, KMP_MSG(IttFunctionError, func), err_code,
__kmp_msg_null); __kmp_msg_null);
if (__kmp_generate_warnings == kmp_warnings_off) { if (__kmp_generate_warnings == kmp_warnings_off) {
__kmp_str_free(&err_code.str); __kmp_str_free(&err_code.str);
} }
} break; } break;
default: { KMP_WARNING(IttUnknownError, err); } default: {
KMP_WARNING(IttUnknownError, err);
}
} }
} // __itt_error_handler } // __itt_error_handler
#endif /* USE_ITT_BUILD */ #endif /* USE_ITT_BUILD */

openmp/runtime/src/kmp_lock.h

Show First 20 Lines • Show All 649 Lines • ▼ Show 20 Lines if (__kmp_user_lock_kind == lk_tas) { \
} \ } \
if (lck->tas.lk.poll != 0 || \ if (lck->tas.lk.poll != 0 || \
!__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) { \ !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) { \
kmp_uint32 spins; \ kmp_uint32 spins; \
KMP_FSYNC_PREPARE(lck); \ KMP_FSYNC_PREPARE(lck); \
KMP_INIT_YIELD(spins); \ KMP_INIT_YIELD(spins); \
do { \ do { \
KMP_YIELD_OVERSUB_ELSE_SPIN(spins); \ KMP_YIELD_OVERSUB_ELSE_SPIN(spins); \
} while ( \ } while (lck->tas.lk.poll != 0 || !__kmp_atomic_compare_store_acq( \
lck->tas.lk.poll != 0 || \ &lck->tas.lk.poll, 0, gtid + 1)); \
!__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)); \
} \ } \
KMP_FSYNC_ACQUIRED(lck); \ KMP_FSYNC_ACQUIRED(lck); \
} else { \ } else { \
KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL); \ KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL); \
(*__kmp_acquire_user_lock_with_checks_)(lck, gtid); \ (*__kmp_acquire_user_lock_with_checks_)(lck, gtid); \
} }
#else #else
▲ Show 20 Lines • Show All 608 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_lock.cpp

Show First 20 Lines • Show All 1,484 Lines • ▼ Show 20 Lines#endif
KA_TRACE(1000, ("__kmp_release_queuing_lock: lck:%p, T#%d exiting: after " KA_TRACE(1000, ("__kmp_release_queuing_lock: lck:%p, T#%d exiting: after "
"dequeuing\n", "dequeuing\n",
lck, gtid)); lck, gtid));
#ifdef DEBUG_QUEUING_LOCKS #ifdef DEBUG_QUEUING_LOCKS
TRACE_LOCK(gtid + 1, "rel exit 2"); TRACE_LOCK(gtid + 1, "rel exit 2");
#endif #endif
return KMP_LOCK_RELEASED; return KMP_LOCK_RELEASED;
} }
/* KMP_CPU_PAUSE(); don't want to make releasing thread hold up acquiring /* KMP_CPU_PAUSE(); don't want to make releasing thread hold up acquiring
threads */ threads */
#ifdef DEBUG_QUEUING_LOCKS #ifdef DEBUG_QUEUING_LOCKS
TRACE_LOCK(gtid + 1, "rel retry"); TRACE_LOCK(gtid + 1, "rel retry");
#endif #endif
} /* while */ } /* while */
KMP_ASSERT2(0, "should not get here"); KMP_ASSERT2(0, "should not get here");
return KMP_LOCK_RELEASED; return KMP_LOCK_RELEASED;
▲ Show 20 Lines • Show All 411 Lines • ▼ Show 20 Lines if (strcmp(__kmp_speculative_statsfile, "-") == 0) {
size_t buffLen = KMP_STRLEN(__kmp_speculative_statsfile) + 20; size_t buffLen = KMP_STRLEN(__kmp_speculative_statsfile) + 20;
char buffer[buffLen]; char buffer[buffLen];
KMP_SNPRINTF(&buffer[0], buffLen, __kmp_speculative_statsfile, KMP_SNPRINTF(&buffer[0], buffLen, __kmp_speculative_statsfile,
(kmp_int32)getpid()); (kmp_int32)getpid());
statsFile.open(buffer, "w"); statsFile.open(buffer, "w");
} }
fprintf(statsFile, "Speculative lock statistics (all approximate!)\n"); fprintf(statsFile, "Speculative lock statistics (all approximate!)\n");
fprintf(statsFile, " Lock parameters: \n" fprintf(statsFile,
" Lock parameters: \n"
" max_soft_retries : %10d\n" " max_soft_retries : %10d\n"
" max_badness : %10d\n", " max_badness : %10d\n",
__kmp_adaptive_backoff_params.max_soft_retries, __kmp_adaptive_backoff_params.max_soft_retries,
__kmp_adaptive_backoff_params.max_badness); __kmp_adaptive_backoff_params.max_badness);
fprintf(statsFile, " Non-speculative acquire attempts : %10d\n", fprintf(statsFile, " Non-speculative acquire attempts : %10d\n",
t->nonSpeculativeAcquireAttempts); t->nonSpeculativeAcquireAttempts);
fprintf(statsFile, " Total critical sections : %10d\n", fprintf(statsFile, " Total critical sections : %10d\n",
totalSections); totalSections);
fprintf(statsFile, " Successful speculations : %10d (%5.1f%%)\n", fprintf(statsFile, " Successful speculations : %10d (%5.1f%%)\n",
t->successfulSpeculations, t->successfulSpeculations,
▲ Show 20 Lines • Show All 2,108 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_os.h

Show First 20 Lines • Show All 327 Lines • ▼ Show 20 Lines
#define KMP_CACHE_PREFETCH(ADDR) /* nothing */ #define KMP_CACHE_PREFETCH(ADDR) /* nothing */
// Define attribute that indicates that the fall through from the previous // Define attribute that indicates that the fall through from the previous
// case label is intentional and should not be diagnosed by a compiler // case label is intentional and should not be diagnosed by a compiler
// Code from libcxx/include/__config // Code from libcxx/include/__config
// Use a function like macro to imply that it must be followed by a semicolon // Use a function like macro to imply that it must be followed by a semicolon
#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough) #if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
# define KMP_FALLTHROUGH() [[fallthrough]] #define KMP_FALLTHROUGH() [[fallthrough]]
#elif __has_cpp_attribute(clang::fallthrough) #elif __has_cpp_attribute(clang::fallthrough)
# define KMP_FALLTHROUGH() [[clang::fallthrough]] #define KMP_FALLTHROUGH() [[clang::fallthrough]]
#elif __has_attribute(fallthrough) || __GNUC__ >= 7 #elif __has_attribute(fallthrough) || __GNUC__ >= 7
# define KMP_FALLTHROUGH() __attribute__((__fallthrough__)) #define KMP_FALLTHROUGH() __attribute__((__fallthrough__))
#else #else
# define KMP_FALLTHROUGH() ((void)0) #define KMP_FALLTHROUGH() ((void)0)
#endif #endif
#if KMP_HAVE_ATTRIBUTE_WAITPKG #if KMP_HAVE_ATTRIBUTE_WAITPKG
#define KMP_ATTRIBUTE_TARGET_WAITPKG __attribute__((target("waitpkg"))) #define KMP_ATTRIBUTE_TARGET_WAITPKG __attribute__((target("waitpkg")))
#else #else
#define KMP_ATTRIBUTE_TARGET_WAITPKG /* Nothing */ #define KMP_ATTRIBUTE_TARGET_WAITPKG /* Nothing */
#endif #endif
▲ Show 20 Lines • Show All 324 Lines • ▼ Show 20 Lines __sync_val_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8)(cv), \
(kmp_uint8)(sv)) (kmp_uint8)(sv))
#define KMP_COMPARE_AND_STORE_RET16(p, cv, sv) \ #define KMP_COMPARE_AND_STORE_RET16(p, cv, sv) \
__sync_val_compare_and_swap((volatile kmp_uint16 *)(p), (kmp_uint16)(cv), \ __sync_val_compare_and_swap((volatile kmp_uint16 *)(p), (kmp_uint16)(cv), \
(kmp_uint16)(sv)) (kmp_uint16)(sv))
#define KMP_COMPARE_AND_STORE_RET32(p, cv, sv) \ #define KMP_COMPARE_AND_STORE_RET32(p, cv, sv) \
__sync_val_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32)(cv), \ __sync_val_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32)(cv), \
(kmp_uint32)(sv)) (kmp_uint32)(sv))
#if KMP_ARCH_MIPS #if KMP_ARCH_MIPS
static inline bool mips_sync_bool_compare_and_swap( static inline bool mips_sync_bool_compare_and_swap(volatile kmp_uint64 *p,
volatile kmp_uint64 *p, kmp_uint64 cv, kmp_uint64 sv) { kmp_uint64 cv,
kmp_uint64 sv) {
return __atomic_compare_exchange(p, &cv, &sv, false, __ATOMIC_SEQ_CST, return __atomic_compare_exchange(p, &cv, &sv, false, __ATOMIC_SEQ_CST,
__ATOMIC_SEQ_CST); __ATOMIC_SEQ_CST);
} }
static inline bool mips_sync_val_compare_and_swap( static inline bool mips_sync_val_compare_and_swap(volatile kmp_uint64 *p,
volatile kmp_uint64 *p, kmp_uint64 cv, kmp_uint64 sv) { kmp_uint64 cv,
kmp_uint64 sv) {
__atomic_compare_exchange(p, &cv, &sv, false, __ATOMIC_SEQ_CST, __atomic_compare_exchange(p, &cv, &sv, false, __ATOMIC_SEQ_CST,
__ATOMIC_SEQ_CST); __ATOMIC_SEQ_CST);
return cv; return cv;
} }
#define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv) \ #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv) \
mips_sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),\ mips_sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), \
(kmp_uint64)(sv)) (kmp_uint64)(cv), (kmp_uint64)(sv))
#define KMP_COMPARE_AND_STORE_REL64(p, cv, sv) \ #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv) \
mips_sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),\ mips_sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), \
(kmp_uint64)(sv)) (kmp_uint64)(cv), (kmp_uint64)(sv))
#define KMP_COMPARE_AND_STORE_RET64(p, cv, sv) \ #define KMP_COMPARE_AND_STORE_RET64(p, cv, sv) \
mips_sync_val_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv), \ mips_sync_val_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv), \
(kmp_uint64)(sv)) (kmp_uint64)(sv))
#else #else
#define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv) \ #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv) \
__sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv), \ __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv), \
(kmp_uint64)(sv)) (kmp_uint64)(sv))
#define KMP_COMPARE_AND_STORE_REL64(p, cv, sv) \ #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv) \
__sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv), \ __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv), \
(kmp_uint64)(sv)) (kmp_uint64)(sv))
#define KMP_COMPARE_AND_STORE_RET64(p, cv, sv) \ #define KMP_COMPARE_AND_STORE_RET64(p, cv, sv) \
▲ Show 20 Lines • Show All 382 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_platform.h

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
#define KMP_OS_OPENBSD 1 #define KMP_OS_OPENBSD 1
#endif #endif
#if (defined __GNU__) #if (defined __GNU__)
#undef KMP_OS_HURD #undef KMP_OS_HURD
#define KMP_OS_HURD 1 #define KMP_OS_HURD 1
#endif #endif
#if (1 != \ #if (1 != KMP_OS_LINUX + KMP_OS_DRAGONFLY + KMP_OS_FREEBSD + KMP_OS_NETBSD + \
KMP_OS_LINUX + KMP_OS_DRAGONFLY + KMP_OS_FREEBSD + KMP_OS_NETBSD + \
KMP_OS_OPENBSD + KMP_OS_DARWIN + KMP_OS_WINDOWS + KMP_OS_HURD) KMP_OS_OPENBSD + KMP_OS_DARWIN + KMP_OS_WINDOWS + KMP_OS_HURD)
#error Unknown OS #error Unknown OS
#endif #endif
#if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \ #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \
KMP_OS_OPENBSD || KMP_OS_DARWIN || KMP_OS_HURD KMP_OS_OPENBSD || KMP_OS_DARWIN || KMP_OS_HURD
#undef KMP_OS_UNIX #undef KMP_OS_UNIX
#define KMP_OS_UNIX 1 #define KMP_OS_UNIX 1
#endif #endif
/* ---------------------- Architecture recognition ------------------- */ /* ---------------------- Architecture recognition ------------------- */
#define KMP_ARCH_X86 0 #define KMP_ARCH_X86 0
#define KMP_ARCH_X86_64 0 #define KMP_ARCH_X86_64 0
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
/* Specify 32 bit architectures here */ /* Specify 32 bit architectures here */
#define KMP_32_BIT_ARCH (KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS) #define KMP_32_BIT_ARCH (KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS)
// Platforms which support Intel(R) Many Integrated Core Architecture // Platforms which support Intel(R) Many Integrated Core Architecture
#define KMP_MIC_SUPPORTED \ #define KMP_MIC_SUPPORTED \
((KMP_ARCH_X86 || KMP_ARCH_X86_64) && (KMP_OS_LINUX || KMP_OS_WINDOWS)) ((KMP_ARCH_X86 || KMP_ARCH_X86_64) && (KMP_OS_LINUX || KMP_OS_WINDOWS))
// TODO: Fixme - This is clever, but really fugly // TODO: Fixme - This is clever, but really fugly
#if (1 != \ #if (1 != KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 + \
KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 + \ KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64 + \
KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64 + KMP_ARCH_RISCV64) KMP_ARCH_RISCV64)
#error Unknown or unsupported architecture #error Unknown or unsupported architecture
#endif #endif
#endif // KMP_PLATFORM_H #endif // KMP_PLATFORM_H

openmp/runtime/src/kmp_runtime.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,366 Lines • ▼ Show 20 Lines#endif
} }
if (__kmp_env_consistency_check) if (__kmp_env_consistency_check)
__kmp_push_parallel(global_tid, NULL); __kmp_push_parallel(global_tid, NULL);
#if OMPT_SUPPORT #if OMPT_SUPPORT
serial_team->t.ompt_team_info.master_return_address = codeptr; serial_team->t.ompt_team_info.master_return_address = codeptr;
if (ompt_enabled.enabled && if (ompt_enabled.enabled &&
this_thr->th.ompt_thread_info.state != ompt_state_overhead) { this_thr->th.ompt_thread_info.state != ompt_state_overhead) {
OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0); OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr =
OMPT_GET_FRAME_ADDRESS(0);
ompt_lw_taskteam_t lw_taskteam; ompt_lw_taskteam_t lw_taskteam;
__ompt_lw_taskteam_init(&lw_taskteam, this_thr, global_tid, __ompt_lw_taskteam_init(&lw_taskteam, this_thr, global_tid,
&ompt_parallel_data, codeptr); &ompt_parallel_data, codeptr);
__ompt_lw_taskteam_link(&lw_taskteam, this_thr, 1); __ompt_lw_taskteam_link(&lw_taskteam, this_thr, 1);
// don't use lw_taskteam after linking. content was swaped // don't use lw_taskteam after linking. content was swaped
/* OMPT implicit task begin */ /* OMPT implicit task begin */
implicit_task_data = OMPT_CUR_TASK_DATA(this_thr); implicit_task_data = OMPT_CUR_TASK_DATA(this_thr);
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_begin, OMPT_CUR_TEAM_DATA(this_thr), ompt_scope_begin, OMPT_CUR_TEAM_DATA(this_thr),
OMPT_CUR_TASK_DATA(this_thr), 1, __kmp_tid_from_gtid(global_tid), ompt_task_implicit); // TODO: Can this be ompt_task_initial? OMPT_CUR_TASK_DATA(this_thr), 1, __kmp_tid_from_gtid(global_tid),
OMPT_CUR_TASK_INFO(this_thr) ompt_task_implicit); // TODO: Can this be ompt_task_initial?
->thread_num = __kmp_tid_from_gtid(global_tid); OMPT_CUR_TASK_INFO(this_thr)->thread_num =
__kmp_tid_from_gtid(global_tid);
} }
/* OMPT state */ /* OMPT state */
this_thr->th.ompt_thread_info.state = ompt_state_work_parallel; this_thr->th.ompt_thread_info.state = ompt_state_work_parallel;
OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0); OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr =
OMPT_GET_FRAME_ADDRESS(0);
} }
#endif #endif
} }
/* most of the work for a fork */ /* most of the work for a fork */
/* return true if we really went parallel, false if serialized */ /* return true if we really went parallel, false if serialized */
int __kmp_fork_call(ident_t *loc, int gtid, int __kmp_fork_call(ident_t *loc, int gtid,
enum fork_context_e call_context, // Intel, GNU, ... enum fork_context_e call_context, // Intel, GNU, ...
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines#if OMPT_SUPPORT
exit_frame_p = &(lw_taskteam.ompt_task_info.frame.exit_frame.ptr); exit_frame_p = &(lw_taskteam.ompt_task_info.frame.exit_frame.ptr);
__ompt_lw_taskteam_link(&lw_taskteam, master_th, 0); __ompt_lw_taskteam_link(&lw_taskteam, master_th, 0);
// don't use lw_taskteam after linking. content was swaped // don't use lw_taskteam after linking. content was swaped
/* OMPT implicit task begin */ /* OMPT implicit task begin */
implicit_task_data = OMPT_CUR_TASK_DATA(master_th); implicit_task_data = OMPT_CUR_TASK_DATA(master_th);
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
OMPT_CUR_TASK_INFO(master_th) OMPT_CUR_TASK_INFO(master_th)->thread_num =
->thread_num = __kmp_tid_from_gtid(gtid); __kmp_tid_from_gtid(gtid);
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th), ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
implicit_task_data, 1, implicit_task_data, 1,
OMPT_CUR_TASK_INFO(master_th)->thread_num, ompt_task_implicit); OMPT_CUR_TASK_INFO(master_th)->thread_num, ompt_task_implicit);
} }
/* OMPT state */ /* OMPT state */
master_th->th.ompt_thread_info.state = ompt_state_work_parallel; master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
} else { } else {
exit_frame_p = &dummy; exit_frame_p = &dummy;
} }
#endif #endif
// AC: need to decrement t_serialized for enquiry functions to work // AC: need to decrement t_serialized for enquiry functions to work
// correctly, will restore at join time // correctly, will restore at join time
parent_team->t.t_serialized--; parent_team->t.t_serialized--;
{ {
KMP_TIME_PARTITIONED_BLOCK(OMP_parallel); KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK); KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
__kmp_invoke_microtask(microtask, gtid, 0, argc, parent_team->t.t_argv __kmp_invoke_microtask(microtask, gtid, 0, argc, parent_team->t.t_argv
#if OMPT_SUPPORT #if OMPT_SUPPORT
, ,
exit_frame_p exit_frame_p
#endif #endif
); );
} }
#if OMPT_SUPPORT #if OMPT_SUPPORT
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
*exit_frame_p = NULL; *exit_frame_p = NULL;
OMPT_CUR_TASK_INFO(master_th)->frame.exit_frame = ompt_data_none; OMPT_CUR_TASK_INFO(master_th)->frame.exit_frame = ompt_data_none;
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines#endif /* KMP_OS_LINUX && ( KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || \
__kmpc_serialized_parallel(loc, gtid); __kmpc_serialized_parallel(loc, gtid);
if (call_context == fork_context_intel) { if (call_context == fork_context_intel) {
/* TODO this sucks, use the compiler itself to pass args! :) */ /* TODO this sucks, use the compiler itself to pass args! :) */
master_th->th.th_serial_team->t.t_ident = loc; master_th->th.th_serial_team->t.t_ident = loc;
if (!ap) { if (!ap) {
// revert change made in __kmpc_serialized_parallel() // revert change made in __kmpc_serialized_parallel()
master_th->th.th_serial_team->t.t_level--; master_th->th.th_serial_team->t.t_level--;
// Get args from parent team for teams construct // Get args from parent team for teams construct
#if OMPT_SUPPORT #if OMPT_SUPPORT
void *dummy; void *dummy;
void **exit_frame_p; void **exit_frame_p;
ompt_task_info_t *task_info; ompt_task_info_t *task_info;
ompt_lw_taskteam_t lw_taskteam; ompt_lw_taskteam_t lw_taskteam;
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
__ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid, __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,
&ompt_parallel_data, return_address); &ompt_parallel_data, return_address);
__ompt_lw_taskteam_link(&lw_taskteam, master_th, 0); __ompt_lw_taskteam_link(&lw_taskteam, master_th, 0);
// don't use lw_taskteam after linking. content was swaped // don't use lw_taskteam after linking. content was swaped
task_info = OMPT_CUR_TASK_INFO(master_th); task_info = OMPT_CUR_TASK_INFO(master_th);
exit_frame_p = &(task_info->frame.exit_frame.ptr); exit_frame_p = &(task_info->frame.exit_frame.ptr);
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
OMPT_CUR_TASK_INFO(master_th) OMPT_CUR_TASK_INFO(master_th)->thread_num =
->thread_num = __kmp_tid_from_gtid(gtid); __kmp_tid_from_gtid(gtid);
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th), ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
&(task_info->task_data), 1, &(task_info->task_data), 1,
OMPT_CUR_TASK_INFO(master_th)->thread_num, OMPT_CUR_TASK_INFO(master_th)->thread_num,
ompt_task_implicit); ompt_task_implicit);
} }
/* OMPT state */ /* OMPT state */
master_th->th.ompt_thread_info.state = ompt_state_work_parallel; master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
} else { } else {
exit_frame_p = &dummy; exit_frame_p = &dummy;
} }
#endif #endif
{ {
KMP_TIME_PARTITIONED_BLOCK(OMP_parallel); KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK); KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
__kmp_invoke_microtask(microtask, gtid, 0, argc, __kmp_invoke_microtask(microtask, gtid, 0, argc,
parent_team->t.t_argv parent_team->t.t_argv
#if OMPT_SUPPORT #if OMPT_SUPPORT
, ,
exit_frame_p exit_frame_p
#endif #endif
); );
} }
#if OMPT_SUPPORT #if OMPT_SUPPORT
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
*exit_frame_p = NULL; *exit_frame_p = NULL;
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_end, NULL, &(task_info->task_data), 1, ompt_scope_end, NULL, &(task_info->task_data), 1,
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines#if OMPT_SUPPORT
/* OMPT implicit task begin */ /* OMPT implicit task begin */
implicit_task_data = OMPT_CUR_TASK_DATA(master_th); implicit_task_data = OMPT_CUR_TASK_DATA(master_th);
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th), ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
implicit_task_data, 1, __kmp_tid_from_gtid(gtid), implicit_task_data, 1, __kmp_tid_from_gtid(gtid),
ompt_task_implicit); ompt_task_implicit);
OMPT_CUR_TASK_INFO(master_th) OMPT_CUR_TASK_INFO(master_th)->thread_num =
->thread_num = __kmp_tid_from_gtid(gtid); __kmp_tid_from_gtid(gtid);
} }
/* OMPT state */ /* OMPT state */
master_th->th.ompt_thread_info.state = ompt_state_work_parallel; master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
} else { } else {
exit_frame_p = &dummy; exit_frame_p = &dummy;
} }
#endif #endif
{ {
KMP_TIME_PARTITIONED_BLOCK(OMP_parallel); KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK); KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
__kmp_invoke_microtask(microtask, gtid, 0, argc, args __kmp_invoke_microtask(microtask, gtid, 0, argc, args
#if OMPT_SUPPORT #if OMPT_SUPPORT
, ,
exit_frame_p exit_frame_p
#endif #endif
); );
} }
#if OMPT_SUPPORT #if OMPT_SUPPORT
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
*exit_frame_p = NULL; *exit_frame_p = NULL;
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_end, NULL, &(task_info->task_data), 1, ompt_scope_end, NULL, &(task_info->task_data), 1,
▲ Show 20 Lines • Show All 730 Lines • ▼ Show 20 Linesvoid __kmp_set_num_threads(int new_nth, int gtid) {
// reduced (in the absence of a num_threads clause), then reduce it now, // reduced (in the absence of a num_threads clause), then reduce it now,
// rather than waiting for the next parallel region. // rather than waiting for the next parallel region.
root = thread->th.th_root; root = thread->th.th_root;
if (__kmp_init_parallel && (!root->r.r_active) && if (__kmp_init_parallel && (!root->r.r_active) &&
(root->r.r_hot_team->t.t_nproc > new_nth) (root->r.r_hot_team->t.t_nproc > new_nth)
#if KMP_NESTED_HOT_TEAMS #if KMP_NESTED_HOT_TEAMS
&& __kmp_hot_teams_max_level && !__kmp_hot_teams_mode && __kmp_hot_teams_max_level && !__kmp_hot_teams_mode
#endif #endif
) { ) {
kmp_team_t *hot_team = root->r.r_hot_team; kmp_team_t *hot_team = root->r.r_hot_team;
int f; int f;
__kmp_acquire_bootstrap_lock(&__kmp_forkjoin_lock); __kmp_acquire_bootstrap_lock(&__kmp_forkjoin_lock);
// Release the extra threads we don't need any more. // Release the extra threads we don't need any more.
for (f = new_nth; f < hot_team->t.t_nproc; f++) { for (f = new_nth; f < hot_team->t.t_nproc; f++) {
KMP_DEBUG_ASSERT(hot_team->t.t_threads[f] != NULL); KMP_DEBUG_ASSERT(hot_team->t.t_threads[f] != NULL);
▲ Show 20 Lines • Show All 528 Lines • ▼ Show 20 Lines root_team =
1, // new_nproc 1, // new_nproc
1, // max_nproc 1, // max_nproc
#if OMPT_SUPPORT #if OMPT_SUPPORT
ompt_data_none, // root parallel id ompt_data_none, // root parallel id
#endif #endif
__kmp_nested_proc_bind.bind_types[0], &r_icvs, __kmp_nested_proc_bind.bind_types[0], &r_icvs,
0 // argc 0 // argc
USE_NESTED_HOT_ARG(NULL) // master thread is unknown USE_NESTED_HOT_ARG(NULL) // master thread is unknown
); );
#if USE_DEBUGGER #if USE_DEBUGGER
// Non-NULL value should be assigned to make the debugger display the root // Non-NULL value should be assigned to make the debugger display the root
// team. // team.
TCW_SYNC_PTR(root_team->t.t_pkfn, (microtask_t)(~0)); TCW_SYNC_PTR(root_team->t.t_pkfn, (microtask_t)(~0));
#endif #endif
KF_TRACE(10, ("__kmp_initialize_root: after root_team = %p\n", root_team)); KF_TRACE(10, ("__kmp_initialize_root: after root_team = %p\n", root_team));
Show All 20 Lines hot_team =
1, // new_nproc 1, // new_nproc
__kmp_dflt_team_nth_ub * 2, // max_nproc __kmp_dflt_team_nth_ub * 2, // max_nproc
#if OMPT_SUPPORT #if OMPT_SUPPORT
ompt_data_none, // root parallel id ompt_data_none, // root parallel id
#endif #endif
__kmp_nested_proc_bind.bind_types[0], &r_icvs, __kmp_nested_proc_bind.bind_types[0], &r_icvs,
0 // argc 0 // argc
USE_NESTED_HOT_ARG(NULL) // master thread is unknown USE_NESTED_HOT_ARG(NULL) // master thread is unknown
); );
KF_TRACE(10, ("__kmp_initialize_root: after hot_team = %p\n", hot_team)); KF_TRACE(10, ("__kmp_initialize_root: after hot_team = %p\n", hot_team));
root->r.r_hot_team = hot_team; root->r.r_hot_team = hot_team;
root_team->t.t_control_stack_top = NULL; root_team->t.t_control_stack_top = NULL;
/* first-time initialization */ /* first-time initialization */
hot_team->t.t_parent = root_team; hot_team->t.t_parent = root_team;
Show All 14 Linestypedef struct kmp_team_list_item {
kmp_team_p const *entry; kmp_team_p const *entry;
struct kmp_team_list_item *next; struct kmp_team_list_item *next;
} kmp_team_list_item_t; } kmp_team_list_item_t;
typedef kmp_team_list_item_t *kmp_team_list_t; typedef kmp_team_list_item_t *kmp_team_list_t;
static void __kmp_print_structure_team_accum( // Add team to list of teams. static void __kmp_print_structure_team_accum( // Add team to list of teams.
kmp_team_list_t list, // List of teams. kmp_team_list_t list, // List of teams.
kmp_team_p const *team // Team to add. kmp_team_p const *team // Team to add.
) { ) {
// List must terminate with item where both entry and next are NULL. // List must terminate with item where both entry and next are NULL.
// Team is added to the list only once. // Team is added to the list only once.
// List is sorted in ascending order by team id. // List is sorted in ascending order by team id.
// Team id is *not* a key. // Team id is *not* a key.
kmp_team_list_t l; kmp_team_list_t l;
Show All 27 Lines // Insert team.
*item = *l; *item = *l;
l->entry = team; l->entry = team;
l->next = item; l->next = item;
} }
} }
static void __kmp_print_structure_team(char const *title, kmp_team_p const *team static void __kmp_print_structure_team(char const *title, kmp_team_p const *team
) { ) {
__kmp_printf("%s", title); __kmp_printf("%s", title);
if (team != NULL) { if (team != NULL) {
__kmp_printf("%2x %p\n", team->t.t_id, team); __kmp_printf("%2x %p\n", team->t.t_id, team);
} else { } else {
__kmp_printf(" - (nil)\n"); __kmp_printf(" - (nil)\n");
} }
} }
▲ Show 20 Lines • Show All 206 Lines • ▼ Show 20 Lines/* This function attempts to create free entries in __kmp_threads and
If any argument is negative, the behavior is undefined. */ If any argument is negative, the behavior is undefined. */
static int __kmp_expand_threads(int nNeed) { static int __kmp_expand_threads(int nNeed) {
int added = 0; int added = 0;
int minimumRequiredCapacity; int minimumRequiredCapacity;
int newCapacity; int newCapacity;
kmp_info_t **newThreads; kmp_info_t **newThreads;
kmp_root_t **newRoot; kmp_root_t **newRoot;
// All calls to __kmp_expand_threads should be under __kmp_forkjoin_lock, so // All calls to __kmp_expand_threads should be under __kmp_forkjoin_lock, so
// resizing __kmp_threads does not need additional protection if foreign // resizing __kmp_threads does not need additional protection if foreign
// threads are present // threads are present
#if KMP_OS_WINDOWS && !KMP_DYNAMIC_LIB #if KMP_OS_WINDOWS && !KMP_DYNAMIC_LIB
/* only for Windows static library */ /* only for Windows static library */
/* reclaim array entries for root threads that are already dead */ /* reclaim array entries for root threads that are already dead */
added = __kmp_reclaim_dead_roots(); added = __kmp_reclaim_dead_roots();
if (nNeed) { if (nNeed) {
nNeed -= added; nNeed -= added;
▲ Show 20 Lines • Show All 302 Lines • ▼ Show 20 Lines if (!initial_thread && ompt_enabled.enabled) {
ompt_set_thread_state(root_thread, ompt_state_overhead); ompt_set_thread_state(root_thread, ompt_state_overhead);
if (ompt_enabled.ompt_callback_thread_begin) { if (ompt_enabled.ompt_callback_thread_begin) {
ompt_callbacks.ompt_callback(ompt_callback_thread_begin)( ompt_callbacks.ompt_callback(ompt_callback_thread_begin)(
ompt_thread_initial, __ompt_get_thread_data_internal()); ompt_thread_initial, __ompt_get_thread_data_internal());
} }
ompt_data_t *task_data; ompt_data_t *task_data;
ompt_data_t *parallel_data; ompt_data_t *parallel_data;
__ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data, NULL); __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data,
NULL);
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial); ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial);
} }
ompt_set_thread_state(root_thread, ompt_state_work_serial); ompt_set_thread_state(root_thread, ompt_state_work_serial);
} }
#endif #endif
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines KA_TRACE(
(LPVOID) & (root->r.r_uber_thread->th), (LPVOID) & (root->r.r_uber_thread->th),
root->r.r_uber_thread->th.th_info.ds.ds_thread)); root->r.r_uber_thread->th.th_info.ds.ds_thread));
__kmp_free_handle(root->r.r_uber_thread->th.th_info.ds.ds_thread); __kmp_free_handle(root->r.r_uber_thread->th.th_info.ds.ds_thread);
#endif /* KMP_OS_WINDOWS */ #endif /* KMP_OS_WINDOWS */
#if OMPT_SUPPORT #if OMPT_SUPPORT
ompt_data_t *task_data; ompt_data_t *task_data;
ompt_data_t *parallel_data; ompt_data_t *parallel_data;
__ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data, NULL); __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data,
NULL);
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_end, parallel_data, task_data, 0, 1, ompt_task_initial); ompt_scope_end, parallel_data, task_data, 0, 1, ompt_task_initial);
} }
if (ompt_enabled.ompt_callback_thread_end) { if (ompt_enabled.ompt_callback_thread_end) {
ompt_callbacks.ompt_callback(ompt_callback_thread_end)( ompt_callbacks.ompt_callback(ompt_callback_thread_end)(
&(root->r.r_uber_thread->th.ompt_thread_info.thread_data)); &(root->r.r_uber_thread->th.ompt_thread_info.thread_data));
} }
▲ Show 20 Lines • Show All 224 Lines • ▼ Show 20 Lines if (!dispatch->th_disp_buffer) {
(dispatch_private_info_t *)__kmp_allocate(disp_size); (dispatch_private_info_t *)__kmp_allocate(disp_size);
if (__kmp_storage_map) { if (__kmp_storage_map) {
__kmp_print_storage_map_gtid( __kmp_print_storage_map_gtid(
gtid, &dispatch->th_disp_buffer[0], gtid, &dispatch->th_disp_buffer[0],
&dispatch->th_disp_buffer[team->t.t_max_nproc == 1 &dispatch->th_disp_buffer[team->t.t_max_nproc == 1
? 1 ? 1
: __kmp_dispatch_num_buffers], : __kmp_dispatch_num_buffers],
disp_size, "th_%d.th_dispatch.th_disp_buffer " disp_size,
"th_%d.th_dispatch.th_disp_buffer "
"(team_%d.t_dispatch[%d].th_disp_buffer)", "(team_%d.t_dispatch[%d].th_disp_buffer)",
gtid, team->t.t_id, gtid); gtid, team->t.t_id, gtid);
} }
} else { } else {
memset(&dispatch->th_disp_buffer[0], '\0', disp_size); memset(&dispatch->th_disp_buffer[0], '\0', disp_size);
} }
dispatch->th_dispatch_pr_current = 0; dispatch->th_dispatch_pr_current = 0;
dispatch->th_dispatch_sh_current = 0; dispatch->th_dispatch_sh_current = 0;
▲ Show 20 Lines • Show All 1,768 Lines • ▼ Show 20 Lines
#endif /* USE_FAST_MEMORY */ #endif /* USE_FAST_MEMORY */
__kmp_suspend_uninitialize_thread(thread); __kmp_suspend_uninitialize_thread(thread);
KMP_DEBUG_ASSERT(__kmp_threads[gtid] == thread); KMP_DEBUG_ASSERT(__kmp_threads[gtid] == thread);
TCW_SYNC_PTR(__kmp_threads[gtid], NULL); TCW_SYNC_PTR(__kmp_threads[gtid], NULL);
--__kmp_all_nth; --__kmp_all_nth;
// __kmp_nth was decremented when thread is added to the pool. // __kmp_nth was decremented when thread is added to the pool.
#ifdef KMP_ADJUST_BLOCKTIME #ifdef KMP_ADJUST_BLOCKTIME
/* Adjust blocktime back to user setting or default if necessary */ /* Adjust blocktime back to user setting or default if necessary */
/* Middle initialization might never have occurred */ /* Middle initialization might never have occurred */
if (!__kmp_env_blocktime && (__kmp_avail_proc > 0)) { if (!__kmp_env_blocktime && (__kmp_avail_proc > 0)) {
KMP_DEBUG_ASSERT(__kmp_avail_proc > 0); KMP_DEBUG_ASSERT(__kmp_avail_proc > 0);
if (__kmp_nth <= __kmp_avail_proc) { if (__kmp_nth <= __kmp_avail_proc) {
__kmp_zero_bt = FALSE; __kmp_zero_bt = FALSE;
▲ Show 20 Lines • Show All 531 Lines • ▼ Show 20 Lines if (value != NULL && strcmp(value, __kmp_registration_str) == 0) {
char *flag_val_str = NULL; char *flag_val_str = NULL;
char const *file_name = NULL; char const *file_name = NULL;
__kmp_str_split(tail, '-', &flag_addr_str, &tail); __kmp_str_split(tail, '-', &flag_addr_str, &tail);
__kmp_str_split(tail, '-', &flag_val_str, &tail); __kmp_str_split(tail, '-', &flag_val_str, &tail);
file_name = tail; file_name = tail;
if (tail != NULL) { if (tail != NULL) {
long *flag_addr = 0; long *flag_addr = 0;
long flag_val = 0; long flag_val = 0;
KMP_SSCANF(flag_addr_str, "%p", RCAST(void**, &flag_addr)); KMP_SSCANF(flag_addr_str, "%p", RCAST(void **, &flag_addr));
KMP_SSCANF(flag_val_str, "%lx", &flag_val); KMP_SSCANF(flag_val_str, "%lx", &flag_val);
if (flag_addr != 0 && flag_val != 0 && strcmp(file_name, "") != 0) { if (flag_addr != 0 && flag_val != 0 && strcmp(file_name, "") != 0) {
// First, check whether environment-encoded address is mapped into // First, check whether environment-encoded address is mapped into
// addr space. // addr space.
// If so, dereference it to see if it still has the right value. // If so, dereference it to see if it still has the right value.
if (__kmp_is_address_mapped(flag_addr) && *flag_addr == flag_val) { if (__kmp_is_address_mapped(flag_addr) && *flag_addr == flag_val) {
neighbor = 1; neighbor = 1;
} else { } else {
Show All 28 Lines
#if KMP_OS_UNIX && KMP_DYNAMIC_LIB // shared memory is with dynamic library #if KMP_OS_UNIX && KMP_DYNAMIC_LIB // shared memory is with dynamic library
// close shared memory. // close shared memory.
shm_unlink(shm_name); // this removes file in /dev/shm shm_unlink(shm_name); // this removes file in /dev/shm
#else #else
// Clear the variable and try to register library again. // Clear the variable and try to register library again.
__kmp_env_unset(name); __kmp_env_unset(name);
#endif #endif
} break; } break;
default: { KMP_DEBUG_ASSERT(0); } break; default: {
KMP_DEBUG_ASSERT(0);
} break;
} }
} }
KMP_INTERNAL_FREE((void *)value); KMP_INTERNAL_FREE((void *)value);
#if KMP_OS_UNIX && KMP_DYNAMIC_LIB // shared memory is with dynamic library #if KMP_OS_UNIX && KMP_DYNAMIC_LIB // shared memory is with dynamic library
KMP_INTERNAL_FREE((void *)shm_name); KMP_INTERNAL_FREE((void *)shm_name);
#endif #endif
} // while } // while
KMP_INTERNAL_FREE((void *)name); KMP_INTERNAL_FREE((void *)name);
▲ Show 20 Lines • Show All 689 Lines • ▼ Show 20 Lines
#if OMPT_SUPPORT #if OMPT_SUPPORT
void *dummy; void *dummy;
void **exit_frame_p; void **exit_frame_p;
ompt_data_t *my_task_data; ompt_data_t *my_task_data;
ompt_data_t *my_parallel_data; ompt_data_t *my_parallel_data;
int ompt_team_size; int ompt_team_size;
if (ompt_enabled.enabled) { if (ompt_enabled.enabled) {
exit_frame_p = &( exit_frame_p = &(team->t.t_implicit_task_taskdata[tid]
team->t.t_implicit_task_taskdata[tid].ompt_task_info.frame.exit_frame.ptr); .ompt_task_info.frame.exit_frame.ptr);
} else { } else {
exit_frame_p = &dummy; exit_frame_p = &dummy;
} }
my_task_data = my_task_data =
&(team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_data); &(team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_data);
my_parallel_data = &(team->t.ompt_team_info.parallel_data); my_parallel_data = &(team->t.ompt_team_info.parallel_data);
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
Show All 16 Lines
#endif #endif
rc = __kmp_invoke_microtask((microtask_t)TCR_SYNC_PTR(team->t.t_pkfn), gtid, rc = __kmp_invoke_microtask((microtask_t)TCR_SYNC_PTR(team->t.t_pkfn), gtid,
tid, (int)team->t.t_argc, (void **)team->t.t_argv tid, (int)team->t.t_argc, (void **)team->t.t_argv
#if OMPT_SUPPORT #if OMPT_SUPPORT
, ,
exit_frame_p exit_frame_p
#endif #endif
); );
#if OMPT_SUPPORT #if OMPT_SUPPORT
*exit_frame_p = NULL; *exit_frame_p = NULL;
this_thr->th.ompt_thread_info.parallel_flags |= ompt_parallel_team; this_thr->th.ompt_thread_info.parallel_flags |= ompt_parallel_team;
#endif #endif
#if KMP_STATS_ENABLED #if KMP_STATS_ENABLED
if (previous_state == stats_state_e::TEAMS_REGION) { if (previous_state == stats_state_e::TEAMS_REGION) {
KMP_SET_THREAD_STATE(previous_state); KMP_SET_THREAD_STATE(previous_state);
} }
KMP_POP_PARTITIONED_TIMER(); KMP_POP_PARTITIONED_TIMER();
#endif #endif
▲ Show 20 Lines • Show All 298 Lines • ▼ Show 20 Lines
void __kmp_internal_join(ident_t *id, int gtid, kmp_team_t *team) { void __kmp_internal_join(ident_t *id, int gtid, kmp_team_t *team) {
kmp_info_t *this_thr = __kmp_threads[gtid]; kmp_info_t *this_thr = __kmp_threads[gtid];
KMP_DEBUG_ASSERT(team); KMP_DEBUG_ASSERT(team);
KMP_DEBUG_ASSERT(this_thr->th.th_team == team); KMP_DEBUG_ASSERT(this_thr->th.th_team == team);
KMP_ASSERT(KMP_MASTER_GTID(gtid)); KMP_ASSERT(KMP_MASTER_GTID(gtid));
KMP_MB(); /* Flush all pending memory write invalidates. */ KMP_MB(); /* Flush all pending memory write invalidates. */
/* Join barrier after fork */ /* Join barrier after fork */
#ifdef KMP_DEBUG #ifdef KMP_DEBUG
if (__kmp_threads[gtid] && if (__kmp_threads[gtid] &&
__kmp_threads[gtid]->th.th_team_nproc != team->t.t_nproc) { __kmp_threads[gtid]->th.th_team_nproc != team->t.t_nproc) {
__kmp_printf("GTID: %d, __kmp_threads[%d]=%p\n", gtid, gtid, __kmp_printf("GTID: %d, __kmp_threads[%d]=%p\n", gtid, gtid,
__kmp_threads[gtid]); __kmp_threads[gtid]);
__kmp_printf("__kmp_threads[%d]->th.th_team_nproc=%d, TEAM: %p, " __kmp_printf("__kmp_threads[%d]->th.th_team_nproc=%d, TEAM: %p, "
"team->t.t_nproc=%d\n", "team->t.t_nproc=%d\n",
Show All 27 Lines#if OMPT_OPTIONAL
if (ompt_enabled.ompt_callback_sync_region) { if (ompt_enabled.ompt_callback_sync_region) {
ompt_callbacks.ompt_callback(ompt_callback_sync_region)( ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
ompt_sync_region_barrier_implicit, ompt_scope_end, NULL, task_data, ompt_sync_region_barrier_implicit, ompt_scope_end, NULL, task_data,
codeptr); codeptr);
} }
#endif #endif
if (!KMP_MASTER_TID(ds_tid) && ompt_enabled.ompt_callback_implicit_task) { if (!KMP_MASTER_TID(ds_tid) && ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_end, NULL, task_data, 0, ds_tid, ompt_task_implicit); // TODO: Can this be ompt_task_initial? ompt_scope_end, NULL, task_data, 0, ds_tid,
ompt_task_implicit); // TODO: Can this be ompt_task_initial?
} }
} }
#endif #endif
KMP_MB(); /* Flush all pending memory write invalidates. */ KMP_MB(); /* Flush all pending memory write invalidates. */
KMP_ASSERT(this_thr->th.th_team == team); KMP_ASSERT(this_thr->th.th_team == team);
} }
▲ Show 20 Lines • Show All 413 Lines • ▼ Show 20 Lines
* T {thread_identifier} - native thread identifier (integer) * T {thread_identifier} - native thread identifier (integer)
* N {num_threads} - omp_get_num_threads() * N {num_threads} - omp_get_num_threads()
* A {ancestor_tnum} - omp_get_ancestor_thread_num(omp_get_level()-1) * A {ancestor_tnum} - omp_get_ancestor_thread_num(omp_get_level()-1)
* a {thread_affinity} - comma separated list of integers or integer ranges * a {thread_affinity} - comma separated list of integers or integer ranges
* (values of affinity mask) * (values of affinity mask)
* *
* Implementation-specific field types can be added * Implementation-specific field types can be added
* If a type is unknown, print "undefined" * If a type is unknown, print "undefined"
*/ */
// Structure holding the short name, long name, and corresponding data type // Structure holding the short name, long name, and corresponding data type
// for snprintf. A table of these will represent the entire valid keyword // for snprintf. A table of these will represent the entire valid keyword
// field types. // field types.
typedef struct kmp_affinity_format_field_t { typedef struct kmp_affinity_format_field_t {
char short_name; // from spec e.g., L -> thread level char short_name; // from spec e.g., L -> thread level
const char *long_name; // from spec thread_level -> thread level const char *long_name; // from spec thread_level -> thread level
char field_format; // data type for snprintf (typically 'd' or 's' char field_format; // data type for snprintf (typically 'd' or 's'
▲ Show 20 Lines • Show All 178 Lines • ▼ Show 20 Lines#endif
return rc; return rc;
} }
/* /*
* Return number of characters needed to hold the affinity string * Return number of characters needed to hold the affinity string
* (not including null byte character) * (not including null byte character)
* The resultant string is printed to buffer, which the caller can then * The resultant string is printed to buffer, which the caller can then
* handle afterwards * handle afterwards
*/ */
size_t __kmp_aux_capture_affinity(int gtid, const char *format, size_t __kmp_aux_capture_affinity(int gtid, const char *format,
kmp_str_buf_t *buffer) { kmp_str_buf_t *buffer) {
const char *parse_ptr; const char *parse_ptr;
size_t retval; size_t retval;
const kmp_info_t *th; const kmp_info_t *th;
kmp_str_buf_t field; kmp_str_buf_t field;
KMP_DEBUG_ASSERT(buffer); KMP_DEBUG_ASSERT(buffer);
▲ Show 20 Lines • Show All 398 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_sched.cpp

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesstatic void __kmp_for_static_init(ident_t *loc, kmp_int32 global_tid,
T *plower, T *pupper, T *plower, T *pupper,
typename traits_t<T>::signed_t *pstride, typename traits_t<T>::signed_t *pstride,
typename traits_t<T>::signed_t incr, typename traits_t<T>::signed_t incr,
typename traits_t<T>::signed_t chunk typename traits_t<T>::signed_t chunk
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
void *codeptr void *codeptr
#endif #endif
) { ) {
KMP_COUNT_BLOCK(OMP_LOOP_STATIC); KMP_COUNT_BLOCK(OMP_LOOP_STATIC);
KMP_PUSH_PARTITIONED_TIMER(OMP_loop_static); KMP_PUSH_PARTITIONED_TIMER(OMP_loop_static);
KMP_PUSH_PARTITIONED_TIMER(OMP_loop_static_scheduling); KMP_PUSH_PARTITIONED_TIMER(OMP_loop_static_scheduling);
typedef typename traits_t<T>::unsigned_t UT; typedef typename traits_t<T>::unsigned_t UT;
typedef typename traits_t<T>::signed_t ST; typedef typename traits_t<T>::signed_t ST;
/* this all has to be changed back to TID and such.. */ /* this all has to be changed back to TID and such.. */
kmp_int32 gtid = global_tid; kmp_int32 gtid = global_tid;
▲ Show 20 Lines • Show All 716 Lines • ▼ Show 20 Linesvoid __kmpc_for_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype,
kmp_int32 *pupper, kmp_int32 *pstride, kmp_int32 *pupper, kmp_int32 *pstride,
kmp_int32 incr, kmp_int32 chunk) { kmp_int32 incr, kmp_int32 chunk) {
__kmp_for_static_init<kmp_int32>(loc, gtid, schedtype, plastiter, plower, __kmp_for_static_init<kmp_int32>(loc, gtid, schedtype, plastiter, plower,
pupper, pstride, incr, chunk pupper, pstride, incr, chunk
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
OMPT_GET_RETURN_ADDRESS(0) OMPT_GET_RETURN_ADDRESS(0)
#endif #endif
); );
} }
/*! /*!
See @ref __kmpc_for_static_init_4 See @ref __kmpc_for_static_init_4
*/ */
void __kmpc_for_static_init_4u(ident_t *loc, kmp_int32 gtid, void __kmpc_for_static_init_4u(ident_t *loc, kmp_int32 gtid,
kmp_int32 schedtype, kmp_int32 *plastiter, kmp_int32 schedtype, kmp_int32 *plastiter,
kmp_uint32 *plower, kmp_uint32 *pupper, kmp_uint32 *plower, kmp_uint32 *pupper,
kmp_int32 *pstride, kmp_int32 incr, kmp_int32 *pstride, kmp_int32 incr,
kmp_int32 chunk) { kmp_int32 chunk) {
__kmp_for_static_init<kmp_uint32>(loc, gtid, schedtype, plastiter, plower, __kmp_for_static_init<kmp_uint32>(loc, gtid, schedtype, plastiter, plower,
pupper, pstride, incr, chunk pupper, pstride, incr, chunk
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
OMPT_GET_RETURN_ADDRESS(0) OMPT_GET_RETURN_ADDRESS(0)
#endif #endif
); );
} }
/*! /*!
See @ref __kmpc_for_static_init_4 See @ref __kmpc_for_static_init_4
*/ */
void __kmpc_for_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype, void __kmpc_for_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype,
kmp_int32 *plastiter, kmp_int64 *plower, kmp_int32 *plastiter, kmp_int64 *plower,
kmp_int64 *pupper, kmp_int64 *pstride, kmp_int64 *pupper, kmp_int64 *pstride,
kmp_int64 incr, kmp_int64 chunk) { kmp_int64 incr, kmp_int64 chunk) {
__kmp_for_static_init<kmp_int64>(loc, gtid, schedtype, plastiter, plower, __kmp_for_static_init<kmp_int64>(loc, gtid, schedtype, plastiter, plower,
pupper, pstride, incr, chunk pupper, pstride, incr, chunk
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
OMPT_GET_RETURN_ADDRESS(0) OMPT_GET_RETURN_ADDRESS(0)
#endif #endif
); );
} }
/*! /*!
See @ref __kmpc_for_static_init_4 See @ref __kmpc_for_static_init_4
*/ */
void __kmpc_for_static_init_8u(ident_t *loc, kmp_int32 gtid, void __kmpc_for_static_init_8u(ident_t *loc, kmp_int32 gtid,
kmp_int32 schedtype, kmp_int32 *plastiter, kmp_int32 schedtype, kmp_int32 *plastiter,
kmp_uint64 *plower, kmp_uint64 *pupper, kmp_uint64 *plower, kmp_uint64 *pupper,
kmp_int64 *pstride, kmp_int64 incr, kmp_int64 *pstride, kmp_int64 incr,
kmp_int64 chunk) { kmp_int64 chunk) {
__kmp_for_static_init<kmp_uint64>(loc, gtid, schedtype, plastiter, plower, __kmp_for_static_init<kmp_uint64>(loc, gtid, schedtype, plastiter, plower,
pupper, pstride, incr, chunk pupper, pstride, incr, chunk
#if OMPT_SUPPORT && OMPT_OPTIONAL #if OMPT_SUPPORT && OMPT_OPTIONAL
, ,
OMPT_GET_RETURN_ADDRESS(0) OMPT_GET_RETURN_ADDRESS(0)
#endif #endif
); );
} }
/*! /*!
@} @}
*/ */
/*! /*!
@ingroup WORK_SHARING @ingroup WORK_SHARING
@param loc Source code location @param loc Source code location
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_settings.cpp

Show First 20 Lines • Show All 217 Lines • ▼ Show 20 Lines if (ca >= 'a' && ca <= 'z')
ca -= 'a' - 'A'; ca -= 'a' - 'A';
if (cb >= 'a' && cb <= 'z') if (cb >= 'a' && cb <= 'z')
cb -= 'a' - 'A'; cb -= 'a' - 'A';
if (ca != cb) if (ca != cb)
return (int)(unsigned char)*a - (int)(unsigned char)*b; return (int)(unsigned char)*a - (int)(unsigned char)*b;
++a; ++a;
++b; ++b;
} }
return *a return *a ? (*b && *b != sentinel)
? (*b && *b != sentinel)
? (int)(unsigned char)*a - (int)(unsigned char)*b ? (int)(unsigned char)*a - (int)(unsigned char)*b
: 1 : 1
: (*b && *b != sentinel) ? -1 : 0; : (*b && *b != sentinel) ? -1
: 0;
} }
// ============================================================================= // =============================================================================
// Table structures and helper functions. // Table structures and helper functions.
typedef struct __kmp_setting kmp_setting_t; typedef struct __kmp_setting kmp_setting_t;
typedef struct __kmp_stg_ss_data kmp_stg_ss_data_t; typedef struct __kmp_stg_ss_data kmp_stg_ss_data_t;
typedef struct __kmp_stg_wp_data kmp_stg_wp_data_t; typedef struct __kmp_stg_wp_data kmp_stg_wp_data_t;
Show All 28 Linesstruct __kmp_stg_fr_data {
int force; // 0 -- KMP_DETERMINISTIC_REDUCTION, 1 -- KMP_FORCE_REDUCTION. int force; // 0 -- KMP_DETERMINISTIC_REDUCTION, 1 -- KMP_FORCE_REDUCTION.
kmp_setting_t **rivals; // Array of pointers to rivals (including itself). kmp_setting_t **rivals; // Array of pointers to rivals (including itself).
}; // struct __kmp_stg_fr_data }; // struct __kmp_stg_fr_data
static int __kmp_stg_check_rivals( // 0 -- Ok, 1 -- errors found. static int __kmp_stg_check_rivals( // 0 -- Ok, 1 -- errors found.
char const *name, // Name of variable. char const *name, // Name of variable.
char const *value, // Value of the variable. char const *value, // Value of the variable.
kmp_setting_t **rivals // List of rival settings (must include current one). kmp_setting_t **rivals // List of rival settings (must include current one).
); );
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// Helper parse functions. // Helper parse functions.
static void __kmp_stg_parse_bool(char const *name, char const *value, static void __kmp_stg_parse_bool(char const *name, char const *value,
int *out) { int *out) {
if (__kmp_str_match_true(value)) { if (__kmp_str_match_true(value)) {
*out = TRUE; *out = TRUE;
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
static void __kmp_stg_parse_int( static void __kmp_stg_parse_int(
char const char const
*name, // I: Name of environment variable (used in warning messages). *name, // I: Name of environment variable (used in warning messages).
char const *value, // I: Value of environment variable to parse. char const *value, // I: Value of environment variable to parse.
int min, // I: Minimum allowed value. int min, // I: Minimum allowed value.
int max, // I: Maximum allowed value. int max, // I: Maximum allowed value.
int *out // O: Output (parsed) value. int *out // O: Output (parsed) value.
) { ) {
char const *msg = NULL; char const *msg = NULL;
kmp_uint64 uint = *out; kmp_uint64 uint = *out;
__kmp_str_to_uint(value, &uint, &msg); __kmp_str_to_uint(value, &uint, &msg);
if (msg == NULL) { if (msg == NULL) {
if (uint < (unsigned int)min) { if (uint < (unsigned int)min) {
msg = KMP_I18N_STR(ValueTooSmall); msg = KMP_I18N_STR(ValueTooSmall);
uint = min; uint = min;
} else if (uint > (unsigned int)max) { } else if (uint > (unsigned int)max) {
▲ Show 20 Lines • Show All 526 Lines • ▼ Show 20 Lines
static void __kmp_stg_parse_stackpad(char const *name, char const *value, static void __kmp_stg_parse_stackpad(char const *name, char const *value,
void *data) { void *data) {
__kmp_stg_parse_int(name, // Env var name __kmp_stg_parse_int(name, // Env var name
value, // Env var value value, // Env var value
KMP_MIN_STKPADDING, // Min value KMP_MIN_STKPADDING, // Min value
KMP_MAX_STKPADDING, // Max value KMP_MAX_STKPADDING, // Max value
&__kmp_stkpadding // Var to initialize &__kmp_stkpadding // Var to initialize
); );
} // __kmp_stg_parse_stackpad } // __kmp_stg_parse_stackpad
static void __kmp_stg_print_stackpad(kmp_str_buf_t *buffer, char const *name, static void __kmp_stg_print_stackpad(kmp_str_buf_t *buffer, char const *name,
void *data) { void *data) {
__kmp_stg_print_int(buffer, name, __kmp_stkpadding); __kmp_stg_print_int(buffer, name, __kmp_stkpadding);
} // __kmp_stg_print_stackpad } // __kmp_stg_print_stackpad
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
▲ Show 20 Lines • Show All 1,497 Lines • ▼ Show 20 Lines if (count > 0) {
KMP_WARNING(AffNoParam, name, "disabled"); KMP_WARNING(AffNoParam, name, "disabled");
} }
} break; } break;
case affinity_default: { case affinity_default: {
if (count > 0) { if (count > 0) {
KMP_WARNING(AffNoParam, name, "default"); KMP_WARNING(AffNoParam, name, "default");
} }
} break; } break;
default: { KMP_ASSERT(0); } default: {
KMP_ASSERT(0);
}
} }
} // __kmp_parse_affinity_env } // __kmp_parse_affinity_env
static void __kmp_stg_parse_affinity(char const *name, char const *value, static void __kmp_stg_parse_affinity(char const *name, char const *value,
void *data) { void *data) {
kmp_setting_t **rivals = (kmp_setting_t **)data; kmp_setting_t **rivals = (kmp_setting_t **)data;
int rc; int rc;
▲ Show 20 Lines • Show All 2,259 Lines • ▼ Show 20 Lines __kmp_str_buf_print(buffer, "%d,%d'\n",
__kmp_adaptive_backoff_params.max_badness); __kmp_adaptive_backoff_params.max_badness);
} // __kmp_stg_print_adaptive_lock_props } // __kmp_stg_print_adaptive_lock_props
#if KMP_DEBUG_ADAPTIVE_LOCKS #if KMP_DEBUG_ADAPTIVE_LOCKS
static void __kmp_stg_parse_speculative_statsfile(char const *name, static void __kmp_stg_parse_speculative_statsfile(char const *name,
char const *value, char const *value,
void *data) { void *data) {
__kmp_stg_parse_file(name, value, "", CCAST(char**, &__kmp_speculative_statsfile)); __kmp_stg_parse_file(name, value, "",
CCAST(char **, &__kmp_speculative_statsfile));
} // __kmp_stg_parse_speculative_statsfile } // __kmp_stg_parse_speculative_statsfile
static void __kmp_stg_print_speculative_statsfile(kmp_str_buf_t *buffer, static void __kmp_stg_print_speculative_statsfile(kmp_str_buf_t *buffer,
char const *name, char const *name,
void *data) { void *data) {
if (__kmp_str_match("-", 0, __kmp_speculative_statsfile)) { if (__kmp_str_match("-", 0, __kmp_speculative_statsfile)) {
__kmp_stg_print_str(buffer, name, "stdout"); __kmp_stg_print_str(buffer, name, "stdout");
} else { } else {
▲ Show 20 Lines • Show All 231 Lines • ▼ Show 20 Linesstatic void __kmp_stg_print_forkjoin_frames_mode(kmp_str_buf_t *buffer,
char const *name, void *data) { char const *name, void *data) {
__kmp_stg_print_int(buffer, name, __kmp_forkjoin_frames_mode); __kmp_stg_print_int(buffer, name, __kmp_forkjoin_frames_mode);
} // __kmp_stg_print_forkjoin_frames } // __kmp_stg_print_forkjoin_frames
#endif /* USE_ITT_BUILD */ #endif /* USE_ITT_BUILD */
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// KMP_ENABLE_TASK_THROTTLING // KMP_ENABLE_TASK_THROTTLING
static void __kmp_stg_parse_task_throttling(char const *name, static void __kmp_stg_parse_task_throttling(char const *name, char const *value,
char const *value, void *data) { void *data) {
__kmp_stg_parse_bool(name, value, &__kmp_enable_task_throttling); __kmp_stg_parse_bool(name, value, &__kmp_enable_task_throttling);
} // __kmp_stg_parse_task_throttling } // __kmp_stg_parse_task_throttling
static void __kmp_stg_print_task_throttling(kmp_str_buf_t *buffer, static void __kmp_stg_print_task_throttling(kmp_str_buf_t *buffer,
char const *name, void *data) { char const *name, void *data) {
__kmp_stg_print_bool(buffer, name, __kmp_enable_task_throttling); __kmp_stg_print_bool(buffer, name, __kmp_enable_task_throttling);
} // __kmp_stg_print_task_throttling } // __kmp_stg_print_task_throttling
#if KMP_HAVE_MWAIT || KMP_HAVE_UMWAIT #if KMP_HAVE_MWAIT || KMP_HAVE_UMWAIT
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// KMP_USER_LEVEL_MWAIT // KMP_USER_LEVEL_MWAIT
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines else {
} }
__kmp_str_buf_print(buffer, ": %s\n", KMP_I18N_STR(NotDefined)); __kmp_str_buf_print(buffer, ": %s\n", KMP_I18N_STR(NotDefined));
} }
} // __kmp_stg_print_omp_tool_libraries } // __kmp_stg_print_omp_tool_libraries
static char *__kmp_tool_verbose_init = NULL; static char *__kmp_tool_verbose_init = NULL;
static void __kmp_stg_parse_omp_tool_verbose_init(char const *name, static void __kmp_stg_parse_omp_tool_verbose_init(char const *name,
char const *value, void *data) { char const *value,
void *data) {
__kmp_stg_parse_str(name, value, &__kmp_tool_verbose_init); __kmp_stg_parse_str(name, value, &__kmp_tool_verbose_init);
} // __kmp_stg_parse_omp_tool_libraries } // __kmp_stg_parse_omp_tool_libraries
static void __kmp_stg_print_omp_tool_verbose_init(kmp_str_buf_t *buffer, static void __kmp_stg_print_omp_tool_verbose_init(kmp_str_buf_t *buffer,
char const *name, void *data) { char const *name,
void *data) {
if (__kmp_tool_verbose_init) if (__kmp_tool_verbose_init)
__kmp_stg_print_str(buffer, name, __kmp_tool_libraries); __kmp_stg_print_str(buffer, name, __kmp_tool_libraries);
else { else {
if (__kmp_env_format) { if (__kmp_env_format) {
KMP_STR_BUF_PRINT_NAME; KMP_STR_BUF_PRINT_NAME;
} else { } else {
__kmp_str_buf_print(buffer, " %s", name); __kmp_str_buf_print(buffer, " %s", name);
} }
▲ Show 20 Lines • Show All 517 Lines • ▼ Show 20 Linesstatic void __kmp_stg_parse(char const *name, char const *value) {
} }
} // __kmp_stg_parse } // __kmp_stg_parse
static int __kmp_stg_check_rivals( // 0 -- Ok, 1 -- errors found. static int __kmp_stg_check_rivals( // 0 -- Ok, 1 -- errors found.
char const *name, // Name of variable. char const *name, // Name of variable.
char const *value, // Value of the variable. char const *value, // Value of the variable.
kmp_setting_t **rivals // List of rival settings (must include current one). kmp_setting_t **rivals // List of rival settings (must include current one).
) { ) {
if (rivals == NULL) { if (rivals == NULL) {
return 0; return 0;
} }
// Loop thru higher priority settings (listed before current). // Loop thru higher priority settings (listed before current).
int i = 0; int i = 0;
for (; strcmp(rivals[i]->name, name) != 0; i++) { for (; strcmp(rivals[i]->name, name) != 0; i++) {
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines#if KMP_AFFINITY_SUPPORTED
// Special case. KMP_AFFINITY is not a rival to other affinity env vars // Special case. KMP_AFFINITY is not a rival to other affinity env vars
// if no affinity type is specified. We want to allow // if no affinity type is specified. We want to allow
// KMP_AFFINITY=[no],verbose/[no]warnings/etc. to be enabled when // KMP_AFFINITY=[no],verbose/[no]warnings/etc. to be enabled when
// specifying the affinity type via GOMP_CPU_AFFINITY or the OMP 4.0 // specifying the affinity type via GOMP_CPU_AFFINITY or the OMP 4.0
// affinity mechanism. // affinity mechanism.
__kmp_affinity_notype = NULL; __kmp_affinity_notype = NULL;
char const *aff_str = __kmp_env_blk_var(&block, "KMP_AFFINITY"); char const *aff_str = __kmp_env_blk_var(&block, "KMP_AFFINITY");
if (aff_str != NULL) { if (aff_str != NULL) {
// Check if the KMP_AFFINITY type is specified in the string. // Check if the KMP_AFFINITY type is specified in the string.
// We just search the string for "compact", "scatter", etc. // We just search the string for "compact", "scatter", etc.
// without really parsing the string. The syntax of the // without really parsing the string. The syntax of the
// KMP_AFFINITY env var is such that none of the affinity // KMP_AFFINITY env var is such that none of the affinity
// type names can appear anywhere other that the type // type names can appear anywhere other that the type
// specifier, even as substrings. // specifier, even as substrings.
// //
// I can't find a case-insensitive version of strstr on Windows* OS. // I can't find a case-insensitive version of strstr on Windows* OS.
// Use the case-sensitive version for now. // Use the case-sensitive version for now.
#if KMP_OS_WINDOWS #if KMP_OS_WINDOWS
#define FIND strstr #define FIND strstr
#else #else
#define FIND strcasestr #define FIND strcasestr
#endif #endif
if ((FIND(aff_str, "none") == NULL) && if ((FIND(aff_str, "none") == NULL) &&
▲ Show 20 Lines • Show All 354 Lines • ▼ Show 20 Linesvoid __kmp_env_print() {
for (i = 0; i < block.count; ++i) { for (i = 0; i < block.count; ++i) {
char const *name = block.vars[i].name; char const *name = block.vars[i].name;
char const *value = block.vars[i].value; char const *value = block.vars[i].value;
if ((KMP_STRLEN(name) > 4 && strncmp(name, "KMP_", 4) == 0) || if ((KMP_STRLEN(name) > 4 && strncmp(name, "KMP_", 4) == 0) ||
strncmp(name, "OMP_", 4) == 0 strncmp(name, "OMP_", 4) == 0
#ifdef KMP_GOMP_COMPAT #ifdef KMP_GOMP_COMPAT
|| strncmp(name, "GOMP_", 5) == 0 || strncmp(name, "GOMP_", 5) == 0
#endif // KMP_GOMP_COMPAT #endif // KMP_GOMP_COMPAT
) { ) {
__kmp_str_buf_print(&buffer, " %s=%s\n", name, value); __kmp_str_buf_print(&buffer, " %s=%s\n", name, value);
} }
} }
__kmp_str_buf_print(&buffer, "\n"); __kmp_str_buf_print(&buffer, "\n");
// Print internal (effective) settings. // Print internal (effective) settings.
__kmp_str_buf_print(&buffer, "%s\n\n", KMP_I18N_STR(EffectiveSettings)); __kmp_str_buf_print(&buffer, "%s\n\n", KMP_I18N_STR(EffectiveSettings));
for (int i = 0; i < __kmp_stg_count; ++i) { for (int i = 0; i < __kmp_stg_count; ++i) {
Show All 11 Lines#endif // KMP_GOMP_COMPAT
__kmp_printf("\n"); __kmp_printf("\n");
} // __kmp_env_print } // __kmp_env_print
void __kmp_env_print_2() { void __kmp_env_print_2() {
__kmp_display_env_impl(__kmp_display_env, __kmp_display_env_verbose); __kmp_display_env_impl(__kmp_display_env, __kmp_display_env_verbose);
} // __kmp_env_print_2 } // __kmp_env_print_2
void __kmp_display_env_impl(int display_env, int display_env_verbose) { void __kmp_display_env_impl(int display_env, int display_env_verbose) {
kmp_env_blk_t block; kmp_env_blk_t block;
kmp_str_buf_t buffer; kmp_str_buf_t buffer;
__kmp_env_format = 1; __kmp_env_format = 1;
__kmp_stg_init(); __kmp_stg_init();
__kmp_str_buf_init(&buffer); __kmp_str_buf_init(&buffer);
__kmp_env_blk_init(&block, NULL); __kmp_env_blk_init(&block, NULL);
__kmp_env_blk_sort(&block); __kmp_env_blk_sort(&block);
__kmp_str_buf_print(&buffer, "\n%s\n", KMP_I18N_STR(DisplayEnvBegin)); __kmp_str_buf_print(&buffer, "\n%s\n", KMP_I18N_STR(DisplayEnvBegin));
__kmp_str_buf_print(&buffer, " _OPENMP='%d'\n", __kmp_openmp_version); __kmp_str_buf_print(&buffer, " _OPENMP='%d'\n", __kmp_openmp_version);
for (int i = 0; i < __kmp_stg_count; ++i) { for (int i = 0; i < __kmp_stg_count; ++i) {
if (__kmp_stg_table[i].print != NULL && if (__kmp_stg_table[i].print != NULL &&
((display_env && ((display_env && strncmp(__kmp_stg_table[i].name, "OMP_", 4) == 0) ||
strncmp(__kmp_stg_table[i].name, "OMP_", 4) == 0) ||
display_env_verbose)) { display_env_verbose)) {
__kmp_stg_table[i].print(&buffer, __kmp_stg_table[i].name, __kmp_stg_table[i].print(&buffer, __kmp_stg_table[i].name,
__kmp_stg_table[i].data); __kmp_stg_table[i].data);
} }
} }
__kmp_str_buf_print(&buffer, "%s\n", KMP_I18N_STR(DisplayEnvEnd)); __kmp_str_buf_print(&buffer, "%s\n", KMP_I18N_STR(DisplayEnvEnd));
__kmp_str_buf_print(&buffer, "\n"); __kmp_str_buf_print(&buffer, "\n");
Show All 10 Lines

openmp/runtime/src/kmp_stats.h

Show First 20 Lines • Show All 283 Lines • ▼ Show 20 Lines
* \details Explicit timers are ones where we need to allocate a timer itself * \details Explicit timers are ones where we need to allocate a timer itself
* (as well as the accumulated timing statistics). We allocate these on a * (as well as the accumulated timing statistics). We allocate these on a
* per-thread basis, and explicitly start and stop them. Block timers just * per-thread basis, and explicitly start and stop them. Block timers just
* allocate the timer itself on the stack, and use the destructor to notice * allocate the timer itself on the stack, and use the destructor to notice
* block exit; they don't need to be defined here. The name here should be the * block exit; they don't need to be defined here. The name here should be the
* same as that of a timer above. * same as that of a timer above.
* *
* @ingroup STATS_GATHERING * @ingroup STATS_GATHERING
*/ */
#define KMP_FOREACH_EXPLICIT_TIMER(macro, arg) KMP_FOREACH_TIMER(macro, arg) #define KMP_FOREACH_EXPLICIT_TIMER(macro, arg) KMP_FOREACH_TIMER(macro, arg)
#define ENUMERATE(name, ignore, prefix) prefix##name, #define ENUMERATE(name, ignore, prefix) prefix##name,
enum timer_e { KMP_FOREACH_TIMER(ENUMERATE, TIMER_) TIMER_LAST }; enum timer_e { KMP_FOREACH_TIMER(ENUMERATE, TIMER_) TIMER_LAST };
enum explicit_timer_e { enum explicit_timer_e {
KMP_FOREACH_EXPLICIT_TIMER(ENUMERATE, EXPLICIT_TIMER_) EXPLICIT_TIMER_LAST KMP_FOREACH_EXPLICIT_TIMER(ENUMERATE, EXPLICIT_TIMER_) EXPLICIT_TIMER_LAST
}; };
▲ Show 20 Lines • Show All 578 Lines • ▼ Show 20 Lines
* *
* @param name timer name as specified under the KMP_FOREACH_TIMER() macro * @param name timer name as specified under the KMP_FOREACH_TIMER() macro
* @param value double precision sample value to add to statistics for the timer * @param value double precision sample value to add to statistics for the timer
* *
* \details Use KMP_COUNT_VALUE(name, value) macro to add a particular value to * \details Use KMP_COUNT_VALUE(name, value) macro to add a particular value to
* a timer statistics. * a timer statistics.
* *
* @ingroup STATS_GATHERING * @ingroup STATS_GATHERING
*/ */
#define KMP_COUNT_VALUE(name, value) \ #define KMP_COUNT_VALUE(name, value) \
__kmp_stats_thread_ptr->getTimer(TIMER_##name)->addSample((double)value) __kmp_stats_thread_ptr->getTimer(TIMER_##name)->addSample((double)value)
/*! /*!
* \brief Increments specified counter (name). * \brief Increments specified counter (name).
* *
* @param name counter name as specified under the KMP_FOREACH_COUNTER() macro * @param name counter name as specified under the KMP_FOREACH_COUNTER() macro
* *
* \details Use KMP_COUNT_BLOCK(name, value) macro to increment a statistics * \details Use KMP_COUNT_BLOCK(name, value) macro to increment a statistics
* counter for the executing thread. * counter for the executing thread.
* *
* @ingroup STATS_GATHERING * @ingroup STATS_GATHERING
*/ */
#define KMP_COUNT_BLOCK(name) \ #define KMP_COUNT_BLOCK(name) \
__kmp_stats_thread_ptr->getCounter(COUNTER_##name)->increment() __kmp_stats_thread_ptr->getCounter(COUNTER_##name)->increment()
/*! /*!
* \brief Outputs the current thread statistics and reset them. * \brief Outputs the current thread statistics and reset them.
* *
* @param heading_string heading put above the final stats output * @param heading_string heading put above the final stats output
* *
* \details Explicitly stops all timers and outputs all stats. Environment * \details Explicitly stops all timers and outputs all stats. Environment
* variable, `OMPTB_STATSFILE=filename`, can be used to output the stats to a * variable, `OMPTB_STATSFILE=filename`, can be used to output the stats to a
* filename instead of stderr. Environment variable, * filename instead of stderr. Environment variable,
* `OMPTB_STATSTHREADS=true|undefined`, can be used to output thread specific * `OMPTB_STATSTHREADS=true|undefined`, can be used to output thread specific
* stats. For now the `OMPTB_STATSTHREADS` environment variable can either be * stats. For now the `OMPTB_STATSTHREADS` environment variable can either be
* defined with any value, which will print out thread specific stats, or it can * defined with any value, which will print out thread specific stats, or it can
* be undefined (not specified in the environment) and thread specific stats * be undefined (not specified in the environment) and thread specific stats
* won't be printed. It should be noted that all statistics are reset when this * won't be printed. It should be noted that all statistics are reset when this
* macro is called. * macro is called.
* *
* @ingroup STATS_GATHERING * @ingroup STATS_GATHERING
*/ */
#define KMP_OUTPUT_STATS(heading_string) __kmp_output_stats(heading_string) #define KMP_OUTPUT_STATS(heading_string) __kmp_output_stats(heading_string)
/*! /*!
* \brief Initializes the partitioned timers to begin with name. * \brief Initializes the partitioned timers to begin with name.
* *
* @param name timer which you want this thread to begin with * @param name timer which you want this thread to begin with
* *
* @ingroup STATS_GATHERING * @ingroup STATS_GATHERING
*/ */
#define KMP_INIT_PARTITIONED_TIMERS(name) \ #define KMP_INIT_PARTITIONED_TIMERS(name) \
__kmp_stats_thread_ptr->getPartitionedTimers()->init(explicitTimer( \ __kmp_stats_thread_ptr->getPartitionedTimers()->init(explicitTimer( \
__kmp_stats_thread_ptr->getTimer(TIMER_##name), TIMER_##name)) __kmp_stats_thread_ptr->getTimer(TIMER_##name), TIMER_##name))
#define KMP_TIME_PARTITIONED_BLOCK(name) \ #define KMP_TIME_PARTITIONED_BLOCK(name) \
blockPartitionedTimer __PBLOCKTIME__( \ blockPartitionedTimer __PBLOCKTIME__( \
__kmp_stats_thread_ptr->getPartitionedTimers(), \ __kmp_stats_thread_ptr->getPartitionedTimers(), \
explicitTimer(__kmp_stats_thread_ptr->getTimer(TIMER_##name), \ explicitTimer(__kmp_stats_thread_ptr->getTimer(TIMER_##name), \
Show All 20 Lines blockThreadState __BTHREADSTATE__(__kmp_stats_thread_ptr->getStatePointer(), \
state_name) state_name)
/*! /*!
* \brief resets all stats (counters to 0, timers to 0 elapsed ticks) * \brief resets all stats (counters to 0, timers to 0 elapsed ticks)
* *
* \details Reset all stats for all threads. * \details Reset all stats for all threads.
* *
* @ingroup STATS_GATHERING * @ingroup STATS_GATHERING
*/ */
#define KMP_RESET_STATS() __kmp_reset_stats() #define KMP_RESET_STATS() __kmp_reset_stats()
#if (KMP_DEVELOPER_STATS) #if (KMP_DEVELOPER_STATS)
#define KMP_COUNT_DEVELOPER_VALUE(n, v) KMP_COUNT_VALUE(n, v) #define KMP_COUNT_DEVELOPER_VALUE(n, v) KMP_COUNT_VALUE(n, v)
#define KMP_COUNT_DEVELOPER_BLOCK(n) KMP_COUNT_BLOCK(n) #define KMP_COUNT_DEVELOPER_BLOCK(n) KMP_COUNT_BLOCK(n)
#define KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(n) KMP_TIME_PARTITIONED_BLOCK(n) #define KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(n) KMP_TIME_PARTITIONED_BLOCK(n)
#define KMP_PUSH_DEVELOPER_PARTITIONED_TIMER(n) KMP_PUSH_PARTITIONED_TIMER(n) #define KMP_PUSH_DEVELOPER_PARTITIONED_TIMER(n) KMP_PUSH_PARTITIONED_TIMER(n)
#define KMP_POP_DEVELOPER_PARTITIONED_TIMER(n) KMP_POP_PARTITIONED_TIMER(n) #define KMP_POP_DEVELOPER_PARTITIONED_TIMER(n) KMP_POP_PARTITIONED_TIMER(n)
Show All 37 Lines

openmp/runtime/src/kmp_stats.cpp

Show First 20 Lines • Show All 694 Lines • ▼ Show 20 Lines
void kmp_stats_output_module::printPloticusFile() { void kmp_stats_output_module::printPloticusFile() {
int i; int i;
int size = __kmp_stats_list->size(); int size = __kmp_stats_list->size();
kmp_safe_raii_file_t plotOut(plotFileName, "w+"); kmp_safe_raii_file_t plotOut(plotFileName, "w+");
fprintf(plotOut, "#proc page\n" fprintf(plotOut, "#proc page\n"
" pagesize: 15 10\n" " pagesize: 15 10\n"
" scale: 1.0\n\n"); " scale: 1.0\n\n");
fprintf(plotOut, "#proc getdata\n" fprintf(plotOut,
"#proc getdata\n"
" file: %s\n\n", " file: %s\n\n",
eventsFileName); eventsFileName);
fprintf(plotOut, "#proc areadef\n" fprintf(plotOut,
"#proc areadef\n"
" title: OpenMP Sampling Timeline\n" " title: OpenMP Sampling Timeline\n"
" titledetails: align=center size=16\n" " titledetails: align=center size=16\n"
" rectangle: 1 1 13 9\n" " rectangle: 1 1 13 9\n"
" xautorange: datafield=2,3\n" " xautorange: datafield=2,3\n"
" yautorange: -1 %d\n\n", " yautorange: -1 %d\n\n",
size); size);
fprintf(plotOut, "#proc xaxis\n" fprintf(plotOut, "#proc xaxis\n"
" stubs: inc\n" " stubs: inc\n"
" stubdetails: size=12\n" " stubdetails: size=12\n"
" label: Time (ticks)\n" " label: Time (ticks)\n"
" labeldetails: size=14\n\n"); " labeldetails: size=14\n\n");
fprintf(plotOut, "#proc yaxis\n" fprintf(plotOut,
"#proc yaxis\n"
" stubs: inc 1\n" " stubs: inc 1\n"
" stubrange: 0 %d\n" " stubrange: 0 %d\n"
" stubdetails: size=12\n" " stubdetails: size=12\n"
" label: Thread #\n" " label: Thread #\n"
" labeldetails: size=14\n\n", " labeldetails: size=14\n\n",
size - 1); size - 1);
fprintf(plotOut, "#proc bars\n" fprintf(plotOut, "#proc bars\n"
" exactcolorfield: 5\n" " exactcolorfield: 5\n"
" axis: x\n" " axis: x\n"
" locfield: 1\n" " locfield: 1\n"
" segmentfields: 2 3\n" " segmentfields: 2 3\n"
" barwidthfield: 4\n\n"); " barwidthfield: 4\n\n");
// create legend entries corresponding to the timer color // create legend entries corresponding to the timer color
for (i = 0; i < TIMER_LAST; i++) { for (i = 0; i < TIMER_LAST; i++) {
if (timeStat::logEvent((timer_e)i)) { if (timeStat::logEvent((timer_e)i)) {
rgb_color c = getEventColor((timer_e)i); rgb_color c = getEventColor((timer_e)i);
fprintf(plotOut, "#proc legendentry\n" fprintf(plotOut,
"#proc legendentry\n"
" sampletype: color\n" " sampletype: color\n"
" label: %s\n" " label: %s\n"
" details: rgb(%1.1f,%1.1f,%1.1f)\n\n", " details: rgb(%1.1f,%1.1f,%1.1f)\n\n",
timeStat::name((timer_e)i), c.r, c.g, c.b); timeStat::name((timer_e)i), c.r, c.g, c.b);
} }
} }
fprintf(plotOut, "#proc legend\n" fprintf(plotOut, "#proc legend\n"
" format: down\n" " format: down\n"
" location: max max\n\n"); " location: max max\n\n");
return; return;
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines if (eventPrintingEnabled()) {
kmp_stats_event_vector events = (*it)->getEventVector(); kmp_stats_event_vector events = (*it)->getEventVector();
printEvents(eventsOut, &events, t); printEvents(eventsOut, &events, t);
} }
// Accumulate timers. // Accumulate timers.
for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) { for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
// See if we should ignore this timer when aggregating // See if we should ignore this timer when aggregating
if ((timeStat::masterOnly(s) && (t != 0)) || // Timer only valid on master if ((timeStat::masterOnly(s) && (t != 0)) || // Timer only valid on master
// and this thread is worker // and this thread is worker
(timeStat::workerOnly(s) && (t == 0)) // Timer only valid on worker (timeStat::workerOnly(s) && (t == 0)) // Timer only valid on worker
// and this thread is the master // and this thread is the master
) { ) {
continue; continue;
} }
statistic *threadStat = (*it)->getTimer(s); statistic *threadStat = (*it)->getTimer(s);
allStats[s] += *threadStat; allStats[s] += *threadStat;
// Add Total stats for timers that are valid in more than one thread // Add Total stats for timers that are valid in more than one thread
if (!timeStat::noTotal(s)) if (!timeStat::noTotal(s))
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_str.cpp

Show First 20 Lines • Show All 163 Lines • ▼ Show 20 Linesint __kmp_str_buf_vprint(kmp_str_buf_t *buffer, char const *format,
KMP_STR_BUF_INVARIANT(buffer); KMP_STR_BUF_INVARIANT(buffer);
for (;;) { for (;;) {
int const free = buffer->size - buffer->used; int const free = buffer->size - buffer->used;
int size; int size;
// Try to format string. // Try to format string.
{ {
/* On Linux* OS Intel(R) 64, vsnprintf() modifies args argument, so vsnprintf() /* On Linux* OS Intel(R) 64, vsnprintf() modifies args argument, so
crashes if it is called for the second time with the same args. To prevent vsnprintf() crashes if it is called for the second time with the same
the crash, we have to pass a fresh intact copy of args to vsnprintf() on each args. To prevent the crash, we have to pass a fresh intact copy of args
iteration. to vsnprintf() on each iteration.
Unfortunately, standard va_copy() macro is not available on Windows* OS. Unfortunately, standard va_copy() macro is not available on Windows*
However, it seems vsnprintf() does not modify args argument on Windows* OS. OS. However, it seems vsnprintf() does not modify args argument on
Windows* OS.
*/ */
#if !KMP_OS_WINDOWS #if !KMP_OS_WINDOWS
va_list _args; va_list _args;
va_copy(_args, args); // Make copy of args. va_copy(_args, args); // Make copy of args.
#define args _args // Substitute args with its copy, _args. #define args _args // Substitute args with its copy, _args.
#endif // KMP_OS_WINDOWS #endif // KMP_OS_WINDOWS
rc = KMP_VSNPRINTF(buffer->str + buffer->used, free, format, args); rc = KMP_VSNPRINTF(buffer->str + buffer->used, free, format, args);
#if !KMP_OS_WINDOWS #if !KMP_OS_WINDOWS
▲ Show 20 Lines • Show All 210 Lines • ▼ Show 20 Lines
/* This function is intended to compare file names. On Windows* OS file names /* This function is intended to compare file names. On Windows* OS file names
are case-insensitive, so functions performs case-insensitive comparison. On are case-insensitive, so functions performs case-insensitive comparison. On
Linux* OS it performs case-sensitive comparison. Note: The function returns Linux* OS it performs case-sensitive comparison. Note: The function returns
*true* if strings are *equal*. */ *true* if strings are *equal*. */
int __kmp_str_eqf( // True, if strings are equal, false otherwise. int __kmp_str_eqf( // True, if strings are equal, false otherwise.
char const *lhs, // First string. char const *lhs, // First string.
char const *rhs // Second string. char const *rhs // Second string.
) { ) {
int result; int result;
#if KMP_OS_WINDOWS #if KMP_OS_WINDOWS
result = (_stricmp(lhs, rhs) == 0); result = (_stricmp(lhs, rhs) == 0);
#else #else
result = (strcmp(lhs, rhs) == 0); result = (strcmp(lhs, rhs) == 0);
#endif #endif
return result; return result;
} // __kmp_str_eqf } // __kmp_str_eqf
Show All 27 Lines 2. __kmp_thread_malloc() cannot be used because it requires pointer to thread
(for example, in __kmp_register_library_startup()) when no thread (for example, in __kmp_register_library_startup()) when no thread
structures are allocated yet. structures are allocated yet.
So standard malloc() is the only available option. So standard malloc() is the only available option.
*/ */
char *__kmp_str_format( // Allocated string. char *__kmp_str_format( // Allocated string.
char const *format, // Format string. char const *format, // Format string.
... // Other parameters. ... // Other parameters.
) { ) {
va_list args; va_list args;
int size = 512; int size = 512;
char *buffer = NULL; char *buffer = NULL;
int rc; int rc;
// Allocate buffer. // Allocate buffer.
buffer = (char *)KMP_INTERNAL_MALLOC(size); buffer = (char *)KMP_INTERNAL_MALLOC(size);
if (buffer == NULL) { if (buffer == NULL) {
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines while (found) {
found = strchr(found + 1, search_for); found = strchr(found + 1, search_for);
} }
} // __kmp_str_replace } // __kmp_str_replace
void __kmp_str_split(char *str, // I: String to split. void __kmp_str_split(char *str, // I: String to split.
char delim, // I: Character to split on. char delim, // I: Character to split on.
char **head, // O: Pointer to head (may be NULL). char **head, // O: Pointer to head (may be NULL).
char **tail // O: Pointer to tail (may be NULL). char **tail // O: Pointer to tail (may be NULL).
) { ) {
char *h = str; char *h = str;
char *t = NULL; char *t = NULL;
if (str != NULL) { if (str != NULL) {
char *ptr = strchr(str, delim); char *ptr = strchr(str, delim);
if (ptr != NULL) { if (ptr != NULL) {
*ptr = 0; *ptr = 0;
t = ptr + 1; t = ptr + 1;
} }
} }
if (head != NULL) { if (head != NULL) {
*head = h; *head = h;
} }
if (tail != NULL) { if (tail != NULL) {
*tail = t; *tail = t;
} }
} // __kmp_str_split } // __kmp_str_split
/* strtok_r() is not available on Windows* OS. This function reimplements /* strtok_r() is not available on Windows* OS. This function reimplements
strtok_r(). */ strtok_r(). */
char *__kmp_str_token( char *__kmp_str_token(
char *str, // String to split into tokens. Note: String *is* modified! char *str, // String to split into tokens. Note: String *is* modified!
char const *delim, // Delimiters. char const *delim, // Delimiters.
char **buf // Internal buffer. char **buf // Internal buffer.
) { ) {
char *token = NULL; char *token = NULL;
#if KMP_OS_WINDOWS #if KMP_OS_WINDOWS
// On Windows* OS there is no strtok_r() function. Let us implement it. // On Windows* OS there is no strtok_r() function. Let us implement it.
if (str != NULL) { if (str != NULL) {
*buf = str; // First call, initialize buf. *buf = str; // First call, initialize buf.
} }
*buf += strspn(*buf, delim); // Skip leading delimiters. *buf += strspn(*buf, delim); // Skip leading delimiters.
if (**buf != 0) { // Rest of the string is not yet empty. if (**buf != 0) { // Rest of the string is not yet empty.
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines/* The routine parses input string. It is expected it is a unsigned integer with
value. In case of overflow *size is set to KMP_SIZE_T_MAX, in case of unknown value. In case of overflow *size is set to KMP_SIZE_T_MAX, in case of unknown
unit *size is set to zero. */ unit *size is set to zero. */
void __kmp_str_to_size( // R: Error code. void __kmp_str_to_size( // R: Error code.
char const *str, // I: String of characters, unsigned number and unit ("b", char const *str, // I: String of characters, unsigned number and unit ("b",
// "kb", etc). // "kb", etc).
size_t *out, // O: Parsed number. size_t *out, // O: Parsed number.
size_t dfactor, // I: The factor if none of the letters specified. size_t dfactor, // I: The factor if none of the letters specified.
char const **error // O: Null if everything is ok, error message otherwise. char const **error // O: Null if everything is ok, error message otherwise.
) { ) {
size_t value = 0; size_t value = 0;
size_t factor = 0; size_t factor = 0;
int overflow = 0; int overflow = 0;
int i = 0; int i = 0;
int digit; int digit;
KMP_DEBUG_ASSERT(str != NULL); KMP_DEBUG_ASSERT(str != NULL);
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines#undef _case
*error = NULL; *error = NULL;
*out = value; *out = value;
} // __kmp_str_to_size } // __kmp_str_to_size
void __kmp_str_to_uint( // R: Error code. void __kmp_str_to_uint( // R: Error code.
char const *str, // I: String of characters, unsigned number. char const *str, // I: String of characters, unsigned number.
kmp_uint64 *out, // O: Parsed number. kmp_uint64 *out, // O: Parsed number.
char const **error // O: Null if everything is ok, error message otherwise. char const **error // O: Null if everything is ok, error message otherwise.
) { ) {
size_t value = 0; size_t value = 0;
int overflow = 0; int overflow = 0;
int i = 0; int i = 0;
int digit; int digit;
KMP_DEBUG_ASSERT(str != NULL); KMP_DEBUG_ASSERT(str != NULL);
// Skip spaces. // Skip spaces.
Show All 37 Lines

openmp/runtime/src/kmp_taskdeps.h

/* /*
* kmp_taskdeps.h * kmp_taskdeps.h
*/ */
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef KMP_TASKDEPS_H #ifndef KMP_TASKDEPS_H
#define KMP_TASKDEPS_H #define KMP_TASKDEPS_H
#include "kmp.h" #include "kmp.h"
#define KMP_ACQUIRE_DEPNODE(gtid, n) __kmp_acquire_lock(&(n)->dn.lock, (gtid)) #define KMP_ACQUIRE_DEPNODE(gtid, n) __kmp_acquire_lock(&(n)->dn.lock, (gtid))
#define KMP_RELEASE_DEPNODE(gtid, n) __kmp_release_lock(&(n)->dn.lock, (gtid)) #define KMP_RELEASE_DEPNODE(gtid, n) __kmp_release_lock(&(n)->dn.lock, (gtid))
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_taskdeps.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
static inline kmp_depnode_t *__kmp_node_ref(kmp_depnode_t *node) { static inline kmp_depnode_t *__kmp_node_ref(kmp_depnode_t *node) {
KMP_ATOMIC_INC(&node->dn.nrefs); KMP_ATOMIC_INC(&node->dn.nrefs);
return node; return node;
} }
enum { KMP_DEPHASH_OTHER_SIZE = 97, KMP_DEPHASH_MASTER_SIZE = 997 }; enum { KMP_DEPHASH_OTHER_SIZE = 97, KMP_DEPHASH_MASTER_SIZE = 997 };
size_t sizes[] = { 997, 2003, 4001, 8191, 16001, 32003, 64007, 131071, 270029 }; size_t sizes[] = {997, 2003, 4001, 8191, 16001, 32003, 64007, 131071, 270029};
const size_t MAX_GEN = 8; const size_t MAX_GEN = 8;
static inline size_t __kmp_dephash_hash(kmp_intptr_t addr, size_t hsize) { static inline size_t __kmp_dephash_hash(kmp_intptr_t addr, size_t hsize) {
// TODO alternate to try: set = (((Addr64)(addrUsefulBits * 9.618)) % // TODO alternate to try: set = (((Addr64)(addrUsefulBits * 9.618)) %
// m_num_sets ); // m_num_sets );
return ((addr >> 6) ^ (addr >> 2)) % hsize; return ((addr >> 6) ^ (addr >> 2)) % hsize;
} }
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines for (size_t i = 0; i < h_size; i++)
h->buckets[i] = 0; h->buckets[i] = 0;
return h; return h;
} }
#define ENTRY_LAST_INS 0 #define ENTRY_LAST_INS 0
#define ENTRY_LAST_MTXS 1 #define ENTRY_LAST_MTXS 1
static kmp_dephash_entry * static kmp_dephash_entry *__kmp_dephash_find(kmp_info_t *thread,
__kmp_dephash_find(kmp_info_t *thread, kmp_dephash_t **hash, kmp_intptr_t addr) { kmp_dephash_t **hash,
kmp_intptr_t addr) {
kmp_dephash_t *h = *hash; kmp_dephash_t *h = *hash;
if (h->nelements != 0 if (h->nelements != 0 && h->nconflicts / h->size >= 1) {
&& h->nconflicts/h->size >= 1) {
*hash = __kmp_dephash_extend(thread, h); *hash = __kmp_dephash_extend(thread, h);
h = *hash; h = *hash;
} }
size_t bucket = __kmp_dephash_hash(addr, h->size); size_t bucket = __kmp_dephash_hash(addr, h->size);
kmp_dephash_entry_t *entry; kmp_dephash_entry_t *entry;
for (entry = h->buckets[bucket]; entry; entry = entry->next_in_bucket) for (entry = h->buckets[bucket]; entry; entry = entry->next_in_bucket)
if (entry->addr == addr) if (entry->addr == addr)
▲ Show 20 Lines • Show All 364 Lines • ▼ Show 20 Lines if (ompt_enabled.ompt_callback_task_create) {
ompt_callbacks.ompt_callback(ompt_callback_task_create)( ompt_callbacks.ompt_callback(ompt_callback_task_create)(
&(current_task->ompt_task_info.task_data), &(current_task->ompt_task_info.task_data),
&(current_task->ompt_task_info.frame), &(current_task->ompt_task_info.frame),
&(new_taskdata->ompt_task_info.task_data), &(new_taskdata->ompt_task_info.task_data),
ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 1, ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 1,
OMPT_LOAD_OR_GET_RETURN_ADDRESS(gtid)); OMPT_LOAD_OR_GET_RETURN_ADDRESS(gtid));
} }
new_taskdata->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0); new_taskdata->ompt_task_info.frame.enter_frame.ptr =
OMPT_GET_FRAME_ADDRESS(0);
} }
#if OMPT_OPTIONAL #if OMPT_OPTIONAL
/* OMPT grab all dependences if requested by the tool */ /* OMPT grab all dependences if requested by the tool */
if (ndeps + ndeps_noalias > 0 && if (ndeps + ndeps_noalias > 0 && ompt_enabled.ompt_callback_dependences) {
ompt_enabled.ompt_callback_dependences) {
kmp_int32 i; kmp_int32 i;
int ompt_ndeps = ndeps + ndeps_noalias; int ompt_ndeps = ndeps + ndeps_noalias;
ompt_dependence_t *ompt_deps = (ompt_dependence_t *)KMP_OMPT_DEPS_ALLOC( ompt_dependence_t *ompt_deps = (ompt_dependence_t *)KMP_OMPT_DEPS_ALLOC(
thread, (ndeps + ndeps_noalias) * sizeof(ompt_dependence_t)); thread, (ndeps + ndeps_noalias) * sizeof(ompt_dependence_t));
KMP_ASSERT(ompt_deps != NULL); KMP_ASSERT(ompt_deps != NULL);
▲ Show 20 Lines • Show All 250 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_tasking.cpp

Show First 20 Lines • Show All 558 Lines • ▼ Show 20 Lines
// Initialize OMPT fields maintained by a task. This will only be called after // Initialize OMPT fields maintained by a task. This will only be called after
// ompt_start_tool, so we already know whether ompt is enabled or not. // ompt_start_tool, so we already know whether ompt is enabled or not.
static inline void __ompt_task_init(kmp_taskdata_t *task, int tid) { static inline void __ompt_task_init(kmp_taskdata_t *task, int tid) {
// The calls to __ompt_task_init already have the ompt_enabled condition. // The calls to __ompt_task_init already have the ompt_enabled condition.
task->ompt_task_info.task_data.value = 0; task->ompt_task_info.task_data.value = 0;
task->ompt_task_info.frame.exit_frame = ompt_data_none; task->ompt_task_info.frame.exit_frame = ompt_data_none;
task->ompt_task_info.frame.enter_frame = ompt_data_none; task->ompt_task_info.frame.enter_frame = ompt_data_none;
task->ompt_task_info.frame.exit_frame_flags = ompt_frame_runtime | ompt_frame_framepointer; task->ompt_task_info.frame.exit_frame_flags =
task->ompt_task_info.frame.enter_frame_flags = ompt_frame_runtime | ompt_frame_framepointer; ompt_frame_runtime | ompt_frame_framepointer;
task->ompt_task_info.frame.enter_frame_flags =
ompt_frame_runtime | ompt_frame_framepointer;
} }
// __ompt_task_start: // __ompt_task_start:
// Build and trigger task-begin event // Build and trigger task-begin event
static inline void __ompt_task_start(kmp_task_t *task, static inline void __ompt_task_start(kmp_task_t *task,
kmp_taskdata_t *current_task, kmp_taskdata_t *current_task,
kmp_int32 gtid) { kmp_int32 gtid) {
kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task); kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linesstatic void __kmpc_omp_task_begin_if0_template(ident_t *loc_ref, kmp_int32 gtid,
__kmp_task_start(gtid, task, current_task); __kmp_task_start(gtid, task, current_task);
#if OMPT_SUPPORT #if OMPT_SUPPORT
if (ompt) { if (ompt) {
if (current_task->ompt_task_info.frame.enter_frame.ptr == NULL) { if (current_task->ompt_task_info.frame.enter_frame.ptr == NULL) {
current_task->ompt_task_info.frame.enter_frame.ptr = current_task->ompt_task_info.frame.enter_frame.ptr =
taskdata->ompt_task_info.frame.exit_frame.ptr = frame_address; taskdata->ompt_task_info.frame.exit_frame.ptr = frame_address;
current_task->ompt_task_info.frame.enter_frame_flags = current_task->ompt_task_info.frame.enter_frame_flags =
taskdata->ompt_task_info.frame.exit_frame_flags = ompt_frame_application | ompt_frame_framepointer; taskdata->ompt_task_info.frame.exit_frame_flags =
ompt_frame_application | ompt_frame_framepointer;
} }
if (ompt_enabled.ompt_callback_task_create) { if (ompt_enabled.ompt_callback_task_create) {
ompt_task_info_t *parent_info = &(current_task->ompt_task_info); ompt_task_info_t *parent_info = &(current_task->ompt_task_info);
ompt_callbacks.ompt_callback(ompt_callback_task_create)( ompt_callbacks.ompt_callback(ompt_callback_task_create)(
&(parent_info->task_data), &(parent_info->frame), &(parent_info->task_data), &(parent_info->frame),
&(taskdata->ompt_task_info.task_data), &(taskdata->ompt_task_info.task_data),
ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(taskdata), 0, ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(taskdata), 0,
return_address); return_address);
▲ Show 20 Lines • Show All 300 Lines • ▼ Show 20 Lines#endif
// td_flags.executing must be marked as 0 after __kmp_release_deps has been // td_flags.executing must be marked as 0 after __kmp_release_deps has been
// called. Othertwise, if a task is executed immediately from the // called. Othertwise, if a task is executed immediately from the
// release_deps code, the flag will be reset to 1 again by this same // release_deps code, the flag will be reset to 1 again by this same
// function // function
KMP_DEBUG_ASSERT(taskdata->td_flags.executing == 1); KMP_DEBUG_ASSERT(taskdata->td_flags.executing == 1);
taskdata->td_flags.executing = 0; // suspend the finishing task taskdata->td_flags.executing = 0; // suspend the finishing task
} }
KA_TRACE( KA_TRACE(
20, ("__kmp_task_finish: T#%d finished task %p, %d incomplete children\n", 20, ("__kmp_task_finish: T#%d finished task %p, %d incomplete children\n",
gtid, taskdata, children)); gtid, taskdata, children));
// Free this task and then ancestor tasks if they have no children. // Free this task and then ancestor tasks if they have no children.
// Restore th_current_task first as suggested by John: // Restore th_current_task first as suggested by John:
// johnmc: if an asynchronous inquiry peers into the runtime system // johnmc: if an asynchronous inquiry peers into the runtime system
// it doesn't see the freed task as the current task. // it doesn't see the freed task as the current task.
Show All 25 Linesstatic void __kmpc_omp_task_complete_if0_template(ident_t *loc_ref,
KA_TRACE(10, ("__kmpc_omp_task_complete_if0(exit): T#%d loc=%p task=%p\n", KA_TRACE(10, ("__kmpc_omp_task_complete_if0(exit): T#%d loc=%p task=%p\n",
gtid, loc_ref, KMP_TASK_TO_TASKDATA(task))); gtid, loc_ref, KMP_TASK_TO_TASKDATA(task)));
#if OMPT_SUPPORT #if OMPT_SUPPORT
if (ompt) { if (ompt) {
ompt_frame_t *ompt_frame; ompt_frame_t *ompt_frame;
__ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL); __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
ompt_frame->enter_frame = ompt_data_none; ompt_frame->enter_frame = ompt_data_none;
ompt_frame->enter_frame_flags = ompt_frame_runtime | ompt_frame_framepointer; ompt_frame->enter_frame_flags =
ompt_frame_runtime | ompt_frame_framepointer;
} }
#endif #endif
return; return;
} }
#if OMPT_SUPPORT #if OMPT_SUPPORT
OMPT_NOINLINE OMPT_NOINLINE
▲ Show 20 Lines • Show All 406 Lines • ▼ Show 20 Lines
kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
kmp_int32 flags, size_t sizeof_kmp_task_t, kmp_int32 flags, size_t sizeof_kmp_task_t,
size_t sizeof_shareds, size_t sizeof_shareds,
kmp_routine_entry_t task_entry) { kmp_routine_entry_t task_entry) {
kmp_task_t *retval; kmp_task_t *retval;
kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *)&flags; kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *)&flags;
__kmp_assert_valid_gtid(gtid); __kmp_assert_valid_gtid(gtid);
input_flags->native = FALSE; input_flags->native = FALSE;
// __kmp_task_alloc() sets up all other runtime flags // __kmp_task_alloc() sets up all other runtime flags
KA_TRACE(10, ("__kmpc_omp_task_alloc(enter): T#%d loc=%p, flags=(%s %s %s) " KA_TRACE(10, ("__kmpc_omp_task_alloc(enter): T#%d loc=%p, flags=(%s %s %s) "
"sizeof_task=%ld sizeof_shared=%ld entry=%p\n", "sizeof_task=%ld sizeof_shared=%ld entry=%p\n",
gtid, loc_ref, input_flags->tiedness ? "tied " : "untied", gtid, loc_ref, input_flags->tiedness ? "tied " : "untied",
input_flags->proxy ? "proxy" : "", input_flags->proxy ? "proxy" : "",
input_flags->detachable ? "detachable" : "", sizeof_kmp_task_t, input_flags->detachable ? "detachable" : "", sizeof_kmp_task_t,
sizeof_shareds, task_entry)); sizeof_shareds, task_entry));
retval = __kmp_task_alloc(loc_ref, gtid, input_flags, sizeof_kmp_task_t, retval = __kmp_task_alloc(loc_ref, gtid, input_flags, sizeof_kmp_task_t,
▲ Show 20 Lines • Show All 193 Lines • ▼ Show 20 Lines
#if USE_ITT_BUILD && USE_ITT_NOTIFY #if USE_ITT_BUILD && USE_ITT_NOTIFY
if (kmp_itt_count_task) { if (kmp_itt_count_task) {
// Barrier imbalance - adjust arrive time with the task duration // Barrier imbalance - adjust arrive time with the task duration
thread->th.th_bar_arrive_time += (__itt_get_timestamp() - cur_time); thread->th.th_bar_arrive_time += (__itt_get_timestamp() - cur_time);
} }
KMP_FSYNC_CANCEL(taskdata); // destroy self (just executed) KMP_FSYNC_CANCEL(taskdata); // destroy self (just executed)
KMP_FSYNC_RELEASING(taskdata->td_parent); // releasing parent KMP_FSYNC_RELEASING(taskdata->td_parent); // releasing parent
#endif #endif
} }
// Proxy tasks are not handled by the runtime // Proxy tasks are not handled by the runtime
if (taskdata->td_flags.proxy != TASK_PROXY) { if (taskdata->td_flags.proxy != TASK_PROXY) {
ANNOTATE_HAPPENS_BEFORE(taskdata->td_parent); ANNOTATE_HAPPENS_BEFORE(taskdata->td_parent);
#if OMPT_SUPPORT #if OMPT_SUPPORT
if (UNLIKELY(ompt_enabled.enabled)) { if (UNLIKELY(ompt_enabled.enabled)) {
thread->th.ompt_thread_info = oldInfo; thread->th.ompt_thread_info = oldInfo;
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
#if OMPT_SUPPORT #if OMPT_SUPPORT
kmp_taskdata_t *parent = NULL; kmp_taskdata_t *parent = NULL;
if (UNLIKELY(ompt_enabled.enabled)) { if (UNLIKELY(ompt_enabled.enabled)) {
if (!new_taskdata->td_flags.started) { if (!new_taskdata->td_flags.started) {
OMPT_STORE_RETURN_ADDRESS(gtid); OMPT_STORE_RETURN_ADDRESS(gtid);
parent = new_taskdata->td_parent; parent = new_taskdata->td_parent;
if (!parent->ompt_task_info.frame.enter_frame.ptr) { if (!parent->ompt_task_info.frame.enter_frame.ptr) {
parent->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0); parent->ompt_task_info.frame.enter_frame.ptr =
OMPT_GET_FRAME_ADDRESS(0);
} }
if (ompt_enabled.ompt_callback_task_create) { if (ompt_enabled.ompt_callback_task_create) {
ompt_data_t task_data = ompt_data_none; ompt_data_t task_data = ompt_data_none;
ompt_callbacks.ompt_callback(ompt_callback_task_create)( ompt_callbacks.ompt_callback(ompt_callback_task_create)(
parent ? &(parent->ompt_task_info.task_data) : &task_data, parent ? &(parent->ompt_task_info.task_data) : &task_data,
parent ? &(parent->ompt_task_info.frame) : NULL, parent ? &(parent->ompt_task_info.frame) : NULL,
&(new_taskdata->ompt_task_info.task_data), &(new_taskdata->ompt_task_info.task_data),
ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 0, ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 0,
▲ Show 20 Lines • Show All 1,549 Lines • ▼ Show 20 Lines
#ifdef BUILD_TIED_TASK_STACK #ifdef BUILD_TIED_TASK_STACK
// GEH: Figure out if this is the right thing to do // GEH: Figure out if this is the right thing to do
for (i = maxthreads; i < nthreads; i++) { for (i = maxthreads; i < nthreads; i++) {
kmp_thread_data_t *thread_data = &(*threads_data_p)[i]; kmp_thread_data_t *thread_data = &(*threads_data_p)[i];
__kmp_init_task_stack(__kmp_gtid_from_thread(thread), thread_data); __kmp_init_task_stack(__kmp_gtid_from_thread(thread), thread_data);
} }
#endif // BUILD_TIED_TASK_STACK #endif // BUILD_TIED_TASK_STACK
// Install the new data and free the old data // Install the new data and free the old data
(*threads_data_p) = new_data; (*threads_data_p) = new_data;
__kmp_free(old_data); __kmp_free(old_data);
} else { } else {
KE_TRACE(10, ("__kmp_realloc_task_threads_data: T#%d allocating " KE_TRACE(10, ("__kmp_realloc_task_threads_data: T#%d allocating "
"threads data for task_team %p, size = %d\n", "threads data for task_team %p, size = %d\n",
__kmp_gtid_from_thread(thread), task_team, nthreads)); __kmp_gtid_from_thread(thread), task_team, nthreads));
// Make the initial allocate for threads_data array, and zero entries // Make the initial allocate for threads_data array, and zero entries
// Cannot use __kmp_thread_calloc() because threads not around for // Cannot use __kmp_thread_calloc() because threads not around for
▲ Show 20 Lines • Show All 903 Lines • ▼ Show 20 Lines#endif
kmp_uint64 lower = task_bounds.get_lb(); kmp_uint64 lower = task_bounds.get_lb();
kmp_uint64 upper = task_bounds.get_ub(); kmp_uint64 upper = task_bounds.get_ub();
kmp_uint64 i; kmp_uint64 i;
kmp_info_t *thread = __kmp_threads[gtid]; kmp_info_t *thread = __kmp_threads[gtid];
kmp_taskdata_t *current_task = thread->th.th_current_task; kmp_taskdata_t *current_task = thread->th.th_current_task;
kmp_task_t *next_task; kmp_task_t *next_task;
kmp_int32 lastpriv = 0; kmp_int32 lastpriv = 0;
KMP_DEBUG_ASSERT( KMP_DEBUG_ASSERT(tc == num_tasks * grainsize +
tc == num_tasks * grainsize + (last_chunk < 0 ? last_chunk : extras)); (last_chunk < 0 ? last_chunk : extras));
KMP_DEBUG_ASSERT(num_tasks > extras); KMP_DEBUG_ASSERT(num_tasks > extras);
KMP_DEBUG_ASSERT(num_tasks > 0); KMP_DEBUG_ASSERT(num_tasks > 0);
KA_TRACE(20, ("__kmp_taskloop_linear: T#%d: %lld tasks, grainsize %lld, " KA_TRACE(20, ("__kmp_taskloop_linear: T#%d: %lld tasks, grainsize %lld, "
"extras %lld, last_chunk %lld, i=%lld,%lld(%d)%lld, dup %p\n", "extras %lld, last_chunk %lld, i=%lld,%lld(%d)%lld, dup %p\n",
gtid, num_tasks, grainsize, extras, last_chunk, lower, upper, gtid, num_tasks, grainsize, extras, last_chunk, lower, upper,
ub_glob, st, task_dup)); ub_glob, st, task_dup));
// Launch num_tasks tasks, assign grainsize iterations each task // Launch num_tasks tasks, assign grainsize iterations each task
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines for (i = 0; i < num_tasks; ++i) {
KA_TRACE(40, KA_TRACE(40,
("__kmp_taskloop_linear: T#%d; task #%llu: task %p: lower %lld, " ("__kmp_taskloop_linear: T#%d; task #%llu: task %p: lower %lld, "
"upper %lld stride %lld, (offsets %p %p)\n", "upper %lld stride %lld, (offsets %p %p)\n",
gtid, i, next_task, lower, upper, st, gtid, i, next_task, lower, upper, st,
next_task_bounds.get_lower_offset(), next_task_bounds.get_lower_offset(),
next_task_bounds.get_upper_offset())); next_task_bounds.get_upper_offset()));
#if OMPT_SUPPORT #if OMPT_SUPPORT
__kmp_omp_taskloop_task(NULL, gtid, next_task, __kmp_omp_taskloop_task(NULL, gtid, next_task,
codeptr_ra); // schedule new task codeptr_ra); // schedule new task
#else #else
__kmp_omp_task(gtid, next_task, true); // schedule new task __kmp_omp_task(gtid, next_task, true); // schedule new task
#endif #endif
lower = upper + st; // adjust lower bound for the next iteration lower = upper + st; // adjust lower bound for the next iteration
} }
// free the pattern task and exit // free the pattern task and exit
__kmp_task_start(gtid, task, current_task); // make internal bookkeeping __kmp_task_start(gtid, task, current_task); // make internal bookkeeping
// do not execute the pattern task, just do internal bookkeeping // do not execute the pattern task, just do internal bookkeeping
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines#endif
kmp_info_t *thread = __kmp_threads[gtid]; kmp_info_t *thread = __kmp_threads[gtid];
// kmp_taskdata_t *current_task = thread->th.th_current_task; // kmp_taskdata_t *current_task = thread->th.th_current_task;
kmp_task_t *next_task; kmp_task_t *next_task;
size_t lower_offset = size_t lower_offset =
(char *)lb - (char *)task; // remember offset of lb in the task structure (char *)lb - (char *)task; // remember offset of lb in the task structure
size_t upper_offset = size_t upper_offset =
(char *)ub - (char *)task; // remember offset of ub in the task structure (char *)ub - (char *)task; // remember offset of ub in the task structure
KMP_DEBUG_ASSERT( KMP_DEBUG_ASSERT(tc == num_tasks * grainsize +
tc == num_tasks * grainsize + (last_chunk < 0 ? last_chunk : extras)); (last_chunk < 0 ? last_chunk : extras));
KMP_DEBUG_ASSERT(num_tasks > extras); KMP_DEBUG_ASSERT(num_tasks > extras);
KMP_DEBUG_ASSERT(num_tasks > 0); KMP_DEBUG_ASSERT(num_tasks > 0);
// split the loop in two halves // split the loop in two halves
kmp_uint64 lb1, ub0, tc0, tc1, ext0, ext1; kmp_uint64 lb1, ub0, tc0, tc1, ext0, ext1;
kmp_int64 last_chunk0 = 0, last_chunk1 = 0; kmp_int64 last_chunk0 = 0, last_chunk1 = 0;
kmp_uint64 gr_size0 = grainsize; kmp_uint64 gr_size0 = grainsize;
kmp_uint64 n_tsk0 = num_tasks >> 1; // num_tasks/2 to execute kmp_uint64 n_tsk0 = num_tasks >> 1; // num_tasks/2 to execute
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Lines if (grainsize > tc) {
extras = tc % num_tasks; extras = tc % num_tasks;
} }
} }
break; break;
default: default:
KMP_ASSERT2(0, "unknown scheduling of taskloop"); KMP_ASSERT2(0, "unknown scheduling of taskloop");
} }
KMP_DEBUG_ASSERT( KMP_DEBUG_ASSERT(tc == num_tasks * grainsize +
tc == num_tasks * grainsize + (last_chunk < 0 ? last_chunk : extras)); (last_chunk < 0 ? last_chunk : extras));
KMP_DEBUG_ASSERT(num_tasks > extras); KMP_DEBUG_ASSERT(num_tasks > extras);
KMP_DEBUG_ASSERT(num_tasks > 0); KMP_DEBUG_ASSERT(num_tasks > 0);
// ========================================================================= // =========================================================================
// check if clause value first // check if clause value first
// Also require GOMP_taskloop to reduce to linear (taskdata->td_flags.native) // Also require GOMP_taskloop to reduce to linear (taskdata->td_flags.native)
if (if_val == 0) { // if(0) specified, mark task as serial if (if_val == 0) { // if(0) specified, mark task as serial
taskdata->td_flags.task_serial = 1; taskdata->td_flags.task_serial = 1;
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_threadprivate.cpp

Show First 20 Lines • Show All 404 Lines • ▼ Show 20 Linesstruct private_common *kmp_threadprivate_insert(int gtid, void *pc_addr,
if ((__kmp_foreign_tp) ? (KMP_INITIAL_GTID(gtid)) : (KMP_UBER_GTID(gtid))) { if ((__kmp_foreign_tp) ? (KMP_INITIAL_GTID(gtid)) : (KMP_UBER_GTID(gtid))) {
tn->par_addr = (void *)pc_addr; tn->par_addr = (void *)pc_addr;
} else { } else {
tn->par_addr = (void *)__kmp_allocate(tn->cmn_size); tn->par_addr = (void *)__kmp_allocate(tn->cmn_size);
} }
__kmp_release_lock(&__kmp_global_lock, gtid); __kmp_release_lock(&__kmp_global_lock, gtid);
/* +++++++++ END OF CRITICAL SECTION +++++++++ */ /* +++++++++ END OF CRITICAL SECTION +++++++++ */
#ifdef USE_CHECKS_COMMON #ifdef USE_CHECKS_COMMON
if (pc_size > d_tn->cmn_size) { if (pc_size > d_tn->cmn_size) {
KC_TRACE( KC_TRACE(
10, ("__kmp_threadprivate_insert: THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC 10, ("__kmp_threadprivate_insert: THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC
" ,%" KMP_UINTPTR_SPEC ")\n", " ,%" KMP_UINTPTR_SPEC ")\n",
pc_addr, pc_size, d_tn->cmn_size)); pc_addr, pc_size, d_tn->cmn_size));
KMP_FATAL(TPCommonBlocksInconsist); KMP_FATAL(TPCommonBlocksInconsist);
▲ Show 20 Lines • Show All 376 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_utility.cpp

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines if (bits_seen == 1) {
current_bit >>= 1; current_bit >>= 1;
} }
return ((int)((current_bit - 1) & apic_id)); return ((int)((current_bit - 1) & apic_id));
} }
static kmp_uint64 __kmp_parse_frequency( // R: Frequency in Hz. static kmp_uint64 __kmp_parse_frequency( // R: Frequency in Hz.
char const *frequency // I: Float number and unit: MHz, GHz, or TGz. char const *frequency // I: Float number and unit: MHz, GHz, or TGz.
) { ) {
double value = 0.0; double value = 0.0;
char *unit = NULL; char *unit = NULL;
kmp_uint64 result = 0; /* Zero is a better unknown value than all ones. */ kmp_uint64 result = 0; /* Zero is a better unknown value than all ones. */
if (frequency == NULL) { if (frequency == NULL) {
return result; return result;
} }
▲ Show 20 Lines • Show All 306 Lines • Show Last 20 Lines

openmp/runtime/src/kmp_version.cpp

Show First 20 Lines • Show All 172 Lines • ▼ Show 20 Lines __kmp_str_buf_print(
&buffer, "%sthread affinity support: %s\n", KMP_VERSION_PREF_STR, &buffer, "%sthread affinity support: %s\n", KMP_VERSION_PREF_STR,
#if KMP_AFFINITY_SUPPORTED #if KMP_AFFINITY_SUPPORTED
(KMP_AFFINITY_CAPABLE() (KMP_AFFINITY_CAPABLE()
? (__kmp_affinity_type == affinity_none ? "not used" : "yes") ? (__kmp_affinity_type == affinity_none ? "not used" : "yes")
: "no") : "no")
#else #else
"no" "no"
#endif #endif
); );
__kmp_printf("%s", buffer.str); __kmp_printf("%s", buffer.str);
__kmp_str_buf_free(&buffer); __kmp_str_buf_free(&buffer);
K_DIAG(1, ("KMP_VERSION is true\n")); K_DIAG(1, ("KMP_VERSION is true\n"));
#endif // KMP_STUB #endif // KMP_STUB
} // __kmp_print_version_1 } // __kmp_print_version_1
// Called at parallel initialization time. // Called at parallel initialization time.
static int __kmp_version_2_printed = FALSE; static int __kmp_version_2_printed = FALSE;
Show All 9 Lines

openmp/runtime/src/kmp_wait_release.h

Show First 20 Lines • Show All 977 Lines • ▼ Show 20 Lines bool notdone_check() {
// Calculate flag_switch // Calculate flag_switch
if (this_thr->th.th_bar[bt].bb.wait_flag == KMP_BARRIER_SWITCH_TO_OWN_FLAG) if (this_thr->th.th_bar[bt].bb.wait_flag == KMP_BARRIER_SWITCH_TO_OWN_FLAG)
flag_switch = true; flag_switch = true;
if (byteref(get(), offset) != 1 && !flag_switch) if (byteref(get(), offset) != 1 && !flag_switch)
return true; return true;
else if (flag_switch) { else if (flag_switch) {
this_thr->th.th_bar[bt].bb.wait_flag = KMP_BARRIER_SWITCHING; this_thr->th.th_bar[bt].bb.wait_flag = KMP_BARRIER_SWITCHING;
kmp_flag_64<> flag(&this_thr->th.th_bar[bt].bb.b_go, kmp_flag_64<> flag(&this_thr->th.th_bar[bt].bb.b_go,
(kmp_uint64)KMP_BARRIER_STATE_BUMP); (kmp_uint64)KMP_BARRIER_STATE_BUMP);
__kmp_wait_64(this_thr, &flag, TRUE USE_ITT_BUILD_ARG(itt_sync_obj)); __kmp_wait_64(this_thr, &flag, TRUE USE_ITT_BUILD_ARG(itt_sync_obj));
} }
return false; return false;
} }
void internal_release() { void internal_release() {
// Other threads can write their own bytes simultaneously. // Other threads can write their own bytes simultaneously.
if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME) { if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME) {
byteref(get(), offset) = 1; byteref(get(), offset) = 1;
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

openmp/runtime/src/ompt-event-specific.h

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
| Optional Events | Optional Events
+--------------------------------------------------------------------------*/ +--------------------------------------------------------------------------*/
#define ompt_callback_sync_region_wait_implemented \ #define ompt_callback_sync_region_wait_implemented \
ompt_event_MAY_ALWAYS_OPTIONAL ompt_event_MAY_ALWAYS_OPTIONAL
#define ompt_callback_mutex_released_implemented ompt_event_MAY_ALWAYS_OPTIONAL #define ompt_callback_mutex_released_implemented ompt_event_MAY_ALWAYS_OPTIONAL
#define ompt_callback_dependences_implemented \ #define ompt_callback_dependences_implemented ompt_event_MAY_ALWAYS_OPTIONAL
ompt_event_MAY_ALWAYS_OPTIONAL
#define ompt_callback_task_dependence_implemented ompt_event_MAY_ALWAYS_OPTIONAL #define ompt_callback_task_dependence_implemented ompt_event_MAY_ALWAYS_OPTIONAL
#define ompt_callback_work_implemented ompt_event_MAY_ALWAYS_OPTIONAL #define ompt_callback_work_implemented ompt_event_MAY_ALWAYS_OPTIONAL
#define ompt_callback_masked_implemented ompt_event_MAY_ALWAYS_OPTIONAL #define ompt_callback_masked_implemented ompt_event_MAY_ALWAYS_OPTIONAL
#define ompt_callback_target_map_implemented ompt_event_UNIMPLEMENTED #define ompt_callback_target_map_implemented ompt_event_UNIMPLEMENTED
#define ompt_callback_target_map_emi_implemented ompt_event_UNIMPLEMENTED #define ompt_callback_target_map_emi_implemented ompt_event_UNIMPLEMENTED
Show All 21 Lines

openmp/runtime/src/ompt-general.cpp

Show First 20 Lines • Show All 302 Lines • ▼ Show 20 Lines#elif KMP_OS_WINDOWS
start_tool = (ompt_start_tool_t)GetProcAddress(h, "ompt_start_tool"); start_tool = (ompt_start_tool_t)GetProcAddress(h, "ompt_start_tool");
if (!start_tool) { if (!start_tool) {
OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %s\n", OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %s\n",
GetLastError()); GetLastError());
} else } else
#else #else
#error Activation of OMPT is not supported on this platform. #error Activation of OMPT is not supported on this platform.
#endif #endif
{// if (start_tool) { // if (start_tool)
ret = (*start_tool)(omp_version, runtime_version); ret = (*start_tool)(omp_version, runtime_version);
if (ret) { if (ret) {
OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n"); OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n");
OMPT_VERBOSE_INIT_PRINT( OMPT_VERBOSE_INIT_PRINT(
"Tool was started and is using the OMPT interface.\n"); "Tool was started and is using the OMPT interface.\n");
break; break;
} }
OMPT_VERBOSE_INIT_CONTINUED_PRINT( OMPT_VERBOSE_INIT_CONTINUED_PRINT(
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines case omp_tool_enabled:
//-------------------------------------------------- //--------------------------------------------------
ompt_start_tool_result = ompt_start_tool_result =
ompt_try_start_tool(__kmp_openmp_version, ompt_get_runtime_version()); ompt_try_start_tool(__kmp_openmp_version, ompt_get_runtime_version());
memset(&ompt_enabled, 0, sizeof(ompt_enabled)); memset(&ompt_enabled, 0, sizeof(ompt_enabled));
break; break;
case omp_tool_error: case omp_tool_error:
fprintf(stderr, "Warning: OMP_TOOL has invalid value \"%s\".\n" fprintf(stderr,
"Warning: OMP_TOOL has invalid value \"%s\".\n"
" legal values are (NULL,\"\",\"disabled\"," " legal values are (NULL,\"\",\"disabled\","
"\"enabled\").\n", "\"enabled\").\n",
ompt_env_var); ompt_env_var);
break; break;
} }
if (verbose_init && verbose_file != stderr && verbose_file != stdout) if (verbose_init && verbose_file != stderr && verbose_file != stdout)
fclose(verbose_file); fclose(verbose_file);
#if OMPT_DEBUG #if OMPT_DEBUG
printf("ompt_pre_init(): ompt_enabled = %d\n", ompt_enabled); printf("ompt_pre_init(): ompt_enabled = %d\n", ompt_enabled);
#endif #endif
Show All 12 Linesvoid ompt_post_init() {
ompt_post_initialized = 1; ompt_post_initialized = 1;
//-------------------------------------------------- //--------------------------------------------------
// Initialize the tool if so indicated. // Initialize the tool if so indicated.
//-------------------------------------------------- //--------------------------------------------------
if (ompt_start_tool_result) { if (ompt_start_tool_result) {
ompt_enabled.enabled = !!ompt_start_tool_result->initialize( ompt_enabled.enabled = !!ompt_start_tool_result->initialize(
ompt_fn_lookup, omp_get_initial_device(), &(ompt_start_tool_result->tool_data)); ompt_fn_lookup, omp_get_initial_device(),
&(ompt_start_tool_result->tool_data));
if (!ompt_enabled.enabled) { if (!ompt_enabled.enabled) {
// tool not enabled, zero out the bitmap, and done // tool not enabled, zero out the bitmap, and done
memset(&ompt_enabled, 0, sizeof(ompt_enabled)); memset(&ompt_enabled, 0, sizeof(ompt_enabled));
return; return;
} }
kmp_info_t *root_thread = ompt_get_thread(); kmp_info_t *root_thread = ompt_get_thread();
ompt_set_thread_state(root_thread, ompt_state_overhead); ompt_set_thread_state(root_thread, ompt_state_overhead);
if (ompt_enabled.ompt_callback_thread_begin) { if (ompt_enabled.ompt_callback_thread_begin) {
ompt_callbacks.ompt_callback(ompt_callback_thread_begin)( ompt_callbacks.ompt_callback(ompt_callback_thread_begin)(
ompt_thread_initial, __ompt_get_thread_data_internal()); ompt_thread_initial, __ompt_get_thread_data_internal());
} }
ompt_data_t *task_data; ompt_data_t *task_data;
ompt_data_t *parallel_data; ompt_data_t *parallel_data;
__ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data, NULL); __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data,
NULL);
if (ompt_enabled.ompt_callback_implicit_task) { if (ompt_enabled.ompt_callback_implicit_task) {
ompt_callbacks.ompt_callback(ompt_callback_implicit_task)( ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial); ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial);
} }
ompt_set_thread_state(root_thread, ompt_state_work_serial); ompt_set_thread_state(root_thread, ompt_state_work_serial);
} }
} }
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 LinesOMPT_API_ROUTINE int ompt_enumerate_mutex_impls(int current_impl,
return 0; return 0;
} }
/***************************************************************************** /*****************************************************************************
* callbacks * callbacks
****************************************************************************/ ****************************************************************************/
OMPT_API_ROUTINE ompt_set_result_t ompt_set_callback(ompt_callbacks_t which, OMPT_API_ROUTINE ompt_set_result_t ompt_set_callback(ompt_callbacks_t which,
ompt_callback_t callback) { ompt_callback_t callback) {
switch (which) { switch (which) {
#define ompt_event_macro(event_name, callback_type, event_id) \ #define ompt_event_macro(event_name, callback_type, event_id) \
case event_name: \ case event_name: \
ompt_callbacks.ompt_callback(event_name) = (callback_type)callback; \ ompt_callbacks.ompt_callback(event_name) = (callback_type)callback; \
ompt_enabled.event_name = (callback != 0); \ ompt_enabled.event_name = (callback != 0); \
if (callback) \ if (callback) \
return ompt_event_implementation_status(event_name); \ return ompt_event_implementation_status(event_name); \
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines
****************************************************************************/ ****************************************************************************/
/* /*
* Currently unused function * Currently unused function
OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; } OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; }
*/ */
/***************************************************************************** /*****************************************************************************
* application-facing API * application-facing API
****************************************************************************/ ****************************************************************************/
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| control | control
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
int __kmp_control_tool(uint64_t command, uint64_t modifier, void *arg) { int __kmp_control_tool(uint64_t command, uint64_t modifier, void *arg) {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

openmp/runtime/src/ompt-specific.h

Show All 17 Lines
#if OMPT_SUPPORT #if OMPT_SUPPORT
/***************************************************************************** /*****************************************************************************
* forward declarations * forward declarations
****************************************************************************/ ****************************************************************************/
void __ompt_team_assign_id(kmp_team_t *team, ompt_data_t ompt_pid); void __ompt_team_assign_id(kmp_team_t *team, ompt_data_t ompt_pid);
void __ompt_thread_assign_wait_id(void *variable); void __ompt_thread_assign_wait_id(void *variable);
void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr, void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr, int gtid,
int gtid, ompt_data_t *ompt_pid, void *codeptr); ompt_data_t *ompt_pid, void *codeptr);
void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt, kmp_info_t *thr, void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt, kmp_info_t *thr,
int on_heap, bool always = false); int on_heap, bool always = false);
void __ompt_lw_taskteam_unlink(kmp_info_t *thr); void __ompt_lw_taskteam_unlink(kmp_info_t *thr);
ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size); ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size);
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines if (ompt_enabled.enabled && gtid >= 0 && __kmp_threads[gtid] && \
!__kmp_threads[gtid]->th.ompt_thread_info.return_address) \ !__kmp_threads[gtid]->th.ompt_thread_info.return_address) \
__kmp_threads[gtid]->th.ompt_thread_info.return_address = \ __kmp_threads[gtid]->th.ompt_thread_info.return_address = \
__builtin_return_address(0)*/ __builtin_return_address(0)*/
#define OMPT_STORE_RETURN_ADDRESS(gtid) \ #define OMPT_STORE_RETURN_ADDRESS(gtid) \
OmptReturnAddressGuard ReturnAddressGuard{gtid, __builtin_return_address(0)}; OmptReturnAddressGuard ReturnAddressGuard{gtid, __builtin_return_address(0)};
#define OMPT_LOAD_RETURN_ADDRESS(gtid) __ompt_load_return_address(gtid) #define OMPT_LOAD_RETURN_ADDRESS(gtid) __ompt_load_return_address(gtid)
#define OMPT_LOAD_OR_GET_RETURN_ADDRESS(gtid) \ #define OMPT_LOAD_OR_GET_RETURN_ADDRESS(gtid) \
((ompt_enabled.enabled && gtid >= 0 && __kmp_threads[gtid] && \ ((ompt_enabled.enabled && gtid >= 0 && __kmp_threads[gtid] && \
__kmp_threads[gtid]->th.ompt_thread_info.return_address)? \ __kmp_threads[gtid]->th.ompt_thread_info.return_address) \
__ompt_load_return_address(gtid): \ ? __ompt_load_return_address(gtid) \
__builtin_return_address(0)) : __builtin_return_address(0))
//****************************************************************************** //******************************************************************************
// inline functions // inline functions
//****************************************************************************** //******************************************************************************
inline kmp_info_t *ompt_get_thread_gtid(int gtid) { inline kmp_info_t *ompt_get_thread_gtid(int gtid) {
return (gtid >= 0) ? __kmp_thread_from_gtid(gtid) : NULL; return (gtid >= 0) ? __kmp_thread_from_gtid(gtid) : NULL;
} }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

openmp/runtime/src/test-touch.c

// test-touch.c // // test-touch.c //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
extern double omp_get_wtime(); extern double omp_get_wtime();
extern int omp_get_num_threads(); extern int omp_get_num_threads();
extern int omp_get_max_threads(); extern int omp_get_max_threads();
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
int main() { int main() {
omp_get_wtime(); omp_get_wtime();
omp_get_num_threads(); omp_get_num_threads();
omp_get_max_threads(); omp_get_max_threads();
return 0; return 0;
} }
// end of file // // end of file //

openmp/runtime/src/thirdparty/ittnotify/disable_warnings.h

// clang-format off
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ittnotify_config.h" #include "ittnotify_config.h"
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#pragma warning (disable: 593) /* parameter "XXXX" was set but never used */ #pragma warning(disable: 593) /* parameter "XXXX" was set but never used */
#pragma warning (disable: 344) /* typedef name has already been declared (with same type) */ #pragma warning(disable: 344) /* typedef name has already been declared (with
tianshilei1992AuthorUnsubmitted
Done
ReplyInline Actions

The tailing \ is unnecessary. Probably because clang-format takes it part of the pragma.

tianshilei1992: The tailing `\` is unnecessary. Probably because `clang-format` takes it part of the pragma.
same type) */
#pragma warning (disable: 174) /* expression has no effect */ #pragma warning(disable: 174) /* expression has no effect */
#pragma warning (disable: 4127) /* conditional expression is constant */ #pragma warning(disable: 4127) /* conditional expression is constant */
#pragma warning (disable: 4306) /* conversion from '?' to '?' of greater size */ #pragma warning(disable: 4306) /* conversion from '?' to '?' of greater size */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if defined __INTEL_COMPILER #if defined __INTEL_COMPILER
#pragma warning (disable: 869) /* parameter "XXXXX" was never referenced */ #pragma warning(disable: 869) /* parameter "XXXXX" was never referenced */
#pragma warning (disable: 1418) /* external function definition with no prior declaration */ #pragma warning(disable: 1418) /* external function definition with no prior
declaration */
#pragma warning (disable: 1419) /* external declaration in primary source file */ #pragma warning(disable: 1419) /* external declaration in primary source file */
#endif /* __INTEL_COMPILER */ #endif /* __INTEL_COMPILER */

openmp/runtime/src/thirdparty/ittnotify/ittnotify.h

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
expense of extra API calls. expense of extra API calls.
The same ID may not be reused for different instances, unless a previous The same ID may not be reused for different instances, unless a previous
[ref] __itt_id_destroy call for that ID has been issued. [ref] __itt_id_destroy call for that ID has been issued.
*/ */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef ITT_OS_WIN #ifndef ITT_OS_WIN
# define ITT_OS_WIN 1 #define ITT_OS_WIN 1
#endif /* ITT_OS_WIN */ #endif /* ITT_OS_WIN */
#ifndef ITT_OS_LINUX #ifndef ITT_OS_LINUX
# define ITT_OS_LINUX 2 #define ITT_OS_LINUX 2
#endif /* ITT_OS_LINUX */ #endif /* ITT_OS_LINUX */
#ifndef ITT_OS_MAC #ifndef ITT_OS_MAC
# define ITT_OS_MAC 3 #define ITT_OS_MAC 3
#endif /* ITT_OS_MAC */ #endif /* ITT_OS_MAC */
#ifndef ITT_OS_FREEBSD #ifndef ITT_OS_FREEBSD
# define ITT_OS_FREEBSD 4 #define ITT_OS_FREEBSD 4
#endif /* ITT_OS_FREEBSD */ #endif /* ITT_OS_FREEBSD */
#ifndef ITT_OS #ifndef ITT_OS
# if defined WIN32 || defined _WIN32 #if defined WIN32 || defined _WIN32
# define ITT_OS ITT_OS_WIN #define ITT_OS ITT_OS_WIN
# elif defined( __APPLE__ ) && defined( __MACH__ ) #elif defined(__APPLE__) && defined(__MACH__)
# define ITT_OS ITT_OS_MAC #define ITT_OS ITT_OS_MAC
# elif defined( __FreeBSD__ ) #elif defined(__FreeBSD__)
# define ITT_OS ITT_OS_FREEBSD #define ITT_OS ITT_OS_FREEBSD
# else #else
# define ITT_OS ITT_OS_LINUX #define ITT_OS ITT_OS_LINUX
# endif #endif
#endif /* ITT_OS */ #endif /* ITT_OS */
#ifndef ITT_PLATFORM_WIN #ifndef ITT_PLATFORM_WIN
# define ITT_PLATFORM_WIN 1 #define ITT_PLATFORM_WIN 1
#endif /* ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM_WIN */
#ifndef ITT_PLATFORM_POSIX #ifndef ITT_PLATFORM_POSIX
# define ITT_PLATFORM_POSIX 2 #define ITT_PLATFORM_POSIX 2
#endif /* ITT_PLATFORM_POSIX */ #endif /* ITT_PLATFORM_POSIX */
#ifndef ITT_PLATFORM_MAC #ifndef ITT_PLATFORM_MAC
# define ITT_PLATFORM_MAC 3 #define ITT_PLATFORM_MAC 3
#endif /* ITT_PLATFORM_MAC */ #endif /* ITT_PLATFORM_MAC */
#ifndef ITT_PLATFORM_FREEBSD #ifndef ITT_PLATFORM_FREEBSD
# define ITT_PLATFORM_FREEBSD 4 #define ITT_PLATFORM_FREEBSD 4
#endif /* ITT_PLATFORM_FREEBSD */ #endif /* ITT_PLATFORM_FREEBSD */
#ifndef ITT_PLATFORM #ifndef ITT_PLATFORM
# if ITT_OS==ITT_OS_WIN #if ITT_OS == ITT_OS_WIN
# define ITT_PLATFORM ITT_PLATFORM_WIN #define ITT_PLATFORM ITT_PLATFORM_WIN
# elif ITT_OS==ITT_OS_MAC #elif ITT_OS == ITT_OS_MAC
# define ITT_PLATFORM ITT_PLATFORM_MAC #define ITT_PLATFORM ITT_PLATFORM_MAC
# elif ITT_OS==ITT_OS_FREEBSD #elif ITT_OS == ITT_OS_FREEBSD
# define ITT_PLATFORM ITT_PLATFORM_FREEBSD #define ITT_PLATFORM ITT_PLATFORM_FREEBSD
# else #else
# define ITT_PLATFORM ITT_PLATFORM_POSIX #define ITT_PLATFORM ITT_PLATFORM_POSIX
# endif #endif
#endif /* ITT_PLATFORM */ #endif /* ITT_PLATFORM */
#if defined(_UNICODE) && !defined(UNICODE) #if defined(_UNICODE) && !defined(UNICODE)
#define UNICODE #define UNICODE
#endif #endif
#include <stddef.h> #include <stddef.h>
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#include <tchar.h> #include <tchar.h>
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#include <stdint.h> #include <stdint.h>
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
#include <wchar.h> #include <wchar.h>
#endif /* UNICODE || _UNICODE */ #endif /* UNICODE || _UNICODE */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#ifndef ITTAPI_CDECL #ifndef ITTAPI_CDECL
# if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
# define ITTAPI_CDECL __cdecl #define ITTAPI_CDECL __cdecl
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__ #if defined _M_IX86 || defined __i386__
# define ITTAPI_CDECL __attribute__ ((cdecl)) #define ITTAPI_CDECL __attribute__((cdecl))
# else /* _M_IX86 || __i386__ */ #else /* _M_IX86 || __i386__ */
# define ITTAPI_CDECL /* actual only on x86 platform */ #define ITTAPI_CDECL /* actual only on x86 platform */
# endif /* _M_IX86 || __i386__ */ #endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* ITTAPI_CDECL */ #endif /* ITTAPI_CDECL */
#ifndef STDCALL #ifndef STDCALL
# if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
# define STDCALL __stdcall #define STDCALL __stdcall
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__ #if defined _M_IX86 || defined __i386__
# define STDCALL __attribute__ ((stdcall)) #define STDCALL __attribute__((stdcall))
# else /* _M_IX86 || __i386__ */ #else /* _M_IX86 || __i386__ */
# define STDCALL /* supported only on x86 platform */ #define STDCALL /* supported only on x86 platform */
# endif /* _M_IX86 || __i386__ */ #endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* STDCALL */ #endif /* STDCALL */
#define ITTAPI ITTAPI_CDECL #define ITTAPI ITTAPI_CDECL
#define LIBITTAPI ITTAPI_CDECL #define LIBITTAPI ITTAPI_CDECL
/* TODO: Temporary for compatibility! */ /* TODO: Temporary for compatibility! */
#define ITTAPI_CALL ITTAPI_CDECL #define ITTAPI_CALL ITTAPI_CDECL
#define LIBITTAPI_CALL ITTAPI_CDECL #define LIBITTAPI_CALL ITTAPI_CDECL
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
/* use __forceinline (VC++ specific) */ /* use __forceinline (VC++ specific) */
#define ITT_INLINE __forceinline #define ITT_INLINE __forceinline
#define ITT_INLINE_ATTRIBUTE /* nothing */ #define ITT_INLINE_ATTRIBUTE /* nothing */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/* /*
* Generally, functions are not inlined unless optimization is specified. * Generally, functions are not inlined unless optimization is specified.
* For functions declared inline, this attribute inlines the function even * For functions declared inline, this attribute inlines the function even
* if no optimization level was specified. * if no optimization level was specified.
*/ */
#ifdef __STRICT_ANSI__ #ifdef __STRICT_ANSI__
#define ITT_INLINE static #define ITT_INLINE static
#define ITT_INLINE_ATTRIBUTE __attribute__((unused)) #define ITT_INLINE_ATTRIBUTE __attribute__((unused))
#else /* __STRICT_ANSI__ */ #else /* __STRICT_ANSI__ */
#define ITT_INLINE static inline #define ITT_INLINE static inline
#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused)) #define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
#endif /* __STRICT_ANSI__ */ #endif /* __STRICT_ANSI__ */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @endcond */ /** @endcond */
#ifdef INTEL_ITTNOTIFY_ENABLE_LEGACY #ifdef INTEL_ITTNOTIFY_ENABLE_LEGACY
# if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
# pragma message("WARNING!!! Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro") #pragma message( \
"WARNING!!! Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro")
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# warning "Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro" #warning \
"Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro"
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# include "legacy/ittnotify.h" #include "legacy/ittnotify.h"
#endif /* INTEL_ITTNOTIFY_ENABLE_LEGACY */ #endif /* INTEL_ITTNOTIFY_ENABLE_LEGACY */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
/* Helper macro for joining tokens */ /* Helper macro for joining tokens */
#define ITT_JOIN_AUX(p,n) p##n #define ITT_JOIN_AUX(p, n) p##n
#define ITT_JOIN(p,n) ITT_JOIN_AUX(p,n) #define ITT_JOIN(p, n) ITT_JOIN_AUX(p, n)
#ifdef ITT_MAJOR #ifdef ITT_MAJOR
#undef ITT_MAJOR #undef ITT_MAJOR
#endif #endif
#ifdef ITT_MINOR #ifdef ITT_MINOR
#undef ITT_MINOR #undef ITT_MINOR
#endif #endif
#define ITT_MAJOR 3 #define ITT_MAJOR 3
#define ITT_MINOR 0 #define ITT_MINOR 0
/* Standard versioning of a token with major and minor version numbers */ /* Standard versioning of a token with major and minor version numbers */
#define ITT_VERSIONIZE(x) \ #define ITT_VERSIONIZE(x) \
ITT_JOIN(x, \ ITT_JOIN(x, ITT_JOIN(_, ITT_JOIN(ITT_MAJOR, ITT_JOIN(_, ITT_MINOR))))
ITT_JOIN(_, \
ITT_JOIN(ITT_MAJOR, \
ITT_JOIN(_, ITT_MINOR))))
#ifndef INTEL_ITTNOTIFY_PREFIX #ifndef INTEL_ITTNOTIFY_PREFIX
# define INTEL_ITTNOTIFY_PREFIX __itt_ #define INTEL_ITTNOTIFY_PREFIX __itt_
#endif /* INTEL_ITTNOTIFY_PREFIX */ #endif /* INTEL_ITTNOTIFY_PREFIX */
#ifndef INTEL_ITTNOTIFY_POSTFIX #ifndef INTEL_ITTNOTIFY_POSTFIX
# define INTEL_ITTNOTIFY_POSTFIX _ptr_ #define INTEL_ITTNOTIFY_POSTFIX _ptr_
#endif /* INTEL_ITTNOTIFY_POSTFIX */ #endif /* INTEL_ITTNOTIFY_POSTFIX */
#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n) #define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)
#define ITTNOTIFY_NAME(n) ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n,INTEL_ITTNOTIFY_POSTFIX))) #define ITTNOTIFY_NAME(n) \
ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n, INTEL_ITTNOTIFY_POSTFIX)))
#define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n) #define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)
#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n) #define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)
#define ITTNOTIFY_VOID_D0(n,d) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d) #define ITTNOTIFY_VOID_D0(n, d) \
#define ITTNOTIFY_VOID_D1(n,d,x) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x) (!(d)->flags) ? (void)0 \
#define ITTNOTIFY_VOID_D2(n,d,x,y) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y) : (!ITTNOTIFY_NAME(n)) ? (void)0 \
#define ITTNOTIFY_VOID_D3(n,d,x,y,z) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z) : ITTNOTIFY_NAME(n)(d)
#define ITTNOTIFY_VOID_D4(n,d,x,y,z,a) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a) #define ITTNOTIFY_VOID_D1(n, d, x) \
#define ITTNOTIFY_VOID_D5(n,d,x,y,z,a,b) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b) (!(d)->flags) ? (void)0 \
#define ITTNOTIFY_VOID_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c) : (!ITTNOTIFY_NAME(n)) ? (void)0 \
#define ITTNOTIFY_DATA_D0(n,d) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d) : ITTNOTIFY_NAME(n)(d, x)
#define ITTNOTIFY_DATA_D1(n,d,x) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x) #define ITTNOTIFY_VOID_D2(n, d, x, y) \
#define ITTNOTIFY_DATA_D2(n,d,x,y) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y) (!(d)->flags) ? (void)0 \
#define ITTNOTIFY_DATA_D3(n,d,x,y,z) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z) : (!ITTNOTIFY_NAME(n)) ? (void)0 \
#define ITTNOTIFY_DATA_D4(n,d,x,y,z,a) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a) : ITTNOTIFY_NAME(n)(d, x, y)
#define ITTNOTIFY_DATA_D5(n,d,x,y,z,a,b) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b) #define ITTNOTIFY_VOID_D3(n, d, x, y, z) \
#define ITTNOTIFY_DATA_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c) (!(d)->flags) ? (void)0 \
: (!ITTNOTIFY_NAME(n)) ? (void)0 \
: ITTNOTIFY_NAME(n)(d, x, y, z)
#define ITTNOTIFY_VOID_D4(n, d, x, y, z, a) \
(!(d)->flags) ? (void)0 \
: (!ITTNOTIFY_NAME(n)) ? (void)0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a)
#define ITTNOTIFY_VOID_D5(n, d, x, y, z, a, b) \
(!(d)->flags) ? (void)0 \
: (!ITTNOTIFY_NAME(n)) ? (void)0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a, b)
#define ITTNOTIFY_VOID_D6(n, d, x, y, z, a, b, c) \
(!(d)->flags) ? (void)0 \
: (!ITTNOTIFY_NAME(n)) ? (void)0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c)
#define ITTNOTIFY_DATA_D0(n, d) \
(!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d)
#define ITTNOTIFY_DATA_D1(n, d, x) \
(!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x)
#define ITTNOTIFY_DATA_D2(n, d, x, y) \
(!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y)
#define ITTNOTIFY_DATA_D3(n, d, x, y, z) \
(!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y, z)
#define ITTNOTIFY_DATA_D4(n, d, x, y, z, a) \
(!(d)->flags) ? 0 \
: (!ITTNOTIFY_NAME(n)) ? 0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a)
#define ITTNOTIFY_DATA_D5(n, d, x, y, z, a, b) \
(!(d)->flags) ? 0 \
: (!ITTNOTIFY_NAME(n)) ? 0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a, b)
#define ITTNOTIFY_DATA_D6(n, d, x, y, z, a, b, c) \
(!(d)->flags) ? 0 \
: (!ITTNOTIFY_NAME(n)) ? 0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c)
#ifdef ITT_STUB #ifdef ITT_STUB
#undef ITT_STUB #undef ITT_STUB
#endif #endif
#ifdef ITT_STUBV #ifdef ITT_STUBV
#undef ITT_STUBV #undef ITT_STUBV
#endif #endif
#define ITT_STUBV(api,type,name,args) \ #define ITT_STUBV(api, type, name, args) \
typedef type (api* ITT_JOIN(ITTNOTIFY_NAME(name),_t)) args; \ typedef type(api *ITT_JOIN(ITTNOTIFY_NAME(name), _t)) args; \
extern ITT_JOIN(ITTNOTIFY_NAME(name),_t) ITTNOTIFY_NAME(name); extern ITT_JOIN(ITTNOTIFY_NAME(name), _t) ITTNOTIFY_NAME(name);
#define ITT_STUB ITT_STUBV #define ITT_STUB ITT_STUBV
/** @endcond */ /** @endcond */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/** @cond exclude_from_gpa_documentation */ /** @cond exclude_from_gpa_documentation */
/** /**
* @defgroup public Public API * @defgroup public Public API
* @{ * @{
* @} * @}
*/ */
/** /**
* @defgroup control Collection Control * @defgroup control Collection Control
* @ingroup public * @ingroup public
* General behavior: application continues to run, but no profiling information is being collected * General behavior: application continues to run, but no profiling information
* is being collected
* *
* Pausing occurs not only for the current thread but for all process as well as spawned processes * Pausing occurs not only for the current thread but for all process as well as
* spawned processes
* - Intel(R) Parallel Inspector and Intel(R) Inspector XE: * - Intel(R) Parallel Inspector and Intel(R) Inspector XE:
* - Does not analyze or report errors that involve memory access. * - Does not analyze or report errors that involve memory access.
* - Other errors are reported as usual. Pausing data collection in * - Other errors are reported as usual. Pausing data collection in
* Intel(R) Parallel Inspector and Intel(R) Inspector XE * Intel(R) Parallel Inspector and Intel(R) Inspector XE
* only pauses tracing and analyzing memory access. * only pauses tracing and analyzing memory access.
* It does not pause tracing or analyzing threading APIs. * It does not pause tracing or analyzing threading APIs.
* . * .
* - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE: * - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE:
Show All 9 Lines
/** @brief Resume collection */ /** @brief Resume collection */
void ITTAPI __itt_resume(void); void ITTAPI __itt_resume(void);
/** @brief Detach collection */ /** @brief Detach collection */
void ITTAPI __itt_detach(void); void ITTAPI __itt_detach(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, pause, (void)) ITT_STUBV(ITTAPI, void, pause, (void))
ITT_STUBV(ITTAPI, void, resume, (void)) ITT_STUBV(ITTAPI, void, resume, (void))
ITT_STUBV(ITTAPI, void, detach, (void)) ITT_STUBV(ITTAPI, void, detach, (void))
#define __itt_pause ITTNOTIFY_VOID(pause) #define __itt_pause ITTNOTIFY_VOID(pause)
#define __itt_pause_ptr ITTNOTIFY_NAME(pause) #define __itt_pause_ptr ITTNOTIFY_NAME(pause)
#define __itt_resume ITTNOTIFY_VOID(resume) #define __itt_resume ITTNOTIFY_VOID(resume)
#define __itt_resume_ptr ITTNOTIFY_NAME(resume) #define __itt_resume_ptr ITTNOTIFY_NAME(resume)
#define __itt_detach ITTNOTIFY_VOID(detach) #define __itt_detach ITTNOTIFY_VOID(detach)
#define __itt_detach_ptr ITTNOTIFY_NAME(detach) #define __itt_detach_ptr ITTNOTIFY_NAME(detach)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_pause() #define __itt_pause()
#define __itt_pause_ptr 0 #define __itt_pause_ptr 0
#define __itt_resume() #define __itt_resume()
#define __itt_resume_ptr 0 #define __itt_resume_ptr 0
#define __itt_detach() #define __itt_detach()
#define __itt_detach_ptr 0 #define __itt_detach_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_pause_ptr 0 #define __itt_pause_ptr 0
#define __itt_resume_ptr 0 #define __itt_resume_ptr 0
#define __itt_detach_ptr 0 #define __itt_detach_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} control group */ /** @} control group */
/** @endcond */ /** @endcond */
/** /**
* @defgroup threads Threads * @defgroup threads Threads
* @ingroup public * @ingroup public
* Give names to threads * Give names to threads
* @{ * @{
*/ */
/** /**
* @brief Sets thread name of calling thread * @brief Sets thread name of calling thread
* @param[in] name - name of thread * @param[in] name - name of thread
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_thread_set_nameA(const char *name); void ITTAPI __itt_thread_set_nameA(const char *name);
void ITTAPI __itt_thread_set_nameW(const wchar_t *name); void ITTAPI __itt_thread_set_nameW(const wchar_t *name);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_thread_set_name __itt_thread_set_nameW #define __itt_thread_set_name __itt_thread_set_nameW
# define __itt_thread_set_name_ptr __itt_thread_set_nameW_ptr #define __itt_thread_set_name_ptr __itt_thread_set_nameW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_thread_set_name __itt_thread_set_nameA #define __itt_thread_set_name __itt_thread_set_nameA
# define __itt_thread_set_name_ptr __itt_thread_set_nameA_ptr #define __itt_thread_set_name_ptr __itt_thread_set_nameA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
void ITTAPI __itt_thread_set_name(const char *name); void ITTAPI __itt_thread_set_name(const char *name);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name)) ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name))
ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name)) ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name)) ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_thread_set_nameA ITTNOTIFY_VOID(thread_set_nameA) #define __itt_thread_set_nameA ITTNOTIFY_VOID(thread_set_nameA)
#define __itt_thread_set_nameA_ptr ITTNOTIFY_NAME(thread_set_nameA) #define __itt_thread_set_nameA_ptr ITTNOTIFY_NAME(thread_set_nameA)
#define __itt_thread_set_nameW ITTNOTIFY_VOID(thread_set_nameW) #define __itt_thread_set_nameW ITTNOTIFY_VOID(thread_set_nameW)
#define __itt_thread_set_nameW_ptr ITTNOTIFY_NAME(thread_set_nameW) #define __itt_thread_set_nameW_ptr ITTNOTIFY_NAME(thread_set_nameW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thread_set_name ITTNOTIFY_VOID(thread_set_name) #define __itt_thread_set_name ITTNOTIFY_VOID(thread_set_name)
#define __itt_thread_set_name_ptr ITTNOTIFY_NAME(thread_set_name) #define __itt_thread_set_name_ptr ITTNOTIFY_NAME(thread_set_name)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_thread_set_nameA(name) #define __itt_thread_set_nameA(name)
#define __itt_thread_set_nameA_ptr 0 #define __itt_thread_set_nameA_ptr 0
#define __itt_thread_set_nameW(name) #define __itt_thread_set_nameW(name)
#define __itt_thread_set_nameW_ptr 0 #define __itt_thread_set_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thread_set_name(name) #define __itt_thread_set_name(name)
#define __itt_thread_set_name_ptr 0 #define __itt_thread_set_name_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_thread_set_nameA_ptr 0 #define __itt_thread_set_nameA_ptr 0
#define __itt_thread_set_nameW_ptr 0 #define __itt_thread_set_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thread_set_name_ptr 0 #define __itt_thread_set_name_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @cond exclude_from_gpa_documentation */ /** @cond exclude_from_gpa_documentation */
/** /**
* @brief Mark current thread as ignored from this point on, for the duration of its existence. * @brief Mark current thread as ignored from this point on, for the duration of
* its existence.
*/ */
void ITTAPI __itt_thread_ignore(void); void ITTAPI __itt_thread_ignore(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, thread_ignore, (void)) ITT_STUBV(ITTAPI, void, thread_ignore, (void))
#define __itt_thread_ignore ITTNOTIFY_VOID(thread_ignore) #define __itt_thread_ignore ITTNOTIFY_VOID(thread_ignore)
#define __itt_thread_ignore_ptr ITTNOTIFY_NAME(thread_ignore) #define __itt_thread_ignore_ptr ITTNOTIFY_NAME(thread_ignore)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_thread_ignore() #define __itt_thread_ignore()
#define __itt_thread_ignore_ptr 0 #define __itt_thread_ignore_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_thread_ignore_ptr 0 #define __itt_thread_ignore_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} threads group */ /** @} threads group */
/** /**
* @defgroup suppress Error suppression * @defgroup suppress Error suppression
* @ingroup public * @ingroup public
* General behavior: application continues to run, but errors are suppressed * General behavior: application continues to run, but errors are suppressed
* *
* @{ * @{
*/ */
// clang-format off
/*****************************************************************//** /*****************************************************************//**
* @name group of functions used for error suppression in correctness tools * @name group of functions used for error suppression in correctness tools
*********************************************************************/ *********************************************************************/
// clang-format on
/** @{ */ /** @{ */
/** /**
* @hideinitializer * @hideinitializer
* @brief possible value for suppression mask * @brief possible value for suppression mask
*/ */
#define __itt_suppress_all_errors 0x7fffffff #define __itt_suppress_all_errors 0x7fffffff
/** /**
* @hideinitializer * @hideinitializer
jdoerfertUnsubmitted
Done
ReplyInline Actions

This needs to be fixed. Change the comment style or sth

jdoerfert: This needs to be fixed. Change the comment style or sth
* @brief possible value for suppression mask (suppresses errors from threading analysis) * @brief possible value for suppression mask (suppresses errors from threading
* analysis)
*/ */
#define __itt_suppress_threading_errors 0x000000ff #define __itt_suppress_threading_errors 0x000000ff
/** /**
* @hideinitializer * @hideinitializer
* @brief possible value for suppression mask (suppresses errors from memory analysis) * @brief possible value for suppression mask (suppresses errors from memory
* analysis)
*/ */
#define __itt_suppress_memory_errors 0x0000ff00 #define __itt_suppress_memory_errors 0x0000ff00
/** /**
* @brief Start suppressing errors identified in mask on this thread * @brief Start suppressing errors identified in mask on this thread
*/ */
void ITTAPI __itt_suppress_push(unsigned int mask); void ITTAPI __itt_suppress_push(unsigned int mask);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask)) ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask))
#define __itt_suppress_push ITTNOTIFY_VOID(suppress_push) #define __itt_suppress_push ITTNOTIFY_VOID(suppress_push)
#define __itt_suppress_push_ptr ITTNOTIFY_NAME(suppress_push) #define __itt_suppress_push_ptr ITTNOTIFY_NAME(suppress_push)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_suppress_push(mask) #define __itt_suppress_push(mask)
#define __itt_suppress_push_ptr 0 #define __itt_suppress_push_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_suppress_push_ptr 0 #define __itt_suppress_push_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Undo the effects of the matching call to __itt_suppress_push * @brief Undo the effects of the matching call to __itt_suppress_push
*/ */
void ITTAPI __itt_suppress_pop(void); void ITTAPI __itt_suppress_pop(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, suppress_pop, (void)) ITT_STUBV(ITTAPI, void, suppress_pop, (void))
#define __itt_suppress_pop ITTNOTIFY_VOID(suppress_pop) #define __itt_suppress_pop ITTNOTIFY_VOID(suppress_pop)
#define __itt_suppress_pop_ptr ITTNOTIFY_NAME(suppress_pop) #define __itt_suppress_pop_ptr ITTNOTIFY_NAME(suppress_pop)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_suppress_pop() #define __itt_suppress_pop()
#define __itt_suppress_pop_ptr 0 #define __itt_suppress_pop_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_suppress_pop_ptr 0 #define __itt_suppress_pop_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @enum __itt_model_disable * @enum __itt_model_disable
* @brief Enumerator for the disable methods * @brief Enumerator for the disable methods
*/ */
typedef enum __itt_suppress_mode { typedef enum __itt_suppress_mode {
__itt_unsuppress_range, __itt_unsuppress_range,
__itt_suppress_range __itt_suppress_range
} __itt_suppress_mode_t; } __itt_suppress_mode_t;
/** /**
* @brief Mark a range of memory for error suppression or unsuppression for error types included in mask * @brief Mark a range of memory for error suppression or unsuppression for
* error types included in mask
*/ */
void ITTAPI __itt_suppress_mark_range(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size); void ITTAPI __itt_suppress_mark_range(__itt_suppress_mode_t mode,
unsigned int mask, void *address,
size_t size);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, suppress_mark_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size)) ITT_STUBV(ITTAPI, void, suppress_mark_range,
(__itt_suppress_mode_t mode, unsigned int mask, void *address,
size_t size))
#define __itt_suppress_mark_range ITTNOTIFY_VOID(suppress_mark_range) #define __itt_suppress_mark_range ITTNOTIFY_VOID(suppress_mark_range)
#define __itt_suppress_mark_range_ptr ITTNOTIFY_NAME(suppress_mark_range) #define __itt_suppress_mark_range_ptr ITTNOTIFY_NAME(suppress_mark_range)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_suppress_mark_range(mask) #define __itt_suppress_mark_range(mask)
#define __itt_suppress_mark_range_ptr 0 #define __itt_suppress_mark_range_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_suppress_mark_range_ptr 0 #define __itt_suppress_mark_range_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Undo the effect of a matching call to __itt_suppress_mark_range. If not matching * @brief Undo the effect of a matching call to __itt_suppress_mark_range. If
* call is found, nothing is changed. * not matching call is found, nothing is changed.
*/ */
void ITTAPI __itt_suppress_clear_range(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size); void ITTAPI __itt_suppress_clear_range(__itt_suppress_mode_t mode,
unsigned int mask, void *address,
size_t size);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, suppress_clear_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size)) ITT_STUBV(ITTAPI, void, suppress_clear_range,
(__itt_suppress_mode_t mode, unsigned int mask, void *address,
size_t size))
#define __itt_suppress_clear_range ITTNOTIFY_VOID(suppress_clear_range) #define __itt_suppress_clear_range ITTNOTIFY_VOID(suppress_clear_range)
#define __itt_suppress_clear_range_ptr ITTNOTIFY_NAME(suppress_clear_range) #define __itt_suppress_clear_range_ptr ITTNOTIFY_NAME(suppress_clear_range)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_suppress_clear_range(mask) #define __itt_suppress_clear_range(mask)
#define __itt_suppress_clear_range_ptr 0 #define __itt_suppress_clear_range_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_suppress_clear_range_ptr 0 #define __itt_suppress_clear_range_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} */ /** @} */
/** @} suppress group */ /** @} suppress group */
/** /**
* @defgroup sync Synchronization * @defgroup sync Synchronization
* @ingroup public * @ingroup public
* Indicate user-written synchronization code * Indicate user-written synchronization code
* @{ * @{
*/ */
/** /**
* @hideinitializer * @hideinitializer
* @brief possible value of attribute argument for sync object type * @brief possible value of attribute argument for sync object type
*/ */
#define __itt_attr_barrier 1 #define __itt_attr_barrier 1
/** /**
* @hideinitializer * @hideinitializer
* @brief possible value of attribute argument for sync object type * @brief possible value of attribute argument for sync object type
*/ */
#define __itt_attr_mutex 2 #define __itt_attr_mutex 2
/** /**
@brief Name a synchronization object @brief Name a synchronization object
@param[in] addr Handle for the synchronization object. You should @param[in] addr Handle for the synchronization object. You should
use a real address to uniquely identify the synchronization object. use a real address to uniquely identify the synchronization object.
@param[in] objtype null-terminated object type string. If NULL is @param[in] objtype null-terminated object type string. If NULL is
passed, the name will be "User Synchronization". passed, the name will be "User Synchronization".
@param[in] objname null-terminated object name string. If NULL, @param[in] objname null-terminated object name string. If NULL,
no name will be assigned to the object. no name will be assigned to the object.
@param[in] attribute one of [#__itt_attr_barrier, #__itt_attr_mutex] @param[in] attribute one of [#__itt_attr_barrier, #__itt_attr_mutex]
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_sync_createA(void *addr, const char *objtype, const char *objname, int attribute); void ITTAPI __itt_sync_createA(void *addr, const char *objtype,
void ITTAPI __itt_sync_createW(void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute); const char *objname, int attribute);
void ITTAPI __itt_sync_createW(void *addr, const wchar_t *objtype,
const wchar_t *objname, int attribute);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_sync_create __itt_sync_createW #define __itt_sync_create __itt_sync_createW
# define __itt_sync_create_ptr __itt_sync_createW_ptr #define __itt_sync_create_ptr __itt_sync_createW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_sync_create __itt_sync_createA #define __itt_sync_create __itt_sync_createA
# define __itt_sync_create_ptr __itt_sync_createA_ptr #define __itt_sync_create_ptr __itt_sync_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
void ITTAPI __itt_sync_create (void *addr, const char *objtype, const char *objname, int attribute); void ITTAPI __itt_sync_create(void *addr, const char *objtype,
const char *objname, int attribute);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, sync_createA, (void *addr, const char *objtype, const char *objname, int attribute)) ITT_STUBV(ITTAPI, void, sync_createA,
ITT_STUBV(ITTAPI, void, sync_createW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute)) (void *addr, const char *objtype, const char *objname, int attribute))
ITT_STUBV(ITTAPI, void, sync_createW,
(void *addr, const wchar_t *objtype, const wchar_t *objname,
int attribute))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_create, (void *addr, const char* objtype, const char* objname, int attribute)) ITT_STUBV(ITTAPI, void, sync_create,
(void *addr, const char *objtype, const char *objname, int attribute))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_createA ITTNOTIFY_VOID(sync_createA) #define __itt_sync_createA ITTNOTIFY_VOID(sync_createA)
#define __itt_sync_createA_ptr ITTNOTIFY_NAME(sync_createA) #define __itt_sync_createA_ptr ITTNOTIFY_NAME(sync_createA)
#define __itt_sync_createW ITTNOTIFY_VOID(sync_createW) #define __itt_sync_createW ITTNOTIFY_VOID(sync_createW)
#define __itt_sync_createW_ptr ITTNOTIFY_NAME(sync_createW) #define __itt_sync_createW_ptr ITTNOTIFY_NAME(sync_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_create ITTNOTIFY_VOID(sync_create) #define __itt_sync_create ITTNOTIFY_VOID(sync_create)
#define __itt_sync_create_ptr ITTNOTIFY_NAME(sync_create) #define __itt_sync_create_ptr ITTNOTIFY_NAME(sync_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_createA(addr, objtype, objname, attribute) #define __itt_sync_createA(addr, objtype, objname, attribute)
#define __itt_sync_createA_ptr 0 #define __itt_sync_createA_ptr 0
#define __itt_sync_createW(addr, objtype, objname, attribute) #define __itt_sync_createW(addr, objtype, objname, attribute)
#define __itt_sync_createW_ptr 0 #define __itt_sync_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_create(addr, objtype, objname, attribute) #define __itt_sync_create(addr, objtype, objname, attribute)
#define __itt_sync_create_ptr 0 #define __itt_sync_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_createA_ptr 0 #define __itt_sync_createA_ptr 0
#define __itt_sync_createW_ptr 0 #define __itt_sync_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_create_ptr 0 #define __itt_sync_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
@brief Rename a synchronization object @brief Rename a synchronization object
You can use the rename call to assign or reassign a name to a given You can use the rename call to assign or reassign a name to a given
synchronization object. synchronization object.
@param[in] addr handle for the synchronization object. @param[in] addr handle for the synchronization object.
@param[in] name null-terminated object name string. @param[in] name null-terminated object name string.
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_sync_renameA(void *addr, const char *name); void ITTAPI __itt_sync_renameA(void *addr, const char *name);
void ITTAPI __itt_sync_renameW(void *addr, const wchar_t *name); void ITTAPI __itt_sync_renameW(void *addr, const wchar_t *name);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_sync_rename __itt_sync_renameW #define __itt_sync_rename __itt_sync_renameW
# define __itt_sync_rename_ptr __itt_sync_renameW_ptr #define __itt_sync_rename_ptr __itt_sync_renameW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_sync_rename __itt_sync_renameA #define __itt_sync_rename __itt_sync_renameA
# define __itt_sync_rename_ptr __itt_sync_renameA_ptr #define __itt_sync_rename_ptr __itt_sync_renameA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
void ITTAPI __itt_sync_rename(void *addr, const char *name); void ITTAPI __itt_sync_rename(void *addr, const char *name);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name)) ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name))
ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name)) ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name)) ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_renameA ITTNOTIFY_VOID(sync_renameA) #define __itt_sync_renameA ITTNOTIFY_VOID(sync_renameA)
#define __itt_sync_renameA_ptr ITTNOTIFY_NAME(sync_renameA) #define __itt_sync_renameA_ptr ITTNOTIFY_NAME(sync_renameA)
#define __itt_sync_renameW ITTNOTIFY_VOID(sync_renameW) #define __itt_sync_renameW ITTNOTIFY_VOID(sync_renameW)
#define __itt_sync_renameW_ptr ITTNOTIFY_NAME(sync_renameW) #define __itt_sync_renameW_ptr ITTNOTIFY_NAME(sync_renameW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_rename ITTNOTIFY_VOID(sync_rename) #define __itt_sync_rename ITTNOTIFY_VOID(sync_rename)
#define __itt_sync_rename_ptr ITTNOTIFY_NAME(sync_rename) #define __itt_sync_rename_ptr ITTNOTIFY_NAME(sync_rename)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_renameA(addr, name) #define __itt_sync_renameA(addr, name)
#define __itt_sync_renameA_ptr 0 #define __itt_sync_renameA_ptr 0
#define __itt_sync_renameW(addr, name) #define __itt_sync_renameW(addr, name)
#define __itt_sync_renameW_ptr 0 #define __itt_sync_renameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_rename(addr, name) #define __itt_sync_rename(addr, name)
#define __itt_sync_rename_ptr 0 #define __itt_sync_rename_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_renameA_ptr 0 #define __itt_sync_renameA_ptr 0
#define __itt_sync_renameW_ptr 0 #define __itt_sync_renameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_rename_ptr 0 #define __itt_sync_rename_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
@brief Destroy a synchronization object. @brief Destroy a synchronization object.
@param addr Handle for the synchronization object. @param addr Handle for the synchronization object.
*/ */
void ITTAPI __itt_sync_destroy(void *addr); void ITTAPI __itt_sync_destroy(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr)) ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr))
#define __itt_sync_destroy ITTNOTIFY_VOID(sync_destroy) #define __itt_sync_destroy ITTNOTIFY_VOID(sync_destroy)
#define __itt_sync_destroy_ptr ITTNOTIFY_NAME(sync_destroy) #define __itt_sync_destroy_ptr ITTNOTIFY_NAME(sync_destroy)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_sync_destroy(addr) #define __itt_sync_destroy(addr)
#define __itt_sync_destroy_ptr 0 #define __itt_sync_destroy_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_sync_destroy_ptr 0 #define __itt_sync_destroy_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
// clang-format off
/*****************************************************************//** /*****************************************************************//**
* @name group of functions is used for performance measurement tools * @name group of functions is used for performance measurement tools
*********************************************************************/ *********************************************************************/
// clang-format on
/** @{ */ /** @{ */
/** /**
* @brief Enter spin loop on user-defined sync object * @brief Enter spin loop on user-defined sync object
*/ */
void ITTAPI __itt_sync_prepare(void* addr); void ITTAPI __itt_sync_prepare(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
jdoerfertUnsubmitted
Done
ReplyInline Actions

same.

jdoerfert: same.
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, sync_prepare, (void *addr)) ITT_STUBV(ITTAPI, void, sync_prepare, (void *addr))
#define __itt_sync_prepare ITTNOTIFY_VOID(sync_prepare) #define __itt_sync_prepare ITTNOTIFY_VOID(sync_prepare)
#define __itt_sync_prepare_ptr ITTNOTIFY_NAME(sync_prepare) #define __itt_sync_prepare_ptr ITTNOTIFY_NAME(sync_prepare)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_sync_prepare(addr) #define __itt_sync_prepare(addr)
#define __itt_sync_prepare_ptr 0 #define __itt_sync_prepare_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_sync_prepare_ptr 0 #define __itt_sync_prepare_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Quit spin loop without acquiring spin object * @brief Quit spin loop without acquiring spin object
*/ */
void ITTAPI __itt_sync_cancel(void *addr); void ITTAPI __itt_sync_cancel(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr)) ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr))
#define __itt_sync_cancel ITTNOTIFY_VOID(sync_cancel) #define __itt_sync_cancel ITTNOTIFY_VOID(sync_cancel)
#define __itt_sync_cancel_ptr ITTNOTIFY_NAME(sync_cancel) #define __itt_sync_cancel_ptr ITTNOTIFY_NAME(sync_cancel)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_sync_cancel(addr) #define __itt_sync_cancel(addr)
#define __itt_sync_cancel_ptr 0 #define __itt_sync_cancel_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_sync_cancel_ptr 0 #define __itt_sync_cancel_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Successful spin loop completion (sync object acquired) * @brief Successful spin loop completion (sync object acquired)
*/ */
void ITTAPI __itt_sync_acquired(void *addr); void ITTAPI __itt_sync_acquired(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr)) ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr))
#define __itt_sync_acquired ITTNOTIFY_VOID(sync_acquired) #define __itt_sync_acquired ITTNOTIFY_VOID(sync_acquired)
#define __itt_sync_acquired_ptr ITTNOTIFY_NAME(sync_acquired) #define __itt_sync_acquired_ptr ITTNOTIFY_NAME(sync_acquired)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_sync_acquired(addr) #define __itt_sync_acquired(addr)
#define __itt_sync_acquired_ptr 0 #define __itt_sync_acquired_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_sync_acquired_ptr 0 #define __itt_sync_acquired_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Start sync object releasing code. Is called before the lock release call. * @brief Start sync object releasing code. Is called before the lock release
* call.
*/ */
void ITTAPI __itt_sync_releasing(void* addr); void ITTAPI __itt_sync_releasing(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, sync_releasing, (void *addr)) ITT_STUBV(ITTAPI, void, sync_releasing, (void *addr))
#define __itt_sync_releasing ITTNOTIFY_VOID(sync_releasing) #define __itt_sync_releasing ITTNOTIFY_VOID(sync_releasing)
#define __itt_sync_releasing_ptr ITTNOTIFY_NAME(sync_releasing) #define __itt_sync_releasing_ptr ITTNOTIFY_NAME(sync_releasing)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_sync_releasing(addr) #define __itt_sync_releasing(addr)
#define __itt_sync_releasing_ptr 0 #define __itt_sync_releasing_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_sync_releasing_ptr 0 #define __itt_sync_releasing_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} */ /** @} */
/** @} sync group */ /** @} sync group */
// clang-format off
/**************************************************************//** /**************************************************************//**
* @name group of functions is used for correctness checking tools * @name group of functions is used for correctness checking tools
******************************************************************/ ******************************************************************/
// clang-format on
/** @{ */ /** @{ */
/** /**
* @ingroup legacy * @ingroup legacy
* @deprecated Legacy API * @deprecated Legacy API
* @brief Fast synchronization which does no require spinning. * @brief Fast synchronization which does no require spinning.
* - This special function is to be used by TBB and OpenMP libraries only when they know * - This special function is to be used by TBB and OpenMP libraries only when
jdoerfertUnsubmitted
Done
ReplyInline Actions

same.

jdoerfert: same.
* there is no spin but they need to suppress TC warnings about shared variable modifications. * they know there is no spin but they need to suppress TC warnings about shared
* - It only has corresponding pointers in static library and does not have corresponding function * variable modifications.
* in dynamic library. * - It only has corresponding pointers in static library and does not have
* corresponding function in dynamic library.
* @see void __itt_sync_prepare(void* addr); * @see void __itt_sync_prepare(void* addr);
*/ */
void ITTAPI __itt_fsync_prepare(void* addr); void ITTAPI __itt_fsync_prepare(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, fsync_prepare, (void *addr)) ITT_STUBV(ITTAPI, void, fsync_prepare, (void *addr))
#define __itt_fsync_prepare ITTNOTIFY_VOID(fsync_prepare) #define __itt_fsync_prepare ITTNOTIFY_VOID(fsync_prepare)
#define __itt_fsync_prepare_ptr ITTNOTIFY_NAME(fsync_prepare) #define __itt_fsync_prepare_ptr ITTNOTIFY_NAME(fsync_prepare)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_fsync_prepare(addr) #define __itt_fsync_prepare(addr)
#define __itt_fsync_prepare_ptr 0 #define __itt_fsync_prepare_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_fsync_prepare_ptr 0 #define __itt_fsync_prepare_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup legacy * @ingroup legacy
* @deprecated Legacy API * @deprecated Legacy API
* @brief Fast synchronization which does no require spinning. * @brief Fast synchronization which does no require spinning.
* - This special function is to be used by TBB and OpenMP libraries only when they know * - This special function is to be used by TBB and OpenMP libraries only when
* there is no spin but they need to suppress TC warnings about shared variable modifications. * they know there is no spin but they need to suppress TC warnings about shared
* - It only has corresponding pointers in static library and does not have corresponding function * variable modifications.
* in dynamic library. * - It only has corresponding pointers in static library and does not have
* corresponding function in dynamic library.
* @see void __itt_sync_cancel(void *addr); * @see void __itt_sync_cancel(void *addr);
*/ */
void ITTAPI __itt_fsync_cancel(void *addr); void ITTAPI __itt_fsync_cancel(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr)) ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr))
#define __itt_fsync_cancel ITTNOTIFY_VOID(fsync_cancel) #define __itt_fsync_cancel ITTNOTIFY_VOID(fsync_cancel)
#define __itt_fsync_cancel_ptr ITTNOTIFY_NAME(fsync_cancel) #define __itt_fsync_cancel_ptr ITTNOTIFY_NAME(fsync_cancel)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_fsync_cancel(addr) #define __itt_fsync_cancel(addr)
#define __itt_fsync_cancel_ptr 0 #define __itt_fsync_cancel_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_fsync_cancel_ptr 0 #define __itt_fsync_cancel_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup legacy * @ingroup legacy
* @deprecated Legacy API * @deprecated Legacy API
* @brief Fast synchronization which does no require spinning. * @brief Fast synchronization which does no require spinning.
* - This special function is to be used by TBB and OpenMP libraries only when they know * - This special function is to be used by TBB and OpenMP libraries only when
* there is no spin but they need to suppress TC warnings about shared variable modifications. * they know there is no spin but they need to suppress TC warnings about shared
* - It only has corresponding pointers in static library and does not have corresponding function * variable modifications.
* in dynamic library. * - It only has corresponding pointers in static library and does not have
* corresponding function in dynamic library.
* @see void __itt_sync_acquired(void *addr); * @see void __itt_sync_acquired(void *addr);
*/ */
void ITTAPI __itt_fsync_acquired(void *addr); void ITTAPI __itt_fsync_acquired(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr)) ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr))
#define __itt_fsync_acquired ITTNOTIFY_VOID(fsync_acquired) #define __itt_fsync_acquired ITTNOTIFY_VOID(fsync_acquired)
#define __itt_fsync_acquired_ptr ITTNOTIFY_NAME(fsync_acquired) #define __itt_fsync_acquired_ptr ITTNOTIFY_NAME(fsync_acquired)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_fsync_acquired(addr) #define __itt_fsync_acquired(addr)
#define __itt_fsync_acquired_ptr 0 #define __itt_fsync_acquired_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_fsync_acquired_ptr 0 #define __itt_fsync_acquired_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup legacy * @ingroup legacy
* @deprecated Legacy API * @deprecated Legacy API
* @brief Fast synchronization which does no require spinning. * @brief Fast synchronization which does no require spinning.
* - This special function is to be used by TBB and OpenMP libraries only when they know * - This special function is to be used by TBB and OpenMP libraries only when
* there is no spin but they need to suppress TC warnings about shared variable modifications. * they know there is no spin but they need to suppress TC warnings about shared
* - It only has corresponding pointers in static library and does not have corresponding function * variable modifications.
* in dynamic library. * - It only has corresponding pointers in static library and does not have
* corresponding function in dynamic library.
* @see void __itt_sync_releasing(void* addr); * @see void __itt_sync_releasing(void* addr);
*/ */
void ITTAPI __itt_fsync_releasing(void* addr); void ITTAPI __itt_fsync_releasing(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, fsync_releasing, (void *addr)) ITT_STUBV(ITTAPI, void, fsync_releasing, (void *addr))
#define __itt_fsync_releasing ITTNOTIFY_VOID(fsync_releasing) #define __itt_fsync_releasing ITTNOTIFY_VOID(fsync_releasing)
#define __itt_fsync_releasing_ptr ITTNOTIFY_NAME(fsync_releasing) #define __itt_fsync_releasing_ptr ITTNOTIFY_NAME(fsync_releasing)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_fsync_releasing(addr) #define __itt_fsync_releasing(addr)
#define __itt_fsync_releasing_ptr 0 #define __itt_fsync_releasing_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_fsync_releasing_ptr 0 #define __itt_fsync_releasing_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} */ /** @} */
/** /**
* @defgroup model Modeling by Intel(R) Parallel Advisor * @defgroup model Modeling by Intel(R) Parallel Advisor
* @ingroup public * @ingroup public
Show All 16 Lines
* API used by the Intel(R) Parallel Advisor to describe potential concurrency * API used by the Intel(R) Parallel Advisor to describe potential concurrency
* and related activities. User-added source annotations expand to calls * and related activities. User-added source annotations expand to calls
* to these procedures to enable modeling of a hypothetical concurrent * to these procedures to enable modeling of a hypothetical concurrent
* execution serially. * execution serially.
* @{ * @{
*/ */
#if !defined(_ADVISOR_ANNOTATE_H_) || defined(ANNOTATE_EXPAND_NULL) #if !defined(_ADVISOR_ANNOTATE_H_) || defined(ANNOTATE_EXPAND_NULL)
typedef void* __itt_model_site; /*!< @brief handle for lexical site */ typedef void *__itt_model_site; /*!< @brief handle for lexical site */
typedef void* __itt_model_site_instance; /*!< @brief handle for dynamic instance */ typedef void
*__itt_model_site_instance; /*!< @brief handle for dynamic instance */
typedef void* __itt_model_task; /*!< @brief handle for lexical site */ typedef void *__itt_model_task; /*!< @brief handle for lexical site */
typedef void* __itt_model_task_instance; /*!< @brief handle for dynamic instance */ typedef void
*__itt_model_task_instance; /*!< @brief handle for dynamic instance */
/** /**
* @enum __itt_model_disable * @enum __itt_model_disable
* @brief Enumerator for the disable methods * @brief Enumerator for the disable methods
*/ */
typedef enum { typedef enum {
__itt_model_disable_observation, __itt_model_disable_observation,
__itt_model_disable_collection __itt_model_disable_collection
} __itt_model_disable; } __itt_model_disable;
#endif /* !_ADVISOR_ANNOTATE_H_ || ANNOTATE_EXPAND_NULL */ #endif /* !_ADVISOR_ANNOTATE_H_ || ANNOTATE_EXPAND_NULL */
/** /**
* @brief ANNOTATE_SITE_BEGIN/ANNOTATE_SITE_END support. * @brief ANNOTATE_SITE_BEGIN/ANNOTATE_SITE_END support.
* *
* site_begin/end model a potential concurrency site. * site_begin/end model a potential concurrency site.
* site instances may be recursively nested with themselves. * site instances may be recursively nested with themselves.
* site_end exits the most recently started but unended site for the current * site_end exits the most recently started but unended site for the current
* thread. The handle passed to end may be used to validate structure. * thread. The handle passed to end may be used to validate structure.
* Instances of a site encountered on different threads concurrently * Instances of a site encountered on different threads concurrently
* are considered completely distinct. If the site name for two different * are considered completely distinct. If the site name for two different
* lexical sites match, it is unspecified whether they are treated as the * lexical sites match, it is unspecified whether they are treated as the
* same or different for data presentation. * same or different for data presentation.
*/ */
void ITTAPI __itt_model_site_begin(__itt_model_site *site, __itt_model_site_instance *instance, const char *name); void ITTAPI __itt_model_site_begin(__itt_model_site *site,
__itt_model_site_instance *instance,
const char *name);
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_model_site_beginW(const wchar_t *name); void ITTAPI __itt_model_site_beginW(const wchar_t *name);
#endif #endif
void ITTAPI __itt_model_site_beginA(const char *name); void ITTAPI __itt_model_site_beginA(const char *name);
void ITTAPI __itt_model_site_beginAL(const char *name, size_t siteNameLen); void ITTAPI __itt_model_site_beginAL(const char *name, size_t siteNameLen);
void ITTAPI __itt_model_site_end (__itt_model_site *site, __itt_model_site_instance *instance); void ITTAPI __itt_model_site_end(__itt_model_site *site,
__itt_model_site_instance *instance);
void ITTAPI __itt_model_site_end_2(void); void ITTAPI __itt_model_site_end_2(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_site_begin, (__itt_model_site *site, __itt_model_site_instance *instance, const char *name)) ITT_STUBV(ITTAPI, void, model_site_begin,
(__itt_model_site * site, __itt_model_site_instance *instance,
const char *name))
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name)) ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name))
#endif #endif
ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name)) ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name))
ITT_STUBV(ITTAPI, void, model_site_beginAL, (const char *name, size_t siteNameLen)) ITT_STUBV(ITTAPI, void, model_site_beginAL,
ITT_STUBV(ITTAPI, void, model_site_end, (__itt_model_site *site, __itt_model_site_instance *instance)) (const char *name, size_t siteNameLen))
ITT_STUBV(ITTAPI, void, model_site_end,
(__itt_model_site * site, __itt_model_site_instance *instance))
ITT_STUBV(ITTAPI, void, model_site_end_2, (void)) ITT_STUBV(ITTAPI, void, model_site_end_2, (void))
#define __itt_model_site_begin ITTNOTIFY_VOID(model_site_begin) #define __itt_model_site_begin ITTNOTIFY_VOID(model_site_begin)
#define __itt_model_site_begin_ptr ITTNOTIFY_NAME(model_site_begin) #define __itt_model_site_begin_ptr ITTNOTIFY_NAME(model_site_begin)
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_model_site_beginW ITTNOTIFY_VOID(model_site_beginW) #define __itt_model_site_beginW ITTNOTIFY_VOID(model_site_beginW)
#define __itt_model_site_beginW_ptr ITTNOTIFY_NAME(model_site_beginW) #define __itt_model_site_beginW_ptr ITTNOTIFY_NAME(model_site_beginW)
#endif #endif
#define __itt_model_site_beginA ITTNOTIFY_VOID(model_site_beginA) #define __itt_model_site_beginA ITTNOTIFY_VOID(model_site_beginA)
#define __itt_model_site_beginA_ptr ITTNOTIFY_NAME(model_site_beginA) #define __itt_model_site_beginA_ptr ITTNOTIFY_NAME(model_site_beginA)
#define __itt_model_site_beginAL ITTNOTIFY_VOID(model_site_beginAL) #define __itt_model_site_beginAL ITTNOTIFY_VOID(model_site_beginAL)
#define __itt_model_site_beginAL_ptr ITTNOTIFY_NAME(model_site_beginAL) #define __itt_model_site_beginAL_ptr ITTNOTIFY_NAME(model_site_beginAL)
#define __itt_model_site_end ITTNOTIFY_VOID(model_site_end) #define __itt_model_site_end ITTNOTIFY_VOID(model_site_end)
#define __itt_model_site_end_ptr ITTNOTIFY_NAME(model_site_end) #define __itt_model_site_end_ptr ITTNOTIFY_NAME(model_site_end)
#define __itt_model_site_end_2 ITTNOTIFY_VOID(model_site_end_2) #define __itt_model_site_end_2 ITTNOTIFY_VOID(model_site_end_2)
#define __itt_model_site_end_2_ptr ITTNOTIFY_NAME(model_site_end_2) #define __itt_model_site_end_2_ptr ITTNOTIFY_NAME(model_site_end_2)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_site_begin(site, instance, name) #define __itt_model_site_begin(site, instance, name)
#define __itt_model_site_begin_ptr 0 #define __itt_model_site_begin_ptr 0
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_model_site_beginW(name) #define __itt_model_site_beginW(name)
#define __itt_model_site_beginW_ptr 0 #define __itt_model_site_beginW_ptr 0
#endif #endif
#define __itt_model_site_beginA(name) #define __itt_model_site_beginA(name)
#define __itt_model_site_beginA_ptr 0 #define __itt_model_site_beginA_ptr 0
#define __itt_model_site_beginAL(name, siteNameLen) #define __itt_model_site_beginAL(name, siteNameLen)
#define __itt_model_site_beginAL_ptr 0 #define __itt_model_site_beginAL_ptr 0
#define __itt_model_site_end(site, instance) #define __itt_model_site_end(site, instance)
#define __itt_model_site_end_ptr 0 #define __itt_model_site_end_ptr 0
#define __itt_model_site_end_2() #define __itt_model_site_end_2()
#define __itt_model_site_end_2_ptr 0 #define __itt_model_site_end_2_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_site_begin_ptr 0 #define __itt_model_site_begin_ptr 0
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_model_site_beginW_ptr 0 #define __itt_model_site_beginW_ptr 0
#endif #endif
#define __itt_model_site_beginA_ptr 0 #define __itt_model_site_beginA_ptr 0
#define __itt_model_site_beginAL_ptr 0 #define __itt_model_site_beginAL_ptr 0
#define __itt_model_site_end_ptr 0 #define __itt_model_site_end_ptr 0
#define __itt_model_site_end_2_ptr 0 #define __itt_model_site_end_2_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief ANNOTATE_TASK_BEGIN/ANNOTATE_TASK_END support * @brief ANNOTATE_TASK_BEGIN/ANNOTATE_TASK_END support
* *
* task_begin/end model a potential task, which is contained within the most * task_begin/end model a potential task, which is contained within the most
* closely enclosing dynamic site. task_end exits the most recently started * closely enclosing dynamic site. task_end exits the most recently started
* but unended task. The handle passed to end may be used to validate * but unended task. The handle passed to end may be used to validate
* structure. It is unspecified if bad dynamic nesting is detected. If it * structure. It is unspecified if bad dynamic nesting is detected. If it
* is, it should be encoded in the resulting data collection. The collector * is, it should be encoded in the resulting data collection. The collector
* should not fail due to construct nesting issues, nor attempt to directly * should not fail due to construct nesting issues, nor attempt to directly
* indicate the problem. * indicate the problem.
*/ */
void ITTAPI __itt_model_task_begin(__itt_model_task *task, __itt_model_task_instance *instance, const char *name); void ITTAPI __itt_model_task_begin(__itt_model_task *task,
__itt_model_task_instance *instance,
const char *name);
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_model_task_beginW(const wchar_t *name); void ITTAPI __itt_model_task_beginW(const wchar_t *name);
void ITTAPI __itt_model_iteration_taskW(const wchar_t *name); void ITTAPI __itt_model_iteration_taskW(const wchar_t *name);
#endif #endif
void ITTAPI __itt_model_task_beginA(const char *name); void ITTAPI __itt_model_task_beginA(const char *name);
void ITTAPI __itt_model_task_beginAL(const char *name, size_t taskNameLen); void ITTAPI __itt_model_task_beginAL(const char *name, size_t taskNameLen);
void ITTAPI __itt_model_iteration_taskA(const char *name); void ITTAPI __itt_model_iteration_taskA(const char *name);
void ITTAPI __itt_model_iteration_taskAL(const char *name, size_t taskNameLen); void ITTAPI __itt_model_iteration_taskAL(const char *name, size_t taskNameLen);
void ITTAPI __itt_model_task_end (__itt_model_task *task, __itt_model_task_instance *instance); void ITTAPI __itt_model_task_end(__itt_model_task *task,
__itt_model_task_instance *instance);
void ITTAPI __itt_model_task_end_2(void); void ITTAPI __itt_model_task_end_2(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_task_begin, (__itt_model_task *task, __itt_model_task_instance *instance, const char *name)) ITT_STUBV(ITTAPI, void, model_task_begin,
(__itt_model_task * task, __itt_model_task_instance *instance,
const char *name))
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name)) ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name))
ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name)) ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name))
#endif #endif
ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name)) ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name))
ITT_STUBV(ITTAPI, void, model_task_beginAL, (const char *name, size_t taskNameLen)) ITT_STUBV(ITTAPI, void, model_task_beginAL,
(const char *name, size_t taskNameLen))
ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name)) ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name))
ITT_STUBV(ITTAPI, void, model_iteration_taskAL, (const char *name, size_t taskNameLen)) ITT_STUBV(ITTAPI, void, model_iteration_taskAL,
ITT_STUBV(ITTAPI, void, model_task_end, (__itt_model_task *task, __itt_model_task_instance *instance)) (const char *name, size_t taskNameLen))
ITT_STUBV(ITTAPI, void, model_task_end,
(__itt_model_task * task, __itt_model_task_instance *instance))
ITT_STUBV(ITTAPI, void, model_task_end_2, (void)) ITT_STUBV(ITTAPI, void, model_task_end_2, (void))
#define __itt_model_task_begin ITTNOTIFY_VOID(model_task_begin) #define __itt_model_task_begin ITTNOTIFY_VOID(model_task_begin)
#define __itt_model_task_begin_ptr ITTNOTIFY_NAME(model_task_begin) #define __itt_model_task_begin_ptr ITTNOTIFY_NAME(model_task_begin)
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_model_task_beginW ITTNOTIFY_VOID(model_task_beginW) #define __itt_model_task_beginW ITTNOTIFY_VOID(model_task_beginW)
#define __itt_model_task_beginW_ptr ITTNOTIFY_NAME(model_task_beginW) #define __itt_model_task_beginW_ptr ITTNOTIFY_NAME(model_task_beginW)
#define __itt_model_iteration_taskW ITTNOTIFY_VOID(model_iteration_taskW) #define __itt_model_iteration_taskW ITTNOTIFY_VOID(model_iteration_taskW)
#define __itt_model_iteration_taskW_ptr ITTNOTIFY_NAME(model_iteration_taskW) #define __itt_model_iteration_taskW_ptr ITTNOTIFY_NAME(model_iteration_taskW)
#endif #endif
#define __itt_model_task_beginA ITTNOTIFY_VOID(model_task_beginA) #define __itt_model_task_beginA ITTNOTIFY_VOID(model_task_beginA)
#define __itt_model_task_beginA_ptr ITTNOTIFY_NAME(model_task_beginA) #define __itt_model_task_beginA_ptr ITTNOTIFY_NAME(model_task_beginA)
#define __itt_model_task_beginAL ITTNOTIFY_VOID(model_task_beginAL) #define __itt_model_task_beginAL ITTNOTIFY_VOID(model_task_beginAL)
#define __itt_model_task_beginAL_ptr ITTNOTIFY_NAME(model_task_beginAL) #define __itt_model_task_beginAL_ptr ITTNOTIFY_NAME(model_task_beginAL)
#define __itt_model_iteration_taskA ITTNOTIFY_VOID(model_iteration_taskA) #define __itt_model_iteration_taskA ITTNOTIFY_VOID(model_iteration_taskA)
#define __itt_model_iteration_taskA_ptr ITTNOTIFY_NAME(model_iteration_taskA) #define __itt_model_iteration_taskA_ptr ITTNOTIFY_NAME(model_iteration_taskA)
#define __itt_model_iteration_taskAL ITTNOTIFY_VOID(model_iteration_taskAL) #define __itt_model_iteration_taskAL ITTNOTIFY_VOID(model_iteration_taskAL)
#define __itt_model_iteration_taskAL_ptr ITTNOTIFY_NAME(model_iteration_taskAL) #define __itt_model_iteration_taskAL_ptr ITTNOTIFY_NAME(model_iteration_taskAL)
#define __itt_model_task_end ITTNOTIFY_VOID(model_task_end) #define __itt_model_task_end ITTNOTIFY_VOID(model_task_end)
#define __itt_model_task_end_ptr ITTNOTIFY_NAME(model_task_end) #define __itt_model_task_end_ptr ITTNOTIFY_NAME(model_task_end)
#define __itt_model_task_end_2 ITTNOTIFY_VOID(model_task_end_2) #define __itt_model_task_end_2 ITTNOTIFY_VOID(model_task_end_2)
#define __itt_model_task_end_2_ptr ITTNOTIFY_NAME(model_task_end_2) #define __itt_model_task_end_2_ptr ITTNOTIFY_NAME(model_task_end_2)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_task_begin(task, instance, name) #define __itt_model_task_begin(task, instance, name)
#define __itt_model_task_begin_ptr 0 #define __itt_model_task_begin_ptr 0
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_model_task_beginW(name) #define __itt_model_task_beginW(name)
#define __itt_model_task_beginW_ptr 0 #define __itt_model_task_beginW_ptr 0
#endif #endif
#define __itt_model_task_beginA(name) #define __itt_model_task_beginA(name)
#define __itt_model_task_beginA_ptr 0 #define __itt_model_task_beginA_ptr 0
#define __itt_model_task_beginAL(name, siteNameLen) #define __itt_model_task_beginAL(name, siteNameLen)
#define __itt_model_task_beginAL_ptr 0 #define __itt_model_task_beginAL_ptr 0
#define __itt_model_iteration_taskA(name) #define __itt_model_iteration_taskA(name)
#define __itt_model_iteration_taskA_ptr 0 #define __itt_model_iteration_taskA_ptr 0
#define __itt_model_iteration_taskAL(name, siteNameLen) #define __itt_model_iteration_taskAL(name, siteNameLen)
#define __itt_model_iteration_taskAL_ptr 0 #define __itt_model_iteration_taskAL_ptr 0
#define __itt_model_task_end(task, instance) #define __itt_model_task_end(task, instance)
#define __itt_model_task_end_ptr 0 #define __itt_model_task_end_ptr 0
#define __itt_model_task_end_2() #define __itt_model_task_end_2()
#define __itt_model_task_end_2_ptr 0 #define __itt_model_task_end_2_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_task_begin_ptr 0 #define __itt_model_task_begin_ptr 0
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_model_task_beginW_ptr 0 #define __itt_model_task_beginW_ptr 0
#endif #endif
#define __itt_model_task_beginA_ptr 0 #define __itt_model_task_beginA_ptr 0
#define __itt_model_task_beginAL_ptr 0 #define __itt_model_task_beginAL_ptr 0
#define __itt_model_iteration_taskA_ptr 0 #define __itt_model_iteration_taskA_ptr 0
#define __itt_model_iteration_taskAL_ptr 0 #define __itt_model_iteration_taskAL_ptr 0
#define __itt_model_task_end_ptr 0 #define __itt_model_task_end_ptr 0
#define __itt_model_task_end_2_ptr 0 #define __itt_model_task_end_2_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief ANNOTATE_LOCK_ACQUIRE/ANNOTATE_LOCK_RELEASE support * @brief ANNOTATE_LOCK_ACQUIRE/ANNOTATE_LOCK_RELEASE support
* *
* lock_acquire/release model a potential lock for both lockset and * lock_acquire/release model a potential lock for both lockset and
* performance modeling. Each unique address is modeled as a separate * performance modeling. Each unique address is modeled as a separate
Show All 11 Lines
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock)) ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock))
ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock)) ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock))
ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock)) ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock))
ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock)) ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock))
#define __itt_model_lock_acquire ITTNOTIFY_VOID(model_lock_acquire) #define __itt_model_lock_acquire ITTNOTIFY_VOID(model_lock_acquire)
#define __itt_model_lock_acquire_ptr ITTNOTIFY_NAME(model_lock_acquire) #define __itt_model_lock_acquire_ptr ITTNOTIFY_NAME(model_lock_acquire)
#define __itt_model_lock_acquire_2 ITTNOTIFY_VOID(model_lock_acquire_2) #define __itt_model_lock_acquire_2 ITTNOTIFY_VOID(model_lock_acquire_2)
#define __itt_model_lock_acquire_2_ptr ITTNOTIFY_NAME(model_lock_acquire_2) #define __itt_model_lock_acquire_2_ptr ITTNOTIFY_NAME(model_lock_acquire_2)
#define __itt_model_lock_release ITTNOTIFY_VOID(model_lock_release) #define __itt_model_lock_release ITTNOTIFY_VOID(model_lock_release)
#define __itt_model_lock_release_ptr ITTNOTIFY_NAME(model_lock_release) #define __itt_model_lock_release_ptr ITTNOTIFY_NAME(model_lock_release)
#define __itt_model_lock_release_2 ITTNOTIFY_VOID(model_lock_release_2) #define __itt_model_lock_release_2 ITTNOTIFY_VOID(model_lock_release_2)
#define __itt_model_lock_release_2_ptr ITTNOTIFY_NAME(model_lock_release_2) #define __itt_model_lock_release_2_ptr ITTNOTIFY_NAME(model_lock_release_2)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_lock_acquire(lock) #define __itt_model_lock_acquire(lock)
#define __itt_model_lock_acquire_ptr 0 #define __itt_model_lock_acquire_ptr 0
#define __itt_model_lock_acquire_2(lock) #define __itt_model_lock_acquire_2(lock)
#define __itt_model_lock_acquire_2_ptr 0 #define __itt_model_lock_acquire_2_ptr 0
#define __itt_model_lock_release(lock) #define __itt_model_lock_release(lock)
#define __itt_model_lock_release_ptr 0 #define __itt_model_lock_release_ptr 0
#define __itt_model_lock_release_2(lock) #define __itt_model_lock_release_2(lock)
#define __itt_model_lock_release_2_ptr 0 #define __itt_model_lock_release_2_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_lock_acquire_ptr 0 #define __itt_model_lock_acquire_ptr 0
#define __itt_model_lock_acquire_2_ptr 0 #define __itt_model_lock_acquire_2_ptr 0
#define __itt_model_lock_release_ptr 0 #define __itt_model_lock_release_ptr 0
#define __itt_model_lock_release_2_ptr 0 #define __itt_model_lock_release_2_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief ANNOTATE_RECORD_ALLOCATION/ANNOTATE_RECORD_DEALLOCATION support * @brief ANNOTATE_RECORD_ALLOCATION/ANNOTATE_RECORD_DEALLOCATION support
* *
* record_allocation/deallocation describe user-defined memory allocator * record_allocation/deallocation describe user-defined memory allocator
* behavior, which may be required for correctness modeling to understand * behavior, which may be required for correctness modeling to understand
* when storage is not expected to be actually reused across threads. * when storage is not expected to be actually reused across threads.
*/ */
void ITTAPI __itt_model_record_allocation (void *addr, size_t size); void ITTAPI __itt_model_record_allocation(void *addr, size_t size);
void ITTAPI __itt_model_record_deallocation(void *addr); void ITTAPI __itt_model_record_deallocation(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size)) ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size))
ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr)) ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr))
#define __itt_model_record_allocation ITTNOTIFY_VOID(model_record_allocation) #define __itt_model_record_allocation ITTNOTIFY_VOID(model_record_allocation)
#define __itt_model_record_allocation_ptr ITTNOTIFY_NAME(model_record_allocation) #define __itt_model_record_allocation_ptr \
#define __itt_model_record_deallocation ITTNOTIFY_VOID(model_record_deallocation) ITTNOTIFY_NAME(model_record_allocation)
#define __itt_model_record_deallocation_ptr ITTNOTIFY_NAME(model_record_deallocation) #define __itt_model_record_deallocation \
ITTNOTIFY_VOID(model_record_deallocation)
#define __itt_model_record_deallocation_ptr \
ITTNOTIFY_NAME(model_record_deallocation)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_record_allocation(addr, size) #define __itt_model_record_allocation(addr, size)
#define __itt_model_record_allocation_ptr 0 #define __itt_model_record_allocation_ptr 0
#define __itt_model_record_deallocation(addr) #define __itt_model_record_deallocation(addr)
#define __itt_model_record_deallocation_ptr 0 #define __itt_model_record_deallocation_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_record_allocation_ptr 0 #define __itt_model_record_allocation_ptr 0
#define __itt_model_record_deallocation_ptr 0 #define __itt_model_record_deallocation_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief ANNOTATE_INDUCTION_USES support * @brief ANNOTATE_INDUCTION_USES support
* *
* Note particular storage is inductive through the end of the current site * Note particular storage is inductive through the end of the current site
*/ */
void ITTAPI __itt_model_induction_uses(void* addr, size_t size); void ITTAPI __itt_model_induction_uses(void *addr, size_t size);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_induction_uses, (void *addr, size_t size)) ITT_STUBV(ITTAPI, void, model_induction_uses, (void *addr, size_t size))
#define __itt_model_induction_uses ITTNOTIFY_VOID(model_induction_uses) #define __itt_model_induction_uses ITTNOTIFY_VOID(model_induction_uses)
#define __itt_model_induction_uses_ptr ITTNOTIFY_NAME(model_induction_uses) #define __itt_model_induction_uses_ptr ITTNOTIFY_NAME(model_induction_uses)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_induction_uses(addr, size) #define __itt_model_induction_uses(addr, size)
#define __itt_model_induction_uses_ptr 0 #define __itt_model_induction_uses_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_induction_uses_ptr 0 #define __itt_model_induction_uses_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief ANNOTATE_REDUCTION_USES support * @brief ANNOTATE_REDUCTION_USES support
* *
* Note particular storage is used for reduction through the end * Note particular storage is used for reduction through the end
* of the current site * of the current site
*/ */
void ITTAPI __itt_model_reduction_uses(void* addr, size_t size); void ITTAPI __itt_model_reduction_uses(void *addr, size_t size);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_reduction_uses, (void *addr, size_t size)) ITT_STUBV(ITTAPI, void, model_reduction_uses, (void *addr, size_t size))
#define __itt_model_reduction_uses ITTNOTIFY_VOID(model_reduction_uses) #define __itt_model_reduction_uses ITTNOTIFY_VOID(model_reduction_uses)
#define __itt_model_reduction_uses_ptr ITTNOTIFY_NAME(model_reduction_uses) #define __itt_model_reduction_uses_ptr ITTNOTIFY_NAME(model_reduction_uses)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_reduction_uses(addr, size) #define __itt_model_reduction_uses(addr, size)
#define __itt_model_reduction_uses_ptr 0 #define __itt_model_reduction_uses_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_reduction_uses_ptr 0 #define __itt_model_reduction_uses_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief ANNOTATE_OBSERVE_USES support * @brief ANNOTATE_OBSERVE_USES support
* *
* Have correctness modeling record observations about uses of storage * Have correctness modeling record observations about uses of storage
* through the end of the current site * through the end of the current site
*/ */
void ITTAPI __itt_model_observe_uses(void* addr, size_t size); void ITTAPI __itt_model_observe_uses(void *addr, size_t size);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_observe_uses, (void *addr, size_t size)) ITT_STUBV(ITTAPI, void, model_observe_uses, (void *addr, size_t size))
#define __itt_model_observe_uses ITTNOTIFY_VOID(model_observe_uses) #define __itt_model_observe_uses ITTNOTIFY_VOID(model_observe_uses)
#define __itt_model_observe_uses_ptr ITTNOTIFY_NAME(model_observe_uses) #define __itt_model_observe_uses_ptr ITTNOTIFY_NAME(model_observe_uses)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_observe_uses(addr, size) #define __itt_model_observe_uses(addr, size)
#define __itt_model_observe_uses_ptr 0 #define __itt_model_observe_uses_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_observe_uses_ptr 0 #define __itt_model_observe_uses_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief ANNOTATE_CLEAR_USES support * @brief ANNOTATE_CLEAR_USES support
* *
* Clear the special handling of a piece of storage related to induction, * Clear the special handling of a piece of storage related to induction,
* reduction or observe_uses * reduction or observe_uses
*/ */
void ITTAPI __itt_model_clear_uses(void* addr); void ITTAPI __itt_model_clear_uses(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_clear_uses, (void *addr)) ITT_STUBV(ITTAPI, void, model_clear_uses, (void *addr))
#define __itt_model_clear_uses ITTNOTIFY_VOID(model_clear_uses) #define __itt_model_clear_uses ITTNOTIFY_VOID(model_clear_uses)
#define __itt_model_clear_uses_ptr ITTNOTIFY_NAME(model_clear_uses) #define __itt_model_clear_uses_ptr ITTNOTIFY_NAME(model_clear_uses)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_clear_uses(addr) #define __itt_model_clear_uses(addr)
#define __itt_model_clear_uses_ptr 0 #define __itt_model_clear_uses_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_clear_uses_ptr 0 #define __itt_model_clear_uses_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief ANNOTATE_DISABLE_*_PUSH/ANNOTATE_DISABLE_*_POP support * @brief ANNOTATE_DISABLE_*_PUSH/ANNOTATE_DISABLE_*_POP support
* *
* disable_push/disable_pop push and pop disabling based on a parameter. * disable_push/disable_pop push and pop disabling based on a parameter.
Show All 17 Lines
void ITTAPI __itt_model_disable_push(__itt_model_disable x); void ITTAPI __itt_model_disable_push(__itt_model_disable x);
void ITTAPI __itt_model_disable_pop(void); void ITTAPI __itt_model_disable_pop(void);
void ITTAPI __itt_model_aggregate_task(size_t x); void ITTAPI __itt_model_aggregate_task(size_t x);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x)) ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x))
ITT_STUBV(ITTAPI, void, model_disable_pop, (void)) ITT_STUBV(ITTAPI, void, model_disable_pop, (void))
ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t x)) ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t x))
#define __itt_model_disable_push ITTNOTIFY_VOID(model_disable_push) #define __itt_model_disable_push ITTNOTIFY_VOID(model_disable_push)
#define __itt_model_disable_push_ptr ITTNOTIFY_NAME(model_disable_push) #define __itt_model_disable_push_ptr ITTNOTIFY_NAME(model_disable_push)
#define __itt_model_disable_pop ITTNOTIFY_VOID(model_disable_pop) #define __itt_model_disable_pop ITTNOTIFY_VOID(model_disable_pop)
#define __itt_model_disable_pop_ptr ITTNOTIFY_NAME(model_disable_pop) #define __itt_model_disable_pop_ptr ITTNOTIFY_NAME(model_disable_pop)
#define __itt_model_aggregate_task ITTNOTIFY_VOID(model_aggregate_task) #define __itt_model_aggregate_task ITTNOTIFY_VOID(model_aggregate_task)
#define __itt_model_aggregate_task_ptr ITTNOTIFY_NAME(model_aggregate_task) #define __itt_model_aggregate_task_ptr ITTNOTIFY_NAME(model_aggregate_task)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_model_disable_push(x) #define __itt_model_disable_push(x)
#define __itt_model_disable_push_ptr 0 #define __itt_model_disable_push_ptr 0
#define __itt_model_disable_pop() #define __itt_model_disable_pop()
#define __itt_model_disable_pop_ptr 0 #define __itt_model_disable_pop_ptr 0
#define __itt_model_aggregate_task(x) #define __itt_model_aggregate_task(x)
#define __itt_model_aggregate_task_ptr 0 #define __itt_model_aggregate_task_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_model_disable_push_ptr 0 #define __itt_model_disable_push_ptr 0
#define __itt_model_disable_pop_ptr 0 #define __itt_model_disable_pop_ptr 0
#define __itt_model_aggregate_task_ptr 0 #define __itt_model_aggregate_task_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} model group */ /** @} model group */
/** /**
* @defgroup heap Heap * @defgroup heap Heap
* @ingroup public * @ingroup public
* Heap group * Heap group
* @{ * @{
*/ */
typedef void* __itt_heap_function; typedef void *__itt_heap_function;
/** /**
* @brief Create an identification for heap function * @brief Create an identification for heap function
* @return non-zero identifier or NULL * @return non-zero identifier or NULL
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_heap_function ITTAPI __itt_heap_function_createA(const char* name, const char* domain); __itt_heap_function ITTAPI __itt_heap_function_createA(const char *name,
__itt_heap_function ITTAPI __itt_heap_function_createW(const wchar_t* name, const wchar_t* domain); const char *domain);
__itt_heap_function ITTAPI __itt_heap_function_createW(const wchar_t *name,
const wchar_t *domain);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_heap_function_create __itt_heap_function_createW #define __itt_heap_function_create __itt_heap_function_createW
# define __itt_heap_function_create_ptr __itt_heap_function_createW_ptr #define __itt_heap_function_create_ptr __itt_heap_function_createW_ptr
#else #else
# define __itt_heap_function_create __itt_heap_function_createA #define __itt_heap_function_create __itt_heap_function_createA
# define __itt_heap_function_create_ptr __itt_heap_function_createA_ptr #define __itt_heap_function_create_ptr __itt_heap_function_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_heap_function ITTAPI __itt_heap_function_create(const char* name, const char* domain); __itt_heap_function ITTAPI __itt_heap_function_create(const char *name,
const char *domain);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA, (const char* name, const char* domain)) ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA,
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW, (const wchar_t* name, const wchar_t* domain)) (const char *name, const char *domain))
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW,
(const wchar_t *name, const wchar_t *domain))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create, (const char* name, const char* domain)) ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create,
(const char *name, const char *domain))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_heap_function_createA ITTNOTIFY_DATA(heap_function_createA) #define __itt_heap_function_createA ITTNOTIFY_DATA(heap_function_createA)
#define __itt_heap_function_createA_ptr ITTNOTIFY_NAME(heap_function_createA) #define __itt_heap_function_createA_ptr ITTNOTIFY_NAME(heap_function_createA)
#define __itt_heap_function_createW ITTNOTIFY_DATA(heap_function_createW) #define __itt_heap_function_createW ITTNOTIFY_DATA(heap_function_createW)
#define __itt_heap_function_createW_ptr ITTNOTIFY_NAME(heap_function_createW) #define __itt_heap_function_createW_ptr ITTNOTIFY_NAME(heap_function_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_heap_function_create ITTNOTIFY_DATA(heap_function_create) #define __itt_heap_function_create ITTNOTIFY_DATA(heap_function_create)
#define __itt_heap_function_create_ptr ITTNOTIFY_NAME(heap_function_create) #define __itt_heap_function_create_ptr ITTNOTIFY_NAME(heap_function_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_heap_function_createA(name, domain) (__itt_heap_function)0 #define __itt_heap_function_createA(name, domain) (__itt_heap_function)0
#define __itt_heap_function_createA_ptr 0 #define __itt_heap_function_createA_ptr 0
#define __itt_heap_function_createW(name, domain) (__itt_heap_function)0 #define __itt_heap_function_createW(name, domain) (__itt_heap_function)0
#define __itt_heap_function_createW_ptr 0 #define __itt_heap_function_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_heap_function_create(name, domain) (__itt_heap_function)0 #define __itt_heap_function_create(name, domain) (__itt_heap_function)0
#define __itt_heap_function_create_ptr 0 #define __itt_heap_function_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_heap_function_createA_ptr 0 #define __itt_heap_function_createA_ptr 0
#define __itt_heap_function_createW_ptr 0 #define __itt_heap_function_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_heap_function_create_ptr 0 #define __itt_heap_function_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record an allocation begin occurrence. * @brief Record an allocation begin occurrence.
*/ */
void ITTAPI __itt_heap_allocate_begin(__itt_heap_function h, size_t size, int initialized); void ITTAPI __itt_heap_allocate_begin(__itt_heap_function h, size_t size,
int initialized);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_allocate_begin, (__itt_heap_function h, size_t size, int initialized)) ITT_STUBV(ITTAPI, void, heap_allocate_begin,
(__itt_heap_function h, size_t size, int initialized))
#define __itt_heap_allocate_begin ITTNOTIFY_VOID(heap_allocate_begin) #define __itt_heap_allocate_begin ITTNOTIFY_VOID(heap_allocate_begin)
#define __itt_heap_allocate_begin_ptr ITTNOTIFY_NAME(heap_allocate_begin) #define __itt_heap_allocate_begin_ptr ITTNOTIFY_NAME(heap_allocate_begin)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_allocate_begin(h, size, initialized) #define __itt_heap_allocate_begin(h, size, initialized)
#define __itt_heap_allocate_begin_ptr 0 #define __itt_heap_allocate_begin_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_allocate_begin_ptr 0 #define __itt_heap_allocate_begin_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record an allocation end occurrence. * @brief Record an allocation end occurrence.
*/ */
void ITTAPI __itt_heap_allocate_end(__itt_heap_function h, void** addr, size_t size, int initialized); void ITTAPI __itt_heap_allocate_end(__itt_heap_function h, void **addr,
size_t size, int initialized);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_allocate_end, (__itt_heap_function h, void** addr, size_t size, int initialized)) ITT_STUBV(ITTAPI, void, heap_allocate_end,
(__itt_heap_function h, void **addr, size_t size, int initialized))
#define __itt_heap_allocate_end ITTNOTIFY_VOID(heap_allocate_end) #define __itt_heap_allocate_end ITTNOTIFY_VOID(heap_allocate_end)
#define __itt_heap_allocate_end_ptr ITTNOTIFY_NAME(heap_allocate_end) #define __itt_heap_allocate_end_ptr ITTNOTIFY_NAME(heap_allocate_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_allocate_end(h, addr, size, initialized) #define __itt_heap_allocate_end(h, addr, size, initialized)
#define __itt_heap_allocate_end_ptr 0 #define __itt_heap_allocate_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_allocate_end_ptr 0 #define __itt_heap_allocate_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record a free begin occurrence. * @brief Record a free begin occurrence.
*/ */
void ITTAPI __itt_heap_free_begin(__itt_heap_function h, void* addr); void ITTAPI __itt_heap_free_begin(__itt_heap_function h, void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void* addr)) ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void *addr))
#define __itt_heap_free_begin ITTNOTIFY_VOID(heap_free_begin) #define __itt_heap_free_begin ITTNOTIFY_VOID(heap_free_begin)
#define __itt_heap_free_begin_ptr ITTNOTIFY_NAME(heap_free_begin) #define __itt_heap_free_begin_ptr ITTNOTIFY_NAME(heap_free_begin)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_free_begin(h, addr) #define __itt_heap_free_begin(h, addr)
#define __itt_heap_free_begin_ptr 0 #define __itt_heap_free_begin_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_free_begin_ptr 0 #define __itt_heap_free_begin_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record a free end occurrence. * @brief Record a free end occurrence.
*/ */
void ITTAPI __itt_heap_free_end(__itt_heap_function h, void* addr); void ITTAPI __itt_heap_free_end(__itt_heap_function h, void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void* addr)) ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void *addr))
#define __itt_heap_free_end ITTNOTIFY_VOID(heap_free_end) #define __itt_heap_free_end ITTNOTIFY_VOID(heap_free_end)
#define __itt_heap_free_end_ptr ITTNOTIFY_NAME(heap_free_end) #define __itt_heap_free_end_ptr ITTNOTIFY_NAME(heap_free_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_free_end(h, addr) #define __itt_heap_free_end(h, addr)
#define __itt_heap_free_end_ptr 0 #define __itt_heap_free_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_free_end_ptr 0 #define __itt_heap_free_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record a reallocation begin occurrence. * @brief Record a reallocation begin occurrence.
*/ */
void ITTAPI __itt_heap_reallocate_begin(__itt_heap_function h, void* addr, size_t new_size, int initialized); void ITTAPI __itt_heap_reallocate_begin(__itt_heap_function h, void *addr,
size_t new_size, int initialized);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_reallocate_begin, (__itt_heap_function h, void* addr, size_t new_size, int initialized)) ITT_STUBV(ITTAPI, void, heap_reallocate_begin,
(__itt_heap_function h, void *addr, size_t new_size, int initialized))
#define __itt_heap_reallocate_begin ITTNOTIFY_VOID(heap_reallocate_begin) #define __itt_heap_reallocate_begin ITTNOTIFY_VOID(heap_reallocate_begin)
#define __itt_heap_reallocate_begin_ptr ITTNOTIFY_NAME(heap_reallocate_begin) #define __itt_heap_reallocate_begin_ptr ITTNOTIFY_NAME(heap_reallocate_begin)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_reallocate_begin(h, addr, new_size, initialized) #define __itt_heap_reallocate_begin(h, addr, new_size, initialized)
#define __itt_heap_reallocate_begin_ptr 0 #define __itt_heap_reallocate_begin_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_reallocate_begin_ptr 0 #define __itt_heap_reallocate_begin_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record a reallocation end occurrence. * @brief Record a reallocation end occurrence.
*/ */
void ITTAPI __itt_heap_reallocate_end(__itt_heap_function h, void* addr, void** new_addr, size_t new_size, int initialized); void ITTAPI __itt_heap_reallocate_end(__itt_heap_function h, void *addr,
void **new_addr, size_t new_size,
int initialized);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_reallocate_end, (__itt_heap_function h, void* addr, void** new_addr, size_t new_size, int initialized)) ITT_STUBV(ITTAPI, void, heap_reallocate_end,
(__itt_heap_function h, void *addr, void **new_addr, size_t new_size,
int initialized))
#define __itt_heap_reallocate_end ITTNOTIFY_VOID(heap_reallocate_end) #define __itt_heap_reallocate_end ITTNOTIFY_VOID(heap_reallocate_end)
#define __itt_heap_reallocate_end_ptr ITTNOTIFY_NAME(heap_reallocate_end) #define __itt_heap_reallocate_end_ptr ITTNOTIFY_NAME(heap_reallocate_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_reallocate_end(h, addr, new_addr, new_size, initialized) #define __itt_heap_reallocate_end(h, addr, new_addr, new_size, initialized)
#define __itt_heap_reallocate_end_ptr 0 #define __itt_heap_reallocate_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_reallocate_end_ptr 0 #define __itt_heap_reallocate_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @brief internal access begin */ /** @brief internal access begin */
void ITTAPI __itt_heap_internal_access_begin(void); void ITTAPI __itt_heap_internal_access_begin(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void)) ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void))
#define __itt_heap_internal_access_begin ITTNOTIFY_VOID(heap_internal_access_begin) #define __itt_heap_internal_access_begin \
#define __itt_heap_internal_access_begin_ptr ITTNOTIFY_NAME(heap_internal_access_begin) ITTNOTIFY_VOID(heap_internal_access_begin)
#define __itt_heap_internal_access_begin_ptr \
ITTNOTIFY_NAME(heap_internal_access_begin)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_internal_access_begin() #define __itt_heap_internal_access_begin()
#define __itt_heap_internal_access_begin_ptr 0 #define __itt_heap_internal_access_begin_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_internal_access_begin_ptr 0 #define __itt_heap_internal_access_begin_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @brief internal access end */ /** @brief internal access end */
void ITTAPI __itt_heap_internal_access_end(void); void ITTAPI __itt_heap_internal_access_end(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void)) ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void))
#define __itt_heap_internal_access_end ITTNOTIFY_VOID(heap_internal_access_end) #define __itt_heap_internal_access_end ITTNOTIFY_VOID(heap_internal_access_end)
#define __itt_heap_internal_access_end_ptr ITTNOTIFY_NAME(heap_internal_access_end) #define __itt_heap_internal_access_end_ptr \
ITTNOTIFY_NAME(heap_internal_access_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_internal_access_end() #define __itt_heap_internal_access_end()
#define __itt_heap_internal_access_end_ptr 0 #define __itt_heap_internal_access_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_internal_access_end_ptr 0 #define __itt_heap_internal_access_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @brief record memory growth begin */ /** @brief record memory growth begin */
void ITTAPI __itt_heap_record_memory_growth_begin(void); void ITTAPI __itt_heap_record_memory_growth_begin(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void)) ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void))
#define __itt_heap_record_memory_growth_begin ITTNOTIFY_VOID(heap_record_memory_growth_begin) #define __itt_heap_record_memory_growth_begin \
#define __itt_heap_record_memory_growth_begin_ptr ITTNOTIFY_NAME(heap_record_memory_growth_begin) ITTNOTIFY_VOID(heap_record_memory_growth_begin)
#define __itt_heap_record_memory_growth_begin_ptr \
ITTNOTIFY_NAME(heap_record_memory_growth_begin)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_record_memory_growth_begin() #define __itt_heap_record_memory_growth_begin()
#define __itt_heap_record_memory_growth_begin_ptr 0 #define __itt_heap_record_memory_growth_begin_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_record_memory_growth_begin_ptr 0 #define __itt_heap_record_memory_growth_begin_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @brief record memory growth end */ /** @brief record memory growth end */
void ITTAPI __itt_heap_record_memory_growth_end(void); void ITTAPI __itt_heap_record_memory_growth_end(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void)) ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void))
#define __itt_heap_record_memory_growth_end ITTNOTIFY_VOID(heap_record_memory_growth_end) #define __itt_heap_record_memory_growth_end \
#define __itt_heap_record_memory_growth_end_ptr ITTNOTIFY_NAME(heap_record_memory_growth_end) ITTNOTIFY_VOID(heap_record_memory_growth_end)
#define __itt_heap_record_memory_growth_end_ptr \
ITTNOTIFY_NAME(heap_record_memory_growth_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_record_memory_growth_end() #define __itt_heap_record_memory_growth_end()
#define __itt_heap_record_memory_growth_end_ptr 0 #define __itt_heap_record_memory_growth_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_record_memory_growth_end_ptr 0 #define __itt_heap_record_memory_growth_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Specify the type of heap detection/reporting to modify. * @brief Specify the type of heap detection/reporting to modify.
*/ */
/** /**
* @hideinitializer * @hideinitializer
* @brief Report on memory leaks. * @brief Report on memory leaks.
*/ */
#define __itt_heap_leaks 0x00000001 #define __itt_heap_leaks 0x00000001
/** /**
* @hideinitializer * @hideinitializer
* @brief Report on memory growth. * @brief Report on memory growth.
*/ */
#define __itt_heap_growth 0x00000002 #define __itt_heap_growth 0x00000002
/** @brief heap reset detection */ /** @brief heap reset detection */
void ITTAPI __itt_heap_reset_detection(unsigned int reset_mask); void ITTAPI __itt_heap_reset_detection(unsigned int reset_mask);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask)) ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask))
#define __itt_heap_reset_detection ITTNOTIFY_VOID(heap_reset_detection) #define __itt_heap_reset_detection ITTNOTIFY_VOID(heap_reset_detection)
#define __itt_heap_reset_detection_ptr ITTNOTIFY_NAME(heap_reset_detection) #define __itt_heap_reset_detection_ptr ITTNOTIFY_NAME(heap_reset_detection)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_reset_detection() #define __itt_heap_reset_detection()
#define __itt_heap_reset_detection_ptr 0 #define __itt_heap_reset_detection_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_reset_detection_ptr 0 #define __itt_heap_reset_detection_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @brief report */ /** @brief report */
void ITTAPI __itt_heap_record(unsigned int record_mask); void ITTAPI __itt_heap_record(unsigned int record_mask);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask)) ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask))
#define __itt_heap_record ITTNOTIFY_VOID(heap_record) #define __itt_heap_record ITTNOTIFY_VOID(heap_record)
#define __itt_heap_record_ptr ITTNOTIFY_NAME(heap_record) #define __itt_heap_record_ptr ITTNOTIFY_NAME(heap_record)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_heap_record() #define __itt_heap_record()
#define __itt_heap_record_ptr 0 #define __itt_heap_record_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_heap_record_ptr 0 #define __itt_heap_record_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} heap group */ /** @} heap group */
/** @endcond */ /** @endcond */
/* ========================================================================== */ /* ========================================================================== */
/** /**
* @defgroup domains Domains * @defgroup domains Domains
* @ingroup public * @ingroup public
* Domains group * Domains group
* @{ * @{
*/ */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_domain typedef struct ___itt_domain {
{ volatile int flags; /*!< Zero if disabled, non-zero if enabled. The meaning of
volatile int flags; /*!< Zero if disabled, non-zero if enabled. The meaning of different non-zero values is reserved to the runtime */ different non-zero values is reserved to the runtime */
const char* nameA; /*!< Copy of original name in ASCII. */ const char *nameA; /*!< Copy of original name in ASCII. */
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
const wchar_t* nameW; /*!< Copy of original name in UNICODE. */ const wchar_t *nameW; /*!< Copy of original name in UNICODE. */
#else /* UNICODE || _UNICODE */ #else /* UNICODE || _UNICODE */
void* nameW; void *nameW;
#endif /* UNICODE || _UNICODE */ #endif /* UNICODE || _UNICODE */
int extra1; /*!< Reserved to the runtime */ int extra1; /*!< Reserved to the runtime */
void* extra2; /*!< Reserved to the runtime */ void *extra2; /*!< Reserved to the runtime */
struct ___itt_domain* next; struct ___itt_domain *next;
} __itt_domain; } __itt_domain;
#pragma pack(pop) #pragma pack(pop)
/** @endcond */ /** @endcond */
/** /**
* @ingroup domains * @ingroup domains
* @brief Create a domain. * @brief Create a domain.
* Create domain using some domain name: the URI naming style is recommended. * Create domain using some domain name: the URI naming style is recommended.
* Because the set of domains is expected to be static over the application's * Because the set of domains is expected to be static over the application's
* execution time, there is no mechanism to destroy a domain. * execution time, there is no mechanism to destroy a domain.
* Any domain can be accessed by any thread in the process, regardless of * Any domain can be accessed by any thread in the process, regardless of
* which thread created the domain. This call is thread-safe. * which thread created the domain. This call is thread-safe.
* @param[in] name name of domain * @param[in] name name of domain
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_domain* ITTAPI __itt_domain_createA(const char *name); __itt_domain *ITTAPI __itt_domain_createA(const char *name);
__itt_domain* ITTAPI __itt_domain_createW(const wchar_t *name); __itt_domain *ITTAPI __itt_domain_createW(const wchar_t *name);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_domain_create __itt_domain_createW #define __itt_domain_create __itt_domain_createW
# define __itt_domain_create_ptr __itt_domain_createW_ptr #define __itt_domain_create_ptr __itt_domain_createW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_domain_create __itt_domain_createA #define __itt_domain_create __itt_domain_createA
# define __itt_domain_create_ptr __itt_domain_createA_ptr #define __itt_domain_create_ptr __itt_domain_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_domain* ITTAPI __itt_domain_create(const char *name); __itt_domain *ITTAPI __itt_domain_create(const char *name);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_domain*, domain_createA, (const char *name)) ITT_STUB(ITTAPI, __itt_domain *, domain_createA, (const char *name))
ITT_STUB(ITTAPI, __itt_domain*, domain_createW, (const wchar_t *name)) ITT_STUB(ITTAPI, __itt_domain *, domain_createW, (const wchar_t *name))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_domain*, domain_create, (const char *name)) ITT_STUB(ITTAPI, __itt_domain *, domain_create, (const char *name))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_domain_createA ITTNOTIFY_DATA(domain_createA) #define __itt_domain_createA ITTNOTIFY_DATA(domain_createA)
#define __itt_domain_createA_ptr ITTNOTIFY_NAME(domain_createA) #define __itt_domain_createA_ptr ITTNOTIFY_NAME(domain_createA)
#define __itt_domain_createW ITTNOTIFY_DATA(domain_createW) #define __itt_domain_createW ITTNOTIFY_DATA(domain_createW)
#define __itt_domain_createW_ptr ITTNOTIFY_NAME(domain_createW) #define __itt_domain_createW_ptr ITTNOTIFY_NAME(domain_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_domain_create ITTNOTIFY_DATA(domain_create) #define __itt_domain_create ITTNOTIFY_DATA(domain_create)
#define __itt_domain_create_ptr ITTNOTIFY_NAME(domain_create) #define __itt_domain_create_ptr ITTNOTIFY_NAME(domain_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_domain_createA(name) (__itt_domain*)0 #define __itt_domain_createA(name) (__itt_domain *)0
#define __itt_domain_createA_ptr 0 #define __itt_domain_createA_ptr 0
#define __itt_domain_createW(name) (__itt_domain*)0 #define __itt_domain_createW(name) (__itt_domain *)0
#define __itt_domain_createW_ptr 0 #define __itt_domain_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_domain_create(name) (__itt_domain*)0 #define __itt_domain_create(name) (__itt_domain *)0
#define __itt_domain_create_ptr 0 #define __itt_domain_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_domain_createA_ptr 0 #define __itt_domain_createA_ptr 0
#define __itt_domain_createW_ptr 0 #define __itt_domain_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_domain_create_ptr 0 #define __itt_domain_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} domains group */ /** @} domains group */
/** /**
* @defgroup ids IDs * @defgroup ids IDs
* @ingroup public * @ingroup public
* IDs group * IDs group
* @{ * @{
*/ */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_id typedef struct ___itt_id {
{
unsigned long long d1, d2, d3; unsigned long long d1, d2, d3;
} __itt_id; } __itt_id;
#pragma pack(pop) #pragma pack(pop)
/** @endcond */ /** @endcond */
static const __itt_id __itt_null = { 0, 0, 0 }; static const __itt_id __itt_null = {0, 0, 0};
/** /**
* @ingroup ids * @ingroup ids
* @brief A convenience function is provided to create an ID without domain control. * @brief A convenience function is provided to create an ID without domain
* @brief This is a convenience function to initialize an __itt_id structure. This function * control.
* does not affect the collector runtime in any way. After you make the ID with this * @brief This is a convenience function to initialize an __itt_id structure.
* function, you still must create it with the __itt_id_create function before using the ID * This function does not affect the collector runtime in any way. After you
* to identify a named entity. * make the ID with this function, you still must create it with the
* __itt_id_create function before using the ID to identify a named entity.
* @param[in] addr The address of object; high QWORD of the ID value. * @param[in] addr The address of object; high QWORD of the ID value.
* @param[in] extra The extra data to unique identify object; low QWORD of the ID value. * @param[in] extra The extra data to unique identify object; low QWORD of the
* ID value.
*/ */
ITT_INLINE __itt_id ITTAPI __itt_id_make(void* addr, unsigned long long extra) ITT_INLINE_ATTRIBUTE;
ITT_INLINE __itt_id ITTAPI __itt_id_make(void* addr, unsigned long long extra) ITT_INLINE __itt_id ITTAPI __itt_id_make(void *addr, unsigned long long extra)
{ ITT_INLINE_ATTRIBUTE;
ITT_INLINE __itt_id ITTAPI __itt_id_make(void *addr, unsigned long long extra) {
__itt_id id = __itt_null; __itt_id id = __itt_null;
id.d1 = (unsigned long long)((uintptr_t)addr); id.d1 = (unsigned long long)((uintptr_t)addr);
id.d2 = (unsigned long long)extra; id.d2 = (unsigned long long)extra;
id.d3 = (unsigned long long)0; /* Reserved. Must be zero */ id.d3 = (unsigned long long)0; /* Reserved. Must be zero */
return id; return id;
} }
/** /**
* @ingroup ids * @ingroup ids
* @brief Create an instance of identifier. * @brief Create an instance of identifier.
* This establishes the beginning of the lifetime of an instance of * This establishes the beginning of the lifetime of an instance of
* the given ID in the trace. Once this lifetime starts, the ID * the given ID in the trace. Once this lifetime starts, the ID
* can be used to tag named entity instances in calls such as * can be used to tag named entity instances in calls such as
* __itt_task_begin, and to specify relationships among * __itt_task_begin, and to specify relationships among
* identified named entity instances, using the \ref relations APIs. * identified named entity instances, using the \ref relations APIs.
* Instance IDs are not domain specific! * Instance IDs are not domain specific!
* @param[in] domain The domain controlling the execution of this call. * @param[in] domain The domain controlling the execution of this call.
* @param[in] id The ID to create. * @param[in] id The ID to create.
*/ */
void ITTAPI __itt_id_create(const __itt_domain *domain, __itt_id id); void ITTAPI __itt_id_create(const __itt_domain *domain, __itt_id id);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id)) ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id))
#define __itt_id_create(d,x) ITTNOTIFY_VOID_D1(id_create,d,x) #define __itt_id_create(d, x) ITTNOTIFY_VOID_D1(id_create, d, x)
#define __itt_id_create_ptr ITTNOTIFY_NAME(id_create) #define __itt_id_create_ptr ITTNOTIFY_NAME(id_create)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_id_create(domain,id) #define __itt_id_create(domain, id)
#define __itt_id_create_ptr 0 #define __itt_id_create_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_id_create_ptr 0 #define __itt_id_create_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup ids * @ingroup ids
* @brief Destroy an instance of identifier. * @brief Destroy an instance of identifier.
* This ends the lifetime of the current instance of the given ID value in the trace. * This ends the lifetime of the current instance of the given ID value in the
* Any relationships that are established after this lifetime ends are invalid. * trace. Any relationships that are established after this lifetime ends are
* This call must be performed before the given ID value can be reused for a different * invalid. This call must be performed before the given ID value can be reused
* named entity instance. * for a different named entity instance.
* @param[in] domain The domain controlling the execution of this call. * @param[in] domain The domain controlling the execution of this call.
* @param[in] id The ID to destroy. * @param[in] id The ID to destroy.
*/ */
void ITTAPI __itt_id_destroy(const __itt_domain *domain, __itt_id id); void ITTAPI __itt_id_destroy(const __itt_domain *domain, __itt_id id);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id)) ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id))
#define __itt_id_destroy(d,x) ITTNOTIFY_VOID_D1(id_destroy,d,x) #define __itt_id_destroy(d, x) ITTNOTIFY_VOID_D1(id_destroy, d, x)
#define __itt_id_destroy_ptr ITTNOTIFY_NAME(id_destroy) #define __itt_id_destroy_ptr ITTNOTIFY_NAME(id_destroy)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_id_destroy(domain,id) #define __itt_id_destroy(domain, id)
#define __itt_id_destroy_ptr 0 #define __itt_id_destroy_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_id_destroy_ptr 0 #define __itt_id_destroy_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} ids group */ /** @} ids group */
/** /**
* @defgroup handless String Handles * @defgroup handless String Handles
* @ingroup public * @ingroup public
* String Handles group * String Handles group
* @{ * @{
*/ */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_string_handle typedef struct ___itt_string_handle {
{
const char* strA; /*!< Copy of original string in ASCII. */ const char *strA; /*!< Copy of original string in ASCII. */
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
const wchar_t* strW; /*!< Copy of original string in UNICODE. */ const wchar_t *strW; /*!< Copy of original string in UNICODE. */
#else /* UNICODE || _UNICODE */ #else /* UNICODE || _UNICODE */
void* strW; void *strW;
#endif /* UNICODE || _UNICODE */ #endif /* UNICODE || _UNICODE */
int extra1; /*!< Reserved. Must be zero */ int extra1; /*!< Reserved. Must be zero */
void* extra2; /*!< Reserved. Must be zero */ void *extra2; /*!< Reserved. Must be zero */
struct ___itt_string_handle* next; struct ___itt_string_handle *next;
} __itt_string_handle; } __itt_string_handle;
#pragma pack(pop) #pragma pack(pop)
/** @endcond */ /** @endcond */
/** /**
* @ingroup handles * @ingroup handles
* @brief Create a string handle. * @brief Create a string handle.
* Create and return handle value that can be associated with a string. * Create and return handle value that can be associated with a string.
* Consecutive calls to __itt_string_handle_create with the same name * Consecutive calls to __itt_string_handle_create with the same name
* return the same value. Because the set of string handles is expected to remain * return the same value. Because the set of string handles is expected to
* static during the application's execution time, there is no mechanism to destroy a string handle. * remain static during the application's execution time, there is no mechanism
* Any string handle can be accessed by any thread in the process, regardless of which thread created * to destroy a string handle. Any string handle can be accessed by any thread
* the string handle. This call is thread-safe. * in the process, regardless of which thread created the string handle. This
* call is thread-safe.
* @param[in] name The input string * @param[in] name The input string
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_string_handle* ITTAPI __itt_string_handle_createA(const char *name); __itt_string_handle *ITTAPI __itt_string_handle_createA(const char *name);
__itt_string_handle* ITTAPI __itt_string_handle_createW(const wchar_t *name); __itt_string_handle *ITTAPI __itt_string_handle_createW(const wchar_t *name);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_string_handle_create __itt_string_handle_createW #define __itt_string_handle_create __itt_string_handle_createW
# define __itt_string_handle_create_ptr __itt_string_handle_createW_ptr #define __itt_string_handle_create_ptr __itt_string_handle_createW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_string_handle_create __itt_string_handle_createA #define __itt_string_handle_create __itt_string_handle_createA
# define __itt_string_handle_create_ptr __itt_string_handle_createA_ptr #define __itt_string_handle_create_ptr __itt_string_handle_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_string_handle* ITTAPI __itt_string_handle_create(const char *name); __itt_string_handle *ITTAPI __itt_string_handle_create(const char *name);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createA, (const char *name)) ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createA,
ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createW, (const wchar_t *name)) (const char *name))
ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createW,
(const wchar_t *name))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_create, (const char *name)) ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_create,
(const char *name))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_string_handle_createA ITTNOTIFY_DATA(string_handle_createA) #define __itt_string_handle_createA ITTNOTIFY_DATA(string_handle_createA)
#define __itt_string_handle_createA_ptr ITTNOTIFY_NAME(string_handle_createA) #define __itt_string_handle_createA_ptr ITTNOTIFY_NAME(string_handle_createA)
#define __itt_string_handle_createW ITTNOTIFY_DATA(string_handle_createW) #define __itt_string_handle_createW ITTNOTIFY_DATA(string_handle_createW)
#define __itt_string_handle_createW_ptr ITTNOTIFY_NAME(string_handle_createW) #define __itt_string_handle_createW_ptr ITTNOTIFY_NAME(string_handle_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_string_handle_create ITTNOTIFY_DATA(string_handle_create) #define __itt_string_handle_create ITTNOTIFY_DATA(string_handle_create)
#define __itt_string_handle_create_ptr ITTNOTIFY_NAME(string_handle_create) #define __itt_string_handle_create_ptr ITTNOTIFY_NAME(string_handle_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_string_handle_createA(name) (__itt_string_handle*)0 #define __itt_string_handle_createA(name) (__itt_string_handle *)0
#define __itt_string_handle_createA_ptr 0 #define __itt_string_handle_createA_ptr 0
#define __itt_string_handle_createW(name) (__itt_string_handle*)0 #define __itt_string_handle_createW(name) (__itt_string_handle *)0
#define __itt_string_handle_createW_ptr 0 #define __itt_string_handle_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_string_handle_create(name) (__itt_string_handle*)0 #define __itt_string_handle_create(name) (__itt_string_handle *)0
#define __itt_string_handle_create_ptr 0 #define __itt_string_handle_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_string_handle_createA_ptr 0 #define __itt_string_handle_createA_ptr 0
#define __itt_string_handle_createW_ptr 0 #define __itt_string_handle_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_string_handle_create_ptr 0 #define __itt_string_handle_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} handles group */ /** @} handles group */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
typedef unsigned long long __itt_timestamp; typedef unsigned long long __itt_timestamp;
/** @endcond */ /** @endcond */
#define __itt_timestamp_none ((__itt_timestamp)-1LL) #define __itt_timestamp_none ((__itt_timestamp)-1LL)
/** @cond exclude_from_gpa_documentation */ /** @cond exclude_from_gpa_documentation */
/** /**
* @ingroup timestamps * @ingroup timestamps
* @brief Return timestamp corresponding to the current moment. * @brief Return timestamp corresponding to the current moment.
* This returns the timestamp in the format that is the most relevant for the current * This returns the timestamp in the format that is the most relevant for the
* host or platform (RDTSC, QPC, and others). You can use the "<" operator to * current host or platform (RDTSC, QPC, and others). You can use the "<"
* compare __itt_timestamp values. * operator to compare __itt_timestamp values.
*/ */
__itt_timestamp ITTAPI __itt_get_timestamp(void); __itt_timestamp ITTAPI __itt_get_timestamp(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void)) ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void))
#define __itt_get_timestamp ITTNOTIFY_DATA(get_timestamp) #define __itt_get_timestamp ITTNOTIFY_DATA(get_timestamp)
#define __itt_get_timestamp_ptr ITTNOTIFY_NAME(get_timestamp) #define __itt_get_timestamp_ptr ITTNOTIFY_NAME(get_timestamp)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_get_timestamp() #define __itt_get_timestamp()
#define __itt_get_timestamp_ptr 0 #define __itt_get_timestamp_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_get_timestamp_ptr 0 #define __itt_get_timestamp_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} timestamps */ /** @} timestamps */
/** @endcond */ /** @endcond */
/** @cond exclude_from_gpa_documentation */ /** @cond exclude_from_gpa_documentation */
/** /**
* @defgroup regions Regions * @defgroup regions Regions
* @ingroup public * @ingroup public
* Regions group * Regions group
* @{ * @{
*/ */
/** /**
* @ingroup regions * @ingroup regions
* @brief Begin of region instance. * @brief Begin of region instance.
* Successive calls to __itt_region_begin with the same ID are ignored * Successive calls to __itt_region_begin with the same ID are ignored
* until a call to __itt_region_end with the same ID * until a call to __itt_region_end with the same ID
* @param[in] domain The domain for this region instance * @param[in] domain The domain for this region instance
* @param[in] id The instance ID for this region instance. Must not be __itt_null * @param[in] id The instance ID for this region instance. Must not be
* @param[in] parentid The instance ID for the parent of this region instance, or __itt_null * __itt_null
* @param[in] parentid The instance ID for the parent of this region instance,
* or __itt_null
* @param[in] name The name of this region * @param[in] name The name of this region
*/ */
void ITTAPI __itt_region_begin(const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name); void ITTAPI __itt_region_begin(const __itt_domain *domain, __itt_id id,
__itt_id parentid, __itt_string_handle *name);
/** /**
* @ingroup regions * @ingroup regions
* @brief End of region instance. * @brief End of region instance.
* The first call to __itt_region_end with a given ID ends the * The first call to __itt_region_end with a given ID ends the
* region. Successive calls with the same ID are ignored, as are * region. Successive calls with the same ID are ignored, as are
* calls that do not have a matching __itt_region_begin call. * calls that do not have a matching __itt_region_begin call.
* @param[in] domain The domain for this region instance * @param[in] domain The domain for this region instance
* @param[in] id The instance ID for this region instance * @param[in] id The instance ID for this region instance
*/ */
void ITTAPI __itt_region_end(const __itt_domain *domain, __itt_id id); void ITTAPI __itt_region_end(const __itt_domain *domain, __itt_id id);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, region_begin, (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name)) ITT_STUBV(ITTAPI, void, region_begin,
(const __itt_domain *domain, __itt_id id, __itt_id parentid,
__itt_string_handle *name))
ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id)) ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id))
#define __itt_region_begin(d,x,y,z) ITTNOTIFY_VOID_D3(region_begin,d,x,y,z) #define __itt_region_begin(d, x, y, z) \
ITTNOTIFY_VOID_D3(region_begin, d, x, y, z)
#define __itt_region_begin_ptr ITTNOTIFY_NAME(region_begin) #define __itt_region_begin_ptr ITTNOTIFY_NAME(region_begin)
#define __itt_region_end(d,x) ITTNOTIFY_VOID_D1(region_end,d,x) #define __itt_region_end(d, x) ITTNOTIFY_VOID_D1(region_end, d, x)
#define __itt_region_end_ptr ITTNOTIFY_NAME(region_end) #define __itt_region_end_ptr ITTNOTIFY_NAME(region_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_region_begin(d,x,y,z) #define __itt_region_begin(d, x, y, z)
#define __itt_region_begin_ptr 0 #define __itt_region_begin_ptr 0
#define __itt_region_end(d,x) #define __itt_region_end(d, x)
#define __itt_region_end_ptr 0 #define __itt_region_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_region_begin_ptr 0 #define __itt_region_begin_ptr 0
#define __itt_region_end_ptr 0 #define __itt_region_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} regions group */ /** @} regions group */
/** /**
* @defgroup frames Frames * @defgroup frames Frames
* @ingroup public * @ingroup public
* Frames are similar to regions, but are intended to be easier to use and to implement. * Frames are similar to regions, but are intended to be easier to use and to
* In particular: * implement. In particular:
* - Frames always represent periods of elapsed time * - Frames always represent periods of elapsed time
* - By default, frames have no nesting relationships * - By default, frames have no nesting relationships
* @{ * @{
*/ */
/** /**
* @ingroup frames * @ingroup frames
* @brief Begin a frame instance. * @brief Begin a frame instance.
Show All 24 Lines
* Passing special __itt_timestamp_none value as "end" argument means * Passing special __itt_timestamp_none value as "end" argument means
* take the current timestamp as the end timestamp. * take the current timestamp as the end timestamp.
* @param[in] domain The domain for this frame instance * @param[in] domain The domain for this frame instance
* @param[in] id The instance ID for this frame instance or NULL * @param[in] id The instance ID for this frame instance or NULL
* @param[in] begin Timestamp of the beginning of the frame * @param[in] begin Timestamp of the beginning of the frame
* @param[in] end Timestamp of the end of the frame * @param[in] end Timestamp of the end of the frame
*/ */
void ITTAPI __itt_frame_submit_v3(const __itt_domain *domain, __itt_id *id, void ITTAPI __itt_frame_submit_v3(const __itt_domain *domain, __itt_id *id,
__itt_timestamp begin, __itt_timestamp end); __itt_timestamp begin, __itt_timestamp end);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, frame_begin_v3, (const __itt_domain *domain, __itt_id *id)) ITT_STUBV(ITTAPI, void, frame_begin_v3,
ITT_STUBV(ITTAPI, void, frame_end_v3, (const __itt_domain *domain, __itt_id *id)) (const __itt_domain *domain, __itt_id *id))
ITT_STUBV(ITTAPI, void, frame_submit_v3, (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin, __itt_timestamp end)) ITT_STUBV(ITTAPI, void, frame_end_v3,
(const __itt_domain *domain, __itt_id *id))
ITT_STUBV(ITTAPI, void, frame_submit_v3,
(const __itt_domain *domain, __itt_id *id, __itt_timestamp begin,
__itt_timestamp end))
#define __itt_frame_begin_v3(d,x) ITTNOTIFY_VOID_D1(frame_begin_v3,d,x) #define __itt_frame_begin_v3(d, x) ITTNOTIFY_VOID_D1(frame_begin_v3, d, x)
#define __itt_frame_begin_v3_ptr ITTNOTIFY_NAME(frame_begin_v3) #define __itt_frame_begin_v3_ptr ITTNOTIFY_NAME(frame_begin_v3)
#define __itt_frame_end_v3(d,x) ITTNOTIFY_VOID_D1(frame_end_v3,d,x) #define __itt_frame_end_v3(d, x) ITTNOTIFY_VOID_D1(frame_end_v3, d, x)
#define __itt_frame_end_v3_ptr ITTNOTIFY_NAME(frame_end_v3) #define __itt_frame_end_v3_ptr ITTNOTIFY_NAME(frame_end_v3)
#define __itt_frame_submit_v3(d,x,b,e) ITTNOTIFY_VOID_D3(frame_submit_v3,d,x,b,e) #define __itt_frame_submit_v3(d, x, b, e) \
ITTNOTIFY_VOID_D3(frame_submit_v3, d, x, b, e)
#define __itt_frame_submit_v3_ptr ITTNOTIFY_NAME(frame_submit_v3) #define __itt_frame_submit_v3_ptr ITTNOTIFY_NAME(frame_submit_v3)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_frame_begin_v3(domain,id) #define __itt_frame_begin_v3(domain, id)
#define __itt_frame_begin_v3_ptr 0 #define __itt_frame_begin_v3_ptr 0
#define __itt_frame_end_v3(domain,id) #define __itt_frame_end_v3(domain, id)
#define __itt_frame_end_v3_ptr 0 #define __itt_frame_end_v3_ptr 0
#define __itt_frame_submit_v3(domain,id,begin,end) #define __itt_frame_submit_v3(domain, id, begin, end)
#define __itt_frame_submit_v3_ptr 0 #define __itt_frame_submit_v3_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_frame_begin_v3_ptr 0 #define __itt_frame_begin_v3_ptr 0
#define __itt_frame_end_v3_ptr 0 #define __itt_frame_end_v3_ptr 0
#define __itt_frame_submit_v3_ptr 0 #define __itt_frame_submit_v3_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} frames group */ /** @} frames group */
/** @endcond */ /** @endcond */
/** /**
* @defgroup taskgroup Task Group * @defgroup taskgroup Task Group
* @ingroup public * @ingroup public
* Task Group * Task Group
* @{ * @{
*/ */
/** /**
* @ingroup task_groups * @ingroup task_groups
* @brief Denotes a task_group instance. * @brief Denotes a task_group instance.
* Successive calls to __itt_task_group with the same ID are ignored. * Successive calls to __itt_task_group with the same ID are ignored.
* @param[in] domain The domain for this task_group instance * @param[in] domain The domain for this task_group instance
* @param[in] id The instance ID for this task_group instance. Must not be __itt_null. * @param[in] id The instance ID for this task_group instance. Must not be
* @param[in] parentid The instance ID for the parent of this task_group instance, or __itt_null. * __itt_null.
* @param[in] parentid The instance ID for the parent of this task_group
* instance, or __itt_null.
* @param[in] name The name of this task_group * @param[in] name The name of this task_group
*/ */
void ITTAPI __itt_task_group(const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name); void ITTAPI __itt_task_group(const __itt_domain *domain, __itt_id id,
__itt_id parentid, __itt_string_handle *name);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, task_group, (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name)) ITT_STUBV(ITTAPI, void, task_group,
(const __itt_domain *domain, __itt_id id, __itt_id parentid,
__itt_string_handle *name))
#define __itt_task_group(d,x,y,z) ITTNOTIFY_VOID_D3(task_group,d,x,y,z) #define __itt_task_group(d, x, y, z) ITTNOTIFY_VOID_D3(task_group, d, x, y, z)
#define __itt_task_group_ptr ITTNOTIFY_NAME(task_group) #define __itt_task_group_ptr ITTNOTIFY_NAME(task_group)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_task_group(d,x,y,z) #define __itt_task_group(d, x, y, z)
#define __itt_task_group_ptr 0 #define __itt_task_group_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_task_group_ptr 0 #define __itt_task_group_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} taskgroup group */ /** @} taskgroup group */
/** /**
* @defgroup tasks Tasks * @defgroup tasks Tasks
* @ingroup public * @ingroup public
Show All 14 Lines
* @{ * @{
*/ */
/** /**
* @ingroup tasks * @ingroup tasks
* @brief Begin a task instance. * @brief Begin a task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
* @param[in] taskid The instance ID for this task instance, or __itt_null * @param[in] taskid The instance ID for this task instance, or __itt_null
* @param[in] parentid The parent instance to which this task instance belongs, or __itt_null * @param[in] parentid The parent instance to which this task instance belongs,
* or __itt_null
* @param[in] name The name of this task * @param[in] name The name of this task
*/ */
void ITTAPI __itt_task_begin(const __itt_domain *domain, __itt_id taskid, __itt_id parentid, __itt_string_handle *name); void ITTAPI __itt_task_begin(const __itt_domain *domain, __itt_id taskid,
__itt_id parentid, __itt_string_handle *name);
/** /**
* @ingroup tasks * @ingroup tasks
* @brief Begin a task instance. * @brief Begin a task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
* @param[in] taskid The identifier for this task instance (may be 0) * @param[in] taskid The identifier for this task instance (may be 0)
* @param[in] parentid The parent of this task (may be 0) * @param[in] parentid The parent of this task (may be 0)
* @param[in] fn The pointer to the function you are tracing * @param[in] fn The pointer to the function you are tracing
*/ */
void ITTAPI __itt_task_begin_fn(const __itt_domain *domain, __itt_id taskid, __itt_id parentid, void* fn); void ITTAPI __itt_task_begin_fn(const __itt_domain *domain, __itt_id taskid,
__itt_id parentid, void *fn);
/** /**
* @ingroup tasks * @ingroup tasks
* @brief End the current task instance. * @brief End the current task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
*/ */
void ITTAPI __itt_task_end(const __itt_domain *domain); void ITTAPI __itt_task_end(const __itt_domain *domain);
/** /**
* @ingroup tasks * @ingroup tasks
* @brief Begin an overlapped task instance. * @brief Begin an overlapped task instance.
* @param[in] domain The domain for this task. * @param[in] domain The domain for this task.
* @param[in] taskid The identifier for this task instance, *cannot* be __itt_null. * @param[in] taskid The identifier for this task instance, *cannot* be
* __itt_null.
* @param[in] parentid The parent of this task, or __itt_null. * @param[in] parentid The parent of this task, or __itt_null.
* @param[in] name The name of this task. * @param[in] name The name of this task.
*/ */
void ITTAPI __itt_task_begin_overlapped(const __itt_domain* domain, __itt_id taskid, __itt_id parentid, __itt_string_handle* name); void ITTAPI __itt_task_begin_overlapped(const __itt_domain *domain,
__itt_id taskid, __itt_id parentid,
__itt_string_handle *name);
/** /**
* @ingroup tasks * @ingroup tasks
* @brief End an overlapped task instance. * @brief End an overlapped task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
* @param[in] taskid Explicit ID of finished task * @param[in] taskid Explicit ID of finished task
*/ */
void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain, __itt_id taskid); void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain,
__itt_id taskid);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, task_begin, (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name)) ITT_STUBV(ITTAPI, void, task_begin,
ITT_STUBV(ITTAPI, void, task_begin_fn, (const __itt_domain *domain, __itt_id id, __itt_id parentid, void* fn)) (const __itt_domain *domain, __itt_id id, __itt_id parentid,
__itt_string_handle *name))
ITT_STUBV(ITTAPI, void, task_begin_fn,
(const __itt_domain *domain, __itt_id id, __itt_id parentid,
void *fn))
ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain)) ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain))
ITT_STUBV(ITTAPI, void, task_begin_overlapped, (const __itt_domain *domain, __itt_id taskid, __itt_id parentid, __itt_string_handle *name)) ITT_STUBV(ITTAPI, void, task_begin_overlapped,
ITT_STUBV(ITTAPI, void, task_end_overlapped, (const __itt_domain *domain, __itt_id taskid)) (const __itt_domain *domain, __itt_id taskid, __itt_id parentid,
__itt_string_handle *name))
ITT_STUBV(ITTAPI, void, task_end_overlapped,
(const __itt_domain *domain, __itt_id taskid))
#define __itt_task_begin(d,x,y,z) ITTNOTIFY_VOID_D3(task_begin,d,x,y,z) #define __itt_task_begin(d, x, y, z) ITTNOTIFY_VOID_D3(task_begin, d, x, y, z)
#define __itt_task_begin_ptr ITTNOTIFY_NAME(task_begin) #define __itt_task_begin_ptr ITTNOTIFY_NAME(task_begin)
#define __itt_task_begin_fn(d,x,y,z) ITTNOTIFY_VOID_D3(task_begin_fn,d,x,y,z) #define __itt_task_begin_fn(d, x, y, z) \
ITTNOTIFY_VOID_D3(task_begin_fn, d, x, y, z)
#define __itt_task_begin_fn_ptr ITTNOTIFY_NAME(task_begin_fn) #define __itt_task_begin_fn_ptr ITTNOTIFY_NAME(task_begin_fn)
#define __itt_task_end(d) ITTNOTIFY_VOID_D0(task_end,d) #define __itt_task_end(d) ITTNOTIFY_VOID_D0(task_end, d)
#define __itt_task_end_ptr ITTNOTIFY_NAME(task_end) #define __itt_task_end_ptr ITTNOTIFY_NAME(task_end)
#define __itt_task_begin_overlapped(d,x,y,z) ITTNOTIFY_VOID_D3(task_begin_overlapped,d,x,y,z) #define __itt_task_begin_overlapped(d, x, y, z) \
ITTNOTIFY_VOID_D3(task_begin_overlapped, d, x, y, z)
#define __itt_task_begin_overlapped_ptr ITTNOTIFY_NAME(task_begin_overlapped) #define __itt_task_begin_overlapped_ptr ITTNOTIFY_NAME(task_begin_overlapped)
#define __itt_task_end_overlapped(d,x) ITTNOTIFY_VOID_D1(task_end_overlapped,d,x) #define __itt_task_end_overlapped(d, x) \
ITTNOTIFY_VOID_D1(task_end_overlapped, d, x)
#define __itt_task_end_overlapped_ptr ITTNOTIFY_NAME(task_end_overlapped) #define __itt_task_end_overlapped_ptr ITTNOTIFY_NAME(task_end_overlapped)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_task_begin(domain,id,parentid,name) #define __itt_task_begin(domain, id, parentid, name)
#define __itt_task_begin_ptr 0 #define __itt_task_begin_ptr 0
#define __itt_task_begin_fn(domain,id,parentid,fn) #define __itt_task_begin_fn(domain, id, parentid, fn)
#define __itt_task_begin_fn_ptr 0 #define __itt_task_begin_fn_ptr 0
#define __itt_task_end(domain) #define __itt_task_end(domain)
#define __itt_task_end_ptr 0 #define __itt_task_end_ptr 0
#define __itt_task_begin_overlapped(domain,taskid,parentid,name) #define __itt_task_begin_overlapped(domain, taskid, parentid, name)
#define __itt_task_begin_overlapped_ptr 0 #define __itt_task_begin_overlapped_ptr 0
#define __itt_task_end_overlapped(domain,taskid) #define __itt_task_end_overlapped(domain, taskid)
#define __itt_task_end_overlapped_ptr 0 #define __itt_task_end_overlapped_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_task_begin_ptr 0 #define __itt_task_begin_ptr 0
#define __itt_task_begin_fn_ptr 0 #define __itt_task_begin_fn_ptr 0
#define __itt_task_end_ptr 0 #define __itt_task_end_ptr 0
#define __itt_task_begin_overlapped_ptr 0 #define __itt_task_begin_overlapped_ptr 0
#define __itt_task_end_overlapped_ptr 0 #define __itt_task_end_overlapped_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} tasks group */ /** @} tasks group */
/** /**
* @defgroup markers Markers * @defgroup markers Markers
* Markers represent a single discreet event in time. Markers have a scope, * Markers represent a single discreet event in time. Markers have a scope,
* described by an enumerated type __itt_scope. Markers are created by * described by an enumerated type __itt_scope. Markers are created by
* the API call __itt_marker. A marker instance can be given an ID for use in * the API call __itt_marker. A marker instance can be given an ID for use in
* adding metadata. * adding metadata.
* @{ * @{
*/ */
/** /**
* @brief Describes the scope of an event object in the trace. * @brief Describes the scope of an event object in the trace.
*/ */
typedef enum typedef enum {
{
__itt_scope_unknown = 0, __itt_scope_unknown = 0,
__itt_scope_global, __itt_scope_global,
__itt_scope_track_group, __itt_scope_track_group,
__itt_scope_track, __itt_scope_track,
__itt_scope_task, __itt_scope_task,
__itt_scope_marker __itt_scope_marker
} __itt_scope; } __itt_scope;
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#define __itt_marker_scope_unknown __itt_scope_unknown #define __itt_marker_scope_unknown __itt_scope_unknown
#define __itt_marker_scope_global __itt_scope_global #define __itt_marker_scope_global __itt_scope_global
#define __itt_marker_scope_process __itt_scope_track_group #define __itt_marker_scope_process __itt_scope_track_group
#define __itt_marker_scope_thread __itt_scope_track #define __itt_marker_scope_thread __itt_scope_track
#define __itt_marker_scope_task __itt_scope_task #define __itt_marker_scope_task __itt_scope_task
/** @endcond */ /** @endcond */
/** /**
* @ingroup markers * @ingroup markers
* @brief Create a marker instance * @brief Create a marker instance
* @param[in] domain The domain for this marker * @param[in] domain The domain for this marker
* @param[in] id The instance ID for this marker or __itt_null * @param[in] id The instance ID for this marker or __itt_null
* @param[in] name The name for this marker * @param[in] name The name for this marker
* @param[in] scope The scope for this marker * @param[in] scope The scope for this marker
*/ */
void ITTAPI __itt_marker(const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope); void ITTAPI __itt_marker(const __itt_domain *domain, __itt_id id,
__itt_string_handle *name, __itt_scope scope);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, marker, (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope)) ITT_STUBV(ITTAPI, void, marker,
(const __itt_domain *domain, __itt_id id, __itt_string_handle *name,
__itt_scope scope))
#define __itt_marker(d,x,y,z) ITTNOTIFY_VOID_D3(marker,d,x,y,z) #define __itt_marker(d, x, y, z) ITTNOTIFY_VOID_D3(marker, d, x, y, z)
#define __itt_marker_ptr ITTNOTIFY_NAME(marker) #define __itt_marker_ptr ITTNOTIFY_NAME(marker)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_marker(domain,id,name,scope) #define __itt_marker(domain, id, name, scope)
#define __itt_marker_ptr 0 #define __itt_marker_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_marker_ptr 0 #define __itt_marker_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} markers group */ /** @} markers group */
/** /**
* @defgroup metadata Metadata * @defgroup metadata Metadata
* The metadata API is used to attach extra information to named * The metadata API is used to attach extra information to named
* entities. Metadata can be attached to an identified named entity by ID, * entities. Metadata can be attached to an identified named entity by ID,
* or to the current entity (which is always a task). * or to the current entity (which is always a task).
* *
* Conceptually metadata has a type (what kind of metadata), a key (the * Conceptually metadata has a type (what kind of metadata), a key (the
* name of the metadata), and a value (the actual data). The encoding of * name of the metadata), and a value (the actual data). The encoding of
* the value depends on the type of the metadata. * the value depends on the type of the metadata.
* *
* The type of metadata is specified by an enumerated type __itt_metadata_type. * The type of metadata is specified by an enumerated type __itt_metadata_type.
* @{ * @{
*/ */
/** /**
* @ingroup parameters * @ingroup parameters
* @brief describes the type of metadata * @brief describes the type of metadata
*/ */
typedef enum { typedef enum {
__itt_metadata_unknown = 0, __itt_metadata_unknown = 0,
__itt_metadata_u64, /**< Unsigned 64-bit integer */ __itt_metadata_u64, /**< Unsigned 64-bit integer */
__itt_metadata_s64, /**< Signed 64-bit integer */ __itt_metadata_s64, /**< Signed 64-bit integer */
__itt_metadata_u32, /**< Unsigned 32-bit integer */ __itt_metadata_u32, /**< Unsigned 32-bit integer */
__itt_metadata_s32, /**< Signed 32-bit integer */ __itt_metadata_s32, /**< Signed 32-bit integer */
__itt_metadata_u16, /**< Unsigned 16-bit integer */ __itt_metadata_u16, /**< Unsigned 16-bit integer */
__itt_metadata_s16, /**< Signed 16-bit integer */ __itt_metadata_s16, /**< Signed 16-bit integer */
__itt_metadata_float, /**< Signed 32-bit floating-point */ __itt_metadata_float, /**< Signed 32-bit floating-point */
__itt_metadata_double /**< SIgned 64-bit floating-point */ __itt_metadata_double /**< SIgned 64-bit floating-point */
} __itt_metadata_type; } __itt_metadata_type;
/** /**
* @ingroup parameters * @ingroup parameters
* @brief Add metadata to an instance of a named entity. * @brief Add metadata to an instance of a named entity.
* @param[in] domain The domain controlling the call * @param[in] domain The domain controlling the call
* @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task * @param[in] id The identifier of the instance to which the metadata is to be
* added, or __itt_null to add to the current task
* @param[in] key The name of the metadata * @param[in] key The name of the metadata
* @param[in] type The type of the metadata * @param[in] type The type of the metadata
* @param[in] count The number of elements of the given type. If count == 0, no metadata will be added. * @param[in] count The number of elements of the given type. If count == 0, no
* metadata will be added.
* @param[in] data The metadata itself * @param[in] data The metadata itself
*/ */
void ITTAPI __itt_metadata_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data); void ITTAPI __itt_metadata_add(const __itt_domain *domain, __itt_id id,
__itt_string_handle *key,
__itt_metadata_type type, size_t count,
void *data);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, metadata_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data)) ITT_STUBV(ITTAPI, void, metadata_add,
#define __itt_metadata_add(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(metadata_add,d,x,y,z,a,b) (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
__itt_metadata_type type, size_t count, void *data))
#define __itt_metadata_add(d, x, y, z, a, b) \
ITTNOTIFY_VOID_D5(metadata_add, d, x, y, z, a, b)
#define __itt_metadata_add_ptr ITTNOTIFY_NAME(metadata_add) #define __itt_metadata_add_ptr ITTNOTIFY_NAME(metadata_add)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_metadata_add(d,x,y,z,a,b) #define __itt_metadata_add(d, x, y, z, a, b)
#define __itt_metadata_add_ptr 0 #define __itt_metadata_add_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_metadata_add_ptr 0 #define __itt_metadata_add_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup parameters * @ingroup parameters
* @brief Add string metadata to an instance of a named entity. * @brief Add string metadata to an instance of a named entity.
* @param[in] domain The domain controlling the call * @param[in] domain The domain controlling the call
* @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task * @param[in] id The identifier of the instance to which the metadata is to be
* added, or __itt_null to add to the current task
* @param[in] key The name of the metadata * @param[in] key The name of the metadata
* @param[in] data The metadata itself * @param[in] data The metadata itself
* @param[in] length The number of characters in the string, or -1 if the length is unknown but the string is null-terminated * @param[in] length The number of characters in the string, or -1 if the length
* is unknown but the string is null-terminated
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length); void ITTAPI __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id,
void ITTAPI __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t *data, size_t length); __itt_string_handle *key, const char *data,
size_t length);
void ITTAPI __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id,
__itt_string_handle *key,
const wchar_t *data, size_t length);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_metadata_str_add __itt_metadata_str_addW #define __itt_metadata_str_add __itt_metadata_str_addW
# define __itt_metadata_str_add_ptr __itt_metadata_str_addW_ptr #define __itt_metadata_str_add_ptr __itt_metadata_str_addW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_metadata_str_add __itt_metadata_str_addA #define __itt_metadata_str_add __itt_metadata_str_addA
# define __itt_metadata_str_add_ptr __itt_metadata_str_addA_ptr #define __itt_metadata_str_add_ptr __itt_metadata_str_addA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
void ITTAPI __itt_metadata_str_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length); void ITTAPI __itt_metadata_str_add(const __itt_domain *domain, __itt_id id,
__itt_string_handle *key, const char *data,
size_t length);
#endif #endif
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, metadata_str_addA, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length)) ITT_STUBV(ITTAPI, void, metadata_str_addA,
ITT_STUBV(ITTAPI, void, metadata_str_addW, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t *data, size_t length)) (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ const char *data, size_t length))
ITT_STUBV(ITTAPI, void, metadata_str_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length)) ITT_STUBV(ITTAPI, void, metadata_str_addW,
(const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
const wchar_t *data, size_t length))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, metadata_str_add,
(const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
const char *data, size_t length))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_metadata_str_addA(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_addA,d,x,y,z,a) #define __itt_metadata_str_addA(d, x, y, z, a) \
ITTNOTIFY_VOID_D4(metadata_str_addA, d, x, y, z, a)
#define __itt_metadata_str_addA_ptr ITTNOTIFY_NAME(metadata_str_addA) #define __itt_metadata_str_addA_ptr ITTNOTIFY_NAME(metadata_str_addA)
#define __itt_metadata_str_addW(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_addW,d,x,y,z,a) #define __itt_metadata_str_addW(d, x, y, z, a) \
ITTNOTIFY_VOID_D4(metadata_str_addW, d, x, y, z, a)
#define __itt_metadata_str_addW_ptr ITTNOTIFY_NAME(metadata_str_addW) #define __itt_metadata_str_addW_ptr ITTNOTIFY_NAME(metadata_str_addW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_metadata_str_add(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add,d,x,y,z,a) #define __itt_metadata_str_add(d, x, y, z, a) \
ITTNOTIFY_VOID_D4(metadata_str_add, d, x, y, z, a)
#define __itt_metadata_str_add_ptr ITTNOTIFY_NAME(metadata_str_add) #define __itt_metadata_str_add_ptr ITTNOTIFY_NAME(metadata_str_add)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_metadata_str_addA(d,x,y,z,a) #define __itt_metadata_str_addA(d, x, y, z, a)
#define __itt_metadata_str_addA_ptr 0 #define __itt_metadata_str_addA_ptr 0
#define __itt_metadata_str_addW(d,x,y,z,a) #define __itt_metadata_str_addW(d, x, y, z, a)
#define __itt_metadata_str_addW_ptr 0 #define __itt_metadata_str_addW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_metadata_str_add(d,x,y,z,a) #define __itt_metadata_str_add(d, x, y, z, a)
#define __itt_metadata_str_add_ptr 0 #define __itt_metadata_str_add_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_metadata_str_addA_ptr 0 #define __itt_metadata_str_addA_ptr 0
#define __itt_metadata_str_addW_ptr 0 #define __itt_metadata_str_addW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_metadata_str_add_ptr 0 #define __itt_metadata_str_add_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup parameters * @ingroup parameters
* @brief Add metadata to an instance of a named entity. * @brief Add metadata to an instance of a named entity.
* @param[in] domain The domain controlling the call * @param[in] domain The domain controlling the call
* @param[in] scope The scope of the instance to which the metadata is to be added * @param[in] scope The scope of the instance to which the metadata is to be
added
* @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task * @param[in] id The identifier of the instance to which the metadata is to be
added, or __itt_null to add to the current task
* @param[in] key The name of the metadata * @param[in] key The name of the metadata
* @param[in] type The type of the metadata * @param[in] type The type of the metadata
* @param[in] count The number of elements of the given type. If count == 0, no metadata will be added. * @param[in] count The number of elements of the given type. If count == 0, no
metadata will be added.
* @param[in] data The metadata itself * @param[in] data The metadata itself
*/ */
void ITTAPI __itt_metadata_add_with_scope(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data); void ITTAPI __itt_metadata_add_with_scope(const __itt_domain *domain,
__itt_scope scope,
__itt_string_handle *key,
__itt_metadata_type type,
size_t count, void *data);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, metadata_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data)) ITT_STUBV(ITTAPI, void, metadata_add_with_scope,
#define __itt_metadata_add_with_scope(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(metadata_add_with_scope,d,x,y,z,a,b) (const __itt_domain *domain, __itt_scope scope,
#define __itt_metadata_add_with_scope_ptr ITTNOTIFY_NAME(metadata_add_with_scope) __itt_string_handle *key, __itt_metadata_type type, size_t count,
void *data))
#define __itt_metadata_add_with_scope(d, x, y, z, a, b) \
ITTNOTIFY_VOID_D5(metadata_add_with_scope, d, x, y, z, a, b)
#define __itt_metadata_add_with_scope_ptr \
ITTNOTIFY_NAME(metadata_add_with_scope)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_metadata_add_with_scope(d,x,y,z,a,b) #define __itt_metadata_add_with_scope(d, x, y, z, a, b)
#define __itt_metadata_add_with_scope_ptr 0 #define __itt_metadata_add_with_scope_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_metadata_add_with_scope_ptr 0 #define __itt_metadata_add_with_scope_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup parameters * @ingroup parameters
* @brief Add string metadata to an instance of a named entity. * @brief Add string metadata to an instance of a named entity.
* @param[in] domain The domain controlling the call * @param[in] domain The domain controlling the call
* @param[in] scope The scope of the instance to which the metadata is to be added * @param[in] scope The scope of the instance to which the metadata is to be
added
* @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task * @param[in] id The identifier of the instance to which the metadata is to be
added, or __itt_null to add to the current task
* @param[in] key The name of the metadata * @param[in] key The name of the metadata
* @param[in] data The metadata itself * @param[in] data The metadata itself
* @param[in] length The number of characters in the string, or -1 if the length is unknown but the string is null-terminated * @param[in] length The number of characters in the string, or -1 if the length
is unknown but the string is null-terminated
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_metadata_str_add_with_scopeA(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length); void ITTAPI __itt_metadata_str_add_with_scopeA(const __itt_domain *domain,
void ITTAPI __itt_metadata_str_add_with_scopeW(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length); __itt_scope scope,
__itt_string_handle *key,
const char *data, size_t length);
void ITTAPI __itt_metadata_str_add_with_scopeW(const __itt_domain *domain,
__itt_scope scope,
__itt_string_handle *key,
const wchar_t *data,
size_t length);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeW #define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeW
# define __itt_metadata_str_add_with_scope_ptr __itt_metadata_str_add_with_scopeW_ptr #define __itt_metadata_str_add_with_scope_ptr \
__itt_metadata_str_add_with_scopeW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeA #define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeA
# define __itt_metadata_str_add_with_scope_ptr __itt_metadata_str_add_with_scopeA_ptr #define __itt_metadata_str_add_with_scope_ptr \
__itt_metadata_str_add_with_scopeA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
void ITTAPI __itt_metadata_str_add_with_scope(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length); void ITTAPI __itt_metadata_str_add_with_scope(const __itt_domain *domain,
__itt_scope scope,
__itt_string_handle *key,
const char *data, size_t length);
#endif #endif
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length)) ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA,
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length)) (const __itt_domain *domain, __itt_scope scope,
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ __itt_string_handle *key, const char *data, size_t length))
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length)) ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW,
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ (const __itt_domain *domain, __itt_scope scope,
#if ITT_PLATFORM==ITT_PLATFORM_WIN __itt_string_handle *key, const wchar_t *data, size_t length))
#define __itt_metadata_str_add_with_scopeA(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeA,d,x,y,z,a) #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_metadata_str_add_with_scopeA_ptr ITTNOTIFY_NAME(metadata_str_add_with_scopeA) ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope,
#define __itt_metadata_str_add_with_scopeW(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeW,d,x,y,z,a) (const __itt_domain *domain, __itt_scope scope,
#define __itt_metadata_str_add_with_scopeW_ptr ITTNOTIFY_NAME(metadata_str_add_with_scopeW) __itt_string_handle *key, const char *data, size_t length))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_metadata_str_add_with_scope(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add_with_scope,d,x,y,z,a) #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_metadata_str_add_with_scope_ptr ITTNOTIFY_NAME(metadata_str_add_with_scope) #define __itt_metadata_str_add_with_scopeA(d, x, y, z, a) \
ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeA, d, x, y, z, a)
#define __itt_metadata_str_add_with_scopeA_ptr \
ITTNOTIFY_NAME(metadata_str_add_with_scopeA)
#define __itt_metadata_str_add_with_scopeW(d, x, y, z, a) \
ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeW, d, x, y, z, a)
#define __itt_metadata_str_add_with_scopeW_ptr \
ITTNOTIFY_NAME(metadata_str_add_with_scopeW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_metadata_str_add_with_scope(d, x, y, z, a) \
ITTNOTIFY_VOID_D4(metadata_str_add_with_scope, d, x, y, z, a)
#define __itt_metadata_str_add_with_scope_ptr \
ITTNOTIFY_NAME(metadata_str_add_with_scope)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_metadata_str_add_with_scopeA(d,x,y,z,a) #define __itt_metadata_str_add_with_scopeA(d, x, y, z, a)
#define __itt_metadata_str_add_with_scopeA_ptr 0 #define __itt_metadata_str_add_with_scopeA_ptr 0
#define __itt_metadata_str_add_with_scopeW(d,x,y,z,a) #define __itt_metadata_str_add_with_scopeW(d, x, y, z, a)
#define __itt_metadata_str_add_with_scopeW_ptr 0 #define __itt_metadata_str_add_with_scopeW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_metadata_str_add_with_scope(d,x,y,z,a) #define __itt_metadata_str_add_with_scope(d, x, y, z, a)
#define __itt_metadata_str_add_with_scope_ptr 0 #define __itt_metadata_str_add_with_scope_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_metadata_str_add_with_scopeA_ptr 0 #define __itt_metadata_str_add_with_scopeA_ptr 0
#define __itt_metadata_str_add_with_scopeW_ptr 0 #define __itt_metadata_str_add_with_scopeW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_metadata_str_add_with_scope_ptr 0 #define __itt_metadata_str_add_with_scope_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} metadata group */ /** @} metadata group */
/** /**
* @defgroup relations Relations * @defgroup relations Relations
* Instances of named entities can be explicitly associated with other * Instances of named entities can be explicitly associated with other
* instances using instance IDs and the relationship API calls. * instances using instance IDs and the relationship API calls.
* *
* @{ * @{
*/ */
/** /**
* @ingroup relations * @ingroup relations
* @brief The kind of relation between two instances is specified by the enumerated type __itt_relation. * @brief The kind of relation between two instances is specified by the
* Relations between instances can be added with an API call. The relation * enumerated type __itt_relation. Relations between instances can be added with
* API uses instance IDs. Relations can be added before or after the actual * an API call. The relation API uses instance IDs. Relations can be added
* instances are created and persist independently of the instances. This * before or after the actual instances are created and persist independently of
* is the motivation for having different lifetimes for instance IDs and * the instances. This is the motivation for having different lifetimes for
* the actual instances. * instance IDs and the actual instances.
*/ */
typedef enum typedef enum {
{
__itt_relation_is_unknown = 0, __itt_relation_is_unknown = 0,
__itt_relation_is_dependent_on, /**< "A is dependent on B" means that A cannot start until B completes */ __itt_relation_is_dependent_on, /**< "A is dependent on B" means that A cannot
__itt_relation_is_sibling_of, /**< "A is sibling of B" means that A and B were created as a group */ start until B completes */
__itt_relation_is_sibling_of, /**< "A is sibling of B" means that A and B were
created as a group */
__itt_relation_is_parent_of, /**< "A is parent of B" means that A created B */ __itt_relation_is_parent_of, /**< "A is parent of B" means that A created B */
__itt_relation_is_continuation_of, /**< "A is continuation of B" means that A assumes the dependencies of B */ __itt_relation_is_continuation_of, /**< "A is continuation of B" means that A
__itt_relation_is_child_of, /**< "A is child of B" means that A was created by B (inverse of is_parent_of) */ assumes the dependencies of B */
__itt_relation_is_continued_by, /**< "A is continued by B" means that B assumes the dependencies of A (inverse of is_continuation_of) */ __itt_relation_is_child_of, /**< "A is child of B" means that A was created by
__itt_relation_is_predecessor_to /**< "A is predecessor to B" means that B cannot start until A completes (inverse of is_dependent_on) */ B (inverse of is_parent_of) */
__itt_relation_is_continued_by, /**< "A is continued by B" means that B
assumes the dependencies of A (inverse of
is_continuation_of) */
__itt_relation_is_predecessor_to /**< "A is predecessor to B" means that B
cannot start until A completes (inverse of
is_dependent_on) */
} __itt_relation; } __itt_relation;
/** /**
* @ingroup relations * @ingroup relations
* @brief Add a relation to the current task instance. * @brief Add a relation to the current task instance.
* The current task instance is the head of the relation. * The current task instance is the head of the relation.
* @param[in] domain The domain controlling this call * @param[in] domain The domain controlling this call
* @param[in] relation The kind of relation * @param[in] relation The kind of relation
* @param[in] tail The ID for the tail of the relation * @param[in] tail The ID for the tail of the relation
*/ */
void ITTAPI __itt_relation_add_to_current(const __itt_domain *domain, __itt_relation relation, __itt_id tail); void ITTAPI __itt_relation_add_to_current(const __itt_domain *domain,
__itt_relation relation,
__itt_id tail);
/** /**
* @ingroup relations * @ingroup relations
* @brief Add a relation between two instance identifiers. * @brief Add a relation between two instance identifiers.
* @param[in] domain The domain controlling this call * @param[in] domain The domain controlling this call
* @param[in] head The ID for the head of the relation * @param[in] head The ID for the head of the relation
* @param[in] relation The kind of relation * @param[in] relation The kind of relation
* @param[in] tail The ID for the tail of the relation * @param[in] tail The ID for the tail of the relation
*/ */
void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail); void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head,
__itt_relation relation, __itt_id tail);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, relation_add_to_current, (const __itt_domain *domain, __itt_relation relation, __itt_id tail)) ITT_STUBV(ITTAPI, void, relation_add_to_current,
ITT_STUBV(ITTAPI, void, relation_add, (const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail)) (const __itt_domain *domain, __itt_relation relation, __itt_id tail))
#define __itt_relation_add_to_current(d,x,y) ITTNOTIFY_VOID_D2(relation_add_to_current,d,x,y) ITT_STUBV(ITTAPI, void, relation_add,
#define __itt_relation_add_to_current_ptr ITTNOTIFY_NAME(relation_add_to_current) (const __itt_domain *domain, __itt_id head, __itt_relation relation,
#define __itt_relation_add(d,x,y,z) ITTNOTIFY_VOID_D3(relation_add,d,x,y,z) __itt_id tail))
#define __itt_relation_add_to_current(d, x, y) \
ITTNOTIFY_VOID_D2(relation_add_to_current, d, x, y)
#define __itt_relation_add_to_current_ptr \
ITTNOTIFY_NAME(relation_add_to_current)
#define __itt_relation_add(d, x, y, z) \
ITTNOTIFY_VOID_D3(relation_add, d, x, y, z)
#define __itt_relation_add_ptr ITTNOTIFY_NAME(relation_add) #define __itt_relation_add_ptr ITTNOTIFY_NAME(relation_add)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_relation_add_to_current(d,x,y) #define __itt_relation_add_to_current(d, x, y)
#define __itt_relation_add_to_current_ptr 0 #define __itt_relation_add_to_current_ptr 0
#define __itt_relation_add(d,x,y,z) #define __itt_relation_add(d, x, y, z)
#define __itt_relation_add_ptr 0 #define __itt_relation_add_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_relation_add_to_current_ptr 0 #define __itt_relation_add_to_current_ptr 0
#define __itt_relation_add_ptr 0 #define __itt_relation_add_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} relations group */ /** @} relations group */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_clock_info typedef struct ___itt_clock_info {
{
unsigned long long clock_freq; /*!< Clock domain frequency */ unsigned long long clock_freq; /*!< Clock domain frequency */
unsigned long long clock_base; /*!< Clock domain base timestamp */ unsigned long long clock_base; /*!< Clock domain base timestamp */
} __itt_clock_info; } __itt_clock_info;
#pragma pack(pop) #pragma pack(pop)
/** @endcond */ /** @endcond */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
typedef void (ITTAPI *__itt_get_clock_info_fn)(__itt_clock_info* clock_info, void* data); typedef void(ITTAPI *__itt_get_clock_info_fn)(__itt_clock_info *clock_info,
void *data);
/** @endcond */ /** @endcond */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_clock_domain typedef struct ___itt_clock_domain {
{
__itt_clock_info info; /*!< Most recent clock domain info */ __itt_clock_info info; /*!< Most recent clock domain info */
__itt_get_clock_info_fn fn; /*!< Callback function pointer */ __itt_get_clock_info_fn fn; /*!< Callback function pointer */
void* fn_data; /*!< Input argument for the callback function */ void *fn_data; /*!< Input argument for the callback function */
int extra1; /*!< Reserved. Must be zero */ int extra1; /*!< Reserved. Must be zero */
void* extra2; /*!< Reserved. Must be zero */ void *extra2; /*!< Reserved. Must be zero */
struct ___itt_clock_domain* next; struct ___itt_clock_domain *next;
} __itt_clock_domain; } __itt_clock_domain;
#pragma pack(pop) #pragma pack(pop)
/** @endcond */ /** @endcond */
/** /**
* @ingroup clockdomains * @ingroup clockdomains
* @brief Create a clock domain. * @brief Create a clock domain.
* Certain applications require the capability to trace their application using * Certain applications require the capability to trace their application using
* a clock domain different than the CPU, for instance the instrumentation of events * a clock domain different than the CPU, for instance the instrumentation of
* that occur on a GPU. * events that occur on a GPU. Because the set of domains is expected to be
* Because the set of domains is expected to be static over the application's execution time, * static over the application's execution time, there is no mechanism to
* there is no mechanism to destroy a domain. * destroy a domain. Any domain can be accessed by any thread in the process,
* Any domain can be accessed by any thread in the process, regardless of which thread created * regardless of which thread created the domain. This call is thread-safe.
* the domain. This call is thread-safe. * @param[in] fn A pointer to a callback function which retrieves alternative
* @param[in] fn A pointer to a callback function which retrieves alternative CPU timestamps * CPU timestamps
* @param[in] fn_data Argument for a callback function; may be NULL * @param[in] fn_data Argument for a callback function; may be NULL
*/ */
__itt_clock_domain* ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn, void* fn_data); __itt_clock_domain *ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn,
void *fn_data);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_clock_domain*, clock_domain_create, (__itt_get_clock_info_fn fn, void* fn_data)) ITT_STUB(ITTAPI, __itt_clock_domain *, clock_domain_create,
(__itt_get_clock_info_fn fn, void *fn_data))
#define __itt_clock_domain_create ITTNOTIFY_DATA(clock_domain_create) #define __itt_clock_domain_create ITTNOTIFY_DATA(clock_domain_create)
#define __itt_clock_domain_create_ptr ITTNOTIFY_NAME(clock_domain_create) #define __itt_clock_domain_create_ptr ITTNOTIFY_NAME(clock_domain_create)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_clock_domain_create(fn,fn_data) (__itt_clock_domain*)0 #define __itt_clock_domain_create(fn, fn_data) (__itt_clock_domain *)0
#define __itt_clock_domain_create_ptr 0 #define __itt_clock_domain_create_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_clock_domain_create_ptr 0 #define __itt_clock_domain_create_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup clockdomains * @ingroup clockdomains
* @brief Recalculate clock domains frequencies and clock base timestamps. * @brief Recalculate clock domains frequencies and clock base timestamps.
*/ */
void ITTAPI __itt_clock_domain_reset(void); void ITTAPI __itt_clock_domain_reset(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, clock_domain_reset, (void)) ITT_STUBV(ITTAPI, void, clock_domain_reset, (void))
#define __itt_clock_domain_reset ITTNOTIFY_VOID(clock_domain_reset) #define __itt_clock_domain_reset ITTNOTIFY_VOID(clock_domain_reset)
#define __itt_clock_domain_reset_ptr ITTNOTIFY_NAME(clock_domain_reset) #define __itt_clock_domain_reset_ptr ITTNOTIFY_NAME(clock_domain_reset)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_clock_domain_reset() #define __itt_clock_domain_reset()
#define __itt_clock_domain_reset_ptr 0 #define __itt_clock_domain_reset_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_clock_domain_reset_ptr 0 #define __itt_clock_domain_reset_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief Create an instance of identifier. This establishes the beginning of the lifetime of * @brief Create an instance of identifier. This establishes the beginning of
* an instance of the given ID in the trace. Once this lifetime starts, the ID can be used to * the lifetime of an instance of the given ID in the trace. Once this lifetime
* tag named entity instances in calls such as __itt_task_begin, and to specify relationships among * starts, the ID can be used to tag named entity instances in calls such as
* identified named entity instances, using the \ref relations APIs. * __itt_task_begin, and to specify relationships among identified named entity
* instances, using the \ref relations APIs.
* @param[in] domain The domain controlling the execution of this call. * @param[in] domain The domain controlling the execution of this call.
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] id The ID to create. * @param[in] id The ID to create.
*/ */
void ITTAPI __itt_id_create_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id); void ITTAPI __itt_id_create_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id);
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief Destroy an instance of identifier. This ends the lifetime of the current instance of the * @brief Destroy an instance of identifier. This ends the lifetime of the
* given ID value in the trace. Any relationships that are established after this lifetime ends are * current instance of the given ID value in the trace. Any relationships that
* invalid. This call must be performed before the given ID value can be reused for a different * are established after this lifetime ends are invalid. This call must be
* named entity instance. * performed before the given ID value can be reused for a different named
* entity instance.
* @param[in] domain The domain controlling the execution of this call. * @param[in] domain The domain controlling the execution of this call.
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] id The ID to destroy. * @param[in] id The ID to destroy.
*/ */
void ITTAPI __itt_id_destroy_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id); void ITTAPI __itt_id_destroy_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, id_create_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id)) ITT_STUBV(ITTAPI, void, id_create_ex,
ITT_STUBV(ITTAPI, void, id_destroy_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id)) (const __itt_domain *domain, __itt_clock_domain *clock_domain,
#define __itt_id_create_ex(d,x,y,z) ITTNOTIFY_VOID_D3(id_create_ex,d,x,y,z) unsigned long long timestamp, __itt_id id))
ITT_STUBV(ITTAPI, void, id_destroy_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id))
#define __itt_id_create_ex(d, x, y, z) \
ITTNOTIFY_VOID_D3(id_create_ex, d, x, y, z)
#define __itt_id_create_ex_ptr ITTNOTIFY_NAME(id_create_ex) #define __itt_id_create_ex_ptr ITTNOTIFY_NAME(id_create_ex)
#define __itt_id_destroy_ex(d,x,y,z) ITTNOTIFY_VOID_D3(id_destroy_ex,d,x,y,z) #define __itt_id_destroy_ex(d, x, y, z) \
ITTNOTIFY_VOID_D3(id_destroy_ex, d, x, y, z)
#define __itt_id_destroy_ex_ptr ITTNOTIFY_NAME(id_destroy_ex) #define __itt_id_destroy_ex_ptr ITTNOTIFY_NAME(id_destroy_ex)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_id_create_ex(domain,clock_domain,timestamp,id) #define __itt_id_create_ex(domain, clock_domain, timestamp, id)
#define __itt_id_create_ex_ptr 0 #define __itt_id_create_ex_ptr 0
#define __itt_id_destroy_ex(domain,clock_domain,timestamp,id) #define __itt_id_destroy_ex(domain, clock_domain, timestamp, id)
#define __itt_id_destroy_ex_ptr 0 #define __itt_id_destroy_ex_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_id_create_ex_ptr 0 #define __itt_id_create_ex_ptr 0
#define __itt_id_destroy_ex_ptr 0 #define __itt_id_destroy_ex_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief Begin a task instance. * @brief Begin a task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] taskid The instance ID for this task instance, or __itt_null * @param[in] taskid The instance ID for this task instance, or __itt_null
* @param[in] parentid The parent instance to which this task instance belongs, or __itt_null * @param[in] parentid The parent instance to which this task instance belongs,
* or __itt_null
* @param[in] name The name of this task * @param[in] name The name of this task
*/ */
void ITTAPI __itt_task_begin_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name); void ITTAPI __itt_task_begin_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id taskid,
__itt_id parentid, __itt_string_handle *name);
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief Begin a task instance. * @brief Begin a task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] taskid The identifier for this task instance, or __itt_null * @param[in] taskid The identifier for this task instance, or __itt_null
* @param[in] parentid The parent of this task, or __itt_null * @param[in] parentid The parent of this task, or __itt_null
* @param[in] fn The pointer to the function you are tracing * @param[in] fn The pointer to the function you are tracing
*/ */
void ITTAPI __itt_task_begin_fn_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, void* fn); void ITTAPI __itt_task_begin_fn_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp,
__itt_id taskid, __itt_id parentid,
void *fn);
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief End the current task instance. * @brief End the current task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
*/ */
void ITTAPI __itt_task_end_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp); void ITTAPI __itt_task_end_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, task_begin_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name)) ITT_STUBV(ITTAPI, void, task_begin_ex,
ITT_STUBV(ITTAPI, void, task_begin_fn_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, void* fn)) (const __itt_domain *domain, __itt_clock_domain *clock_domain,
ITT_STUBV(ITTAPI, void, task_end_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp)) unsigned long long timestamp, __itt_id id, __itt_id parentid,
#define __itt_task_begin_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(task_begin_ex,d,x,y,z,a,b) __itt_string_handle *name))
ITT_STUBV(ITTAPI, void, task_begin_fn_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id, __itt_id parentid,
void *fn))
ITT_STUBV(ITTAPI, void, task_end_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp))
#define __itt_task_begin_ex(d, x, y, z, a, b) \
ITTNOTIFY_VOID_D5(task_begin_ex, d, x, y, z, a, b)
#define __itt_task_begin_ex_ptr ITTNOTIFY_NAME(task_begin_ex) #define __itt_task_begin_ex_ptr ITTNOTIFY_NAME(task_begin_ex)
#define __itt_task_begin_fn_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(task_begin_fn_ex,d,x,y,z,a,b) #define __itt_task_begin_fn_ex(d, x, y, z, a, b) \
ITTNOTIFY_VOID_D5(task_begin_fn_ex, d, x, y, z, a, b)
#define __itt_task_begin_fn_ex_ptr ITTNOTIFY_NAME(task_begin_fn_ex) #define __itt_task_begin_fn_ex_ptr ITTNOTIFY_NAME(task_begin_fn_ex)
#define __itt_task_end_ex(d,x,y) ITTNOTIFY_VOID_D2(task_end_ex,d,x,y) #define __itt_task_end_ex(d, x, y) ITTNOTIFY_VOID_D2(task_end_ex, d, x, y)
#define __itt_task_end_ex_ptr ITTNOTIFY_NAME(task_end_ex) #define __itt_task_end_ex_ptr ITTNOTIFY_NAME(task_end_ex)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_task_begin_ex(domain,clock_domain,timestamp,id,parentid,name) #define __itt_task_begin_ex(domain, clock_domain, timestamp, id, parentid, name)
#define __itt_task_begin_ex_ptr 0 #define __itt_task_begin_ex_ptr 0
#define __itt_task_begin_fn_ex(domain,clock_domain,timestamp,id,parentid,fn) #define __itt_task_begin_fn_ex(domain, clock_domain, timestamp, id, parentid, \
fn)
#define __itt_task_begin_fn_ex_ptr 0 #define __itt_task_begin_fn_ex_ptr 0
#define __itt_task_end_ex(domain,clock_domain,timestamp) #define __itt_task_end_ex(domain, clock_domain, timestamp)
#define __itt_task_end_ex_ptr 0 #define __itt_task_end_ex_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_task_begin_ex_ptr 0 #define __itt_task_begin_ex_ptr 0
#define __itt_task_begin_fn_ex_ptr 0 #define __itt_task_begin_fn_ex_ptr 0
#define __itt_task_end_ex_ptr 0 #define __itt_task_end_ex_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @defgroup counters Counters * @defgroup counters Counters
* @ingroup public * @ingroup public
* Counters are user-defined objects with a monotonically increasing * Counters are user-defined objects with a monotonically increasing
* value. Counter values are 64-bit unsigned integers. * value. Counter values are 64-bit unsigned integers.
* Counters have names that can be displayed in * Counters have names that can be displayed in
* the tools. * the tools.
* @{ * @{
*/ */
/** /**
* @brief opaque structure for counter identification * @brief opaque structure for counter identification
*/ */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
typedef struct ___itt_counter* __itt_counter; typedef struct ___itt_counter *__itt_counter;
/** /**
* @brief Create an unsigned 64 bits integer counter with given name/domain * @brief Create an unsigned 64 bits integer counter with given name/domain
* *
* After __itt_counter_create() is called, __itt_counter_inc(id), __itt_counter_inc_delta(id, delta), * After __itt_counter_create() is called, __itt_counter_inc(id),
* __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr) * __itt_counter_inc_delta(id, delta),
* can be used to change the value of the counter, where value_ptr is a pointer to an unsigned 64 bits integer * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id,
* clock_domain, timestamp, value_ptr) can be used to change the value of the
* counter, where value_ptr is a pointer to an unsigned 64 bits integer
* *
* The call is equal to __itt_counter_create_typed(name, domain, __itt_metadata_u64) * The call is equal to __itt_counter_create_typed(name, domain,
* __itt_metadata_u64)
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_counter ITTAPI __itt_counter_createA(const char *name, const char *domain); __itt_counter ITTAPI __itt_counter_createA(const char *name,
__itt_counter ITTAPI __itt_counter_createW(const wchar_t *name, const wchar_t *domain); const char *domain);
__itt_counter ITTAPI __itt_counter_createW(const wchar_t *name,
const wchar_t *domain);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_counter_create __itt_counter_createW #define __itt_counter_create __itt_counter_createW
# define __itt_counter_create_ptr __itt_counter_createW_ptr #define __itt_counter_create_ptr __itt_counter_createW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_counter_create __itt_counter_createA #define __itt_counter_create __itt_counter_createA
# define __itt_counter_create_ptr __itt_counter_createA_ptr #define __itt_counter_create_ptr __itt_counter_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_counter ITTAPI __itt_counter_create(const char *name, const char *domain); __itt_counter ITTAPI __itt_counter_create(const char *name, const char *domain);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char *name, const char *domain)) ITT_STUB(ITTAPI, __itt_counter, counter_createA,
ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain)) (const char *name, const char *domain))
ITT_STUB(ITTAPI, __itt_counter, counter_createW,
(const wchar_t *name, const wchar_t *domain))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_counter, counter_create, (const char *name, const char *domain)) ITT_STUB(ITTAPI, __itt_counter, counter_create,
(const char *name, const char *domain))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_counter_createA ITTNOTIFY_DATA(counter_createA) #define __itt_counter_createA ITTNOTIFY_DATA(counter_createA)
#define __itt_counter_createA_ptr ITTNOTIFY_NAME(counter_createA) #define __itt_counter_createA_ptr ITTNOTIFY_NAME(counter_createA)
#define __itt_counter_createW ITTNOTIFY_DATA(counter_createW) #define __itt_counter_createW ITTNOTIFY_DATA(counter_createW)
#define __itt_counter_createW_ptr ITTNOTIFY_NAME(counter_createW) #define __itt_counter_createW_ptr ITTNOTIFY_NAME(counter_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_counter_create ITTNOTIFY_DATA(counter_create) #define __itt_counter_create ITTNOTIFY_DATA(counter_create)
#define __itt_counter_create_ptr ITTNOTIFY_NAME(counter_create) #define __itt_counter_create_ptr ITTNOTIFY_NAME(counter_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_counter_createA(name, domain) #define __itt_counter_createA(name, domain)
#define __itt_counter_createA_ptr 0 #define __itt_counter_createA_ptr 0
#define __itt_counter_createW(name, domain) #define __itt_counter_createW(name, domain)
#define __itt_counter_createW_ptr 0 #define __itt_counter_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_counter_create(name, domain) #define __itt_counter_create(name, domain)
#define __itt_counter_create_ptr 0 #define __itt_counter_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_counter_createA_ptr 0 #define __itt_counter_createA_ptr 0
#define __itt_counter_createW_ptr 0 #define __itt_counter_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_counter_create_ptr 0 #define __itt_counter_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Increment the unsigned 64 bits integer counter value * @brief Increment the unsigned 64 bits integer counter value
* *
* Calling this function to non-unsigned 64 bits integer counters has no effect * Calling this function to non-unsigned 64 bits integer counters has no effect
*/ */
void ITTAPI __itt_counter_inc(__itt_counter id); void ITTAPI __itt_counter_inc(__itt_counter id);
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id)) ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id))
#define __itt_counter_inc ITTNOTIFY_VOID(counter_inc) #define __itt_counter_inc ITTNOTIFY_VOID(counter_inc)
#define __itt_counter_inc_ptr ITTNOTIFY_NAME(counter_inc) #define __itt_counter_inc_ptr ITTNOTIFY_NAME(counter_inc)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_inc(id) #define __itt_counter_inc(id)
#define __itt_counter_inc_ptr 0 #define __itt_counter_inc_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_inc_ptr 0 #define __itt_counter_inc_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Increment the unsigned 64 bits integer counter value with x * @brief Increment the unsigned 64 bits integer counter value with x
* *
* Calling this function to non-unsigned 64 bits integer counters has no effect * Calling this function to non-unsigned 64 bits integer counters has no effect
*/ */
void ITTAPI __itt_counter_inc_delta(__itt_counter id, unsigned long long value); void ITTAPI __itt_counter_inc_delta(__itt_counter id, unsigned long long value);
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_inc_delta, (__itt_counter id, unsigned long long value)) ITT_STUBV(ITTAPI, void, counter_inc_delta,
(__itt_counter id, unsigned long long value))
#define __itt_counter_inc_delta ITTNOTIFY_VOID(counter_inc_delta) #define __itt_counter_inc_delta ITTNOTIFY_VOID(counter_inc_delta)
#define __itt_counter_inc_delta_ptr ITTNOTIFY_NAME(counter_inc_delta) #define __itt_counter_inc_delta_ptr ITTNOTIFY_NAME(counter_inc_delta)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_inc_delta(id, value) #define __itt_counter_inc_delta(id, value)
#define __itt_counter_inc_delta_ptr 0 #define __itt_counter_inc_delta_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_inc_delta_ptr 0 #define __itt_counter_inc_delta_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Decrement the unsigned 64 bits integer counter value * @brief Decrement the unsigned 64 bits integer counter value
* *
* Calling this function to non-unsigned 64 bits integer counters has no effect * Calling this function to non-unsigned 64 bits integer counters has no effect
*/ */
void ITTAPI __itt_counter_dec(__itt_counter id); void ITTAPI __itt_counter_dec(__itt_counter id);
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id)) ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id))
#define __itt_counter_dec ITTNOTIFY_VOID(counter_dec) #define __itt_counter_dec ITTNOTIFY_VOID(counter_dec)
#define __itt_counter_dec_ptr ITTNOTIFY_NAME(counter_dec) #define __itt_counter_dec_ptr ITTNOTIFY_NAME(counter_dec)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_dec(id) #define __itt_counter_dec(id)
#define __itt_counter_dec_ptr 0 #define __itt_counter_dec_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_dec_ptr 0 #define __itt_counter_dec_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Decrement the unsigned 64 bits integer counter value with x * @brief Decrement the unsigned 64 bits integer counter value with x
* *
* Calling this function to non-unsigned 64 bits integer counters has no effect * Calling this function to non-unsigned 64 bits integer counters has no effect
*/ */
void ITTAPI __itt_counter_dec_delta(__itt_counter id, unsigned long long value); void ITTAPI __itt_counter_dec_delta(__itt_counter id, unsigned long long value);
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_dec_delta, (__itt_counter id, unsigned long long value)) ITT_STUBV(ITTAPI, void, counter_dec_delta,
(__itt_counter id, unsigned long long value))
#define __itt_counter_dec_delta ITTNOTIFY_VOID(counter_dec_delta) #define __itt_counter_dec_delta ITTNOTIFY_VOID(counter_dec_delta)
#define __itt_counter_dec_delta_ptr ITTNOTIFY_NAME(counter_dec_delta) #define __itt_counter_dec_delta_ptr ITTNOTIFY_NAME(counter_dec_delta)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_dec_delta(id, value) #define __itt_counter_dec_delta(id, value)
#define __itt_counter_dec_delta_ptr 0 #define __itt_counter_dec_delta_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_dec_delta_ptr 0 #define __itt_counter_dec_delta_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup counters * @ingroup counters
* @brief Increment a counter by one. * @brief Increment a counter by one.
* The first call with a given name creates a counter by that name and sets its * The first call with a given name creates a counter by that name and sets its
* value to zero. Successive calls increment the counter value. * value to zero. Successive calls increment the counter value.
* @param[in] domain The domain controlling the call. Counter names are not domain specific. * @param[in] domain The domain controlling the call. Counter names are not
* The domain argument is used only to enable or disable the API calls. * domain specific. The domain argument is used only to enable or disable the
* API calls.
* @param[in] name The name of the counter * @param[in] name The name of the counter
*/ */
void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain, __itt_string_handle *name); void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain,
__itt_string_handle *name);
/** /**
* @ingroup counters * @ingroup counters
* @brief Increment a counter by the value specified in delta. * @brief Increment a counter by the value specified in delta.
* @param[in] domain The domain controlling the call. Counter names are not domain specific. * @param[in] domain The domain controlling the call. Counter names are not
* The domain argument is used only to enable or disable the API calls. * domain specific. The domain argument is used only to enable or disable the
* API calls.
* @param[in] name The name of the counter * @param[in] name The name of the counter
* @param[in] delta The amount by which to increment the counter * @param[in] delta The amount by which to increment the counter
*/ */
void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta); void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain,
__itt_string_handle *name,
unsigned long long delta);
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_inc_v3, (const __itt_domain *domain, __itt_string_handle *name)) ITT_STUBV(ITTAPI, void, counter_inc_v3,
ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta)) (const __itt_domain *domain, __itt_string_handle *name))
ITT_STUBV(ITTAPI, void, counter_inc_delta_v3,
(const __itt_domain *domain, __itt_string_handle *name,
unsigned long long delta))
#define __itt_counter_inc_v3(d,x) ITTNOTIFY_VOID_D1(counter_inc_v3,d,x) #define __itt_counter_inc_v3(d, x) ITTNOTIFY_VOID_D1(counter_inc_v3, d, x)
#define __itt_counter_inc_v3_ptr ITTNOTIFY_NAME(counter_inc_v3) #define __itt_counter_inc_v3_ptr ITTNOTIFY_NAME(counter_inc_v3)
#define __itt_counter_inc_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_inc_delta_v3,d,x,y) #define __itt_counter_inc_delta_v3(d, x, y) \
ITTNOTIFY_VOID_D2(counter_inc_delta_v3, d, x, y)
#define __itt_counter_inc_delta_v3_ptr ITTNOTIFY_NAME(counter_inc_delta_v3) #define __itt_counter_inc_delta_v3_ptr ITTNOTIFY_NAME(counter_inc_delta_v3)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_inc_v3(domain,name) #define __itt_counter_inc_v3(domain, name)
#define __itt_counter_inc_v3_ptr 0 #define __itt_counter_inc_v3_ptr 0
#define __itt_counter_inc_delta_v3(domain,name,delta) #define __itt_counter_inc_delta_v3(domain, name, delta)
#define __itt_counter_inc_delta_v3_ptr 0 #define __itt_counter_inc_delta_v3_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_inc_v3_ptr 0 #define __itt_counter_inc_v3_ptr 0
#define __itt_counter_inc_delta_v3_ptr 0 #define __itt_counter_inc_delta_v3_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup counters * @ingroup counters
* @brief Decrement a counter by one. * @brief Decrement a counter by one.
* The first call with a given name creates a counter by that name and sets its * The first call with a given name creates a counter by that name and sets its
* value to zero. Successive calls decrement the counter value. * value to zero. Successive calls decrement the counter value.
* @param[in] domain The domain controlling the call. Counter names are not domain specific. * @param[in] domain The domain controlling the call. Counter names are not
* The domain argument is used only to enable or disable the API calls. * domain specific. The domain argument is used only to enable or disable the
* API calls.
* @param[in] name The name of the counter * @param[in] name The name of the counter
*/ */
void ITTAPI __itt_counter_dec_v3(const __itt_domain *domain, __itt_string_handle *name); void ITTAPI __itt_counter_dec_v3(const __itt_domain *domain,
__itt_string_handle *name);
/** /**
* @ingroup counters * @ingroup counters
* @brief Decrement a counter by the value specified in delta. * @brief Decrement a counter by the value specified in delta.
* @param[in] domain The domain controlling the call. Counter names are not domain specific. * @param[in] domain The domain controlling the call. Counter names are not
* The domain argument is used only to enable or disable the API calls. * domain specific. The domain argument is used only to enable or disable the
* API calls.
* @param[in] name The name of the counter * @param[in] name The name of the counter
* @param[in] delta The amount by which to decrement the counter * @param[in] delta The amount by which to decrement the counter
*/ */
void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta); void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain *domain,
__itt_string_handle *name,
unsigned long long delta);
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_dec_v3, (const __itt_domain *domain, __itt_string_handle *name)) ITT_STUBV(ITTAPI, void, counter_dec_v3,
ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta)) (const __itt_domain *domain, __itt_string_handle *name))
ITT_STUBV(ITTAPI, void, counter_dec_delta_v3,
(const __itt_domain *domain, __itt_string_handle *name,
unsigned long long delta))
#define __itt_counter_dec_v3(d,x) ITTNOTIFY_VOID_D1(counter_dec_v3,d,x) #define __itt_counter_dec_v3(d, x) ITTNOTIFY_VOID_D1(counter_dec_v3, d, x)
#define __itt_counter_dec_v3_ptr ITTNOTIFY_NAME(counter_dec_v3) #define __itt_counter_dec_v3_ptr ITTNOTIFY_NAME(counter_dec_v3)
#define __itt_counter_dec_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_dec_delta_v3,d,x,y) #define __itt_counter_dec_delta_v3(d, x, y) \
ITTNOTIFY_VOID_D2(counter_dec_delta_v3, d, x, y)
#define __itt_counter_dec_delta_v3_ptr ITTNOTIFY_NAME(counter_dec_delta_v3) #define __itt_counter_dec_delta_v3_ptr ITTNOTIFY_NAME(counter_dec_delta_v3)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_dec_v3(domain,name) #define __itt_counter_dec_v3(domain, name)
#define __itt_counter_dec_v3_ptr 0 #define __itt_counter_dec_v3_ptr 0
#define __itt_counter_dec_delta_v3(domain,name,delta) #define __itt_counter_dec_delta_v3(domain, name, delta)
#define __itt_counter_dec_delta_v3_ptr 0 #define __itt_counter_dec_delta_v3_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_dec_v3_ptr 0 #define __itt_counter_dec_v3_ptr 0
#define __itt_counter_dec_delta_v3_ptr 0 #define __itt_counter_dec_delta_v3_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} counters group */ /** @} counters group */
/** /**
* @brief Set the counter value * @brief Set the counter value
*/ */
void ITTAPI __itt_counter_set_value(__itt_counter id, void *value_ptr); void ITTAPI __itt_counter_set_value(__itt_counter id, void *value_ptr);
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr)) ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr))
#define __itt_counter_set_value ITTNOTIFY_VOID(counter_set_value) #define __itt_counter_set_value ITTNOTIFY_VOID(counter_set_value)
#define __itt_counter_set_value_ptr ITTNOTIFY_NAME(counter_set_value) #define __itt_counter_set_value_ptr ITTNOTIFY_NAME(counter_set_value)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_set_value(id, value_ptr) #define __itt_counter_set_value(id, value_ptr)
#define __itt_counter_set_value_ptr 0 #define __itt_counter_set_value_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_set_value_ptr 0 #define __itt_counter_set_value_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Set the counter value * @brief Set the counter value
*/ */
void ITTAPI __itt_counter_set_value_ex(__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr); void ITTAPI __itt_counter_set_value_ex(__itt_counter id,
__itt_clock_domain *clock_domain,
unsigned long long timestamp,
void *value_ptr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr)) ITT_STUBV(ITTAPI, void, counter_set_value_ex,
(__itt_counter id, __itt_clock_domain *clock_domain,
unsigned long long timestamp, void *value_ptr))
#define __itt_counter_set_value_ex ITTNOTIFY_VOID(counter_set_value_ex) #define __itt_counter_set_value_ex ITTNOTIFY_VOID(counter_set_value_ex)
#define __itt_counter_set_value_ex_ptr ITTNOTIFY_NAME(counter_set_value_ex) #define __itt_counter_set_value_ex_ptr ITTNOTIFY_NAME(counter_set_value_ex)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr) #define __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
#define __itt_counter_set_value_ex_ptr 0 #define __itt_counter_set_value_ex_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_set_value_ex_ptr 0 #define __itt_counter_set_value_ex_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Create a typed counter with given name/domain * @brief Create a typed counter with given name/domain
* *
* After __itt_counter_create_typed() is called, __itt_counter_inc(id), __itt_counter_inc_delta(id, delta), * After __itt_counter_create_typed() is called, __itt_counter_inc(id),
* __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr) * __itt_counter_inc_delta(id, delta),
* can be used to change the value of the counter * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id,
* clock_domain, timestamp, value_ptr) can be used to change the value of the
* counter
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_counter ITTAPI __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type); __itt_counter ITTAPI __itt_counter_create_typedA(const char *name,
__itt_counter ITTAPI __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type); const char *domain,
__itt_metadata_type type);
__itt_counter ITTAPI __itt_counter_create_typedW(const wchar_t *name,
const wchar_t *domain,
__itt_metadata_type type);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_counter_create_typed __itt_counter_create_typedW #define __itt_counter_create_typed __itt_counter_create_typedW
# define __itt_counter_create_typed_ptr __itt_counter_create_typedW_ptr #define __itt_counter_create_typed_ptr __itt_counter_create_typedW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_counter_create_typed __itt_counter_create_typedA #define __itt_counter_create_typed __itt_counter_create_typedA
# define __itt_counter_create_typed_ptr __itt_counter_create_typedA_ptr #define __itt_counter_create_typed_ptr __itt_counter_create_typedA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_counter ITTAPI __itt_counter_create_typed(const char *name, const char *domain, __itt_metadata_type type); __itt_counter ITTAPI __itt_counter_create_typed(const char *name,
const char *domain,
__itt_metadata_type type);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char *name, const char *domain, __itt_metadata_type type)) ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA,
ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)) (const char *name, const char *domain, __itt_metadata_type type))
ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW,
(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_counter, counter_create_typed, (const char *name, const char *domain, __itt_metadata_type type)) ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,
(const char *name, const char *domain, __itt_metadata_type type))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_counter_create_typedA ITTNOTIFY_DATA(counter_create_typedA) #define __itt_counter_create_typedA ITTNOTIFY_DATA(counter_create_typedA)
#define __itt_counter_create_typedA_ptr ITTNOTIFY_NAME(counter_create_typedA) #define __itt_counter_create_typedA_ptr ITTNOTIFY_NAME(counter_create_typedA)
#define __itt_counter_create_typedW ITTNOTIFY_DATA(counter_create_typedW) #define __itt_counter_create_typedW ITTNOTIFY_DATA(counter_create_typedW)
#define __itt_counter_create_typedW_ptr ITTNOTIFY_NAME(counter_create_typedW) #define __itt_counter_create_typedW_ptr ITTNOTIFY_NAME(counter_create_typedW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_counter_create_typed ITTNOTIFY_DATA(counter_create_typed) #define __itt_counter_create_typed ITTNOTIFY_DATA(counter_create_typed)
#define __itt_counter_create_typed_ptr ITTNOTIFY_NAME(counter_create_typed) #define __itt_counter_create_typed_ptr ITTNOTIFY_NAME(counter_create_typed)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_counter_create_typedA(name, domain, type) #define __itt_counter_create_typedA(name, domain, type)
#define __itt_counter_create_typedA_ptr 0 #define __itt_counter_create_typedA_ptr 0
#define __itt_counter_create_typedW(name, domain, type) #define __itt_counter_create_typedW(name, domain, type)
#define __itt_counter_create_typedW_ptr 0 #define __itt_counter_create_typedW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_counter_create_typed(name, domain, type) #define __itt_counter_create_typed(name, domain, type)
#define __itt_counter_create_typed_ptr 0 #define __itt_counter_create_typed_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_counter_create_typedA_ptr 0 #define __itt_counter_create_typedA_ptr 0
#define __itt_counter_create_typedW_ptr 0 #define __itt_counter_create_typedW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_counter_create_typed_ptr 0 #define __itt_counter_create_typed_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Destroy the counter identified by the pointer previously returned by __itt_counter_create() or * @brief Destroy the counter identified by the pointer previously returned by
* __itt_counter_create() or
* __itt_counter_create_typed() * __itt_counter_create_typed()
*/ */
void ITTAPI __itt_counter_destroy(__itt_counter id); void ITTAPI __itt_counter_destroy(__itt_counter id);
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id)) ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id))
#define __itt_counter_destroy ITTNOTIFY_VOID(counter_destroy) #define __itt_counter_destroy ITTNOTIFY_VOID(counter_destroy)
#define __itt_counter_destroy_ptr ITTNOTIFY_NAME(counter_destroy) #define __itt_counter_destroy_ptr ITTNOTIFY_NAME(counter_destroy)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_counter_destroy(id) #define __itt_counter_destroy(id)
#define __itt_counter_destroy_ptr 0 #define __itt_counter_destroy_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_counter_destroy_ptr 0 #define __itt_counter_destroy_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} counters group */ /** @} counters group */
/** /**
* @ingroup markers * @ingroup markers
* @brief Create a marker instance. * @brief Create a marker instance.
* @param[in] domain The domain for this marker * @param[in] domain The domain for this marker
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] id The instance ID for this marker, or __itt_null * @param[in] id The instance ID for this marker, or __itt_null
* @param[in] name The name for this marker * @param[in] name The name for this marker
* @param[in] scope The scope for this marker * @param[in] scope The scope for this marker
*/ */
void ITTAPI __itt_marker_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope); void ITTAPI __itt_marker_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id,
__itt_string_handle *name, __itt_scope scope);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, marker_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope)) ITT_STUBV(ITTAPI, void, marker_ex,
#define __itt_marker_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(marker_ex,d,x,y,z,a,b) (const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id, __itt_string_handle *name,
__itt_scope scope))
#define __itt_marker_ex(d, x, y, z, a, b) \
ITTNOTIFY_VOID_D5(marker_ex, d, x, y, z, a, b)
#define __itt_marker_ex_ptr ITTNOTIFY_NAME(marker_ex) #define __itt_marker_ex_ptr ITTNOTIFY_NAME(marker_ex)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_marker_ex(domain,clock_domain,timestamp,id,name,scope) #define __itt_marker_ex(domain, clock_domain, timestamp, id, name, scope)
#define __itt_marker_ex_ptr 0 #define __itt_marker_ex_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_marker_ex_ptr 0 #define __itt_marker_ex_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief Add a relation to the current task instance. * @brief Add a relation to the current task instance.
* The current task instance is the head of the relation. * The current task instance is the head of the relation.
* @param[in] domain The domain controlling this call * @param[in] domain The domain controlling this call
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] relation The kind of relation * @param[in] relation The kind of relation
* @param[in] tail The ID for the tail of the relation * @param[in] tail The ID for the tail of the relation
*/ */
void ITTAPI __itt_relation_add_to_current_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail); void ITTAPI __itt_relation_add_to_current_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp,
__itt_relation relation,
__itt_id tail);
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief Add a relation between two instance identifiers. * @brief Add a relation between two instance identifiers.
* @param[in] domain The domain controlling this call * @param[in] domain The domain controlling this call
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] head The ID for the head of the relation * @param[in] head The ID for the head of the relation
* @param[in] relation The kind of relation * @param[in] relation The kind of relation
* @param[in] tail The ID for the tail of the relation * @param[in] tail The ID for the tail of the relation
*/ */
void ITTAPI __itt_relation_add_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail); void ITTAPI __itt_relation_add_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id head,
__itt_relation relation, __itt_id tail);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, relation_add_to_current_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail)) ITT_STUBV(ITTAPI, void, relation_add_to_current_ex,
ITT_STUBV(ITTAPI, void, relation_add_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail)) (const __itt_domain *domain, __itt_clock_domain *clock_domain,
#define __itt_relation_add_to_current_ex(d,x,y,z,a) ITTNOTIFY_VOID_D4(relation_add_to_current_ex,d,x,y,z,a) unsigned long long timestamp, __itt_relation relation,
#define __itt_relation_add_to_current_ex_ptr ITTNOTIFY_NAME(relation_add_to_current_ex) __itt_id tail))
#define __itt_relation_add_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(relation_add_ex,d,x,y,z,a,b) ITT_STUBV(ITTAPI, void, relation_add_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id head, __itt_relation relation,
__itt_id tail))
#define __itt_relation_add_to_current_ex(d, x, y, z, a) \
ITTNOTIFY_VOID_D4(relation_add_to_current_ex, d, x, y, z, a)
#define __itt_relation_add_to_current_ex_ptr \
ITTNOTIFY_NAME(relation_add_to_current_ex)
#define __itt_relation_add_ex(d, x, y, z, a, b) \
ITTNOTIFY_VOID_D5(relation_add_ex, d, x, y, z, a, b)
#define __itt_relation_add_ex_ptr ITTNOTIFY_NAME(relation_add_ex) #define __itt_relation_add_ex_ptr ITTNOTIFY_NAME(relation_add_ex)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_relation_add_to_current_ex(domain,clock_domain,timestamp,relation,tail) #define __itt_relation_add_to_current_ex(domain, clock_domain, timestamp, \
relation, tail)
#define __itt_relation_add_to_current_ex_ptr 0 #define __itt_relation_add_to_current_ex_ptr 0
#define __itt_relation_add_ex(domain,clock_domain,timestamp,head,relation,tail) #define __itt_relation_add_ex(domain, clock_domain, timestamp, head, relation, \
tail)
#define __itt_relation_add_ex_ptr 0 #define __itt_relation_add_ex_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_relation_add_to_current_ex_ptr 0 #define __itt_relation_add_to_current_ex_ptr 0
#define __itt_relation_add_ex_ptr 0 #define __itt_relation_add_ex_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
typedef enum ___itt_track_group_type typedef enum ___itt_track_group_type {
{
__itt_track_group_type_normal = 0 __itt_track_group_type_normal = 0
} __itt_track_group_type; } __itt_track_group_type;
/** @endcond */ /** @endcond */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_track_group typedef struct ___itt_track_group {
{
__itt_string_handle* name; /*!< Name of the track group */ __itt_string_handle *name; /*!< Name of the track group */
struct ___itt_track* track; /*!< List of child tracks */ struct ___itt_track *track; /*!< List of child tracks */
__itt_track_group_type tgtype; /*!< Type of the track group */ __itt_track_group_type tgtype; /*!< Type of the track group */
int extra1; /*!< Reserved. Must be zero */ int extra1; /*!< Reserved. Must be zero */
void* extra2; /*!< Reserved. Must be zero */ void *extra2; /*!< Reserved. Must be zero */
struct ___itt_track_group* next; struct ___itt_track_group *next;
} __itt_track_group; } __itt_track_group;
#pragma pack(pop) #pragma pack(pop)
/** @endcond */ /** @endcond */
/** /**
* @brief Placeholder for custom track types. Currently, "normal" custom track * @brief Placeholder for custom track types. Currently, "normal" custom track
* is the only available track type. * is the only available track type.
*/ */
typedef enum ___itt_track_type typedef enum ___itt_track_type {
{
__itt_track_type_normal = 0 __itt_track_type_normal = 0
#ifdef INTEL_ITTNOTIFY_API_PRIVATE #ifdef INTEL_ITTNOTIFY_API_PRIVATE
, __itt_track_type_queue ,
__itt_track_type_queue
#endif /* INTEL_ITTNOTIFY_API_PRIVATE */ #endif /* INTEL_ITTNOTIFY_API_PRIVATE */
} __itt_track_type; } __itt_track_type;
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_track typedef struct ___itt_track {
{
__itt_string_handle* name; /*!< Name of the track group */ __itt_string_handle *name; /*!< Name of the track group */
__itt_track_group* group; /*!< Parent group to a track */ __itt_track_group *group; /*!< Parent group to a track */
__itt_track_type ttype; /*!< Type of the track */ __itt_track_type ttype; /*!< Type of the track */
int extra1; /*!< Reserved. Must be zero */ int extra1; /*!< Reserved. Must be zero */
void* extra2; /*!< Reserved. Must be zero */ void *extra2; /*!< Reserved. Must be zero */
struct ___itt_track* next; struct ___itt_track *next;
} __itt_track; } __itt_track;
#pragma pack(pop) #pragma pack(pop)
/** @endcond */ /** @endcond */
/** /**
* @brief Create logical track group. * @brief Create logical track group.
*/ */
__itt_track_group* ITTAPI __itt_track_group_create(__itt_string_handle* name, __itt_track_group_type track_group_type); __itt_track_group *ITTAPI __itt_track_group_create(
__itt_string_handle *name, __itt_track_group_type track_group_type);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_track_group*, track_group_create, (__itt_string_handle* name, __itt_track_group_type track_group_type)) ITT_STUB(ITTAPI, __itt_track_group *, track_group_create,
(__itt_string_handle * name, __itt_track_group_type track_group_type))
#define __itt_track_group_create ITTNOTIFY_DATA(track_group_create) #define __itt_track_group_create ITTNOTIFY_DATA(track_group_create)
#define __itt_track_group_create_ptr ITTNOTIFY_NAME(track_group_create) #define __itt_track_group_create_ptr ITTNOTIFY_NAME(track_group_create)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_track_group_create(name) (__itt_track_group*)0 #define __itt_track_group_create(name) (__itt_track_group *)0
#define __itt_track_group_create_ptr 0 #define __itt_track_group_create_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_track_group_create_ptr 0 #define __itt_track_group_create_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Create logical track. * @brief Create logical track.
*/ */
__itt_track* ITTAPI __itt_track_create(__itt_track_group* track_group, __itt_string_handle* name, __itt_track_type track_type); __itt_track *ITTAPI __itt_track_create(__itt_track_group *track_group,
__itt_string_handle *name,
__itt_track_type track_type);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_track*, track_create, (__itt_track_group* track_group,__itt_string_handle* name, __itt_track_type track_type)) ITT_STUB(ITTAPI, __itt_track *, track_create,
(__itt_track_group * track_group, __itt_string_handle *name,
__itt_track_type track_type))
#define __itt_track_create ITTNOTIFY_DATA(track_create) #define __itt_track_create ITTNOTIFY_DATA(track_create)
#define __itt_track_create_ptr ITTNOTIFY_NAME(track_create) #define __itt_track_create_ptr ITTNOTIFY_NAME(track_create)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_track_create(track_group,name,track_type) (__itt_track*)0 #define __itt_track_create(track_group, name, track_type) (__itt_track *)0
#define __itt_track_create_ptr 0 #define __itt_track_create_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_track_create_ptr 0 #define __itt_track_create_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Set the logical track. * @brief Set the logical track.
*/ */
void ITTAPI __itt_set_track(__itt_track* track); void ITTAPI __itt_set_track(__itt_track *track);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, set_track, (__itt_track *track)) ITT_STUBV(ITTAPI, void, set_track, (__itt_track * track))
#define __itt_set_track ITTNOTIFY_VOID(set_track) #define __itt_set_track ITTNOTIFY_VOID(set_track)
#define __itt_set_track_ptr ITTNOTIFY_NAME(set_track) #define __itt_set_track_ptr ITTNOTIFY_NAME(set_track)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_set_track(track) #define __itt_set_track(track)
#define __itt_set_track_ptr 0 #define __itt_set_track_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_set_track_ptr 0 #define __itt_set_track_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/* ========================================================================== */ /* ========================================================================== */
/** @cond exclude_from_gpa_documentation */ /** @cond exclude_from_gpa_documentation */
/** /**
* @defgroup events Events * @defgroup events Events
* @ingroup public * @ingroup public
* Events group * Events group
* @{ * @{
*/ */
/** @brief user event type */ /** @brief user event type */
typedef int __itt_event; typedef int __itt_event;
/** /**
* @brief Create an event notification * @brief Create an event notification
* @note name or namelen being null/name and namelen not matching, user event feature not enabled * @note name or namelen being null/name and namelen not matching, user event
* feature not enabled
* @return non-zero event identifier upon success and __itt_err otherwise * @return non-zero event identifier upon success and __itt_err otherwise
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen); __itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen);
__itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen); __itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_event_create __itt_event_createW #define __itt_event_create __itt_event_createW
# define __itt_event_create_ptr __itt_event_createW_ptr #define __itt_event_create_ptr __itt_event_createW_ptr
#else #else
# define __itt_event_create __itt_event_createA #define __itt_event_create __itt_event_createA
# define __itt_event_create_ptr __itt_event_createA_ptr #define __itt_event_create_ptr __itt_event_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_event LIBITTAPI __itt_event_create(const char *name, int namelen); __itt_event LIBITTAPI __itt_event_create(const char *name, int namelen);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen)) ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen))
ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen)) ITT_STUB(LIBITTAPI, __itt_event, event_createW,
(const wchar_t *name, int namelen))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen)) ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_event_createA ITTNOTIFY_DATA(event_createA) #define __itt_event_createA ITTNOTIFY_DATA(event_createA)
#define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA) #define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA)
#define __itt_event_createW ITTNOTIFY_DATA(event_createW) #define __itt_event_createW ITTNOTIFY_DATA(event_createW)
#define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW) #define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create ITTNOTIFY_DATA(event_create) #define __itt_event_create ITTNOTIFY_DATA(event_create)
#define __itt_event_create_ptr ITTNOTIFY_NAME(event_create) #define __itt_event_create_ptr ITTNOTIFY_NAME(event_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_event_createA(name, namelen) (__itt_event)0 #define __itt_event_createA(name, namelen) (__itt_event)0
#define __itt_event_createA_ptr 0 #define __itt_event_createA_ptr 0
#define __itt_event_createW(name, namelen) (__itt_event)0 #define __itt_event_createW(name, namelen) (__itt_event)0
#define __itt_event_createW_ptr 0 #define __itt_event_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create(name, namelen) (__itt_event)0 #define __itt_event_create(name, namelen) (__itt_event)0
#define __itt_event_create_ptr 0 #define __itt_event_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_event_createA_ptr 0 #define __itt_event_createA_ptr 0
#define __itt_event_createW_ptr 0 #define __itt_event_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create_ptr 0 #define __itt_event_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record an event occurrence. * @brief Record an event occurrence.
* @return __itt_err upon failure (invalid event id/user event feature not enabled) * @return __itt_err upon failure (invalid event id/user event feature not
* enabled)
*/ */
int LIBITTAPI __itt_event_start(__itt_event event); int LIBITTAPI __itt_event_start(__itt_event event);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event)) ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event))
#define __itt_event_start ITTNOTIFY_DATA(event_start) #define __itt_event_start ITTNOTIFY_DATA(event_start)
#define __itt_event_start_ptr ITTNOTIFY_NAME(event_start) #define __itt_event_start_ptr ITTNOTIFY_NAME(event_start)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_event_start(event) (int)0 #define __itt_event_start(event) (int)0
#define __itt_event_start_ptr 0 #define __itt_event_start_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_event_start_ptr 0 #define __itt_event_start_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record an event end occurrence. * @brief Record an event end occurrence.
* @note It is optional if events do not have durations. * @note It is optional if events do not have durations.
* @return __itt_err upon failure (invalid event id/user event feature not enabled) * @return __itt_err upon failure (invalid event id/user event feature not
* enabled)
*/ */
int LIBITTAPI __itt_event_end(__itt_event event); int LIBITTAPI __itt_event_end(__itt_event event);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event)) ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event))
#define __itt_event_end ITTNOTIFY_DATA(event_end) #define __itt_event_end ITTNOTIFY_DATA(event_end)
#define __itt_event_end_ptr ITTNOTIFY_NAME(event_end) #define __itt_event_end_ptr ITTNOTIFY_NAME(event_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_event_end(event) (int)0 #define __itt_event_end(event) (int)0
#define __itt_event_end_ptr 0 #define __itt_event_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_event_end_ptr 0 #define __itt_event_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} events group */ /** @} events group */
/** /**
* @defgroup arrays Arrays Visualizer * @defgroup arrays Arrays Visualizer
* @ingroup public * @ingroup public
* Visualize arrays * Visualize arrays
* @{ * @{
*/ */
/** /**
* @enum __itt_av_data_type * @enum __itt_av_data_type
* @brief Defines types of arrays data (for C/C++ intrinsic types) * @brief Defines types of arrays data (for C/C++ intrinsic types)
*/ */
typedef enum typedef enum {
{
__itt_e_first = 0, __itt_e_first = 0,
__itt_e_char = 0, /* 1-byte integer */ __itt_e_char = 0, /* 1-byte integer */
__itt_e_uchar, /* 1-byte unsigned integer */ __itt_e_uchar, /* 1-byte unsigned integer */
__itt_e_int16, /* 2-byte integer */ __itt_e_int16, /* 2-byte integer */
__itt_e_uint16, /* 2-byte unsigned integer */ __itt_e_uint16, /* 2-byte unsigned integer */
__itt_e_int32, /* 4-byte integer */ __itt_e_int32, /* 4-byte integer */
__itt_e_uint32, /* 4-byte unsigned integer */ __itt_e_uint32, /* 4-byte unsigned integer */
__itt_e_int64, /* 8-byte integer */ __itt_e_int64, /* 8-byte integer */
__itt_e_uint64, /* 8-byte unsigned integer */ __itt_e_uint64, /* 8-byte unsigned integer */
__itt_e_float, /* 4-byte floating */ __itt_e_float, /* 4-byte floating */
__itt_e_double, /* 8-byte floating */ __itt_e_double, /* 8-byte floating */
__itt_e_last = __itt_e_double __itt_e_last = __itt_e_double
} __itt_av_data_type; } __itt_av_data_type;
/** /**
* @brief Save an array data to a file. * @brief Save an array data to a file.
* Output format is defined by the file extension. The csv and bmp formats are supported (bmp - for 2-dimensional array only). * Output format is defined by the file extension. The csv and bmp formats are
* supported (bmp - for 2-dimensional array only).
* @param[in] data - pointer to the array data * @param[in] data - pointer to the array data
* @param[in] rank - the rank of the array * @param[in] rank - the rank of the array
* @param[in] dimensions - pointer to an array of integers, which specifies the array dimensions. * @param[in] dimensions - pointer to an array of integers, which specifies the
* The size of dimensions must be equal to the rank * array dimensions. The size of dimensions must be equal to the rank
* @param[in] type - the type of the array, specified as one of the __itt_av_data_type values (for intrinsic types) * @param[in] type - the type of the array, specified as one of the
* @param[in] filePath - the file path; the output format is defined by the file extension * __itt_av_data_type values (for intrinsic types)
* @param[in] columnOrder - defines how the array is stored in the linear memory. * @param[in] filePath - the file path; the output format is defined by the file
* It should be 1 for column-major order (e.g. in FORTRAN) or 0 - for row-major order (e.g. in C). * extension
* @param[in] columnOrder - defines how the array is stored in the linear
* memory. It should be 1 for column-major order (e.g. in FORTRAN) or 0 - for
* row-major order (e.g. in C).
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
int ITTAPI __itt_av_saveA(void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder); int ITTAPI __itt_av_saveA(void *data, int rank, const int *dimensions, int type,
int ITTAPI __itt_av_saveW(void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder); const char *filePath, int columnOrder);
int ITTAPI __itt_av_saveW(void *data, int rank, const int *dimensions, int type,
const wchar_t *filePath, int columnOrder);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_av_save __itt_av_saveW #define __itt_av_save __itt_av_saveW
# define __itt_av_save_ptr __itt_av_saveW_ptr #define __itt_av_save_ptr __itt_av_saveW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_av_save __itt_av_saveA #define __itt_av_save __itt_av_saveA
# define __itt_av_save_ptr __itt_av_saveA_ptr #define __itt_av_save_ptr __itt_av_saveA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
int ITTAPI __itt_av_save(void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder); int ITTAPI __itt_av_save(void *data, int rank, const int *dimensions, int type,
const char *filePath, int columnOrder);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, av_saveA, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder)) ITT_STUB(ITTAPI, int, av_saveA,
ITT_STUB(ITTAPI, int, av_saveW, (void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder)) (void *data, int rank, const int *dimensions, int type,
const char *filePath, int columnOrder))
ITT_STUB(ITTAPI, int, av_saveW,
(void *data, int rank, const int *dimensions, int type,
const wchar_t *filePath, int columnOrder))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, av_save, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder)) ITT_STUB(ITTAPI, int, av_save,
(void *data, int rank, const int *dimensions, int type,
const char *filePath, int columnOrder))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_av_saveA ITTNOTIFY_DATA(av_saveA) #define __itt_av_saveA ITTNOTIFY_DATA(av_saveA)
#define __itt_av_saveA_ptr ITTNOTIFY_NAME(av_saveA) #define __itt_av_saveA_ptr ITTNOTIFY_NAME(av_saveA)
#define __itt_av_saveW ITTNOTIFY_DATA(av_saveW) #define __itt_av_saveW ITTNOTIFY_DATA(av_saveW)
#define __itt_av_saveW_ptr ITTNOTIFY_NAME(av_saveW) #define __itt_av_saveW_ptr ITTNOTIFY_NAME(av_saveW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_av_save ITTNOTIFY_DATA(av_save) #define __itt_av_save ITTNOTIFY_DATA(av_save)
#define __itt_av_save_ptr ITTNOTIFY_NAME(av_save) #define __itt_av_save_ptr ITTNOTIFY_NAME(av_save)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_av_saveA(name) #define __itt_av_saveA(name)
#define __itt_av_saveA_ptr 0 #define __itt_av_saveA_ptr 0
#define __itt_av_saveW(name) #define __itt_av_saveW(name)
#define __itt_av_saveW_ptr 0 #define __itt_av_saveW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_av_save(name) #define __itt_av_save(name)
#define __itt_av_save_ptr 0 #define __itt_av_save_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_av_saveA_ptr 0 #define __itt_av_saveA_ptr 0
#define __itt_av_saveW_ptr 0 #define __itt_av_saveW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_av_save_ptr 0 #define __itt_av_save_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
void ITTAPI __itt_enable_attach(void); void ITTAPI __itt_enable_attach(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, enable_attach, (void)) ITT_STUBV(ITTAPI, void, enable_attach, (void))
#define __itt_enable_attach ITTNOTIFY_VOID(enable_attach) #define __itt_enable_attach ITTNOTIFY_VOID(enable_attach)
#define __itt_enable_attach_ptr ITTNOTIFY_NAME(enable_attach) #define __itt_enable_attach_ptr ITTNOTIFY_NAME(enable_attach)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_enable_attach() #define __itt_enable_attach()
#define __itt_enable_attach_ptr 0 #define __itt_enable_attach_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_enable_attach_ptr 0 #define __itt_enable_attach_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @cond exclude_from_gpa_documentation */ /** @cond exclude_from_gpa_documentation */
/** @} arrays group */ /** @} arrays group */
/** @endcond */ /** @endcond */
/** /**
* @brief Module load info * @brief Module load info
* This API is used to report necessary information in case of module relocation * This API is used to report necessary information in case of module relocation
* @param[in] start_addr - relocated module start address * @param[in] start_addr - relocated module start address
* @param[in] end_addr - relocated module end address * @param[in] end_addr - relocated module end address
* @param[in] path - file system path to the module * @param[in] path - file system path to the module
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_module_loadA(void *start_addr, void *end_addr, const char *path); void ITTAPI __itt_module_loadA(void *start_addr, void *end_addr,
void ITTAPI __itt_module_loadW(void *start_addr, void *end_addr, const wchar_t *path); const char *path);
void ITTAPI __itt_module_loadW(void *start_addr, void *end_addr,
const wchar_t *path);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_module_load __itt_module_loadW #define __itt_module_load __itt_module_loadW
# define __itt_module_load_ptr __itt_module_loadW_ptr #define __itt_module_load_ptr __itt_module_loadW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_module_load __itt_module_loadA #define __itt_module_load __itt_module_loadA
# define __itt_module_load_ptr __itt_module_loadA_ptr #define __itt_module_load_ptr __itt_module_loadA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
void ITTAPI __itt_module_load(void *start_addr, void *end_addr, const char *path); void ITTAPI __itt_module_load(void *start_addr, void *end_addr,
const char *path);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, void, module_loadA, (void *start_addr, void *end_addr, const char *path)) ITT_STUB(ITTAPI, void, module_loadA,
ITT_STUB(ITTAPI, void, module_loadW, (void *start_addr, void *end_addr, const wchar_t *path)) (void *start_addr, void *end_addr, const char *path))
ITT_STUB(ITTAPI, void, module_loadW,
(void *start_addr, void *end_addr, const wchar_t *path))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, void, module_load, (void *start_addr, void *end_addr, const char *path)) ITT_STUB(ITTAPI, void, module_load,
(void *start_addr, void *end_addr, const char *path))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_module_loadA ITTNOTIFY_VOID(module_loadA) #define __itt_module_loadA ITTNOTIFY_VOID(module_loadA)
#define __itt_module_loadA_ptr ITTNOTIFY_NAME(module_loadA) #define __itt_module_loadA_ptr ITTNOTIFY_NAME(module_loadA)
#define __itt_module_loadW ITTNOTIFY_VOID(module_loadW) #define __itt_module_loadW ITTNOTIFY_VOID(module_loadW)
#define __itt_module_loadW_ptr ITTNOTIFY_NAME(module_loadW) #define __itt_module_loadW_ptr ITTNOTIFY_NAME(module_loadW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_module_load ITTNOTIFY_VOID(module_load) #define __itt_module_load ITTNOTIFY_VOID(module_load)
#define __itt_module_load_ptr ITTNOTIFY_NAME(module_load) #define __itt_module_load_ptr ITTNOTIFY_NAME(module_load)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_module_loadA(start_addr, end_addr, path) #define __itt_module_loadA(start_addr, end_addr, path)
#define __itt_module_loadA_ptr 0 #define __itt_module_loadA_ptr 0
#define __itt_module_loadW(start_addr, end_addr, path) #define __itt_module_loadW(start_addr, end_addr, path)
#define __itt_module_loadW_ptr 0 #define __itt_module_loadW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_module_load(start_addr, end_addr, path) #define __itt_module_load(start_addr, end_addr, path)
#define __itt_module_load_ptr 0 #define __itt_module_load_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_module_loadA_ptr 0 #define __itt_module_loadA_ptr 0
#define __itt_module_loadW_ptr 0 #define __itt_module_loadW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_module_load_ptr 0 #define __itt_module_load_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* _ITTNOTIFY_H_ */ #endif /* _ITTNOTIFY_H_ */
#ifdef INTEL_ITTNOTIFY_API_PRIVATE #ifdef INTEL_ITTNOTIFY_API_PRIVATE
#ifndef _ITTNOTIFY_PRIVATE_ #ifndef _ITTNOTIFY_PRIVATE_
#define _ITTNOTIFY_PRIVATE_ #define _ITTNOTIFY_PRIVATE_
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief Begin an overlapped task instance. * @brief Begin an overlapped task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] taskid The identifier for this task instance, *cannot* be __itt_null. * @param[in] taskid The identifier for this task instance, *cannot* be
* __itt_null.
* @param[in] parentid The parent of this task, or __itt_null. * @param[in] parentid The parent of this task, or __itt_null.
* @param[in] name The name of this task. * @param[in] name The name of this task.
*/ */
void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name); void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp,
__itt_id taskid, __itt_id parentid,
__itt_string_handle *name);
/** /**
* @ingroup clockdomain * @ingroup clockdomain
* @brief End an overlapped task instance. * @brief End an overlapped task instance.
* @param[in] domain The domain for this task * @param[in] domain The domain for this task
* @param[in] clock_domain The clock domain controlling the execution of this call. * @param[in] clock_domain The clock domain controlling the execution of this
* call.
* @param[in] timestamp The user defined timestamp. * @param[in] timestamp The user defined timestamp.
* @param[in] taskid Explicit ID of finished task * @param[in] taskid Explicit ID of finished task
*/ */
void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid); void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain *domain,
__itt_clock_domain *clock_domain,
unsigned long long timestamp,
__itt_id taskid);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex, (const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name)) ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex,
ITT_STUBV(ITTAPI, void, task_end_overlapped_ex, (const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid)) (const __itt_domain *domain, __itt_clock_domain *clock_domain,
#define __itt_task_begin_overlapped_ex(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(task_begin_overlapped_ex,d,x,y,z,a,b) unsigned long long timestamp, __itt_id taskid, __itt_id parentid,
#define __itt_task_begin_overlapped_ex_ptr ITTNOTIFY_NAME(task_begin_overlapped_ex) __itt_string_handle *name))
#define __itt_task_end_overlapped_ex(d,x,y,z) ITTNOTIFY_VOID_D3(task_end_overlapped_ex,d,x,y,z) ITT_STUBV(ITTAPI, void, task_end_overlapped_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id taskid))
#define __itt_task_begin_overlapped_ex(d, x, y, z, a, b) \
ITTNOTIFY_VOID_D5(task_begin_overlapped_ex, d, x, y, z, a, b)
#define __itt_task_begin_overlapped_ex_ptr \
ITTNOTIFY_NAME(task_begin_overlapped_ex)
#define __itt_task_end_overlapped_ex(d, x, y, z) \
ITTNOTIFY_VOID_D3(task_end_overlapped_ex, d, x, y, z)
#define __itt_task_end_overlapped_ex_ptr ITTNOTIFY_NAME(task_end_overlapped_ex) #define __itt_task_end_overlapped_ex_ptr ITTNOTIFY_NAME(task_end_overlapped_ex)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_task_begin_overlapped_ex(domain,clock_domain,timestamp,taskid,parentid,name) #define __itt_task_begin_overlapped_ex(domain, clock_domain, timestamp, \
taskid, parentid, name)
#define __itt_task_begin_overlapped_ex_ptr 0 #define __itt_task_begin_overlapped_ex_ptr 0
#define __itt_task_end_overlapped_ex(domain,clock_domain,timestamp,taskid) #define __itt_task_end_overlapped_ex(domain, clock_domain, timestamp, taskid)
#define __itt_task_end_overlapped_ex_ptr 0 #define __itt_task_end_overlapped_ex_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_task_begin_overlapped_ex_ptr 0 #define __itt_task_begin_overlapped_ex_ptr 0
#define __itt_task_end_overlapped_ptr 0 #define __itt_task_end_overlapped_ptr 0
#define __itt_task_end_overlapped_ex_ptr 0 #define __itt_task_end_overlapped_ex_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @defgroup makrs_internal Marks * @defgroup makrs_internal Marks
* @ingroup internal * @ingroup internal
* Marks group * Marks group
* @warning Internal API: * @warning Internal API:
* - It is not shipped to outside of Intel * - It is not shipped to outside of Intel
* - It is delivered to internal Intel teams using e-mail or SVN access only * - It is delivered to internal Intel teams using e-mail or SVN access only
* @{ * @{
*/ */
/** @brief user mark type */ /** @brief user mark type */
typedef int __itt_mark_type; typedef int __itt_mark_type;
/** /**
* @brief Creates a user mark type with the specified name using char or Unicode string. * @brief Creates a user mark type with the specified name using char or Unicode
* string.
* @param[in] name - name of mark to create * @param[in] name - name of mark to create
* @return Returns a handle to the mark type * @return Returns a handle to the mark type
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_mark_type ITTAPI __itt_mark_createA(const char *name); __itt_mark_type ITTAPI __itt_mark_createA(const char *name);
__itt_mark_type ITTAPI __itt_mark_createW(const wchar_t *name); __itt_mark_type ITTAPI __itt_mark_createW(const wchar_t *name);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_mark_create __itt_mark_createW #define __itt_mark_create __itt_mark_createW
# define __itt_mark_create_ptr __itt_mark_createW_ptr #define __itt_mark_create_ptr __itt_mark_createW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_mark_create __itt_mark_createA #define __itt_mark_create __itt_mark_createA
# define __itt_mark_create_ptr __itt_mark_createA_ptr #define __itt_mark_create_ptr __itt_mark_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_mark_type ITTAPI __itt_mark_create(const char *name); __itt_mark_type ITTAPI __itt_mark_create(const char *name);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name)) ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name))
ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name)) ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name)) ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_mark_createA ITTNOTIFY_DATA(mark_createA) #define __itt_mark_createA ITTNOTIFY_DATA(mark_createA)
#define __itt_mark_createA_ptr ITTNOTIFY_NAME(mark_createA) #define __itt_mark_createA_ptr ITTNOTIFY_NAME(mark_createA)
#define __itt_mark_createW ITTNOTIFY_DATA(mark_createW) #define __itt_mark_createW ITTNOTIFY_DATA(mark_createW)
#define __itt_mark_createW_ptr ITTNOTIFY_NAME(mark_createW) #define __itt_mark_createW_ptr ITTNOTIFY_NAME(mark_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark_create ITTNOTIFY_DATA(mark_create) #define __itt_mark_create ITTNOTIFY_DATA(mark_create)
#define __itt_mark_create_ptr ITTNOTIFY_NAME(mark_create) #define __itt_mark_create_ptr ITTNOTIFY_NAME(mark_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_mark_createA(name) (__itt_mark_type)0 #define __itt_mark_createA(name) (__itt_mark_type)0
#define __itt_mark_createA_ptr 0 #define __itt_mark_createA_ptr 0
#define __itt_mark_createW(name) (__itt_mark_type)0 #define __itt_mark_createW(name) (__itt_mark_type)0
#define __itt_mark_createW_ptr 0 #define __itt_mark_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark_create(name) (__itt_mark_type)0 #define __itt_mark_create(name) (__itt_mark_type)0
#define __itt_mark_create_ptr 0 #define __itt_mark_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_mark_createA_ptr 0 #define __itt_mark_createA_ptr 0
#define __itt_mark_createW_ptr 0 #define __itt_mark_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark_create_ptr 0 #define __itt_mark_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Creates a "discrete" user mark type of the specified type and an optional parameter using char or Unicode string. * @brief Creates a "discrete" user mark type of the specified type and an
* optional parameter using char or Unicode string.
* *
* - The mark of "discrete" type is placed to collection results in case of success. It appears in overtime view(s) as a special tick sign. * - The mark of "discrete" type is placed to collection results in case of
* - The call is "synchronous" - function returns after mark is actually added to results. * success. It appears in overtime view(s) as a special tick sign.
* - This function is useful, for example, to mark different phases of application * - The call is "synchronous" - function returns after mark is actually added
* (beginning of the next mark automatically meand end of current region). * to results.
* - Can be used together with "continuous" marks (see below) at the same collection session * - This function is useful, for example, to mark different phases of
* application (beginning of the next mark automatically meand end of current
* region).
* - Can be used together with "continuous" marks (see below) at the same
* collection session
* @param[in] mt - mark, created by __itt_mark_create(const char* name) function * @param[in] mt - mark, created by __itt_mark_create(const char* name) function
* @param[in] parameter - string parameter of mark * @param[in] parameter - string parameter of mark
* @return Returns zero value in case of success, non-zero value otherwise. * @return Returns zero value in case of success, non-zero value otherwise.
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
int ITTAPI __itt_markA(__itt_mark_type mt, const char *parameter); int ITTAPI __itt_markA(__itt_mark_type mt, const char *parameter);
int ITTAPI __itt_markW(__itt_mark_type mt, const wchar_t *parameter); int ITTAPI __itt_markW(__itt_mark_type mt, const wchar_t *parameter);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_mark __itt_markW #define __itt_mark __itt_markW
# define __itt_mark_ptr __itt_markW_ptr #define __itt_mark_ptr __itt_markW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_mark __itt_markA #define __itt_mark __itt_markA
# define __itt_mark_ptr __itt_markA_ptr #define __itt_mark_ptr __itt_markA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
int ITTAPI __itt_mark(__itt_mark_type mt, const char *parameter); int ITTAPI __itt_mark(__itt_mark_type mt, const char *parameter);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter)) ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter))
ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter)) ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter)) ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_markA ITTNOTIFY_DATA(markA) #define __itt_markA ITTNOTIFY_DATA(markA)
#define __itt_markA_ptr ITTNOTIFY_NAME(markA) #define __itt_markA_ptr ITTNOTIFY_NAME(markA)
#define __itt_markW ITTNOTIFY_DATA(markW) #define __itt_markW ITTNOTIFY_DATA(markW)
#define __itt_markW_ptr ITTNOTIFY_NAME(markW) #define __itt_markW_ptr ITTNOTIFY_NAME(markW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark ITTNOTIFY_DATA(mark) #define __itt_mark ITTNOTIFY_DATA(mark)
#define __itt_mark_ptr ITTNOTIFY_NAME(mark) #define __itt_mark_ptr ITTNOTIFY_NAME(mark)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_markA(mt, parameter) (int)0 #define __itt_markA(mt, parameter) (int)0
#define __itt_markA_ptr 0 #define __itt_markA_ptr 0
#define __itt_markW(mt, parameter) (int)0 #define __itt_markW(mt, parameter) (int)0
#define __itt_markW_ptr 0 #define __itt_markW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark(mt, parameter) (int)0 #define __itt_mark(mt, parameter) (int)0
#define __itt_mark_ptr 0 #define __itt_mark_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_markA_ptr 0 #define __itt_markA_ptr 0
#define __itt_markW_ptr 0 #define __itt_markW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark_ptr 0 #define __itt_mark_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Use this if necessary to create a "discrete" user event type (mark) for process * @brief Use this if necessary to create a "discrete" user event type (mark)
* rather then for one thread * for process rather then for one thread
* @see int __itt_mark(__itt_mark_type mt, const char* parameter); * @see int __itt_mark(__itt_mark_type mt, const char* parameter);
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
int ITTAPI __itt_mark_globalA(__itt_mark_type mt, const char *parameter); int ITTAPI __itt_mark_globalA(__itt_mark_type mt, const char *parameter);
int ITTAPI __itt_mark_globalW(__itt_mark_type mt, const wchar_t *parameter); int ITTAPI __itt_mark_globalW(__itt_mark_type mt, const wchar_t *parameter);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_mark_global __itt_mark_globalW #define __itt_mark_global __itt_mark_globalW
# define __itt_mark_global_ptr __itt_mark_globalW_ptr #define __itt_mark_global_ptr __itt_mark_globalW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_mark_global __itt_mark_globalA #define __itt_mark_global __itt_mark_globalA
# define __itt_mark_global_ptr __itt_mark_globalA_ptr #define __itt_mark_global_ptr __itt_mark_globalA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
int ITTAPI __itt_mark_global(__itt_mark_type mt, const char *parameter); int ITTAPI __itt_mark_global(__itt_mark_type mt, const char *parameter);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter)) ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter))
ITT_STUB(ITTAPI, int, mark_globalW, (__itt_mark_type mt, const wchar_t *parameter)) ITT_STUB(ITTAPI, int, mark_globalW,
(__itt_mark_type mt, const wchar_t *parameter))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter)) ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_mark_globalA ITTNOTIFY_DATA(mark_globalA) #define __itt_mark_globalA ITTNOTIFY_DATA(mark_globalA)
#define __itt_mark_globalA_ptr ITTNOTIFY_NAME(mark_globalA) #define __itt_mark_globalA_ptr ITTNOTIFY_NAME(mark_globalA)
#define __itt_mark_globalW ITTNOTIFY_DATA(mark_globalW) #define __itt_mark_globalW ITTNOTIFY_DATA(mark_globalW)
#define __itt_mark_globalW_ptr ITTNOTIFY_NAME(mark_globalW) #define __itt_mark_globalW_ptr ITTNOTIFY_NAME(mark_globalW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark_global ITTNOTIFY_DATA(mark_global) #define __itt_mark_global ITTNOTIFY_DATA(mark_global)
#define __itt_mark_global_ptr ITTNOTIFY_NAME(mark_global) #define __itt_mark_global_ptr ITTNOTIFY_NAME(mark_global)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_mark_globalA(mt, parameter) (int)0 #define __itt_mark_globalA(mt, parameter) (int)0
#define __itt_mark_globalA_ptr 0 #define __itt_mark_globalA_ptr 0
#define __itt_mark_globalW(mt, parameter) (int)0 #define __itt_mark_globalW(mt, parameter) (int)0
#define __itt_mark_globalW_ptr 0 #define __itt_mark_globalW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark_global(mt, parameter) (int)0 #define __itt_mark_global(mt, parameter) (int)0
#define __itt_mark_global_ptr 0 #define __itt_mark_global_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_mark_globalA_ptr 0 #define __itt_mark_globalA_ptr 0
#define __itt_mark_globalW_ptr 0 #define __itt_mark_globalW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_mark_global_ptr 0 #define __itt_mark_global_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Creates an "end" point for "continuous" mark with specified name. * @brief Creates an "end" point for "continuous" mark with specified name.
* *
* - Returns zero value in case of success, non-zero value otherwise. * - Returns zero value in case of success, non-zero value otherwise.
Show All 9 Lines
* @return Returns zero value in case of success, non-zero value otherwise. * @return Returns zero value in case of success, non-zero value otherwise.
*/ */
int ITTAPI __itt_mark_off(__itt_mark_type mt); int ITTAPI __itt_mark_off(__itt_mark_type mt);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt)) ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt))
#define __itt_mark_off ITTNOTIFY_DATA(mark_off) #define __itt_mark_off ITTNOTIFY_DATA(mark_off)
#define __itt_mark_off_ptr ITTNOTIFY_NAME(mark_off) #define __itt_mark_off_ptr ITTNOTIFY_NAME(mark_off)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_mark_off(mt) (int)0 #define __itt_mark_off(mt) (int)0
#define __itt_mark_off_ptr 0 #define __itt_mark_off_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_mark_off_ptr 0 #define __itt_mark_off_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Use this if necessary to create an "end" point for mark of process * @brief Use this if necessary to create an "end" point for mark of process
* @see int __itt_mark_off(__itt_mark_type mt); * @see int __itt_mark_off(__itt_mark_type mt);
*/ */
int ITTAPI __itt_mark_global_off(__itt_mark_type mt); int ITTAPI __itt_mark_global_off(__itt_mark_type mt);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt)) ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt))
#define __itt_mark_global_off ITTNOTIFY_DATA(mark_global_off) #define __itt_mark_global_off ITTNOTIFY_DATA(mark_global_off)
#define __itt_mark_global_off_ptr ITTNOTIFY_NAME(mark_global_off) #define __itt_mark_global_off_ptr ITTNOTIFY_NAME(mark_global_off)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_mark_global_off(mt) (int)0 #define __itt_mark_global_off(mt) (int)0
#define __itt_mark_global_off_ptr 0 #define __itt_mark_global_off_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_mark_global_off_ptr 0 #define __itt_mark_global_off_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} marks group */ /** @} marks group */
/** /**
* @defgroup counters_internal Counters * @defgroup counters_internal Counters
* @ingroup internal * @ingroup internal
* Counters group * Counters group
* @{ * @{
*/ */
/** /**
* @defgroup stitch Stack Stitching * @defgroup stitch Stack Stitching
* @ingroup internal * @ingroup internal
* Stack Stitching group * Stack Stitching group
* @{ * @{
*/ */
/** /**
* @brief opaque structure for counter identification * @brief opaque structure for counter identification
*/ */
typedef struct ___itt_caller *__itt_caller; typedef struct ___itt_caller *__itt_caller;
/** /**
* @brief Create the stitch point e.g. a point in call stack where other stacks should be stitched to. * @brief Create the stitch point e.g. a point in call stack where other stacks
* The function returns a unique identifier which is used to match the cut points with corresponding stitch points. * should be stitched to. The function returns a unique identifier which is used
* to match the cut points with corresponding stitch points.
*/ */
__itt_caller ITTAPI __itt_stack_caller_create(void); __itt_caller ITTAPI __itt_stack_caller_create(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void)) ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void))
#define __itt_stack_caller_create ITTNOTIFY_DATA(stack_caller_create) #define __itt_stack_caller_create ITTNOTIFY_DATA(stack_caller_create)
#define __itt_stack_caller_create_ptr ITTNOTIFY_NAME(stack_caller_create) #define __itt_stack_caller_create_ptr ITTNOTIFY_NAME(stack_caller_create)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_stack_caller_create() (__itt_caller)0 #define __itt_stack_caller_create() (__itt_caller)0
#define __itt_stack_caller_create_ptr 0 #define __itt_stack_caller_create_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_stack_caller_create_ptr 0 #define __itt_stack_caller_create_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Destroy the information about stitch point identified by the pointer previously returned by __itt_stack_caller_create() * @brief Destroy the information about stitch point identified by the pointer
* previously returned by __itt_stack_caller_create()
*/ */
void ITTAPI __itt_stack_caller_destroy(__itt_caller id); void ITTAPI __itt_stack_caller_destroy(__itt_caller id);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id)) ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id))
#define __itt_stack_caller_destroy ITTNOTIFY_VOID(stack_caller_destroy) #define __itt_stack_caller_destroy ITTNOTIFY_VOID(stack_caller_destroy)
#define __itt_stack_caller_destroy_ptr ITTNOTIFY_NAME(stack_caller_destroy) #define __itt_stack_caller_destroy_ptr ITTNOTIFY_NAME(stack_caller_destroy)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_stack_caller_destroy(id) #define __itt_stack_caller_destroy(id)
#define __itt_stack_caller_destroy_ptr 0 #define __itt_stack_caller_destroy_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_stack_caller_destroy_ptr 0 #define __itt_stack_caller_destroy_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Sets the cut point. Stack from each event which occurs after this call will be cut * @brief Sets the cut point. Stack from each event which occurs after this call
* at the same stack level the function was called and stitched to the corresponding stitch point. * will be cut at the same stack level the function was called and stitched to
* the corresponding stitch point.
*/ */
void ITTAPI __itt_stack_callee_enter(__itt_caller id); void ITTAPI __itt_stack_callee_enter(__itt_caller id);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id)) ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id))
#define __itt_stack_callee_enter ITTNOTIFY_VOID(stack_callee_enter) #define __itt_stack_callee_enter ITTNOTIFY_VOID(stack_callee_enter)
#define __itt_stack_callee_enter_ptr ITTNOTIFY_NAME(stack_callee_enter) #define __itt_stack_callee_enter_ptr ITTNOTIFY_NAME(stack_callee_enter)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_stack_callee_enter(id) #define __itt_stack_callee_enter(id)
#define __itt_stack_callee_enter_ptr 0 #define __itt_stack_callee_enter_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_stack_callee_enter_ptr 0 #define __itt_stack_callee_enter_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief This function eliminates the cut point which was set by latest __itt_stack_callee_enter(). * @brief This function eliminates the cut point which was set by latest
* __itt_stack_callee_enter().
*/ */
void ITTAPI __itt_stack_callee_leave(__itt_caller id); void ITTAPI __itt_stack_callee_leave(__itt_caller id);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id)) ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id))
#define __itt_stack_callee_leave ITTNOTIFY_VOID(stack_callee_leave) #define __itt_stack_callee_leave ITTNOTIFY_VOID(stack_callee_leave)
#define __itt_stack_callee_leave_ptr ITTNOTIFY_NAME(stack_callee_leave) #define __itt_stack_callee_leave_ptr ITTNOTIFY_NAME(stack_callee_leave)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_stack_callee_leave(id) #define __itt_stack_callee_leave(id)
#define __itt_stack_callee_leave_ptr 0 #define __itt_stack_callee_leave_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_stack_callee_leave_ptr 0 #define __itt_stack_callee_leave_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} stitch group */ /** @} stitch group */
/* ***************************************************************************************************************************** */ /* *****************************************************************************************************************************
*/
#include <stdarg.h> #include <stdarg.h>
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
typedef enum __itt_error_code typedef enum __itt_error_code {
{
__itt_error_success = 0, /*!< no error */ __itt_error_success = 0, /*!< no error */
__itt_error_no_module = 1, /*!< module can't be loaded */ __itt_error_no_module = 1, /*!< module can't be loaded */
/* %1$s -- library name; win: %2$d -- system error code; unx: %2$s -- system error message. */ /* %1$s -- library name; win: %2$d -- system error code; unx: %2$s -- system
error message. */
__itt_error_no_symbol = 2, /*!< symbol not found */ __itt_error_no_symbol = 2, /*!< symbol not found */
/* %1$s -- library name, %2$s -- symbol name. */ /* %1$s -- library name, %2$s -- symbol name. */
__itt_error_unknown_group = 3, /*!< unknown group specified */ __itt_error_unknown_group = 3, /*!< unknown group specified */
/* %1$s -- env var name, %2$s -- group name. */ /* %1$s -- env var name, %2$s -- group name. */
__itt_error_cant_read_env = 4, /*!< GetEnvironmentVariable() failed */ __itt_error_cant_read_env = 4, /*!< GetEnvironmentVariable() failed */
/* %1$s -- env var name, %2$d -- system error. */ /* %1$s -- env var name, %2$d -- system error. */
__itt_error_env_too_long = 5, /*!< variable value too long */ __itt_error_env_too_long = 5, /*!< variable value too long */
/* %1$s -- env var name, %2$d -- actual length of the var, %3$d -- max allowed length. */ /* %1$s -- env var name, %2$d -- actual length of the var, %3$d -- max allowed
__itt_error_system = 6 /*!< pthread_mutexattr_init or pthread_mutex_init failed */ length. */
__itt_error_system =
6 /*!< pthread_mutexattr_init or pthread_mutex_init failed */
/* %1$s -- function name, %2$d -- errno. */ /* %1$s -- function name, %2$d -- errno. */
} __itt_error_code; } __itt_error_code;
typedef void (__itt_error_handler_t)(__itt_error_code code, va_list); typedef void(__itt_error_handler_t)(__itt_error_code code, va_list);
__itt_error_handler_t* __itt_set_error_handler(__itt_error_handler_t*); __itt_error_handler_t *__itt_set_error_handler(__itt_error_handler_t *);
const char* ITTAPI __itt_api_version(void); const char *ITTAPI __itt_api_version(void);
/** @endcond */ /** @endcond */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#define __itt_error_handler ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, error_handler) #define __itt_error_handler ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, error_handler)
void __itt_error_handler(__itt_error_code code, va_list args); void __itt_error_handler(__itt_error_code code, va_list args);
extern const int ITTNOTIFY_NAME(err); extern const int ITTNOTIFY_NAME(err);
#define __itt_err ITTNOTIFY_NAME(err) #define __itt_err ITTNOTIFY_NAME(err)
ITT_STUB(ITTAPI, const char*, api_version, (void)) ITT_STUB(ITTAPI, const char *, api_version, (void))
#define __itt_api_version ITTNOTIFY_DATA(api_version) #define __itt_api_version ITTNOTIFY_DATA(api_version)
#define __itt_api_version_ptr ITTNOTIFY_NAME(api_version) #define __itt_api_version_ptr ITTNOTIFY_NAME(api_version)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_api_version() (const char*)0 #define __itt_api_version() (const char *)0
#define __itt_api_version_ptr 0 #define __itt_api_version_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_api_version_ptr 0 #define __itt_api_version_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* _ITTNOTIFY_PRIVATE_ */ #endif /* _ITTNOTIFY_PRIVATE_ */
#endif /* INTEL_ITTNOTIFY_API_PRIVATE */ #endif /* INTEL_ITTNOTIFY_API_PRIVATE */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_config.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _ITTNOTIFY_CONFIG_H_ #ifndef _ITTNOTIFY_CONFIG_H_
#define _ITTNOTIFY_CONFIG_H_ #define _ITTNOTIFY_CONFIG_H_
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef ITT_OS_WIN #ifndef ITT_OS_WIN
# define ITT_OS_WIN 1 #define ITT_OS_WIN 1
#endif /* ITT_OS_WIN */ #endif /* ITT_OS_WIN */
#ifndef ITT_OS_LINUX #ifndef ITT_OS_LINUX
# define ITT_OS_LINUX 2 #define ITT_OS_LINUX 2
#endif /* ITT_OS_LINUX */ #endif /* ITT_OS_LINUX */
#ifndef ITT_OS_MAC #ifndef ITT_OS_MAC
# define ITT_OS_MAC 3 #define ITT_OS_MAC 3
#endif /* ITT_OS_MAC */ #endif /* ITT_OS_MAC */
#ifndef ITT_OS_FREEBSD #ifndef ITT_OS_FREEBSD
# define ITT_OS_FREEBSD 4 #define ITT_OS_FREEBSD 4
#endif /* ITT_OS_FREEBSD */ #endif /* ITT_OS_FREEBSD */
#ifndef ITT_OS #ifndef ITT_OS
# if defined WIN32 || defined _WIN32 #if defined WIN32 || defined _WIN32
# define ITT_OS ITT_OS_WIN #define ITT_OS ITT_OS_WIN
# elif defined( __APPLE__ ) && defined( __MACH__ ) #elif defined(__APPLE__) && defined(__MACH__)
# define ITT_OS ITT_OS_MAC #define ITT_OS ITT_OS_MAC
# elif defined( __FreeBSD__ ) #elif defined(__FreeBSD__)
# define ITT_OS ITT_OS_FREEBSD #define ITT_OS ITT_OS_FREEBSD
# else #else
# define ITT_OS ITT_OS_LINUX #define ITT_OS ITT_OS_LINUX
# endif #endif
#endif /* ITT_OS */ #endif /* ITT_OS */
#ifndef ITT_PLATFORM_WIN #ifndef ITT_PLATFORM_WIN
# define ITT_PLATFORM_WIN 1 #define ITT_PLATFORM_WIN 1
#endif /* ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM_WIN */
#ifndef ITT_PLATFORM_POSIX #ifndef ITT_PLATFORM_POSIX
# define ITT_PLATFORM_POSIX 2 #define ITT_PLATFORM_POSIX 2
#endif /* ITT_PLATFORM_POSIX */ #endif /* ITT_PLATFORM_POSIX */
#ifndef ITT_PLATFORM_MAC #ifndef ITT_PLATFORM_MAC
# define ITT_PLATFORM_MAC 3 #define ITT_PLATFORM_MAC 3
#endif /* ITT_PLATFORM_MAC */ #endif /* ITT_PLATFORM_MAC */
#ifndef ITT_PLATFORM_FREEBSD #ifndef ITT_PLATFORM_FREEBSD
# define ITT_PLATFORM_FREEBSD 4 #define ITT_PLATFORM_FREEBSD 4
#endif /* ITT_PLATFORM_FREEBSD */ #endif /* ITT_PLATFORM_FREEBSD */
#ifndef ITT_PLATFORM #ifndef ITT_PLATFORM
# if ITT_OS==ITT_OS_WIN #if ITT_OS == ITT_OS_WIN
# define ITT_PLATFORM ITT_PLATFORM_WIN #define ITT_PLATFORM ITT_PLATFORM_WIN
# elif ITT_OS==ITT_OS_MAC #elif ITT_OS == ITT_OS_MAC
# define ITT_PLATFORM ITT_PLATFORM_MAC #define ITT_PLATFORM ITT_PLATFORM_MAC
# elif ITT_OS==ITT_OS_FREEBSD #elif ITT_OS == ITT_OS_FREEBSD
# define ITT_PLATFORM ITT_PLATFORM_FREEBSD #define ITT_PLATFORM ITT_PLATFORM_FREEBSD
# else #else
# define ITT_PLATFORM ITT_PLATFORM_POSIX #define ITT_PLATFORM ITT_PLATFORM_POSIX
# endif #endif
#endif /* ITT_PLATFORM */ #endif /* ITT_PLATFORM */
#if defined(_UNICODE) && !defined(UNICODE) #if defined(_UNICODE) && !defined(UNICODE)
#define UNICODE #define UNICODE
#endif #endif
#include <stddef.h> #include <stddef.h>
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#include <tchar.h> #include <tchar.h>
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#include <stdint.h> #include <stdint.h>
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
#include <wchar.h> #include <wchar.h>
#endif /* UNICODE || _UNICODE */ #endif /* UNICODE || _UNICODE */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#ifndef ITTAPI_CDECL #ifndef ITTAPI_CDECL
# if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
# define ITTAPI_CDECL __cdecl #define ITTAPI_CDECL __cdecl
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__ #if defined _M_IX86 || defined __i386__
# define ITTAPI_CDECL __attribute__ ((cdecl)) #define ITTAPI_CDECL __attribute__((cdecl))
# else /* _M_IX86 || __i386__ */ #else /* _M_IX86 || __i386__ */
# define ITTAPI_CDECL /* actual only on x86 platform */ #define ITTAPI_CDECL /* actual only on x86 platform */
# endif /* _M_IX86 || __i386__ */ #endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* ITTAPI_CDECL */ #endif /* ITTAPI_CDECL */
#ifndef STDCALL #ifndef STDCALL
# if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
# define STDCALL __stdcall #define STDCALL __stdcall
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__ #if defined _M_IX86 || defined __i386__
# define STDCALL __attribute__ ((stdcall)) #define STDCALL __attribute__((stdcall))
# else /* _M_IX86 || __i386__ */ #else /* _M_IX86 || __i386__ */
# define STDCALL /* supported only on x86 platform */ #define STDCALL /* supported only on x86 platform */
# endif /* _M_IX86 || __i386__ */ #endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* STDCALL */ #endif /* STDCALL */
#define ITTAPI ITTAPI_CDECL #define ITTAPI ITTAPI_CDECL
#define LIBITTAPI ITTAPI_CDECL #define LIBITTAPI ITTAPI_CDECL
/* TODO: Temporary for compatibility! */ /* TODO: Temporary for compatibility! */
#define ITTAPI_CALL ITTAPI_CDECL #define ITTAPI_CALL ITTAPI_CDECL
#define LIBITTAPI_CALL ITTAPI_CDECL #define LIBITTAPI_CALL ITTAPI_CDECL
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
/* use __forceinline (VC++ specific) */ /* use __forceinline (VC++ specific) */
#define ITT_INLINE __forceinline #define ITT_INLINE __forceinline
#define ITT_INLINE_ATTRIBUTE /* nothing */ #define ITT_INLINE_ATTRIBUTE /* nothing */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/* /*
* Generally, functions are not inlined unless optimization is specified. * Generally, functions are not inlined unless optimization is specified.
* For functions declared inline, this attribute inlines the function even * For functions declared inline, this attribute inlines the function even
* if no optimization level was specified. * if no optimization level was specified.
*/ */
#ifdef __STRICT_ANSI__ #ifdef __STRICT_ANSI__
#define ITT_INLINE static #define ITT_INLINE static
#define ITT_INLINE_ATTRIBUTE __attribute__((unused)) #define ITT_INLINE_ATTRIBUTE __attribute__((unused))
#else /* __STRICT_ANSI__ */ #else /* __STRICT_ANSI__ */
#define ITT_INLINE static inline #define ITT_INLINE static inline
#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused)) #define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
#endif /* __STRICT_ANSI__ */ #endif /* __STRICT_ANSI__ */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @endcond */ /** @endcond */
#ifndef ITT_ARCH_IA32 #ifndef ITT_ARCH_IA32
# define ITT_ARCH_IA32 1 #define ITT_ARCH_IA32 1
#endif /* ITT_ARCH_IA32 */ #endif /* ITT_ARCH_IA32 */
#ifndef ITT_ARCH_IA32E #ifndef ITT_ARCH_IA32E
# define ITT_ARCH_IA32E 2 #define ITT_ARCH_IA32E 2
#endif /* ITT_ARCH_IA32E */ #endif /* ITT_ARCH_IA32E */
/* Was there a magical reason we didn't have 3 here before? */ /* Was there a magical reason we didn't have 3 here before? */
#ifndef ITT_ARCH_AARCH64 #ifndef ITT_ARCH_AARCH64
# define ITT_ARCH_AARCH64 3 #define ITT_ARCH_AARCH64 3
#endif /* ITT_ARCH_AARCH64 */ #endif /* ITT_ARCH_AARCH64 */
#ifndef ITT_ARCH_ARM #ifndef ITT_ARCH_ARM
# define ITT_ARCH_ARM 4 #define ITT_ARCH_ARM 4
#endif /* ITT_ARCH_ARM */ #endif /* ITT_ARCH_ARM */
#ifndef ITT_ARCH_PPC64 #ifndef ITT_ARCH_PPC64
# define ITT_ARCH_PPC64 5 #define ITT_ARCH_PPC64 5
#endif /* ITT_ARCH_PPC64 */ #endif /* ITT_ARCH_PPC64 */
#ifndef ITT_ARCH_MIPS #ifndef ITT_ARCH_MIPS
# define ITT_ARCH_MIPS 6 #define ITT_ARCH_MIPS 6
#endif /* ITT_ARCH_MIPS */ #endif /* ITT_ARCH_MIPS */
#ifndef ITT_ARCH_MIPS64 #ifndef ITT_ARCH_MIPS64
# define ITT_ARCH_MIPS64 6 #define ITT_ARCH_MIPS64 6
#endif /* ITT_ARCH_MIPS64 */ #endif /* ITT_ARCH_MIPS64 */
#ifndef ITT_ARCH_RISCV64 #ifndef ITT_ARCH_RISCV64
# define ITT_ARCH_RISCV64 7 #define ITT_ARCH_RISCV64 7
#endif /* ITT_ARCH_RISCV64 */ #endif /* ITT_ARCH_RISCV64 */
#ifndef ITT_ARCH #ifndef ITT_ARCH
# if defined _M_IX86 || defined __i386__ #if defined _M_IX86 || defined __i386__
# define ITT_ARCH ITT_ARCH_IA32 #define ITT_ARCH ITT_ARCH_IA32
# elif defined _M_X64 || defined _M_AMD64 || defined __x86_64__ #elif defined _M_X64 || defined _M_AMD64 || defined __x86_64__
# define ITT_ARCH ITT_ARCH_IA32E #define ITT_ARCH ITT_ARCH_IA32E
# elif defined _M_IA64 || defined __ia64__ #elif defined _M_IA64 || defined __ia64__
# define ITT_ARCH ITT_ARCH_IA64 #define ITT_ARCH ITT_ARCH_IA64
# elif defined _M_ARM || defined __arm__ #elif defined _M_ARM || defined __arm__
# define ITT_ARCH ITT_ARCH_ARM #define ITT_ARCH ITT_ARCH_ARM
# elif defined __powerpc64__ #elif defined __powerpc64__
# define ITT_ARCH ITT_ARCH_PPC64 #define ITT_ARCH ITT_ARCH_PPC64
# elif defined __aarch64__ #elif defined __aarch64__
# define ITT_ARCH ITT_ARCH_AARCH64 #define ITT_ARCH ITT_ARCH_AARCH64
# elif defined __mips__ && !defined __mips64 #elif defined __mips__ && !defined __mips64
# define ITT_ARCH ITT_ARCH_MIPS #define ITT_ARCH ITT_ARCH_MIPS
# elif defined __mips__ && defined __mips64 #elif defined __mips__ && defined __mips64
# define ITT_ARCH ITT_ARCH_MIPS64 #define ITT_ARCH ITT_ARCH_MIPS64
# elif defined __riscv && __riscv_xlen == 64 #elif defined __riscv && __riscv_xlen == 64
# define ITT_ARCH ITT_ARCH_RISCV64 #define ITT_ARCH ITT_ARCH_RISCV64
# endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
# define ITT_EXTERN_C extern "C" #define ITT_EXTERN_C extern "C"
# define ITT_EXTERN_C_BEGIN extern "C" { #define ITT_EXTERN_C_BEGIN extern "C" {
# define ITT_EXTERN_C_END } #define ITT_EXTERN_C_END }
#else #else
# define ITT_EXTERN_C /* nothing */ #define ITT_EXTERN_C /* nothing */
# define ITT_EXTERN_C_BEGIN /* nothing */ #define ITT_EXTERN_C_BEGIN /* nothing */
# define ITT_EXTERN_C_END /* nothing */ #define ITT_EXTERN_C_END /* nothing */
#endif /* __cplusplus */ #endif /* __cplusplus */
#define ITT_TO_STR_AUX(x) #x #define ITT_TO_STR_AUX(x) #x
#define ITT_TO_STR(x) ITT_TO_STR_AUX(x) #define ITT_TO_STR(x) ITT_TO_STR_AUX(x)
#define __ITT_BUILD_ASSERT(expr, suffix) do { \ #define __ITT_BUILD_ASSERT(expr, suffix) \
do { \
static char __itt_build_check_##suffix[(expr) ? 1 : -1]; \ static char __itt_build_check_##suffix[(expr) ? 1 : -1]; \
__itt_build_check_##suffix[0] = 0; \ __itt_build_check_##suffix[0] = 0; \
} while(0) } while (0)
#define _ITT_BUILD_ASSERT(expr, suffix) __ITT_BUILD_ASSERT((expr), suffix) #define _ITT_BUILD_ASSERT(expr, suffix) __ITT_BUILD_ASSERT((expr), suffix)
#define ITT_BUILD_ASSERT(expr) _ITT_BUILD_ASSERT((expr), __LINE__) #define ITT_BUILD_ASSERT(expr) _ITT_BUILD_ASSERT((expr), __LINE__)
#define ITT_MAGIC { 0xED, 0xAB, 0xAB, 0xEC, 0x0D, 0xEE, 0xDA, 0x30 } #define ITT_MAGIC \
{ 0xED, 0xAB, 0xAB, 0xEC, 0x0D, 0xEE, 0xDA, 0x30 }
/* Replace with snapshot date YYYYMMDD for promotion build. */ /* Replace with snapshot date YYYYMMDD for promotion build. */
#define API_VERSION_BUILD 20151119 #define API_VERSION_BUILD 20151119
#ifndef API_VERSION_NUM #ifndef API_VERSION_NUM
#define API_VERSION_NUM 0.0.0 #define API_VERSION_NUM 0.0.0
#endif /* API_VERSION_NUM */ #endif /* API_VERSION_NUM */
#define API_VERSION "ITT-API-Version " ITT_TO_STR(API_VERSION_NUM) \ #define API_VERSION \
" (" ITT_TO_STR(API_VERSION_BUILD) ")" "ITT-API-Version " ITT_TO_STR(API_VERSION_NUM) " (" ITT_TO_STR( \
API_VERSION_BUILD) ")"
/* OS communication functions */ /* OS communication functions */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#include <windows.h> #include <windows.h>
typedef HMODULE lib_t; typedef HMODULE lib_t;
typedef DWORD TIDT; typedef DWORD TIDT;
typedef CRITICAL_SECTION mutex_t; typedef CRITICAL_SECTION mutex_t;
#define MUTEX_INITIALIZER { 0 } #define MUTEX_INITIALIZER \
{ 0 }
#define strong_alias(name, aliasname) /* empty for Windows */ #define strong_alias(name, aliasname) /* empty for Windows */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#include <dlfcn.h> #include <dlfcn.h>
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
#include <wchar.h> #include <wchar.h>
#endif /* UNICODE */ #endif /* UNICODE */
#ifndef _GNU_SOURCE #ifndef _GNU_SOURCE
#define _GNU_SOURCE 1 /* need for PTHREAD_MUTEX_RECURSIVE */ #define _GNU_SOURCE 1 /* need for PTHREAD_MUTEX_RECURSIVE */
#endif /* _GNU_SOURCE */ #endif /* _GNU_SOURCE */
#ifndef __USE_UNIX98 #ifndef __USE_UNIX98
#define __USE_UNIX98 1 /* need for PTHREAD_MUTEX_RECURSIVE, on SLES11.1 with gcc 4.3.4 wherein pthread.h missing dependency on __USE_XOPEN2K8 */ #define __USE_UNIX98 \
1 /* need for PTHREAD_MUTEX_RECURSIVE, on SLES11.1 with gcc 4.3.4 wherein \
pthread.h missing dependency on __USE_XOPEN2K8 */
#endif /*__USE_UNIX98*/ #endif /*__USE_UNIX98*/
#include <pthread.h> #include <pthread.h>
typedef void* lib_t; typedef void *lib_t;
typedef pthread_t TIDT; typedef pthread_t TIDT;
typedef pthread_mutex_t mutex_t; typedef pthread_mutex_t mutex_t;
#define MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER #define MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
#define _strong_alias(name, aliasname) \ #define _strong_alias(name, aliasname) \
extern __typeof (name) aliasname __attribute__ ((alias (#name))); extern __typeof(name) aliasname __attribute__((alias(#name)));
#define strong_alias(name, aliasname) _strong_alias(name, aliasname) #define strong_alias(name, aliasname) _strong_alias(name, aliasname)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_get_proc(lib, name) GetProcAddress(lib, name) #define __itt_get_proc(lib, name) GetProcAddress(lib, name)
#define __itt_mutex_init(mutex) InitializeCriticalSection(mutex) #define __itt_mutex_init(mutex) InitializeCriticalSection(mutex)
#define __itt_mutex_lock(mutex) EnterCriticalSection(mutex) #define __itt_mutex_lock(mutex) EnterCriticalSection(mutex)
#define __itt_mutex_unlock(mutex) LeaveCriticalSection(mutex) #define __itt_mutex_unlock(mutex) LeaveCriticalSection(mutex)
#define __itt_load_lib(name) LoadLibraryA(name) #define __itt_load_lib(name) LoadLibraryA(name)
#define __itt_unload_lib(handle) FreeLibrary(handle) #define __itt_unload_lib(handle) FreeLibrary(handle)
#define __itt_system_error() (int)GetLastError() #define __itt_system_error() (int)GetLastError()
#define __itt_fstrcmp(s1, s2) lstrcmpA(s1, s2) #define __itt_fstrcmp(s1, s2) lstrcmpA(s1, s2)
#define __itt_fstrnlen(s, l) strnlen_s(s, l) #define __itt_fstrnlen(s, l) strnlen_s(s, l)
#define __itt_fstrcpyn(s1, b, s2, l) strncpy_s(s1, b, s2, l) #define __itt_fstrcpyn(s1, b, s2, l) strncpy_s(s1, b, s2, l)
#define __itt_fstrdup(s) _strdup(s) #define __itt_fstrdup(s) _strdup(s)
#define __itt_thread_id() GetCurrentThreadId() #define __itt_thread_id() GetCurrentThreadId()
#define __itt_thread_yield() SwitchToThread() #define __itt_thread_yield() SwitchToThread()
#ifndef ITT_SIMPLE_INIT #ifndef ITT_SIMPLE_INIT
ITT_INLINE long ITT_INLINE long
__itt_interlocked_increment(volatile long* ptr) ITT_INLINE_ATTRIBUTE; __itt_interlocked_increment(volatile long *ptr) ITT_INLINE_ATTRIBUTE;
ITT_INLINE long __itt_interlocked_increment(volatile long* ptr) ITT_INLINE long __itt_interlocked_increment(volatile long *ptr) {
{
return InterlockedIncrement(ptr); return InterlockedIncrement(ptr);
} }
#endif /* ITT_SIMPLE_INIT */ #endif /* ITT_SIMPLE_INIT */
#define DL_SYMBOLS (1) #define DL_SYMBOLS (1)
#define PTHREAD_SYMBOLS (1) #define PTHREAD_SYMBOLS (1)
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
#define __itt_get_proc(lib, name) dlsym(lib, name) #define __itt_get_proc(lib, name) dlsym(lib, name)
#define __itt_mutex_init(mutex) {\ #define __itt_mutex_init(mutex) \
{ \
pthread_mutexattr_t mutex_attr; \ pthread_mutexattr_t mutex_attr; \
int error_code = pthread_mutexattr_init(&mutex_attr); \ int error_code = pthread_mutexattr_init(&mutex_attr); \
if (error_code) \ if (error_code) \
__itt_report_error(__itt_error_system, "pthread_mutexattr_init", \ __itt_report_error(__itt_error_system, "pthread_mutexattr_init", \
error_code); \ error_code); \
error_code = pthread_mutexattr_settype(&mutex_attr, \ error_code = \
PTHREAD_MUTEX_RECURSIVE); \ pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE); \
if (error_code) \ if (error_code) \
__itt_report_error(__itt_error_system, "pthread_mutexattr_settype", \ __itt_report_error(__itt_error_system, "pthread_mutexattr_settype", \
error_code); \ error_code); \
error_code = pthread_mutex_init(mutex, &mutex_attr); \ error_code = pthread_mutex_init(mutex, &mutex_attr); \
if (error_code) \ if (error_code) \
__itt_report_error(__itt_error_system, "pthread_mutex_init", \ __itt_report_error(__itt_error_system, "pthread_mutex_init", \
error_code); \ error_code); \
error_code = pthread_mutexattr_destroy(&mutex_attr); \ error_code = pthread_mutexattr_destroy(&mutex_attr); \
if (error_code) \ if (error_code) \
__itt_report_error(__itt_error_system, "pthread_mutexattr_destroy", \ __itt_report_error(__itt_error_system, "pthread_mutexattr_destroy", \
error_code); \ error_code); \
} }
#define __itt_mutex_lock(mutex) pthread_mutex_lock(mutex) #define __itt_mutex_lock(mutex) pthread_mutex_lock(mutex)
#define __itt_mutex_unlock(mutex) pthread_mutex_unlock(mutex) #define __itt_mutex_unlock(mutex) pthread_mutex_unlock(mutex)
#define __itt_load_lib(name) dlopen(name, RTLD_LAZY) #define __itt_load_lib(name) dlopen(name, RTLD_LAZY)
#define __itt_unload_lib(handle) dlclose(handle) #define __itt_unload_lib(handle) dlclose(handle)
#define __itt_system_error() errno #define __itt_system_error() errno
#define __itt_fstrcmp(s1, s2) strcmp(s1, s2) #define __itt_fstrcmp(s1, s2) strcmp(s1, s2)
/* makes customer code define safe APIs for SDL_STRNLEN_S and SDL_STRNCPY_S */ /* makes customer code define safe APIs for SDL_STRNLEN_S and SDL_STRNCPY_S */
#ifdef SDL_STRNLEN_S #ifdef SDL_STRNLEN_S
#define __itt_fstrnlen(s, l) SDL_STRNLEN_S(s, l) #define __itt_fstrnlen(s, l) SDL_STRNLEN_S(s, l)
#else #else
#define __itt_fstrnlen(s, l) strlen(s) #define __itt_fstrnlen(s, l) strlen(s)
#endif /* SDL_STRNLEN_S */ #endif /* SDL_STRNLEN_S */
#ifdef SDL_STRNCPY_S #ifdef SDL_STRNCPY_S
#define __itt_fstrcpyn(s1, b, s2, l) SDL_STRNCPY_S(s1, b, s2, l) #define __itt_fstrcpyn(s1, b, s2, l) SDL_STRNCPY_S(s1, b, s2, l)
#else #else
#define __itt_fstrcpyn(s1, b, s2, l) strncpy(s1, s2, l) #define __itt_fstrcpyn(s1, b, s2, l) strncpy(s1, s2, l)
#endif /* SDL_STRNCPY_S */ #endif /* SDL_STRNCPY_S */
#define __itt_fstrdup(s) strdup(s) #define __itt_fstrdup(s) strdup(s)
#define __itt_thread_id() pthread_self() #define __itt_thread_id() pthread_self()
#define __itt_thread_yield() sched_yield() #define __itt_thread_yield() sched_yield()
#if ITT_ARCH==ITT_ARCH_IA64 #if ITT_ARCH == ITT_ARCH_IA64
#ifdef __INTEL_COMPILER #ifdef __INTEL_COMPILER
#define __TBB_machine_fetchadd4(addr, val) __fetchadd4_acq((void *)addr, val) #define __TBB_machine_fetchadd4(addr, val) __fetchadd4_acq((void *)addr, val)
#else /* __INTEL_COMPILER */ #else /* __INTEL_COMPILER */
/* TODO: Add Support for not Intel compilers for IA-64 architecture */ /* TODO: Add Support for not Intel compilers for IA-64 architecture */
#endif /* __INTEL_COMPILER */ #endif /* __INTEL_COMPILER */
#elif ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_IA32E /* ITT_ARCH!=ITT_ARCH_IA64 */ #elif ITT_ARCH == ITT_ARCH_IA32 || \
ITT_INLINE long ITT_ARCH == ITT_ARCH_IA32E /* ITT_ARCH!=ITT_ARCH_IA64 */
__TBB_machine_fetchadd4(volatile void* ptr, long addend) ITT_INLINE_ATTRIBUTE; ITT_INLINE long __TBB_machine_fetchadd4(volatile void *ptr,
ITT_INLINE long __TBB_machine_fetchadd4(volatile void* ptr, long addend) long addend) ITT_INLINE_ATTRIBUTE;
{ ITT_INLINE long __TBB_machine_fetchadd4(volatile void *ptr, long addend) {
long result; long result;
__asm__ __volatile__("lock\nxadd %0,%1" __asm__ __volatile__("lock\nxadd %0,%1"
: "=r"(result),"=m"(*(volatile int*)ptr) : "=r"(result), "=m"(*(volatile int *)ptr)
: "0"(addend), "m"(*(volatile int*)ptr) : "0"(addend), "m"(*(volatile int *)ptr)
: "memory"); : "memory");
return result; return result;
} }
#elif ITT_ARCH == ITT_ARCH_ARM || ITT_ARCH == ITT_ARCH_PPC64 || \ #elif ITT_ARCH == ITT_ARCH_ARM || ITT_ARCH == ITT_ARCH_PPC64 || \
ITT_ARCH == ITT_ARCH_AARCH64 || ITT_ARCH == ITT_ARCH_MIPS || \ ITT_ARCH == ITT_ARCH_AARCH64 || ITT_ARCH == ITT_ARCH_MIPS || \
ITT_ARCH == ITT_ARCH_MIPS64 || ITT_ARCH == ITT_ARCH_RISCV64 ITT_ARCH == ITT_ARCH_MIPS64 || ITT_ARCH == ITT_ARCH_RISCV64
#define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val) #define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val)
#endif /* ITT_ARCH==ITT_ARCH_IA64 */ #endif /* ITT_ARCH==ITT_ARCH_IA64 */
#ifndef ITT_SIMPLE_INIT #ifndef ITT_SIMPLE_INIT
ITT_INLINE long ITT_INLINE long
__itt_interlocked_increment(volatile long* ptr) ITT_INLINE_ATTRIBUTE; __itt_interlocked_increment(volatile long *ptr) ITT_INLINE_ATTRIBUTE;
ITT_INLINE long __itt_interlocked_increment(volatile long* ptr) ITT_INLINE long __itt_interlocked_increment(volatile long *ptr) {
{
return __TBB_machine_fetchadd4(ptr, 1) + 1L; return __TBB_machine_fetchadd4(ptr, 1) + 1L;
} }
#endif /* ITT_SIMPLE_INIT */ #endif /* ITT_SIMPLE_INIT */
void* dlopen(const char*, int) __attribute__((weak)); void *dlopen(const char *, int) __attribute__((weak));
void* dlsym(void*, const char*) __attribute__((weak)); void *dlsym(void *, const char *) __attribute__((weak));
int dlclose(void*) __attribute__((weak)); int dlclose(void *) __attribute__((weak));
#define DL_SYMBOLS (dlopen && dlsym && dlclose) #define DL_SYMBOLS (dlopen && dlsym && dlclose)
int pthread_mutex_init(pthread_mutex_t*, const pthread_mutexattr_t*) __attribute__((weak)); int pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *)
__attribute__((weak));
int pthread_mutex_lock(pthread_mutex_t*) __attribute__((weak)); int pthread_mutex_lock(pthread_mutex_t *) __attribute__((weak));
int pthread_mutex_unlock(pthread_mutex_t*) __attribute__((weak)); int pthread_mutex_unlock(pthread_mutex_t *) __attribute__((weak));
int pthread_mutex_destroy(pthread_mutex_t*) __attribute__((weak)); int pthread_mutex_destroy(pthread_mutex_t *) __attribute__((weak));
int pthread_mutexattr_init(pthread_mutexattr_t*) __attribute__((weak)); int pthread_mutexattr_init(pthread_mutexattr_t *) __attribute__((weak));
int pthread_mutexattr_settype(pthread_mutexattr_t*, int) __attribute__((weak)); int pthread_mutexattr_settype(pthread_mutexattr_t *, int) __attribute__((weak));
int pthread_mutexattr_destroy(pthread_mutexattr_t*) __attribute__((weak)); int pthread_mutexattr_destroy(pthread_mutexattr_t *) __attribute__((weak));
pthread_t pthread_self(void) __attribute__((weak)); pthread_t pthread_self(void) __attribute__((weak));
#define PTHREAD_SYMBOLS (pthread_mutex_init && pthread_mutex_lock && pthread_mutex_unlock && pthread_mutex_destroy && pthread_mutexattr_init && pthread_mutexattr_settype && pthread_mutexattr_destroy && pthread_self) #define PTHREAD_SYMBOLS \
(pthread_mutex_init && pthread_mutex_lock && pthread_mutex_unlock && \
pthread_mutex_destroy && pthread_mutexattr_init && \
pthread_mutexattr_settype && pthread_mutexattr_destroy && pthread_self)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
typedef enum { typedef enum {
__itt_collection_normal = 0, __itt_collection_normal = 0,
__itt_collection_paused = 1 __itt_collection_paused = 1
} __itt_collection_state; } __itt_collection_state;
typedef enum { typedef enum {
__itt_thread_normal = 0, __itt_thread_normal = 0,
__itt_thread_ignored = 1 __itt_thread_ignored = 1
} __itt_thread_state; } __itt_thread_state;
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_thread_info typedef struct ___itt_thread_info {
{
const char* nameA; /*!< Copy of original name in ASCII. */ const char *nameA; /*!< Copy of original name in ASCII. */
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
const wchar_t* nameW; /*!< Copy of original name in UNICODE. */ const wchar_t *nameW; /*!< Copy of original name in UNICODE. */
#else /* UNICODE || _UNICODE */ #else /* UNICODE || _UNICODE */
void* nameW; void *nameW;
#endif /* UNICODE || _UNICODE */ #endif /* UNICODE || _UNICODE */
TIDT tid; TIDT tid;
__itt_thread_state state; /*!< Thread state (paused or normal) */ __itt_thread_state state; /*!< Thread state (paused or normal) */
int extra1; /*!< Reserved to the runtime */ int extra1; /*!< Reserved to the runtime */
void* extra2; /*!< Reserved to the runtime */ void *extra2; /*!< Reserved to the runtime */
struct ___itt_thread_info* next; struct ___itt_thread_info *next;
} __itt_thread_info; } __itt_thread_info;
#include "ittnotify_types.h" /* For __itt_group_id definition */ #include "ittnotify_types.h" /* For __itt_group_id definition */
typedef struct ___itt_api_info_20101001 typedef struct ___itt_api_info_20101001 {
{
const char* name; const char *name;
void** func_ptr; void **func_ptr;
void* init_func; void *init_func;
__itt_group_id group; __itt_group_id group;
} __itt_api_info_20101001; } __itt_api_info_20101001;
typedef struct ___itt_api_info typedef struct ___itt_api_info {
{
const char* name; const char *name;
void** func_ptr; void **func_ptr;
void* init_func; void *init_func;
void* null_func; void *null_func;
__itt_group_id group; __itt_group_id group;
} __itt_api_info; } __itt_api_info;
typedef struct __itt_counter_info typedef struct __itt_counter_info {
{
const char* nameA; /*!< Copy of original name in ASCII. */ const char *nameA; /*!< Copy of original name in ASCII. */
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
const wchar_t* nameW; /*!< Copy of original name in UNICODE. */ const wchar_t *nameW; /*!< Copy of original name in UNICODE. */
#else /* UNICODE || _UNICODE */ #else /* UNICODE || _UNICODE */
void* nameW; void *nameW;
#endif /* UNICODE || _UNICODE */ #endif /* UNICODE || _UNICODE */
const char* domainA; /*!< Copy of original name in ASCII. */ const char *domainA; /*!< Copy of original name in ASCII. */
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
const wchar_t* domainW; /*!< Copy of original name in UNICODE. */ const wchar_t *domainW; /*!< Copy of original name in UNICODE. */
#else /* UNICODE || _UNICODE */ #else /* UNICODE || _UNICODE */
void* domainW; void *domainW;
#endif /* UNICODE || _UNICODE */ #endif /* UNICODE || _UNICODE */
int type; int type;
long index; long index;
int extra1; /*!< Reserved to the runtime */ int extra1; /*!< Reserved to the runtime */
void* extra2; /*!< Reserved to the runtime */ void *extra2; /*!< Reserved to the runtime */
struct __itt_counter_info* next; struct __itt_counter_info *next;
} __itt_counter_info_t; } __itt_counter_info_t;
struct ___itt_domain; struct ___itt_domain;
struct ___itt_string_handle; struct ___itt_string_handle;
typedef struct ___itt_global typedef struct ___itt_global {
{
unsigned char magic[8]; unsigned char magic[8];
unsigned long version_major; unsigned long version_major;
unsigned long version_minor; unsigned long version_minor;
unsigned long version_build; unsigned long version_build;
volatile long api_initialized; volatile long api_initialized;
volatile long mutex_initialized; volatile long mutex_initialized;
volatile long atomic_counter; volatile long atomic_counter;
mutex_t mutex; mutex_t mutex;
lib_t lib; lib_t lib;
void* error_handler; void *error_handler;
const char** dll_path_ptr; const char **dll_path_ptr;
__itt_api_info* api_list_ptr; __itt_api_info *api_list_ptr;
struct ___itt_global* next; struct ___itt_global *next;
/* Joinable structures below */ /* Joinable structures below */
__itt_thread_info* thread_list; __itt_thread_info *thread_list;
struct ___itt_domain* domain_list; struct ___itt_domain *domain_list;
struct ___itt_string_handle* string_list; struct ___itt_string_handle *string_list;
__itt_collection_state state; __itt_collection_state state;
__itt_counter_info_t* counter_list; __itt_counter_info_t *counter_list;
} __itt_global; } __itt_global;
#pragma pack(pop) #pragma pack(pop)
#define NEW_THREAD_INFO_W(gptr,h,h_tail,t,s,n) { \ #define NEW_THREAD_INFO_W(gptr, h, h_tail, t, s, n) \
{ \
h = (__itt_thread_info*)malloc(sizeof(__itt_thread_info)); \ h = (__itt_thread_info *)malloc(sizeof(__itt_thread_info)); \
if (h != NULL) { \ if (h != NULL) { \
h->tid = t; \ h->tid = t; \
h->nameA = NULL; \ h->nameA = NULL; \
h->nameW = n ? _wcsdup(n) : NULL; \ h->nameW = n ? _wcsdup(n) : NULL; \
h->state = s; \ h->state = s; \
h->extra1 = 0; /* reserved */ \ h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \ h->extra2 = NULL; /* reserved */ \
h->next = NULL; \ h->next = NULL; \
if (h_tail == NULL) \ if (h_tail == NULL) \
(gptr)->thread_list = h; \ (gptr)->thread_list = h; \
else \ else \
h_tail->next = h; \ h_tail->next = h; \
} \ } \
} }
#define NEW_THREAD_INFO_A(gptr,h,h_tail,t,s,n) { \ #define NEW_THREAD_INFO_A(gptr, h, h_tail, t, s, n) \
{ \
h = (__itt_thread_info*)malloc(sizeof(__itt_thread_info)); \ h = (__itt_thread_info *)malloc(sizeof(__itt_thread_info)); \
if (h != NULL) { \ if (h != NULL) { \
h->tid = t; \ h->tid = t; \
h->nameA = n ? __itt_fstrdup(n) : NULL; \ h->nameA = n ? __itt_fstrdup(n) : NULL; \
h->nameW = NULL; \ h->nameW = NULL; \
h->state = s; \ h->state = s; \
h->extra1 = 0; /* reserved */ \ h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \ h->extra2 = NULL; /* reserved */ \
h->next = NULL; \ h->next = NULL; \
if (h_tail == NULL) \ if (h_tail == NULL) \
(gptr)->thread_list = h; \ (gptr)->thread_list = h; \
else \ else \
h_tail->next = h; \ h_tail->next = h; \
} \ } \
} }
#define NEW_DOMAIN_W(gptr,h,h_tail,name) { \ #define NEW_DOMAIN_W(gptr, h, h_tail, name) \
{ \
h = (__itt_domain*)malloc(sizeof(__itt_domain)); \ h = (__itt_domain *)malloc(sizeof(__itt_domain)); \
if (h != NULL) { \ if (h != NULL) { \
h->flags = 1; /* domain is enabled by default */ \ h->flags = 1; /* domain is enabled by default */ \
h->nameA = NULL; \ h->nameA = NULL; \
h->nameW = name ? _wcsdup(name) : NULL; \ h->nameW = name ? _wcsdup(name) : NULL; \
h->extra1 = 0; /* reserved */ \ h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \ h->extra2 = NULL; /* reserved */ \
h->next = NULL; \ h->next = NULL; \
if (h_tail == NULL) \ if (h_tail == NULL) \
(gptr)->domain_list = h; \ (gptr)->domain_list = h; \
else \ else \
h_tail->next = h; \ h_tail->next = h; \
} \ } \
} }
#define NEW_DOMAIN_A(gptr,h,h_tail,name) { \ #define NEW_DOMAIN_A(gptr, h, h_tail, name) \
{ \
h = (__itt_domain*)malloc(sizeof(__itt_domain)); \ h = (__itt_domain *)malloc(sizeof(__itt_domain)); \
if (h != NULL) { \ if (h != NULL) { \
h->flags = 1; /* domain is enabled by default */ \ h->flags = 1; /* domain is enabled by default */ \
h->nameA = name ? __itt_fstrdup(name) : NULL; \ h->nameA = name ? __itt_fstrdup(name) : NULL; \
h->nameW = NULL; \ h->nameW = NULL; \
h->extra1 = 0; /* reserved */ \ h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \ h->extra2 = NULL; /* reserved */ \
h->next = NULL; \ h->next = NULL; \
if (h_tail == NULL) \ if (h_tail == NULL) \
(gptr)->domain_list = h; \ (gptr)->domain_list = h; \
else \ else \
h_tail->next = h; \ h_tail->next = h; \
} \ } \
} }
#define NEW_STRING_HANDLE_W(gptr,h,h_tail,name) { \ #define NEW_STRING_HANDLE_W(gptr, h, h_tail, name) \
{ \
h = (__itt_string_handle*)malloc(sizeof(__itt_string_handle)); \ h = (__itt_string_handle *)malloc(sizeof(__itt_string_handle)); \
if (h != NULL) { \ if (h != NULL) { \
h->strA = NULL; \ h->strA = NULL; \
h->strW = name ? _wcsdup(name) : NULL; \ h->strW = name ? _wcsdup(name) : NULL; \
h->extra1 = 0; /* reserved */ \ h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \ h->extra2 = NULL; /* reserved */ \
h->next = NULL; \ h->next = NULL; \
if (h_tail == NULL) \ if (h_tail == NULL) \
(gptr)->string_list = h; \ (gptr)->string_list = h; \
else \ else \
h_tail->next = h; \ h_tail->next = h; \
} \ } \
} }
#define NEW_STRING_HANDLE_A(gptr,h,h_tail,name) { \ #define NEW_STRING_HANDLE_A(gptr, h, h_tail, name) \
{ \
h = (__itt_string_handle*)malloc(sizeof(__itt_string_handle)); \ h = (__itt_string_handle *)malloc(sizeof(__itt_string_handle)); \
if (h != NULL) { \ if (h != NULL) { \
h->strA = name ? __itt_fstrdup(name) : NULL; \ h->strA = name ? __itt_fstrdup(name) : NULL; \
h->strW = NULL; \ h->strW = NULL; \
h->extra1 = 0; /* reserved */ \ h->extra1 = 0; /* reserved */ \
h->extra2 = NULL; /* reserved */ \ h->extra2 = NULL; /* reserved */ \
h->next = NULL; \ h->next = NULL; \
if (h_tail == NULL) \ if (h_tail == NULL) \
(gptr)->string_list = h; \ (gptr)->string_list = h; \
else \ else \
h_tail->next = h; \ h_tail->next = h; \
} \ } \
} }
#define NEW_COUNTER_W(gptr,h,h_tail,name,domain,type) { \ #define NEW_COUNTER_W(gptr, h, h_tail, name, domain, type) \
{ \
h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \ h = (__itt_counter_info_t *)malloc(sizeof(__itt_counter_info_t)); \
if (h != NULL) { \ if (h != NULL) { \
h->nameA = NULL; \ h->nameA = NULL; \
h->nameW = name ? _wcsdup(name) : NULL; \ h->nameW = name ? _wcsdup(name) : NULL; \
h->domainA = NULL; \ h->domainA = NULL; \
h->domainW = name ? _wcsdup(domain) : NULL; \ h->domainW = name ? _wcsdup(domain) : NULL; \
h->type = type; \ h->type = type; \
h->index = 0; \ h->index = 0; \
h->next = NULL; \ h->next = NULL; \
if (h_tail == NULL) \ if (h_tail == NULL) \
(gptr)->counter_list = h; \ (gptr)->counter_list = h; \
else \ else \
h_tail->next = h; \ h_tail->next = h; \
} \ } \
} }
#define NEW_COUNTER_A(gptr,h,h_tail,name,domain,type) { \ #define NEW_COUNTER_A(gptr, h, h_tail, name, domain, type) \
{ \
h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \ h = (__itt_counter_info_t *)malloc(sizeof(__itt_counter_info_t)); \
if (h != NULL) { \ if (h != NULL) { \
h->nameA = name ? __itt_fstrdup(name) : NULL; \ h->nameA = name ? __itt_fstrdup(name) : NULL; \
h->nameW = NULL; \ h->nameW = NULL; \
h->domainA = domain ? __itt_fstrdup(domain) : NULL; \ h->domainA = domain ? __itt_fstrdup(domain) : NULL; \
h->domainW = NULL; \ h->domainW = NULL; \
h->type = type; \ h->type = type; \
h->index = 0; \ h->index = 0; \
h->next = NULL; \ h->next = NULL; \
if (h_tail == NULL) \ if (h_tail == NULL) \
(gptr)->counter_list = h; \ (gptr)->counter_list = h; \
else \ else \
h_tail->next = h; \ h_tail->next = h; \
} \ } \
} }
#endif /* _ITTNOTIFY_CONFIG_H_ */ #endif /* _ITTNOTIFY_CONFIG_H_ */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_static.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ittnotify_config.h" #include "ittnotify_config.h"
#ifndef ITT_FORMAT_DEFINED #ifndef ITT_FORMAT_DEFINED
# ifndef ITT_FORMAT #ifndef ITT_FORMAT
# define ITT_FORMAT #define ITT_FORMAT
# endif /* ITT_FORMAT */ #endif /* ITT_FORMAT */
# ifndef ITT_NO_PARAMS #ifndef ITT_NO_PARAMS
# define ITT_NO_PARAMS #define ITT_NO_PARAMS
# endif /* ITT_NO_PARAMS */ #endif /* ITT_NO_PARAMS */
#endif /* ITT_FORMAT_DEFINED */ #endif /* ITT_FORMAT_DEFINED */
/* /*
* parameters for macro expected: * parameters for macro expected:
* ITT_STUB(api, type, func_name, arguments, params, func_name_in_dll, group, printf_fmt) * ITT_STUB(api, type, func_name, arguments, params, func_name_in_dll, group,
* printf_fmt)
*/ */
#ifdef __ITT_INTERNAL_INIT #ifdef __ITT_INTERNAL_INIT
#ifndef __ITT_INTERNAL_BODY #ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_domain*, domain_createA, (const char *name), (ITT_FORMAT name), domain_createA, __itt_group_structure, "\"%s\"") ITT_STUB(ITTAPI, __itt_domain *, domain_createA, (const char *name),
ITT_STUB(ITTAPI, __itt_domain*, domain_createW, (const wchar_t *name), (ITT_FORMAT name), domain_createW, __itt_group_structure, "\"%S\"") (ITT_FORMAT name), domain_createA, __itt_group_structure, "\"%s\"")
ITT_STUB(ITTAPI, __itt_domain *, domain_createW, (const wchar_t *name),
(ITT_FORMAT name), domain_createW, __itt_group_structure, "\"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_domain*, domain_create, (const char *name), (ITT_FORMAT name), domain_create, __itt_group_structure, "\"%s\"") ITT_STUB(ITTAPI, __itt_domain *, domain_create, (const char *name),
(ITT_FORMAT name), domain_create, __itt_group_structure, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createA, (const char *name), (ITT_FORMAT name), string_handle_createA, __itt_group_structure, "\"%s\"") ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createA,
ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createW, (const wchar_t *name), (ITT_FORMAT name), string_handle_createW, __itt_group_structure, "\"%S\"") (const char *name), (ITT_FORMAT name), string_handle_createA,
__itt_group_structure, "\"%s\"")
ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createW,
(const wchar_t *name), (ITT_FORMAT name), string_handle_createW,
__itt_group_structure, "\"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_create, (const char *name), (ITT_FORMAT name), string_handle_create, __itt_group_structure, "\"%s\"") ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_create,
(const char *name), (ITT_FORMAT name), string_handle_create,
__itt_group_structure, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char *name, const char *domain), (ITT_FORMAT name, domain), counter_createA, __itt_group_counter, "\"%s\", \"%s\"") ITT_STUB(ITTAPI, __itt_counter, counter_createA,
ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), counter_createW, __itt_group_counter, "\"%s\", \"%s\"") (const char *name, const char *domain), (ITT_FORMAT name, domain),
counter_createA, __itt_group_counter, "\"%s\", \"%s\"")
ITT_STUB(ITTAPI, __itt_counter, counter_createW,
(const wchar_t *name, const wchar_t *domain),
(ITT_FORMAT name, domain), counter_createW, __itt_group_counter,
"\"%s\", \"%s\"")
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_counter, counter_create, (const char *name, const char *domain), (ITT_FORMAT name, domain), counter_create, __itt_group_counter, "\"%s\", \"%s\"") ITT_STUB(ITTAPI, __itt_counter, counter_create,
(const char *name, const char *domain), (ITT_FORMAT name, domain),
counter_create, __itt_group_counter, "\"%s\", \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char *name, const char *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedA, __itt_group_counter, "\"%s\", \"%s\", %d") ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA,
ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedW, __itt_group_counter, "\"%s\", \"%s\", %d") (const char *name, const char *domain, __itt_metadata_type type),
(ITT_FORMAT name, domain, type), counter_create_typedA,
__itt_group_counter, "\"%s\", \"%s\", %d")
ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW,
(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type),
(ITT_FORMAT name, domain, type), counter_create_typedW,
__itt_group_counter, "\"%s\", \"%s\", %d")
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_counter, counter_create_typed, (const char *name, const char *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typed, __itt_group_counter, "\"%s\", \"%s\", %d") ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,
(const char *name, const char *domain, __itt_metadata_type type),
(ITT_FORMAT name, domain, type), counter_create_typed,
__itt_group_counter, "\"%s\", \"%s\", %d")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, pause, (void), (ITT_NO_PARAMS), pause,
ITT_STUBV(ITTAPI, void, pause, (void), (ITT_NO_PARAMS), pause, __itt_group_control | __itt_group_legacy, "no args") __itt_group_control | __itt_group_legacy, "no args")
ITT_STUBV(ITTAPI, void, resume, (void), (ITT_NO_PARAMS), resume, __itt_group_control | __itt_group_legacy, "no args") ITT_STUBV(ITTAPI, void, resume, (void), (ITT_NO_PARAMS), resume,
__itt_group_control | __itt_group_legacy, "no args")
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name), (ITT_FORMAT name), thread_set_nameA, __itt_group_thread, "\"%s\"") ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name), (ITT_FORMAT name),
ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name), (ITT_FORMAT name), thread_set_nameW, __itt_group_thread, "\"%S\"") thread_set_nameA, __itt_group_thread, "\"%s\"")
ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name),
(ITT_FORMAT name), thread_set_nameW, __itt_group_thread, "\"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name), (ITT_FORMAT name), thread_set_name, __itt_group_thread, "\"%s\"") ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name), (ITT_FORMAT name),
thread_set_name, __itt_group_thread, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, thread_ignore, (void), (ITT_NO_PARAMS), thread_ignore, __itt_group_thread, "no args") ITT_STUBV(ITTAPI, void, thread_ignore, (void), (ITT_NO_PARAMS), thread_ignore,
__itt_group_thread, "no args")
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char *name, int namelen), (ITT_FORMAT name, namelen), thr_name_setA, __itt_group_thread | __itt_group_legacy, "\"%s\", %d") ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char *name, int namelen),
ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen), thr_name_setW, __itt_group_thread | __itt_group_legacy, "\"%S\", %d") (ITT_FORMAT name, namelen), thr_name_setA,
__itt_group_thread | __itt_group_legacy, "\"%s\", %d")
ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen),
(ITT_FORMAT name, namelen), thr_name_setW,
__itt_group_thread | __itt_group_legacy, "\"%S\", %d")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, thr_name_set, (const char *name, int namelen), (ITT_FORMAT name, namelen), thr_name_set, __itt_group_thread | __itt_group_legacy, "\"%s\", %d") ITT_STUB(LIBITTAPI, int, thr_name_set, (const char *name, int namelen),
(ITT_FORMAT name, namelen), thr_name_set,
__itt_group_thread | __itt_group_legacy, "\"%s\", %d")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(LIBITTAPI, void, thr_ignore, (void), (ITT_NO_PARAMS), thr_ignore, __itt_group_thread | __itt_group_legacy, "no args") ITT_STUBV(LIBITTAPI, void, thr_ignore, (void), (ITT_NO_PARAMS), thr_ignore,
__itt_group_thread | __itt_group_legacy, "no args")
#endif /* __ITT_INTERNAL_BODY */ #endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(ITTAPI, void, enable_attach, (void), (ITT_NO_PARAMS), enable_attach, __itt_group_all, "no args") ITT_STUBV(ITTAPI, void, enable_attach, (void), (ITT_NO_PARAMS), enable_attach,
__itt_group_all, "no args")
#else /* __ITT_INTERNAL_INIT */ #else /* __ITT_INTERNAL_INIT */
ITT_STUBV(ITTAPI, void, detach, (void), (ITT_NO_PARAMS), detach, __itt_group_control | __itt_group_legacy, "no args") ITT_STUBV(ITTAPI, void, detach, (void), (ITT_NO_PARAMS), detach,
__itt_group_control | __itt_group_legacy, "no args")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, sync_createA, (void *addr, const char *objtype, const char *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_createA, __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
ITT_STUBV(ITTAPI, void, sync_createW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_createW, __itt_group_sync | __itt_group_fsync, "%p, \"%S\", \"%S\", %x")
ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name), (ITT_FORMAT addr, name), sync_renameA, __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name), (ITT_FORMAT addr, name), sync_renameW, __itt_group_sync | __itt_group_fsync, "%p, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_create, (void *addr, const char *objtype, const char *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_create, __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name), (ITT_FORMAT addr, name), sync_rename, __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr), (ITT_FORMAT addr), sync_destroy, __itt_group_sync | __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, sync_prepare, (void* addr), (ITT_FORMAT addr), sync_prepare, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr), (ITT_FORMAT addr), sync_cancel, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr), (ITT_FORMAT addr), sync_acquired, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_releasing, (void* addr), (ITT_FORMAT addr), sync_releasing, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask), (ITT_FORMAT mask), suppress_push, __itt_group_suppress, "%p")
ITT_STUBV(ITTAPI, void, suppress_pop, (void), (ITT_NO_PARAMS), suppress_pop, __itt_group_suppress, "no args")
ITT_STUBV(ITTAPI, void, suppress_mark_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size),(ITT_FORMAT mode, mask, address, size), suppress_mark_range, __itt_group_suppress, "%d, %p, %p, %d")
ITT_STUBV(ITTAPI, void, suppress_clear_range,(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size),(ITT_FORMAT mode, mask, address, size), suppress_clear_range,__itt_group_suppress, "%d, %p, %p, %d")
ITT_STUBV(ITTAPI, void, fsync_prepare, (void* addr), (ITT_FORMAT addr), sync_prepare, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr), (ITT_FORMAT addr), sync_cancel, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr), (ITT_FORMAT addr), sync_acquired, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_releasing, (void* addr), (ITT_FORMAT addr), sync_releasing, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, model_site_begin, (__itt_model_site *site, __itt_model_site_instance *instance, const char *name), (ITT_FORMAT site, instance, name), model_site_begin, __itt_group_model, "%p, %p, \"%s\"")
ITT_STUBV(ITTAPI, void, model_site_end, (__itt_model_site *site, __itt_model_site_instance *instance), (ITT_FORMAT site, instance), model_site_end, __itt_group_model, "%p, %p")
ITT_STUBV(ITTAPI, void, model_task_begin, (__itt_model_task *task, __itt_model_task_instance *instance, const char *name), (ITT_FORMAT task, instance, name), model_task_begin, __itt_group_model, "%p, %p, \"%s\"")
ITT_STUBV(ITTAPI, void, model_task_end, (__itt_model_task *task, __itt_model_task_instance *instance), (ITT_FORMAT task, instance), model_task_end, __itt_group_model, "%p, %p")
ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock), (ITT_FORMAT lock), model_lock_acquire, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock), (ITT_FORMAT lock), model_lock_release, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size), (ITT_FORMAT addr, size), model_record_allocation, __itt_group_model, "%p, %d")
ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr), (ITT_FORMAT addr), model_record_deallocation, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_induction_uses, (void* addr, size_t size), (ITT_FORMAT addr, size), model_induction_uses, __itt_group_model, "%p, %d")
ITT_STUBV(ITTAPI, void, model_reduction_uses, (void* addr, size_t size), (ITT_FORMAT addr, size), model_reduction_uses, __itt_group_model, "%p, %d")
ITT_STUBV(ITTAPI, void, model_observe_uses, (void* addr, size_t size), (ITT_FORMAT addr, size), model_observe_uses, __itt_group_model, "%p, %d")
ITT_STUBV(ITTAPI, void, model_clear_uses, (void* addr), (ITT_FORMAT addr), model_clear_uses, __itt_group_model, "%p")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name), (ITT_FORMAT name), model_site_beginW, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name), (ITT_FORMAT name), model_task_beginW, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name), (ITT_FORMAT name), model_iteration_taskW, __itt_group_model, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name), (ITT_FORMAT name), model_site_beginA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_site_beginAL, (const char *name, size_t len), (ITT_FORMAT name, len), model_site_beginAL, __itt_group_model, "\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name), (ITT_FORMAT name), model_task_beginA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_task_beginAL, (const char *name, size_t len), (ITT_FORMAT name, len), model_task_beginAL, __itt_group_model, "\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name), (ITT_FORMAT name), model_iteration_taskA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_iteration_taskAL, (const char *name, size_t len), (ITT_FORMAT name, len), model_iteration_taskAL, __itt_group_model, "\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_site_end_2, (void), (ITT_NO_PARAMS), model_site_end_2, __itt_group_model, "no args")
ITT_STUBV(ITTAPI, void, model_task_end_2, (void), (ITT_NO_PARAMS), model_task_end_2, __itt_group_model, "no args")
ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock), (ITT_FORMAT lock), model_lock_acquire_2, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock), (ITT_FORMAT lock), model_lock_release_2, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t count), (ITT_FORMAT count), model_aggregate_task, __itt_group_model, "%d")
ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x), (ITT_FORMAT x), model_disable_push, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_disable_pop, (void), (ITT_NO_PARAMS), model_disable_pop, __itt_group_model, "no args")
#endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA, (const char *name, const char *domain), (ITT_FORMAT name, domain), heap_function_createA, __itt_group_heap, "\"%s\", \"%s\"") ITT_STUBV(ITTAPI, void, sync_createA,
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), heap_function_createW, __itt_group_heap, "\"%s\", \"%s\"") (void *addr, const char *objtype, const char *objname, int attribute),
(ITT_FORMAT addr, objtype, objname, attribute), sync_createA,
__itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
ITT_STUBV(ITTAPI, void, sync_createW,
(void *addr, const wchar_t *objtype, const wchar_t *objname,
int attribute),
(ITT_FORMAT addr, objtype, objname, attribute), sync_createW,
__itt_group_sync | __itt_group_fsync, "%p, \"%S\", \"%S\", %x")
ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name),
(ITT_FORMAT addr, name), sync_renameA,
__itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name),
(ITT_FORMAT addr, name), sync_renameW,
__itt_group_sync | __itt_group_fsync, "%p, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_create,
(void *addr, const char *objtype, const char *objname, int attribute),
(ITT_FORMAT addr, objtype, objname, attribute), sync_create,
__itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name),
(ITT_FORMAT addr, name), sync_rename,
__itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr), (ITT_FORMAT addr),
sync_destroy, __itt_group_sync | __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, sync_prepare, (void *addr), (ITT_FORMAT addr),
sync_prepare, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr), (ITT_FORMAT addr),
sync_cancel, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr), (ITT_FORMAT addr),
sync_acquired, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, sync_releasing, (void *addr), (ITT_FORMAT addr),
sync_releasing, __itt_group_sync, "%p")
ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask), (ITT_FORMAT mask),
suppress_push, __itt_group_suppress, "%p")
ITT_STUBV(ITTAPI, void, suppress_pop, (void), (ITT_NO_PARAMS), suppress_pop,
__itt_group_suppress, "no args")
ITT_STUBV(ITTAPI, void, suppress_mark_range,
(__itt_suppress_mode_t mode, unsigned int mask, void *address,
size_t size),
(ITT_FORMAT mode, mask, address, size), suppress_mark_range,
__itt_group_suppress, "%d, %p, %p, %d")
ITT_STUBV(ITTAPI, void, suppress_clear_range,
(__itt_suppress_mode_t mode, unsigned int mask, void *address,
size_t size),
(ITT_FORMAT mode, mask, address, size), suppress_clear_range,
__itt_group_suppress, "%d, %p, %p, %d")
ITT_STUBV(ITTAPI, void, fsync_prepare, (void *addr), (ITT_FORMAT addr),
sync_prepare, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr), (ITT_FORMAT addr),
sync_cancel, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr), (ITT_FORMAT addr),
sync_acquired, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, fsync_releasing, (void *addr), (ITT_FORMAT addr),
sync_releasing, __itt_group_fsync, "%p")
ITT_STUBV(ITTAPI, void, model_site_begin,
(__itt_model_site * site, __itt_model_site_instance *instance,
const char *name),
(ITT_FORMAT site, instance, name), model_site_begin,
__itt_group_model, "%p, %p, \"%s\"")
ITT_STUBV(ITTAPI, void, model_site_end,
(__itt_model_site * site, __itt_model_site_instance *instance),
(ITT_FORMAT site, instance), model_site_end, __itt_group_model,
"%p, %p")
ITT_STUBV(ITTAPI, void, model_task_begin,
(__itt_model_task * task, __itt_model_task_instance *instance,
const char *name),
(ITT_FORMAT task, instance, name), model_task_begin,
__itt_group_model, "%p, %p, \"%s\"")
ITT_STUBV(ITTAPI, void, model_task_end,
(__itt_model_task * task, __itt_model_task_instance *instance),
(ITT_FORMAT task, instance), model_task_end, __itt_group_model,
"%p, %p")
ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock), (ITT_FORMAT lock),
model_lock_acquire, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock), (ITT_FORMAT lock),
model_lock_release, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size),
(ITT_FORMAT addr, size), model_record_allocation, __itt_group_model,
"%p, %d")
ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr),
(ITT_FORMAT addr), model_record_deallocation, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_induction_uses, (void *addr, size_t size),
(ITT_FORMAT addr, size), model_induction_uses, __itt_group_model,
"%p, %d")
ITT_STUBV(ITTAPI, void, model_reduction_uses, (void *addr, size_t size),
(ITT_FORMAT addr, size), model_reduction_uses, __itt_group_model,
"%p, %d")
ITT_STUBV(ITTAPI, void, model_observe_uses, (void *addr, size_t size),
(ITT_FORMAT addr, size), model_observe_uses, __itt_group_model,
"%p, %d")
ITT_STUBV(ITTAPI, void, model_clear_uses, (void *addr), (ITT_FORMAT addr),
model_clear_uses, __itt_group_model, "%p")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name),
(ITT_FORMAT name), model_site_beginW, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name),
(ITT_FORMAT name), model_task_beginW, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name),
(ITT_FORMAT name), model_iteration_taskW, __itt_group_model, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name),
(ITT_FORMAT name), model_site_beginA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_site_beginAL, (const char *name, size_t len),
(ITT_FORMAT name, len), model_site_beginAL, __itt_group_model,
"\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name),
(ITT_FORMAT name), model_task_beginA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_task_beginAL, (const char *name, size_t len),
(ITT_FORMAT name, len), model_task_beginAL, __itt_group_model,
"\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name),
(ITT_FORMAT name), model_iteration_taskA, __itt_group_model, "\"%s\"")
ITT_STUBV(ITTAPI, void, model_iteration_taskAL, (const char *name, size_t len),
(ITT_FORMAT name, len), model_iteration_taskAL, __itt_group_model,
"\"%s\", %d")
ITT_STUBV(ITTAPI, void, model_site_end_2, (void), (ITT_NO_PARAMS),
model_site_end_2, __itt_group_model, "no args")
ITT_STUBV(ITTAPI, void, model_task_end_2, (void), (ITT_NO_PARAMS),
model_task_end_2, __itt_group_model, "no args")
ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock), (ITT_FORMAT lock),
model_lock_acquire_2, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock), (ITT_FORMAT lock),
model_lock_release_2, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t count),
(ITT_FORMAT count), model_aggregate_task, __itt_group_model, "%d")
ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x),
(ITT_FORMAT x), model_disable_push, __itt_group_model, "%p")
ITT_STUBV(ITTAPI, void, model_disable_pop, (void), (ITT_NO_PARAMS),
model_disable_pop, __itt_group_model, "no args")
#endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA,
(const char *name, const char *domain), (ITT_FORMAT name, domain),
heap_function_createA, __itt_group_heap, "\"%s\", \"%s\"")
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW,
(const wchar_t *name, const wchar_t *domain),
(ITT_FORMAT name, domain), heap_function_createW, __itt_group_heap,
"\"%s\", \"%s\"")
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create, (const char *name, const char *domain), (ITT_FORMAT name, domain), heap_function_create, __itt_group_heap, "\"%s\", \"%s\"") ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create,
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ (const char *name, const char *domain), (ITT_FORMAT name, domain),
#endif /* __ITT_INTERNAL_BODY */ heap_function_create, __itt_group_heap, "\"%s\", \"%s\"")
ITT_STUBV(ITTAPI, void, heap_allocate_begin, (__itt_heap_function h, size_t size, int initialized), (ITT_FORMAT h, size, initialized), heap_allocate_begin, __itt_group_heap, "%p, %lu, %d") #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, heap_allocate_end, (__itt_heap_function h, void** addr, size_t size, int initialized), (ITT_FORMAT h, addr, size, initialized), heap_allocate_end, __itt_group_heap, "%p, %p, %lu, %d") #endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void* addr), (ITT_FORMAT h, addr), heap_free_begin, __itt_group_heap, "%p, %p") ITT_STUBV(ITTAPI, void, heap_allocate_begin,
ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void* addr), (ITT_FORMAT h, addr), heap_free_end, __itt_group_heap, "%p, %p") (__itt_heap_function h, size_t size, int initialized),
ITT_STUBV(ITTAPI, void, heap_reallocate_begin, (__itt_heap_function h, void* addr, size_t new_size, int initialized), (ITT_FORMAT h, addr, new_size, initialized), heap_reallocate_begin, __itt_group_heap, "%p, %p, %lu, %d") (ITT_FORMAT h, size, initialized), heap_allocate_begin,
ITT_STUBV(ITTAPI, void, heap_reallocate_end, (__itt_heap_function h, void* addr, void** new_addr, size_t new_size, int initialized), (ITT_FORMAT h, addr, new_addr, new_size, initialized), heap_reallocate_end, __itt_group_heap, "%p, %p, %p, %lu, %d") __itt_group_heap, "%p, %lu, %d")
ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void), (ITT_NO_PARAMS), heap_internal_access_begin, __itt_group_heap, "no args") ITT_STUBV(ITTAPI, void, heap_allocate_end,
ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void), (ITT_NO_PARAMS), heap_internal_access_end, __itt_group_heap, "no args") (__itt_heap_function h, void **addr, size_t size, int initialized),
ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void), (ITT_NO_PARAMS), heap_record_memory_growth_begin, __itt_group_heap, "no args") (ITT_FORMAT h, addr, size, initialized), heap_allocate_end,
ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void), (ITT_NO_PARAMS), heap_record_memory_growth_end, __itt_group_heap, "no args") __itt_group_heap, "%p, %p, %lu, %d")
ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask), (ITT_FORMAT reset_mask), heap_reset_detection, __itt_group_heap, "%u") ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void *addr),
ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask), (ITT_FORMAT record_mask), heap_record, __itt_group_heap, "%u") (ITT_FORMAT h, addr), heap_free_begin, __itt_group_heap, "%p, %p")
ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void *addr),
ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), id_create, __itt_group_structure, "%p, %lu") (ITT_FORMAT h, addr), heap_free_end, __itt_group_heap, "%p, %p")
ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), id_destroy, __itt_group_structure, "%p, %lu") ITT_STUBV(ITTAPI, void, heap_reallocate_begin,
(__itt_heap_function h, void *addr, size_t new_size, int initialized),
ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void), (ITT_NO_PARAMS), get_timestamp, __itt_group_structure, "no args") (ITT_FORMAT h, addr, new_size, initialized), heap_reallocate_begin,
__itt_group_heap, "%p, %p, %lu, %d")
ITT_STUBV(ITTAPI, void, region_begin, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), region_begin, __itt_group_structure, "%p, %lu, %lu, %p") ITT_STUBV(ITTAPI, void, heap_reallocate_end,
ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), region_end, __itt_group_structure, "%p, %lu") (__itt_heap_function h, void *addr, void **new_addr, size_t new_size,
int initialized),
#ifndef __ITT_INTERNAL_BODY (ITT_FORMAT h, addr, new_addr, new_size, initialized),
ITT_STUBV(ITTAPI, void, frame_begin_v3, (const __itt_domain *domain, __itt_id *id), (ITT_FORMAT domain, id), frame_begin_v3, __itt_group_structure, "%p, %p") heap_reallocate_end, __itt_group_heap, "%p, %p, %p, %lu, %d")
ITT_STUBV(ITTAPI, void, frame_end_v3, (const __itt_domain *domain, __itt_id *id), (ITT_FORMAT domain, id), frame_end_v3, __itt_group_structure, "%p, %p") ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void), (ITT_NO_PARAMS),
ITT_STUBV(ITTAPI, void, frame_submit_v3, (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin, __itt_timestamp end), (ITT_FORMAT domain, id, begin, end), frame_submit_v3, __itt_group_structure, "%p, %p, %lu, %lu") heap_internal_access_begin, __itt_group_heap, "no args")
#endif /* __ITT_INTERNAL_BODY */ ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void), (ITT_NO_PARAMS),
heap_internal_access_end, __itt_group_heap, "no args")
ITT_STUBV(ITTAPI, void, task_group, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_group, __itt_group_structure, "%p, %lu, %lu, %p") ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void),
(ITT_NO_PARAMS), heap_record_memory_growth_begin, __itt_group_heap,
ITT_STUBV(ITTAPI, void, task_begin, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_begin, __itt_group_structure, "%p, %lu, %lu, %p") "no args")
ITT_STUBV(ITTAPI, void, task_begin_fn, (const __itt_domain *domain, __itt_id id, __itt_id parent, void* fn), (ITT_FORMAT domain, id, parent, fn), task_begin_fn, __itt_group_structure, "%p, %lu, %lu, %p") ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void), (ITT_NO_PARAMS),
ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain), (ITT_FORMAT domain), task_end, __itt_group_structure, "%p") heap_record_memory_growth_end, __itt_group_heap, "no args")
ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask),
ITT_STUBV(ITTAPI, void, counter_inc_v3, (const __itt_domain *domain, __itt_string_handle *name), (ITT_FORMAT domain, name), counter_inc_v3, __itt_group_structure, "%p, %p") (ITT_FORMAT reset_mask), heap_reset_detection, __itt_group_heap, "%u")
ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_inc_delta_v3, __itt_group_structure, "%p, %p, %lu") ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask),
ITT_STUBV(ITTAPI, void, counter_dec_v3, (const __itt_domain *domain, __itt_string_handle *name), (ITT_FORMAT domain, name), counter_dec_v3, __itt_group_structure, "%p, %p") (ITT_FORMAT record_mask), heap_record, __itt_group_heap, "%u")
ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_dec_delta_v3, __itt_group_structure, "%p, %p, %lu")
ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id),
ITT_STUBV(ITTAPI, void, marker, (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, id, name, scope), marker, __itt_group_structure, "%p, %lu, %p, %d") (ITT_FORMAT domain, id), id_create, __itt_group_structure, "%p, %lu")
ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id),
ITT_STUBV(ITTAPI, void, metadata_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data), (ITT_FORMAT domain, id, key, type, count, data), metadata_add, __itt_group_structure, "%p, %lu, %p, %d, %lu, %p") (ITT_FORMAT domain, id), id_destroy, __itt_group_structure, "%p, %lu")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, metadata_str_addA, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char* data, size_t length), (ITT_FORMAT domain, id, key, data, length), metadata_str_addA, __itt_group_structure, "%p, %lu, %p, %p, %lu") ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void), (ITT_NO_PARAMS),
ITT_STUBV(ITTAPI, void, metadata_str_addW, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t* data, size_t length), (ITT_FORMAT domain, id, key, data, length), metadata_str_addW, __itt_group_structure, "%p, %lu, %p, %p, %lu") get_timestamp, __itt_group_structure, "no args")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, metadata_str_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char* data, size_t length), (ITT_FORMAT domain, id, key, data, length), metadata_str_add, __itt_group_structure, "%p, %lu, %p, %p, %lu") ITT_STUBV(ITTAPI, void, region_begin,
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ (const __itt_domain *domain, __itt_id id, __itt_id parent,
__itt_string_handle *name),
ITT_STUBV(ITTAPI, void, relation_add_to_current, (const __itt_domain *domain, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, relation, tail), relation_add_to_current, __itt_group_structure, "%p, %lu, %p") (ITT_FORMAT domain, id, parent, name), region_begin,
ITT_STUBV(ITTAPI, void, relation_add, (const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, head, relation, tail), relation_add, __itt_group_structure, "%p, %p, %lu, %p") __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id),
#ifndef __ITT_INTERNAL_BODY (ITT_FORMAT domain, id), region_end, __itt_group_structure, "%p, %lu")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen), (ITT_FORMAT name, namelen), event_createA, __itt_group_mark | __itt_group_legacy, "\"%s\", %d") #ifndef __ITT_INTERNAL_BODY
ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen), event_createW, __itt_group_mark | __itt_group_legacy, "\"%S\", %d") ITT_STUBV(ITTAPI, void, frame_begin_v3,
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ (const __itt_domain *domain, __itt_id *id), (ITT_FORMAT domain, id),
ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen), (ITT_FORMAT name, namelen), event_create, __itt_group_mark | __itt_group_legacy, "\"%s\", %d") frame_begin_v3, __itt_group_structure, "%p, %p")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ ITT_STUBV(ITTAPI, void, frame_end_v3,
ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event), (ITT_FORMAT event), event_start, __itt_group_mark | __itt_group_legacy, "%d") (const __itt_domain *domain, __itt_id *id), (ITT_FORMAT domain, id),
ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event), (ITT_FORMAT event), event_end, __itt_group_mark | __itt_group_legacy, "%d") frame_end_v3, __itt_group_structure, "%p, %p")
#endif /* __ITT_INTERNAL_BODY */ ITT_STUBV(ITTAPI, void, frame_submit_v3,
(const __itt_domain *domain, __itt_id *id, __itt_timestamp begin,
#ifndef __ITT_INTERNAL_BODY __itt_timestamp end),
#if ITT_PLATFORM==ITT_PLATFORM_WIN (ITT_FORMAT domain, id, begin, end), frame_submit_v3,
ITT_STUBV(ITTAPI, void, sync_set_nameA, (void *addr, const char *objtype, const char *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameA, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", \"%s\", %x") __itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, sync_set_nameW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameW, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%S\", \"%S\", %x") #endif /* __ITT_INTERNAL_BODY */
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_set_name, (void *addr, const char *objtype, const char *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_name, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "p, \"%s\", \"%s\", %x") ITT_STUBV(ITTAPI, void, task_group,
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ (const __itt_domain *domain, __itt_id id, __itt_id parent,
__itt_string_handle *name),
#if ITT_PLATFORM==ITT_PLATFORM_WIN (ITT_FORMAT domain, id, parent, name), task_group,
ITT_STUB(LIBITTAPI, int, notify_sync_nameA, (void *p, const char *objtype, int typelen, const char *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_nameA, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", %d, \"%s\", %d, %x") __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUB(LIBITTAPI, int, notify_sync_nameW, (void *p, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_nameW, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%S\", %d, \"%S\", %d, %x")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ ITT_STUBV(ITTAPI, void, task_begin,
ITT_STUB(LIBITTAPI, int, notify_sync_name, (void *p, const char *objtype, int typelen, const char *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_name, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", %d, \"%s\", %d, %x") (const __itt_domain *domain, __itt_id id, __itt_id parent,
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ __itt_string_handle *name),
(ITT_FORMAT domain, id, parent, name), task_begin,
ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *p), (ITT_FORMAT p), notify_sync_prepare, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p") __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *p), (ITT_FORMAT p), notify_sync_cancel, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p") ITT_STUBV(ITTAPI, void, task_begin_fn,
ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *p), (ITT_FORMAT p), notify_sync_acquired, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p") (const __itt_domain *domain, __itt_id id, __itt_id parent, void *fn),
ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *p), (ITT_FORMAT p), notify_sync_releasing, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p") (ITT_FORMAT domain, id, parent, fn), task_begin_fn,
#endif /* __ITT_INTERNAL_BODY */ __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain),
ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size), (ITT_FORMAT addr, size), memory_read, __itt_group_legacy, "%p, %lu") (ITT_FORMAT domain), task_end, __itt_group_structure, "%p")
ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size), (ITT_FORMAT addr, size), memory_write, __itt_group_legacy, "%p, %lu")
ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size), (ITT_FORMAT addr, size), memory_update, __itt_group_legacy, "%p, %lu") ITT_STUBV(ITTAPI, void, counter_inc_v3,
(const __itt_domain *domain, __itt_string_handle *name),
ITT_STUB(LIBITTAPI, __itt_state_t, state_get, (void), (ITT_NO_PARAMS), state_get, __itt_group_legacy, "no args") (ITT_FORMAT domain, name), counter_inc_v3, __itt_group_structure,
ITT_STUB(LIBITTAPI, __itt_state_t, state_set, (__itt_state_t s), (ITT_FORMAT s), state_set, __itt_group_legacy, "%d") "%p, %p")
ITT_STUB(LIBITTAPI, __itt_obj_state_t, obj_mode_set, (__itt_obj_prop_t p, __itt_obj_state_t s), (ITT_FORMAT p, s), obj_mode_set, __itt_group_legacy, "%d, %d") ITT_STUBV(ITTAPI, void, counter_inc_delta_v3,
ITT_STUB(LIBITTAPI, __itt_thr_state_t, thr_mode_set, (__itt_thr_prop_t p, __itt_thr_state_t s), (ITT_FORMAT p, s), thr_mode_set, __itt_group_legacy, "%d, %d") (const __itt_domain *domain, __itt_string_handle *name,
unsigned long long value),
#ifndef __ITT_INTERNAL_BODY (ITT_FORMAT domain, name, value), counter_inc_delta_v3,
#if ITT_PLATFORM==ITT_PLATFORM_WIN __itt_group_structure, "%p, %p, %lu")
ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char *domain), (ITT_FORMAT domain), frame_createA, __itt_group_frame, "\"%s\"") ITT_STUBV(ITTAPI, void, counter_dec_v3,
ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain), (ITT_FORMAT domain), frame_createW, __itt_group_frame, "\"%s\"") (const __itt_domain *domain, __itt_string_handle *name),
(ITT_FORMAT domain, name), counter_dec_v3, __itt_group_structure,
"%p, %p")
ITT_STUBV(ITTAPI, void, counter_dec_delta_v3,
(const __itt_domain *domain, __itt_string_handle *name,
unsigned long long value),
(ITT_FORMAT domain, name, value), counter_dec_delta_v3,
__itt_group_structure, "%p, %p, %lu")
ITT_STUBV(ITTAPI, void, marker,
(const __itt_domain *domain, __itt_id id, __itt_string_handle *name,
__itt_scope scope),
(ITT_FORMAT domain, id, name, scope), marker, __itt_group_structure,
"%p, %lu, %p, %d")
ITT_STUBV(ITTAPI, void, metadata_add,
(const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
__itt_metadata_type type, size_t count, void *data),
(ITT_FORMAT domain, id, key, type, count, data), metadata_add,
__itt_group_structure, "%p, %lu, %p, %d, %lu, %p")
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, metadata_str_addA,
(const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
const char *data, size_t length),
(ITT_FORMAT domain, id, key, data, length), metadata_str_addA,
__itt_group_structure, "%p, %lu, %p, %p, %lu")
ITT_STUBV(ITTAPI, void, metadata_str_addW,
(const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
const wchar_t *data, size_t length),
(ITT_FORMAT domain, id, key, data, length), metadata_str_addW,
__itt_group_structure, "%p, %lu, %p, %p, %lu")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, metadata_str_add,
(const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
const char *data, size_t length),
(ITT_FORMAT domain, id, key, data, length), metadata_str_add,
__itt_group_structure, "%p, %lu, %p, %p, %lu")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, relation_add_to_current,
(const __itt_domain *domain, __itt_relation relation, __itt_id tail),
(ITT_FORMAT domain, relation, tail), relation_add_to_current,
__itt_group_structure, "%p, %lu, %p")
ITT_STUBV(ITTAPI, void, relation_add,
(const __itt_domain *domain, __itt_id head, __itt_relation relation,
__itt_id tail),
(ITT_FORMAT domain, head, relation, tail), relation_add,
__itt_group_structure, "%p, %p, %lu, %p")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen),
(ITT_FORMAT name, namelen), event_createA,
__itt_group_mark | __itt_group_legacy, "\"%s\", %d")
ITT_STUB(LIBITTAPI, __itt_event, event_createW,
(const wchar_t *name, int namelen), (ITT_FORMAT name, namelen),
event_createW, __itt_group_mark | __itt_group_legacy, "\"%S\", %d")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen),
(ITT_FORMAT name, namelen), event_create,
__itt_group_mark | __itt_group_legacy, "\"%s\", %d")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event), (ITT_FORMAT event),
event_start, __itt_group_mark | __itt_group_legacy, "%d")
ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event), (ITT_FORMAT event),
event_end, __itt_group_mark | __itt_group_legacy, "%d")
#endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, sync_set_nameA,
(void *addr, const char *objtype, const char *objname, int attribute),
(ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameA,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy,
"%p, \"%s\", \"%s\", %x")
ITT_STUBV(ITTAPI, void, sync_set_nameW,
(void *addr, const wchar_t *objtype, const wchar_t *objname,
int attribute),
(ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameW,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy,
"%p, \"%S\", \"%S\", %x")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_set_name,
(void *addr, const char *objtype, const char *objname, int attribute),
(ITT_FORMAT addr, objtype, objname, attribute), sync_set_name,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy,
"p, \"%s\", \"%s\", %x")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, int, notify_sync_nameA,
(void *p, const char *objtype, int typelen, const char *objname,
int namelen, int attribute),
(ITT_FORMAT p, objtype, typelen, objname, namelen, attribute),
notify_sync_nameA,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy,
"%p, \"%s\", %d, \"%s\", %d, %x")
ITT_STUB(LIBITTAPI, int, notify_sync_nameW,
(void *p, const wchar_t *objtype, int typelen, const wchar_t *objname,
int namelen, int attribute),
(ITT_FORMAT p, objtype, typelen, objname, namelen, attribute),
notify_sync_nameW,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy,
"%p, \"%S\", %d, \"%S\", %d, %x")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, notify_sync_name,
(void *p, const char *objtype, int typelen, const char *objname,
int namelen, int attribute),
(ITT_FORMAT p, objtype, typelen, objname, namelen, attribute),
notify_sync_name,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy,
"%p, \"%s\", %d, \"%s\", %d, %x")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *p), (ITT_FORMAT p),
notify_sync_prepare,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *p), (ITT_FORMAT p),
notify_sync_cancel,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *p), (ITT_FORMAT p),
notify_sync_acquired,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *p), (ITT_FORMAT p),
notify_sync_releasing,
__itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
#endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size),
(ITT_FORMAT addr, size), memory_read, __itt_group_legacy, "%p, %lu")
ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size),
(ITT_FORMAT addr, size), memory_write, __itt_group_legacy, "%p, %lu")
ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size),
(ITT_FORMAT addr, size), memory_update, __itt_group_legacy, "%p, %lu")
ITT_STUB(LIBITTAPI, __itt_state_t, state_get, (void), (ITT_NO_PARAMS),
state_get, __itt_group_legacy, "no args")
ITT_STUB(LIBITTAPI, __itt_state_t, state_set, (__itt_state_t s), (ITT_FORMAT s),
state_set, __itt_group_legacy, "%d")
ITT_STUB(LIBITTAPI, __itt_obj_state_t, obj_mode_set,
(__itt_obj_prop_t p, __itt_obj_state_t s), (ITT_FORMAT p, s),
obj_mode_set, __itt_group_legacy, "%d, %d")
ITT_STUB(LIBITTAPI, __itt_thr_state_t, thr_mode_set,
(__itt_thr_prop_t p, __itt_thr_state_t s), (ITT_FORMAT p, s),
thr_mode_set, __itt_group_legacy, "%d, %d")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char *domain),
(ITT_FORMAT domain), frame_createA, __itt_group_frame, "\"%s\"")
ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain),
(ITT_FORMAT domain), frame_createW, __itt_group_frame, "\"%s\"")
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_frame, frame_create, (const char *domain), (ITT_FORMAT domain), frame_create, __itt_group_frame, "\"%s\"") ITT_STUB(ITTAPI, __itt_frame, frame_create, (const char *domain),
(ITT_FORMAT domain), frame_create, __itt_group_frame, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* __ITT_INTERNAL_BODY */ #endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame), (ITT_FORMAT frame), frame_begin, __itt_group_frame, "%p") ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame), (ITT_FORMAT frame),
ITT_STUBV(ITTAPI, void, frame_end, (__itt_frame frame), (ITT_FORMAT frame), frame_end, __itt_group_frame, "%p") frame_begin, __itt_group_frame, "%p")
ITT_STUBV(ITTAPI, void, frame_end, (__itt_frame frame), (ITT_FORMAT frame),
ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id), (ITT_FORMAT id), counter_destroy, __itt_group_counter, "%p") frame_end, __itt_group_frame, "%p")
ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id), (ITT_FORMAT id), counter_inc, __itt_group_counter, "%p")
ITT_STUBV(ITTAPI, void, counter_inc_delta, (__itt_counter id, unsigned long long value), (ITT_FORMAT id, value), counter_inc_delta, __itt_group_counter, "%p, %lu") ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id), (ITT_FORMAT id),
ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id), (ITT_FORMAT id), counter_dec, __itt_group_counter, "%p") counter_destroy, __itt_group_counter, "%p")
ITT_STUBV(ITTAPI, void, counter_dec_delta, (__itt_counter id, unsigned long long value), (ITT_FORMAT id, value), counter_dec_delta, __itt_group_counter, "%p, %lu") ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id), (ITT_FORMAT id),
ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr), (ITT_FORMAT id, value_ptr), counter_set_value, __itt_group_counter, "%p, %p") counter_inc, __itt_group_counter, "%p")
ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr), (ITT_FORMAT id, clock_domain, timestamp, value_ptr), counter_set_value_ex, __itt_group_counter, "%p, %p, %llu, %p") ITT_STUBV(ITTAPI, void, counter_inc_delta,
(__itt_counter id, unsigned long long value), (ITT_FORMAT id, value),
#ifndef __ITT_INTERNAL_BODY counter_inc_delta, __itt_group_counter, "%p, %lu")
#if ITT_PLATFORM==ITT_PLATFORM_WIN ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id), (ITT_FORMAT id),
ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name), (ITT_FORMAT name), mark_createA, __itt_group_mark, "\"%s\"") counter_dec, __itt_group_counter, "%p")
ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name), (ITT_FORMAT name), mark_createW, __itt_group_mark, "\"%S\"") ITT_STUBV(ITTAPI, void, counter_dec_delta,
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ (__itt_counter id, unsigned long long value), (ITT_FORMAT id, value),
ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name), (ITT_FORMAT name), mark_create, __itt_group_mark, "\"%s\"") counter_dec_delta, __itt_group_counter, "%p, %lu")
ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr),
(ITT_FORMAT id, value_ptr), counter_set_value, __itt_group_counter,
"%p, %p")
ITT_STUBV(ITTAPI, void, counter_set_value_ex,
(__itt_counter id, __itt_clock_domain *clock_domain,
unsigned long long timestamp, void *value_ptr),
(ITT_FORMAT id, clock_domain, timestamp, value_ptr),
counter_set_value_ex, __itt_group_counter, "%p, %p, %llu, %p")
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name),
(ITT_FORMAT name), mark_createA, __itt_group_mark, "\"%s\"")
ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name),
(ITT_FORMAT name), mark_createW, __itt_group_mark, "\"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name),
(ITT_FORMAT name), mark_create, __itt_group_mark, "\"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* __ITT_INTERNAL_BODY */
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter),
(ITT_FORMAT mt, parameter), markA, __itt_group_mark, "%d, \"%s\"")
ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter),
(ITT_FORMAT mt, parameter), markW, __itt_group_mark, "%d, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter),
(ITT_FORMAT mt, parameter), mark, __itt_group_mark, "%d, \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt), (ITT_FORMAT mt), mark_off,
__itt_group_mark, "%d")
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter),
(ITT_FORMAT mt, parameter), mark_globalA, __itt_group_mark,
"%d, \"%s\"")
ITT_STUB(ITTAPI, int, mark_globalW,
(__itt_mark_type mt, const wchar_t *parameter),
(ITT_FORMAT mt, parameter), mark_globalW, __itt_group_mark,
"%d, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter),
(ITT_FORMAT mt, parameter), mark_global, __itt_group_mark,
"%d, \"%S\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt), (ITT_FORMAT mt),
mark_global_off, __itt_group_mark, "%d")
#ifndef __ITT_INTERNAL_BODY
ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void), (ITT_NO_PARAMS),
stack_caller_create, __itt_group_stitch, "no args")
#endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id),
(ITT_FORMAT id), stack_caller_destroy, __itt_group_stitch, "%p")
ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id), (ITT_FORMAT id),
stack_callee_enter, __itt_group_stitch, "%p")
ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id), (ITT_FORMAT id),
stack_callee_leave, __itt_group_stitch, "%p")
ITT_STUB(ITTAPI, __itt_clock_domain *, clock_domain_create,
(__itt_get_clock_info_fn fn, void *fn_data), (ITT_FORMAT fn, fn_data),
clock_domain_create, __itt_group_structure, "%p, %p")
ITT_STUBV(ITTAPI, void, clock_domain_reset, (void), (ITT_NO_PARAMS),
clock_domain_reset, __itt_group_structure, "no args")
ITT_STUBV(ITTAPI, void, id_create_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id),
(ITT_FORMAT domain, clock_domain, timestamp, id), id_create_ex,
__itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, id_destroy_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id),
(ITT_FORMAT domain, clock_domain, timestamp, id), id_destroy_ex,
__itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, task_begin_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id, __itt_id parentid,
__itt_string_handle *name),
(ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name),
task_begin_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_begin_fn_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id, __itt_id parentid,
void *fn),
(ITT_FORMAT domain, clock_domain, timestamp, id, parentid, fn),
task_begin_fn_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_end_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp),
(ITT_FORMAT domain, clock_domain, timestamp), task_end_ex,
__itt_group_structure, "%p, %p, %lu")
ITT_STUBV(ITTAPI, void, task_begin_overlapped,
(const __itt_domain *domain, __itt_id id, __itt_id parent,
__itt_string_handle *name),
(ITT_FORMAT domain, id, parent, name), task_begin_overlapped,
__itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id, __itt_id parentid,
__itt_string_handle *name),
(ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name),
task_begin_overlapped_ex, __itt_group_structure,
"%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_end_overlapped,
(const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id),
task_end_overlapped, __itt_group_structure, "%p, %lu")
ITT_STUBV(ITTAPI, void, task_end_overlapped_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id),
(ITT_FORMAT domain, clock_domain, timestamp, id),
task_end_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, marker_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id id, __itt_string_handle *name,
__itt_scope scope),
(ITT_FORMAT domain, clock_domain, timestamp, id, name, scope),
marker_ex, __itt_group_structure, "%p, %p, %lu, %lu, %p, %d")
ITT_STUBV(ITTAPI, void, metadata_add_with_scope,
(const __itt_domain *domain, __itt_scope scope,
__itt_string_handle *key, __itt_metadata_type type, size_t count,
void *data),
(ITT_FORMAT domain, scope, key, type, count, data),
metadata_add_with_scope, __itt_group_structure,
"%p, %d, %p, %d, %lu, %p")
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA,
(const __itt_domain *domain, __itt_scope scope,
__itt_string_handle *key, const char *data, size_t length),
(ITT_FORMAT domain, scope, key, data, length),
metadata_str_add_with_scopeA, __itt_group_structure,
"%p, %d, %p, %p, %lu")
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW,
(const __itt_domain *domain, __itt_scope scope,
__itt_string_handle *key, const wchar_t *data, size_t length),
(ITT_FORMAT domain, scope, key, data, length),
metadata_str_add_with_scopeW, __itt_group_structure,
"%p, %d, %p, %p, %lu")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope,
(const __itt_domain *domain, __itt_scope scope,
__itt_string_handle *key, const char *data, size_t length),
(ITT_FORMAT domain, scope, key, data, length),
metadata_str_add_with_scope, __itt_group_structure,
"%p, %d, %p, %p, %lu")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, relation_add_to_current_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_relation relation,
__itt_id tail),
(ITT_FORMAT domain, clock_domain, timestamp, relation, tail),
relation_add_to_current_ex, __itt_group_structure,
"%p, %p, %lu, %d, %lu")
ITT_STUBV(ITTAPI, void, relation_add_ex,
(const __itt_domain *domain, __itt_clock_domain *clock_domain,
unsigned long long timestamp, __itt_id head, __itt_relation relation,
__itt_id tail),
(ITT_FORMAT domain, clock_domain, timestamp, head, relation, tail),
relation_add_ex, __itt_group_structure, "%p, %p, %lu, %lu, %d, %lu")
ITT_STUB(ITTAPI, __itt_track_group *, track_group_create,
(__itt_string_handle * name, __itt_track_group_type track_group_type),
(ITT_FORMAT name, track_group_type), track_group_create,
__itt_group_structure, "%p, %d")
ITT_STUB(ITTAPI, __itt_track *, track_create,
(__itt_track_group * track_group, __itt_string_handle *name,
__itt_track_type track_type),
(ITT_FORMAT track_group, name, track_type), track_create,
__itt_group_structure, "%p, %p, %d")
ITT_STUBV(ITTAPI, void, set_track, (__itt_track * track), (ITT_FORMAT track),
set_track, __itt_group_structure, "%p")
#ifndef __ITT_INTERNAL_BODY
ITT_STUB(ITTAPI, const char *, api_version, (void), (ITT_NO_PARAMS),
api_version, __itt_group_all & ~__itt_group_legacy, "no args")
#endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, av_saveA,
(void *data, int rank, const int *dimensions, int type,
const char *filePath, int columnOrder),
(ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder),
av_saveA, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
ITT_STUB(ITTAPI, int, av_saveW,
(void *data, int rank, const int *dimensions, int type,
const wchar_t *filePath, int columnOrder),
(ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder),
av_saveW, __itt_group_arrays, "%p, %d, %p, %d, \"%S\", %d")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, av_save,
(void *data, int rank, const int *dimensions, int type,
const char *filePath, int columnOrder),
(ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder),
av_save, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* __ITT_INTERNAL_BODY */ #endif /* __ITT_INTERNAL_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter), (ITT_FORMAT mt, parameter), markA, __itt_group_mark, "%d, \"%s\"")
ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter), (ITT_FORMAT mt, parameter), markW, __itt_group_mark, "%d, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter), (ITT_FORMAT mt, parameter), mark, __itt_group_mark, "%d, \"%s\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt), (ITT_FORMAT mt), mark_off, __itt_group_mark, "%d")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter), (ITT_FORMAT mt, parameter), mark_globalA, __itt_group_mark, "%d, \"%s\"")
ITT_STUB(ITTAPI, int, mark_globalW, (__itt_mark_type mt, const wchar_t *parameter), (ITT_FORMAT mt, parameter), mark_globalW, __itt_group_mark, "%d, \"%S\"")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter), (ITT_FORMAT mt, parameter), mark_global, __itt_group_mark, "%d, \"%S\"")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt), (ITT_FORMAT mt), mark_global_off, __itt_group_mark, "%d")
#ifndef __ITT_INTERNAL_BODY
ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void), (ITT_NO_PARAMS), stack_caller_create, __itt_group_stitch, "no args")
#endif /* __ITT_INTERNAL_BODY */
ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id), (ITT_FORMAT id), stack_caller_destroy, __itt_group_stitch, "%p")
ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id), (ITT_FORMAT id), stack_callee_enter, __itt_group_stitch, "%p")
ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id), (ITT_FORMAT id), stack_callee_leave, __itt_group_stitch, "%p")
ITT_STUB(ITTAPI, __itt_clock_domain*, clock_domain_create, (__itt_get_clock_info_fn fn, void* fn_data), (ITT_FORMAT fn, fn_data), clock_domain_create, __itt_group_structure, "%p, %p")
ITT_STUBV(ITTAPI, void, clock_domain_reset, (void), (ITT_NO_PARAMS), clock_domain_reset, __itt_group_structure, "no args")
ITT_STUBV(ITTAPI, void, id_create_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), id_create_ex, __itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, id_destroy_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), id_destroy_ex, __itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, task_begin_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name), task_begin_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_begin_fn_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, void* fn), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, fn), task_begin_fn_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_end_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp), (ITT_FORMAT domain, clock_domain, timestamp), task_end_ex, __itt_group_structure, "%p, %p, %lu")
ITT_STUBV(ITTAPI, void, task_begin_overlapped, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_begin_overlapped, __itt_group_structure, "%p, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name), task_begin_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
ITT_STUBV(ITTAPI, void, task_end_overlapped, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), task_end_overlapped, __itt_group_structure, "%p, %lu")
ITT_STUBV(ITTAPI, void, task_end_overlapped_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), task_end_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu")
ITT_STUBV(ITTAPI, void, marker_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, clock_domain, timestamp, id, name, scope), marker_ex, __itt_group_structure, "%p, %p, %lu, %lu, %p, %d")
ITT_STUBV(ITTAPI, void, metadata_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data), (ITT_FORMAT domain, scope, key, type, count, data), metadata_add_with_scope, __itt_group_structure, "%p, %d, %p, %d, %lu, %p")
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length), (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scopeA, __itt_group_structure, "%p, %d, %p, %p, %lu")
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length), (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scopeW, __itt_group_structure, "%p, %d, %p, %p, %lu")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length), (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scope, __itt_group_structure, "%p, %d, %p, %p, %lu")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, relation_add_to_current_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, clock_domain, timestamp, relation, tail), relation_add_to_current_ex, __itt_group_structure, "%p, %p, %lu, %d, %lu")
ITT_STUBV(ITTAPI, void, relation_add_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, clock_domain, timestamp, head, relation, tail), relation_add_ex, __itt_group_structure, "%p, %p, %lu, %lu, %d, %lu")
ITT_STUB(ITTAPI, __itt_track_group*, track_group_create, (__itt_string_handle* name, __itt_track_group_type track_group_type), (ITT_FORMAT name, track_group_type), track_group_create, __itt_group_structure, "%p, %d")
ITT_STUB(ITTAPI, __itt_track*, track_create, (__itt_track_group* track_group,__itt_string_handle* name, __itt_track_type track_type), (ITT_FORMAT track_group, name, track_type), track_create, __itt_group_structure, "%p, %p, %d")
ITT_STUBV(ITTAPI, void, set_track, (__itt_track *track), (ITT_FORMAT track), set_track, __itt_group_structure, "%p")
#ifndef __ITT_INTERNAL_BODY
ITT_STUB(ITTAPI, const char*, api_version, (void), (ITT_NO_PARAMS), api_version, __itt_group_all & ~__itt_group_legacy, "no args")
#endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY #ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, int, av_saveA, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_saveA, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d") ITT_STUBV(ITTAPI, void, module_loadA,
ITT_STUB(ITTAPI, int, av_saveW, (void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_saveW, __itt_group_arrays, "%p, %d, %p, %d, \"%S\", %d") (void *start_addr, void *end_addr, const char *path),
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ (ITT_FORMAT start_addr, end_addr, path), module_loadA,
ITT_STUB(ITTAPI, int, av_save, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_save, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d") __itt_group_none, "%p, %p, %p")
ITT_STUBV(ITTAPI, void, module_loadW,
(void *start_addr, void *end_addr, const wchar_t *path),
(ITT_FORMAT start_addr, end_addr, path), module_loadW,
__itt_group_none, "%p, %p, %p")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, module_load,
(void *start_addr, void *end_addr, const char *path),
(ITT_FORMAT start_addr, end_addr, path), module_load,
__itt_group_none, "%p, %p, %p")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* __ITT_INTERNAL_BODY */ #endif /* __ITT_INTERNAL_BODY */
#ifndef __ITT_INTERNAL_BODY
#if ITT_PLATFORM==ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, module_loadA, (void *start_addr, void* end_addr, const char *path), (ITT_FORMAT start_addr, end_addr, path), module_loadA, __itt_group_none, "%p, %p, %p")
ITT_STUBV(ITTAPI, void, module_loadW, (void *start_addr, void* end_addr, const wchar_t *path), (ITT_FORMAT start_addr, end_addr, path), module_loadW, __itt_group_none, "%p, %p, %p")
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, module_load, (void *start_addr, void *end_addr, const char *path), (ITT_FORMAT start_addr, end_addr, path), module_load, __itt_group_none, "%p, %p, %p")
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* __ITT_INTERNAL_BODY */
#endif /* __ITT_INTERNAL_INIT */ #endif /* __ITT_INTERNAL_INIT */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_static.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "kmp_config.h" #include "kmp_config.h"
#include "kmp_os.h" #include "kmp_os.h"
#include "ittnotify_config.h" #include "ittnotify_config.h"
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#if defined(__MINGW32__) #if defined(__MINGW32__)
#include <limits.h> #include <limits.h>
#else #else
#define PATH_MAX 512 #define PATH_MAX 512
#endif #endif
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
#include <limits.h> #include <limits.h>
#include <dlfcn.h> #include <dlfcn.h>
Show All 10 Lines
#include "legacy/ittnotify.h" #include "legacy/ittnotify.h"
#if KMP_MSVC_COMPAT #if KMP_MSVC_COMPAT
#include "disable_warnings.h" #include "disable_warnings.h"
#endif #endif
static const char api_version[] = API_VERSION "\0\n@(#) $Revision: 481659 $\n"; static const char api_version[] = API_VERSION "\0\n@(#) $Revision: 481659 $\n";
#define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n) #define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)
#if ITT_OS==ITT_OS_WIN #if ITT_OS == ITT_OS_WIN
static const char* ittnotify_lib_name = "libittnotify.dll"; static const char *ittnotify_lib_name = "libittnotify.dll";
#elif ITT_OS==ITT_OS_LINUX || ITT_OS==ITT_OS_FREEBSD #elif ITT_OS == ITT_OS_LINUX || ITT_OS == ITT_OS_FREEBSD
static const char* ittnotify_lib_name = "libittnotify.so"; static const char *ittnotify_lib_name = "libittnotify.so";
#elif ITT_OS==ITT_OS_MAC #elif ITT_OS == ITT_OS_MAC
static const char* ittnotify_lib_name = "libittnotify.dylib"; static const char *ittnotify_lib_name = "libittnotify.dylib";
#else #else
#error Unsupported or unknown OS. #error Unsupported or unknown OS.
#endif #endif
#ifdef __ANDROID__ #ifdef __ANDROID__
#include <android/log.h> #include <android/log.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <linux/limits.h> #include <linux/limits.h>
#ifdef ITT_ANDROID_LOG #ifdef ITT_ANDROID_LOG
#define ITT_ANDROID_LOG_TAG "INTEL_VTUNE_USERAPI" #define ITT_ANDROID_LOG_TAG "INTEL_VTUNE_USERAPI"
#define ITT_ANDROID_LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, ITT_ANDROID_LOG_TAG, __VA_ARGS__)) #define ITT_ANDROID_LOGI(...) \
#define ITT_ANDROID_LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, ITT_ANDROID_LOG_TAG, __VA_ARGS__)) ((void)__android_log_print(ANDROID_LOG_INFO, ITT_ANDROID_LOG_TAG, \
#define ITT_ANDROID_LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR,ITT_ANDROID_LOG_TAG, __VA_ARGS__)) __VA_ARGS__))
#define ITT_ANDROID_LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG,ITT_ANDROID_LOG_TAG, __VA_ARGS__)) #define ITT_ANDROID_LOGW(...) \
((void)__android_log_print(ANDROID_LOG_WARN, ITT_ANDROID_LOG_TAG, \
__VA_ARGS__))
#define ITT_ANDROID_LOGE(...) \
((void)__android_log_print(ANDROID_LOG_ERROR, ITT_ANDROID_LOG_TAG, \
__VA_ARGS__))
#define ITT_ANDROID_LOGD(...) \
((void)__android_log_print(ANDROID_LOG_DEBUG, ITT_ANDROID_LOG_TAG, \
__VA_ARGS__))
#else #else
#define ITT_ANDROID_LOGI(...) #define ITT_ANDROID_LOGI(...)
#define ITT_ANDROID_LOGW(...) #define ITT_ANDROID_LOGW(...)
#define ITT_ANDROID_LOGE(...) #define ITT_ANDROID_LOGE(...)
#define ITT_ANDROID_LOGD(...) #define ITT_ANDROID_LOGD(...)
#endif #endif
/* default location of userapi collector on Android */ /* default location of userapi collector on Android */
#define ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(x) "/data/data/com.intel.vtune/perfrun/lib" \ #define ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(x) \
#x "/runtime/libittnotify.so" "/data/data/com.intel.vtune/perfrun/lib" #x "/runtime/libittnotify.so"
#if ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_ARM #if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
#define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(32) #define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(32)
#else #else
#define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(64) #define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(64)
#endif #endif
#endif #endif
#ifndef PATH_MAX #ifndef PATH_MAX
#define PATH_MAX 4096 #define PATH_MAX 4096
#endif #endif
#ifndef LIB_VAR_NAME #ifndef LIB_VAR_NAME
#if ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_ARM || ITT_ARCH==ITT_ARCH_MIPS #if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM || \
ITT_ARCH == ITT_ARCH_MIPS
#define LIB_VAR_NAME INTEL_LIBITTNOTIFY32 #define LIB_VAR_NAME INTEL_LIBITTNOTIFY32
#else #else
#define LIB_VAR_NAME INTEL_LIBITTNOTIFY64 #define LIB_VAR_NAME INTEL_LIBITTNOTIFY64
#endif #endif
#endif /* LIB_VAR_NAME */ #endif /* LIB_VAR_NAME */
#define ITT_MUTEX_INIT_AND_LOCK(p) { \ #define ITT_MUTEX_INIT_AND_LOCK(p) \
if (PTHREAD_SYMBOLS) \
{ \
if (!p.mutex_initialized) \
{ \
if (__itt_interlocked_increment(&p.atomic_counter) == 1) \
{ \ { \
if (PTHREAD_SYMBOLS) { \
if (!p.mutex_initialized) { \
if (__itt_interlocked_increment(&p.atomic_counter) == 1) { \
__itt_mutex_init(&p.mutex); \ __itt_mutex_init(&p.mutex); \
p.mutex_initialized = 1; \ p.mutex_initialized = 1; \
} \ } else \
else \
while (!p.mutex_initialized) \ while (!p.mutex_initialized) \
__itt_thread_yield(); \ __itt_thread_yield(); \
} \ } \
__itt_mutex_lock(&p.mutex); \ __itt_mutex_lock(&p.mutex); \
} \ } \
} }
typedef int (__itt_init_ittlib_t)(const char*, __itt_group_id); typedef int(__itt_init_ittlib_t)(const char *, __itt_group_id);
/* this define used to control initialization function name. */ /* this define used to control initialization function name. */
#ifndef __itt_init_ittlib_name #ifndef __itt_init_ittlib_name
ITT_EXTERN_C int _N_(init_ittlib)(const char*, __itt_group_id); ITT_EXTERN_C int _N_(init_ittlib)(const char *, __itt_group_id);
static __itt_init_ittlib_t* __itt_init_ittlib_ptr = _N_(init_ittlib); static __itt_init_ittlib_t *__itt_init_ittlib_ptr = _N_(init_ittlib);
#define __itt_init_ittlib_name __itt_init_ittlib_ptr #define __itt_init_ittlib_name __itt_init_ittlib_ptr
#endif /* __itt_init_ittlib_name */ #endif /* __itt_init_ittlib_name */
typedef void (__itt_fini_ittlib_t)(void); typedef void(__itt_fini_ittlib_t)(void);
/* this define used to control finalization function name. */ /* this define used to control finalization function name. */
#ifndef __itt_fini_ittlib_name #ifndef __itt_fini_ittlib_name
ITT_EXTERN_C void _N_(fini_ittlib)(void); ITT_EXTERN_C void _N_(fini_ittlib)(void);
static __itt_fini_ittlib_t* __itt_fini_ittlib_ptr = _N_(fini_ittlib); static __itt_fini_ittlib_t *__itt_fini_ittlib_ptr = _N_(fini_ittlib);
#define __itt_fini_ittlib_name __itt_fini_ittlib_ptr #define __itt_fini_ittlib_name __itt_fini_ittlib_ptr
#endif /* __itt_fini_ittlib_name */ #endif /* __itt_fini_ittlib_name */
/* building pointers to imported funcs */ /* building pointers to imported funcs */
#undef ITT_STUBV #undef ITT_STUBV
#undef ITT_STUB #undef ITT_STUB
#define ITT_STUB(api,type,name,args,params,ptr,group,format) \ #define ITT_STUB(api, type, name, args, params, ptr, group, format) \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args;\ static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \
typedef type api ITT_JOIN(_N_(name),_t) args; \ typedef type api ITT_JOIN(_N_(name), _t) args; \
ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END \ ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args \ ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \
{ \ ITT_EXTERN_C_END \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args { \
__itt_init_ittlib_name(NULL, __itt_group_all); \ __itt_init_ittlib_name(NULL, __itt_group_all); \
if (ITTNOTIFY_NAME(name) && ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init))) \ if (ITTNOTIFY_NAME(name) && \
ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init))) \
return ITTNOTIFY_NAME(name) params; \ return ITTNOTIFY_NAME(name) params; \
else \ else \
return (type)0; \ return (type)0; \
} }
#define ITT_STUBV(api,type,name,args,params,ptr,group,format) \ #define ITT_STUBV(api, type, name, args, params, ptr, group, format) \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args;\ static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \
typedef type api ITT_JOIN(_N_(name),_t) args; \ typedef type api ITT_JOIN(_N_(name), _t) args; \
ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END \ ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args \ ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \
{ \ ITT_EXTERN_C_END \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args { \
__itt_init_ittlib_name(NULL, __itt_group_all); \ __itt_init_ittlib_name(NULL, __itt_group_all); \
if (ITTNOTIFY_NAME(name) && ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init))) \ if (ITTNOTIFY_NAME(name) && \
ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init))) \
ITTNOTIFY_NAME(name) params; \ ITTNOTIFY_NAME(name) params; \
else \ else \
return; \ return; \
} }
#undef __ITT_INTERNAL_INIT #undef __ITT_INTERNAL_INIT
#include "ittnotify_static.h" #include "ittnotify_static.h"
#undef ITT_STUB #undef ITT_STUB
#undef ITT_STUBV #undef ITT_STUBV
#define ITT_STUB(api,type,name,args,params,ptr,group,format) \ #define ITT_STUB(api, type, name, args, params, ptr, group, format) \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args;\ static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \
typedef type api ITT_JOIN(_N_(name),_t) args; \ typedef type api ITT_JOIN(_N_(name), _t) args; \
ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \
ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \
ITT_EXTERN_C_END
#define ITT_STUBV(api,type,name,args,params,ptr,group,format) \ #define ITT_STUBV(api, type, name, args, params, ptr, group, format) \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args;\ static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args; \
typedef type api ITT_JOIN(_N_(name),_t) args; \ typedef type api ITT_JOIN(_N_(name), _t) args; \
ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) = \
ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)); \
ITT_EXTERN_C_END
#define __ITT_INTERNAL_INIT #define __ITT_INTERNAL_INIT
#include "ittnotify_static.h" #include "ittnotify_static.h"
#undef __ITT_INTERNAL_INIT #undef __ITT_INTERNAL_INIT
ITT_GROUP_LIST(group_list); ITT_GROUP_LIST(group_list);
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_group_alias typedef struct ___itt_group_alias {
{
const char* env_var; const char *env_var;
__itt_group_id groups; __itt_group_id groups;
} __itt_group_alias; } __itt_group_alias;
static __itt_group_alias group_alias[] = { static __itt_group_alias group_alias[] = {
{ "KMP_FOR_TPROFILE", (__itt_group_id)(__itt_group_control | __itt_group_thread | __itt_group_sync | __itt_group_mark) }, {"KMP_FOR_TPROFILE",
{ "KMP_FOR_TCHECK", (__itt_group_id)(__itt_group_control | __itt_group_thread | __itt_group_sync | __itt_group_fsync | __itt_group_mark | __itt_group_suppress) }, (__itt_group_id)(__itt_group_control | __itt_group_thread |
__itt_group_sync | __itt_group_mark)},
{"KMP_FOR_TCHECK",
(__itt_group_id)(__itt_group_control | __itt_group_thread |
__itt_group_sync | __itt_group_fsync | __itt_group_mark |
__itt_group_suppress)},
{ NULL, (__itt_group_none) }, {NULL, (__itt_group_none)},
{ api_version, (__itt_group_none) } /* !!! Just to avoid unused code elimination !!! */ {api_version,
(__itt_group_none)} /* !!! Just to avoid unused code elimination !!! */
}; };
#pragma pack(pop) #pragma pack(pop)
// clang-format off
#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT #if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
#pragma warning(push) #pragma warning(push)
#pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function pointer 'XXX' to data pointer 'void *' */ #pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function
pointer 'XXX' to data pointer 'void *' */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
// clang-format onå
static __itt_api_info api_list[] = { static __itt_api_info api_list[] = {
/* Define functions with static implementation */ /* Define functions with static implementation */
#undef ITT_STUB #undef ITT_STUB
#undef ITT_STUBV #undef ITT_STUBV
#define ITT_STUB(api,type,name,args,params,nameindll,group,format) { ITT_TO_STR(ITT_JOIN(__itt_,nameindll)), (void**)(void*)&ITTNOTIFY_NAME(name), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), (__itt_group_id)(group)}, #define ITT_STUB(api, type, name, args, params, nameindll, group, format) \
{ITT_TO_STR(ITT_JOIN(__itt_, nameindll)), \
(void **)(void *)&ITTNOTIFY_NAME(name), \
(void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), \
(void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), \
(__itt_group_id)(group)},
#define ITT_STUBV ITT_STUB #define ITT_STUBV ITT_STUB
#define __ITT_INTERNAL_INIT #define __ITT_INTERNAL_INIT
#include "ittnotify_static.h" #include "ittnotify_static.h"
#undef __ITT_INTERNAL_INIT #undef __ITT_INTERNAL_INIT
/* Define functions without static implementation */ /* Define functions without static implementation */
#undef ITT_STUB #undef ITT_STUB
#undef ITT_STUBV #undef ITT_STUBV
#define ITT_STUB(api,type,name,args,params,nameindll,group,format) {ITT_TO_STR(ITT_JOIN(__itt_,nameindll)), (void**)(void*)&ITTNOTIFY_NAME(name), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), NULL, (__itt_group_id)(group)}, #define ITT_STUB(api, type, name, args, params, nameindll, group, format) \
{ITT_TO_STR(ITT_JOIN(__itt_, nameindll)), \
(void **)(void *)&ITTNOTIFY_NAME(name), \
(void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), NULL, \
(__itt_group_id)(group)},
#define ITT_STUBV ITT_STUB #define ITT_STUBV ITT_STUB
#include "ittnotify_static.h" #include "ittnotify_static.h"
{NULL, NULL, NULL, NULL, __itt_group_none} {NULL, NULL, NULL, NULL, __itt_group_none}};
};
#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT #if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
#pragma warning(pop) #pragma warning(pop)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/* static part descriptor which handles. all notification api attributes. */ /* static part descriptor which handles. all notification api attributes. */
__itt_global _N_(_ittapi_global) = { __itt_global _N_(_ittapi_global) = {
ITT_MAGIC, /* identification info */ ITT_MAGIC, /* identification info */
ITT_MAJOR, ITT_MINOR, API_VERSION_BUILD, /* version info */ ITT_MAJOR,
ITT_MINOR,
API_VERSION_BUILD, /* version info */
0, /* api_initialized */ 0, /* api_initialized */
0, /* mutex_initialized */ 0, /* mutex_initialized */
0, /* atomic_counter */ 0, /* atomic_counter */
MUTEX_INITIALIZER, /* mutex */ MUTEX_INITIALIZER, /* mutex */
NULL, /* dynamic library handle */ NULL, /* dynamic library handle */
NULL, /* error_handler */ NULL, /* error_handler */
NULL, /* dll_path_ptr */ NULL, /* dll_path_ptr */
(__itt_api_info*)&api_list, /* api_list_ptr */ (__itt_api_info *)&api_list, /* api_list_ptr */
NULL, /* next __itt_global */ NULL, /* next __itt_global */
NULL, /* thread_list */ NULL, /* thread_list */
NULL, /* domain_list */ NULL, /* domain_list */
NULL, /* string_list */ NULL, /* string_list */
__itt_collection_normal, /* collection state */ __itt_collection_normal, /* collection state */
NULL /* counter_list */ NULL /* counter_list */
}; };
typedef void (__itt_api_init_t)(__itt_global*, __itt_group_id); typedef void(__itt_api_init_t)(__itt_global *, __itt_group_id);
typedef void (__itt_api_fini_t)(__itt_global*); typedef void(__itt_api_fini_t)(__itt_global *);
/* ========================================================================= */ /* ========================================================================= */
#ifdef ITT_NOTIFY_EXT_REPORT #ifdef ITT_NOTIFY_EXT_REPORT
ITT_EXTERN_C void _N_(error_handler)(__itt_error_code, va_list args); ITT_EXTERN_C void _N_(error_handler)(__itt_error_code, va_list args);
#endif /* ITT_NOTIFY_EXT_REPORT */ #endif /* ITT_NOTIFY_EXT_REPORT */
// clang-format off
#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT #if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
#pragma warning(push) #pragma warning(push)
#pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer 'void *' to function pointer 'XXX' */ #pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer
'void *' to function pointer 'XXX' */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
// clang-format on
static void __itt_report_error(unsigned code_arg, ...) static void __itt_report_error(unsigned code_arg, ...) {
{
va_list args; va_list args;
va_start(args, code_arg); va_start(args, code_arg);
// We use unsigned for the code argument and explicitly cast it here to the // We use unsigned for the code argument and explicitly cast it here to the
// right enumerator because variadic functions are not compatible with // right enumerator because variadic functions are not compatible with
// default promotions. // default promotions.
__itt_error_code code = (__itt_error_code)code_arg; __itt_error_code code = (__itt_error_code)code_arg;
if (_N_(_ittapi_global).error_handler != NULL) if (_N_(_ittapi_global).error_handler != NULL) {
{ __itt_error_handler_t *handler =
__itt_error_handler_t* handler = (__itt_error_handler_t*)(size_t)_N_(_ittapi_global).error_handler; (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;
handler(code, args); handler(code, args);
} }
#ifdef ITT_NOTIFY_EXT_REPORT #ifdef ITT_NOTIFY_EXT_REPORT
_N_(error_handler)(code, args); _N_(error_handler)(code, args);
#endif /* ITT_NOTIFY_EXT_REPORT */ #endif /* ITT_NOTIFY_EXT_REPORT */
va_end(args); va_end(args);
} }
#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT #if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
#pragma warning(pop) #pragma warning(pop)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW),_init))(const wchar_t* name) static __itt_domain *ITTAPI
{ ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))(const wchar_t *name) {
__itt_domain *h_tail = NULL, *h = NULL; __itt_domain *h_tail = NULL, *h = NULL;
if (name == NULL) if (name == NULL) {
{
return NULL; return NULL;
} }
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{ if (ITTNOTIFY_NAME(domain_createW) &&
if (ITTNOTIFY_NAME(domain_createW) && ITTNOTIFY_NAME(domain_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW),_init))) ITTNOTIFY_NAME(domain_createW) !=
{ ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))) {
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(domain_createW)(name); return ITTNOTIFY_NAME(domain_createW)(name);
} }
} }
for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL; h_tail = h, h = h->next) for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;
{ h_tail = h, h = h->next) {
if (h->nameW != NULL && !wcscmp(h->nameW, name)) break; if (h->nameW != NULL && !wcscmp(h->nameW, name))
break;
} }
if (h == NULL) if (h == NULL) {
{
NEW_DOMAIN_W(&_N_(_ittapi_global),h,h_tail,name); NEW_DOMAIN_W(&_N_(_ittapi_global), h, h_tail, name);
} }
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return h; return h;
} }
static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),_init))(const char* name) static __itt_domain *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),
_init))(const char *name)
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),_init))(const char* name) static __itt_domain *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),
_init))(const char *name)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
{ {
__itt_domain *h_tail = NULL, *h = NULL; __itt_domain *h_tail = NULL, *h = NULL;
if (name == NULL) if (name == NULL) {
{
return NULL; return NULL;
} }
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
if (ITTNOTIFY_NAME(domain_createA) && ITTNOTIFY_NAME(domain_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),_init))) if (ITTNOTIFY_NAME(domain_createA) &&
{ ITTNOTIFY_NAME(domain_createA) !=
ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA), _init))) {
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(domain_createA)(name); return ITTNOTIFY_NAME(domain_createA)(name);
} }
#else #else
if (ITTNOTIFY_NAME(domain_create) && ITTNOTIFY_NAME(domain_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),_init))) if (ITTNOTIFY_NAME(domain_create) &&
{ ITTNOTIFY_NAME(domain_create) !=
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create), _init))) {
if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(domain_create)(name); return ITTNOTIFY_NAME(domain_create)(name);
} }
#endif #endif
} }
for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL; h_tail = h, h = h->next) for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;
{ h_tail = h, h = h->next) {
if (h->nameA != NULL && !__itt_fstrcmp(h->nameA, name)) break; if (h->nameA != NULL && !__itt_fstrcmp(h->nameA, name))
break;
} }
if (h == NULL) if (h == NULL) {
{
NEW_DOMAIN_A(&_N_(_ittapi_global),h,h_tail,name); NEW_DOMAIN_A(&_N_(_ittapi_global), h, h_tail, name);
} }
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return h; return h;
} }
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW),_init))(const wchar_t* name) static __itt_string_handle *ITTAPI ITT_VERSIONIZE(
{ ITT_JOIN(_N_(string_handle_createW), _init))(const wchar_t *name) {
__itt_string_handle *h_tail = NULL, *h = NULL; __itt_string_handle *h_tail = NULL, *h = NULL;
if (name == NULL) if (name == NULL) {
{
return NULL; return NULL;
} }
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{ if (ITTNOTIFY_NAME(string_handle_createW) &&
if (ITTNOTIFY_NAME(string_handle_createW) && ITTNOTIFY_NAME(string_handle_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW),_init))) ITTNOTIFY_NAME(string_handle_createW) !=
{ ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW), _init))) {
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(string_handle_createW)(name); return ITTNOTIFY_NAME(string_handle_createW)(name);
} }
} }
for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL; h_tail = h, h = h->next) for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;
{ h_tail = h, h = h->next) {
if (h->strW != NULL && !wcscmp(h->strW, name)) break; if (h->strW != NULL && !wcscmp(h->strW, name))
break;
} }
if (h == NULL) if (h == NULL) {
{
NEW_STRING_HANDLE_W(&_N_(_ittapi_global),h,h_tail,name); NEW_STRING_HANDLE_W(&_N_(_ittapi_global), h, h_tail, name);
} }
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return h; return h;
} }
static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA),_init))(const char* name) static __itt_string_handle *ITTAPI
ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA), _init))(const char *name)
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create),_init))(const char* name) static __itt_string_handle *ITTAPI
ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))(const char *name)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
{ {
__itt_string_handle *h_tail = NULL, *h = NULL; __itt_string_handle *h_tail = NULL, *h = NULL;
if (name == NULL) if (name == NULL) {
{
return NULL; return NULL;
} }
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
if (ITTNOTIFY_NAME(string_handle_createA) && ITTNOTIFY_NAME(string_handle_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA),_init))) if (ITTNOTIFY_NAME(string_handle_createA) &&
{ ITTNOTIFY_NAME(string_handle_createA) !=
ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA), _init))) {
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(string_handle_createA)(name); return ITTNOTIFY_NAME(string_handle_createA)(name);
} }
#else #else
if (ITTNOTIFY_NAME(string_handle_create) && ITTNOTIFY_NAME(string_handle_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create),_init))) if (ITTNOTIFY_NAME(string_handle_create) &&
{ ITTNOTIFY_NAME(string_handle_create) !=
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))) {
if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(string_handle_create)(name); return ITTNOTIFY_NAME(string_handle_create)(name);
} }
#endif #endif
} }
for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL; h_tail = h, h = h->next) for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;
{ h_tail = h, h = h->next) {
if (h->strA != NULL && !__itt_fstrcmp(h->strA, name)) break; if (h->strA != NULL && !__itt_fstrcmp(h->strA, name))
break;
} }
if (h == NULL) if (h == NULL) {
{
NEW_STRING_HANDLE_A(&_N_(_ittapi_global),h,h_tail,name); NEW_STRING_HANDLE_A(&_N_(_ittapi_global), h, h_tail, name);
} }
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return h; return h;
} }
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW),_init))(const wchar_t *name, const wchar_t *domain) static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
{ _N_(counter_createW), _init))(const wchar_t *name, const wchar_t *domain) {
__itt_counter_info_t *h_tail = NULL, *h = NULL; __itt_counter_info_t *h_tail = NULL, *h = NULL;
__itt_metadata_type type = __itt_metadata_u64; __itt_metadata_type type = __itt_metadata_u64;
if (name == NULL) if (name == NULL) {
{
return NULL; return NULL;
} }
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{ if (ITTNOTIFY_NAME(counter_createW) &&
if (ITTNOTIFY_NAME(counter_createW) && ITTNOTIFY_NAME(counter_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW),_init))) ITTNOTIFY_NAME(counter_createW) !=
{ ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW), _init))) {
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(counter_createW)(name, domain); return ITTNOTIFY_NAME(counter_createW)(name, domain);
} }
} }
for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next) for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
{ h_tail = h, h = h->next) {
if (h->nameW != NULL && h->type == type && !wcscmp(h->nameW, name) && ((h->domainW == NULL && domain == NULL) || if (h->nameW != NULL && h->type == type && !wcscmp(h->nameW, name) &&
(h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain)))) break; ((h->domainW == NULL && domain == NULL) ||
(h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))
break;
} }
if (h == NULL) if (h == NULL) {
{
NEW_COUNTER_W(&_N_(_ittapi_global),h,h_tail,name,domain,type); NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);
} }
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return (__itt_counter)h; return (__itt_counter)h;
} }
static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),_init))(const char *name, const char *domain) static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),
_init))(const char *name,
const char *domain)
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),_init))(const char *name, const char *domain) static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),
_init))(const char *name,
const char *domain)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
{ {
__itt_counter_info_t *h_tail = NULL, *h = NULL; __itt_counter_info_t *h_tail = NULL, *h = NULL;
__itt_metadata_type type = __itt_metadata_u64; __itt_metadata_type type = __itt_metadata_u64;
if (name == NULL) if (name == NULL) {
{
return NULL; return NULL;
} }
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
if (ITTNOTIFY_NAME(counter_createA) && ITTNOTIFY_NAME(counter_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),_init))) if (ITTNOTIFY_NAME(counter_createA) &&
{ ITTNOTIFY_NAME(counter_createA) !=
ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA), _init))) {
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(counter_createA)(name, domain); return ITTNOTIFY_NAME(counter_createA)(name, domain);
} }
#else #else
if (ITTNOTIFY_NAME(counter_create) && ITTNOTIFY_NAME(counter_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),_init))) if (ITTNOTIFY_NAME(counter_create) &&
{ ITTNOTIFY_NAME(counter_create) !=
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create), _init))) {
if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(counter_create)(name, domain); return ITTNOTIFY_NAME(counter_create)(name, domain);
} }
#endif #endif
} }
for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next) for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
{ h_tail = h, h = h->next) {
if (h->nameA != NULL && h->type == type && !__itt_fstrcmp(h->nameA, name) && ((h->domainA == NULL && domain == NULL) || if (h->nameA != NULL && h->type == type && !__itt_fstrcmp(h->nameA, name) &&
(h->domainA != NULL && domain != NULL && !__itt_fstrcmp(h->domainA, domain)))) break; ((h->domainA == NULL && domain == NULL) ||
(h->domainA != NULL && domain != NULL &&
!__itt_fstrcmp(h->domainA, domain))))
break;
} }
if (h == NULL) if (h == NULL) {
{
NEW_COUNTER_A(&_N_(_ittapi_global),h,h_tail,name,domain,type); NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);
} }
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return (__itt_counter)h; return (__itt_counter)h;
} }
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),_init))(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type) static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),
{ _init))(
const wchar_t *name, const wchar_t *domain, __itt_metadata_type type) {
__itt_counter_info_t *h_tail = NULL, *h = NULL; __itt_counter_info_t *h_tail = NULL, *h = NULL;
if (name == NULL) if (name == NULL) {
{
return NULL; return NULL;
} }
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{ if (ITTNOTIFY_NAME(counter_create_typedW) &&
if (ITTNOTIFY_NAME(counter_create_typedW) && ITTNOTIFY_NAME(counter_create_typedW) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),_init))) ITTNOTIFY_NAME(counter_create_typedW) !=
{ ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW), _init))) {
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(counter_create_typedW)(name, domain, type); return ITTNOTIFY_NAME(counter_create_typedW)(name, domain, type);
} }
} }
for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next) for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
{ h_tail = h, h = h->next) {
if (h->nameW != NULL && h->type == type && !wcscmp(h->nameW, name) && ((h->domainW == NULL && domain == NULL) || if (h->nameW != NULL && h->type == type && !wcscmp(h->nameW, name) &&
(h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain)))) break; ((h->domainW == NULL && domain == NULL) ||
(h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))
break;
} }
if (h == NULL) if (h == NULL) {
{
NEW_COUNTER_W(&_N_(_ittapi_global),h,h_tail,name,domain,type); NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);
} }
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return (__itt_counter)h; return (__itt_counter)h;
} }
static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA),_init))(const char *name, const char *domain, __itt_metadata_type type) static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
_N_(counter_create_typedA), _init))(const char *name, const char *domain,
__itt_metadata_type type)
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed),_init))(const char *name, const char *domain, __itt_metadata_type type) static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
_N_(counter_create_typed), _init))(const char *name, const char *domain,
__itt_metadata_type type)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
{ {
__itt_counter_info_t *h_tail = NULL, *h = NULL; __itt_counter_info_t *h_tail = NULL, *h = NULL;
if (name == NULL) if (name == NULL) {
{
return NULL; return NULL;
} }
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
if (ITTNOTIFY_NAME(counter_create_typedA) && ITTNOTIFY_NAME(counter_create_typedA) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA),_init))) if (ITTNOTIFY_NAME(counter_create_typedA) &&
{ ITTNOTIFY_NAME(counter_create_typedA) !=
ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA), _init))) {
__itt_mutex_unlock(&_N_(_ittapi_global).mutex); __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(counter_create_typedA)(name, domain, type); return ITTNOTIFY_NAME(counter_create_typedA)(name, domain, type);
} }
#else #else
if (ITTNOTIFY_NAME(counter_create_typed) && ITTNOTIFY_NAME(counter_create_typed) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed),_init))) if (ITTNOTIFY_NAME(counter_create_typed) &&
{ ITTNOTIFY_NAME(counter_create_typed) !=
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed), _init))) {
if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return ITTNOTIFY_NAME(counter_create_typed)(name, domain, type); return ITTNOTIFY_NAME(counter_create_typed)(name, domain, type);
} }
#endif #endif
} }
for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next) for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
{ h_tail = h, h = h->next) {
if (h->nameA != NULL && h->type == type && !__itt_fstrcmp(h->nameA, name) && ((h->domainA == NULL && domain == NULL) || if (h->nameA != NULL && h->type == type && !__itt_fstrcmp(h->nameA, name) &&
(h->domainA != NULL && domain != NULL && !__itt_fstrcmp(h->domainA, domain)))) break; ((h->domainA == NULL && domain == NULL) ||
(h->domainA != NULL && domain != NULL &&
!__itt_fstrcmp(h->domainA, domain))))
break;
} }
if (h == NULL) if (h == NULL) {
{
NEW_COUNTER_A(&_N_(_ittapi_global),h,h_tail,name,domain,type); NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);
} }
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
return (__itt_counter)h; return (__itt_counter)h;
} }
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(pause),_init))(void) static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))(void) {
{ if (!_N_(_ittapi_global).api_initialized &&
if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) _N_(_ittapi_global).thread_list == NULL) {
{
__itt_init_ittlib_name(NULL, __itt_group_all); __itt_init_ittlib_name(NULL, __itt_group_all);
} }
if (ITTNOTIFY_NAME(pause) && ITTNOTIFY_NAME(pause) != ITT_VERSIONIZE(ITT_JOIN(_N_(pause),_init))) if (ITTNOTIFY_NAME(pause) &&
{ ITTNOTIFY_NAME(pause) != ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))) {
ITTNOTIFY_NAME(pause)(); ITTNOTIFY_NAME(pause)();
} } else {
else
{
_N_(_ittapi_global).state = __itt_collection_paused; _N_(_ittapi_global).state = __itt_collection_paused;
} }
} }
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(resume),_init))(void) static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(resume), _init))(void) {
{ if (!_N_(_ittapi_global).api_initialized &&
if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) _N_(_ittapi_global).thread_list == NULL) {
{
__itt_init_ittlib_name(NULL, __itt_group_all); __itt_init_ittlib_name(NULL, __itt_group_all);
} }
if (ITTNOTIFY_NAME(resume) && ITTNOTIFY_NAME(resume) != ITT_VERSIONIZE(ITT_JOIN(_N_(resume),_init))) if (ITTNOTIFY_NAME(resume) &&
{ ITTNOTIFY_NAME(resume) != ITT_VERSIONIZE(ITT_JOIN(_N_(resume), _init))) {
ITTNOTIFY_NAME(resume)(); ITTNOTIFY_NAME(resume)();
} } else {
else
{
_N_(_ittapi_global).state = __itt_collection_normal; _N_(_ittapi_global).state = __itt_collection_normal;
} }
} }
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init))(const wchar_t* name) static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),
{ _init))(const wchar_t *name) {
if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) if (!_N_(_ittapi_global).api_initialized &&
{ _N_(_ittapi_global).thread_list == NULL) {
__itt_init_ittlib_name(NULL, __itt_group_all); __itt_init_ittlib_name(NULL, __itt_group_all);
} }
if (ITTNOTIFY_NAME(thread_set_nameW) && ITTNOTIFY_NAME(thread_set_nameW) != ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init))) if (ITTNOTIFY_NAME(thread_set_nameW) &&
{ ITTNOTIFY_NAME(thread_set_nameW) !=
ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW), _init))) {
ITTNOTIFY_NAME(thread_set_nameW)(name); ITTNOTIFY_NAME(thread_set_nameW)(name);
} }
} }
static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setW),_init))(const wchar_t* name, int namelen) static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setW),
{ _init))(const wchar_t *name,
int namelen) {
(void)namelen; (void)namelen;
ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init))(name); ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW), _init))(name);
return 0; return 0;
} }
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init))(const char* name) static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),
_init))(const char *name)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),_init))(const char* name) static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),
_init))(const char *name)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
{ {
if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) if (!_N_(_ittapi_global).api_initialized &&
{ _N_(_ittapi_global).thread_list == NULL) {
__itt_init_ittlib_name(NULL, __itt_group_all); __itt_init_ittlib_name(NULL, __itt_group_all);
} }
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
if (ITTNOTIFY_NAME(thread_set_nameA) && ITTNOTIFY_NAME(thread_set_nameA) != ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init))) if (ITTNOTIFY_NAME(thread_set_nameA) &&
{ ITTNOTIFY_NAME(thread_set_nameA) !=
ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA), _init))) {
ITTNOTIFY_NAME(thread_set_nameA)(name); ITTNOTIFY_NAME(thread_set_nameA)(name);
} }
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
if (ITTNOTIFY_NAME(thread_set_name) && ITTNOTIFY_NAME(thread_set_name) != ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),_init))) if (ITTNOTIFY_NAME(thread_set_name) &&
{ ITTNOTIFY_NAME(thread_set_name) !=
ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name), _init))) {
ITTNOTIFY_NAME(thread_set_name)(name); ITTNOTIFY_NAME(thread_set_name)(name);
} }
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
} }
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setA),_init))(const char* name, int namelen) static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setA),
{ _init))(const char *name,
int namelen) {
(void)namelen; (void)namelen;
ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init))(name); ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA), _init))(name);
return 0; return 0;
} }
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_set),_init))(const char* name, int namelen) static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_set),
{ _init))(const char *name,
int namelen) {
(void)namelen; (void)namelen;
ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),_init))(name); ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name), _init))(name);
return 0; return 0;
} }
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore),_init))(void) static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))(void) {
{ if (!_N_(_ittapi_global).api_initialized &&
if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) _N_(_ittapi_global).thread_list == NULL) {
{
__itt_init_ittlib_name(NULL, __itt_group_all); __itt_init_ittlib_name(NULL, __itt_group_all);
} }
if (ITTNOTIFY_NAME(thread_ignore) && ITTNOTIFY_NAME(thread_ignore) != ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore),_init))) if (ITTNOTIFY_NAME(thread_ignore) &&
{ ITTNOTIFY_NAME(thread_ignore) !=
ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))) {
ITTNOTIFY_NAME(thread_ignore)(); ITTNOTIFY_NAME(thread_ignore)();
} }
} }
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_ignore),_init))(void) static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_ignore), _init))(void) {
{
ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore),_init))(); ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))();
} }
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(enable_attach),_init))(void) static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(enable_attach), _init))(void) {
{
#ifdef __ANDROID__ #ifdef __ANDROID__
/* /*
* if LIB_VAR_NAME env variable were set before then stay previous value * if LIB_VAR_NAME env variable were set before then stay previous value
* else set default path * else set default path
*/ */
setenv(ITT_TO_STR(LIB_VAR_NAME), ANDROID_ITTNOTIFY_DEFAULT_PATH, 0); setenv(ITT_TO_STR(LIB_VAR_NAME), ANDROID_ITTNOTIFY_DEFAULT_PATH, 0);
#endif #endif
} }
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
static const char* __itt_fsplit(const char* s, const char* sep, const char** out, int* len) static const char *__itt_fsplit(const char *s, const char *sep,
{ const char **out, int *len) {
int i; int i;
int j; int j;
if (!s || !sep || !out || !len) if (!s || !sep || !out || !len)
return NULL; return NULL;
for (i = 0; s[i]; i++) for (i = 0; s[i]; i++) {
{
int b = 0; int b = 0;
for (j = 0; sep[j]; j++) for (j = 0; sep[j]; j++)
if (s[i] == sep[j]) if (s[i] == sep[j]) {
{
b = 1; b = 1;
break; break;
} }
if (!b) if (!b)
break; break;
} }
if (!s[i]) if (!s[i])
return NULL; return NULL;
*len = 0; *len = 0;
*out = &s[i]; *out = &s[i];
for (; s[i]; i++, (*len)++) for (; s[i]; i++, (*len)++) {
{
int b = 0; int b = 0;
for (j = 0; sep[j]; j++) for (j = 0; sep[j]; j++)
if (s[i] == sep[j]) if (s[i] == sep[j]) {
{
b = 1; b = 1;
break; break;
} }
if (b) if (b)
break; break;
} }
for (; s[i]; i++) for (; s[i]; i++) {
{
int b = 0; int b = 0;
for (j = 0; sep[j]; j++) for (j = 0; sep[j]; j++)
if (s[i] == sep[j]) if (s[i] == sep[j]) {
{
b = 1; b = 1;
break; break;
} }
if (!b) if (!b)
break; break;
} }
return &s[i]; return &s[i];
} }
/* This function return value of env variable that placed into static buffer. /* This function return value of env variable that placed into static buffer.
* !!! The same static buffer is used for subsequent calls. !!! * !!! The same static buffer is used for subsequent calls. !!!
* This was done to avoid dynamic allocation for few calls. * This was done to avoid dynamic allocation for few calls.
* Actually we need this function only four times. * Actually we need this function only four times.
*/ */
static const char* __itt_get_env_var(const char* name) static const char *__itt_get_env_var(const char *name) {
{
#define MAX_ENV_VALUE_SIZE 4086 #define MAX_ENV_VALUE_SIZE 4086
static char env_buff[MAX_ENV_VALUE_SIZE]; static char env_buff[MAX_ENV_VALUE_SIZE];
static char* env_value = (char*)env_buff; static char *env_value = (char *)env_buff;
if (name != NULL) if (name != NULL) {
{
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff); size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);
DWORD rc = GetEnvironmentVariableA(name, env_value, (DWORD)max_len); DWORD rc = GetEnvironmentVariableA(name, env_value, (DWORD)max_len);
if (rc >= max_len) if (rc >= max_len)
__itt_report_error(__itt_error_env_too_long, name, (size_t)rc - 1, (size_t)(max_len - 1)); __itt_report_error(__itt_error_env_too_long, name, (size_t)rc - 1,
else if (rc > 0) (size_t)(max_len - 1));
{ else if (rc > 0) {
const char* ret = (const char*)env_value; const char *ret = (const char *)env_value;
env_value += rc + 1; env_value += rc + 1;
return ret; return ret;
} } else {
else
{
/* If environment variable is empty, GetEnvironmentVariables() /* If environment variable is empty, GetEnvironmentVariables()
* returns zero (number of characters (not including terminating null), * returns zero (number of characters (not including terminating null),
* and GetLastError() returns ERROR_SUCCESS. */ * and GetLastError() returns ERROR_SUCCESS. */
DWORD err = GetLastError(); DWORD err = GetLastError();
if (err == ERROR_SUCCESS) if (err == ERROR_SUCCESS)
return env_value; return env_value;
if (err != ERROR_ENVVAR_NOT_FOUND) if (err != ERROR_ENVVAR_NOT_FOUND)
__itt_report_error(__itt_error_cant_read_env, name, (int)err); __itt_report_error(__itt_error_cant_read_env, name, (int)err);
} }
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
char* env = getenv(name); char *env = getenv(name);
if (env != NULL) if (env != NULL) {
{
size_t len = __itt_fstrnlen(env, MAX_ENV_VALUE_SIZE); size_t len = __itt_fstrnlen(env, MAX_ENV_VALUE_SIZE);
size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff); size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);
if (len < max_len) if (len < max_len) {
{
const char* ret = (const char*)env_value; const char *ret = (const char *)env_value;
__itt_fstrcpyn(env_value, max_len, env, len + 1); __itt_fstrcpyn(env_value, max_len, env, len + 1);
env_value += len + 1; env_value += len + 1;
return ret; return ret;
} else } else
__itt_report_error(__itt_error_env_too_long, name, (size_t)len, (size_t)(max_len - 1)); __itt_report_error(__itt_error_env_too_long, name, (size_t)len,
(size_t)(max_len - 1));
} }
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
} }
return NULL; return NULL;
} }
static const char* __itt_get_lib_name(void) static const char *__itt_get_lib_name(void) {
{
const char* lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME)); const char *lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));
#ifdef __ANDROID__ #ifdef __ANDROID__
if (lib_name == NULL) if (lib_name == NULL) {
{
#if ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_ARM #if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
const char* const marker_filename = "com.intel.itt.collector_lib_32"; const char *const marker_filename = "com.intel.itt.collector_lib_32";
#else #else
const char* const marker_filename = "com.intel.itt.collector_lib_64"; const char *const marker_filename = "com.intel.itt.collector_lib_64";
#endif #endif
char system_wide_marker_filename[PATH_MAX] = {0}; char system_wide_marker_filename[PATH_MAX] = {0};
int itt_marker_file_fd = -1; int itt_marker_file_fd = -1;
ssize_t res = 0; ssize_t res = 0;
res = snprintf(system_wide_marker_filename, PATH_MAX - 1, "%s%s", "/data/local/tmp/", marker_filename); res = snprintf(system_wide_marker_filename, PATH_MAX - 1, "%s%s",
if (res < 0) "/data/local/tmp/", marker_filename);
{ if (res < 0) {
ITT_ANDROID_LOGE("Unable to concatenate marker file string."); ITT_ANDROID_LOGE("Unable to concatenate marker file string.");
return lib_name; return lib_name;
} }
itt_marker_file_fd = open(system_wide_marker_filename, O_RDONLY); itt_marker_file_fd = open(system_wide_marker_filename, O_RDONLY);
if (itt_marker_file_fd == -1) if (itt_marker_file_fd == -1) {
{
const pid_t my_pid = getpid(); const pid_t my_pid = getpid();
char cmdline_path[PATH_MAX] = {0}; char cmdline_path[PATH_MAX] = {0};
char package_name[PATH_MAX] = {0}; char package_name[PATH_MAX] = {0};
char app_sandbox_file[PATH_MAX] = {0}; char app_sandbox_file[PATH_MAX] = {0};
int cmdline_fd = 0; int cmdline_fd = 0;
ITT_ANDROID_LOGI("Unable to open system-wide marker file."); ITT_ANDROID_LOGI("Unable to open system-wide marker file.");
res = snprintf(cmdline_path, PATH_MAX - 1, "/proc/%d/cmdline", my_pid); res = snprintf(cmdline_path, PATH_MAX - 1, "/proc/%d/cmdline", my_pid);
if (res < 0) if (res < 0) {
{
ITT_ANDROID_LOGE("Unable to get cmdline path string."); ITT_ANDROID_LOGE("Unable to get cmdline path string.");
return lib_name; return lib_name;
} }
ITT_ANDROID_LOGI("CMD file: %s\n", cmdline_path); ITT_ANDROID_LOGI("CMD file: %s\n", cmdline_path);
cmdline_fd = open(cmdline_path, O_RDONLY); cmdline_fd = open(cmdline_path, O_RDONLY);
if (cmdline_fd == -1) if (cmdline_fd == -1) {
{
ITT_ANDROID_LOGE("Unable to open %s file!", cmdline_path); ITT_ANDROID_LOGE("Unable to open %s file!", cmdline_path);
return lib_name; return lib_name;
} }
res = read(cmdline_fd, package_name, PATH_MAX - 1); res = read(cmdline_fd, package_name, PATH_MAX - 1);
if (res == -1) if (res == -1) {
{
ITT_ANDROID_LOGE("Unable to read %s file!", cmdline_path); ITT_ANDROID_LOGE("Unable to read %s file!", cmdline_path);
res = close(cmdline_fd); res = close(cmdline_fd);
if (res == -1) if (res == -1) {
{
ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path); ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);
} }
return lib_name; return lib_name;
} }
res = close(cmdline_fd); res = close(cmdline_fd);
if (res == -1) if (res == -1) {
{
ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path); ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);
return lib_name; return lib_name;
} }
ITT_ANDROID_LOGI("Package name: %s\n", package_name); ITT_ANDROID_LOGI("Package name: %s\n", package_name);
res = snprintf(app_sandbox_file, PATH_MAX - 1, "/data/data/%s/%s", package_name, marker_filename); res = snprintf(app_sandbox_file, PATH_MAX - 1, "/data/data/%s/%s",
if (res < 0) package_name, marker_filename);
{ if (res < 0) {
ITT_ANDROID_LOGE("Unable to concatenate marker file string."); ITT_ANDROID_LOGE("Unable to concatenate marker file string.");
return lib_name; return lib_name;
} }
ITT_ANDROID_LOGI("Lib marker file name: %s\n", app_sandbox_file); ITT_ANDROID_LOGI("Lib marker file name: %s\n", app_sandbox_file);
itt_marker_file_fd = open(app_sandbox_file, O_RDONLY); itt_marker_file_fd = open(app_sandbox_file, O_RDONLY);
if (itt_marker_file_fd == -1) if (itt_marker_file_fd == -1) {
{
ITT_ANDROID_LOGE("Unable to open app marker file!"); ITT_ANDROID_LOGE("Unable to open app marker file!");
return lib_name; return lib_name;
} }
} }
{ {
char itt_lib_name[PATH_MAX] = {0}; char itt_lib_name[PATH_MAX] = {0};
res = read(itt_marker_file_fd, itt_lib_name, PATH_MAX - 1); res = read(itt_marker_file_fd, itt_lib_name, PATH_MAX - 1);
if (res == -1) if (res == -1) {
{
ITT_ANDROID_LOGE("Unable to read %s file!", itt_marker_file_fd); ITT_ANDROID_LOGE("Unable to read %s file!", itt_marker_file_fd);
res = close(itt_marker_file_fd); res = close(itt_marker_file_fd);
if (res == -1) if (res == -1) {
{
ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd); ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);
} }
return lib_name; return lib_name;
} }
ITT_ANDROID_LOGI("ITT Lib path: %s", itt_lib_name); ITT_ANDROID_LOGI("ITT Lib path: %s", itt_lib_name);
res = close(itt_marker_file_fd); res = close(itt_marker_file_fd);
if (res == -1) if (res == -1) {
{
ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd); ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);
return lib_name; return lib_name;
} }
ITT_ANDROID_LOGI("Set env %s to %s", ITT_TO_STR(LIB_VAR_NAME), itt_lib_name); ITT_ANDROID_LOGI("Set env %s to %s", ITT_TO_STR(LIB_VAR_NAME),
itt_lib_name);
res = setenv(ITT_TO_STR(LIB_VAR_NAME), itt_lib_name, 0); res = setenv(ITT_TO_STR(LIB_VAR_NAME), itt_lib_name, 0);
if (res == -1) if (res == -1) {
{
ITT_ANDROID_LOGE("Unable to set env var!"); ITT_ANDROID_LOGE("Unable to set env var!");
return lib_name; return lib_name;
} }
lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME)); lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));
ITT_ANDROID_LOGI("ITT Lib path from env: %s", lib_name); ITT_ANDROID_LOGI("ITT Lib path from env: %s", lib_name);
} }
} }
#endif #endif
return lib_name; return lib_name;
} }
/* Avoid clashes with std::min, reported by tbb team */ /* Avoid clashes with std::min, reported by tbb team */
#define __itt_min(a,b) (a) < (b) ? (a) : (b) #define __itt_min(a, b) (a) < (b) ? (a) : (b)
static __itt_group_id __itt_get_groups(void) static __itt_group_id __itt_get_groups(void) {
{
int i; int i;
__itt_group_id res = __itt_group_none; __itt_group_id res = __itt_group_none;
const char* var_name = "INTEL_ITTNOTIFY_GROUPS"; const char *var_name = "INTEL_ITTNOTIFY_GROUPS";
const char* group_str = __itt_get_env_var(var_name); const char *group_str = __itt_get_env_var(var_name);
if (group_str != NULL) if (group_str != NULL) {
{
int len; int len;
char gr[255]; char gr[255];
const char* chunk; const char *chunk;
while ((group_str = __itt_fsplit(group_str, ",; ", &chunk, &len)) != NULL) while ((group_str = __itt_fsplit(group_str, ",; ", &chunk, &len)) != NULL) {
{
int min_len = __itt_min(len, (int)(sizeof(gr) - 1)); int min_len = __itt_min(len, (int)(sizeof(gr) - 1));
__itt_fstrcpyn(gr, sizeof(gr) - 1, chunk, min_len); __itt_fstrcpyn(gr, sizeof(gr) - 1, chunk, min_len);
gr[min_len] = 0; gr[min_len] = 0;
for (i = 0; group_list[i].name != NULL; i++) for (i = 0; group_list[i].name != NULL; i++) {
{ if (!__itt_fstrcmp(gr, group_list[i].name)) {
if (!__itt_fstrcmp(gr, group_list[i].name))
{
res = (__itt_group_id)(res | group_list[i].id); res = (__itt_group_id)(res | group_list[i].id);
break; break;
} }
} }
} }
/* TODO: !!! Workaround for bug with warning for unknown group !!! /* TODO: !!! Workaround for bug with warning for unknown group !!!
* Should be fixed in new initialization scheme. * Should be fixed in new initialization scheme.
* Now the following groups should be set always. */ * Now the following groups should be set always. */
for (i = 0; group_list[i].id != __itt_group_none; i++) for (i = 0; group_list[i].id != __itt_group_none; i++)
if (group_list[i].id != __itt_group_all && if (group_list[i].id != __itt_group_all &&
group_list[i].id > __itt_group_splitter_min && group_list[i].id > __itt_group_splitter_min &&
group_list[i].id < __itt_group_splitter_max) group_list[i].id < __itt_group_splitter_max)
res = (__itt_group_id)(res | group_list[i].id); res = (__itt_group_id)(res | group_list[i].id);
return res; return res;
} } else {
else
{
for (i = 0; group_alias[i].env_var != NULL; i++) for (i = 0; group_alias[i].env_var != NULL; i++)
if (__itt_get_env_var(group_alias[i].env_var) != NULL) if (__itt_get_env_var(group_alias[i].env_var) != NULL)
return group_alias[i].groups; return group_alias[i].groups;
} }
return res; return res;
} }
#undef __itt_min #undef __itt_min
static int __itt_lib_version(lib_t lib) static int __itt_lib_version(lib_t lib) {
{
if (lib == NULL) if (lib == NULL)
return 0; return 0;
if (__itt_get_proc(lib, "__itt_api_init")) if (__itt_get_proc(lib, "__itt_api_init"))
return 2; return 2;
if (__itt_get_proc(lib, "__itt_api_version")) if (__itt_get_proc(lib, "__itt_api_version"))
return 1; return 1;
return 0; return 0;
} }
/* It's not used right now! Comment it out to avoid warnings. /* It's not used right now! Comment it out to avoid warnings.
static void __itt_reinit_all_pointers(void) static void __itt_reinit_all_pointers(void)
{ {
int i; int i;
// Fill all pointers with initial stubs // Fill all pointers with initial stubs
for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
*_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].init_func; *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
_N_(_ittapi_global).api_list_ptr[i].init_func;
} }
*/ */
static void __itt_nullify_all_pointers(void) static void __itt_nullify_all_pointers(void) {
{
int i; int i;
/* Nullify all pointers except domain_create, string_handle_create and counter_create */ /* Nullify all pointers except domain_create, string_handle_create and
* counter_create */
for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
*_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func; *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
_N_(_ittapi_global).api_list_ptr[i].null_func;
} }
// clang-format off
#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT #if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
#pragma warning(push) #pragma warning(push)
#pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function pointer 'XXX' to data pointer 'void *' */ #pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function
#pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer 'void *' to function pointer 'XXX' */ pointer 'XXX' to data pointer 'void *' */
#pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer
'void *' to function pointer 'XXX' */
tianshilei1992AuthorUnsubmitted
Done
ReplyInline Actions

Here as well

tianshilei1992: Here as well
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
// clang-format on
ITT_EXTERN_C void _N_(fini_ittlib)(void) ITT_EXTERN_C void _N_(fini_ittlib)(void) {
{
__itt_api_fini_t* __itt_api_fini_ptr = NULL; __itt_api_fini_t *__itt_api_fini_ptr = NULL;
static volatile TIDT current_thread = 0; static volatile TIDT current_thread = 0;
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
if (_N_(_ittapi_global).api_initialized) if (_N_(_ittapi_global).api_initialized) {
{ if (current_thread == 0) {
if (current_thread == 0) if (PTHREAD_SYMBOLS)
{ current_thread = __itt_thread_id();
if (PTHREAD_SYMBOLS) current_thread = __itt_thread_id(); if (_N_(_ittapi_global).lib != NULL) {
if (_N_(_ittapi_global).lib != NULL) __itt_api_fini_ptr = (__itt_api_fini_t *)(size_t)__itt_get_proc(
{ _N_(_ittapi_global).lib, "__itt_api_fini");
__itt_api_fini_ptr = (__itt_api_fini_t*)(size_t)__itt_get_proc(_N_(_ittapi_global).lib, "__itt_api_fini");
} }
if (__itt_api_fini_ptr) if (__itt_api_fini_ptr) {
{
__itt_api_fini_ptr(&_N_(_ittapi_global)); __itt_api_fini_ptr(&_N_(_ittapi_global));
} }
__itt_nullify_all_pointers(); __itt_nullify_all_pointers();
/* TODO: !!! not safe !!! don't support unload so far. /* TODO: !!! not safe !!! don't support unload so far.
* if (_N_(_ittapi_global).lib != NULL) * if (_N_(_ittapi_global).lib != NULL)
* __itt_unload_lib(_N_(_ittapi_global).lib); * __itt_unload_lib(_N_(_ittapi_global).lib);
* _N_(_ittapi_global).lib = NULL; * _N_(_ittapi_global).lib = NULL;
*/ */
_N_(_ittapi_global).api_initialized = 0; _N_(_ittapi_global).api_initialized = 0;
current_thread = 0; current_thread = 0;
} }
} }
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
} }
} }
ITT_EXTERN_C int _N_(init_ittlib)(const char* lib_name, __itt_group_id init_groups) ITT_EXTERN_C int _N_(init_ittlib)(const char *lib_name,
{ __itt_group_id init_groups) {
int i; int i;
__itt_group_id groups; __itt_group_id groups;
#ifdef ITT_COMPLETE_GROUP #ifdef ITT_COMPLETE_GROUP
__itt_group_id zero_group = __itt_group_none; __itt_group_id zero_group = __itt_group_none;
#endif /* ITT_COMPLETE_GROUP */ #endif /* ITT_COMPLETE_GROUP */
static volatile TIDT current_thread = 0; static volatile TIDT current_thread = 0;
if (!_N_(_ittapi_global).api_initialized) if (!_N_(_ittapi_global).api_initialized) {
{
#ifndef ITT_SIMPLE_INIT #ifndef ITT_SIMPLE_INIT
ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global)); ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
#endif /* ITT_SIMPLE_INIT */ #endif /* ITT_SIMPLE_INIT */
if (!_N_(_ittapi_global).api_initialized) if (!_N_(_ittapi_global).api_initialized) {
{ if (current_thread == 0) {
if (current_thread == 0) if (PTHREAD_SYMBOLS)
{ current_thread = __itt_thread_id();
if (PTHREAD_SYMBOLS) current_thread = __itt_thread_id(); if (lib_name == NULL) {
if (lib_name == NULL)
{
lib_name = __itt_get_lib_name(); lib_name = __itt_get_lib_name();
} }
groups = __itt_get_groups(); groups = __itt_get_groups();
if (DL_SYMBOLS && (groups != __itt_group_none || lib_name != NULL)) if (DL_SYMBOLS && (groups != __itt_group_none || lib_name != NULL)) {
{ _N_(_ittapi_global).lib = __itt_load_lib(
_N_(_ittapi_global).lib = __itt_load_lib((lib_name == NULL) ? ittnotify_lib_name : lib_name); (lib_name == NULL) ? ittnotify_lib_name : lib_name);
if (_N_(_ittapi_global).lib != NULL) if (_N_(_ittapi_global).lib != NULL) {
{
__itt_api_init_t* __itt_api_init_ptr; __itt_api_init_t *__itt_api_init_ptr;
int lib_version = __itt_lib_version(_N_(_ittapi_global).lib); int lib_version = __itt_lib_version(_N_(_ittapi_global).lib);
switch (lib_version) { switch (lib_version) {
case 0: case 0:
groups = __itt_group_legacy; groups = __itt_group_legacy;
KMP_FALLTHROUGH(); KMP_FALLTHROUGH();
case 1: case 1:
/* Fill all pointers from dynamic library */ /* Fill all pointers from dynamic library */
for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL;
{ i++) {
if (_N_(_ittapi_global).api_list_ptr[i].group & groups & init_groups) if (_N_(_ittapi_global).api_list_ptr[i].group & groups &
{ init_groups) {
*_N_(_ittapi_global).api_list_ptr[i].func_ptr = (void*)__itt_get_proc(_N_(_ittapi_global).lib, _N_(_ittapi_global).api_list_ptr[i].name); *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr == NULL) (void *)__itt_get_proc(
{ _N_(_ittapi_global).lib,
/* Restore pointers for function with static implementation */ _N_(_ittapi_global).api_list_ptr[i].name);
*_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func; if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr == NULL) {
__itt_report_error(__itt_error_no_symbol, lib_name, _N_(_ittapi_global).api_list_ptr[i].name); /* Restore pointers for function with static implementation
*/
*_N_(_ittapi_global).api_list_ptr[i].func_ptr =
_N_(_ittapi_global).api_list_ptr[i].null_func;
__itt_report_error(
__itt_error_no_symbol, lib_name,
_N_(_ittapi_global).api_list_ptr[i].name);
#ifdef ITT_COMPLETE_GROUP #ifdef ITT_COMPLETE_GROUP
zero_group = (__itt_group_id)(zero_group | _N_(_ittapi_global).api_list_ptr[i].group); zero_group = (__itt_group_id)(
zero_group | _N_(_ittapi_global).api_list_ptr[i].group);
#endif /* ITT_COMPLETE_GROUP */ #endif /* ITT_COMPLETE_GROUP */
} }
} } else
else *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
*_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func; _N_(_ittapi_global).api_list_ptr[i].null_func;
} }
if (groups == __itt_group_legacy) if (groups == __itt_group_legacy) {
{
/* Compatibility with legacy tools */ /* Compatibility with legacy tools */
ITTNOTIFY_NAME(thread_ignore) = ITTNOTIFY_NAME(thr_ignore); ITTNOTIFY_NAME(thread_ignore) = ITTNOTIFY_NAME(thr_ignore);
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITTNOTIFY_NAME(sync_createA) = ITTNOTIFY_NAME(sync_set_nameA); ITTNOTIFY_NAME(sync_createA) = ITTNOTIFY_NAME(sync_set_nameA);
ITTNOTIFY_NAME(sync_createW) = ITTNOTIFY_NAME(sync_set_nameW); ITTNOTIFY_NAME(sync_createW) = ITTNOTIFY_NAME(sync_set_nameW);
#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
ITTNOTIFY_NAME(sync_create) = ITTNOTIFY_NAME(sync_set_name); ITTNOTIFY_NAME(sync_create) = ITTNOTIFY_NAME(sync_set_name);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITTNOTIFY_NAME(sync_prepare) = ITTNOTIFY_NAME(notify_sync_prepare); ITTNOTIFY_NAME(sync_prepare) =
ITTNOTIFY_NAME(sync_cancel) = ITTNOTIFY_NAME(notify_sync_cancel); ITTNOTIFY_NAME(notify_sync_prepare);
ITTNOTIFY_NAME(sync_acquired) = ITTNOTIFY_NAME(notify_sync_acquired); ITTNOTIFY_NAME(sync_cancel) =
ITTNOTIFY_NAME(sync_releasing) = ITTNOTIFY_NAME(notify_sync_releasing); ITTNOTIFY_NAME(notify_sync_cancel);
ITTNOTIFY_NAME(sync_acquired) =
ITTNOTIFY_NAME(notify_sync_acquired);
ITTNOTIFY_NAME(sync_releasing) =
ITTNOTIFY_NAME(notify_sync_releasing);
} }
#ifdef ITT_COMPLETE_GROUP #ifdef ITT_COMPLETE_GROUP
for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
if (_N_(_ittapi_global).api_list_ptr[i].group & zero_group) if (_N_(_ittapi_global).api_list_ptr[i].group & zero_group)
*_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func; *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
_N_(_ittapi_global).api_list_ptr[i].null_func;
#endif /* ITT_COMPLETE_GROUP */ #endif /* ITT_COMPLETE_GROUP */
break; break;
case 2: case 2:
__itt_api_init_ptr = (__itt_api_init_t*)(size_t)__itt_get_proc(_N_(_ittapi_global).lib, "__itt_api_init"); __itt_api_init_ptr = (__itt_api_init_t *)(size_t)__itt_get_proc(
_N_(_ittapi_global).lib, "__itt_api_init");
if (__itt_api_init_ptr) if (__itt_api_init_ptr)
__itt_api_init_ptr(&_N_(_ittapi_global), init_groups); __itt_api_init_ptr(&_N_(_ittapi_global), init_groups);
break; break;
} }
} } else {
else
{
__itt_nullify_all_pointers(); __itt_nullify_all_pointers();
__itt_report_error(__itt_error_no_module, lib_name, __itt_report_error(__itt_error_no_module, lib_name,
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_system_error() __itt_system_error()
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
dlerror() dlerror()
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
); );
} }
} } else {
else
{
__itt_nullify_all_pointers(); __itt_nullify_all_pointers();
} }
_N_(_ittapi_global).api_initialized = 1; _N_(_ittapi_global).api_initialized = 1;
current_thread = 0; current_thread = 0;
/* !!! Just to avoid unused code elimination !!! */ /* !!! Just to avoid unused code elimination !!! */
if (__itt_fini_ittlib_ptr == _N_(fini_ittlib)) current_thread = 0; if (__itt_fini_ittlib_ptr == _N_(fini_ittlib))
current_thread = 0;
} }
} }
#ifndef ITT_SIMPLE_INIT #ifndef ITT_SIMPLE_INIT
if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex); if (PTHREAD_SYMBOLS)
__itt_mutex_unlock(&_N_(_ittapi_global).mutex);
#endif /* ITT_SIMPLE_INIT */ #endif /* ITT_SIMPLE_INIT */
} }
/* Evaluating if any function ptr is non empty and it's in init_groups */ /* Evaluating if any function ptr is non empty and it's in init_groups */
for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) {
{ if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr !=
if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr != _N_(_ittapi_global).api_list_ptr[i].null_func && _N_(_ittapi_global).api_list_ptr[i].null_func &&
_N_(_ittapi_global).api_list_ptr[i].group & init_groups) _N_(_ittapi_global).api_list_ptr[i].group & init_groups) {
{
return 1; return 1;
} }
} }
return 0; return 0;
} }
ITT_EXTERN_C __itt_error_handler_t* _N_(set_error_handler)(__itt_error_handler_t* handler) ITT_EXTERN_C __itt_error_handler_t *
{ _N_(set_error_handler)(__itt_error_handler_t *handler) {
__itt_error_handler_t* prev = (__itt_error_handler_t*)(size_t)_N_(_ittapi_global).error_handler; __itt_error_handler_t *prev =
(__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;
_N_(_ittapi_global).error_handler = (void*)(size_t)handler; _N_(_ittapi_global).error_handler = (void *)(size_t)handler;
return prev; return prev;
} }
#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT #if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
#pragma warning(pop) #pragma warning(pop)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_types.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _ITTNOTIFY_TYPES_H_ #ifndef _ITTNOTIFY_TYPES_H_
#define _ITTNOTIFY_TYPES_H_ #define _ITTNOTIFY_TYPES_H_
typedef enum ___itt_group_id typedef enum ___itt_group_id {
{
__itt_group_none = 0, __itt_group_none = 0,
__itt_group_legacy = 1<<0, __itt_group_legacy = 1 << 0,
__itt_group_control = 1<<1, __itt_group_control = 1 << 1,
__itt_group_thread = 1<<2, __itt_group_thread = 1 << 2,
__itt_group_mark = 1<<3, __itt_group_mark = 1 << 3,
__itt_group_sync = 1<<4, __itt_group_sync = 1 << 4,
__itt_group_fsync = 1<<5, __itt_group_fsync = 1 << 5,
__itt_group_jit = 1<<6, __itt_group_jit = 1 << 6,
__itt_group_model = 1<<7, __itt_group_model = 1 << 7,
__itt_group_splitter_min = 1<<7, __itt_group_splitter_min = 1 << 7,
__itt_group_counter = 1<<8, __itt_group_counter = 1 << 8,
__itt_group_frame = 1<<9, __itt_group_frame = 1 << 9,
__itt_group_stitch = 1<<10, __itt_group_stitch = 1 << 10,
__itt_group_heap = 1<<11, __itt_group_heap = 1 << 11,
__itt_group_splitter_max = 1<<12, __itt_group_splitter_max = 1 << 12,
__itt_group_structure = 1<<12, __itt_group_structure = 1 << 12,
__itt_group_suppress = 1<<13, __itt_group_suppress = 1 << 13,
__itt_group_arrays = 1<<14, __itt_group_arrays = 1 << 14,
__itt_group_all = -1 __itt_group_all = -1
} __itt_group_id; } __itt_group_id;
#pragma pack(push, 8) #pragma pack(push, 8)
typedef struct ___itt_group_list typedef struct ___itt_group_list {
{
__itt_group_id id; __itt_group_id id;
const char* name; const char *name;
} __itt_group_list; } __itt_group_list;
#pragma pack(pop) #pragma pack(pop)
#define ITT_GROUP_LIST(varname) \ #define ITT_GROUP_LIST(varname) \
static __itt_group_list varname[] = { \ static __itt_group_list varname[] = {{__itt_group_all, "all"}, \
{ __itt_group_all, "all" }, \
{ __itt_group_control, "control" }, \ {__itt_group_control, "control"}, \
{ __itt_group_thread, "thread" }, \ {__itt_group_thread, "thread"}, \
{ __itt_group_mark, "mark" }, \ {__itt_group_mark, "mark"}, \
{ __itt_group_sync, "sync" }, \ {__itt_group_sync, "sync"}, \
{ __itt_group_fsync, "fsync" }, \ {__itt_group_fsync, "fsync"}, \
{ __itt_group_jit, "jit" }, \ {__itt_group_jit, "jit"}, \
{ __itt_group_model, "model" }, \ {__itt_group_model, "model"}, \
{ __itt_group_counter, "counter" }, \ {__itt_group_counter, "counter"}, \
{ __itt_group_frame, "frame" }, \ {__itt_group_frame, "frame"}, \
{ __itt_group_stitch, "stitch" }, \ {__itt_group_stitch, "stitch"}, \
{ __itt_group_heap, "heap" }, \ {__itt_group_heap, "heap"}, \
{ __itt_group_structure, "structure" }, \ {__itt_group_structure, "structure"}, \
{ __itt_group_suppress, "suppress" }, \ {__itt_group_suppress, "suppress"}, \
{ __itt_group_arrays, "arrays" }, \ {__itt_group_arrays, "arrays"}, \
{ __itt_group_none, NULL } \ {__itt_group_none, NULL}}
}
#endif /* _ITTNOTIFY_TYPES_H_ */ #endif /* _ITTNOTIFY_TYPES_H_ */

openmp/runtime/src/thirdparty/ittnotify/legacy/ittnotify.h

Show All 11 Lines
/** /**
* @file * @file
* @brief Legacy User API functions and types * @brief Legacy User API functions and types
*/ */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef ITT_OS_WIN #ifndef ITT_OS_WIN
# define ITT_OS_WIN 1 #define ITT_OS_WIN 1
#endif /* ITT_OS_WIN */ #endif /* ITT_OS_WIN */
#ifndef ITT_OS_LINUX #ifndef ITT_OS_LINUX
# define ITT_OS_LINUX 2 #define ITT_OS_LINUX 2
#endif /* ITT_OS_LINUX */ #endif /* ITT_OS_LINUX */
#ifndef ITT_OS_MAC #ifndef ITT_OS_MAC
# define ITT_OS_MAC 3 #define ITT_OS_MAC 3
#endif /* ITT_OS_MAC */ #endif /* ITT_OS_MAC */
#ifndef ITT_OS_FREEBSD #ifndef ITT_OS_FREEBSD
# define ITT_OS_FREEBSD 4 #define ITT_OS_FREEBSD 4
#endif /* ITT_OS_FREEBSD */ #endif /* ITT_OS_FREEBSD */
#ifndef ITT_OS #ifndef ITT_OS
# if defined WIN32 || defined _WIN32 #if defined WIN32 || defined _WIN32
# define ITT_OS ITT_OS_WIN #define ITT_OS ITT_OS_WIN
# elif defined( __APPLE__ ) && defined( __MACH__ ) #elif defined(__APPLE__) && defined(__MACH__)
# define ITT_OS ITT_OS_MAC #define ITT_OS ITT_OS_MAC
# elif defined( __FreeBSD__ ) #elif defined(__FreeBSD__)
# define ITT_OS ITT_OS_FREEBSD #define ITT_OS ITT_OS_FREEBSD
# else #else
# define ITT_OS ITT_OS_LINUX #define ITT_OS ITT_OS_LINUX
# endif #endif
#endif /* ITT_OS */ #endif /* ITT_OS */
#ifndef ITT_PLATFORM_WIN #ifndef ITT_PLATFORM_WIN
# define ITT_PLATFORM_WIN 1 #define ITT_PLATFORM_WIN 1
#endif /* ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM_WIN */
#ifndef ITT_PLATFORM_POSIX #ifndef ITT_PLATFORM_POSIX
# define ITT_PLATFORM_POSIX 2 #define ITT_PLATFORM_POSIX 2
#endif /* ITT_PLATFORM_POSIX */ #endif /* ITT_PLATFORM_POSIX */
#ifndef ITT_PLATFORM_MAC #ifndef ITT_PLATFORM_MAC
# define ITT_PLATFORM_MAC 3 #define ITT_PLATFORM_MAC 3
#endif /* ITT_PLATFORM_MAC */ #endif /* ITT_PLATFORM_MAC */
#ifndef ITT_PLATFORM_FREEBSD #ifndef ITT_PLATFORM_FREEBSD
# define ITT_PLATFORM_FREEBSD 4 #define ITT_PLATFORM_FREEBSD 4
#endif /* ITT_PLATFORM_FREEBSD */ #endif /* ITT_PLATFORM_FREEBSD */
#ifndef ITT_PLATFORM #ifndef ITT_PLATFORM
# if ITT_OS==ITT_OS_WIN #if ITT_OS == ITT_OS_WIN
# define ITT_PLATFORM ITT_PLATFORM_WIN #define ITT_PLATFORM ITT_PLATFORM_WIN
# elif ITT_OS==ITT_OS_MAC #elif ITT_OS == ITT_OS_MAC
# define ITT_PLATFORM ITT_PLATFORM_MAC #define ITT_PLATFORM ITT_PLATFORM_MAC
# elif ITT_OS==ITT_OS_FREEBSD #elif ITT_OS == ITT_OS_FREEBSD
# define ITT_PLATFORM ITT_PLATFORM_FREEBSD #define ITT_PLATFORM ITT_PLATFORM_FREEBSD
# else #else
# define ITT_PLATFORM ITT_PLATFORM_POSIX #define ITT_PLATFORM ITT_PLATFORM_POSIX
# endif #endif
#endif /* ITT_PLATFORM */ #endif /* ITT_PLATFORM */
#if defined(_UNICODE) && !defined(UNICODE) #if defined(_UNICODE) && !defined(UNICODE)
#define UNICODE #define UNICODE
#endif #endif
#include <stddef.h> #include <stddef.h>
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#include <tchar.h> #include <tchar.h>
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#include <stdint.h> #include <stdint.h>
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
#include <wchar.h> #include <wchar.h>
#endif /* UNICODE || _UNICODE */ #endif /* UNICODE || _UNICODE */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#ifndef ITTAPI_CDECL #ifndef ITTAPI_CDECL
# if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
# define ITTAPI_CDECL __cdecl #define ITTAPI_CDECL __cdecl
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__ #if defined _M_IX86 || defined __i386__
# define ITTAPI_CDECL __attribute__ ((cdecl)) #define ITTAPI_CDECL __attribute__((cdecl))
# else /* _M_IX86 || __i386__ */ #else /* _M_IX86 || __i386__ */
# define ITTAPI_CDECL /* actual only on x86 platform */ #define ITTAPI_CDECL /* actual only on x86 platform */
# endif /* _M_IX86 || __i386__ */ #endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* ITTAPI_CDECL */ #endif /* ITTAPI_CDECL */
#ifndef STDCALL #ifndef STDCALL
# if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
# define STDCALL __stdcall #define STDCALL __stdcall
# else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
# if defined _M_IX86 || defined __i386__ #if defined _M_IX86 || defined __i386__
# define STDCALL __attribute__ ((stdcall)) #define STDCALL __attribute__((stdcall))
# else /* _M_IX86 || __i386__ */ #else /* _M_IX86 || __i386__ */
# define STDCALL /* supported only on x86 platform */ #define STDCALL /* supported only on x86 platform */
# endif /* _M_IX86 || __i386__ */ #endif /* _M_IX86 || __i386__ */
# endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* STDCALL */ #endif /* STDCALL */
#define ITTAPI ITTAPI_CDECL #define ITTAPI ITTAPI_CDECL
#define LIBITTAPI ITTAPI_CDECL #define LIBITTAPI ITTAPI_CDECL
/* TODO: Temporary for compatibility! */ /* TODO: Temporary for compatibility! */
#define ITTAPI_CALL ITTAPI_CDECL #define ITTAPI_CALL ITTAPI_CDECL
#define LIBITTAPI_CALL ITTAPI_CDECL #define LIBITTAPI_CALL ITTAPI_CDECL
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
/* use __forceinline (VC++ specific) */ /* use __forceinline (VC++ specific) */
#define ITT_INLINE __forceinline #define ITT_INLINE __forceinline
#define ITT_INLINE_ATTRIBUTE /* nothing */ #define ITT_INLINE_ATTRIBUTE /* nothing */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/* /*
* Generally, functions are not inlined unless optimization is specified. * Generally, functions are not inlined unless optimization is specified.
* For functions declared inline, this attribute inlines the function even * For functions declared inline, this attribute inlines the function even
* if no optimization level was specified. * if no optimization level was specified.
*/ */
#ifdef __STRICT_ANSI__ #ifdef __STRICT_ANSI__
#define ITT_INLINE static #define ITT_INLINE static
#define ITT_INLINE_ATTRIBUTE __attribute__((unused)) #define ITT_INLINE_ATTRIBUTE __attribute__((unused))
#else /* __STRICT_ANSI__ */ #else /* __STRICT_ANSI__ */
#define ITT_INLINE static inline #define ITT_INLINE static inline
#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused)) #define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
#endif /* __STRICT_ANSI__ */ #endif /* __STRICT_ANSI__ */
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @endcond */ /** @endcond */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
/* Helper macro for joining tokens */ /* Helper macro for joining tokens */
#define ITT_JOIN_AUX(p,n) p##n #define ITT_JOIN_AUX(p, n) p##n
#define ITT_JOIN(p,n) ITT_JOIN_AUX(p,n) #define ITT_JOIN(p, n) ITT_JOIN_AUX(p, n)
#ifdef ITT_MAJOR #ifdef ITT_MAJOR
#undef ITT_MAJOR #undef ITT_MAJOR
#endif #endif
#ifdef ITT_MINOR #ifdef ITT_MINOR
#undef ITT_MINOR #undef ITT_MINOR
#endif #endif
#define ITT_MAJOR 3 #define ITT_MAJOR 3
#define ITT_MINOR 0 #define ITT_MINOR 0
/* Standard versioning of a token with major and minor version numbers */ /* Standard versioning of a token with major and minor version numbers */
#define ITT_VERSIONIZE(x) \ #define ITT_VERSIONIZE(x) \
ITT_JOIN(x, \ ITT_JOIN(x, ITT_JOIN(_, ITT_JOIN(ITT_MAJOR, ITT_JOIN(_, ITT_MINOR))))
ITT_JOIN(_, \
ITT_JOIN(ITT_MAJOR, \
ITT_JOIN(_, ITT_MINOR))))
#ifndef INTEL_ITTNOTIFY_PREFIX #ifndef INTEL_ITTNOTIFY_PREFIX
# define INTEL_ITTNOTIFY_PREFIX __itt_ #define INTEL_ITTNOTIFY_PREFIX __itt_
#endif /* INTEL_ITTNOTIFY_PREFIX */ #endif /* INTEL_ITTNOTIFY_PREFIX */
#ifndef INTEL_ITTNOTIFY_POSTFIX #ifndef INTEL_ITTNOTIFY_POSTFIX
# define INTEL_ITTNOTIFY_POSTFIX _ptr_ #define INTEL_ITTNOTIFY_POSTFIX _ptr_
#endif /* INTEL_ITTNOTIFY_POSTFIX */ #endif /* INTEL_ITTNOTIFY_POSTFIX */
#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n) #define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)
#define ITTNOTIFY_NAME(n) ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n,INTEL_ITTNOTIFY_POSTFIX))) #define ITTNOTIFY_NAME(n) \
ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n, INTEL_ITTNOTIFY_POSTFIX)))
#define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n) #define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)
#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n) #define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)
#define ITTNOTIFY_VOID_D0(n,d) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d) #define ITTNOTIFY_VOID_D0(n, d) \
#define ITTNOTIFY_VOID_D1(n,d,x) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x) (!(d)->flags) ? (void)0 \
#define ITTNOTIFY_VOID_D2(n,d,x,y) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y) : (!ITTNOTIFY_NAME(n)) ? (void)0 \
#define ITTNOTIFY_VOID_D3(n,d,x,y,z) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z) : ITTNOTIFY_NAME(n)(d)
#define ITTNOTIFY_VOID_D4(n,d,x,y,z,a) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a) #define ITTNOTIFY_VOID_D1(n, d, x) \
#define ITTNOTIFY_VOID_D5(n,d,x,y,z,a,b) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b) (!(d)->flags) ? (void)0 \
#define ITTNOTIFY_VOID_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c) : (!ITTNOTIFY_NAME(n)) ? (void)0 \
#define ITTNOTIFY_DATA_D0(n,d) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d) : ITTNOTIFY_NAME(n)(d, x)
#define ITTNOTIFY_DATA_D1(n,d,x) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x) #define ITTNOTIFY_VOID_D2(n, d, x, y) \
#define ITTNOTIFY_DATA_D2(n,d,x,y) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y) (!(d)->flags) ? (void)0 \
#define ITTNOTIFY_DATA_D3(n,d,x,y,z) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z) : (!ITTNOTIFY_NAME(n)) ? (void)0 \
#define ITTNOTIFY_DATA_D4(n,d,x,y,z,a) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a) : ITTNOTIFY_NAME(n)(d, x, y)
#define ITTNOTIFY_DATA_D5(n,d,x,y,z,a,b) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b) #define ITTNOTIFY_VOID_D3(n, d, x, y, z) \
#define ITTNOTIFY_DATA_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c) (!(d)->flags) ? (void)0 \
: (!ITTNOTIFY_NAME(n)) ? (void)0 \
: ITTNOTIFY_NAME(n)(d, x, y, z)
#define ITTNOTIFY_VOID_D4(n, d, x, y, z, a) \
(!(d)->flags) ? (void)0 \
: (!ITTNOTIFY_NAME(n)) ? (void)0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a)
#define ITTNOTIFY_VOID_D5(n, d, x, y, z, a, b) \
(!(d)->flags) ? (void)0 \
: (!ITTNOTIFY_NAME(n)) ? (void)0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a, b)
#define ITTNOTIFY_VOID_D6(n, d, x, y, z, a, b, c) \
(!(d)->flags) ? (void)0 \
: (!ITTNOTIFY_NAME(n)) ? (void)0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c)
#define ITTNOTIFY_DATA_D0(n, d) \
(!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d)
#define ITTNOTIFY_DATA_D1(n, d, x) \
(!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x)
#define ITTNOTIFY_DATA_D2(n, d, x, y) \
(!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y)
#define ITTNOTIFY_DATA_D3(n, d, x, y, z) \
(!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y, z)
#define ITTNOTIFY_DATA_D4(n, d, x, y, z, a) \
(!(d)->flags) ? 0 \
: (!ITTNOTIFY_NAME(n)) ? 0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a)
#define ITTNOTIFY_DATA_D5(n, d, x, y, z, a, b) \
(!(d)->flags) ? 0 \
: (!ITTNOTIFY_NAME(n)) ? 0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a, b)
#define ITTNOTIFY_DATA_D6(n, d, x, y, z, a, b, c) \
(!(d)->flags) ? 0 \
: (!ITTNOTIFY_NAME(n)) ? 0 \
: ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c)
#ifdef ITT_STUB #ifdef ITT_STUB
#undef ITT_STUB #undef ITT_STUB
#endif #endif
#ifdef ITT_STUBV #ifdef ITT_STUBV
#undef ITT_STUBV #undef ITT_STUBV
#endif #endif
#define ITT_STUBV(api,type,name,args) \ #define ITT_STUBV(api, type, name, args) \
typedef type (api* ITT_JOIN(ITTNOTIFY_NAME(name),_t)) args; \ typedef type(api *ITT_JOIN(ITTNOTIFY_NAME(name), _t)) args; \
extern ITT_JOIN(ITTNOTIFY_NAME(name),_t) ITTNOTIFY_NAME(name); extern ITT_JOIN(ITTNOTIFY_NAME(name), _t) ITTNOTIFY_NAME(name);
#define ITT_STUB ITT_STUBV #define ITT_STUB ITT_STUBV
/** @endcond */ /** @endcond */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/** /**
* @defgroup legacy Legacy API * @defgroup legacy Legacy API
* @{ * @{
* @} * @}
*/ */
/** /**
* @defgroup legacy_control Collection Control * @defgroup legacy_control Collection Control
* @ingroup legacy * @ingroup legacy
* General behavior: application continues to run, but no profiling information is being collected * General behavior: application continues to run, but no profiling information
* is being collected
* *
* Pausing occurs not only for the current thread but for all process as well as spawned processes * Pausing occurs not only for the current thread but for all process as well as
* spawned processes
* - Intel(R) Parallel Inspector and Intel(R) Inspector XE: * - Intel(R) Parallel Inspector and Intel(R) Inspector XE:
* - Does not analyze or report errors that involve memory access. * - Does not analyze or report errors that involve memory access.
* - Other errors are reported as usual. Pausing data collection in * - Other errors are reported as usual. Pausing data collection in
* Intel(R) Parallel Inspector and Intel(R) Inspector XE * Intel(R) Parallel Inspector and Intel(R) Inspector XE
* only pauses tracing and analyzing memory access. * only pauses tracing and analyzing memory access.
* It does not pause tracing or analyzing threading APIs. * It does not pause tracing or analyzing threading APIs.
* . * .
* - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE: * - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE:
Show All 10 Lines
/** @brief Resume collection */ /** @brief Resume collection */
void ITTAPI __itt_resume(void); void ITTAPI __itt_resume(void);
/** @brief Detach collection */ /** @brief Detach collection */
void ITTAPI __itt_detach(void); void ITTAPI __itt_detach(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, pause, (void)) ITT_STUBV(ITTAPI, void, pause, (void))
ITT_STUBV(ITTAPI, void, resume, (void)) ITT_STUBV(ITTAPI, void, resume, (void))
ITT_STUBV(ITTAPI, void, detach, (void)) ITT_STUBV(ITTAPI, void, detach, (void))
#define __itt_pause ITTNOTIFY_VOID(pause) #define __itt_pause ITTNOTIFY_VOID(pause)
#define __itt_pause_ptr ITTNOTIFY_NAME(pause) #define __itt_pause_ptr ITTNOTIFY_NAME(pause)
#define __itt_resume ITTNOTIFY_VOID(resume) #define __itt_resume ITTNOTIFY_VOID(resume)
#define __itt_resume_ptr ITTNOTIFY_NAME(resume) #define __itt_resume_ptr ITTNOTIFY_NAME(resume)
#define __itt_detach ITTNOTIFY_VOID(detach) #define __itt_detach ITTNOTIFY_VOID(detach)
#define __itt_detach_ptr ITTNOTIFY_NAME(detach) #define __itt_detach_ptr ITTNOTIFY_NAME(detach)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_pause() #define __itt_pause()
#define __itt_pause_ptr 0 #define __itt_pause_ptr 0
#define __itt_resume() #define __itt_resume()
#define __itt_resume_ptr 0 #define __itt_resume_ptr 0
#define __itt_detach() #define __itt_detach()
#define __itt_detach_ptr 0 #define __itt_detach_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_pause_ptr 0 #define __itt_pause_ptr 0
#define __itt_resume_ptr 0 #define __itt_resume_ptr 0
#define __itt_detach_ptr 0 #define __itt_detach_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
#endif /* _ITTNOTIFY_H_ */ #endif /* _ITTNOTIFY_H_ */
/** @} legacy_control group */ /** @} legacy_control group */
/** /**
* @defgroup legacy_threads Threads * @defgroup legacy_threads Threads
* @ingroup legacy * @ingroup legacy
* Threads group * Threads group
* @warning Legacy API * @warning Legacy API
* @{ * @{
*/ */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Set name to be associated with thread in analysis GUI. * @brief Set name to be associated with thread in analysis GUI.
* @return __itt_err upon failure (name or namelen being null,name and namelen mismatched) * @return __itt_err upon failure (name or namelen being null,name and namelen
* mismatched)
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
int LIBITTAPI __itt_thr_name_setA(const char *name, int namelen); int LIBITTAPI __itt_thr_name_setA(const char *name, int namelen);
int LIBITTAPI __itt_thr_name_setW(const wchar_t *name, int namelen); int LIBITTAPI __itt_thr_name_setW(const wchar_t *name, int namelen);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_thr_name_set __itt_thr_name_setW #define __itt_thr_name_set __itt_thr_name_setW
# define __itt_thr_name_set_ptr __itt_thr_name_setW_ptr #define __itt_thr_name_set_ptr __itt_thr_name_setW_ptr
#else #else
# define __itt_thr_name_set __itt_thr_name_setA #define __itt_thr_name_set __itt_thr_name_setA
# define __itt_thr_name_set_ptr __itt_thr_name_setA_ptr #define __itt_thr_name_set_ptr __itt_thr_name_setA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
int LIBITTAPI __itt_thr_name_set(const char *name, int namelen); int LIBITTAPI __itt_thr_name_set(const char *name, int namelen);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char *name, int namelen)) ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char *name, int namelen))
ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen)) ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, thr_name_set, (const char *name, int namelen)) ITT_STUB(LIBITTAPI, int, thr_name_set, (const char *name, int namelen))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_thr_name_setA ITTNOTIFY_DATA(thr_name_setA) #define __itt_thr_name_setA ITTNOTIFY_DATA(thr_name_setA)
#define __itt_thr_name_setA_ptr ITTNOTIFY_NAME(thr_name_setA) #define __itt_thr_name_setA_ptr ITTNOTIFY_NAME(thr_name_setA)
#define __itt_thr_name_setW ITTNOTIFY_DATA(thr_name_setW) #define __itt_thr_name_setW ITTNOTIFY_DATA(thr_name_setW)
#define __itt_thr_name_setW_ptr ITTNOTIFY_NAME(thr_name_setW) #define __itt_thr_name_setW_ptr ITTNOTIFY_NAME(thr_name_setW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thr_name_set ITTNOTIFY_DATA(thr_name_set) #define __itt_thr_name_set ITTNOTIFY_DATA(thr_name_set)
#define __itt_thr_name_set_ptr ITTNOTIFY_NAME(thr_name_set) #define __itt_thr_name_set_ptr ITTNOTIFY_NAME(thr_name_set)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_thr_name_setA(name, namelen) #define __itt_thr_name_setA(name, namelen)
#define __itt_thr_name_setA_ptr 0 #define __itt_thr_name_setA_ptr 0
#define __itt_thr_name_setW(name, namelen) #define __itt_thr_name_setW(name, namelen)
#define __itt_thr_name_setW_ptr 0 #define __itt_thr_name_setW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thr_name_set(name, namelen) #define __itt_thr_name_set(name, namelen)
#define __itt_thr_name_set_ptr 0 #define __itt_thr_name_set_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_thr_name_setA_ptr 0 #define __itt_thr_name_setA_ptr 0
#define __itt_thr_name_setW_ptr 0 #define __itt_thr_name_setW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_thr_name_set_ptr 0 #define __itt_thr_name_set_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Mark current thread as ignored from this point on, for the duration of its existence. * @brief Mark current thread as ignored from this point on, for the duration of
* its existence.
*/ */
void LIBITTAPI __itt_thr_ignore(void); void LIBITTAPI __itt_thr_ignore(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, thr_ignore, (void)) ITT_STUBV(LIBITTAPI, void, thr_ignore, (void))
#define __itt_thr_ignore ITTNOTIFY_VOID(thr_ignore) #define __itt_thr_ignore ITTNOTIFY_VOID(thr_ignore)
#define __itt_thr_ignore_ptr ITTNOTIFY_NAME(thr_ignore) #define __itt_thr_ignore_ptr ITTNOTIFY_NAME(thr_ignore)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_thr_ignore() #define __itt_thr_ignore()
#define __itt_thr_ignore_ptr 0 #define __itt_thr_ignore_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_thr_ignore_ptr 0 #define __itt_thr_ignore_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} legacy_threads group */ /** @} legacy_threads group */
/** /**
* @defgroup legacy_sync Synchronization * @defgroup legacy_sync Synchronization
* @ingroup legacy * @ingroup legacy
* Synchronization group * Synchronization group
* @warning Legacy API * @warning Legacy API
* @{ * @{
*/ */
/** /**
* @hideinitializer * @hideinitializer
* @brief possible value of attribute argument for sync object type * @brief possible value of attribute argument for sync object type
*/ */
#define __itt_attr_barrier 1 #define __itt_attr_barrier 1
/** /**
* @hideinitializer * @hideinitializer
* @brief possible value of attribute argument for sync object type * @brief possible value of attribute argument for sync object type
*/ */
#define __itt_attr_mutex 2 #define __itt_attr_mutex 2
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Assign a name to a sync object using char or Unicode string * @brief Assign a name to a sync object using char or Unicode string
* @param[in] addr - pointer to the sync object. You should use a real pointer to your object * @param[in] addr - pointer to the sync object. You should use a real
* to make sure that the values don't clash with other object addresses * pointer to your object to make sure that the values don't clash with other
* @param[in] objtype - null-terminated object type string. If NULL is passed, the object will * object addresses
* be assumed to be of generic "User Synchronization" type * @param[in] objtype - null-terminated object type string. If NULL is passed,
* @param[in] objname - null-terminated object name string. If NULL, no name will be assigned * the object will be assumed to be of generic "User Synchronization" type
* to the object -- you can use the __itt_sync_rename call later to assign * @param[in] objname - null-terminated object name string. If NULL, no name
* the name * will be assigned to the object -- you can use the __itt_sync_rename call
* @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values which defines the * later to assign the name
* exact semantics of how prepare/acquired/releasing calls work. * @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values
*/ * which defines the exact semantics of how prepare/acquired/releasing calls
#if ITT_PLATFORM==ITT_PLATFORM_WIN * work.
void ITTAPI __itt_sync_set_nameA(void *addr, const char *objtype, const char *objname, int attribute); */
void ITTAPI __itt_sync_set_nameW(void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute); #if ITT_PLATFORM == ITT_PLATFORM_WIN
void ITTAPI __itt_sync_set_nameA(void *addr, const char *objtype,
const char *objname, int attribute);
void ITTAPI __itt_sync_set_nameW(void *addr, const wchar_t *objtype,
const wchar_t *objname, int attribute);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_sync_set_name __itt_sync_set_nameW #define __itt_sync_set_name __itt_sync_set_nameW
# define __itt_sync_set_name_ptr __itt_sync_set_nameW_ptr #define __itt_sync_set_name_ptr __itt_sync_set_nameW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_sync_set_name __itt_sync_set_nameA #define __itt_sync_set_name __itt_sync_set_nameA
# define __itt_sync_set_name_ptr __itt_sync_set_nameA_ptr #define __itt_sync_set_name_ptr __itt_sync_set_nameA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
void ITTAPI __itt_sync_set_name(void *addr, const char* objtype, const char* objname, int attribute); void ITTAPI __itt_sync_set_name(void *addr, const char *objtype,
const char *objname, int attribute);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUBV(ITTAPI, void, sync_set_nameA, (void *addr, const char *objtype, const char *objname, int attribute)) ITT_STUBV(ITTAPI, void, sync_set_nameA,
ITT_STUBV(ITTAPI, void, sync_set_nameW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute)) (void *addr, const char *objtype, const char *objname, int attribute))
ITT_STUBV(ITTAPI, void, sync_set_nameW,
(void *addr, const wchar_t *objtype, const wchar_t *objname,
int attribute))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUBV(ITTAPI, void, sync_set_name, (void *addr, const char *objtype, const char *objname, int attribute)) ITT_STUBV(ITTAPI, void, sync_set_name,
(void *addr, const char *objtype, const char *objname, int attribute))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_set_nameA ITTNOTIFY_VOID(sync_set_nameA) #define __itt_sync_set_nameA ITTNOTIFY_VOID(sync_set_nameA)
#define __itt_sync_set_nameA_ptr ITTNOTIFY_NAME(sync_set_nameA) #define __itt_sync_set_nameA_ptr ITTNOTIFY_NAME(sync_set_nameA)
#define __itt_sync_set_nameW ITTNOTIFY_VOID(sync_set_nameW) #define __itt_sync_set_nameW ITTNOTIFY_VOID(sync_set_nameW)
#define __itt_sync_set_nameW_ptr ITTNOTIFY_NAME(sync_set_nameW) #define __itt_sync_set_nameW_ptr ITTNOTIFY_NAME(sync_set_nameW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_set_name ITTNOTIFY_VOID(sync_set_name) #define __itt_sync_set_name ITTNOTIFY_VOID(sync_set_name)
#define __itt_sync_set_name_ptr ITTNOTIFY_NAME(sync_set_name) #define __itt_sync_set_name_ptr ITTNOTIFY_NAME(sync_set_name)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_set_nameA(addr, objtype, objname, attribute) #define __itt_sync_set_nameA(addr, objtype, objname, attribute)
#define __itt_sync_set_nameA_ptr 0 #define __itt_sync_set_nameA_ptr 0
#define __itt_sync_set_nameW(addr, objtype, objname, attribute) #define __itt_sync_set_nameW(addr, objtype, objname, attribute)
#define __itt_sync_set_nameW_ptr 0 #define __itt_sync_set_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_set_name(addr, objtype, objname, attribute) #define __itt_sync_set_name(addr, objtype, objname, attribute)
#define __itt_sync_set_name_ptr 0 #define __itt_sync_set_name_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_sync_set_nameA_ptr 0 #define __itt_sync_set_nameA_ptr 0
#define __itt_sync_set_nameW_ptr 0 #define __itt_sync_set_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_sync_set_name_ptr 0 #define __itt_sync_set_name_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Assign a name and type to a sync object using char or Unicode string * @brief Assign a name and type to a sync object using char or Unicode string
* @param[in] addr - pointer to the sync object. You should use a real pointer to your object * @param[in] addr - pointer to the sync object. You should use a real
* to make sure that the values don't clash with other object addresses * pointer to your object to make sure that the values don't clash with other
* @param[in] objtype - null-terminated object type string. If NULL is passed, the object will * object addresses
* be assumed to be of generic "User Synchronization" type * @param[in] objtype - null-terminated object type string. If NULL is passed,
* @param[in] objname - null-terminated object name string. If NULL, no name will be assigned * the object will be assumed to be of generic "User Synchronization" type
* to the object -- you can use the __itt_sync_rename call later to assign * @param[in] objname - null-terminated object name string. If NULL, no name
* the name * will be assigned to the object -- you can use the __itt_sync_rename call
* @param[in] typelen, namelen - a length of string for appropriate objtype and objname parameter * later to assign the name
* @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values which defines the * @param[in] typelen, namelen - a length of string for appropriate objtype
* exact semantics of how prepare/acquired/releasing calls work. * and objname parameter
* @return __itt_err upon failure (name or namelen being null,name and namelen mismatched) * @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values
*/ * which defines the exact semantics of how prepare/acquired/releasing calls
#if ITT_PLATFORM==ITT_PLATFORM_WIN * work.
int LIBITTAPI __itt_notify_sync_nameA(void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute); * @return __itt_err upon failure (name or namelen being null,name and namelen
int LIBITTAPI __itt_notify_sync_nameW(void *addr, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute); * mismatched)
*/
#if ITT_PLATFORM == ITT_PLATFORM_WIN
int LIBITTAPI __itt_notify_sync_nameA(void *addr, const char *objtype,
int typelen, const char *objname,
int namelen, int attribute);
int LIBITTAPI __itt_notify_sync_nameW(void *addr, const wchar_t *objtype,
int typelen, const wchar_t *objname,
int namelen, int attribute);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_notify_sync_name __itt_notify_sync_nameW #define __itt_notify_sync_name __itt_notify_sync_nameW
#else #else
# define __itt_notify_sync_name __itt_notify_sync_nameA #define __itt_notify_sync_name __itt_notify_sync_nameA
#endif #endif
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
int LIBITTAPI __itt_notify_sync_name(void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute); int LIBITTAPI __itt_notify_sync_name(void *addr, const char *objtype,
int typelen, const char *objname,
int namelen, int attribute);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, int, notify_sync_nameA, (void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute)) ITT_STUB(LIBITTAPI, int, notify_sync_nameA,
ITT_STUB(LIBITTAPI, int, notify_sync_nameW, (void *addr, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute)) (void *addr, const char *objtype, int typelen, const char *objname,
int namelen, int attribute))
ITT_STUB(LIBITTAPI, int, notify_sync_nameW,
(void *addr, const wchar_t *objtype, int typelen,
const wchar_t *objname, int namelen, int attribute))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, int, notify_sync_name, (void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute)) ITT_STUB(LIBITTAPI, int, notify_sync_name,
(void *addr, const char *objtype, int typelen, const char *objname,
int namelen, int attribute))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_notify_sync_nameA ITTNOTIFY_DATA(notify_sync_nameA) #define __itt_notify_sync_nameA ITTNOTIFY_DATA(notify_sync_nameA)
#define __itt_notify_sync_nameA_ptr ITTNOTIFY_NAME(notify_sync_nameA) #define __itt_notify_sync_nameA_ptr ITTNOTIFY_NAME(notify_sync_nameA)
#define __itt_notify_sync_nameW ITTNOTIFY_DATA(notify_sync_nameW) #define __itt_notify_sync_nameW ITTNOTIFY_DATA(notify_sync_nameW)
#define __itt_notify_sync_nameW_ptr ITTNOTIFY_NAME(notify_sync_nameW) #define __itt_notify_sync_nameW_ptr ITTNOTIFY_NAME(notify_sync_nameW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_notify_sync_name ITTNOTIFY_DATA(notify_sync_name) #define __itt_notify_sync_name ITTNOTIFY_DATA(notify_sync_name)
#define __itt_notify_sync_name_ptr ITTNOTIFY_NAME(notify_sync_name) #define __itt_notify_sync_name_ptr ITTNOTIFY_NAME(notify_sync_name)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_notify_sync_nameA(addr, objtype, typelen, objname, namelen, attribute) #define __itt_notify_sync_nameA(addr, objtype, typelen, objname, namelen, \
attribute)
#define __itt_notify_sync_nameA_ptr 0 #define __itt_notify_sync_nameA_ptr 0
#define __itt_notify_sync_nameW(addr, objtype, typelen, objname, namelen, attribute) #define __itt_notify_sync_nameW(addr, objtype, typelen, objname, namelen, \
attribute)
#define __itt_notify_sync_nameW_ptr 0 #define __itt_notify_sync_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_notify_sync_name(addr, objtype, typelen, objname, namelen, attribute) #define __itt_notify_sync_name(addr, objtype, typelen, objname, namelen, \
attribute)
#define __itt_notify_sync_name_ptr 0 #define __itt_notify_sync_name_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_notify_sync_nameA_ptr 0 #define __itt_notify_sync_nameA_ptr 0
#define __itt_notify_sync_nameW_ptr 0 #define __itt_notify_sync_nameW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_notify_sync_name_ptr 0 #define __itt_notify_sync_name_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Enter spin loop on user-defined sync object * @brief Enter spin loop on user-defined sync object
*/ */
void LIBITTAPI __itt_notify_sync_prepare(void* addr); void LIBITTAPI __itt_notify_sync_prepare(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *addr)) ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *addr))
#define __itt_notify_sync_prepare ITTNOTIFY_VOID(notify_sync_prepare) #define __itt_notify_sync_prepare ITTNOTIFY_VOID(notify_sync_prepare)
#define __itt_notify_sync_prepare_ptr ITTNOTIFY_NAME(notify_sync_prepare) #define __itt_notify_sync_prepare_ptr ITTNOTIFY_NAME(notify_sync_prepare)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_notify_sync_prepare(addr) #define __itt_notify_sync_prepare(addr)
#define __itt_notify_sync_prepare_ptr 0 #define __itt_notify_sync_prepare_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_notify_sync_prepare_ptr 0 #define __itt_notify_sync_prepare_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Quit spin loop without acquiring spin object * @brief Quit spin loop without acquiring spin object
*/ */
void LIBITTAPI __itt_notify_sync_cancel(void *addr); void LIBITTAPI __itt_notify_sync_cancel(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *addr)) ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *addr))
#define __itt_notify_sync_cancel ITTNOTIFY_VOID(notify_sync_cancel) #define __itt_notify_sync_cancel ITTNOTIFY_VOID(notify_sync_cancel)
#define __itt_notify_sync_cancel_ptr ITTNOTIFY_NAME(notify_sync_cancel) #define __itt_notify_sync_cancel_ptr ITTNOTIFY_NAME(notify_sync_cancel)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_notify_sync_cancel(addr) #define __itt_notify_sync_cancel(addr)
#define __itt_notify_sync_cancel_ptr 0 #define __itt_notify_sync_cancel_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_notify_sync_cancel_ptr 0 #define __itt_notify_sync_cancel_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Successful spin loop completion (sync object acquired) * @brief Successful spin loop completion (sync object acquired)
*/ */
void LIBITTAPI __itt_notify_sync_acquired(void *addr); void LIBITTAPI __itt_notify_sync_acquired(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *addr)) ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *addr))
#define __itt_notify_sync_acquired ITTNOTIFY_VOID(notify_sync_acquired) #define __itt_notify_sync_acquired ITTNOTIFY_VOID(notify_sync_acquired)
#define __itt_notify_sync_acquired_ptr ITTNOTIFY_NAME(notify_sync_acquired) #define __itt_notify_sync_acquired_ptr ITTNOTIFY_NAME(notify_sync_acquired)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_notify_sync_acquired(addr) #define __itt_notify_sync_acquired(addr)
#define __itt_notify_sync_acquired_ptr 0 #define __itt_notify_sync_acquired_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_notify_sync_acquired_ptr 0 #define __itt_notify_sync_acquired_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Start sync object releasing code. Is called before the lock release call. * @brief Start sync object releasing code. Is called before the lock release
* call.
*/ */
void LIBITTAPI __itt_notify_sync_releasing(void* addr); void LIBITTAPI __itt_notify_sync_releasing(void *addr);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *addr)) ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *addr))
#define __itt_notify_sync_releasing ITTNOTIFY_VOID(notify_sync_releasing) #define __itt_notify_sync_releasing ITTNOTIFY_VOID(notify_sync_releasing)
#define __itt_notify_sync_releasing_ptr ITTNOTIFY_NAME(notify_sync_releasing) #define __itt_notify_sync_releasing_ptr ITTNOTIFY_NAME(notify_sync_releasing)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_notify_sync_releasing(addr) #define __itt_notify_sync_releasing(addr)
#define __itt_notify_sync_releasing_ptr 0 #define __itt_notify_sync_releasing_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_notify_sync_releasing_ptr 0 #define __itt_notify_sync_releasing_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} legacy_sync group */ /** @} legacy_sync group */
#ifndef _ITTNOTIFY_H_ #ifndef _ITTNOTIFY_H_
/** /**
* @defgroup legacy_events Events * @defgroup legacy_events Events
* @ingroup legacy * @ingroup legacy
* Events group * Events group
* @{ * @{
*/ */
/** @brief user event type */ /** @brief user event type */
typedef int __itt_event; typedef int __itt_event;
/** /**
* @brief Create an event notification * @brief Create an event notification
* @note name or namelen being null/name and namelen not matching, user event feature not enabled * @note name or namelen being null/name and namelen not matching, user event
* feature not enabled
* @return non-zero event identifier upon success and __itt_err otherwise * @return non-zero event identifier upon success and __itt_err otherwise
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen); __itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen);
__itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen); __itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_event_create __itt_event_createW #define __itt_event_create __itt_event_createW
# define __itt_event_create_ptr __itt_event_createW_ptr #define __itt_event_create_ptr __itt_event_createW_ptr
#else #else
# define __itt_event_create __itt_event_createA #define __itt_event_create __itt_event_createA
# define __itt_event_create_ptr __itt_event_createA_ptr #define __itt_event_create_ptr __itt_event_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_event LIBITTAPI __itt_event_create(const char *name, int namelen); __itt_event LIBITTAPI __itt_event_create(const char *name, int namelen);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen)) ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen))
ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen)) ITT_STUB(LIBITTAPI, __itt_event, event_createW,
(const wchar_t *name, int namelen))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen)) ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_event_createA ITTNOTIFY_DATA(event_createA) #define __itt_event_createA ITTNOTIFY_DATA(event_createA)
#define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA) #define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA)
#define __itt_event_createW ITTNOTIFY_DATA(event_createW) #define __itt_event_createW ITTNOTIFY_DATA(event_createW)
#define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW) #define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create ITTNOTIFY_DATA(event_create) #define __itt_event_create ITTNOTIFY_DATA(event_create)
#define __itt_event_create_ptr ITTNOTIFY_NAME(event_create) #define __itt_event_create_ptr ITTNOTIFY_NAME(event_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_event_createA(name, namelen) (__itt_event)0 #define __itt_event_createA(name, namelen) (__itt_event)0
#define __itt_event_createA_ptr 0 #define __itt_event_createA_ptr 0
#define __itt_event_createW(name, namelen) (__itt_event)0 #define __itt_event_createW(name, namelen) (__itt_event)0
#define __itt_event_createW_ptr 0 #define __itt_event_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create(name, namelen) (__itt_event)0 #define __itt_event_create(name, namelen) (__itt_event)0
#define __itt_event_create_ptr 0 #define __itt_event_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_event_createA_ptr 0 #define __itt_event_createA_ptr 0
#define __itt_event_createW_ptr 0 #define __itt_event_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_event_create_ptr 0 #define __itt_event_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record an event occurrence. * @brief Record an event occurrence.
* @return __itt_err upon failure (invalid event id/user event feature not enabled) * @return __itt_err upon failure (invalid event id/user event feature not
* enabled)
*/ */
int LIBITTAPI __itt_event_start(__itt_event event); int LIBITTAPI __itt_event_start(__itt_event event);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event)) ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event))
#define __itt_event_start ITTNOTIFY_DATA(event_start) #define __itt_event_start ITTNOTIFY_DATA(event_start)
#define __itt_event_start_ptr ITTNOTIFY_NAME(event_start) #define __itt_event_start_ptr ITTNOTIFY_NAME(event_start)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_event_start(event) (int)0 #define __itt_event_start(event) (int)0
#define __itt_event_start_ptr 0 #define __itt_event_start_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_event_start_ptr 0 #define __itt_event_start_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @brief Record an event end occurrence. * @brief Record an event end occurrence.
* @note It is optional if events do not have durations. * @note It is optional if events do not have durations.
* @return __itt_err upon failure (invalid event id/user event feature not enabled) * @return __itt_err upon failure (invalid event id/user event feature not
* enabled)
*/ */
int LIBITTAPI __itt_event_end(__itt_event event); int LIBITTAPI __itt_event_end(__itt_event event);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event)) ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event))
#define __itt_event_end ITTNOTIFY_DATA(event_end) #define __itt_event_end ITTNOTIFY_DATA(event_end)
#define __itt_event_end_ptr ITTNOTIFY_NAME(event_end) #define __itt_event_end_ptr ITTNOTIFY_NAME(event_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_event_end(event) (int)0 #define __itt_event_end(event) (int)0
#define __itt_event_end_ptr 0 #define __itt_event_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_event_end_ptr 0 #define __itt_event_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} legacy_events group */ /** @} legacy_events group */
#endif /* _ITTNOTIFY_H_ */ #endif /* _ITTNOTIFY_H_ */
/** /**
* @defgroup legacy_memory Memory Accesses * @defgroup legacy_memory Memory Accesses
* @ingroup legacy * @ingroup legacy
*/ */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Inform the tool of memory accesses on reading * @brief Inform the tool of memory accesses on reading
*/ */
void LIBITTAPI __itt_memory_read(void *addr, size_t size); void LIBITTAPI __itt_memory_read(void *addr, size_t size);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size)) ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size))
#define __itt_memory_read ITTNOTIFY_VOID(memory_read) #define __itt_memory_read ITTNOTIFY_VOID(memory_read)
#define __itt_memory_read_ptr ITTNOTIFY_NAME(memory_read) #define __itt_memory_read_ptr ITTNOTIFY_NAME(memory_read)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_memory_read(addr, size) #define __itt_memory_read(addr, size)
#define __itt_memory_read_ptr 0 #define __itt_memory_read_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_memory_read_ptr 0 #define __itt_memory_read_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Inform the tool of memory accesses on writing * @brief Inform the tool of memory accesses on writing
*/ */
void LIBITTAPI __itt_memory_write(void *addr, size_t size); void LIBITTAPI __itt_memory_write(void *addr, size_t size);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size)) ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size))
#define __itt_memory_write ITTNOTIFY_VOID(memory_write) #define __itt_memory_write ITTNOTIFY_VOID(memory_write)
#define __itt_memory_write_ptr ITTNOTIFY_NAME(memory_write) #define __itt_memory_write_ptr ITTNOTIFY_NAME(memory_write)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_memory_write(addr, size) #define __itt_memory_write(addr, size)
#define __itt_memory_write_ptr 0 #define __itt_memory_write_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_memory_write_ptr 0 #define __itt_memory_write_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief Inform the tool of memory accesses on updating * @brief Inform the tool of memory accesses on updating
*/ */
void LIBITTAPI __itt_memory_update(void *address, size_t size); void LIBITTAPI __itt_memory_update(void *address, size_t size);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size)) ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size))
#define __itt_memory_update ITTNOTIFY_VOID(memory_update) #define __itt_memory_update ITTNOTIFY_VOID(memory_update)
#define __itt_memory_update_ptr ITTNOTIFY_NAME(memory_update) #define __itt_memory_update_ptr ITTNOTIFY_NAME(memory_update)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_memory_update(addr, size) #define __itt_memory_update(addr, size)
#define __itt_memory_update_ptr 0 #define __itt_memory_update_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_memory_update_ptr 0 #define __itt_memory_update_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} legacy_memory group */ /** @} legacy_memory group */
/** /**
* @defgroup legacy_state Thread and Object States * @defgroup legacy_state Thread and Object States
* @ingroup legacy * @ingroup legacy
*/ */
/** @brief state type */ /** @brief state type */
typedef int __itt_state_t; typedef int __itt_state_t;
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
typedef enum __itt_obj_state { typedef enum __itt_obj_state {
__itt_obj_state_err = 0, __itt_obj_state_err = 0,
__itt_obj_state_clr = 1, __itt_obj_state_clr = 1,
__itt_obj_state_set = 2, __itt_obj_state_set = 2,
__itt_obj_state_use = 3 __itt_obj_state_use = 3
} __itt_obj_state_t; } __itt_obj_state_t;
typedef enum __itt_thr_state { typedef enum __itt_thr_state {
__itt_thr_state_err = 0, __itt_thr_state_err = 0,
__itt_thr_state_clr = 1, __itt_thr_state_clr = 1,
__itt_thr_state_set = 2 __itt_thr_state_set = 2
} __itt_thr_state_t; } __itt_thr_state_t;
typedef enum __itt_obj_prop { typedef enum __itt_obj_prop {
__itt_obj_prop_watch = 1, __itt_obj_prop_watch = 1,
__itt_obj_prop_ignore = 2, __itt_obj_prop_ignore = 2,
__itt_obj_prop_sharable = 3 __itt_obj_prop_sharable = 3
} __itt_obj_prop_t; } __itt_obj_prop_t;
typedef enum __itt_thr_prop { typedef enum __itt_thr_prop { __itt_thr_prop_quiet = 1 } __itt_thr_prop_t;
__itt_thr_prop_quiet = 1
} __itt_thr_prop_t;
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief managing thread and object states * @brief managing thread and object states
*/ */
__itt_state_t LIBITTAPI __itt_state_get(void); __itt_state_t LIBITTAPI __itt_state_get(void);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_state_t, state_get, (void)) ITT_STUB(ITTAPI, __itt_state_t, state_get, (void))
#define __itt_state_get ITTNOTIFY_DATA(state_get) #define __itt_state_get ITTNOTIFY_DATA(state_get)
#define __itt_state_get_ptr ITTNOTIFY_NAME(state_get) #define __itt_state_get_ptr ITTNOTIFY_NAME(state_get)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_state_get(void) (__itt_state_t)0 #define __itt_state_get(void) (__itt_state_t)0
#define __itt_state_get_ptr 0 #define __itt_state_get_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_state_get_ptr 0 #define __itt_state_get_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief managing thread and object states * @brief managing thread and object states
*/ */
__itt_state_t LIBITTAPI __itt_state_set(__itt_state_t s); __itt_state_t LIBITTAPI __itt_state_set(__itt_state_t s);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_state_t, state_set, (__itt_state_t s)) ITT_STUB(ITTAPI, __itt_state_t, state_set, (__itt_state_t s))
#define __itt_state_set ITTNOTIFY_DATA(state_set) #define __itt_state_set ITTNOTIFY_DATA(state_set)
#define __itt_state_set_ptr ITTNOTIFY_NAME(state_set) #define __itt_state_set_ptr ITTNOTIFY_NAME(state_set)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_state_set(s) (__itt_state_t)0 #define __itt_state_set(s) (__itt_state_t)0
#define __itt_state_set_ptr 0 #define __itt_state_set_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_state_set_ptr 0 #define __itt_state_set_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief managing thread and object modes * @brief managing thread and object modes
*/ */
__itt_thr_state_t LIBITTAPI __itt_thr_mode_set(__itt_thr_prop_t p, __itt_thr_state_t s); __itt_thr_state_t LIBITTAPI __itt_thr_mode_set(__itt_thr_prop_t p,
__itt_thr_state_t s);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_thr_state_t, thr_mode_set, (__itt_thr_prop_t p, __itt_thr_state_t s)) ITT_STUB(ITTAPI, __itt_thr_state_t, thr_mode_set,
(__itt_thr_prop_t p, __itt_thr_state_t s))
#define __itt_thr_mode_set ITTNOTIFY_DATA(thr_mode_set) #define __itt_thr_mode_set ITTNOTIFY_DATA(thr_mode_set)
#define __itt_thr_mode_set_ptr ITTNOTIFY_NAME(thr_mode_set) #define __itt_thr_mode_set_ptr ITTNOTIFY_NAME(thr_mode_set)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_thr_mode_set(p, s) (__itt_thr_state_t)0 #define __itt_thr_mode_set(p, s) (__itt_thr_state_t)0
#define __itt_thr_mode_set_ptr 0 #define __itt_thr_mode_set_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_thr_mode_set_ptr 0 #define __itt_thr_mode_set_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** /**
* @deprecated Legacy API * @deprecated Legacy API
* @brief managing thread and object modes * @brief managing thread and object modes
*/ */
__itt_obj_state_t LIBITTAPI __itt_obj_mode_set(__itt_obj_prop_t p, __itt_obj_state_t s); __itt_obj_state_t LIBITTAPI __itt_obj_mode_set(__itt_obj_prop_t p,
__itt_obj_state_t s);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUB(ITTAPI, __itt_obj_state_t, obj_mode_set, (__itt_obj_prop_t p, __itt_obj_state_t s)) ITT_STUB(ITTAPI, __itt_obj_state_t, obj_mode_set,
(__itt_obj_prop_t p, __itt_obj_state_t s))
#define __itt_obj_mode_set ITTNOTIFY_DATA(obj_mode_set) #define __itt_obj_mode_set ITTNOTIFY_DATA(obj_mode_set)
#define __itt_obj_mode_set_ptr ITTNOTIFY_NAME(obj_mode_set) #define __itt_obj_mode_set_ptr ITTNOTIFY_NAME(obj_mode_set)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_obj_mode_set(p, s) (__itt_obj_state_t)0 #define __itt_obj_mode_set(p, s) (__itt_obj_state_t)0
#define __itt_obj_mode_set_ptr 0 #define __itt_obj_mode_set_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_obj_mode_set_ptr 0 #define __itt_obj_mode_set_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} legacy_state group */ /** @} legacy_state group */
/** /**
* @defgroup frames Frames * @defgroup frames Frames
* @ingroup legacy * @ingroup legacy
* Frames group * Frames group
* @{ * @{
*/ */
/** /**
* @brief opaque structure for frame identification * @brief opaque structure for frame identification
*/ */
typedef struct __itt_frame_t *__itt_frame; typedef struct __itt_frame_t *__itt_frame;
/** /**
* @brief Create a global frame with given domain * @brief Create a global frame with given domain
*/ */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
__itt_frame ITTAPI __itt_frame_createA(const char *domain); __itt_frame ITTAPI __itt_frame_createA(const char *domain);
__itt_frame ITTAPI __itt_frame_createW(const wchar_t *domain); __itt_frame ITTAPI __itt_frame_createW(const wchar_t *domain);
#if defined(UNICODE) || defined(_UNICODE) #if defined(UNICODE) || defined(_UNICODE)
# define __itt_frame_create __itt_frame_createW #define __itt_frame_create __itt_frame_createW
# define __itt_frame_create_ptr __itt_frame_createW_ptr #define __itt_frame_create_ptr __itt_frame_createW_ptr
#else /* UNICODE */ #else /* UNICODE */
# define __itt_frame_create __itt_frame_createA #define __itt_frame_create __itt_frame_createA
# define __itt_frame_create_ptr __itt_frame_createA_ptr #define __itt_frame_create_ptr __itt_frame_createA_ptr
#endif /* UNICODE */ #endif /* UNICODE */
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
__itt_frame ITTAPI __itt_frame_create(const char *domain); __itt_frame ITTAPI __itt_frame_create(const char *domain);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char *domain)) ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char *domain))
ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain)) ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain))
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
ITT_STUB(ITTAPI, __itt_frame, frame_create, (const char *domain)) ITT_STUB(ITTAPI, __itt_frame, frame_create, (const char *domain))
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_frame_createA ITTNOTIFY_DATA(frame_createA) #define __itt_frame_createA ITTNOTIFY_DATA(frame_createA)
#define __itt_frame_createA_ptr ITTNOTIFY_NAME(frame_createA) #define __itt_frame_createA_ptr ITTNOTIFY_NAME(frame_createA)
#define __itt_frame_createW ITTNOTIFY_DATA(frame_createW) #define __itt_frame_createW ITTNOTIFY_DATA(frame_createW)
#define __itt_frame_createW_ptr ITTNOTIFY_NAME(frame_createW) #define __itt_frame_createW_ptr ITTNOTIFY_NAME(frame_createW)
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_frame_create ITTNOTIFY_DATA(frame_create) #define __itt_frame_create ITTNOTIFY_DATA(frame_create)
#define __itt_frame_create_ptr ITTNOTIFY_NAME(frame_create) #define __itt_frame_create_ptr ITTNOTIFY_NAME(frame_create)
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_frame_createA(domain) #define __itt_frame_createA(domain)
#define __itt_frame_createA_ptr 0 #define __itt_frame_createA_ptr 0
#define __itt_frame_createW(domain) #define __itt_frame_createW(domain)
#define __itt_frame_createW_ptr 0 #define __itt_frame_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_frame_create(domain) #define __itt_frame_create(domain)
#define __itt_frame_create_ptr 0 #define __itt_frame_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#if ITT_PLATFORM==ITT_PLATFORM_WIN #if ITT_PLATFORM == ITT_PLATFORM_WIN
#define __itt_frame_createA_ptr 0 #define __itt_frame_createA_ptr 0
#define __itt_frame_createW_ptr 0 #define __itt_frame_createW_ptr 0
#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#define __itt_frame_create_ptr 0 #define __itt_frame_create_ptr 0
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @brief Record a frame begin occurrence. */ /** @brief Record a frame begin occurrence. */
void ITTAPI __itt_frame_begin(__itt_frame frame); void ITTAPI __itt_frame_begin(__itt_frame frame);
/** @brief Record a frame end occurrence. */ /** @brief Record a frame end occurrence. */
void ITTAPI __itt_frame_end (__itt_frame frame); void ITTAPI __itt_frame_end(__itt_frame frame);
/** @cond exclude_from_documentation */ /** @cond exclude_from_documentation */
#ifndef INTEL_NO_MACRO_BODY #ifndef INTEL_NO_MACRO_BODY
#ifndef INTEL_NO_ITTNOTIFY_API #ifndef INTEL_NO_ITTNOTIFY_API
ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame)) ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame))
ITT_STUBV(ITTAPI, void, frame_end, (__itt_frame frame)) ITT_STUBV(ITTAPI, void, frame_end, (__itt_frame frame))
#define __itt_frame_begin ITTNOTIFY_VOID(frame_begin) #define __itt_frame_begin ITTNOTIFY_VOID(frame_begin)
#define __itt_frame_begin_ptr ITTNOTIFY_NAME(frame_begin) #define __itt_frame_begin_ptr ITTNOTIFY_NAME(frame_begin)
#define __itt_frame_end ITTNOTIFY_VOID(frame_end) #define __itt_frame_end ITTNOTIFY_VOID(frame_end)
#define __itt_frame_end_ptr ITTNOTIFY_NAME(frame_end) #define __itt_frame_end_ptr ITTNOTIFY_NAME(frame_end)
#else /* INTEL_NO_ITTNOTIFY_API */ #else /* INTEL_NO_ITTNOTIFY_API */
#define __itt_frame_begin(frame) #define __itt_frame_begin(frame)
#define __itt_frame_begin_ptr 0 #define __itt_frame_begin_ptr 0
#define __itt_frame_end(frame) #define __itt_frame_end(frame)
#define __itt_frame_end_ptr 0 #define __itt_frame_end_ptr 0
#endif /* INTEL_NO_ITTNOTIFY_API */ #endif /* INTEL_NO_ITTNOTIFY_API */
#else /* INTEL_NO_MACRO_BODY */ #else /* INTEL_NO_MACRO_BODY */
#define __itt_frame_begin_ptr 0 #define __itt_frame_begin_ptr 0
#define __itt_frame_end_ptr 0 #define __itt_frame_end_ptr 0
#endif /* INTEL_NO_MACRO_BODY */ #endif /* INTEL_NO_MACRO_BODY */
/** @endcond */ /** @endcond */
/** @} frames group */ /** @} frames group */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* _LEGACY_ITTNOTIFY_H_ */ #endif /* _LEGACY_ITTNOTIFY_H_ */

openmp/runtime/src/z_Linux_util.cpp

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Linesvoid __kmp_affinity_bind_thread(int which) {
__kmp_set_system_affinity(mask, TRUE); __kmp_set_system_affinity(mask, TRUE);
KMP_CPU_FREE_FROM_STACK(mask); KMP_CPU_FREE_FROM_STACK(mask);
} }
/* Determine if we can access affinity functionality on this version of /* Determine if we can access affinity functionality on this version of
* Linux* OS by checking __NR_sched_{get,set}affinity system calls, and set * Linux* OS by checking __NR_sched_{get,set}affinity system calls, and set
* __kmp_affin_mask_size to the appropriate value (0 means not capable). */ * __kmp_affin_mask_size to the appropriate value (0 means not capable). */
void __kmp_affinity_determine_capable(const char *env_var) { void __kmp_affinity_determine_capable(const char *env_var) {
// Check and see if the OS supports thread affinity. // Check and see if the OS supports thread affinity.
#if KMP_OS_LINUX #if KMP_OS_LINUX
#define KMP_CPU_SET_SIZE_LIMIT (1024 * 1024) #define KMP_CPU_SET_SIZE_LIMIT (1024 * 1024)
#elif KMP_OS_FREEBSD #elif KMP_OS_FREEBSD
#define KMP_CPU_SET_SIZE_LIMIT (sizeof(cpuset_t)) #define KMP_CPU_SET_SIZE_LIMIT (sizeof(cpuset_t))
#endif #endif
#if KMP_OS_LINUX #if KMP_OS_LINUX
// If Linux* OS: // If Linux* OS:
// If the syscall fails or returns a suggestion for the size, // If the syscall fails or returns a suggestion for the size,
// then we don't have to search for an appropriate size. // then we don't have to search for an appropriate size.
long gCode; long gCode;
long sCode; long sCode;
unsigned char *buf; unsigned char *buf;
buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT); buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT);
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines if (sCode < 0) {
return; return;
} }
} }
} }
#elif KMP_OS_FREEBSD #elif KMP_OS_FREEBSD
long gCode; long gCode;
unsigned char *buf; unsigned char *buf;
buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT); buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT);
gCode = pthread_getaffinity_np(pthread_self(), KMP_CPU_SET_SIZE_LIMIT, reinterpret_cast<cpuset_t *>(buf)); gCode = pthread_getaffinity_np(pthread_self(), KMP_CPU_SET_SIZE_LIMIT,
reinterpret_cast<cpuset_t *>(buf));
KA_TRACE(30, ("__kmp_affinity_determine_capable: " KA_TRACE(30, ("__kmp_affinity_determine_capable: "
"initial getaffinity call returned %d errno = %d\n", "initial getaffinity call returned %d errno = %d\n",
gCode, errno)); gCode, errno));
if (gCode == 0) { if (gCode == 0) {
KMP_AFFINITY_ENABLE(KMP_CPU_SET_SIZE_LIMIT); KMP_AFFINITY_ENABLE(KMP_CPU_SET_SIZE_LIMIT);
KA_TRACE(10, ("__kmp_affinity_determine_capable: " KA_TRACE(10, ("__kmp_affinity_determine_capable: "
"affinity supported (mask size %d)\n", "affinity supported (mask size %d)\n",
(int)__kmp_affin_mask_size)); (int)__kmp_affin_mask_size));
KMP_INTERNAL_FREE(buf); KMP_INTERNAL_FREE(buf);
return; return;
} }
#endif #endif
// save uncaught error code // save uncaught error code
// int error = errno; // int error = errno;
KMP_INTERNAL_FREE(buf); KMP_INTERNAL_FREE(buf);
// restore uncaught error code, will be printed at the next KMP_WARNING below // restore uncaught error code, will be printed at the next KMP_WARNING below
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines
/* Set thread stack info according to values returned by pthread_getattr_np(). /* Set thread stack info according to values returned by pthread_getattr_np().
If values are unreasonable, assume call failed and use incremental stack If values are unreasonable, assume call failed and use incremental stack
refinement method instead. Returns TRUE if the stack parameters could be refinement method instead. Returns TRUE if the stack parameters could be
determined exactly, FALSE if incremental refinement is necessary. */ determined exactly, FALSE if incremental refinement is necessary. */
static kmp_int32 __kmp_set_stack_info(int gtid, kmp_info_t *th) { static kmp_int32 __kmp_set_stack_info(int gtid, kmp_info_t *th) {
int stack_data; int stack_data;
#if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \ #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \
KMP_OS_HURD KMP_OS_HURD
pthread_attr_t attr; pthread_attr_t attr;
int status; int status;
size_t size = 0; size_t size = 0;
void *addr = 0; void *addr = 0;
/* Always do incremental stack refinement for ubermaster threads since the /* Always do incremental stack refinement for ubermaster threads since the
initial thread stack range can be reduced by sibling thread creation so initial thread stack range can be reduced by sibling thread creation so
pthread_attr_getstack may cause thread gtid aliasing */ pthread_attr_getstack may cause thread gtid aliasing */
Show All 21 Lines#endif
if (size != 0 && addr != 0) { // was stack parameter determination successful? if (size != 0 && addr != 0) { // was stack parameter determination successful?
/* Store the correct base and size */ /* Store the correct base and size */
TCW_PTR(th->th.th_info.ds.ds_stackbase, (((char *)addr) + size)); TCW_PTR(th->th.th_info.ds.ds_stackbase, (((char *)addr) + size));
TCW_PTR(th->th.th_info.ds.ds_stacksize, size); TCW_PTR(th->th.th_info.ds.ds_stacksize, size);
TCW_4(th->th.th_info.ds.ds_stackgrow, FALSE); TCW_4(th->th.th_info.ds.ds_stackgrow, FALSE);
return TRUE; return TRUE;
} }
#endif /* KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || #endif /* KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD \
KMP_OS_HURD */ || KMP_OS_HURD */
/* Use incremental refinement starting from initial conservative estimate */ /* Use incremental refinement starting from initial conservative estimate */
TCW_PTR(th->th.th_info.ds.ds_stacksize, 0); TCW_PTR(th->th.th_info.ds.ds_stacksize, 0);
TCW_PTR(th->th.th_info.ds.ds_stackbase, &stack_data); TCW_PTR(th->th.th_info.ds.ds_stackbase, &stack_data);
TCW_4(th->th.th_info.ds.ds_stackgrow, TRUE); TCW_4(th->th.th_info.ds.ds_stackgrow, TRUE);
return FALSE; return FALSE;
} }
static void *__kmp_launch_worker(void *thr) { static void *__kmp_launch_worker(void *thr) {
int status, old_type, old_state; int status, old_type, old_state;
#ifdef KMP_BLOCK_SIGNALS #ifdef KMP_BLOCK_SIGNALS
sigset_t new_set, old_set; sigset_t new_set, old_set;
#endif /* KMP_BLOCK_SIGNALS */ #endif /* KMP_BLOCK_SIGNALS */
void *exit_val; void *exit_val;
#if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \ #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \
KMP_OS_OPENBSD || KMP_OS_HURD KMP_OS_OPENBSD || KMP_OS_HURD
void *volatile padding = 0; void *volatile padding = 0;
#endif #endif
int gtid; int gtid;
gtid = ((kmp_info_t *)thr)->th.th_info.ds.ds_gtid; gtid = ((kmp_info_t *)thr)->th.th_info.ds.ds_gtid;
__kmp_gtid_set_specific(gtid); __kmp_gtid_set_specific(gtid);
#ifdef KMP_TDATA_GTID #ifdef KMP_TDATA_GTID
__kmp_gtid = gtid; __kmp_gtid = gtid;
Show All 32 Lines
#ifdef KMP_BLOCK_SIGNALS #ifdef KMP_BLOCK_SIGNALS
status = sigfillset(&new_set); status = sigfillset(&new_set);
KMP_CHECK_SYSFAIL_ERRNO("sigfillset", status); KMP_CHECK_SYSFAIL_ERRNO("sigfillset", status);
status = pthread_sigmask(SIG_BLOCK, &new_set, &old_set); status = pthread_sigmask(SIG_BLOCK, &new_set, &old_set);
KMP_CHECK_SYSFAIL("pthread_sigmask", status); KMP_CHECK_SYSFAIL("pthread_sigmask", status);
#endif /* KMP_BLOCK_SIGNALS */ #endif /* KMP_BLOCK_SIGNALS */
#if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \ #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \
KMP_OS_OPENBSD KMP_OS_OPENBSD
if (__kmp_stkoffset > 0 && gtid > 0) { if (__kmp_stkoffset > 0 && gtid > 0) {
padding = KMP_ALLOCA(gtid * __kmp_stkoffset); padding = KMP_ALLOCA(gtid * __kmp_stkoffset);
} }
#endif #endif
KMP_MB(); KMP_MB();
__kmp_set_stack_info(gtid, (kmp_info_t *)thr); __kmp_set_stack_info(gtid, (kmp_info_t *)thr);
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines /* Set stack size for this thread now.
stacksize causes the thread to have an offset before the dummy alloca() stacksize causes the thread to have an offset before the dummy alloca()
takes place to create the offset. Since we want the user to have a takes place to create the offset. Since we want the user to have a
sufficient stacksize AND support a stack offset, we alloca() twice the sufficient stacksize AND support a stack offset, we alloca() twice the
offset so that the upcoming alloca() does not eliminate any premade offset, offset so that the upcoming alloca() does not eliminate any premade offset,
and also gives the user the stack space they requested for all threads */ and also gives the user the stack space they requested for all threads */
stack_size += gtid * __kmp_stkoffset * 2; stack_size += gtid * __kmp_stkoffset * 2;
#if defined(__ANDROID__) && __ANDROID_API__ < 19 #if defined(__ANDROID__) && __ANDROID_API__ < 19
// Round the stack size to a multiple of the page size. Older versions of // Round the stack size to a multiple of the page size. Older versions of
// Android (until KitKat) would fail pthread_attr_setstacksize with EINVAL // Android (until KitKat) would fail pthread_attr_setstacksize with EINVAL
// if the stack size was not a multiple of the page size. // if the stack size was not a multiple of the page size.
stack_size = (stack_size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1); stack_size = (stack_size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
#endif #endif
KA_TRACE(10, ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, " KA_TRACE(10, ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
"__kmp_stksize = %lu bytes, final stacksize = %lu bytes\n", "__kmp_stksize = %lu bytes, final stacksize = %lu bytes\n",
gtid, KMP_DEFAULT_STKSIZE, __kmp_stksize, stack_size)); gtid, KMP_DEFAULT_STKSIZE, __kmp_stksize, stack_size));
#ifdef _POSIX_THREAD_ATTR_STACKSIZE #ifdef _POSIX_THREAD_ATTR_STACKSIZE
status = pthread_attr_setstacksize(&thread_attr, stack_size); status = pthread_attr_setstacksize(&thread_attr, stack_size);
▲ Show 20 Lines • Show All 545 Lines • ▼ Show 20 Lines
void __kmp_suspend_initialize_thread(kmp_info_t *th) { void __kmp_suspend_initialize_thread(kmp_info_t *th) {
ANNOTATE_HAPPENS_AFTER(&th->th.th_suspend_init_count); ANNOTATE_HAPPENS_AFTER(&th->th.th_suspend_init_count);
int old_value = KMP_ATOMIC_LD_RLX(&th->th.th_suspend_init_count); int old_value = KMP_ATOMIC_LD_RLX(&th->th.th_suspend_init_count);
int new_value = __kmp_fork_count + 1; int new_value = __kmp_fork_count + 1;
// Return if already initialized // Return if already initialized
if (old_value == new_value) if (old_value == new_value)
return; return;
// Wait, then return if being initialized // Wait, then return if being initialized
if (old_value == -1 || if (old_value == -1 || !__kmp_atomic_compare_store(
!__kmp_atomic_compare_store(&th->th.th_suspend_init_count, old_value, &th->th.th_suspend_init_count, old_value, -1)) {
-1)) {
while (KMP_ATOMIC_LD_ACQ(&th->th.th_suspend_init_count) != new_value) { while (KMP_ATOMIC_LD_ACQ(&th->th.th_suspend_init_count) != new_value) {
KMP_CPU_PAUSE(); KMP_CPU_PAUSE();
} }
} else { } else {
// Claim to be the initializer and do initializations // Claim to be the initializer and do initializations
int status; int status;
status = pthread_cond_init(&th->th.th_suspend_cv.c_cond, status = pthread_cond_init(&th->th.th_suspend_cv.c_cond,
&__kmp_suspend_cond_attr); &__kmp_suspend_cond_attr);
▲ Show 20 Lines • Show All 393 Lines • ▼ Show 20 Linesvoid __kmp_clear_system_time(void) {
TIMEVAL_TO_TIMESPEC(&tval, &__kmp_sys_timer_data.start); TIMEVAL_TO_TIMESPEC(&tval, &__kmp_sys_timer_data.start);
} }
static int __kmp_get_xproc(void) { static int __kmp_get_xproc(void) {
int r = 0; int r = 0;
#if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \ #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || \
KMP_OS_OPENBSD || KMP_OS_HURD KMP_OS_OPENBSD || KMP_OS_HURD
__kmp_type_convert(sysconf(_SC_NPROCESSORS_ONLN), &(r)); __kmp_type_convert(sysconf(_SC_NPROCESSORS_ONLN), &(r));
#elif KMP_OS_DARWIN #elif KMP_OS_DARWIN
// Bug C77011 High "OpenMP Threads and number of active cores". // Bug C77011 High "OpenMP Threads and number of active cores".
// Find the number of available CPUs. // Find the number of available CPUs.
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
#if (KMP_ARCH_X86 || KMP_ARCH_X86_64) #if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
if (!__kmp_cpuinfo.initialized) { if (!__kmp_cpuinfo.initialized) {
__kmp_query_cpuid(&__kmp_cpuinfo); __kmp_query_cpuid(&__kmp_cpuinfo);
} }
#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */ #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
__kmp_xproc = __kmp_get_xproc(); __kmp_xproc = __kmp_get_xproc();
#if ! KMP_32_BIT_ARCH #if !KMP_32_BIT_ARCH
struct rlimit rlim; struct rlimit rlim;
// read stack size of calling thread, save it as default for worker threads; // read stack size of calling thread, save it as default for worker threads;
// this should be done before reading environment variables // this should be done before reading environment variables
status = getrlimit(RLIMIT_STACK, &rlim); status = getrlimit(RLIMIT_STACK, &rlim);
if (status == 0) { // success? if (status == 0) { // success?
__kmp_stksize = rlim.rlim_cur; __kmp_stksize = rlim.rlim_cur;
__kmp_check_stksize(&__kmp_stksize); // check value and adjust if needed __kmp_check_stksize(&__kmp_stksize); // check value and adjust if needed
} }
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
int __kmp_is_address_mapped(void *addr) { int __kmp_is_address_mapped(void *addr) {
int found = 0; int found = 0;
int rc; int rc;
#if KMP_OS_LINUX || KMP_OS_HURD #if KMP_OS_LINUX || KMP_OS_HURD
/* On GNUish OSes, read the /proc/<pid>/maps pseudo-file to get all the address /* On GNUish OSes, read the /proc/<pid>/maps pseudo-file to get all the
ranges mapped into the address space. */ address ranges mapped into the address space. */
char *name = __kmp_str_format("/proc/%d/maps", getpid()); char *name = __kmp_str_format("/proc/%d/maps", getpid());
FILE *file = NULL; FILE *file = NULL;
file = fopen(name, "r"); file = fopen(name, "r");
KMP_ASSERT(file != NULL); KMP_ASSERT(file != NULL);
for (;;) { for (;;) {
Show All 24 Lines#if KMP_OS_LINUX || KMP_OS_HURD
fclose(file); fclose(file);
KMP_INTERNAL_FREE(name); KMP_INTERNAL_FREE(name);
#elif KMP_OS_FREEBSD #elif KMP_OS_FREEBSD
char *buf; char *buf;
size_t lstsz; size_t lstsz;
int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_VMMAP, getpid()}; int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_VMMAP, getpid()};
rc = sysctl(mib, 4, NULL, &lstsz, NULL, 0); rc = sysctl(mib, 4, NULL, &lstsz, NULL, 0);
if (rc < 0) if (rc < 0)
return 0; return 0;
// We pass from number of vm entry's semantic // We pass from number of vm entry's semantic
// to size of whole entry map list. // to size of whole entry map list.
lstsz = lstsz * 4 / 3; lstsz = lstsz * 4 / 3;
buf = reinterpret_cast<char *>(kmpc_malloc(lstsz)); buf = reinterpret_cast<char *>(kmpc_malloc(lstsz));
rc = sysctl(mib, 4, buf, &lstsz, NULL, 0); rc = sysctl(mib, 4, buf, &lstsz, NULL, 0);
if (rc < 0) { if (rc < 0) {
kmpc_free(buf); kmpc_free(buf);
return 0; return 0;
} }
char *lw = buf; char *lw = buf;
char *up = buf + lstsz; char *up = buf + lstsz;
while (lw < up) { while (lw < up) {
struct kinfo_vmentry *cur = reinterpret_cast<struct kinfo_vmentry *>(lw); struct kinfo_vmentry *cur = reinterpret_cast<struct kinfo_vmentry *>(lw);
size_t cursz = cur->kve_structsize; size_t cursz = cur->kve_structsize;
if (cursz == 0) if (cursz == 0)
break; break;
void *start = reinterpret_cast<void *>(cur->kve_start); void *start = reinterpret_cast<void *>(cur->kve_start);
void *end = reinterpret_cast<void *>(cur->kve_end); void *end = reinterpret_cast<void *>(cur->kve_end);
// Readable/Writable addresses within current map entry // Readable/Writable addresses within current map entry
if ((addr >= start) && (addr < end)) { if ((addr >= start) && (addr < end)) {
if ((cur->kve_protection & KVME_PROT_READ) != 0 && if ((cur->kve_protection & KVME_PROT_READ) != 0 &&
(cur->kve_protection & KVME_PROT_WRITE) != 0) { (cur->kve_protection & KVME_PROT_WRITE) != 0) {
found = 1; found = 1;
break; break;
} }
} }
lw += cursz; lw += cursz;
} }
kmpc_free(buf); kmpc_free(buf);
#elif KMP_OS_DARWIN #elif KMP_OS_DARWIN
/* On OS X*, /proc pseudo filesystem is not available. Try to read memory /* On OS X*, /proc pseudo filesystem is not available. Try to read memory
using vm interface. */ using vm interface. */
int buffer; int buffer;
vm_size_t count; vm_size_t count;
rc = vm_read_overwrite( rc = vm_read_overwrite(
mach_task_self(), // Task to read memory of. mach_task_self(), // Task to read memory of.
(vm_address_t)(addr), // Address to read from. (vm_address_t)(addr), // Address to read from.
1, // Number of bytes to be read. 1, // Number of bytes to be read.
(vm_address_t)(&buffer), // Address of buffer to save read bytes in. (vm_address_t)(&buffer), // Address of buffer to save read bytes in.
&count // Address of var to save number of read bytes in. &count // Address of var to save number of read bytes in.
); );
if (rc == 0) { if (rc == 0) {
// Memory successfully read. // Memory successfully read.
found = 1; found = 1;
} }
#elif KMP_OS_NETBSD #elif KMP_OS_NETBSD
int mib[5]; int mib[5];
▲ Show 20 Lines • Show All 577 Lines • Show Last 20 Lines

openmp/tools/archer/ompt-tsan.cpp

Show First 20 Lines • Show All 618 Lines • ▼ Show 20 Lines case ompt_scope_beginend:
case ompt_sync_region_taskgroup: case ompt_sync_region_taskgroup:
Data->TaskGroup = new Taskgroup(Data->TaskGroup); Data->TaskGroup = new Taskgroup(Data->TaskGroup);
break; break;
case ompt_sync_region_reduction: case ompt_sync_region_reduction:
// should never be reached // should never be reached
break; break;
} }
if (endpoint == ompt_scope_begin) if (endpoint == ompt_scope_begin)
break; break;
KMP_FALLTHROUGH(); KMP_FALLTHROUGH();
case ompt_scope_end: case ompt_scope_end:
TsanFuncExit(); TsanFuncExit();
switch (kind) { switch (kind) {
case ompt_sync_region_barrier_implementation: case ompt_sync_region_barrier_implementation:
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines case ompt_sync_region_taskgroup: {
Data->TaskGroup = Parent; Data->TaskGroup = Parent;
break; break;
} }
case ompt_sync_region_reduction: case ompt_sync_region_reduction:
// Should not occur according to OpenMP 5.1 // Should not occur according to OpenMP 5.1
// Tested in OMPT tests // Tested in OMPT tests
break; break;
} }
break; break;
} }
} }
static void ompt_tsan_reduction(ompt_sync_region_t kind, static void ompt_tsan_reduction(ompt_sync_region_t kind,
ompt_scope_endpoint_t endpoint, ompt_scope_endpoint_t endpoint,
ompt_data_t *parallel_data, ompt_data_t *parallel_data,
▲ Show 20 Lines • Show All 346 Lines • Show Last 20 Lines

openmp/tools/multiplex/ompt-multiplex.h

Show All 14 Lines
#ifndef OMPT_MULTIPLEX_H #ifndef OMPT_MULTIPLEX_H
#define OMPT_MULTIPLEX_H #define OMPT_MULTIPLEX_H
#ifndef _GNU_SOURCE #ifndef _GNU_SOURCE
#define _GNU_SOURCE #define _GNU_SOURCE
#endif #endif
#include <dlfcn.h> #include <dlfcn.h>
#include <errno.h>
#include <execinfo.h> #include <execinfo.h>
#include <inttypes.h> #include <inttypes.h>
#include <omp-tools.h> #include <omp-tools.h>
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <errno.h>
static ompt_set_callback_t ompt_multiplex_set_callback; static ompt_set_callback_t ompt_multiplex_set_callback;
static ompt_get_task_info_t ompt_multiplex_get_task_info; static ompt_get_task_info_t ompt_multiplex_get_task_info;
static ompt_get_thread_data_t ompt_multiplex_get_thread_data; static ompt_get_thread_data_t ompt_multiplex_get_thread_data;
static ompt_get_parallel_info_t ompt_multiplex_get_parallel_info; static ompt_get_parallel_info_t ompt_multiplex_get_parallel_info;
// contains name of the environment var in which the tool path is specified // contains name of the environment var in which the tool path is specified
#ifndef CLIENT_TOOL_LIBRARIES_VAR #ifndef CLIENT_TOOL_LIBRARIES_VAR
▲ Show 20 Lines • Show All 1,057 Lines • Show Last 20 Lines