Update XRay to support x86-64 (RDTSC), use dladdr() as an optional way to

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 <alloca.h>
 #include <assert.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "xray/xray_priv.h"
 
 #if defined(XRAY)
 
+#define FORCE_INLINE  __attribute__((always_inline))
+
+#if defined(__amd64__)
+FORCE_INLINE uint64_t RDTSC64() {
+  uint64_t a, d;
+  __asm__ __volatile__("rdtsc" : "=a" (a), "=d" (d));
+  return ((uint64_t)a) | (((uint64_t)d) << 32);
+}
+#define RDTSC(_x) _x = RDTSC64()
+#else
 #define RDTSC(_x)      __asm__ __volatile__ ("rdtsc" : "=A" (_x));
-#define FORCE_INLINE  __attribute__((always_inline))
+#endif
+
 
 /* Use a TLS variable for cheap thread uid. */
 volatile __thread int g_xray_thread_id;
 
 
 struct XRayTraceStackEntry {
   uint32_t depth_addr;
   uint64_t tsc;
   uint32_t dest;
   uint32_t annotation_index;
@@ skipping 550 matching lines @@
 int XRayTraceBufferNextEntry(int index) {
   if (XRayTraceBufferIsAnnotation(index))
     index = XRayTraceBufferSkipAnnotation(index);
   else
     index = XRayTraceBufferIncrementIndex(index);
   return index;
 }
 
 
 /* Dumps the trace report for a given frame. */
-void XRayTraceReport(FILE* f, int frame, char* label, float cutoff) {
+void XRayTraceReport(FILE* f, int frame, char* label,
+                     float percent_cutoff, int ticks_cutoff) {
   int index;
   int start;
   int end;
   float total;
   int bad_depth = 0;
   char space[257];
   memset(space, ' ', 256);
   space[256] = 0;
   if (NULL == f) {
     f = stdout;
@@ skipping 14 matching lines @@
   while (index != end) {
     if (!XRayTraceBufferIsAnnotation(index)) {
       const char* symbol_name;
       char annotation[1024];
       struct XRayTraceBufferEntry* e = &g_xray.buffer[index];
       uint32_t depth = XRAY_EXTRACT_DEPTH(e->depth_addr);
       uint32_t addr = XRAY_EXTRACT_ADDR(e->depth_addr);
       uint32_t ticks = (e->ticks);
       uint32_t annotation_index = (e->annotation_index);
       float percent = 100.0f * (float)ticks / total;
-      if (percent >= cutoff) {
+      if (percent >= percent_cutoff && ticks >= ticks_cutoff) {
         if (depth > 250) bad_depth++;

[bradn, 2013/06/27 23:01:24]

Might be nice to give this (250) a name and move up top (optional).

[nfullagar1, 2013/06/27 23:41:55]

This code isn't needed, I'll remove it.

         struct XRaySymbol* symbol;
         symbol = XRaySymbolTableLookup(g_xray.symbols, addr);
         symbol_name = XRaySymbolGetName(symbol);
         if (0 != annotation_index) {
           XRayTraceBufferCopyToString(annotation_index, annotation);
         } else {
           strcpy(annotation, "");
         }
         fprintf(f, "0x%08X   %10ld     %5.1f     %s%s %s\n",
                 (unsigned int)addr, (int64_t)ticks, percent,
@@ skipping 76 matching lines @@
         index,
         (int64_t)total_ticks,
         capture_size,
         annotation_count,
         label);
   }
 }
 
 
 /* Dump a frame report followed by trace report(s) for each frame. */
-void XRayReport(FILE* f, float cutoff) {
+void XRayReport(FILE* f, float percent_cutoff, int ticks_cutoff) {
   int head;
   int index;
   int counter = 0;
-  fprintf(f, "Number of symbols: %d\n", XRaySymbolCount(g_xray.symbols));
+  if (g_xray.symbols)
+    fprintf(f, "Number of symbols: %d\n", XRaySymbolCount(g_xray.symbols));
   XRayFrameReport(f);
   fprintf(f, "\n");
   head = g_xray.frame.head;
   index = g_xray.frame.tail;
   while (index != head) {
     char label[XRAY_MAX_LABEL];
     fprintf(f, "\n");
     XRayFrameMakeLabel(counter, label);
-    XRayTraceReport(f, index, label, cutoff);
+    XRayTraceReport(f, index, label, percent_cutoff, ticks_cutoff);
     index = XRayFrameNext(index);
+
     ++counter;
   }
   fprintf(f,
   "======================================================================\n");
 #if defined(XRAY_OUTPUT_HASH_COLLISIONS)
   XRayHashTableHisto(f);
 #endif
 }
 
 
 /* Write a profile report to text file. */
-void XRaySaveReport(const char* filename, float cutoff) {
+void XRaySaveReport(const char* filename,
+                    float percent_cutoff,
+                    int ticks_cutoff) {
   FILE* f;
   f = fopen(filename, "wt");
   if (NULL != f) {
-    XRayReport(f, cutoff);
+    XRayReport(f, percent_cutoff, ticks_cutoff);
     fclose(f);
   }
 }
 
 
 /* Initialize XRay */
 void XRayInit(int stack_depth, int buffer_size, int frame_count,
               const char* mapfilename) {
   int adj_frame_count = frame_count + 1;
   assert(false == g_xray.initialized);
@@ skipping 13 matching lines @@
   g_xray.disabled = 0;
   g_xray.annotation_filter = 0xFFFFFFFF;
   g_xray.guard0 = XRAY_GUARD_VALUE;
   g_xray.guard1 = XRAY_GUARD_VALUE;
   g_xray.guard2 = XRAY_GUARD_VALUE;
   g_xray.initialized = true;
   XRaySetMaxStackDepth(stack_depth);
   XRayReset();
 
   /* Mapfile is optional; we don't need it for captures, only for reports. */
-  if (NULL != mapfilename) {
-    g_xray.symbols = XRaySymbolTableCreate(XRAY_DEFAULT_SYMBOL_TABLE_SIZE);
+  g_xray.symbols = XRaySymbolTableCreate(XRAY_DEFAULT_SYMBOL_TABLE_SIZE);
+  if (NULL != mapfilename)
     XRaySymbolTableParseMapfile(g_xray.symbols, mapfilename);
-  }
 }
 
 
 /* Shut down and free memory used by XRay. */
 void XRayShutdown() {
   assert(true == g_xray.initialized);
   assert(NULL == g_xray.recording);
   XRayCheckGuards();
   if (NULL != g_xray.symbols) {
     XRaySymbolTableFree(g_xray.symbols);
   }
   XRayFree(g_xray.frame.entry);
   XRayFree(g_xray.buffer);
   g_xray.initialized = false;
 }
 
 #endif  /* XRAY */