ruby-prof 1.4.5-x64-mingw-ucrt → 1.5.0-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cba10a97d617a1790367cfdb878483d8cf0808d7eddf0d6df9c232f3a069caa
-  data.tar.gz: '03992e76849aa6d15751f80525b4b96432a7be8e89efdc79e511bad30849dcac'
+  metadata.gz: dc83e5cdca77c3e07af7ad99f69acfbf8dde2013c435855d996925db9dcd586c
+  data.tar.gz: 9c14d146c1194db666cec9f9ab05e4a798bd0a6ed5c535d850be581ddf8734fa
 SHA512:
-  metadata.gz: 7924a150c8ed70cc2292a41a448907f45c298f92b6aca51ed29b9c19fa8454dfba3b3e388471975e663a51bb752edd95166c75eb43ed442ee5ace68214e18a1e
-  data.tar.gz: c4d20eb492adbc12502d7254be171d58b5f035c377d661af771073689357d95ad1f4f6ef9cd7e206cb6c023021c15a371a9ea23de6998bac3fbb4fcaf7358dfc
+  metadata.gz: 56e6c6a054fed0bdbb08a41ead10898495efb4201c19f2bd3572f3b0ac939e1770c3c4f1bb82da4399ba27f99ed135447e004263d57af86a0888a6a6a349f1fc
+  data.tar.gz: 251eba317457ec6ea583b25656c062f92e8f55a35c7279f39a1f9987234fd9b481fbfd6ab72d71af34541ca49aad2b0feacefbc4d44ca75a4486ec003cb2fa19

data/CHANGES

@@ -1,3 +1,9 @@
+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)
+* Expand API to allow creation of +Measurement+, +CallTree+, +MethodInfo+ and +Thread+ instances. This
+ was done to make is possible to write tests for the new Profile#merge! functionality (Charlie Savage)
+
 1.4.5 (2022-12-27)
 =====================
 * Look for ruby_prof extension built on install in the lib directory (Charlie Savage)

data/Rakefile

@@ -61,7 +61,7 @@ end
 desc "Generate rdoc documentation"
 RDoc::Task.new("rdoc") do |rdoc|
   rdoc.rdoc_dir = 'doc'
-  rdoc.title    = "ruby-prof"
+  rdoc.title = "ruby-prof"
   # Show source inline with line numbers
   rdoc.options << "--line-numbers"
   # Make the readme file the start page for the generated html

data/ext/ruby_prof/rp_allocation.c

@@ -242,13 +242,13 @@ static VALUE prof_allocation_dump(VALUE self)
 
     VALUE result = rb_hash_new();
 
-    rb_hash_aset(result, ID2SYM(rb_intern("key")), INT2FIX(allocation->key));
+    rb_hash_aset(result, ID2SYM(rb_intern("key")), ULL2NUM(allocation->key));
     rb_hash_aset(result, ID2SYM(rb_intern("klass_name")), prof_allocation_klass_name(self));
     rb_hash_aset(result, ID2SYM(rb_intern("klass_flags")), INT2FIX(allocation->klass_flags));
     rb_hash_aset(result, ID2SYM(rb_intern("source_file")), allocation->source_file);
     rb_hash_aset(result, ID2SYM(rb_intern("source_line")), INT2FIX(allocation->source_line));
     rb_hash_aset(result, ID2SYM(rb_intern("count")), INT2FIX(allocation->count));
-    rb_hash_aset(result, ID2SYM(rb_intern("memory")), LONG2FIX(allocation->memory));
+    rb_hash_aset(result, ID2SYM(rb_intern("memory")), ULL2NUM(allocation->memory));
 
     return result;
 }
@@ -259,13 +259,13 @@ static VALUE prof_allocation_load(VALUE self, VALUE data)
     prof_allocation_t* allocation = prof_get_allocation(self);
     allocation->object = self;
 
-    allocation->key = FIX2LONG(rb_hash_aref(data, ID2SYM(rb_intern("key"))));
+    allocation->key = RB_NUM2ULL(rb_hash_aref(data, ID2SYM(rb_intern("key"))));
     allocation->klass_name = rb_hash_aref(data, ID2SYM(rb_intern("klass_name")));
     allocation->klass_flags = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("klass_flags"))));
     allocation->source_file = rb_hash_aref(data, ID2SYM(rb_intern("source_file")));
     allocation->source_line = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("source_line"))));
     allocation->count = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("count"))));
