contrib/llvm/lib/ExecutionEngine/IntelJITEvents/jitprofiling.c

   1 /*===-- jitprofiling.c - JIT (Just-In-Time) Profiling API----------*- C -*-===*
   2  *
   3  *                     The LLVM Compiler Infrastructure
   4  *
   5  * This file is distributed under the University of Illinois Open Source
   6  * License. See LICENSE.TXT for details.
   7  *
   8  *===----------------------------------------------------------------------===*
   9  *
  10  * This file provides Intel(R) Performance Analyzer JIT (Just-In-Time)
  11  * Profiling API implementation.
  12  *
  13  * NOTE: This file comes in a style different from the rest of LLVM
  14  * source base since  this is a piece of code shared from Intel(R)
  15  * products.  Please do not reformat / re-style this code to make
  16  * subsequent merges and contributions from the original source base eaiser.
  17  *
  18  *===----------------------------------------------------------------------===*/
  19 #include "ittnotify_config.h"
  20
  21 #if ITT_PLATFORM==ITT_PLATFORM_WIN
  22 #include <windows.h>
  23 #pragma optimize("", off)
  24 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
  25 #include <pthread.h>
  26 #include <dlfcn.h>
  27 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
  28 #include <malloc.h>
  29 #include <stdlib.h>
  30
  31 #include "jitprofiling.h"
  32
  33 static const char rcsid[] = "\n@(#) $Revision: 243501 $\n";
  34
  35 #define DLL_ENVIRONMENT_VAR             "VS_PROFILER"
  36
  37 #ifndef NEW_DLL_ENVIRONMENT_VAR
  38 #if ITT_ARCH==ITT_ARCH_IA32
  39 #define NEW_DLL_ENVIRONMENT_VAR         "INTEL_JIT_PROFILER32"
  40 #else
  41 #define NEW_DLL_ENVIRONMENT_VAR         "INTEL_JIT_PROFILER64"
  42 #endif
  43 #endif /* NEW_DLL_ENVIRONMENT_VAR */
  44
  45 #if ITT_PLATFORM==ITT_PLATFORM_WIN
  46 #define DEFAULT_DLLNAME                 "JitPI.dll"
  47 HINSTANCE m_libHandle = NULL;
  48 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
  49 #define DEFAULT_DLLNAME                 "libJitPI.so"
  50 void* m_libHandle = NULL;
  51 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
  52
  53 /* default location of JIT profiling agent on Android */
  54 #define ANDROID_JIT_AGENT_PATH  "/data/intel/libittnotify.so"
  55
  56 /* the function pointers */
  57 typedef unsigned int(*TPInitialize)(void);
  58 static TPInitialize FUNC_Initialize=NULL;
  59
  60 typedef unsigned int(*TPNotify)(unsigned int, void*);
  61 static TPNotify FUNC_NotifyEvent=NULL;
  62
  63 static iJIT_IsProfilingActiveFlags executionMode = iJIT_NOTHING_RUNNING;
  64
  65 /* end collector dll part. */
  66
  67 /* loadiJIT_Funcs() : this function is called just in the beginning
  68  *  and is responsible to load the functions from BistroJavaCollector.dll
  69  * result:
  70  *  on success: the functions loads, iJIT_DLL_is_missing=0, return value = 1
  71  *  on failure: the functions are NULL, iJIT_DLL_is_missing=1, return value = 0
  72  */
  73 static int loadiJIT_Funcs(void);
  74
  75 /* global representing whether the BistroJavaCollector can't be loaded */
  76 static int iJIT_DLL_is_missing = 0;
  77
  78 /* Virtual stack - the struct is used as a virtual stack for each thread.
  79  * Every thread initializes with a stack of size INIT_TOP_STACK.
  80  * Every method entry decreases from the current stack point,
  81  * and when a thread stack reaches its top of stack (return from the global
  82  * function), the top of stack and the current stack increase. Notice that
  83  * when returning from a function the stack pointer is the address of
  84  * the function return.
  85 */
  86 #if ITT_PLATFORM==ITT_PLATFORM_WIN
  87 static DWORD threadLocalStorageHandle = 0;
  88 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
  89 static pthread_key_t threadLocalStorageHandle = (pthread_key_t)0;
  90 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
  91
  92 #define INIT_TOP_Stack 10000
  93
  94 typedef struct
  95 {
  96     unsigned int TopStack;
  97     unsigned int CurrentStack;
  98 } ThreadStack, *pThreadStack;
  99
 100 /* end of virtual stack. */
 101
 102 /*
 103  * The function for reporting virtual-machine related events to VTune.
 104  * Note: when reporting iJVM_EVENT_TYPE_ENTER_NIDS, there is no need to fill
 105  * in the stack_id field in the iJIT_Method_NIDS structure, as VTune fills it.
 106  * The return value in iJVM_EVENT_TYPE_ENTER_NIDS &&
 107  * iJVM_EVENT_TYPE_LEAVE_NIDS events will be 0 in case of failure.
 108  * in iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED event
 109  * it will be -1 if EventSpecificData == 0 otherwise it will be 0.
 110 */
 111
 112 ITT_EXTERN_C int JITAPI
 113 iJIT_NotifyEvent(iJIT_JVM_EVENT event_type, void *EventSpecificData)
 114 {
 115     int ReturnValue;
 116
 117     /*
 118      * This section is for debugging outside of VTune.
 119      * It creates the environment variables that indicates call graph mode.
 120      * If running outside of VTune remove the remark.
 121      *
 122      *
 123      * static int firstTime = 1;
 124      * char DoCallGraph[12] = "DoCallGraph";
 125      * if (firstTime)
 126      * {
 127      * firstTime = 0;
 128      * SetEnvironmentVariable( "BISTRO_COLLECTORS_DO_CALLGRAPH", DoCallGraph);
 129      * }
 130      *
 131      * end of section.
 132     */
 133
 134     /* initialization part - the functions have not been loaded yet. This part
 135      *        will load the functions, and check if we are in Call Graph mode.
 136      *        (for special treatment).
 137      */
 138     if (!FUNC_NotifyEvent)
 139     {
 140         if (iJIT_DLL_is_missing)
 141             return 0;
 142
 143         /* load the Function from the DLL */
 144         if (!loadiJIT_Funcs())
 145             return 0;
 146
 147         /* Call Graph initialization. */
 148     }
 149
 150     /* If the event is method entry/exit, check that in the current mode
 151      * VTune is allowed to receive it
 152      */
 153     if ((event_type == iJVM_EVENT_TYPE_ENTER_NIDS ||
 154          event_type == iJVM_EVENT_TYPE_LEAVE_NIDS) &&
 155         (executionMode != iJIT_CALLGRAPH_ON))
 156     {
 157         return 0;
 158     }
 159     /* This section is performed when method enter event occurs.
 160      * It updates the virtual stack, or creates it if this is the first
 161      * method entry in the thread. The stack pointer is decreased.
 162      */
 163     if (event_type == iJVM_EVENT_TYPE_ENTER_NIDS)
 164     {
 165 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 166         pThreadStack threadStack =
 167             (pThreadStack)TlsGetValue (threadLocalStorageHandle);
 168 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 169         pThreadStack threadStack =
 170             (pThreadStack)pthread_getspecific(threadLocalStorageHandle);
 171 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 172
 173         /* check for use of reserved method IDs */
 174         if ( ((piJIT_Method_NIDS) EventSpecificData)->method_id <= 999 )
 175             return 0;
 176
 177         if (!threadStack)
 178         {
 179             /* initialize the stack. */
 180             threadStack = (pThreadStack) calloc (sizeof(ThreadStack), 1);
 181             threadStack->TopStack = INIT_TOP_Stack;
 182             threadStack->CurrentStack = INIT_TOP_Stack;
 183 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 184             TlsSetValue(threadLocalStorageHandle,(void*)threadStack);
 185 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 186             pthread_setspecific(threadLocalStorageHandle,(void*)threadStack);
 187 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 188         }
 189
 190         /* decrease the stack. */
 191         ((piJIT_Method_NIDS) EventSpecificData)->stack_id =
 192             (threadStack->CurrentStack)--;
 193     }
 194
 195     /* This section is performed when method leave event occurs
 196      * It updates the virtual stack.
 197      *    Increases the stack pointer.
 198      *    If the stack pointer reached the top (left the global function)
 199      *        increase the pointer and the top pointer.
 200      */
 201     if (event_type == iJVM_EVENT_TYPE_LEAVE_NIDS)
 202     {
 203 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 204         pThreadStack threadStack =
 205            (pThreadStack)TlsGetValue (threadLocalStorageHandle);
 206 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 207         pThreadStack threadStack =
 208             (pThreadStack)pthread_getspecific(threadLocalStorageHandle);
 209 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 210
 211         /* check for use of reserved method IDs */
 212         if ( ((piJIT_Method_NIDS) EventSpecificData)->method_id <= 999 )
 213             return 0;
 214
 215         if (!threadStack)
 216         {
 217             /* Error: first report in this thread is method exit */
 218             exit (1);
 219         }
 220
 221         ((piJIT_Method_NIDS) EventSpecificData)->stack_id =
 222             ++(threadStack->CurrentStack) + 1;
 223
 224         if (((piJIT_Method_NIDS) EventSpecificData)->stack_id
 225                > threadStack->TopStack)
 226             ((piJIT_Method_NIDS) EventSpecificData)->stack_id =
 227                 (unsigned int)-1;
 228     }
 229
 230     if (event_type == iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED)
 231     {
 232         /* check for use of reserved method IDs */
 233         if ( ((piJIT_Method_Load) EventSpecificData)->method_id <= 999 )
 234             return 0;
 235     }
 236
 237     ReturnValue = (int)FUNC_NotifyEvent(event_type, EventSpecificData);
 238
 239     return ReturnValue;
 240 }
 241
 242 /* The new mode call back routine */
 243 ITT_EXTERN_C void JITAPI
 244 iJIT_RegisterCallbackEx(void *userdata, iJIT_ModeChangedEx
 245                         NewModeCallBackFuncEx)
 246 {
 247     /* is it already missing... or the load of functions from the DLL failed */
 248     if (iJIT_DLL_is_missing || !loadiJIT_Funcs())
 249     {
 250         /* then do not bother with notifications */
 251         NewModeCallBackFuncEx(userdata, iJIT_NO_NOTIFICATIONS);
 252         /* Error: could not load JIT functions. */
 253         return;
 254     }
 255     /* nothing to do with the callback */
 256 }
 257
 258 /*
 259  * This function allows the user to query in which mode, if at all,
 260  *VTune is running
 261  */
 262 ITT_EXTERN_C iJIT_IsProfilingActiveFlags JITAPI iJIT_IsProfilingActive()
 263 {
 264     if (!iJIT_DLL_is_missing)
 265     {
 266         loadiJIT_Funcs();
 267     }
 268
 269     return executionMode;
 270 }
 271
 272 /* this function loads the collector dll (BistroJavaCollector)
 273  * and the relevant functions.
 274  * on success: all functions load,     iJIT_DLL_is_missing = 0, return value = 1
 275  * on failure: all functions are NULL, iJIT_DLL_is_missing = 1, return value = 0
 276  */
 277 static int loadiJIT_Funcs()
 278 {
 279     static int bDllWasLoaded = 0;
 280     char *dllName = (char*)rcsid; /* !! Just to avoid unused code elimination */
 281 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 282     DWORD dNameLength = 0;
 283 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 284
 285     if(bDllWasLoaded)
 286     {
 287         /* dll was already loaded, no need to do it for the second time */
 288         return 1;
 289     }
 290
 291     /* Assumes that the DLL will not be found */
 292     iJIT_DLL_is_missing = 1;
 293     FUNC_NotifyEvent = NULL;
 294
 295     if (m_libHandle)
 296     {
 297 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 298         FreeLibrary(m_libHandle);
 299 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 300         dlclose(m_libHandle);
 301 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 302         m_libHandle = NULL;
 303     }
 304
 305     /* Try to get the dll name from the environment */
 306 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 307     dNameLength = GetEnvironmentVariableA(NEW_DLL_ENVIRONMENT_VAR, NULL, 0);
 308     if (dNameLength)
 309     {
 310         DWORD envret = 0;
 311         dllName = (char*)malloc(sizeof(char) * (dNameLength + 1));
 312         envret = GetEnvironmentVariableA(NEW_DLL_ENVIRONMENT_VAR,
 313                                          dllName, dNameLength);
 314         if (envret)
 315         {
 316             /* Try to load the dll from the PATH... */
 317             m_libHandle = LoadLibraryExA(dllName,
 318                                          NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 319         }
 320         free(dllName);
 321     } else {
 322         /* Try to use old VS_PROFILER variable */
 323         dNameLength = GetEnvironmentVariableA(DLL_ENVIRONMENT_VAR, NULL, 0);
 324         if (dNameLength)
 325         {
 326             DWORD envret = 0;
 327             dllName = (char*)malloc(sizeof(char) * (dNameLength + 1));
 328             envret = GetEnvironmentVariableA(DLL_ENVIRONMENT_VAR,
 329                                              dllName, dNameLength);
 330             if (envret)
 331             {
 332                 /* Try to load the dll from the PATH... */
 333                 m_libHandle = LoadLibraryA(dllName);
 334             }
 335             free(dllName);
 336         }
 337     }
 338 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 339     dllName = getenv(NEW_DLL_ENVIRONMENT_VAR);
 340     if (!dllName)
 341         dllName = getenv(DLL_ENVIRONMENT_VAR);
 342 #ifdef ANDROID
 343     if (!dllName)
 344         dllName = ANDROID_JIT_AGENT_PATH;
 345 #endif
 346     if (dllName)
 347     {
 348         /* Try to load the dll from the PATH... */
 349         m_libHandle = dlopen(dllName, RTLD_LAZY);
 350     }
 351 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 352
 353     if (!m_libHandle)
 354     {
 355 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 356         m_libHandle = LoadLibraryA(DEFAULT_DLLNAME);
 357 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 358         m_libHandle = dlopen(DEFAULT_DLLNAME, RTLD_LAZY);
 359 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 360     }
 361
 362     /* if the dll wasn't loaded - exit. */
 363     if (!m_libHandle)
 364     {
 365         iJIT_DLL_is_missing = 1; /* don't try to initialize
 366                                   * JIT agent the second time
 367                                   */
 368         return 0;
 369     }
 370
 371 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 372     FUNC_NotifyEvent = (TPNotify)GetProcAddress(m_libHandle, "NotifyEvent");
 373 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 374     FUNC_NotifyEvent = (TPNotify)dlsym(m_libHandle, "NotifyEvent");
 375 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 376     if (!FUNC_NotifyEvent)
 377     {
 378         FUNC_Initialize = NULL;
 379         return 0;
 380     }
 381
 382 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 383     FUNC_Initialize = (TPInitialize)GetProcAddress(m_libHandle, "Initialize");
 384 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 385     FUNC_Initialize = (TPInitialize)dlsym(m_libHandle, "Initialize");
 386 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 387     if (!FUNC_Initialize)
 388     {
 389         FUNC_NotifyEvent = NULL;
 390         return 0;
 391     }
 392
 393     executionMode = (iJIT_IsProfilingActiveFlags)FUNC_Initialize();
 394
 395     bDllWasLoaded = 1;
 396     iJIT_DLL_is_missing = 0; /* DLL is ok. */
 397
 398     /*
 399      * Call Graph mode: init the thread local storage
 400      * (need to store the virtual stack there).
 401      */
 402     if ( executionMode == iJIT_CALLGRAPH_ON )
 403     {
 404         /* Allocate a thread local storage slot for the thread "stack" */
 405         if (!threadLocalStorageHandle)
 406 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 407             threadLocalStorageHandle = TlsAlloc();
 408 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 409         pthread_key_create(&threadLocalStorageHandle, NULL);
 410 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 411     }
 412
 413     return 1;
 414 }
 415
 416 /*
 417  * This function should be called by the user whenever a thread ends,
 418  * to free the thread "virtual stack" storage
 419  */
 420 ITT_EXTERN_C void JITAPI FinalizeThread()
 421 {
 422     if (threadLocalStorageHandle)
 423     {
 424 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 425         pThreadStack threadStack =
 426             (pThreadStack)TlsGetValue (threadLocalStorageHandle);
 427 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 428         pThreadStack threadStack =
 429             (pThreadStack)pthread_getspecific(threadLocalStorageHandle);
 430 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 431         if (threadStack)
 432         {
 433             free (threadStack);
 434             threadStack = NULL;
 435 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 436             TlsSetValue (threadLocalStorageHandle, threadStack);
 437 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 438             pthread_setspecific(threadLocalStorageHandle, threadStack);
 439 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 440         }
 441     }
 442 }
 443
 444 /*
 445  * This function should be called by the user when the process ends,
 446  * to free the local storage index
 447 */
 448 ITT_EXTERN_C void JITAPI FinalizeProcess()
 449 {
 450     if (m_libHandle)
 451     {
 452 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 453         FreeLibrary(m_libHandle);
 454 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 455         dlclose(m_libHandle);
 456 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 457         m_libHandle = NULL;
 458     }
 459
 460     if (threadLocalStorageHandle)
 461 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 462         TlsFree (threadLocalStorageHandle);
 463 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 464     pthread_key_delete(threadLocalStorageHandle);
 465 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 466 }
 467
 468 /*
 469  * This function should be called by the user for any method once.
 470  * The function will return a unique method ID, the user should maintain
 471  * the ID for each method
 472  */
 473 ITT_EXTERN_C unsigned int JITAPI iJIT_GetNewMethodID()
 474 {
 475     static unsigned int methodID = 0x100000;
 476
 477     if (methodID == 0)
 478         return 0;  /* ERROR : this is not a valid value */
 479
 480     return methodID++;
 481 }