heap_dump 0.0.1 → 0.0.2

data/ext/heap_dump/heap_dump.c

@@ -6,6 +6,8 @@
 #include "yarv-headers/constant.h"
 #include "yarv-headers/node.h"
 #include "yarv-headers/vm_core.h"
+#include "yarv-headers/atomic.h"
+#include "yarv-headers/iseq.h"
 
 //#undef RCLASS_IV_TBL
 //#include "yarv-headers/internal.h"
@@ -36,7 +38,7 @@ static ID classid;
 #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)
+#define yg_double(d) (yajl_gen_double(ctx->yajl, d)==yajl_gen_invalid_number? yg_cstring("inf|NaN") : true)
 
 //#define yg_id(obj) yg_int(NUM2LONG(rb_obj_id(obj)))
 #define yg_id(obj) yg_id1(obj,ctx)
@@ -92,9 +94,16 @@ static inline const char* rb_builtin_type(VALUE obj){
 
 //FIXME: handle non-ids?
 static void yg_id1(VALUE obj, walk_ctx_t* ctx){
-  if(!obj) return;
+  if(!obj) {
+    yajl_gen_null(ctx->yajl);
+    return;
+  }
   if (IMMEDIATE_P(obj)) {
-    if (FIXNUM_P(obj)) { /*ignore immediate fixnum*/ return; }
+    //printf("immediate\n");
+    if (FIXNUM_P(obj)) { /*ignore immediate fixnum*/
+      //fixme: output some readable info
+      yajl_gen_null(ctx->yajl);
+      return; }
     if (obj == Qtrue){ yajl_gen_bool(ctx->yajl, true); return; }
     if (SYMBOL_P(obj)) {
       //printf("symbol\n");
@@ -103,22 +112,43 @@ static void yg_id1(VALUE obj, walk_ctx_t* ctx){
       return;
     }
     if (obj == Qundef) { yg_cstring("(undef)"); return; }
-    printf("immediate p\n");
-  } else /*non-immediate*/ if (!RTEST(obj)) {
-    if (obj == Qnil){
-      yajl_gen_null(ctx->yajl);
-      return;
-    }
-    if (obj == Qfalse) {
-      yajl_gen_bool(ctx->yajl, false);
-      return;
+
+    printf("immediate p %p?\n", obj);
+    yg_cstring("(unknown)");
+    return;
+  } else /*non-immediate*/ {
+    if (!RTEST(obj)) {
+      if (obj == Qnil){
+        yajl_gen_null(ctx->yajl);
+        return;
+      }
+      if (obj == Qfalse) {
+        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);
+    yg_rstring(obj);
     return;
   }
+
   yg_int(NUM2LONG(rb_obj_id(obj)));
 }
 
@@ -217,9 +247,8 @@ static void dump_node_refs(NODE* obj, walk_ctx_t* ctx){
       //printf("node scope\n");
       if(obj->nd_tbl){
         ID *tbl = RNODE(obj)->nd_tbl;
-        int size = tbl[0];
+        unsigned long i = 0, size = tbl[0];
         tbl++;
-        int i = 0;
         for (; i < size; i++) {
           //TODO: dump local var names?
           //printf("%s\n", rb_id2name(tbl[i]));
@@ -312,7 +341,7 @@ 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, obj->nd_aid /*u3 - aid id- - aka frame_this_func?*/);
+     // printf("IFUNC NODE: %p %p %p\n", obj->nd_cfnc, obj->u2.node, (void*)obj->nd_aid /*u3 - aid id- - aka frame_this_func?*/);
       //FIXME: closures may leak references?
       break;
 
@@ -323,7 +352,7 @@ static void dump_node_refs(NODE* obj, walk_ctx_t* ctx){
 
       {const Node_Type_Descrip* descrip = node_type_descrips[nd_type(obj)];
 
-      printf("UNKNOWN NODE TYPE %d(%s): %p %p %p\n", nd_type(obj), descrip ? descrip->name : "unknown", obj->u1.node, obj->u2.node, obj->u3.node);
+      printf("UNKNOWN NODE TYPE %d(%s): %p %p %p\n", nd_type(obj), descrip ? descrip->name : "unknown", (void*)obj->u1.node, (void*)obj->u2.node, (void*)obj->u3.node);
       }
 
       // if (is_pointer_to_heap(objspace, obj->as.node.u1.node)) { gc_mark(objspace, (VALUE)obj->as.node.u1.node, lev); }
@@ -425,6 +454,106 @@ static int dump_const_entry_i(ID key, const rb_const_entry_t *ce, walk_ctx_t *ct
   return ST_CONTINUE;
 }
 
+const char* iseq_type(VALUE type){
+  switch(type){
+    case ISEQ_TYPE_TOP:    return "top";
+    case ISEQ_TYPE_METHOD: return "method";
+    case ISEQ_TYPE_BLOCK:  return "block";
+    case ISEQ_TYPE_CLASS:  return "class";
+    case ISEQ_TYPE_RESCUE: return "rescue";
+    case ISEQ_TYPE_ENSURE: return "ensure";
+    case ISEQ_TYPE_EVAL:   return "eval";
+    case ISEQ_TYPE_MAIN:   return "main";
+    case ISEQ_TYPE_DEFINED_GUARD: return "defined_guard";
+  }
+  printf("unknown iseq type %d!\n", type);
+  return "unknown";
+}
+
+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", iseq->line_no);
+
+  //if(iseq->type != 25116) //also 28 in mark_ary
+  ygh_cstring("type", iseq_type(iseq->type));
+  //see isec.c: iseq_data_to_ary(rb_iseq_t* )
+
+  //28 is what?
+  ygh_id("refs_array_id", iseq->mark_ary);
+
+
+  ygh_id("coverage", iseq->coverage);
+  ygh_id("klass", iseq->klass);
+  ygh_id("cref_stack", (VALUE)iseq->cref_stack); //NODE*
+
+  //TODO: resolve id into str?
+  ygh_int("defined_method_id", iseq->defined_method_id);
+
+  if (iseq->compile_data != 0) {
+    struct iseq_compile_data *const compile_data = iseq->compile_data;
+    ygh_id("cd_marks_ary", compile_data->mark_ary);
+    ygh_id("cd_err_info", compile_data->err_info);
+    ygh_id("cd_catch_table_ary", compile_data->catch_table_ary);
+  }
+}
+
+void dump_data_if_known(VALUE obj, walk_ctx_t *ctx){
+
+  // VM
+  // VM/env
+  // VM/thread
+  // autoload
+  // binding
+  // encoding
+  // iseq <-
+  // method <-
+  // mutex
+  // proc <-
+  // thgroup
+  // time
+
+  const char* typename = RTYPEDDATA_TYPE(obj)->wrap_struct_name;
+
+  if(!strcmp("iseq", typename)){
+    const rb_iseq_t* iseq = RTYPEDDATA_DATA(obj);
+    dump_iseq(iseq, ctx);
+    return;
+  }
+
+  if(!strcmp("proc", typename)){
+    const rb_proc_t *proc = RTYPEDDATA_DATA(obj);
+    ygh_int("is_lambda", proc->is_lambda);
+    ygh_id("blockprocval", proc->blockprocval);
+    ygh_id("envval", proc->envval);
+    //TODO: dump refs from env here (they're dumped in env itself, but just to make analysis easier)?
+
+    //TODO: is this proc->block.iseq bound somewhere else? probably not
+    // if(proc->block.iseq && !RUBY_VM_IFUNC_P(proc->block.iseq)) {
+    //   yg_cstring("iseq");
+    //   yajl_gen_map_open(ctx->yajl);
+    //   ygh_id("id", proc->block.iseq);
+    //   dump_iseq(proc->block.iseq, ctx);
+    //   yajl_gen_map_close(ctx->yajl);
+    // } else {
+      ygh_id("iseq", proc->block.iseq);
+    // }
+    return;
+  }
+
+  if(!strcmp("VM/env", typename)){
+    const rb_env_t* env = RTYPEDDATA_DATA(obj);
+    int i = 0;
+    yg_cstring("refs");
+    yajl_gen_array_open(ctx->yajl);
+    for(; i > env->env_size; i++)
+      yg_id(env->env[i]);
+    yajl_gen_array_close(ctx->yajl);
+    return;
+  }
+
+}
+
 static VALUE rb_class_real_checked(VALUE cl)
 {
     if (cl == 0)
@@ -443,9 +572,14 @@ static inline void walk_live_object(VALUE obj, walk_ctx_t *ctx){
   ctx->live_objects++;
   yajl_gen_map_open(ctx->yajl);
 
-  ygh_int("id", NUM2LONG(rb_obj_id(obj))); //TODO: object_id is value>>2 ?
+  ygh_int("id", NUM2LONG(rb_obj_id(obj)));
   ygh_cstring("bt", rb_builtin_type(obj));
 
+  //TODO:
+  #ifdef GC_DEBUG
+  //RVALUE etc. has file/line info in this case
+  #endif
+
   switch(BUILTIN_TYPE(obj)){ // no need to call TYPE(), as value is on heap
     case T_NODE:
       dump_node(RNODE(obj), ctx);
@@ -568,11 +702,45 @@ static inline void walk_live_object(VALUE obj, walk_ctx_t *ctx){
     case T_FLOAT:
       ygh_double("val", RFLOAT_VALUE(obj));
       break;
-    // T(T_BIGNUM);
-    // T(T_RATIONAL); // refs too (num/den)...
-    // T(T_COMPLEX);
+    case T_RATIONAL:
+      //TODO: dump value for immediate components
+      yg_cstring("refs");
+      yajl_gen_array_open(ctx->yajl);
+      yg_id(RRATIONAL(obj)->num);
+      yg_id(RRATIONAL(obj)->den);
+      yajl_gen_array_close(ctx->yajl);
+      break;
+    case T_COMPLEX:
+      yg_cstring("refs");
+      yajl_gen_array_open(ctx->yajl);
+      yg_id(RCOMPLEX(obj)->real);
+      yg_id(RCOMPLEX(obj)->imag);
+      yajl_gen_array_close(ctx->yajl);
+      break;
+
+    case T_BIGNUM:
+      {
+        long len = RBIGNUM_LEN(obj), i;
+        BDIGIT* digits = RBIGNUM_DIGITS(obj);
+        yg_cstring("digits");
+        yajl_gen_array_open(ctx->yajl);
+        for(i = 0; i < len; i++)
+          yg_int(digits[i]);
+        yajl_gen_array_close(ctx->yajl);
+      }
+      break;
+
+    case T_DATA: // data of extensions + raw bytecode etc., refs undumpable? maybe in some way mess with mark callback? (need to intercept rb_gc_mark :( )
+      if(RTYPEDDATA_P(obj)){
+        ygh_cstring("type_name", RTYPEDDATA_TYPE(obj)->wrap_struct_name);
+        if(RTYPEDDATA_TYPE(obj)->dsize){
+          ygh_int("size", RTYPEDDATA_TYPE(obj)->dsize(RTYPEDDATA_DATA(obj)));
+        }
+
+        dump_data_if_known(obj, ctx);
+      }
+      break;
 
-    // T(T_DATA); // data of extensions, undumpable? maybe in some way mess with mark callback? (need to intercept rb_gc_mark :( )
     // T(T_UNDEF);
     default: break;
   }
@@ -601,34 +769,476 @@ static int objspace_walker(void *vstart, void *vend, int stride, walk_ctx_t *ctx
 }
 
 
+//TODO: move to separate header.
+/*
+  Bits of code taken directly from ruby gc
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+  Copyright (C) 2000  Information-technology Promotion Agency, Japan
+*/
+// #if defined(__x86_64__) && defined(__GNUC__) && !defined(__native_client__)
+// #define SET_MACHINE_STACK_END(p) __asm__("movq\t%%rsp, %0" : "=r" (*(p)))
+// #elif defined(__i386) && defined(__GNUC__) && !defined(__native_client__)
+// #define SET_MACHINE_STACK_END(p) __asm__("movl\t%%esp, %0" : "=r" (*(p)))
+// #else
+NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
+#define SET_MACHINE_STACK_END(p) rb_gc_set_stack_end(p)
+#define USE_CONSERVATIVE_STACK_END
+// #endif
+void
+rb_gc_set_stack_end(VALUE **stack_end_p)
+{
+    VALUE stack_end;
+    *stack_end_p = &stack_end;
+}
+
+#ifdef __ia64
+#define SET_STACK_END (SET_MACHINE_STACK_END(&th->machine_stack_end), th->machine_register_stack_end = rb_ia64_bsp())
+#else
+#define SET_STACK_END SET_MACHINE_STACK_END(&th->machine_stack_end)
+#endif
+
+#define STACK_START (th->machine_stack_start)
+#define STACK_END (th->machine_stack_end)
+#define STACK_LEVEL_MAX (th->machine_stack_maxsize/sizeof(VALUE))
+
+#if STACK_GROW_DIRECTION < 0
+# define STACK_LENGTH  (size_t)(STACK_START - STACK_END)
+#elif STACK_GROW_DIRECTION > 0
+# define STACK_LENGTH  (size_t)(STACK_END - STACK_START + 1)
+#else
+# define STACK_LENGTH  ((STACK_END < STACK_START) ? (size_t)(STACK_START - STACK_END) \
+      : (size_t)(STACK_END - STACK_START + 1))
+#endif
+#if !STACK_GROW_DIRECTION
+int ruby_stack_grow_direction;
+int
+ruby_get_stack_grow_direction(volatile VALUE *addr)
+{
+    VALUE *end;
+    SET_MACHINE_STACK_END(&end);
+
+    if (end > addr) return ruby_stack_grow_direction = 1;
+    return ruby_stack_grow_direction = -1;
+}
+#endif
+
+#if STACK_GROW_DIRECTION < 0
+#define GET_STACK_BOUNDS(start, end, appendix) ((start) = STACK_END, (end) = STACK_START)
+#elif STACK_GROW_DIRECTION > 0
+#define GET_STACK_BOUNDS(start, end, appendix) ((start) = STACK_START, (end) = STACK_END+(appendix))
+#else
+#define GET_STACK_BOUNDS(start, end, appendix) \
+    ((STACK_END < STACK_START) ? \
+     ((start) = STACK_END, (end) = STACK_START) : ((start) = STACK_START, (end) = STACK_END+(appendix)))
+#endif
+
+#define rb_setjmp(env) RUBY_SETJMP(env)
+#define rb_jmp_buf rb_jmpbuf_t
+
+#define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
+
+extern st_table *rb_class_tbl;
+
+
+/////////////
+#define MARK_STACK_MAX 1024
+
+#ifndef CALC_EXACT_MALLOC_SIZE
+#define CALC_EXACT_MALLOC_SIZE 0
+#endif
+#include "ruby/re.h"
+
+#ifndef FALSE
+# define FALSE 0
+#elif FALSE
+# error FALSE must be false
+#endif
+#ifndef TRUE
+# define TRUE 1
+#elif !TRUE
+# error TRUE must be true
+#endif
+
+//FIXME: this should be autoextracted from ruby
+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;
+
+typedef struct gc_profile_record {
+    double gc_time;
+    double gc_mark_time;
+    double gc_sweep_time;
+    double gc_invoke_time;
+
+    size_t heap_use_slots;
+    size_t heap_live_objects;
+    size_t heap_free_objects;
+    size_t heap_total_objects;
+    size_t heap_use_size;
+    size_t heap_total_size;
+
+    int have_finalize;
+    int is_marked;
+
+    size_t allocate_increase;
+    size_t allocate_limit;
+} gc_profile_record;
+
+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;
+};
+
+
+// typedef struct rb_objspace {
+//   struct {
+//     size_t limit;
+//     size_t increase;
+// //FIXME: this should match ruby settings
+// //#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;
+
+//   struct {
+//     VALUE buffer[MARK_STACK_MAX];
+//     VALUE *ptr;
+//     int overflow;
+//   } markstack;
+
+//   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;
+// } rb_objspace_t;
+
+
+// 1.9.2-p290:
+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;
+  size_t length;
+  size_t used;
+  RVALUE *freelist;
+  RVALUE *range[2];
+  RVALUE *freed;
+    } heap;
+    struct {
+  int dont_gc;
+  int during_gc;
+    } flags;
+    struct {
+  st_table *table;
+  RVALUE *deferred;
+    } final;
+    struct {
+  VALUE buffer[MARK_STACK_MAX];
+  VALUE *ptr;
+  int overflow;
+    } markstack;
+    struct {
+  int run;
+  gc_profile_record *record;
+  size_t count;
+  size_t size;
+  double invoke_time;
+    } profile;
+    struct gc_list *global_list;
+    unsigned int count;
+    int gc_stress;
+} 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 mark_stack    objspace->markstack.buffer
+#define mark_stack_ptr    objspace->markstack.ptr
+#define mark_stack_overflow objspace->markstack.overflow
+#define global_List   objspace->global_list
+
+#define RANY(o) ((RVALUE*)(o))
+
+static inline int
+is_pointer_to_heap(void *ptr, rb_objspace_t *objspace)
+{
+    if(!ptr) return false;
+    if(!objspace) objspace = GET_THREAD()->vm->objspace;
+
+    register RVALUE *p = RANY(ptr);
+    //register struct sorted_heaps_slot *heap;
+    register size_t hi, lo, mid;
+
+    if (p < lomem || p > himem) {
+      //printf("not in range %p - %p (objspace %p, l%u used %u)\n", lo, hi, objspace, heaps_length, heaps_used);
+      return FALSE;
+    }
+    //printf("ptr in range\n");
+    if ((VALUE)p % sizeof(RVALUE) != 0) return FALSE;
+    //printf("ptr %p align correct\n", ptr);
+
+  //1.9.2-p290
+  /* check if p looks like a pointer using bsearch*/
+      lo = 0;
+      hi = heaps_used;
+      while (lo < hi) {
+    mid = (lo + hi) / 2;
+    register struct heaps_slot *heap;
+    heap = &heaps[mid];
+    if (heap->slot <= p) {
+        if (p < heap->slot + heap->limit)
+      return TRUE;
+        lo = mid + 1;
+    }
+    else {
+        hi = mid;
+    }
+      }
+    //printf("not found");
+    return FALSE;
+}
+
+
+static void dump_machine_context(walk_ctx_t *ctx){
+  //TODO: other threads?
+  rb_thread_t* th = GET_THREAD()->vm->main_thread; //GET_THREAD();
+  union {
+    rb_jmp_buf j;
+    VALUE v[sizeof(rb_jmp_buf) / sizeof(VALUE)];
+  } save_regs_gc_mark;
+  VALUE *stack_start, *stack_end;
+
+
+  yg_cstring("stack_and_registers");
+  yajl_gen_array_open(ctx->yajl);
+
+  FLUSH_REGISTER_WINDOWS;
+  /* This assumes that all registers are saved into the jmp_buf (and stack) */
+  rb_setjmp(save_regs_gc_mark.j);
+
+  SET_STACK_END;
+  GET_STACK_BOUNDS(stack_start, stack_end, 1);
+
+  //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_pointer_to_heap((void*)v, NULL))
+      yg_id(v);
+  }
+
+  //printf("stack: %p %p\n", stack_start, stack_end);
+
+  //rb_gc_mark_locations(stack_start, stack_end);
+  if(stack_start < stack_end){
+    n = stack_end - stack_start;
+    x = stack_start;
+    while (n--) {
+      VALUE v = *(x++);
+      //printf("val: %p\n", (void*)v);
+      //FIXME: other objspace (not default one?)
+      if(is_pointer_to_heap((void*)v, NULL)) {
+        //printf("ON heap\n");
+        yg_id(v);
+      }
+    }
+  }
+
+  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){
+  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));
+
+  //val - damaged in some way?
+
+  //printf("name %s\n", RSTRING_PTR(rb_class_path(rb_class_real_checked(value))));
+
+  //if(is_pointer_to_heap(value, NULL)){
+    //printf("on heap\n");
+    yg_id(value);
+  //}
+
+  return ST_CONTINUE;
+}
+
 static VALUE
 rb_heapdump_dump(VALUE self, VALUE filename)
 {
-  struct walk_ctx ctx;
-  memset(&ctx, 0, sizeof(ctx));
+  struct walk_ctx ctx_o, *ctx = &ctx_o;
+  memset(ctx, 0, sizeof(*ctx));
 
   Check_Type(filename, T_STRING);
 
   printf("Dump should go to %s\n", RSTRING_PTR(filename));
-  ctx.file = fopen(RSTRING_PTR(filename), "wt");
-  ctx.yajl = yajl_gen_alloc(NULL,NULL);
-  yajl_gen_array_open(ctx.yajl);
+  ctx->file = fopen(RSTRING_PTR(filename), "wt");
+  ctx->yajl = yajl_gen_alloc(NULL,NULL);
+  yajl_gen_array_open(ctx->yajl);
 
-  rb_objspace_each_objects(objspace_walker, &ctx);
+  //dump origins:
+  yajl_gen_map_open(ctx->yajl);
+  ygh_cstring("id", "_ROOTS_");
+
+  printf("machine context\n");
+
+  dump_machine_context(ctx);
+  flush_yajl(ctx);
+
+  struct gc_list *list;
+  /* mark protected global variables */
+  printf("global_List\n");
+  for (list = GET_THREAD()->vm->global_List; list; list = list->next) {
+    VALUE v = *list->varptr;
+    //printf("global %p\n", v);
+  }
+
+  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: other gc entry points - symbols, encodings, etc.
+
+  yajl_gen_map_close(ctx->yajl); //id:roots
+  flush_yajl(ctx);
+
+  //now dump all live objects
+  printf("starting objspace walk\n");
+  rb_objspace_each_objects(objspace_walker, ctx);
 
-  yajl_gen_array_close(ctx.yajl);
-  flush_yajl(&ctx);
-  yajl_gen_free(ctx.yajl);
-  fclose(ctx.file);
+  yajl_gen_array_close(ctx->yajl);
+  flush_yajl(ctx);
+  yajl_gen_free(ctx->yajl);
+  fclose(ctx->file);
 
-  printf("Walker called %d times, seen %d live objects.\n", ctx.walker_called, ctx.live_objects);
+  printf("Walker called %d times, seen %d live objects.\n", ctx->walker_called, ctx->live_objects);
 
   return Qnil;
 }
 
 
 void Init_heap_dump(){
-  printf("heap_dump extension loading\n");
   //ruby-internal need to be required before linking us, but just in case..
   rb_require("internal/node");
   rb_require("yajl");

data/heap_dump.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = HeapDump::VERSION
 
-  gem.required_ruby_version = '>=1.9.2'
+  gem.required_ruby_version = '~>1.9.2p290' # heap structure changed in 1.9.3, support later
   #gem.platform = Gem::Platform::CURRENT # other than osx - maybe later
 
   gem.extensions = "ext/heap_dump/extconf.rb"

data/lib/heap_dump/version.rb

@@ -1,3 +1,3 @@
 module HeapDump
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/heap_dump.rb

@@ -9,7 +9,8 @@ require 'heap_dump.bundle'
 
 module HeapDump
   # Dumps ruby object space to file
-  def self.dump filename='dump.json'
+  def self.dump filename='dump.json', gc_before_dump=true
+    GC.start if gc_before_dump
     return dump_ext(filename)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heap_dump
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-25 00:00:00.000000000Z
+date: 2012-05-29 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-internal
-  requirement: &70288827505440 !ruby/object:Gem::Requirement
+  requirement: &70106505219640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.8.5
   type: :runtime
   prerelease: false
-  version_requirements: *70288827505440
+  version_requirements: *70106505219640
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &70288827504740 !ruby/object:Gem::Requirement
+  requirement: &70106505219140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.1'
   type: :runtime
   prerelease: false
-  version_requirements: *70288827504740
+  version_requirements: *70106505219140
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &70288827504140 !ruby/object:Gem::Requirement
+  requirement: &70106505218720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70288827504140
+  version_requirements: *70106505218720
 description: dump ruby 1.9 heap contents
 email:
 - vasilyfedoseyev@gmail.com
@@ -72,9 +72,9 @@ require_paths:
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ~>
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 1.9.2p290
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: