| /* |
| Copyright 2005-2010 Intel Corporation. All Rights Reserved. |
| |
| This file is part of Threading Building Blocks. |
| |
| Threading Building Blocks is free software; you can redistribute it |
| and/or modify it under the terms of the GNU General Public License |
| version 2 as published by the Free Software Foundation. |
| |
| Threading Building Blocks is distributed in the hope that it will be |
| useful, but WITHOUT ANY WARRANTY; without even the implied warranty |
| of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with Threading Building Blocks; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| |
| As a special exception, you may use this file as part of a free software |
| library without restriction. Specifically, if other files instantiate |
| templates or use macros or inline functions from this file, or you compile |
| this file and link it with other files to produce an executable, this |
| file does not by itself cause the resulting executable to be covered by |
| the GNU General Public License. This exception does not however |
| invalidate any other reasons why the executable file might be covered by |
| the GNU General Public License. |
| */ |
| |
| #include "ittnotify_config.h" |
| |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| #include <windows.h> |
| #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ |
| #include <pthread.h> |
| #include <dlfcn.h> |
| #include <errno.h> |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include "disable_warnings.h" |
| |
| #define INTEL_NO_MACRO_BODY |
| #include "ittnotify.h" |
| #include "legacy/ittnotify.h" |
| #include "internal/ittnotify.h" |
| #include "prototype/ittnotify.h" |
| |
| #include "ittnotify_types.h" |
| |
| #ifndef INTEL_ITTNOTIFY_PREFIX |
| #define INTEL_ITTNOTIFY_PREFIX __itt_ |
| #endif /* INTEL_ITTNOTIFY_PREFIX */ |
| #ifndef INTEL_ITTNOTIFY_POSTFIX |
| #define INTEL_ITTNOTIFY_POSTFIX _ptr_ |
| #endif /* INTEL_ITTNOTIFY_POSTFIX */ |
| |
| #define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n) |
| |
| #ifndef CDECL |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| #define CDECL __cdecl |
| #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| #define CDECL |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| #endif /* CDECL */ |
| |
| #ifndef STDCALL |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| #define STDCALL __stdcall |
| #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ |
| #define STDCALL |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| #endif /* STDCALL */ |
| |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| typedef FARPROC FPTR; |
| typedef DWORD TIDT; |
| #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ |
| typedef void* FPTR; |
| typedef pthread_t TIDT; |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| |
| /* OS communication functions */ |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| typedef HMODULE lib_t; |
| typedef CRITICAL_SECTION mutex_t; |
| #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ |
| typedef void* lib_t; |
| typedef pthread_mutex_t mutex_t; |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| |
| static volatile long ittnotify_init = 0; |
| static lib_t ittnotify_lib = NULL; |
| static __itt_error_notification_t* error_handler = NULL; |
| |
| #if ITT_OS==ITT_OS_WIN |
| static const char* ittnotify_lib_name = "libittnotify.dll"; |
| #elif ITT_OS==ITT_OS_LINUX |
| static const char* ittnotify_lib_name = "libittnotify.so"; |
| #elif ITT_OS==ITT_OS_MAC |
| static const char* ittnotify_lib_name = "libittnotify.dylib"; |
| #else |
| #error Unsupported or unknown OS. |
| #endif |
| |
| #ifndef LIB_VAR_NAME |
| #if ITT_ARCH==ITT_ARCH_IA32 |
| #define LIB_VAR_NAME INTEL_LIBITTNOTIFY32 |
| #else |
| #define LIB_VAR_NAME INTEL_LIBITTNOTIFY64 |
| #endif |
| #endif /* LIB_VAR_NAME */ |
| |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| #define __itt_get_proc(lib, name) GetProcAddress(lib, name) |
| #define __itt_mutex_init(mutex) InitializeCriticalSection(mutex) |
| #define __itt_mutex_lock(mutex) EnterCriticalSection(mutex) |
| #define __itt_mutex_unlock(mutex) LeaveCriticalSection(mutex) |
| #define __itt_load_lib(name) LoadLibraryA(name) |
| #define __itt_unload_lib(handle) FreeLibrary(handle) |
| #define __itt_system_error() (int)GetLastError() |
| #define __itt_fstrcmp(s1, s2) lstrcmpA(s1, s2) |
| #define __itt_fstrlen(s) lstrlenA(s) |
| #define __itt_fstrcpyn(s1, s2, l) lstrcpynA(s1, s2, l) |
| #define __itt_thread_id() GetCurrentThreadId() |
| #define __itt_thread_yield() SwitchToThread() |
| #ifndef ITT_SIMPLE_INIT |
| static int __itt_interlocked_increment(volatile int* ptr) |
| { |
| ITT_BUILD_ASSERT(sizeof(int) == sizeof(long)); |
| return InterlockedIncrement((volatile long *)ptr); |
| } |
| #endif /* ITT_SIMPLE_INIT */ |
| #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ |
| #define __itt_get_proc(lib, name) dlsym(lib, name) |
| #define __itt_mutex_init(mutex) \ |
| { \ |
| pthread_mutexattr_t mutex_attr; \ |
| int error_code = pthread_mutexattr_init(&mutex_attr); \ |
| if (error_code) \ |
| __itt_report_error(__itt_error_system, "pthread_mutexattr_init", error_code); \ |
| error_code = pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE); \ |
| if (error_code) \ |
| __itt_report_error(__itt_error_system, "pthread_mutexattr_settype", error_code); \ |
| error_code = pthread_mutex_init(mutex, &mutex_attr); \ |
| if (error_code) \ |
| __itt_report_error(__itt_error_system, "pthread_mutex_init", error_code); \ |
| error_code = pthread_mutexattr_destroy(&mutex_attr); \ |
| if (error_code) \ |
| __itt_report_error(__itt_error_system, "pthread_mutexattr_destroy", error_code); \ |
| } |
| #define __itt_mutex_lock(mutex) pthread_mutex_lock(mutex) |
| #define __itt_mutex_unlock(mutex) pthread_mutex_unlock(mutex) |
| #define __itt_load_lib(name) dlopen(name, RTLD_LAZY) |
| #define __itt_unload_lib(handle) dlclose(handle) |
| #define __itt_system_error() errno |
| #define __itt_fstrcmp(s1, s2) strcmp(s1, s2) |
| #define __itt_fstrlen(s) strlen(s) |
| #define __itt_fstrcpyn(s1, s2, l) strncpy(s1, s2, l) |
| #define __itt_thread_id() pthread_self() |
| #define __itt_thread_yield() sched_yield() |
| #if ITT_ARCH==ITT_ARCH_IA64 |
| #ifdef __INTEL_COMPILER |
| #define __TBB_machine_fetchadd4(addr, val) __fetchadd4_acq((void *)addr, val) |
| #else /* __INTEL_COMPILER */ |
| // TODO: Add Support for not Intel compilers for IA64 |
| #endif /* __INTEL_COMPILER */ |
| #else /* ITT_ARCH!=ITT_ARCH_IA64 */ |
| #ifndef ITT_SIMPLE_INIT |
| static int __TBB_machine_fetchadd4(volatile void* ptr, int addend) |
| { |
| int result; |
| __asm__ __volatile__("lock\nxaddl %0,%1" |
| : "=r"(result),"=m"(*(int *)ptr) |
| : "0"(addend), "m"(*(int *)ptr) |
| : "memory"); |
| return result; |
| } |
| #endif // ITT_SIMPLE_INIT |
| #endif /* ITT_ARCH==ITT_ARCH_IA64 */ |
| #ifndef ITT_SIMPLE_INIT |
| static int __itt_interlocked_increment(volatile int* ptr) |
| { |
| return __TBB_machine_fetchadd4(ptr, 1) + 1; |
| } |
| #endif /* ITT_SIMPLE_INIT */ |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| |
| const int _N_(err) = 0; |
| |
| typedef int (__itt_init_ittlib_t)(const char*, __itt_group_id); |
| |
| /* this define used to control initialization function name. */ |
| #ifndef __itt_init_ittlib_name |
| static int _N_(init_ittlib)(const char*, __itt_group_id); |
| static __itt_init_ittlib_t* __itt_init_ittlib_ptr = _N_(init_ittlib); |
| #define __itt_init_ittlib_name __itt_init_ittlib_ptr |
| #endif /* __itt_init_ittlib_name */ |
| |
| /* building pointers to imported funcs */ |
| #undef ITT_STUBV |
| #undef ITT_STUB |
| #define ITT_STUB(api,type,name,args,params,ptr,group,format) \ |
| static type api ITT_JOIN(_N_(name),_init) args; \ |
| typedef type api name##_t args; \ |
| extern "C" name##_t* ITTNOTIFY_NAME(name); \ |
| name##_t* ITTNOTIFY_NAME(name) = ITT_JOIN(_N_(name),_init); \ |
| static type api ITT_JOIN(_N_(name),_init) args \ |
| { \ |
| if (__itt_init_ittlib_name(NULL, __itt_group_none) \ |
| && ITTNOTIFY_NAME(name) \ |
| && ITTNOTIFY_NAME(name) != ITT_JOIN(_N_(name),_init)) \ |
| return ITTNOTIFY_NAME(name) params; \ |
| else \ |
| return (type)0; \ |
| } |
| |
| #define ITT_STUBV(api,type,name,args,params,ptr,group,format) \ |
| static type api ITT_JOIN(_N_(name),_init) args; \ |
| typedef type api name##_t args; \ |
| extern "C" name##_t* ITTNOTIFY_NAME(name); \ |
| name##_t* ITTNOTIFY_NAME(name) = ITT_JOIN(_N_(name),_init); \ |
| static type api ITT_JOIN(_N_(name),_init) args \ |
| { \ |
| if (__itt_init_ittlib_name(NULL, __itt_group_none) \ |
| && ITTNOTIFY_NAME(name) \ |
| && ITTNOTIFY_NAME(name) != ITT_JOIN(_N_(name),_init)) \ |
| ITTNOTIFY_NAME(name) params; \ |
| else \ |
| return; \ |
| } |
| |
| /* Define types and *_init functions. */ |
| #include "ittnotify_static.h" |
| |
| ITT_GROUP_LIST(group_list); |
| |
| typedef struct __itt_group_alias_ |
| { |
| const char* env_var; |
| __itt_group_id groups; |
| } __itt_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_TCHECK", (__itt_group_id)(__itt_group_control | __itt_group_thread | __itt_group_fsync | __itt_group_mark) }, |
| { NULL, (__itt_group_none) } |
| }; |
| |
| typedef struct __itt_func_map_ |
| { |
| const char* name; |
| void** func_ptr; |
| __itt_group_id group; |
| } __itt_func_map; |
| |
| #define __ptr_(pname,name,group) {ITT_TO_STR(ITT_JOIN(__itt_,pname)), (void**)(void*)&ITTNOTIFY_NAME(name), (__itt_group_id)(group)}, |
| #undef ITT_STUB |
| #undef ITT_STUBV |
| #define ITT_STUB(api,type,name,args,params,nameindll,group,format) __ptr_(nameindll,name,group) |
| #define ITT_STUBV ITT_STUB |
| |
| static __itt_func_map func_map[] = { |
| #include "ittnotify_static.h" |
| {NULL, NULL, __itt_group_none} |
| }; |
| |
| #ifndef ITT_SIMPLE_INIT |
| |
| #undef ITT_STUBV |
| #undef ITT_STUB |
| #define ITT_STUBV(api,type,name,args,params,ptr,group,format) \ |
| ITT_EXTERN_C type api _N_(name) args \ |
| { \ |
| if (ITTNOTIFY_NAME(name)) \ |
| ITTNOTIFY_NAME(name) params; \ |
| else \ |
| return; \ |
| } |
| |
| #define ITT_STUB(api,type,name,args,params,ptr,group,format) \ |
| ITT_EXTERN_C type api _N_(name) args \ |
| { \ |
| if (ITTNOTIFY_NAME(name)) \ |
| return ITTNOTIFY_NAME(name) params; \ |
| else \ |
| return (type)0; \ |
| } |
| |
| /* Define ITT functions. */ |
| #include "ittnotify_static.h" |
| |
| #endif /* ITT_SIMPLE_INIT */ |
| |
| static const char* __itt_fsplit(const char* s, const char* sep, const char** out, int* len) |
| { |
| int i; |
| int j; |
| |
| if (!s || !sep || !out || !len) |
| return 0; |
| |
| for (i = 0; s[i]; i++) |
| { |
| int b = 0; |
| for (j = 0; sep[j]; j++) |
| if (s[i] == sep[j]) |
| { |
| b = 1; |
| break; |
| } |
| if (!b) |
| break; |
| } |
| |
| if (!s[i]) |
| return 0; |
| |
| *len = 0; |
| *out = s + i; |
| |
| for (; s[i]; i++, (*len)++) |
| { |
| int b = 0; |
| for (j = 0; sep[j]; j++) |
| if (s[i] == sep[j]) |
| { |
| b = 1; |
| break; |
| } |
| if (b) |
| break; |
| } |
| |
| for (; s[i]; i++) |
| { |
| int b = 0; |
| for (j = 0; sep[j]; j++) |
| if (s[i] == sep[j]) |
| { |
| b = 1; |
| break; |
| } |
| if (!b) |
| break; |
| } |
| |
| return s + i; |
| } |
| |
| #ifdef ITT_NOTIFY_EXT_REPORT |
| ITT_EXTERN_C void _N_(error_handler)(__itt_error_code, va_list args); |
| #endif /* ITT_NOTIFY_EXT_REPORT */ |
| |
| static void __itt_report_error(__itt_error_code code, ...) |
| { |
| va_list args; |
| va_start( args, code ); |
| if (error_handler != NULL) |
| error_handler(code, args); |
| #ifdef ITT_NOTIFY_EXT_REPORT |
| _N_(error_handler)(code, args); |
| #endif /* ITT_NOTIFY_EXT_REPORT */ |
| va_end(args); |
| } |
| |
| static const char* __itt_get_env_var(const char* name) |
| { |
| #define MAX_ENV_VALUE_SIZE 4086 |
| static char env_buff[MAX_ENV_VALUE_SIZE]; |
| static char* env_value = (char*)&env_buff; |
| |
| if (name != NULL) |
| { |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| size_t max_len = MAX_ENV_VALUE_SIZE - ((size_t)env_value - (size_t)&env_buff); |
| DWORD rc = GetEnvironmentVariableA(name, env_value, (DWORD)max_len); |
| if (rc >= max_len) |
| { |
| __itt_report_error(__itt_error_env_too_long, name, (size_t)rc - 1, (size_t)(max_len - 1)); |
| } |
| else if (rc > 0) |
| { |
| char* ret = env_value; |
| env_value += rc + 1; |
| return ret; |
| } |
| else |
| { |
| /* If environment variable is empty, GetEnvirornmentVariables() returns zero (number of */ |
| /* characters (not including terminating null), and GetLastError() returns ERROR_SUCCESS. */ |
| DWORD err = GetLastError(); |
| if (err == ERROR_SUCCESS) |
| return env_value; |
| |
| if (err != ERROR_ENVVAR_NOT_FOUND) |
| __itt_report_error(__itt_error_cant_read_env, name, (int)err); |
| } |
| #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */ |
| char* env = getenv(name); |
| if (env != NULL) |
| { |
| size_t len = strlen(env); |
| size_t max_len = MAX_ENV_VALUE_SIZE - ((size_t)env_value - (size_t)&env_buff); |
| if (len < max_len) |
| { |
| char* ret = env_value; |
| strncpy(env_value, env, len + 1); |
| env_value += len + 1; |
| return ret; |
| } else |
| __itt_report_error(__itt_error_env_too_long, name, (size_t)len, (size_t)(max_len - 1)); |
| } |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| } |
| return NULL; |
| } |
| |
| static const char* __itt_get_lib_name() |
| { |
| const char* lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME)); |
| return (lib_name == NULL) ? ittnotify_lib_name : lib_name; |
| } |
| |
| #ifndef min |
| #define min(a,b) (a) < (b) ? (a) : (b) |
| #endif /* min */ |
| |
| static __itt_group_id __itt_get_groups() |
| { |
| int i; |
| __itt_group_id res = __itt_group_none; |
| |
| const char* var_name = "INTEL_ITTNOTIFY_GROUPS"; |
| const char* group_str = __itt_get_env_var(var_name); |
| if (group_str != NULL) |
| { |
| int len; |
| char gr[255]; |
| const char* chunk; |
| while ((group_str = __itt_fsplit(group_str, ",; ", &chunk, &len)) != NULL) |
| { |
| __itt_fstrcpyn(gr, chunk, sizeof(gr)); |
| |
| gr[min((size_t)len, sizeof(gr) - 1)] = 0; |
| |
| for (i = 0; group_list[i].name != NULL; i++) |
| { |
| if (!__itt_fstrcmp(gr, group_list[i].name)) |
| { |
| res = (__itt_group_id)(res | group_list[i].id); |
| break; |
| } |
| } |
| } |
| /* TODO: !!! Workaround for bug with warning for unknown group !!! |
| * Should be fixed in new initialization scheme. |
| * Now the following groups should be set always. |
| */ |
| for (i = 0; group_list[i].id != __itt_group_none; i++) |
| if (group_list[i].id != __itt_group_all && group_list[i].id > __itt_group_splitter) |
| res = (__itt_group_id)(res | group_list[i].id); |
| return res; |
| } |
| else |
| { |
| for (i = 0; group_alias[i].env_var != NULL; i++) |
| if (__itt_get_env_var(group_alias[i].env_var) != NULL) |
| return group_alias[i].groups; |
| } |
| |
| return res; |
| } |
| |
| static int __itt_is_legacy_lib(lib_t lib) |
| { |
| if (lib == NULL) |
| return 0; // if unknown assume NO |
| |
| if (__itt_get_proc(lib, "__itt_api_version")) |
| return 0; // New interface - NO |
| return 1; // It's legacy otherwise |
| } |
| |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| #pragma warning(push) |
| #pragma warning(disable: 4054) |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| |
| /* ITT_EXTERN_C - should be exported after agreament |
| static void _N_(fini_ittlib)(void) |
| { |
| int i; |
| |
| if (ittnotify_init) |
| { |
| // Clear all pointers |
| for (i = 0; func_map[i].name != NULL; i++) |
| *func_map[i].func_ptr = NULL; |
| |
| if (ittnotify_lib != NULL) |
| __itt_unload_lib(ittnotify_lib); |
| |
| ittnotify_lib = NULL; |
| ittnotify_init = 0; |
| } |
| } |
| */ |
| |
| static int _N_(init_ittlib)(const char* lib_name, __itt_group_id groups) |
| { |
| int i, ret = 0; |
| static volatile TIDT current_thread = 0; |
| |
| if (!ittnotify_init) |
| { |
| #ifndef ITT_SIMPLE_INIT |
| static mutex_t mutex; |
| static volatile int inter_counter = 0; |
| static volatile int mutex_initialized = 0; |
| |
| if (!mutex_initialized) |
| { |
| if (__itt_interlocked_increment(&inter_counter) == 1) |
| { |
| __itt_mutex_init(&mutex); |
| mutex_initialized = 1; |
| } |
| else |
| while (!mutex_initialized) |
| __itt_thread_yield(); |
| } |
| |
| __itt_mutex_lock(&mutex); |
| #endif /* ITT_SIMPLE_INIT */ |
| |
| if (!ittnotify_init) |
| { |
| if (current_thread == 0) |
| { |
| current_thread = __itt_thread_id(); |
| if (groups == __itt_group_none) |
| groups = __itt_get_groups(); |
| if (groups == __itt_group_none) |
| { |
| // Clear all pointers |
| for (i = 0; func_map[i].name != NULL; i++ ) |
| *func_map[i].func_ptr = NULL; |
| } |
| else |
| { |
| __itt_group_id zero_group = __itt_group_none; |
| if (lib_name == NULL) |
| lib_name = __itt_get_lib_name(); |
| ittnotify_lib = __itt_load_lib(lib_name); |
| if (ittnotify_lib != NULL) |
| { |
| if (__itt_is_legacy_lib(ittnotify_lib)) |
| groups = __itt_group_legacy; |
| |
| for (i = 0; func_map[i].name != NULL; i++) |
| { |
| if (func_map[i].group & groups) |
| { |
| *func_map[i].func_ptr = (void*)__itt_get_proc(ittnotify_lib, func_map[i].name); |
| if (*func_map[i].func_ptr == NULL) |
| { |
| __itt_report_error(__itt_error_no_symbol, lib_name, func_map[i].name ); |
| zero_group = (__itt_group_id)(zero_group | func_map[i].group); |
| } |
| } |
| else |
| *func_map[i].func_ptr = NULL; |
| } |
| |
| if (groups == __itt_group_legacy) |
| { |
| // Compatibility with legacy tools |
| ITTNOTIFY_NAME(sync_prepare) = ITTNOTIFY_NAME(notify_sync_prepare); |
| ITTNOTIFY_NAME(sync_cancel) = ITTNOTIFY_NAME(notify_sync_cancel); |
| ITTNOTIFY_NAME(sync_acquired) = ITTNOTIFY_NAME(notify_sync_acquired); |
| ITTNOTIFY_NAME(sync_releasing) = ITTNOTIFY_NAME(notify_sync_releasing); |
| } |
| } |
| else |
| { |
| // Clear all pointers |
| for (i = 0; func_map[i].name != NULL; i++) |
| *func_map[i].func_ptr = NULL; |
| |
| __itt_report_error(__itt_error_no_module, lib_name, |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| __itt_system_error() |
| #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| dlerror() |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
| ); |
| } |
| #ifdef ITT_COMPLETE_GROUP |
| for (i = 0; func_map[i].name != NULL; i++) |
| if (func_map[i].group & zero_group) |
| *func_map[i].func_ptr = NULL; |
| #endif /* ITT_COMPLETE_GROUP */ |
| |
| /* evaluating if any function ptr is non empty */ |
| for (i = 0; func_map[i].name != NULL; i++) |
| { |
| if (*func_map[i].func_ptr != NULL) |
| { |
| ret = 1; |
| break; |
| } |
| } |
| } |
| |
| ittnotify_init = 1; |
| current_thread = 0; |
| } |
| } |
| |
| #ifndef ITT_SIMPLE_INIT |
| __itt_mutex_unlock(&mutex); |
| #endif /* ITT_SIMPLE_INIT */ |
| } |
| |
| return ret; |
| } |
| |
| ITT_EXTERN_C __itt_error_notification_t* _N_(set_error_handler)(__itt_error_notification_t* handler) |
| { |
| __itt_error_notification_t* prev = error_handler; |
| error_handler = handler; |
| return prev; |
| } |
| |
| #if ITT_PLATFORM==ITT_PLATFORM_WIN |
| #pragma warning(pop) |
| #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */ |
