gctools 0.2.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZDEyYzcxODZkNjQ4NDA4ZDg0NDA4ZDZhZGM3Y2RkOTcwOWYzYTM0MA==
+  data.tar.gz: !binary |-
+    NTBhOWZkOTRkOTg2NzJjODhlNWNhZjk1ZWQ0MWFkYWYzOWIxODAzNQ==
+SHA512:
+  metadata.gz: !binary |-
+    YzNjMTMyMzZmMjVjMDA3OTUwNGU5YTY3NmVhZjg0OTU2NTMyZWQ4Mjc1ODNj
+    OWYwMDZiNGMxNjNmMTRkNzMwNmM2YmJkYTAyODM4NTQyNmJmMTZmOTU2NGFi
+    NWYyNzQ1NTVmYWZlNzJmODEzYjc2MGRmNzljZWNkMDNlNmIxMDA=
+  data.tar.gz: !binary |-
+    N2IxZTJiYWY3YTUxYmNjZjcyZTMwZGQzNDQ4ZmM1MTllMTY2NmZhMmZlODlj
+    ODVlYjgyODZiZTFiOGNkMDQ0OTY1ZDVjZTBjYjI1ZjE2Y2IyYTZkMWJmNTBi
+    ZTZiNWE5MTQ5YmE2OWNjYzQwMmM0NGJjNjJkYTRmNTQ2ZGU4Zjc=

data/.gitignore

