ruby-prof 1.5.0 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d83990694d6493dddde036de6cec8e46896e310a35421346d04ca3290d60c26f
-  data.tar.gz: d5453b5095fde4cbb16b214bbfda31ab767cd0cf6f1a3bcddb8c47e330224f5e
+  metadata.gz: 382fb19115df1fa6e8ac2da32cea739768fceba7228e04cd3e72009185954545
+  data.tar.gz: 4047e3e6f69c7a8b2750346837e264ae786185f07bd1aec666ecf6cd84a08c0f
 SHA512:
-  metadata.gz: 9bcae5e92e3f8978b1ef8b5bfb41ebcbadac6137c69e6cd2bbc4279f68d711e9e688b52d3b845c4cb31e735114e5ee55664108b75b20fb1f5674586d2c50aed7
-  data.tar.gz: 0c7de45558488b79106c86673beaf4db41bc9e6355923f8fdee63d2b02772f8dce3d5061f136c21909232342e87d7f7987cfc91ccc7a39365f03b2562a62241e
+  metadata.gz: 41057a0f80b47b0477cd394c26bc693e6574e496b8d607004cbc0523f89f45b247569fe9af66e54c236ebc6025ff7636188b6314298db995c6d70ecda3ff5a5b
+  data.tar.gz: 8df4a3e9dbc3fd82f65892e63a0c41f124d0c749e12b4fd120fb4bca42a4f09a5aac689f9906161e024aca9f495e75d47bf8d9fe7a9088fb1e7df5e305eb9e3f

data/CHANGES

@@ -1,3 +1,16 @@
+1.6.1 (2023-02-21)
+=====================
+* Fix loading C extension for MacOS (Charlie Savage)
+
+1.6.0 (2023-02-20)
+=====================
+* Add support for Ruby's compacting garbage collector (Charlie Savage)
+* Add rbs signature files (Charlie Savage)
+* Update rack adapter used for profiling Rails to include latest ruby-prof features (Charlie Savage)
+* Add warnings for deprecated methods (Charlie Savage)
+* Update tests to not use deprecated methods (Charlie Savage)
+* Improve tests on OSX (Charlie Savage)
+
 1.5.0 (2023-02-06)
 =====================
 * Add new Profile#merge! method that merges results for threads/fibers that share the same root method (Charlie Savage)

data/ext/ruby_prof/rp_allocation.c

@@ -2,32 +2,11 @@
    Please see the LICENSE file for copyright and distribution information */
 
 #include "rp_allocation.h"
+#include "rp_method.h"
 
 VALUE cRpAllocation;
 
-prof_allocation_t* allocations_table_lookup(st_table* table, st_data_t key)
-{
-    prof_allocation_t* result = NULL;
-    st_data_t value;
-    if (rb_st_lookup(table, key, &value))
-    {
-        result = (prof_allocation_t*)value;
-    }
-
-    return result;
-}
-
-void allocations_table_insert(st_table* table, st_data_t key, prof_allocation_t* allocation)
-{
-    rb_st_insert(table, (st_data_t)key, (st_data_t)allocation);
-}
-
-st_data_t allocations_key(VALUE klass, int source_line)
-{
-    return (klass << 4) + source_line;
-}
-
-/* ======   prof_allocation_t  ====== */
+// ------ prof_allocation_t ------
 prof_allocation_t* prof_allocation_create(void)
 {
     prof_allocation_t* result = ALLOC(prof_allocation_t);
@@ -43,48 +22,17 @@ prof_allocation_t* prof_allocation_create(void)
     return result;
 }
 
-prof_allocation_t* prof_get_allocation(VALUE self)
+prof_allocation_t* prof_allocation_get(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
        ending up in endless recursion. */
     prof_allocation_t* result = RTYPEDDATA_DATA(self);
-
     if (!result)
         rb_raise(rb_eRuntimeError, "This RubyProf::Allocation instance has already been freed, likely because its profile has been freed.");
 
     return result;
 }
 
