airbnb-ruby-prof 0.0.1

data/ext/ruby_prof/rp_method.h

@@ -0,0 +1,79 @@
+/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_METHOD_INFO__
+#define __RP_METHOD_INFO__
+
+#include <ruby.h>
+
+extern VALUE cMethodInfo;
+
+/* A key used to identify each method */
+typedef struct
+{
+    VALUE klass;                            /* The method's class. */
+    ID mid;                                 /* The method id. */
+    st_index_t key;                         /* Cache calculated key */
+} prof_method_key_t;
+
+/* Source relation bit offsets. */
+enum {
+    kModuleIncludee = 0,                    /* Included module */
+    kModuleSingleton,                       /* Singleton class of a module */
+    kObjectSingleton                        /* Singleton class of an object */
+};
+
+/* Forward declaration, see rp_call_info.h */
+struct prof_call_infos_t;
+
+/* Profiling information for each method. */
+/* Excluded methods have no call_infos, source_klass, or source_file. */
+typedef struct
+{
+    /* Hot */
+
+    prof_method_key_t *key;                 /* Table key */
+
+    struct prof_call_infos_t *call_infos;   /* Call infos */
+    int visits;                             /* Current visits on the stack */
+
+    unsigned int excluded : 1;              /* Exclude from profile? */
+    unsigned int recursive : 1;             /* Recursive (direct or mutual)? */
+
+    /* Cold */
+
+    VALUE object;                           /* Cached ruby object */
+    VALUE source_klass;                     /* Source class */
+    const char *source_file;                /* Source file */
+    int line;                               /* Line number */
+
+    unsigned int resolved : 1;              /* Source resolved? */
+    unsigned int relation : 3;              /* Source relation bits */
+} prof_method_t;
+
+void rp_init_method_info(void);
+
+void method_key(prof_method_key_t* key, VALUE klass, ID mid);
+
+st_table * method_table_create();
+prof_method_t * method_table_lookup(st_table *table, const prof_method_key_t* key);
+size_t method_table_insert(st_table *table, const prof_method_key_t *key, prof_method_t *val);
+void method_table_free(st_table *table);
+
+prof_method_t* prof_method_create(VALUE klass, ID mid, const char* source_file, int line);
+prof_method_t* prof_method_create_excluded(VALUE klass, ID mid);
+
+VALUE prof_method_wrap(prof_method_t *result);
+void prof_method_mark(prof_method_t *method);
+
+const char* prof_method_t_source_file(prof_method_t *method);
+VALUE prof_method_t_calltree_name(prof_method_t *method);
+double prof_method_t_self_time(prof_method_t *method, int idx);
+
+/* Setup infrastructure to use method keys as hash comparisons */
+int method_table_cmp(prof_method_key_t *key1, prof_method_key_t *key2);
+st_index_t method_table_hash(prof_method_key_t *key);
+
+extern struct st_hash_type type_method_hash;
+
+#endif

data/ext/ruby_prof/rp_stack.c

