heap_dump 0.0.32 → 0.0.33

data/README.md

@@ -4,7 +4,7 @@ Low-level ruby heap memory dump - including data and code references, useful for
 Has no performance overhead while not active, so can be used in production environment.
 
 Originally written across ruby 1.9.2-p290 data structures.
-Does work on other 1.9.2s, 1.9.3 and 2.0.0-preview1, but not well-tested yet(output is not proven to be as full etc.).
+Does work on other 1.9.2s, 1.9.3, 2.0.0-preview1 and 2.0.0-preview2, but not well-tested yet(output is not proven to be as full etc.).
 
 Currently is under development and output format may differ.
 
@@ -69,7 +69,7 @@ Also heap_dump now includes an object counter, like `ObjectSpace.count_objects`,
 
 ```ruby
 
-HeapDump.count_objects :YourNameSpace # => json string
+HeapDump.count_objects [YourNameSpace, "SomeClass"] # => json string
 ```
 
 which results in something like:
@@ -100,7 +100,8 @@ which results in something like:
     },
     "user_types": {
         "YourNameSpace::B": 2,
-        "YourNameSpace::A": 3
+        "YourNameSpace::A": 3,
+        "SomeClass": 1
     }
 }
 ```
@@ -131,6 +132,9 @@ or `call heapdump_dump(0)`, filename defaults to dump.json.
 Note that yajl-ruby gem (and heap_dump itself) should be available to process this being injected into.
 Also on rare ocassions process(for example if gdb attached while a signal/gc) may crash after and even during dumping, so safer way is to embed it in advance, there's no performance overhead.
 
+Object count from gdb: `call (void)heapdump_count_objects_print("Object", "")` (null or empty string terminated list of namespace/class names)
+or `call (char*)heapdump_count_objects_return("Object", "")`, note that you then should free memory - `call (void)free($$)`
+
 ### Importing dump in MongoDB
 
 Dump can be imported in mongo for some map-reduce, easy script access etc.
@@ -178,6 +182,21 @@ Then make a full dump and inspect references to those objects.
 
 Note that heapdump operates only on process it has been called on, so if you have multiple workers (Unicorn/Rainbows/Passenger spawned processes etc.) - you may run into a situation when request for dump is not routed to process you're interested in.
 
+Also it may be a good idea to run dump in forked process or/and on signal:
+
+```ruby
+
+  Signal.trap('USR2') do
+    old_pid = Process.pid
+    fork {
+      puts "Dumping worker #{old_pid}"
+      require 'heap_dump'
+      HeapDump.dump "dump_#{old_pid}.json"
+      exit
+    }
+  end
+```
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -42,6 +42,9 @@ task :test => :compile do
   HeapDump.verbose = true
   HeapDump.dump
   puts "Done"
+  class A; end
+  A.new
+  puts HeapDump.count_objects [A]
 end
 
 task :default => :test

data/ext/heap_dump/extconf.rb

@@ -13,6 +13,7 @@ unless ARGV.any? {|arg| arg.include?('--with-ruby-include') }
     ruby_include = "#{ENV['rvm_path']}/src/#{$2}" unless File.exist?(ruby_include)
     ARGV << "--with-ruby-include=#{ruby_include}"
   end
+  puts "Using ruby source from #{ruby_include}"
 end
 
 require 'mkmf'
@@ -45,8 +46,14 @@ spec = instance_eval(File.read(gemspec), gemspec).dependencies.find{|d|d.name ==
 yajl = find_gem_dir(spec.name, spec.requirement)
 find_header('api/yajl_gen.h', File.join(yajl, 'ext', 'yajl'))
 
-#TODO: inject ruby version
-unless find_header("gc_internal.h", File.join(File.dirname(__FILE__),'specific', "ruby-#{RUBY_VERSION}")) && have_header("gc_internal.h")
+specific = RUBY_VERSION
+
+# here other specific headers may be injected, for example - patched releases etc.
+if RUBY_VERSION == '2.0.0' && RUBY_REVISION == 37411
+  specific = "2.0.0_preview1"
+end
+
+unless find_header("gc_internal.h", File.join(File.dirname(__FILE__),'specific', "ruby-#{specific}")) && have_header("gc_internal.h")
   raise "Do not have internal structs for your ruby version"
 end
 
@@ -85,6 +92,10 @@ hdrs = proc {
 
 dir_config("ruby") # allow user to pass in non-standard core include directory
 
+if ENV['DEBUG']
+  CONFIG['debugflags'] << ' -ggdb3 -O0'
+end
+
 if !Debugger::RubyCoreSource::create_makefile_with_core(hdrs, "heap_dump")
   STDERR.print("Makefile creation failed\n")
   STDERR.print("*************************************************************\n\n")

data/ext/heap_dump/heap_dump.c

@@ -390,7 +390,8 @@ static void dump_node_refs(NODE* obj, walk_ctx_t* ctx){
       return;
 
     case NODE_MEMO:
-      yg_id((VALUE)obj->u1.node);
+      if(is_in_heap(NULL, obj->u1.node))
+        yg_id((VALUE)obj->u1.node);
       break;
 
     //not implemented:
@@ -1718,26 +1719,16 @@ iterate_user_type_counts(VALUE key, VALUE value, yajl_gen yajl){
 }
 
 static VALUE
-rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
-  yajl_gen_config cfg;
-  yajl_gen yajl;
+heapdump_count_objects_core(yajl_gen yajl, VALUE string_prefixes, int do_gc){
   VALUE cls, class_name, prefix;
   size_t counts[T_MASK+1];
   size_t freed = 0;
   size_t total = 0;
   size_t i;
   long int n;
-  const unsigned char* buf;
-  unsigned int len;
   VALUE hash = rb_hash_new();
   rb_objspace_t *objspace = GET_THREAD()->vm->objspace;
 
-  rb_check_array_type(string_prefixes);
-  memset(&cfg, 0, sizeof(cfg));
-  cfg.beautify = true;
-  cfg.htmlSafe = true;
-  cfg.indentString = "    ";
-  yajl = yajl_gen_alloc(&cfg,NULL);
   yg_map();
   if(do_gc){
     yg_cstring("gc_ran");
@@ -1799,6 +1790,26 @@ rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
   yg_map_end();
 
   yg_map_end(); //all document
+  return hash;
+#undef YAJL
+}
+
+static VALUE
+rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
+  yajl_gen_config cfg;
+  yajl_gen yajl;
+  const unsigned char* buf;
+  unsigned int len;
+
+  rb_check_array_type(string_prefixes);
+
+  memset(&cfg, 0, sizeof(cfg));
+  cfg.beautify = true;
+  cfg.htmlSafe = true;
+  cfg.indentString = "    ";
+  yajl = yajl_gen_alloc(&cfg,NULL);
+
+  heapdump_count_objects_core(yajl, string_prefixes, RTEST(do_gc));
 
   //flush yajl:
   if(yajl_gen_get_buf(yajl, &buf, &len) == yajl_gen_status_ok){
@@ -1810,7 +1821,68 @@ rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
   } else {
     return Qnil;
   }
-#undef YAJL
+}
+
+//NOTE: return value must be freed if not null
+static const char* heapdump_count_objects_ex(int return_string, char* first_name, va_list args){
+  yajl_gen_config cfg;
+  yajl_gen yajl;
+  const unsigned char* buf;
+  unsigned int len;
+  VALUE string_prefixes;
+
+
+  memset(&cfg, 0, sizeof(cfg));
+  cfg.beautify = !return_string;
+  // cfg.htmlSafe = true;
+  cfg.indentString = "    ";
+  yajl = yajl_gen_alloc(&cfg,NULL);
+
+  string_prefixes = rb_ary_new();
+  while(first_name && first_name[0]){
+    rb_ary_push(string_prefixes, rb_str_new2(first_name));
+    first_name = va_arg(args, char*);
+  }
+
+  heapdump_count_objects_core(yajl, string_prefixes, false);
+
+  //flush yajl:
+  if(yajl_gen_get_buf(yajl, &buf, &len) == yajl_gen_status_ok){
+    char* result = NULL;
+    if(!return_string){
+      fwrite(buf, len, 1, stderr);
+      fprintf(stderr, "\n");
+    } else {
+      result = malloc(len);
+      memcpy(result, buf, len);
+    }
+    yajl_gen_clear(yajl);
+    yajl_gen_free(yajl);
+    return result; //NOTE: that memory is already freed! (but it's usually ok for gdb)
+  }
+  return NULL;
+}
+
+void heapdump_count_objects_print(char* first_name, ...){
+  va_list args;
+  va_start(args, first_name);
+  heapdump_count_objects_ex(false, first_name, args);
+  va_end(args);
+}
+
+//NOTE: return value must be freed if not null
+const char* heapdump_count_objects_return(char* first_name, ...){
+  va_list args;
+  va_start(args, first_name);
+  const char* res = heapdump_count_objects_ex(true, first_name, args);
+  va_end(args);
+  return res;
+}
+
+
+static VALUE rb_heapdump_trigger_int_3(VALUE self){
+  __asm__("int $0x3;");
+  return Qnil;
 }
 
 void Init_heap_dump(){
@@ -1827,6 +1899,7 @@ void Init_heap_dump(){
   rb_mHeapDumpModule = rb_define_module("HeapDump");
   rb_define_singleton_method(rb_mHeapDumpModule, "dump_ext", rb_heapdump_dump, 1);
   rb_define_singleton_method(rb_mHeapDumpModule, "count_objects_ext", rb_heapdump_count_objects, 2);
+  rb_define_singleton_method(rb_mHeapDumpModule, "int3", rb_heapdump_trigger_int_3, 0);
 
   rb_define_singleton_method(rb_mHeapDumpModule, "verbose", heapdump_verbose, 0);
   rb_define_singleton_method(rb_mHeapDumpModule, "verbose=", heapdump_verbose_setter, 1);

data/ext/heap_dump/specific/ruby-2.0.0/gc_internal.h

@@ -29,7 +29,6 @@ typedef struct gc_profile_record {
 #endif
 } gc_profile_record;
 
-
 #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)
 #pragma pack(push, 1) /* magic for reducing sizeof(RVALUE): 24 -> 20 */
 #endif
@@ -69,9 +68,7 @@ typedef struct RVALUE {
 #endif
 
 struct heaps_slot {
-    void *membase;
-    RVALUE *slot;
-    size_t limit;
+    struct heaps_header *header;
     uintptr_t *bits;
     RVALUE *freelist;
     struct heaps_slot *next;
@@ -82,12 +79,9 @@ struct heaps_slot {
 struct heaps_header {
     struct heaps_slot *base;
     uintptr_t *bits;
-};
-
-struct sorted_heaps_slot {
     RVALUE *start;
     RVALUE *end;
-    struct heaps_slot *slot;
+    size_t limit;
 };
 
 struct heaps_free_bitmap {
@@ -133,13 +127,12 @@ typedef struct rb_objspace {
   struct heaps_slot *ptr;
   struct heaps_slot *sweep_slots;
   struct heaps_slot *free_slots;
-  struct sorted_heaps_slot *sorted;
+  struct heaps_header **sorted;
   size_t length;
   size_t used;
         struct heaps_free_bitmap *free_bitmap;
   RVALUE *range[2];
-  RVALUE *freed;
-  size_t live_num;
+  struct heaps_header *freed;
   size_t free_num;
   size_t free_min;
   size_t final_num;
@@ -165,6 +158,8 @@ typedef struct rb_objspace {
     } profile;
     struct gc_list *global_list;
     size_t count;
+    size_t total_allocated_object_num;
+    size_t total_freed_object_num;
     int gc_stress;
 
     struct mark_func_data_struct {
@@ -208,7 +203,6 @@ typedef struct rb_objspace {
 #define BITMAP_INDEX(p) (NUM_IN_SLOT(p) / (sizeof(uintptr_t) * CHAR_BIT))
 #define BITMAP_OFFSET(p) (NUM_IN_SLOT(p) & ((sizeof(uintptr_t) * CHAR_BIT)-1))
 #define MARKED_IN_BITMAP(bits, p) (bits[BITMAP_INDEX(p)] & ((uintptr_t)1 << BITMAP_OFFSET(p)))
-
 //
 #define RANY(o) ((RVALUE*)(o))
 //
@@ -217,7 +211,7 @@ static inline int
 is_pointer_to_heap(rb_objspace_t *objspace, void *ptr)
 {
     register RVALUE *p = RANY(ptr);
-    register struct sorted_heaps_slot *heap;
+    register struct heaps_header *heap;
     register size_t hi, lo, mid;
 
     if (p < lomem || p > himem) return FALSE;
@@ -228,7 +222,7 @@ is_pointer_to_heap(rb_objspace_t *objspace, void *ptr)
     hi = heaps_used;
     while (lo < hi) {
   mid = (lo + hi) / 2;
-  heap = &objspace->heap.sorted[mid];
+  heap = objspace->heap.sorted[mid];
   if (heap->start <= p) {
       if (p < heap->end)
     return TRUE;
@@ -242,10 +236,10 @@ is_pointer_to_heap(rb_objspace_t *objspace, void *ptr)
 }
 
 //from count_objects:
-#define FOR_EACH_HEAP_SLOT(p) for (i = 0; i < heaps_used; i++) {\
-      RVALUE *p = objspace->heap.sorted[i].start, *pend = objspace->heap.sorted[i].end;\
-      if(!p) continue;\
-      for (; p < pend; p++) {
-#define FOR_EACH_HEAP_SLOT_END(total) } total += objspace->heap.sorted[i].slot->limit; }
+#define FOR_EACH_HEAP_SLOT(p)     for (i = 0; i < heaps_used; i++) { RVALUE *p, *pend;\
+        p = objspace->heap.sorted[i]->start; pend = p + objspace->heap.sorted[i]->limit;\
+        for (;p < pend; p++) {
+
+#define FOR_EACH_HEAP_SLOT_END(total) } total += objspace->heap.sorted[i]->limit; }
 
 #define NODE_OPTBLOCK 1000000 //FIXME

data/ext/heap_dump/specific/ruby-2.0.0_preview1/fiber.h

@@ -0,0 +1,67 @@
+#define CAPTURE_JUST_VALID_VM_STACK 1
+
+enum context_type {
+    CONTINUATION_CONTEXT = 0,
+    FIBER_CONTEXT = 1,
+    ROOT_FIBER_CONTEXT = 2
+};
+
+typedef struct rb_context_struct {
+    enum context_type type;
+    VALUE self;
+    int argc;
+    VALUE value;
+    VALUE *vm_stack;
+#ifdef CAPTURE_JUST_VALID_VM_STACK
+    size_t vm_stack_slen;  /* length of stack (head of th->stack) */
+    size_t vm_stack_clen;  /* length of control frames (tail of th->stack) */
+#endif
+    VALUE *machine_stack;
+    VALUE *machine_stack_src;
+#ifdef __ia64
+    VALUE *machine_register_stack;
+    VALUE *machine_register_stack_src;
+    int machine_register_stack_size;
+#endif
+    rb_thread_t saved_thread;
+    rb_jmpbuf_t jmpbuf;
+    size_t machine_stack_size;
+} rb_context_t;
+
+enum fiber_status {
+    CREATED,
+    RUNNING,
+    TERMINATED
+};
+
+#if FIBER_USE_NATIVE && !defined(_WIN32)
+#define MAX_MAHINE_STACK_CACHE  10
+static int machine_stack_cache_index = 0;
+typedef struct machine_stack_cache_struct {
+    void *ptr;
+    size_t size;
+} machine_stack_cache_t;
+static machine_stack_cache_t machine_stack_cache[MAX_MAHINE_STACK_CACHE];
+static machine_stack_cache_t terminated_machine_stack;
+#endif
+
+typedef struct rb_fiber_struct {
+    rb_context_t cont;
+    VALUE prev;
+    enum fiber_status status;
+    struct rb_fiber_struct *prev_fiber;
+    struct rb_fiber_struct *next_fiber;
+    /* If a fiber invokes "transfer",
+     * then this fiber can't "resume" any more after that.
+     * You shouldn't mix "transfer" and "resume".
+     */
+    int transfered;
+
+#if FIBER_USE_NATIVE
+#ifdef _WIN32
+    void *fib_handle;
+#else
+    ucontext_t context;
+#endif
+#endif
+} rb_fiber_t;

data/ext/heap_dump/specific/ruby-2.0.0_preview1/gc_internal.h

@@ -0,0 +1,251 @@
+#include "ruby/re.h"
+
+#ifndef GC_PROFILE_MORE_DETAIL
+#define GC_PROFILE_MORE_DETAIL 0
+#endif
+
+typedef struct gc_profile_record {
+    double gc_time;
+    double gc_invoke_time;
+
+    size_t heap_total_objects;
+    size_t heap_use_size;
+    size_t heap_total_size;
+
+    int is_marked;
+
+#if GC_PROFILE_MORE_DETAIL
+    double gc_mark_time;
+    double gc_sweep_time;
+
+    size_t heap_use_slots;
+    size_t heap_live_objects;
+    size_t heap_free_objects;
+
+    int have_finalize;
+
+    size_t allocate_increase;
+    size_t allocate_limit;
+#endif
+} gc_profile_record;
+
+
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)
+#pragma pack(push, 1) /* magic for reducing sizeof(RVALUE): 24 -> 20 */
+#endif
+
+typedef struct RVALUE {
+    union {
+  struct {
+      VALUE flags;    /* always 0 for freed obj */
+      struct RVALUE *next;
+  } free;
+  struct RBasic  basic;
+  struct RObject object;
+  struct RClass  klass;
+  struct RFloat  flonum;
+  struct RString string;
+  struct RArray  array;
+  struct RRegexp regexp;
+  struct RHash   hash;
+  struct RData   data;
+  struct RTypedData   typeddata;
+  struct RStruct rstruct;
+  struct RBignum bignum;
+  struct RFile   file;
+  struct RNode   node;
+  struct RMatch  match;
+  struct RRational rational;
+  struct RComplex complex;
+    } as;
+#ifdef GC_DEBUG
+    const char *file;
+    int   line;
+#endif
+} RVALUE;
+
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)
+#pragma pack(pop)
+#endif
+
+struct heaps_slot {
+    void *membase;
+    RVALUE *slot;
+    size_t limit;
+    uintptr_t *bits;
+    RVALUE *freelist;
+    struct heaps_slot *next;
+    struct heaps_slot *prev;
+    struct heaps_slot *free_next;
+};
+
+struct heaps_header {
+    struct heaps_slot *base;
+    uintptr_t *bits;
+};
+
+struct sorted_heaps_slot {
+    RVALUE *start;
+    RVALUE *end;
+    struct heaps_slot *slot;
+};
+
+struct heaps_free_bitmap {
+    struct heaps_free_bitmap *next;
+};
+
+struct gc_list {
+    VALUE *varptr;
+    struct gc_list *next;
+};
+
+#define STACK_CHUNK_SIZE 500
+
+typedef struct stack_chunk {
+    VALUE data[STACK_CHUNK_SIZE];
+    struct stack_chunk *next;
+} stack_chunk_t;
+
+typedef struct mark_stack {
+    stack_chunk_t *chunk;
+    stack_chunk_t *cache;
+    size_t index;
+    size_t limit;
+    size_t cache_size;
+    size_t unused_cache_size;
+} mark_stack_t;
+
+#ifndef CALC_EXACT_MALLOC_SIZE
+#define CALC_EXACT_MALLOC_SIZE 0
+#endif
+
+typedef struct rb_objspace {
+    struct {
+  size_t limit;
+  size_t increase;
+#if CALC_EXACT_MALLOC_SIZE
+  size_t allocated_size;
+  size_t allocations;
+#endif
+    } malloc_params;
+    struct {
+  size_t increment;
+  struct heaps_slot *ptr;
+  struct heaps_slot *sweep_slots;
+  struct heaps_slot *free_slots;
+  struct sorted_heaps_slot *sorted;
+  size_t length;
+  size_t used;
+        struct heaps_free_bitmap *free_bitmap;
+  RVALUE *range[2];
+  RVALUE *freed;
+  size_t live_num;
+  size_t free_num;
+  size_t free_min;
+  size_t final_num;
+  size_t do_heap_free;
+    } heap;
+    struct {
+  int dont_gc;
+  int dont_lazy_sweep;
+  int during_gc;
+  rb_atomic_t finalizing;
+    } flags;
+    struct {
+  st_table *table;
+  RVALUE *deferred;
+    } final;
+    mark_stack_t mark_stack;
+    struct {
+  int run;
+  gc_profile_record *record;
+  size_t count;
+  size_t size;
+  double invoke_time;
+    } profile;
+    struct gc_list *global_list;
+    size_t count;
+    int gc_stress;
+
+    struct mark_func_data_struct {
+  void *data;
+  void (*mark_func)(VALUE v, void *data);
+    } *mark_func_data;
+} rb_objspace_t;
+
+#define malloc_limit    objspace->malloc_params.limit
+#define malloc_increase   objspace->malloc_params.increase
+#define heaps     objspace->heap.ptr
+#define heaps_length    objspace->heap.length
+#define heaps_used    objspace->heap.used
+#define lomem     objspace->heap.range[0]
+#define himem     objspace->heap.range[1]
+#define heaps_inc   objspace->heap.increment
+#define heaps_freed   objspace->heap.freed
+#define dont_gc     objspace->flags.dont_gc
+#define during_gc   objspace->flags.during_gc
+#define finalizing    objspace->flags.finalizing
+#define finalizer_table   objspace->final.table
+#define deferred_final_list objspace->final.deferred
+#define global_List   objspace->global_list
+#define ruby_gc_stress    objspace->gc_stress
+#define initial_malloc_limit  initial_params.initial_malloc_limit
+#define initial_heap_min_slots  initial_params.initial_heap_min_slots
+#define initial_free_min  initial_params.initial_free_min
+
+#define is_lazy_sweeping(objspace) ((objspace)->heap.sweep_slots != 0)
+
+#define nonspecial_obj_id(obj) (VALUE)((SIGNED_VALUE)(obj)|FIXNUM_FLAG)
+
+#define RANY(o) ((RVALUE*)(o))
+#define has_free_object (objspace->heap.free_slots && objspace->heap.free_slots->freelist)
+
+#define HEAP_HEADER(p) ((struct heaps_header *)(p))
+#define GET_HEAP_HEADER(x) (HEAP_HEADER((uintptr_t)(x) & ~(HEAP_ALIGN_MASK)))
+#define GET_HEAP_SLOT(x) (GET_HEAP_HEADER(x)->base)
+#define GET_HEAP_BITMAP(x) (GET_HEAP_HEADER(x)->bits)
+#define NUM_IN_SLOT(p) (((uintptr_t)(p) & HEAP_ALIGN_MASK)/sizeof(RVALUE))
+#define BITMAP_INDEX(p) (NUM_IN_SLOT(p) / (sizeof(uintptr_t) * CHAR_BIT))
+#define BITMAP_OFFSET(p) (NUM_IN_SLOT(p) & ((sizeof(uintptr_t) * CHAR_BIT)-1))
+#define MARKED_IN_BITMAP(bits, p) (bits[BITMAP_INDEX(p)] & ((uintptr_t)1 << BITMAP_OFFSET(p)))
+
+//
+#define RANY(o) ((RVALUE*)(o))
+//
+
+static inline int
+is_pointer_to_heap(rb_objspace_t *objspace, void *ptr)
+{
+    register RVALUE *p = RANY(ptr);
+    register struct sorted_heaps_slot *heap;
+    register size_t hi, lo, mid;
+
+    if (p < lomem || p > himem) return FALSE;
+    if ((VALUE)p % sizeof(RVALUE) != 0) return FALSE;
+
+    /* check if p looks like a pointer using bsearch*/
+    lo = 0;
+    hi = heaps_used;
+    while (lo < hi) {
+  mid = (lo + hi) / 2;
+  heap = &objspace->heap.sorted[mid];
+  if (heap->start <= p) {
+      if (p < heap->end)
+    return TRUE;
+      lo = mid + 1;
+  }
+  else {
+      hi = mid;
+  }
+    }
+    return FALSE;
+}
+
+//from count_objects:
+#define FOR_EACH_HEAP_SLOT(p) for (i = 0; i < heaps_used; i++) {\
+      RVALUE *p = objspace->heap.sorted[i].start, *pend = objspace->heap.sorted[i].end;\
+      if(!p) continue;\
+      for (; p < pend; p++) {
+#define FOR_EACH_HEAP_SLOT_END(total) } total += objspace->heap.sorted[i].slot->limit; }
+
+#define NODE_OPTBLOCK 1000000 //FIXME

data/ext/heap_dump/specific/ruby-2.0.0_preview1/internal_typed_data.h

@@ -0,0 +1,109 @@
+ //FIXME: autogen this from ruby (this copied from 1.9.3p194)
+
+// thread.c:
+struct thgroup {
+  int enclosed;
+  VALUE group;
+};
+
+// enumerator.c:
+struct enumerator {
+    VALUE obj;
+    ID    meth;
+    VALUE args;
+    VALUE fib;
+    VALUE dst;
+    VALUE lookahead;
+    VALUE feedvalue;
+    VALUE stop_exc;
+};
+
+//
+struct generator {
+    VALUE proc;
+};
+
+struct yielder {
+    VALUE proc;
+};
+
+
+// proc.c:
+struct METHOD {
+    VALUE recv;
+    VALUE rclass;
+    VALUE defined_class; //FIXME: dump this
+    ID id;
+    rb_method_entry_t *me;
+    struct unlinked_method_entry_list_entry *ume;
+};
+
+//
+#define METHOD_DEFINITIONP(m) (m->me ? m->me->def : NULL)
+
+//class.c:
+#define HAVE_RB_CLASS_TBL 1
+//For som reason this fails to link directly on 1.9.3 :(
+
+//HACK:
+#include <dlfcn.h>
+
+inline st_table * rb_get_class_tbl(){
+  Dl_info info;
+  void* image;
+  if(!dladdr(rb_intern, &info) || !info.dli_fname){
+    return NULL;
+  }
+  image = dlopen(info.dli_fname, RTLD_NOLOAD | RTLD_GLOBAL);
+  // printf("Image is %p, addr is %p (%p rel)\n", image, rb_intern, ((void*)rb_intern - image));
+  if(image)
+  {
+    void* tbl = dlsym(image, "_rb_class_tbl");
+    dlclose(image);
+    if(tbl)
+      return tbl;
+  }
+
+  //TODO: parse sym table and calculate address?
+
+  return NULL;
+}
+
+#define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
+#define GET_THREAD() ruby_current_thread
+
+//FIXME: get global const for it:  rb_define_global_const("RUBY_ENGINE", ruby_engine_name = MKSTR(engine));
+#define ruby_engine_name Qnil
+
+#define ID_ALLOCATOR 0
+
+//vm_trace.c
+typedef enum {
+    RUBY_HOOK_FLAG_SAFE    = 0x01,
+    RUBY_HOOK_FLAG_DELETED = 0x02,
+    RUBY_HOOK_FLAG_RAW_ARG = 0x04
+} rb_hook_flag_t;
+typedef struct rb_event_hook_struct {
+    rb_hook_flag_t hook_flags;
+    rb_event_flag_t events;
+    rb_event_hook_func_t func;
+    VALUE data;
+    struct rb_event_hook_struct *next;
+} rb_event_hook_t;
+
+//vm_backtrace.c
+inline static int
+calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
+{
+    return rb_iseq_line_no(iseq, pc - iseq->iseq_encoded);
+}
+
+int rb_vm_get_sourceline(const rb_control_frame_t * cfp){
+  int lineno = 0;
+  const rb_iseq_t *iseq = cfp->iseq;
+
+  if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
+  lineno = calc_lineno(cfp->iseq, cfp->pc);
+  }
+  return lineno;
+}

data/lib/heap_dump/version.rb

@@ -1,3 +1,3 @@
 module HeapDump
-  VERSION = "0.0.32"
+  VERSION = "0.0.33"
 end

data/lib/heap_dump.rb

@@ -11,13 +11,13 @@ module HeapDump
   end
 
   # provides an object count - like ObjectSpace.count_objects, but also for user classes
-  def self.count_objects namespaces_array, gc=false
-    unless namespaces_array.is_a?(Array) && namespaces_array.all?{|v|v.is_a? Symbol}
-      if namespaces_array.is_a? Symbol
-        namespaces_array = [namespaces_array]
+  def self.count_objects namespaces_array=[], gc=false
+    unless namespaces_array.is_a?(Array) && namespaces_array.all?{|v|v.respond_to? :to_s}
+      if namespaces_array.respond_to? :to_s
+        namespaces_array = [namespaces_array.to_s]
       else
         #TODO: actually, better way is to accept anything convertable, even module itself
-        raise ArgumentError.new("namespaces_array must be a symbol or array of symbols")
+        raise ArgumentError.new("namespaces_array must be a symbol/string or array of strings/symbols")
       end
     end
     prefixes_array = namespaces_array.map{|c| c.to_s}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heap_dump
 version: !ruby/object:Gem::Version
-  version: 0.0.32
+  version: 0.0.33
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-21 00:00:00.000000000 Z
+date: 2012-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debugger-ruby_core_source
@@ -85,6 +85,9 @@ files:
 - ext/heap_dump/specific/ruby-2.0.0/fiber.h
 - ext/heap_dump/specific/ruby-2.0.0/gc_internal.h
 - ext/heap_dump/specific/ruby-2.0.0/internal_typed_data.h
+- ext/heap_dump/specific/ruby-2.0.0_preview1/fiber.h
+- ext/heap_dump/specific/ruby-2.0.0_preview1/gc_internal.h
+- ext/heap_dump/specific/ruby-2.0.0_preview1/internal_typed_data.h
 - heap_dump.gemspec
 - lib/heap_dump.rb
 - lib/heap_dump/version.rb
@@ -106,6 +109,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3329195941644190960
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -114,4 +120,3 @@ specification_version: 3
 summary: Allows to dump heap to track reference leaks, including leaks in proc contexts
   and fibers
 test_files: []
-has_rdoc: