ruby-prof 0.8.1-x86-mingw32 → 0.11.0.rc1-x86-mingw32

data/ext/ruby_prof/rp_method.h

@@ -0,0 +1,55 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_METHOD_INFO__
+#define __RP_METHOD_INFO__
+
+#include <ruby.h>
+
+#ifndef RUBY_VM
+#include <st.h>
+typedef st_data_t st_index_t;
+#endif
+
+extern VALUE cMethodInfo;
+
+/* A key used to identify each method */
+typedef struct 
+{
+    VALUE klass;                            /* The method's class. */
+    ID mid;                                 /* The method id. */
+    int depth;                              /* The recursion depth. */
+    st_index_t key;                         /* Cache calculated key */
+} prof_method_key_t;
+
+/* Forward declaration, see rp_call_info.h */
+struct prof_call_infos_t;
+
+/* Profiling information for each method. */
+typedef struct 
+{
+    prof_method_key_t *key;                 /* Method key */
+    const char *source_file;                /* The method's source file */
+    int line;                               /* The method's line number. */
+    struct prof_call_infos_t *call_infos;   /* Call info objects for this method */
+    VALUE object;                           /* Cached ruby object */
+} prof_method_t;
+
+void rp_init_method_info(void);
+
+st_table * method_table_create();
+prof_method_t * method_table_lookup(st_table *table, const prof_method_key_t* key);
+size_t method_table_insert(st_table *table, const prof_method_key_t *key, prof_method_t *val);
+void method_table_free(st_table *table);
+
+prof_method_t* prof_method_create(prof_method_key_t *key, const char* source_file, int line);
+VALUE prof_method_wrap(prof_method_t *result);
+void prof_method_mark(prof_method_t *method);
+
+/* Setup infrastructure to use method keys as hash comparisons */
+int method_table_cmp(prof_method_key_t *key1, prof_method_key_t *key2);
+st_index_t method_table_hash(prof_method_key_t *key);
+
+extern struct st_hash_type type_method_hash;
+
+#endif

data/ext/ruby_prof/rp_stack.c

@@ -0,0 +1,61 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "rp_stack.h"
+
+#define INITIAL_STACK_SIZE 8
+
+
+/* Creates a stack of prof_frame_t to keep track
+   of timings for active methods. */
+prof_stack_t *
+stack_create()
+{
+    prof_stack_t *stack = ALLOC(prof_stack_t);
+    stack->start = ALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
+    stack->ptr = stack->start;
+    stack->end = stack->start + INITIAL_STACK_SIZE;
+
+    return stack;
+}
+
+void
+stack_free(prof_stack_t *stack)
+{
+    xfree(stack->start);
+    xfree(stack);
+}
+
+prof_frame_t *
+stack_push(prof_stack_t *stack)
+{
+  /* Is there space on the stack?  If not, double
+     its size. */
+  if (stack->ptr == stack->end  )   
+  {
+    size_t len = stack->ptr - stack->start;
+    size_t new_capacity = (stack->end - stack->start) * 2;
+    REALLOC_N(stack->start, prof_frame_t, new_capacity);
+    stack->ptr = stack->start + len;
+    stack->end = stack->start + new_capacity;
+  }
+  return stack->ptr++;
+}
+
+prof_frame_t *
+stack_pop(prof_stack_t *stack)
+{
+    if (stack->ptr == stack->start)
+      return NULL;
+    else
+      return --stack->ptr;
+}
+
+prof_frame_t *
+stack_peek(prof_stack_t *stack)
+{
+    if (stack->ptr == stack->start)
+      return NULL;
+    else
+      return stack->ptr - 1;
+}

data/ext/ruby_prof/rp_stack.h

@@ -0,0 +1,40 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_STACK__
+#define __RP_STACK__
+
+#include <ruby.h>
+
+#include "rp_measure.h"
+#include "rp_call_info.h"
+
+
+/* Temporary object that maintains profiling information
+   for active methods - there is one per method.*/
+typedef struct 
+{
+    /* Caching prof_method_t values significantly
+       increases performance. */
+    prof_call_info_t *call_info;
+    double start_time;
+    double wait_time;
+    double child_time;
+    unsigned int line;
+} prof_frame_t;
+
+/* Current stack of active methods.*/
+typedef struct 
+{
+    prof_frame_t *start;
+    prof_frame_t *end;
+    prof_frame_t *ptr;
+} prof_stack_t;
+
+prof_stack_t * stack_create();
+void stack_free(prof_stack_t *stack);
+prof_frame_t * stack_push(prof_stack_t *stack);
+prof_frame_t * stack_pop(prof_stack_t *stack);
+prof_frame_t * stack_peek(prof_stack_t *stack);
+
+#endif //__RP_STACK__

data/ext/ruby_prof/rp_thread.c

@@ -0,0 +1,113 @@
+/* Copyright (C) 2005-2011 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"
+
+/* ======   thread_data_t  ====== */
+thread_data_t*
+thread_data_create(double measure)
+{
+    thread_data_t* result = ALLOC(thread_data_t);
+    result->stack = stack_create();
+    result->method_table = method_table_create();
+    result->last_switch = measure;
+    return result;
+}
+
+void
+thread_data_free(thread_data_t* thread_data)
+{
+    method_table_free(thread_data->method_table);
+    stack_free(thread_data->stack);
+    xfree(thread_data);
+}
+
+
+/* ======   Thread Table  ====== */
+/* The thread table is hash keyed on ruby thread_id that stores instances
+   of thread_data_t. */
+
+st_table *
+threads_table_create()
+{
+    return st_init_numtable();
+}
+
+size_t
+threads_table_insert(prof_profile_t* profile, VALUE thread, thread_data_t *thread_data)
+{
+    /* Its too slow to key on the real thread id so just typecast thread instead. */
+    return st_insert(profile->threads_tbl, (st_data_t) thread, (st_data_t) thread_data);
+}
+
+thread_data_t *
+threads_table_lookup(prof_profile_t* profile, VALUE thread_id)
+{
+    thread_data_t* result;
+    st_data_t val;
+
+    /* Its too slow to key on the real thread id so just typecast thread instead. */
+    if (st_lookup(profile->threads_tbl, (st_data_t) thread_id, &val))
+    {
+      result = (thread_data_t *) val;
+    }
+    else
+    {
+        result = thread_data_create(profile->measurer->measure());
+        result->thread_id = thread_id;
+
+        /* Insert the table */
+        threads_table_insert(profile, thread_id, result);
+    }
+    return result;
+}
+
+int
+free_thread_data(st_data_t key, st_data_t value, st_data_t dummy)
+{
+    thread_data_free((thread_data_t*)value);
+    return ST_CONTINUE;
+}
+
+void
+threads_table_free(st_table *table)
+{
+    st_foreach(table, free_thread_data, 0);
+    st_free_table(table);
+}
+
+thread_data_t *
+switch_thread(void* prof, VALUE thread_id)
+{
+	prof_profile_t* profile = (prof_profile_t*)prof;
+    prof_frame_t *frame = NULL;
+    double wait_time = 0;
+
+    /* Get new thread information. */
+    thread_data_t *thread_data = threads_table_lookup(profile, thread_id);
+
+    /* How long has this thread been waiting? */
+    wait_time = profile->measurement - thread_data->last_switch;
+
+    thread_data->last_switch = profile->measurement; // XXXX a test that fails if this is 0
+
+    /* Get the frame at the top of the stack.  This may represent
+       the current method (EVENT_LINE, EVENT_RETURN)  or the
+       previous method (EVENT_CALL).*/
+    frame = stack_peek(thread_data->stack);
+
+    if (frame)
+	{
+      frame->wait_time += wait_time;
+    }
+
+    /* Save on the last thread the time of the context switch
+       and reset this thread's last context switch to 0.*/
+    if (profile->last_thread_data)
+	{
+      profile->last_thread_data->last_switch = profile->measurement;
+    }
+
+    profile->last_thread_data = thread_data;
+    return thread_data;
+}

data/ext/ruby_prof/rp_thread.h

@@ -0,0 +1,20 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_THREAD__
+#define __RP_THREAD__
+
+/* Profiling information for a thread. */
+typedef struct 
+{
+    VALUE thread_id;                  /* Thread id */
+    st_table* method_table;           /* Methods called in the thread */
+    prof_stack_t* stack;              /* Active methods */
+    double last_switch;       /* Point of last context switch */
+} thread_data_t;
+
+st_table * threads_table_create();
+thread_data_t* switch_thread(void* prof, VALUE thread_id);
+void threads_table_free(st_table *table);
+
+#endif //__RP_THREAD__

data/ext/ruby_prof/ruby_prof.c

@@ -1,858 +1,66 @@
-/*
- * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
- *                     Charlie Savage <cfis@savagexi.com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
 
 /* ruby-prof tracks the time spent executing every method in ruby programming.
    The main players are:
 
-     prof_result_t     - Its one field, values,  contains the overall results
-     thread_data_t     - Stores data about a single thread.  
+     profile_t         - This represents 1 profile.
+     thread_data_t     - Stores data about a single thread.
      prof_stack_t      - The method call stack in a particular thread
-     prof_method_t     - Profiling information for each method
-     prof_call_info_t  - Keeps track a method's callers and callees. 
+     prof_method_t     - Profiling information about each method
+     prof_call_info_t  - Keeps track a method's callers and callees.
+
+  The final result is an instance of a profile object which has a hash table of
+  thread_data_t, keyed on the thread id.  Each thread in turn has a hash table
+  of prof_method_t, keyed on the method id.  A hash table is used for quick 
+  look up when doing a profile.  However, it is exposed to Ruby as an array.
 
-  The final resulut is a hash table of thread_data_t, keyed on the thread
-  id.  Each thread has an hash a table of prof_method_t, keyed on the
-  method id.  A hash table is used for quick look up when doing a profile.
-  However, it is exposed to Ruby as an array.
-  
   Each prof_method_t has two hash tables, parent and children, of prof_call_info_t.
   These objects keep track of a method's callers (who called the method) and its
   callees (who the method called).  These are keyed the method id, but once again,
   are exposed to Ruby as arrays.  Each prof_call_into_t maintains a pointer to the
-  caller or callee method, thereby making it easy to navigate through the call 
-  hierarchy in ruby - which is very helpful for creating call graphs.      
+  caller or callee method, thereby making it easy to navigate through the call
+  hierarchy in ruby - which is very helpful for creating call graphs.
 */
 
 #include "ruby_prof.h"
 #include <stdio.h>
 #include <assert.h>
 
-/* ================  Helper Functions  =================*/
-static VALUE
-figure_singleton_name(VALUE klass)
-{
-    VALUE result = Qnil;
-
-    /* We have come across a singleton object. First
-       figure out what it is attached to.*/
-    VALUE attached = rb_iv_get(klass, "__attached__");
-
-    /* Is this a singleton class acting as a metaclass? */
-    if (BUILTIN_TYPE(attached) == T_CLASS)
-    {
-        result = rb_str_new2("<Class::");
-        rb_str_append(result, rb_inspect(attached));
-        rb_str_cat2(result, ">");
-    }
+VALUE mProf;
+VALUE cProfile;
 
-    /* Is this for singleton methods on a module? */
-    else if (BUILTIN_TYPE(attached) == T_MODULE)
-    {
-        result = rb_str_new2("<Module::");
-        rb_str_append(result, rb_inspect(attached));
-        rb_str_cat2(result, ">");
-    }
-
-    /* Is this for singleton methods on an object? */
-    else if (BUILTIN_TYPE(attached) == T_OBJECT)
-    {
-        /* Make sure to get the super class so that we don't
-           mistakenly grab a T_ICLASS which would lead to
-           unknown method errors. */
-#ifdef RCLASS_SUPER
-        VALUE super = rb_class_real(RCLASS_SUPER(klass));
-#else
-        VALUE super = rb_class_real(RCLASS(klass)->super);
+#ifndef RUBY_VM
+/* Global variable to hold current profile - needed 
+   prior to Ruby 1.9 */
+static prof_profile_t* pCurrentProfile;
 #endif
-        result = rb_str_new2("<Object::");
-        rb_str_append(result, rb_inspect(super));
-        rb_str_cat2(result, ">");
-    }
-    
-    /* Ok, this could be other things like an array made put onto
-       a singleton object (yeah, it happens, see the singleton
-       objects test case). */
-    else
-    {
-        result = rb_inspect(klass);
-    }
-
-    return result;
-}
-
-static VALUE
-klass_name(VALUE klass)
-{
-    VALUE result = Qnil;
-    
-    if (klass == 0 || klass == Qnil)
-    {
-        result = rb_str_new2("Global");
-    }
-    else if (BUILTIN_TYPE(klass) == T_MODULE)
-    {
-        result = rb_inspect(klass);
-    }
-    else if (BUILTIN_TYPE(klass) == T_CLASS && FL_TEST(klass, FL_SINGLETON))
-    {
-        result = figure_singleton_name(klass);
-    }
-    else if (BUILTIN_TYPE(klass) == T_CLASS)
-    {
-        result = rb_inspect(klass);
-    }
-    else
-    {
-        /* Should never happen. */
-        result = rb_str_new2("Unknown");
-    }
 
-    return result;
-}
-
-static VALUE
-method_name(ID mid, int depth)
+static prof_profile_t*
+prof_get_profile(VALUE self)
 {
-    VALUE result;
-
-    if (mid == ID_ALLOCATOR) 
-        result = rb_str_new2("allocate");
-    else if (mid == 0)
-        result = rb_str_new2("[No method]");
-    else
-        result = rb_String(ID2SYM(mid));
-    
-    if (depth > 0)
-    {
-      char buffer[65];
-      sprintf(buffer, "(d%i)", depth);
-      rb_str_cat2(result, buffer);
-    }
-
-    return result;
-}
-
-static VALUE
-full_name(VALUE klass, ID mid, int depth)
-{
-  VALUE result = klass_name(klass);
-  rb_str_cat2(result, "#");
-  rb_str_append(result, method_name(mid, depth));
-  
-  return result;
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+    return (prof_profile_t*)RDATA(self)->data;
 }
 
