ruby-prof 0.11.0.rc1-x86-mingw32 → 0.11.0.rc2-x86-mingw32

data/ext/ruby_prof/rp_stack.c

@@ -29,6 +29,8 @@ stack_free(prof_stack_t *stack)
 prof_frame_t *
 stack_push(prof_stack_t *stack)
 {
+  prof_frame_t* result = NULL;
+
   /* Is there space on the stack?  If not, double
      its size. */
   if (stack->ptr == stack->end  )   
@@ -36,10 +38,23 @@ stack_push(prof_stack_t *stack)
     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;
   }
-  return stack->ptr++;
+
+  // Setup returned stack pointer to be valid
+  result = stack->ptr;
+  result->child_time = 0;
+  result->switch_time = 0;
+  result->wait_time = 0;
+  result->depth = (stack->ptr - stack->start);
+
+  // Increment the stack ptr for next time
+  stack->ptr++;
+
+  // Return the result
+  return result;
 }
 
 prof_frame_t *

data/ext/ruby_prof/rp_stack.h

@@ -11,15 +11,18 @@
 
 
 /* Temporary object that maintains profiling information
-   for active methods - there is one per method.*/
+   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;
     double start_time;
+    double switch_time;  /* Time at switch to different thread */
     double wait_time;
     double child_time;
+    int depth;
     unsigned int line;
 } prof_frame_t;
 

data/ext/ruby_prof/rp_thread.c

@@ -3,25 +3,96 @@
 
 #include "ruby_prof.h"
 
+VALUE cRpThread;
+
 /* ======   thread_data_t  ====== */
 thread_data_t*
-thread_data_create(double measure)
+thread_data_create()
 {
     thread_data_t* result = ALLOC(thread_data_t);
     result->stack = stack_create();
     result->method_table = method_table_create();
-    result->last_switch = measure;
+	result->top = NULL;
+	result->object = Qnil;
+	result->methods = Qnil;
     return result;
 }
 
-void
+/* 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);
+    thread_data->top = NULL;
     method_table_free(thread_data->method_table);
     stack_free(thread_data->stack);
-    xfree(thread_data);
+
+    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);
+	
+	prof_method_mark(thread->top);
+	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;
+}
+
+static 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
@@ -33,6 +104,20 @@ 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 thread, thread_data_t *thread_data)
 {
@@ -53,7 +138,7 @@ threads_table_lookup(prof_profile_t* profile, VALUE thread_id)
     }
     else
     {
-        result = thread_data_create(profile->measurer->measure());
+        result = thread_data_create();
         result->thread_id = thread_id;
 
         /* Insert the table */
@@ -62,52 +147,97 @@ threads_table_lookup(prof_profile_t* profile, VALUE thread_id)
     return result;
 }
 
-int
-free_thread_data(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, free_thread_data, 0);
-    st_free_table(table);
-}
-
 thread_data_t *
 switch_thread(void* prof, VALUE thread_id)
 {
-	prof_profile_t* profile = (prof_profile_t*)prof;
-    prof_frame_t *frame = NULL;
-    double wait_time = 0;
+    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);
 
-    /* How long has this thread been waiting? */
-    wait_time = profile->measurement - thread_data->last_switch;
-
-    thread_data->last_switch = profile->measurement; // XXXX a test that fails if this is 0
-
-    /* Get the frame at the top of the stack.  This may represent
-       the current method (EVENT_LINE, EVENT_RETURN)  or the
-       previous method (EVENT_CALL).*/
-    frame = stack_peek(thread_data->stack);
+    /* Get current frame for this thread */
+    prof_frame_t *frame = stack_peek(thread_data->stack);
 
+    /* Update the time this thread waited for another thread */
     if (frame)
