ruby-prof 0.11.2-x86-mingw32 → 0.12.1-x86-mingw32

data/ext/ruby_prof/rp_call_info.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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"
@@ -10,7 +10,6 @@ VALUE cCallInfo;
 
 // Forward declarations
 st_table * call_info_table_create();
-void call_info_table_free(st_table *table);
 
 
 /* =======  prof_call_info_t   ========*/
@@ -31,9 +30,8 @@ prof_call_info_create(prof_method_t* method, prof_call_info_t* parent)
     result->line = 0;
     return result;
 }
-
 static void
-prof_call_info_free(prof_call_info_t *call_info)
+prof_call_info_ruby_gc_free(prof_call_info_t *call_info)
 {
 	/* Has this thread object been accessed by Ruby?  If
 	   yes clean it up so to avoid a segmentation fault. */
@@ -44,8 +42,13 @@ prof_call_info_free(prof_call_info_t *call_info)
 		RDATA(call_info->object)->dmark = NULL;
     }
 	call_info->object = Qnil;
+}
 
-	call_info_table_free(call_info->call_infos);
+static void
+prof_call_info_free(prof_call_info_t *call_info)
+{
+	prof_call_info_ruby_gc_free(call_info);
+	xfree(call_info->call_infos);
 	xfree(call_info);
 }
 
@@ -53,10 +56,13 @@ static void
 prof_call_info_mark(prof_call_info_t *call_info)
 {
 	if (call_info->object)
-		rb_gc_mark(call_info->children);
+		rb_gc_mark(call_info->object);
 
 	if (call_info->children)
 		rb_gc_mark(call_info->children);
+
+	/* We don't mark the call info child table since that will be done
+	   via the appropriate method */
 }
 
 VALUE
@@ -64,7 +70,7 @@ prof_call_info_wrap(prof_call_info_t *call_info)
 {
   if (call_info->object == Qnil)
   {
-    call_info->object = Data_Wrap_Struct(cCallInfo, prof_call_info_mark, prof_call_info_free, call_info);
+    call_info->object = Data_Wrap_Struct(cCallInfo, prof_call_info_mark, prof_call_info_ruby_gc_free, call_info);
   }
   return call_info->object;
 }
@@ -89,20 +95,6 @@ call_info_table_create()
   return st_init_table(&type_method_hash);
 }
 
-/*static int
-call_info_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
-{
-    prof_call_info_free((prof_call_info_t*)value);
-    return ST_CONTINUE;
-}*/
-
-void
-call_info_table_free(st_table *table)
-{
-  //st_foreach(table, call_info_table_free_iterator, 0);
-    st_free_table(table);
-}
-
 size_t
 call_info_table_insert(st_table *table, const prof_method_key_t *key, prof_call_info_t *val)
 {
@@ -337,11 +329,29 @@ prof_call_infos_create()
    return result;
 }
 
+void
+prof_call_infos_mark(prof_call_infos_t *call_infos)
+{
+    prof_call_info_t **call_info;
+
+	if (call_infos->object)
+		rb_gc_mark(call_infos->object);
+
+    for(call_info=call_infos->start; call_info<call_infos->ptr; call_info++)
+    {
+		prof_call_info_mark(*call_info);
+    }
+}
+
 void
 prof_call_infos_free(prof_call_infos_t *call_infos)
 {
-  xfree(call_infos->start);
-  xfree(call_infos);
+    prof_call_info_t **call_info;
+
+    for(call_info=call_infos->start; call_info<call_infos->ptr; call_info++)
+    {
+		prof_call_info_free(*call_info);
+    }
 }
 
 void
@@ -375,7 +385,6 @@ prof_call_infos_wrap(prof_call_infos_t *call_infos)
   return call_infos->object;
 }
 
