ruby-prof 1.2.0 → 1.3.0

data/ext/ruby_prof/rp_measurement.h

@@ -18,7 +18,7 @@ typedef enum
     MEASURE_MEMORY
 } prof_measure_mode_t;
 
-typedef struct
+typedef struct prof_measurer_t
 {
     get_measurement measure;
     prof_measure_mode_t mode;

data/ext/ruby_prof/rp_method.c

@@ -138,7 +138,7 @@ prof_method_t* prof_get_method(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
        ending up in endless recursion. */
-    prof_method_t* result = DATA_PTR(self);
+    prof_method_t* result = RTYPEDDATA_DATA(self);
 
     if (!result)
         rb_raise(rb_eRuntimeError, "This RubyProf::MethodInfo instance has already been freed, likely because its profile has been freed.");
@@ -146,9 +146,11 @@ prof_method_t* prof_get_method(VALUE self)
     return result;
 }
 
-prof_method_t* prof_method_create(VALUE klass, VALUE msym, VALUE source_file, int source_line)
+prof_method_t* prof_method_create(VALUE profile, VALUE klass, VALUE msym, VALUE source_file, int source_line)
 {
     prof_method_t* result = ALLOC(prof_method_t);
+    result->profile = profile;
+
     result->key = method_key(klass, msym);
     result->klass_flags = 0;
 
@@ -181,8 +183,11 @@ prof_method_t* prof_method_create(VALUE klass, VALUE msym, VALUE source_file, in
    out our Ruby object reference.*/
 static void prof_method_ruby_gc_free(void* data)
 {
-    prof_method_t* method = (prof_method_t*)data;
-    method->object = Qnil;
+    if (data)
+    {
+        prof_method_t* method = (prof_method_t*)data;
+        method->object = Qnil;
+    }
 }
 
 static void prof_method_free(prof_method_t* method)
@@ -191,9 +196,7 @@ static void prof_method_free(prof_method_t* method)
        yes clean it up so to avoid a segmentation fault. */
     if (method->object != Qnil)
     {
-        RDATA(method->object)->dmark = NULL;
-        RDATA(method->object)->dfree = NULL;
-        RDATA(method->object)->data = NULL;
+        RTYPEDDATA(method->object)->data = NULL;
         method->object = Qnil;
     }
 
@@ -210,8 +213,13 @@ size_t prof_method_size(const void* data)
 
 void prof_method_mark(void* data)
 {
+    if (!data) return;
+
     prof_method_t* method = (prof_method_t*)data;
 
+    if (method->profile != Qnil)
+        rb_gc_mark(method->profile);
+
     if (method->object != Qnil)
         rb_gc_mark(method->object);
 
@@ -229,16 +237,29 @@ void prof_method_mark(void* data)
 
 static VALUE prof_method_allocate(VALUE klass)
 {
-    prof_method_t* method_data = prof_method_create(Qnil, Qnil, Qnil, 0);
+    prof_method_t* method_data = prof_method_create(Qnil, Qnil, Qnil, Qnil, 0);
     method_data->object = prof_method_wrap(method_data);
     return method_data->object;
 }
 
+static const rb_data_type_t method_info_type =
+{
+    .wrap_struct_name = "MethodInfo",
+    .function =
+    {
+        .dmark = prof_method_mark,
+        .dfree = prof_method_ruby_gc_free,
+        .dsize = prof_method_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+}; 
+
 VALUE prof_method_wrap(prof_method_t* method)
 {
     if (method->object == Qnil)
     {
-        method->object = Data_Wrap_Struct(cRpMethodInfo, prof_method_mark, prof_method_ruby_gc_free, method);
+        method->object = TypedData_Wrap_Struct(cRpMethodInfo, &method_info_type, method);
     }
     return method->object;
 }
@@ -392,7 +413,7 @@ static VALUE prof_method_call_trees(VALUE self)
 /* :nodoc: */
 static VALUE prof_method_dump(VALUE self)
 {
-    prof_method_t* method_data = DATA_PTR(self);
+    prof_method_t* method_data = prof_get_method(self);
     VALUE result = rb_hash_new();
 
     rb_hash_aset(result, ID2SYM(rb_intern("klass_name")), prof_method_klass_name(self));
@@ -414,7 +435,7 @@ static VALUE prof_method_dump(VALUE self)
 /* :nodoc: */
 static VALUE prof_method_load(VALUE self, VALUE data)
 {
-    prof_method_t* method_data = RDATA(self)->data;
+    prof_method_t* method_data = prof_get_method(self);
     method_data->object = self;
 
     method_data->klass_name = rb_hash_aref(data, ID2SYM(rb_intern("klass_name")));
@@ -447,7 +468,7 @@ static VALUE prof_method_load(VALUE self, VALUE data)
 void rp_init_method_info()
 {
     /* MethodInfo */
-    cRpMethodInfo = rb_define_class_under(mProf, "MethodInfo", rb_cData);
+    cRpMethodInfo = rb_define_class_under(mProf, "MethodInfo", rb_cObject);
     rb_undef_method(CLASS_OF(cRpMethodInfo), "new");
     rb_define_alloc_func(cRpMethodInfo, prof_method_allocate);
 

data/ext/ruby_prof/rp_method.h

@@ -9,38 +9,37 @@
 
 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 
 };
 
-/* Profiling information for each method. */
-/* Excluded methods have no call_trees, 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 */
+    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 
 
-    int visits;                             /* Current visits on the stack */
+    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 
 
-    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 */
-
-    VALUE object;                           /* Cached ruby object */
+    VALUE object;                           // Cached ruby object 
 
     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);
@@ -51,7 +50,7 @@ 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 klass, VALUE msym, VALUE source_file, int source_line);
+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);

data/ext/ruby_prof/rp_profile.c

@@ -109,15 +109,17 @@ static int excludes_method(st_data_t key, prof_profile_t* profile)
             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)
+static prof_method_t* create_method(VALUE profile, st_data_t key, VALUE klass, VALUE msym, VALUE source_file, int source_line)
 {
-    prof_method_t* result = prof_method_create(klass, msym, source_file, source_line);
-    method_table_insert(profile->last_thread_data->method_table, result->key, result);
+    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;
 }
 
-static prof_method_t* check_parent_method(prof_profile_t* profile, thread_data_t* thread_data)
+static prof_method_t* check_parent_method(VALUE profile, thread_data_t* thread_data)
 {
     VALUE msym = ID2SYM(rb_intern("_inserted_parent_"));
     st_data_t key = method_key(cProfile, msym);
@@ -132,7 +134,7 @@ static prof_method_t* check_parent_method(prof_profile_t* profile, thread_data_t
     return result;
 }
 
-prof_method_t* check_method(prof_profile_t* profile, rb_trace_arg_t* trace_arg, rb_event_flag_t event, thread_data_t* thread_data)
+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);
 
@@ -150,7 +152,8 @@ prof_method_t* check_method(prof_profile_t* profile, rb_trace_arg_t* trace_arg,
 
     st_data_t key = method_key(klass, msym);
 
-    if (excludes_method(key, profile))
+    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);
@@ -208,15 +211,17 @@ static void prof_trace(prof_profile_t* profile, rb_trace_arg_t* trace_arg, doubl
 
 static void prof_event_hook(VALUE trace_point, void* data)
 {
-    prof_profile_t* profile = (prof_profile_t*)data;
+    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
@@ -224,7 +229,7 @@ static void prof_event_hook(VALUE trace_point, void* data)
     if (self == mProf)
         return;
 
-    thread_data_t* thread_data = check_fiber(profile, measurement);
+    thread_data_t* thread_data = check_fiber(profile_t, measurement);
 
     if (!thread_data->trace)
         return;
@@ -252,7 +257,7 @@ static void prof_event_hook(VALUE trace_point, void* data)
                 }
                 else
                 {
-                    frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile->paused));
+                    frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile_t->paused));
                 }
                 
                 thread_data->call_tree = call_tree;
