ruby-prof 1.1.0-x64-mingw32 → 1.4.2-x64-mingw32

data/ext/ruby_prof/rp_method.h

@@ -9,62 +9,54 @@
 
 extern VALUE cRpMethodInfo;
 
-/* Source relation bit offsets. */
+// Source relation bit offsets. 
 enum {
-    kModuleIncludee = 0x1,                    /* Included in module */
-    kClassSingleton = 0x2,                    /* Singleton of a class */
-    kModuleSingleton = 0x4,                   /* Singleton of a module */
-    kObjectSingleton = 0x8,                   /* Singleton of an object */
-    kOtherSingleton = 0x10                    /* Singleton of unkown object */
+    kModuleIncludee = 0x1,                    // Included in module 
+    kClassSingleton = 0x2,                    // Singleton of a class 
+    kModuleSingleton = 0x4,                   // Singleton of a module 
+    kObjectSingleton = 0x8,                   // Singleton of an object 
+    kOtherSingleton = 0x10                    // Singleton of unkown 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
+// Profiling information for each method. 
+// Excluded methods have no call_trees, source_klass, or source_file. 
+typedef struct prof_method_t
 {
-    st_data_t key;                          /* Table key */
-
-    int visits;                             /* Current visits on the stack */
-    bool excluded;                          /* Exclude from profile? */
-
-    st_table* parent_call_infos;            /* Call infos that call this method */
-    st_table* child_call_infos;             /* Call infos that this method calls */
-    st_table* allocations_table;            /* Tracks object allocations */
+    VALUE profile;                          // Profile this method is associated with - needed for mark phase
+    struct prof_call_trees_t* call_trees;   // Call infos that call this method 
+    st_table* allocations_table;            // Tracks object allocations 
 
-    unsigned int klass_flags;               /* Information about the type of class */
-    VALUE klass;                            /* Resolved klass */
-    VALUE klass_name;                       /* Resolved klass name for this method */
-    VALUE method_name;                      /* Resolved method name for this method */
+    st_data_t key;                          // Table key 
+    unsigned int klass_flags;               // Information about the type of class 
+    VALUE klass;                            // Resolved klass 
+    VALUE klass_name;                       // Resolved klass name for this method 
+    VALUE method_name;                      // Resolved method name for this method 
 
-    VALUE object;                           /* Cached ruby object */
+    VALUE object;                           // Cached ruby object 
 
-    bool root;                               /* Is this a root method */
     bool recursive;
-    VALUE source_file;                       /* Source file */
-    int source_line;                         /* Line number */
+    int visits;                             // Current visits on the stack 
+    VALUE source_file;                      // Source file 
+    int source_line;                        // Line number 
 
-    prof_measurement_t *measurement;
+    prof_measurement_t* measurement;        // Stores measurement data for this method
 } prof_method_t;
 
 void rp_init_method_info(void);
 
 st_data_t method_key(VALUE klass, VALUE msym);
 
-st_table *method_table_create(void);
-prof_method_t* prof_method_create_excluded(VALUE klass, VALUE msym);
-prof_method_t *method_table_lookup(st_table *table, st_data_t key);
-size_t method_table_insert(st_table *table, st_data_t key, prof_method_t *val);
-void method_table_free(st_table *table);
-prof_method_t *prof_method_create(VALUE klass, VALUE msym, VALUE source_file, int source_line);
-prof_method_t *prof_method_get(VALUE self);
+st_table* method_table_create(void);
+prof_method_t* method_table_lookup(st_table* table, st_data_t key);
+size_t method_table_insert(st_table* table, st_data_t key, prof_method_t* val);
+void method_table_free(st_table* table);
+prof_method_t* prof_method_create(VALUE profile, VALUE klass, VALUE msym, VALUE source_file, int source_line);
+prof_method_t* prof_get_method(VALUE self);
 
-VALUE prof_method_wrap(prof_method_t *result);
-void prof_method_mark(void *data);
+VALUE prof_method_wrap(prof_method_t* result);
+void prof_method_mark(void* data);
 
-VALUE resolve_klass(VALUE klass, unsigned int *klass_flags);
+VALUE resolve_klass(VALUE klass, unsigned int* klass_flags);
 VALUE resolve_klass_name(VALUE klass, unsigned int* klass_flags);
 
 #endif //__RP_METHOD_INFO__

data/ext/ruby_prof/rp_profile.c

@@ -1,28 +1,29 @@
 /* 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 */
 
-/* Document-class: RubyProf::Profile
+   /* Document-class: RubyProf::Profile
 
-The Profile class represents a single profiling run and provides the main API for using ruby-prof.
-After creating a Profile instance, start profiling code by calling the Profile#start method. To finish profiling,
-call Profile#stop. Once profiling is completed, the Profile instance contains the results.
+   The Profile class represents a single profiling run and provides the main API for using ruby-prof.
+   After creating a Profile instance, start profiling code by calling the Profile#start method. To finish profiling,
+   call Profile#stop. Once profiling is completed, the Profile instance contains the results.
 
-  profile = RubyProf::Profile.new
-  profile.start
-  ...
-  result = profile.stop
+     profile = RubyProf::Profile.new
+     profile.start
+     ...
+     result = profile.stop
 
-Alternatively, you can use the block syntax:
+   Alternatively, you can use the block syntax:
 
-  profile = RubyProf::Profile.profile do
-    ...
-  end
-*/
+     profile = RubyProf::Profile.profile do
+       ...
+     end
+   */
 
 #include <assert.h>
 
 #include "rp_allocation.h"
-#include "rp_call_info.h"
+#include "rp_call_trees.h"
+#include "rp_call_tree.h"
 #include "rp_profile.h"
 #include "rp_method.h"
 
@@ -35,259 +36,276 @@ VALUE cProfile;
  */
 FILE* trace_file = NULL;
 
-static int
-excludes_method(st_data_t key, prof_profile_t* profile)
+static const char* get_event_name(rb_event_flag_t event)
 {
-    return (profile->exclude_methods_tbl &&
-            method_table_lookup(profile->exclude_methods_tbl, key) != NULL);
-}
-
-static prof_method_t*
-create_method(prof_profile_t* profile, st_data_t key, VALUE klass, VALUE msym, VALUE source_file, int source_line)
+    switch (event) {
+    case RUBY_EVENT_LINE:
+        return "line";
+    case RUBY_EVENT_CLASS:
+        return "class";
+    case RUBY_EVENT_END:
+        return "end";
+    case RUBY_EVENT_CALL:
+        return "call";
+    case RUBY_EVENT_RETURN:
+        return "return";
+    case RUBY_EVENT_B_CALL:
+        return "b-call";
+    case RUBY_EVENT_B_RETURN:
+        return "b-return";
+    case RUBY_EVENT_C_CALL:
+        return "c-call";
+    case RUBY_EVENT_C_RETURN:
+        return "c-return";
+    case RUBY_EVENT_THREAD_BEGIN:
+        return "thread-begin";
+    case RUBY_EVENT_THREAD_END:
+        return "thread-end";
+    case RUBY_EVENT_FIBER_SWITCH:
+        return "fiber-switch";
+    case RUBY_EVENT_RAISE:
+        return "raise";
+    case RUBY_INTERNAL_EVENT_NEWOBJ:
+        return "newobj";
+    default:
+        return "unknown";
+    }
+}
+
+thread_data_t* check_fiber(prof_profile_t* profile, double measurement)
 {
-    prof_method_t* result = NULL;
-    
-    if (excludes_method(key, profile))
+    thread_data_t* result = NULL;
+
+    // Get the current fiber
+    VALUE fiber = rb_fiber_current();
+
+    /* We need to switch the profiling context if we either had none before,
+     we don't merge fibers and the fiber ids differ, or the thread ids differ. */
+    if (profile->last_thread_data->fiber != fiber)
     {
-        /* We found a exclusion sentinel so propagate it into the thread's local hash table. */
-        /* TODO(nelgau): Is there a way to avoid this allocation completely so that all these
-         tables share the same exclusion method struct? The first attempt failed due to my
-         ignorance of the whims of the GC. */
-        result = prof_method_create_excluded(klass, msym);
+        result = threads_table_lookup(profile, fiber);
+        if (!result)
+        {
+            result = threads_table_insert(profile, fiber);
+        }
+        switch_thread(profile, result, measurement);
     }
     else
     {
-        result = prof_method_create(klass, msym, source_file, source_line);
+        result = profile->last_thread_data;
     }
-    
-    /* Insert the newly created method, or the exlcusion sentinel. */
-    method_table_insert(profile->last_thread_data->method_table, result->key, result);
-    
     return result;
 }
 
-static const char *
-get_event_name(rb_event_flag_t event)
+static int excludes_method(st_data_t key, prof_profile_t* profile)
 {
-    switch (event) {
-        case RUBY_EVENT_LINE:
-            return "line";
-        case RUBY_EVENT_CLASS:
-            return "class";
-        case RUBY_EVENT_END:
-            return "end";
-        case RUBY_EVENT_CALL:
-            return "call";
-        case RUBY_EVENT_RETURN:
-            return "return";
-        case RUBY_EVENT_B_CALL:
-            return "b-call";
-        case RUBY_EVENT_B_RETURN:
-            return "b-return";
-        case RUBY_EVENT_C_CALL:
-            return "c-call";
-        case RUBY_EVENT_C_RETURN:
-            return "c-return";
-        case RUBY_EVENT_THREAD_BEGIN:
-            return "thread-begin";
-        case RUBY_EVENT_THREAD_END:
-            return "thread-end";
-        case RUBY_EVENT_FIBER_SWITCH:
-            return "fiber-switch";
-        case RUBY_EVENT_RAISE:
-            return "raise";
-        default:
-            return "unknown";
-    }
+    return (profile->exclude_methods_tbl &&
+            method_table_lookup(profile->exclude_methods_tbl, key) != NULL);
 }
 
