ruby-prof 0.18.0-x64-mingw32 → 1.1.0-x64-mingw32

data/ext/ruby_prof/rp_allocation.h

@@ -0,0 +1,31 @@
+/* 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 */
+
+#ifndef _RP_ALLOCATION_
+#define _RP_ALLOCATION_
+
+#include "ruby_prof.h"
+#include "rp_method.h"
+
+typedef struct
+{
+    st_data_t key;                    /* Key in hash table */
+    unsigned int klass_flags;         /* Information about the type of class */
+    VALUE klass;                      /* Klass that was created */
+    VALUE klass_name;                 /* Name of the class that was created */
+    VALUE source_file;                /* Line number where allocation happens */
+    int source_line;                  /* Line number where allocation happens */
+    int count;                        /* Number of allocations */
+    size_t memory;                    /* Amount of allocated memory */
+    VALUE object;                     /* Cache to wrapped object */
+} 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);
+
+
+#endif //_RP_ALLOCATION_

data/ext/ruby_prof/rp_call_info.c

@@ -1,86 +1,100 @@
 /* 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 */
 
-#include "ruby_prof.h"
+#include "rp_call_info.h"
 
 #define INITIAL_CALL_INFOS_SIZE 2
 
-VALUE cCallInfo;
-
-
-// Forward declarations
-st_table * call_info_table_create();
-
+VALUE cRpCallnfo;
 
 /* =======  prof_call_info_t   ========*/
 prof_call_info_t *
-prof_call_info_create(prof_method_t* method, prof_call_info_t* parent)
+prof_call_info_create(prof_method_t *method, prof_method_t *parent, VALUE source_file, int source_line)
 {
     prof_call_info_t *result = ALLOC(prof_call_info_t);
-    result->object = Qnil;
-    result->target = method;
+    result->method = method;
     result->parent = parent;
-    result->call_infos = call_info_table_create();
-    result->children = Qnil;
-
-    result->total_time = 0;
-    result->self_time = 0;
-    result->wait_time = 0;
+    result->object = Qnil;
+    result->measurement = prof_measurement_create();
 
-    result->called = 0;
+    result->visits = 0;
 
-    result->recursive = 0;
     result->depth = 0;
-    result->line = 0;
+    result->source_line = source_line;
+    result->source_file = source_file;
 
     return result;
 }
+
 static void
-prof_call_info_ruby_gc_free(prof_call_info_t *call_info)
+prof_call_info_ruby_gc_free(void *data)
 {
-	/* Has this thread object been accessed by Ruby?  If
+    prof_call_info_t *call_info = (prof_call_info_t*)data;
+
+    /* Has this call info object been accessed by Ruby?  If
 	   yes clean it up so to avoid a segmentation fault. */
 	if (call_info->object != Qnil)
 	{
-		RDATA(call_info->object)->data = NULL;
-		RDATA(call_info->object)->dfree = NULL;
-		RDATA(call_info->object)->dmark = NULL;
+        RDATA(call_info->object)->dmark = NULL;
+        RDATA(call_info->object)->dfree = NULL;
+        RDATA(call_info->object)->data = NULL;
+        call_info->object = Qnil;
     }
-	call_info->object = Qnil;
 }
 
-static void
+void
 prof_call_info_free(prof_call_info_t *call_info)
 {
-	prof_call_info_ruby_gc_free(call_info);
-	st_free_table(call_info->call_infos);
-	xfree(call_info);
+    prof_measurement_free(call_info->measurement);
+    prof_call_info_ruby_gc_free(call_info);
+    xfree(call_info);
 }
 
