ittnotify_static.c File Reference

#include "ittnotify_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "ittnotify.h"
#include "legacy/ittnotify.h"
#include "disable_warnings.h"
#include "ittnotify_static.h"

Include dependency graph for ittnotify_static.c:

Go to the source code of this file.

Classes
struct	___itt_group_alias

Macros
#define	PATH_MAX   512
#define	INTEL_NO_MACRO_BODY
#define	INTEL_ITTNOTIFY_API_PRIVATE
#define	_N_(n)   ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
#define	LIB_VAR_NAME   INTEL_LIBITTNOTIFY64
#define	ITT_MUTEX_INIT_AND_LOCK(p)
#define	__itt_init_ittlib_name   __itt_init_ittlib_ptr
#define	__itt_fini_ittlib_name   __itt_fini_ittlib_ptr
#define	ITT_STUB(api, type, name, args, params, ptr, group, format)
#define	ITT_STUBV(api, type, name, args, params, ptr, group, format)
#define	ITT_STUB(api, type, name, args, params, ptr, group, format)
#define	ITT_STUBV(api, type, name, args, params, ptr, group, format)
#define	__ITT_INTERNAL_INIT
#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_INTERNAL_INIT
#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_report_error(code, ...)   __itt_report_error_impl((int)code,__VA_ARGS__)
#define	MAX_ENV_VALUE_SIZE   4086
#define	__itt_min(a, b)   ((a) < (b) ? (a) : (b))

Typedefs
typedef int()	__itt_init_ittlib_t(const char *, __itt_group_id)
typedef void()	__itt_fini_ittlib_t(void)
typedef struct ___itt_group_alias	__itt_group_alias
typedef void()	__itt_api_init_t(__itt_global *, __itt_group_id)
typedef void()	__itt_api_fini_t(__itt_global *)

Functions
const int	_N_ (err)=0
ITT_EXTERN_C int _N_()	init_ittlib (const char *, __itt_group_id)
ITT_EXTERN_C void _N_()	fini_ittlib (void)
__itt_global	_N_ (_ittapi_global)
	ITT_GROUP_LIST (group_list)
static void	__itt_report_error_impl (int code,...)
static __itt_domain *ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(domain_createW), _init)) const
static __itt_domain *ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(domain_createA), _init)) const
static __itt_string_handle *ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(string_handle_createW), _init)) const
static __itt_string_handle *ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(string_handle_createA), _init)) const
static __itt_counter ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(counter_createW), _init)) const
static __itt_counter ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(counter_createA), _init)) const
static __itt_counter ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(counter_create_typedW), _init)) const
static __itt_counter ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(counter_create_typedA), _init)) const
static void ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(pause), _init))
static void ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(resume), _init))
static void ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(thread_set_nameW), _init)) const
static int ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(thr_name_setW), _init)) const
static void ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(thread_set_nameA), _init)) const
static int ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(thr_name_setA), _init)) const
static void ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(thread_ignore), _init))
static void ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(thr_ignore), _init))
static void ITTAPI	ITT_VERSIONIZE (ITT_JOIN(_N_(enable_attach), _init))
static const char *	__itt_fsplit (const char *s, const char *sep, const char **out, int *len)
static const char *	__itt_get_env_var (const char *name)
static const char *	__itt_get_lib_name (void)
static __itt_group_id	__itt_get_groups (void)
static int	__itt_lib_version (lib_t lib)
static void	__itt_nullify_all_pointers (void)
ITT_EXTERN_C __itt_error_handler_t *_N_()	set_error_handler (__itt_error_handler_t *handler)
ITT_EXTERN_C void _N_()	mark_pt_region_begin (__itt_pt_region region)
ITT_EXTERN_C void _N_()	mark_pt_region_end (__itt_pt_region region)

Variables
static const char	api_version [] = API_VERSION "\0\n@(#) $Revision$\n"
static const char *	ittnotify_lib_name = "libittnotify.dll"
static __itt_init_ittlib_t *	__itt_init_ittlib_ptr = _N_(init_ittlib)
static __itt_fini_ittlib_t *	__itt_fini_ittlib_ptr = _N_(fini_ittlib)
static __itt_group_alias	group_alias []
static __itt_api_info	api_list []
static const char	dll_path [PATH_MAX] = { 0 }

Macro Definition Documentation

__itt_fini_ittlib_name

#define __itt_fini_ittlib_name   __itt_fini_ittlib_ptr

Definition at line 130 of file ittnotify_static.c.

__itt_init_ittlib_name

#define __itt_init_ittlib_name   __itt_init_ittlib_ptr

Definition at line 121 of file ittnotify_static.c.

__ITT_INTERNAL_INIT [1/2]

#define __ITT_INTERNAL_INIT

Definition at line 181 of file ittnotify_static.c.

__ITT_INTERNAL_INIT [2/2]

#define __ITT_INTERNAL_INIT

Definition at line 181 of file ittnotify_static.c.

__itt_min

#define __itt_min	(		a,
			b
	)		((a) < (b) ? (a) : (b))

Definition at line 942 of file ittnotify_static.c.

__itt_report_error

#define __itt_report_error	(		code,
			...
	)		__itt_report_error_impl((int)code,__VA_ARGS__)

Definition at line 283 of file ittnotify_static.c.

_N_

#define _N_

(

n

)

ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)

Definition at line 40 of file ittnotify_static.c.

INTEL_ITTNOTIFY_API_PRIVATE

#define INTEL_ITTNOTIFY_API_PRIVATE

Definition at line 32 of file ittnotify_static.c.

INTEL_NO_MACRO_BODY

#define INTEL_NO_MACRO_BODY

Definition at line 31 of file ittnotify_static.c.

ITT_MUTEX_INIT_AND_LOCK

#define ITT_MUTEX_INIT_AND_LOCK

(

p

)

Value:

{                                 \
    if (PTHREAD_SYMBOLS)                                             \
    {                                                                \
        if (!p.mutex_initialized)                                    \
        {                                                            \
            if (__itt_interlocked_increment(&p.atomic_counter) == 1) \
            {                                                        \
                __itt_mutex_init(&p.mutex);                          \
                p.mutex_initialized = 1;                             \
            }                                                        \
            else                                                     \
                while (!p.mutex_initialized)                         \
                    __itt_thread_yield();                            \
        }                                                            \
        __itt_mutex_lock(&p.mutex);                                  \
    }                                                                \
}

Definition at line 95 of file ittnotify_static.c.

ITT_STUB [1/4]

#define ITT_STUB	(		api,
			type,
			name,
			args,
			params,
			ptr,
			group,
			format
	)

Value:

static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) 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 \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args \
{                                                              \
    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) \
        __itt_init_ittlib_name(NULL, __itt_group_all);         \
    if (ITTNOTIFY_NAME(name) && ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init))) \
        return ITTNOTIFY_NAME(name) params;                    \
    else                                                       \
        return (type)0;                                        \
}

Definition at line 171 of file ittnotify_static.c.

ITT_STUB [2/4]

#define ITT_STUB	(		api,
			type,
			name,
			args,
			params,
			ptr,
			group,
			format
	)

Value:

static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) 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

Definition at line 171 of file ittnotify_static.c.

ITT_STUB [3/4]

#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)},

Definition at line 171 of file ittnotify_static.c.

ITT_STUB [4/4]

#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)},

Definition at line 171 of file ittnotify_static.c.

ITT_STUBV [1/4]

#define ITT_STUBV	(		api,
			type,
			name,
			args,
			params,
			ptr,
			group,
			format
	)

Value:

static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) 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 \
static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args \
{                                                              \
    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL) \
        __itt_init_ittlib_name(NULL, __itt_group_all);         \
    if (ITTNOTIFY_NAME(name) && ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init))) \
        ITTNOTIFY_NAME(name) params;                           \
    else                                                       \
        return;                                                \
}

Definition at line 176 of file ittnotify_static.c.

ITT_STUBV [2/4]

#define ITT_STUBV	(		api,
			type,
			name,
			args,
			params,
			ptr,
			group,
			format
	)

Value:

static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) 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

Definition at line 176 of file ittnotify_static.c.

ITT_STUBV [3/4]

#define ITT_STUBV   ITT_STUB

Definition at line 176 of file ittnotify_static.c.

ITT_STUBV [4/4]

#define ITT_STUBV   ITT_STUB

Definition at line 176 of file ittnotify_static.c.

LIB_VAR_NAME

#define LIB_VAR_NAME   INTEL_LIBITTNOTIFY64

Definition at line 91 of file ittnotify_static.c.

MAX_ENV_VALUE_SIZE

#define MAX_ENV_VALUE_SIZE   4086

PATH_MAX

#define PATH_MAX   512

Definition at line 20 of file ittnotify_static.c.

Typedef Documentation

__itt_api_fini_t

typedef void() __itt_api_fini_t(__itt_global *)

Definition at line 255 of file ittnotify_static.c.

__itt_api_init_t

typedef void() __itt_api_init_t(__itt_global *, __itt_group_id)

Definition at line 254 of file ittnotify_static.c.

__itt_fini_ittlib_t

typedef void() __itt_fini_ittlib_t(void)

Definition at line 124 of file ittnotify_static.c.

__itt_group_alias

typedef struct ___itt_group_alias __itt_group_alias

__itt_init_ittlib_t

typedef int() __itt_init_ittlib_t(const char *, __itt_group_id)

Definition at line 115 of file ittnotify_static.c.

Function Documentation

__itt_fsplit()

static const char* __itt_fsplit ( const char *  s, const char *  sep, const char **  out, int *  len  )

static

Definition at line 709 of file ittnotify_static.c.

{
    int i;
    int j;

    if (!s || !sep || !out || !len)
        return NULL;

    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 NULL;

    *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];
}

References s.

Referenced by __itt_get_groups().

Here is the caller graph for this function:

__itt_get_env_var()

static const char* __itt_get_env_var ( const char *  name )

static

Definition at line 770 of file ittnotify_static.c.

{
#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 - 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)
        {
            const char* ret = (const char*)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 = __itt_fstrnlen(env, MAX_ENV_VALUE_SIZE);
            size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);
            if (len < max_len)
            {
                const char* ret = (const char*)env_value;
                __itt_fstrcpyn(env_value, max_len, 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;
}

References __itt_fstrcpyn, __itt_fstrnlen, __itt_report_error, MAX_ENV_VALUE_SIZE, and name.

Referenced by __itt_get_groups(), and __itt_get_lib_name().

Here is the caller graph for this function:

__itt_get_groups()

static __itt_group_id __itt_get_groups ( void  )

static

Definition at line 944 of file ittnotify_static.c.

{
    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)
        {
            int min_len = __itt_min(len, (int)(sizeof(gr) - 1));
            __itt_fstrcpyn(gr, sizeof(gr) - 1, chunk,  min_len);
            gr[min_len] = 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_min &&
                group_list[i].id < __itt_group_splitter_max)
                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;
}

References __itt_fsplit(), __itt_fstrcmp, __itt_fstrcpyn, __itt_get_env_var(), __itt_group_all, __itt_group_none, __itt_group_splitter_max, __itt_group_splitter_min, __itt_min, ___itt_group_alias::env_var, group_alias, and name.

Referenced by init_ittlib().

Here is the call graph for this function:

Here is the caller graph for this function:

__itt_get_lib_name()

static const char* __itt_get_lib_name ( void  )

static

Definition at line 821 of file ittnotify_static.c.

{
    const char* lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));

#ifdef __ANDROID__
    if (lib_name == NULL)
    {

#if ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_ARM
        const char* const marker_filename = "com.intel.itt.collector_lib_32";
#else
        const char* const marker_filename = "com.intel.itt.collector_lib_64";
#endif

        char system_wide_marker_filename[PATH_MAX] = {0};
        int itt_marker_file_fd = -1;
        ssize_t res = 0;

        res = snprintf(system_wide_marker_filename, PATH_MAX - 1, "%s%s", "/data/local/tmp/", marker_filename);
        if (res < 0)
        {
            ITT_ANDROID_LOGE("Unable to concatenate marker file string.");
            return lib_name;
        }
        itt_marker_file_fd = open(system_wide_marker_filename, O_RDONLY);

        if (itt_marker_file_fd == -1)
        {
            const pid_t my_pid = getpid();
            char cmdline_path[PATH_MAX] = {0};
            char package_name[PATH_MAX] = {0};
            char app_sandbox_file[PATH_MAX] = {0};
            int cmdline_fd = 0;

            ITT_ANDROID_LOGI("Unable to open system-wide marker file.");
            res = snprintf(cmdline_path, PATH_MAX - 1, "/proc/%d/cmdline", my_pid);
            if (res < 0)
            {
                ITT_ANDROID_LOGE("Unable to get cmdline path string.");
                return lib_name;
            }

            ITT_ANDROID_LOGI("CMD file: %s\n", cmdline_path);
            cmdline_fd = open(cmdline_path, O_RDONLY);
            if (cmdline_fd == -1)
            {
                ITT_ANDROID_LOGE("Unable to open %s file!", cmdline_path);
                return lib_name;
            }
            res = read(cmdline_fd, package_name, PATH_MAX - 1);
            if (res == -1)
            {
                ITT_ANDROID_LOGE("Unable to read %s file!", cmdline_path);
                res = close(cmdline_fd);
                if (res == -1)
                {
                    ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);
                }
                return lib_name;
            }
            res = close(cmdline_fd);
            if (res == -1)
            {
                ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);
                return lib_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);
            if (res < 0)
            {
                ITT_ANDROID_LOGE("Unable to concatenate marker file string.");
                return lib_name;
            }

            ITT_ANDROID_LOGI("Lib marker file name: %s\n", app_sandbox_file);
            itt_marker_file_fd = open(app_sandbox_file, O_RDONLY);
            if (itt_marker_file_fd == -1)
            {
                ITT_ANDROID_LOGE("Unable to open app marker file!");
                return lib_name;
            }
        }

        {
            char itt_lib_name[PATH_MAX] = {0};

            res = read(itt_marker_file_fd, itt_lib_name, PATH_MAX - 1);
            if (res == -1)
            {
                ITT_ANDROID_LOGE("Unable to read %s file!", itt_marker_file_fd);
                res = close(itt_marker_file_fd);
                if (res == -1)
                {
                    ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);
                }
                return lib_name;
            }
            ITT_ANDROID_LOGI("ITT Lib path: %s", itt_lib_name);
            res = close(itt_marker_file_fd);
            if (res == -1)
            {
                ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);
                return 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);
            if (res == -1)
            {
                ITT_ANDROID_LOGE("Unable to set env var!");
                return lib_name;
            }
            lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));
            ITT_ANDROID_LOGI("ITT Lib path from env: %s", lib_name);
        }
    }
#endif

    return lib_name;
}

References __itt_get_env_var(), ITT_TO_STR, LIB_VAR_NAME, and PATH_MAX.

Referenced by init_ittlib().

Here is the call graph for this function:

Here is the caller graph for this function:

__itt_lib_version()

static int __itt_lib_version ( lib_t  lib )

static

Definition at line 993 of file ittnotify_static.c.

{
    if (lib == NULL)
        return 0;
    if (__itt_get_proc(lib, "__itt_api_init"))
        return 2;
    if (__itt_get_proc(lib, "__itt_api_version"))
        return 1;
    return 0;
}

References __itt_get_proc.

Referenced by init_ittlib().

Here is the caller graph for this function:

__itt_nullify_all_pointers()

static void __itt_nullify_all_pointers ( void  )

static

Definition at line 1014 of file ittnotify_static.c.

{
    int i;
    /* Nulify all pointers except domain_create, string_handle_create  and counter_create */
    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;
}

References _N_.

Referenced by fini_ittlib(), and init_ittlib().

Here is the caller graph for this function:

__itt_report_error_impl()

static void __itt_report_error_impl ( int  code,   ...  )

static

Definition at line 268 of file ittnotify_static.c.

                                                   {
    va_list args;
    va_start(args, code);
    if (_N_(_ittapi_global).error_handler != NULL)
    {
        __itt_error_handler_t* handler = (__itt_error_handler_t*)(size_t)_N_(_ittapi_global).error_handler;
        handler((__itt_error_code)code, args);
    }
#ifdef ITT_NOTIFY_EXT_REPORT
    _N_(error_handler)(code, args);
#endif /* ITT_NOTIFY_EXT_REPORT */
    va_end(args);
}

References _N_.

_N_() [1/2]

const int _N_ ( err  )

pure virtual

_N_() [2/2]

__itt_global _N_

(

_ittapi_global

)

Initial value:

= {
    ITT_MAGIC,                                     
    ITT_MAJOR, ITT_MINOR, API_VERSION_BUILD,       
    0,                                             
    0,                                             
    0,                                             
    MUTEX_INITIALIZER,                             
    NULL,                                          
    NULL,                                          
    (const char**)&dll_path,                       
    (__itt_api_info*)&api_list,                    
    NULL,                                          
    NULL,                                          
    NULL,                                          
    NULL,                                          
    __itt_collection_normal,                       
    NULL,                                          
    0                                              
}

fini_ittlib()

ITT_EXTERN_C void _N_() fini_ittlib

(

void

)

Definition at line 1028 of file ittnotify_static.c.

{
    __itt_api_fini_t* __itt_api_fini_ptr = NULL;
    static volatile TIDT current_thread = 0;

    if (_N_(_ittapi_global).api_initialized)
    {
        ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
        if (_N_(_ittapi_global).api_initialized)
        {
            if (current_thread == 0)
            {
                if (PTHREAD_SYMBOLS) current_thread = __itt_thread_id();
                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");
                }
                if (__itt_api_fini_ptr)
                {
                    __itt_api_fini_ptr(&_N_(_ittapi_global));
                }

                __itt_nullify_all_pointers();

 /* TODO: !!! not safe !!! don't support unload so far.
  *             if (_N_(_ittapi_global).lib != NULL)
  *                 __itt_unload_lib(_N_(_ittapi_global).lib);
  *             _N_(_ittapi_global).lib = NULL;
  */
                _N_(_ittapi_global).api_initialized = 0;
                current_thread = 0;
            }
        }
        if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    }
}

References __itt_get_proc, __itt_mutex_unlock, __itt_nullify_all_pointers(), __itt_thread_id, _N_, ITT_MUTEX_INIT_AND_LOCK, and PTHREAD_SYMBOLS.

Referenced by init_ittlib().

Here is the call graph for this function:

Here is the caller graph for this function:

init_ittlib()

ITT_EXTERN_C int _N_() init_ittlib	(	const char *	lib_name,
		__itt_group_id	init_groups
	)

Definition at line 1065 of file ittnotify_static.c.