-VALUE get_fiber(prof_profile_t* profile)
+static prof_method_t* create_method(VALUE profile, st_data_t key, VALUE klass, VALUE msym, VALUE source_file, int source_line)
 {
-    if (profile->merge_fibers)
-        return rb_thread_current();
-    else
-        return rb_fiber_current();
+    prof_method_t* result = prof_method_create(profile, klass, msym, source_file, source_line);
+
+    prof_profile_t* profile_t = prof_get_profile(profile);
+    method_table_insert(profile_t->last_thread_data->method_table, result->key, result);
+
+    return result;
 }
-/* ===========  Profiling ================= */
-thread_data_t* check_fiber(prof_profile_t *profile, double measurement)
+
+static prof_method_t* check_parent_method(VALUE profile, thread_data_t* thread_data)
 {
-    thread_data_t* result = NULL;
-    
-    /* Get the current thread and fiber information. */
-    VALUE fiber = get_fiber(profile);
-    
-    /* We need to switch the profiling context if we either had none before,
-     we don't merge fibers and the fiber ids differ, or the thread ids differ. */
-    if (profile->last_thread_data->fiber != fiber)
+    VALUE msym = ID2SYM(rb_intern("_inserted_parent_"));
+    st_data_t key = method_key(cProfile, msym);
+
+    prof_method_t* result = method_table_lookup(thread_data->method_table, key);
+
+    if (!result)
     {
-        result = threads_table_lookup(profile, fiber);
-        if (!result)
-        {
-            result = threads_table_insert(profile, fiber);
-        }
-        switch_thread(profile, result, measurement);
+        result = create_method(profile, key, cProfile, msym, Qnil, 0);
     }
-    else
+
+    return result;
+}
+
+prof_method_t* check_method(VALUE profile, rb_trace_arg_t* trace_arg, rb_event_flag_t event, thread_data_t* thread_data)
+{
+    VALUE klass = rb_tracearg_defined_class(trace_arg);
+
+    /* Special case - skip any methods from the mProf
+     module or cProfile class since they clutter
+     the results but aren't important to them results. */
+    if (klass == cProfile)
+        return NULL;
+
+#ifdef HAVE_RB_TRACEARG_CALLEE_ID
+    VALUE msym = rb_tracearg_callee_id(trace_arg);
+#else
+    VALUE msym = rb_tracearg_method_id(trace_arg);
+#endif
+
+    st_data_t key = method_key(klass, msym);
+
+    prof_profile_t* profile_t = prof_get_profile(profile);
+    if (excludes_method(key, profile_t))
+        return NULL;
+
+    prof_method_t* result = method_table_lookup(thread_data->method_table, key);
+
+    if (!result)
     {
-        result = profile->last_thread_data;
+        VALUE source_file = (event != RUBY_EVENT_C_CALL ? rb_tracearg_path(trace_arg) : Qnil);
+        int source_line = (event != RUBY_EVENT_C_CALL ? FIX2INT(rb_tracearg_lineno(trace_arg)) : 0);
+        result = create_method(profile, key, klass, msym, source_file, source_line);
     }
+    
     return result;
 }
 
-static void
-prof_trace(prof_profile_t* profile, rb_trace_arg_t *trace_arg, double measurement)
+/* ===========  Profiling ================= */
+static void prof_trace(prof_profile_t* profile, rb_trace_arg_t* trace_arg, double measurement)
 {
     static VALUE last_fiber = Qnil;
-    VALUE fiber = get_fiber(profile);
-    
+    VALUE fiber = rb_fiber_current();
+
     rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
     const char* event_name = get_event_name(event);
-    
+
     VALUE source_file = rb_tracearg_path(trace_arg);
     int source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
-    
-    #ifdef HAVE_RB_TRACEARG_CALLEE_ID
+
+#ifdef HAVE_RB_TRACEARG_CALLEE_ID
     VALUE msym = rb_tracearg_callee_id(trace_arg);
-    #else
+#else
     VALUE msym = rb_tracearg_method_id(trace_arg);
-    #endif
-    
+#endif
+
     unsigned int klass_flags;
     VALUE klass = rb_tracearg_defined_class(trace_arg);
     VALUE resolved_klass = resolve_klass(klass, &klass_flags);
     const char* class_name = "";
-    
+
     if (resolved_klass != Qnil)
         class_name = rb_class2name(resolved_klass);
-    
+
     if (last_fiber != fiber)
     {
         fprintf(trace_file, "\n");
     }
-    
+
     const char* method_name_char = (msym != Qnil ? rb_id2name(SYM2ID(msym)) : "");
     const char* source_file_char = (source_file != Qnil ? StringValuePtr(source_file) : "");
-    
+
     fprintf(trace_file, "%2lu:%2f %-8s %s#%s    %s:%2d\n",
-            FIX2ULONG(fiber), (double) measurement,
+            FIX2ULONG(fiber), (double)measurement,
             event_name, class_name, method_name_char, source_file_char, source_line);
     fflush(trace_file);
     last_fiber = fiber;
 }
 
