ruby-prof 1.1.0-x64-mingw32 → 1.3.0-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92a058890ba891a0ccc0d5ef289dd4a5e0067359592ed04f95047a3bf30d0839
-  data.tar.gz: 833c854ce3e2790ea696f411f5b3c8fd1fd9827e9eca4ffa0d2e3bb21871dd60
+  metadata.gz: 0e7a5ed3eff6d7d963f459a572dd63561423abb6d8911076e086e3588befb37b
+  data.tar.gz: b4bf7cc5ec23482ccbcb103b6c7ab87c8614da0076d6a43f4848d6cd8aee3178
 SHA512:
-  metadata.gz: e9c9c5e882ecd371ceb24365d46446e863fbcfaac365dbd84c1aed3ffd24fafe2d7b8e7bc7d09babe07fc8e0d8877fb5c112917b6c1915305cb881dc34f8d49c
-  data.tar.gz: 3206613c98c989672a6d329280c3076efb173e4fea0828b09f57ef4698f546aab8ec8cda04e6ef6ccd9d35101f8b2ae5af0a36b04f5c04fca6afa59543e34706
+  metadata.gz: 4797da262fc687b47bea5c33bdcfdd102197afb8a3ff441b00a5444bc06de4deb83421569b6e8f815381a385e79edc08c4339b2d3ab26f9f7c920a155c00f080
+  data.tar.gz: bc891673567736bef06b12eb72514425261a678ad9d33ad709835e1e1cffd265c4657ba436a2e28486a45fa35fd678117ac2a2882c564fbfb334eb1edcec3918

data/CHANGES

@@ -1,3 +1,21 @@
+1.3.0 (2020-02-22)
+=====================
+* Update C code to use newer RTypedData API versus older RData API.
+* Update C code to use rb_cObject versus the older, deprecated, rb_cData.
+* Update memory management - CallInfo's now keep alive their owning Profile instances. Fixes crashes that
+  could happen in rare instances.
+
+1.2.0 (2020-01-23)
+=====================
+* Fix call stack printer broken in version 1.0.0 (Charlie Savage)
+* Ruby 2.7.0 support (Charlie Savage)
+* Switch to Windows high precision timer for measuring wall time (Charlie Savage)
+* Much better support for reverse call trees - if you start RubyProf at the bottom
+  of a call tree it will correctly calculate times as it ascends the tree (Charlie Savage)
+* Port AggregateCallInfo from Ruby to C to increase performance
+* API change - CallInfo has been renamed CallTree
+* Fix crashes on Ruby 2.4.*
+
 1.1.0 (2019-12-14)
 =====================
 Changes
@@ -342,7 +360,7 @@ Fixes
 
 0.7.1 (2008-11-28)
 ========================
-* Added new AggregateCallInfo class for printers to
+* Added new AggregateCallTree class for printers to
   make results easier to read.  Take this call sequence
   for example:
 

data/bin/ruby-prof

@@ -1,7 +1,6 @@
 #! /usr/bin/env ruby
 
 # First require ruby-prof
-require 'rubygems'
 require 'ruby-prof'
 
 # Now setup option parser
@@ -14,64 +13,45 @@ module RubyProf
   # Profiles a Ruby program.
   #
   # == Usage
-  #
-  # ruby_prof [options] <script.rb> [--] [script-options]
+  # ruby-prof [options] <script.rb> [--] [profiled-script-command-line-options]
   #
   # Options:
-  #  -p, --printer=printer          Select a printer:
-  #                                   flat - Prints a flat profile as text (default).
-  #                                   graph - Prints a graph profile as text.
-  #                                   graph_html - Prints a graph profile as html.
-  #                                   call_tree - format for KCacheGrind
-  #                                   call_stack - prints a HTML visualization of the call tree
-  #                                   dot - Prints a graph profile as a dot file
-  #                                   multi - Creates several reports in output directory
-  #
-  #  -m, --min_percent=min_percent  The minimum percent a method must take before
-  #                                 being included in output reports. This option is not supported for call tree reports.
-  #
-  #  -f, --file=path                Output results to a file instead of standard out.
-  #
-  #  --mode=measure_mode            Select what ruby-prof should measure:
-  #                                   wall - Wall time (default)
-  #                                   process - Process time
-  #                                   allocations - Object allocations
-  #                                   memory - Allocated memory
-  #
-  #  -s, --sort=sort_mode           Select how ruby-prof results should be sorted:
-  #                                   total - Total time
-  #                                   self - Self time
-  #                                   wait - Wait time
-  #                                   child - Child time
-  #
-  #  --replace-progname             Replace $0 when loading the .rb files.
-  #
-  #  --specialized-instruction      Turn on specified instruction.
-  #
-  #  -v                             Show version, set $VERBOSE to true, profile script if option given
-  #
-  #  -d                             Set $DEBUG to true
-  #
-  #  -R, --require-noprof lib       Require a specific library (not profiled)
-  #
-  #  -E, --eval-noprof code         Execute the ruby statements (not profiled)
-  #
-  #  -x, --exclude regexp           Exclude methods by regexp (see method elimination)
-  #
-  #  -X, --exclude-file file        Exclude methods by regexp listed in file (see method elimination)
-  #
-  #  --exclude-common-cycles        Make common iterators like Integer#times appear inlined
-  #
-  #  --exclude-common-callbacks     Make common callbacks invocations like Integer#times appear inlined so you can see call origins in graph
-  #
-  #  -h, --help                     Show help message
-  #
-  #  --version                      Show version
-  #
-  #
+  #    -p, --printer=printer            Select a printer:
+  #                                       flat - Prints a flat profile as text (default).
+  #                                       graph - Prints a graph profile as text.
+  #                                       graph_html - Prints a graph profile as html.
+  #                                       call_tree - format for KCacheGrind
+  #                                       call_stack - prints a HTML visualization of the call tree
+  #                                       dot - Prints a graph profile as a dot file
+  #                                       multi - Creates several reports in output directory
+  #    -m, --min_percent=min_percent    The minimum percent a method must take before
+  #                                       being included in output reports.
+  #                                       This option is not supported for call tree.
+  #    -f, --file=path                  Output results to a file instead of standard out.
+  #        --mode=measure_mode          Select what ruby-prof should measure:
+  #                                       wall - Wall time (default).
+  #                                       process - Process time.
+  #                                       allocations - Object allocations (requires patched Ruby interpreter).
+  #                                       memory - Allocated memory in KB (requires patched Ruby interpreter).
+  #    -s, --sort=sort_mode             Select how ruby-prof results should be sorted:
+  #                                       total - Total time
+  #                                       self - Self time
+  #                                       wait - Wait time
+  #                                       child - Child time
+  #        --allow_exceptions           Raise exceptions encountered during profiling (true) or suppress them (false)
+  #    -R, --require-noprof=lib         require a specific library (not profiled)
+  #    -E, --eval-noprof=code           execute the ruby statements (not profiled)
+  #        --exclude=methods    A comma separated list of methods to exclude.
+  #                                       Specify instance methods via # (Integer#times)
+  #                                       Specify class methods via . (Integer.superclass)
+  #        --exclude-common             Remove common methods from the profile
+  #    -h, --help                       Show help message
+  #    -v, --version version            Show version (1.1.0)
+
   class Cmd
     # :enddoc:
     attr_accessor :options
+    attr_reader :profile
 
     def initialize
       setup_options
@@ -84,15 +64,52 @@ module RubyProf
     def setup_options
       @options = OpenStruct.new
       options.printer = RubyProf::FlatPrinter
+      options.measure_mode = RubyProf::WALL_TIME
       options.min_percent = 0
       options.file = nil
-      options.replace_prog_name = false
-      options.specialized_instruction = false
-
+      options.allow_exceptions = false
+      options.exclude_common = false
+      options.exclude = Array.new
       options.pre_libs = Array.new
       options.pre_execs = Array.new
     end
 
+    # This is copied from ActiveSupport:
+    def constantize(camel_cased_word)
+      if !camel_cased_word.include?("::")
+        Object.const_get(camel_cased_word)
+      else
+        names = camel_cased_word.split("::")
+
+        # Trigger a built-in NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check if it is owned directly. The check
+            # stops when we reach Object or the end of ancestors tree.
+            constant = constant.ancestors.inject(constant) do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
+          end
+        end
+      end
+    end
+
     def option_parser
       OptionParser.new do |opts|
         opts.banner = "ruby_prof #{RubyProf::VERSION}\n" +
@@ -182,94 +199,45 @@ module RubyProf
                                 end
         end
 
-        opts.on("--replace-progname", "Replace $0 when loading the .rb files.") do
-          options.replace_prog_name = true
-        end
-
-        if defined?(RubyVM)
-          opts.on("--specialized-instruction", "Turn on specified instruction.") do
-            options.specialized_instruction = true
-          end
-        end
-
         opts.on_tail("-h", "--help", "Show help message") do
           puts opts
           exit
         end
 
-        opts.on_tail("--version", "Show version #{RubyProf::VERSION}") do
+        opts.on_tail("-v version", "--version", "Show version (#{RubyProf::VERSION})") do
           puts "ruby_prof " + RubyProf::VERSION
           exit
         end
 
-        opts.on("-v","Show version, set $VERBOSE to true, profile script if option given") do
-          puts "ruby version: " + [RUBY_PATCHLEVEL, RUBY_PLATFORM, RUBY_VERSION].join(' ')
-          $VERBOSE = true
-        end
-
-        opts.on("-d", "Set $DEBUG to true") do
-          $DEBUG = true
+        opts.on('--allow_exceptions', 'Raise exceptions encountered during profiling (true) or suppress them (false)') do
+          options.allow_exceptions = true
         end
 
-        opts.on('-R lib', '--require-noprof lib', 'require a specific library (not profiled)') do |lib|
+        opts.on('-R lib', '--require-noprof=lib', 'require a specific library (not profiled)') do |lib|
           options.pre_libs << lib
         end
 
-        opts.on('-E code', '--eval-noprof code', 'execute the ruby statements (not profiled)') do |code|
+        opts.on('-E code', '--eval-noprof=code', 'execute the ruby statements (not profiled)') do |code|
           options.pre_execs << code
         end
 
-        opts.on('-x regexp', '--exclude regexp', 'exclude methods by regexp (see method elimination)') do |meth|
-          options.eliminate_methods ||= []
-          options.eliminate_methods << Regexp.new(meth)
-        end
-
-        opts.on('-X file', '--exclude-file file', 'exclude methods by regexp listed in file (see method elimination)') do|file|
-          options.eliminate_methods_files ||= []
-          options.eliminate_methods_files << file
-        end
-
-        opts.on('--exclude-common-cycles', 'make common iterators like Integer#times appear inlined') do |meth|
-          options.eliminate_methods ||= []
-          options.eliminate_methods += %w{
-            Integer#times
-            Integer#upto
-            Integer#downto
-            Enumerator#each
-            Enumerator#each_with_index
-            Enumerator#each_with_object
-
-            Array#each
-            Array#each_index
-            Array#reverse_each
-            Array#map
-
-            Hash#each
-            Hash#each_pair
-            Hash#each_key
-            Hash#each_value
-
-            Range#each
-            Enumerable#each_cons
-            Enumerable#each_entry
-            Enumerable#each_slice
-            Enumerable#each_with_index
-            Enumerable#each_with_object
-            Enumerable#reverse_each
-            Enumerable#inject
-            Enumerable#collect
-            Enumerable#reduce
-          }
-          #TODO: may be the whole Enumerable module should be excluded via 'Enumerable#.*', we need feedback on use cases.
+        opts.on('--exclude=methods', String,
+                'A comma separated list of methods to exclude.',
+                '  Specify instance methods via # (Integer#times)',
+                '  Specify class methods via . (Integer.superclass)') do |exclude_string|
+          exclude_string.split(',').each do |string|
+            match = string.strip.match(/(.*)(#|\.)(.*)/)
+            klass = constantize(match[1])
+            if match[2] == '.'
+              klass = klass.singleton_class
+            end
+            method = match[3].to_sym
+            options.exclude << [klass, method]
+          end
         end
 
-        opts.on('--exclude-common-callbacks', 'make common callbacks invocations like Integer#times appear inlined so you can see call origins in graph') do|meth|
-          options.eliminate_methods ||= []
-          options.eliminate_methods += %w{
-            Method#call
-            Proc#call
-            ActiveSupport::Callbacks::ClassMethods#__run_callback
-          }
+        opts.on('--exclude-common', 'Remove common methods from the profile') do
+          options.exclude_common = true
         end
       end
     end
@@ -313,23 +281,15 @@ module RubyProf
     end
 
     def run
-      # Get the script we will execute
       script = ARGV.shift
-      if options.replace_prog_name
-        $0 = File.expand_path(script)
+      @profile = Profile.new(options.to_h)
+      options.exclude.each do |klass, method|
+        @profile.exclude_method!(klass, method)
       end
 
-      # Set VM compile option
-      if defined?(RubyVM)
-        RubyVM::InstructionSequence.compile_option = {
-            :trace_instruction => true,
-            :specialized_instruction => options.specialized_instruction
-        }
+      profile.profile do
+       load script
       end
-
-      # Set the measure mode
-      RubyProf.measure_mode = options.measure_mode if options.measure_mode
-      RubyProf.start_script(script)
     end
   end
 end
@@ -342,20 +302,8 @@ cmd = RubyProf::Cmd.new
 # *after* any other one that will be installed.
 
 at_exit {
-  # Stop profiling
-  result = RubyProf.stop
-
-  # Eliminate unwanted methods from call graph
-  if cmd.options.eliminate_methods
-    result.eliminate_methods!(cmd.options.eliminate_methods)
-  end
-
-  if cmd.options.eliminate_methods_files
-    cmd.options.eliminate_methods_files.each {|f| result.eliminate_methods!(f)}
-  end
-
   # Create a printer
-  printer = cmd.options.printer.new(result)
+  printer = cmd.options.printer.new(cmd.profile)
   printer_options = {:min_percent => cmd.options.min_percent, :sort_method => cmd.options.sort_method}
 
   # Get output

data/ext/ruby_prof/rp_aggregate_call_tree.c

@@ -0,0 +1,59 @@
+/* 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_aggregate_call_tree.h"
+
+VALUE cRpAggregateCallTree;
+
+void prof_aggregate_call_tree_mark(void* data)
+{
+    prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
+
+    if (call_tree->object != Qnil)
+        rb_gc_mark(call_tree->object);
+
+    if (call_tree->source_file != Qnil)
+        rb_gc_mark(call_tree->source_file);
+
+    prof_measurement_mark(call_tree->measurement);
+}
+
+static void prof_aggregate_call_tree_ruby_gc_free(void* data)
+{
+    prof_call_tree_t* call_tree = (prof_call_tree_t*)data;
+    prof_call_tree_free(call_tree);
+}
+
+size_t prof_aggregate_call_tree_size(const void* data)
+{
+    return sizeof(prof_call_tree_t);
+}
+
+static const rb_data_type_t aggregate_call_tree_type =
+{
+    .wrap_struct_name = "Aggregate_CallTree",
+    .function =
+    {
+        .dmark = prof_aggregate_call_tree_mark,
+        .dfree = prof_aggregate_call_tree_ruby_gc_free,
+        .dsize = prof_aggregate_call_tree_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE prof_aggregate_call_tree_wrap(prof_call_tree_t* call_tree)
+{
+    if (call_tree->object == Qnil)
+    {
+        call_tree->object = TypedData_Wrap_Struct(cRpAggregateCallTree, &aggregate_call_tree_type, call_tree);
+    }
+    return call_tree->object;
+}
+
+void rp_init_aggregate_call_tree()
+{
+    // AggregateCallTree
+    cRpAggregateCallTree = rb_define_class_under(mProf, "AggregateCallTree", cRpCallTree);
+    rb_undef_method(CLASS_OF(cRpAggregateCallTree), "new");
+}

data/ext/ruby_prof/rp_aggregate_call_tree.h

@@ -0,0 +1,13 @@
+/* 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 */
+
+#ifndef __RP_AGGREGATE_CALL_TREE_H__
+#define __RP_AGGREGATE_CALL_TREE_H__
+
+#include "ruby_prof.h"
+#include "rp_call_tree.h"
+
+void rp_init_aggregate_call_tree(void);
+VALUE prof_aggregate_call_tree_wrap(prof_call_tree_t* call_tree);
+
+#endif //__RP_AGGREGATE_CALL_TREE_H__

data/ext/ruby_prof/rp_allocation.c

@@ -5,12 +5,11 @@
 
 VALUE cRpAllocation;
 
-prof_allocation_t*
-allocations_table_lookup(st_table *table, st_data_t key)
+prof_allocation_t* allocations_table_lookup(st_table* table, st_data_t key)
 {
     prof_allocation_t* result = NULL;
     st_data_t value;
-    if (st_lookup(table, key, &value))
+    if (rb_st_lookup(table, key, &value))
     {
         result = (prof_allocation_t*)value;
     }
@@ -18,23 +17,20 @@ allocations_table_lookup(st_table *table, st_data_t key)
     return result;
 }
 
-void
-allocations_table_insert(st_table *table, st_data_t key, prof_allocation_t * allocation)
+void allocations_table_insert(st_table* table, st_data_t key, prof_allocation_t* allocation)
 {
-    st_insert(table, (st_data_t)key, (st_data_t)allocation);
+    rb_st_insert(table, (st_data_t)key, (st_data_t)allocation);
 }
 
-st_data_t
-allocations_key(VALUE klass, int source_line)
+st_data_t allocations_key(VALUE klass, int source_line)
 {
     return (klass << 4) + source_line;
 }
 
 /* ======   prof_allocation_t  ====== */
-prof_allocation_t*
-prof_allocation_create(void)
+prof_allocation_t* prof_allocation_create(void)
 {
-    prof_allocation_t *result = ALLOC(prof_allocation_t);
+    prof_allocation_t* result = ALLOC(prof_allocation_t);
     result->count = 0;
     result->klass = Qnil;
     result->klass_name = Qnil;
@@ -47,8 +43,19 @@ prof_allocation_create(void)
     return result;
 }
 
-prof_allocation_t*
-prof_allocate_increment(prof_method_t* method, rb_trace_arg_t* trace_arg)
+prof_allocation_t* prof_get_allocation(VALUE self)
+{
+    /* Can't use Data_Get_Struct because that triggers the event hook
+       ending up in endless recursion. */
+    prof_allocation_t* result = RTYPEDDATA_DATA(self);
+
+    if (!result)
+        rb_raise(rb_eRuntimeError, "This RubyProf::Allocation instance has already been freed, likely because its profile has been freed.");
+
+    return result;
+}
+
+prof_allocation_t* prof_allocate_increment(prof_method_t* method, rb_trace_arg_t* trace_arg)
 {
     VALUE object = rb_tracearg_object(trace_arg);
     if (BUILTIN_TYPE(object) == T_IMEMO)
@@ -78,76 +85,85 @@ prof_allocate_increment(prof_method_t* method, rb_trace_arg_t* trace_arg)
     return allocation;
 }
 
-static void
-prof_allocation_ruby_gc_free(void *data)
+static void prof_allocation_ruby_gc_free(void* data)
 {
-    prof_allocation_t* allocation = (prof_allocation_t*)data;
+    if (data)
+    {
+        prof_allocation_t* allocation = (prof_allocation_t*)data;
+        allocation->object = Qnil;
+    }
+}
 
+void prof_allocation_free(prof_allocation_t* allocation)
+{
     /* Has this allocation object been accessed by Ruby?  If
        yes clean it up so to avoid a segmentation fault. */
     if (allocation->object != Qnil)
     {
-        RDATA(allocation->object)->dmark = NULL;
-        RDATA(allocation->object)->dfree = NULL;
-        RDATA(allocation->object)->data = NULL;
+        RTYPEDDATA(allocation->object)->data = NULL;
         allocation->object = Qnil;
     }
-}
 
-void
-prof_allocation_free(prof_allocation_t* allocation)
-{
-    prof_allocation_ruby_gc_free(allocation);
     xfree(allocation);
 }
 
-size_t
-prof_allocation_size(const void* data)
+size_t prof_allocation_size(const void* data)
 {
     return sizeof(prof_allocation_t);
 }
 
-void
-prof_allocation_mark(void *data)
+void prof_allocation_mark(void* data)
 {
+    if (!data) return;
+
     prof_allocation_t* allocation = (prof_allocation_t*)data;
+    if (allocation->object != Qnil)
+        rb_gc_mark(allocation->object);
+
     if (allocation->klass != Qnil)
         rb_gc_mark(allocation->klass);
-    
+
     if (allocation->klass_name != Qnil)
         rb_gc_mark(allocation->klass_name);
 
-    if (allocation->object != Qnil)
-            rb_gc_mark(allocation->object);
-
     if (allocation->source_file != Qnil)
         rb_gc_mark(allocation->source_file);
 }
 
-VALUE
-prof_allocation_wrap(prof_allocation_t *allocation)
+static const rb_data_type_t allocation_type =
+{
+    .wrap_struct_name = "Allocation",
+    .function =
+    {
+        .dmark = prof_allocation_mark,
+        .dfree = prof_allocation_ruby_gc_free,
+        .dsize = prof_allocation_size,
+    },
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+}; 
+
+VALUE prof_allocation_wrap(prof_allocation_t* allocation)
 {
     if (allocation->object == Qnil)
     {
-        allocation->object = Data_Wrap_Struct(cRpAllocation, prof_allocation_mark , prof_allocation_ruby_gc_free, allocation);
+        allocation->object = TypedData_Wrap_Struct(cRpAllocation, &allocation_type, allocation);
     }
     return allocation->object;
 }
 
-static VALUE
-prof_allocation_allocate(VALUE klass)
+static VALUE prof_allocation_allocate(VALUE klass)
 {
     prof_allocation_t* allocation = prof_allocation_create();
     allocation->object = prof_allocation_wrap(allocation);
     return allocation->object;
 }
 
-prof_allocation_t*
-prof_allocation_get(VALUE self)
+prof_allocation_t* prof_allocation_get(VALUE self)
 {
     /* Can't use Data_Get_Struct because that triggers the event hook
        ending up in endless recursion. */
-    prof_allocation_t* result = DATA_PTR(self);
+    prof_allocation_t* result = RTYPEDDATA_DATA(self);
     if (!result)
         rb_raise(rb_eRuntimeError, "This RubyProf::Allocation instance has already been freed, likely because its profile has been freed.");
 
@@ -158,8 +174,7 @@ prof_allocation_get(VALUE self)
    klass -> Class
 
 Returns the type of Class being allocated. */
-static VALUE
-prof_allocation_klass_name(VALUE self)
+static VALUE prof_allocation_klass_name(VALUE self)
 {
     prof_allocation_t* allocation = prof_allocation_get(self);
 
@@ -174,8 +189,7 @@ prof_allocation_klass_name(VALUE self)
 
 Returns the klass flags */
 
-static VALUE
-prof_allocation_klass_flags(VALUE self)
+static VALUE prof_allocation_klass_flags(VALUE self)
 {
     prof_allocation_t* allocation = prof_allocation_get(self);
     return INT2FIX(allocation->klass_flags);
@@ -185,8 +199,7 @@ prof_allocation_klass_flags(VALUE self)
    source_file -> string
 
 Returns the the line number where objects were allocated. */
-static VALUE
-prof_allocation_source_file(VALUE self)
+static VALUE prof_allocation_source_file(VALUE self)
 {
     prof_allocation_t* allocation = prof_allocation_get(self);
     return allocation->source_file;
@@ -196,8 +209,7 @@ prof_allocation_source_file(VALUE self)
    line -> number
 
 Returns the the line number where objects were allocated. */
-static VALUE
-prof_allocation_source_line(VALUE self)
+static VALUE prof_allocation_source_line(VALUE self)
 {
     prof_allocation_t* allocation = prof_allocation_get(self);
     return INT2FIX(allocation->source_line);
@@ -207,8 +219,7 @@ prof_allocation_source_line(VALUE self)
    count -> number
 
 Returns the number of times this class has been allocated. */
-static VALUE
-prof_allocation_count(VALUE self)
+static VALUE prof_allocation_count(VALUE self)
 {
     prof_allocation_t* allocation = prof_allocation_get(self);
     return INT2FIX(allocation->count);
@@ -218,18 +229,16 @@ prof_allocation_count(VALUE self)
    memory -> number
 
 Returns the amount of memory allocated. */
-static VALUE
-prof_allocation_memory(VALUE self)
+static VALUE prof_allocation_memory(VALUE self)
 {
     prof_allocation_t* allocation = prof_allocation_get(self);
     return ULL2NUM(allocation->memory);
 }
 
 /* :nodoc: */
-static VALUE
-prof_allocation_dump(VALUE self)
+static VALUE prof_allocation_dump(VALUE self)
 {
-    prof_allocation_t* allocation = DATA_PTR(self);
+    prof_allocation_t* allocation = prof_get_allocation(self);
 
     VALUE result = rb_hash_new();
 
@@ -245,10 +254,9 @@ prof_allocation_dump(VALUE self)
 }
 
 /* :nodoc: */
-static VALUE
-prof_allocation_load(VALUE self, VALUE data)
+static VALUE prof_allocation_load(VALUE self, VALUE data)
 {
-    prof_allocation_t* allocation = DATA_PTR(self);
+    prof_allocation_t* allocation = prof_get_allocation(self);
     allocation->object = self;
 
     allocation->key = FIX2LONG(rb_hash_aref(data, ID2SYM(rb_intern("key"))));
@@ -264,7 +272,7 @@ prof_allocation_load(VALUE self, VALUE data)
 
 void rp_init_allocation(void)
 {
-    cRpAllocation = rb_define_class_under(mProf, "Allocation", rb_cData);
+    cRpAllocation = rb_define_class_under(mProf, "Allocation", rb_cObject);
     rb_undef_method(CLASS_OF(cRpAllocation), "new");
     rb_define_alloc_func(cRpAllocation, prof_allocation_allocate);