@@ -306,7 +311,7 @@ static void prof_event_hook(VALUE trace_point, void* data)
                 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->paused));
+            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;
@@ -347,12 +352,12 @@ void prof_install_hook(VALUE self)
                                                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);
     }
 
@@ -377,7 +382,7 @@ 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)
@@ -399,19 +404,19 @@ static int mark_threads(st_data_t key, st_data_t value, st_data_t result)
     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_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);
     rb_gc_mark(profile->running);
     rb_gc_mark(profile->paused);
-    rb_gc_mark(profile->tracepoints);
 
     // 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.
@@ -419,14 +424,14 @@ static void prof_mark(prof_profile_t* profile)
         rb_st_foreach(profile->threads_tbl, mark_threads, 0);
 
     if (profile->exclude_methods_tbl)
-        rb_st_foreach(profile->exclude_methods_tbl, mark_methods, 0);
+        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);
@@ -454,11 +459,29 @@ static void prof_free(prof_profile_t* profile)
     xfree(profile);
 }
 
+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;
@@ -846,7 +869,7 @@ static VALUE prof_exclude_method(VALUE self, VALUE klass, VALUE msym)
 
     if (!method)
     {
-        method = prof_method_create(klass, msym, Qnil, 0);
+        method = prof_method_create(self, klass, msym, Qnil, 0);
         method_table_insert(profile->exclude_methods_tbl, method->key, method);
     }
 
@@ -870,7 +893,7 @@ 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);
+        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);
     }
 

data/ext/ruby_prof/rp_profile.h

@@ -10,7 +10,7 @@
 
 extern VALUE cProfile;
 
