heap_dump 0.0.28 → 0.0.29

data/README.md

@@ -24,6 +24,7 @@ Or install it yourself as:
 
 ## Usage
 
+### Dumping heap references
 In your code call:
 
 ```ruby
@@ -34,6 +35,77 @@ HeapDump.dump
 this will run GC and then create a dump.json with live heap contents.
 Json contains one object per line, thus can be easily grepped.
 
+#### Output example/format
+
+Format is not stable yet, but looks like this:
+
+```json
+
+[{"id":"_ROOTS_","stack_and_registers":[70313628419480,70313628419480,70313628419480,"trace",70313627751860],"classes":[70313627319820,70313628530860]}
+,{"id":70365602702620,"bt":"T_ARRAY","val":[">=",70365602705060]}
+,{"id":70365602847060,"bt":"T_ARRAY","val":[]}
+,{"id":70365602702660,"bt":"T_DATA","type_name":"iseq","size":564,"name":"activate_spec","filename":"/Users/vasfed/.rvm/rubies/ruby-1.9.2-p290/lib/ruby/site_ruby/1.9.1/rubygems.rb","line":485,"type":"method","refs_array_id":70365602847060,"coverage":null,"klass":70365602821240,"cref_stack":70365602848300,"defined_method_id":12672}
+,{"id":70365602702680,"bt":"T_STRING","val":"activate_spec"}
+,{"id":70365602821260,"bt":"T_HASH","val":{"EXEEXT":"","RUBY_SO_NAME":"ruby.1.9.1","arch":"x86_64-darwin11.2.0","bindir":70365603049640,"libdir":70365603050600,"ruby_install_name":"ruby","ruby_version":"1.9.1","rubylibprefix":70365603112080,"sitedir":70365603112440,"sitelibdir":70365603048920,"datadir":70365603049880,"vendordir":70365603112500,"vendorlibdir":70365603048800}}
+,{"id":70365602712560,"bt":"T_CLASS","name":"URI::HTTPS","methods":{},"ivs":{"__classpath__":"URI::HTTPS","DEFAULT_PORT":443},"super":70365602771440}
+,{"id":70365602771400,"bt":"T_CLASS","name":"Class","methods":{"build":70365602782860},"ivs":{"__attached__":70365602771440},"super":70365611597900}
+,{"id":70365602717060,"bt":"T_DATA","type_name":"proc","size":72,"is_lambda":0,"blockprocval":null,"envval":70365602712440,"iseq":{"id":70365600821896,"name":"block in <class:FileList>","filename":"/Users/vasfed/.rvm/gems/ruby-1.9.2-p290/gems/rake-0.9.2.2/lib/rake/file_list.rb","line":743,"type":"block","refs_array_id":70365611724600,"coverage":null,"klass":null,"cref_stack":70365611799480,"defined_method_id":0}}
+,{"id":70365603045160,"bt":"T_DATA","type_name":"VM/env","size":128,"refs":[]}
+,{"id":70365613258980,"bt":"T_ICLASS","name":"Object","methods":{"==":"(CFUNC)",">":"(CFUNC)",">=":"(CFUNC)","<":"(CFUNC)","<=":"(CFUNC)","between?":"(CFUNC)"},"ivs":{"__classid__":"Comparable"},"super":70365613259120}
+,{"id":70151795145340,"bt":"T_DATA","type_name":"proc","size":72,"is_lambda":0,"blockprocval":null,"envval":70151795224840,"iseq":{"id":70151828020360,"name":"block in subscribe","filename":"/Users/vasfed/acceptor.rb","line":91,"type":"block","refs_array_id":70151796420080,"coverage":null,"klass":null,"cref_stack":70151796421080,"defined_method_id":0}}
+,{"id":70151795224840,"bt":"T_DATA","type_name":"VM/env","size":120,"refs":[70151806738200,70151796176180,"string1",null,0,70151795224840,null]}
+]
+```
+etc.
+
+bt field is ruby builtin type name.
+
+Where available - val/refs/ivs/etc. field present with hash/array of references.
+Long numbers usually are object ids.
+
+### Counting objects in heap
+
+Also heap_dump now includes an object counter, like `ObjectSpace.count_objects`, but capable of counting objects from your namespace
+
+```ruby
+
+HeapDump.count_objects :YourNameSpace # => json string
+```
+
+which results in something like:
+
+```json
+
+{
+    "total_slots": 56419,
+    "free_slots": 12384,
+    "basic_types": {
+        "T_OBJECT": 1945,
+        "T_CLASS": 931,
+        "T_MODULE": 68,
+        "T_FLOAT": 24,
+        "T_STRING": 26557,
+        "T_REGEXP": 346,
+        "T_ARRAY": 6556,
+        "T_HASH": 159,
+        "T_STRUCT": 45,
+        "T_BIGNUM": 2,
+        "T_FILE": 6,
+        "T_DATA": 3516,
+        "T_MATCH": 15,
+        "T_COMPLEX": 1,
+        "T_RATIONAL": 10,
+        "T_NODE": 3754,
+        "T_ICLASS": 100
+    },
+    "user_types": {
+        "YourNameSpace::B": 2,
+        "YourNameSpace::A": 3
+    }
+}
+```
+
+
 ### Injecting into live process via GDB
 
 For long-running applications common and recommended usecase is to have some kind of custom action or signal handler in app itself that invokes dump.
@@ -71,34 +143,6 @@ cat dump.json | sed 's/^[,\[]//;s/\]$//;s/^{"id"/{"_id"/' | mongoimport -d datab
 Note that even small dumps usually contain a few hundred thousands objects, so do not forget to add some indexes.
 
 
-### Output example/format
-
-Format is not stable yet, but looks like this:
-
-```json
-
-[{"id":"_ROOTS_","stack_and_registers":[70313628419480,70313628419480,70313628419480,"trace",70313627751860],"classes":[70313627319820,70313628530860]}
-,{"id":70365602702620,"bt":"T_ARRAY","val":[">=",70365602705060]}
-,{"id":70365602847060,"bt":"T_ARRAY","val":[]}
-,{"id":70365602702660,"bt":"T_DATA","type_name":"iseq","size":564,"name":"activate_spec","filename":"/Users/vasfed/.rvm/rubies/ruby-1.9.2-p290/lib/ruby/site_ruby/1.9.1/rubygems.rb","line":485,"type":"method","refs_array_id":70365602847060,"coverage":null,"klass":70365602821240,"cref_stack":70365602848300,"defined_method_id":12672}
-,{"id":70365602702680,"bt":"T_STRING","val":"activate_spec"}
-,{"id":70365602821260,"bt":"T_HASH","val":{"EXEEXT":"","RUBY_SO_NAME":"ruby.1.9.1","arch":"x86_64-darwin11.2.0","bindir":70365603049640,"libdir":70365603050600,"ruby_install_name":"ruby","ruby_version":"1.9.1","rubylibprefix":70365603112080,"sitedir":70365603112440,"sitelibdir":70365603048920,"datadir":70365603049880,"vendordir":70365603112500,"vendorlibdir":70365603048800}}
-,{"id":70365602712560,"bt":"T_CLASS","name":"URI::HTTPS","methods":{},"ivs":{"__classpath__":"URI::HTTPS","DEFAULT_PORT":443},"super":70365602771440}
-,{"id":70365602771400,"bt":"T_CLASS","name":"Class","methods":{"build":70365602782860},"ivs":{"__attached__":70365602771440},"super":70365611597900}
-,{"id":70365602717060,"bt":"T_DATA","type_name":"proc","size":72,"is_lambda":0,"blockprocval":null,"envval":70365602712440,"iseq":{"id":70365600821896,"name":"block in <class:FileList>","filename":"/Users/vasfed/.rvm/gems/ruby-1.9.2-p290/gems/rake-0.9.2.2/lib/rake/file_list.rb","line":743,"type":"block","refs_array_id":70365611724600,"coverage":null,"klass":null,"cref_stack":70365611799480,"defined_method_id":0}}
-,{"id":70365603045160,"bt":"T_DATA","type_name":"VM/env","size":128,"refs":[]}
-,{"id":70365613258980,"bt":"T_ICLASS","name":"Object","methods":{"==":"(CFUNC)",">":"(CFUNC)",">=":"(CFUNC)","<":"(CFUNC)","<=":"(CFUNC)","between?":"(CFUNC)"},"ivs":{"__classid__":"Comparable"},"super":70365613259120}
-,{"id":70151795145340,"bt":"T_DATA","type_name":"proc","size":72,"is_lambda":0,"blockprocval":null,"envval":70151795224840,"iseq":{"id":70151828020360,"name":"block in subscribe","filename":"/Users/vasfed/acceptor.rb","line":91,"type":"block","refs_array_id":70151796420080,"coverage":null,"klass":null,"cref_stack":70151796421080,"defined_method_id":0}}
-,{"id":70151795224840,"bt":"T_DATA","type_name":"VM/env","size":120,"refs":[70151806738200,70151796176180,"string1",null,0,70151795224840,null]}
-]
-```
-etc.
-
-bt field is ruby builtin type name.
-
-Where available - val/refs/ivs/etc. field present with hash/array of references.
-Long numbers usually are object ids.
-
 ## What may leak
 
 ### Brief Ruby GC decription
@@ -126,6 +170,14 @@ Obvious references: from variables, instance variables (including class), arrays
 Less obvious: method closures. These are stored in T_DATAs with 'VM/env' type.
 Latest version of heap_dump allows to trace such references: search for a env, by it's id you can find it's owner iseq, which usually has file and line number where block/lambda/proc was created.
 
+## Hints on finding leaks
+
+Usually it's a good practice first to detect leaking type by running several `HeapDump.count_objects` while making some load on your app and comparing results. Note objects that may be reasons for others to linger in memory according to your architecture (for example - something like "session"/"incoming connection"/"delayed job" etc.).
+
+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.
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -37,8 +37,11 @@ task :test => :compile do
       Fiber.yield e
       fiber_var = :some_fiber_var3
     }.resume
-  puts "Dumping..."
+  $some_global = "value_global"
+  puts "Dumping...(rake)"
+  HeapDump.verbose = true
   HeapDump.dump
+  puts "Done"
 end
 
 task :default => :test

data/ext/heap_dump/heap_dump.c

@@ -47,6 +47,7 @@
 
 // simple test - rake compile && bundle exec ruby -e 'require "heap_dump"; HeapDump.dump'
 
+#include <dlfcn.h>
 
 #ifdef HAVE_GC_INTERNAL_H
 #include "gc_internal.h"
@@ -64,12 +65,16 @@ static VALUE rb_mHeapDumpModule;
 static ID classid;
 
 //shortcuts to yajl
-#define yg_string(str,len) yajl_gen_string(ctx->yajl, str, len)
+#define YAJL ctx->yajl
+#define yg_string(str,len) yajl_gen_string(YAJL, str, len)
 #define yg_cstring(str) yg_string(str, (unsigned int)strlen(str))
 #define yg_rstring(str) yg_string(RSTRING_PTR(str), (unsigned int)RSTRING_LEN(str))
-#define yg_int(i) yajl_gen_integer(ctx->yajl, i)
-#define yg_double(d) (yajl_gen_double(ctx->yajl, d)==yajl_gen_invalid_number? yg_cstring("inf|NaN") : true)
-#define yg_null() yajl_gen_null(ctx->yajl)
+#define yg_int(i) yajl_gen_integer(YAJL, i)
+#define yg_double(d) (yajl_gen_double(YAJL, d)==yajl_gen_invalid_number? yg_cstring("inf|NaN") : true)
+#define yg_null() yajl_gen_null(YAJL)
+#define yg_bool(b) yajl_gen_bool(YAJL, b);
+
+#define yg_funcaddr(addr) yg_funcaddr_real(ctx, addr)
 
 //#define yg_id(obj) yg_int(NUM2LONG(rb_obj_id(obj)))
 #define yg_id(obj) yg_id1(obj,ctx)
@@ -82,10 +87,10 @@ static ID classid;
 #define ygh_cstring(key,str) {yg_cstring(key); yg_cstring(str);}
 #define ygh_rstring(key,str) {yg_cstring(key); yg_rstring(str);}
 
-#define yg_map() yajl_gen_map_open(ctx->yajl);
-#define yg_map_end() yajl_gen_map_close(ctx->yajl);
-#define yg_array() yajl_gen_array_open(ctx->yajl);
-#define yg_array_end() yajl_gen_array_close(ctx->yajl);
+#define yg_map() yajl_gen_map_open(YAJL);
+#define yg_map_end() yajl_gen_map_close(YAJL);
+#define yg_array() yajl_gen_array_open(YAJL);
+#define yg_array_end() yajl_gen_array_close(YAJL);
 
 
 // context for objectspace_walker callback
@@ -138,6 +143,15 @@ static inline const char* rb_builtin_type(VALUE obj){
 #define true 1
 #define false 0
 
+static void yg_funcaddr_real(walk_ctx_t* ctx, void* addr){
+  Dl_info info;
+  if(dladdr(addr, &info) && info.dli_sname){
+    yg_cstring(info.dli_sname);
+  } else {
+    yg_cstring("(unknown)");
+  }
+}
+
 //FIXME: handle non-ids?
 static void yg_id1(VALUE obj, walk_ctx_t* ctx){
   if(!obj) {
@@ -145,23 +159,17 @@ static void yg_id1(VALUE obj, walk_ctx_t* ctx){
     return;
   }
   if (IMMEDIATE_P(obj)) {
-    //printf("immediate\n");
-    if (FIXNUM_P(obj)) { /*ignore immediate fixnum*/
-      //fixme: output some readable info
-      //yajl_gen_null(ctx->yajl);
+    if (FIXNUM_P(obj)) {
       yg_int(FIX2LONG(obj));
       return;
     }
     if (obj == Qtrue){ yajl_gen_bool(ctx->yajl, true); return; }
     if (SYMBOL_P(obj)) {
-      //printf("symbol\n");
       yg_cstring(rb_id2name(SYM2ID(obj)));
-      //printf("symbol %s\n", rb_id2name(SYM2ID(obj)));
       return;
     }
     if (obj == Qundef) { yg_cstring("(undef)"); return; }
 
-    printf("immediate p %p?\n", (void*)obj);
     yg_cstring("(unknown)");
     return;
   } else /*non-immediate*/ {
@@ -174,26 +182,11 @@ static void yg_id1(VALUE obj, walk_ctx_t* ctx){
         yajl_gen_bool(ctx->yajl, false);
         return;
       }
-      //printf("non r-test\n");
     }
   }
 
-  //25116(0x621c aka 0b110001000011100), 28(0x) - wtf?
-  //28 = 0x1c
-  //1c= TNODE? or other flags combination
-
-  //also 30(x1e) ? - some internal symbols?
-
-  // if((obj & ~(~(VALUE)0 << RUBY_SPECIAL_SHIFT)) == 0x1c){
-  //   printf("!!!!! special shift flags is 0x1c: %p\n", obj);
-  //   yg_cstring("(unknown or internal 1c)");
-  //   return;
-  // }
-
   if(BUILTIN_TYPE(obj) == T_STRING && (!(RBASIC(obj)->flags & RSTRING_NOEMBED))){
-    //printf("embedded string\n");
-    //yajl_gen_null(ctx->yajl);
-
+    //embedded string
     if(rb_enc_get_index(obj) == rb_usascii_encindex())
       yg_rstring(obj);
     else{
@@ -319,14 +312,14 @@ static void dump_node_refs(NODE* obj, walk_ctx_t* ctx){
       return; //goto again;
 
     case NODE_SCOPE:  /* 2,3 */ //ANN("format: [nd_tbl]: local table, [nd_args]: arguments, [nd_body]: body");
-      //printf("node scope\n");
+      //actually this is not present in live ruby 1.9+
       if(obj->nd_tbl){
         ID *tbl = RNODE(obj)->nd_tbl;
         unsigned long i = 0, size = tbl[0];
         tbl++;
         for (; i < size; i++) {
           //TODO: dump local var names?
-          //printf("%s\n", rb_id2name(tbl[i]));
+          // rb_id2name(tbl[i])...
           //yg_id(tbl[i]); //FIXME: these are ids, not values
         }
       }
@@ -399,7 +392,6 @@ static void dump_node_refs(NODE* obj, walk_ctx_t* ctx){
 
     case NODE_MEMO:
       yg_id((VALUE)obj->u1.node);
-      //printf("MEMO NODE: %p %p %p\n", obj->u1.node, obj->u2.node, obj->u3.node);
       break;
 
     //not implemented:
@@ -416,14 +408,15 @@ static void dump_node_refs(NODE* obj, walk_ctx_t* ctx){
 
     //iteration func - blocks,procs,lambdas etc:
     case NODE_IFUNC: //NEN_CFNC, NEN_TVAL, NEN_STATE? / u2 seems to be data for func(context?)
-      //printf("IFUNC NODE: %p %p %p\n", obj->nd_cfnc, obj->u2.node, (void*)obj->nd_aid /*u3 - aid id- - aka frame_this_func?*/);
+      {
+        //find in symbol table, if present:
+        yg_funcaddr(obj->nd_cfnc);
+      }
       if(is_in_heap(obj->u2.node, 0)){
-        //printf("in heap: %p\n", obj->u2.node);
         //TODO: do we need to dump it inline?
         yg_id((VALUE)obj->u2.node);
       }
       if(is_in_heap( (void*)obj->nd_aid, 0)){
-        //printf("in heap: %p\n", (void*)obj->nd_aid);
         yg_id(obj->nd_aid);
       }
       break;
@@ -432,11 +425,7 @@ static void dump_node_refs(NODE* obj, walk_ctx_t* ctx){
     case NODE_BEGIN: break;
     default:    /* unlisted NODE */
       //FIXME: check pointers!
-
-      {
-      printf("UNKNOWN NODE TYPE %d(%s): %p %p %p\n", nd_type(obj), node_type_name(obj), (void*)obj->u1.node, (void*)obj->u2.node, (void*)obj->u3.node);
-      }
-
+      {}
       // if (is_in_heap(obj->as.node.u1.node, objspace)) { gc_mark(objspace, (VALUE)obj->as.node.u1.node, lev); }
       // if (is_in_heap(obj->as.node.u2.node, objspace)) { gc_mark(objspace, (VALUE)obj->as.node.u2.node, lev); }
       // if (is_in_heap(obj->as.node.u3.node, objspace)) { gc_mark(objspace, (VALUE)obj->as.node.u3.node, lev); }
@@ -459,11 +448,6 @@ static inline void dump_node(NODE* obj, walk_ctx_t *ctx){
 
 static int
 dump_keyvalue(st_data_t key, st_data_t value, walk_ctx_t *ctx){
-    if ((VALUE)key == Qundef){
-      printf("undef key!\n");
-      // return ST_CONTINUE;
-    }
-
     if(!key || (VALUE)key == Qnil){
       yg_cstring("___null_key___"); //TODO: just ""?
     } else {
@@ -477,7 +461,7 @@ dump_keyvalue(st_data_t key, st_data_t value, walk_ctx_t *ctx){
           buf[sizeof(buf)-1] = 0;
           switch(type){
             case T_FIXNUM:
-              snprintf(buf, sizeof(buf)-1, "%d", FIX2INT(key));
+              snprintf(buf, sizeof(buf)-1, "%ld", FIX2LONG(key));
               break;
             case T_FLOAT:
               snprintf(buf, sizeof(buf)-1, "%lg", NUM2DBL(key));
@@ -508,22 +492,17 @@ static void dump_method_definition_as_value(const rb_method_definition_t *def, w
     yajl_gen_null(ctx->yajl);
     return;
   }
-  //printf("mdef %d\n", def->type);
 
   switch (def->type) {
     case VM_METHOD_TYPE_ISEQ:
-      //printf("method iseq %p\n", def->body.iseq);
-      //printf("self %p\n", def->body.iseq->self);
       yg_id(def->body.iseq->self);
       break;
     case VM_METHOD_TYPE_CFUNC: yg_cstring("(CFUNC)"); break;
     case VM_METHOD_TYPE_ATTRSET:
     case VM_METHOD_TYPE_IVAR:
-      //printf("method ivar\n");
       yg_id(def->body.attr.location);
       break;
     case VM_METHOD_TYPE_BMETHOD:
-      //printf("method binary\n");
       yg_id(def->body.proc);
       break;
     case VM_METHOD_TYPE_ZSUPER: yg_cstring("(ZSUPER)"); break;
@@ -546,7 +525,6 @@ static int dump_method_entry_i(ID key, const rb_method_entry_t *me, st_data_t da
   }
 
   //gc_mark(objspace, me->klass, lev);?
-  //printf("method entry\n");
   dump_method_definition_as_value(me->def, ctx);
   return ST_CONTINUE;
 }
@@ -556,24 +534,16 @@ static int dump_iv_entry(ID key, VALUE value, walk_ctx_t *ctx){
   if(key_str)
     yg_cstring(key_str);
   else{
-    // printf("Null key! %d\n", key);
+    // cannot use yg_null() - keys must be strings
+    //TODO: just ""?
     yg_cstring("___null_key___");
-    //yg_null();
   }
   yg_id(value);
   return ST_CONTINUE;
 }
 
 static int dump_const_entry_i(ID key, const rb_const_entry_t *ce, walk_ctx_t *ctx){
-
-//was(ID key, VALUE value, walk_ctx_t *ctx){
-
-  printf("const entry\n");
-
   VALUE value = ce->value;
-  //file = ce->file
-
-  printf("const key %p\n", (void*)key);
   yg_cstring(rb_id2name(key));
   yg_id(value);
   return ST_CONTINUE;
@@ -591,14 +561,13 @@ static const char* iseq_type(VALUE type){
     case ISEQ_TYPE_MAIN:   return "main";
     case ISEQ_TYPE_DEFINED_GUARD: return "defined_guard";
   }
-  printf("unknown iseq type %p!\n", (void*)type);
-  return "unknown";
+  return "unknown_iseq";
 }
 
 static void dump_iseq(const rb_iseq_t* iseq, walk_ctx_t *ctx){
   if(iseq->name) ygh_rstring("name", iseq->name);
   if(iseq->filename) ygh_rstring("filename", iseq->filename);
-  ygh_int("line", FIX2INT(iseq->line_no));
+  ygh_int("line", FIX2LONG(iseq->line_no));
 
   //if(iseq->type != 25116) //also 28 in mark_ary
   ygh_cstring("type", iseq_type(iseq->type));
@@ -626,6 +595,21 @@ static void dump_iseq(const rb_iseq_t* iseq, walk_ctx_t *ctx){
     ygh_id("cd_err_info", compile_data->err_info);
     ygh_id("cd_catch_table_ary", compile_data->catch_table_ary);
   }
+
+  if(iseq->local_table_size > 0){
+    yg_cstring("local_table");
+    yg_array();
+    int i;
+    for(i = 0; i < iseq->local_table_size; i++){
+      char* name = rb_id2name(iseq->local_table[i]);
+      if(name){
+        yg_cstring(name);
+      } else {
+        yg_cstring("(unnamed)");
+      }
+    }
+    yg_array_end();
+  }
 }
 
 static void dump_block(const rb_block_t* block, walk_ctx_t *ctx){
@@ -758,26 +742,20 @@ static void dump_data_if_known(VALUE obj, walk_ctx_t *ctx){
   }
 
   if(!strcmp("method", typename)){
-    //printf("method\n");
     struct METHOD *data = RTYPEDDATA_DATA(obj);
-    //printf("method %p: %p %p\n", data, data->rclass, data->recv);
     ygh_id("rclass", data->rclass);
     ygh_id("recv", data->recv);
     ygh_int("method_id", data->id);
 
     yg_cstring("method");
     if(METHOD_DEFINITIONP(data)){
-      //printf("methof def %p\n", &data->me);
       dump_method_definition_as_value(METHOD_DEFINITIONP(data), ctx);
-      //printf("meth end\n");
     }
     return;
   }
 
   if(!strcmp("binding", typename)){
-    //printf("binding\n");
     rb_binding_t *bind = RTYPEDDATA_DATA(obj);
-    //printf("binding %p\n", bind);
     if(!bind) return;
     ygh_id("env", bind->env);
     ygh_id("filename", bind->filename);
@@ -929,9 +907,9 @@ static void dump_data_if_known(VALUE obj, walk_ctx_t *ctx){
 
 static VALUE rb_class_real_checked(VALUE cl)
 {
-    if (cl == 0)
+    if (cl == 0 || IMMEDIATE_P(cl))
         return 0;
-    while ((RBASIC(cl)->flags & FL_SINGLETON) || BUILTIN_TYPE(cl) == T_ICLASS) {
+    while (cl && ((RBASIC(cl)->flags & FL_SINGLETON) || BUILTIN_TYPE(cl) == T_ICLASS)) {
       if(RCLASS_EXT(cl) && RCLASS_SUPER(cl)){
         cl = RCLASS_SUPER(cl);
       } else {
@@ -1084,14 +1062,13 @@ static inline void walk_live_object(VALUE obj, walk_ctx_t *ctx){
           yajl_gen_map_close(ctx->yajl);
         }
 
-        #if 0
+        #ifdef HAVE_CONSTANT_H
         // this is for 1.9.3 or so - where rb_classext_t has const_tbl
         if(RCLASS_CONST_TBL(obj)){
           yg_cstring("consts");
-          yajl_gen_map_open(ctx->yajl);
-          flush_yajl(ctx); //for debug only
+          yg_map();
           st_foreach(RCLASS_CONST_TBL(obj), dump_const_entry_i, (st_data_t)ctx);
-          yajl_gen_map_close(ctx->yajl);
+          yg_map_end();
         }
         #endif
 
@@ -1115,7 +1092,7 @@ static inline void walk_live_object(VALUE obj, walk_ctx_t *ctx){
       break;
 
     case T_FIXNUM:
-      ygh_int("val", NUM2LONG(obj));
+      ygh_int("val", FIX2LONG(obj));
       break;
     case T_FLOAT:
       ygh_double("val", RFLOAT_VALUE(obj));
@@ -1271,7 +1248,7 @@ static inline int is_in_heap(void *ptr, void* osp){
 
 
 static int
-dump_backtrace(void* data, VALUE file, int line, VALUE method)
+dump_backtrace(void* data, VALUE file, int line, VALUE method, int argc, VALUE* argv)
 {
     walk_ctx_t *ctx = data;
     yg_map();
@@ -1287,54 +1264,76 @@ dump_backtrace(void* data, VALUE file, int line, VALUE method)
       //fprintf(fp, "\tfrom %s:%d:in `%s'\n", filename, line, RSTRING_PTR(method));
       ygh_rstring("method", method);
     }