-static void
-prof_event_hook(VALUE trace_point, void* data)
+static void prof_event_hook(VALUE trace_point, void* data)
 {
-    prof_profile_t* profile = (prof_profile_t*)data;
-    thread_data_t* thread_data = NULL;
-    prof_frame_t *frame = NULL;
+    VALUE profile = (VALUE)data;
+    prof_profile_t* profile_t = prof_get_profile(profile);
+
     rb_trace_arg_t* trace_arg = rb_tracearg_from_tracepoint(trace_point);
-    double measurement = prof_measure(profile->measurer, trace_arg);
+    double measurement = prof_measure(profile_t->measurer, trace_arg);
     rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
     VALUE self = rb_tracearg_self(trace_arg);
-    
+
     if (trace_file != NULL)
     {
-        prof_trace(profile, trace_arg, measurement);
+        prof_trace(profile_t, trace_arg, measurement);
     }
-    
+
     /* Special case - skip any methods from the mProf
      module since they clutter the results but aren't important to them results. */
     if (self == mProf)
         return;
-    
-    thread_data = check_fiber(profile, measurement);
-    
+
+    thread_data_t* thread_data = check_fiber(profile_t, measurement);
+
     if (!thread_data->trace)
         return;
-    
-    /* Get the current frame for the current thread. */
-    frame = thread_data->stack->ptr;
-    
+
     switch (event)
     {
         case RUBY_EVENT_LINE:
         {
-            /* Keep track of the current line number in this method.  When
-             a new method is called, we know what line number it was
-             called from. */
-            if (frame->call_info)
+            prof_frame_t* frame = prof_frame_current(thread_data->stack);
+
+            if (!frame)
             {
-                if (prof_frame_is_real(frame))
+                prof_method_t* method = check_method(profile, trace_arg, event, thread_data);
+
+                if (!method)
+                    break;
+
+                prof_call_tree_t* call_tree = prof_call_tree_create(method, NULL, method->source_file, method->source_line);
+                prof_add_call_tree(method->call_trees, call_tree);
+
+                if (thread_data->call_tree)
                 {
-                    frame->source_file = rb_tracearg_path(trace_arg);
-                    frame->source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
+                    prof_call_tree_add_parent(thread_data->call_tree, call_tree);
+                    frame = prof_frame_unshift(thread_data->stack, call_tree, thread_data->call_tree, measurement);
                 }
-                break;
+                else
+                {
+                    frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile_t->paused));
+                }
+                
+                thread_data->call_tree = call_tree;
             }
             
-            /* If we get here there was no frame, which means this is
-             the first method seen for this thread, so fall through
-             to below to create it. */
+            frame->source_file = rb_tracearg_path(trace_arg);
+            frame->source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
+            
+            break;
         }
         case RUBY_EVENT_CALL:
         case RUBY_EVENT_C_CALL:
         {
-            prof_frame_t* next_frame;
-            prof_call_info_t* call_info;
-            prof_method_t* method;
+            prof_method_t* method = check_method(profile, trace_arg, event, thread_data);
 
-            /* Get current measurement */
-            measurement = prof_measure(profile->measurer, trace_arg);
+            if (!method)
+                break;
 
-            VALUE klass = rb_tracearg_defined_class(trace_arg);
-            
-            /* Special case - skip any methods from the mProf
-             module or cProfile class since they clutter
-             the results but aren't important to them results. */
-            if (klass == cProfile)
-                return;
-            
-            #ifdef HAVE_RB_TRACEARG_CALLEE_ID
-            VALUE msym = rb_tracearg_callee_id(trace_arg);
-            #else
-            VALUE msym = rb_tracearg_method_id(trace_arg);
-            #endif
+            prof_frame_t* frame = prof_frame_current(thread_data->stack);
+            prof_call_tree_t* parent_call_tree = NULL;
+            prof_call_tree_t* call_tree = NULL;
 
-            st_data_t key = method_key(klass, msym);
-            
-            method = method_table_lookup(thread_data->method_table, key);
-            
-            if (!method)
-            {
-                VALUE source_file = (event != RUBY_EVENT_C_CALL ? rb_tracearg_path(trace_arg) : Qnil);
-                int source_line = (event != RUBY_EVENT_C_CALL ? FIX2INT(rb_tracearg_lineno(trace_arg)) : 0);
-                method = create_method(profile, key, klass, msym, source_file, source_line);
-            }
-            
-            if (method->excluded)
+            // Frame can be NULL if we are switching from one fiber to another (see FiberTest#fiber_test)
+            if (frame)
             {
-                prof_stack_pass(thread_data->stack);
-                break;
+                parent_call_tree = frame->call_tree;
+                call_tree = call_tree_table_lookup(parent_call_tree->children, method->key);
             }
-            
-            if (!frame->call_info)
+            else if (!frame && thread_data->call_tree)
             {
-                method->root = true;
-                call_info = prof_call_info_create(method, NULL, method->source_file, method->source_line);
-                st_insert(method->parent_call_infos, (st_data_t)&key, (st_data_t)call_info);
+                // There is no current parent - likely we have returned out of the highest level method we have profiled so far. 
+                // This can happen with enumerators (see fiber_test.rb). So create a new dummy parent.
+                prof_method_t* parent_method = check_parent_method(profile, thread_data);
+                parent_call_tree = prof_call_tree_create(parent_method, NULL, Qnil, 0);
+                prof_add_call_tree(parent_method->call_trees, parent_call_tree);
+                prof_call_tree_add_parent(thread_data->call_tree, parent_call_tree);
+                frame = prof_frame_unshift(thread_data->stack, parent_call_tree, thread_data->call_tree, measurement);
+                thread_data->call_tree = parent_call_tree;
             }
-            else
+
+            if (!call_tree)
             {
-                call_info = call_info_table_lookup(method->parent_call_infos, frame->call_info->method->key);
-                
-                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->method, frame->source_file, frame->source_line);
-                    call_info_table_insert(method->parent_call_infos, frame->call_info->method->key, call_info);
-                    call_info_table_insert(frame->call_info->method->child_call_infos, method->key, call_info);
-                }
+                // This call info does not yet exist.  So create it and add it to previous CallTree's children and the current method.
+                call_tree = prof_call_tree_create(method, parent_call_tree, frame ? frame->source_file : Qnil, frame? frame->source_line : 0);
+                prof_add_call_tree(method->call_trees, call_tree);
+                if (parent_call_tree)
+                    prof_call_tree_add_child(parent_call_tree, call_tree);
             }
 