-	{
-      frame->wait_time += wait_time;
+    {
+        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)
-	{
-      profile->last_thread_data->last_switch = profile->measurement;
+    {
+       prof_frame_t *last_frame = stack_peek(profile->last_thread_data->stack);
+       if (last_frame)
+         last_frame->switch_time = measurement;
     }
 
     profile->last_thread_data = thread_data;
     return thread_data;
 }
+
+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;
+    rb_ary_push(methods, prof_method_wrap(method));
+
+    return ST_CONTINUE;
+}
+
+
+/* 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:
+   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;
+}
+
+/* call-seq:
+   method -> MethodInfo
+
+Returns the top level method for this thread (ie, the starting
+method). */
+static VALUE
+prof_thread_top_method(VALUE self)
+{
+    thread_data_t* thread = prof_get_thread(self);
+	return  prof_method_wrap(thread->top);
+}
+
+void rp_init_thread()
+{
+    cRpThread = rb_define_class_under(mProf, "Thread", rb_cObject);
+    rb_undef_method(CLASS_OF(cRpThread), "new");
+
+    rb_define_method(cRpThread, "id", prof_thread_id, 0);
+    rb_define_method(cRpThread, "methods", prof_thread_methods, 0);
+    rb_define_method(cRpThread, "top_method", prof_thread_top_method, 0);
+}

data/ext/ruby_prof/rp_thread.h

@@ -7,14 +7,20 @@
 /* Profiling information for a thread. */
 typedef struct 
 {
+	VALUE object;                     /* Cache to wrapped object */
+	VALUE methods;                    /* Array of RubyProf::MethodInfo */
     VALUE thread_id;                  /* Thread id */
     st_table* method_table;           /* Methods called in the thread */
-    prof_stack_t* stack;              /* Active methods */
-    double last_switch;       /* Point of last context switch */
+    prof_stack_t* stack;              /* Stack of frames */
+    prof_method_t* top;               /* The top method called in this thread */
 } thread_data_t;
 
+void rp_init_thread();
 st_table * threads_table_create();
 thread_data_t* switch_thread(void* prof, VALUE thread_id);
 void threads_table_free(st_table *table);
+VALUE prof_thread_wrap(thread_data_t *thread);
+void prof_thread_mark(thread_data_t *thread);
+
 
 #endif //__RP_THREAD__

data/ext/ruby_prof/ruby_prof.c

@@ -24,7 +24,6 @@
 */
 
 #include "ruby_prof.h"
-#include <stdio.h>
 #include <assert.h>
 
 VALUE mProf;
@@ -44,14 +43,6 @@ prof_get_profile(VALUE self)
     return (prof_profile_t*)RDATA(self)->data;
 }
 
-void
-method_key(prof_method_key_t* key, VALUE klass, ID mid)
-{
-    key->klass = klass;
-    key->mid = mid;
-    key->key = (klass << 4) + (mid << 2);
-}
-
 /* support tracing ruby events from ruby-prof. useful for getting at
    what actually happens inside the ruby interpreter (and ruby-prof).
    set environment variable RUBY_PROF_TRACE to filename you want to
@@ -91,81 +82,85 @@ get_event_name(rb_event_flag_t event)
   }
 }
 
+static prof_method_t*
+create_method(rb_event_flag_t event, VALUE klass, ID mid, const char* source_file, int line)
+{
+    /* Line numbers are not accurate for c method calls */
+    if (event == RUBY_EVENT_C_CALL)
+    {
+		line = 0;
+		source_file = NULL;
+    }
+
+    return prof_method_create(klass, mid, source_file, line);
+}
+
 
 static prof_method_t*
 #ifdef RUBY_VM
- get_method(rb_event_flag_t event, VALUE klass, ID mid, st_table* method_table)
+ get_method(rb_event_flag_t event, VALUE klass, ID mid, thread_data_t* thread_data)
 # else
- get_method(rb_event_flag_t event, NODE *node, VALUE klass, ID mid, st_table* method_table)
+ get_method(rb_event_flag_t event, NODE *node, VALUE klass, ID mid, thread_data_t* thread_data)
 #endif
 {
     prof_method_key_t key;
     prof_method_t *method = NULL;
 
     method_key(&key, klass, mid);
-    method = method_table_lookup(method_table, &key);
+    method = method_table_lookup(thread_data->method_table, &key);
 
     if (!method)
     {
-      const char* source_file = rb_sourcefile();
+ 	  const char* source_file = rb_sourcefile();
       int line = rb_sourceline();
 
-      /* Line numbers are not accurate for c method calls */
-      if (event == RUBY_EVENT_C_CALL)
-      {
-        line = 0;
-        source_file = NULL;
-      }
+	  method = create_method(event, klass, mid, source_file, line);
+      method_table_insert(thread_data->method_table, method->key, method);
 
-      method = prof_method_create(&key, source_file, line);
-      method_table_insert(method_table, method->key, method);
+	  /* Is this the first method added to the thread? */
+	  if (!thread_data->top)
+		  thread_data->top = method;
     }
     return method;
 }
 