@@ -0,0 +1,221 @@
+/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "rp_stack.h"
+
+#define INITIAL_STACK_SIZE 8
+
+
+void
+prof_frame_pause(prof_frame_t *frame, prof_measurements_t *current_measurements)
+{
+    if (frame && prof_frame_is_unpaused(frame)) {
+        for(size_t i = 0; i < current_measurements->len; i++) {
+            frame->measurements[i].pause = current_measurements->values[i];
+        }
+    }
+}
+
+void
+prof_frame_unpause(prof_frame_t *frame, prof_measurements_t *current_measurements)
+{
+    if (frame && prof_frame_is_paused(frame)) {
+        for(size_t i = 0; i < current_measurements->len; i++) {
+            frame->measurements[i].dead += (current_measurements->values[i] - frame->measurements[i].pause);
+            frame->measurements[i].pause = -1;
+        }
+    }
+}
+
+prof_frame_t*
+prof_stack_frame_get(size_t measurements_len, size_t i, prof_frame_t *stack_start)
+{
+    size_t offset = i * FRAME_SIZE(measurements_len);
+
+    return (prof_frame_t*)((uintptr_t)stack_start + offset);
+}
+
+/* Creates a stack of prof_frame_t to keep track
+   of timings for active methods. */
+prof_stack_t *
+prof_stack_create(size_t measurements_len)
+{
+    prof_stack_t *stack = ALLOC(prof_stack_t);
+    stack->measurements_len = measurements_len;
+    stack->start = (prof_frame_t*) ruby_xmalloc2(INITIAL_STACK_SIZE, FRAME_SIZE(measurements_len));
+    for (size_t i = 0; i < INITIAL_STACK_SIZE; i++) {
+        prof_frame_t *frame = prof_stack_frame_get(measurements_len, i, stack->start);
+        frame->measurements_len = measurements_len;
+    }
+    stack->ptr = stack->start;
+    stack->end = (prof_frame_t*)((uintptr_t)(stack->start) +
+        (INITIAL_STACK_SIZE * FRAME_SIZE(measurements_len)));
+
+    return stack;
+}
+
+void
+prof_stack_free(prof_stack_t *stack)
+{
+    xfree(stack->start);
+    xfree(stack);
+}
+
+static void
+prof_stack_realloc(prof_stack_t *stack, size_t measurements_len)
+{
+
+    size_t len = ((uintptr_t)(stack->ptr) - (uintptr_t)(stack->start)) / FRAME_SIZE(measurements_len);
+    size_t new_capacity =
+      (((uintptr_t)(stack->end) - (uintptr_t)(stack->start)) * 2) / FRAME_SIZE(measurements_len);
+
+    stack->start =
+        (prof_frame_t*) ruby_xrealloc2(
+            (char*)(stack->start), new_capacity, FRAME_SIZE(measurements_len));
+
+    for (int i = 0; i < new_capacity; i++) {
+        prof_frame_t *frame = prof_stack_frame_get(measurements_len, i, stack->start);
+        frame->measurements_len = measurements_len;
+    }
+
+    /* Memory just got moved, reset pointers */
+    stack->ptr = (prof_frame_t*) ((uintptr_t)(stack->start) + len * FRAME_SIZE(measurements_len));
+    stack->end = (prof_frame_t*) ((uintptr_t)(stack->start) + new_capacity * FRAME_SIZE(measurements_len));
+}
+
+prof_frame_t *
+prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, prof_measurements_t *measurements, int paused)
+{
+  prof_frame_t *result;
+  prof_frame_t* parent_frame;
+  prof_method_t *method;
+  size_t measurements_len = stack->measurements_len;
+
+  parent_frame = prof_stack_peek(stack);
+
+  /* Is there space on the stack?  If not, double
+     its size. */
+  if (stack->ptr == stack->end)
+  {
+      prof_stack_realloc(stack, measurements_len);
+  }
+
+  // Reserve the next available frame pointer.
+  result = stack->ptr;
+  stack->ptr = NEXT_FRAME(stack);
+
+  result->call_info = call_info;
+  // shortening of 64 bit into 32;
+  result->call_info->depth = (int)
+      (((uintptr_t)(stack->ptr) - (uintptr_t)(stack->start)) / FRAME_SIZE(measurements_len));
+  result->passes = 0;
+
+  for (size_t i = 0; i < measurements_len; i++) {
+      result->measurements[i].start = measurements->values[i];
+      result->measurements[i].pause = -1; // init as not paused
+      result->measurements[i].switch_t = 0;
+      result->measurements[i].wait = 0;
+      result->measurements[i].child = 0;
+      result->measurements[i].dead = 0;
+  }
+
+  method = call_info->target;
+
+  /* If the method was visited previously, it's recursive. */
+  if (method->visits > 0)
+  {
+    method->recursive = 1;
+    call_info->recursive = 1;
+  }
+  /* Enter the method. */
+  method->visits++;
+
+  // Unpause the parent frame, if it exists.
+  // If currently paused then:
+  //   1) The child frame will begin paused.
+  //   2) The parent will inherit the child's dead time.
+  prof_frame_unpause(parent_frame, measurements);
+
+  if (paused) {
+    prof_frame_pause(result, measurements);
+  }
+
+  // Return the result
+  return result;
+}
+
+prof_frame_t *
+prof_stack_pop(prof_stack_t *stack, prof_measurements_t *measurements)
+{
+  prof_frame_t *frame;
+  prof_frame_t *parent_frame;
+  prof_call_info_t *call_info;
+  prof_method_t *method;
+
+  double total_time;
+  double self_time;
+
+  frame = prof_stack_peek(stack);
+
+  /* Frame can be null.  This can happen if RubProf.start is called from
+     a method that exits.  And it can happen if an exception is raised
+     in code that is being profiled and the stack unwinds (RubyProf is
+     not notified of that by the ruby runtime. */
+  if (!frame) {
+    return NULL;
+  }
+
+  /* Match passes until we reach the frame itself. */
+  if (prof_frame_is_pass(frame)) {
+    frame->passes--;
+    /* Additional frames can be consumed. See pop_frames(). */
+    return frame;
+  }
+
+  /* Consume this frame. */
+  stack->ptr = PREVIOUS_FRAME(stack);
+
+  prof_frame_unpause(frame, measurements);
+
+  /* Update information about the current method */
+  call_info = frame->call_info;
+  method = call_info->target;
+
+  call_info->called++;
+
+  for (size_t i = 0; i < measurements->len; i++) {
+      total_time = measurements->values[i] - frame->measurements[i].start - frame->measurements[i].dead;
+      self_time = total_time - frame->measurements[i].child - frame->measurements[i].wait;
+
+      call_info->measure_values[i].total += total_time;
+      call_info->measure_values[i].self += self_time;
+      call_info->measure_values[i].wait += frame->measurements[i].wait;
+  }
+
+  /* Leave the method. */
+  method->visits--;
+
+  parent_frame = prof_stack_peek(stack);
+  if (parent_frame)
+  {
+      for (size_t i = 0; i < measurements->len; i++) {
+          parent_frame->measurements[i].child +=
+              measurements->values[i] - frame->measurements[i].start - frame->measurements[i].dead;
+          parent_frame->measurements[i].dead += frame->measurements[i].dead;
+      }
+
+      call_info->line = parent_frame->line;
+  }
+
+  return frame;
+}
+
+prof_frame_t *
+prof_stack_pass(prof_stack_t *stack)
+{
+  prof_frame_t *frame = prof_stack_peek(stack);
+  if (frame) {
+    frame->passes++;
+  }
+  return frame;
+}

