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;
 
 
 struct XRayTraceStackEntry {
   uint32_t depth_addr;
   uint64_t tsc;
   uint32_t dest;
   uint32_t annotation_index;
 };
@@ skipping 32 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;
+
+  struct XrayTimestampPair start_time;
+  bool start_time_initialized;

[nfullagar1, 2013/07/17 00:53:19]

wrap these as well with XRAY_DISABLE_BROWSER_INTEGRATION

[grosse, 2013/07/17 19:37:56]

Done.

 } 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);
+XRAY_NO_INSTRUMENT void __pnacl_profile_func_enter(const char* fname);
+XRAY_NO_INSTRUMENT void __pnacl_profile_func_exit(const char* fname);

[nfullagar1, 2013/07/17 00:53:19]

above: need to add back __cyg_profile versions for non-pnacl, and wrap with #if
defined(__pnacl__) #else #endf

[grosse, 2013/07/17 19:37:56]

Done.

 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);
 }
 
 
-
+#if defined(__pnacl__)
 /* 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 */

[nfullagar1, 2013/07/17 00:53:19]

comment above should include compiler options for pnacl environ.  (same for
func_exit below)

+void __pnacl_profile_func_enter(const char* fname) {

[nfullagar1, 2013/07/17 00:53:19]

fname -> this_fn, and I think you could avoid a lot of the duplicate code
between pnacl & non-pnacl.

+  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)fname;
+      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 */
+void __pnacl_profile_func_exit(const char* fname) {
+  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);
+    }
+  }
+}
+#else
+/* 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 */
 void __cyg_profile_func_enter(void* this_fn, void* call_site) {
   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;
@@ skipping 22 matching lines @@
       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);
     }
   }
 }
+#endif // __pnacl__

[nfullagar1, 2013/07/17 00:53:19]

above: /* __pnacl__ */
/* c style comment */

[grosse, 2013/07/17 19:37:56]

Done.

+
+
+void XRayGetTSC(uint64_t* tsc) {GTSC(*tsc);}
+
+struct XrayTimestampPair* XRayGetStartTimestamp(
+    struct XRayTraceCapture* capture)
+{
+  assert(capture->start_time_initialized);
+  return &capture->start_time;
+}
 
 
 /* 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;
@@ skipping 204 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_NOPEPPER

[nfullagar1, 2013/07/17 00:53:19]

XRAY_DISABLE_BROWSER_INTEGRATION  (here & elsewhere)

[grosse, 2013/07/17 19:37:56]

Done.

+  if (!capture->start_time_initialized) {
+    capture->start_time = XRayPepperBeginCalibration();

[nfullagar1, 2013/07/17 00:53:19]

XRayBrowserBeginCalibration ?

+    capture->start_time_initialized = true;
+  }
+#endif /* XRAY_NOPEPPER */

[nfullagar1, 2013/07/17 00:53:19]

I think the above may be better if this was done for each frame.  There's
already some placeholders in frame.entry[i].start_tsc & end_tsc -- these could
become time stamp pair values.

(See additional notes in browser.c)

+
 }
 
 
 /* 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 97 matching lines @@
   capture->frame.head = 0;
   capture->frame.tail = 0;
   capture->disabled = 0;
   capture->annotation_filter = 0xFFFFFFFF;
   capture->guard0 = XRAY_GUARD_VALUE_0x12345678;
   capture->guard1 = XRAY_GUARD_VALUE_0x12345678;
   capture->guard2 = XRAY_GUARD_VALUE_0x87654321;
   capture->guard3 = XRAY_GUARD_VALUE_0x12345678;
   capture->initialized = true;
   capture->recording = false;
+  capture->start_time_initialized = 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);
 
   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 */