-/* ================  Stack Handling   =================*/
-/* Creates a stack of prof_frame_t to keep track
-   of timings for active methods. */
-static prof_stack_t *
-stack_create()
-{
-    prof_stack_t *stack = ALLOC(prof_stack_t);
-    stack->start = ALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);
-    stack->ptr = stack->start;
-    stack->end = stack->start + INITIAL_STACK_SIZE;
-    return stack;
-}
-
-static void
-stack_free(prof_stack_t *stack)
-{
-    xfree(stack->start);
-    xfree(stack);
-}
-
-static prof_frame_t *
-stack_push(prof_stack_t *stack)
-{
-  /* Is there space on the stack?  If not, double
-     its size. */
-  if (stack->ptr == stack->end)
-  {
-    size_t len = stack->ptr - stack->start;
-    size_t new_capacity = (stack->end - stack->start) * 2;
-    REALLOC_N(stack->start, prof_frame_t, new_capacity);
-    stack->ptr = stack->start + len;
-    stack->end = stack->start + new_capacity;
-  }
-  return stack->ptr++;
-}
-
-static prof_frame_t *
-stack_pop(prof_stack_t *stack)
-{
-    if (stack->ptr == stack->start)
-      return NULL;
-    else
-      return --stack->ptr;
-}
-
-static prof_frame_t *
-stack_peek(prof_stack_t *stack)
-{
-    if (stack->ptr == stack->start)
-      return NULL;
-    else
-      return stack->ptr - 1;
-}
-
-/* ================  Method Key   =================*/
-static int 
-method_table_cmp(prof_method_key_t *key1, prof_method_key_t *key2) 
-{
-    return (key1->klass != key2->klass) || 
-           (key1->mid != key2->mid) || 
-           (key1->depth != key2->depth);
-}
-
-static int 
-method_table_hash(prof_method_key_t *key) 
-{
-   return key->key;
-}
-
-static struct st_hash_type type_method_hash = {
-    method_table_cmp,
-    method_table_hash
-};
-
-static void
-method_key(prof_method_key_t* key, VALUE klass, ID mid, int depth)
+void
+method_key(prof_method_key_t* key, VALUE klass, ID mid)
 {
     key->klass = klass;
     key->mid = mid;
-    key->depth = depth;
-    key->key = (klass << 4) + (mid << 2) + depth;
-}
-
-
-/* ================  Call Info   =================*/
-static st_table *
-call_info_table_create()
-{
-  return st_init_table(&type_method_hash);
-}
-
-static size_t
-call_info_table_insert(st_table *table, const prof_method_key_t *key, prof_call_info_t *val)
-{
-  return st_insert(table, (st_data_t) key, (st_data_t) val);
-}
-
-static prof_call_info_t *
-call_info_table_lookup(st_table *table, const prof_method_key_t *key)
-{
-    st_data_t val;
-    if (st_lookup(table, (st_data_t) key, &val))
-    {
-      return (prof_call_info_t *) val;
-    }
-    else
-    {
-      return NULL;
-    }
-}
-
-static void
-call_info_table_free(st_table *table)
-{
-    st_free_table(table);
-}
-
-/* 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. */
-
-/* :nodoc: */
-static prof_call_info_t *
-prof_call_info_create(prof_method_t* method, prof_call_info_t* parent)
-{
-    prof_call_info_t *result = ALLOC(prof_call_info_t);
-    result->object = Qnil;
-    result->target = method;
-    result->parent = parent;
-    result->call_infos = call_info_table_create();
-    result->children = Qnil;
-
-    result->called = 0;
-    result->total_time = 0;
-    result->self_time = 0;
-    result->wait_time = 0;
-    result->line = 0;
-    return result;
-}
-
-static void prof_method_mark(prof_method_t *method);
-
-static void
-prof_call_info_mark(prof_call_info_t *call_info)
-{
-  {
-    VALUE target = call_info->target->object;
-    if (NIL_P(target))
-      prof_method_mark(call_info->target);
-    else
-      rb_gc_mark(target);
-  }
-  rb_gc_mark(call_info->children);
-  if (call_info->parent) {
-    VALUE parent = call_info->parent->object;
-    if (NIL_P(parent)) {
-      prof_call_info_mark(call_info->parent);
-    }
-    else {
-      rb_gc_mark(parent);
-    }
-  }
-}
-
-static void
-prof_call_info_free(prof_call_info_t *call_info)
-{
-  call_info_table_free(call_info->call_infos); 
-  xfree(call_info);
-}
-
-static 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_free, call_info);
-  }
-  return call_info->object;
-}
-
-static prof_call_info_t *
-prof_get_call_info_result(VALUE obj)
-{
-    if (BUILTIN_TYPE(obj) != T_DATA)
-    {
-        /* Should never happen */
-      rb_raise(rb_eTypeError, "Not a call info object");
-    }
-    return (prof_call_info_t *) DATA_PTR(obj);
-}
-
-
-/* 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_result(self);
-    return prof_method_wrap(result->target);
-}
-
-/* call-seq:
-   called -> int
-
-Returns the total amount of times this method was called. */
-static VALUE
-prof_call_info_called(VALUE self)
-{
-    prof_call_info_t *result = prof_get_call_info_result(self);
-    return INT2NUM(result->called);
-}
-
-/* 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_result(self);
-  return rb_int_new(result->line);
-}
-
-/* call-seq:
-   total_time -> float
-
-Returns the total amount of time spent in this method and its children. */
-static VALUE
-prof_call_info_total_time(VALUE self)
-{
-    prof_call_info_t *result = prof_get_call_info_result(self);
-    return rb_float_new(convert_measurement(result->total_time));
-}
-
-/* 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_result(self);
-
-    return rb_float_new(convert_measurement(result->self_time));
-}
-
-/* call-seq:
-   wait_time -> float
-
-Returns the total amount of time this method waited for other threads. */
-static VALUE
-prof_call_info_wait_time(VALUE self)
-{
-    prof_call_info_t *result = prof_get_call_info_result(self);
-
-    return rb_float_new(convert_measurement(result->wait_time));
-}
-
-/* call-seq:
-   parent -> call_info
-
-Returns the call_infos parent call_info object (the method that called this method).*/
-static VALUE
-prof_call_info_parent(VALUE self)
-{
-    prof_call_info_t *result = prof_get_call_info_result(self);
-    if (result->parent)
-      return prof_call_info_wrap(result->parent);
-    else
-      return Qnil;
-}
-
-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;
-}
-
-/* call-seq:
-   children -> hash
-
-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_result(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;
-}
-
-/* ================  Call Infos   =================*/
-static 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;
-}
-
-static void
-prof_call_infos_free(prof_call_infos_t *call_infos)
-{
-  xfree(call_infos->start);
-  xfree(call_infos);
-}
-
-static 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++;
-}
-
-static 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;
-}
-
-
-/* ================  Method Info   =================*/
-/* Document-class: RubyProf::MethodInfo
-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::Result object.
-*/
-
-static prof_method_t*
-prof_method_create(prof_method_key_t *key, const char* source_file, int line)
-{
-    prof_method_t *result = ALLOC(prof_method_t);
-    result->object = Qnil;
-    result->key = ALLOC(prof_method_key_t);
-    method_key(result->key, key->klass, key->mid, key->depth);   
-
-    result->call_infos = prof_call_infos_create();
-
-    result->active = 0;
-
-    if (source_file != NULL) 
-    {
-      int len = strlen(source_file) + 1;    
-      char *buffer = ALLOC_N(char, len);
-
-      MEMCPY(buffer, source_file, char, len);
-      result->source_file = buffer;
-    }
-    else 
-    {    
-      result->source_file = source_file;
-    }      
-    result->line = line;
-
-    return result;
-}
-
-static void
-prof_method_mark(prof_method_t *method)
-{
-  rb_gc_mark(method->call_infos->object);
-  rb_gc_mark(method->key->klass);
-}
-
-static void
-prof_method_free(prof_method_t *method)
-{
-  if (method->source_file)
-  {
-    xfree((char*)method->source_file);    
-  }
-
-  prof_call_infos_free(method->call_infos);
-  xfree(method->key);
-  xfree(method);
-}
-
-static VALUE
-prof_method_wrap(prof_method_t *result)
-{
-  if (result->object == Qnil)
-  {
-    result->object = Data_Wrap_Struct(cMethodInfo, prof_method_mark, prof_method_free, result);
-  }
-  return result->object;
-}
-
-static prof_method_t *
-get_prof_method(VALUE obj)
-{
-    return (prof_method_t *) DATA_PTR(obj);
-}
-
-/* call-seq:
-   line_no -> int
-
-   returns the line number of the method */
-static VALUE
-prof_method_line(VALUE self)
-{
-    return rb_int_new(get_prof_method(self)->line);
-}
-
-/* call-seq:
-   source_file => string
-
-return the source file of the method 
-*/
-static VALUE prof_method_source_file(VALUE self)
-{
-    const char* sf = get_prof_method(self)->source_file;
-    if(!sf)
-    {
-      return rb_str_new2("ruby_runtime");
-    }
-    else
-    {
-      return rb_str_new2(sf);
-    }
-}
-
-
-/* call-seq:
-   method_class -> klass
-
-Returns the Ruby klass that owns this method. */
-static VALUE
-prof_method_klass(VALUE self)
-{
-    prof_method_t *result = get_prof_method(self);
-    return result->key->klass;
-}
-
-/* call-seq:
-   method_id -> ID
-
-Returns the id of this method. */
-static VALUE
-prof_method_id(VALUE self)
-{
-    prof_method_t *result = get_prof_method(self);
-    return ID2SYM(result->key->mid);
-}
-
-/* call-seq:
-   klass_name -> string
-
-Returns the name of this method's class.  Singleton classes
-will have the form <Object::Object>. */
-
-static VALUE
-prof_klass_name(VALUE self)
-{
-    prof_method_t *method = get_prof_method(self);
-    return klass_name(method->key->klass);
-}
-
-/* call-seq:
-   method_name -> string
-
-Returns the name of this method in the format Object#method.  Singletons
-methods will be returned in the format <Object::Object>#method.*/
-
-static VALUE
-prof_method_name(VALUE self, int depth)
-{
-    prof_method_t *method = get_prof_method(self);
-    return method_name(method->key->mid, depth);
-}
-
-/* call-seq:
-   full_name -> string
-
-Returns the full name of this method in the format Object#method.*/
-
-static VALUE
-prof_full_name(VALUE self)
-{
-    prof_method_t *method = get_prof_method(self);
-    return full_name(method->key->klass, method->key->mid, method->key->depth);
-}
-
-/* call-seq:
-   call_infos -> Array of call_info
-
-Returns an array of call info objects that contain profiling information 
-about the current method.*/
-static VALUE
-prof_method_call_infos(VALUE self)
-{
-    prof_method_t *method = get_prof_method(self);
-    return prof_call_infos_wrap(method->call_infos);
-}
-
-static int
-collect_methods(st_data_t key, st_data_t value, st_data_t result)
-{
-    /* Called for each method stored in a thread's method table. 
-       We want to store the method info information into an array.*/
-    VALUE methods = (VALUE) result;
-    prof_method_t *method = (prof_method_t *) value;
-    rb_ary_push(methods, prof_method_wrap(method));
-
-    /* Wrap call info objects */
-    prof_call_infos_wrap(method->call_infos);
-
-    return ST_CONTINUE;
-}
-
-/* ================  Method Table   =================*/
-static st_table *
-method_table_create()
-{
-  return st_init_table(&type_method_hash);
-}
-
-static size_t
-method_table_insert(st_table *table, const prof_method_key_t *key, prof_method_t *val)
-{
-  return st_insert(table, (st_data_t) key, (st_data_t) val);
-}
-
-static prof_method_t *
-method_table_lookup(st_table *table, const prof_method_key_t* key)
-{
-    st_data_t val;
-    if (st_lookup(table, (st_data_t)key, &val))
-    {
-      return (prof_method_t *) val;
-    }
-    else 
-    {
-      return NULL;
-    }
-}
-
-
-static void
-method_table_free(st_table *table)
-{
-    /* Don't free the contents since they are wrapped by
-       Ruby objects! */
-    st_free_table(table);
-}
-
-
-/* ================  Thread Handling   =================*/
-
-/* ---- Keeps track of thread's stack and methods ---- */
-static thread_data_t*
-thread_data_create()
-{
-    thread_data_t* result = ALLOC(thread_data_t);
-    result->stack = stack_create();
-    result->method_table = method_table_create();
-    result->last_switch = get_measurement();
-    return result;
-}
-
-static void
-thread_data_free(thread_data_t* thread_data)
-{
-    method_table_free(thread_data->method_table);
-    stack_free(thread_data->stack);
-    xfree(thread_data);
-}
-
-/* ---- Hash, keyed on thread, that stores thread's stack
-        and methods---- */
-
-static st_table *
-threads_table_create()
-{
-    return st_init_numtable();
-}
-
-static size_t
-threads_table_insert(st_table *table, VALUE thread, thread_data_t *thread_data)
-{
-    /* Its too slow to key on the real thread id so just typecast thread instead. */
-    return st_insert(table, (st_data_t) thread, (st_data_t) thread_data);
-}
-
-static thread_data_t *
-threads_table_lookup(st_table *table, VALUE thread_id)
-{
-    thread_data_t* result;
-    st_data_t val;
-
-    /* Its too slow to key on the real thread id so just typecast thread instead. */
-    if (st_lookup(table, (st_data_t) thread_id, &val))
-    {
-      result = (thread_data_t *) val;
-    }
-    else
-    {
-        result = thread_data_create();
-        result->thread_id = thread_id;
-
-        /* Insert the table */
-        threads_table_insert(threads_tbl, thread_id, result);
-    }
-    return result;
-}
-
-static int
-free_thread_data(st_data_t key, st_data_t value, st_data_t dummy)
-{
-    thread_data_free((thread_data_t*)value);
-    return ST_CONTINUE;
-}
-
-
-static void
-threads_table_free(st_table *table)
-{
-    st_foreach(table, free_thread_data, 0);
-    st_free_table(table);
-}
-
-
-static int
-collect_threads(st_data_t key, st_data_t value, st_data_t result)
-{
-    /* Although threads are keyed on an id, that is actually a 
-       pointer to the VALUE object of the thread.  So its bogus.
-       However, in thread_data is the real thread id stored
-       as an int. */
-    thread_data_t* thread_data = (thread_data_t*) value;
-    VALUE threads_hash = (VALUE) result;
-
-    VALUE methods = rb_ary_new();
-
-    /* Now collect an array of all the called methods */
-    st_table* method_table = thread_data->method_table;
-    st_foreach(method_table, collect_methods, methods);
- 
-    /* Store the results in the threads hash keyed on the thread id. */
-    rb_hash_aset(threads_hash, thread_data->thread_id, methods);
-
-    return ST_CONTINUE;
+    key->key = (klass << 4) + (mid << 2);
 }
 
