ruby-prof 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0006623bb548f82d74fa8bdd6cfa8e257ec5deea1d4f37f53dab8d9c780427d9
-  data.tar.gz: b30fd0deaf1ac3c3acf8519e3280aac4fc2b48a402658905ffe2f68c14edb80a
+  metadata.gz: 522834d46befbdc0f999e78d9bff9f2f98883c6bf5a15fc8d56444bf34778a72
+  data.tar.gz: b4bf7cc5ec23482ccbcb103b6c7ab87c8614da0076d6a43f4848d6cd8aee3178
 SHA512:
-  metadata.gz: 7869ef3006a8e36883b5fb6f592eacf7d0243ef1959c0f1b8f67f378004bb880199ffa0914d5df4807ae35cd0c7843de1f2379a0602c798f83b4b0e25b6d764d
-  data.tar.gz: d804cfc1f3c77f864583b5afcbf608bce6d9af098343a9212cb1a7e19488f2fae7177d225a55887249c85ee15efc2d6b1c239b5b847b9fd7deca298aa3a368a6
+  metadata.gz: ef3c25b85260c8c3878c3dbfb5d80469731f1070ecb3d5d8c474dc8d5c149578757fcfec91af508742cdd1b1da7500a4cf7dc2670b23f3261d5689f4fcd5f27c
+  data.tar.gz: bc891673567736bef06b12eb72514425261a678ad9d33ad709835e1e1cffd265c4657ba436a2e28486a45fa35fd678117ac2a2882c564fbfb334eb1edcec3918

data/CHANGES

@@ -1,3 +1,10 @@
+1.3.0 (2020-02-22)
+=====================
+* Update C code to use newer RTypedData API versus older RData API.
+* Update C code to use rb_cObject versus the older, deprecated, rb_cData.
+* Update memory management - CallInfo's now keep alive their owning Profile instances. Fixes crashes that
+  could happen in rare instances.
+
 1.2.0 (2020-01-23)
 =====================
 * Fix call stack printer broken in version 1.0.0 (Charlie Savage)

data/ext/ruby_prof/rp_aggregate_call_tree.c

@@ -24,11 +24,29 @@ static void prof_aggregate_call_tree_ruby_gc_free(void* data)
     prof_call_tree_free(call_tree);
 }
 