{
    int i;
    __itt_group_id groups;
#ifdef ITT_COMPLETE_GROUP
    __itt_group_id zero_group = __itt_group_none;
#endif /* ITT_COMPLETE_GROUP */
    static volatile TIDT current_thread = 0;

    if (!_N_(_ittapi_global).api_initialized)
    {
#ifndef ITT_SIMPLE_INIT
        ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
#endif /* ITT_SIMPLE_INIT */

        if (!_N_(_ittapi_global).api_initialized)
        {
            if (current_thread == 0)
            {
                if (PTHREAD_SYMBOLS) current_thread = __itt_thread_id();
                if (lib_name == NULL)
                {
                    lib_name = __itt_get_lib_name();
                }
                groups = __itt_get_groups();
                if (DL_SYMBOLS && (groups != __itt_group_none || lib_name != NULL))
                {
                    _N_(_ittapi_global).lib = __itt_load_lib((lib_name == NULL) ? ittnotify_lib_name : lib_name);

                    if (_N_(_ittapi_global).lib != NULL)
                    {
                        __itt_api_init_t* __itt_api_init_ptr;
                        int lib_version = __itt_lib_version(_N_(_ittapi_global).lib);

                        switch (lib_version) {
                        case 0:
                            groups = __itt_group_legacy;
                            /* Falls through */
                        case 1:
                            /* Fill all pointers from dynamic library */
                            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)
                                {
                                    *_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);
                                    if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr == NULL)
                                    {
                                        /* 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
                                        zero_group = (__itt_group_id)(zero_group | _N_(_ittapi_global).api_list_ptr[i].group);
#endif /* ITT_COMPLETE_GROUP */
                                    }
                                }
                                else
                                    *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func;
                            }

                            if (groups == __itt_group_legacy)
                            {
                                /* Compatibility with legacy tools */
                                ITTNOTIFY_NAME(thread_ignore)  = ITTNOTIFY_NAME(thr_ignore);
#if ITT_PLATFORM==ITT_PLATFORM_WIN
                                ITTNOTIFY_NAME(sync_createA)   = ITTNOTIFY_NAME(sync_set_nameA);
                                ITTNOTIFY_NAME(sync_createW)   = ITTNOTIFY_NAME(sync_set_nameW);
#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
                                ITTNOTIFY_NAME(sync_create)    = ITTNOTIFY_NAME(sync_set_name);
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
                                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);
                            }

#ifdef ITT_COMPLETE_GROUP
                            for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
                                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;
#endif /* ITT_COMPLETE_GROUP */
                            break;
                        case 2:
                            __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)
                                __itt_api_init_ptr(&_N_(_ittapi_global), init_groups);
                            break;
                        }
                    }
                    else
                    {
                        __itt_nullify_all_pointers();

#if ITT_PLATFORM==ITT_PLATFORM_WIN
                        int error = __itt_system_error();
#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
                        const char* error = dlerror();
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
                        __itt_report_error(__itt_error_no_module, lib_name, error);
                    }
                }
                else
                {
                    __itt_nullify_all_pointers();
                }
                _N_(_ittapi_global).api_initialized = 1;
                current_thread = 0;
                /* !!! Just to avoid unused code elimination !!! */
                if (__itt_fini_ittlib_ptr == _N_(fini_ittlib)) current_thread = 0;
            }
        }

#ifndef ITT_SIMPLE_INIT
        if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
