object_tracing.c

/**********************************************************************

  object_tracing.c - Object Tracing mechanism/ObjectSpace extender for MRI.

  $Author$
  created at: Mon May 27 16:27:44 2013

  NOTE: This extension library is not expected to exist except C Ruby.
  NOTE: This feature is an example usage of internal event tracing APIs.

  All the files in this distribution are covered under the Ruby's
  license (see the file COPYING).

**********************************************************************/

#include "internal.h"
#include "internal/gc.h"
#include "ruby/debug.h"
#include "objspace.h"

struct traceobj_arg {
    int running;
    int keep_remains;
    VALUE newobj_trace;
    VALUE freeobj_trace;
    st_table *object_table; /* obj (VALUE) -> allocation_info */
    st_table *str_table;    /* cstr -> refcount */
    struct traceobj_arg *prev_traceobj_arg;
};

static const char *
make_unique_str(st_table *tbl, const char *str, long len)
{
    if (!str) {
        return NULL;
    }
    else {
        st_data_t n;
        char *result;

        if (st_lookup(tbl, (st_data_t)str, &n)) {
            st_insert(tbl, (st_data_t)str, n+1);
            st_get_key(tbl, (st_data_t)str, &n);
            result = (char *)n;
        }
        else {
            result = (char *)ruby_xmalloc(len+1);
            strncpy(result, str, len);
            result[len] = 0;
            st_add_direct(tbl, (st_data_t)result, 1);
        }
        return result;
    }
}

static void
delete_unique_str(st_table *tbl, const char *str)
{
    if (str) {
        st_data_t n;

        st_lookup(tbl, (st_data_t)str, &n);
        if (n == 1) {
            n = (st_data_t)str;
            st_delete(tbl, &n, 0);
            ruby_xfree((char *)n);
        }
        else {
            st_insert(tbl, (st_data_t)str, n-1);
        }
    }
}

static void
newobj_i(VALUE tpval, void *data)
{
    struct traceobj_arg *arg = (struct traceobj_arg *)data;
    rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
    VALUE obj = rb_tracearg_object(tparg);
    VALUE path = rb_tracearg_path(tparg);
    VALUE line = rb_tracearg_lineno(tparg);
    VALUE mid = rb_tracearg_method_id(tparg);
    VALUE klass = rb_tracearg_defined_class(tparg);
    struct allocation_info *info;
    const char *path_cstr = RTEST(path) ? make_unique_str(arg->str_table, RSTRING_PTR(path), RSTRING_LEN(path)) : 0;
    VALUE class_path = (RTEST(klass) && !OBJ_FROZEN(klass)) ? rb_class_path_cached(klass) : Qnil;
    const char *class_path_cstr = RTEST(class_path) ? make_unique_str(arg->str_table, RSTRING_PTR(class_path), RSTRING_LEN(class_path)) : 0;
    st_data_t v;

    if (st_lookup(arg->object_table, (st_data_t)obj, &v)) {
        info = (struct allocation_info *)v;
        if (arg->keep_remains) {
            if (info->living) {
                /* do nothing. there is possibility to keep living if FREEOBJ events while suppressing tracing */
            }
        }
        /* reuse info */
        delete_unique_str(arg->str_table, info->path);
        delete_unique_str(arg->str_table, info->class_path);
    }
    else {
        info = (struct allocation_info *)ruby_xmalloc(sizeof(struct allocation_info));
    }
    info->living = 1;
    info->flags = RBASIC(obj)->flags;
    info->klass = RBASIC_CLASS(obj);

    info->path = path_cstr;
    info->line = NUM2INT(line);
    info->mid = mid;
    info->class_path = class_path_cstr;
    info->generation = rb_gc_count();
    st_insert(arg->object_table, (st_data_t)obj, (st_data_t)info);
}

static void
freeobj_i(VALUE tpval, void *data)
{
    struct traceobj_arg *arg = (struct traceobj_arg *)data;
    rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
    st_data_t obj = (st_data_t)rb_tracearg_object(tparg);
    st_data_t v;
    struct allocation_info *info;

    /* Modifying the st table can cause allocations, which can trigger GC.
     * Since freeobj_i is called during GC, it must not trigger another GC. */
    VALUE gc_disabled = rb_gc_disable_no_rest();

    if (arg->keep_remains) {
        if (st_lookup(arg->object_table, obj, &v)) {
            info = (struct allocation_info *)v;
            info->living = 0;
        }
    }
    else {
        if (st_delete(arg->object_table, &obj, &v)) {
            info = (struct allocation_info *)v;
            delete_unique_str(arg->str_table, info->path);
            delete_unique_str(arg->str_table, info->class_path);
            ruby_xfree(info);
        }
    }

    if (gc_disabled == Qfalse) rb_gc_enable();
}