+size_t prof_aggregate_call_tree_size(const void* data)
+{
+    return sizeof(prof_call_tree_t);
+}
+
+static const rb_data_type_t aggregate_call_tree_type =
+{
+    .wrap_struct_name = "Aggregate_CallTree",
+    .function =
+    {
+        .dmark = prof_aggregate_call_tree_mark,
+        .dfree = prof_aggregate_call_tree_ruby_gc_free,
+        .dsize = prof_aggregate_call_tree_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE prof_aggregate_call_tree_wrap(prof_call_tree_t* call_tree)
 {
     if (call_tree->object == Qnil)
     {
-        call_tree->object = Data_Wrap_Struct(cRpAggregateCallTree, prof_aggregate_call_tree_mark, prof_aggregate_call_tree_ruby_gc_free, call_tree);
+        call_tree->object = TypedData_Wrap_Struct(cRpAggregateCallTree, &aggregate_call_tree_type, call_tree);
     }
     return call_tree->object;
 }

data/ext/ruby_prof/rp_allocation.c

@@ -43,6 +43,18 @@ prof_allocation_t* prof_allocation_create(void)
     return result;
 }
 
+prof_allocation_t* prof_get_allocation(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);
@@ -75,8 +87,11 @@ prof_allocation_t* prof_allocate_increment(prof_method_t* method, rb_trace_arg_t
 
 static void prof_allocation_ruby_gc_free(void* data)
 {
-    prof_allocation_t* allocation = (prof_allocation_t*)data;
-    allocation->object = Qnil;
+    if (data)
+    {
+        prof_allocation_t* allocation = (prof_allocation_t*)data;
+        allocation->object = Qnil;
+    }
 }
 
 void prof_allocation_free(prof_allocation_t* allocation)
@@ -85,9 +100,7 @@ void prof_allocation_free(prof_allocation_t* allocation)
        yes clean it up so to avoid a segmentation fault. */
     if (allocation->object != Qnil)
     {
-        RDATA(allocation->object)->dmark = NULL;
-        RDATA(allocation->object)->dfree = NULL;
-        RDATA(allocation->object)->data = NULL;
+        RTYPEDDATA(allocation->object)->data = NULL;
         allocation->object = Qnil;
     }
 
@@ -101,6 +114,8 @@ size_t prof_allocation_size(const void* data)
 
 void prof_allocation_mark(void* data)
 {
+    if (!data) return;
+
     prof_allocation_t* allocation = (prof_allocation_t*)data;
     if (allocation->object != Qnil)
         rb_gc_mark(allocation->object);
@@ -115,11 +130,24 @@ void prof_allocation_mark(void* data)
         rb_gc_mark(allocation->source_file);
 }
 
+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,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+}; 
+
 VALUE prof_allocation_wrap(prof_allocation_t* allocation)
 {
     if (allocation->object == Qnil)
     {
-        allocation->object = Data_Wrap_Struct(cRpAllocation, prof_allocation_mark, prof_allocation_ruby_gc_free, allocation);
+        allocation->object = TypedData_Wrap_Struct(cRpAllocation, &allocation_type, allocation);
     }
     return allocation->object;
 }
@@ -135,7 +163,7 @@ 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 = DATA_PTR(self);
+    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.");
 
@@ -210,7 +238,7 @@ static VALUE prof_allocation_memory(VALUE self)
 /* :nodoc: */
 static VALUE prof_allocation_dump(VALUE self)
 {
-    prof_allocation_t* allocation = DATA_PTR(self);
+    prof_allocation_t* allocation = prof_get_allocation(self);
 
     VALUE result = rb_hash_new();
 
@@ -228,7 +256,7 @@ static VALUE prof_allocation_dump(VALUE self)
 /* :nodoc: */
 static VALUE prof_allocation_load(VALUE self, VALUE data)
 {
-    prof_allocation_t* allocation = DATA_PTR(self);
+    prof_allocation_t* allocation = prof_get_allocation(self);
     allocation->object = self;
 
     allocation->key = FIX2LONG(rb_hash_aref(data, ID2SYM(rb_intern("key"))));
@@ -244,7 +272,7 @@ static VALUE prof_allocation_load(VALUE self, VALUE data)
 
 void rp_init_allocation(void)
 {
-    cRpAllocation = rb_define_class_under(mProf, "Allocation", rb_cData);
+    cRpAllocation = rb_define_class_under(mProf, "Allocation", rb_cObject);
     rb_undef_method(CLASS_OF(cRpAllocation), "new");
     rb_define_alloc_func(cRpAllocation, prof_allocation_allocate);
 

data/ext/ruby_prof/rp_allocation.h

@@ -7,7 +7,7 @@
 #include "ruby_prof.h"
 #include "rp_method.h"
 
-typedef struct
+typedef struct prof_allocation_t
 {
     st_data_t key;                    /* Key in hash table */
     unsigned int klass_flags;         /* Information about the type of class */

data/ext/ruby_prof/rp_call_tree.c

@@ -13,14 +13,12 @@ prof_call_tree_t* prof_call_tree_create(prof_method_t* method, prof_call_tree_t*
     prof_call_tree_t* result = ALLOC(prof_call_tree_t);
     result->method = method;
     result->parent = parent;
-    result->children = rb_st_init_numtable();
     result->object = Qnil;
-    result->measurement = prof_measurement_create();
-
     result->visits = 0;
-
     result->source_line = source_line;
     result->source_file = source_file;
+    result->children = rb_st_init_numtable();
+    result->measurement = prof_measurement_create();
 
     return result;
 }
@@ -73,6 +71,9 @@ static int prof_call_tree_mark_children(st_data_t key, st_data_t value, st_data_
 
 void prof_call_tree_mark(void* data)
 {
+    if (!data)
+        return;
+
     prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
 
     if (call_tree->object != Qnil)
@@ -81,6 +82,7 @@ void prof_call_tree_mark(void* data)
     if (call_tree->source_file != Qnil)
         rb_gc_mark(call_tree->source_file);
 
+    prof_method_mark(call_tree->method);
     prof_measurement_mark(call_tree->measurement);
 
     // Recurse down through the whole call tree but only from the top node
@@ -91,8 +93,11 @@ void prof_call_tree_mark(void* data)
 
 static void prof_call_tree_ruby_gc_free(void* data)
 {
-    prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
-    call_tree->object = Qnil;
+    if (data)
+    {
+        prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
+        call_tree->object = Qnil;
+    }
 }
 
 static int prof_call_tree_free_children(st_data_t key, st_data_t value, st_data_t data)
@@ -108,9 +113,7 @@ void prof_call_tree_free(prof_call_tree_t* call_tree_data)
        yes clean it up so to avoid a segmentation fault. */
     if (call_tree_data->object != Qnil)
     {
-        RDATA(call_tree_data->object)->dmark = NULL;
-        RDATA(call_tree_data->object)->dfree = NULL;
-        RDATA(call_tree_data->object)->data = NULL;
+        RTYPEDDATA(call_tree_data->object)->data = NULL;
         call_tree_data->object = Qnil;
     }
 
@@ -130,11 +133,24 @@ size_t prof_call_tree_size(const void* data)
     return sizeof(prof_call_tree_t);
 }
 
+static const rb_data_type_t call_tree_type =
+{
+    .wrap_struct_name = "CallTree",
+    .function =
+    {
+        .dmark = prof_call_tree_mark,
+        .dfree = prof_call_tree_ruby_gc_free,
+        .dsize = prof_call_tree_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE prof_call_tree_wrap(prof_call_tree_t* call_tree)
 {
     if (call_tree->object == Qnil)
     {
-        call_tree->object = Data_Wrap_Struct(cRpCallTree, prof_call_tree_mark, prof_call_tree_ruby_gc_free, call_tree);
+        call_tree->object = TypedData_Wrap_Struct(cRpCallTree, &call_tree_type, call_tree);
     }
     return call_tree->object;
 }
@@ -150,7 +166,7 @@ prof_call_tree_t* prof_get_call_tree(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
        ending up in endless recursion. */
-    prof_call_tree_t* result = DATA_PTR(self);
+    prof_call_tree_t* result = RTYPEDDATA_DATA(self);
 
     if (!result)
         rb_raise(rb_eRuntimeError, "This RubyProf::CallTree instance has already been freed, likely because its profile has been freed.");
@@ -335,7 +351,7 @@ static VALUE prof_call_tree_load(VALUE self, VALUE data)
 void rp_init_call_tree()
 {
     /* CallTree */
-    cRpCallTree = rb_define_class_under(mProf, "CallTree", rb_cData);
+    cRpCallTree = rb_define_class_under(mProf, "CallTree", rb_cObject);
     rb_undef_method(CLASS_OF(cRpCallTree), "new");
     rb_define_alloc_func(cRpCallTree, prof_call_tree_allocate);
 

data/ext/ruby_prof/rp_call_trees.c

@@ -14,7 +14,7 @@ prof_call_trees_t* prof_get_call_trees(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
        ending up in endless recursion. */
-    prof_call_trees_t* result = DATA_PTR(self);
+    prof_call_trees_t* result = RTYPEDDATA_DATA(self);
 
     if (!result)
         rb_raise(rb_eRuntimeError, "This RubyProf::CallTrees instance has already been freed, likely because its profile has been freed.");
@@ -32,8 +32,11 @@ prof_call_trees_t* prof_call_trees_create()
     return result;
 }
 
-void prof_call_trees_mark(prof_call_trees_t* call_trees)
+void prof_call_trees_mark(void* data)
 {
+    if (!data) return;
+
+    prof_call_trees_t* call_trees = (prof_call_trees_t*)data;
     prof_call_tree_t** call_tree;
     for (call_tree = call_trees->start; call_tree < call_trees->ptr; call_tree++)
     {
@@ -47,9 +50,7 @@ void prof_call_trees_free(prof_call_trees_t* call_trees)
        yes clean it up so to avoid a segmentation fault. */
     if (call_trees->object != Qnil)
     {
-        RDATA(call_trees->object)->dmark = NULL;
-        RDATA(call_trees->object)->dfree = NULL;
-        RDATA(call_trees->object)->data = NULL;
+        RTYPEDDATA(call_trees->object)->data = NULL;
         call_trees->object = Qnil;
     }
 
@@ -59,9 +60,12 @@ void prof_call_trees_free(prof_call_trees_t* call_trees)
 
 void prof_call_trees_ruby_gc_free(void* data)
 {
-    // This object gets freed by its owning method
-    prof_call_trees_t* call_trees = (prof_call_trees_t*)data;
-    call_trees->object = Qnil;
+    if (data)
+    {
+        // This object gets freed by its owning method
+        prof_call_trees_t* call_trees = (prof_call_trees_t*)data;
+        call_trees->object = Qnil;
+    }
 }
 
 static int prof_call_trees_collect_aggregates(st_data_t key, st_data_t value, st_data_t data)
@@ -94,11 +98,29 @@ static int prof_call_trees_collect_callees(st_data_t key, st_data_t value, st_da
     return ST_CONTINUE;
 }
 
+size_t prof_call_trees_size(const void* data)
+{
+    return sizeof(prof_call_trees_t);
+}
+
+static const rb_data_type_t call_trees_type =
+{
+    .wrap_struct_name = "CallTrees",
+    .function =
+    {
+        .dmark = prof_call_trees_mark,
+        .dfree = prof_call_trees_ruby_gc_free,
+        .dsize = prof_call_trees_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 VALUE prof_call_trees_wrap(prof_call_trees_t* call_trees)
 {
     if (call_trees->object == Qnil)
     {
-        call_trees->object = Data_Wrap_Struct(cRpCallTrees, prof_call_trees_mark, prof_call_trees_ruby_gc_free, call_trees);
+        call_trees->object = TypedData_Wrap_Struct(cRpCallTrees, &call_trees_type, call_trees);
     }
     return call_trees->object;
 }
@@ -235,7 +257,7 @@ VALUE prof_call_trees_dump(VALUE self)
 /* :nodoc: */
 VALUE prof_call_trees_load(VALUE self, VALUE data)
 {
-    prof_call_trees_t* call_trees_data = DATA_PTR(self);
+    prof_call_trees_t* call_trees_data = prof_get_call_trees(self);
     call_trees_data->object = self;
 
     VALUE call_trees = rb_hash_aref(data, ID2SYM(rb_intern("call_trees")));
@@ -251,7 +273,7 @@ VALUE prof_call_trees_load(VALUE self, VALUE data)
 
 void rp_init_call_trees()
 {
-    cRpCallTrees = rb_define_class_under(mProf, "CallTrees", rb_cData);
+    cRpCallTrees = rb_define_class_under(mProf, "CallTrees", rb_cObject);
     rb_undef_method(CLASS_OF(cRpCallTrees), "new");
     rb_define_alloc_func(cRpCallTrees, prof_call_trees_allocate);
 

data/ext/ruby_prof/rp_call_trees.h

@@ -20,7 +20,6 @@ typedef struct prof_call_trees_t
 
 void rp_init_call_trees();
 prof_call_trees_t* prof_call_trees_create();
-void prof_call_trees_mark(prof_call_trees_t* call_trees);
 void prof_call_trees_free(prof_call_trees_t* call_trees);
 prof_call_trees_t* prof_get_call_trees(VALUE self);
 void prof_add_call_tree(prof_call_trees_t* call_trees, prof_call_tree_t* call_tree);

data/ext/ruby_prof/rp_measurement.c

@@ -53,6 +53,8 @@ prof_measurement_t* prof_measurement_create(void)
 
 void prof_measurement_mark(void* data)
 {
+    if (!data) return;
+
     prof_measurement_t* measurement_data = (prof_measurement_t*)data;
 
     if (measurement_data->object != Qnil)
@@ -61,9 +63,12 @@ void prof_measurement_mark(void* data)
 
 static void prof_measurement_ruby_gc_free(void* data)
 {
-    // Measurements are freed by their owning object (call info or method)
-    prof_measurement_t* measurement = (prof_measurement_t*)data;
-    measurement->object = Qnil;
+    if (data)
+    {
+        // Measurements are freed by their owning object (call info or method)
+        prof_measurement_t* measurement = (prof_measurement_t*)data;
+        measurement->object = Qnil;
+    }
 }
 
 void prof_measurement_free(prof_measurement_t* measurement)
@@ -72,9 +77,7 @@ void prof_measurement_free(prof_measurement_t* measurement)
        yes clean it up so to avoid a segmentation fault. */
     if (measurement->object != Qnil)
     {
-        RDATA(measurement->object)->dmark = NULL;
-        RDATA(measurement->object)->dfree = NULL;
-        RDATA(measurement->object)->data = NULL;
+        RTYPEDDATA(measurement->object)->data = NULL;
         measurement->object = Qnil;
     }
 
@@ -86,11 +89,24 @@ size_t prof_measurement_size(const void* data)
     return sizeof(prof_measurement_t);
 }
 
+static const rb_data_type_t measurement_type =
+{
+    .wrap_struct_name = "Measurement",
+    .function =
+    {
+        .dmark = prof_measurement_mark,
+        .dfree = prof_measurement_ruby_gc_free,
+        .dsize = prof_measurement_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+}; 
+
 VALUE prof_measurement_wrap(prof_measurement_t* measurement)
 {
     if (measurement->object == Qnil)
     {
-        measurement->object = Data_Wrap_Struct(cRpMeasurement, NULL, prof_measurement_ruby_gc_free, measurement);
+        measurement->object = TypedData_Wrap_Struct(cRpMeasurement, &measurement_type, measurement);
     }
     return measurement->object;
 }
@@ -106,7 +122,7 @@ prof_measurement_t* prof_get_measurement(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
        ending up in endless recursion. */
-    prof_measurement_t* result = DATA_PTR(self);
+    prof_measurement_t* result = RTYPEDDATA_DATA(self);
 
     if (!result)
         rb_raise(rb_eRuntimeError, "This RubyProf::Measurement instance has already been freed, likely because its profile has been freed.");
@@ -206,7 +222,7 @@ void rp_init_measure()
     rp_init_measure_allocations();
     rp_init_measure_memory();
 
-    cRpMeasurement = rb_define_class_under(mProf, "Measurement", rb_cData);
+    cRpMeasurement = rb_define_class_under(mProf, "Measurement", rb_cObject);
     rb_undef_method(CLASS_OF(cRpMeasurement), "new");
     rb_define_alloc_func(cRpMeasurement, prof_measurement_allocate);