-static void
-update_result(double total_time,
-              prof_frame_t *parent_frame,
-              prof_frame_t *frame)
-{
-    double self_time = total_time - frame->child_time - frame->wait_time;
-    prof_call_info_t *call_info = frame->call_info;
-
-    /* Update information about the current method */
-    call_info->called++;
-    call_info->total_time += total_time;
-    call_info->self_time += self_time;
-    call_info->wait_time += frame->wait_time;
-
-    /* Note where the current method was called from */
-    if (parent_frame)
-      call_info->line = parent_frame->line;
-}
-
 static prof_frame_t*
 pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
 {
   prof_frame_t *frame = NULL;
   prof_frame_t* parent_frame = NULL;
+  prof_call_info_t *call_info;
+  double measurement = profile->measurer->measure();
   double total_time;
+  double self_time;
 
   frame = stack_pop(thread_data->stack); // only time it's called
+
   /* 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 == NULL) return NULL;
+  if (frame == NULL) 
+      return NULL;
 
   /* Calculate the total time this method took */
-  total_time = profile->measurement - frame->start_time;
+  total_time = measurement - frame->start_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 = stack_peek(thread_data->stack);
   if (parent_frame)
   {
-        parent_frame->child_time += total_time;
+      parent_frame->child_time += total_time;
+      call_info->line = parent_frame->line;
   }
 
-  update_result(total_time, parent_frame, frame); // only time it's called
   return frame;
 }
 
@@ -194,6 +189,42 @@ prof_pop_threads(prof_profile_t* profile)
     st_foreach(profile->threads_tbl, pop_frames, (st_data_t) profile);
 }
 
+/* ===========  Profiling ================= */
+#ifdef RUBY_VM
+static void
+prof_trace(prof_profile_t* profile, rb_event_flag_t event, ID mid, VALUE klass, double measurement)
+#else
+static void
+prof_trace(prof_profile_t* profile, rb_event_flag_t event, NODE *node, ID mid, VALUE klass, double measurement)
+#endif
+{
+    static VALUE last_thread_id = Qnil;
+
+    VALUE thread = rb_thread_current();
+    VALUE thread_id = rb_obj_id(thread);
+    const char* class_name = NULL;
+    const char* method_name = rb_id2name(mid);
+    const char* source_file = rb_sourcefile();
+    unsigned int source_line = rb_sourceline();
+
+    const char* event_name = get_event_name(event);
+
+    if (klass != 0)
+        klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
+
+    class_name = rb_class2name(klass);
+
+    if (last_thread_id != thread_id)
+    {
+        fprintf(trace_file, "\n");
+    }
+
+    fprintf(trace_file, "%2u:%2ums %-8s %s:%2d  %s#%s\n",
+            (unsigned int) thread_id, (unsigned int) measurement, event_name, source_file, source_line, class_name, method_name);
+    fflush(trace_file);
+    last_thread_id = thread_id;
+}
+
 #ifdef RUBY_VM
 static void
 prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
@@ -207,11 +238,12 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
 #else
     prof_profile_t* profile = prof_get_profile(data);
 #endif	
-	
-	VALUE thread = Qnil;
+    
+    VALUE thread = Qnil;
     VALUE thread_id = Qnil;
     thread_data_t* thread_data = NULL;
     prof_frame_t *frame = NULL;