+/* support tracing ruby events from ruby-prof. useful for getting at
+   what actually happens inside the ruby interpreter (and ruby-prof).
+   set environment variable RUBY_PROF_TRACE to filename you want to
+   find the trace in.
+ */
+static FILE* trace_file = NULL;
 
-/* ================  Profiling    =================*/
-/* Copied from eval.c */
-#ifdef DEBUG
-static char *
+/* Copied from eval.c (1.8.x) / thread.c (1.9.2) */
+static const char *
 get_event_name(rb_event_flag_t event)
 {
   switch (event) {
@@ -872,43 +80,43 @@ get_event_name(rb_event_flag_t event)
   return "c-return";
     case RUBY_EVENT_RAISE:
   return "raise";
-  
+
 #ifdef RUBY_VM
     case RUBY_EVENT_SWITCH:
   return "thread-interrupt";
 #endif
-  
+
     default:
   return "unknown";
   }
 }
-#endif
 
-static prof_method_t* 
+
+static prof_method_t*
 #ifdef RUBY_VM
- get_method(rb_event_flag_t event, VALUE klass, ID mid, int depth, st_table* method_table)
+ get_method(rb_event_flag_t event, VALUE klass, ID mid, st_table* method_table)
 # else
- get_method(rb_event_flag_t event, NODE *node, VALUE klass, ID mid, int depth, st_table* method_table)
-#endif 
+ get_method(rb_event_flag_t event, NODE *node, VALUE klass, ID mid, st_table* method_table)
+#endif
 {
     prof_method_key_t key;
     prof_method_t *method = NULL;
-    
-    method_key(&key, klass, mid, depth);
+
+    method_key(&key, klass, mid);
     method = method_table_lookup(method_table, &key);
 
     if (!method)
     {
       const char* source_file = rb_sourcefile();
       int line = rb_sourceline();
-      
+
       /* Line numbers are not accurate for c method calls */
       if (event == RUBY_EVENT_C_CALL)
       {
         line = 0;
         source_file = NULL;
       }
-        
+
       method = prof_method_create(&key, source_file, line);
       method_table_insert(method_table, method->key, method);
     }
@@ -916,62 +124,30 @@ static prof_method_t*
 }
 
 static void
