memprof 0.2.9 → 0.3.0

data/ext/extconf.rb

@@ -144,18 +144,41 @@ if have_header('mach-o/dyld.h')
   # XXX How to determine this properly? RUBY_PLATFORM reports "i686-darwin10.2.0" on Snow Leopard.
   add_define "_ARCH_x86_64_"
 
-  expressions = [
-    [:sizeof__RVALUE, "sizeof(RVALUE)"],
-    [:sizeof__heaps_slot, "sizeof(struct heaps_slot)"],
-    [:offset__heaps_slot__slot, "(int)&(((struct heaps_slot *)0)->slot)"],
-    [:offset__heaps_slot__limit, "(int)&(((struct heaps_slot *)0)->limit)"]
-    # "&add_freelist",
-    # "&rb_newobj",
-    # "&freelist",
-    # "&heaps",
-    # "&heaps_used"
+  sizes_of = [
+    'RVALUE',
+    'struct heaps_slot'
   ]
 
+  offsets_of = {
+    'struct heaps_slot' => %w[ slot limit ],
+    'struct BLOCK' => %w[ body var cref self klass wrapper block_obj orig_thread dyna_vars scope prev ],
+    'struct METHOD' => %w[ klass rklass recv id oid body ]
+  }
+
+  addresses_of = [
+    # 'add_freelist',
+    # 'rb_newobj',
+    # 'freelist',
+    # 'heaps',
+    # 'heaps_used'
+  ]
+
+  expressions = []
+
+  sizes_of.each do |type|
+    name = type.sub(/^struct\s*/,'')
+    expressions << ["sizeof__#{name}", "sizeof(#{type})"]
+  end
+  offsets_of.each do |type, members|
+    name = type.sub(/^struct\s*/,'')
+    members.each do |member|
+      expressions << ["offset__#{name}__#{member}", "(size_t)&(((#{type} *)0)->#{member})"]
+    end
+  end
+  addresses_of.each do |name|
+    expressions << ["address__#{name}", "&#{name}"]
+  end
+
   pid = fork{sleep}
   output = IO.popen('gdb --interpreter=mi --quiet', 'w+') do |io|
     io.puts "attach #{pid}"
@@ -175,8 +198,8 @@ if have_header('mach-o/dyld.h')
   end
 
   values = results.map{ |l| l[/value="(.+?)"/, 1] }
-  vars = Hash[ *expressions.map{|n,e| n }.zip(values).flatten(1) ].each do |name, val|
-    add_define "#{name}=#{val}"
+  vars = Hash[ *expressions.map{|n,e| n }.zip(values).flatten ].each do |name, val|
+    add_define "#{name}=#{val.split.first}"
   end
 end
 
@@ -189,7 +212,10 @@ when 'i486'
 end
 add_define "_ARCH_#{arch}_"
 
-add_define "_MEMPROF_DEBUG" if ENV['MEMPROF_DEBUG'] == '1'
+if ENV['MEMPROF_DEBUG'] == '1'
+  add_define "_MEMPROF_DEBUG"
+  $preload = ["\nCFLAGS = -Wall -Wextra -fPIC -ggdb3 -O0"]
+end
 
 if is_elf or is_macho
   create_makefile('memprof')

data/ext/mach.c

@@ -348,7 +348,7 @@ get_symtab_string(uint32_t stroff) {
  */
 
 void *
-bin_find_symbol(const char *symbol, size_t *size) {
+bin_find_symbol(const char *symbol, size_t *size, int search_libs) {
   void *ptr = NULL;
   uint32_t i, j;
 
@@ -438,12 +438,12 @@ bin_find_symbol_name(void *symbol) {
  */
 
 int
-bin_update_image(const char *trampee, struct tramp_st2_entry *tramp)
+bin_update_image(const char *trampee, struct tramp_st2_entry *tramp, void **orig_function)
 {
   int ret = -1;
   int i;
   int header_count = _dyld_image_count();
-  void *trampee_addr = bin_find_symbol(trampee, NULL);
+  void *trampee_addr = bin_find_symbol(trampee, NULL, 0);
 
   // Go through all the mach objects that are loaded into this process
   for (i=0; i < header_count; i++) {

data/ext/memprof.c

@@ -4,14 +4,14 @@
 #define _GNU_SOURCE
 #endif
 
+#include <assert.h>
+#include <err.h>
 #include <fcntl.h>
 #include <stddef.h>
-#include <stdio.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <assert.h>
-#include <err.h>
 #include <sysexits.h>
 
 #include <st.h>
@@ -23,20 +23,36 @@
 #include "tramp.h"
 #include "util.h"
 
-
 /*
  * bleak_house stuff
  */
 static VALUE eUnsupported;
 static int track_objs = 0;
+static int memprof_started = 0;
 static st_table *objs = NULL;
 
+/*
+ * stuff needed for heap dumping
+ */
+static VALUE (*rb_classname)(VALUE);
+static double (*rb_timeofday)();
+static RUBY_DATA_FUNC *rb_bm_mark;
+static RUBY_DATA_FUNC *rb_blk_free;
+static RUBY_DATA_FUNC *rb_thread_mark;
 struct memprof_config memprof_config;
 
+/*
+ * memprof config struct init
+ */
+static void init_memprof_config_base();
+static void init_memprof_config_extended();
+
 struct obj_track {
   VALUE obj;
   char *source;
   int line;
+  int len;
+  struct timeval time[];
 };
 
 static VALUE gc_hook;
@@ -92,7 +108,7 @@ newobj_tramp()
   struct obj_track *tracker = NULL;
 
   if (track_objs && objs) {
-    tracker = malloc(sizeof(*tracker));
+    tracker = malloc(sizeof(*tracker) + sizeof(struct timeval));
 
     if (tracker) {
       if (ruby_current_node && ruby_current_node->nd_file &&
@@ -108,6 +124,13 @@ newobj_tramp()
       }
 
       tracker->obj = ret;
+      tracker->len = 1;
+
+      /* TODO a way for the user to disallow time tracking */
+      if (gettimeofday(&tracker->time[0], NULL) == -1) {
+        perror("gettimeofday failed. Continuing anyway, error");
+      }
+
       rb_gc_disable();
       st_insert(objs, (st_data_t)ret, (st_data_t)tracker);
       rb_gc_enable();
@@ -209,6 +232,13 @@ objs_to_array(st_data_t key, st_data_t record, st_data_t arg)
 static VALUE
 memprof_start(VALUE self)
 {
+  if (!memprof_started) {
+
+    insert_tramp("rb_newobj", newobj_tramp);
+    insert_tramp("add_freelist", freelist_tramp);
+    memprof_started = 1;
+  }
+
   if (track_objs == 1)
     return Qfalse;
 
@@ -219,6 +249,8 @@ memprof_start(VALUE self)
 static VALUE
 memprof_stop(VALUE self)
 {
+  /* TODO: remove trampolines and set memprof_started = 0 */
+
   if (track_objs == 0)
     return Qfalse;
 
@@ -302,11 +334,215 @@ memprof_track(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+struct memprof_malloc_stats {
+  size_t malloc_bytes_requested;
+  size_t calloc_bytes_requested;
+  size_t realloc_bytes_requested;
+
+  size_t malloc_bytes_actual;
+  size_t calloc_bytes_actual;
+  size_t realloc_bytes_actual;
+  size_t free_bytes_actual;
+
+  size_t malloc_calls;
+  size_t calloc_calls;
+  size_t realloc_calls;
+  size_t free_calls;
+};
+
+static struct memprof_malloc_stats memprof_malloc_stats;
+static void *orig_malloc, *orig_realloc, *orig_calloc, *orig_free;
+static size_t (*malloc_usable_size)(void *ptr);
+
+static void *
+malloc_tramp(size_t size)
+{
+  void *ret = NULL;
+  memprof_malloc_stats.malloc_bytes_requested += size;
+  memprof_malloc_stats.malloc_calls++;
+  ret = malloc(size);
+  memprof_malloc_stats.malloc_bytes_actual += malloc_usable_size(ret);
+  return ret;
+}
+
+static void *
+calloc_tramp(size_t nmemb, size_t size)
+{
+  void *ret = NULL;
+  memprof_malloc_stats.calloc_bytes_requested += (nmemb * size);
+  memprof_malloc_stats.calloc_calls++;
+  ret = calloc(nmemb, size);
+  memprof_malloc_stats.calloc_bytes_actual += malloc_usable_size(ret);
+  return ret;
+}
+
+static void *
+realloc_tramp(void *ptr, size_t size)
+{
+  /* TODO need to check malloc_usable_size of before/after i guess? */
+  void *ret = NULL;
+  memprof_malloc_stats.realloc_bytes_requested += size;
+  memprof_malloc_stats.realloc_calls++;
+  ret = realloc(ptr, size);
+  memprof_malloc_stats.realloc_bytes_actual += malloc_usable_size(ptr);
+  return ret;
+}
+
+static void
+free_tramp(void *ptr)
+{
+  /* TODO use malloc_usable_size to track bytes freed? */
+  memprof_malloc_stats.free_bytes_actual += malloc_usable_size(ptr);
+  memprof_malloc_stats.free_calls++;
+  free(ptr);
+}
+
+static void
+memprof_start_track_bytes()
+{
+  struct tramp_st2_entry tmp;
+
+  if (!malloc_usable_size) {
+    if ((malloc_usable_size =
+          bin_find_symbol("MallocExtension_GetAllocatedSize", NULL, 1)) == NULL) {
+      malloc_usable_size = bin_find_symbol("malloc_usable_size", NULL, 1);
+      dbg_printf("tcmalloc was not found...\n");
+    }
+    assert(malloc_usable_size != NULL);
+    dbg_printf("malloc_usable_size: %p\n", malloc_usable_size);
+  }
+
+  tmp.addr = malloc_tramp;
+  bin_update_image("malloc", &tmp, &orig_malloc);
+  assert(orig_malloc != NULL);
+  dbg_printf("orig_malloc: %p\n", orig_malloc);
+
+  tmp.addr = realloc_tramp;
+  bin_update_image("realloc", &tmp, &orig_realloc);
+  dbg_printf("orig_realloc: %p\n", orig_realloc);
+
+  tmp.addr = calloc_tramp;
+  bin_update_image("calloc", &tmp, &orig_calloc);
+  dbg_printf("orig_calloc: %p\n", orig_calloc);
+
+  tmp.addr = free_tramp;
+  bin_update_image("free", &tmp, &orig_free);
+  assert(orig_free != NULL);
+  dbg_printf("orig_free: %p\n", orig_free);
+}
+
+static void
+memprof_stop_track_bytes()
+{
+  struct tramp_st2_entry tmp;
+
+  tmp.addr = orig_malloc;
+  bin_update_image("malloc", &tmp, NULL);
+
+  tmp.addr = orig_realloc;
+  bin_update_image("realloc", &tmp, NULL);
+
+  tmp.addr = orig_calloc;
+  bin_update_image("calloc", &tmp, NULL);
+
+  tmp.addr = orig_free;
+  bin_update_image("free", &tmp, NULL);
+}
+
+static void
+memprof_reset_track_bytes()
+{
+  memset(&memprof_malloc_stats, 0, sizeof(memprof_malloc_stats));
+}
+
+static VALUE
+memprof_track_bytes(int argc, VALUE *argv, VALUE self)
+{
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "block required");
+
+  memprof_start_track_bytes();
+  rb_yield(Qnil);
+  fprintf(stderr, "================ Requested ====================\n");
+  fprintf(stderr, "Malloced: %zd, Realloced: %zd, Calloced: %zd\n",
+      memprof_malloc_stats.malloc_bytes_requested, memprof_malloc_stats.realloc_bytes_requested,
+      memprof_malloc_stats.calloc_bytes_requested);
+  fprintf(stderr, "================ Actual ====================\n");
+  fprintf(stderr, "Malloced: %zd, Realloced: %zd, Calloced: %zd, Freed: %zd\n",
+      memprof_malloc_stats.malloc_bytes_actual, memprof_malloc_stats.realloc_bytes_actual,
+      memprof_malloc_stats.calloc_bytes_actual, memprof_malloc_stats.free_bytes_actual);
+  fprintf(stderr, "================ Call count ====================\n");
+  fprintf(stderr, "Calls to malloc: %zd, realloc: %zd, calloc: %zd, free: %zd\n",
+      memprof_malloc_stats.malloc_calls,
+      memprof_malloc_stats.realloc_calls,
+      memprof_malloc_stats.calloc_calls,
+      memprof_malloc_stats.free_calls);
+
+  memprof_reset_track_bytes();
+  memprof_stop_track_bytes();
+  return Qnil;
+}
+
 #include <yajl/yajl_gen.h>
 #include <stdarg.h>
 #include "env.h"
+#include "rubyio.h"
 #include "re.h"
 
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(ary) RARRAY(ary)->ptr
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(ary) RARRAY(ary)->len
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(str) RSTRING(str)->len
+#endif
+
+/* HAX: copied from internal yajl_gen.c (PATCH yajl before building instead)
+ */
+
+typedef enum {
+    yajl_gen_start,
+    yajl_gen_map_start,
+    yajl_gen_map_key,
+    yajl_gen_map_val,
+    yajl_gen_array_start,
+    yajl_gen_in_array,
+    yajl_gen_complete,
+    yajl_gen_error
+} yajl_gen_state;
+
+struct yajl_gen_t
+{
+    unsigned int depth;
+    unsigned int pretty;
+    const char * indentString;
+    yajl_gen_state state[YAJL_MAX_DEPTH];
+    yajl_print_t print;
+    void * ctx; /* yajl_buf */
+    /* memory allocation routines */
+    yajl_alloc_funcs alloc;
+};
+
+static void
+yajl_gen_reset(yajl_gen gen)
+{
+  yajl_gen_clear(gen);
+  assert (gen->state[gen->depth] == yajl_gen_complete);
+  gen->state[gen->depth] = yajl_gen_start;
+  gen->print(gen->ctx, "\n", 1);
+}
+
+/* END HAX
+ */
+
 static yajl_gen_status
 yajl_gen_cstr(yajl_gen gen, const char * str)
 {
@@ -335,6 +571,24 @@ yajl_gen_format(yajl_gen gen, char *format, ...)
   return ret;
 }
 
+static yajl_gen_status
+yajl_gen_id(yajl_gen gen, ID id)
+{
+  if (id) {
+    if (id < 100)
+      return yajl_gen_format(gen, ":%c", id);
+    else
+      return yajl_gen_format(gen, ":%s", rb_id2name(id));
+  } else
+    return yajl_gen_null(gen);
+}
+
+static yajl_gen_status
+yajl_gen_pointer(yajl_gen gen, void* ptr)
+{
+  return yajl_gen_format(gen, "0x%x", ptr);
+}
+
 static yajl_gen_status
 yajl_gen_value(yajl_gen gen, VALUE obj)
 {
@@ -347,9 +601,9 @@ yajl_gen_value(yajl_gen gen, VALUE obj)
   else if (obj == Qfalse)
     return yajl_gen_bool(gen, 0);
   else if (SYMBOL_P(obj))
-    return yajl_gen_format(gen, ":%s", rb_id2name(SYM2ID(obj)));
+    return yajl_gen_id(gen, SYM2ID(obj));
   else
-    return yajl_gen_format(gen, "0x%x", obj);
+    return yajl_gen_pointer(gen, (void*)obj);
 }
 
 static int
@@ -418,7 +672,20 @@ nd_type_str(VALUE obj)
   }
 }
 
-static VALUE (*rb_classname)(VALUE);
+static inline void
+obj_dump_class(yajl_gen gen, VALUE obj)
+{
+  if (RBASIC(obj)->klass) {
+    yajl_gen_cstr(gen, "class");
+    yajl_gen_value(gen, RBASIC(obj)->klass);
+
+    VALUE name = rb_classname(RBASIC(obj)->klass);
+    if (RTEST(name)) {
+      yajl_gen_cstr(gen, "class_name");
+      yajl_gen_cstr(gen, RSTRING_PTR(name));
+    }
+  }
+}
 
 /* TODO
  *  look for FL_EXIVAR flag and print ivars
@@ -442,42 +709,307 @@ obj_dump(VALUE obj, yajl_gen gen)
     yajl_gen_cstr(gen, tracker->source);
     yajl_gen_cstr(gen, "line");
     yajl_gen_integer(gen, tracker->line);
+    yajl_gen_cstr(gen, "time");
+    yajl_gen_integer(gen, (tracker->time[0].tv_sec * 1000000) + tracker->time[0].tv_usec);
   }
 
   yajl_gen_cstr(gen, "type");
   switch (type=BUILTIN_TYPE(obj)) {
     case T_DATA:
       yajl_gen_cstr(gen, "data");
+      obj_dump_class(gen, obj);
 
-      if (RBASIC(obj)->klass) {
-        yajl_gen_cstr(gen, "class");
-        yajl_gen_value(gen, RBASIC(obj)->klass);
+      if (DATA_PTR(obj)) {
+        yajl_gen_cstr(gen, "data");
+        yajl_gen_pointer(gen, DATA_PTR(obj));
+      }
+
+      if (RDATA(obj)->dfree == (RUBY_DATA_FUNC)rb_blk_free) {
+        void *val;
+        VALUE ptr;
+
+        val = *(void**)(DATA_PTR(obj) + memprof_config.offset_BLOCK_body);
+        if (val) {
+          yajl_gen_cstr(gen, "nd_body");
+          yajl_gen_pointer(gen, val);
+        }
+
+        val = *(void**)(DATA_PTR(obj) + memprof_config.offset_BLOCK_var);
+        if (val) {
+          yajl_gen_cstr(gen, "nd_var");
+          yajl_gen_pointer(gen, val);
+        }
+
+        val = *(void**)(DATA_PTR(obj) + memprof_config.offset_BLOCK_cref);
+        if (val) {
+          yajl_gen_cstr(gen, "nd_cref");
+          yajl_gen_pointer(gen, val);
+        }
+
+        val = *(void**)(DATA_PTR(obj) + memprof_config.offset_BLOCK_dyna_vars);
+        if (val) {
+          yajl_gen_cstr(gen, "vars");
+          yajl_gen_pointer(gen, val);
+        }
+
+        val = *(void**)(DATA_PTR(obj) + memprof_config.offset_BLOCK_scope);
+        if (val) {
+          yajl_gen_cstr(gen, "scope");
+          yajl_gen_pointer(gen, val);
+        }
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_BLOCK_self);
+        yajl_gen_cstr(gen, "self");
+        yajl_gen_value(gen, ptr);
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_BLOCK_klass);
+        yajl_gen_cstr(gen, "klass");
+        yajl_gen_value(gen, ptr);
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_BLOCK_orig_thread);
+        yajl_gen_cstr(gen, "thread");
+        yajl_gen_value(gen, ptr);
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_BLOCK_wrapper);
+        if (RTEST(ptr)) {
+          yajl_gen_cstr(gen, "wrapper");
+          yajl_gen_value(gen, ptr);
+        }
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_BLOCK_block_obj);
+        if (RTEST(ptr)) {
+          yajl_gen_cstr(gen, "block");
+          yajl_gen_value(gen, ptr);
+        }
+
+        /* TODO: is .prev actually useful? refers to non-heap allocated struct BLOCKs,
+         * but we don't print out any information about those
+         */
+        /*
+        yajl_gen_cstr(gen, "prev");
+        yajl_gen_array_open(gen);
+        val = *(void**)(DATA_PTR(obj) + memprof_config.offset_BLOCK_prev);
+        while (val) {
+          yajl_gen_pointer(gen, val);
+          prev = val;
+          val = *(void**)(ptr + memprof_config.offset_BLOCK_prev);
+          if (prev == val)
+            break;
+        }
+        yajl_gen_array_close(gen);
+        */
+
+      } else if (RDATA(obj)->dmark == (RUBY_DATA_FUNC)rb_bm_mark) {
+        VALUE ptr;
+        ID id, mid;
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_METHOD_klass);
+        if (RTEST(ptr)) {
+          yajl_gen_cstr(gen, "klass");
+          yajl_gen_value(gen, ptr);
+        }
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_METHOD_rklass);
+        if (RTEST(ptr)) {
+          yajl_gen_cstr(gen, "rklass");
+          yajl_gen_value(gen, ptr);
+        }
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_METHOD_recv);
+        if (RTEST(ptr)) {
+          yajl_gen_cstr(gen, "recv");
+          yajl_gen_value(gen, ptr);
+        }
+
+        ptr = *(VALUE*)(DATA_PTR(obj) + memprof_config.offset_METHOD_body);
+        if (RTEST(ptr)) {
+          yajl_gen_cstr(gen, "node");
+          yajl_gen_value(gen, ptr);
+        }
+
+        mid = *(ID*)(DATA_PTR(obj) + memprof_config.offset_METHOD_id);
+        if (mid) {
+          yajl_gen_cstr(gen, "mid");
+          yajl_gen_id(gen, mid);
+        }
+
+        id = *(ID*)(DATA_PTR(obj) + memprof_config.offset_METHOD_oid);
+        if (id && id != mid) {
+          yajl_gen_cstr(gen, "oid");
+          yajl_gen_id(gen, id);
+        }
+
+      } else if (RDATA(obj)->dmark == (RUBY_DATA_FUNC)rb_thread_mark) {
+        rb_thread_t th = (rb_thread_t)DATA_PTR(obj);
+
+        if (th == rb_curr_thread) {
+          yajl_gen_cstr(gen, "current");
+          yajl_gen_bool(gen, 1);
+        } else {
+          if (th->dyna_vars) {
+            yajl_gen_cstr(gen, "varmap");
+            yajl_gen_pointer(gen, th->dyna_vars);
+          }
+
+          yajl_gen_cstr(gen, "node");
+          yajl_gen_pointer(gen, th->node);
+
+          yajl_gen_cstr(gen, "cref");
+          yajl_gen_pointer(gen, th->cref);
+
+          char *status;
+          switch (th->status) {
+            case THREAD_TO_KILL:
+              status = "to_kill";
+              break;
+            case THREAD_RUNNABLE:
+              status = "runnable";
+              break;
+            case THREAD_STOPPED:
+              status = "stopped";
+              break;
+            case THREAD_KILLED:
+              status = "killed";
+              break;
+            default:
+              status = "unknown";
+          }
+
+          yajl_gen_cstr(gen, "status");
+          yajl_gen_cstr(gen, status);
+
+          #define WAIT_FD		(1<<0)
+          #define WAIT_SELECT	(1<<1)
+          #define WAIT_TIME	(1<<2)
+          #define WAIT_JOIN	(1<<3)
+          #define WAIT_PID	(1<<4)
+
+          yajl_gen_cstr(gen, "wait_for");
+          yajl_gen_array_open(gen);
+          if (th->wait_for & WAIT_FD)
+            yajl_gen_cstr(gen, "fd");
+          if (th->wait_for & WAIT_SELECT)
+            yajl_gen_cstr(gen, "select");
+          if (th->wait_for & WAIT_TIME)
+            yajl_gen_cstr(gen, "time");
+          if (th->wait_for & WAIT_JOIN)
+            yajl_gen_cstr(gen, "join");
+          if (th->wait_for & WAIT_PID)
+            yajl_gen_cstr(gen, "pid");
+          yajl_gen_array_close(gen);
+
+          if (th->wait_for & WAIT_FD) {
+            yajl_gen_cstr(gen, "fd");
+            yajl_gen_integer(gen, th->fd);
+          }
+
+          #define DELAY_INFTY 1E30
+
+          if (th->wait_for & WAIT_TIME) {
+            yajl_gen_cstr(gen, "delay");
+            if (th->delay == DELAY_INFTY)
+              yajl_gen_cstr(gen, "infinity");
+            else
+              yajl_gen_double(gen, th->delay - rb_timeofday());
+          }
+
+          if (th->wait_for & WAIT_JOIN) {
+            yajl_gen_cstr(gen, "join");
+            yajl_gen_value(gen, th->join->thread);
+          }
+        }
+
+        yajl_gen_cstr(gen, "priority");
+        yajl_gen_integer(gen, th->priority);
+
+        if (th == rb_main_thread) {
+          yajl_gen_cstr(gen, "main");
+          yajl_gen_bool(gen, 1);
+        }
+
+        if (th->next && th->next != rb_main_thread) {
+          yajl_gen_cstr(gen, "next");
+          yajl_gen_value(gen, th->next->thread);
+        }
+        if (th->prev && th->prev != th && (th->prev == rb_main_thread || th->prev != th->next)) {
+          yajl_gen_cstr(gen, "prev");
+          yajl_gen_value(gen, th->prev->thread);
+        }
+
+        if (th->locals) {
+          yajl_gen_cstr(gen, "variables");
+          yajl_gen_map_open(gen);
+          st_foreach(th->locals, each_ivar, (st_data_t)gen);
+          yajl_gen_map_close(gen);
+        }
 
-        yajl_gen_cstr(gen, "class_name");
-        VALUE name = rb_classname(RBASIC(obj)->klass);
-        if (RTEST(name))
-          yajl_gen_cstr(gen, RSTRING(name)->ptr);
-        else
-          yajl_gen_cstr(gen, 0);
       }
       break;
 
     case T_STRUCT:
       yajl_gen_cstr(gen, "struct");
-
-      yajl_gen_cstr(gen, "class");
-      yajl_gen_value(gen, RBASIC(obj)->klass);
-
-      yajl_gen_cstr(gen, "class_name");
-      yajl_gen_cstr(gen, rb_obj_classname(obj));
+      obj_dump_class(gen, obj);
       break;
 
     case T_FILE:
       yajl_gen_cstr(gen, "file");
+      obj_dump_class(gen, obj);
+
+      OpenFile *file = RFILE(obj)->fptr;
+
+      if (file->f) {
+        yajl_gen_cstr(gen, "fileno");
+        yajl_gen_integer(gen, fileno(file->f));
+      }
+
+      if (file->f2) {
+        yajl_gen_cstr(gen, "fileno2");
+        yajl_gen_integer(gen, fileno(file->f2));
+      }
+
+      if (file->pid) {
+        yajl_gen_cstr(gen, "pid");
+        yajl_gen_integer(gen, file->pid);
+      }
+
+      if (file->path) {
+        yajl_gen_cstr(gen, "path");
+        yajl_gen_cstr(gen, file->path);
+      }
+
+      if (file->mode) {
+        yajl_gen_cstr(gen, "mode");
+        yajl_gen_array_open(gen);
+        if (file->mode & FMODE_READABLE)
+          yajl_gen_cstr(gen, "readable");
+        if (file->mode & FMODE_WRITABLE)
+          yajl_gen_cstr(gen, "writable");
+        if (file->mode & FMODE_READWRITE)
+          yajl_gen_cstr(gen, "readwrite");
+        if (file->mode & FMODE_APPEND)
+          yajl_gen_cstr(gen, "append");
+        if (file->mode & FMODE_CREATE)
+          yajl_gen_cstr(gen, "create");
+        if (file->mode & FMODE_BINMODE)
+          yajl_gen_cstr(gen, "binmode");
+        if (file->mode & FMODE_SYNC)
+          yajl_gen_cstr(gen, "sync");
+        if (file->mode & FMODE_WBUF)
+          yajl_gen_cstr(gen, "wbuf");
+        if (file->mode & FMODE_RBUF)
+          yajl_gen_cstr(gen, "rbuf");
+        if (file->mode & FMODE_WSPLIT)
+          yajl_gen_cstr(gen, "wsplit");
+        if (file->mode & FMODE_WSPLIT_INITIALIZED)
+          yajl_gen_cstr(gen, "wsplit_initialized");
+        yajl_gen_array_close(gen);
+      }
+
       break;
 
     case T_FLOAT:
       yajl_gen_cstr(gen, "float");
+      obj_dump_class(gen, obj);
 
       yajl_gen_cstr(gen, "data");
       yajl_gen_double(gen, RFLOAT(obj)->value);
@@ -485,6 +1017,7 @@ obj_dump(VALUE obj, yajl_gen gen)
 
     case T_BIGNUM:
       yajl_gen_cstr(gen, "bignum");
+      obj_dump_class(gen, obj);
 
       yajl_gen_cstr(gen, "negative");
       yajl_gen_bool(gen, RBIGNUM(obj)->sign == 0);
@@ -498,6 +1031,7 @@ obj_dump(VALUE obj, yajl_gen gen)
 
     case T_MATCH:
       yajl_gen_cstr(gen, "match");
+      obj_dump_class(gen, obj);
 
       yajl_gen_cstr(gen, "data");
       yajl_gen_value(gen, RMATCH(obj)->str);
@@ -505,6 +1039,7 @@ obj_dump(VALUE obj, yajl_gen gen)
 
     case T_REGEXP:
       yajl_gen_cstr(gen, "regexp");
+      obj_dump_class(gen, obj);
 
       yajl_gen_cstr(gen, "length");
       yajl_gen_integer(gen, RREGEXP(obj)->len);
@@ -523,8 +1058,10 @@ obj_dump(VALUE obj, yajl_gen gen)
         VALUE *list = &scope->local_vars[-1];
         VALUE cur = *list++;
 
-        yajl_gen_cstr(gen, "node");
-        yajl_gen_value(gen, cur);
+        if (RTEST(cur)) {
+          yajl_gen_cstr(gen, "node");
+          yajl_gen_value(gen, cur);
+        }
 
         if (n) {
           yajl_gen_cstr(gen, "variables");
@@ -536,7 +1073,7 @@ obj_dump(VALUE obj, yajl_gen gen)
             if (!rb_is_local_id(scope->local_tbl[i]))
               continue;
 
-            yajl_gen_cstr(gen, scope->local_tbl[i] == 95 ? "_" : rb_id2name(scope->local_tbl[i]));
+            yajl_gen_id(gen, scope->local_tbl[i]);
             yajl_gen_value(gen, cur);
           }
           yajl_gen_map_close(gen);
@@ -559,8 +1096,8 @@ obj_dump(VALUE obj, yajl_gen gen)
       yajl_gen_cstr(gen, "node_code");
       yajl_gen_integer(gen, nd_type(obj));
 
-      #define PRINT_ID(sub) yajl_gen_format(gen, ":%s", rb_id2name(RNODE(obj)->sub.id));
-      #define PRINT_VAL(sub) yajl_gen_value(gen, RNODE(obj)->sub.value);
+      #define PRINT_ID(sub) yajl_gen_id(gen, RNODE(obj)->sub.id)
+      #define PRINT_VAL(sub) yajl_gen_value(gen, RNODE(obj)->sub.value)
 
       int nd_type = nd_type(obj);
       yajl_gen_cstr(gen, "n1");
@@ -580,9 +1117,18 @@ obj_dump(VALUE obj, yajl_gen gen)
         case NODE_GASGN:
         case NODE_DASGN_CURR:
         case NODE_BLOCK_ARG:
+        case NODE_CDECL:
+        case NODE_VALIAS:
           PRINT_ID(u1);
           break;
 
+        case NODE_OP_ASGN2:
+          if (RNODE(obj)->u3.id > 1000000)
+            PRINT_VAL(u1);
+          else
+            PRINT_ID(u1);
+          break;
+
         case NODE_SCOPE: {
           ID *tbl = RNODE(obj)->nd_tbl;
           yajl_gen_array_open(gen);
@@ -591,13 +1137,14 @@ obj_dump(VALUE obj, yajl_gen gen)
             int i = 3;
 
             for (; i < size+1; i++) {
-              yajl_gen_cstr(gen, tbl[i] == 95 ? "_" : rb_id2name(tbl[i]));
+              yajl_gen_id(gen, tbl[i]);
             }
           }
           yajl_gen_array_close(gen);
           break;
         }
 
+        case NODE_IFUNC:
         case NODE_CFUNC: {
           const char *name = bin_find_symbol_name((void*)RNODE(obj)->u1.value);
           yajl_gen_format(gen, "0x%x: %s", RNODE(obj)->u1.value, name ? name : "???");
@@ -618,13 +1165,51 @@ obj_dump(VALUE obj, yajl_gen gen)
         case NODE_VCALL:
         case NODE_COLON2:
         case NODE_COLON3:
+        case NODE_BACK_REF:
+        case NODE_DEFS:
+        case NODE_VALIAS:
           PRINT_ID(u2);
           break;
 
+        case NODE_OP_ASGN1:
+          if (RNODE(obj)->nd_mid == 0)
+            yajl_gen_cstr(gen, ":||");
+          else if (RNODE(obj)->nd_mid == 1)
+            yajl_gen_cstr(gen, ":&&");
+          else
+            PRINT_ID(u2);
+          break;
+
+        case NODE_OP_ASGN2:
+          if (RNODE(obj)->u3.id > 1000000) {
+            PRINT_VAL(u2);
+          } else {
+            if (RNODE(obj)->nd_mid == 0)
+              yajl_gen_cstr(gen, ":||");
+            else if (RNODE(obj)->nd_mid == 1)
+              yajl_gen_cstr(gen, ":&&");
+            else
+              PRINT_ID(u2);
+          }
+          break;
+
+        case NODE_DREGX:
+        case NODE_DREGX_ONCE:
         case NODE_NTH_REF:
+        case NODE_IFUNC:
+        case NODE_CFUNC:
+        case NODE_NEWLINE:
           yajl_gen_integer(gen, RNODE(obj)->u2.argc);
           break;
 
+        case NODE_BLOCK:
+        case NODE_ARRAY:
+          if (RNODE(obj)->u2.node == RNODE(obj))
+            yajl_gen_null(gen);
+          else
+            PRINT_VAL(u2);
+          break;
+
         default:
           PRINT_VAL(u2);
       }
@@ -635,6 +1220,13 @@ obj_dump(VALUE obj, yajl_gen gen)
           yajl_gen_integer(gen, RNODE(obj)->u3.cnt);
           break;
 
+        case NODE_OP_ASGN2:
+          if (RNODE(obj)->u3.id > 1000000)
+            PRINT_VAL(u3);
+          else
+            PRINT_ID(u3);
+          break;
+
         default:
           PRINT_VAL(u3);
       }
@@ -642,9 +1234,10 @@ obj_dump(VALUE obj, yajl_gen gen)
 
     case T_STRING:
       yajl_gen_cstr(gen, "string");
+      obj_dump_class(gen, obj);
 
       yajl_gen_cstr(gen, "length");
-      yajl_gen_integer(gen, RSTRING(obj)->len);
+      yajl_gen_integer(gen, RSTRING_LEN(obj));
 
       if (FL_TEST(obj, ELTS_SHARED|FL_USER3)) {
         yajl_gen_cstr(gen, "shared");
@@ -659,12 +1252,13 @@ obj_dump(VALUE obj, yajl_gen gen)
         yajl_gen_array_close(gen);
       } else {
         yajl_gen_cstr(gen, "data");
-        yajl_gen_string(gen, (unsigned char *)RSTRING(obj)->ptr, RSTRING(obj)->len);
+        yajl_gen_string(gen, (unsigned char *)RSTRING_PTR(obj), RSTRING_LEN(obj));
       }
       break;
 
     case T_VARMAP:
       yajl_gen_cstr(gen, "varmap");
+      obj_dump_class(gen, obj);
 
       struct RVarmap *vars = (struct RVarmap *)obj;
 
@@ -676,7 +1270,7 @@ obj_dump(VALUE obj, yajl_gen gen)
       if (vars->id) {
         yajl_gen_cstr(gen, "data");
         yajl_gen_map_open(gen);
-        yajl_gen_cstr(gen, rb_id2name(vars->id));
+        yajl_gen_id(gen, vars->id);
         yajl_gen_value(gen, vars->val);
         yajl_gen_map_close(gen);
       }
@@ -686,23 +1280,26 @@ obj_dump(VALUE obj, yajl_gen gen)
     case T_MODULE:
     case T_ICLASS:
       yajl_gen_cstr(gen, type==T_CLASS ? "class" : type==T_MODULE ? "module" : "iclass");
+      obj_dump_class(gen, obj);
 
       yajl_gen_cstr(gen, "name");
       VALUE name = rb_classname(obj);
       if (RTEST(name))
-        yajl_gen_cstr(gen, RSTRING(name)->ptr);
+        yajl_gen_cstr(gen, RSTRING_PTR(name));
       else
         yajl_gen_cstr(gen, 0);
 
       yajl_gen_cstr(gen, "super");
       yajl_gen_value(gen, RCLASS(obj)->super);
 
-      yajl_gen_cstr(gen, "super_name");
-      VALUE super_name = rb_classname(RCLASS(obj)->super);
-      if (RTEST(super_name))
-        yajl_gen_cstr(gen, RSTRING(super_name)->ptr);
-      else
-        yajl_gen_cstr(gen, 0);
+      if (RTEST(RCLASS(obj)->super)) {
+        yajl_gen_cstr(gen, "super_name");
+        VALUE super_name = rb_classname(RCLASS(obj)->super);
+        if (RTEST(super_name))
+          yajl_gen_cstr(gen, RSTRING_PTR(super_name));
+        else
+          yajl_gen_cstr(gen, 0);
+      }
 
       if (FL_TEST(obj, FL_SINGLETON)) {
         yajl_gen_cstr(gen, "singleton");
@@ -716,7 +1313,7 @@ obj_dump(VALUE obj, yajl_gen gen)
         yajl_gen_map_close(gen);
       }
 
-      if (type != T_ICLASS && RCLASS(obj)->m_tbl && RCLASS(obj)->m_tbl->num_entries) {
+      if (RCLASS(obj)->m_tbl && RCLASS(obj)->m_tbl->num_entries) {
         yajl_gen_cstr(gen, "methods");
         yajl_gen_map_open(gen);
         st_foreach(RCLASS(obj)->m_tbl, each_ivar, (st_data_t)gen);
@@ -726,12 +1323,7 @@ obj_dump(VALUE obj, yajl_gen gen)
 
     case T_OBJECT:
       yajl_gen_cstr(gen, "object");
-
-      yajl_gen_cstr(gen, "class");
-      yajl_gen_value(gen, RBASIC(obj)->klass);
-
-      yajl_gen_cstr(gen, "class_name");
-      yajl_gen_cstr(gen, rb_obj_classname(obj));
+      obj_dump_class(gen, obj);
 
       struct RClass *klass = RCLASS(obj);
 
@@ -745,6 +1337,7 @@ obj_dump(VALUE obj, yajl_gen gen)
 
     case T_ARRAY:
       yajl_gen_cstr(gen, "array");
+      obj_dump_class(gen, obj);
 
       struct RArray *ary = RARRAY(obj);
 
@@ -766,6 +1359,7 @@ obj_dump(VALUE obj, yajl_gen gen)
 
     case T_HASH:
       yajl_gen_cstr(gen, "hash");
+      obj_dump_class(gen, obj);
 
       struct RHash *hash = RHASH(obj);
 
@@ -790,6 +1384,7 @@ obj_dump(VALUE obj, yajl_gen gen)
 
     default:
       yajl_gen_cstr(gen, "unknown");
+      obj_dump_class(gen, obj);
   }
 
   yajl_gen_cstr(gen, "code");
@@ -810,11 +1405,163 @@ extern st_table *rb_global_tbl;
 static int
 globals_each_dump(st_data_t key, st_data_t record, st_data_t arg)
 {
-  yajl_gen_cstr((yajl_gen)arg, rb_id2name((ID)key));
+  yajl_gen_id((yajl_gen)arg, (ID)key);
   yajl_gen_value((yajl_gen)arg, rb_gvar_get((void*)record));
   return ST_CONTINUE;
 }
 
+static void
+memprof_dump_globals(yajl_gen gen)
+{
+  yajl_gen_map_open(gen);
+
+  yajl_gen_cstr(gen, "_id");
+  yajl_gen_cstr(gen, "globals");
+
+  yajl_gen_cstr(gen, "type");
+  yajl_gen_cstr(gen, "globals");
+
+  yajl_gen_cstr(gen, "variables");
+
+  yajl_gen_map_open(gen);
+  st_foreach(rb_global_tbl, globals_each_dump, (st_data_t)gen);
+  yajl_gen_map_close(gen);
+
+  yajl_gen_map_close(gen);
+  yajl_gen_reset(gen);
+}
+
+static void
+memprof_dump_stack_frame(yajl_gen gen, struct FRAME *frame)
+{
+  yajl_gen_map_open(gen);
+
+  yajl_gen_cstr(gen, "_id");
+  yajl_gen_pointer(gen, frame);
+
+  yajl_gen_cstr(gen, "type");
+  yajl_gen_cstr(gen, "frame");
+
+  yajl_gen_cstr(gen, "self");
+  yajl_gen_value(gen, frame->self);
+
+  if (frame->last_class) {
+    yajl_gen_cstr(gen, "last_class");
+    yajl_gen_value(gen, frame->last_class);
+  }
+
+  if (frame->orig_func) {
+    yajl_gen_cstr(gen, "orig_func");
+    yajl_gen_id(gen, frame->orig_func);
+  }
+
+  if (frame->last_func && frame->last_func != frame->orig_func) {
+    yajl_gen_cstr(gen, "last_func");
+    yajl_gen_id(gen, frame->last_func);
+  }
+
+  if (frame->node) {
+    yajl_gen_cstr(gen, "node");
+    yajl_gen_pointer(gen, (void*)frame->node);
+  }
+
+  if (frame->prev) {
+    yajl_gen_cstr(gen, "prev");
+    yajl_gen_pointer(gen, (void*)frame->prev);
+  }
+
+  if (frame->tmp) {
+    yajl_gen_cstr(gen, "tmp");
+    yajl_gen_pointer(gen, (void*)frame->tmp);
+  }
+
+  yajl_gen_map_close(gen);
+  yajl_gen_reset(gen);
+
+  if (frame->prev) {
+    memprof_dump_stack_frame(gen, frame->prev);
+  }
+}
+
+static void
+memprof_dump_stack(yajl_gen gen)
+{
+  memprof_dump_stack_frame(gen, ruby_frame);
+}
+
+static void
+memprof_dump_lsof(yajl_gen gen)
+{
+  VALUE cmd = rb_str_new2("lsof -np ");
+  VALUE pid = rb_funcall(rb_mProcess, rb_intern("pid"), 0);
+  rb_str_append(cmd, rb_funcall(pid, rb_intern("to_s"), 0));
+
+  VALUE lsof = rb_funcall(rb_cObject, '`', 1, cmd);
+  if (RTEST(lsof)) {
+    VALUE newline = rb_str_new2("\n");
+    VALUE lines = rb_funcall(lsof, rb_intern("split"), 1, newline);
+    int i;
+    for (i=1; i < RARRAY_LEN(lines); i++) {
+      VALUE parts = rb_funcall(RARRAY_PTR(lines)[i], rb_intern("split"), 2, Qnil, INT2FIX(9));
+
+      yajl_gen_map_open(gen);
+
+      yajl_gen_cstr(gen, "_id");
+      yajl_gen_format(gen, "lsof:%d", i);
+
+      yajl_gen_cstr(gen, "type");
+      yajl_gen_cstr(gen, "lsof");
+
+      yajl_gen_cstr(gen, "fd");
+      yajl_gen_cstr(gen, RSTRING_PTR(RARRAY_PTR(parts)[3]));
+
+      yajl_gen_cstr(gen, "fd_type");
+      yajl_gen_cstr(gen, RSTRING_PTR(RARRAY_PTR(parts)[4]));
+
+      yajl_gen_cstr(gen, "fd_name");
+      yajl_gen_cstr(gen, RSTRING_PTR(RARRAY_PTR(parts)[RARRAY_LEN(parts)-1]));
+
+      yajl_gen_map_close(gen);
+      yajl_gen_reset(gen);
+    }
+  }
+}
+
+static void
+memprof_dump_ps(yajl_gen gen)
+{
+  VALUE cmd = rb_str_new2("ps -o rss,vsize -p ");
+  VALUE pid = rb_funcall(rb_mProcess, rb_intern("pid"), 0);
+  rb_str_append(cmd, rb_funcall(pid, rb_intern("to_s"), 0));
+
+  VALUE ps = rb_funcall(rb_cObject, '`', 1, cmd);
+  if (RTEST(ps)) {
+    VALUE newline = rb_str_new2("\n");
+    VALUE lines = rb_funcall(ps, rb_intern("split"), 1, newline);
+
+    if (RARRAY_LEN(lines) == 2) {
+      VALUE parts = rb_funcall(RARRAY_PTR(lines)[1], rb_intern("split"), 0);
+
+      yajl_gen_map_open(gen);
+
+      yajl_gen_cstr(gen, "_id");
+      yajl_gen_cstr(gen, "ps");
+
+      yajl_gen_cstr(gen, "type");
+      yajl_gen_cstr(gen, "ps");
+
+      yajl_gen_cstr(gen, "rss");
+      yajl_gen_cstr(gen, RSTRING_PTR(RARRAY_PTR(parts)[0]));
+
+      yajl_gen_cstr(gen, "vsize");
+      yajl_gen_cstr(gen, RSTRING_PTR(RARRAY_PTR(parts)[1]));
+
+      yajl_gen_map_close(gen);
+      yajl_gen_reset(gen);
+    }
+  }
+}
+
 static void
 json_print(void *ctx, const char * str, unsigned int len)
 {
@@ -868,8 +1615,8 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
       memprof_config.heaps_used == NULL ||
       memprof_config.sizeof_RVALUE == 0 ||
       memprof_config.sizeof_heaps_slot == 0 ||
-      memprof_config.offset_heaps_slot_slot == -1 ||
-      memprof_config.offset_heaps_slot_limit == -1)
+      memprof_config.offset_heaps_slot_slot == SIZE_MAX ||
+      memprof_config.offset_heaps_slot_limit == SIZE_MAX)
     rb_raise(eUnsupported, "not enough config data to dump heap");
 
   char *heaps = *(char**)memprof_config.heaps;
@@ -878,12 +1625,20 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
   char *p, *pend;
   int i, limit;
   VALUE str;
+  char *filename = NULL;
+  char *in_progress_filename = NULL;
   FILE *out = NULL;
 
   rb_scan_args(argc, argv, "01", &str);
 
   if (RTEST(str)) {
-    out = fopen(StringValueCStr(str), "w");
+    filename = StringValueCStr(str);
+    size_t filename_len = strlen(filename);
+    in_progress_filename = alloca(filename_len + 13);
+    memcpy(in_progress_filename, filename, filename_len);
+    memcpy(in_progress_filename + filename_len, ".IN_PROGRESS\0", 13);
+
+    out = fopen(in_progress_filename, "w");
     if (!out)
       rb_raise(rb_eArgError, "unable to open output file");
   }
@@ -893,23 +1648,8 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
 
   track_objs = 0;
 
-  //yajl_gen_array_open(gen);
-
-  yajl_gen_map_open(gen);
-
-  yajl_gen_cstr(gen, "_id");
-  yajl_gen_cstr(gen, "globals");
-
-  yajl_gen_cstr(gen, "type");
-  yajl_gen_cstr(gen, "globals");
-
-  yajl_gen_cstr(gen, "variables");
-
-  yajl_gen_map_open(gen);
-  st_foreach(rb_global_tbl, globals_each_dump, (st_data_t)gen);
-  yajl_gen_map_close(gen);
-
-  yajl_gen_map_close(gen);
+  memprof_dump_globals(gen);
+  memprof_dump_stack(gen);
 
   for (i=0; i < heaps_used; i++) {
     p = *(char**)(heaps + (i * memprof_config.sizeof_heaps_slot) + memprof_config.offset_heaps_slot_slot);
@@ -919,23 +1659,23 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
     while (p < pend) {
       if (RBASIC(p)->flags) {
         obj_dump((VALUE)p, gen);
-        // XXX ugh
-        yajl_gen_clear(gen);
-        yajl_gen_free(gen);
-        gen = yajl_gen_alloc2((yajl_print_t)&json_print, &conf, NULL, (void*)out);
-        while(fputc('\n', out ? out : stdout) == EOF);
+        yajl_gen_reset(gen);
       }
 
       p += memprof_config.sizeof_RVALUE;
     }
   }
 
-  //yajl_gen_array_close(gen);
+  memprof_dump_lsof(gen);
+  memprof_dump_ps(gen);
+
   yajl_gen_clear(gen);
   yajl_gen_free(gen);
 
-  if (out)
+  if (out) {
     fclose(out);
+    rename(in_progress_filename, filename);
+  }
 
   track_objs = 1;
 
@@ -945,8 +1685,8 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
 static void
 init_memprof_config_base() {
   memset(&memprof_config, 0, sizeof(memprof_config));
-  memprof_config.offset_heaps_slot_limit = -1;
-  memprof_config.offset_heaps_slot_slot = -1;
+  memprof_config.offset_heaps_slot_limit = SIZE_MAX;
+  memprof_config.offset_heaps_slot_slot = SIZE_MAX;
   memprof_config.pagesize = getpagesize();
   assert(memprof_config.pagesize);
 }
@@ -954,7 +1694,7 @@ init_memprof_config_base() {
 static void
 init_memprof_config_extended() {
   /* If we don't have add_freelist, find the functions it gets inlined into */
-  memprof_config.add_freelist               = bin_find_symbol("add_freelist", NULL);
+  memprof_config.add_freelist               = bin_find_symbol("add_freelist", NULL, 0);
 
   /*
    * Sometimes gc_sweep gets inlined in garbage_collect
@@ -962,27 +1702,31 @@ init_memprof_config_extended() {
    */
   if (memprof_config.add_freelist == NULL) {
     memprof_config.gc_sweep                 = bin_find_symbol("gc_sweep",
-                                                &memprof_config.gc_sweep_size);
+                                                &memprof_config.gc_sweep_size, 0);
     if (memprof_config.gc_sweep == NULL)
       memprof_config.gc_sweep               = bin_find_symbol("garbage_collect_0",
-                                                &memprof_config.gc_sweep_size);
+                                                &memprof_config.gc_sweep_size, 0);
     if (memprof_config.gc_sweep == NULL)
       memprof_config.gc_sweep               = bin_find_symbol("garbage_collect",
-                                                &memprof_config.gc_sweep_size);
+                                                &memprof_config.gc_sweep_size, 0);
 
     memprof_config.finalize_list            = bin_find_symbol("finalize_list",
-                                                &memprof_config.finalize_list_size);
+                                                &memprof_config.finalize_list_size, 0);
     memprof_config.rb_gc_force_recycle      = bin_find_symbol("rb_gc_force_recycle",
-                                                &memprof_config.rb_gc_force_recycle_size);
-    memprof_config.freelist                 = bin_find_symbol("freelist", NULL);
+                                                &memprof_config.rb_gc_force_recycle_size, 0);
+    memprof_config.freelist                 = bin_find_symbol("freelist", NULL, 0);
   }
 