-    allocation->memory = FIX2LONG(rb_hash_aref(data, ID2SYM(rb_intern("memory"))));
+    allocation->memory = NUM2ULONG(rb_hash_aref(data, ID2SYM(rb_intern("memory"))));
 
     return data;
 }

data/ext/ruby_prof/rp_call_tree.c

@@ -9,6 +9,7 @@ VALUE cRpCallTree;
 prof_call_tree_t* prof_call_tree_create(prof_method_t* method, prof_call_tree_t* parent, VALUE source_file, int source_line)
 {
     prof_call_tree_t* result = ALLOC(prof_call_tree_t);
+    result->owner = OWNER_C;
     result->method = method;
     result->parent = parent;
     result->object = Qnil;
@@ -23,34 +24,12 @@ prof_call_tree_t* prof_call_tree_create(prof_method_t* method, prof_call_tree_t*
 
 prof_call_tree_t* prof_call_tree_copy(prof_call_tree_t* other)
 {
-    prof_call_tree_t* result = ALLOC(prof_call_tree_t);
-    result->children = rb_st_init_numtable();
-    result->object = Qnil;
-    result->visits = 0;
-
-    result->method = other->method;
-    result->parent = other->parent;
-    result->source_line = other->source_line;
-    result->source_file = other->source_file;
-
-    result->measurement = prof_measurement_create();
-    result->measurement->called = other->measurement->called;
-    result->measurement->total_time = other->measurement->total_time;
-    result->measurement->self_time = other->measurement->self_time;
-    result->measurement->wait_time = other->measurement->wait_time;
-    result->measurement->object = Qnil;
+    prof_call_tree_t* result = prof_call_tree_create(other->method, other->parent, other->source_file, other->source_line);
+    result->measurement = prof_measurement_copy(other->measurement);
 
     return result;
 }
 
-void prof_call_tree_merge(prof_call_tree_t* result, prof_call_tree_t* other)
-{
-    result->measurement->called += other->measurement->called;
-    result->measurement->total_time += other->measurement->total_time;
-    result->measurement->self_time += other->measurement->self_time;
-    result->measurement->wait_time += other->measurement->wait_time;
-}
-
 static int prof_call_tree_collect_children(st_data_t key, st_data_t value, st_data_t result)
 {
     prof_call_tree_t* call_tree = (prof_call_tree_t*)value;
@@ -89,15 +68,6 @@ void prof_call_tree_mark(void* data)
         rb_st_foreach(call_tree->children, prof_call_tree_mark_children, 0);
 }
 
-static void prof_call_tree_ruby_gc_free(void* data)
-{
-    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)
 {
     prof_call_tree_t* call_tree = (prof_call_tree_t*)value;
@@ -126,6 +96,27 @@ void prof_call_tree_free(prof_call_tree_t* call_tree_data)
     xfree(call_tree_data);
 }
 
+static void prof_call_tree_ruby_gc_free(void* data)
+{
+  prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
+
+  if (!call_tree)
+  {
+    // Object has already been freed by C code
+    return;
+  }
+  else if (call_tree->owner == OWNER_RUBY)
+  {
+    // Ruby owns this object, we need to free the underlying C struct
+    prof_call_tree_free(call_tree);
+  }
+  else
+  {
+    // The Ruby object is being freed, but not the underlying C structure. So unlink the two.
+    call_tree->object = Qnil;
+  }
+}
+
 size_t prof_call_tree_size(const void* data)
 {
     return sizeof(prof_call_tree_t);
@@ -156,6 +147,8 @@ VALUE prof_call_tree_wrap(prof_call_tree_t* call_tree)
 static VALUE prof_call_tree_allocate(VALUE klass)
 {
     prof_call_tree_t* call_tree = prof_call_tree_create(NULL, NULL, Qnil, 0);
+    // This object is being created by Ruby
+    call_tree->owner = OWNER_RUBY;
     call_tree->object = prof_call_tree_wrap(call_tree);
     return call_tree->object;
 }
@@ -213,10 +206,26 @@ void prof_call_tree_add_parent(prof_call_tree_t* self, prof_call_tree_t* parent)
 void prof_call_tree_add_child(prof_call_tree_t* self, prof_call_tree_t* child)
 {
     call_tree_table_insert(self->children, child->method->key, child);
+    
+    // The child is now managed by C since its parent will free it
+    child->owner = OWNER_C;
 }
 
 /* =======  RubyProf::CallTree   ========*/
 
+/* call-seq:
+   new(method_info) -> call_tree
+
+Creates a new CallTree instance. +Klass+ should be a reference to
+a Ruby class and +method_name+ a symbol identifying one of its instance methods.*/
+static VALUE prof_call_tree_initialize(VALUE self, VALUE method_info)
+{
+  prof_call_tree_t* call_tree_ptr = prof_get_call_tree(self);
+  call_tree_ptr->method = prof_get_method(method_info);
+
+  return self;
+}
+
 /* call-seq:
    parent -> call_tree
 
@@ -242,6 +251,29 @@ static VALUE prof_call_tree_children(VALUE self)
     return result;
 }
 
+/* call-seq:
+   add_child(call_tree) -> call_tree
+
+Adds the specified call_tree as a child. If the method represented by the call tree is
+already a child than a IndexError is thrown.
+
+The returned value is the added child*/
+static VALUE prof_call_tree_add_child_ruby(VALUE self, VALUE child)
+{
+  prof_call_tree_t* parent_ptr = prof_get_call_tree(self);
+  prof_call_tree_t* child_ptr = prof_get_call_tree(child);
+
+  prof_call_tree_t* existing_ptr = call_tree_table_lookup(parent_ptr->children, child_ptr->method->key);
+  if (existing_ptr)
+  {
+    rb_raise(rb_eIndexError, "Child call tree already exists");
+  }
+
+  prof_call_tree_add_parent(child_ptr, parent_ptr);
+
+  return child;
+}
+
 /* call-seq:
    called -> MethodInfo
 
@@ -294,12 +326,65 @@ static VALUE prof_call_tree_line(VALUE self)
     return INT2FIX(result->source_line);
 }
 
+static int prof_call_tree_merge_children(st_data_t key, st_data_t value, st_data_t data)
+{
+  prof_call_tree_t* other_child = (prof_call_tree_t*)value;
+  prof_call_tree_t* self = (prof_call_tree_t*)data;
+
+  st_data_t self_child;
+  if (rb_st_lookup(self->children, other_child->method->key, &self_child))
+  {
+    prof_call_tree_merge_internal((prof_call_tree_t*)self_child, other_child);
+  }
+  else
+  {
+    prof_call_tree_t* copy = prof_call_tree_copy(other_child);
+    prof_call_tree_add_child(self, copy);
+  }
+  return ST_CONTINUE;
+}
+
+void prof_call_tree_merge_internal(prof_call_tree_t* self, prof_call_tree_t* other)
+{
+  // Make sure the methods are the same
+  if (self->method->key != other->method->key)
+    return;
+
+  // Make sure the parents are the same.
+  // 1. They can both be set and be equal
+  // 2. They can both be unset (null)
+  if (self->parent && other->parent)
+  {
+    if (self->parent->method->key != other->parent->method->key)
+      return;
+  }
+  else if (self->parent || other->parent)
+  {
+    return;
+  }
+
+  prof_measurement_merge_internal(self->measurement, other->measurement);
+  prof_measurement_merge_internal(self->method->measurement, other->method->measurement);
+
+  rb_st_foreach(other->children, prof_call_tree_merge_children, (st_data_t)self);
+}
+
+VALUE prof_call_tree_merge(VALUE self, VALUE other)
+{
+  prof_call_tree_t* source = prof_get_call_tree(self);
+  prof_call_tree_t* destination = prof_get_call_tree(other);
+  prof_call_tree_merge_internal(source, destination);
+  return other;
+}
+
 /* :nodoc: */
 static VALUE prof_call_tree_dump(VALUE self)
 {
     prof_call_tree_t* call_tree_data = prof_get_call_tree(self);
     VALUE result = rb_hash_new();
 
+    rb_hash_aset(result, ID2SYM(rb_intern("owner")), INT2FIX(call_tree_data->owner));
+
     rb_hash_aset(result, ID2SYM(rb_intern("measurement")), prof_measurement_wrap(call_tree_data->measurement));
 
     rb_hash_aset(result, ID2SYM(rb_intern("source_file")), call_tree_data->source_file);
@@ -320,6 +405,8 @@ static VALUE prof_call_tree_load(VALUE self, VALUE data)
     prof_call_tree_t* call_tree = prof_get_call_tree(self);
     call_tree->object = self;
 
+    call_tree->owner = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("owner"))));
+
     VALUE measurement = rb_hash_aref(data, ID2SYM(rb_intern("measurement")));
     call_tree->measurement = prof_get_measurement(measurement);
 
@@ -350,18 +437,21 @@ void rp_init_call_tree()
 {
     /* CallTree */
     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);
+    rb_define_method(cRpCallTree, "initialize", prof_call_tree_initialize, 1);
 
-    rb_define_method(cRpCallTree, "parent", prof_call_tree_parent, 0);
-    rb_define_method(cRpCallTree, "children", prof_call_tree_children, 0);
     rb_define_method(cRpCallTree, "target", prof_call_tree_target, 0);
     rb_define_method(cRpCallTree, "measurement", prof_call_tree_measurement, 0);
+    rb_define_method(cRpCallTree, "parent", prof_call_tree_parent, 0);
+    rb_define_method(cRpCallTree, "children", prof_call_tree_children, 0);
+    rb_define_method(cRpCallTree, "add_child", prof_call_tree_add_child_ruby, 1);
 
     rb_define_method(cRpCallTree, "depth", prof_call_tree_depth, 0);
     rb_define_method(cRpCallTree, "source_file", prof_call_tree_source_file, 0);
     rb_define_method(cRpCallTree, "line", prof_call_tree_line, 0);
 
+    rb_define_method(cRpCallTree, "merge!", prof_call_tree_merge, 1);
+
     rb_define_method(cRpCallTree, "_dump_data", prof_call_tree_dump, 0);
     rb_define_method(cRpCallTree, "_load_data", prof_call_tree_load, 1);
 }