+    double measurement;
 
     #ifdef RUBY_VM
       if (event != RUBY_EVENT_C_CALL && event != RUBY_EVENT_C_RETURN) {
@@ -221,34 +253,15 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     #endif
 
     /* Get current measurement */
-    profile->measurement = profile->measurer->measure();
+    measurement = profile->measurer->measure();
 
     if (trace_file != NULL)
     {
-        static VALUE last_thread_id = Qnil;
-
-        VALUE thread = rb_thread_current();
-        VALUE thread_id = rb_obj_id(thread);
-        const char* class_name = NULL;
-        const char* method_name = rb_id2name(mid);
-        const char* source_file = rb_sourcefile();
-        unsigned int source_line = rb_sourceline();
-
-        const char* event_name = get_event_name(event);
-
-        if (klass != 0)
-          klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
-
-        class_name = rb_class2name(klass);
-
-        if (last_thread_id != thread_id) {
-          fprintf(trace_file, "\n");
-        }
-
-        fprintf(trace_file, "%2u:%2ums %-8s %s:%2d  %s#%s\n",
-               (unsigned int) thread_id, (unsigned int) profile->measurement, event_name, source_file, source_line, class_name, method_name);
-        /* fflush(trace_file); */
-        last_thread_id = thread_id;
+#ifdef RUBY_VM
+        prof_trace(profile, event, mid, klass, measurement);
+#else
+        prof_trace(profile, event, node, mid, klass, measurement);
+#endif
     }
 
     /* Special case - skip any methods from the mProf
@@ -271,6 +284,8 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     else
       thread_data = profile->last_thread_data;
 
+    /* Get the current frame for the current thread. */
+    frame = stack_peek(thread_data->stack);
 
     switch (event) {
     case RUBY_EVENT_LINE:
@@ -279,9 +294,6 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
          a new method is called, we know what line number it was
          called from. */
 
-       /* Get the current frame for the current thread. */
-      frame = stack_peek(thread_data->stack);
-
       if (frame)
       {
         frame->line = rb_sourceline();
@@ -298,20 +310,10 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         prof_call_info_t *call_info = NULL;
         prof_method_t *method = NULL;
 
-        /* Get the current frame for the current thread. */
-        frame = stack_peek(thread_data->stack);
-
-        /* Is this an include for a module?  If so get the actual
-           module class since we want to combine all profiling
-           results for that module. */
-
-        if (klass != 0)
-          klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
-
         #ifdef RUBY_VM
-        method = get_method(event, klass, mid, thread_data->method_table);
+        method = get_method(event, klass, mid, thread_data);
         #else
-        method = get_method(event, node, klass, mid, thread_data->method_table);
+        method = get_method(event, node, klass, mid, thread_data);
         #endif
 
         if (!frame)
@@ -325,6 +327,8 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
 
           if (!call_info)
           {
+            /* This call info does not yet exist.  So create it, then add
+               it to previous callinfo's children and to the current method .*/
             call_info = prof_call_info_create(method, frame->call_info);
             call_info_table_insert(frame->call_info->call_infos, method->key, call_info);
             prof_add_call_info(method->call_infos, call_info);
@@ -334,23 +338,20 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         /* Push a new frame onto the stack for a new c-call or ruby call (into a method) */
         frame = stack_push(thread_data->stack);
         frame->call_info = call_info;
-        frame->start_time = profile->measurement;
-        frame->wait_time = 0;
-        frame->child_time = 0;
+		frame->call_info->depth = frame->depth;
+        frame->start_time = measurement;
         frame->line = rb_sourceline();
         break;
     }
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_C_RETURN:
     {
-        frame = pop_frame(profile, thread_data);
+      pop_frame(profile, thread_data);
       break;
     }
   }
 }
 
-
-/* ===========  Profiling ================= */
 void
 prof_install_hook(VALUE self)
 {
@@ -365,7 +366,7 @@ prof_install_hook(VALUE self)
           RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN
           | RUBY_EVENT_LINE);
 
-	pCurrentProfile = prof_get_profile(self);
+    pCurrentProfile = prof_get_profile(self);
 #endif	
 
 #if defined(TOGGLE_GC_STATS)
@@ -381,65 +382,53 @@ prof_remove_hook()
 #endif
 
 #ifndef RUBY_VM
-	pCurrentProfile = NULL;
+    pCurrentProfile = NULL;
 #endif
 
     /* Now unregister from event   */
     rb_remove_event_hook(prof_event_hook);
 }
 
-
 static int
-collect_methods(st_data_t key, st_data_t value, st_data_t result)
+collect_threads(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;
-    rb_ary_push(methods, prof_method_wrap(method));
-
-    /* Wrap call info objects */
-    prof_call_infos_wrap(method->call_infos);
-
+    thread_data_t* thread_data = (thread_data_t*) value;
+    VALUE threads_array = (VALUE) result;
+	rb_ary_push(threads_array, prof_thread_wrap(thread_data));
     return ST_CONTINUE;
 }
 
