ruby-prof 1.4.4-x64-mingw-ucrt

data/ext/ruby_prof/rp_call_tree.h

@@ -0,0 +1,43 @@
+/* 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_CALL_TREE_H__
+#define __RP_CALL_TREE_H__
+
+#include "ruby_prof.h"
+#include "rp_measurement.h"
+#include "rp_method.h"
+
+extern VALUE cRpCallTree;
+
+/* Callers and callee information for a method. */
+typedef struct prof_call_tree_t
+{
+    prof_method_t* method;
+    struct prof_call_tree_t* parent;
+    st_table* children;             /* Call infos that this call info calls */
+    prof_measurement_t* measurement;
+    VALUE object;
+
+    int visits;                             /* Current visits on the stack */
+
+    unsigned int source_line;
+    VALUE source_file;
+} 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_mark(void* data);
+prof_call_tree_t* call_tree_table_lookup(st_table* table, st_data_t key);
+
+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);
+
+uint32_t prof_call_figure_depth(prof_call_tree_t* call_tree_data);
+prof_call_tree_t* prof_get_call_tree(VALUE self);
+VALUE prof_call_tree_wrap(prof_call_tree_t* call_tree);
+void prof_call_tree_free(prof_call_tree_t* call_tree);
+void rp_init_call_tree();
+
+#endif //__RP_CALL_TREE_H__

data/ext/ruby_prof/rp_call_trees.c