+    ygh_int("argc", argc);
+    if(argc > 0){
+      yg_cstring("argv");
+      yg_array();
+      int i;
+      for(i = 0; i < argc; i++)
+        yg_id(argv[i]);
+      yg_array_end();
+    }
     yg_map_end();
     return FALSE;
 }
 
-//TODO: autogen, this func is just copied from vm.c
-//typedef int rb_backtrace_iter_func(void *, VALUE, int, VALUE);
+typedef int (rb_backtrace_iter_ext_func)(void *arg, VALUE file, int line, VALUE method_name, int argc, VALUE* argv);
+
+// copied from ruby_ext_backtrace
 static int
-vm_backtrace_each(const rb_thread_t *th, int lev, void (*init)(void *), rb_backtrace_iter_func *iter, void *arg)
+vm_backtrace_each_ext(rb_thread_t *th, int lev, void (*init)(void *), rb_backtrace_iter_ext_func *iter, void *arg)
 {
-    const rb_control_frame_t *limit_cfp = th->cfp;
-    const rb_control_frame_t *cfp = (void *)(th->stack + th->stack_size);
-    VALUE file = Qnil;
-    int line_no = 0;
-
-    cfp -= 2;
-    while (lev-- >= 0) {
-  if (++limit_cfp > cfp) {
-      return FALSE;
+  const rb_control_frame_t *limit_cfp = th->cfp;
+  const rb_control_frame_t *cfp = (void *)(th->stack + th->stack_size);
+  VALUE file = Qnil;
+  int line_no = 0;
+
+  cfp -= 2;
+  //skip lev frames:
+  while (lev-- >= 0) {
+    if (++limit_cfp > cfp)
+        return FALSE;
   }
-    }
-    if (init) (*init)(arg);
-    limit_cfp = RUBY_VM_NEXT_CONTROL_FRAME(limit_cfp);
-    if (th->vm->progname) file = th->vm->progname;
-    while (cfp > limit_cfp) {
-  if (cfp->iseq != 0) {
-      if (cfp->pc != 0) {
-    rb_iseq_t *iseq = cfp->iseq;
-
-    line_no = rb_vm_get_sourceline(cfp);
-    file = iseq->filename;
-    if ((*iter)(arg, file, line_no, iseq->name)) break;
-      }
-  }
-  else if (RUBYVM_CFUNC_FRAME_P(cfp)) {
-      ID id;
-      
 
-      if (NIL_P(file)) file = ruby_engine_name;
-      if (cfp->me->def)
-    id = cfp->me->def->original_id;
-      else
-    id = cfp->me->called_id;
-      if (id != ID_ALLOCATOR && (*iter)(arg, file, line_no, rb_id2str(id)))
-    break;
+  if (init) (*init)(arg);
+
+  limit_cfp = RUBY_VM_NEXT_CONTROL_FRAME(limit_cfp);
+  if (th->vm->progname) file = th->vm->progname;
+
+  while (cfp > limit_cfp) {
+    if (cfp->iseq != 0) {
+        if (cfp->pc != 0) {
+          rb_iseq_t *iseq = cfp->iseq;
+
+          line_no = rb_vm_get_sourceline(cfp);
+          file = iseq->filename;
+
+          //arguments pushed this way: *reg_cfp->sp++ = recv; for (i = 0; i < argc; i++) *reg_cfp->sp++ = argv[i];
+          //local vars = cfp->iseq->local_size - cfp->iseq->arg_size;
+          //in memory: receiver params locals (bp(incremented))
+          VALUE* argv = &cfp->bp[- cfp->iseq->local_size - 1];
+          if ((*iter)(arg, file, line_no, iseq->name, cfp->iseq->arg_size, argv)) break;
+        }
+    } else
+      if (RUBYVM_CFUNC_FRAME_P(cfp)) {
+        ID id = cfp->me->def? cfp->me->def->original_id : cfp->me->called_id;
+
+        if (NIL_P(file)) file = ruby_engine_name;
+
+        if (id != ID_ALLOCATOR){
+          VALUE* argv = NULL;
+          // when argc==-1/-2(variable length params without/with splat) - the cfp has no info on params count :(
+          //TODO: infere from somewhere ex. find self in stack? (not guaranted btw, for example: obj.method(obj, 123, obj) - will find last param instead of self)
+          if(cfp->me->def->body.cfunc.argc >= 0){ //only fixed args
+            argv = &cfp->bp[- cfp->me->def->body.cfunc.argc - 2]; // args+self, bp was incremented thus minus 2
+          }
+          //file+line no from previous iseq frame
+          if((*iter)(arg, file, line_no, rb_id2str(id), cfp->me->def->body.cfunc.argc, argv)) break;
+        }
+      }
+    cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp);
   }
-  cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp);
-    }
-    return TRUE;
+  return TRUE;
 }
 
 static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
