Implement in-heap backing store for typed arrays.

src/third_party/vtune/jitprofiling.cc

 /*
   This file is provided under a dual BSD/GPLv2 license.  When using or
   redistributing this file, you may do so under either license.
 
   GPL LICENSE SUMMARY
 
   Copyright(c) 2005-2012 Intel Corporation. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of version 2 of the GNU General Public License as
@@ skipping 85 matching lines @@
 typedef unsigned int(*TPInitialize)(void);
 static TPInitialize FUNC_Initialize=NULL;
 
 typedef unsigned int(*TPNotify)(unsigned int, void*);
 static TPNotify FUNC_NotifyEvent=NULL;
 
 static iJIT_IsProfilingActiveFlags executionMode = iJIT_NOTHING_RUNNING;
 
 /* end collector dll part. */
 
-/* loadiJIT_Funcs() : this function is called just in the beginning and is responsible 
+/* loadiJIT_Funcs() : this function is called just in the beginning and is responsible
 ** to load the functions from BistroJavaCollector.dll
 ** result:
 **              on success: the functions loads,    iJIT_DLL_is_missing=0, return value = 1.
 **              on failure: the functions are NULL, iJIT_DLL_is_missing=1, return value = 0.
-*/ 
+*/
 static int loadiJIT_Funcs(void);
 
 /* global representing whether the BistroJavaCollector can't be loaded */
 static int iJIT_DLL_is_missing = 0;
 
 /* Virtual stack - the struct is used as a virtual stack for each thread.
 ** Every thread initializes with a stack of size INIT_TOP_STACK.
 ** Every method entry decreases from the current stack point,
 ** and when a thread stack reaches its top of stack (return from the global function),
 ** the top of stack and the current stack increase. Notice that when returning from a function
 ** the stack pointer is the address of the function return.
 */
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 static DWORD threadLocalStorageHandle = 0;
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 static pthread_key_t threadLocalStorageHandle = (pthread_key_t)0;
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #define INIT_TOP_Stack 10000
 