@@ -0,0 +1,288 @@
+/* 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"
+
+#define INITIAL_CALL_TREES_SIZE 2
+
+VALUE cRpCallTrees;
+
+/* =======  Call Infos   ========*/
+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 = RTYPEDDATA_DATA(self);
+
+    if (!result)
+        rb_raise(rb_eRuntimeError, "This RubyProf::CallTrees instance has already been freed, likely because its profile has been freed.");
+
+    return result;
+}
+
+prof_call_trees_t* prof_call_trees_create()
+{
+    prof_call_trees_t* result = ALLOC(prof_call_trees_t);
+    result->start = ALLOC_N(prof_call_tree_t*, INITIAL_CALL_TREES_SIZE);
+    result->end = result->start + INITIAL_CALL_TREES_SIZE;
+    result->ptr = result->start;
+    result->object = Qnil;
+    return result;
+}
+
+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++)
+    {
+        prof_call_tree_mark(*call_tree);
+    }
+}
+
+void prof_call_trees_free(prof_call_trees_t* call_trees)
+{
+    /* Has this method object been accessed by Ruby?  If
+       yes clean it up so to avoid a segmentation fault. */
+    if (call_trees->object != Qnil)
+    {
+        RTYPEDDATA(call_trees->object)->data = NULL;
+        call_trees->object = Qnil;
+    }
+
+    // Note we do not free our call_tree structures - since they have no parents they will free themselves
+    xfree(call_trees);
+}
+
+void prof_call_trees_ruby_gc_free(void* data)
+{
+    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)
+{
+    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);
+    rb_ary_push(result, aggregate_call_tree);
+
+    return ST_CONTINUE;
+}
+
+static int prof_call_trees_collect_callees(st_data_t key, st_data_t value, st_data_t hash)
+{
+    st_table* callers = (st_table*)hash;
+    prof_call_tree_t* call_tree_data = (prof_call_tree_t*)value;
+
+    prof_call_tree_t* aggregate_call_tree_data = NULL;
+
+    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);
+    }
+    else
+    {
+        aggregate_call_tree_data = prof_call_tree_copy(call_tree_data);
+        rb_st_insert(callers, call_tree_data->method->key, (st_data_t)aggregate_call_tree_data);
+    }
+
+    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 = TypedData_Wrap_Struct(cRpCallTrees, &call_trees_type, call_trees);
+    }
+    return call_trees->object;
+}
+
+void prof_add_call_tree(prof_call_trees_t* call_trees, prof_call_tree_t* call_tree)
+{
+    if (call_trees->ptr == call_trees->end)
+    {
+        size_t len = call_trees->ptr - call_trees->start;
+        size_t new_capacity = (call_trees->end - call_trees->start) * 2;
+        REALLOC_N(call_trees->start, prof_call_tree_t*, new_capacity);
+        call_trees->ptr = call_trees->start + len;
+        call_trees->end = call_trees->start + new_capacity;
+    }
+    *call_trees->ptr = call_tree;
+    call_trees->ptr++;
+}
+
+/* ================  Call Infos   =================*/
+/* Document-class: RubyProf::CallTrees
+The RubyProf::MethodInfo class stores profiling data for a method.
+One instance of the RubyProf::MethodInfo class is created per method
+called per thread.  Thus, if a method is called in two different
+thread then there will be two RubyProf::MethodInfo objects
+created.  RubyProf::MethodInfo objects can be accessed via
+the RubyProf::Profile object. */
+VALUE prof_call_trees_allocate(VALUE klass)
+{
+    prof_call_trees_t* call_trees_data = prof_call_trees_create();
+    call_trees_data->object = prof_call_trees_wrap(call_trees_data);
+    return call_trees_data->object;
+}
+
+
+/* call-seq:
+   min_depth -> Integer
+
+Returns the minimum depth of this method in any call tree */
+VALUE prof_call_trees_min_depth(VALUE self)
+{
+    unsigned int depth = INT_MAX;
+
+    prof_call_trees_t* call_trees = prof_get_call_trees(self);
+    for (prof_call_tree_t** p_call_tree = call_trees->start; p_call_tree < call_trees->ptr; p_call_tree++)
+    {
+        unsigned int call_tree_depth = prof_call_figure_depth(*p_call_tree);
+        if (call_tree_depth < depth)
+            depth = call_tree_depth;
+    }
+
+    return UINT2NUM(depth);
+}
+
+/* call-seq:
+   callers -> array
+
+Returns an array of all CallTree objects that called this method. */
+VALUE prof_call_trees_call_trees(VALUE self)
+{
+    VALUE result = rb_ary_new();
+
+    prof_call_trees_t* call_trees = prof_get_call_trees(self);
+    for (prof_call_tree_t** p_call_tree = call_trees->start; p_call_tree < call_trees->ptr; p_call_tree++)
+    {
+        VALUE call_tree = prof_call_tree_wrap(*p_call_tree);
+        rb_ary_push(result, call_tree);
+    }
+    return result;
+}
+
+/* call-seq:
+   callers -> array
+
+Returns an array of aggregated CallTree objects that called this method (ie, parents).*/
+VALUE prof_call_trees_callers(VALUE self)
+{
+    st_table* callers = rb_st_init_numtable();
+
+    prof_call_trees_t* call_trees = prof_get_call_trees(self);
+    for (prof_call_tree_t** p_call_tree = call_trees->start; p_call_tree < call_trees->ptr; p_call_tree++)
+    {
+        prof_call_tree_t* parent = (*p_call_tree)->parent;
+        if (parent == NULL)
+            continue;
+
+        prof_call_tree_t* aggregate_call_tree_data = NULL;
+
+        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);
+        }
+        else
+        {
+            aggregate_call_tree_data = prof_call_tree_copy(*p_call_tree);
+            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_free_table(callers);
+    return result;
+}
+
+/* call-seq:
+   callees -> array
+
+Returns an array of aggregated CallTree objects that this method called (ie, children).*/
+VALUE prof_call_trees_callees(VALUE self)
+{
+    st_table* callees = rb_st_init_numtable();
+
+    prof_call_trees_t* call_trees = prof_get_call_trees(self);
+    for (prof_call_tree_t** call_tree = call_trees->start; call_tree < call_trees->ptr; call_tree++)
+    {
+        rb_st_foreach((*call_tree)->children, prof_call_trees_collect_callees, (st_data_t)callees);
+    }
+
+    VALUE result = rb_ary_new_capa((long)callees->num_entries);
+    rb_st_foreach(callees, prof_call_trees_collect_aggregates, result);
+    rb_st_free_table(callees);
+    return result;
+}
+
+/* :nodoc: */
+VALUE prof_call_trees_dump(VALUE self)
+{
+    VALUE result = rb_hash_new();
+    rb_hash_aset(result, ID2SYM(rb_intern("call_trees")), prof_call_trees_call_trees(self));
+
+    return result;
+}
+
+/* :nodoc: */
+VALUE prof_call_trees_load(VALUE self, VALUE data)
+{
+    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")));
+    for (int i = 0; i < rb_array_len(call_trees); i++)
+    {
+        VALUE call_tree = rb_ary_entry(call_trees, i);
+        prof_call_tree_t* call_tree_data = prof_get_call_tree(call_tree);
+        prof_add_call_tree(call_trees_data, call_tree_data);
+    }
+
+    return data;
+}
+
+void rp_init_call_trees()
+{
+    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);
+
+    rb_define_method(cRpCallTrees, "min_depth", prof_call_trees_min_depth, 0);
+
+    rb_define_method(cRpCallTrees, "call_trees", prof_call_trees_call_trees, 0);
+    rb_define_method(cRpCallTrees, "callers", prof_call_trees_callers, 0);
+    rb_define_method(cRpCallTrees, "callees", prof_call_trees_callees, 0);
+
+    rb_define_method(cRpCallTrees, "_dump_data", prof_call_trees_dump, 0);
+    rb_define_method(cRpCallTrees, "_load_data", prof_call_trees_load, 1);
+}

