Update Xray for PNaCl

native_client_sdk/src/libraries/xray/xray.c

 /* Copyright (c) 2013 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 /* XRay -- a simple profiler for Native Client */
 
 #include <assert.h>
 #include <errno.h>
@@ skipping 22 matching lines @@
 #define GTSC(_x)      __asm__ __volatile__ ("rdtsc" : "=A" (_x));
 #else
 FORCE_INLINE uint64_t GTOD() {
   struct timeval tv;
   gettimeofday(&tv, NULL);
   return (uint64_t)tv.tv_sec * 1000000 + (uint64_t)tv.tv_usec;
 }
 #define GTSC(_x) _x = GTOD();
 #endif
 
-
 /* Use a TLS variable for cheap thread uid. */
 __thread struct XRayTraceCapture* g_xray_capture = NULL;
+__thread int g_xray_thread_id_placeholder = 0;
 
 
 struct XRayTraceStackEntry {
   uint32_t depth_addr;
   uint64_t tsc;
   uint32_t dest;
   uint32_t annotation_index;
 };
 
 
 struct XRayTraceFrameEntry {
   /* Indices into global tracebuffer */
   int start;
   int end;
   uint64_t start_tsc;
   uint64_t end_tsc;
   uint64_t total_ticks;
   int annotation_count;
   bool valid;
+
+#ifndef XRAY_DISABLE_BROWSER_INTEGRATION
+  struct XRayTimestampPair start_time;
+  struct XRayTimestampPair end_time;
+#endif

[nfullagar1, 2013/07/18 21:36:00]

nit: there's a mix of #endif and #endif  /* XRAY_DISABLE_BROWSER_INTEGRATION */
Better to have this be consistent one way or the other.

[grosse, 2013/07/18 23:00:06]

Done.

 };
 
 
 struct XRayTraceFrame {
   struct XRayTraceFrameEntry* entry;
   int head;
   int tail;
   int count;
 };
 
@@ skipping 11 matching lines @@
   bool initialized;
   uint32_t annotation_filter;
   uint32_t guard0;
   struct XRayTraceStackEntry stack[XRAY_TRACE_STACK_SIZE] XRAY_ALIGN64;
   uint32_t guard1;
   uint32_t guard2;
   char annotation[XRAY_ANNOTATION_STACK_SIZE] XRAY_ALIGN64;
   uint32_t guard3;
   struct XRayTraceBufferEntry* buffer;
   struct XRayTraceFrame frame;
+
+#ifndef XRAY_DISABLE_BROWSER_INTEGRATION
+  int32_t thread_id;
+#endif
 } XRAY_ALIGN64;
 
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-XRAY_NO_INSTRUMENT void __cyg_profile_func_enter(void* this_fn,
-                                                 void* call_site);
-XRAY_NO_INSTRUMENT void __cyg_profile_func_exit(void* this_fn,
-                                                void* call_site);
+#if defined(__pnacl__)
+XRAY_NO_INSTRUMENT void __pnacl_profile_func_enter(const char* fname);
+XRAY_NO_INSTRUMENT void __pnacl_profile_func_exit(const char* fname);
+#else
+XRAY_NO_INSTRUMENT void __cyg_profile_func_enter(
+    void* this_fn, void* call_site);
+XRAY_NO_INSTRUMENT void __cyg_profile_func_exit(void* this_fn, void* call_site);

[nfullagar1, 2013/07/18 21:36:00]

above: see earlier comment re: indent as it was before.

[grosse, 2013/07/18 23:00:06]

Done.

+#endif
+
 XRAY_NO_INSTRUMENT void __xray_profile_append_annotation(
     struct XRayTraceCapture* capture,
     struct XRayTraceStackEntry* se,
     struct XRayTraceBufferEntry* be);
 
 #ifdef __cplusplus
 }
 #endif
 
-
 /* Asserts that the guard values haven't changed. */
 void XRayCheckGuards(struct XRayTraceCapture* capture) {
   assert(capture->guard0 == XRAY_GUARD_VALUE_0x12345678);
   assert(capture->guard1 == XRAY_GUARD_VALUE_0x12345678);
   assert(capture->guard2 == XRAY_GUARD_VALUE_0x87654321);
   assert(capture->guard3 == XRAY_GUARD_VALUE_0x12345678);
 }
 
 /* Decrements the trace index, wrapping around if needed. */
 XRAY_FORCE_INLINE int XRayTraceDecrementIndexInline(
@@ skipping 169 matching lines @@
 }
 
 
 /* Generic memory free for XRay */
 void XRayFree(void* data) {
   assert(NULL != data);
   free(data);
 }
 
 
-
 /* Main profile capture function that is called at the start */
 /* of every instrumented function.  This function is implicitly */
 /* called when code is compilied with the -finstrument-functions option */
