ruby-prof-danielhoey 0.8.1

data/ext/ruby_prof/call_tree.h

@@ -0,0 +1,32 @@
+#ifndef CALL_TREE
+#define CALL_TREE 
+
+#include <ruby.h>
+#include <st.h>
+#include "measurement.h"
+
+void init_call_tree();
+VALUE call_tree_create_root();
+VALUE call_tree_create_thread(VALUE parent, char* thread_id, char* file, prof_measure_t time);
+
+VALUE call_tree_initialize(VALUE self, VALUE parent, VALUE klass_text, VALUE method, char* file);
+VALUE call_tree_initialize_copy(VALUE copy, VALUE original);
+VALUE call_tree_children(VALUE self);
+VALUE call_tree_fetch(VALUE self, VALUE index);
+VALUE call_tree_add(VALUE self, ID klass, ID mid, char* file);
+VALUE call_tree_size(VALUE self);
+VALUE call_tree_find_child(VALUE self, ID klass, ID mid, char* file);
+VALUE call_tree_method_start(VALUE self, VALUE klass_text, ID mid, char* file, prof_measure_t time);
+VALUE call_tree_method_stop(VALUE self, prof_measure_t time);
+void call_tree_method_pause(VALUE self, prof_measure_t time);
+void call_tree_method_resume(VALUE self, prof_measure_t time);
+VALUE call_tree_to_s(VALUE self);
+
+VALUE call_tree_parent(VALUE self);
+VALUE call_tree_method(VALUE self);
+VALUE call_tree_klass(VALUE self);
+VALUE call_tree_time(VALUE self);
+VALUE call_tree_file(VALUE self);
+VALUE call_tree_call_count(VALUE self);
+
+#endif

data/ext/ruby_prof/extconf.rb

@@ -0,0 +1,40 @@
+require "mkmf"
+
+if RUBY_VERSION >= "1.9"
+  if RUBY_RELEASE_DATE < "2005-03-17"
+    STDERR.print("Ruby version is too old\n")
+    exit(1)
+  end
+elsif RUBY_VERSION >= "1.8"
+  if RUBY_RELEASE_DATE < "2005-03-22"
+    STDERR.print("Ruby version is too old\n")
+    exit(1)
+  end
+else
+  STDERR.print("Ruby version is too old\n")
+  exit(1)
+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")
+
+def add_define(name)
+  $defs.push("-D#{name}")
+end
+
+add_define 'DEBUG' if $DEBUG
+
+create_makefile("ruby_prof")

data/ext/ruby_prof/list.c

@@ -0,0 +1,66 @@
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+#include <assert.h>
+#include <ruby.h>
+#include "list.h"
+
+typedef struct list_t{
+  int allocated_size;
+  int assigned_size;
+  list_data_t* data;
+} list_t;
+
+
+list new_list(int size)
+{
+    list new_list = (list) ALLOC(list_t);
+    list_data_t* data = (list_data_t*) ALLOC_N(list_data_t, size);
+
+    new_list->allocated_size = size;
+    new_list->assigned_size = 0;
+    new_list->data = data;
+
+    return new_list;
+}
+
+void delete_list(list l)
+{
+    xfree(l->data);
+}
+
+void list_add(list l, list_data_t item)
+{
+    if (l->assigned_size >= l->allocated_size)
+    {
+        int new_allocated_size = l->allocated_size*2;
+        list_data_t* new_data = (list_data_t*) ALLOC_N(list_data_t, new_allocated_size);
+        int i;
+        for (i=0; i<l->allocated_size; i++)
+        {
+            new_data[i] = l->data[i]; 
+        }
+        xfree(l->data);
+        l->data = new_data;
+        l->allocated_size = new_allocated_size;
+    }
+
+    l->data[l->assigned_size] = item;
+    l->assigned_size++; 
+}
+
+list_data_t list_get(list l, int index)
+{
+    assert(index < l->allocated_size);
+    return l->data[index];
+}
+
+int list_size(list l)
+{
+    return l->assigned_size;
+}
+
+list_data_t* list_data(list l)
+{
+    return l->data;
+}

data/ext/ruby_prof/list.h

@@ -0,0 +1,10 @@
+#include <ruby.h>
+
+typedef struct list_t* list;
+typedef VALUE list_data_t;
+
+list new_list(int size);
+void list_add(list l, list_data_t data);
+list_data_t list_get(list l, int index);
+int list_size(list l);
+list_data_t* list_data(list l);

data/ext/ruby_prof/measure_allocations.h

@@ -0,0 +1,58 @@
+/* :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. */
+
+#include <ruby.h>
+
+#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
+#define MEASURE_ALLOCATIONS 3
+ 
+static prof_measure_t
+measure_allocations()
+{ 
+    return rb_os_allocated_objects(); 
+}
+
+static double
+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/ruby_prof/measure_cpu_time.h

@@ -0,0 +1,152 @@
+/* :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. */
+
+#include <ruby.h>
+
+#if defined(_WIN32) || (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__) || defined(__powerpc__) || defined(__ppc__)))
+#define MEASURE_CPU_TIME 2
+
+static unsigned LONG_LONG cpu_frequency;
+
+#if defined(__GNUC__)
+
+#include <stdint.h>
+
+static prof_measure_t
+measure_cpu_time()
+{
+#if defined(__i386__) || defined(__x86_64__) 
+    uint32_t a, d;
+    __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));
+    return ((uint64_t)d << 32) + a;
+#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_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
+
+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 ULL2NUM(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 = NUM2LL(val);
+    return val;
+}
+
+#endif

data/ext/ruby_prof/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/ruby_prof/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