data/ext/ruby_prof/rp_call_trees.h

@@ -0,0 +1,28 @@
+/* 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 */
+
+#ifndef __RP_CALL_TREES_H__
+#define __RP_CALL_TREES_H__
+
+#include "ruby_prof.h"
+#include "rp_call_tree.h"
+
+   /* Array of call_tree objects */
+typedef struct prof_call_trees_t
+{
+    prof_call_tree_t** start;
+    prof_call_tree_t** end;
+    prof_call_tree_t** ptr;
+
+    VALUE object;
+} prof_call_trees_t;
+
+
+void rp_init_call_trees();
+prof_call_trees_t* prof_call_trees_create();
+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);
+VALUE prof_call_trees_wrap(prof_call_trees_t* call_trees);
+
+#endif //__RP_CALL_TREES_H__

data/ext/ruby_prof/rp_measure_allocations.c

@@ -0,0 +1,47 @@
+/* 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 */
+
+/* :nodoc: */
+
+#include "rp_measurement.h"
+
+static VALUE cMeasureAllocations;
+VALUE total_allocated_objects_key;
+
+static double measure_allocations(rb_trace_arg_t* trace_arg)
+{
+    static double result = 0;
+
+    if (trace_arg)
+    {
+        // Only process creation of new objects
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ) {
+            // Don't count allocations of internal IMemo objects
+            VALUE object = rb_tracearg_object(trace_arg);
+            if (BUILTIN_TYPE(object) != T_IMEMO)
+                result++;
+        }
+    }
+    return result;
+}
+
+prof_measurer_t* prof_measurer_allocations(bool track_allocations)
+{
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_ALLOCATIONS;
+    measure->measure = measure_allocations;
+    measure->multiplier = 1;
+    // Need to track allocations to get RUBY_INTERNAL_EVENT_NEWOBJ event
+    measure->track_allocations = track_allocations;
+
+    return measure;
+}
+
+void rp_init_measure_allocations()
+{
+    total_allocated_objects_key = ID2SYM(rb_intern("total_allocated_objects"));
+    rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
+
+    cMeasureAllocations = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
+}

data/ext/ruby_prof/rp_measure_memory.c

@@ -0,0 +1,46 @@
+/* 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 */
+
+/* :nodoc: */
+
+#include "rp_measurement.h"
+
+static VALUE cMeasureMemory;
+
+static double measure_memory(rb_trace_arg_t* trace_arg)
+{
+    static double result = 0;
+
+    if (trace_arg)
+    {
+        // Only process creation of new objects
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
+        {
+            // Don't count allocations of internal IMemo objects
+            VALUE object = rb_tracearg_object(trace_arg);
+            if (BUILTIN_TYPE(object) != T_IMEMO)
+                result += rb_obj_memsize_of(object);
+        }
+    }
+
+    return result;
+}
+
+prof_measurer_t* prof_measurer_memory(bool track_allocations)
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->mode = MEASURE_MEMORY;
+  measure->measure = measure_memory;
+  measure->multiplier = 1;
+  // Need to track allocations to get RUBY_INTERNAL_EVENT_NEWOBJ event
+  measure->track_allocations = true;
+  return measure;
+}
+
+void rp_init_measure_memory()
+{
+    rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
+
+    cMeasureMemory = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
+}

data/ext/ruby_prof/rp_measure_process_time.c