data/ext/ruby_prof/rp_call_tree.h

@@ -13,6 +13,7 @@ extern VALUE cRpCallTree;
 /* Callers and callee information for a method. */
 typedef struct prof_call_tree_t
 {
+    prof_owner_t owner;
     prof_method_t* method;
     struct prof_call_tree_t* parent;
     st_table* children;             /* Call infos that this call info calls */
@@ -27,7 +28,7 @@ typedef struct prof_call_tree_t
 
 prof_call_tree_t* prof_call_tree_create(prof_method_t* method, prof_call_tree_t* parent, VALUE source_file, int source_line);
 prof_call_tree_t* prof_call_tree_copy(prof_call_tree_t* other);
-void prof_call_tree_merge(prof_call_tree_t* result, prof_call_tree_t* other);
+void prof_call_tree_merge_internal(prof_call_tree_t* destination, prof_call_tree_t* other);
 void prof_call_tree_mark(void* data);
 prof_call_tree_t* call_tree_table_lookup(st_table* table, st_data_t key);
 

data/ext/ruby_prof/rp_call_trees.c

@@ -1,7 +1,6 @@
 /* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
    Please see the LICENSE file for copyright and distribution information */
 
-#include "rp_aggregate_call_tree.h"
 #include "rp_call_trees.h"
 #include "rp_measurement.h"
 
@@ -68,11 +67,11 @@ void prof_call_trees_ruby_gc_free(void* data)
     }
 }
 