-            /* Push a new frame onto the stack for a new c-call or ruby call (into a method) */
-            next_frame = prof_stack_push(thread_data->stack, call_info, measurement, RTEST(profile->paused));
+            if (!thread_data->call_tree)
+                thread_data->call_tree = call_tree;
+
+            // Push a new frame onto the stack for a new c-call or ruby call (into a method)
+            prof_frame_t* next_frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile_t->paused));
             next_frame->source_file = method->source_file;
             next_frame->source_line = method->source_line;
             break;
@@ -295,8 +313,13 @@ prof_event_hook(VALUE trace_point, void* data)
         case RUBY_EVENT_RETURN:
         case RUBY_EVENT_C_RETURN:
         {
-            /* Get current measurement */
-            prof_stack_pop(thread_data->stack, measurement);
+            // We need to check for excluded methods so that we don't pop them off the stack
+            prof_method_t* method = check_method(profile, trace_arg, event, thread_data);
+
+            if (!method)
+                break;
+
+            prof_frame_pop(thread_data->stack, measurement);
             break;
         }
         case RUBY_INTERNAL_EVENT_NEWOBJ:
@@ -315,35 +338,33 @@ prof_event_hook(VALUE trace_point, void* data)
     }
 }
 
-void
-prof_install_hook(VALUE self)
+void prof_install_hook(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
-    
+
     VALUE event_tracepoint = rb_tracepoint_new(Qnil,
                                                RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
                                                RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN |
                                                RUBY_EVENT_LINE,
-                                               prof_event_hook, profile);
+                                               prof_event_hook, (void*)self);
     rb_ary_push(profile->tracepoints, event_tracepoint);
-    
+
     if (profile->measurer->track_allocations)
     {
-        VALUE allocation_tracepoint = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, prof_event_hook, profile);
+        VALUE allocation_tracepoint = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, prof_event_hook, (void*)self);
         rb_ary_push(profile->tracepoints, allocation_tracepoint);
     }
-    
+
     for (int i = 0; i < RARRAY_LEN(profile->tracepoints); i++)
     {
         rb_tracepoint_enable(rb_ary_entry(profile->tracepoints, i));
     }
 }
 
