ruby-prof 1.5.0-x64-mingw-ucrt → 1.6.2-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc83e5cdca77c3e07af7ad99f69acfbf8dde2013c435855d996925db9dcd586c
-  data.tar.gz: 9c14d146c1194db666cec9f9ab05e4a798bd0a6ed5c535d850be581ddf8734fa
+  metadata.gz: 4b4e4760579e79fbe1f366a04b3fe39aad288034c2db4ac4683c0f892ac3b8e7
+  data.tar.gz: a1a82b7f129560014af92d6256f6e4a0ef06ee909cf2fff7fd643e92ab92f770
 SHA512:
-  metadata.gz: 56e6c6a054fed0bdbb08a41ead10898495efb4201c19f2bd3572f3b0ac939e1770c3c4f1bb82da4399ba27f99ed135447e004263d57af86a0888a6a6a349f1fc
-  data.tar.gz: 251eba317457ec6ea583b25656c062f92e8f55a35c7279f39a1f9987234fd9b481fbfd6ab72d71af34541ca49aad2b0feacefbc4d44ca75a4486ec003cb2fa19
+  metadata.gz: 58af0b67459d001ba4781b4d25544fb3d75d6806877c4695b2fd41357333bc5e8ba8b9425e7ed8b8f3aba6daaf00f32b5045757ca1284d1aa0eb131f51dcbbec
+  data.tar.gz: f3c3e5953671deca67472e3740bd5757dc2cab05cb4c364080e43d5b33803611b404351fbadf5402ad6118974957db40df3fa858d736231c3269c6a1e4d3995f

data/CHANGES

@@ -1,3 +1,22 @@
+1.6.2 (2023-04-17)
+=====================
+* Fix Profile#merge! implementation (asksurya)
+* Fix ruby-prof command line program (Charlie Savage)
+* Added CMakeLists.txt file (Charlie Savage)
+
+1.6.1 (2023-02-21)
+=====================
+* Fix loading C extension for MacOS (Charlie Savage)
+
+1.6.0 (2023-02-20)
+=====================
+* Add support for Ruby's compacting garbage collector (Charlie Savage)
+* Add rbs signature files (Charlie Savage)
+* Update rack adapter used for profiling Rails to include latest ruby-prof features (Charlie Savage)
+* Add warnings for deprecated methods (Charlie Savage)
+* Update tests to not use deprecated methods (Charlie Savage)
+* Improve tests on OSX (Charlie Savage)
+
 1.5.0 (2023-02-06)
 =====================
 * Add new Profile#merge! method that merges results for threads/fibers that share the same root method (Charlie Savage)

data/bin/ruby-prof

@@ -1,5 +1,10 @@
 #! /usr/bin/env ruby
 
+# To make testing/debugging easier test within this source tree versus an installed gem
+require 'bundler/setup'
+ext_path = File.expand_path(File.join(__dir__, '..', 'ext', 'ruby_prof'))
+$LOAD_PATH.unshift(File.expand_path(ext_path))
+
 # First require ruby-prof
 require 'ruby-prof'
 
@@ -16,37 +21,38 @@ module RubyProf
   # 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
+  #        --allow_exceptions           Raise exceptions encountered during profiling (true) or suppress them (false)
+  #    -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
+  #    -f, --file=path                  Output results to a file instead of standard out.
   #    -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).
+  #    -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
+  #    -R, --require-noprof=lib         require a specific library (not profiled)
   #    -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
+  #        --track_allocations          Track allocations while profiling
   #    -v, --version version            Show version (1.1.0)
+  #    -h, --help                       Show help message
 
   class Cmd
     # :enddoc:
@@ -63,15 +69,16 @@ 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.allow_exceptions = false
-      options.exclude_common = false
       options.exclude = Array.new
+      options.exclude_common = false
+      options.file = nil
+      options.measure_mode = RubyProf::WALL_TIME
+      options.min_percent = 0
       options.pre_libs = Array.new
       options.pre_execs = Array.new
