ruby-prof 0.18.0-x64-mingw32 → 1.1.0-x64-mingw32

data/ext/ruby_prof/rp_profile.h

@@ -0,0 +1,37 @@
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_PROFILE_H__
+#define __RP_PROFILE_H__
+
+#include "ruby_prof.h"
+#include "rp_measurement.h"
+#include "rp_thread.h"
+
+extern VALUE cProfile;
+
+typedef struct
+{
+    VALUE running;
+    VALUE paused;
+
+    prof_measurer_t* measurer;
+    VALUE threads;
+
+    VALUE tracepoints;
+
+    st_table* threads_tbl;
+    st_table* exclude_threads_tbl;
+    st_table* include_threads_tbl;
+    st_table* exclude_methods_tbl;
+    thread_data_t* last_thread_data;
+    double measurement_at_pause_resume;
+    bool allow_exceptions;
+    bool merge_fibers;
+} prof_profile_t;
+
+void rp_init_profile(void);
+prof_profile_t* prof_get_profile(VALUE self);
+
+
+#endif //__RP_PROFILE_H__

data/ext/ruby_prof/rp_stack.c

@@ -3,7 +3,7 @@
 
 #include "rp_stack.h"
 
-#define INITIAL_STACK_SIZE 8
+#define INITIAL_STACK_SIZE 32
 
 void
 prof_frame_pause(prof_frame_t *frame, double current_measurement)
@@ -15,20 +15,20 @@ prof_frame_pause(prof_frame_t *frame, double current_measurement)
 void
 prof_frame_unpause(prof_frame_t *frame, double current_measurement)
 {
-    if (frame && prof_frame_is_paused(frame)) {
+    if (frame && prof_frame_is_paused(frame))
+    {
         frame->dead_time += (current_measurement - frame->pause_time);
         frame->pause_time = -1;
     }
 }
 
-
 /* Creates a stack of prof_frame_t to keep track
    of timings for active methods. */
 prof_stack_t *
 prof_stack_create()
 {
     prof_stack_t *stack = ALLOC(prof_stack_t);
-    stack->start = ALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
+    stack->start = ZALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
     stack->ptr = stack->start;
     stack->end = stack->start + INITIAL_STACK_SIZE;
 
@@ -45,61 +45,62 @@ prof_stack_free(prof_stack_t *stack)
 prof_frame_t *
 prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measurement, int paused)
 {
-  prof_frame_t *result;
-  prof_frame_t* parent_frame;
-  prof_method_t *method;
+    prof_frame_t *result;
+    prof_frame_t* parent_frame;
 
-  /* Is there space on the stack?  If not, double
+    /* Is there space on the stack?  If not, double
      its size. */
-  if (stack->ptr == stack->end)
-  {
-    size_t len = stack->ptr - stack->start;
-    size_t new_capacity = (stack->end - stack->start) * 2;
-    REALLOC_N(stack->start, prof_frame_t, new_capacity);
-    /* Memory just got moved, reset pointers */
-    stack->ptr = stack->start + len;
-    stack->end = stack->start + new_capacity;
-  }
-
-  parent_frame = prof_stack_peek(stack);
-
-  // Reserve the next available frame pointer.
-  result = stack->ptr++;
-
-  result->call_info = call_info;
-  result->call_info->depth = (int)(stack->ptr - stack->start); // shortening of 64 bit into 32;
-  result->passes = 0;
-
-  result->start_time = measurement;
-  result->pause_time = -1; // init as not paused.
-  result->switch_time = 0;
-  result->wait_time = 0;
-  result->child_time = 0;
-  result->dead_time = 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, measurement);
+    if (stack->ptr == stack->end - 1)
+    {
+        size_t len = stack->ptr - stack->start;
+        size_t new_capacity = (stack->end - stack->start) * 2;
+        REALLOC_N(stack->start, prof_frame_t, new_capacity);
+
+        /* Memory just got moved, reset pointers */
+        stack->ptr = stack->start + len;
+        stack->end = stack->start + new_capacity;
+    }
 
-  if (paused) {
-    prof_frame_pause(result, measurement);
-  }
+    parent_frame = stack->ptr;
+    stack->ptr++;
+
+    result = stack->ptr;
+    result->call_info = call_info;
+    result->call_info->depth = (int)(stack->ptr - stack->start); // shortening of 64 bit into 32;
+    result->passes = 0;
+
+    result->start_time = measurement;
+    result->pause_time = -1; // init as not paused.
+    result->switch_time = 0;
+    result->wait_time = 0;
+    result->child_time = 0;
+    result->dead_time = 0;
+    result->source_file = Qnil;
+    result->source_line = 0;
+
+    call_info->measurement->called++;
+    call_info->visits++;
+
+    if (call_info->method->visits > 0)
+    {
+        call_info->method->recursive = true;
+    }
+    call_info->method->measurement->called++;
+    call_info->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, measurement);
+
+    if (paused)
+    {
+        prof_frame_pause(result, measurement);
+    }
 
-  // Return the result
-  return result;
+    // Return the result
+    return result;
 }
 
 prof_frame_t *
@@ -108,23 +109,18 @@ prof_stack_pop(prof_stack_t *stack, double measurement)
   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);
+  if (stack->ptr == stack->start)
+      return NULL;
 
-  /* Frame can be null, which means the stack is empty.  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;
-  }
+  frame = stack->ptr;
 
   /* Match passes until we reach the frame itself. */
-  if (prof_frame_is_pass(frame)) {
+  if (prof_frame_is_pass(frame))
+  {
     frame->passes--;
     /* Additional frames can be consumed. See pop_frames(). */
     return frame;
@@ -133,30 +129,37 @@ prof_stack_pop(prof_stack_t *stack, double measurement)
   /* Consume this frame. */
   stack->ptr--;
 
+  parent_frame = stack->ptr;
+
   /* Calculate the total time this method took */
   prof_frame_unpause(frame, measurement);
+  
   total_time = measurement - frame->start_time - frame->dead_time;
   self_time = total_time - frame->child_time - frame->wait_time;
 
   /* Update information about the current method */
   call_info = frame->call_info;
-  method = call_info->target;
 
-  call_info->called++;
-  call_info->total_time += total_time;
-  call_info->self_time += self_time;
-  call_info->wait_time += frame->wait_time;
+  // Update method measurement
+  call_info->method->measurement->self_time += self_time;
+  call_info->method->measurement->wait_time += frame->wait_time;
+  if (call_info->method->visits == 1)
+    call_info->method->measurement->total_time += total_time;
 
-  /* Leave the method. */
-  method->visits--;
+  call_info->method->visits--;
+
+  // Update method measurement
+  call_info->measurement->self_time += self_time;
+  call_info->measurement->wait_time += frame->wait_time;
+  if (call_info->visits == 1)
+      call_info->measurement->total_time += total_time;
+
+  call_info->visits--;
 
-  parent_frame = prof_stack_peek(stack);
   if (parent_frame)
   {
       parent_frame->child_time += total_time;
       parent_frame->dead_time += frame->dead_time;
-
-      call_info->line = parent_frame->line;
   }
 
   return frame;
@@ -165,9 +168,29 @@ prof_stack_pop(prof_stack_t *stack, double measurement)
 prof_frame_t *
 prof_stack_pass(prof_stack_t *stack)
 {
-  prof_frame_t *frame = prof_stack_peek(stack);
-  if (frame) {
-    frame->passes++;
-  }
-  return frame;
+    prof_frame_t* frame = stack->ptr;
+    if (frame)
+    {
+        frame->passes++;
+    }
+    return frame;
+}
+
+prof_method_t*
+prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line)
+{
+    prof_frame_t* frame = stack->ptr;
+    while (frame >= stack->start)
+    {
+        if (!frame->call_info)
+            return NULL;
+
+        if (rb_str_equal(source_file, frame->call_info->method->source_file) &&
+            source_line >= frame->call_info->method->source_line)
+        {
+            return frame->call_info->method;
+        }
+        frame--;
+    }
+    return NULL;
 }

data/ext/ruby_prof/rp_stack.h

@@ -4,12 +4,9 @@
 #ifndef __RP_STACK__
 #define __RP_STACK__
 
-#include <ruby.h>
-
-#include "rp_measure.h"
+#include "ruby_prof.h"
 #include "rp_call_info.h"
 
-
 /* Temporary object that maintains profiling information
    for active methods.  They are created and destroyed
    as the program moves up and down its stack. */
@@ -19,7 +16,8 @@ typedef struct
        increases performance. */
     prof_call_info_t *call_info;
 
-    unsigned int line;
+    VALUE source_file;
+    unsigned int source_line;
     unsigned int passes; /* Count of "pass" frames, _after_ this one. */
 
     double start_time;
@@ -47,17 +45,12 @@ typedef struct
     prof_frame_t *ptr;
 } prof_stack_t;
 
-prof_stack_t *prof_stack_create();
+prof_stack_t *prof_stack_create(void);
 void prof_stack_free(prof_stack_t *stack);
 
 prof_frame_t *prof_stack_push(prof_stack_t *stack, prof_call_info_t *call_info, double measurement, int paused);
 prof_frame_t *prof_stack_pop(prof_stack_t *stack, double measurement);
 prof_frame_t *prof_stack_pass(prof_stack_t *stack);
