ruby-prof 0.6.0 → 0.7.0

data/ext/extconf.rb

@@ -16,6 +16,19 @@ else
 end
 
 have_header("sys/times.h")
+
+# Stefan Kaes / Alexander Dymo GC patch
 have_func("rb_os_allocated_objects")
 have_func("rb_gc_allocated_size")
+have_func("rb_gc_collections")
+have_func("rb_gc_time")
+
+# Lloyd Hilaiel's heap info patch
+have_func("rb_heap_total_mem")
+have_func("rb_gc_heap_info")
+
+# Ruby 1.9 unexposed methods
+have_func("rb_gc_malloc_allocations")
+have_func("rb_gc_malloc_allocated_size")
+
 create_makefile("ruby_prof")

data/ext/measure_allocations.h

@@ -1,5 +1,5 @@
 /* :nodoc: 
- * Copyright (C) 2007  Shugo Maeda <shugo@ruby-lang.org>
+ * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.
  *
@@ -24,6 +24,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE. */
 
+#include <ruby.h>
 
 #if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
 #define MEASURE_ALLOCATIONS 3
@@ -40,4 +41,18 @@ convert_allocations(prof_measure_t c)
     return  c; 
 }
 
+/* Document-method: prof_measure_allocations
+   call-seq:
+     measure_allocations -> int
+
+Returns the total number of object allocations since Ruby started.*/
+static VALUE
+prof_measure_allocations(VALUE self)
+{
+#if defined(HAVE_LONG_LONG)
+    return ULL2NUM(rb_os_allocated_objects());
+#else
+    return ULONG2NUM(rb_os_allocated_objects());
+#endif
+}
 #endif

data/ext/measure_cpu_time.h

@@ -1,5 +1,5 @@
 /* :nodoc: 
- * Copyright (C) 2007  Shugo Maeda <shugo@ruby-lang.org>
+ * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.
  *
@@ -24,6 +24,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE. */
 
+#include <ruby.h>
 
 #if defined(_WIN32) || (defined(__GNUC__) && (defined(__i386__) || defined(__powerpc__) || defined(__ppc__)))
 #define MEASURE_CPU_TIME 2
@@ -110,6 +111,17 @@ convert_cpu_time(prof_measure_t c)
     return (double) c / cpu_frequency;
 }
 
+/* Document-method: prof_measure_cpu_time
+   call-seq:
+     measure_cpu_time -> float
+
+Returns the cpu time.*/
+static VALUE
+prof_measure_cpu_time(VALUE self)
+{
+    return rb_float_new(convert_cpu_time(measure_cpu_time()));
+}
+
 /* Document-method: prof_get_cpu_frequency
    call-seq:
      cpu_frequency -> int
@@ -119,7 +131,7 @@ RubyProf::measure_mode is set to CPU_TIME. */
 static VALUE
 prof_get_cpu_frequency(VALUE self)
 {
-    return LONG2NUM(cpu_frequency);
+    return ULL2NUM(cpu_frequency);
 }
 
 /* Document-method: prof_set_cpu_frequency
@@ -131,7 +143,7 @@ RubyProf::measure_mode is set to CPU_TIME. */
 static VALUE
 prof_set_cpu_frequency(VALUE self, VALUE val)
 {
-    cpu_frequency = NUM2LONG(val);
+    cpu_frequency = NUM2LL(val);
     return val;
 }
 

data/ext/measure_gc_runs.h

@@ -0,0 +1,76 @@
+/* :nodoc: 
+ * 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. */
+
+#if defined(HAVE_RB_GC_COLLECTIONS)
+#define MEASURE_GC_RUNS 5
+
+static prof_measure_t
+measure_gc_runs()
+{
+    return NUM2INT(rb_gc_collections());
+}
+
+static double
+convert_gc_runs(prof_measure_t c)
+{
+    return c;
+}
+
+/* Document-method: prof_measure_gc_runs
+   call-seq:
+     gc_runs -> Integer
+
+Returns the total number of garbage collections.*/
+static VALUE
+prof_measure_gc_runs(VALUE self)
+{
+    return rb_gc_collections();
+}
+
+#elif defined(HAVE_RB_GC_HEAP_INFO)
+#define MEASURE_GC_RUNS 5
+
+static prof_measure_t
+measure_gc_runs()
+{
+  VALUE h = rb_gc_heap_info();
+  return NUM2UINT(rb_hash_aref(h, rb_str_new2("num_gc_passes")));
+}
+
+static double
+convert_gc_runs(prof_measure_t c)
+{
+    return c;
+}
+
+static VALUE
+prof_measure_gc_runs(VALUE self)
+{
+  VALUE h = rb_gc_heap_info();
+  return rb_hash_aref(h, rb_str_new2("num_gc_passes"));
+}
+
+#endif

data/ext/measure_gc_time.h

@@ -0,0 +1,57 @@
+/* :nodoc: 
+ * 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. */
+
+#if defined(HAVE_RB_GC_TIME)
+#define MEASURE_GC_TIME 6
+
+static prof_measure_t
+measure_gc_time()
+{
+#if HAVE_LONG_LONG
+    return NUM2LL(rb_gc_time());
+#else
+    return NUM2LONG(rb_gc_time());
+#endif
+}
+
+static double
+convert_gc_time(prof_measure_t c)
+{
+    return (double) c / 1000000;
+}
+
+/* Document-method: prof_measure_gc_time
+   call-seq:
+     gc_time -> Integer
+
+Returns the time spent doing garbage collections in microseconds.*/
+static VALUE
+prof_measure_gc_time(VALUE self)
+{
+    return rb_gc_time();
+}
+
+#endif

data/ext/measure_memory.h

@@ -1,5 +1,6 @@
 /* :nodoc: 
  * Copyright (C) 2008  Alexander Dymo <adymo@pluron.com>
+ *
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -26,17 +27,75 @@
 
 #if defined(HAVE_RB_GC_ALLOCATED_SIZE)
 #define MEASURE_MEMORY 4
+#define TOGGLE_GC_STATS 1
  
 static prof_measure_t
 measure_memory()
 {
-    return rb_gc_allocated_size();
+#if defined(HAVE_LONG_LONG)
+    return NUM2LL(rb_gc_allocated_size());
+#else
+    return NUM2ULONG(rb_gc_allocated_size());
+#endif
 }
 
 static double
 convert_memory(prof_measure_t c)
 { 
-    return  c / 1024; 
+    return (double) c / 1024; 
+}
+
+/* Document-method: prof_measure_memory
+   call-seq:
+     measure_memory -> int
+
+Returns total allocated memory in bytes.*/
+static VALUE
+prof_measure_memory(VALUE self)
+{
+    return rb_gc_allocated_size();
+}
+
+#elif defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
+#define MEASURE_MEMORY 4
+
+static prof_measure_t
+measure_memory()
+{
+    return rb_gc_malloc_allocated_size();
+}
+
+static double
+convert_memory(prof_measure_t c)
+{
+    return (double) c / 1024;
+}
+
+static VALUE
+prof_measure_memory(VALUE self)
+{
+    return UINT2NUM(rb_gc_malloc_allocated_size());
+}
+
+#elif defined(HAVE_RB_HEAP_TOTAL_MEM)
+#define MEASURE_MEMORY 4
+
+static prof_measure_t
+measure_memory()
+{
+    return rb_heap_total_mem();
+}
+
+static double
+convert_memory(prof_measure_t c)
+{
+    return (double) c / 1024;
+}
+
+static VALUE
+prof_measure_memory(VALUE self)
+{
+    return ULONG2NUM(rb_heap_total_mem());
 }
 
 #endif