@@ -0,0 +1,4 @@
+/tmp
+/lib/gctools/*.bundle
+/lib/gctools/*.so
+/.bundle

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    gctools (0.2.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.1.0)
+    rake-compiler (0.9.2)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  gctools!
+  rake-compiler (~> 0.9)

data/README.md

@@ -0,0 +1,24 @@
+## gctools
+
+gc profiler/logger and oobgc for rgengc in ruby 2.1
+
+### design
+
+built on new apis and events offered in ruby 2.1:
+
+  * rb_gc_stat()
+  * rb_gc_latest_gc_info()
+  * RUBY_INTERNAL_EVENT_GC_START
+  * RUBY_INTERNAL_EVENT_GC_END_MARK
+  * RUBY_INTERNAL_EVENT_GC_END_SWEEP
+
+### usage
+
+#### logger
+
+require 'gctools/logger'
+
+#### oobgc
+
+require 'gctools/oobgc'
+GC::OOB.run

data/Rakefile

@@ -0,0 +1,36 @@
+task :default => :test
+
+# ==========================================================
+# Packaging
+# ==========================================================
+
+GEMSPEC = eval(File.read('gctools.gemspec'))
+
+require 'rubygems/package_task'
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+end
+
+# ==========================================================
+# Ruby Extension
+# ==========================================================
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('gcprof', GEMSPEC) do |ext|
+  ext.ext_dir = 'ext/gcprof'
+  ext.lib_dir = 'lib/gctools'
+end
+Rake::ExtensionTask.new('oobgc', GEMSPEC) do |ext|
+  ext.ext_dir = 'ext/oobgc'
+  ext.lib_dir = 'lib/gctools'
+end
+task :build => :compile
+
+# ==========================================================
+# Testing
+# ==========================================================
+
+require 'rake/testtask'
+Rake::TestTask.new 'test' do |t|
+  t.test_files = FileList['test/test_*.rb']
+end
+task :test => :build

data/ext/gcprof/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+have_func('rb_gc_stat')
+have_func('rb_gc_latest_gc_info')
+gc_event = have_const('RUBY_INTERNAL_EVENT_GC_END_MARK')
+
+if gc_event
+  create_makefile('gctools/gcprof')
+else
+  File.open('Makefile', 'w') do |f|
+    f.puts "install:\n\t\n"
+  end
+end

data/ext/gcprof/gcprof.c

@@ -0,0 +1,146 @@
+#include <time.h>
+#include <sys/time.h>
+#include "ruby/ruby.h"
+#include "ruby/debug.h"
+
+static VALUE mGCProf;
+static VALUE sym_time, sym_count, sym_immediate_sweep;
+static struct {
+    size_t serial;
+    VALUE tpval;
+    VALUE proc;
+
+    VALUE info;
+    VALUE start;
+    VALUE end_mark;
+    VALUE end_sweep;
+} _gcprof;
+
+  static inline double
+walltime()
+{
+  struct timespec ts;
+#ifdef HAVE_CLOCK_GETTIME
+  if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
+    rb_sys_fail("clock_gettime");
+  }
+#else
+  {
+    struct timeval tv;
+    if (gettimeofday(&tv, 0) < 0) {
+      rb_sys_fail("gettimeofday");
+    }
+    ts.tv_sec = tv.tv_sec;
+    ts.tv_nsec = tv.tv_usec * 1000;
+  }
+#endif
+  return ts.tv_sec + ts.tv_nsec * 1e-9;
+}
+
+static const char *
+event_flag_name(rb_event_flag_t flag)
+{
+  switch (flag) {
+    case RUBY_INTERNAL_EVENT_GC_START:
+      return "gc_start";
+    case RUBY_INTERNAL_EVENT_GC_END_MARK:
+      return "gc_end_mark";
+    case RUBY_INTERNAL_EVENT_GC_END_SWEEP:
+      return "gc_end_sweep";
+    default:
+      return "unknown";
+  }
+}
+
+static void
+invoke_proc(void *data)
+{
+  VALUE args[4] = {_gcprof.info, _gcprof.start, _gcprof.end_mark, _gcprof.end_sweep};
+  if (_gcprof.serial != (size_t)data) return;
+  if (_gcprof.serial != NUM2SIZET(rb_hash_aref(_gcprof.end_sweep, sym_count))) args[3] = Qnil;
+  rb_proc_call_with_block(_gcprof.proc, 4, args, Qnil);
+}
+
+static void
+gc_hook_i(VALUE tpval, void *data)
+{
+  rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+  rb_event_flag_t flag = rb_tracearg_event_flag(tparg);
+  VALUE obj =
+    flag == RUBY_INTERNAL_EVENT_GC_START ? _gcprof.start :
+    flag == RUBY_INTERNAL_EVENT_GC_END_MARK ? _gcprof.end_mark :
+    _gcprof.end_sweep;
+
+  if (0) {
+    fprintf(stderr, "TRACEPOINT: time=%f, event=%s(%zu)\n", walltime(), event_flag_name(rb_tracearg_event_flag(tparg)), rb_gc_count());
+  }
+
+  rb_hash_aset(obj, sym_time, DBL2NUM(walltime()));
+  rb_gc_stat(obj);
+
+  switch (flag) {
+    case RUBY_INTERNAL_EVENT_GC_START:
+      rb_gc_latest_gc_info(_gcprof.info);
+      _gcprof.serial = rb_gc_count();
+      return;
+    case RUBY_INTERNAL_EVENT_GC_END_MARK:
+      if (RTEST(rb_hash_aref(_gcprof.info, sym_immediate_sweep))) return;
+      /* fall through */
+    case RUBY_INTERNAL_EVENT_GC_END_SWEEP:
+      rb_postponed_job_register(0, invoke_proc, (void *)_gcprof.serial);
+      break;
+  }
+}
+
+static VALUE
+set_after_gc_hook(VALUE module, VALUE proc)
+{
+  rb_event_flag_t events;
+
+  /* disable previous keys */
+  if (RTEST(_gcprof.tpval)) {
+    rb_tracepoint_disable(_gcprof.tpval);
+    _gcprof.tpval = Qnil;
+    _gcprof.proc = Qnil;
+  }
+
+  if (RTEST(proc)) {
+    if (!rb_obj_is_proc(proc)) {
+      rb_raise(rb_eTypeError, "trace_func needs to be Proc");
+    }
+
+    events = RUBY_INTERNAL_EVENT_GC_START|RUBY_INTERNAL_EVENT_GC_END_MARK|RUBY_INTERNAL_EVENT_GC_END_SWEEP;
+    _gcprof.tpval = rb_tracepoint_new(0, events, gc_hook_i, (void *)0);
+    _gcprof.proc = proc;
+    rb_tracepoint_enable(_gcprof.tpval);
+  }
+
+  return proc;
+}
+
+
+void
+Init_gcprof(void)
+{
+  mGCProf = rb_define_module("GCProf");
+  rb_define_module_function(mGCProf, "after_gc_hook=", set_after_gc_hook, 1);
+
+  sym_immediate_sweep = ID2SYM(rb_intern("immediate_sweep"));
+  sym_time = ID2SYM(rb_intern("time"));
+  sym_count = ID2SYM(rb_intern("count"));
+
+  rb_gc_latest_gc_info(_gcprof.info = rb_hash_new());
+  _gcprof.start = rb_hash_new();
+  rb_hash_aset(_gcprof.start, sym_time, INT2FIX(0));
+  rb_gc_stat(_gcprof.start);
+  _gcprof.end_mark = rb_obj_dup(_gcprof.start);
+  _gcprof.end_sweep = rb_obj_dup(_gcprof.start);
+
+  rb_gc_register_mark_object(_gcprof.info);
+  rb_gc_register_mark_object(_gcprof.start);
+  rb_gc_register_mark_object(_gcprof.end_mark);
+  rb_gc_register_mark_object(_gcprof.end_sweep);
+
+  rb_gc_register_address(&_gcprof.proc);
+  rb_gc_register_address(&_gcprof.tpval);
+}