-static void
-prof_call_info_mark(prof_call_info_t *call_info)
+size_t
+prof_call_info_size(const void *data)
+{
+    return sizeof(prof_call_info_t);
+}
+
+void
+prof_call_info_mark(void *data)
 {
-	if (call_info->object)
+    prof_call_info_t *call_info = (prof_call_info_t*)data;
+
+    if (call_info->source_file != Qnil)
+        rb_gc_mark(call_info->source_file);
+
+    if (call_info->object != Qnil)
 		rb_gc_mark(call_info->object);
 
-	if (call_info->children)
-		rb_gc_mark(call_info->children);
+    if (call_info->method && call_info->method->object != Qnil)
+        rb_gc_mark(call_info->method->object);
+
+    if (call_info->parent && call_info->parent->object != Qnil)
+        rb_gc_mark(call_info->parent->object);
 
-	/* We don't mark the call info child table since that will be done
-	   via the appropriate method */
+    prof_measurement_mark(call_info->measurement);
 }
 
 VALUE
 prof_call_info_wrap(prof_call_info_t *call_info)
 {
-  if (call_info->object == Qnil)
-  {
-    call_info->object = Data_Wrap_Struct(cCallInfo, prof_call_info_mark, prof_call_info_ruby_gc_free, call_info);
-  }
-  return call_info->object;
+    if (call_info->object == Qnil)
+    {
+        call_info->object =  Data_Wrap_Struct(cRpCallnfo, prof_call_info_mark, prof_call_info_ruby_gc_free, call_info);
+    }
+    return call_info->object;
 }
 
-static prof_call_info_t *
+static VALUE
+prof_call_info_allocate(VALUE klass)
+{
+    prof_call_info_t* call_info = prof_call_info_create(NULL, NULL, Qnil, 0);
+    call_info->object = prof_call_info_wrap(call_info);
+    return call_info->object;
+}
+
+prof_call_info_t *
 prof_get_call_info(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
@@ -97,17 +111,17 @@ prof_get_call_info(VALUE self)
 st_table *
 call_info_table_create()
 {
-  return st_init_table(&type_method_hash);
+    return st_init_numtable();
 }
 
 size_t
-call_info_table_insert(st_table *table, const prof_method_key_t *key, prof_call_info_t *val)
+call_info_table_insert(st_table *table, st_data_t key, prof_call_info_t *val)
 {
   return st_insert(table, (st_data_t) key, (st_data_t) val);
 }
 
 prof_call_info_t *
-call_info_table_lookup(st_table *table, const prof_method_key_t *key)
+call_info_table_lookup(st_table *table, st_data_t key)
 {
     st_data_t val;
     if (st_lookup(table, (st_data_t) key, &val))
@@ -120,62 +134,42 @@ call_info_table_lookup(st_table *table, const prof_method_key_t *key)
     }
 }
 
-
 /* =======  RubyProf::CallInfo   ========*/
 
-/* Document-class: RubyProf::CallInfo
-RubyProf::CallInfo is a helper class used by RubyProf::MethodInfo
-to keep track of which child methods were called and how long
-they took to execute. */
-
-
-/* call-seq:
-   called -> MethodInfo
-
-Returns the target method. */
-static VALUE
-prof_call_info_target(VALUE self)
-{
-    /* Target is a pointer to a method_info - so we have to be careful
-       about the GC.  We will wrap the method_info but provide no
-       free method so the underlying object is not freed twice! */
-
-    prof_call_info_t *result = prof_get_call_info(self);
-    return prof_method_wrap(result->target);
-}
-
 /* call-seq:
-   called -> int
+   parent -> call_info
 
-Returns the total amount of times this method was called. */
+Returns the call_infos parent call_info object (the method that called this method).*/
 static VALUE
-prof_call_info_called(VALUE self)
+prof_call_info_parent(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info(self);
-    return INT2NUM(result->called);
+    prof_call_info_t* call_info = prof_get_call_info(self);
+    if (call_info->parent)
+        return prof_method_wrap(call_info->parent);
+    else
+        return Qnil;
 }
 
 /* call-seq:
-   called=n -> n
+   called -> MethodInfo
 
-Sets the call count to n. */
+Returns the target method. */
 static VALUE