-void
-prof_remove_hook(VALUE self)
+void prof_remove_hook(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
-    
+
     for (int i = 0; i < RARRAY_LEN(profile->tracepoints); i++)
     {
         rb_tracepoint_disable(rb_ary_entry(profile->tracepoints, i));
@@ -351,18 +372,16 @@ prof_remove_hook(VALUE self)
     rb_ary_clear(profile->tracepoints);
 }
 
-prof_profile_t*
-prof_get_profile(VALUE self)
+prof_profile_t* prof_get_profile(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
        ending up in endless recursion. */
-    return DATA_PTR(self);
+    return RTYPEDDATA_DATA(self);
 }
 
-static int
-collect_threads(st_data_t key, st_data_t value, st_data_t result)
+static int collect_threads(st_data_t key, st_data_t value, st_data_t result)
 {
-    thread_data_t* thread_data = (thread_data_t*) value;
+    thread_data_t* thread_data = (thread_data_t*)value;
     if (thread_data->trace)
     {
         VALUE threads_array = (VALUE)result;
@@ -372,36 +391,41 @@ collect_threads(st_data_t key, st_data_t value, st_data_t result)
 }
 
 /* ========  Profile Class ====== */
-static int
-mark_threads(st_data_t key, st_data_t value, st_data_t result)
+static int mark_threads(st_data_t key, st_data_t value, st_data_t result)
 {
-    thread_data_t *thread = (thread_data_t *) value;
+    thread_data_t* thread = (thread_data_t*)value;
     prof_thread_mark(thread);
     return ST_CONTINUE;
 }
 
-static int
-mark_methods(st_data_t key, st_data_t value, st_data_t result)
+static int prof_profile_mark_methods(st_data_t key, st_data_t value, st_data_t result)
 {
-    prof_method_t *method = (prof_method_t *) value;
+    prof_method_t* method = (prof_method_t*)value;
     prof_method_mark(method);
     return ST_CONTINUE;
 }
 
-static void
-prof_mark(prof_profile_t *profile)
+static void prof_profile_mark(void* data)
 {
+    prof_profile_t* profile = (prof_profile_t*)data;
     rb_gc_mark(profile->tracepoints);
-    st_foreach(profile->threads_tbl, mark_threads, 0);
-    st_foreach(profile->exclude_methods_tbl, mark_methods, 0);
+    rb_gc_mark(profile->running);
+    rb_gc_mark(profile->paused);
+
+    // If GC stress is true (useful for debugging), when threads_table_create is called in the
+    // allocate method Ruby will immediately call this mark method. Thus the threads_tbl will be NULL.
+    if (profile->threads_tbl)
+        rb_st_foreach(profile->threads_tbl, mark_threads, 0);
+
+    if (profile->exclude_methods_tbl)
+        rb_st_foreach(profile->exclude_methods_tbl, prof_profile_mark_methods, 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)
+/* Freeing the profile creates a cascade of freeing. It frees its threads table, which frees 
+   each thread and its associated call treee and methods. */
+static void prof_profile_ruby_gc_free(void* data)
 {
+    prof_profile_t* profile = (prof_profile_t*)data;
     profile->last_thread_data = NULL;
 
     threads_table_free(profile->threads_tbl);
@@ -409,13 +433,13 @@ prof_free(prof_profile_t *profile)
 
     if (profile->exclude_threads_tbl)
     {
-        st_free_table(profile->exclude_threads_tbl);
+        rb_st_free_table(profile->exclude_threads_tbl);
         profile->exclude_threads_tbl = NULL;
     }
 
     if (profile->include_threads_tbl)
     {
-        st_free_table(profile->include_threads_tbl);
+        rb_st_free_table(profile->include_threads_tbl);
         profile->include_threads_tbl = NULL;
     }
 
@@ -429,32 +453,46 @@ prof_free(prof_profile_t *profile)
     xfree(profile);
 }
 
-static VALUE
-prof_allocate(VALUE klass)
+size_t prof_profile_size(const void* data)
+{
+    return sizeof(prof_profile_t);
+}
+
+static const rb_data_type_t profile_type =
+{
+    .wrap_struct_name = "Profile",
+    .function =
+    {
+        .dmark = prof_profile_mark,
+        .dfree = prof_profile_ruby_gc_free,
+        .dsize = prof_profile_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE prof_allocate(VALUE klass)
 {
     VALUE result;
     prof_profile_t* profile;
-    result = Data_Make_Struct(klass, prof_profile_t, prof_mark, prof_free, profile);
+    result = TypedData_Make_Struct(klass, prof_profile_t, &profile_type, profile);
     profile->threads_tbl = threads_table_create();
     profile->exclude_threads_tbl = NULL;
     profile->include_threads_tbl = NULL;
     profile->running = Qfalse;
     profile->allow_exceptions = false;
-    profile->merge_fibers = false;
     profile->exclude_methods_tbl = method_table_create();
     profile->running = Qfalse;
     profile->tracepoints = rb_ary_new();
     return result;
 }
 
-static void
-prof_exclude_common_methods(VALUE profile)
+static void prof_exclude_common_methods(VALUE profile)
 {
     rb_funcall(profile, rb_intern("exclude_common_methods!"), 0);
 }
 
-static int
-pop_frames(VALUE key, st_data_t value, st_data_t data)
+static int pop_frames(VALUE 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;
@@ -463,7 +501,7 @@ pop_frames(VALUE key, st_data_t value, st_data_t data)
     if (profile->last_thread_data->fiber != thread_data->fiber)
         switch_thread(profile, thread_data, measurement);
 
-    while (prof_stack_pop(thread_data->stack, measurement));
+    while (prof_frame_pop(thread_data->stack, measurement));
 
     return ST_CONTINUE;
 }
@@ -471,7 +509,7 @@ pop_frames(VALUE key, st_data_t value, st_data_t data)
 static void
 prof_stop_threads(prof_profile_t* profile)
 {
-    st_foreach(profile->threads_tbl, pop_frames, (st_data_t)profile);
+    rb_st_foreach(profile->threads_tbl, pop_frames, (st_data_t)profile);
 }
 
 /* call-seq:
@@ -480,19 +518,16 @@ prof_stop_threads(prof_profile_t* profile)
 
    Returns a new profiler. Possible options for the options hash are:
 
-   measure_mode::     Measure mode. Specifies the profile measure mode.
+   measure_mode:      Measure mode. Specifies the profile measure mode.
                       If not specified, defaults to RubyProf::WALL_TIME.
-   exclude_threads::  Threads to exclude from the profiling results.
-   include_threads::  Focus profiling on only the given threads. This will ignore
-                      all other threads.
-   allow_exceptions:: Whether to raise exceptions encountered during profiling,
+   allow_exceptions:  Whether to raise exceptions encountered during profiling,
                       or to suppress all exceptions during profiling
-   merge_fibers::     Whether profiling data for a given thread's fibers should all be
-                      subsumed under a single entry. Basically only useful to produce
-                      callgrind profiles.
-*/
-static VALUE
-prof_initialize(int argc,  VALUE *argv, VALUE self)
+   track_allocations: Whether to track object allocations while profiling. True or false.
+   exclude_common:    Exclude common methods from the profile. True or false.
+   exclude_threads:   Threads to exclude from the profiling results.
+   include_threads:   Focus profiling on only the given threads. This will ignore
+                      all other threads. */
+static VALUE prof_initialize(int argc, VALUE* argv, VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
     VALUE mode_or_options;
@@ -501,7 +536,6 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
     VALUE include_threads = Qnil;
     VALUE exclude_common = Qnil;
     VALUE allow_exceptions = Qfalse;
-    VALUE merge_fibers = Qfalse;
     VALUE track_allocations = Qfalse;
 
     int i;
@@ -521,7 +555,6 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
             mode = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("measure_mode")));
             track_allocations = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("track_allocations")));
             allow_exceptions = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("allow_exceptions")));