data/ext/oobgc/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+have_func('rb_gc_stat')
+have_func('rb_gc_latest_gc_info')
+gc_event = have_const('RUBY_INTERNAL_EVENT_GC_END_MARK')
+
+if gc_event
+  create_makefile('gctools/oobgc')
+else
+  File.open('Makefile', 'w') do |f|
+    f.puts "install:\n\t\n"
+  end
+end

data/ext/oobgc/oobgc.c

@@ -0,0 +1,217 @@
+#include <time.h>
+#include <sys/time.h>
+#include "ruby/ruby.h"
+#include "ruby/intern.h"
+#include "ruby/debug.h"
+
+struct {
+  int installed;
+  VALUE tpval;
+
+  int sweep_needed;
+  size_t prev_allocated_object;
+  size_t allocation_limit;
+  size_t heap_obj_limit;
+
+  struct {
+    size_t total_allocated_object;
+    size_t heap_tomb_page_length;
+  } start;
+
+  struct {
+    size_t mean;
+    size_t max;
+  } threshold;
+
+  struct {
+    size_t minor;
+    size_t major;
+    size_t sweep;
+  } stat;
+} _oobgc;
+
+static VALUE mOOB;
+static VALUE sym_total_allocated_object, sym_heap_swept_slot, sym_heap_tomb_page_length, sym_heap_final_slot;
+static VALUE sym_old_object, sym_old_object_limit, sym_remembered_shady_object, sym_remembered_shady_object_limit;
+static VALUE sym_major_by, sym_count, sym_major_count, sym_minor_count, sym_sweep_count, minor_gc_args;
+static    ID id_start;
+
+static void
+gc_event_i(VALUE tpval, void *data)
+{
+  rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+  rb_event_flag_t flag = rb_tracearg_event_flag(tparg);
+
+  switch (flag) {
+    case RUBY_INTERNAL_EVENT_GC_START:
+      _oobgc.allocation_limit = 0;
+      _oobgc.start.total_allocated_object = rb_gc_stat(sym_total_allocated_object);
+      _oobgc.start.heap_tomb_page_length = rb_gc_stat(sym_heap_tomb_page_length);
+      break;
+
+    case RUBY_INTERNAL_EVENT_GC_END_MARK:
+      _oobgc.sweep_needed = 1;
+      break;
+
+    case RUBY_INTERNAL_EVENT_GC_END_SWEEP:
+      _oobgc.sweep_needed = 0;
+      _oobgc.allocation_limit =
+        _oobgc.start.total_allocated_object +
+        rb_gc_stat(sym_heap_swept_slot) +
+        (rb_gc_stat(sym_heap_tomb_page_length) * _oobgc.heap_obj_limit) -
+        rb_gc_stat(sym_heap_final_slot);
+      break;
+  }
+}
+
+static VALUE
+install()
+{
+  rb_event_flag_t events =
+    RUBY_INTERNAL_EVENT_GC_START    |
+    RUBY_INTERNAL_EVENT_GC_END_MARK |
+    RUBY_INTERNAL_EVENT_GC_END_SWEEP;
+
+  if (_oobgc.installed)
+    return Qfalse;
+
+  if (!_oobgc.tpval) {
+    _oobgc.tpval = rb_tracepoint_new(0, events, gc_event_i, (void *)0);
+    rb_ivar_set(mOOB, rb_intern("tpval"), _oobgc.tpval);
+  }
+
+  rb_tracepoint_enable(_oobgc.tpval);
+  _oobgc.installed = 1;
+  return Qtrue;
+}
+
+static void
+gc_start_major()
+{
+  rb_gc_start();
+  _oobgc.stat.major++;
+}
+
+static void
+gc_start_minor()
+{
+  rb_funcall(rb_mGC, id_start, 1, minor_gc_args);
+
+  if (RTEST(rb_gc_latest_gc_info(sym_major_by)))
+    _oobgc.stat.major++;
+  else
+    _oobgc.stat.minor++;
+}
+
+static VALUE
+oobgc(VALUE self)
+{
+  size_t curr = rb_gc_stat(sym_total_allocated_object);
+  if (!_oobgc.installed) install();
+
+  if (!_oobgc.prev_allocated_object) {
+    _oobgc.prev_allocated_object = curr;
+  } else {
+    size_t diff = curr - _oobgc.prev_allocated_object;
+    _oobgc.prev_allocated_object = curr;
+
+    if (_oobgc.threshold.mean)
+      _oobgc.threshold.mean = (diff / 4) + (_oobgc.threshold.mean * 3 / 4);
+    else
+      _oobgc.threshold.mean = diff;
+
+    if (diff > _oobgc.threshold.max)
+      _oobgc.threshold.max = diff;
+    if (_oobgc.threshold.max > 200000)
+      _oobgc.threshold.max = 200000;
+  }
+
+  if (_oobgc.sweep_needed) {
+    /* lazy sweep started sometime recently.
+     * disable/enable the GC to force gc_rest_sweep() OOB
+     */
+    if (rb_gc_disable() == Qfalse) rb_gc_enable();
+    _oobgc.stat.sweep++;
+    return Qtrue;
+
+  } else if (_oobgc.allocation_limit) {
+    /* GC will be required when total_allocated_object gets
+     * close to allocation_limit
+     */
+    if ((rb_gc_stat(sym_old_object) >= rb_gc_stat(sym_old_object_limit)*0.97 ||
+        rb_gc_stat(sym_remembered_shady_object) >= rb_gc_stat(sym_remembered_shady_object_limit)*0.97) &&
+        curr >= _oobgc.allocation_limit - _oobgc.threshold.max*0.98) {
+      /*fprintf(stderr, "oobgc MAJOR: %zu >= %zu - %zu\n", curr, _oobgc.allocation_limit, _oobgc.threshold.max);*/
+      gc_start_major();
+      return Qtrue;
+
+    } else if (curr >= _oobgc.allocation_limit - _oobgc.threshold.mean) {
+      /*fprintf(stderr, "oobgc minor: %zu >= %zu - %zu\n", curr, _oobgc.allocation_limit, _oobgc.threshold.mean);*/
+      gc_start_minor();
+      return Qtrue;
+    }
+  }
+
+  return Qfalse;
+}
+
+static VALUE
+oobgc_stat(VALUE self, VALUE key)
+{
+  if (!_oobgc.installed)
+    return Qnil;
+
+  if (key == sym_count)
+    return SIZET2NUM(_oobgc.stat.major + _oobgc.stat.minor + _oobgc.stat.sweep);
+  else if (key == sym_major_count)
+    return SIZET2NUM(_oobgc.stat.major);
+  else if (key == sym_minor_count)
+    return SIZET2NUM(_oobgc.stat.minor);
+  else if (key == sym_sweep_count)
+    return SIZET2NUM(_oobgc.stat.sweep);
+  else
+    return Qnil;
+}
+
+static VALUE
+oobgc_clear(VALUE self)
+{
+  MEMZERO(&_oobgc.stat, _oobgc.stat, 1);
+  return Qnil;
+}
+
+void
+Init_oobgc()
+{
+  mOOB = rb_define_module_under(rb_mGC, "OOB");
+  rb_define_singleton_method(mOOB, "setup", install, 0);
+  rb_define_singleton_method(mOOB, "run", oobgc, 0);
+  rb_define_singleton_method(mOOB, "stat", oobgc_stat, 1);
+  rb_define_singleton_method(mOOB, "clear", oobgc_clear, 0);
+
+#define S(name) sym_##name = ID2SYM(rb_intern(#name));
+  S(total_allocated_object);
+  S(heap_swept_slot);
+  S(heap_tomb_page_length);
+  S(heap_final_slot);
+
+  S(old_object);
+  S(old_object_limit);
+  S(remembered_shady_object);
+  S(remembered_shady_object_limit);
+
+  S(major_by);
+  S(count);
+  S(major_count);
+  S(minor_count);
+  S(sweep_count);
+#undef S
+
+  id_start = rb_intern("start");
+  _oobgc.heap_obj_limit =
+    NUM2SIZET(rb_hash_aref(rb_const_get(rb_mGC, rb_intern("INTERNAL_CONSTANTS")), ID2SYM(rb_intern("HEAP_OBJ_LIMIT"))));
+
+  minor_gc_args = rb_hash_new();
+  rb_hash_aset(minor_gc_args, ID2SYM(rb_intern("full_mark")), Qfalse);
+  rb_ivar_set(mOOB, rb_intern("minor_gc_args"), minor_gc_args);
+}