-prof_call_info_set_called(VALUE self, VALUE called)
+prof_call_info_target(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info(self);
-    result->called = NUM2INT(called);
-    return called;
+    prof_call_info_t *call_info = prof_get_call_info(self);
+    return prof_method_wrap(call_info->method);
 }
 
 /* call-seq:
-   recursive? -> boolean
+   called -> Measurement
 
-   Returns the true if this call info is a recursive invocation */
+Returns the measurement associated with this call_info. */
 static VALUE
-prof_call_info_recursive(VALUE self)
+prof_call_info_measurement(VALUE self)
 {
-  prof_call_info_t *result = prof_get_call_info(self);
-  return result->recursive ? Qtrue : Qfalse;
+    prof_call_info_t* call_info = prof_get_call_info(self);
+    return prof_measurement_wrap(call_info->measurement);
 }
 
 /* call-seq:
@@ -190,236 +184,88 @@ prof_call_info_depth(VALUE self)
 }
 
 /* call-seq:
-   line_no -> int
-
-   returns the line number of the method */
-static VALUE
-prof_call_info_line(VALUE self)
-{
-  prof_call_info_t *result = prof_get_call_info(self);
-  return rb_int_new(result->line);
-}
-
-/* call-seq:
-   total_time -> float
+   source_file => string
 
-Returns the total amount of time spent in this method and its children. */
+return the source file of the method
+*/
 static VALUE
-prof_call_info_total_time(VALUE self)
+prof_call_info_source_file(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info(self);
-    return rb_float_new(result->total_time);
+    prof_call_info_t* result = prof_get_call_info(self);
+    return result->source_file;
 }
 
 /* call-seq:
-   add_total_time(call_info) -> nil
-
-adds total time time from call_info to self. */
-static VALUE
-prof_call_info_add_total_time(VALUE self, VALUE other)
-{
-    prof_call_info_t *result = prof_get_call_info(self);
-    prof_call_info_t *other_info = prof_get_call_info(other);
-
-    result->total_time += other_info->total_time;
-    return Qnil;
-}
-
-/* call-seq:
-   self_time -> float
-
-Returns the total amount of time spent in this method. */
-static VALUE
-prof_call_info_self_time(VALUE self)
-{
-    prof_call_info_t *result = prof_get_call_info(self);
-
-    return rb_float_new(result->self_time);
-}
-
-/* call-seq:
-   add_self_time(call_info) -> nil
+   line_no -> int
 
-adds self time from call_info to self. */
+   returns the line number of the method */
 static VALUE
-prof_call_info_add_self_time(VALUE self, VALUE other)
+prof_call_info_line(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info(self);
-    prof_call_info_t *other_info = prof_get_call_info(other);
-
-    result->self_time += other_info->self_time;
-    return Qnil;
+  prof_call_info_t *result = prof_get_call_info(self);
+  return INT2FIX(result->source_line);
 }
 
-/* call-seq:
-   wait_time -> float
-
-Returns the total amount of time this method waited for other threads. */
+/* :nodoc: */
 static VALUE
-prof_call_info_wait_time(VALUE self)
+prof_call_info_dump(VALUE self)
 {
-    prof_call_info_t *result = prof_get_call_info(self);
-
-    return rb_float_new(result->wait_time);
-}
+    prof_call_info_t* call_info_data = prof_get_call_info(self);
+    VALUE result = rb_hash_new();
 
-/* call-seq:
-   add_wait_time(call_info) -> nil
+    rb_hash_aset(result, ID2SYM(rb_intern("measurement")), prof_measurement_wrap(call_info_data->measurement));
 
-adds wait time from call_info to self. */
+    rb_hash_aset(result, ID2SYM(rb_intern("depth")), INT2FIX(call_info_data->depth));
+    rb_hash_aset(result, ID2SYM(rb_intern("source_file")), call_info_data->source_file);
+    rb_hash_aset(result, ID2SYM(rb_intern("source_line")), INT2FIX(call_info_data->source_line));
 