+      options.printer = RubyProf::FlatPrinter
+      options.track_allocations = false
     end
 
     # This is copied from ActiveSupport:
@@ -118,40 +125,31 @@ module RubyProf
         opts.separator ""
         opts.separator "Options:"
 
-        opts.on('-p printer', '--printer=printer', [:flat, :flat_with_line_numbers, :graph, :graph_html, :call_tree, :call_stack, :dot, :multi],
-                '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'
-        ) do |printer|
+        opts.on('--allow_exceptions', 'Raise exceptions encountered during profiling (true) or suppress them (false)') do
+          options.allow_exceptions = true
+        end
 
-          case printer
-          when :flat
-            options.printer = RubyProf::FlatPrinter
-          when :graph
-            options.printer = RubyProf::GraphPrinter
-          when :graph_html
-            options.printer = RubyProf::GraphHtmlPrinter
-          when :call_tree
-            options.printer = RubyProf::CallTreePrinter
-          when :call_stack
-            options.printer = RubyProf::CallStackPrinter
-          when :dot
-            options.printer = RubyProf::DotPrinter
-          when :multi
-            options.printer = RubyProf::MultiPrinter
+        opts.on('-E code', '--eval-noprof=code', 'execute the ruby statements (not profiled)') do |code|
+          options.pre_execs << code
+        end
+
+        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('-m min_percent', '--min_percent=min_percent', Float,
-                'The minimum percent a method must take before ',
-                '  being included in output reports.',
-                '  This option is not supported for call tree.') do |min_percent|
-          options.min_percent = min_percent
+        opts.on('--exclude-common', 'Remove common methods from the profile') do
+          options.exclude_common = true
         end
 
         opts.on('-f path', '--file=path',
@@ -160,6 +158,13 @@ module RubyProf
           options.old_wd = Dir.pwd
         end
 
+        opts.on('-m min_percent', '--min_percent=min_percent', Float,
+                'The minimum percent a method must take before ',
+                '  being included in output reports.',
+                '  This option is not supported for call tree.') do |min_percent|
+          options.min_percent = min_percent
+        end
+
         opts.on('--mode=measure_mode',
                 [:process, :wall, :allocations, :memory],
                 'Select what ruby-prof should measure:',
@@ -180,6 +185,39 @@ module RubyProf
           end
         end
 
+        opts.on('-p printer', '--printer=printer', [:flat, :flat_with_line_numbers, :graph, :graph_html, :call_tree, :call_stack, :dot, :multi],
+                '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'
+        ) do |printer|
+
+          case printer
+            when :flat
+              options.printer = RubyProf::FlatPrinter
+            when :graph
+              options.printer = RubyProf::GraphPrinter
+            when :graph_html
+              options.printer = RubyProf::GraphHtmlPrinter
+            when :call_tree
+              options.printer = RubyProf::CallTreePrinter
+            when :call_stack
+              options.printer = RubyProf::CallStackPrinter
+            when :dot
+              options.printer = RubyProf::DotPrinter
+            when :multi
+              options.printer = RubyProf::MultiPrinter
+          end
+        end
+
+        opts.on('-R lib', '--require-noprof=lib', 'require a specific library (not profiled)') do |lib|
+          options.pre_libs << lib
+        end
+
         opts.on('-s sort_mode', '--sort=sort_mode', [:total, :self, :wait, :child],
                 'Select how ruby-prof results should be sorted:',
                 '  total - Total time',
@@ -199,9 +237,8 @@ module RubyProf
                                 end
         end
 
-        opts.on_tail("-h", "--help", "Show help message") do
-          puts opts
-          exit
+        opts.on('--track_allocations', 'Track allocations while profiling') do
+          options.track_allocations = true
         end
 
         opts.on_tail("-v version", "--version", "Show version (#{RubyProf::VERSION})") do
@@ -209,35 +246,9 @@ module RubyProf
           exit
         end
 
-        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|
-          options.pre_libs << lib
-        end
-
-        opts.on('-E code', '--eval-noprof=code', 'execute the ruby statements (not profiled)') do |code|
-          options.pre_execs << code
-        end
-
-        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', 'Remove common methods from the profile') do
-          options.exclude_common = true
+        opts.on_tail("-h", "--help", "Show help message") do
+          puts opts
+          exit
         end
       end
     end
@@ -281,12 +292,18 @@ module RubyProf
     end
 
     def run
-      script = ARGV.shift
-      @profile = Profile.new(options.to_h)
+      profile_options = {:allow_exceptions => options.allow_exceptions,
+                         :exclude_common => options.exclude_common,
+                         :measure_mode => options.measure_mode,
+                         :track_allocations => options.track_allocations}
+
+      @profile = Profile.new(**profile_options)
+
       options.exclude.each do |klass, method|
         @profile.exclude_method!(klass, method)
       end
 
+      script = ARGV.shift
       profile.profile do
        load script
       end
@@ -304,7 +321,8 @@ cmd = RubyProf::Cmd.new
 at_exit {
   # Create a printer
   printer = cmd.options.printer.new(cmd.profile)
-  printer_options = {:min_percent => cmd.options.min_percent, :sort_method => cmd.options.sort_method}
+  printer_options = {:min_percent => cmd.options.min_percent,
+                     :sort_method => cmd.options.sort_method}
 
   # Get output
   if cmd.options.file

data/ext/ruby_prof/rp_allocation.c

@@ -2,32 +2,11 @@
    Please see the LICENSE file for copyright and distribution information */
 
 #include "rp_allocation.h"
+#include "rp_method.h"
 
 VALUE cRpAllocation;
 
-prof_allocation_t* allocations_table_lookup(st_table* table, st_data_t key)
-{
-    prof_allocation_t* result = NULL;
-    st_data_t value;
-    if (rb_st_lookup(table, key, &value))
-    {
-        result = (prof_allocation_t*)value;
-    }
-
-    return result;
-}
-
-void allocations_table_insert(st_table* table, st_data_t key, prof_allocation_t* allocation)
-{
-    rb_st_insert(table, (st_data_t)key, (st_data_t)allocation);
-}
-
-st_data_t allocations_key(VALUE klass, int source_line)
-{
-    return (klass << 4) + source_line;
-}
-
-/* ======   prof_allocation_t  ====== */
+// ------ prof_allocation_t ------
 prof_allocation_t* prof_allocation_create(void)
 {
     prof_allocation_t* result = ALLOC(prof_allocation_t);
@@ -43,48 +22,17 @@ prof_allocation_t* prof_allocation_create(void)
     return result;
 }
 
-prof_allocation_t* prof_get_allocation(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 = 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)
-        return NULL;
-
-    VALUE klass = rb_obj_class(object);
-
-    int source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
-    st_data_t key = allocations_key(klass, source_line);
-
-    prof_allocation_t* allocation = allocations_table_lookup(method->allocations_table, key);
-    if (!allocation)
-    {
-        allocation = prof_allocation_create();
-        allocation->source_line = source_line;
-        allocation->source_file = rb_tracearg_path(trace_arg);
-        allocation->klass_flags = 0;
-        allocation->klass = resolve_klass(klass, &allocation->klass_flags);
-
-        allocation->key = key;
-        allocations_table_insert(method->allocations_table, key, allocation);
-    }
-
-    allocation->count++;
-    allocation->memory += rb_obj_memsize_of(object);
-
-    return allocation;
-}
-
 static void prof_allocation_ruby_gc_free(void* data)
 {
     if (data)
@@ -118,30 +66,39 @@ void prof_allocation_mark(void* data)
 
     prof_allocation_t* allocation = (prof_allocation_t*)data;
     if (allocation->object != Qnil)
-        rb_gc_mark(allocation->object);
+        rb_gc_mark_movable(allocation->object);
 
     if (allocation->klass != Qnil)
-        rb_gc_mark(allocation->klass);
+        rb_gc_mark_movable(allocation->klass);
 
     if (allocation->klass_name != Qnil)
-        rb_gc_mark(allocation->klass_name);
+        rb_gc_mark_movable(allocation->klass_name);
 
     if (allocation->source_file != Qnil)
         rb_gc_mark(allocation->source_file);
 }
 
-static const rb_data_type_t allocation_type =
+void prof_allocation_compact(void* data)
 {
-    .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
-};
+    prof_allocation_t* allocation = (prof_allocation_t*)data;
+    allocation->object = rb_gc_location(allocation->object);
+    allocation->klass = rb_gc_location(allocation->klass);
+    allocation->klass_name = rb_gc_location(allocation->klass_name);
+}
+
+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,
+                                .dcompact = prof_allocation_compact
+                        },
+                .data = NULL,
+                .flags = RUBY_TYPED_FREE_IMMEDIATELY
+        };
 
 VALUE prof_allocation_wrap(prof_allocation_t* allocation)
 {
@@ -152,24 +109,122 @@ VALUE prof_allocation_wrap(prof_allocation_t* allocation)
     return allocation->object;
 }
 