data/gctools.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name = 'gctools'
+  s.version = '0.2.1'
+  s.summary = 'rgengc tools for ruby 2.1+'
+  s.description = 'gc debugger, logger and profiler for rgengc in ruby 2.1'
+
+  s.homepage = 'https://github.com/tmm1/gctools'
+  s.authors = 'Aman Gupta'
+  s.email   = 'aman@tmm1.net'
+  s.license = 'MIT'
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions = ['ext/gcprof/extconf.rb', 'ext/oobgc/extconf.rb']
+  s.add_development_dependency 'rake-compiler', '~> 0.9'
+end

data/lib/gctools/logger.rb

@@ -0,0 +1,71 @@
+require 'gctools/gcprof'
+
+=begin
+GC::Profiler.enable
+at_exit{ GC::Profiler.raw_data.map{ |d| p(d) } }
+=end
+
+=begin
+prev_alloc = GC.stat(:total_allocated_object)
+GCProf.after_gc_hook = proc { |info, start, end_mark, end_sweep|
+  before = start
+  after = end_sweep || end_mark
+
+  if !info[:immediate_sweep] && end_sweep
+    STDERR.printf "[%f:% 4d]                   swept after %1.3fs  swept:% 8d  marked:% 8d\n",
+      after[:time],
+      after[:count],
+      after[:time] - end_mark[:time],
+      after[:heap_swept_slot],
+      marked_num
+  else
+    type = info[:major_by] ? "MAJOR GC" : "minor gc"
+    diff = after[:time] - before[:time]
+    diff_alloc, prev_alloc = before[:total_allocated_object] - prev_alloc, after[:total_allocated_object]
+
+    STDERR.printf "[%f:% 4d] %s (% 13s) took %1.3fs  alloc:% 8d  live: % 8d -> % 8d  free: % 8d -> % 8d %s\n",
+      before[:time],
+      before[:count],
+      type,
+      info.values_at(:major_by, :gc_by).compact.join(","),
+      after[:time] - before[:time],
+      diff_alloc,
+      before[:heap_live_slot],
+      after[:heap_live_slot],
+      before[:heap_free_slot],
+      after[:heap_free_slot],
+      info[:immediate_sweep] ? "  +immediate_sweep" : ""
+  end
+}
+=end
+
+GCProf.after_gc_hook =
+proc{ |info, start, end_mark, end_sweep|
+  if end_sweep
+    # eden_slots = oldgen_slots + remembered_shady_slots + longlived_infant_slots + new_infant_slots + empty_eden_slots
+    # heap_swept_slot = new_infant_slots + empty_eden_slots + empty_moved_tomb_slots
+    eden_slots = GC::INTERNAL_CONSTANTS[:HEAP_OBJ_LIMIT] * end_sweep[:heap_eden_page_length]
+    oldgen_slots = end_sweep[:old_object]
+    remembered_shady_slots = end_sweep[:remembered_shady_object]
+    new_infant_slots = end_sweep[:total_allocated_object] - end_mark[:total_allocated_object]
+    empty_moved_tomb_slots = GC::INTERNAL_CONSTANTS[:HEAP_OBJ_LIMIT] * (end_sweep[:heap_tomb_page_length] - end_mark[:heap_tomb_page_length])
+    empty_eden_slots = end_sweep[:heap_swept_slot] - new_infant_slots - empty_moved_tomb_slots
+    longlived_infant_slots = eden_slots - oldgen_slots - remembered_shady_slots - new_infant_slots - empty_eden_slots
+
+    # total_slots = eden_slots + tomb_slots
+    tomb_slots = GC::INTERNAL_CONSTANTS[:HEAP_OBJ_LIMIT] * end_sweep[:heap_tomb_page_length]
+    total_slots = eden_slots + tomb_slots
+
+    STDERR.printf "[%s in %1.3fs (% 13s)] % 8d slots = old (%4.1f%%) + remembered_shady (%4.1f%%) + shady (%4.1f%%) + infant (%4.1f%%) + empty (%4.1f%%) + tomb (%4.1f%%)\n",
+      info[:major_by] ? 'MAJOR GC' : 'minor gc',
+      end_mark[:time] - start[:time],
+      info.values_at(:major_by, :gc_by).compact.join(","),
+      total_slots,
+      oldgen_slots * 100.0 / total_slots,
+      remembered_shady_slots * 100.0 / total_slots,
+      longlived_infant_slots * 100.0 / total_slots,
+      new_infant_slots * 100.0 / total_slots,
+      empty_eden_slots * 100.0 / total_slots,
+      tomb_slots * 100.0 / total_slots
+  end
+}