#endif /* ITT_SIMPLE_INIT */
    }

    /* 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++)
    {
        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].group & init_groups)
        {
            return 1;
        }
    }
    return 0;
}

References __itt_fini_ittlib_ptr, __itt_get_groups(), __itt_get_lib_name(), __itt_get_proc, __itt_group_legacy, __itt_group_none, __itt_lib_version(), __itt_load_lib, __itt_mutex_unlock, __itt_nullify_all_pointers(), __itt_report_error, __itt_system_error, __itt_thread_id, _N_, DL_SYMBOLS, fini_ittlib(), ITT_MUTEX_INIT_AND_LOCK, ittnotify_lib_name, name, notify_sync_cancel, notify_sync_releasing, PTHREAD_SYMBOLS, sync_cancel, sync_createA, sync_releasing, and sync_set_nameW.

Here is the call graph for this function:

ITT_GROUP_LIST()

ITT_GROUP_LIST

(

group_list

)

ITT_VERSIONIZE() [1/17]

static __itt_domain* ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(domain_createW), _init)  ) const

static

Definition at line 292 of file ittnotify_static.c.

{
    __itt_domain *h_tail = NULL, *h = NULL;

    if (name == NULL)
    {
        return NULL;
    }

    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
    if (_N_(_ittapi_global).api_initialized)
    {
        if (ITTNOTIFY_NAME(domain_createW) && ITTNOTIFY_NAME(domain_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW),_init)))
        {
            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            return ITTNOTIFY_NAME(domain_createW)(name);
        }
    }
    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 == NULL)
    {
        NEW_DOMAIN_W(&_N_(_ittapi_global),h,h_tail,name);
    }
    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    return h;
}

References __itt_mutex_unlock, _N_, h, ITT_MUTEX_INIT_AND_LOCK, name, NEW_DOMAIN_W, and PTHREAD_SYMBOLS.

Referenced by ITT_VERSIONIZE().

Here is the caller graph for this function:

ITT_VERSIONIZE() [2/17]

static __itt_domain* ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(domain_createA), _init)  ) const

static

Definition at line 322 of file ittnotify_static.c.

{
    __itt_domain *h_tail = NULL, *h = NULL;

    if (name == NULL)
    {
        return NULL;
    }

    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
    if (_N_(_ittapi_global).api_initialized)
    {
#if ITT_PLATFORM==ITT_PLATFORM_WIN
        if (ITTNOTIFY_NAME(domain_createA) && ITTNOTIFY_NAME(domain_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),_init)))
        {
            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            return ITTNOTIFY_NAME(domain_createA)(name);
        }
#else
        if (ITTNOTIFY_NAME(domain_create) && ITTNOTIFY_NAME(domain_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),_init)))
        {
            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            return ITTNOTIFY_NAME(domain_create)(name);
        }
#endif
    }
    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 == NULL)
    {
        NEW_DOMAIN_A(&_N_(_ittapi_global),h,h_tail,name);
    }
    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    return h;
}

References __itt_fstrcmp, __itt_mutex_unlock, _N_, h, ITT_MUTEX_INIT_AND_LOCK, ITT_VERSIONIZE(), name, NEW_DOMAIN_A, and PTHREAD_SYMBOLS.

Here is the call graph for this function:

ITT_VERSIONIZE() [3/17]

static __itt_string_handle* ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(string_handle_createW), _init)  ) const

static

Definition at line 364 of file ittnotify_static.c.

{
    __itt_string_handle *h_tail = NULL, *h = NULL;

    if (name == NULL)
    {
        return NULL;
    }

    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
    if (_N_(_ittapi_global).api_initialized)
    {
        if (ITTNOTIFY_NAME(string_handle_createW) && ITTNOTIFY_NAME(string_handle_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW),_init)))
        {
            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            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)
    {
        if (h->strW != NULL && !wcscmp(h->strW, name)) break;
    }
    if (h == NULL)
    {
        NEW_STRING_HANDLE_W(&_N_(_ittapi_global),h,h_tail,name);
    }
    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    return h;
}

References __itt_mutex_unlock, _N_, h, ITT_MUTEX_INIT_AND_LOCK, ITT_VERSIONIZE(), name, and NEW_STRING_HANDLE_W.

Here is the call graph for this function:

ITT_VERSIONIZE() [4/17]

static __itt_string_handle* ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(string_handle_createA), _init)  ) const

static

Definition at line 394 of file ittnotify_static.c.

{
    __itt_string_handle *h_tail = NULL, *h = NULL;

    if (name == NULL)
    {
        return NULL;
    }

    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
    if (_N_(_ittapi_global).api_initialized)
    {
#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)))
        {
            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            return ITTNOTIFY_NAME(string_handle_createA)(name);
        }
#else
        if (ITTNOTIFY_NAME(string_handle_create) && ITTNOTIFY_NAME(string_handle_create) != 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);
        }
#endif
    }
    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 == NULL)
    {
        NEW_STRING_HANDLE_A(&_N_(_ittapi_global),h,h_tail,name);
    }
    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    return h;
}

References __itt_fstrcmp, __itt_mutex_unlock, _N_, h, ITT_MUTEX_INIT_AND_LOCK, ITT_VERSIONIZE(), name, NEW_STRING_HANDLE_A, and PTHREAD_SYMBOLS.

Here is the call graph for this function:

ITT_VERSIONIZE() [5/17]

static __itt_counter ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(counter_createW), _init)  ) const

static

Definition at line 436 of file ittnotify_static.c.

{
    __itt_counter_info_t *h_tail = NULL, *h = NULL;
    __itt_metadata_type type = __itt_metadata_u64;

    if (name == NULL)
    {
        return NULL;
    }

    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
    if (_N_(_ittapi_global).api_initialized)
    {
        if (ITTNOTIFY_NAME(counter_createW) && ITTNOTIFY_NAME(counter_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW),_init)))
        {
            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            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)
    {
        if (h->nameW != NULL  && h->type == type && !wcscmp(h->nameW, name) && ((h->domainW == NULL && domain == NULL) ||
            (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain)))) break;

    }
    if (h == NULL)
    {
        NEW_COUNTER_W(&_N_(_ittapi_global),h,h_tail,name,domain,type);
    }
    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    return (__itt_counter)h;
}

References __itt_metadata_u64, __itt_mutex_unlock, _N_, domain, h, ITT_MUTEX_INIT_AND_LOCK, ITT_VERSIONIZE(), name, NEW_COUNTER_W, and type.

Here is the call graph for this function:

ITT_VERSIONIZE() [6/17]

static __itt_counter ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(counter_createA), _init)  ) const

static

Definition at line 469 of file ittnotify_static.c.

{
    __itt_counter_info_t *h_tail = NULL, *h = NULL;
    __itt_metadata_type type = __itt_metadata_u64;

    if (name == NULL)
    {
        return NULL;
    }

    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
    if (_N_(_ittapi_global).api_initialized)
    {
#if ITT_PLATFORM==ITT_PLATFORM_WIN
        if (ITTNOTIFY_NAME(counter_createA) && ITTNOTIFY_NAME(counter_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),_init)))
        {
    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            return ITTNOTIFY_NAME(counter_createA)(name, domain);
        }
#else
        if (ITTNOTIFY_NAME(counter_create) && ITTNOTIFY_NAME(counter_create) != 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);
        }
#endif
    }
    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) || 
            (h->domainA != NULL && domain != NULL && !__itt_fstrcmp(h->domainA, domain)))) break;
    }
    if (h == NULL)
    {
       NEW_COUNTER_A(&_N_(_ittapi_global),h,h_tail,name,domain,type);
    }
    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    return (__itt_counter)h;
}

References __itt_fstrcmp, __itt_metadata_u64, __itt_mutex_unlock, _N_, domain, h, ITT_MUTEX_INIT_AND_LOCK, ITT_VERSIONIZE(), name, NEW_COUNTER_A, PTHREAD_SYMBOLS, and type.

Here is the call graph for this function:

ITT_VERSIONIZE() [7/17]

static __itt_counter ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(counter_create_typedW), _init)  ) const

static

Definition at line 513 of file ittnotify_static.c.

{
    __itt_counter_info_t *h_tail = NULL, *h = NULL;

    if (name == NULL)
    {
        return NULL;
    }

    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
    if (_N_(_ittapi_global).api_initialized)
    {
        if (ITTNOTIFY_NAME(counter_create_typedW) && ITTNOTIFY_NAME(counter_create_typedW) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),_init)))
        {
            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            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)
    {
        if (h->nameW != NULL  && h->type == type && !wcscmp(h->nameW, name) && ((h->domainW == NULL && domain == NULL) ||
            (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain)))) break;

    }
    if (h == NULL)
    {
        NEW_COUNTER_W(&_N_(_ittapi_global),h,h_tail,name,domain,type);
    }
    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    return (__itt_counter)h;
}

References __itt_mutex_unlock, _N_, domain, h, ITT_MUTEX_INIT_AND_LOCK, ITT_VERSIONIZE(), name, NEW_COUNTER_W, and type.

Here is the call graph for this function:

ITT_VERSIONIZE() [8/17]

static __itt_counter ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(counter_create_typedA), _init)  ) const

static

Definition at line 545 of file ittnotify_static.c.

{
    __itt_counter_info_t *h_tail = NULL, *h = NULL;

    if (name == NULL)
    {
        return NULL;
    }

    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
    if (_N_(_ittapi_global).api_initialized)
    {
#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)))
        {
            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
            return ITTNOTIFY_NAME(counter_create_typedA)(name, domain, type);
        }
#else
        if (ITTNOTIFY_NAME(counter_create_typed) && ITTNOTIFY_NAME(counter_create_typed) != 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);
        }
#endif
    }
    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) || 
            (h->domainA != NULL && domain != NULL && !__itt_fstrcmp(h->domainA, domain)))) break;
    }
    if (h == NULL)
    {
       NEW_COUNTER_A(&_N_(_ittapi_global),h,h_tail,name,domain,type);
    }
    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
    return (__itt_counter)h;
}

References __itt_fstrcmp, __itt_mutex_unlock, _N_, domain, h, ITT_MUTEX_INIT_AND_LOCK, ITT_VERSIONIZE(), name, NEW_COUNTER_A, PTHREAD_SYMBOLS, and type.

Here is the call graph for this function:

ITT_VERSIONIZE() [9/17]

static void ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(pause), _init)  )

static

Definition at line 589 of file ittnotify_static.c.

{
    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
    {
        __itt_init_ittlib_name(NULL, __itt_group_all);
    }
    if (ITTNOTIFY_NAME(pause) && ITTNOTIFY_NAME(pause) != ITT_VERSIONIZE(ITT_JOIN(_N_(pause),_init)))
    {
        ITTNOTIFY_NAME(pause)();
    }
    else
    {
        _N_(_ittapi_global).state = __itt_collection_paused;
    }
}

References __itt_collection_paused, __itt_group_all, __itt_init_ittlib_name, _N_, ITT_VERSIONIZE(), and tbb::internal::pause().

Here is the call graph for this function:

ITT_VERSIONIZE() [10/17]

static void ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(resume), _init)  )

static

Definition at line 605 of file ittnotify_static.c.

{
    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
    {
        __itt_init_ittlib_name(NULL, __itt_group_all);
    }
    if (ITTNOTIFY_NAME(resume) && ITTNOTIFY_NAME(resume) != ITT_VERSIONIZE(ITT_JOIN(_N_(resume),_init)))
    {
        ITTNOTIFY_NAME(resume)();
    }
    else
    {
        _N_(_ittapi_global).state = __itt_collection_normal;
    }
}

References __itt_collection_normal, __itt_group_all, __itt_init_ittlib_name, _N_, and ITT_VERSIONIZE().

Here is the call graph for this function:

ITT_VERSIONIZE() [11/17]

static void ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(thread_set_nameW), _init)  ) const

static

Definition at line 622 of file ittnotify_static.c.

{
    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
    {
        __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)))
    {
        ITTNOTIFY_NAME(thread_set_nameW)(name);
    }
}

References __itt_group_all, __itt_init_ittlib_name, _N_, ITT_VERSIONIZE(), and name.

Here is the call graph for this function:

ITT_VERSIONIZE() [12/17]

static int ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(thr_name_setW), _init)  ) const

static

Definition at line 634 of file ittnotify_static.c.

{
    (void)namelen;
    ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init))(name);
    return 0;
}

References _N_, ITT_VERSIONIZE(), name, namelen, and void.

Here is the call graph for this function:

ITT_VERSIONIZE() [13/17]

static void ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(thread_set_nameA), _init)  ) const

static

Definition at line 641 of file ittnotify_static.c.

{
    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
    {
        __itt_init_ittlib_name(NULL, __itt_group_all);
    }
#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)))
    {
        ITTNOTIFY_NAME(thread_set_nameA)(name);
    }
#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)))
    {
        ITTNOTIFY_NAME(thread_set_name)(name);
    }
#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
}

References __itt_group_all, __itt_init_ittlib_name, _N_, ITT_VERSIONIZE(), and name.

Here is the call graph for this function:

ITT_VERSIONIZE() [14/17]

static int ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(thr_name_setA), _init)  ) const

static

Definition at line 664 of file ittnotify_static.c.

{
    (void)namelen;
    ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init))(name);
    return 0;
}

References _N_, ITT_VERSIONIZE(), name, namelen, and void.

Here is the call graph for this function:

ITT_VERSIONIZE() [15/17]

static void ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(thread_ignore), _init)  )

static

Definition at line 679 of file ittnotify_static.c.

{
    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
    {
        __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)))
    {
        ITTNOTIFY_NAME(thread_ignore)();
    }
}

References __itt_group_all, __itt_init_ittlib_name, _N_, and ITT_VERSIONIZE().

Here is the call graph for this function:

ITT_VERSIONIZE() [16/17]

static void ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(thr_ignore), _init)  )

static

Definition at line 691 of file ittnotify_static.c.

{
    ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore),_init))();
}

References _N_, and ITT_VERSIONIZE().

Here is the call graph for this function:

ITT_VERSIONIZE() [17/17]

static void ITTAPI ITT_VERSIONIZE ( ITT_JOIN(_N_(enable_attach), _init)  )

static

Definition at line 696 of file ittnotify_static.c.

{
#ifdef __ANDROID__
    /*
     * if LIB_VAR_NAME env variable were set before then stay previous value
     * else set default path
    */
    setenv(ITT_TO_STR(LIB_VAR_NAME), ANDROID_ITTNOTIFY_DEFAULT_PATH, 0);
