ruby-prof 0.4.1 → 0.5.0

data/ext/measure_cpu_time.h

@@ -0,0 +1,138 @@
+/* :nodoc: 
+ * Copyright (C) 2007  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(_WIN32) || (defined(__GNUC__) && (defined(__i386__) || defined(__powerpc__) || defined(__ppc__)))
+#define MEASURE_CPU_TIME 2
+
+static unsigned long long cpu_frequency;
+
+#if defined(__GNUC__)
+
+static prof_measure_t
+measure_cpu_time()
+{
+#if defined(__i386__)
+    unsigned long long x;
+    __asm__ __volatile__ ("rdtsc" : "=A" (x));
+    return x;
+#elif defined(__powerpc__) || defined(__ppc__)
+    unsigned long long x, y;
+
+    __asm__ __volatile__ ("\n\
+1:	mftbu   %1\n\
+  mftb    %L0\n\
+  mftbu   %0\n\
+  cmpw    %0,%1\n\
+  bne-    1b"
+  : "=r" (x), "=r" (y));
+    return x;
+#endif
+}
+
+#elif defined(_WIN32)
+
+static prof_measure_t
+measure_cpu_time()
+{
+    prof_measure_t cycles = 0;
+
+    __asm
+    {
+        rdtsc
+        mov DWORD PTR cycles, eax
+        mov DWORD PTR [cycles + 4], edx
+    }
+    return cycles;
+}
+
+#endif
+
+
+/* The _WIN32 check is needed for msys (and maybe cygwin?) */
+#if defined(__GNUC__) && !defined(_WIN32)
+
+unsigned long long get_cpu_frequency()
+{
+    unsigned long long x, y;
+
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = 500000000;
+    x = measure_cpu_time();
+    nanosleep(&ts, NULL);
+    y = measure_cpu_time();
+    return (y - x) * 2;
+}
+
+#elif defined(_WIN32)
+
+unsigned long long get_cpu_frequency()
+{
+    unsigned long long x, y;
+    unsigned long long frequency;
+    x = measure_cpu_time();
+
+    /* Use the windows sleep function, not Ruby's */
+    Sleep(500);
+    y = measure_cpu_time();
+    frequency = 2*(y-x);
+    return frequency;
+}
+#endif
+
+static double
+convert_cpu_time(prof_measure_t c)
+{
+    return (double) c / cpu_frequency;
+}
+
+/* Document-method: prof_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. */
+static VALUE
+prof_get_cpu_frequency(VALUE self)
+{
+    return LONG2NUM(cpu_frequency);
+}
+
+/* Document-method: prof_set_cpu_frequency
+   call-seq:
+     cpu_frequency=value -> void
+
+Sets the cpu's frequency.   This value is needed when 
+RubyProf::measure_mode is set to CPU_TIME. */
+static VALUE
+prof_set_cpu_frequency(VALUE self, VALUE val)
+{
+    cpu_frequency = NUM2LONG(val);
+    return val;
+}
+
+#endif

data/ext/measure_process_time.h

@@ -0,0 +1,41 @@
+/* :nodoc: 
+ * Copyright (C) 2007  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. */
+
+#include <time.h>
+
+#define MEASURE_PROCESS_TIME 0
+
+static prof_measure_t
+measure_process_time()
+{
+    return clock();
+}
+
+static double
+convert_process_time(prof_measure_t c)
+{
+    return (double) c / CLOCKS_PER_SEC;
+}

data/ext/measure_wall_time.h

@@ -0,0 +1,42 @@
+/* :nodoc: 
+ * Copyright (C) 2007  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. */
+
+
+#define MEASURE_WALL_TIME 1
+
+static prof_measure_t
+measure_wall_time()
+{
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec * 1000000 + tv.tv_usec;
+}
+
+static double
+convert_wall_time(prof_measure_t c)
+{
+    return (double) c / 1000000;
+}

data/ext/ruby_prof.c

@@ -1,6 +1,6 @@
 /*
- * $Id: prof.c 298 2005-05-11 08:33:37Z shugo $
- * Copyright (C) 2005  Shugo Maeda <shugo@ruby-lang.org>
+ * Copyright (C) 2007  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
@@ -25,240 +25,141 @@
  * SUCH DAMAGE.
  */
 
+/* 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.  
+     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. 
+
+  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.      
+*/
+
+
 #include <stdio.h>
-#include <time.h>
-#ifdef HAVE_SYS_TIMES_H
-#include <sys/times.h>
-#endif
 
 #include <ruby.h>
 #include <node.h>
 #include <st.h>
 
-#define PROF_VERSION "0.4.1"
 
+/* ================  Constants  =================*/
+#define INITIAL_STACK_SIZE 8
+#define PROF_VERSION "0.5.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"
+
+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;
 
-#ifdef HAVE_LONG_LONG
-typedef LONG_LONG prof_clock_t;
-#else
-typedef unsigned long prof_clock_t;
-#endif
+/* 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 {
-    VALUE klass;
-    ID mid;
+    prof_method_t *target;
     int called;
-    prof_clock_t self_time;
-    prof_clock_t total_time;
+    prof_measure_t total_time;
+    prof_measure_t self_time;
+    prof_measure_t wait_time;
+    int line;  
 } prof_call_info_t;
 
-typedef struct {
-    /* Cache hash value for speed reasons. */
-    st_data_t key;
-    VALUE klass;
-    ID mid;
-    int thread_id;
-    int called;
-    prof_clock_t self_time;
-    prof_clock_t total_time;
-    st_table *parents;
-    st_table *children;
-    /* Hack - piggyback a field to keep track of the
-        of times the method appears in the current 
-       stack.  Used to detect recursive cycles.  This
-       works because there is an instance of this struct
-       per method per thread.  Could have a separate
-       hash table...would be cleaner but adds a bit of
-       code and 1 extra lookup per event.*/
-    int stack_count;
-} prof_method_t;
 