data/ext/ruby_prof/rp_stack.h

@@ -0,0 +1,81 @@
+/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_STACK__
+#define __RP_STACK__
+
+#include <ruby.h>
+
+#include "rp_measure.h"
+#include "rp_call_info.h"
+
+
+typedef struct
+{
+    double start;
+    double switch_t; // Time at switch to different thread
+    double wait;
+    double child;
+    double pause; //Time pause() was initiated
+    double dead; // Time to ignore (i.e. total amount of time between pause/resume blocks)
+} prof_frame_measurement_t;
+
+/* Temporary object that maintains profiling information
+   for active methods.  They are created and destroyed
+   as the program moves up and down its stack. */
+typedef struct
+{
+    /* Caching prof_method_t values significantly
+       increases performance. */
+    prof_call_info_t *call_info;
+
+    unsigned int line;
+    unsigned int passes; /* Count of "pass" frames, _after_ this one. */
+
+    size_t measurements_len;
+    prof_frame_measurement_t measurements[];
+} prof_frame_t;
+
+#define prof_frame_is_real(f) ((f)->passes == 0)
+#define prof_frame_is_pass(f) ((f)->passes > 0)
+
+#define prof_frame_is_paused(f) (f->measurements[0].pause >= 0)
+#define prof_frame_is_unpaused(f) (f->measurements[0].pause < 0)
+
+void prof_frame_pause(prof_frame_t*, prof_measurements_t *current_measurements);
+void prof_frame_unpause(prof_frame_t*, prof_measurements_t *current_measurements);
+
+/* Current stack of active methods.*/
+typedef struct prof_stack_t
+{
+    size_t measurements_len;
+    prof_frame_t *start;
+    prof_frame_t *end;
+    prof_frame_t *ptr;
+} prof_stack_t;
+
+prof_stack_t *prof_stack_create(size_t measurements_len);
+void prof_stack_free(prof_stack_t *stack);
+
+prof_frame_t *prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info,
+                              prof_measurements_t *measurements, int paused);
+prof_frame_t *prof_stack_pop(prof_stack_t *stack, prof_measurements_t *measurements);
+prof_frame_t *prof_stack_pass(prof_stack_t *stack);
+
+#define FRAME_SIZE(measurements_len) (sizeof(prof_frame_t) + (measurements_len) * sizeof(prof_frame_measurement_t))
+#define NEXT_FRAME(stack) (prof_frame_t*) \
+    ((uintptr_t)((stack)->ptr) + FRAME_SIZE((stack)->measurements_len))
+#define PREVIOUS_FRAME(stack) (prof_frame_t*) \
+    ((uintptr_t)((stack)->ptr) - FRAME_SIZE((stack)->measurements_len))
+
+static inline prof_frame_t *
+prof_stack_peek(prof_stack_t *stack) {
+    if (stack->ptr != stack->start) {
+        return (prof_frame_t*) ((uintptr_t)(stack->ptr) - 1 * FRAME_SIZE(stack->measurements_len));
+    } else {
+        return NULL;
+    }
+}
+
+
+#endif //__RP_STACK__