-typedef struct
+typedef struct prof_profile_t
 {
     VALUE running;
     VALUE paused;

data/ext/ruby_prof/rp_stack.h

@@ -10,7 +10,7 @@
    /* Temporary object that maintains profiling information
       for active methods.  They are created and destroyed
       as the program moves up and down its stack. */
-typedef struct
+typedef struct prof_frame_t
 {
     /* Caching prof_method_t values significantly
        increases performance. */
@@ -34,7 +34,7 @@ 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.*/
-typedef struct
+typedef struct prof_stack_t
 {
     prof_frame_t* start;
     prof_frame_t* end;

data/ext/ruby_prof/rp_thread.c

@@ -46,11 +46,14 @@ static int mark_methods(st_data_t key, st_data_t value, st_data_t result)
 
 size_t prof_thread_size(const void* data)
 {
-    return sizeof(prof_call_tree_t);
+    return sizeof(thread_data_t);
 }
 
 void prof_thread_mark(void* data)
 {
+    if (!data)
+        return;
+
     thread_data_t* thread = (thread_data_t*)data;
 
     if (thread->object != Qnil)
@@ -75,8 +78,11 @@ void prof_thread_mark(void* data)
 
 void prof_thread_ruby_gc_free(void* data)
 {
-    thread_data_t* thread_data = (thread_data_t*)data;
-    thread_data->object = Qnil;
+    if (data)
+    {
+        thread_data_t* thread_data = (thread_data_t*)data;
+        thread_data->object = Qnil;
+    }
 }
 
 static void prof_thread_free(thread_data_t* thread_data)
@@ -85,9 +91,7 @@ static void prof_thread_free(thread_data_t* thread_data)
        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)->dmark = NULL;
-        RDATA(thread_data->object)->dfree = NULL;
-        RDATA(thread_data->object)->data = NULL;
+        RTYPEDDATA(thread_data->object)->data = NULL;
         thread_data->object = Qnil;
     }
 
@@ -101,11 +105,24 @@ static void prof_thread_free(thread_data_t* thread_data)
     xfree(thread_data);
 }
 
+static const rb_data_type_t thread_type =
+{
+    .wrap_struct_name = "ThreadInfo",
+    .function =
+    {
+        .dmark = prof_thread_mark,
+        .dfree = prof_thread_ruby_gc_free,
+        .dsize = prof_thread_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE prof_thread_wrap(thread_data_t* thread)
 {
     if (thread->object == Qnil)
     {
-        thread->object = Data_Wrap_Struct(cRpThread, prof_thread_mark, prof_thread_ruby_gc_free, thread);
+        thread->object = TypedData_Wrap_Struct(cRpThread, &thread_type, thread);
     }
     return thread->object;
 }
@@ -117,11 +134,11 @@ static VALUE prof_thread_allocate(VALUE klass)
     return thread_data->object;
 }
 
-static thread_data_t* prof_get_thread(VALUE self)
+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);
+    thread_data_t* result = RTYPEDDATA_DATA(self);
     if (!result)
         rb_raise(rb_eRuntimeError, "This RubyProf::Thread instance has already been freed, likely because its profile has been freed.");
 
@@ -299,7 +316,7 @@ static VALUE prof_thread_methods(VALUE self)
 /* :nodoc: */
 static VALUE prof_thread_dump(VALUE self)
 {
-    thread_data_t* thread_data = DATA_PTR(self);
+    thread_data_t* thread_data = RTYPEDDATA_DATA(self);
 
     VALUE result = rb_hash_new();
     rb_hash_aset(result, ID2SYM(rb_intern("fiber_id")), thread_data->fiber_id);
@@ -312,7 +329,7 @@ static VALUE prof_thread_dump(VALUE self)
 /* :nodoc: */
 static VALUE prof_thread_load(VALUE self, VALUE data)
 {
-    thread_data_t* thread_data = DATA_PTR(self);
+    thread_data_t* thread_data = RTYPEDDATA_DATA(self);
 
     VALUE call_tree = rb_hash_aref(data, ID2SYM(rb_intern("call_tree")));
     thread_data->call_tree = prof_get_call_tree(call_tree);
@@ -323,7 +340,7 @@ static VALUE prof_thread_load(VALUE self, VALUE data)
     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);
+        prof_method_t* method_data = RTYPEDDATA_DATA(method);
         method_table_insert(thread_data->method_table, method_data->key, method_data);
     }
 
@@ -332,7 +349,7 @@ static VALUE prof_thread_load(VALUE self, VALUE data)
 
 void rp_init_thread(void)
 {
-    cRpThread = rb_define_class_under(mProf, "Thread", rb_cData);
+    cRpThread = rb_define_class_under(mProf, "Thread", rb_cObject);
     rb_undef_method(CLASS_OF(cRpThread), "new");
     rb_define_alloc_func(cRpThread, prof_thread_allocate);