static int
free_keys_i(st_data_t key, st_data_t value, st_data_t data)
{
    ruby_xfree((void *)key);
    return ST_CONTINUE;
}

static int
free_values_i(st_data_t key, st_data_t value, st_data_t data)
{
    ruby_xfree((void *)value);
    return ST_CONTINUE;
}

static void
allocation_info_tracer_mark(void *ptr)
{
    struct traceobj_arg *trace_arg = (struct traceobj_arg *)ptr;
    rb_gc_mark(trace_arg->newobj_trace);
    rb_gc_mark(trace_arg->freeobj_trace);
}

static void
allocation_info_tracer_free(void *ptr)
{
    struct traceobj_arg *arg = (struct traceobj_arg *)ptr;
    /* clear tables */
    st_foreach(arg->object_table, free_values_i, 0);
    st_free_table(arg->object_table);
    st_foreach(arg->str_table, free_keys_i, 0);
    st_free_table(arg->str_table);
    xfree(arg);
}

static size_t
allocation_info_tracer_memsize(const void *ptr)
{
    size_t size;
    struct traceobj_arg *trace_arg = (struct traceobj_arg *)ptr;
    size = sizeof(*trace_arg);
    size += st_memsize(trace_arg->object_table);
    size += st_memsize(trace_arg->str_table);
    return size;
}

static int
hash_foreach_should_replace_key(st_data_t key, st_data_t value, st_data_t argp, int error)
{
    VALUE allocated_object;

    allocated_object = (VALUE)value;
    if (allocated_object != rb_gc_location(allocated_object)) {
        return ST_REPLACE;
    }

    return ST_CONTINUE;
}

static int
hash_replace_key(st_data_t *key, st_data_t *value, st_data_t argp, int existing)
{
    *key = rb_gc_location((VALUE)*key);

    return ST_CONTINUE;
}

static void
allocation_info_tracer_compact(void *ptr)
{
    struct traceobj_arg *trace_arg = (struct traceobj_arg *)ptr;

    if (trace_arg->object_table &&
            st_foreach_with_replace(trace_arg->object_table, hash_foreach_should_replace_key, hash_replace_key, 0)) {
        rb_raise(rb_eRuntimeError, "hash modified during iteration");
    }
}

static const rb_data_type_t allocation_info_tracer_type = {
    "ObjectTracing/allocation_info_tracer",
    {
        allocation_info_tracer_mark,
        allocation_info_tracer_free, /* Never called because global */
        allocation_info_tracer_memsize,
        allocation_info_tracer_compact,
    },
    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
};

static VALUE traceobj_arg;
static struct traceobj_arg *tmp_trace_arg; /* TODO: Do not use global variables */
static int tmp_keep_remains;               /* TODO: Do not use global variables */

static struct traceobj_arg *
get_traceobj_arg(void)
{
    if (tmp_trace_arg == 0) {
        VALUE obj = TypedData_Make_Struct(rb_cObject, struct traceobj_arg, &allocation_info_tracer_type, tmp_trace_arg);
        traceobj_arg = obj;
        rb_gc_register_mark_object(traceobj_arg);
        tmp_trace_arg->running = 0;
        tmp_trace_arg->keep_remains = tmp_keep_remains;
        tmp_trace_arg->newobj_trace = 0;
        tmp_trace_arg->freeobj_trace = 0;
        tmp_trace_arg->object_table = st_init_numtable();
        tmp_trace_arg->str_table = st_init_strtable();
    }
    return tmp_trace_arg;
}

/*
 * call-seq: trace_object_allocations_start
 *
 * Starts tracing object allocations.
 *
 */
static VALUE
trace_object_allocations_start(VALUE self)
{
    struct traceobj_arg *arg = get_traceobj_arg();

    if (arg->running++ > 0) {
        /* do nothing */
    }
    else {
        if (arg->newobj_trace == 0) {
            arg->newobj_trace = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, arg);
            arg->freeobj_trace = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, arg);
        }
        rb_tracepoint_enable(arg->newobj_trace);
        rb_tracepoint_enable(arg->freeobj_trace);
    }

    return Qnil;
}