-static int prof_call_trees_collect_aggregates(st_data_t key, st_data_t value, st_data_t data)
+static int prof_call_trees_collect(st_data_t key, st_data_t value, st_data_t data)
 {
     VALUE result = (VALUE)data;
     prof_call_tree_t* call_tree_data = (prof_call_tree_t*)value;
-    VALUE aggregate_call_tree = prof_aggregate_call_tree_wrap(call_tree_data);
+    VALUE aggregate_call_tree = prof_call_tree_wrap(call_tree_data);
     rb_ary_push(result, aggregate_call_tree);
 
     return ST_CONTINUE;
@@ -87,11 +86,16 @@ static int prof_call_trees_collect_callees(st_data_t key, st_data_t value, st_da
 
     if (rb_st_lookup(callers, call_tree_data->method->key, (st_data_t*)&aggregate_call_tree_data))
     {
-        prof_call_tree_merge(aggregate_call_tree_data, call_tree_data);
+      prof_measurement_merge_internal(aggregate_call_tree_data->measurement, call_tree_data->measurement);
     }
     else
     {
+        // Copy the call tree so we don't touch the original and give Ruby ownerhip 
+        // of it so that it is freed on GC
         aggregate_call_tree_data = prof_call_tree_copy(call_tree_data);
+        aggregate_call_tree_data->owner = OWNER_RUBY;
+
+
         rb_st_insert(callers, call_tree_data->method->key, (st_data_t)aggregate_call_tree_data);
     }
 
@@ -210,17 +214,21 @@ VALUE prof_call_trees_callers(VALUE self)
 
         if (rb_st_lookup(callers, parent->method->key, (st_data_t*)&aggregate_call_tree_data))
         {
-            prof_call_tree_merge(aggregate_call_tree_data, *p_call_tree);
+          prof_measurement_merge_internal(aggregate_call_tree_data->measurement, (*p_call_tree)->measurement);
         }
         else
         {
+            // Copy the call tree so we don't touch the original and give Ruby ownerhip 
+            // of it so that it is freed on GC
             aggregate_call_tree_data = prof_call_tree_copy(*p_call_tree);
+            aggregate_call_tree_data->owner = OWNER_RUBY;
+
             rb_st_insert(callers, parent->method->key, (st_data_t)aggregate_call_tree_data);
         }
     }
 
     VALUE result = rb_ary_new_capa((long)callers->num_entries);
-    rb_st_foreach(callers, prof_call_trees_collect_aggregates, result);
+    rb_st_foreach(callers, prof_call_trees_collect, result);
     rb_st_free_table(callers);
     return result;
 }
@@ -240,7 +248,7 @@ VALUE prof_call_trees_callees(VALUE self)
     }
 
     VALUE result = rb_ary_new_capa((long)callees->num_entries);
-    rb_st_foreach(callees, prof_call_trees_collect_aggregates, result);
+    rb_st_foreach(callees, prof_call_trees_collect, result);
     rb_st_free_table(callees);
     return result;
 }

data/ext/ruby_prof/rp_measurement.c

@@ -43,6 +43,7 @@ double prof_measure(prof_measurer_t* measurer, rb_trace_arg_t* trace_arg)
 prof_measurement_t* prof_measurement_create(void)
 {
     prof_measurement_t* result = ALLOC(prof_measurement_t);
+    result->owner = OWNER_C;
     result->total_time = 0;
     result->self_time = 0;
     result->wait_time = 0;
@@ -51,6 +52,52 @@ prof_measurement_t* prof_measurement_create(void)
     return result;
 }
 
+/* call-seq:
+     new(total_time, self_time, wait_time, called) -> Measurement
+
+   Creates a new measuremen instance. */
+static VALUE prof_measurement_initialize(VALUE self, VALUE total_time, VALUE self_time, VALUE wait_time, VALUE called)
+{
+  prof_measurement_t* result = prof_get_measurement(self);
+
+  result->total_time = NUM2DBL(total_time);
+  result->self_time = NUM2DBL(self_time);
+  result->wait_time = NUM2DBL(wait_time);
+  result->called = NUM2INT(called);
+  result->object = self;
+  return self;
+}
+
+prof_measurement_t* prof_measurement_copy(prof_measurement_t* other)
+{
+  prof_measurement_t* result = prof_measurement_create();
+  result->called = other->called;
+  result->total_time = other->total_time;
+  result->self_time = other->self_time;
+  result->wait_time = other->wait_time;
+
+  return result;
+}
+
+static VALUE prof_measurement_initialize_copy(VALUE self, VALUE other)
+{
+  // This object was created by Ruby either via Measurment#clone or Measurement#dup 
+  // and thus prof_measurement_allocate was called so the object is owned by Ruby
+
+  if (self == other)
+    return self;
+
+  prof_measurement_t* self_ptr = prof_get_measurement(self);
+  prof_measurement_t* other_ptr = prof_get_measurement(other);
+
+  self_ptr->called = other_ptr->called;
+  self_ptr->total_time = other_ptr->total_time;
+  self_ptr->self_time = other_ptr->self_time;
+  self_ptr->wait_time = other_ptr->wait_time;
+
+  return self;
+}
+
 void prof_measurement_mark(void* data)
 {
     if (!data) return;
@@ -61,16 +108,6 @@ void prof_measurement_mark(void* data)
         rb_gc_mark(measurement_data->object);
 }
 