+#if defined(__pnacl__)
+void __pnacl_profile_func_enter(const char* this_fn) {
+#else
 void __cyg_profile_func_enter(void* this_fn, void* call_site) {
+#endif
   struct XRayTraceCapture* capture = g_xray_capture;
   if (capture && capture->recording) {
     uint32_t depth = capture->stack_depth;
     if (depth < capture->max_stack_depth) {
       struct XRayTraceStackEntry* se = &capture->stack[depth];
       uint32_t addr = (uint32_t)this_fn;
       se->depth_addr = XRAY_PACK_DEPTH_ADDR(depth, addr);
       se->dest = capture->buffer_index;
       se->annotation_index = 0;
       GTSC(se->tsc);
       capture->buffer_index =
         XRayTraceIncrementIndexInline(capture, capture->buffer_index);
     }
     ++capture->stack_depth;
   }
 }
 
 
 /* Main profile capture function that is called at the exit of */
 /* every instrumented function.  This function is implicity called */
 /* when the code is compiled with the -finstrument-functions option */
+#if defined(__pnacl__)
+void __pnacl_profile_func_exit(const char* this_fn) {
+#else
 void __cyg_profile_func_exit(void* this_fn, void* call_site) {
+#endif
   struct XRayTraceCapture* capture = g_xray_capture;
   if (capture && capture->recording) {
     --capture->stack_depth;
     if (capture->stack_depth < capture->max_stack_depth) {
       uint32_t depth = capture->stack_depth;
       struct XRayTraceStackEntry* se = &capture->stack[depth];
       uint32_t buffer_index = se->dest;
       uint64_t tsc;
       struct XRayTraceBufferEntry* be = &capture->buffer[buffer_index];
       GTSC(tsc);
       be->depth_addr = se->depth_addr;
       be->start_tick = se->tsc;
       be->end_tick = tsc;
       be->annotation_index = 0;
       if (0 != se->annotation_index)
         __xray_profile_append_annotation(capture, se, be);
     }
   }
 }
 
+#ifndef XRAY_DISABLE_BROWSER_INTEGRATION
+void XRayGetTSC(uint64_t* tsc) {
+  GTSC(*tsc);
+}
+
+int32_t XRayGetSavedThreadID(struct XRayTraceCapture* capture) {
+  return capture->thread_id;
+}
+
+struct XRayTimestampPair XRayFrameGetStartTimestampPair(
+    struct XRayTraceCapture* capture, int frame) {
+  return capture->frame.entry[frame].start_time;
+}
+
+struct XRayTimestampPair XRayFrameGetEndTimestampPair(
+    struct XRayTraceCapture* capture, int frame) {
+  return capture->frame.entry[frame].end_time;
+}
+#endif
 
 /* Special case appending annotation string to trace buffer */
 /* this function should only ever be called from __cyg_profile_func_exit() */
 void __xray_profile_append_annotation(struct XRayTraceCapture* capture,
                                       struct XRayTraceStackEntry* se,
                                       struct XRayTraceBufferEntry* be) {
   struct XRayTraceStackEntry* parent = se - 1;
   int start = parent->annotation_index;
   be->annotation_index = capture->buffer_index;
   char* str = &capture->annotation[start];
@@ skipping 203 matching lines @@
   /* The trace stack[0] is reserved */
   memset(&capture->stack[0], 0, sizeof(capture->stack[0]));
   /* Annotation index 0 is reserved to indicate no annotation */
   capture->stack[0].annotation_index = 1;
   capture->annotation[0] = 0;
   capture->annotation[1] = 0;
   capture->annotation_count = 0;
   capture->recording = true;
   GTSC(capture->frame.entry[i].start_tsc);
   g_xray_capture = capture;
+
+#ifndef XRAY_DISABLE_BROWSER_INTEGRATION
+  capture->frame.entry[i].start_time = XRayGenerateTimestampsNow();
+#endif  /* XRAY_DISABLE_BROWSER_INTEGRATION */
+
 }
 
 
 /* Ends a frame and disables capturing. Advances to the next frame. */
 /* Must be paired with XRayStartFrame(), and called from the same thread. */
 void XRayEndFrame(struct XRayTraceCapture* capture) {
   int i;
   assert(capture);
   assert(capture->initialized);
   assert(capture->recording);
@@ skipping 19 matching lines @@
   if (be->depth_addr != XRAY_FRAME_MARKER) {
     fprintf(stderr,
       "XRay: XRayStopFrame() detects insufficient trace buffer size!\n");
     XRayReset(capture);
   } else {
     /* Replace marker with an empty annotation string. */
     be->depth_addr = XRAY_NULL_ANNOTATION;
     XRayCheckGuards(capture);
   }
   g_xray_capture = NULL;
+
+#ifndef XRAY_DISABLE_BROWSER_INTEGRATION
+  capture->frame.entry[i].end_time = XRayGenerateTimestampsNow();
+#endif  /* XRAY_DISABLE_BROWSER_INTEGRATION */
 }
 
 
 /* Get the last frame captured.  Do not call while capturing. */
 /* (ie call outside of XRayStartFrame() / XRayStopFrame() pair) */
 int XRayGetLastFrame(struct XRayTraceCapture* capture) {
   assert(capture);
   assert(capture->initialized);
   assert(!capture->recording);
   assert(0 == capture->disabled);
@@ skipping 67 matching lines @@
   capture->recording = false;
   XRaySetMaxStackDepth(capture, stack_depth);
   XRayReset(capture);
 
   /* Mapfile is optional; we don't need it for captures, only for reports. */
   capture->symbols =
       XRaySymbolTableCreate(XRAY_DEFAULT_SYMBOL_TABLE_SIZE);
   if (NULL != mapfilename)
     XRaySymbolTableParseMapfile(capture->symbols, mapfilename);
 
+#ifndef XRAY_DISABLE_BROWSER_INTEGRATION
+  /* Use the address of a thread local variable as a fake thread id. */
+  capture->thread_id = (int32_t)(&g_xray_thread_id_placeholder);
+#endif
+
   return capture;
 }
 
 
 /* Shut down and free memory used by XRay. */
 void XRayShutdown(struct XRayTraceCapture* capture) {
   assert(capture);
   assert(capture->initialized);
   assert(!capture->recording);
   XRayCheckGuards(capture);
   if (NULL != capture->symbols) {
     XRaySymbolTableFree(capture->symbols);
   }
   XRayFree(capture->frame.entry);
   XRayFree(capture->buffer);
   capture->initialized = false;
   XRayFree(capture);
 }
 
 #endif  /* XRAY */