-  memprof_config.classname                  = bin_find_symbol("classname", NULL);
-  memprof_config.rb_mark_table_add_filename = bin_find_symbol("rb_mark_table_add_filename", NULL);
+  memprof_config.classname                  = bin_find_symbol("classname", NULL, 0);
+  memprof_config.timeofday                  = bin_find_symbol("timeofday", NULL, 0);
+  memprof_config.bm_mark                    = bin_find_symbol("bm_mark", NULL, 0);
+  memprof_config.blk_free                   = bin_find_symbol("blk_free", NULL, 0);
+  memprof_config.thread_mark                = bin_find_symbol("thread_mark", NULL, 0);
+  memprof_config.rb_mark_table_add_filename = bin_find_symbol("rb_mark_table_add_filename", NULL, 0);
 
   /* Stuff for dumping the heap */
-  memprof_config.heaps                      = bin_find_symbol("heaps", NULL);
-  memprof_config.heaps_used                 = bin_find_symbol("heaps_used", NULL);
+  memprof_config.heaps                      = bin_find_symbol("heaps", NULL, 0);
+  memprof_config.heaps_used                 = bin_find_symbol("heaps_used", NULL, 0);
 #ifdef sizeof__RVALUE
   memprof_config.sizeof_RVALUE              = sizeof__RVALUE;
 #else