-static void prof_measurement_ruby_gc_free(void* data)
-{
-    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)
 {
     /* Has this measurement object been accessed by Ruby?  If
@@ -84,6 +121,27 @@ void prof_measurement_free(prof_measurement_t* measurement)
     xfree(measurement);
 }
 
+static void prof_measurement_ruby_gc_free(void* data)
+{
+  prof_measurement_t* measurement = (prof_measurement_t*)data;
+
+  if (!measurement)
+  {
+    // Object has already been freed by C code
+    return;
+  }
+  else if (measurement->owner == OWNER_RUBY)
+  {
+    // Ruby owns this object, we need to free the underlying C struct
+    prof_measurement_free(measurement);
+  }
+  else
+  {
+    // The Ruby object is being freed, but not the underlying C structure. So unlink the two.
+    measurement->object = Qnil;
+  }
+}
+
 size_t prof_measurement_size(const void* data)
 {
     return sizeof(prof_measurement_t);
@@ -114,6 +172,8 @@ VALUE prof_measurement_wrap(prof_measurement_t* measurement)
 static VALUE prof_measurement_allocate(VALUE klass)
 {
     prof_measurement_t* measurement = prof_measurement_create();
+    // This object is being created by Ruby
+    measurement->owner = OWNER_RUBY;
     measurement->object = prof_measurement_wrap(measurement);
     return measurement->object;
 }
@@ -140,6 +200,17 @@ static VALUE prof_measurement_total_time(VALUE self)
     return rb_float_new(result->total_time);
 }
 
+/* call-seq:
+   total_time=value -> value
+
+Sets the call count to n. */
+static VALUE prof_measurement_set_total_time(VALUE self, VALUE value)
+{
+  prof_measurement_t* result = prof_get_measurement(self);
+  result->total_time = NUM2DBL(value);
+  return value;
+}
+
 /* call-seq:
    self_time -> float
 
@@ -152,6 +223,17 @@ prof_measurement_self_time(VALUE self)
     return rb_float_new(result->self_time);
 }
 
+/* call-seq:
+   self_time=value -> value
+
+Sets the call count to value. */
+static VALUE prof_measurement_set_self_time(VALUE self, VALUE value)
+{
+  prof_measurement_t* result = prof_get_measurement(self);
+  result->self_time = NUM2DBL(value);
+  return value;
+}
+
 /* call-seq:
    wait_time -> float
 
@@ -163,6 +245,17 @@ static VALUE prof_measurement_wait_time(VALUE self)
     return rb_float_new(result->wait_time);
 }
 
+/* call-seq:
+   wait_time=value -> value
+
+Sets the wait time to value. */
+static VALUE prof_measurement_set_wait_time(VALUE self, VALUE value)
+{
+  prof_measurement_t* result = prof_get_measurement(self);
+  result->wait_time = NUM2DBL(value);
+  return value;
+}
+
 /* call-seq:
    called -> int
 
@@ -174,23 +267,44 @@ static VALUE prof_measurement_called(VALUE self)
 }
 
 /* call-seq:
-   called=n -> n
+   called=value -> value
 
-Sets the call count to n. */
-static VALUE prof_measurement_set_called(VALUE self, VALUE called)
+Sets the call count to value. */
+static VALUE prof_measurement_set_called(VALUE self, VALUE value)
 {
-    prof_measurement_t* result = prof_get_measurement(self);
-    result->called = NUM2INT(called);
-    return called;
+  prof_measurement_t* result = prof_get_measurement(self);
+  result->called = NUM2INT(value);
+  return value;
 }
 
 /* :nodoc: */
-static VALUE
-prof_measurement_dump(VALUE self)
+void prof_measurement_merge_internal(prof_measurement_t* self, prof_measurement_t* other)
+{
+  self->called += other->called;
+  self->total_time += other->total_time;
+  self->self_time += other->self_time;
+  self->wait_time += other->wait_time;
+}
+
+/* call-seq:
+   merge(other)
+
+   Adds the content of other measurement to this measurement */
+VALUE prof_measurement_merge(VALUE self, VALUE other)
+{
+  prof_measurement_t* self_ptr = prof_get_measurement(self);
+  prof_measurement_t* other_ptr = prof_get_measurement(other);
+  prof_measurement_merge_internal(self_ptr, other_ptr);
+  return self;
+}
+
+/* :nodoc: */
+static VALUE prof_measurement_dump(VALUE self)
 {
     prof_measurement_t* measurement_data = prof_get_measurement(self);
     VALUE result = rb_hash_new();
 
+    rb_hash_aset(result, ID2SYM(rb_intern("owner")), INT2FIX(measurement_data->owner));
     rb_hash_aset(result, ID2SYM(rb_intern("total_time")), rb_float_new(measurement_data->total_time));
     rb_hash_aset(result, ID2SYM(rb_intern("self_time")), rb_float_new(measurement_data->self_time));
     rb_hash_aset(result, ID2SYM(rb_intern("wait_time")), rb_float_new(measurement_data->wait_time));
@@ -206,6 +320,7 @@ prof_measurement_load(VALUE self, VALUE data)
     prof_measurement_t* measurement = prof_get_measurement(self);
     measurement->object = self;
 
+    measurement->owner = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("owner"))));
     measurement->total_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("total_time"))));
     measurement->self_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("self_time"))));
     measurement->wait_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("wait_time"))));