+/* Temporary object that maintains profiling information
+   for active methods - there is one per method.*/
 typedef struct {
-    /* Cache prof_method_t values to significantly 
-       increase speed. */
-    prof_method_t *method_info;
-    prof_clock_t start_time;
-    prof_clock_t child_cost;
-} prof_data_t;
-
+    /* 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_data_t *start;
-    prof_data_t *end;
-    prof_data_t *ptr;
+    prof_frame_t *start;
+    prof_frame_t *end;
+    prof_frame_t *ptr;
 } prof_stack_t;
 
+/* Profiling information for a thread. */
 typedef struct {
-    prof_stack_t* stack;
-    st_table* minfo_table;
-    int thread_id;
+    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;
 
-static VALUE toplevel_id;
-static st_data_t toplevel_key;
-static int clock_mode;
-static st_table *threads_tbl = NULL;
-static VALUE class_tbl = Qnil;
-
-#define CLOCK_MODE_PROCESS 0
-#define CLOCK_MODE_WALL 1
-#if defined(_WIN32) || (defined(__GNUC__) && (defined(__i386__) || defined(__powerpc__) || defined(__ppc__)))
-#define CLOCK_MODE_CPU 2
-static double cpu_frequency;
-#endif
-
-#define INITIAL_STACK_SIZE 8
-
-static prof_clock_t
-clock_get_clock()
-{
-    return clock();
-}
-
-static double
-clock_clock2sec(prof_clock_t c)
-{
-    return (double) c / CLOCKS_PER_SEC;
-}
-
-static prof_clock_t
-gettimeofday_get_clock()
-{
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return tv.tv_sec * 1000000 + tv.tv_usec;
-}
-
-static double
-gettimeofday_clock2sec(prof_clock_t c)
-{
-    return (double) c / 1000000;
-}
-
-#ifdef CLOCK_MODE_CPU
-
-
-#if defined(__GNUC__)
-
-static prof_clock_t
-cpu_get_clock()
-{
-#if defined(__i386__)
-    unsigned long long x;
-    __asm__ __volatile__ ("rdtsc" : "=A" (x));
-    return x;
-#elif defined(__powerpc__) || defined(__ppc__)
-    unsigned long long x, y;
-
-    __asm__ __volatile__ ("\n\
-1:	mftbu   %1\n\
-	mftb    %L0\n\
-	mftbu   %0\n\
-	cmpw    %0,%1\n\
-	bne-    1b"
-	: "=r" (x), "=r" (y));
-    return x;
-#endif
-}
-
-#elif defined(_WIN32)
-
-static prof_clock_t
-cpu_get_clock()
-{
-    prof_clock_t cycles = 0;
-
-    __asm
-    {
-        rdtsc
-        mov DWORD PTR cycles, eax
-        mov DWORD PTR [cycles + 4], edx
-    }
-    return cycles;
-}
-
-#endif
-
-
-/* The _WIN32 check is needed for msys (and maybe cygwin?) */
-#if defined(__GNUC__) && !defined(_WIN32)
-
-double get_cpu_frequency()
-{
-    unsigned long long x, y;
-
-    struct timespec ts;
-    ts.tv_sec = 0;
-    ts.tv_nsec = 500000000;
-    x = cpu_get_clock();
-    nanosleep(&ts, NULL);
-    y = cpu_get_clock();
-    return (y - x) * 2;
-}
-
-#elif defined(_WIN32)
-
-double get_cpu_frequency()
-{
-    unsigned long long x, y;
-    double frequency;
-    x = cpu_get_clock();
-
-    /* Use the windows sleep function, not Ruby's */
-    Sleep(500);
-    y = cpu_get_clock();
-    frequency = 2*(y-x);
-    return frequency;
-}
-#endif
 
-static double
-cpu_clock2sec(prof_clock_t c)
-{
-    return (double) c / cpu_frequency;
-}
-
-/* call-seq:
-   cpu_frequency -> int
-
-Returns the cpu's frequency.  This value is needed when using the 
-cpu RubyProf::clock_mode. */
-static VALUE
-prof_get_cpu_frequency(VALUE self)
-{
-    return rb_float_new(cpu_frequency);
-}
-
-/* call-seq:
-   cpu_frequency=value -> void
-
-Sets the cpu's frequency.  This value is needed when using the 
-cpu RubyProf::clock_mode. */
-static VALUE
-prof_set_cpu_freqeuncy(VALUE self, VALUE val)
-{
-    cpu_frequency = NUM2DBL(val);
-    return val;
-}
-
-#endif
-
-static prof_clock_t (*get_clock)() = clock_get_clock;
-static double (*clock2sec)(prof_clock_t) = clock_clock2sec;
+/* ================  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;
 
 
+/* ================  Helper Functions  =================*/
 /* Helper method to get the id of a Ruby thread. */
-static inline int
+static inline long
 get_thread_id(VALUE thread)
 {
-    return NUM2INT(rb_obj_id(thread));
+    return NUM2ULONG(rb_obj_id(thread));
 }
 
 static VALUE
@@ -270,25 +171,24 @@ figure_singleton_name(VALUE klass)
        figure out what it is attached to.*/
     VALUE attached = rb_iv_get(klass, "__attached__");
 
-
     /* Is this a singleton class acting as a metaclass? */
-    if (TYPE(attached) == T_CLASS)
+    if (BUILTIN_TYPE(attached) == T_CLASS)
     {
         result = rb_str_new2("<Class::");
         rb_str_append(result, rb_inspect(attached));
-        rb_str_cat2(result, ">#");
+        rb_str_cat2(result, ">");
     }
 
     /* Is this for singleton methods on a module? */
-    else if (TYPE(attached) == T_MODULE)
+    else if (BUILTIN_TYPE(attached) == T_MODULE)
     {
         result = rb_str_new2("<Module::");
         rb_str_append(result, rb_inspect(attached));
-        rb_str_cat2(result, ">#");
+        rb_str_cat2(result, ">");
     }
 
-    /* Is it a regular singleton class for an object? */
-    else if (TYPE(attached) == T_OBJECT)
+    /* 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
@@ -296,79 +196,106 @@ figure_singleton_name(VALUE klass)
         VALUE super = rb_class_real(RCLASS(klass)->super);
         result = rb_str_new2("<Object::");
         rb_str_append(result, rb_inspect(super));
-        rb_str_cat2(result, ">#");
+        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
     {
-        /* Should never happen. */
-        result = rb_str_new2("<Unknown:");
-        rb_str_append(result, rb_inspect(klass));
-        rb_str_cat2(result, ">#");
-        rb_raise(rb_eRuntimeError, "Unknown singleton class: %i", result);
+        result = rb_inspect(klass);
     }
 
     return result;
 }
 
 static VALUE
-method_name(VALUE klass, ID mid)
+klass_name(VALUE klass)
 {
-    VALUE result;
-    VALUE method_name;
-
-    if (mid == ID_ALLOCATOR) 
-        method_name = rb_str_new2("allocate");
-    else
-        method_name = rb_String(ID2SYM(mid));
+    VALUE result = Qnil;
     
-
-    if (klass == Qnil)
-        result = rb_str_new2("#");
-    else if (TYPE(klass) == T_MODULE)
+    if (klass == 0 || klass == Qnil)
+    {
+        result = rb_str_new2("Global");
+    }
+    else if (BUILTIN_TYPE(klass) == T_MODULE)
     {
         result = rb_inspect(klass);
-        rb_str_cat2(result, "#");
     }
-    else if (TYPE(klass) == T_CLASS && FL_TEST(klass, FL_SINGLETON))
+    else if (BUILTIN_TYPE(klass) == T_CLASS && FL_TEST(klass, FL_SINGLETON))
     {
         result = figure_singleton_name(klass);
     }
-    else if (TYPE(klass) == T_CLASS)
+    else if (BUILTIN_TYPE(klass) == T_CLASS)
     {
         result = rb_inspect(klass);
-        rb_str_cat2(result, "#");
     }
     else
     {
         /* Should never happen. */
-        result = rb_str_new2("Unknown#");
-        rb_str_append(result, rb_inspect(klass));
-        rb_str_cat2(result, ">#");
-        rb_raise(rb_eRuntimeError, "Unsupported type in method name: %i\n", result);
+        result = rb_str_new2("Unknown");
     }
 
-    /* Last add in the method name */
-    rb_str_append(result, method_name);
+    return result;
+}
+
+static VALUE
+method_name(ID mid, int depth)
+{
+    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, "%i", depth);
+      rb_str_cat2(result, "-");
+      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;
+}
+
+
 static inline st_data_t