/*
 * call-seq: trace_object_allocations_stop
 *
 * Stop tracing object allocations.
 *
 * Note that if ::trace_object_allocations_start is called n-times, then
 * tracing will stop after calling ::trace_object_allocations_stop n-times.
 *
 */
static VALUE
trace_object_allocations_stop(VALUE self)
{
    struct traceobj_arg *arg = get_traceobj_arg();

    if (arg->running > 0) {
        arg->running--;
    }

    if (arg->running == 0) {
        if (arg->newobj_trace != 0) {
            rb_tracepoint_disable(arg->newobj_trace);
        }
        if (arg->freeobj_trace != 0) {
            rb_tracepoint_disable(arg->freeobj_trace);
        }
    }

    return Qnil;
}

/*
 * call-seq: trace_object_allocations_clear
 *
 * Clear recorded tracing information.
 *
 */
static VALUE
trace_object_allocations_clear(VALUE self)
{
    struct traceobj_arg *arg = get_traceobj_arg();

    /* clear tables */
    st_foreach(arg->object_table, free_values_i, 0);
    st_clear(arg->object_table);
    st_foreach(arg->str_table, free_keys_i, 0);
    st_clear(arg->str_table);

    /* do not touch TracePoints */

    return Qnil;
}

/*
 * call-seq: trace_object_allocations { block }
 *
 * Starts tracing object allocations from the ObjectSpace extension module.
 *
 * For example:
 *
 *	require 'objspace'
 *
 *	class C
 *	  include ObjectSpace
 *
 *	  def foo
 *	    trace_object_allocations do
 *	      obj = Object.new
 *	      p "#{allocation_sourcefile(obj)}:#{allocation_sourceline(obj)}"
 *	    end
 *	  end
 *	end
 *
 *	C.new.foo #=> "objtrace.rb:8"
 *
 * This example has included the ObjectSpace module to make it easier to read,
 * but you can also use the ::trace_object_allocations notation (recommended).
 *
 * Note that this feature introduces a huge performance decrease and huge
 * memory consumption.
 */
static VALUE
trace_object_allocations(VALUE self)
{
    trace_object_allocations_start(self);
    return rb_ensure(rb_yield, Qnil, trace_object_allocations_stop, self);
}

int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
static int object_allocations_reporter_registered = 0;

static int
object_allocations_reporter_i(st_data_t key, st_data_t val, st_data_t ptr)
{
    FILE *out = (FILE *)ptr;
    VALUE obj = (VALUE)key;
    struct allocation_info *info = (struct allocation_info *)val;

    fprintf(out, "-- %p (%s F: %p, ", (void *)obj, info->living ? "live" : "dead", (void *)info->flags);
    if (info->class_path) fprintf(out, "C: %s", info->class_path);
    else                  fprintf(out, "C: %p", (void *)info->klass);
    fprintf(out, "@%s:%lu", info->path ? info->path : "", info->line);
    if (!NIL_P(info->mid)) {
        VALUE m = rb_sym2str(info->mid);
        fprintf(out, " (%s)", RSTRING_PTR(m));
    }
    fprintf(out, ")\n");

    return ST_CONTINUE;
}

static void
object_allocations_reporter(FILE *out, void *ptr)
{
    fprintf(out, "== object_allocations_reporter: START\n");
    if (tmp_trace_arg) {
        st_foreach(tmp_trace_arg->object_table, object_allocations_reporter_i, (st_data_t)out);
    }
    fprintf(out, "== object_allocations_reporter: END\n");
}

static VALUE
trace_object_allocations_debug_start(VALUE self)
{
    tmp_keep_remains = 1;
    if (object_allocations_reporter_registered == 0) {
        object_allocations_reporter_registered = 1;
        rb_bug_reporter_add(object_allocations_reporter, 0);
    }

    return trace_object_allocations_start(self);
}

static struct allocation_info *
lookup_allocation_info(VALUE obj)
{
    if (tmp_trace_arg) {
        st_data_t info;
        if (st_lookup(tmp_trace_arg->object_table, obj, &info)) {
            return (struct allocation_info *)info;
        }
    }
    return NULL;
}

struct allocation_info *
objspace_lookup_allocation_info(VALUE obj)
{
    return lookup_allocation_info(obj);
}