#endif
}

References ITT_TO_STR, and LIB_VAR_NAME.

mark_pt_region_begin()

ITT_EXTERN_C void _N_() mark_pt_region_begin

(

__itt_pt_region

region

)

__itt_mark_pt_region functions marks region of interest region parameter defines different regions. 0 <= region < 8

Definition at line 1213 of file ittnotify_static.c.

{
#if defined(ITT_API_IPT_SUPPORT) && (ITT_PLATFORM==ITT_PLATFORM_WIN || ITT_PLATFORM==ITT_PLATFORM_POSIX) && !defined(__ANDROID__)
    if (_N_(_ittapi_global).ipt_collect_events == 1)
    {
        __itt_pt_mark_event(2*region);
    }
    else
    {
        __itt_pt_mark(2*region);
    }
#else
    (void)region;
#endif
}

References _N_, and void.

mark_pt_region_end()

ITT_EXTERN_C void _N_() mark_pt_region_end

(

__itt_pt_region

region

)

Definition at line 1229 of file ittnotify_static.c.

{
#if defined(ITT_API_IPT_SUPPORT) && (ITT_PLATFORM==ITT_PLATFORM_WIN || ITT_PLATFORM==ITT_PLATFORM_POSIX) && !defined(__ANDROID__)
    if (_N_(_ittapi_global).ipt_collect_events == 1)
    {
        __itt_pt_mark_event(2*region + 1);
    }
    else
    {
        __itt_pt_mark(2*region + 1);
    }
#else
     (void)region;
#endif
}

References _N_, and void.

set_error_handler()

ITT_EXTERN_C __itt_error_handler_t* _N_() set_error_handler

(

__itt_error_handler_t *

handler

)

Definition at line 1193 of file ittnotify_static.c.

{
    __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;
    return prev;
}

References _N_.

Variable Documentation

__itt_fini_ittlib_ptr

__itt_fini_ittlib_t* __itt_fini_ittlib_ptr = _N_(fini_ittlib)

static

Definition at line 129 of file ittnotify_static.c.

Referenced by init_ittlib().

__itt_init_ittlib_ptr

__itt_init_ittlib_t* __itt_init_ittlib_ptr = _N_(init_ittlib)

static

Definition at line 120 of file ittnotify_static.c.

api_list

__itt_api_info api_list[]

static

Definition at line 209 of file ittnotify_static.c.

api_version

const char api_version[] = API_VERSION "\0\n@(#) $Revision$\n"

static

Definition at line 38 of file ittnotify_static.c.

dll_path

const char dll_path[PATH_MAX] = { 0 }

static

Definition at line 231 of file ittnotify_static.c.

group_alias

__itt_group_alias group_alias[]

static

Initial value:

= {
    { "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_sync  | __itt_group_fsync | __itt_group_mark | __itt_group_suppress) },
    { NULL,               (__itt_group_none) },
    { api_version,        (__itt_group_none) } 
}

Definition at line 195 of file ittnotify_static.c.

Referenced by __itt_get_groups().

ittnotify_lib_name

const char* ittnotify_lib_name = "libittnotify.dll"

static

Definition at line 43 of file ittnotify_static.c.

Referenced by init_ittlib().