+/* ========  Profile Class ====== */
 static int
-collect_threads(st_data_t key, st_data_t value, st_data_t result)
+mark_threads(st_data_t key, st_data_t value, st_data_t result)
 {
-    /* Although threads are keyed on an id, that is actually a
-       pointer to the VALUE object of the thread.  So its bogus.
-       However, in thread_data is the real thread id stored
-       as an int. */
-    thread_data_t* thread_data = (thread_data_t*) value;
-    VALUE threads_hash = (VALUE) result;
-
-    VALUE methods = rb_ary_new();
-
-    /* Now collect an array of all the called methods */
-    st_table* method_table = thread_data->method_table;
-    st_foreach(method_table, collect_methods, methods);
-
-    /* Store the results in the threads hash keyed on the thread id. */
-    rb_hash_aset(threads_hash, thread_data->thread_id, methods);
-
+    thread_data_t *thread = (thread_data_t *) value;
+    prof_thread_mark(thread);
     return ST_CONTINUE;
 }
 
-/* ========  Profile Class ====== */
 static void
 prof_mark(prof_profile_t *profile)
 {
-    VALUE threads = profile->threads;
-    rb_gc_mark(threads);
+	st_foreach(profile->threads_tbl, mark_threads, 0);
 }
 
+/* Freeing the profile creates a cascade of freeing.
+   It fress the thread table, which frees its methods,
+   which frees its call infos. */
 static void
 prof_free(prof_profile_t *profile)
 {
-    profile->threads = Qnil;
+	profile->last_thread_data = NULL;
+
+	threads_table_free(profile->threads_tbl);
+    profile->threads_tbl = NULL;
+
     st_free_table(profile->exclude_threads_tbl);
-	profile->exclude_threads_tbl = NULL;
+    profile->exclude_threads_tbl = NULL;
+
+	xfree(profile->measurer);
+	profile->measurer = NULL;
 
     xfree(profile);
 }
@@ -450,7 +439,8 @@ prof_allocate(VALUE klass)
     VALUE result;
     prof_profile_t* profile;
     result = Data_Make_Struct(klass, prof_profile_t, prof_mark, prof_free, profile);
-    profile->exclude_threads_tbl = threads_table_create();
+    profile->threads_tbl = threads_table_create();
+	profile->exclude_threads_tbl = threads_table_create();
     profile->running = Qfalse;
     return result;
 }
@@ -469,9 +459,9 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
     VALUE mode;
-	prof_measure_mode_t measurer;
+    prof_measure_mode_t measurer;
     VALUE exclude_threads;
-	int i;
+    int i;
     
     switch (rb_scan_args(argc, argv, "02", &mode, &exclude_threads))
     {
@@ -479,32 +469,30 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
       {
         measurer = MEASURE_WALL_TIME;
         exclude_threads = rb_ary_new();
-		break;
+        break;
       }
       case 1:
       {
         measurer = (prof_measure_mode_t)NUM2INT(mode);
         exclude_threads = rb_ary_new();
-		break;
+        break;
       }
       case 2:
       {
-		Check_Type(exclude_threads, T_ARRAY);
+        Check_Type(exclude_threads, T_ARRAY);
         measurer = (prof_measure_mode_t)NUM2INT(mode);
-		break;
+        break;
       }
     }
 
     profile->measurer = prof_get_measurer(measurer);
-    profile->threads = rb_hash_new();
-
 
-	for (i = 0; i < RARRAY_LEN(exclude_threads); i++)
-	{
-		VALUE thread = rb_ary_entry(exclude_threads, i);
-		VALUE thread_id = rb_obj_id(thread);
-	    st_insert(profile->exclude_threads_tbl, thread_id, Qtrue);
-	}
+    for (i = 0; i < RARRAY_LEN(exclude_threads); i++)
+    {
+        VALUE thread = rb_ary_entry(exclude_threads, i);
+        VALUE thread_id = rb_obj_id(thread);
+        st_insert(profile->exclude_threads_tbl, thread_id, Qtrue);
+    }
 
     return self;
 }
