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