-update_result(prof_measure_t total_time,
-              prof_frame_t *parent_frame, 
+update_result(double total_time,
+              prof_frame_t *parent_frame,
               prof_frame_t *frame)
 {
-    prof_measure_t self_time = total_time - frame->child_time - frame->wait_time;
+    double self_time = total_time - frame->child_time - frame->wait_time;
     prof_call_info_t *call_info = frame->call_info;
-    
+
     /* Update information about the current method */
     call_info->called++;
     call_info->total_time += total_time;
     call_info->self_time += self_time;
     call_info->wait_time += frame->wait_time;
-    
+
     /* Note where the current method was called from */
     if (parent_frame)
       call_info->line = parent_frame->line;
 }
 
-static thread_data_t *
-switch_thread(VALUE thread_id, prof_measure_t now)
-{
-	prof_frame_t *frame = NULL;
-	prof_measure_t wait_time = 0;
-    /* Get new thread information. */
-    thread_data_t *thread_data = threads_table_lookup(threads_tbl, thread_id);
-
-    /* How long has this thread been waiting? */
-    wait_time = now - thread_data->last_switch;
-    
-    thread_data->last_switch = now; // XXXX a test that fails if this is 0
-
-    /* Get the frame at the top of the stack.  This may represent
-       the current method (EVENT_LINE, EVENT_RETURN)  or the
-       previous method (EVENT_CALL).*/
-    frame = stack_peek(thread_data->stack);
-  
-    if (frame) {
-      frame->wait_time += wait_time;
-    }
-      
-    /* Save on the last thread the time of the context switch
-       and reset this thread's last context switch to 0.*/
-    if (last_thread_data) {
-      last_thread_data->last_switch = now;   
-    }
-      
-    last_thread_data = thread_data;
-    return thread_data;
-}
-
 static prof_frame_t*
-pop_frame(thread_data_t *thread_data, prof_measure_t now)
+pop_frame(prof_profile_t* profile, thread_data_t *thread_data)
 {
   prof_frame_t *frame = NULL;
   prof_frame_t* parent_frame = NULL;
-  prof_measure_t total_time;
+  double total_time;
 
   frame = stack_pop(thread_data->stack); // only time it's called
   /* Frame can be null.  This can happen if RubProf.start is called from
@@ -981,56 +157,44 @@ pop_frame(thread_data_t *thread_data, prof_measure_t now)
   if (frame == NULL) return NULL;
 
   /* Calculate the total time this method took */
-  total_time = now - frame->start_time;
-
-  /* Now deactivate the method */
-  frame->call_info->target->active = 0;
+  total_time = profile->measurement - frame->start_time;
 
   parent_frame = stack_peek(thread_data->stack);
   if (parent_frame)
   {
-  	parent_frame->child_time += total_time;
+        parent_frame->child_time += total_time;
   }
-    
+
   update_result(total_time, parent_frame, frame); // only time it's called
   return frame;
 }
 
-static int 
-pop_frames(st_data_t key, st_data_t value, st_data_t now_arg)
+static int
+pop_frames(st_data_t key, st_data_t value, st_data_t data)
 {
     VALUE thread_id = (VALUE)key;
     thread_data_t* thread_data = (thread_data_t *) value;
-    prof_measure_t now = *(prof_measure_t *) now_arg;
+    prof_profile_t* profile = (prof_profile_t*) data;
 
-    if (!last_thread_data || last_thread_data->thread_id != thread_id)
-      thread_data = switch_thread(thread_id, now);
+    if (!profile->last_thread_data || profile->last_thread_data->thread_id != thread_id)
+      thread_data = switch_thread(profile, thread_id);
     else
-      thread_data = last_thread_data;
+      thread_data = profile->last_thread_data;
 
-    while (pop_frame(thread_data, now))
+    while (pop_frame(profile, thread_data))
     {
     }
-    
+
     return ST_CONTINUE;
 }
 
-static void 
-prof_pop_threads()
+static void
+prof_pop_threads(prof_profile_t* profile)
 {
-    /* Get current measurement */
-    prof_measure_t now = get_measurement();
-    st_foreach(threads_tbl, pop_frames, (st_data_t) &now);
+    st_foreach(profile->threads_tbl, pop_frames, (st_data_t) profile);
 }
 
-
 #ifdef RUBY_VM
-
-/* These are mostly to avoid bugs in core */
-static inline void walk_up_until_right_frame(prof_frame_t *frame, thread_data_t* thread_data, ID mid, VALUE klass, prof_measure_t now);
-void prof_install_hook();
-void prof_remove_hook();
-
 static void
 prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
 #else
@@ -1038,9 +202,14 @@ static void
 prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 #endif
 {
-    VALUE thread = Qnil;
+#ifndef RUBY_VM
+    prof_profile_t* profile = pCurrentProfile;
+#else
+    prof_profile_t* profile = prof_get_profile(data);
+#endif	
+	
+	VALUE thread = Qnil;
     VALUE thread_id = Qnil;
-    prof_measure_t now = 0;
     thread_data_t* thread_data = NULL;
     prof_frame_t *frame = NULL;
 
@@ -1051,13 +220,10 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
       }
     #endif
 
-    /* Get current timestamp */
-    now = get_measurement();
+    /* Get current measurement */
+    profile->measurement = profile->measurer->measure();
 
-#ifdef DEBUG
-    /*  This code is here for debug purposes - uncomment it out
-        when debugging to see a print out of exactly what the
-        profiler is tracing. */
+    if (trace_file != NULL)
     {
         static VALUE last_thread_id = Qnil;
 
@@ -1068,7 +234,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         const char* source_file = rb_sourcefile();
         unsigned int source_line = rb_sourceline();
 
-        char* event_name = get_event_name(event);
+        const char* event_name = get_event_name(event);
 
         if (klass != 0)
           klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
@@ -1076,69 +242,53 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         class_name = rb_class2name(klass);
 
         if (last_thread_id != thread_id) {
-          printf("\n");
+          fprintf(trace_file, "\n");
         }
-        
-        printf("%2u:%2ums %-8s %s:%2d  %s#%s\n",
-               (unsigned int) thread_id, (unsigned int) now, event_name, source_file, source_line, class_name, method_name);
-        fflush(stdout);
-        last_thread_id = thread_id;               
+
+        fprintf(trace_file, "%2u:%2ums %-8s %s:%2d  %s#%s\n",
+               (unsigned int) thread_id, (unsigned int) profile->measurement, event_name, source_file, source_line, class_name, method_name);
+        /* fflush(trace_file); */
+        last_thread_id = thread_id;
     }
-#endif
-    
-    /* Special case - skip any methods from the mProf 
-       module, such as Prof.stop, since they clutter
+
+    /* Special case - skip any methods from the mProf
+       module or cProfile class since they clutter
        the results but aren't important to them results. */
-    if (self == mProf) return;
+    if (self == mProf || klass == cProfile) return;
 
     /* Get the current thread information. */
     thread = rb_thread_current();
     thread_id = rb_obj_id(thread);
-    
-   # ifdef RUBY_VM
-     /* ensure that new threads are hooked [sigh] (bug in core) */
-     prof_remove_hook();
-     prof_install_hook();
-   # endif
-
-    if (exclude_threads_tbl &&
-        st_lookup(exclude_threads_tbl, (st_data_t) thread_id, 0)) 
+
+    if (st_lookup(profile->exclude_threads_tbl, (st_data_t) thread_id, 0))
     {
       return;
-    }    
-    
-    
+    }
+
     /* Was there a context switch? */
-    if (!last_thread_data || last_thread_data->thread_id != thread_id)
-      thread_data = switch_thread(thread_id, now);
+    if (!profile->last_thread_data || profile->last_thread_data->thread_id != thread_id)
+      thread_data = switch_thread(profile, thread_id);
     else
-      thread_data = last_thread_data;
-    
-    
+      thread_data = profile->last_thread_data;
+
+
     switch (event) {
     case RUBY_EVENT_LINE:
     {
       /* Keep track of the current line number in this method.  When
-         a new method is called, we know what line number it was 
+         a new method is called, we know what line number it was
          called from. */
-         
+
        /* Get the current frame for the current thread. */
       frame = stack_peek(thread_data->stack);
 
       if (frame)
       {
-        frame->line = rb_sourceline();        
-        
-        # ifdef RUBY_VM
-          // disabled till I figure out why it causes
-          // us to lose valuable frame information...maybe mid comes in wrong sometimes?
-          // walk_up_until_right_frame(frame, thread_data, mid, klass, now);
-        # endif
-        
+        frame->line = rb_sourceline();
         break;
       }
 
-      /* If we get here there was no frame, which means this is 
+      /* If we get here there was no frame, which means this is
          the first method seen for this thread, so fall through
          to below to create it. */
     }
@@ -1154,27 +304,15 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         /* Is this an include for a module?  If so get the actual
            module class since we want to combine all profiling
            results for that module. */
-        
+
         if (klass != 0)
           klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
-          
-        /* Assume this is the first time we have called this method. */
+
         #ifdef RUBY_VM
-          method = get_method(event, klass, mid, 0, thread_data->method_table);
+        method = get_method(event, klass, mid, thread_data->method_table);
         #else
-          method = get_method(event, node, klass, mid, 0, thread_data->method_table);
+        method = get_method(event, node, klass, mid, thread_data->method_table);
         #endif
-        /* Check for a recursive call */
-        while (method->active) // it's while because we start at 0 and then inc. to the right recursive depth
-        {
-          /* Yes, this method is already active somewhere up the stack */
-          #ifdef RUBY_VM
-            method = get_method(event, klass, mid, method->key->depth + 1, thread_data->method_table);
-          #else
-            method = get_method(event, node, klass, mid, method->key->depth + 1, thread_data->method_table);
-          #endif
-        }          
-        method->active = 1;                
 
         if (!frame)
         {
@@ -1196,7 +334,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         /* Push a new frame onto the stack for a new c-call or ruby call (into a method) */
         frame = stack_push(thread_data->stack);
         frame->call_info = call_info;
-        frame->start_time = now;
+        frame->start_time = profile->measurement;
         frame->wait_time = 0;
         frame->child_time = 0;
         frame->line = rb_sourceline();
@@ -1204,302 +342,218 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     }
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_C_RETURN:
-    {      
-    	frame = pop_frame(thread_data, now);
-      
-      # ifdef RUBY_VM
-        // we need to walk up the stack to find the right one [http://redmine.ruby-lang.org/issues/show/2610] (for now)
-        // sometimes frames don't have line and source somehow [like blank]
-        // if we hit one there's not much we can do...I guess...
-        // or maybe we don't have one because we're at the top or something.
-        walk_up_until_right_frame(frame, thread_data, mid, klass, now);
-      # endif
-                
+    {
+        frame = pop_frame(profile, thread_data);
       break;
     }
-    }
-}
-
-#ifdef RUBY_VM
-
-static inline void walk_up_until_right_frame(prof_frame_t *frame, thread_data_t* thread_data, ID mid, VALUE klass, prof_measure_t now) {
-  // while it doesn't match, pop on up until we have found where we belong...
-  while( frame && frame->call_info->target->key->mid && frame->call_info->target->key->klass && ((frame->call_info->target->key->mid != mid) || (frame->call_info->target->key->klass != klass))){
-    frame = pop_frame(thread_data, now);
   }
 }
-#endif
 
-/* ========  ProfResult ============== */
 
-/* Document-class: RubyProf::Result
-The RubyProf::Result class is used to store the results of a 
-profiling run.  And instace of the class is returned from
-the methods RubyProf#stop and RubyProf#profile.
+/* ===========  Profiling ================= */
+void
+prof_install_hook(VALUE self)
+{
+#ifdef RUBY_VM
+    rb_add_event_hook(prof_event_hook,
+          RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
+          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN
+            | RUBY_EVENT_LINE, self); // RUBY_EVENT_SWITCH
+#else
+    rb_add_event_hook(prof_event_hook,
+          RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
+          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN
+          | RUBY_EVENT_LINE);
 
-RubyProf::Result has one field, called threads, which is a hash
-table keyed on thread ID.  For each thread id, the hash table
-stores another hash table that contains profiling information
-for each method called during the threads execution.  That
-hash table is keyed on method name and contains
-RubyProf::MethodInfo objects. */
+	pCurrentProfile = prof_get_profile(self);
+#endif	
 
-static void
-prof_result_mark(prof_result_t *prof_result)
-{
-    VALUE threads = prof_result->threads;
-    rb_gc_mark(threads);
+#if defined(TOGGLE_GC_STATS)
+    rb_gc_enable_stats();
+#endif
 }
 
-static void
-prof_result_free(prof_result_t *prof_result)
+void
+prof_remove_hook()
 {
-    prof_result->threads = Qnil;
-    xfree(prof_result);
+#if defined(TOGGLE_GC_STATS)
+    rb_gc_disable_stats();
+#endif
+
+#ifndef RUBY_VM
+	pCurrentProfile = NULL;
+#endif
+
+    /* Now unregister from event   */
+    rb_remove_event_hook(prof_event_hook);
 }
 
-static VALUE
-prof_result_new()
+
+static int
+collect_methods(st_data_t key, st_data_t value, st_data_t result)
 {
-    prof_result_t *prof_result = ALLOC(prof_result_t);
+    /* Called for each method stored in a thread's method table.
+       We want to store the method info information into an array.*/
+    VALUE methods = (VALUE) result;
+    prof_method_t *method = (prof_method_t *) value;
+    rb_ary_push(methods, prof_method_wrap(method));
 
-    /* Wrap threads in Ruby regular Ruby hash table. */
-    prof_result->threads = rb_hash_new();
-    st_foreach(threads_tbl, collect_threads, prof_result->threads);
+    /* Wrap call info objects */
+    prof_call_infos_wrap(method->call_infos);
 
-    return Data_Wrap_Struct(cResult, prof_result_mark, prof_result_free, prof_result);
+    return ST_CONTINUE;
 }
 
-
-static prof_result_t *
-get_prof_result(VALUE obj)
+static int
+collect_threads(st_data_t key, st_data_t value, st_data_t result)
 {
-    if (BUILTIN_TYPE(obj) != T_DATA ||
-      RDATA(obj)->dfree != (RUBY_DATA_FUNC) prof_result_free)
-    {
-        /* Should never happen */
-      rb_raise(rb_eTypeError, "wrong result object (%d %d) ", BUILTIN_TYPE(obj) != T_DATA, RDATA(obj)->dfree != (RUBY_DATA_FUNC) prof_result_free);
-    }
-    return (prof_result_t *) DATA_PTR(obj);
-}
+    /* Although threads are keyed on an id, that is actually a
+       pointer to the VALUE object of the thread.  So its bogus.
+       However, in thread_data is the real thread id stored
+       as an int. */
+    thread_data_t* thread_data = (thread_data_t*) value;
+    VALUE threads_hash = (VALUE) result;
 
-/* call-seq:
-   threads -> Hash
+    VALUE methods = rb_ary_new();
 
-Returns a hash table keyed on thread ID.  For each thread id,
-the hash table stores another hash table that contains profiling
-information for each method called during the threads execution.
-That hash table is keyed on method name and contains 
-RubyProf::MethodInfo objects. */
-static VALUE
-prof_result_threads(VALUE self)
-{
-    prof_result_t *prof_result = get_prof_result(self);
-    return prof_result->threads;
-}
+    /* Now collect an array of all the called methods */
+    st_table* method_table = thread_data->method_table;
+    st_foreach(method_table, collect_methods, methods);
 
+    /* Store the results in the threads hash keyed on the thread id. */
+    rb_hash_aset(threads_hash, thread_data->thread_id, methods);
 
+    return ST_CONTINUE;
+}
 
-/* call-seq:
-   measure_mode -> measure_mode
-   
-   Returns what ruby-prof is measuring.  Valid values include:
-   
-   *RubyProf::PROCESS_TIME - Measure process time.  This is default.  It is implemented using the clock functions in the C Runtime library.
-   *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows
-   *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms. 
-   *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
-   *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
-   *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
-   *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
-static VALUE
-prof_get_measure_mode(VALUE self)
+/* ========  Profile Class ====== */
+static void
+prof_mark(prof_profile_t *profile)
 {
-    return INT2NUM(measure_mode);
+    VALUE threads = profile->threads;
+    rb_gc_mark(threads);
 }
 
-/* call-seq:
-   measure_mode=value -> void
-   
-   Specifies what ruby-prof should measure.  Valid values include:
-   
-   *RubyProf::PROCESS_TIME - Measure process time.  This is default.  It is implemented using the clock functions in the C Runtime library.
-   *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows
-   *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms. 
-   *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
-   *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
-   *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
-   *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
-static VALUE
-prof_set_measure_mode(VALUE self, VALUE val)
+static void
+prof_free(prof_profile_t *profile)
 {
-    long mode = NUM2LONG(val);
-
-    if (threads_tbl)
-    {
-      rb_raise(rb_eRuntimeError, "can't set measure_mode while profiling");
-    }
-
-    switch (mode) {
-      case MEASURE_PROCESS_TIME:
-        get_measurement = measure_process_time;
-        convert_measurement = convert_process_time;
-        break;
-        
-      case MEASURE_WALL_TIME:
-        get_measurement = measure_wall_time;
-        convert_measurement = convert_wall_time;
-        break;
-        
-      #if defined(MEASURE_CPU_TIME)
-      case MEASURE_CPU_TIME:
-        if (cpu_frequency == 0)
-            cpu_frequency = get_cpu_frequency();
-        get_measurement = measure_cpu_time;
-        convert_measurement = convert_cpu_time;
-        break;
-      #endif
-              
-      #if defined(MEASURE_ALLOCATIONS)
-      case MEASURE_ALLOCATIONS:
-        get_measurement = measure_allocations;
-        convert_measurement = convert_allocations;
-        break;
-      #endif
-        
-      #if defined(MEASURE_MEMORY)
-      case MEASURE_MEMORY:
-        get_measurement = measure_memory;
-        convert_measurement = convert_memory;
-        break;
-      #endif
-
-      #if defined(MEASURE_GC_RUNS)
-      case MEASURE_GC_RUNS:
-        get_measurement = measure_gc_runs;
-        convert_measurement = convert_gc_runs;
-        break;
-      #endif
+    profile->threads = Qnil;
+    st_free_table(profile->exclude_threads_tbl);
+	profile->exclude_threads_tbl = NULL;
 
-      #if defined(MEASURE_GC_TIME)
-      case MEASURE_GC_TIME:
-        get_measurement = measure_gc_time;
-        convert_measurement = convert_gc_time;
-        break;
-      #endif
-
-      default:
-        rb_raise(rb_eArgError, "invalid mode: %ld", mode);
-        break;
-    }
-    
-    measure_mode = mode;
-    return val;
+    xfree(profile);
 }
 
-/* call-seq:
-   exclude_threads= -> void
-
-   Specifies what threads ruby-prof should exclude from profiling */
 static VALUE
-prof_set_exclude_threads(VALUE self, VALUE threads)
+prof_allocate(VALUE klass)
 {
-    int i;
-
-    if (threads_tbl != NULL)
-    {
-      rb_raise(rb_eRuntimeError, "can't set exclude_threads while profiling");
-    }
+    VALUE result;
+    prof_profile_t* profile;
+    result = Data_Make_Struct(klass, prof_profile_t, prof_mark, prof_free, profile);
+    profile->exclude_threads_tbl = threads_table_create();
+    profile->running = Qfalse;
+    return result;
+}
 
-    /* Stay simple, first free the old hash table */
-    if (exclude_threads_tbl)
-    {
-      st_free_table(exclude_threads_tbl);
-      exclude_threads_tbl = NULL;
-    }
+/* call-seq:
+   RubyProf::Profile.new(mode, exclude_threads) -> instance
 
-    /* Now create a new one if the user passed in any threads */
-    if (threads != Qnil)
+   Returns a new profiler.
+   
+   == Parameters
+   mode::  Measure mode (optional). Specifies the profile measure mode.  If not specified, defaults
+           to RubyProf::WALL_TIME.
+   exclude_threads:: Threads to exclude from the profiling results (optional). */
+static VALUE
+prof_initialize(int argc,  VALUE *argv, VALUE self)
+{
+    prof_profile_t* profile = prof_get_profile(self);
+    VALUE mode;
+	prof_measure_mode_t measurer;
+    VALUE exclude_threads;
+	int i;
+    
+    switch (rb_scan_args(argc, argv, "02", &mode, &exclude_threads))
     {
-      Check_Type(threads, T_ARRAY);
-      exclude_threads_tbl = st_init_numtable();
-
-      for (i=0; i < RARRAY_LEN(threads); ++i) 
+      case 0:
       {
-        VALUE thread = rb_ary_entry(threads, i);
-        st_insert(exclude_threads_tbl, (st_data_t) rb_obj_id(thread), 0);
+        measurer = MEASURE_WALL_TIME;
+        exclude_threads = rb_ary_new();
+		break;
       }
-    }    
-    return threads;
-}
-
+      case 1:
+      {
+        measurer = (prof_measure_mode_t)NUM2INT(mode);
+        exclude_threads = rb_ary_new();
+		break;
+      }
+      case 2:
+      {
+		Check_Type(exclude_threads, T_ARRAY);
+        measurer = (prof_measure_mode_t)NUM2INT(mode);
+		break;
+      }
+    }
 
-/* =========  Profiling ============= */
-void
-prof_install_hook()
-{
-#ifdef RUBY_VM
-    rb_add_event_hook(prof_event_hook,
-          RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
-          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN 
-            | RUBY_EVENT_LINE, Qnil); // RUBY_EVENT_SWITCH
-#else
-    rb_add_event_hook(prof_event_hook,
-          RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
-          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN 
-          | RUBY_EVENT_LINE);
-#endif
+    profile->measurer = prof_get_measurer(measurer);
+    profile->threads = rb_hash_new();
 
-#if defined(TOGGLE_GC_STATS)
-    rb_gc_enable_stats();
-#endif
-}
 
-void
-prof_remove_hook()
-{
-#if defined(TOGGLE_GC_STATS)
-    rb_gc_disable_stats();
-#endif
+	for (i = 0; i < RARRAY_LEN(exclude_threads); i++)
+	{
+		VALUE thread = rb_ary_entry(exclude_threads, i);
+		VALUE thread_id = rb_obj_id(thread);
+	    st_insert(profile->exclude_threads_tbl, thread_id, Qtrue);
+	}
 
-    /* Now unregister from event   */
-    rb_remove_event_hook(prof_event_hook);
+    return self;
 }
 
-
-
 /* call-seq:
    running? -> boolean
-   
+
    Returns whether a profile is currently running.*/
 static VALUE
 prof_running(VALUE self)
 {
-    if (threads_tbl != NULL)
-        return Qtrue;
-    else
-        return Qfalse;
+    prof_profile_t* profile = prof_get_profile(self);
+    return profile->running;
 }
 
 /* call-seq:
    start -> RubyProf
-   
+
    Starts recording profile data.*/
 static VALUE
 prof_start(VALUE self)
 {
-    if (threads_tbl != NULL)
+	char* trace_file_name;
+    prof_profile_t* profile = prof_get_profile(self);
+        
+    if (profile->running == Qtrue)
     {
         rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
     }
 
-    /* Setup globals */
-    last_thread_data = NULL;
-    threads_tbl = threads_table_create();
+    profile->running = Qtrue;
+    profile->last_thread_data = NULL;
+    profile->threads_tbl = threads_table_create();
+
+    /* open trace file if environment wants it */
+    trace_file_name = getenv("RUBY_PROF_TRACE");
+    if (trace_file_name != NULL) {
+      if (0==strcmp(trace_file_name, "stdout")) {
+        trace_file = stdout;
+      } else if (0==strcmp(trace_file_name, "stderr")) {
+        trace_file = stderr;
+      } else {
+        trace_file = fopen(trace_file_name, "a");
+      }
+    }
 
-    prof_install_hook();              
+    prof_install_hook(self);
     return self;
-}    
+}
 
 /* call-seq:
    pause -> RubyProf
@@ -1508,31 +562,36 @@ prof_start(VALUE self)
 static VALUE
 prof_pause(VALUE self)
 {
-    if (threads_tbl == NULL)
+    prof_profile_t* profile = prof_get_profile(self);
+    if (profile->running == Qfalse)
     {
         rb_raise(rb_eRuntimeError, "RubyProf is not running.");
     }
 
+    profile->running = Qfalse;
+
     prof_remove_hook();
     return self;
 }
 
 /* call-seq:
    resume {block} -> RubyProf
-   
+
    Resumes recording profile data.*/
 static VALUE
 prof_resume(VALUE self)
 {
-    if (threads_tbl == NULL)
-    { 
+    prof_profile_t* profile = prof_get_profile(self);
+    if (profile->running == Qfalse)
+    {
         prof_start(self);
     }
     else
-    { 
-        prof_install_hook();
+    {
+        profile->running = Qtrue;
+        prof_install_hook(self);
     }
-    
+
     if (rb_block_given_p())
     {
       rb_ensure(rb_yield, self, prof_pause, self);
@@ -1542,28 +601,47 @@ prof_resume(VALUE self)
 }
 
 /* call-seq:
-   stop -> RubyProf::Result
+   stop -> self
 
-   Stops collecting profile data and returns a RubyProf::Result object. */
+   Stops collecting profile data.*/
 static VALUE
 prof_stop(VALUE self)
 {
-    VALUE result = Qnil;
+    prof_profile_t* profile = prof_get_profile(self);
+
+	/* get 'now' before prof emove hook because it calls GC.disable_stats
+      which makes the call within prof_pop_threads of now return 0, which is wrong
+    */
+    profile->measurement = profile->measurer->measure();
+    if (profile->running == Qfalse)
+    {
+        rb_raise(rb_eRuntimeError, "RubyProf.start was not yet called");
+    }
+  
+    /* close trace file if open */
+    if (trace_file != NULL) {
+      if (trace_file!=stderr && trace_file!=stdout)
+        fclose(trace_file);
+      trace_file = NULL;
+    }
     
     prof_remove_hook();
+    prof_pop_threads(profile);
 
-    prof_pop_threads();
+    /* Unset the last_thread_data (very important!)
+       and the threads table */
+    profile->running = Qfalse;
+    profile->last_thread_data = NULL;
 
-    /* Create the result */
-    result = prof_result_new();
+    /* Save the result */
+    st_foreach(profile->threads_tbl, collect_threads, profile->threads);
+	threads_table_free(profile->threads_tbl);
+	profile->threads_tbl = NULL;
 
-    /* Unset the last_thread_data (very important!) 
-       and the threads table */
-    last_thread_data = NULL;
-    threads_table_free(threads_tbl);
-    threads_tbl = NULL;
+    /* compute minimality of call_infos */
+    rb_funcall(self, rb_intern("compute_minimality") , 0);
 
-    return result;
+    return self;
 }
 
 /* call-seq:
@@ -1571,177 +649,54 @@ prof_stop(VALUE self)
 
 Profiles the specified block and returns a RubyProf::Result object. */
 static VALUE
-prof_profile(VALUE self)
+prof_profile(int argc,  VALUE *argv, VALUE klass)
 {
     int result;
-    
+    VALUE profile = rb_class_new_instance(argc, argv, cProfile);
+
     if (!rb_block_given_p())
     {
         rb_raise(rb_eArgError, "A block must be provided to the profile method.");
     }
 
-    prof_start(self);
-    rb_protect(rb_yield, self, &result);
-    return prof_stop(self);
+    prof_start(profile);
+    rb_protect(rb_yield, profile, &result);
+    return prof_stop(profile);
 }
 
-/* Get arround annoying limitations in RDOC */
-
-/* Document-method: measure_process_time
-   call-seq:
-     measure_process_time -> float
-
-Returns the process time.*/
-
-/* Document-method: measure_wall_time
-   call-seq:
-     measure_wall_time -> float
-
-Returns the wall time.*/
-
-/* Document-method: measure_cpu_time
-   call-seq:
-     measure_cpu_time -> float
-
-Returns the cpu time.*/
-
-/* Document-method: get_cpu_frequency
-   call-seq:
-     cpu_frequency -> int
-
-Returns the cpu's frequency.  This value is needed when 
-RubyProf::measure_mode is set to CPU_TIME. */
-
-/* Document-method: cpu_frequency
-   call-seq:
-     cpu_frequency -> int
-
-Returns the cpu's frequency.  This value is needed when 
-RubyProf::measure_mode is set to CPU_TIME. */
-
-/* Document-method: cpu_frequency=
-   call-seq:
-     cpu_frequency = frequency
-
-Sets the cpu's frequency.  This value is needed when 
-RubyProf::measure_mode is set to CPU_TIME. */
-
-/* Document-method: measure_allocations
-   call-seq:
-     measure_allocations -> int
-
-Returns the total number of object allocations since Ruby started.*/
-
-/* Document-method: measure_memory
-   call-seq:
-     measure_memory -> int
-
-Returns total allocated memory in bytes.*/
-
-/* Document-method: measure_gc_runs
-   call-seq:
-     gc_runs -> Integer
-
-Returns the total number of garbage collections.*/
-
-/* Document-method: measure_gc_time
-   call-seq:
-     gc_time -> Integer
-
-Returns the time spent doing garbage collections in microseconds.*/
-
+/* call-seq:
+   threads -> Hash
 
-#if defined(_WIN32)
-__declspec(dllexport) 
-#endif
-void
+Returns a hash table keyed on thread ID.  For each thread id,
+the hash table stores another hash table that contains profiling
+information for each method called during the threads execution.
+That hash table is keyed on method name and contains
+RubyProf::MethodInfo objects. */
+static VALUE
+prof_threads(VALUE self)
+{
+    prof_profile_t* profile = prof_get_profile(self);
+    return profile->threads;
+}
 
-Init_ruby_prof()
+void Init_ruby_prof()
 {
     mProf = rb_define_module("RubyProf");
     rb_define_const(mProf, "VERSION", rb_str_new2(RUBY_PROF_VERSION));
-    rb_define_module_function(mProf, "start", prof_start, 0);
-    rb_define_module_function(mProf, "stop", prof_stop, 0);
-    rb_define_module_function(mProf, "resume", prof_resume, 0);
-    rb_define_module_function(mProf, "pause", prof_pause, 0);
-    rb_define_module_function(mProf, "running?", prof_running, 0);
-    rb_define_module_function(mProf, "profile", prof_profile, 0);
-    
-    rb_define_singleton_method(mProf, "exclude_threads=", prof_set_exclude_threads, 1);
-    rb_define_singleton_method(mProf, "measure_mode", prof_get_measure_mode, 0);
-    rb_define_singleton_method(mProf, "measure_mode=", prof_set_measure_mode, 1);
-
-    rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
-    rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
-    rb_define_singleton_method(mProf, "measure_process_time", prof_measure_process_time, 0); /* in measure_process_time.h */
-    rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
-    rb_define_singleton_method(mProf, "measure_wall_time", prof_measure_wall_time, 0); /* in measure_wall_time.h */
-
-    #ifndef MEASURE_CPU_TIME
-    rb_define_const(mProf, "CPU_TIME", Qnil);
-    #else
-    rb_define_const(mProf, "CPU_TIME", INT2NUM(MEASURE_CPU_TIME));
-    rb_define_singleton_method(mProf, "measure_cpu_time", prof_measure_cpu_time, 0); /* in measure_cpu_time.h */
-    rb_define_singleton_method(mProf, "cpu_frequency", prof_get_cpu_frequency, 0); /* in measure_cpu_time.h */
-    rb_define_singleton_method(mProf, "cpu_frequency=", prof_set_cpu_frequency, 1); /* in measure_cpu_time.h */
-    #endif
-        
-    #ifndef MEASURE_ALLOCATIONS
-    rb_define_const(mProf, "ALLOCATIONS", Qnil);
-    #else
-    rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
-    rb_define_singleton_method(mProf, "measure_allocations", prof_measure_allocations, 0); /* in measure_allocations.h */
-    #endif
-    
-    #ifndef MEASURE_MEMORY
-    rb_define_const(mProf, "MEMORY", Qnil);
-    #else
-    rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
-    rb_define_singleton_method(mProf, "measure_memory", prof_measure_memory, 0); /* in measure_memory.h */
-    #endif
-
-    #ifndef MEASURE_GC_RUNS
-    rb_define_const(mProf, "GC_RUNS", Qnil);
-    #else
-    rb_define_const(mProf, "GC_RUNS", INT2NUM(MEASURE_GC_RUNS));
-    rb_define_singleton_method(mProf, "measure_gc_runs", prof_measure_gc_runs, 0); /* in measure_gc_runs.h */
-    #endif
-
-    #ifndef MEASURE_GC_TIME
-    rb_define_const(mProf, "GC_TIME", Qnil);
-    #else
-    rb_define_const(mProf, "GC_TIME", INT2NUM(MEASURE_GC_TIME));
-    rb_define_singleton_method(mProf, "measure_gc_time", prof_measure_gc_time, 0); /* in measure_gc_time.h */
-    #endif
-
-    cResult = rb_define_class_under(mProf, "Result", rb_cObject);
-    rb_undef_method(CLASS_OF(cMethodInfo), "new");
-    rb_define_method(cResult, "threads", prof_result_threads, 0);
-
-    /* MethodInfo */
-    cMethodInfo = rb_define_class_under(mProf, "MethodInfo", rb_cObject);
-    rb_undef_method(CLASS_OF(cMethodInfo), "new");
-    
-    rb_define_method(cMethodInfo, "klass", prof_method_klass, 0);
-    rb_define_method(cMethodInfo, "klass_name", prof_klass_name, 0);
-    rb_define_method(cMethodInfo, "method_name", prof_method_name, 0);
-    rb_define_method(cMethodInfo, "full_name", prof_full_name, 0);
-    rb_define_method(cMethodInfo, "method_id", prof_method_id, 0);
     
-    rb_define_method(cMethodInfo, "source_file", prof_method_source_file,0);
-    rb_define_method(cMethodInfo, "line", prof_method_line, 0);
-
-    rb_define_method(cMethodInfo, "call_infos", prof_method_call_infos, 0);
-
-    /* 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, "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, "total_time", prof_call_info_total_time, 0);
-    rb_define_method(cCallInfo, "self_time", prof_call_info_self_time, 0);
-    rb_define_method(cCallInfo, "wait_time", prof_call_info_wait_time, 0);
-    rb_define_method(cCallInfo, "line", prof_call_info_line, 0);
+    rp_init_measure();
+    rp_init_method_info();
+    rp_init_call_info();
+
+	cProfile = rb_define_class_under(mProf, "Profile", rb_cObject);
+    rb_define_singleton_method(cProfile, "profile", prof_profile, -1);
+    rb_define_alloc_func (cProfile, prof_allocate);
+    rb_define_method(cProfile, "initialize", prof_initialize, -1);
+    rb_define_method(cProfile, "start", prof_start, 0);
+    rb_define_method(cProfile, "start", prof_start, 0);
+    rb_define_method(cProfile, "stop", prof_stop, 0);
+    rb_define_method(cProfile, "resume", prof_resume, 0);
+    rb_define_method(cProfile, "pause", prof_pause, 0);
+    rb_define_method(cProfile, "running?", prof_running, 0);
+    rb_define_method(cProfile, "threads", prof_threads, 0);
 }