-
-static inline prof_frame_t *
-prof_stack_peek(prof_stack_t *stack) {
-    return stack->ptr != stack->start ? stack->ptr - 1 : NULL;
-}
-
+prof_method_t *prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line);
 
 #endif //__RP_STACK__

data/ext/ruby_prof/rp_thread.c

@@ -1,50 +1,59 @@
 /* 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"
+/* Document-class: RubyProf::Thread
+
+The Thread class contains profile results for a single fiber (note a Ruby thread can run multiple fibers).
+You cannot create an instance of RubyProf::Thread, instead you access it from a RubyProf::Profile object.
+
+  profile = RubyProf::Profile.profile do
+              ...
+            end
+
+  profile.threads.each do |thread|
+    thread.root_methods.sort.each do |method|
+      puts method.total_time
+    end
+  end
+*/
+
+#include "rp_thread.h"
+#include "rp_profile.h"
 
 VALUE cRpThread;
 
 /* ======   thread_data_t  ====== */
 thread_data_t*
-thread_data_create()
+thread_data_create(void)
 {
     thread_data_t* result = ALLOC(thread_data_t);
     result->stack = prof_stack_create();
     result->method_table = method_table_create();
     result->object = Qnil;
     result->methods = Qnil;
+    result->fiber_id = Qnil;
+    result->thread_id = Qnil;
+    result->trace = true;
+    result->fiber = 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)
+prof_thread_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. */
+    /* Has this method object been accessed by Ruby?  If
+       yes then set its data to nil to avoid a segmentation fault on the next mark and sweep. */
     if (thread_data->object != Qnil)
     {
-        RDATA(thread_data->object)->data = NULL;
-        RDATA(thread_data->object)->dfree = NULL;
         RDATA(thread_data->object)->dmark = NULL;
+        RDATA(thread_data->object)->dfree = NULL;
+        RDATA(thread_data->object)->data = NULL;
+        thread_data->object = Qnil;
     }
-    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);
 }
@@ -57,33 +66,51 @@ mark_methods(st_data_t key, st_data_t value, st_data_t result)
     return ST_CONTINUE;
 }
 
+size_t
+prof_thread_size(const void *data)
+{
+    return sizeof(prof_call_info_t);
+}
+
 void
-prof_thread_mark(thread_data_t *thread)
+prof_thread_mark(void *data)
 {
+    thread_data_t *thread = (thread_data_t*)data;
+    
     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);
-
+    
+    if (thread->thread_id != Qnil)
+        rb_gc_mark(thread->thread_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);
+    if (thread->object == Qnil)
+    {
+        thread->object = Data_Wrap_Struct(cRpThread, prof_thread_mark, NULL, thread);
     }
     return thread->object;
 }
 
+static VALUE
+prof_thread_allocate(VALUE klass)
+{
+    thread_data_t* thread_data = thread_data_create();
+    thread_data->object = prof_thread_wrap(thread_data);
+    return thread_data->object;
+}
+
 static thread_data_t*
 prof_get_thread(VALUE self)
 {
@@ -109,7 +136,7 @@ threads_table_create()
 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);
+    prof_thread_free((thread_data_t*)value);
     return ST_CONTINUE;
 }
 
@@ -120,73 +147,70 @@ threads_table_free(st_table *table)
     st_free_table(table);
 }
 
-size_t
-threads_table_insert(prof_profile_t* profile, VALUE key, thread_data_t *thread_data)
+thread_data_t *
+threads_table_lookup(void *prof, VALUE fiber)
 {
-	unsigned LONG_LONG key_value = NUM2ULL(key);
-	return st_insert(profile->threads_tbl, key_value, (st_data_t) thread_data);
+    prof_profile_t *profile = prof;
+    thread_data_t* result = NULL;
+    st_data_t val;
+
+    if (st_lookup(profile->threads_tbl, fiber, &val))
+    {
+        result = (thread_data_t*)val;
+    }
+
+    return result;
 }
 
-thread_data_t *
-threads_table_lookup(prof_profile_t* profile, VALUE thread_id, VALUE fiber_id)
+thread_data_t*
+threads_table_insert(void *prof, VALUE fiber)
 {
-    thread_data_t* result;
-    st_data_t val;
+    prof_profile_t *profile = prof;
+    thread_data_t *result = thread_data_create();
+    VALUE thread = rb_thread_current();
+
+    result->fiber = fiber;
+    result->fiber_id = rb_obj_id(fiber);
+    result->thread_id = rb_obj_id(thread);
+    st_insert(profile->threads_tbl, (st_data_t)fiber, (st_data_t)result);
 
-    /* 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;
-    unsigned LONG_LONG key_value = NUM2ULL(key);
-    if (st_lookup(profile->threads_tbl, key_value, &val))
+    // Are we tracing this thread?
+    if (profile->include_threads_tbl && !st_lookup(profile->include_threads_tbl, thread, 0))
+    {
+        result->trace= false;
+    }
+    else if (profile->exclude_threads_tbl && st_lookup(profile->exclude_threads_tbl, thread, 0))
     {
-      result = (thread_data_t *) val;
+        result->trace = false;
     }
     else
     {
-        result = thread_data_create();
-        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;
-        /* Insert the table */
-        threads_table_insert(profile, key, result);
+        result->trace = true;
     }
