living_dead 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6409ddbc4318a1d8753890c7f29344587e66fe9f
+  data.tar.gz: 26d81012fe0155e3f8fe0c359f4cbae0d9190d98
+SHA512:
+  metadata.gz: 28f80d02748e796776325a4fc6e8922a0442480ae9ec9395ce66c040ca8ee2824e45e9e3325032683ac6e640dff5be58bd8eabe6171a265be1ad337d5c352a4f
+  data.tar.gz: c10210bc2c3d0ab0fb3e5175810824b4423fcfdff639c3ef871c3c66d45c0244076e1d1b086945d7c062072aa61e12369792338183d2bc16b31232072e6ec5c0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+*.bundle

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.3.3
+before_install:
+  - gem update bundler

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in living_dead.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Richard Schneeman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,108 @@
+# LivingDead
+
+[![Build Status](https://travis-ci.org/schneems/living_dead.svg?branch=master)](https://travis-ci.org/schneems/living_dead)
+
+This module allows to see if an object is retained "still alive" or if it is freed "dead".
+
+![Dancing Zombies](https://www.dropbox.com/s/lshgqzek77107mh/zombies.gif?dl=1)
+
+## Problems
+
+There be dragons see `LivingDead.gc_start` to see some of the hacks we have to do for who knows why to get this to work.
+
+## Install
+
+In your Gemfile add:
+
+```
+gem 'living_dead'
+```
+
+Then run
+
+```
+$ bundle install
+```
+
+## How it works
+
+Before you use this you should understand how it works. This gem is a c-extension. It hooks into the Ruby tracepoint API and registeres a hook for the `RUBY_INTERNAL_EVENT_FREEOBJ` event. This
+event gets called when an object is freed (i.e. it is not retained and garbage collection has been called).
+
+When you call `LivingDead.trace(obj)` we store the `object_id` of the thing you are "tracing" in a hash. Then inside of our c-extension hook we listen for when an object is freed. When this happens we check to see if that object's `object_id` matches one in our hash. If it does we mark it down in a seperate "freed" hash.
+
+We don't retain the objects you are tracing but we do keep a copy of the `object_id`, we can then use this same number to check the freed hash to see if it was recorded as being freed.
+
+> WARNING: Seriously, see `LivingDead.gc_start`. This library isn't bullet proof.
+
+## Quick Start
+
+Require the library and use `LivingDead.trace` to "trace" an object. Later use `LivingDead.traced_objects` to iterate through "tracers" of each object.
+
+Here is an example of tracing an object that is not retained:
+
+```
+require 'living_dead'
+
+def run
+  obj = Object.new
+  LivingDead.trace(obj)
+
+  return nil
+end
+
+run
+
+puts LivingDead.traced_objects.select {|tracer| tracer.retained? }.count
+# => 0
+```
+
+> Note: Calling `LivingDead.traced_objects` auto calls `GC.start`, you don't need to do it manually. However you should look at the implementation of `LivingDead.gc_start` to understand the depth of hacks you're playing with.
+
+Here is an example of tracing an object that IS retained:
+
+```
+require 'living_dead'
+
+def run
+  obj = Object.new
+  LivingDead.trace(obj)
+
+  return obj
+end
+
+@retained_here = run
+
+puts LivingDead.traced_objects.select {|tracer| tracer.retained? }.count
+# => 1
+```
+
+You can get more ways of interacting with a tracer by looking at `LivingDead::ObjectTrace`.
+
+## Development
+
+Compile the code:
+
+```
+$ rake compile
+```
+
+Run the tests:
+
+```
+$ rake spec
+```
+
+or "why not both":
+
+```
+$ rake compile spec
+```
+
+## License
+
+MIT
+
+Copyright Richard Schneeman 2016
+
+

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require 'rspec/core/rake_task'
+
+spec = Gem::Specification.load('living_dead.gemspec')
+
+Rake::ExtensionTask.new("living_dead", spec){|ext|
+  ext.lib_dir = "lib/living_dead"
+}
+
+RSpec::Core::RakeTask.new('spec' => 'compile')
+
+task default: :spec
+
+task :run => 'compile' do
+  ruby %q{-I ./lib test.rb}
+end

data/changelog.md

@@ -0,0 +1,5 @@
+## Master
+
+## 0.0.1
+
+- Initial release

data/ext/living_dead/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('living_dead/living_dead')

data/ext/living_dead/living_dead.c

@@ -0,0 +1,217 @@
+#include "ruby/ruby.h"
+#include "ruby/debug.h"
+#include <assert.h>
+
+size_t rb_obj_memsize_of(VALUE obj); /* in gc.c */
+
+static VALUE rb_mLivingDead;
+
+#define MAX_KEY_DATA 4
+
+#define KEY_PATH    (1<<1)
+#define KEY_LINE    (1<<2)
+#define KEY_TYPE    (1<<3)
+#define KEY_CLASS   (1<<4)
+
+#define MAX_VAL_DATA 6
+
+#define VAL_COUNT     (1<<1)
+#define VAL_OLDCOUNT  (1<<2)
+#define VAL_TOTAL_AGE (1<<3)
+#define VAL_MIN_AGE   (1<<4)
+#define VAL_MAX_AGE   (1<<5)
+#define VAL_MEMSIZE   (1<<6)
+
+struct traceobj_arg {
+    int running;
+    int keys, vals;
+    st_table *object_table;     /* obj (VALUE)      -> allocation_info */
+    st_table *str_table;        /* cstr             -> refcount */
+
+    st_table *aggregate_table;  /* user defined key -> [count, total_age, max_age, min_age] */
+    struct allocation_info *freed_allocation_info;
+
+    /* */
+    size_t **lifetime_table;
+    size_t allocated_count_table[T_MASK];
+    size_t freed_count_table[T_MASK];
+};
+
+struct memcmp_key_data {
+    int n;
+    st_data_t data[MAX_KEY_DATA];
+};
+
+static int
+memcmp_hash_compare(st_data_t a, st_data_t b)
+{
+    struct memcmp_key_data *k1 = (struct memcmp_key_data *)a;
+    struct memcmp_key_data *k2 = (struct memcmp_key_data *)b;
+    return memcmp(&k1->data[0], &k2->data[0], k1->n * sizeof(st_data_t));
+}
+
+static st_index_t
+memcmp_hash_hash(st_data_t a)
+{
+    struct memcmp_key_data *k = (struct memcmp_key_data *)a;
+    return rb_memhash(k->data, sizeof(st_data_t) * k->n);
+}
+
+static const struct st_hash_type memcmp_hash_type = {
+    memcmp_hash_compare, memcmp_hash_hash
+};
+
+static struct traceobj_arg *tmp_trace_arg;
+
+/*
+ * I honestly coppied this from https://github.com/ko1/allocation_tracer
+ * We don't need all this per-say. However it's not hurting anything by being here
+ * at the moment. Same goes for the majority of code above this point.
+ */
+static struct traceobj_arg *
+get_traceobj_arg(void)
+{
+    if (tmp_trace_arg == 0) {
+        tmp_trace_arg = ALLOC_N(struct traceobj_arg, 1);
+        MEMZERO(tmp_trace_arg, struct traceobj_arg, 1);
+        tmp_trace_arg->running = 0;
+        tmp_trace_arg->keys = 0;
+        tmp_trace_arg->vals = VAL_COUNT | VAL_OLDCOUNT | VAL_TOTAL_AGE | VAL_MAX_AGE | VAL_MIN_AGE | VAL_MEMSIZE;
+        tmp_trace_arg->aggregate_table = st_init_table(&memcmp_hash_type);
+        tmp_trace_arg->object_table = st_init_numtable();
+        tmp_trace_arg->str_table = st_init_strtable();
+        tmp_trace_arg->freed_allocation_info = NULL;
+        tmp_trace_arg->lifetime_table = NULL;
+    }
+    return tmp_trace_arg;
+}
+
+/*
+ *
+ * [Internal] Callback for the RUBY_INTERNAL_EVENT_FREEOBJ event
+ *
+ * When an object is freed we check if we are tracing it.
+ * If we are, then we register in the `freed_hash` that it has
+ * been freed by setting the `object_id` key to a value of `true`
+ *
+ */
+static void
+freeobj_i(VALUE tpval, void *data)
+{
+    // struct traceobj_arg *arg = (struct traceobj_arg *)data;
+    VALUE freed_object_id_hash   = rb_ivar_get(rb_mLivingDead, rb_intern("freed_object_id_hash"));
+    VALUE object_id_tracing_hash = rb_ivar_get(rb_mLivingDead, rb_intern("object_id_tracing_hash"));
+
+    rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+    VALUE obj = rb_tracearg_object(tparg);
+    VALUE object_id = rb_obj_id(obj);
+
+
+    // Useful for debugging, we cannot use `rb_p` here since it allocates new memory
+    // Using `rb_p` here will cause a SEGV.
+    //
+    // long oid = NUM2LONG(rb_obj_id(obj));
+    // printf("Freed: %lu\n", oid);
+
+    if (rb_hash_aref(object_id_tracing_hash, object_id) != Qnil ) {
+        rb_hash_aset(freed_object_id_hash, rb_obj_id(obj), Qtrue);
+    }
+}
+
+// Used for debugging only
+//
+// static void
+// newobj_i(VALUE tpval, void *data)
+// {
+//     // struct traceobj_arg *arg = (struct traceobj_arg *)data;
+
+//     rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+//     VALUE obj = rb_tracearg_object(tparg);
+//     long oid = NUM2LONG(rb_obj_id(obj));
+//     printf("NEW: %lu\n", oid);
+// }
+
+
+/*
+ *
+ *  call-seq:
+ *     LivingDead.start -> nil
+ *
+ * Begins tracing object free events
+ *
+ */
+static VALUE
+living_dead_start(VALUE self)
+{
+    VALUE freeobj_hook;
+    // VALUE newobj_hook;
+    struct traceobj_arg *arg = get_traceobj_arg();
+
+    if ((freeobj_hook = rb_ivar_get(rb_mLivingDead, rb_intern("freeobj_hook"))) == Qnil) {
+        rb_ivar_set(rb_mLivingDead, rb_intern("freeobj_hook"), freeobj_hook = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, arg));
+        rb_ivar_set(rb_mLivingDead, rb_intern("object_id_tracing_hash"), rb_hash_new());
+        rb_ivar_set(rb_mLivingDead, rb_intern("freed_object_id_hash"), rb_hash_new());
+
+        // new hook for debugging only
+        // rb_ivar_set(rb_mLivingDead, rb_intern("newobj_hook"), newobj_hook = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, arg));
+
+        // rb_tracepoint_enable(newobj_hook);
+        rb_tracepoint_enable(freeobj_hook);
+    }
+
+    return Qnil;
+}
+
+
+/*
+ *
+ *  call-seq:
+ *     LivingDead.freed_hash  -> {}
+ *
+ * Returns a hash of freed object ids
+ *
+ * The keys are the object ID, values are `true` if they have been freed
+ * otherwise `false`. Note you must invoke GC before calling this method
+ * see LivingDead.gc_start
+ *
+ */
+static VALUE
+living_dead_freed_hash(VALUE self)
+{
+    VALUE freed_object_id_hash = rb_ivar_get(rb_mLivingDead, rb_intern("freed_object_id_hash"));
+
+    return freed_object_id_hash;
+}
+
+/*
+ *
+ *  call-seq:
+ *     LivingDead.tracing_hash  -> {}
+ *
+ * Returns a hash of traced object ids
+ *
+ * The keys are the object ID of the object being traced, values are all truthy.
+ * In `LivingDead.trace` we set the value to be an instance of `LivingDead::ObjectTrace`.
+ *
+ */
+static VALUE
+living_dead_tracing_hash(VALUE self)
+{
+    VALUE freed_object_id_hash = rb_ivar_get(rb_mLivingDead, rb_intern("object_id_tracing_hash"));
+
+    return freed_object_id_hash;
+}
+
+
+void
+Init_living_dead(void)
+{
+    VALUE mod = rb_mLivingDead = rb_const_get(rb_cObject, rb_intern("LivingDead"));
+
+    // LivingDead.trace is a ruby level method
+    // rb_define_module_function(mod, "trace",      living_dead_trace, 1);
+    rb_define_module_function(mod, "start",      living_dead_start, 0);
+    rb_define_module_function(mod, "freed_hash", living_dead_freed_hash, 0);
+    rb_define_module_function(mod, "tracing_hash", living_dead_tracing_hash, 0);
+
+}

data/lib/living_dead.rb

@@ -0,0 +1,96 @@
+require "living_dead/version"
+require "living_dead/living_dead"
+
+require 'stringio'
+
+module LivingDead
+
+  @string_io = StringIO.new
+
+  def self.trace(*args)
+    self.start
+    trace = ObjectTrace.new(*args)
+
+    self.tracing_hash[trace.key] = trace
+    self.freed_hash[trace.key]   = false
+  end
+
+  def self.traced_objects
+    gc_start
+    tracing_hash.map do |_, trace|
+      trace
+    end
+  end
+
+  private
+    # GIANT BALL OF HACKS || THERE BE DRAGONS
+    #
+    # There is so much I don't understand on why I need to do the things
+    # I'm doing in this method.
+    def self.gc_start
+      # During debugging I found calling "puts" made some things
+      # mysteriously work, I have no idea why. If you remove this line
+      # then (more) tests fail. Maybe it has something to do with the way
+      # GC interacts with IO? I seriously have no idea.
+      #
+      @string_io.puts "=="
+
+      # Calling flush so we don't create a memory leak.
+      # Funny enough maybe calling flush without `puts` also works?
+      # IDK
+      #
+      @string_io.flush
+
+      # Why do we need this? Well I'll tell you...
+      # LivingDead calling `singleton_class.instance_eval` does not retain in the simple case
+      # fails without this.
+      #
+      LivingDead.freed_hash
+
+      # Calling GC multiple times fixes a different class of things
+      # Specifically the singleton_class.instance_eval tests.
+      # It might also be related to calling GC in a block, but changing
+      # to 1.times brings back failures.
+      #
+      # Calling 2 times results in eventual failure https://twitter.com/schneems/status/804369346910896128
+      # Calling 5 times results in eventual failure https://twitter.com/schneems/status/804382968307445760
+      # Trying 10 times
+      #
+      10.times { GC.start }
+    end
+  public
+
+  def self.freed_objects
+    gc_start
+    freed_hash.map do |key, _|
+      tracing_hash[key]
+    end
+  end
+
+  class ObjectTrace
+    def initialize(obj = nil, object_id: nil, to_s: nil)
+      @object_id = object_id || obj.object_id
+      @to_s      = to_s&.dup || obj.to_s.dup
+    end
+
+    def to_s
+      "#<LivingDead::ObjectTrace:#{ "0x#{ (object_id << 1).to_s(16) }" } @object_id=#{@object_id} @to_s=#{ @to_s.inspect }, @freed=#{ freed? }>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def retained?
+      !freed?
+    end
+
+    def freed?
+      !!LivingDead.freed_hash[@object_id]
+    end
+
+    def key
+      @object_id
+    end
+  end
+end