-typedef struct 
+typedef struct
 {
     unsigned int TopStack;
     unsigned int CurrentStack;
 } ThreadStack, *pThreadStack;
 
 /* end of virtual stack. */
 
 /*
 ** The function for reporting virtual-machine related events to VTune.
-** Note: when reporting iJVM_EVENT_TYPE_ENTER_NIDS, there is no need to fill in the stack_id 
+** Note: when reporting iJVM_EVENT_TYPE_ENTER_NIDS, there is no need to fill in the stack_id
 ** field in the iJIT_Method_NIDS structure, as VTune fills it.
-** 
+**
 ** The return value in iJVM_EVENT_TYPE_ENTER_NIDS && iJVM_EVENT_TYPE_LEAVE_NIDS events
 ** will be 0 in case of failure.
 ** in iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED event it will be -1 if EventSpecificData == 0
 ** otherwise it will be 0.
 */
 
 ITT_EXTERN_C int JITAPI iJIT_NotifyEvent(iJIT_JVM_EVENT event_type, void *EventSpecificData)
 {
     int ReturnValue;
 
     /*******************************************************************************
-    ** This section is for debugging outside of VTune. 
+    ** This section is for debugging outside of VTune.
     ** It creates the environment variables that indicates call graph mode.
     ** If running outside of VTune remove the remark.
     **
 
       static int firstTime = 1;
       char DoCallGraph[12] = "DoCallGraph";
       if (firstTime)
       {
       firstTime = 0;
       SetEnvironmentVariable( "BISTRO_COLLECTORS_DO_CALLGRAPH", DoCallGraph);
       }
 
     ** end of section.
     *******************************************************************************/
 
     /* initialization part - the functions have not been loaded yet. This part
-    **          will load the functions, and check if we are in Call Graph mode. 
+    **          will load the functions, and check if we are in Call Graph mode.
     **          (for special treatment).
     */
-    if (!FUNC_NotifyEvent) 
+    if (!FUNC_NotifyEvent)
     {
-        if (iJIT_DLL_is_missing) 
+        if (iJIT_DLL_is_missing)
             return 0;
 
         // load the Function from the DLL
-        if (!loadiJIT_Funcs()) 
+        if (!loadiJIT_Funcs())
             return 0;
 
         /* Call Graph initialization. */
     }
 
-    /* If the event is method entry/exit, check that in the current mode 
+    /* If the event is method entry/exit, check that in the current mode
     ** VTune is allowed to receive it
     */
     if ((event_type == iJVM_EVENT_TYPE_ENTER_NIDS || event_type == iJVM_EVENT_TYPE_LEAVE_NIDS) &&
         (executionMode != iJIT_CALLGRAPH_ON))
     {
         return 0;
     }
     /* This section is performed when method enter event occurs.
-    ** It updates the virtual stack, or creates it if this is the first 
+    ** It updates the virtual stack, or creates it if this is the first
     ** method entry in the thread. The stack pointer is decreased.
     */
     if (event_type == iJVM_EVENT_TYPE_ENTER_NIDS)
     {
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
         pThreadStack threadStack = (pThreadStack)TlsGetValue (threadLocalStorageHandle);
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
         pThreadStack threadStack = (pThreadStack)pthread_getspecific(threadLocalStorageHandle);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
@@ skipping 48 matching lines @@
             ((piJIT_Method_NIDS) EventSpecificData)->stack_id = (unsigned int)-1;
     }
 
     if (event_type == iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED)
     {
         // check for use of reserved method IDs
         if ( ((piJIT_Method_Load) EventSpecificData)->method_id <= 999 )
             return 0;
     }
 
-    ReturnValue = (int)FUNC_NotifyEvent(event_type, EventSpecificData);   
+    ReturnValue = (int)FUNC_NotifyEvent(event_type, EventSpecificData);
 
     return ReturnValue;
 }
 
 ITT_EXTERN_C void JITAPI iJIT_RegisterCallbackEx(void *userdata, iJIT_ModeChangedEx NewModeCallBackFuncEx) // The new mode call back routine
 {
     // is it already missing... or the load of functions from the DLL failed
     if (iJIT_DLL_is_missing || !loadiJIT_Funcs())
     {
         NewModeCallBackFuncEx(userdata, iJIT_NO_NOTIFICATIONS);  // then do not bother with notifications
@@ skipping 12 matching lines @@
     {
         loadiJIT_Funcs();
     }
 
     return executionMode;
 }
 #include <stdio.h>
 /* this function loads the collector dll (BistroJavaCollector) and the relevant functions.
 ** on success: all functions load,     iJIT_DLL_is_missing = 0, return value = 1.
 ** on failure: all functions are NULL, iJIT_DLL_is_missing = 1, return value = 0.
-*/ 
+*/
 static int loadiJIT_Funcs()
 {
     static int bDllWasLoaded = 0;
     char *dllName = (char*)rcsid; // !!! Just to avoid unused code elimination !!!
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
     DWORD dNameLength = 0;
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
     if(bDllWasLoaded)
     {// dll was already loaded, no need to do it for the second time
         return 1;
     }
 
     // Assumes that the DLL will not be found
     iJIT_DLL_is_missing = 1;
     FUNC_NotifyEvent = NULL;
 
-    if (m_libHandle) 
+    if (m_libHandle)
     {
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
         FreeLibrary(m_libHandle);
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
         dlclose(m_libHandle);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
         m_libHandle = NULL;
     }
 
     // try to get the dll name from the environment
@@ skipping 55 matching lines @@
     if (!m_libHandle)
     {
         iJIT_DLL_is_missing = 1; // don't try to initialize JIT agent the second time
         return 0;
     }
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
     FUNC_NotifyEvent = (TPNotify)GetProcAddress(m_libHandle, "NotifyEvent");
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
     FUNC_NotifyEvent = reinterpret_cast<TPNotify>(reinterpret_cast<intptr_t>(dlsym(m_libHandle, "NotifyEvent")));
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-    if (!FUNC_NotifyEvent) 
+    if (!FUNC_NotifyEvent)
     {
         FUNC_Initialize = NULL;
         return 0;
     }
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
     FUNC_Initialize = (TPInitialize)GetProcAddress(m_libHandle, "Initialize");
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
     FUNC_Initialize = reinterpret_cast<TPInitialize>(reinterpret_cast<intptr_t>(dlsym(m_libHandle, "Initialize")));
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-    if (!FUNC_Initialize) 
+    if (!FUNC_Initialize)
     {
         FUNC_NotifyEvent = NULL;
         return 0;
     }
 
     executionMode = (iJIT_IsProfilingActiveFlags)FUNC_Initialize();
     if (executionMode != iJIT_SAMPLING_ON)
       executionMode = iJIT_SAMPLING_ON;
 
     bDllWasLoaded = 1;
@@ skipping 11 matching lines @@
             threadLocalStorageHandle = TlsAlloc();
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
         pthread_key_create(&threadLocalStorageHandle, NULL);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
     }
 
     return 1;
 }
 
 /*
-** This function should be called by the user whenever a thread ends, to free the thread 
+** This function should be called by the user whenever a thread ends, to free the thread
 ** "virtual stack" storage
 */
 ITT_EXTERN_C void JITAPI FinalizeThread()
 {
     if (threadLocalStorageHandle)
     {
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
         pThreadStack threadStack = (pThreadStack)TlsGetValue (threadLocalStorageHandle);
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
         pThreadStack threadStack = (pThreadStack)pthread_getspecific(threadLocalStorageHandle);
@@ skipping 10 matching lines @@
         }
     }
 }
 
 /*
 ** This function should be called by the user when the process ends, to free the local
 ** storage index
 */
 ITT_EXTERN_C void JITAPI FinalizeProcess()
 {
-    if (m_libHandle) 
+    if (m_libHandle)
     {
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
         FreeLibrary(m_libHandle);
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
         dlclose(m_libHandle);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
         m_libHandle = NULL;
     }
 
     if (threadLocalStorageHandle)
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
         TlsFree (threadLocalStorageHandle);
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
     pthread_key_delete(threadLocalStorageHandle);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 }
 
 /*
 ** This function should be called by the user for any method once.
-** The function will return a unique method ID, the user should maintain the ID for each 
+** The function will return a unique method ID, the user should maintain the ID for each
 ** method
 */
 ITT_EXTERN_C unsigned int JITAPI iJIT_GetNewMethodID()
 {
     static unsigned int methodID = 0x100000;
 
     if (methodID == 0)
         return 0;       // ERROR : this is not a valid value
 
     return methodID++;
 }