/*
 * call-seq: allocation_sourcefile(object) -> string
 *
 * Returns the source file origin from the given +object+.
 *
 * See ::trace_object_allocations for more information and examples.
 */
static VALUE
allocation_sourcefile(VALUE self, VALUE obj)
{
    struct allocation_info *info = lookup_allocation_info(obj);

    if (info && info->path) {
        return rb_str_new2(info->path);
    }
    else {
        return Qnil;
    }
}

/*
 * call-seq: allocation_sourceline(object) -> integer
 *
 * Returns the original line from source for from the given +object+.
 *
 * See ::trace_object_allocations for more information and examples.
 */
static VALUE
allocation_sourceline(VALUE self, VALUE obj)
{
    struct allocation_info *info = lookup_allocation_info(obj);

    if (info) {
        return INT2FIX(info->line);
    }
    else {
        return Qnil;
    }
}

/*
 * call-seq: allocation_class_path(object) -> string
 *
 * Returns the class for the given +object+.
 *
 *	class A
 *	  def foo
 *	    ObjectSpace::trace_object_allocations do
 *	      obj = Object.new
 *	      p "#{ObjectSpace::allocation_class_path(obj)}"
 *	    end
 *	  end
 *	end
 *
 *	A.new.foo #=> "Class"
 *
 * See ::trace_object_allocations for more information and examples.
 */
static VALUE
allocation_class_path(VALUE self, VALUE obj)
{
    struct allocation_info *info = lookup_allocation_info(obj);

    if (info && info->class_path) {
        return rb_str_new2(info->class_path);
    }
    else {
        return Qnil;
    }
}

/*
 * call-seq: allocation_method_id(object) -> string
 *
 * Returns the method identifier for the given +object+.
 *
 *	class A
 *	  include ObjectSpace
 *
 *	  def foo
 *	    trace_object_allocations do
 *	      obj = Object.new
 *	      p "#{allocation_class_path(obj)}##{allocation_method_id(obj)}"
 *	    end
 *	  end
 *	end
 *
 *	A.new.foo #=> "Class#new"
 *
 * See ::trace_object_allocations for more information and examples.
 */
static VALUE
allocation_method_id(VALUE self, VALUE obj)
{
    struct allocation_info *info = lookup_allocation_info(obj);
    if (info) {
        return info->mid;
    }
    else {
        return Qnil;
    }
}

/*
 * call-seq: allocation_generation(object) -> integer or nil
 *
 * Returns garbage collector generation for the given +object+.
 *
 *	class B
 *	  include ObjectSpace
 *
 *	  def foo
 *	    trace_object_allocations do
 *	      obj = Object.new
 *	      p "Generation is #{allocation_generation(obj)}"
 *	    end
 *	  end
 *	end
 *
 *	B.new.foo #=> "Generation is 3"
 *
 * See ::trace_object_allocations for more information and examples.
 */
static VALUE
allocation_generation(VALUE self, VALUE obj)
{
    struct allocation_info *info = lookup_allocation_info(obj);
    if (info) {
        return SIZET2NUM(info->generation);
    }
    else {
        return Qnil;
    }
}

void
Init_object_tracing(VALUE rb_mObjSpace)
{
#if 0
    rb_mObjSpace = rb_define_module("ObjectSpace"); /* let rdoc know */
#endif

    rb_define_module_function(rb_mObjSpace, "trace_object_allocations", trace_object_allocations, 0);
    rb_define_module_function(rb_mObjSpace, "trace_object_allocations_start", trace_object_allocations_start, 0);
    rb_define_module_function(rb_mObjSpace, "trace_object_allocations_stop", trace_object_allocations_stop, 0);
    rb_define_module_function(rb_mObjSpace, "trace_object_allocations_clear", trace_object_allocations_clear, 0);

    rb_define_module_function(rb_mObjSpace, "trace_object_allocations_debug_start", trace_object_allocations_debug_start, 0);

    rb_define_module_function(rb_mObjSpace, "allocation_sourcefile", allocation_sourcefile, 1);
    rb_define_module_function(rb_mObjSpace, "allocation_sourceline", allocation_sourceline, 1);
    rb_define_module_function(rb_mObjSpace, "allocation_class_path", allocation_class_path, 1);
    rb_define_module_function(rb_mObjSpace, "allocation_method_id", allocation_method_id, 1);
    rb_define_module_function(rb_mObjSpace, "allocation_generation", allocation_generation, 1);
}