data/ext/measure_process_time.h

@@ -1,5 +1,5 @@
-/* :nodoc: 
- * Copyright (C) 2007  Shugo Maeda <shugo@ruby-lang.org>
+/*
+ * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.
  *
@@ -39,3 +39,14 @@ convert_process_time(prof_measure_t c)
 {
     return (double) c / CLOCKS_PER_SEC;
 }
+
+/* Document-method: measure_process_time
+   call-seq:
+     measure_process_time -> float
+
+Returns the process time.*/
+static VALUE
+prof_measure_process_time(VALUE self)
+{
+    return rb_float_new(convert_process_time(measure_process_time()));
+}

data/ext/measure_wall_time.h

@@ -1,5 +1,5 @@
 /* :nodoc: 
- * Copyright (C) 2007  Shugo Maeda <shugo@ruby-lang.org>
+ * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.
  *
@@ -40,3 +40,14 @@ convert_wall_time(prof_measure_t c)
 {
     return (double) c / 1000000;
 }
+
+/* Document-method: prof_measure_wall_time
+   call-seq:
+     measure_wall_time -> float
+
+Returns the wall time.*/
+static VALUE
+prof_measure_wall_time(VALUE self)
+{
+    return rb_float_new(convert_wall_time(measure_wall_time()));
+}

data/ext/mingw/Rakefile

@@ -0,0 +1,23 @@
+# We can't use Ruby's standard build procedures
+# on Windows because the Ruby executable is
+# built with VC++ while here we want to build
+# with MingW.  So just roll our own...
+
+require 'fileutils'
+require 'rbconfig'
+
+EXTENSION_NAME = "ruby_prof.#{Config::CONFIG["DLEXT"]}"
+
+# This is called when the Windows GEM is installed!
+task :install do
+  # Gems will pass these two environment variables:
+  # RUBYARCHDIR=#{dest_path}
+  # RUBYLIBDIR=#{dest_path}
+  
+  dest_path = ENV['RUBYLIBDIR']
+  
+  # Copy the extension
+  cp(EXTENSION_NAME, dest_path)
+end
+
+task :default => :install

data/ext/mingw/build.rake

@@ -0,0 +1,38 @@
+# We can't use Ruby's standard build procedures
+# on Windows because the Ruby executable is
+# built with VC++ while here we want to build
+# with MingW.  So just roll our own...
+
+require 'rake/clean'
+require 'rbconfig'
+
+RUBY_INCLUDE_DIR = Config::CONFIG["archdir"]
+RUBY_BIN_DIR = Config::CONFIG["bindir"]
+RUBY_LIB_DIR = Config::CONFIG["libdir"]
+RUBY_SHARED_LIB = Config::CONFIG["LIBRUBY"]
+RUBY_SHARED_DLL = RUBY_SHARED_LIB.gsub(/lib$/, 'dll')
+    
+EXTENSION_NAME = "ruby_prof.#{Config::CONFIG["DLEXT"]}"
+
+CLEAN.include('*.o')
+CLOBBER.include(EXTENSION_NAME)
+
+task :default => "ruby_prof"
+
+SRC = FileList['../*.c']
+OBJ = SRC.collect do |file_name|
+  File.basename(file_name).ext('o')
+end
+
+SRC.each do |srcfile|
+  objfile = File.basename(srcfile).ext('o')
+  file objfile => srcfile do
+    command = "gcc -c -fPIC -O2 -Wall -o #{objfile} -I/usr/local/include #{srcfile} -I#{RUBY_INCLUDE_DIR}"
+    sh "sh -c '#{command}'" 
+  end
+end
+
+file "ruby_prof" => OBJ do
+  command = "gcc -shared -o #{EXTENSION_NAME} -L/usr/local/lib #{OBJ} #{RUBY_BIN_DIR}/#{RUBY_SHARED_DLL}" 
+  sh "sh -c '#{command}'" 
+end

data/ext/ruby_prof.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007  Shugo Maeda <shugo@ruby-lang.org>
+ * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
  *                     Charlie Savage <cfis@savagexi.com>
  * All rights reserved.
  *
@@ -47,129 +47,10 @@
   hierarchy in ruby - which is very helpful for creating call graphs.      
 */
 
-
-#include <stdio.h>
-
-#include <ruby.h>
-#ifndef RUBY_VM
-#include <node.h>
-#include <st.h>
-typedef rb_event_t rb_event_flag_t;
-#define rb_sourcefile() (node ? node->nd_file : 0)
-#define rb_sourceline() (node ? nd_line(node) : 0)
-#endif
-
-
-/* ================  Constants  =================*/
-#define INITIAL_STACK_SIZE 8
-#define PROF_VERSION "0.6.0"
-
-
-/* ================  Measurement  =================*/
-#ifdef HAVE_LONG_LONG
-typedef LONG_LONG prof_measure_t;
-#else
-typedef unsigned long prof_measure_t;
-#endif
-
-#include "measure_process_time.h"
-#include "measure_wall_time.h"
-#include "measure_cpu_time.h"
-#include "measure_allocations.h"
-#include "measure_memory.h"
-
-static prof_measure_t (*get_measurement)() = measure_process_time;
-static double (*convert_measurement)(prof_measure_t) = convert_process_time;
-
-/* ================  DataTypes  =================*/
-static VALUE mProf;
-static VALUE cResult;
-static VALUE cMethodInfo;
-static VALUE cCallInfo;
-
-/* Profiling information for each method. */
-typedef struct prof_method_t {
-    st_data_t key;              /* Cache hash value for speed reasons. */
-    VALUE name;                 /* Name of the method. */
-    VALUE klass;                /* The method's class. */
-    ID mid;                     /* The method id. */
-    int depth;                  /* The recursive depth this method was called at.*/
-    int called;                 /* Number of times called */
-    const char* source_file;    /* The method's source file */
-    int line;                   /* The method's line number. */
-    prof_measure_t total_time;  /* Total time spent in this method and children. */
-    prof_measure_t self_time;   /* Total time spent in this method. */
-    prof_measure_t wait_time;   /* Total time this method spent waiting for other threads. */
-    st_table *parents;          /* The method's callers (prof_call_info_t). */
-    st_table *children;         /* The method's callees (prof_call_info_t). */
-    int active_frame;           /* # of active frames for this method.  Used to detect
-                                   recursion.  Stashed here to avoid extra lookups in 
-                                   the hook method - so a bit hackey. */
-    struct prof_method_t *base;        /* For recursion - this is the parent method */
-} prof_method_t;
-
-
-/* Callers and callee information for a method. */
-typedef struct {
-    prof_method_t *target;
-    int called;
-    prof_measure_t total_time;
-    prof_measure_t self_time;
-    prof_measure_t wait_time;
-    int line;  
-} prof_call_info_t;
-
-
-/* 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_method_t *method;
-    prof_measure_t start_time;
-    prof_measure_t wait_time;
-    prof_measure_t 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;
-
-/* Profiling information for a thread. */
-typedef struct {
-    unsigned long thread_id;                  /* Thread id */
-    st_table* method_info_table;     /* All called methods */
-    prof_stack_t* stack;             /* Active methods */
-    prof_measure_t last_switch;      /* Point of last context switch */
-} thread_data_t;
-
-typedef struct {
-    VALUE threads;
-} prof_result_t;
-
-
-/* ================  Variables  =================*/
-static int measure_mode;
-static st_table *threads_tbl = NULL;
-/* TODO - If Ruby become multi-threaded this has to turn into
-   a separate stack since this isn't thread safe! */
-static thread_data_t* last_thread_data = NULL;
+#include "ruby_prof.h"
 
 
 /* ================  Helper Functions  =================*/
