airbnb-ruby-prof 0.0.1

data/ext/ruby_prof/rp_fast_call_tree_printer.c

@@ -0,0 +1,247 @@
+#include "ruby_prof.h"
+#include "math.h"
+
+VALUE cFastCallTreePrinter;
+static ID id_addstr;
+
+/* Utility struct to mirror the require ivars in the ruby class.
+
+    output is a ruby IO object
+
+    value_scale is the conversion factor used to scale the result for rounding.
+    This is set based on the measure mode. */
+typedef struct call_tree_printer_vars
+{
+    VALUE output;
+    size_t len;
+    double value_scales[];
+} call_tree_printer_vars;
+
+static call_tree_printer_vars *
+call_tree_printer_vars_allocate(size_t len)
+{
+    call_tree_printer_vars *result =
+      (call_tree_printer_vars*) ruby_xmalloc(
+          sizeof(call_tree_printer_vars) + len * sizeof(double));
+    result->len = len;
+    return result;
+}
+
+/* Converts the recorded value to a fixed point number based on value scale */
+static long int
+convert(double value, double value_scale)
+{
+    return lround(value * value_scale);
+}
+
+static VALUE
+addstr(VALUE io, VALUE str)
+{
+    return rb_funcall(io, id_addstr, 1, str);
+}
+
+static void
+print_header(
+    call_tree_printer_vars *vars,
+    prof_method_t *method,
+    char *name)
+{
+    /* Format is file and method name followed by line and self time */
+    addstr(
+        vars->output,
+        rb_sprintf(
+            "fl=%s\nfn=%s\n%d",
+            prof_method_t_source_file(method),
+            name,
+            method->line));
+}
+
+/* Returns the index of the callee in the call_infos list. */
+static int
+call_info_index(prof_call_infos_t *call_infos, prof_call_info_t *callee)
+{
+    prof_call_info_t **i;
+    for (i = call_infos->start; i < call_infos->ptr; i++) {
+        if ((*i) == callee) {
+            return i - call_infos->start;
+        }
+    }
+
+    return -1;
+}
+
+static void
+print_child(call_tree_printer_vars *vars, prof_call_info_t *callee)
+{
+    prof_method_t *target = callee->target;
+    VALUE name = prof_method_t_calltree_name(target);
+
+    if (target->recursive) {
+        int index = call_info_index(target->call_infos, callee);
+        name = rb_sprintf("%s [%d]", RSTRING_PTR(name), index);
+    }
+
+    addstr(
+        vars->output,
+        rb_sprintf(
+            "cfl=%s\ncfn=%s\ncalls=%d %d\n%d",
+            prof_method_t_source_file(target),
+            RSTRING_PTR(name),
+            callee->called,
+            callee->line,
+            callee->line));
+
+    for(size_t i = 0; i < callee->measures_len; i++) {
+        addstr(
+            vars->output,
+            rb_sprintf(
+                " %ld",
+                convert(callee->measure_values[i].total, vars->value_scales[i])));
+    }
+    addstr(vars->output, rb_str_new2("\n"));
+
+    RB_GC_GUARD(name);
+}
+
+/* Function to be called by st_foreach to print each child call info */
+static int
+print_child_iter(st_data_t key, st_data_t value, st_data_t vars)
+{
+    print_child((call_tree_printer_vars *) vars, (prof_call_info_t *) value);
+    return ST_CONTINUE;
+}
+
+static void
+print_simple_method(call_tree_printer_vars *vars, prof_method_t *method)
+{
+    VALUE calltree_name = prof_method_t_calltree_name(method);
+    size_t measures_len = (*method->call_infos->start)->measures_len;
+
+    print_header(vars, method, RSTRING_PTR(calltree_name));
+    for(size_t j = 0; j < measures_len; j++) {
+        addstr(vars->output,
+              rb_sprintf(" %ld", convert(prof_method_t_self_time(method, j), vars->value_scales[j])));
+    }
+    addstr(vars->output, rb_str_new2("\n"));
+
+    prof_call_info_t **i;
+    for(i = method->call_infos->start; i < method->call_infos->ptr; i++) {
+        st_foreach((*i)->call_infos, print_child_iter, (uintptr_t) vars);
+    }
+
+    RB_GC_GUARD(calltree_name);
+}
+
+static void
+print_recursive_method(call_tree_printer_vars *vars, prof_method_t *method)
+{
+    VALUE calltree_name = prof_method_t_calltree_name(method);
+
+    prof_call_info_t **i;
+    for(i = method->call_infos->start; i < method->call_infos->ptr; i++) {
+        int index = i - method->call_infos->start;
+        VALUE name = rb_sprintf("%s [%d]", RSTRING_PTR(calltree_name), index);
+
+        print_header(vars, method, RSTRING_PTR(name));
+        for(size_t j = 0; j < (*i)->measures_len; j++) {
+            addstr(vars->output,
+                   rb_sprintf(" %ld", convert((*i)->measure_values[j].self, vars->value_scales[j])));
+        }
+        addstr(vars->output, rb_str_new2("\n"));
+
+        st_foreach((*i)->call_infos, print_child_iter, (uintptr_t) vars);
+
+        RB_GC_GUARD(name);
+    }
+
+    RB_GC_GUARD(calltree_name);
+}
+
+static int
+print_method(call_tree_printer_vars *vars, prof_method_t *method)
+{
+    if(!method->excluded) {
+        if (method->recursive) {
+            print_recursive_method(vars, method);
+        } else {
+            print_simple_method(vars, method);
+        }
+
+        addstr(vars->output, rb_str_new2("\n"));
+    }
+
+    return ST_CONTINUE;
+}
+
+/* Iterator to handle reversing an st_table of methods into a provided array */
+static int
+reverse_methods(st_data_t key, st_data_t value, st_data_t arg)
+{
+    prof_method_t ***methods = (prof_method_t ***) arg;
+
+    prof_method_t *method = (prof_method_t *) value;
+
+    *methods = *methods - 1;
+    **methods = method;
+
+    return ST_CONTINUE;
+}
+
+static void
+print_methods_in_reverse(call_tree_printer_vars *vars, st_table *method_table)
+{
+    st_index_t num_entries = method_table->num_entries;
+
+    prof_method_t **reversed = ALLOC_N(prof_method_t*, num_entries);
+    prof_method_t **end = reversed + num_entries;
+
+    prof_method_t **iterator = end;
+
+    st_foreach(method_table, reverse_methods, (uintptr_t) &iterator);
+
+    prof_method_t **i;
+    for(i = reversed; i < end; i++) {
+        print_method(vars, *i);
+    }
+
+    xfree(reversed);
+}
+
+
+/* call-seq:
+   print_thread(thread) -> nil
+
+   Prints to @output the call tree of a thread
+*/
+VALUE
+prof_fast_call_tree_printer_print_thread(VALUE self, VALUE thread) {
+    thread_data_t *thread_data = prof_get_thread(thread);
+
+    VALUE output = rb_iv_get(self, "@output");
+    VALUE value_scales_val = rb_iv_get(self, "@value_scales");
+
+    Check_Type(value_scales_val, T_ARRAY);
+    size_t value_scales_len = RARRAY_LEN(value_scales_val);
+
+    call_tree_printer_vars *vars = call_tree_printer_vars_allocate(value_scales_len);
+    vars->output = output;
+    for(size_t i = 0; i < value_scales_len; i++) {
+        vars->value_scales[i] = NUM2DBL(rb_ary_entry(value_scales_val, i));
+    }
+
+    print_methods_in_reverse(vars, thread_data->method_table);
+
+    xfree(vars);
+
+    return Qnil;
+}
+
+void rp_init_fast_call_tree_printer()
+{
+    id_addstr = rb_intern("<<");
+
+    cFastCallTreePrinter = rb_define_class_under(mProf,
+            "FastCallTreePrinter", rb_cObject);
+    rb_define_method(cFastCallTreePrinter, "print_thread",
+            prof_fast_call_tree_printer_print_thread, 1);
+}

data/ext/ruby_prof/rp_fast_call_tree_printer.h

@@ -0,0 +1,10 @@
+#ifndef __RP_FAST_CALL_TREE_PRINTER_H__
+#define __RP_FAST_CALL_TREE_PRINTER_H__
+
+#include <ruby.h>
+
+extern VALUE cFastCallTreePrinter;
+
+void rp_init_fast_call_tree_printer(void);
+
+#endif

data/ext/ruby_prof/rp_measure.c

@@ -0,0 +1,71 @@
+/* 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 "ruby_prof.h"
+
+VALUE mMeasure;
+
+prof_measurer_t*
+prof_measurer_allocate(size_t len)
+{
+    prof_measurer_t* result =
+      (prof_measurer_t*) ruby_xmalloc(
+          sizeof(prof_measurer_t) + len * sizeof(get_measurement));
+    result->len = len;
+    return result;
+}
+
+prof_measurer_t* prof_get_measurer(prof_measure_mode_t* measures, size_t len)
+{
+    prof_measurer_t* measurer = prof_measurer_allocate(len);
+    measurer->measure_modes = measures;
+
+    for (size_t i = 0; i < len; i++) {
+        switch (measures[i]) {
+        case MEASURE_WALL_TIME:
+            measurer->measures[i] = prof_measurer_wall_time();
+            break;
+        case MEASURE_PROCESS_TIME:
+            measurer->measures[i] = prof_measurer_process_time();
+            break;
+        case MEASURE_CPU_TIME:
+            measurer->measures[i] = prof_measurer_cpu_time();
+            break;
+        case MEASURE_ALLOCATIONS:
+            measurer->measures[i] = prof_measurer_allocations();
+            break;
+        case MEASURE_MEMORY:
+            measurer->measures[i] = prof_measurer_memory();
+            break;
+        case MEASURE_GC_TIME:
+            measurer->measures[i] = prof_measurer_gc_time();
+            break;
+        case MEASURE_GC_RUNS:
+            measurer->measures[i] = prof_measurer_gc_runs();
+            break;
+        default:
+            rb_raise(rb_eArgError, "Unknown measure mode: %d", measures[i]);
+        }
+    }
+
+    return measurer;
+};
+
+void prof_measurer_take_measurements(prof_measurer_t* measurer, prof_measurements_t* dest)
+{
+    for (size_t i = 0; i < measurer->len; i++) {
+        dest->values[i] = measurer->measures[i]();
+    }
+}
+
+void rp_init_measure()
+{
+    mMeasure = rb_define_module_under(mProf, "Measure");
+    rp_init_measure_wall_time();
+    rp_init_measure_cpu_time();
+    rp_init_measure_process_time();
+    rp_init_measure_allocations();
+    rp_init_measure_memory();
+    rp_init_measure_gc_time();
+    rp_init_measure_gc_runs();
+}

data/ext/ruby_prof/rp_measure.h

@@ -0,0 +1,56 @@
+/* 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_MEASUREMENT_H__
+#define __RP_MEASUREMENT_H__
+
+extern VALUE mMeasure;
+
+typedef struct
+{
+    size_t len;
+    double values[];
+} prof_measurements_t;
+
+typedef double (*get_measurement)();
+
+typedef enum
+{
+    MEASURE_WALL_TIME,
+    MEASURE_PROCESS_TIME,
+    MEASURE_CPU_TIME,
+    MEASURE_ALLOCATIONS,
+    MEASURE_MEMORY,
+    MEASURE_GC_TIME,
+    MEASURE_GC_RUNS,
+} prof_measure_mode_t;
+
+typedef struct
+{
+    size_t len;
+    prof_measure_mode_t* measure_modes;
+    get_measurement measures[];
+} prof_measurer_t;
+
+
+prof_measurer_t* prof_get_measurer(prof_measure_mode_t* measures, size_t len);
+get_measurement prof_measurer_allocations();
+get_measurement prof_measurer_cpu_time();
+get_measurement prof_measurer_gc_runs();
+get_measurement prof_measurer_gc_time();
+get_measurement prof_measurer_memory();
+get_measurement prof_measurer_process_time();
+get_measurement prof_measurer_wall_time();
+
+void prof_measurer_take_measurements(prof_measurer_t* measurer, prof_measurements_t* dest);
+
+void rp_init_measure();
+void rp_init_measure_allocations();
+void rp_init_measure_cpu_time();
+void rp_init_measure_gc_runs();
+void rp_init_measure_gc_time();
+void rp_init_measure_memory();
+void rp_init_measure_process_time();
+void rp_init_measure_wall_time();
+
+#endif //__RP_MEASUREMENT_H__

data/ext/ruby_prof/rp_measure_allocations.c

@@ -0,0 +1,74 @@
+/* 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 "ruby_prof.h"
+
+static VALUE cMeasureAllocations;
+
+#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
+  unsigned LONG_LONG rb_os_allocated_objects();
+#endif
+
+#if defined(HAVE_RB_GC_STAT)
+size_t rb_gc_stat(VALUE key);
+
+#if RUBY_PROF_RUBY_VERSION >= 20200
+#define TOTAL_ALLOCATED_OBJECTS_STRING "total_allocated_objects"
+#else
+#define TOTAL_ALLOCATED_OBJECTS_STRING "total_allocated_object"
+#endif
+
+#endif
+
+static double
+measure_allocations()
+{
+#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
+#define MEASURE_ALLOCATIONS_ENABLED Qtrue
+    return rb_os_allocated_objects();
+
+#elif defined(HAVE_RB_GC_STAT) && RUBY_PROF_RUBY_VERSION >= 20100
+#define MEASURE_ALLOCATIONS_ENABLED Qtrue
+    static VALUE total_alloc_symbol = 0;
+    if (!total_alloc_symbol) {
+      total_alloc_symbol = ID2SYM(rb_intern_const(TOTAL_ALLOCATED_OBJECTS_STRING));
+    }
+    return rb_gc_stat(total_alloc_symbol);
+
+#else
+#define MEASURE_ALLOCATIONS_ENABLED Qfalse
+    return 0;
+#endif
+}
+
+
+get_measurement prof_measurer_allocations()
+{
+  return measure_allocations;
+}
+
+/* call-seq:
+     measure -> int
+
+Returns the number of Ruby object allocations. */
+
+static VALUE
+prof_measure_allocations(VALUE self)
+{
+#if defined(HAVE_LONG_LONG)
+    return ULL2NUM(measure_allocations());
+#else
+    return ULONG2NUM(measure_allocations());
+#endif
+}
+
+void rp_init_measure_allocations()
+{
+    rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
+    rb_define_const(mProf, "ALLOCATIONS_ENABLED", MEASURE_ALLOCATIONS_ENABLED);
+
+    cMeasureAllocations = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
+    rb_define_singleton_method(cMeasureAllocations, "measure", prof_measure_allocations, 0);
+}