@@ -1355,6 +1354,7 @@ static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
 
     yg_cstring("cfp");
     yajl_gen_array_open(ctx->yajl);
+    //TODO: this is kind of backtrace, but other direction plus some other info, merge it in backtrace.
     while (cfp != limit_cfp) {
       yajl_gen_map_open(ctx->yajl);
       rb_iseq_t *iseq = cfp->iseq;
@@ -1395,7 +1395,7 @@ static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
 
   yg_cstring("backtrace");
   yg_array();
-  vm_backtrace_each(th, -1, NULL, dump_backtrace, ctx);
+  vm_backtrace_each_ext(th, -1, NULL, dump_backtrace, ctx);
   yg_array_end();
 
   //TODO: mark other...
@@ -1472,7 +1472,6 @@ static void dump_machine_context(walk_ctx_t *ctx){
   //mark_locations_array(objspace, save_regs_gc_mark.v, numberof(save_regs_gc_mark.v));
   VALUE* x = save_regs_gc_mark.v;
   unsigned long n = numberof(save_regs_gc_mark.v);
-  //printf("registers\n");
   while (n--) {
     VALUE v = *(x++);
     if(is_in_heap((void*)v, NULL))
@@ -1480,7 +1479,6 @@ static void dump_machine_context(walk_ctx_t *ctx){
   }
   yajl_gen_array_close(ctx->yajl);
 
-  //printf("stack: %p %p\n", stack_start, stack_end);
   yg_cstring("stack");
   yajl_gen_array_open(ctx->yajl);
   //rb_gc_mark_locations(stack_start, stack_end);
@@ -1489,10 +1487,8 @@ static void dump_machine_context(walk_ctx_t *ctx){
     x = stack_start;
     while (n--) {
       VALUE v = *(x++);
-      //printf("val: %p\n", (void*)v);
       //FIXME: other objspace (not default one?)
       if(is_in_heap((void*)v, NULL)) {
-        //printf("ON heap\n");
         yg_id(v);
       }
     }
@@ -1501,39 +1497,73 @@ static void dump_machine_context(walk_ctx_t *ctx){
   yajl_gen_array_close(ctx->yajl);
 }
 
-static int dump_iv_entry1(ID key, rb_const_entry_t* ce/*st_data_t val*/, walk_ctx_t *ctx){
+#ifdef HAVE_RB_CLASS_TBL
+// 1.9.2, rb_class_tbl fails to be linked in 1.9.3 :(
+
+static int dump_class_tbl_entry(ID key, rb_const_entry_t* ce/*st_data_t val*/, walk_ctx_t *ctx){
   if (!rb_is_const_id(key)) return ST_CONTINUE; //?
-  //rb_const_entry_t* ce = val;
   VALUE value = ce->value;
 
-  //printf("cls %p\n", (void*)value);
-  //printf("id: %s\n", rb_id2name(key));
+  char* id = rb_id2name(key);
+  if(id)
+    yg_cstring(id);
+  else
+    yg_cstring("(unknown)");
+  yg_id(value);
+  return ST_CONTINUE;
+}
+#endif
 
-  //val - damaged in some way?
+#ifdef HAVE_RB_GLOBAL_TBL
+static int dump_global_tbl_entry(ID key, struct rb_global_entry* ge/*st_data_t val*/, walk_ctx_t *ctx){
+  char* id = rb_id2name(key);
+  if(id)
+    yg_cstring(id);
+  else
+    yg_cstring("(unknown)");
 
-  //printf("name %s\n", RSTRING_PTR(rb_class_path(rb_class_real_checked(value))));
+  yg_map();
 
-  //if(is_in_heap(value, NULL)){
-    //printf("on heap\n");
-    yg_id(value);
-  //}
+  Dl_info info;
+  if(dladdr(ge->var->getter, &info) && info.dli_sname){
+    yg_cstring("getter");
+    yg_cstring(info.dli_sname);
 
+    if(!strcmp("rb_gvar_val_getter", info.dli_sname)){
+    yg_cstring("data");
+    yg_id(ge->var->data);
+    }
+  }
+
+  yg_cstring("setter");
+  yg_funcaddr(ge->var->setter);
+
+  yg_map_end();
   return ST_CONTINUE;
 }
+#endif
 
-// static void try_dump_generic_ivars(walk_ctx_t* ctx){
-//   //very nasty hack:
-//   #if defined(__x86_64__) && defined(__GNUC__) && !defined(__native_client__)
-//   printf("Trying generic ivars\n");
-//   //TODO: config to turn this off in case this will not work
 
-//   VALUE stack_end1, stack_end2;
-//   rb_gc_set_stack_end(&stack_end1);
-//   st_table* tbl = rb_generic_ivar_table();
-//   rb_gc_set_stack_end(&stack_end2);
+#include <stdarg.h>
+static bool g_verbose = false;
+static int log_printf(const char* format, ...){
+  va_list list;
+  va_start(list, format);
+  if(g_verbose)
+    vprintf(format, list);
+  va_end(list);
+}
+
+#define log log_printf
+
+static VALUE heapdump_verbose(VALUE self){
+  return g_verbose ? Qtrue : Qfalse;
+}
 
-//   #endif
-// }
+static VALUE heapdump_verbose_setter(VALUE self, VALUE verbose){
+  g_verbose = RTEST(verbose);
+  return heapdump_verbose(self);
+}
 
 
 //public symbol, can be used from GDB
@@ -1544,7 +1574,7 @@ void heapdump_dump(const char* filename){
   if(!filename){
     filename = "dump.json";
   }
-  printf("Dump should go to %s\n", filename);
+  log("Dump should go to %s\n", filename);
   ctx->file = fopen(filename, "wt");
   ctx->yajl = yajl_gen_alloc(NULL,NULL);
   yajl_gen_array_open(ctx->yajl);
@@ -1553,7 +1583,7 @@ void heapdump_dump(const char* filename){
   yajl_gen_map_open(ctx->yajl);
   ygh_cstring("id", "_ROOTS_");
 
-  printf("machine context\n");
+  log("machine context\n");
 
   dump_machine_context(ctx);
   flush_yajl(ctx);
@@ -1561,24 +1591,39 @@ void heapdump_dump(const char* filename){
 
   struct gc_list *list;
   /* mark protected global variables */
-  printf("global_List\n");
+  log("global_list\n");
+  yg_cstring("globals");
+  yg_array();
   for (list = GET_THREAD()->vm->global_List; list; list = list->next) {
     VALUE v = *list->varptr;
-    //printf("global %p\n", v);
+    yg_id(v);
   }
+  yg_array_end();
 
-#ifdef HAVE_RB_CLASS_TBL
-  yg_cstring("classes");
-  yajl_gen_array_open(ctx->yajl);
-  printf("classes\n");
-  if (rb_class_tbl && rb_class_tbl->num_entries > 0)
-    st_foreach(rb_class_tbl, dump_iv_entry1, (st_data_t)ctx);
-  else printf("no classes\n");
-  yajl_gen_array_close(ctx->yajl);
-  flush_yajl(ctx);
+  //TODO: rb_global_tbl
+#ifdef HAVE_RB_GLOBAL_TBL
+  st_table *rb_global_tbl = rb_get_global_tbl();
+  if (rb_global_tbl && rb_global_tbl->num_entries > 0){
+    log("globals\n");
+    yg_cstring("global_tbl");
+    yg_map();
+    st_foreach(rb_global_tbl, dump_global_tbl_entry, (st_data_t)ctx);
+    yg_map_end();
+    flush_yajl(ctx);
+  }
 #endif
 
-  //try_dump_generic_ivars();
+#ifdef HAVE_RB_CLASS_TBL
+  st_table *rb_class_tbl = rb_get_class_tbl();
+  if (rb_class_tbl && rb_class_tbl->num_entries > 0){
+    log("classes\n");
+    yg_cstring("classes");
+    yg_map();
+    st_foreach(rb_class_tbl, dump_class_tbl_entry, (st_data_t)ctx);
+    yg_map_end();
+    flush_yajl(ctx);
+  }
+#endif
 
   //TODO: other gc entry points - symbols, encodings, etc.
 
@@ -1587,7 +1632,7 @@ void heapdump_dump(const char* filename){
   fprintf(ctx->file, "\n");
 
   //now dump all live objects
-  printf("starting objspace walk\n");
+  log("starting objspace walk\n");
   rb_objspace_each_objects(objspace_walker, ctx);
 
   yajl_gen_array_close(ctx->yajl);
@@ -1595,7 +1640,7 @@ void heapdump_dump(const char* filename){
   yajl_gen_free(ctx->yajl);
   fclose(ctx->file);
 
-  printf("Walker called %d times, seen %d live objects.\n", ctx->walker_called, ctx->live_objects);
+  log("Walker called %d times, seen %d live objects.\n", ctx->walker_called, ctx->live_objects);
 }
 
 static VALUE
@@ -1606,6 +1651,113 @@ rb_heapdump_dump(VALUE self, VALUE filename)
   return Qnil;
 }
 
+
+
+// HeapDump.count_objects:
+
+#undef YAJL
+#define YAJL yajl
+static int
+iterate_user_type_counts(VALUE key, VALUE value, yajl_gen yajl){
+  yg_rstring(key);
+  yg_int(FIX2LONG(value));
+  return ST_CONTINUE;
+}
+
+static VALUE
+rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
+  rb_check_array_type(string_prefixes);
+  yajl_gen_config cfg;
+  memset(&cfg, 0, sizeof(cfg));
+  cfg.beautify = true;
+  cfg.htmlSafe = true;
+  cfg.indentString = "    ";
+  yajl_gen yajl = yajl_gen_alloc(&cfg,NULL);
+  yg_map();
+  if(do_gc){
+    yg_cstring("gc_ran");
+    yg_bool(true);
+    rb_gc_start();
+  }
+
+  rb_objspace_t *objspace = GET_THREAD()->vm->objspace;
+  size_t counts[T_MASK+1];
+  size_t freed = 0;
+  size_t total = 0;
+  size_t i;
+  VALUE hash = rb_hash_new();
+
+  for (i = 0; i <= T_MASK; i++) counts[i] = 0;
+
+  FOR_EACH_HEAP_SLOT(p)
+    // danger: allocates memory while walking heap
+    if (p->as.basic.flags) {
+      int type = BUILTIN_TYPE(p);
+      counts[type]++;
+      if(type == T_OBJECT){
+        //take class etc.
+        VALUE cls = rb_class_real_checked(CLASS_OF(p));
+        if(!cls) continue;
+        VALUE class_name = rb_class_path(cls);
+        long int n = RARRAY_LEN(string_prefixes)-1;
+        for(; n >= 0; n--){
+          VALUE prefix = rb_check_string_type(RARRAY_PTR(string_prefixes)[n]);
+          if(NIL_P(prefix)) continue;
+          rb_enc_check(class_name, prefix);
+          if (RSTRING_LEN(class_name) < RSTRING_LEN(prefix)) continue;
+          if (!memcmp(RSTRING_PTR(class_name), RSTRING_PTR(prefix), RSTRING_LEN(prefix)))
+            if(RSTRING_LEN(class_name) == RSTRING_LEN(prefix) ||
+              RSTRING_PTR(class_name)[RSTRING_LEN(prefix)] == ':'){
+              //class match
+              VALUE val = rb_hash_aref(hash, class_name);
+              long num;
+              if(FIXNUM_P(val)){
+                num = FIX2LONG(val) + 1;
+              } else {
+                num = 1;
+              }
+              rb_hash_aset(hash, class_name, LONG2FIX(num));
+            }
+        }
+      }
+    } else {
+      freed++;
+    }
+  FOR_EACH_HEAP_SLOT_END(total)
+
+  ygh_int("total_slots", total);
+  ygh_int("free_slots", freed);
+  yg_cstring("basic_types");
+  yg_map();
+  for (i = 0; i <= T_MASK; i++) {
+    if(!counts[i]) continue;
+    yg_cstring(rb_type_str((int)i));
+    yg_int(counts[i]);
+  }
+  yg_map_end();
+
+  yg_cstring("user_types");
+  yg_map();
+  rb_hash_foreach(hash, iterate_user_type_counts, (VALUE)yajl);
+  yg_map_end();
+
+  yg_map_end(); //all document
+
+  //flush yajl:
+  const unsigned char* buf;
+  unsigned int len;
+  if(yajl_gen_get_buf(yajl, &buf, &len) == yajl_gen_status_ok){
+    //fwrite(buf, len, 1, ctx->file);
+    VALUE res = rb_str_new(buf, len);
+    yajl_gen_clear(yajl);
+    yajl_gen_free(yajl);
+    return res;
+  } else {
+    return Qnil;
+  }
+#undef YAJL
+}
+
 void Init_heap_dump(){
   //ruby-internal need to be required before linking us, but just in case..
   ID require, gem;
@@ -1619,4 +1771,9 @@ 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, "verbose", heapdump_verbose, 0);
+  rb_define_singleton_method(rb_mHeapDumpModule, "verbose=", heapdump_verbose_setter, 1);
+
 }

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

@@ -67,11 +67,7 @@ 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;
+    int finalize_flag;
 };
 
 struct heaps_header {
@@ -79,16 +75,6 @@ struct heaps_header {
     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;
@@ -189,4 +175,10 @@ is_pointer_to_heap(rb_objspace_t *objspace, void *ptr)
     }
       }
     return FALSE;
-}
+}
+
+#define FOR_EACH_HEAP_SLOT(p) for (i = 0; i < heaps_used; i++) {\
+      RVALUE *p = heaps[i].slot; RVALUE *pend = p + heaps[i].limit;\
+      if(!p || p < heaps[i].membase) continue;\
+      for (; p < pend; p++) {
+#define FOR_EACH_HEAP_SLOT_END(total) } total += heaps[i].limit; }

data/ext/heap_dump/specific/ruby-1.9.2/internal_typed_data.h

@@ -39,7 +39,39 @@ struct METHOD {
 #define METHOD_DEFINITIONP(m) m->me.def
 
 #define HAVE_RB_CLASS_TBL 1
-//class.c:
-extern st_table *rb_class_tbl;
+
+inline st_table * rb_get_class_tbl(){
+  //class.c:
+  extern st_table *rb_class_tbl;
+  return rb_class_tbl;
+}
+
+#define HAVE_RB_GLOBAL_TBL 1
+inline st_table * rb_get_global_tbl(){
+  //class.c:
+  extern st_table *rb_global_tbl;
+  return rb_global_tbl;
+}
+#define gvar_getter_t rb_gvar_getter_t
+#define gvar_setter_t rb_gvar_setter_t
+#define gvar_marker_t rb_gvar_marker_t
+
+struct trace_var {
+    int removed;
+    void (*func)(VALUE arg, VALUE val);
+    VALUE data;
+    struct trace_var *next;
+};
+
+//struct global_variable {
+struct rb_global_variable {
+    int   counter;
+    void *data;
+    gvar_getter_t *getter;
+    gvar_setter_t *setter;
+    gvar_marker_t *marker;
+    int block_trace;
+    struct trace_var *trace;
+};
 
 extern VALUE ruby_engine_name;

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

@@ -189,3 +189,10 @@ is_pointer_to_heap(rb_objspace_t *objspace, void *ptr)
     }
     return FALSE;
 }
+
+#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; }
+

data/ext/heap_dump/specific/ruby-1.9.3/internal_typed_data.h

@@ -41,9 +41,39 @@ struct METHOD {
 #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 on 1.9.3 :(
-// extern st_table *rb_class_tbl;
+#define HAVE_RB_CLASS_TBL 1
+//For som reason this fails to link directly on 1.9.3 :(
+
+//HACK:
+// otool -L `which ruby`
+// /Users/vasfed/.rvm/rubies/ruby-1.9.3-p194/bin/ruby:
+//   @executable_path/../lib/libruby.1.9.1.dylib (compatibility version 1.9.1, current version 1.9.1)
+// nm ~/.rvm/rubies/ruby-1.9.3-p194/lib/libruby.1.9.1.dylib | grep rb_class_tbl
+// 000000000024be28 s _rb_class_tbl
+// 00000000000b311c T _rb_intern
+// 000000000024bd38 S _rb_mKernel
+
+#include <dlfcn.h>
+
+inline st_table * rb_get_class_tbl(){
+  Dl_info info;
+  if(!dladdr(rb_intern, &info) || !info.dli_fname){
+    return NULL;
+  }
+  void* 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()))
 

data/lib/heap_dump/version.rb

@@ -1,3 +1,3 @@
 module HeapDump
-  VERSION = "0.0.28"
+  VERSION = "0.0.29"
 end

data/lib/heap_dump.rb

@@ -9,4 +9,18 @@ module HeapDump
     GC.start if gc_before_dump
     return dump_ext(filename)
   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]
+      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")
+      end
+    end
+    prefixes_array = namespaces_array.map{|c| c.to_s}
+    return count_objects_ext(prefixes_array, !!gc)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heap_dump
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.0.29
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-12 00:00:00.000000000 Z
+date: 2012-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debugger-ruby_core_source
@@ -105,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3488312299511292318
+      hash: -3423213544880593547
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24