ruby-prof 0.18.0 → 1.0.0

data/ext/ruby_prof/rp_call_info.h

@@ -4,50 +4,32 @@
 #ifndef __RP_CALL_INFO_H__
 #define __RP_CALL_INFO_H__
 
-#include "rp_measure.h"
+#include "ruby_prof.h"
+#include "rp_measurement.h"
 #include "rp_method.h"
 
-extern VALUE cCallInfo;
-
 /* Callers and callee information for a method. */
 typedef struct prof_call_info_t
 {
-    prof_method_t *target; /* Use target instead of method to avoid conflict with Ruby method */
-    struct prof_call_info_t *parent;
-    st_table *call_infos;
-
-    double total_time;
-    double self_time;
-    double wait_time;
-
+    prof_method_t *method;
+    prof_method_t *parent;
+    prof_measurement_t *measurement;
     VALUE object;
-    VALUE children;
 
-    int called;
+    int visits;                             /* Current visits on the stack */
 
-    unsigned int recursive : 1;
-    unsigned int depth : 15;
-    unsigned int line : 16;
+    unsigned int depth;
+    unsigned int source_line;
+    VALUE source_file;
 } prof_call_info_t;
 
-/* Array of call_info objects */
-typedef struct prof_call_infos_t
-{
-    prof_call_info_t **start;
-    prof_call_info_t **end;
-    prof_call_info_t **ptr;
-    VALUE object;
-} prof_call_infos_t;
-
-
+prof_call_info_t *prof_call_info_create(prof_method_t *method, prof_method_t *parent, VALUE source_file, int source_line);
+void prof_call_info_mark(void *data);
+prof_call_info_t *call_info_table_lookup(st_table* table, st_data_t key);
+size_t call_info_table_insert(st_table *table, st_data_t key, prof_call_info_t *val);
+prof_call_info_t *prof_get_call_info(VALUE self);
+VALUE prof_call_info_wrap(prof_call_info_t* call_info);
+void prof_call_info_free(prof_call_info_t* call_info);
 void rp_init_call_info(void);
-prof_call_infos_t* prof_call_infos_create();
-void prof_call_infos_mark(prof_call_infos_t *call_infos);
-void prof_call_infos_free(prof_call_infos_t *call_infos);
-void prof_add_call_info(prof_call_infos_t *call_infos, prof_call_info_t *call_info);
-VALUE prof_call_infos_wrap(prof_call_infos_t *call_infos);
-prof_call_info_t * prof_call_info_create(prof_method_t* method, prof_call_info_t* parent);
-prof_call_info_t * call_info_table_lookup(st_table *table, const prof_method_key_t *key);
-size_t call_info_table_insert(st_table *table, const prof_method_key_t *key, prof_call_info_t *val);
 
 #endif //__RP_CALL_INFO_H__

data/ext/ruby_prof/rp_measure_allocations.c

@@ -3,74 +3,50 @@
 
 /* :nodoc: */
 
-#include "ruby_prof.h"
+#include "rp_measurement.h"
 
 static VALUE cMeasureAllocations;
+VALUE total_allocated_objects_key;
 
-#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
-  unsigned LONG_LONG rb_os_allocated_objects();
-#endif
-
-#if defined(HAVE_RB_GC_STAT)
-size_t rb_gc_stat(VALUE key);
-
-#if RUBY_PROF_RUBY_VERSION >= 20200
-#define TOTAL_ALLOCATED_OBJECTS_STRING "total_allocated_objects"
-#else
-#define TOTAL_ALLOCATED_OBJECTS_STRING "total_allocated_object"
-#endif
-
-#endif
+static double
+measure_allocations_via_gc_stats(rb_trace_arg_t* trace_arg)
+{
+    return rb_gc_stat(total_allocated_objects_key);
+}
 
 static double
-measure_allocations()
+measure_allocations_via_tracing(rb_trace_arg_t* trace_arg)
 {
-#if defined(HAVE_RB_OS_ALLOCATED_OBJECTS)
-#define MEASURE_ALLOCATIONS_ENABLED Qtrue
-    return rb_os_allocated_objects();
+    static double result = 0;
 
-#elif defined(HAVE_RB_GC_STAT) && RUBY_PROF_RUBY_VERSION >= 20100
-#define MEASURE_ALLOCATIONS_ENABLED Qtrue
-    static VALUE total_alloc_symbol = 0;
-    if (!total_alloc_symbol) {
-      total_alloc_symbol = ID2SYM(rb_intern_const(TOTAL_ALLOCATED_OBJECTS_STRING));
+    if (trace_arg)
+    {
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
+            result++;
     }
-    return rb_gc_stat(total_alloc_symbol);
-
-#else
-#define MEASURE_ALLOCATIONS_ENABLED Qfalse
-    return 0;
-#endif
+    return result;
 }
 
-
-prof_measurer_t* prof_measurer_allocations()
+prof_measurer_t* prof_measurer_allocations(bool track_allocations)
 {
   prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_allocations;
-  return measure;
-}
+  measure->mode = MEASURE_ALLOCATIONS;
+  measure->multiplier = 1;
+  measure->track_allocations = track_allocations;
 
-/* call-seq:
-     measure -> int
+  if (track_allocations)
+      measure->measure = measure_allocations_via_tracing;
+  else
+      measure->measure = measure_allocations_via_gc_stats;
 
-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
+  return measure;
 }
 
 void rp_init_measure_allocations()
 {
+    total_allocated_objects_key = ID2SYM(rb_intern("total_allocated_objects"));
     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_memory.c

@@ -1,77 +1,42 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* Copyright (C) 2005-2013 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"
+#include "rp_measurement.h"
 
 static VALUE cMeasureMemory;
 
-
-#if defined(HAVE_RB_GC_ALLOCATED_SIZE)
-  VALUE rb_gc_allocated_size();
-#endif
-
-#if defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
-  size_t rb_gc_malloc_allocated_size();
-#endif
-
-#if defined(HAVE_RB_HEAP_TOTAL_MEM)
-  //FIXME: did not find the patch to check prototype, assuming it to return size_t
-  size_t rb_heap_total_mem();
-#endif
-
 static double
-measure_memory()
+measure_memory_via_tracing(rb_trace_arg_t* trace_arg)
 {
-#if defined(HAVE_RB_GC_ALLOCATED_SIZE)
-#define MEASURE_MEMORY_ENABLED Qtrue
-#if defined(HAVE_LONG_LONG)
-    return NUM2LL(rb_gc_allocated_size()) / 1024.0;
-#else
-    return NUM2ULONG(rb_gc_allocated_size()) / 1024.0;
-#endif
-
-#elif defined(HAVE_RB_GC_MALLOC_ALLOCATED_SIZE)
-#define MEASURE_MEMORY_ENABLED Qtrue
-    return rb_gc_malloc_allocated_size() / 1024.0;
-
-#elif defined(HAVE_RB_GC_TOTAL_MALLOCED_BYTES)
-#define MEASURE_MEMORY_ENABLED Qtrue
-    return rb_gc_total_malloced_bytes() / 1024.0;
-
-#elif defined(HAVE_RB_HEAP_TOTAL_MEM)
-#define MEASURE_MEMORY_ENABLED Qtrue
-    return rb_heap_total_mem() / 1024.0;
-
-#else
-#define MEASURE_MEMORY_ENABLED Qfalse
-    return 0;
-#endif
+    static double result = 0;
+
+    if (trace_arg)
+    {
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
+        {
+            VALUE object = rb_tracearg_object(trace_arg);
+            result += rb_obj_memsize_of(object);
+        }
+    }
+    return result;
 }
 
-prof_measurer_t* prof_measurer_memory()
+prof_measurer_t* prof_measurer_memory(bool track_allocations)
 {
   prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_memory;
+  measure->mode = MEASURE_MEMORY;
+  measure->measure = measure_memory_via_tracing;
+  measure->multiplier = 1;
+  measure->track_allocations = true;
   return measure;
 }
 
-/* call-seq:
-   measure_process_time -> float
-
-Returns the process time.*/
-static VALUE
-prof_measure_memory(VALUE self)
-{
-    return rb_float_new(measure_memory());
-}
-
 void rp_init_measure_memory()
 {
     rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
-    rb_define_const(mProf, "MEMORY_ENABLED", MEASURE_MEMORY_ENABLED);
 
-    cMeasureMemory = rb_define_class_under(mMeasure, "Memory", rb_cObject);
-    rb_define_singleton_method(cMeasureMemory, "measure", prof_measure_memory, 0);
+    cMeasureMemory = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
 }

data/ext/ruby_prof/rp_measure_process_time.c

@@ -1,71 +1,63 @@
-/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* Copyright (C) 2005-2019 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"
+#include "rp_measurement.h"
 #include <time.h>
 
 static VALUE cMeasureProcessTime;
 
 static double
-measure_process_time()
+measure_process_time(rb_trace_arg_t* trace_arg)
 {
-#if defined(__linux__)
-    struct timespec clock;
-    clock_gettime(CLOCK_PROCESS_CPUTIME_ID , &clock);
-    return clock.tv_sec + (clock.tv_nsec/1000000000.0);
-#elif defined(_win32)
-	FILETIME createTime;
-	FILETIME exitTime;
-	FILETIME sysTime;
-	FILETIME cpuTime;
+#if defined(_WIN32)
+    FILETIME  createTime;
+    FILETIME  exitTime;
+    FILETIME  sysTime;
+    FILETIME  userTime;
 
 	ULARGE_INTEGER sysTimeInt;
-	ULARGE_INTEGER cpuTimeInt;
-	ULONGLONG totalTime;
-
-	GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &cpuTime); 
+	ULARGE_INTEGER userTimeInt;
 
-	/* Doing this based on MSFT's recommendation in the FILETIME structure documentation at
-	  http://msdn.microsoft.com/en-us/library/ms724284%28VS.85%29.aspx*/
+	GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &sysTime, &userTime); 
 
 	sysTimeInt.LowPart = sysTime.dwLowDateTime;
 	sysTimeInt.HighPart = sysTime.dwHighDateTime;