@@ -0,0 +1,66 @@
+/* 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 "rp_measurement.h"
+#include <time.h>
+
+static VALUE cMeasureProcessTime;
+
+static double measure_process_time(rb_trace_arg_t* trace_arg)
+{
+#if defined(_WIN32)
+    FILETIME  createTime;
+    FILETIME  exitTime;
+    FILETIME  kernelTime;
+    FILETIME  userTime;
+
+    ULARGE_INTEGER kernelTimeInt;
+    ULARGE_INTEGER userTimeInt;
+
+    GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &kernelTime, &userTime);
+
+    kernelTimeInt.LowPart = kernelTime.dwLowDateTime;
+    kernelTimeInt.HighPart = kernelTime.dwHighDateTime;
+    userTimeInt.LowPart = userTime.dwLowDateTime;
+    userTimeInt.HighPart = userTime.dwHighDateTime;
+
+    return (double)(kernelTimeInt.QuadPart + userTimeInt.QuadPart);
+#elif !defined(CLOCK_PROCESS_CPUTIME_ID)
+    #include <sys/resource.h>
+    struct rusage usage;
+    getrusage(RUSAGE_SELF, &usage);
+    return usage.ru_stime.tv_sec + usage.ru_utime.tv_sec + ((usage.ru_stime.tv_usec + usage.ru_utime.tv_usec) / 1000000.0);
+#else
+    struct timespec clock;
+    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &clock);
+    return clock.tv_sec + (clock.tv_nsec / 1000000000.0);
+#endif
+}
+
+static double multiplier_process_time(void)
+{
+#if defined(_WIN32)
+    // Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
+    return 1.0 / 10000000.0;
+#else
+    return 1.0;
+#endif
+}
+
+prof_measurer_t* prof_measurer_process_time(bool track_allocations)
+{
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_PROCESS_TIME;
+    measure->measure = measure_process_time;
+    measure->multiplier = multiplier_process_time();
+    measure->track_allocations = track_allocations;
+    return measure;
+}
+
+void rp_init_measure_process_time()
+{
+    rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
+    rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
+
+    cMeasureProcessTime = rb_define_class_under(mMeasure, "ProcessTime", rb_cObject);
+}

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -0,0 +1,64 @@
+/* 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 */
+
+   /* :nodoc: */
+#include "rp_measurement.h"
+
+#if defined(__APPLE__)
+#include <mach/mach_time.h>
+#elif !defined(_WIN32)
+#include <time.h>
+#endif
+
+static VALUE cMeasureWallTime;
+
+static double measure_wall_time(rb_trace_arg_t* trace_arg)
+{
+#if defined(_WIN32)
+    LARGE_INTEGER time;
+    QueryPerformanceCounter(&time);
+    return (double)time.QuadPart;
+#elif defined(__APPLE__)
+    return mach_absolute_time();// * (uint64_t)mach_timebase.numer / (uint64_t)mach_timebase.denom;
+#elif defined(__linux__)
+    struct timespec tv;
+    clock_gettime(CLOCK_MONOTONIC, &tv);
+    return tv.tv_sec + (tv.tv_nsec / 1000000000.0);
+#else
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec + (tv.tv_usec / 1000000.0);
+#endif
+}
+
+static double multiplier_wall_time(void)
+{
+#if defined(_WIN32)
+    LARGE_INTEGER frequency;
+    QueryPerformanceFrequency(&frequency);
+    return 1.0 / frequency.QuadPart;
+#elif defined(__APPLE__)
+    mach_timebase_info_data_t mach_timebase;
+    mach_timebase_info(&mach_timebase);
+    return (uint64_t)mach_timebase.numer / (uint64_t)mach_timebase.denom / 1000000000.0;
+#else
+    return 1.0;
+#endif
+}
+
+prof_measurer_t* prof_measurer_wall_time(bool track_allocations)
+{
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->mode = MEASURE_WALL_TIME;
+    measure->measure = measure_wall_time;
+    measure->multiplier = multiplier_wall_time();
+    measure->track_allocations = track_allocations;
+    return measure;
+}
+
+void rp_init_measure_wall_time()
+{
+    rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
+
+    cMeasureWallTime = rb_define_class_under(mMeasure, "WallTime", rb_cObject);
+}