-/* Helper method to get the id of a Ruby thread. */
-static inline long
-get_thread_id(VALUE thread)
-{
-    //return NUM2ULONG(rb_obj_id(thread));
-    // From line 1997 in gc.c
-    return (long)thread;
-}
-
 static VALUE
 figure_singleton_name(VALUE klass)
 {
@@ -285,21 +166,7 @@ full_name(VALUE klass, ID mid, int depth)
   return result;
 }
 
-
-static inline st_data_t
-method_key(VALUE klass, ID mid, int depth)
-{
-  /* No idea if this is a unique key or not.  Would be
-     best to use the method name, but we can't, since
-     that calls internal ruby functions which would
-     cause the hook method to recursively call itself.
-     And that is too much of a bother to deal with.
-     Plus of course, this is faster. */
-  return (klass * 100) + (mid * 10) + depth;
-}
-
 /* ================  Stack Handling   =================*/
-
 /* Creates a stack of prof_frame_t to keep track
    of timings for active methods. */
 static prof_stack_t *
@@ -319,7 +186,7 @@ stack_free(prof_stack_t *stack)
     xfree(stack);
 }
 
-static inline prof_frame_t *
+static prof_frame_t *
 stack_push(prof_stack_t *stack)
 {
   /* Is there space on the stack?  If not, double
@@ -335,7 +202,7 @@ stack_push(prof_stack_t *stack)
   return stack->ptr++;
 }
 
-static inline prof_frame_t *
+static prof_frame_t *
 stack_pop(prof_stack_t *stack)
 {
     if (stack->ptr == stack->start)
@@ -344,7 +211,7 @@ stack_pop(prof_stack_t *stack)
       return --stack->ptr;
 }
 
-static inline prof_frame_t *
+static prof_frame_t *
 stack_peek(prof_stack_t *stack)
 {
     if (stack->ptr == stack->start)
@@ -353,71 +220,54 @@ stack_peek(prof_stack_t *stack)
       return stack->ptr - 1;
 }
 
-static inline size_t
-stack_size(prof_stack_t *stack)
+/* ================  Method Key   =================*/
+static int 
+method_table_cmp(prof_method_key_t *key1, prof_method_key_t *key2) 
 {
-    return stack->ptr - stack->start;
+    return (key1->klass != key2->klass) || 
+           (key1->mid != key2->mid) || 
+           (key1->depth != key2->depth);
 }
 
-/* ================  Method Info Handling   =================*/
- 
-/* --- Keeps track of the methods the current method calls */
-static st_table *
-method_info_table_create()
+static int 
+method_table_hash(prof_method_key_t *key) 
 {
-    return st_init_numtable();
-}
-
-static inline size_t
-method_info_table_insert(st_table *table, st_data_t key, prof_method_t *val)
-{
-    return st_insert(table, key, (st_data_t) val);
-}
-
-static inline prof_method_t *
-method_info_table_lookup(st_table *table, st_data_t key)
-{
-    st_data_t val;
-    if (st_lookup(table, key, &val))
-    {
-      return (prof_method_t *) val;
-    }
-    else 
-    {
-      return NULL;
-    }
+   return key->key;
 }
 
+static struct st_hash_type type_method_hash = {
+    method_table_cmp,
+    method_table_hash
+};
 
 static void
-method_info_table_free(st_table *table)
+method_key(prof_method_key_t* key, VALUE klass, ID mid, int depth)
 {
-    /* Don't free the contents since they are wrapped by
-       Ruby objects! */
-    st_free_table(table);
+    key->klass = klass;
+    key->mid = mid;
+    key->depth = depth;
+    key->key = (klass << 4) + (mid << 2) + depth;
 }
 
 
-/* ================  Call Info Handling   =================*/
-
-/* ---- Hash, keyed on class/method_id, that holds call_info objects ---- */
+/* ================  Call Info   =================*/
 static st_table *
-caller_table_create()
+call_info_table_create()
 {
-    return st_init_numtable();
+  return st_init_table(&type_method_hash);
 }
 
-static inline size_t
-caller_table_insert(st_table *table, st_data_t key, prof_call_info_t *val)
+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, key, (st_data_t) val);
+  return st_insert(table, (st_data_t) key, (st_data_t) val);
 }
 
-static inline prof_call_info_t *
-caller_table_lookup(st_table *table, st_data_t key)
+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, key, &val))
+    if (st_lookup(table, (st_data_t) key, &val))
     {
       return (prof_call_info_t *) val;
     }
@@ -428,7 +278,7 @@ caller_table_lookup(st_table *table, st_data_t key)
 }
 
 static void
-caller_table_free(st_table *table)
+call_info_table_free(st_table *table)
 {
     st_free_table(table);
 }
@@ -440,43 +290,51 @@ they took to execute. */
 
 /* :nodoc: */
 static prof_call_info_t *