-            merge_fibers = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("merge_fibers")));
             exclude_common = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_common")));
             exclude_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_threads")));
             include_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("include_threads")));
@@ -542,7 +575,6 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
     }
     profile->measurer = prof_get_measurer(NUM2INT(mode), track_allocations == Qtrue);
     profile->allow_exceptions = (allow_exceptions == Qtrue);
-    profile->merge_fibers = (merge_fibers == Qtrue);
 
     if (exclude_threads != Qnil)
     {
@@ -552,7 +584,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
         for (i = 0; i < RARRAY_LEN(exclude_threads); i++)
         {
             VALUE thread = rb_ary_entry(exclude_threads, i);
-            st_insert(profile->exclude_threads_tbl, thread, Qtrue);
+            rb_st_insert(profile->exclude_threads_tbl, thread, Qtrue);
         }
     }
 
@@ -564,7 +596,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
         for (i = 0; i < RARRAY_LEN(include_threads); i++)
         {
             VALUE thread = rb_ary_entry(include_threads, i);
-            st_insert(profile->include_threads_tbl, thread, Qtrue);
+            rb_st_insert(profile->include_threads_tbl, thread, Qtrue);
         }
     }
 
@@ -580,8 +612,7 @@ prof_initialize(int argc,  VALUE *argv, VALUE self)
    paused? -> boolean
 
    Returns whether a profile is currently paused.*/