-prof_allocation_t* prof_allocate_increment(prof_method_t* method, rb_trace_arg_t* trace_arg)
-{
-    VALUE object = rb_tracearg_object(trace_arg);
-    if (BUILTIN_TYPE(object) == T_IMEMO)
-        return NULL;
-
-    VALUE klass = rb_obj_class(object);
-
-    int source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
-    st_data_t key = allocations_key(klass, source_line);
-
-    prof_allocation_t* allocation = allocations_table_lookup(method->allocations_table, key);
-    if (!allocation)
-    {
-        allocation = prof_allocation_create();
-        allocation->source_line = source_line;
-        allocation->source_file = rb_tracearg_path(trace_arg);
-        allocation->klass_flags = 0;
-        allocation->klass = resolve_klass(klass, &allocation->klass_flags);
-
-        allocation->key = key;
-        allocations_table_insert(method->allocations_table, key, allocation);
-    }
-
-    allocation->count++;
-    allocation->memory += rb_obj_memsize_of(object);
-
-    return allocation;
-}
-
 static void prof_allocation_ruby_gc_free(void* data)
 {
     if (data)
@@ -118,30 +66,39 @@ void prof_allocation_mark(void* data)
 
     prof_allocation_t* allocation = (prof_allocation_t*)data;
     if (allocation->object != Qnil)
-        rb_gc_mark(allocation->object);
+        rb_gc_mark_movable(allocation->object);
 
     if (allocation->klass != Qnil)
-        rb_gc_mark(allocation->klass);
+        rb_gc_mark_movable(allocation->klass);
 
     if (allocation->klass_name != Qnil)
-        rb_gc_mark(allocation->klass_name);
+        rb_gc_mark_movable(allocation->klass_name);
 
     if (allocation->source_file != Qnil)
         rb_gc_mark(allocation->source_file);
 }
 
-static const rb_data_type_t allocation_type =
+void prof_allocation_compact(void* data)
 {
-    .wrap_struct_name = "Allocation",
-    .function =
-    {
-        .dmark = prof_allocation_mark,
-        .dfree = prof_allocation_ruby_gc_free,
-        .dsize = prof_allocation_size,
-    },
-    .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+    prof_allocation_t* allocation = (prof_allocation_t*)data;
+    allocation->object = rb_gc_location(allocation->object);
+    allocation->klass = rb_gc_location(allocation->klass);
+    allocation->klass_name = rb_gc_location(allocation->klass_name);
+}
+
+static const rb_data_type_t allocation_type =
+        {
+                .wrap_struct_name = "Allocation",
+                .function =
+                        {
+                                .dmark = prof_allocation_mark,
+                                .dfree = prof_allocation_ruby_gc_free,
+                                .dsize = prof_allocation_size,
+                                .dcompact = prof_allocation_compact
+                        },
+                .data = NULL,
+                .flags = RUBY_TYPED_FREE_IMMEDIATELY
+        };
 
 VALUE prof_allocation_wrap(prof_allocation_t* allocation)
 {
@@ -152,24 +109,122 @@ VALUE prof_allocation_wrap(prof_allocation_t* allocation)
     return allocation->object;
 }
 
-static VALUE prof_allocation_allocate(VALUE klass)
+/* ======   Allocation Table  ====== */
+st_table* prof_allocations_create()
 {
-    prof_allocation_t* allocation = prof_allocation_create();
-    allocation->object = prof_allocation_wrap(allocation);
-    return allocation->object;
+    return rb_st_init_numtable();
 }
 