-static VALUE
-prof_call_info_add_wait_time(VALUE self, VALUE other)
-{
-    prof_call_info_t *result = prof_get_call_info(self);
-    prof_call_info_t *other_info = prof_get_call_info(other);
+    rb_hash_aset(result, ID2SYM(rb_intern("parent")), prof_call_info_parent(self));
+    rb_hash_aset(result, ID2SYM(rb_intern("target")), prof_call_info_target(self));
 
-    result->wait_time += other_info->wait_time;
-    return Qnil;
+    return result;
 }
 
-/* call-seq:
-   parent -> call_info
-
-Returns the call_infos parent call_info object (the method that called this method).*/
+/* :nodoc: */
 static VALUE
-prof_call_info_parent(VALUE self)
+prof_call_info_load(VALUE self, VALUE data)
 {
-    prof_call_info_t *result = prof_get_call_info(self);
-    if (result->parent)
-      return prof_call_info_wrap(result->parent);
-    else
-      return Qnil;
-}
+	VALUE target = Qnil;
+	VALUE parent = Qnil;
+	prof_call_info_t* call_info = prof_get_call_info(self);
+    call_info->object = self;
 
-/* call-seq:
-   parent=new_parent -> new_parent
+    VALUE measurement = rb_hash_aref(data, ID2SYM(rb_intern("measurement")));
+    call_info->measurement = prof_get_measurement(measurement);
 
-Changes the parent of self to new_parent and returns it.*/
-static VALUE
-prof_call_info_set_parent(VALUE self, VALUE new_parent)
-{
-    prof_call_info_t *result = prof_get_call_info(self);
-    if (new_parent == Qnil)
-      result->parent = NULL;
-    else
-      result->parent = prof_get_call_info(new_parent);
-    return prof_call_info_parent(self);
-}
+    call_info->depth = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("depth"))));
+    call_info->source_file = rb_hash_aref(data, ID2SYM(rb_intern("source_file")));
+    call_info->source_line = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("source_line"))));
 
-static int
-prof_call_info_collect_children(st_data_t key, st_data_t value, st_data_t result)
-{
-    prof_call_info_t *call_info = (prof_call_info_t *) value;
-    VALUE arr = (VALUE) result;
-    rb_ary_push(arr, prof_call_info_wrap(call_info));
-    return ST_CONTINUE;
-}
+    parent = rb_hash_aref(data, ID2SYM(rb_intern("parent")));
+    if (parent != Qnil)
+        call_info->parent = prof_method_get(parent);
 
-/* call-seq:
-   children -> hash
+    target = rb_hash_aref(data, ID2SYM(rb_intern("target")));
+    call_info->method = prof_method_get(target);
 
-Returns an array of call info objects of methods that this method
-called (ie, children).*/
-static VALUE
-prof_call_info_children(VALUE self)
-{
-    prof_call_info_t *call_info = prof_get_call_info(self);
-    if (call_info->children == Qnil)
-    {
-      call_info->children = rb_ary_new();
-      st_foreach(call_info->call_infos, prof_call_info_collect_children, call_info->children);
-    }
-    return call_info->children;
+    return data;
 }
 
-/* =======  Call Infos   ========*/
-prof_call_infos_t*
-prof_call_infos_create()
-{
-   prof_call_infos_t *result = ALLOC(prof_call_infos_t);
-   result->start = ALLOC_N(prof_call_info_t*, INITIAL_CALL_INFOS_SIZE);
-   result->end = result->start + INITIAL_CALL_INFOS_SIZE;
-   result->ptr = result->start;
-   result->object = Qnil;
-   return result;
-}
-
-void
-prof_call_infos_mark(prof_call_infos_t *call_infos)
-{
-    prof_call_info_t **call_info;
-
-	if (call_infos->object)
-		rb_gc_mark(call_infos->object);
-
-    for(call_info=call_infos->start; call_info<call_infos->ptr; call_info++)
-    {
-		prof_call_info_mark(*call_info);
-    }
-}
-
-void
-prof_call_infos_free(prof_call_infos_t *call_infos)
+void rp_init_call_info()
 {
-    prof_call_info_t **call_info;
-
-    for(call_info=call_infos->start; call_info<call_infos->ptr; call_info++)
-    {
-		prof_call_info_free(*call_info);
-    }
-}
+    /* CallInfo */
+    cRpCallnfo = rb_define_class_under(mProf, "CallInfo", rb_cData);
+    rb_undef_method(CLASS_OF(cRpCallnfo), "new");
+    rb_define_alloc_func(cRpCallnfo, prof_call_info_allocate);
 