-static VALUE
-prof_paused(VALUE self)
+static VALUE prof_paused(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
     return profile->paused;
@@ -602,8 +633,7 @@ prof_running(VALUE self)
    mode -> measure_mode
 
    Returns the measure mode used in this profile.*/
-static VALUE
-prof_profile_measure_mode(VALUE self)
+static VALUE prof_profile_measure_mode(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
     return INT2NUM(profile->measurer->mode);
@@ -613,8 +643,7 @@ prof_profile_measure_mode(VALUE self)
    track_allocations -> boolean
 
    Returns if object allocations were tracked in this profile.*/
-static VALUE
-prof_profile_track_allocations(VALUE self)
+static VALUE prof_profile_track_allocations(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
     return profile->measurer->track_allocations ? Qtrue : Qfalse;
@@ -624,8 +653,7 @@ prof_profile_track_allocations(VALUE self)
    start -> self
 
    Starts recording profile data.*/
-static VALUE
-prof_start(VALUE self)
+static VALUE prof_start(VALUE self)
 {
     char* trace_file_name;
 
@@ -638,24 +666,25 @@ prof_start(VALUE self)
 
     profile->running = Qtrue;
     profile->paused = Qfalse;
-    profile->last_thread_data = threads_table_insert(profile, get_fiber(profile));
+    profile->last_thread_data = threads_table_insert(profile, rb_fiber_current());
 
     /* open trace file if environment wants it */
     trace_file_name = getenv("RUBY_PROF_TRACE");
-    if (trace_file_name != NULL) 
-    {
-      if (strcmp(trace_file_name, "stdout") == 0) 
-      {
-        trace_file = stdout;
-      } 
-      else if (strcmp(trace_file_name, "stderr") == 0)
-      {
-        trace_file = stderr;
-      }
-      else 
-      {
-        trace_file = fopen(trace_file_name, "w");
-      }
+
+    if (trace_file_name != NULL)
+    {
+        if (strcmp(trace_file_name, "stdout") == 0)
+        {
+            trace_file = stdout;
+        }
+        else if (strcmp(trace_file_name, "stderr") == 0)
+        {
+            trace_file = stderr;
+        }
+        else
+        {
+            trace_file = fopen(trace_file_name, "w");
+        }
     }
 
     prof_install_hook(self);
@@ -666,8 +695,7 @@ prof_start(VALUE self)
    pause -> self
 
    Pauses collecting profile data. */
-static VALUE
-prof_pause(VALUE self)
+static VALUE prof_pause(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
     if (profile->running == Qfalse)
@@ -679,7 +707,7 @@ prof_pause(VALUE self)
     {
         profile->paused = Qtrue;
         profile->measurement_at_pause_resume = prof_measure(profile->measurer, NULL);
-        st_foreach(profile->threads_tbl, pause_thread, (st_data_t) profile);
+        rb_st_foreach(profile->threads_tbl, pause_thread, (st_data_t)profile);
     }
 
     return self;
@@ -690,8 +718,7 @@ prof_pause(VALUE self)
    resume(&block) -> self
 
    Resumes recording profile data.*/
-static VALUE
-prof_resume(VALUE self)
+static VALUE prof_resume(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
     if (profile->running == Qfalse)
@@ -703,7 +730,7 @@ prof_resume(VALUE self)
     {
         profile->paused = Qfalse;
         profile->measurement_at_pause_resume = prof_measure(profile->measurer, NULL);
-        st_foreach(profile->threads_tbl, unpause_thread, (st_data_t) profile);
+        rb_st_foreach(profile->threads_tbl, unpause_thread, (st_data_t)profile);
     }
 
     return rb_block_given_p() ? rb_ensure(rb_yield, self, prof_pause, self) : self;
@@ -713,8 +740,7 @@ prof_resume(VALUE self)
    stop -> self
 
    Stops collecting profile data.*/
-static VALUE
-prof_stop(VALUE self)
+static VALUE prof_stop(VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
 
@@ -728,15 +754,11 @@ prof_stop(VALUE self)
     /* close trace file if open */
     if (trace_file != NULL)
     {
-      if (trace_file !=stderr && trace_file != stdout)
-      {
-#ifdef _MSC_VER
-          _fcloseall();
-#else
-        fclose(trace_file);
-#endif
-      }
-      trace_file = NULL;
+        if (trace_file != stderr && trace_file != stdout)
+        {
+            fclose(trace_file);
+        }
+        trace_file = NULL;
     }
 
     prof_stop_threads(profile);
@@ -753,12 +775,11 @@ prof_stop(VALUE self)
    threads -> Array of RubyProf::Thread
 
 Returns an array of RubyProf::Thread instances that were profiled. */
-static VALUE
-prof_threads(VALUE self)
+static VALUE prof_threads(VALUE self)
 {
     VALUE result = rb_ary_new();
     prof_profile_t* profile = prof_get_profile(self);
-    st_foreach(profile->threads_tbl, collect_threads, result);
+    rb_st_foreach(profile->threads_tbl, collect_threads, result);
     return result;
 }
 
@@ -773,8 +794,7 @@ prof_threads(VALUE self)
        ..
      end
 */
-static VALUE
-prof_profile_object(VALUE self)
+static VALUE prof_profile_object(VALUE self)
 {
     int result;
     prof_profile_t* profile = prof_get_profile(self);
@@ -794,7 +814,6 @@ prof_profile_object(VALUE self)
     }
 
     return self;
-
 }
 
 /* Document-method: RubyProf::Profile::Profile
@@ -809,8 +828,7 @@ prof_profile_object(VALUE self)
        ..
      end
 */
-static VALUE
-prof_profile_class(int argc,  VALUE *argv, VALUE klass)
+static VALUE prof_profile_class(int argc, VALUE* argv, VALUE klass)
 {
     return prof_profile_object(rb_class_new_instance(argc, argv, cProfile));
 }
@@ -820,25 +838,22 @@ prof_profile_class(int argc,  VALUE *argv, VALUE klass)
 
    Excludes the method from profiling results.
 */
-static VALUE
-prof_exclude_method(VALUE self, VALUE klass, VALUE msym)
+static VALUE prof_exclude_method(VALUE self, VALUE klass, VALUE msym)
 {
     prof_profile_t* profile = prof_get_profile(self);
 
-    st_data_t key = method_key(klass, msym);
-    prof_method_t *method;
-
     if (profile->running == Qtrue)
     {
         rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
     }
 
-    method = method_table_lookup(profile->exclude_methods_tbl, key);
+    st_data_t key = method_key(klass, msym);
+    prof_method_t* method = method_table_lookup(profile->exclude_methods_tbl, key);
 
     if (!method)
     {
-      method = prof_method_create_excluded(klass, msym);
-      method_table_insert(profile->exclude_methods_tbl, method->key, method);
+        method = prof_method_create(self, klass, msym, Qnil, 0);
+        method_table_insert(profile->exclude_methods_tbl, method->key, method);
     }
 
     return self;
@@ -861,8 +876,8 @@ VALUE prof_profile_load(VALUE self, VALUE data)
     for (int i = 0; i < rb_array_len(threads); i++)
     {
         VALUE thread = rb_ary_entry(threads, i);
-        thread_data_t* thread_data = DATA_PTR(thread);
-        st_insert(profile->threads_tbl, (st_data_t)thread_data->fiber_id, (st_data_t)thread_data);
+        thread_data_t* thread_data = prof_get_thread(thread);
+        rb_st_insert(profile->threads_tbl, (st_data_t)thread_data->fiber_id, (st_data_t)thread_data);
     }
 
     return data;
@@ -870,8 +885,6 @@ VALUE prof_profile_load(VALUE self, VALUE data)
 
 void rp_init_profile(void)
 {
-    mProf = rb_define_module("RubyProf");
-
     cProfile = rb_define_class_under(mProf, "Profile", rb_cObject);
     rb_define_alloc_func(cProfile, prof_allocate);