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

data/ext/ruby_prof/rp_measure.c

@@ -0,0 +1,48 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_prof.h"
+
+VALUE mMeasure;
+
+prof_measurer_t* prof_get_measurer(prof_measure_mode_t measure)
+{
+    switch (measure)
+    {
+    case MEASURE_ALLOCATIONS:
+      return prof_measurer_allocations();
+      break;
+    case MEASURE_CPU_TIME:
+      return prof_measurer_cpu_time();
+      break;
+    case MEASURE_GC_RUNS:
+      return prof_measurer_gc_runs();
+      break;
+    case MEASURE_GC_TIME:
+      return prof_measurer_gc_time();
+      break;
+    case MEASURE_MEMORY:
+      return prof_measurer_memory();
+      break;
+    case MEASURE_PROCESS_TIME:
+      return prof_measurer_process_time();
+      break;
+    case MEASURE_WALL_TIME:
+      return prof_measurer_wall_time();
+      break;
+	default:
+	  rb_raise(rb_eArgError, "Unknown measure mode: %d", measure);
+    }
+};
+
+void rp_init_measure()
+{
+    mMeasure = rb_define_module_under(mProf, "Measure");
+    rp_init_measure_allocations();
+    rp_init_measure_cpu_time();
+    rp_init_measure_gc_runs();
+    rp_init_measure_gc_time();
+    rp_init_measure_memory();
+    rp_init_measure_process_time();
+    rp_init_measure_wall_time();
+}

data/ext/ruby_prof/rp_measure.h

@@ -0,0 +1,45 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_MEASUREMENT_H__
+#define __RP_MEASUREMENT_H__
+
+extern VALUE mMeasure;
+
+typedef double (*get_measurement)();
+
+typedef struct
+{
+    get_measurement measure;
+} prof_measurer_t;
+
+typedef enum 
+{
+    MEASURE_ALLOCATIONS,
+    MEASURE_CPU_TIME,
+    MEASURE_GC_RUNS,
+    MEASURE_GC_TIME,
+    MEASURE_MEMORY,
+    MEASURE_PROCESS_TIME,
+    MEASURE_WALL_TIME,
+} prof_measure_mode_t;
+
+prof_measurer_t* prof_get_measurer(prof_measure_mode_t measure);
+prof_measurer_t* prof_measurer_allocations();
+prof_measurer_t* prof_measurer_cpu_time();
+prof_measurer_t* prof_measurer_gc_runs();
+prof_measurer_t* prof_measurer_gc_time();
+prof_measurer_t* prof_measurer_memory();
+prof_measurer_t* prof_measurer_process_time();
+prof_measurer_t* prof_measurer_wall_time();
+
+void rp_init_measure();
+void rp_init_measure_allocations();
+void rp_init_measure_cpu_time();
+void rp_init_measure_gc_runs();
+void rp_init_measure_gc_time();
+void rp_init_measure_memory();
+void rp_init_measure_process_time();
+void rp_init_measure_wall_time();
+
+#endif //__RP_MEASUREMENT_H__

data/ext/ruby_prof/rp_measure_allocations.c

@@ -0,0 +1,86 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+/* :nodoc: */
+
+#include "ruby_prof.h"
+
+static VALUE cMeasureAllocations;
+
+#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
+#define MEASURE_ALLOCATIONS_ENABLED Qtrue
+
+static double
+measure_allocations()
+{
+    return rb_os_allocated_objects();
+}
+
+/* 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
+}
+
+#elif defined(HAVE_RB_GC_MALLOC_ALLOCATIONS)
+
+#define MEASURE_ALLOCATIONS_ENABLED Qtrue
+
+static double
+measure_allocations()
+{
+    return rb_gc_malloc_allocations();
+}
+
+#else
+
+#define MEASURE_ALLOCATIONS_ENABLED Qfalse
+
+static double
+measure_allocations()
+{
+    return 0;
+}
+
+#endif
+
+
+prof_measurer_t* prof_measurer_allocations()
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->measure = measure_allocations;
+  return measure;
+}
+
+/* call-seq:
+     measure -> int
+
+Returns the number of Ruby object allocations. */
+
+static VALUE
+prof_measure_allocations(VALUE self)
+{
+#if defined(HAVE_LONG_LONG)
+    return ULL2NUM(measure_allocations());
+#else
+    return ULONG2NUM(measure_allocations());
+#endif
+}
+
+void rp_init_measure_allocations()
+{
+    rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));
+    rb_define_const(mProf, "ALLOCATIONS_ENABLED", MEASURE_ALLOCATIONS_ENABLED);
+
+    cMeasureAllocations = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
+    rb_define_singleton_method(cMeasureAllocations, "measure", prof_measure_allocations, 0);    
+}

data/ext/ruby_prof/rp_measure_cpu_time.c

@@ -0,0 +1,112 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_prof.h"
+
+static VALUE cMeasureCpuTime;
+
+static unsigned long long cpu_frequency = 0;
+
+/* The _WIN32 check is needed for msys (and maybe cygwin?) */
+#if defined(__GNUC__) && !defined(_WIN32)
+
+#include <stdint.h>
+#include <time.h>
+
+static unsigned long long get_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
+}
+
+static unsigned long long get_cpu_frequency()
+{
+    unsigned long long x, y;
+
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = 500000000;
+    x = get_cpu_time();
+    nanosleep(&ts, NULL);
+    y = get_cpu_time();
+    return (y - x) * 2;
+}
+
+#elif defined(_WIN32)
+
+static unsigned long long get_cpu_time()
+{
+	LARGE_INTEGER time;
+	QueryPerformanceCounter(&time);
+	return time.QuadPart;
+};
+
+static unsigned long long get_cpu_frequency()
+{
+	LARGE_INTEGER cpu_frequency;
+	QueryPerformanceFrequency(&cpu_frequency);
+	return cpu_frequency.QuadPart;
+};
+#endif
+
+static double
+measure_cpu_time()
+{
+    return ((double)get_cpu_time()) / cpu_frequency;
+}
+
+
+prof_measurer_t* prof_measurer_cpu_time()
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->measure = measure_cpu_time;
+  return measure;
+}
+
+/* call-seq:
+   measure -> float
+
+Returns the cpu time.*/
+static VALUE
+prof_measure_cpu_time(VALUE self)
+{
+    return rb_float_new(measure_cpu_time());
+}
+
+/* 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);
+}
+
+void rp_init_measure_cpu_time()
+{
+    rb_define_const(mProf, "CPU_TIME", INT2NUM(MEASURE_CPU_TIME));
+	rb_define_const(mProf, "CPU_TIME_ENABLED", Qtrue);
+
+    cMeasureCpuTime = rb_define_class_under(mMeasure, "CpuTime", rb_cObject);
+    rb_define_singleton_method(cMeasureCpuTime, "measure", prof_measure_cpu_time, 0);
+    rb_define_singleton_method(cMeasureCpuTime, "frequency", prof_get_cpu_frequency, 0);
+
+    /* Get cpu_frequency */
+    cpu_frequency = get_cpu_frequency();
+}

data/ext/ruby_prof/rp_measure_gc_runs.c

@@ -0,0 +1,87 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+/* :nodoc: */
+
+#include "ruby_prof.h"
+
+static VALUE cMeasureGcRuns;
+
+#if defined(HAVE_RB_GC_COLLECTIONS)
+
+#define MEASURE_GC_RUNS_ENABLED Qtrue
+
+static double
+measure_gc_runs()
+{
+    return NUM2INT(rb_gc_collections());
+}
+
+/* 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_ENABLED Qtrue
+
+static double
+measure_gc_runs()
+{
+  VALUE h = rb_gc_heap_info();
+  return NUM2UINT(rb_hash_aref(h, rb_str_new2("num_gc_passes")));
+}
+
+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"));
+}
+
+#else 
+
+#define MEASURE_GC_RUNS_ENABLED Qfalse
+
+static double
+measure_gc_runs()
+{
+  return 0;
+}
+#endif
+
+prof_measurer_t* prof_measurer_gc_runs()
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->measure = measure_gc_runs;
+  return measure;
+}
+
+/* call-seq:
+   measure -> int
+
+Returns the number of GC runs.*/
+static VALUE
+prof_measure_gc_runs(VALUE self)
+{
+#if defined(HAVE_LONG_LONG)
+    return ULL2NUM(measure_gc_runs());
+#else
+    return ULONG2NUM(measure_gc_runs());
+#endif
+}
+
+void rp_init_measure_gc_runs()
+{
+    rb_define_const(mProf, "GC_RUNS", INT2NUM(MEASURE_GC_RUNS));
+    rb_define_const(mProf, "GC_RUNS_ENABLED", MEASURE_GC_RUNS_ENABLED);
+	
+    cMeasureGcRuns = rb_define_class_under(mMeasure, "GcRuns", rb_cObject);
+    rb_define_singleton_method(cMeasureGcRuns, "measure", prof_measure_gc_runs, 0);
+}

data/ext/ruby_prof/rp_measure_gc_time.c

@@ -0,0 +1,73 @@
+/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+/* :nodoc: */
+
+#include "ruby_prof.h"
+
+static VALUE cMeasureGcTimes;
+
+#if defined(HAVE_RB_GC_TIME)
+
+#define MEASURE_GC_TIME_ENABLED Qtrue
+
+static double
+measure_gc_time()
+{
+    int conversion = 1000000
+#if HAVE_LONG_LONG
+    return NUM2LL(rb_gc_time() / conversion);
+#else
+    return NUM2LONG(rb_gc_time() / conversion));
+#endif
+}
+
+/* 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();
+}
+
+#else
+
+#define MEASURE_GC_TIME_ENABLED Qfalse
+
+static double
+measure_gc_time()
+{
+    return 0;
+}
+#endif
+
+prof_measurer_t* prof_measurer_gc_time()
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->measure = measure_gc_time;
+  return measure;
+}
+
+/* call-seq:
+   measure -> float
+
+Returns the number of GC runs.*/
+static VALUE
+prof_measure_gc_time(VALUE self)
+{
+#if defined(HAVE_LONG_LONG)
+    return ULL2NUM(measure_gc_time());
+#else
+    return ULONG2NUM(measure_gc_time());
+#endif
+}
+void rp_init_measure_gc_time()
+{
+    rb_define_const(mProf, "GC_TIME", INT2NUM(MEASURE_GC_TIME));
+    rb_define_const(mProf, "GC_TIME_ENABLED", MEASURE_GC_TIME_ENABLED);
+
+    cMeasureGcTimes = rb_define_class_under(mMeasure, "GcTime", rb_cObject);
+    rb_define_singleton_method(cMeasureGcTimes, "measure", prof_measure_gc_time, 0);
+}