+    
     return result;
 }
 
-thread_data_t *
-switch_thread(void* prof, VALUE thread_id, VALUE fiber_id)
+void
+switch_thread(void *prof, thread_data_t *thread_data, double measurement)
 {
-    prof_profile_t* profile = (prof_profile_t*)prof;
-    double measurement = profile->measurer->measure();
-
-    /* Get new thread information. */
-    thread_data_t *thread_data = threads_table_lookup(profile, thread_id, fiber_id);
+    prof_profile_t *profile = prof;
 
     /* 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)
-    {
-        frame->wait_time += measurement - frame->switch_time;
-        frame->switch_time = measurement;
-    }
-
+    prof_frame_t* frame = thread_data->stack->ptr;
+    frame->wait_time += measurement - frame->switch_time;
+    frame->switch_time = measurement;
+ 
     /* 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)
-         last_frame->switch_time = measurement;
+        prof_frame_t* last_frame = profile->last_thread_data->stack->ptr;
+        if (last_frame)
+            last_frame->switch_time = measurement;
     }
 
     profile->last_thread_data = thread_data;
-    return thread_data;
 }
 
 int pause_thread(st_data_t key, st_data_t value, st_data_t data)
@@ -194,7 +218,7 @@ 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_t* frame = thread_data->stack->ptr;
     prof_frame_pause(frame, profile->measurement_at_pause_resume);
 
     return ST_CONTINUE;
@@ -205,7 +229,7 @@ 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_t* frame = thread_data->stack->ptr;
     prof_frame_unpause(frame, profile->measurement_at_pause_resume);
 
     return ST_CONTINUE;
@@ -219,18 +243,18 @@ collect_methods(st_data_t key, st_data_t value, st_data_t result)
     VALUE methods = (VALUE) result;
     prof_method_t *method = (prof_method_t *) value;
 
-    if (!method->excluded) {
+    if (!method->excluded)
+    {
       rb_ary_push(methods, prof_method_wrap(method));
     }
 
     return ST_CONTINUE;
 }
 
-
 /* call-seq:
    id -> number
 
-Returns the id of this thread. */
+Returns the thread id of this thread. */
 static VALUE
 prof_thread_id(VALUE self)
 {
@@ -250,7 +274,7 @@ prof_fiber_id(VALUE self)
 }
 
 /* call-seq:
-   methods -> Array of MethodInfo
+   methods -> [RubyProf::MethodInfo]
 
 Returns an array of methods that were called from this
 thread during program execution. */
@@ -266,12 +290,48 @@ prof_thread_methods(VALUE self)
     return thread->methods;
 }
 
-void rp_init_thread()
+/* :nodoc: */
+static VALUE
+prof_thread_dump(VALUE self)
+{
+    thread_data_t* thread_data = DATA_PTR(self);
+
+    VALUE result = rb_hash_new();
+    rb_hash_aset(result, ID2SYM(rb_intern("fiber_id")), thread_data->fiber_id);
+    rb_hash_aset(result, ID2SYM(rb_intern("methods")), prof_thread_methods(self));
+
+    return result;
+}
+
+/* :nodoc: */
+static VALUE
+prof_thread_load(VALUE self, VALUE data)
+{
+    thread_data_t* thread_data = DATA_PTR(self);
+    thread_data->object = self;
+
+    thread_data->fiber_id = rb_hash_aref(data, ID2SYM(rb_intern("fiber_id")));
+    VALUE methods = rb_hash_aref(data, ID2SYM(rb_intern("methods")));
+
+    for (int i = 0; i < rb_array_len(methods); i++)
+    {
+        VALUE method = rb_ary_entry(methods, i);
+        prof_method_t *method_data = DATA_PTR(method);
+        method_table_insert(thread_data->method_table, method_data->key, method_data);
+    }
+
+    return data;
+}
+
+void rp_init_thread(void)
 {
-    cRpThread = rb_define_class_under(mProf, "Thread", rb_cObject);
+    cRpThread = rb_define_class_under(mProf, "Thread", rb_cData);
     rb_undef_method(CLASS_OF(cRpThread), "new");
+    rb_define_alloc_func(cRpThread, prof_thread_allocate);
 
     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);
+    rb_define_method(cRpThread, "_dump_data", prof_thread_dump, 0);
+    rb_define_method(cRpThread, "_load_data", prof_thread_load, 1);
 }