-prof_allocation_t* prof_allocation_get(VALUE self)
+static int allocations_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
 {
-    /* Can't use Data_Get_Struct because that triggers the event hook
-       ending up in endless recursion. */
-    prof_allocation_t* result = RTYPEDDATA_DATA(self);
-    if (!result)
-        rb_raise(rb_eRuntimeError, "This RubyProf::Allocation instance has already been freed, likely because its profile has been freed.");
+    prof_allocation_free((prof_allocation_t*)value);
+    return ST_CONTINUE;
+}
+
+st_data_t allocations_key(VALUE klass, int source_line)
+{
+    return (klass << 4) + source_line;
+}
+
+static int prof_allocations_collect(st_data_t key, st_data_t value, st_data_t result)
+{
+    prof_allocation_t* allocation = (prof_allocation_t*)value;
+    VALUE arr = (VALUE)result;
+    rb_ary_push(arr, prof_allocation_wrap(allocation));
+    return ST_CONTINUE;
+}
+
+static int prof_allocations_mark_each(st_data_t key, st_data_t value, st_data_t data)
+{
+    prof_allocation_t* allocation = (prof_allocation_t*)value;
+    prof_allocation_mark(allocation);
+    return ST_CONTINUE;
+}
+
+void prof_allocations_mark(st_table* allocations_table)
+{
+    rb_st_foreach(allocations_table, prof_allocations_mark_each, 0);
+}
+
+void prof_allocations_free(st_table* table)
+{
+    rb_st_foreach(table, allocations_table_free_iterator, 0);
+    rb_st_free_table(table);
+}
+
+prof_allocation_t* allocations_table_lookup(st_table* table, st_data_t key)
+{
+    prof_allocation_t* result = NULL;
+    st_data_t value;
+    if (rb_st_lookup(table, key, &value))
+    {
+        result = (prof_allocation_t*)value;
+    }
 
     return result;
 }
 