-call_info_create(prof_method_t* method)
+prof_call_info_create(prof_method_t* method, prof_call_info_t* parent)
 {
-    prof_call_info_t *result;
-
-    result = ALLOC(prof_call_info_t);
+    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
-call_info_free(prof_call_info_t *call_info)
+prof_call_info_mark(prof_call_info_t *call_info)
 {
-    xfree(call_info);
+  rb_gc_mark(prof_method_wrap(call_info->target));
+  rb_gc_mark(call_info->children);
+  if (call_info->parent)
+    rb_gc_mark(prof_call_info_wrap(call_info->parent));
 }
 
-static int
-free_call_infos(st_data_t key, st_data_t value, st_data_t data)
+static void
+prof_call_info_free(prof_call_info_t *call_info)
 {
-    prof_call_info_t* call_info = (prof_call_info_t*) value;
-    call_info_free(call_info);
-    return ST_CONTINUE;
+  call_info_table_free(call_info->call_infos); 
+  xfree(call_info);
 }
 
 static VALUE
-call_info_new(prof_call_info_t *result)
+prof_call_info_wrap(prof_call_info_t *call_info)
 {
-    /* We don't want Ruby freeing the underlying C structures, that
-       is done when the prof_method_t is freed. */
-    return Data_Wrap_Struct(cCallInfo, NULL, NULL, result);
+  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 *
-get_call_info_result(VALUE obj)
+prof_get_call_info_result(VALUE obj)
 {
     if (BUILTIN_TYPE(obj) != T_DATA)
     {
@@ -492,14 +350,14 @@ get_call_info_result(VALUE obj)
 
 Returns the target method. */
 static VALUE
-call_info_target(VALUE self)
+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 = get_call_info_result(self);
-    return Data_Wrap_Struct(cMethodInfo, NULL, NULL, result->target);
+    prof_call_info_t *result = prof_get_call_info_result(self);
+    return prof_method_wrap(result->target);
 }
 
 /* call-seq:
@@ -507,10 +365,9 @@ call_info_target(VALUE self)
 
 Returns the total amount of time this method was called. */
 static VALUE
-call_info_called(VALUE self)
+prof_call_info_called(VALUE self)
 {
-    prof_call_info_t *result = get_call_info_result(self);
-
+    prof_call_info_t *result = prof_get_call_info_result(self);
     return INT2NUM(result->called);
 }
 
@@ -519,9 +376,10 @@ call_info_called(VALUE self)
 
    returns the line number of the method */
 static VALUE
-call_info_line(VALUE self)
+prof_call_info_line(VALUE self)
 {
-    return rb_int_new(get_call_info_result(self)->line);
+  prof_call_info_t *result = prof_get_call_info_result(self);
+  return rb_int_new(result->line);
 }
 
 /* call-seq:
@@ -529,10 +387,9 @@ call_info_line(VALUE self)
 
 Returns the total amount of time spent in this method and its children. */
 static VALUE
-call_info_total_time(VALUE self)
+prof_call_info_total_time(VALUE self)
 {
-    prof_call_info_t *result = get_call_info_result(self);
-
+    prof_call_info_t *result = prof_get_call_info_result(self);
     return rb_float_new(convert_measurement(result->total_time));
 }
 
@@ -541,9 +398,9 @@ call_info_total_time(VALUE self)
 
 Returns the total amount of time spent in this method. */
 static VALUE
-call_info_self_time(VALUE self)
+prof_call_info_self_time(VALUE self)
 {
-    prof_call_info_t *result = get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info_result(self);
 
     return rb_float_new(convert_measurement(result->self_time));
 }
@@ -553,138 +410,177 @@ call_info_self_time(VALUE self)
 
 Returns the total amount of time this method waited for other threads. */
 static VALUE
-call_info_wait_time(VALUE self)
+prof_call_info_wait_time(VALUE self)
 {
-    prof_call_info_t *result = get_call_info_result(self);
+    prof_call_info_t *result = prof_get_call_info_result(self);
 
     return rb_float_new(convert_measurement(result->wait_time));
 }
 
 /* call-seq:
-   children_time -> float
+   parent -> call_info
 
-Returns the total amount of time spent in this method's children. */
+Returns the call_infos parent call_info object (the method that called this method).*/
 static VALUE
-call_info_children_time(VALUE self)
+prof_call_info_parent(VALUE self)
 {
-    prof_call_info_t *result = get_call_info_result(self);
-    prof_measure_t children_time = result->total_time - result->self_time - result->wait_time;
-    return rb_float_new(convert_measurement(children_time));
+    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;
+}
 
-/* 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.
-*/
+/* call-seq:
+   children -> hash
 
-/* :nodoc: */
-static prof_method_t *
-prof_method_create(st_data_t key, VALUE klass, ID mid, int depth, 
-                   const char* source_file, int line)
+Returns an array of call info objects of methods that this method 
+called (ie, children).*/
+static VALUE
+prof_call_info_children(VALUE self)
 {
-    prof_method_t *result = ALLOC(prof_method_t);
-    
-    result->klass = klass;
-    result->mid = mid;
-    result->key = key;
-    result->depth = depth;
+    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;
+}
 
-    result->called = 0;
-    result->total_time = 0;
-    result->self_time = 0;
-    result->wait_time = 0;
-    result->parents = caller_table_create();
-    result->children = caller_table_create();
-    result->active_frame = 0;
-    result->base = result;
-        
-    result->source_file = source_file;
-    result->line = line;
-    return result;
+/* ================  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_method_mark(prof_method_t *data)
+prof_call_infos_free(prof_call_infos_t *call_infos)
 {
-    rb_gc_mark(data->klass);
+  xfree(call_infos->start);
+  xfree(call_infos);
 }
 
 static void
-prof_method_free(prof_method_t *data)
+prof_add_call_info(prof_call_infos_t *call_infos, prof_call_info_t *call_info)
 {
-    st_foreach(data->parents, free_call_infos, 0);
-    caller_table_free(data->parents); 
-    
-    st_foreach(data->children, free_call_infos, 0);
-    caller_table_free(data->children); 
-    
-    xfree(data);
+  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_method_new(prof_method_t *result)
+prof_call_infos_wrap(prof_call_infos_t *call_infos)
 {
-    return Data_Wrap_Struct(cMethodInfo, prof_method_mark, prof_method_free, result);
+  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;
 }
 
-static prof_method_t *
-get_prof_method(VALUE obj)
-{
-    return (prof_method_t *) DATA_PTR(obj);
-}
 
-/* call-seq:
-   called -> int
+/* ================  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.
+*/
 
-Returns the number of times this method was called. */
-static VALUE
-prof_method_called(VALUE self)
+static prof_method_t*
+prof_method_create(prof_method_key_t *key, const char* source_file, int line)
 {
-    prof_method_t *result = get_prof_method(self);
+    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);   
 
-    return INT2NUM(result->called);
-}
+    result->call_infos = prof_call_infos_create();
 
+    result->active = 0;
 
-/* call-seq:
-   total_time -> float
+    if (source_file != NULL) 
+    {
+      int len = strlen(source_file) + 1;    
+      char *buffer = ALLOC_N(char, len);
 
-Returns the total amount of time spent in this method and its children. */
-static VALUE
-prof_method_total_time(VALUE self)
-{
-    prof_method_t *result = get_prof_method(self);
+      MEMCPY(buffer, source_file, char, len);
+      result->source_file = buffer;
+    }
+    else 
+    {    
+      result->source_file = source_file;
+    }      
+    result->line = line;
 
-    return rb_float_new(convert_measurement(result->total_time));
+    return result;
 }
 
-/* call-seq:
-   self_time -> float
+static void
+prof_method_mark(prof_method_t *method)
+{
+  rb_gc_mark(method->call_infos->object);
+  rb_gc_mark(method->key->klass);
+}
 
-Returns the total amount of time spent in this method. */
-static VALUE
-prof_method_self_time(VALUE self)
+static void
+prof_method_free(prof_method_t *method)
 {
-    prof_method_t *result = get_prof_method(self);
+  if (method->source_file)
+  {
+    xfree((char*)method->source_file);    
+  }
 
-    return rb_float_new(convert_measurement(result->self_time));
+  prof_call_infos_free(method->call_infos);
+  xfree(method->key);
+  xfree(method);
 }
 
-/* call-seq:
-   wait_time -> float
-
-Returns the total amount of time this method waited for other threads. */
 static VALUE
-prof_method_wait_time(VALUE self)
+prof_method_wrap(prof_method_t *result)
 {
-    prof_method_t *result = get_prof_method(self);
+  if (result->object == Qnil)
+  {
+    result->object = Data_Wrap_Struct(cMethodInfo, prof_method_mark, prof_method_free, result);
+  }
+  return result->object;
+}
 
-    return rb_float_new(convert_measurement(result->wait_time));
+static prof_method_t *
+get_prof_method(VALUE obj)
+{
+    return (prof_method_t *) DATA_PTR(obj);
 }
 
 /* call-seq:
@@ -697,18 +593,6 @@ prof_method_line(VALUE self)
     return rb_int_new(get_prof_method(self)->line);
 }
 
-/* call-seq:
-   children_time -> float
-
-Returns the total amount of time spent in this method's children. */
-static VALUE
-prof_method_children_time(VALUE self)
-{
-    prof_method_t *result = get_prof_method(self);
-    prof_measure_t children_time = result->total_time - result->self_time - result->wait_time;
-    return rb_float_new(convert_measurement(children_time));
-}
-
 /* call-seq:
    source_file => string
 
@@ -736,8 +620,7 @@ static VALUE
 prof_method_klass(VALUE self)
 {
     prof_method_t *result = get_prof_method(self);
-
-    return result->klass;
+    return result->key->klass;
 }
 
 /* call-seq:
@@ -748,8 +631,7 @@ static VALUE
 prof_method_id(VALUE self)
 {
     prof_method_t *result = get_prof_method(self);
-
-    return ID2SYM(result->mid);
+    return ID2SYM(result->key->mid);
 }
 
 /* call-seq:
@@ -762,7 +644,7 @@ static VALUE
 prof_klass_name(VALUE self)
 {
     prof_method_t *method = get_prof_method(self);
-    return klass_name(method->klass);
+    return klass_name(method->key->klass);
 }
 
 /* call-seq:
@@ -772,10 +654,10 @@ 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)
+prof_method_name(VALUE self, int depth)
 {
     prof_method_t *method = get_prof_method(self);
-    return method_name(method->mid, method->depth);
+    return method_name(method->key->mid, depth);
 }
 
 /* call-seq:
@@ -787,105 +669,70 @@ static VALUE
 prof_full_name(VALUE self)
 {
     prof_method_t *method = get_prof_method(self);
-    return full_name(method->klass, method->mid, method->depth);
+    return full_name(method->key->klass, method->key->mid, method->key->depth);
 }
 
 /* call-seq:
-   called -> MethodInfo
+   call_infos -> Array of call_info
 
-For recursively called methods, returns the base method.  Otherwise, 
-returns self. */
+Returns an array of call info objects that contain profiling information 
+about the current method.*/
 static VALUE
-prof_method_base(VALUE self)
+prof_method_call_infos(VALUE self)
 {
     prof_method_t *method = get_prof_method(self);
-    
-    if (method == method->base)
-      return self;
-    else
-      /* 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! */
-      return Data_Wrap_Struct(cMethodInfo, NULL, NULL, method->base);
+    return prof_call_infos_wrap(method->call_infos);
 }
 
 static int
-prof_method_collect_call_infos(st_data_t key, st_data_t value, st_data_t result)
+collect_methods(st_data_t key, st_data_t value, st_data_t result)
 {
-    /* Create a new Ruby CallInfo object and store it into the hash
-       keyed on the parent's name.  We use the parent's name because
-       we want to see that printed out for child records in
-       a call graph. */
-    prof_call_info_t *call_info = (prof_call_info_t *) value;
-    VALUE arr = (VALUE) result;
-    rb_ary_push(arr, call_info_new(call_info));
+    /* 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;
 }
 
-/* call-seq:
-   children -> hash
-
-Returns an array of call info objects of methods that this method 
-was called by (ie, parents).*/
-static VALUE
-prof_method_parents(VALUE self)
+/* ================  Method Table   =================*/
+static st_table *
+method_table_create()
 {
-    /* Returns an array of call info objects for this
-       method's callers (the methods this method called). */
-
-    VALUE children = rb_ary_new();
-    prof_method_t *result = get_prof_method(self);
-    st_foreach(result->parents, prof_method_collect_call_infos, children);
-    return children;
+  return st_init_table(&type_method_hash);
 }
 
-
-/* call-seq:
-   children -> hash
-
-Returns an array of call info objects of methods that this method 
-called (ie, children).*/
-static VALUE
-prof_method_children(VALUE self)
+static size_t
+method_table_insert(st_table *table, const prof_method_key_t *key, prof_method_t *val)
 {
-    /* Returns an array of call info objects for this
-       method's callees (the methods this method called). */
-
-    VALUE children = rb_ary_new();
-    prof_method_t *result = get_prof_method(self);
-    st_foreach(result->children, prof_method_collect_call_infos, children);
-    return children;
+  return st_insert(table, (st_data_t) key, (st_data_t) val);
 }
 
-/* :nodoc: */
-static VALUE
-prof_method_cmp(VALUE self, VALUE other)
-{
-    /* For call graphs we want to sort methods by
-       their total time, not self time. */
-    prof_method_t *x = get_prof_method(self);
-    prof_method_t *y = get_prof_method(other);
-
-    if (x->called == 0 && y->called == 0)
-      return INT2FIX(0);
-    else if (x->called == 0)
-      return INT2FIX(1);
-    else if (y->called == 0)
-      return INT2FIX(-1);
-    else
-      return rb_dbl_cmp(x->total_time, y->total_time);
+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 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_new(method));
 
-    return ST_CONTINUE;
+static void
+method_table_free(st_table *table)
+{
+    /* Don't free the contents since they are wrapped by
+       Ruby objects! */
+    st_free_table(table);
 }
 
 
@@ -897,20 +744,19 @@ thread_data_create()
 {
     thread_data_t* result = ALLOC(thread_data_t);
     result->stack = stack_create();
-    result->method_info_table = method_info_table_create();
-    result->last_switch = 0;
+    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);
-    method_info_table_free(thread_data->method_info_table);
     xfree(thread_data);
 }
 
-
 /* ---- Hash, keyed on thread, that stores thread's stack
         and methods---- */
 
@@ -920,15 +766,15 @@ threads_table_create()
     return st_init_numtable();
 }
 
-static inline size_t
+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);
+    return st_insert(table, (st_data_t) thread, (st_data_t) thread_data);
 }
 
-static inline thread_data_t *
-threads_table_lookup(st_table *table, long thread_id)
+static thread_data_t *
+threads_table_lookup(st_table *table, VALUE thread_id)
 {
     thread_data_t* result;
     st_data_t val;
@@ -974,14 +820,15 @@ collect_threads(st_data_t key, st_data_t value, st_data_t result)
        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_foreach(thread_data->method_info_table, collect_methods, 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, ULONG2NUM(thread_data->thread_id), methods);
+    rb_hash_aset(threads_hash, thread_data->thread_id, methods);
 
     return ST_CONTINUE;
 }
@@ -989,6 +836,7 @@ collect_threads(st_data_t key, st_data_t value, st_data_t result)
 
 /* ================  Profiling    =================*/
 /* Copied from eval.c */
+#ifdef DEBUG
 static char *
 get_event_name(rb_event_flag_t event)
 {
@@ -1011,70 +859,143 @@ get_event_name(rb_event_flag_t event)
   return "raise";
     default:
   return "unknown";
+  }
+}
+#endif
+
+static prof_method_t* 
+get_method(rb_event_flag_t event, NODE *node, VALUE klass, ID mid, int depth, st_table* method_table)
+{
+    prof_method_key_t key;
+    prof_method_t *method = NULL;
+    
+    method_key(&key, klass, mid, depth);
+    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);
     }
+    return method;
 }
 
 static void
-update_result(thread_data_t* thread_data,
-              prof_measure_t total_time,
-              prof_frame_t  *parent_frame, prof_frame_t *child_frame)
-{
-    prof_method_t *parent = NULL;
-    prof_method_t *child = child_frame->method;
-    prof_call_info_t *parent_call_info = NULL;
-    prof_call_info_t *child_call_info = NULL;
+update_result(prof_measure_t total_time,
+              prof_frame_t *parent_frame, 
+              prof_frame_t *frame)
+{
+    prof_measure_t self_time = total_time - frame->child_time - frame->wait_time;
+
+    prof_call_info_t *call_info = frame->call_info;
     
-    prof_measure_t wait_time = child_frame->wait_time;
-    prof_measure_t self_time = total_time - child_frame->child_time - wait_time;
+    /* 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;
 
-    /* Update information about the child (ie, the current method) */
-    child->called++;
-    child->total_time += total_time;
-    child->self_time += self_time;
-    child->wait_time += wait_time;
+    /* Note where the current method was called from */
+    if (parent_frame)
+      call_info->line = parent_frame->line;
+}
 
-    if (!parent_frame) return;
+static thread_data_t *
+switch_thread(VALUE thread_id, prof_measure_t now)
+{
+    prof_frame_t *frame = NULL;
+    prof_measure_t wait_time = 0;
     
-    parent = parent_frame->method;
-        
-    child_call_info = caller_table_lookup(parent->children, child->key);
-    if (child_call_info == NULL)
-    {
-        child_call_info = call_info_create(child);
-        caller_table_insert(parent->children, child->key, child_call_info);
-    }
+    /* Get new thread information. */
+    thread_data_t *thread_data = threads_table_lookup(threads_tbl, thread_id);
 
-    child_call_info->called++;
-    child_call_info->total_time += total_time;
-    child_call_info->self_time += self_time;
-    child_call_info->wait_time += wait_time;
-    child_call_info->line = parent_frame->line;
-        
-    /* Update child's parent information  */
-    parent_call_info = caller_table_lookup(child->parents, parent->key);
-    if (parent_call_info == NULL)
-    {
-        parent_call_info = call_info_create(parent);
-        caller_table_insert(child->parents, parent->key, parent_call_info);
-    }
-    
-    parent_call_info->called++;
-    parent_call_info->total_time += total_time;
-    parent_call_info->self_time += self_time;
-    parent_call_info->wait_time += wait_time;
-    parent_call_info->line = (parent_frame ? parent_frame->line : 0);
+    /* How long has this thread been waiting? */
+    wait_time = now - thread_data->last_switch;
+    thread_data->last_switch = 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)
+{
+  prof_frame_t *frame = NULL;
+  prof_frame_t* parent_frame = NULL;
+  prof_measure_t total_time;
+
+  frame = stack_pop(thread_data->stack);
     
+  /* Frame can be null.  This can happen if RubProf.start is called from
+     a method that exits.  And it can happen if an exception is raised
+     in code that is being profiled and the stack unwinds (RubProf is
+     not notified of that by the ruby runtime. */
+  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;
+
+  parent_frame = stack_peek(thread_data->stack);
+  if (parent_frame)
+  {
+    parent_frame->child_time += total_time;
+  }
     
-    /* If the caller is the top of the stack, the merge in
-       all the child results.  We have to do this because
-       the top method is never popped since sooner or later
-       the user has to call RubyProf::stop.*/
-      
-    if (stack_size(thread_data->stack) == 1)
+  update_result(total_time, parent_frame, frame);
+  return frame;
+}
+
+static int 
+pop_frames(st_data_t key, st_data_t value, st_data_t now_arg)
+{
+    VALUE thread_id = (VALUE)key;
+    thread_data_t* thread_data = (thread_data_t *) value;
+    prof_measure_t now = *(prof_measure_t *) now_arg;
+
+    if (!last_thread_data || last_thread_data->thread_id != thread_id)
+      thread_data = switch_thread(thread_id, now);
+    else
+      thread_data = last_thread_data;
+
+    while (pop_frame(thread_data, now))
     {
-      parent->total_time += total_time;
-      parent->wait_time += wait_time;
     }
+    
+    return ST_CONTINUE;
+}
+
+static void 
+prof_pop_threads()
+{
+    /* Get current measurement*/
+    prof_measure_t now = get_measurement();
+    st_foreach(threads_tbl, pop_frames, (st_data_t) &now);
 }
 
 
@@ -1087,44 +1008,51 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
 #endif
 {
     
-    VALUE thread;
+    VALUE thread = Qnil;
+    VALUE thread_id = Qnil;
     prof_measure_t now = 0;
     thread_data_t* thread_data = NULL;
-    long thread_id = 0;
     prof_frame_t *frame = NULL;
+
+
 #ifdef RUBY_VM
 
-    if (event != RUBY_EVENT_C_CALL &&
-  event != RUBY_EVENT_C_RETURN) {
-  VALUE thread = rb_thread_current();
-  rb_frame_method_id_and_class(&mid, &klass);
+    if (event != RUBY_EVENT_C_CALL && event != RUBY_EVENT_C_RETURN) {
+        rb_frame_method_id_and_class(&mid, &klass);
     }
 #endif
+
+#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. 
+        profiler is tracing. */
     {
-        st_data_t key = 0;
-        static unsigned long last_thread_id = 0;
+        char* key = 0;
+        static VALUE last_thread_id = Qnil;
 
         VALUE thread = rb_thread_current();
-        unsigned long thread_id = get_thread_id(thread);
-        char* class_name = rb_obj_classname(klass);
+        VALUE thread_id = rb_obj_id(thread);
+        char* class_name = NULL;
         char* method_name = rb_id2name(mid);
-        char* source_file = node ? node->nd_file : 0;
-        unsigned int source_line = node ? nd_line(node) : 0;
+        char* source_file = rb_sourcefile();
+        unsigned int source_line = rb_sourceline();
+
         char* event_name = get_event_name(event);
-        
-        if (last_thread_id != thread_id)
-          printf("\n");
-          
+
         if (klass != 0)
           klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
-        key = method_key(klass, mid, 0);          
-        printf("%2u: %-8s :%2d  %s#%s (%u)\n",
-               thread_id, event_name, source_line, class_name, method_name, key);
+
+        class_name = rb_class2name(klass);
+
+        if (last_thread_id != thread_id)
+          printf("\n");
+
+        printf("%2u: %-8s :%2d  %s#%s\n",
+               thread_id, event_name, source_line, class_name, method_name);
+        fflush(stdout);
         last_thread_id = thread_id;               
-    } */
+    }
+#endif
     
     /* Special case - skip any methods from the mProf 
        module, such as Prof.stop, since they clutter
@@ -1136,41 +1064,23 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     
     /* Get the current thread information. */
     thread = rb_thread_current();
-    thread_id = get_thread_id(thread);
+    thread_id = rb_obj_id(thread);
+
+    if (exclude_threads_tbl &&
+        st_lookup(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)
-    {
-      prof_measure_t wait_time = 0;
-      
-      /* Get new thread information. */
-      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 = 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;
-    }
+      thread_data = switch_thread(thread_id, now);
     else
-    {
       thread_data = last_thread_data;
-      frame = stack_peek(thread_data->stack);
-    }
     
+    /* Get the current frame for the current thread. */
+    frame = stack_peek(thread_data->stack);
+
     switch (event) {
     case RUBY_EVENT_LINE:
     {
@@ -1179,14 +1089,10 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
          called from. */
       if (frame)
       {
-#ifdef RUBY_VM
-    frame->line = rb_sourceline();
-#else
-        if (node)
-          frame->line = nd_line(node);
-#endif
+        frame->line = rb_sourceline();
         break;
       }
+
       /* 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. */
@@ -1194,8 +1100,7 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
     case RUBY_EVENT_CALL:
     case RUBY_EVENT_C_CALL:
     {
-        int depth = 0;
-        st_data_t key = 0;
+        prof_call_info_t *call_info = NULL;
         prof_method_t *method = NULL;
 
         /* Is this an include for a module?  If so get the actual
@@ -1205,56 +1110,41 @@ prof_event_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE kla
         if (klass != 0)
           klass = (BUILTIN_TYPE(klass) == T_ICLASS ? RBASIC(klass)->klass : klass);
           
-        key = method_key(klass, mid, 0);
-   
-        method = method_info_table_lookup(thread_data->method_info_table, key);
-        
-        if (!method)
+        /* Assume this is the first time we have called this method. */
+        method = get_method(event, node, klass, mid, 0, thread_data->method_table);
+
+        /* Check for a recursive call */
+        if (method->active)
         {
-          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, klass, mid, depth, source_file, line);
-          method_info_table_insert(thread_data->method_info_table, key, method);
+          /* Yes, this method is already active */
+          method = get_method(event, node, klass, mid, method->key->depth + 1, thread_data->method_table);
         }
-        
-        depth = method->active_frame;
-        method->active_frame++;                  
-        
-        if (depth > 0)
+        else
         {
-          prof_method_t *base_method = method;
-          key = method_key(klass, mid, depth);
-          method = method_info_table_lookup(thread_data->method_info_table, key);
-          
-          if (!method)
+          /* No, so make it active */
+          method->active = 1;
+        }
+
+        if (!frame)
+        {
+          call_info = prof_call_info_create(method, NULL);
+          prof_add_call_info(method->call_infos, call_info);
+        }
+        else
+        {
+          call_info = call_info_table_lookup(frame->call_info->call_infos, method->key);
+
+          if (!call_info)
           {
-            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, klass, mid, depth, source_file, line);
-            method->base = base_method;
-            method_info_table_insert(thread_data->method_info_table, key, method);
+            call_info = prof_call_info_create(method, frame->call_info);
+            call_info_table_insert(frame->call_info->call_infos, method->key, call_info);
+            prof_add_call_info(method->call_infos, call_info);
           }
         }
 
         /* Push a new frame onto the stack */
         frame = stack_push(thread_data->stack);
-        frame->method = method;
+        frame->call_info = call_info;
         frame->start_time = now;
         frame->wait_time = 0;
         frame->child_time = 0;
@@ -1265,29 +1155,7 @@ 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:
     {
-        prof_frame_t* caller_frame = NULL;
-
-        prof_measure_t total_time;
-
-        frame = stack_pop(thread_data->stack);
-        caller_frame = stack_peek(thread_data->stack);
-          
-        /* Frame can be null.  This can happen if RubProf.start is called from
-           a method that exits.  And it can happen if an exception is raised
-           in code that is being profiled and the stack unwinds (RubProf is
-           not notified of that by the ruby runtime. */
-        if (frame == NULL) return;
-
-        total_time = now - frame->start_time;
-
-        if (caller_frame)
-        {
-            caller_frame->child_time += total_time;
-        }
-          
-        frame->method->base->active_frame--;
-        
-        update_result(thread_data, total_time, caller_frame, frame);
+        pop_frame(thread_data, now);
         break;
       }
     }
@@ -1374,7 +1242,9 @@ prof_result_threads(VALUE self)
    *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::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)
 {
@@ -1390,7 +1260,9 @@ prof_get_measure_mode(VALUE self)
    *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::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)
 {
@@ -1415,7 +1287,7 @@ prof_set_measure_mode(VALUE self, VALUE val)
       #if defined(MEASURE_CPU_TIME)
       case MEASURE_CPU_TIME:
         if (cpu_frequency == 0)
-            cpu_frequency = measure_cpu_time();
+            cpu_frequency = get_cpu_frequency();
         get_measurement = measure_cpu_time;
         convert_measurement = convert_cpu_time;
         break;
@@ -1434,9 +1306,23 @@ prof_set_measure_mode(VALUE self, VALUE val)
         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
+
+      #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: %d", mode);
+        rb_raise(rb_eArgError, "invalid mode: %ld", mode);
         break;
     }
     
@@ -1444,7 +1330,75 @@ prof_set_measure_mode(VALUE self, VALUE val)
     return val;
 }
 
+/* call-seq:
+   exclude_threads= -> void
+
+   Specifies what threads ruby-prof should exclude from profiling */
+static VALUE
+prof_set_exclude_threads(VALUE self, VALUE threads)
+{
+    int i;
+
+    if (threads_tbl != NULL)
+    {
+      rb_raise(rb_eRuntimeError, "can't set exclude_threads while profiling");
+    }
+
+    /* Stay simple, first free the old hash table */
+    if (exclude_threads_tbl)
+    {
+      st_free_table(exclude_threads_tbl);
+      exclude_threads_tbl = NULL;
+    }
+
+    /* Now create a new one if the user passed in any threads */
+    if (threads != Qnil)
+    {
+      Check_Type(threads, T_ARRAY);
+      exclude_threads_tbl = st_init_numtable();
+
+      for (i=0; i < RARRAY_LEN(threads); ++i) 
+      {
+        VALUE thread = rb_ary_entry(threads, i);
+        st_insert(exclude_threads_tbl, (st_data_t) rb_obj_id(thread), 0);
+      }
+    }    
+    return threads;
+}
+
+
 /* =========  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);
+#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
+
+#if defined(TOGGLE_GC_STATS)
+    rb_gc_enable_stats();
+#endif
+}
+
+void
+prof_remove_hook()
+{
+#if defined(TOGGLE_GC_STATS)
+    rb_gc_disable_stats();
+#endif
+
+    /* Now unregister from event   */
+    rb_remove_event_hook(prof_event_hook);
+}
+
 
 
 /* call-seq:
@@ -1461,7 +1415,7 @@ prof_running(VALUE self)
 }
 
 /* call-seq:
-   start -> void
+   start -> RubyProf
    
    Starts recording profile data.*/
 static VALUE
@@ -1475,26 +1429,50 @@ prof_start(VALUE self)
     /* Setup globals */
     last_thread_data = NULL;
     threads_tbl = threads_table_create();
-    
-#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);
-#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
 
-#if defined(MEASURE_MEMORY)
-    rb_gc_enable_stats();
-#endif
+    prof_install_hook();              
+    return self;
+}    
+
+/* call-seq:
+   pause -> RubyProf
+
+   Pauses collecting profile data. */
+static VALUE
+prof_pause(VALUE self)
+{
+    if (threads_tbl == NULL)
+    {
+        rb_raise(rb_eRuntimeError, "RubyProf is not running.");
+    }
 
-    return Qnil;
+    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_start(self);
+    }
+    else
+    { 
+        prof_install_hook();
+    }
+    
+    if (rb_block_given_p())
+    {
+      rb_ensure(rb_yield, self, prof_pause, self);
+    }
+
+    return self;
+}
 
 /* call-seq:
    stop -> RubyProf::Result
@@ -1503,19 +1481,11 @@ prof_start(VALUE self)
 static VALUE
 prof_stop(VALUE self)
 {
-#if defined(MEASURE_MEMORY)
-    rb_gc_disable_stats();
-#endif
-
     VALUE result = Qnil;
+    
+    prof_remove_hook();
 
-    if (threads_tbl == NULL)
-    {
-        rb_raise(rb_eRuntimeError, "RubyProf is not running.");
-    }
-
-    /* Now unregister from event   */
-    rb_remove_event_hook(prof_event_hook);
+    prof_pop_threads();
 
     /* Create the result */
     result = prof_result_new();
@@ -1529,7 +1499,6 @@ prof_stop(VALUE self)
     return result;
 }
 
-
 /* call-seq:
    profile {block} -> RubyProf::Result
 
@@ -1537,16 +1506,83 @@ Profiles the specified block and returns a RubyProf::Result object. */
 static VALUE
 prof_profile(VALUE self)
 {
+    int result;
+    
     if (!rb_block_given_p())
     {
         rb_raise(rb_eArgError, "A block must be provided to the profile method.");
     }
 
     prof_start(self);
-    rb_yield(Qnil);
+    rb_protect(rb_yield, self, &result);
     return prof_stop(self);
 }
 
+/* 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.*/
+
 
 #if defined(_WIN32)
 __declspec(dllexport) 
@@ -1556,23 +1592,29 @@ void
 Init_ruby_prof()
 {
     mProf = rb_define_module("RubyProf");
-    rb_define_const(mProf, "VERSION", rb_str_new2(PROF_VERSION));
+    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
@@ -1581,20 +1623,36 @@ Init_ruby_prof()
     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_include_module(cMethodInfo, rb_mComparable);
     rb_undef_method(CLASS_OF(cMethodInfo), "new");
     
     rb_define_method(cMethodInfo, "klass", prof_method_klass, 0);
@@ -1602,27 +1660,21 @@ Init_ruby_prof()
     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, "base", prof_method_base, 0);
     
-    rb_define_method(cMethodInfo, "parents", prof_method_parents, 0);
-    rb_define_method(cMethodInfo, "children", prof_method_children, 0);
-    rb_define_method(cMethodInfo, "<=>", prof_method_cmp, 1);
     rb_define_method(cMethodInfo, "source_file", prof_method_source_file,0);
     rb_define_method(cMethodInfo, "line", prof_method_line, 0);
-    rb_define_method(cMethodInfo, "called", prof_method_called, 0);
-    rb_define_method(cMethodInfo, "total_time", prof_method_total_time, 0);
-    rb_define_method(cMethodInfo, "self_time", prof_method_self_time, 0);
-    rb_define_method(cMethodInfo, "wait_time", prof_method_wait_time, 0);
-    rb_define_method(cMethodInfo, "children_time", prof_method_children_time, 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, "target", call_info_target, 0);
-    rb_define_method(cCallInfo, "called", call_info_called, 0);
-    rb_define_method(cCallInfo, "total_time", call_info_total_time, 0);
-    rb_define_method(cCallInfo, "self_time", call_info_self_time, 0);
-    rb_define_method(cCallInfo, "wait_time", call_info_wait_time, 0);
-    rb_define_method(cCallInfo, "line", call_info_line, 0);
-    rb_define_method(cCallInfo, "children_time", call_info_children_time, 0);
+    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);
 }
-