@@ -1003,6 +1747,91 @@ init_memprof_config_extended() {
 #else
   memprof_config.offset_heaps_slot_slot     = bin_type_member_offset("heaps_slot", "slot");
 #endif
+#ifdef offset__BLOCK__body
+  memprof_config.offset_BLOCK_body          = offset__BLOCK__body;
+#else
+  memprof_config.offset_BLOCK_body          = bin_type_member_offset("BLOCK", "body");
+#endif
+#ifdef offset__BLOCK__var
+  memprof_config.offset_BLOCK_var           = offset__BLOCK__var;
+#else
+  memprof_config.offset_BLOCK_var           = bin_type_member_offset("BLOCK", "var");
+#endif
+#ifdef offset__BLOCK__cref
+  memprof_config.offset_BLOCK_cref          = offset__BLOCK__cref;
+#else
+  memprof_config.offset_BLOCK_cref          = bin_type_member_offset("BLOCK", "cref");
+#endif
+#ifdef offset__BLOCK__prev
+  memprof_config.offset_BLOCK_prev          = offset__BLOCK__prev;
+#else
+  memprof_config.offset_BLOCK_prev          = bin_type_member_offset("BLOCK", "prev");
+#endif
+#ifdef offset__BLOCK__self
+  memprof_config.offset_BLOCK_self          = offset__BLOCK__self;
+#else
+  memprof_config.offset_BLOCK_self          = bin_type_member_offset("BLOCK", "self");
+#endif
+#ifdef offset__BLOCK__klass
+  memprof_config.offset_BLOCK_klass         = offset__BLOCK__klass;
+#else
+  memprof_config.offset_BLOCK_klass         = bin_type_member_offset("BLOCK", "klass");
+#endif
+#ifdef offset__BLOCK__orig_thread
+  memprof_config.offset_BLOCK_orig_thread   = offset__BLOCK__orig_thread;
+#else
+  memprof_config.offset_BLOCK_orig_thread   = bin_type_member_offset("BLOCK", "orig_thread");
+#endif
+#ifdef offset__BLOCK__wrapper
+  memprof_config.offset_BLOCK_wrapper       = offset__BLOCK__wrapper;
+#else
+  memprof_config.offset_BLOCK_wrapper       = bin_type_member_offset("BLOCK", "wrapper");
+#endif
+#ifdef offset__BLOCK__block_obj
+  memprof_config.offset_BLOCK_block_obj     = offset__BLOCK__block_obj;
+#else
+  memprof_config.offset_BLOCK_block_obj     = bin_type_member_offset("BLOCK", "block_obj");
+#endif
+#ifdef offset__BLOCK__scope
+  memprof_config.offset_BLOCK_scope         = offset__BLOCK__scope;
+#else
+  memprof_config.offset_BLOCK_scope         = bin_type_member_offset("BLOCK", "scope");
+#endif
+#ifdef offset__BLOCK__dyna_vars
+  memprof_config.offset_BLOCK_dyna_vars     = offset__BLOCK__dyna_vars;
+#else
+  memprof_config.offset_BLOCK_dyna_vars     = bin_type_member_offset("BLOCK", "dyna_vars");
+#endif
+#ifdef offset__METHOD__klass
+  memprof_config.offset_METHOD_klass        = offset__METHOD__klass;
+#else
+  memprof_config.offset_METHOD_klass        = bin_type_member_offset("METHOD", "klass");
+#endif
+#ifdef offset__METHOD__rklass
+  memprof_config.offset_METHOD_rklass       = offset__METHOD__rklass;
+#else
+  memprof_config.offset_METHOD_rklass       = bin_type_member_offset("METHOD", "rklass");
+#endif
+#ifdef offset__METHOD__recv
+  memprof_config.offset_METHOD_recv         = offset__METHOD__recv;
+#else
+  memprof_config.offset_METHOD_recv         = bin_type_member_offset("METHOD", "recv");
+#endif
+#ifdef offset__METHOD__id
+  memprof_config.offset_METHOD_id           = offset__METHOD__id;
+#else
+  memprof_config.offset_METHOD_id           = bin_type_member_offset("METHOD", "id");
+#endif
+#ifdef offset__METHOD__oid
+  memprof_config.offset_METHOD_oid          = offset__METHOD__oid;
+#else
+  memprof_config.offset_METHOD_oid          = bin_type_member_offset("METHOD", "oid");
+#endif
+#ifdef offset__METHOD__body
+  memprof_config.offset_METHOD_body         = offset__METHOD__body;
+#else
+  memprof_config.offset_METHOD_body         = bin_type_member_offset("METHOD", "body");
+#endif
 
   int heap_errors_printed = 0;
 
@@ -1018,10 +1847,10 @@ init_memprof_config_extended() {
   if (memprof_config.sizeof_heaps_slot == 0)
     heap_errors_printed += fprintf(stderr,
       "Failed to determine sizeof(heaps_slot)\n");
-  if (memprof_config.offset_heaps_slot_limit == -1)
+  if (memprof_config.offset_heaps_slot_limit == SIZE_MAX)
     heap_errors_printed += fprintf(stderr,
       "Failed to determine offset of heaps_slot->limit\n");
-  if (memprof_config.offset_heaps_slot_slot == -1)
+  if (memprof_config.offset_heaps_slot_slot == SIZE_MAX)
     heap_errors_printed += fprintf(stderr,
       "Failed to determine offset of heaps_slot->slot\n");
 
@@ -1086,6 +1915,7 @@ Init_memprof()
   rb_define_singleton_method(memprof, "track", memprof_track, -1);
   rb_define_singleton_method(memprof, "dump", memprof_dump, -1);
   rb_define_singleton_method(memprof, "dump_all", memprof_dump_all, -1);
+  rb_define_singleton_method(memprof, "track_bytes", memprof_track_bytes, -1);
 
   objs = st_init_numtable();
   init_memprof_config_base();
@@ -1098,15 +1928,13 @@ Init_memprof()
 
   rb_classname = memprof_config.classname;
   rb_add_freelist = memprof_config.add_freelist;
+  rb_timeofday = memprof_config.timeofday;
+  rb_bm_mark = memprof_config.bm_mark;
+  rb_blk_free = memprof_config.blk_free;
+  rb_thread_mark = memprof_config.thread_mark;
   ptr_to_rb_mark_table_add_filename = memprof_config.rb_mark_table_add_filename;
 
   assert(rb_classname);
 
-  insert_tramp("rb_newobj", newobj_tramp);
-  insert_tramp("add_freelist", freelist_tramp);
-
-  if (getenv("MEMPROF"))
-    track_objs = 1;
-
   return;
 }