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;
 };
 
 
 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
 };
 
 
 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);
+#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);
 }
 
 
-
+#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 */
+void __pnacl_profile_func_enter(const char* fname) {

[nfullagar1, 2013/07/18 00:47:22]

(you may have missed this one from last round)
suggestion was to use this_fn instead of fname, and to merge the majority of the
code between the two versions.  AFAICT the code itself is the same between both,
just the function name & arg list is different.

+  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__ */
 
+#ifndef XRAY_DISABLE_BROWSER_INTEGRATION
+void XRayGetTSC(uint64_t* tsc) {GTSC(*tsc);}

[nfullagar1, 2013/07/18 00:47:22]

above: unless it is inlined in a class, avoid putting all on one line.  ie. do
this instead

void foo() {
  statement;
}

[grosse, 2013/07/18 01:26:40]

Done.

+
+int32_t XRayGetThreadID(struct XRayTraceCapture* capture) {

[nfullagar1, 2013/07/18 00:47:22]

Need a brief comment here that ret val is the thread ID taken at BeginCapture,
not the thread id of 'this' thread.

[grosse, 2013/07/18 01:26:40]

Done.

+  return capture->thread_id;
+}
+
+struct XRayTimestampPair* XRayGetTimestamp(
+    struct XRayTraceCapture* capture, int frame, bool end) {
+
+  struct XRayTraceFrameEntry* entry = &(capture->frame.entry[frame]);
+  return end ? &entry->end_time : &entry->start_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 */

[nfullagar1, 2013/07/18 00:47:22]

code style is to have two spaces between #endif and /*

[grosse, 2013/07/18 01:26:40]

Done.

+
 }
 
 
 /* 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
+  capture->thread_id = (int32_t)(&g_xray_capture);

[nfullagar1, 2013/07/18 00:47:22]

Suggest having a separate '__thread int g_xray_tid = 0; ' and a comment here
that we're using the address of a TLS variable as a cheap tid value.

[grosse, 2013/07/18 01:26:40]

Done.

+#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 */