-void
-prof_add_call_info(prof_call_infos_t *call_infos, prof_call_info_t *call_info)
-{
-  if (call_infos->ptr == call_infos->end)
-  {
-    size_t len = call_infos->ptr - call_infos->start;
-    size_t new_capacity = (call_infos->end - call_infos->start) * 2;
-    REALLOC_N(call_infos->start, prof_call_info_t*, new_capacity);
-    call_infos->ptr = call_infos->start + len;
-    call_infos->end = call_infos->start + new_capacity;
-  }
-  *call_infos->ptr = call_info;
-  call_infos->ptr++;
-}
+    rb_define_method(cRpCallnfo, "parent", prof_call_info_parent, 0);
+    rb_define_method(cRpCallnfo, "target", prof_call_info_target, 0);
+    rb_define_method(cRpCallnfo, "measurement", prof_call_info_measurement, 0);
 
-VALUE
-prof_call_infos_wrap(prof_call_infos_t *call_infos)
-{
-  if (call_infos->object == Qnil)
-  {
-    prof_call_info_t **i;
-    call_infos->object = rb_ary_new();
-    for(i=call_infos->start; i<call_infos->ptr; i++)
-    {
-      VALUE call_info = prof_call_info_wrap(*i);
-      rb_ary_push(call_infos->object, call_info);
-    }
-  }
-  return call_infos->object;
-}
+    rb_define_method(cRpCallnfo, "depth", prof_call_info_depth, 0);
+    rb_define_method(cRpCallnfo, "source_file", prof_call_info_source_file, 0);
+    rb_define_method(cRpCallnfo, "line", prof_call_info_line, 0);
 
-void rp_init_call_info()
-{
-    /* CallInfo */
-    cCallInfo = rb_define_class_under(mProf, "CallInfo", rb_cObject);
-    rb_undef_method(CLASS_OF(cCallInfo), "new");
-    rb_define_method(cCallInfo, "parent", prof_call_info_parent, 0);
-    rb_define_method(cCallInfo, "parent=", prof_call_info_set_parent, 1);
-    rb_define_method(cCallInfo, "children", prof_call_info_children, 0);
-    rb_define_method(cCallInfo, "target", prof_call_info_target, 0);
-    rb_define_method(cCallInfo, "called", prof_call_info_called, 0);
-    rb_define_method(cCallInfo, "called=", prof_call_info_set_called, 1);
-    rb_define_method(cCallInfo, "total_time", prof_call_info_total_time, 0);
-    rb_define_method(cCallInfo, "add_total_time", prof_call_info_add_total_time, 1);
-    rb_define_method(cCallInfo, "self_time", prof_call_info_self_time, 0);
-    rb_define_method(cCallInfo, "add_self_time", prof_call_info_add_self_time, 1);
-    rb_define_method(cCallInfo, "wait_time", prof_call_info_wait_time, 0);
-    rb_define_method(cCallInfo, "add_wait_time", prof_call_info_add_wait_time, 1);
-
-    rb_define_method(cCallInfo, "recursive?", prof_call_info_recursive, 0);
-    rb_define_method(cCallInfo, "depth", prof_call_info_depth, 0);
-    rb_define_method(cCallInfo, "line", prof_call_info_line, 0);
+    rb_define_method(cRpCallnfo, "_dump_data", prof_call_info_dump, 0);
+    rb_define_method(cRpCallnfo, "_load_data", prof_call_info_load, 1);
 }