-	cpuTimeInt.LowPart = cpuTime.dwLowDateTime;
-	cpuTimeInt.HighPart = cpuTime.dwHighDateTime;
+    userTimeInt.LowPart = userTime.dwLowDateTime;
+    userTimeInt.HighPart = userTime.dwHighDateTime;
 
-	totalTime = sysTimeInt.QuadPart + cpuTimeInt.QuadPart;
-
-	// Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
-	return totalTime / 10000000.0;
+	return sysTimeInt.QuadPart + userTimeInt.QuadPart;
 #else
-    return ((double)clock()) / CLOCKS_PER_SEC;
+    struct timespec clock;
+    clock_gettime(CLOCK_PROCESS_CPUTIME_ID , &clock);
+    return clock.tv_sec + (clock.tv_nsec/1000000000.0);
 #endif
 }
 
-/* call-seq:
-   measure_process_time -> float
-
-Returns the process time.*/
-static VALUE
-prof_measure_process_time(VALUE self)
+static double
+multiplier_process_time(void)
 {
-    return rb_float_new(measure_process_time());
+#if defined(_WIN32)
+    // Times are in 100-nanosecond time units.  So instead of 10-9 use 10-7
+    return 1.0 / 10000000.0;
+#else
+    return 1.0;
+#endif
 }
 
-prof_measurer_t* prof_measurer_process_time()
+prof_measurer_t* prof_measurer_process_time(bool track_allocations)
 {
   prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->mode = MEASURE_PROCESS_TIME;
   measure->measure = measure_process_time;
+  measure->multiplier = multiplier_process_time();
+  measure->track_allocations = track_allocations;
   return measure;
 }
 
-
 void rp_init_measure_process_time()
 {
     rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
     rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));
-	rb_define_const(mProf, "PROCESS_TIME_ENABLED", Qtrue);
 
     cMeasureProcessTime = rb_define_class_under(mMeasure, "ProcessTime", rb_cObject);
-    rb_define_singleton_method(cMeasureProcessTime, "measure", prof_measure_process_time, 0);
 }

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -2,44 +2,61 @@
    Please see the LICENSE file for copyright and distribution information */
 
 /* :nodoc: */
-#include "ruby_prof.h"
-#if HAVE_GETTIMEOFDAY && !defined(_WIN32)
-#include <sys/time.h>
+#include "rp_measurement.h"
+
+#if defined(__APPLE__)
+#include <mach/mach_time.h>
+#elif !defined(_WIN32)
+#include <time.h>
 #endif
 
 static VALUE cMeasureWallTime;
 
 static double
-measure_wall_time()
+measure_wall_time(rb_trace_arg_t* trace_arg)
 {
+#if defined(_WIN32)
+    return GetTickCount();
+#elif defined(__APPLE__)
+    return mach_absolute_time();// * (uint64_t)mach_timebase.numer / (uint64_t)mach_timebase.denom;
+#elif defined(__linux__)
+    struct timespec tv;
+    clock_gettime(CLOCK_MONOTONIC, &tv);
+    return tv.tv_sec + (tv.tv_nsec / 1000000000.0);
+#else
     struct timeval tv;
     gettimeofday(&tv, NULL);
-    return tv.tv_sec + (tv.tv_usec/1000000.0);
+    return tv.tv_sec + (tv.tv_usec / 1000000.0); 
+#endif
 }
 
-prof_measurer_t* prof_measurer_wall_time()
+static double
+multiplier_wall_time(void)
 {
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_wall_time;
-  return measure;
+#if defined(_WIN32)
+    return 1.0/1000.0;
+#elif defined(__APPLE__)
+    mach_timebase_info_data_t mach_timebase;
+    mach_timebase_info (&mach_timebase);
+    return (uint64_t)mach_timebase.numer / (uint64_t)mach_timebase.denom / 1000000000.0;
+#else
+    return 1.0;
+#endif
 }
 
-/* Document-method: prof_measure_wall_time
-   call-seq:
-     measure_wall_time -> float
-
-Returns the wall time.*/
-static VALUE
-prof_measure_wall_time(VALUE self)
+prof_measurer_t* prof_measurer_wall_time(bool track_allocations)
 {
-    return rb_float_new(measure_wall_time());
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->mode = MEASURE_WALL_TIME;
+  measure->measure = measure_wall_time;
+  measure->multiplier = multiplier_wall_time();
+  measure->track_allocations = track_allocations;
+  return measure;
 }
 
 void rp_init_measure_wall_time()
 {
     rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));
-    rb_define_const(mProf, "WALL_TIME_ENABLED", Qtrue);
 
     cMeasureWallTime = rb_define_class_under(mMeasure, "WallTime", rb_cObject);
-    rb_define_singleton_method(cMeasureWallTime, "measure", prof_measure_wall_time, 0);
 }

data/ext/ruby_prof/rp_measurement.c