-static VALUE prof_allocation_allocate(VALUE klass)
+/* ======   Allocation Table  ====== */
+st_table* prof_allocations_create()
 {
-    prof_allocation_t* allocation = prof_allocation_create();
-    allocation->object = prof_allocation_wrap(allocation);
-    return allocation->object;
+    return rb_st_init_numtable();
 }
 
-prof_allocation_t* prof_allocation_get(VALUE self)
+static int allocations_table_free_iterator(st_data_t key, st_data_t value, st_data_t dummy)
 {
-    /* 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.");
+    prof_allocation_free((prof_allocation_t*)value);
+    return ST_CONTINUE;
+}
+
+st_data_t allocations_key(VALUE klass, int source_line)
+{
+    return (klass << 4) + source_line;
+}
+
+static int prof_allocations_collect(st_data_t key, st_data_t value, st_data_t result)
+{
+    prof_allocation_t* allocation = (prof_allocation_t*)value;
+    VALUE arr = (VALUE)result;
+    rb_ary_push(arr, prof_allocation_wrap(allocation));
+    return ST_CONTINUE;
+}
+
+static int prof_allocations_mark_each(st_data_t key, st_data_t value, st_data_t data)
+{
+    prof_allocation_t* allocation = (prof_allocation_t*)value;
+    prof_allocation_mark(allocation);
+    return ST_CONTINUE;
+}
+
+void prof_allocations_mark(st_table* allocations_table)
+{
+    rb_st_foreach(allocations_table, prof_allocations_mark_each, 0);
+}
+
+void prof_allocations_free(st_table* table)
+{
+    rb_st_foreach(table, allocations_table_free_iterator, 0);
+    rb_st_free_table(table);
+}
+
+prof_allocation_t* allocations_table_lookup(st_table* table, st_data_t key)
+{
+    prof_allocation_t* result = NULL;
+    st_data_t value;
+    if (rb_st_lookup(table, key, &value))
+    {
+        result = (prof_allocation_t*)value;
+    }
 
     return result;
 }
 
+void allocations_table_insert(st_table* table, st_data_t key, prof_allocation_t* allocation)
+{
+    rb_st_insert(table, (st_data_t)key, (st_data_t)allocation);
+}
+
+prof_allocation_t* prof_allocate_increment(st_table* allocations_table, rb_trace_arg_t* trace_arg)
+{
+    VALUE object = rb_tracearg_object(trace_arg);
+    if (BUILTIN_TYPE(object) == T_IMEMO)
+        return NULL;
+
+    VALUE klass = rb_obj_class(object);
+
+    int source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
+    st_data_t key = allocations_key(klass, source_line);
+
+    prof_allocation_t* allocation = allocations_table_lookup(allocations_table, key);
+    if (!allocation)
+    {
+        allocation = prof_allocation_create();
+        allocation->source_line = source_line;
+        allocation->source_file = rb_tracearg_path(trace_arg);
+        allocation->klass_flags = 0;
+        allocation->klass = resolve_klass(klass, &allocation->klass_flags);
+
+        allocation->key = key;
+        allocations_table_insert(allocations_table, key, allocation);
+    }
+
+    allocation->count++;
+    allocation->memory += rb_obj_memsize_of(object);
+
+    return allocation;
+}
+
+// Returns an array of allocations
+VALUE prof_allocations_wrap(st_table* allocations_table)
+{
+    VALUE result = rb_ary_new();
+    rb_st_foreach(allocations_table, prof_allocations_collect, result);
+    return result;
+}
+
+void prof_allocations_unwrap(st_table* allocations_table, VALUE allocations)
+{
+    for (int i = 0; i < rb_array_len(allocations); i++)
+    {
+        VALUE allocation = rb_ary_entry(allocations, i);
+        prof_allocation_t* allocation_data = prof_allocation_get(allocation);
+        rb_st_insert(allocations_table, allocation_data->key, (st_data_t)allocation_data);
+    }
+}
+
+/* ======   prof_allocation_t  ====== */
+static VALUE prof_allocation_allocate(VALUE klass)
+{
+    prof_allocation_t* allocation = prof_allocation_create();
+    allocation->object = prof_allocation_wrap(allocation);
+    return allocation->object;
+}
+
 /* call-seq:
    klass -> Class
 
@@ -238,7 +293,7 @@ static VALUE prof_allocation_memory(VALUE self)
 /* :nodoc: */
 static VALUE prof_allocation_dump(VALUE self)
 {
-    prof_allocation_t* allocation = prof_get_allocation(self);
+    prof_allocation_t* allocation = prof_allocation_get(self);
 
     VALUE result = rb_hash_new();
 
@@ -256,7 +311,7 @@ static VALUE prof_allocation_dump(VALUE self)
 /* :nodoc: */
 static VALUE prof_allocation_load(VALUE self, VALUE data)
 {
-    prof_allocation_t* allocation = prof_get_allocation(self);
+    prof_allocation_t* allocation = prof_allocation_get(self);
     allocation->object = self;
 
     allocation->key = RB_NUM2ULL(rb_hash_aref(data, ID2SYM(rb_intern("key"))));

data/ext/ruby_prof/rp_allocation.h

@@ -5,7 +5,6 @@
 #define _RP_ALLOCATION_
 
 #include "ruby_prof.h"
-#include "rp_method.h"
 
 typedef struct prof_allocation_t
 {
@@ -20,12 +19,15 @@ typedef struct prof_allocation_t
     VALUE object;                     /* Cache to wrapped object */
 } prof_allocation_t;
 
+// Allocation (prof_allocation_t*)
 void rp_init_allocation(void);
-void prof_allocation_free(prof_allocation_t* allocation);
-void prof_allocation_mark(void* data);
-VALUE prof_allocation_wrap(prof_allocation_t* allocation);
-prof_allocation_t* prof_allocation_get(VALUE self);
-prof_allocation_t* prof_allocate_increment(prof_method_t* method, rb_trace_arg_t* trace_arg);
+prof_allocation_t* prof_allocate_increment(st_table* allocations_table, rb_trace_arg_t* trace_arg);
 
+// Allocations (st_table*)
+st_table* prof_allocations_create(void);
+VALUE prof_allocations_wrap(st_table* allocations_table);
+void prof_allocations_unwrap(st_table* allocations_table, VALUE allocations);
+void prof_allocations_mark(st_table* allocations_table);
+void prof_allocations_free(st_table* table);
 
 #endif //_RP_ALLOCATION_