-method_key(VALUE klass, ID mid)
+method_key(VALUE klass, ID mid, int depth)
 {
-    return klass ^ mid;
+  /* 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   =================*/
 
-/* -- Stack to track methods call sequence and times ---- */
+/* 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;
-
-    stack = ALLOC(prof_stack_t);
-    stack->start = stack->ptr =
-	ALLOC_N(prof_data_t, INITIAL_STACK_SIZE);
+    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;
 }
@@ -380,100 +307,116 @@ stack_free(prof_stack_t *stack)
     xfree(stack);
 }
 
-static inline prof_data_t *
+static inline prof_frame_t *
 stack_push(prof_stack_t *stack)
 {
-    if (stack->ptr == stack->end) {
-	int len, new_capa;
-	len = stack->ptr - stack->start;
-	new_capa = (stack->end - stack->start) * 2;
-	REALLOC_N(stack->start, prof_data_t, new_capa);
-	stack->ptr = stack->start + len;
-	stack->end = stack->start + new_capa;
-    }
-    return stack->ptr++;
+  /* 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 inline prof_data_t *
+static inline prof_frame_t *
 stack_pop(prof_stack_t *stack)
 {
     if (stack->ptr == stack->start)
-	    return NULL;
+      return NULL;
     else
-	    return --stack->ptr;
+      return --stack->ptr;
 }
 
-static inline prof_data_t *
+static inline prof_frame_t *
 stack_peek(prof_stack_t *stack)
 {
     if (stack->ptr == stack->start)
-	    return NULL;
+      return NULL;
     else
-	    return stack->ptr - 1;
+      return stack->ptr - 1;
 }
 
+static inline size_t
+stack_size(prof_stack_t *stack)
+{
+    return stack->ptr - stack->start;
+}
 
+/* ================  Method Info Handling   =================*/
  
 /* --- Keeps track of the methods the current method calls */
 static st_table *
-minfo_table_create()
+method_info_table_create()
 {
     return st_init_numtable();
 }
 
-static inline int
-minfo_table_insert(st_table *table, st_data_t key, prof_method_t *val)
+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 *
-minfo_table_lookup(st_table *table, st_data_t key)
+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;
+    if (st_lookup(table, key, &val))
+    {
+      return (prof_method_t *) val;
     }
-    else {
-	    return NULL;
+    else 
+    {
+      return NULL;
     }
 }
 
+
 static void
-minfo_table_free(st_table *table)
+method_info_table_free(st_table *table)
 {
+    /* Don't free the contents since they are wrapped by
+       Ruby objects! */
     st_free_table(table);
 }
 
 
-/* ---- Hash, keyed on class/method_id, that holds
-        child call_info objects ---- */
+/* ================  Call Info Handling   =================*/
+
+/* ---- Hash, keyed on class/method_id, that holds call_info objects ---- */
 static st_table *
-child_table_create()
+caller_table_create()
 {
     return st_init_numtable();
 }
 
-static inline int
-child_table_insert(st_table *table, st_data_t key, prof_call_info_t *val)
+static inline size_t
+caller_table_insert(st_table *table, st_data_t key, prof_call_info_t *val)
 {
     return st_insert(table, key, (st_data_t) val);
 }
 
 static inline prof_call_info_t *
-child_table_lookup(st_table *table, st_data_t key)
+caller_table_lookup(st_table *table, st_data_t key)
 {
     st_data_t val;
-    if (st_lookup(table, key, &val)) {
-	    return (prof_call_info_t *) val;
+    if (st_lookup(table, key, &val))
+    {
+      return (prof_call_info_t *) val;
     }
-    else {
-	    return NULL;
+    else
+    {
+      return NULL;
     }
 }
 
 static void
-child_table_free(st_table *table)
+caller_table_free(st_table *table)
 {
     st_free_table(table);
 }
@@ -485,16 +428,16 @@ they took to execute. */
 
 /* :nodoc: */
 static prof_call_info_t *
-call_info_create(VALUE klass, ID mid)
+call_info_create(prof_method_t* method)
 {
     prof_call_info_t *result;
 
     result = ALLOC(prof_call_info_t);
-    result->klass = klass;
-    result->mid = mid;
+    result->target = method;
     result->called = 0;
     result->total_time = 0;
     result->self_time = 0;
+    result->wait_time = 0;
     return result;
 }
 
@@ -516,21 +459,37 @@ static VALUE
 call_info_new(prof_call_info_t *result)
 {
     /* We don't want Ruby freeing the underlying C structures, that
-       is when the prof_method_t is freed. */
+       is done when the prof_method_t is freed. */
     return Data_Wrap_Struct(cCallInfo, NULL, NULL, result);
 }
 
 static prof_call_info_t *
 get_call_info_result(VALUE obj)
 {
-    if (TYPE(obj) != T_DATA)
+    if (BUILTIN_TYPE(obj) != T_DATA)
     {
         /* Should never happen */
-	    rb_raise(rb_eTypeError, "Not a call info object");
+      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
+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);
+}
+
 /* call-seq:
    called -> int
 
@@ -543,6 +502,16 @@ call_info_called(VALUE self)
     return INT2NUM(result->called);
 }
 
+/* call-seq:
+   line_no -> int
+
+   returns the line number of the method */
+static VALUE
+call_info_line(VALUE self)
+{
+    return rb_int_new(get_call_info_result(self)->line);
+}
+
 /* call-seq:
    total_time -> float
 
@@ -552,7 +521,7 @@ call_info_total_time(VALUE self)
 {
     prof_call_info_t *result = get_call_info_result(self);
 
-    return rb_float_new(clock2sec(result->total_time));
+    return rb_float_new(convert_measurement(result->total_time));
 }
 
 /* call-seq:
@@ -564,7 +533,19 @@ call_info_self_time(VALUE self)
 {
     prof_call_info_t *result = get_call_info_result(self);
 
-    return rb_float_new(clock2sec(result->self_time));
+    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
+call_info_wait_time(VALUE self)
+{
+    prof_call_info_t *result = get_call_info_result(self);
+
+    return rb_float_new(convert_measurement(result->wait_time));
 }
 
 /* call-seq:
@@ -575,8 +556,8 @@ static VALUE
 call_info_children_time(VALUE self)
 {
     prof_call_info_t *result = get_call_info_result(self);
-    prof_clock_t children_time = result->total_time - result->self_time;
-    return rb_float_new(clock2sec(children_time));
+    prof_measure_t children_time = result->total_time - result->self_time - result->wait_time;
+    return rb_float_new(convert_measurement(children_time));
 }
 
 
@@ -591,24 +572,26 @@ the RubyProf::Result object.
 
 /* :nodoc: */
 static prof_method_t *
-prof_method_create(VALUE klass, ID mid, VALUE thread)
+prof_method_create(NODE *node, st_data_t key, VALUE klass, ID mid, int depth)
 {
-    prof_method_t *result;
-
-    /* Store reference to klass so it is not garbage collected */
-    rb_hash_aset(class_tbl, klass, Qnil);
+    prof_method_t *result = ALLOC(prof_method_t);
+    
+    result->klass = klass;
+    result->mid = mid;
+    result->key = key;
+    result->depth = depth;
 
-    result = ALLOC(prof_method_t);
-    result->key = method_key(klass, mid);
     result->called = 0;
     result->total_time = 0;
     result->self_time = 0;
-    result->klass = klass;
-    result->mid = mid;
-    result->thread_id = get_thread_id(thread);
-    result->parents = minfo_table_create();
-    result->children = child_table_create();
-    result->stack_count = 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 = (node ? node->nd_file : 0);
+    result->line =        (node ? nd_line(node) : 0);
     return result;
 }
 
@@ -621,28 +604,24 @@ prof_method_mark(prof_method_t *data)
 static void
 prof_method_free(prof_method_t *data)
 {
+    st_foreach(data->parents, free_call_infos, 0);
+    caller_table_free(data->parents); 
+    
     st_foreach(data->children, free_call_infos, 0);
-    minfo_table_free(data->parents);
-    child_table_free(data->children);
+    caller_table_free(data->children); 
+    
     xfree(data);
 }
 
 static VALUE
 prof_method_new(prof_method_t *result)
 {
-    return Data_Wrap_Struct(cMethodInfo, prof_method_mark, prof_method_free,
-			    result);
+    return Data_Wrap_Struct(cMethodInfo, prof_method_mark, prof_method_free, result);
 }
 
 static prof_method_t *
 get_prof_method(VALUE obj)
 {
-    if (TYPE(obj) != T_DATA ||
-	    RDATA(obj)->dfree != (RUBY_DATA_FUNC) prof_method_free)
-    {
-	    /* Should never happen */
-        rb_raise(rb_eTypeError, "wrong profile result");
-    }
     return (prof_method_t *) DATA_PTR(obj);
 }
 
@@ -668,7 +647,7 @@ prof_method_total_time(VALUE self)
 {
     prof_method_t *result = get_prof_method(self);
 
-    return rb_float_new(clock2sec(result->total_time));
+    return rb_float_new(convert_measurement(result->total_time));
 }
 
 /* call-seq:
@@ -680,39 +659,68 @@ prof_method_self_time(VALUE self)
 {
     prof_method_t *result = get_prof_method(self);
 
-    return rb_float_new(clock2sec(result->self_time));
+    return rb_float_new(convert_measurement(result->self_time));
 }
 
 /* call-seq:
-   children_time -> float
+   wait_time -> float
 
-Returns the total amount of time spent in this method's children. */
+Returns the total amount of time this method waited for other threads. */
 static VALUE
-prof_method_children_time(VALUE self)
+prof_method_wait_time(VALUE self)
 {
     prof_method_t *result = get_prof_method(self);
-    prof_clock_t children_time = result->total_time - result->self_time;
-    return rb_float_new(clock2sec(children_time));
+
+    return rb_float_new(convert_measurement(result->wait_time));
 }
 
 /* call-seq:
-   thread_id -> id
+   line_no -> int
 
-Returns the id of the thread that executed this method.*/
+   returns the line number of the method */
 static VALUE
-prof_thread_id(VALUE self)
+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));
+}
 
-    return INT2FIX(result->thread_id);
+/* 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 Qnil;
+    }
+    else
+    {
+      return rb_str_new2(sf);
+    }
 }
 
+
 /* call-seq:
    method_class -> klass
 
 Returns the Ruby klass that owns this method. */
 static VALUE
-prof_method_class(VALUE self)
+prof_method_klass(VALUE self)
 {
     prof_method_t *result = get_prof_method(self);
 
@@ -731,6 +739,19 @@ prof_method_id(VALUE self)
     return ID2SYM(result->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->klass);
+}
+
 /* call-seq:
    method_name -> string
 
@@ -741,100 +762,85 @@ static VALUE
 prof_method_name(VALUE self)
 {
     prof_method_t *method = get_prof_method(self);
-    return method_name(method->klass, method->mid);
-}
-   
-static int
-prof_method_collect_parents(st_data_t key, st_data_t value, st_data_t parents)
-{
-    prof_method_t *parent = (prof_method_t *) value;
-
-    rb_ary_push(parents, INT2FIX((int) parent));
-    return ST_CONTINUE;
+    return method_name(method->mid, method->depth);
 }
 
-
 /* call-seq:
-   parents -> hash
+   full_name -> string
+
+Returns the full name of this method in the format Object#method.*/
 
-Returns a hash table that lists all the methods that called this
-method (ie, parents). The hash table is keyed on method name and contains references
-to RubyProf::MethodInfo objects.*/
 static VALUE
-prof_method_parents(VALUE self)
+prof_full_name(VALUE self)
 {
-    VALUE result = rb_hash_new();
-    VALUE parents = rb_ary_new();
-    int len = 0;
-    int i = 0;
-
-    /* Get the list of parents */
-    prof_method_t *child = get_prof_method(self);
-    st_foreach(child->parents, prof_method_collect_parents, parents);
-
-    /* Iterate over each parent */
-    len = RARRAY(parents)->len;
-    for(i = 0; i<len; i++)
-    {
-        prof_call_info_t *call_info;
-
-        /* First get the parent */
-        VALUE item = rb_ary_entry(parents, i);
-        prof_method_t *parent = (prof_method_t *)(FIX2INT(item));
-        
-        /* Now get the call info */
-        call_info = child_table_lookup(parent->children, child->key);
-        
-        if (call_info == NULL)
-        {
-           /* Should never happen */
-            rb_raise(rb_eRuntimeError,
-                    "Could not find parent call info object for %s",
-                    method_name(child->klass, child->mid));
-        }
+    prof_method_t *method = get_prof_method(self);
+    return full_name(method->klass, method->mid, method->depth);
+}
 
-        /* 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 parent records in
-           a call graph. */
-        rb_hash_aset(result, method_name(parent->klass, parent->mid),
-                     call_info_new(call_info));
-    }
+/* call-seq:
+   called -> MethodInfo
 
-    return result;
+For recursively called methods, returns the base method.  Otherwise, 
+returns self. */
+static VALUE
+prof_method_base(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);
 }
 
-
 static int
-prof_method_collect_children(st_data_t key, st_data_t value, st_data_t result)
+prof_method_collect_call_infos(st_data_t key, st_data_t value, st_data_t result)
 {
-    prof_call_info_t *call_info = (prof_call_info_t *) value;
-    VALUE name = method_name(call_info->klass, call_info->mid);
-    VALUE hash = (VALUE) 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. */
-    rb_hash_aset(hash, name, call_info_new(call_info));
+    prof_call_info_t *call_info = (prof_call_info_t *) value;
+    VALUE arr = (VALUE) result;
+    rb_ary_push(arr, call_info_new(call_info));
     return ST_CONTINUE;
 }
 
 /* call-seq:
    children -> hash
 
-Returns a hash table that lists all the methods that this method 
-called (ie, children).  The hash table is keyed on method name 
-and contains references to RubyProf::CallInfo objects.*/
+Returns an array of call info objects of methods that this method 
+was called by (ie, parents).*/
+static VALUE
+prof_method_parents(VALUE self)
+{
+    /* 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;
+}
+
+
+/* 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)
 {
-    /* Returns a hash table, keyed on method name, of call info
-       objects for all methods that this method calls (children). */
+    /* Returns an array of call info objects for this
+       method's callees (the methods this method called). */
 
-    VALUE children = rb_hash_new();
+    VALUE children = rb_ary_new();
     prof_method_t *result = get_prof_method(self);
-    st_foreach(result->children, prof_method_collect_children, children);
+    st_foreach(result->children, prof_method_collect_call_infos, children);
     return children;
 }
 
@@ -847,56 +853,41 @@ prof_method_cmp(VALUE self, VALUE other)
     prof_method_t *x = get_prof_method(self);
     prof_method_t *y = get_prof_method(other);
 
-    /* Want toplevel to always be first */
-    if (x->klass == Qnil && x->mid == toplevel_id)
-    	return INT2FIX(1);
-    else if (y->klass == Qnil && y->mid == toplevel_id)
-    	return INT2FIX(-11);
+    if (x->called == 0)
+      return INT2FIX(1);
+    else if (y->called == 0)
+      return INT2FIX(-1);
     else if (x->total_time < y->total_time)
-    	return INT2FIX(-1);
+      return INT2FIX(-1);
     else if (x->total_time == y->total_time)
-    	return INT2FIX(0);
+      return INT2FIX(0);
     else
-		return INT2FIX(1);
+      return INT2FIX(1);
 }
 
 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;
-    VALUE hash = (VALUE) result;
-    VALUE base_name = method_name(method->klass, method->mid);
-    VALUE method_key = base_name;
-
-    /* Sanity check.  If we have generated the same method name for another prof_method 
-       then we will overrite a pre-existing MethodInfo object in the table.  
-       That would leave the original one unreferenced, which means it will 
-       be garbage collected which leads to segmentation faults.  */
-    VALUE existing_value = rb_hash_aref(hash, method_key);
-    
-    int i = 1;
-    while(existing_value != Qnil)
-    {
-        method_key = rb_str_dup(base_name);
-        rb_str_cat2(method_key, "_");
-        rb_str_concat(method_key, rb_inspect(INT2NUM(i)));
-        existing_value = rb_hash_aref(hash, method_key);
-        i++;
-    }
-
-    rb_hash_aset(hash, method_key, prof_method_new(method));
+    rb_ary_push(methods, prof_method_new(method));
 
     return ST_CONTINUE;
 }
 
 
+/* ================  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->minfo_table = minfo_table_create();
+    result->method_info_table = method_info_table_create();
+    result->last_switch = 0;
     return result;
 }
 
@@ -904,7 +895,7 @@ static void
 thread_data_free(thread_data_t* thread_data)
 {
     stack_free(thread_data->stack);
-    minfo_table_free(thread_data->minfo_table);
+    method_info_table_free(thread_data->method_info_table);
     xfree(thread_data);
 }
 
@@ -918,7 +909,7 @@ threads_table_create()
     return st_init_numtable();
 }
 
-static inline int
+static inline 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. */
@@ -934,34 +925,21 @@ threads_table_lookup(st_table *table, VALUE thread)
     /* Its too slow to key on the real thread id so just typecast thread instead. */
     if (st_lookup(table, (st_data_t) thread, &val))
     {
-	    result = (thread_data_t *) val;
+      result = (thread_data_t *) val;
     }
     else
     {
-        prof_method_t *toplevel;
         result = thread_data_create();
+
         /* Store the real thread id here so it can be shown in the results. */
         result->thread_id = get_thread_id(thread);
 
-        /* Add a toplevel method to the thread */
-        toplevel = prof_method_create(Qnil, toplevel_id, thread);
-        toplevel->called = 1;
-        toplevel->total_time = 0;
-        toplevel->self_time = 0;
-        minfo_table_insert(result->minfo_table, toplevel->key, toplevel);
-
         /* Insert the table */
         threads_table_insert(threads_tbl, thread, result);
-	}
+    }
     return result;
 }
 
-static void
-threads_table_free(st_table *table)
-{
-    st_free_table(table);
-}
-
 static int
 free_thread_data(st_data_t key, st_data_t value, st_data_t dummy)
 {
@@ -969,12 +947,15 @@ free_thread_data(st_data_t key, st_data_t value, st_data_t dummy)
     return ST_CONTINUE;
 }
 
+
 static void
-free_threads(st_table* thread_table)
+threads_table_free(st_table *table)
 {
-    st_foreach(thread_table, free_thread_data, 0);
+    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)
 {
@@ -984,166 +965,271 @@ 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 minfo_hash = rb_hash_new();
-    st_foreach(thread_data->minfo_table, collect_methods, minfo_hash);
-    rb_hash_aset(threads_hash, INT2NUM(thread_data->thread_id), minfo_hash);
+    
+    VALUE methods = rb_ary_new();
+    
+    /* Now collect an array of all the called methods */
+    st_foreach(thread_data->method_info_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);
 
     return ST_CONTINUE;
 }
 
-static void
-update_result(prof_method_t * parent, prof_method_t *child,
-              prof_clock_t total_time, prof_clock_t self_time)
+
+/* ================  Profiling    =================*/
+/* Copied from eval.c */
+static char *
+get_event_name(rb_event_t event)
 {
-    /* Update child information on parent (ie, the method that
-       called the current method) */
-    prof_call_info_t *parent_call_info = child_table_lookup(parent->children, child->key);
-    if (parent_call_info == NULL)
-    {
-        parent_call_info = call_info_create(child->klass, child->mid);
-        child_table_insert(parent->children, child->key, parent_call_info);
+  switch (event) {
+    case RUBY_EVENT_LINE:
+	return "line";
+    case RUBY_EVENT_CLASS:
+	return "class";
+    case RUBY_EVENT_END:
+	return "end";
+    case RUBY_EVENT_CALL:
+	return "call";
+    case RUBY_EVENT_RETURN:
+	return "return";
+    case RUBY_EVENT_C_CALL:
+	return "c-call";
+    case RUBY_EVENT_C_RETURN:
+	return "c-return";
+    case RUBY_EVENT_RAISE:
+	return "raise";
+    default:
+	return "unknown";
     }
+}
 
-    parent_call_info->called++;
-    parent_call_info->total_time += total_time;
-    parent_call_info->self_time += self_time;
-
-    /* Slight hack here - if the child is the top level method then we want
-       to update its total time */
-    if (parent->key == toplevel_key)
-        parent->total_time += total_time;
+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;
+    
+    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 child (ie, the current method) */
     child->called++;
     child->total_time += total_time;
     child->self_time += self_time;
+    child->wait_time += wait_time;
+
+    if (!parent_frame) return;
+    
+    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);
+    }
 
-    /* Store pointer to parent */
-    if (minfo_table_lookup(child->parents, parent->key) == NULL)
-        minfo_table_insert(child->parents, parent->key, parent);
+    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);
+    
+    
+    /* 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)
+    {
+      parent->total_time += total_time;
+      parent->wait_time += wait_time;
+    }
 }
 
+
 static void
 prof_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 {
-    static int profiling = 0;
+    
     VALUE thread;
-    thread_data_t* thread_data;
-    prof_data_t *data;
+    prof_measure_t now = 0;
+    thread_data_t* thread_data = NULL;
+    prof_frame_t *frame = NULL;
+    
+    
+/*    {
+        st_data_t key = 0;
+        static unsigned long last_thread_id = 0;
+
+        VALUE thread = rb_thread_current();
+        unsigned long thread_id = get_thread_id(thread);
+        char* class_name = rb_obj_classname(klass);
+        char* method_name = rb_id2name(mid);
+        char* source_file = node ? node->nd_file : 0;
+        unsigned int source_line = node ? nd_line(node) : 0;
+        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);
+        last_thread_id = thread_id;               
+    } */
     
-    if (profiling) return;
-
     /* Special case - skip any methods from the mProf 
        module, such as Prof.stop, since they clutter
-       the results but are not important to the results. */
+       the results but aren't important to them results. */
     if (self == mProf) return;
 
-    /* Set flag showing we have started profiling */
-    profiling++;
-
-    /* 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 (BUILTIN_TYPE(klass) == T_ICLASS)
-        klass = RBASIC(klass)->klass;
-      
-    /* // Debug Code
-    {
-        VALUE class_name = rb_String(klass);
-        char* c_class_name = StringValuePtr(class_name);
-        char* c_method_name = rb_id2name(mid);
-        VALUE generated_name = method_name(klass, mid);
-        char* c_generated_name = StringValuePtr(generated_name);
-        printf("Event: %2d, Method: %s#%s\n", event, c_class_name, c_method_name);
-    }*/
-
+    /* Get current measurement*/
+    now = get_measurement();
+    
+    /* Get the current thread and thread data. */
     thread = rb_thread_current();
     thread_data = threads_table_lookup(threads_tbl, thread);
-  
+    
+    /* 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);
+    
+    /* Check for a context switch */
+    if (last_thread_data && last_thread_data != thread_data)
+    {
+      /* Note how long have we been waiting. */
+      prof_measure_t wait_time = now - thread_data->last_switch;
+      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.*/
+      last_thread_data->last_switch = now;
+      thread_data->last_switch = 0;
+    }
+    last_thread_data = 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 
+         called from. */
+      if (frame)
+      {
+        if (node)
+          frame->line = nd_line(node);
+        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. */
+    }
     case RUBY_EVENT_CALL:
     case RUBY_EVENT_C_CALL:
     {
-        st_data_t key = method_key(klass, mid);
-        prof_method_t *child = minfo_table_lookup(thread_data->minfo_table, key);
-
-	    if (child == NULL) {
-		    child = prof_method_create(klass, mid, thread);
-		    minfo_table_insert(thread_data->minfo_table, key, child);
-	    }
+        int depth = 0;
+        st_data_t key = 0;
+        prof_method_t *method = NULL;
+        
+        /* 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);
+          
+        key = method_key(klass, mid, 0);
+   
+        method = method_info_table_lookup(thread_data->method_info_table, key);
+        
+        if (!method)
+        {
+          method = prof_method_create(node, key, klass, mid, depth);
+          method_info_table_insert(thread_data->method_info_table, key, method);
+        }
+        
+        depth = method->active_frame;
+        method->active_frame++;                  
+        
+        if (depth > 0)
+        {
+          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)
+          {
+            method = prof_method_create(node, key, klass, mid, depth);
+            method->base = base_method;
+            method_info_table_insert(thread_data->method_info_table, key, method);
+          }
+        }
 
-        /* Increment count of number of times this child has been called on
-           the current stack. */
-        child->stack_count++;
-    
-        /* Push the data for this method onto our stack */
-        data = stack_push(thread_data->stack);
-        data->method_info = child;
-	    data->start_time = get_clock();
-	    data->child_cost = 0;
+        /* Push a new frame onto the stack */
+        frame = stack_push(thread_data->stack);
+        frame->method = method;
+        frame->start_time = now;
+        frame->wait_time = 0;
+        frame->child_time = 0;
+        frame->line = node ? nd_line(node) : 0;
 
-	    break;
+        break;
     }
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_C_RETURN:
-	{
-        prof_data_t* caller;
-	    prof_method_t *parent;
-	    prof_method_t *child;
-        prof_clock_t now = get_clock();
-	    prof_clock_t total_time, self_time;
-
-        /* Pop data for this method off the stack. */
-	    data = stack_pop(thread_data->stack);
+    {
+        prof_frame_t* caller_frame = NULL;
 
-        if (data == NULL)
-        {
-            /* Can happen on exceptions.  The stack gets unwound without RubyProf.stop
-               being called. */
-            VALUE name = method_name(klass, mid);
-            VALUE message = rb_str_new2("ruby-prof: An error occured when leaving the method %s.\n");
-            rb_str_cat2(message, "   Perhaps an exception occured in the code being profiled?\n" );
-            rb_warn(StringValuePtr(message), StringValuePtr(name));
-                    
-            return;
-        }
+        prof_measure_t total_time;
 
-        /* Update timing information. */
-        total_time = now - data->start_time;
-        self_time = total_time - data->child_cost;
+        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;
 
-        /* Okay, get the method that called this method (ie, parent) */
-        caller = stack_peek(thread_data->stack);
+        total_time = now - frame->start_time;
 
-	    if (caller == NULL)
+        if (caller_frame)
         {
-            /* We are at the top of the stack, so grab the toplevel method */
-            parent = minfo_table_lookup(thread_data->minfo_table, toplevel_key);
-        }
-        else
-        {
-            caller->child_cost += total_time;
-    	    parent = caller->method_info;
+            caller_frame->child_time += total_time;
         }
+          
+        frame->method->base->active_frame--;
         
-        /* Decrement count of number of times this child has been called on
-           the current stack. */
-        child = data->method_info;
-        child->stack_count--;
-
-        /* If the stack count is greater than zero, then this
-           method has been called recursively.  In that case set the total
-           time to zero because it will be correctly set when we unwind
-           the stack up.  If we don't do this, then the total time for the 
-           method will be double counted per recursive call. */
-        if (child->stack_count != 0)
-            total_time = 0;
-
-        update_result(parent, child, total_time, self_time);
-	    break;
-	}
+        update_result(thread_data, total_time, caller_frame, frame);
+        break;
+      }
     }
-    profiling--;
 }
 
 
@@ -1192,11 +1278,11 @@ prof_result_new()
 static prof_result_t *
 get_prof_result(VALUE obj)
 {
-    if (TYPE(obj) != T_DATA ||
-	    RDATA(obj)->dfree != (RUBY_DATA_FUNC) prof_result_free)
+    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");
+      rb_raise(rb_eTypeError, "wrong result object");
     }
     return (prof_result_t *) DATA_PTR(obj);
 }
@@ -1217,83 +1303,74 @@ prof_result_threads(VALUE self)
 }
 
 
-/* call-seq:
-   thread_id = int
-   toplevel(thread_id) -> RubyProf::MethodInfo
-
-Returns the RubyProf::MethodInfo object that represents the root
-calling method for this thread.  This method will always
-be named #toplevel and contains the total amount of time spent
-executing code in this thread. */
-static VALUE
-prof_result_toplevel(VALUE self, VALUE thread_id)
-{
-    prof_result_t *prof_result = get_prof_result(self);
-    VALUE methods = rb_hash_aref(prof_result->threads, thread_id);
-    VALUE key = method_name(Qnil, toplevel_id);
-    VALUE result = rb_hash_aref(methods, key);
-
-    if (result == Qnil)
-    {
-        /* Should never happen */
-	    rb_raise(rb_eRuntimeError, "Could not find toplevel method information");
-    }
-    return result;
-}
-
 
 /* call-seq:
-   clock_mode -> clock_mode
+   measure_mode -> measure_mode
+   
+   Returns what ruby-prof is measuring.  Valid values include:
    
-   Returns the current clock mode.  Valid values include:
-   *RubyProf::PROCESS_TIME - Measure process time.  This is default.  It is implemented using the clock function in the C Runtime library.
+   *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::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.*/
 static VALUE
-prof_get_clock_mode(VALUE self)
+prof_get_measure_mode(VALUE self)
 {
-    return INT2NUM(clock_mode);
+    return INT2NUM(measure_mode);
 }
 
 /* call-seq:
-   clock_mode=value -> void
+   measure_mode=value -> void
    
-   Specifies the method ruby-prof uses to measure time.  Valid values include:
-   *RubyProf::PROCESS_TIME - Measure process time.  This is default.  It is implemented using the clock function in the C Runtime library.
+   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::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.*/
 static VALUE
-prof_set_clock_mode(VALUE self, VALUE val)
+prof_set_measure_mode(VALUE self, VALUE val)
 {
-    int mode = NUM2INT(val);
+    long mode = NUM2LONG(val);
 
     if (threads_tbl)
     {
-	    rb_raise(rb_eRuntimeError, "can't set clock_mode while profiling");
+      rb_raise(rb_eRuntimeError, "can't set measure_mode while profiling");
     }
 
     switch (mode) {
-    case CLOCK_MODE_PROCESS:
-    	get_clock = clock_get_clock;
-	    clock2sec = clock_clock2sec;
-    	break;
-    case CLOCK_MODE_WALL:
-	    get_clock = gettimeofday_get_clock;
-	    clock2sec = gettimeofday_clock2sec;
-	    break;
-#ifdef CLOCK_MODE_CPU
-    case CLOCK_MODE_CPU:
-	    if (cpu_frequency == 0)
-	        cpu_frequency = get_cpu_frequency();
-	        get_clock = cpu_get_clock;
-	        clock2sec = cpu_clock2sec;
-	    break;
-#endif
-    default:
-	    rb_raise(rb_eArgError, "invalid mode: %d", mode);
-	break;
+      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 = measure_cpu_time();
+        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
+        
+      default:
+        rb_raise(rb_eArgError, "invalid mode: %d", mode);
+        break;
     }
-    clock_mode = mode;
+    
+    measure_mode = mode;
     return val;
 }
 
@@ -1320,21 +1397,19 @@ prof_running(VALUE self)
 static VALUE
 prof_start(VALUE self)
 {
-    toplevel_id = rb_intern("toplevel");
-    toplevel_key = method_key(Qnil, toplevel_id);
-
     if (threads_tbl != NULL)
     {
         rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
     }
 
     /* Setup globals */
-    class_tbl = rb_hash_new();
+    last_thread_data = NULL;
     threads_tbl = threads_table_create();
     
     rb_add_event_hook(prof_event_hook,
-        RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
-        RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN);
+          RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
+          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN 
+          | RUBY_EVENT_LINE);
 
     return Qnil;
 }
@@ -1351,7 +1426,7 @@ prof_stop(VALUE self)
 
     if (threads_tbl == NULL)
     {
-        rb_raise(rb_eRuntimeError, "RubyProf.start is not called yet");
+        rb_raise(rb_eRuntimeError, "RubyProf is not running.");
     }
 
     /* Now unregister from event   */
@@ -1360,14 +1435,12 @@ prof_stop(VALUE self)
     /* Create the result */
     result = prof_result_new();
 
-    /* Free threads table */
-    free_threads(threads_tbl);
+    /* Unset the last_thread_data (very important!) 
+       and the threads table */
+    last_thread_data = NULL;
     threads_table_free(threads_tbl);
     threads_tbl = NULL;
 
-    /* Free reference to class_tbl */
-    class_tbl = Qnil;
-    
     return result;
 }
 
@@ -1403,46 +1476,57 @@ Init_ruby_prof()
     rb_define_module_function(mProf, "stop", prof_stop, 0);
     rb_define_module_function(mProf, "running?", prof_running, 0);
     rb_define_module_function(mProf, "profile", prof_profile, 0);
-    rb_define_singleton_method(mProf, "clock_mode", prof_get_clock_mode, 0);
-    rb_define_singleton_method(mProf, "clock_mode=", prof_set_clock_mode, 1);
-    rb_define_const(mProf, "PROCESS_TIME", INT2NUM(CLOCK_MODE_PROCESS));
-    rb_define_const(mProf, "WALL_TIME", INT2NUM(CLOCK_MODE_WALL));
-#ifdef CLOCK_MODE_CPU
-    rb_define_const(mProf, "CPU_TIME", INT2NUM(CLOCK_MODE_CPU));
-    rb_define_singleton_method(mProf, "cpu_frequency",
-			       prof_get_cpu_frequency, 0);
-    rb_define_singleton_method(mProf, "cpu_frequency=",
-			       prof_set_cpu_freqeuncy, 1);
-#endif
+    
+    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, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
+    rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
+
+    #if defined(MEASURE_CPU_TIME)
+    rb_define_const(mProf, "CPU_TIME", INT2NUM(MEASURE_CPU_TIME));
+    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
+        
+    #if defined(MEASURE_ALLOCATIONS)
+    rb_define_const(mProf, "ALLOCATED_OBJECTS", INT2NUM(MEASURE_ALLOCATIONS));
+    #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);
-    rb_define_method(cResult, "toplevel", prof_result_toplevel, 1);
 
     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, "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, "children_time", prof_method_children_time, 0);
-    rb_define_method(cMethodInfo, "name", prof_method_name, 0);
-    rb_define_method(cMethodInfo, "method_class", prof_method_class, 0);
+    
+    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, "thread_id", prof_thread_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);
 
     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_global_variable(&class_tbl);
 }
 
-/* vim: set filetype=c ts=8 sw=4 noexpandtab : */