-
 void rp_init_call_info()
 {
     /* CallInfo */

data/ext/ruby_prof/rp_call_info.h

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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_CALL_INFO_H__
@@ -37,6 +37,7 @@ typedef struct prof_call_infos_t
 
 void rp_init_call_info(void);
 prof_call_infos_t* prof_call_infos_create();
+void prof_call_infos_mark(prof_call_infos_t *call_infos);
 void prof_call_infos_free(prof_call_infos_t *call_infos);
 void prof_add_call_info(prof_call_infos_t *call_infos, prof_call_info_t *call_info);
 VALUE prof_call_infos_wrap(prof_call_infos_t *call_infos);

data/ext/ruby_prof/rp_measure.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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"

data/ext/ruby_prof/rp_measure.h

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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_MEASUREMENT_H__

data/ext/ruby_prof/rp_measure_allocations.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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 */
 
 /* :nodoc: */

data/ext/ruby_prof/rp_measure_cpu_time.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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"

data/ext/ruby_prof/rp_measure_gc_runs.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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 */
 
 /* :nodoc: */

data/ext/ruby_prof/rp_measure_gc_time.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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 */
 
 /* :nodoc: */

data/ext/ruby_prof/rp_measure_memory.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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 */
 
 /* :nodoc: */

data/ext/ruby_prof/rp_measure_process_time.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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"
@@ -12,7 +12,7 @@ measure_process_time()
 #if defined(__linux__)
     struct timespec clock;
     clock_gettime(CLOCK_PROCESS_CPUTIME_ID , &clock);
-    return (clock.tv_sec * 1000000000 + clock.tv_nsec) / 1000000000.0;
+    return clock.tv_sec + (clock.tv_nsec/1000000000.0);
 #elif defined(_win32)
 	FILETIME createTime;
 	FILETIME exitTime;

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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 */
 
 /* :nodoc: */
@@ -11,7 +11,7 @@ measure_wall_time()
 {
     struct timeval tv;
     gettimeofday(&tv, NULL);
-    return (tv.tv_sec * 1000000 + tv.tv_usec) / 1000000.0;
+    return tv.tv_sec + (tv.tv_usec/1000000.0);
 }
 
 prof_measurer_t* prof_measurer_wall_time()

data/ext/ruby_prof/rp_method.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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"
@@ -98,10 +98,12 @@ method_name(ID mid)
 {
     VALUE result;
 
-    if (mid == ID_ALLOCATOR)
-        result = rb_str_new2("allocate");
-    else if (mid == 0)
+    if (mid == 0)
         result = rb_str_new2("[No method]");
+#ifdef ID_ALLOCATOR
+    else if (mid == ID_ALLOCATOR)
+        result = rb_str_new2("allocate");
+#endif
     else
         result = rb_String(ID2SYM(mid));
 
@@ -139,7 +141,6 @@ prof_method_create(VALUE klass, ID mid, const char* source_file, int line)
     prof_method_t *result = ALLOC(prof_method_t);
     result->object = Qnil;
     result->call_infos = prof_call_infos_create();
-	result->call_infos2 = Qnil;
 
     result->key = ALLOC(prof_method_key_t);
     method_key(result->key, klass, mid);
@@ -188,6 +189,7 @@ prof_method_free(prof_method_t* method)
 {
 	prof_method_ruby_gc_free(method);
 	prof_call_infos_free(method->call_infos);
+	xfree(method->call_infos);
 
 	xfree(method->key);
 	method->key = NULL;
@@ -195,28 +197,13 @@ prof_method_free(prof_method_t* method)
 	xfree(method);
 }
 
-/*static int
-mark_call_infos(st_data_t key, st_data_t value, st_data_t result)
-{
-    prof_call_info_t *call_info = (prof_call_info_t *) value;
-    prof_call_info_mark(call_info);
-    return ST_CONTINUE;
-}
-*/
-
 void
 prof_method_mark(prof_method_t *method)
 {
 	if (method->object)
 		rb_gc_mark(method->object);
 
-	if (method->call_infos2)
-		rb_gc_mark(method->call_infos2);
-
-	if (method->call_infos->object)
-		rb_gc_mark(method->call_infos->object);
-
-	//st_foreach(method->call_info_table, mark_call_infos, NULL);
+	prof_call_infos_mark(method->call_infos);
 }
 
 VALUE
@@ -409,11 +396,11 @@ static VALUE
 prof_method_call_infos(VALUE self)
 {
     prof_method_t *method = get_prof_method(self);
-	if (method->call_infos2 == Qnil)
+	if (method->call_infos->object == Qnil)
 	{
-		method->call_infos2 = prof_call_infos_wrap(method->call_infos);
+		method->call_infos->object = prof_call_infos_wrap(method->call_infos);
 	}
-	return method->call_infos2;
+	return method->call_infos->object;
 }
 
 void rp_init_method_info()

data/ext/ruby_prof/rp_method.h

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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__
@@ -31,9 +31,8 @@ typedef struct
     prof_method_key_t *key;                 /* Method key */
     const char *source_file;                /* The method's source file */
     int line;                               /* The method's line number. */
-    struct prof_call_infos_t *call_infos;          /* Call info objects for this method */
+    struct prof_call_infos_t *call_infos;   /* Call info objects for this method */
     VALUE object;                           /* Cached ruby object */
-	VALUE call_infos2;                      /* Cached array of RubyProf::CallInfo */
 } prof_method_t;
 
 void rp_init_method_info(void);

data/ext/ruby_prof/rp_stack.c

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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"
@@ -6,16 +6,16 @@
 #define INITIAL_STACK_SIZE 8
 
 void
-frame_pause(prof_frame_t *frame, double current_measurement)
+prof_frame_pause(prof_frame_t *frame, double current_measurement)
 {
-    if (frame && frame_is_unpaused(frame))
+    if (frame && prof_frame_is_unpaused(frame))
         frame->pause_time = current_measurement;
 }
 
 void
-frame_unpause(prof_frame_t *frame, double current_measurement)
+prof_frame_unpause(prof_frame_t *frame, double current_measurement)
 {
-    if (frame && frame_is_paused(frame)) {
+    if (frame && prof_frame_is_paused(frame)) {
         frame->dead_time += (current_measurement - frame->pause_time);
         frame->pause_time = -1;
     }
@@ -25,7 +25,7 @@ frame_unpause(prof_frame_t *frame, double current_measurement)
 /* Creates a stack of prof_frame_t to keep track
    of timings for active methods. */
 prof_stack_t *
-stack_create()
+prof_stack_create()
 {
     prof_stack_t *stack = ALLOC(prof_stack_t);
     stack->start = ALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
@@ -36,14 +36,14 @@ stack_create()
 }
 
 void
-stack_free(prof_stack_t *stack)
+prof_stack_free(prof_stack_t *stack)
 {
     xfree(stack->start);
     xfree(stack);
 }
 
 prof_frame_t *
-stack_push(prof_stack_t *stack)
+prof_stack_push(prof_stack_t *stack, double measurement)
 {
   prof_frame_t* result = NULL;
 
@@ -64,7 +64,9 @@ stack_push(prof_stack_t *stack)
   result->child_time = 0;
   result->switch_time = 0;
   result->wait_time = 0;
+  result->dead_time = 0;
   result->depth = (int)(stack->ptr - stack->start); // shortening of 64 bit into 32
+  result->start_time = measurement;
 
   // Increment the stack ptr for next time
   stack->ptr++;
@@ -74,16 +76,55 @@ stack_push(prof_stack_t *stack)
 }
 
 prof_frame_t *
-stack_pop(prof_stack_t *stack)
+prof_stack_pop(prof_stack_t *stack, double measurement)
 {
-    if (stack->ptr == stack->start)
-      return NULL;
-    else
-      return --stack->ptr;
+  prof_frame_t *frame = NULL;
+  prof_frame_t* parent_frame = NULL;
+  prof_call_info_t *call_info;
+
+  double total_time;
+  double self_time;
+#ifdef _MSC_VER
+  BOOL frame_paused;
+#else
+  _Bool frame_paused;
+#endif
+
+  /* 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 (stack->ptr == stack->start)
+    return NULL;
+  
+  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;
+  call_info->called++;
+  call_info->total_time += total_time;
+  call_info->self_time += self_time;
+  call_info->wait_time += frame->wait_time;
+
+  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;
 }
 
 prof_frame_t *
-stack_peek(prof_stack_t *stack)
+prof_stack_peek(prof_stack_t *stack)
 {
     if (stack->ptr == stack->start)
       return NULL;

data/ext/ruby_prof/rp_stack.h

@@ -1,4 +1,4 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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__
@@ -28,10 +28,10 @@ typedef struct
     unsigned int line;
 } prof_frame_t;
 
-#define frame_is_paused(f) (f->pause_time >= 0)
-#define frame_is_unpaused(f) (f->pause_time < 0)
-void frame_pause(prof_frame_t*, double current_measurement);
-void frame_unpause(prof_frame_t*, double current_measurement);
+#define prof_frame_is_paused(f) (f->pause_time >= 0)
+#define prof_frame_is_unpaused(f) (f->pause_time < 0)
+void prof_frame_pause(prof_frame_t*, double current_measurement);
+void prof_frame_unpause(prof_frame_t*, double current_measurement);
 
 
 /* Current stack of active methods.*/
@@ -42,10 +42,10 @@ typedef struct
     prof_frame_t *ptr;
 } prof_stack_t;
 
-prof_stack_t * stack_create();
-void stack_free(prof_stack_t *stack);
-prof_frame_t * stack_push(prof_stack_t *stack);
-prof_frame_t * stack_pop(prof_stack_t *stack);
-prof_frame_t * stack_peek(prof_stack_t *stack);
+prof_stack_t * prof_stack_create();
+void prof_stack_free(prof_stack_t *stack);
+prof_frame_t * prof_stack_push(prof_stack_t *stack, double measurement);
+prof_frame_t * prof_stack_pop(prof_stack_t *stack, double measurement);
+prof_frame_t * prof_stack_peek(prof_stack_t *stack);
 
 #endif //__RP_STACK__