@@ -0,0 +1,236 @@
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#include "rp_measurement.h"
+
+VALUE mMeasure;
+VALUE cRpMeasurement;
+
+prof_measurer_t* prof_measurer_allocations(bool track_allocations);
+prof_measurer_t* prof_measurer_memory(bool track_allocations);
+prof_measurer_t* prof_measurer_process_time(bool track_allocations);
+prof_measurer_t* prof_measurer_wall_time(bool track_allocations);
+
+void rp_init_measure_allocations(void);
+void rp_init_measure_memory(void);
+void rp_init_measure_process_time(void);
+void rp_init_measure_wall_time(void);
+
+prof_measurer_t* prof_get_measurer(prof_measure_mode_t measure, bool track_allocations)
+{
+    switch (measure)
+    {
+    case MEASURE_WALL_TIME:
+        return prof_measurer_wall_time(track_allocations);
+    case MEASURE_PROCESS_TIME:
+        return prof_measurer_process_time(track_allocations);
+    case MEASURE_ALLOCATIONS:
+        return prof_measurer_allocations(track_allocations);
+    case MEASURE_MEMORY:
+        return prof_measurer_memory(track_allocations);
+    default:
+        rb_raise(rb_eArgError, "Unknown measure mode: %d", measure);
+    }
+};
+
+double prof_measure(prof_measurer_t* measurer, rb_trace_arg_t* trace_arg)
+{
+    double measurement = measurer->measure(trace_arg);
+    return measurement * measurer->multiplier;
+}
+
+/* =======  prof_measurement_t   ========*/
+prof_measurement_t *prof_measurement_create(void)
+{
+    prof_measurement_t* result = ALLOC(prof_measurement_t);
+    result->total_time = 0;
+    result->self_time = 0;
+    result->wait_time = 0;
+    result->called = 0;
+    result->object = Qnil;
+    return result;
+}
+
+static void
+prof_measurement_ruby_gc_free(void *data)
+{
+    prof_measurement_t* measurement = (prof_measurement_t*)data;
+
+    /* Has this thread object been accessed by Ruby?  If
+       yes clean it up so to avoid a segmentation fault. */
+    if (measurement->object != Qnil)
+    {
+        RDATA(measurement->object)->data = NULL;
+        RDATA(measurement->object)->dfree = NULL;
+        RDATA(measurement->object)->dmark = NULL;
+    }
+    measurement->object = Qnil;
+}
+
+size_t
+prof_measurement_size(const void *data)
+{
+    return sizeof(prof_measurement_t);
+}
+
+void
+prof_measurement_mark(void *data)
+{
+    prof_measurement_t* measurement = (prof_measurement_t*)data;
+    if (measurement->object != Qnil)
+        rb_gc_mark(measurement->object);
+}
+
+static const rb_data_type_t measurement_type =
+{
+    .wrap_struct_name = "Measurement",
+    .function =
+    {
+        .dmark = prof_measurement_mark,
+        .dfree = prof_measurement_ruby_gc_free,
+        .dsize = prof_measurement_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE
+prof_measurement_wrap(prof_measurement_t* measurement)
+{
+    if (measurement->object == Qnil)
+    {
+        measurement->object = TypedData_Wrap_Struct(cRpMeasurement, &measurement_type, measurement);
+    }
+    return measurement->object;
+}
+
+static VALUE
+prof_measurement_allocate(VALUE klass)
+{
+    prof_measurement_t *measurement = prof_measurement_create();
+    measurement->object = prof_measurement_wrap(measurement);
+    return measurement->object;
+}
+
+prof_measurement_t*
+prof_get_measurement(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+    prof_measurement_t* result = DATA_PTR(self);
+
+    if (!result)
+        rb_raise(rb_eRuntimeError, "This RubyProf::Measurement instance has already been freed, likely because its profile has been freed.");
+
+    return result;
+}
+
+/* call-seq:
+   total_time -> float
+
+Returns the total amount of time spent in this method and its children. */
+static VALUE
+prof_measurement_total_time(VALUE self)
+{
+    prof_measurement_t* result = prof_get_measurement(self);
+    return rb_float_new(result->total_time);
+}
+
+/* call-seq:
+   self_time -> float
+
+Returns the total amount of time spent in this method. */
+static VALUE
+prof_measurement_self_time(VALUE self)
+{
+    prof_measurement_t* result = prof_get_measurement(self);
+
+    return rb_float_new(result->self_time);
+}
+
+/* call-seq:
+   wait_time -> float
+
+Returns the total amount of time this method waited for other threads. */
+static VALUE
+prof_measurement_wait_time(VALUE self)
+{
+    prof_measurement_t* result = prof_get_measurement(self);
+
+    return rb_float_new(result->wait_time);
+}
+
+/* call-seq:
+   called -> int
+
+Returns the total amount of times this method was called. */
+static VALUE
+prof_measurement_called(VALUE self)
+{
+    prof_measurement_t *result = prof_get_measurement(self);
+    return INT2NUM(result->called);
+}
+
+/* call-seq:
+   called=n -> n
+
+Sets the call count to n. */
+static VALUE
+prof_measurement_set_called(VALUE self, VALUE called)
+{
+    prof_measurement_t *result = prof_get_measurement(self);
+    result->called = NUM2INT(called);
+    return called;
+}
+
+/* :nodoc: */
+static VALUE
+prof_measurement_dump(VALUE self)
+{
+    prof_measurement_t* measurement_data = prof_get_measurement(self);
+    VALUE result = rb_hash_new();
+
+    rb_hash_aset(result, ID2SYM(rb_intern("total_time")), rb_float_new(measurement_data->total_time));
+    rb_hash_aset(result, ID2SYM(rb_intern("self_time")), rb_float_new(measurement_data->self_time));
+    rb_hash_aset(result, ID2SYM(rb_intern("wait_time")), rb_float_new(measurement_data->wait_time));
+    rb_hash_aset(result, ID2SYM(rb_intern("called")), INT2FIX(measurement_data->called));
+
+    return result;
+}
+
+/* :nodoc: */
+static VALUE
+prof_measurement_load(VALUE self, VALUE data)
+{
+    prof_measurement_t* measurement = prof_get_measurement(self);
+    measurement->object = self;
+
+    measurement->total_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("total_time"))));
+    measurement->self_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("self_time"))));
+    measurement->wait_time = rb_num2dbl(rb_hash_aref(data, ID2SYM(rb_intern("wait_time"))));
+    measurement->called = FIX2INT(rb_hash_aref(data, ID2SYM(rb_intern("called"))));
+
+    return data;
+}
+
+void rp_init_measure()
+{
+    mMeasure = rb_define_module_under(mProf, "Measure");
+    rp_init_measure_wall_time();
+    rp_init_measure_process_time();
+    rp_init_measure_allocations();
+    rp_init_measure_memory();
+
+    cRpMeasurement = rb_define_class_under(mProf, "Measurement", rb_cData);
+    rb_undef_method(CLASS_OF(cRpMeasurement), "new");
+    rb_define_alloc_func(cRpMeasurement, prof_measurement_allocate);
+
+    rb_define_method(cRpMeasurement, "called", prof_measurement_called, 0);
+    rb_define_method(cRpMeasurement, "called=", prof_measurement_set_called, 1);
+    rb_define_method(cRpMeasurement, "total_time", prof_measurement_total_time, 0);
+    rb_define_method(cRpMeasurement, "self_time", prof_measurement_self_time, 0);
+    rb_define_method(cRpMeasurement, "wait_time", prof_measurement_wait_time, 0);
+
+    rb_define_method(cRpMeasurement, "_dump_data", prof_measurement_dump, 0);
+    rb_define_method(cRpMeasurement, "_load_data", prof_measurement_load, 1);
+}