+void allocations_table_insert(st_table* table, st_data_t key, prof_allocation_t* allocation)
+{
+    rb_st_insert(table, (st_data_t)key, (st_data_t)allocation);
+}
+
+prof_allocation_t* prof_allocate_increment(st_table* allocations_table, rb_trace_arg_t* trace_arg)
+{
+    VALUE object = rb_tracearg_object(trace_arg);
+    if (BUILTIN_TYPE(object) == T_IMEMO)
+        return NULL;
+
+    VALUE klass = rb_obj_class(object);
+
+    int source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
+    st_data_t key = allocations_key(klass, source_line);
+
+    prof_allocation_t* allocation = allocations_table_lookup(allocations_table, key);
+    if (!allocation)
+    {
+        allocation = prof_allocation_create();
+        allocation->source_line = source_line;
+        allocation->source_file = rb_tracearg_path(trace_arg);
+        allocation->klass_flags = 0;
+        allocation->klass = resolve_klass(klass, &allocation->klass_flags);
+
+        allocation->key = key;
+        allocations_table_insert(allocations_table, key, allocation);
+    }
+
+    allocation->count++;
+    allocation->memory += rb_obj_memsize_of(object);
+
+    return allocation;
+}
+
+// Returns an array of allocations
+VALUE prof_allocations_wrap(st_table* allocations_table)
+{
+    VALUE result = rb_ary_new();
+    rb_st_foreach(allocations_table, prof_allocations_collect, result);
+    return result;
+}
+
+void prof_allocations_unwrap(st_table* allocations_table, VALUE allocations)
+{
+    for (int i = 0; i < rb_array_len(allocations); i++)
+    {
+        VALUE allocation = rb_ary_entry(allocations, i);
+        prof_allocation_t* allocation_data = prof_allocation_get(allocation);
+        rb_st_insert(allocations_table, allocation_data->key, (st_data_t)allocation_data);
+    }
+}
+
+/* ======   prof_allocation_t  ====== */
+static VALUE prof_allocation_allocate(VALUE klass)
+{
+    prof_allocation_t* allocation = prof_allocation_create();
+    allocation->object = prof_allocation_wrap(allocation);
+    return allocation->object;
+}
+
 /* call-seq:
    klass -> Class
 
@@ -238,7 +293,7 @@ static VALUE prof_allocation_memory(VALUE self)
 /* :nodoc: */
 static VALUE prof_allocation_dump(VALUE self)
 {
-    prof_allocation_t* allocation = prof_get_allocation(self);
+    prof_allocation_t* allocation = prof_allocation_get(self);
 
     VALUE result = rb_hash_new();
 
@@ -256,7 +311,7 @@ static VALUE prof_allocation_dump(VALUE self)
 /* :nodoc: */
 static VALUE prof_allocation_load(VALUE self, VALUE data)
 {
-    prof_allocation_t* allocation = prof_get_allocation(self);
+    prof_allocation_t* allocation = prof_allocation_get(self);
     allocation->object = self;
 
     allocation->key = RB_NUM2ULL(rb_hash_aref(data, ID2SYM(rb_intern("key"))));

data/ext/ruby_prof/rp_allocation.h

@@ -5,7 +5,6 @@
 #define _RP_ALLOCATION_
 
 #include "ruby_prof.h"
-#include "rp_method.h"
 
 typedef struct prof_allocation_t
 {
@@ -20,12 +19,15 @@ typedef struct prof_allocation_t
     VALUE object;                     /* Cache to wrapped object */
 } prof_allocation_t;
 
+// Allocation (prof_allocation_t*)
 void rp_init_allocation(void);
-void prof_allocation_free(prof_allocation_t* allocation);
-void prof_allocation_mark(void* data);
-VALUE prof_allocation_wrap(prof_allocation_t* allocation);
-prof_allocation_t* prof_allocation_get(VALUE self);
-prof_allocation_t* prof_allocate_increment(prof_method_t* method, rb_trace_arg_t* trace_arg);
+prof_allocation_t* prof_allocate_increment(st_table* allocations_table, rb_trace_arg_t* trace_arg);
 
+// Allocations (st_table*)
+st_table* prof_allocations_create(void);
+VALUE prof_allocations_wrap(st_table* allocations_table);
+void prof_allocations_unwrap(st_table* allocations_table, VALUE allocations);
+void prof_allocations_mark(st_table* allocations_table);
+void prof_allocations_free(st_table* table);
 
 #endif //_RP_ALLOCATION_

data/ext/ruby_prof/rp_call_tree.c

@@ -54,7 +54,7 @@ void prof_call_tree_mark(void* data)
     prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
 
     if (call_tree->object != Qnil)
-        rb_gc_mark(call_tree->object);
+        rb_gc_mark_movable(call_tree->object);
 
     if (call_tree->source_file != Qnil)
         rb_gc_mark(call_tree->source_file);
@@ -68,6 +68,12 @@ void prof_call_tree_mark(void* data)
         rb_st_foreach(call_tree->children, prof_call_tree_mark_children, 0);
 }
 
+void prof_call_tree_compact(void* data)
+{
+    prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
+    call_tree->object = rb_gc_location(call_tree->object);
+}
+
 static int prof_call_tree_free_children(st_data_t key, st_data_t value, st_data_t data)
 {
     prof_call_tree_t* call_tree = (prof_call_tree_t*)value;
@@ -130,6 +136,7 @@ static const rb_data_type_t call_tree_type =
         .dmark = prof_call_tree_mark,
         .dfree = prof_call_tree_ruby_gc_free,
         .dsize = prof_call_tree_size,
+        .dcompact = prof_call_tree_compact
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY

data/ext/ruby_prof/rp_measurement.c

@@ -102,10 +102,16 @@ void prof_measurement_mark(void* data)
 {
     if (!data) return;
 
-    prof_measurement_t* measurement_data = (prof_measurement_t*)data;
+    prof_measurement_t* measurement = (prof_measurement_t*)data;
 
-    if (measurement_data->object != Qnil)
-        rb_gc_mark(measurement_data->object);
+    if (measurement->object != Qnil)
+        rb_gc_mark_movable(measurement->object);
+}
+
+void prof_measurement_compact(void* data)
+{
+    prof_measurement_t* measurement = (prof_measurement_t*)data;
+    measurement->object = rb_gc_location(measurement->object);
 }
 
 void prof_measurement_free(prof_measurement_t* measurement)
@@ -155,6 +161,7 @@ static const rb_data_type_t measurement_type =
         .dmark = prof_measurement_mark,
         .dfree = prof_measurement_ruby_gc_free,
         .dsize = prof_measurement_size,
+        .dcompact = prof_measurement_compact
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY

data/ext/ruby_prof/rp_method.c

@@ -22,31 +22,38 @@ VALUE resolve_klass(VALUE klass, unsigned int* klass_flags)
            figure out what it is attached to.*/
         VALUE attached = rb_iv_get(klass, "__attached__");
 
-        /* Is this a singleton class acting as a metaclass? */
-        if (BUILTIN_TYPE(attached) == T_CLASS)
+        switch (BUILTIN_TYPE(attached))
         {
-            *klass_flags |= kClassSingleton;
-            result = attached;
-        }
-        /* Is this for singleton methods on a module? */
-        else if (BUILTIN_TYPE(attached) == T_MODULE)
-        {
-            *klass_flags |= kModuleSingleton;
-            result = attached;
-        }
-        /* Is this for singleton methods on an object? */
-        else if (BUILTIN_TYPE(attached) == T_OBJECT)
-        {
-            *klass_flags |= kObjectSingleton;
-            result = rb_class_superclass(klass);
-        }
-        /* Ok, this could be other things like an array put onto
-           a singleton object (yeah, it happens, see the singleton
-           objects test case). */
-        else
-        {
-            *klass_flags |= kOtherSingleton;
-            result = klass;
+            /* Is this a singleton class acting as a metaclass? */
+            case T_CLASS:
+            {
+                *klass_flags |= kClassSingleton;
+                result = attached;
+                break;
+            }
+            /* Is this for singleton methods on a module? */
+            case T_MODULE:
+            {
+                *klass_flags |= kModuleSingleton;
+                result = attached;
+                break;
+            }
+            /* Is this for singleton methods on an object? */
+            case T_OBJECT:
+            {
+                *klass_flags |= kObjectSingleton;
+                result = rb_class_superclass(klass);
+                break;
+            }
+            /* Ok, this could be other things like an array put onto
+               a singleton object (yeah, it happens, see the singleton
+               objects test case). */
+            default:
+            {
+                *klass_flags |= kOtherSingleton;
+                result = klass;
+                break;
+            }
         }
     }
     /* Is this an include for a module?  If so get the actual
@@ -56,7 +63,7 @@ VALUE resolve_klass(VALUE klass, unsigned int* klass_flags)
     {
         unsigned int dummy;
         *klass_flags |= kModuleIncludee;
-        result = resolve_klass(RBASIC(klass)->klass, &dummy);
+        result = resolve_klass(RBASIC_CLASS(klass), &dummy);
     }
     return result;
 }
@@ -94,7 +101,7 @@ st_data_t method_key(VALUE klass, VALUE msym)
     }
     else if (BUILTIN_TYPE(klass) == T_ICLASS)
     {
-        resolved_klass = RBASIC(klass)->klass;
+        resolved_klass = RBASIC_CLASS(klass);
     }
 
     st_data_t hash = rb_hash_start(0);
@@ -105,39 +112,6 @@ st_data_t method_key(VALUE klass, VALUE msym)
     return hash;
 }
 
-/* ======   Allocation Table  ====== */
-st_table* allocations_table_create()
-{
-    return rb_st_init_numtable();
-}
-
-static int allocations_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
-{
-    prof_allocation_free((prof_allocation_t*)value);
-    return ST_CONTINUE;
-}
-
-static int prof_method_collect_allocations(st_data_t key, st_data_t value, st_data_t result)
-{
-    prof_allocation_t* allocation = (prof_allocation_t*)value;
-    VALUE arr = (VALUE)result;
-    rb_ary_push(arr, prof_allocation_wrap(allocation));
-    return ST_CONTINUE;
-}
-
-static int prof_method_mark_allocations(st_data_t key, st_data_t value, st_data_t data)
-{
-    prof_allocation_t* allocation = (prof_allocation_t*)value;
-    prof_allocation_mark(allocation);
-    return ST_CONTINUE;
-}
-
-void allocations_table_free(st_table* table)
-{
-    rb_st_foreach(table, allocations_table_free_iterator, 0);
-    rb_st_free_table(table);
-}
-
 /* ================  prof_method_t   =================*/
 prof_method_t* prof_get_method(VALUE self)
 {
@@ -167,7 +141,7 @@ prof_method_t* prof_method_create(VALUE profile, VALUE klass, VALUE msym, VALUE
     result->measurement = prof_measurement_create();
 
     result->call_trees = prof_call_trees_create();
-    result->allocations_table = allocations_table_create();
+    result->allocations_table = prof_allocations_create();
 
     result->visits = 0;
     result->recursive = false;
@@ -205,7 +179,7 @@ static void prof_method_free(prof_method_t* method)
         method->object = Qnil;
     }
 
-    allocations_table_free(method->allocations_table);
+    prof_allocations_free(method->allocations_table);
     prof_call_trees_free(method->call_trees);
     prof_measurement_free(method->measurement);
     xfree(method);
@@ -223,21 +197,29 @@ void prof_method_mark(void* data)
     prof_method_t* method = (prof_method_t*)data;
 
     if (method->profile != Qnil)
-        rb_gc_mark(method->profile);
+        rb_gc_mark_movable(method->profile);
 
     if (method->object != Qnil)
-        rb_gc_mark(method->object);
+        rb_gc_mark_movable(method->object);
 
-    rb_gc_mark(method->klass_name);
-    rb_gc_mark(method->method_name);
+    rb_gc_mark_movable(method->klass_name);
+    rb_gc_mark_movable(method->method_name);
     rb_gc_mark(method->source_file);
 
     if (method->klass != Qnil)
         rb_gc_mark(method->klass);
 
     prof_measurement_mark(method->measurement);
+    prof_allocations_mark(method->allocations_table);
+}
 
-    rb_st_foreach(method->allocations_table, prof_method_mark_allocations, 0);
+void prof_method_compact(void* data)
+{
+    prof_method_t* method = (prof_method_t*)data;
+    method->object = rb_gc_location(method->object);
+    method->profile = rb_gc_location(method->profile);
+    method->klass_name = rb_gc_location(method->klass_name);
+    method->method_name = rb_gc_location(method->method_name);
 }
 
 static VALUE prof_method_allocate(VALUE klass)
@@ -255,6 +237,7 @@ static const rb_data_type_t method_info_type =
         .dmark = prof_method_mark,
         .dfree = prof_method_ruby_gc_free,
         .dsize = prof_method_size,
+        .dcompact = prof_method_compact
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
@@ -360,9 +343,7 @@ Returns an array of allocation information.*/
 static VALUE prof_method_allocations(VALUE self)
 {
     prof_method_t* method = prof_get_method(self);
-    VALUE result = rb_ary_new();
-    rb_st_foreach(method->allocations_table, prof_method_collect_allocations, result);
-    return result;
+    return prof_allocations_wrap(method->allocations_table);
 }
 
 /* call-seq:
@@ -499,13 +480,7 @@ static VALUE prof_method_load(VALUE self, VALUE data)
     method_data->measurement = prof_get_measurement(measurement);
 
     VALUE allocations = rb_hash_aref(data, ID2SYM(rb_intern("allocations")));
-    for (int i = 0; i < rb_array_len(allocations); i++)
-    {
-        VALUE allocation = rb_ary_entry(allocations, i);
-        prof_allocation_t* allocation_data = prof_allocation_get(allocation);
-
-        rb_st_insert(method_data->allocations_table, allocation_data->key, (st_data_t)allocation_data);
-    }
+    prof_allocations_unwrap(method_data->allocations_table, allocations);
     return data;
 }