@@ -527,7 +515,7 @@ prof_running(VALUE self)
 static VALUE
 prof_start(VALUE self)
 {
-	char* trace_file_name;
+    char* trace_file_name;
     prof_profile_t* profile = prof_get_profile(self);
         
     if (profile->running == Qtrue)
@@ -537,17 +525,23 @@ prof_start(VALUE self)
 
     profile->running = Qtrue;
     profile->last_thread_data = NULL;
-    profile->threads_tbl = threads_table_create();
+
 
     /* open trace file if environment wants it */
     trace_file_name = getenv("RUBY_PROF_TRACE");
-    if (trace_file_name != NULL) {
-      if (0==strcmp(trace_file_name, "stdout")) {
+    if (trace_file_name != NULL) 
+    {
+      if (strcmp(trace_file_name, "stdout") == 0) 
+      {
         trace_file = stdout;
-      } else if (0==strcmp(trace_file_name, "stderr")) {
+      } 
+      else if (strcmp(trace_file_name, "stderr") == 0)
+      {
         trace_file = stderr;
-      } else {
-        trace_file = fopen(trace_file_name, "a");
+      }
+      else 
+      {
+        trace_file = fopen(trace_file_name, "w");
       }
     }
 
@@ -609,23 +603,27 @@ prof_stop(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
 
-	/* get 'now' before prof emove hook because it calls GC.disable_stats
-      which makes the call within prof_pop_threads of now return 0, which is wrong
-    */
-    profile->measurement = profile->measurer->measure();
     if (profile->running == Qfalse)
     {
         rb_raise(rb_eRuntimeError, "RubyProf.start was not yet called");
     }
   
+    prof_remove_hook();
+
     /* close trace file if open */
-    if (trace_file != NULL) {
-      if (trace_file!=stderr && trace_file!=stdout)
+    if (trace_file != NULL) 
+    {
+      if (trace_file !=stderr && trace_file != stdout)
+      {
+#ifdef _MSC_VER
+          _fcloseall();
+#else
         fclose(trace_file);
+#endif
+      }
       trace_file = NULL;
     }
     
-    prof_remove_hook();
     prof_pop_threads(profile);
 
     /* Unset the last_thread_data (very important!)
@@ -633,13 +631,8 @@ prof_stop(VALUE self)
     profile->running = Qfalse;
     profile->last_thread_data = NULL;
 
-    /* Save the result */
-    st_foreach(profile->threads_tbl, collect_threads, profile->threads);
-	threads_table_free(profile->threads_tbl);
-	profile->threads_tbl = NULL;
-
-    /* compute minimality of call_infos */
-    rb_funcall(self, rb_intern("compute_minimality") , 0);
+    /* Post process result */
+    rb_funcall(self, rb_intern("post_process") , 0);
 
     return self;
 }
@@ -665,18 +658,17 @@ prof_profile(int argc,  VALUE *argv, VALUE klass)
 }
 
 /* call-seq:
-   threads -> Hash
+   threads -> Array of RubyProf::Thread
 
-Returns a hash table keyed on thread ID.  For each thread id,
-the hash table stores another hash table that contains profiling
-information for each method called during the threads execution.
-That hash table is keyed on method name and contains
-RubyProf::MethodInfo objects. */
+Returns an array of RubyProf::Thread instances that were executed
+while the the program was being run. */
 static VALUE
 prof_threads(VALUE self)
 {
+	VALUE result = rb_ary_new();
     prof_profile_t* profile = prof_get_profile(self);
-    return profile->threads;
+    st_foreach(profile->threads_tbl, collect_threads, result);
+    return result;
 }
 
 void Init_ruby_prof()
@@ -687,8 +679,9 @@ void Init_ruby_prof()
     rp_init_measure();
     rp_init_method_info();
     rp_init_call_info();
+    rp_init_thread();
 
-	cProfile = rb_define_class_under(mProf, "Profile", rb_cObject);
+    cProfile = rb_define_class_under(mProf, "Profile", rb_cObject);
     rb_define_singleton_method(cProfile, "profile", prof_profile, -1);
     rb_define_alloc_func (cProfile, prof_allocate);
     rb_define_method(cProfile, "initialize", prof_initialize, -1);