@@ -223,14 +338,19 @@ void rp_init_measure()
     rp_init_measure_memory();
 
     cRpMeasurement = rb_define_class_under(mProf, "Measurement", rb_cObject);
-    rb_undef_method(CLASS_OF(cRpMeasurement), "new");
     rb_define_alloc_func(cRpMeasurement, prof_measurement_allocate);
 
+    rb_define_method(cRpMeasurement, "initialize", prof_measurement_initialize, 4);
+    rb_define_method(cRpMeasurement, "initialize_copy", prof_measurement_initialize_copy, 1);
+    rb_define_method(cRpMeasurement, "merge!", prof_measurement_merge, 1);
     rb_define_method(cRpMeasurement, "called", prof_measurement_called, 0);
     rb_define_method(cRpMeasurement, "called=", prof_measurement_set_called, 1);
     rb_define_method(cRpMeasurement, "total_time", prof_measurement_total_time, 0);
+    rb_define_method(cRpMeasurement, "total_time=", prof_measurement_set_total_time, 1);
     rb_define_method(cRpMeasurement, "self_time", prof_measurement_self_time, 0);
+    rb_define_method(cRpMeasurement, "self_time=", prof_measurement_set_self_time, 1);
     rb_define_method(cRpMeasurement, "wait_time", prof_measurement_wait_time, 0);
+    rb_define_method(cRpMeasurement, "wait_time=", prof_measurement_set_wait_time, 1);
 
     rb_define_method(cRpMeasurement, "_dump_data", prof_measurement_dump, 0);
     rb_define_method(cRpMeasurement, "_load_data", prof_measurement_load, 1);

data/ext/ruby_prof/rp_measurement.h

@@ -29,6 +29,7 @@ typedef struct prof_measurer_t
 /* Callers and callee information for a method. */
 typedef struct prof_measurement_t
 {
+    prof_owner_t owner;
     double total_time;
     double self_time;
     double wait_time;
@@ -40,10 +41,12 @@ prof_measurer_t* prof_measurer_create(prof_measure_mode_t measure, bool track_al
 double prof_measure(prof_measurer_t* measurer, rb_trace_arg_t* trace_arg);
 
 prof_measurement_t* prof_measurement_create(void);
+prof_measurement_t* prof_measurement_copy(prof_measurement_t* other);
 void prof_measurement_free(prof_measurement_t* measurement);
 VALUE prof_measurement_wrap(prof_measurement_t* measurement);
 prof_measurement_t* prof_get_measurement(VALUE self);
 void prof_measurement_mark(void* data);
+void prof_measurement_merge_internal(prof_measurement_t* destination, prof_measurement_t* other);
 
 void rp_init_measure(void);