data/ext/ruby_prof/rp_thread.c

@@ -0,0 +1,312 @@
+/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_prof.h"
+
+VALUE cRpThread;
+
+/* ======   thread_data_t  ====== */
+thread_data_t*
+thread_data_create(size_t measurements_len)
+{
+    thread_data_t* result = ALLOC(thread_data_t);
+    result->stack = prof_stack_create(measurements_len);
+    result->method_table = method_table_create();
+    result->object = Qnil;
+    result->methods = Qnil;
+    return result;
+}
+
+/* The underlying c structures are freed when the parent profile is freed.
+   However, on shutdown the Ruby GC frees objects in any will-nilly order.
+   That means the ruby thread object wrapping the c thread struct may
+   be freed before the parent profile.  Thus we add in a free function
+   for the garbage collector so that if it does get called will nil
+   out our Ruby object reference.*/
+static void
+thread_data_ruby_gc_free(thread_data_t* thread_data)
+{
+    /* Has this thread object been accessed by Ruby?  If
+       yes clean it up so to avoid a segmentation fault. */
+    if (thread_data->object != Qnil)
+    {
+        RDATA(thread_data->object)->data = NULL;
+        RDATA(thread_data->object)->dfree = NULL;
+        RDATA(thread_data->object)->dmark = NULL;
+    }
+    thread_data->object = Qnil;
+}
+
+static void
+thread_data_free(thread_data_t* thread_data)
+{
+    thread_data_ruby_gc_free(thread_data);
+    method_table_free(thread_data->method_table);
+    prof_stack_free(thread_data->stack);
+
+    thread_data->thread_id = Qnil;
+
+    xfree(thread_data);
+}
+
+static int
+mark_methods(st_data_t key, st_data_t value, st_data_t result)
+{
+    prof_method_t *method = (prof_method_t *) value;
+    prof_method_mark(method);
+    return ST_CONTINUE;
+}
+
+void
+prof_thread_mark(thread_data_t *thread)
+{
+    if (thread->object != Qnil)
+        rb_gc_mark(thread->object);
+
+    if (thread->methods != Qnil)
+        rb_gc_mark(thread->methods);
+
+    if (thread->thread_id != Qnil)
+        rb_gc_mark(thread->thread_id);
+
+    if (thread->fiber_id != Qnil)
+        rb_gc_mark(thread->fiber_id);
+
+    st_foreach(thread->method_table, mark_methods, 0);
+}
+
+VALUE
+prof_thread_wrap(thread_data_t *thread)
+{
+    if (thread->object == Qnil) {
+        thread->object = Data_Wrap_Struct(cRpThread, prof_thread_mark, thread_data_ruby_gc_free, thread);
+    }
+    return thread->object;
+}
+
+thread_data_t*
+prof_get_thread(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+    thread_data_t* result = DATA_PTR(self);
+    if (!result)
+        rb_raise(rb_eRuntimeError, "This RubyProf::Thread instance has already been freed, likely because its profile has been freed.");
+
+    return result;
+}
+
+/* ======   Thread Table  ====== */
+/* The thread table is hash keyed on ruby thread_id that stores instances
+   of thread_data_t. */
+
+st_table *
+threads_table_create()
+{
+    return st_init_numtable();
+}
+
+static int
+thread_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
+{
+    thread_data_free((thread_data_t*)value);
+    return ST_CONTINUE;
+}
+
+void
+threads_table_free(st_table *table)
+{
+    st_foreach(table, thread_table_free_iterator, 0);
+    st_free_table(table);
+}
+
+size_t
+threads_table_insert(prof_profile_t* profile, VALUE fiber, thread_data_t *thread_data)
+{
+    /* Its too slow to key on the real thread id so just typecast thread instead. */
+    return st_insert(profile->threads_tbl, (st_data_t) fiber, (st_data_t) thread_data);
+}
+
+thread_data_t *
+threads_table_lookup(prof_profile_t* profile, VALUE thread_id, VALUE fiber_id)
+{
+    thread_data_t* result;
+    st_data_t val;
+
+    /* If we should merge fibers, we use the thread_id as key, otherwise the fiber id.
+       None of this is perfect, as garbage collected fiber/thread might be reused again later.
+       A real solution would require integration with the garbage collector.
+     */
+    VALUE key = profile->merge_fibers ? thread_id : fiber_id;
+    if (st_lookup(profile->threads_tbl, (st_data_t) key, &val))
+    {
+      result = (thread_data_t *) val;
+    }
+    else
+    {
+        result = thread_data_create(profile->measurer->len);
+
+        result->thread_index = 0;
+        result->thread_id = thread_id;
+        /* We set fiber id to 0 in the merge fiber case. Real fibers never have id 0,
+           so we can identify them later during printing.
+        */
+        result->fiber_id = profile->merge_fibers ? INT2FIX(0) : fiber_id;
+
+        if (thread_id != profile->main_thread_id) {
+          result->thread_index = profile->next_thread_index++;
+        }
+
+        /* Insert the table */
+        threads_table_insert(profile, key, result);
+    }
+    return result;
+}
+
+thread_data_t *
+switch_thread(void* prof, VALUE thread_id, VALUE fiber_id)
+{
+    prof_profile_t* profile = (prof_profile_t*)prof;
+    prof_measurer_take_measurements(profile->measurer, profile->measurements);
+
+    /* Get new thread information. */
+    thread_data_t *thread_data = threads_table_lookup(profile, thread_id, fiber_id);
+
+    /* Get current frame for this thread */
+    prof_frame_t *frame = prof_stack_peek(thread_data->stack);
+
+    /* Update the time this thread waited for another thread */
+    if (frame)
+    {
+        for (size_t i; i < frame->measurements_len; i++) {
+            frame->measurements[i].wait += profile->measurements->values[i] - frame->measurements[i].switch_t;
+            frame->measurements[i].switch_t = profile->measurements->values[i];
+        }
+    }
+
+    /* Save on the last thread the time of the context switch
+       and reset this thread's last context switch to 0.*/
+    if (profile->last_thread_data)
+    {
+        prof_frame_t *last_frame = prof_stack_peek(profile->last_thread_data->stack);
+        if (last_frame) {
+            for(size_t i; i < last_frame->measurements_len; i++) {
+                last_frame->measurements[i].switch_t = profile->measurements->values[i];
+            }
+        }
+    }
+
+    profile->last_thread_data = thread_data;
+    return thread_data;
+}
+
+int pause_thread(st_data_t key, st_data_t value, st_data_t data)
+{
+    thread_data_t* thread_data = (thread_data_t *) value;
+    prof_profile_t* profile = (prof_profile_t*)data;
+
+    prof_frame_t* frame = prof_stack_peek(thread_data->stack);
+    prof_frame_pause(frame, profile->measurements_at_pause_resume);
+
+    return ST_CONTINUE;
+}
+
+int unpause_thread(st_data_t key, st_data_t value, st_data_t data)
+{
+    thread_data_t* thread_data = (thread_data_t *) value;
+    prof_profile_t* profile = (prof_profile_t*)data;
+
+    prof_frame_t* frame = prof_stack_peek(thread_data->stack);
+    prof_frame_unpause(frame, profile->measurements_at_pause_resume);
+
+    return ST_CONTINUE;
+}
+
+static int
+collect_methods(st_data_t key, st_data_t value, st_data_t result)
+{
+    /* Called for each method stored in a thread's method table.
+       We want to store the method info information into an array.*/
+    VALUE methods = (VALUE) result;
+    prof_method_t *method = (prof_method_t *) value;
+
+    if (!method->excluded) {
+      rb_ary_push(methods, prof_method_wrap(method));
+    }
+
+    return ST_CONTINUE;
+}
+
+/* call-seq:
+   index -> number
+
+Returns the index of this thread. */
+static VALUE
+prof_thread_index(VALUE self)
+{
+    thread_data_t* thread = prof_get_thread(self);
+    return ULL2NUM(thread->thread_index);
+}
+
+/* call-seq:
+   main? -> bool
+
+Returns the true if this is the main thread. */
+static VALUE
+prof_thread_main(VALUE self)
+{
+  thread_data_t* thread = prof_get_thread(self);
+  return thread->thread_index == 0 ? Qtrue : Qfalse;
+}
+
+/* call-seq:
+   id -> number
+
+Returns the id of this thread. */
+static VALUE
+prof_thread_id(VALUE self)
+{
+    thread_data_t* thread = prof_get_thread(self);
+    return thread->thread_id;
+}
+
+/* call-seq:
+   fiber_id -> number
+
+Returns the fiber id of this thread. */
+static VALUE
+prof_fiber_id(VALUE self)
+{
+    thread_data_t* thread = prof_get_thread(self);
+    return thread->fiber_id;
+}
+
+/* call-seq:
+   methods -> Array of MethodInfo
+
+Returns an array of methods that were called from this
+thread during program execution. */
+static VALUE
+prof_thread_methods(VALUE self)
+{
+    thread_data_t* thread = prof_get_thread(self);
+    if (thread->methods == Qnil)
+    {
+        thread->methods = rb_ary_new();
+        st_foreach(thread->method_table, collect_methods, thread->methods);
+    }
+    return thread->methods;
+}
+
+void rp_init_thread()
+{
+    cRpThread = rb_define_class_under(mProf, "Thread", rb_cObject);
+    rb_undef_method(CLASS_OF(cRpThread), "new");
+
+    rb_define_method(cRpThread, "index", prof_thread_index, 0);
+    rb_define_method(cRpThread, "main?", prof_thread_main, 0);
+
+    rb_define_method(cRpThread, "id", prof_thread_id, 0);
+    rb_define_method(cRpThread, "fiber_id", prof_fiber_id, 0);
+    rb_define_method(cRpThread, "methods", prof_thread_methods, 0);
+}