data/test/test_gcprof.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'gctools/gcprof'
+
+class TestGCProf < Test::Unit::TestCase
+  def teardown
+    GCProf.after_gc_hook = nil
+  end
+
+  def test_after_gc_hook
+    n = 0
+    GCProf.after_gc_hook = proc{ n += 1 }
+    GC.start
+    Object.new
+    assert_equal 1, n
+  end
+end

data/test/test_oobgc.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+require 'gctools/oobgc'
+require 'json'
+
+class TestOOBGC < Test::Unit::TestCase
+  def setup
+    GC::OOB.setup
+    GC::OOB.clear
+  end
+
+  def test_oob_sweep
+    GC.start(immediate_sweep: false)
+    assert_equal false, GC.latest_gc_info(:immediate_sweep)
+
+    before = GC.stat(:heap_swept_slot)
+    assert_equal true, GC::OOB.run
+    assert_operator GC.stat(:heap_swept_slot), :>, before
+  end
+
+  def test_oob_mark
+    oob = 0
+    before = GC.count
+    minor, major = GC.stat(:minor_gc_count), GC.stat(:major_gc_count)
+
+    20.times do
+      (10_000 + rand(25_000)).times{ Object.new }
+      oob += 1 if GC::OOB.run
+    end
+
+    assert_equal 0, GC.count - before - oob
+    assert_equal 0, GC.stat(:minor_gc_count) - minor - oob
+    assert_equal major, GC.stat(:major_gc_count)
+  end
+
+  def test_oob_major_mark
+    oob = 0
+    before = GC.count
+    minor, major = GC.stat(:minor_gc_count), GC.stat(:major_gc_count)
+    list = []
+
+    20.times do
+      2_000.times do
+        list << JSON.parse('{"hello":"world", "foo":["bar","bar"], "zap":{"zap":"zap"}}')
+        list.shift if list.size > 2_000
+      end
+      oob += 1 if GC::OOB.run
+    end
+
+    assert_equal oob, GC::OOB.stat(:count)
+    assert_equal 1, GC.count - before -
+      GC::OOB.stat(:major_count) - GC::OOB.stat(:minor_count) - GC::OOB.stat(:sweep_count)
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: gctools
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Aman Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: gc debugger, logger and profiler for rgengc in ruby 2.1
+email: aman@tmm1.net
+executables: []
+extensions:
+- ext/gcprof/extconf.rb
+- ext/oobgc/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- ext/gcprof/extconf.rb
+- ext/gcprof/gcprof.c
+- ext/oobgc/extconf.rb
+- ext/oobgc/oobgc.c
+- gctools.gemspec
+- lib/gctools/logger.rb
+- test/test_gcprof.rb
+- test/test_oobgc.rb
+homepage: https://github.com/tmm1/gctools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: rgengc tools for ruby 2.1+
+test_files: []
+has_rdoc: