ssoroka-bleak_house 4.1.1

data/ext/snapshot.c

@@ -0,0 +1,150 @@
+#include <time.h>
+#include "snapshot.h"
+
+static VALUE rb_mB;
+static VALUE rb_cC;
+
+/* Number of filled <tt>heaps_slots</tt> */
+static VALUE heaps_used(VALUE self) {
+  return INT2FIX(rb_gc_heaps_used());
+}
+
+/* Number of allocated <tt>heaps_slots</tt> */
+static VALUE heaps_length(VALUE self) {
+  return INT2FIX(rb_gc_heaps_length());
+}
+
+/* Walk the live, instrumented objects on the heap and write them to <tt>_logfile</tt>. */
+static VALUE snapshot(VALUE self, VALUE _logfile) {
+  Check_Type(_logfile, T_STRING);
+
+  RVALUE *obj, *obj_end;
+  st_table_entry *sym; 
+  
+  struct heaps_slot * heaps = rb_gc_heap_slots();
+  struct st_table * sym_tbl = rb_parse_sym_tbl();
+
+  /* see if the logfile exists already */
+  FILE *logfile = fopen(StringValueCStr(_logfile), "r");
+  int is_new;
+  if (!(is_new = (logfile == NULL)))
+    fclose(logfile);
+
+  /* reopen for writing */
+  if ((logfile = fopen(StringValueCStr(_logfile), "w")) == NULL)
+    rb_raise(rb_eRuntimeError, "couldn't open snapshot file");
+
+  int filled_slots = 0;
+  int free_slots = 0;
+
+  int i; 
+  char * chr;
+    
+  for (i = 0; i < 3; i++) {
+    /* request GC run */
+    rb_funcall(rb_mGC, rb_intern("start"), 0);
+    rb_thread_schedule();
+  }
+  
+  /* walk the heap */
+  for (i = 0; i < rb_gc_heaps_used(); i++) {
+    obj = heaps[i].slot;
+    obj_end = obj + heaps[i].limit;
+    for (; obj < obj_end; obj++) {
+      if (obj->as.basic.flags) { /* always 0 for freed objects */
+        filled_slots ++;
+        
+        /* write the source file*/
+        if (obj->file) {
+          chr = obj->file;          
+          if (*chr != '\0') {
+            fprintf(logfile, "%s", obj->file);
+          } else {
+            fprintf(logfile, "__empty__");   
+          }
+        } else {
+          fprintf(logfile, "__null__");
+        }
+        
+        /* write the source line */
+        fprintf(logfile, ":");        
+        if (obj->line) {
+          fprintf(logfile, "%i", obj->line);
+        } else {
+          fprintf(logfile, "__null__");
+        }
+        
+        /* write the class */
+        fprintf(logfile, ":");
+        switch (TYPE(obj)) {
+          case T_NONE:
+              fprintf(logfile, "__none__"); break;
+          case T_BLKTAG:
+              fprintf(logfile, "__blktag__"); break;
+          case T_UNDEF:
+              fprintf(logfile, "__undef__"); break;
+          case T_VARMAP:
+              fprintf(logfile, "__varmap__"); break;
+          case T_SCOPE:
+              fprintf(logfile, "__scope__"); break;
+          case T_NODE:
+              fprintf(logfile, "__node__"); break;
+          default:
+            if (!obj->as.basic.klass) {
+              fprintf(logfile, "__unknown__");
+            } else {
+              fprintf(logfile, rb_obj_classname((VALUE)obj));
+            }
+        }
+        
+        /* write newline */
+        fprintf(logfile, "\n");
+      } else {
+        free_slots ++;
+      }
+    }
+  }
+  
+  /* walk the symbol table */  
+  /* hashed = lookup_builtin("Symbol");
+  for (i = 0; i < sym_tbl->num_bins; i++) {
+    for (sym = sym_tbl->bins[i]; sym != 0; sym = sym->next) {
+      fprintf(logfile, "%i,%lu\n", hashed + 1, sym->record);
+    }
+  } */
+    
+  fprintf(logfile, "%i filled\n", filled_slots);
+  fprintf(logfile, "%i free\n", free_slots);
+  fclose(logfile);
+  
+  return Qnil;
+}
+
+
+/*
+
+This class performs the actual object logging of BleakHouse. To use it directly, you need to make calls to BleakHouse.snapshot. 
+
+By default, BleakHouse records a snapshot on exit. You can disable this by setting the environment variable <tt>NO_EXIT_HANDLER</tt> before startup. 
+
+It is also possible to externally trigger the snapshot at any time by sending <tt>SIGUSR2</tt> to the process. 
+
+== Example
+
+At the start of your app, put:
+  require 'rubygems'
+  require 'bleak_house'
+  $logfile = "/path/to/logfile"
+
+Run your app. Once it exits, analyze your data:
+  bleak /path/to/logfile
+  
+*/
+void
+Init_snapshot()
+{
+  rb_mB = rb_define_module("BleakHouse");
+  rb_define_singleton_method(rb_mB, "snapshot", snapshot, 1);
+  rb_define_singleton_method(rb_mB, "heaps_used", heaps_used, 0);
+  rb_define_singleton_method(rb_mB, "heaps_length", heaps_length, 0);
+}

data/ext/snapshot.h

@@ -0,0 +1,59 @@
+#include "ruby.h"
+#include "env.h"
+#include "node.h"
+#include "st.h"
+#include "re.h"
+#include "util.h"
+#include "intern.h"
+#include "string.h"
+
+typedef struct RVALUE {
+    union {
+        struct {
+            unsigned long 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 RStruct rstruct;
+        struct RBignum bignum;
+        struct RFile   file;
+        struct RNode   node;
+        struct RMatch  match;
+        struct RVarmap varmap;
+        struct SCOPE   scope;
+    } as;
+    char *file;
+    int   line;    
+} RVALUE;
+
+struct heaps_slot {
+    void *membase;
+    RVALUE *slot;
+    int limit;
+};
+
+typedef struct st_table_entry st_table_entry;
+
+struct st_table_entry {
+    unsigned int hash;
+    st_data_t key;
+    st_data_t record;
+    st_table_entry *next;
+};
+
+struct st_table * rb_parse_sym_tbl();
+struct heaps_slot * rb_gc_heap_slots();
+int rb_gc_heaps_used();
+int rb_gc_heaps_length();
+
+char * inspect(VALUE);
+char * handle_exception(VALUE);
+int lookup_builtin(char *);

data/lib/bleak_house/analyzer.rb

@@ -0,0 +1,54 @@
+
+module BleakHouse
+  module Analyzer
+
+    # Analyze a compatible <tt>bleak.dump</tt>. Accepts one or more filename and the number of lines to display.
+    def self.run(*args)
+      lines = args.last[/^\d+$/] ? args.pop.to_i : 20
+
+      raise "Can't diff more than 2 files" if args.size > 2
+      
+      outputs = args.map do |file|          
+        filled, free = `tail -n 2 #{file}`.split("\n")
+        unless filled =~ /filled/ and free =~ /free/
+          raise "#{file} is incomplete or corrupted"
+        end
+  
+        length = `wc #{file}`.to_i - 2      
+        cmd = ENV['NO_TRACE'] ? "awk -F: '{print $3}' " + file : "cat #{file}"      
+        cmd += " | sort | uniq -c | sort -nr | head -#{lines}"
+  
+        ["#{length} total objects", "#{filled} heap slots", "#{free} heap slots"] + `#{cmd}`.split("\n")
+      end
+    
+      if outputs.size == 1
+        # Just output the data
+        puts "Displaying top #{lines} most common line/class pairs"        
+        puts outputs.first
+      else
+        puts "Displaying change in top #{lines} most common line/class pairs"        
+        puts diff(outputs)
+      end
+
+    end
+    
+    def self.diff(outputs)
+      # Calculate the diff
+      diff = Hash.new(0)
+      # Iterate each item
+      outputs.each_with_index do |output, index|
+        output[3..-1].each do |line|
+          c, key = line.split(" ", 2)
+          index.zero? ? diff[key] -= c.to_i : diff[key] += c.to_i
+        end
+      end
+      # Format the lines in descending order
+      diff.sort_by do |key, value|
+        -value
+      end.map do |key, value|
+        "#{value.to_s.rjust(6)} #{key}"
+      end    
+    end
+    
+  end
+end

data/lib/bleak_house/hook.rb

@@ -0,0 +1,25 @@
+
+module BleakHouse
+  # The body of the exit handler and <tt>SIGUSR2</tt> trap. It writes a snapshot to a dumpfile named after the current Process.pid.
+  def self.hook
+    @count ||= 0
+    filename = "/tmp/bleak.#{Process.pid}.#{@count}.dump"
+    STDERR.puts "** BleakHouse: working..."
+    BleakHouse.snapshot(filename)
+    STDERR.puts "** BleakHouse: complete\n** Bleakhouse: Run 'bleak #{filename}' to analyze."  
+    @count += 1
+  end
+end
+
+unless ENV['NO_EXIT_HANDLER']
+  Kernel.at_exit do
+    BleakHouse.hook
+  end
+  STDERR.puts "** Bleakhouse: installed"
+end
+
+Kernel.trap("USR2") do
+  BleakHouse.hook
+end
+
+

data/lib/bleak_house.rb

@@ -0,0 +1,7 @@
+
+unless RUBY_PATCHLEVEL > 900
+  raise "This build of Ruby has not been successfully patched for BleakHouse."
+end
+
+require 'snapshot'
+require 'bleak_house/hook'

data/ruby/configure.patch

@@ -0,0 +1,242 @@
+Index: configure
+===================================================================
+--- configure	(revision 6446)
++++ configure	(working copy)
+@@ -720,6 +720,7 @@
+ ARCHFILE
+ RDOCTARGET
+ XCFLAGS
++VALGRIND_CFLAGS
+ XLDFLAGS
+ LIBRUBY_LDSHARED
+ LIBRUBY_DLDFLAGS
+@@ -1356,6 +1357,7 @@
+   --enable-pthread        use pthread library.
+   --disable-fastthread    do not use the fastthread mutex
+   --enable-setreuid       use setreuid()/setregid() according to need even if obsolete.
++  --enable-valgrind       use valgrind support
+   --disable-rpath         embed run path into extension libraries.
+   --enable-shared         build a shared library for Ruby.
+   --enable-install-doc    build and install rdoc indexes during install
+@@ -12988,13 +12990,11 @@
+ cat confdefs.h >>conftest.$ac_ext
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+-#include <sys/types.h> /* for off_t */
+-     #include <stdio.h>
++#include <stdio.h>
+ int
+ main ()
+ {
+-int (*fp) (FILE *, off_t, int) = fseeko;
+-     return fseeko (stdin, 0, 0) && fp (stdin, 0, 0);
++return fseeko (stdin, 0, 0) && (fseeko) (stdin, 0, 0);
+   ;
+   return 0;
+ }
+@@ -13034,13 +13034,11 @@
+ cat >>conftest.$ac_ext <<_ACEOF
+ /* end confdefs.h.  */
+ #define _LARGEFILE_SOURCE 1
+-#include <sys/types.h> /* for off_t */
+-     #include <stdio.h>
++#include <stdio.h>
+ int
+ main ()
+ {
+-int (*fp) (FILE *, off_t, int) = fseeko;
+-     return fseeko (stdin, 0, 0) && fp (stdin, 0, 0);
++return fseeko (stdin, 0, 0) && (fseeko) (stdin, 0, 0);
+   ;
+   return 0;
+ }
+@@ -15768,6 +15766,172 @@
+     fi
+ fi
+ 
++# Check whether --enable-valgrind was given.
++if test "${enable_valgrind+set}" = set; then
++  enableval=$enable_valgrind; want_valgrind=$enableval
++else
++  want_valgrind=auto
++fi
++
++
++if test x"$want_valgrind" != xno; then
++
++for ac_header in valgrind/memcheck.h
++do
++as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  { echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++fi
++ac_res=`eval echo '${'$as_ac_Header'}'`
++	       { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
++else
++  # Is the header compilable?
++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5
++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
++cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++$ac_includes_default
++#include <$ac_header>
++_ACEOF
++rm -f conftest.$ac_objext
++if { (ac_try="$ac_compile"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_compile") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } && {
++	 test -z "$ac_c_werror_flag" ||
++	 test ! -s conftest.err
++       } && test -s conftest.$ac_objext; then
++  ac_header_compiler=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++	ac_header_compiler=no
++fi
++
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
++echo "${ECHO_T}$ac_header_compiler" >&6; }
++
++# Is the header present?
++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5
++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
++cat >conftest.$ac_ext <<_ACEOF
++/* confdefs.h.  */
++_ACEOF
++cat confdefs.h >>conftest.$ac_ext
++cat >>conftest.$ac_ext <<_ACEOF
++/* end confdefs.h.  */
++#include <$ac_header>
++_ACEOF
++if { (ac_try="$ac_cpp conftest.$ac_ext"
++case "(($ac_try" in
++  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
++  *) ac_try_echo=$ac_try;;
++esac
++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
++  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
++  ac_status=$?
++  grep -v '^ *+' conftest.er1 >conftest.err
++  rm -f conftest.er1
++  cat conftest.err >&5
++  echo "$as_me:$LINENO: \$? = $ac_status" >&5
++  (exit $ac_status); } >/dev/null && {
++	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
++	 test ! -s conftest.err
++       }; then
++  ac_header_preproc=yes
++else
++  echo "$as_me: failed program was:" >&5
++sed 's/^/| /' conftest.$ac_ext >&5
++
++  ac_header_preproc=no
++fi
++
++rm -f conftest.err conftest.$ac_ext
++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
++echo "${ECHO_T}$ac_header_preproc" >&6; }
++
++# So?  What about this header?
++case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
++  yes:no: )
++    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
++echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
++    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
++echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
++    ac_header_preproc=yes
++    ;;
++  no:yes:* )
++    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
++echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
++    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
++echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
++    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
++echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
++    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
++echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
++    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
++echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
++    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
++echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
++
++    ;;
++esac
++{ echo "$as_me:$LINENO: checking for $ac_header" >&5
++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
++  echo $ECHO_N "(cached) $ECHO_C" >&6
++else
++  eval "$as_ac_Header=\$ac_header_preproc"
++fi
++ac_res=`eval echo '${'$as_ac_Header'}'`
++	       { echo "$as_me:$LINENO: result: $ac_res" >&5
++echo "${ECHO_T}$ac_res" >&6; }
++
++fi
++if test `eval echo '${'$as_ac_Header'}'` = yes; then
++  cat >>confdefs.h <<_ACEOF
++#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
++_ACEOF
++ have_valgrind=yes
++else
++  have_valgrind=no
++fi
++
++done
++
++	if test x"$have_valgrind" = xyes; then
++		cat >>confdefs.h <<\_ACEOF
++#define HAVE_VALGRIND 1
++_ACEOF
++
++		VALGRIND_CFLAGS="";
++	elif test x"$want_valgrind" = xyes -a x"$have_valgrind" = xno; then
++		{ { echo "$as_me:$LINENO: error: valgrind support requested but valgrind not found" >&5
++echo "$as_me: error: valgrind support requested but valgrind not found" >&2;}
++   { (exit 1); exit 1; }; }
++	else
++	  VALGRIND_CFLAGS="";
++	fi
++fi
++
+ DEFAULT_KCODE="KCODE_NONE"
+ 
+ 
+@@ -17854,6 +18018,7 @@
+ ARCHFILE!$ARCHFILE$ac_delim
+ RDOCTARGET!$RDOCTARGET$ac_delim
+ XCFLAGS!$XCFLAGS$ac_delim
++VALGRIND_CFLAGS!$VALGRIND_CFLAGS$ac_delim
+ XLDFLAGS!$XLDFLAGS$ac_delim
+ LIBRUBY_LDSHARED!$LIBRUBY_LDSHARED$ac_delim
+ LIBRUBY_DLDFLAGS!$LIBRUBY_DLDFLAGS$ac_delim
+@@ -17887,7 +18052,7 @@
+ LTLIBOBJS!$LTLIBOBJS$ac_delim
+ _ACEOF
+ 
+-  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 42; then
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 43; then
+     break
+   elif $ac_last_try; then
+     { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5

data/ruby/gc.patch

@@ -0,0 +1,119 @@
+Index: parse.y
+===================================================================
+--- parse.y	(revision 6446)
++++ parse.y	(working copy)
+@@ -6168,6 +6168,11 @@
+  *                                     :wait2, :$>]
+  */
+ 
++struct st_table * 
++rb_parse_sym_tbl() {
++  return sym_tbl;
++}
++
+ VALUE
+ rb_sym_all_symbols()
+ {
+Index: parse.c
+===================================================================
+--- parse.c	(revision 6446)
++++ parse.c	(working copy)
+@@ -11157,6 +11157,11 @@
+  *                                     :wait2, :$>]
+  */
+ 
++struct st_table * 
++rb_parse_sym_tbl() {
++  return sym_tbl;
++}
++
+ VALUE
+ rb_sym_all_symbols()
+ {
+Index: gc.c
+===================================================================
+--- gc.c	(revision 6446)
++++ gc.c	(working copy)
+@@ -260,8 +260,6 @@
+     }
+ }
+ 
+-#undef GC_DEBUG
+-
+ void
+ rb_global_variable(var)
+     VALUE *var;
+@@ -296,10 +294,8 @@
+ 	struct RVarmap varmap;
+ 	struct SCOPE   scope;
+     } as;
+-#ifdef GC_DEBUG
+     char *file;
+     int   line;
+-#endif
+ } RVALUE;
+ 
+ #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)
+@@ -318,6 +314,22 @@
+ static int heaps_length = 0;
+ static int heaps_used   = 0;
+ 
++struct heaps_slot *
++rb_gc_heap_slots()
++{
++    return heaps;
++}
++
++int
++rb_gc_heaps_used() {
++    return heaps_used;
++}
++
++int
++rb_gc_heaps_length() {
++    return heaps_length;
++}
++
+ #define HEAP_MIN_SLOTS 10000
+ static int heap_slots = HEAP_MIN_SLOTS;
+ 
+@@ -396,9 +408,11 @@
+     freelist = freelist->as.free.next;
+     MEMZERO((void*)obj, RVALUE, 1);
+-#ifdef GC_DEBUG
+-    RANY(obj)->file = ruby_sourcefile;
+-    RANY(obj)->line = ruby_sourceline;
+-#endif
++
++    if (ruby_current_node && ruby_current_node->nd_file) {
++      RANY(obj)->file = ruby_current_node->nd_file;
++      RANY(obj)->line = nd_line(ruby_current_node);
++    }
++
+     return obj;
+ }
+ 
+@@ -732,7 +747,10 @@
+     if (rb_special_const_p(ptr)) return; /* special const not marked */
+     if (obj->as.basic.flags == 0) return;       /* free cell */
+     if (obj->as.basic.flags & FL_MARK) return;  /* already marked */
++
+     obj->as.basic.flags |= FL_MARK;
++    /* mark our new reference point for sourcefile objects */
++    mark_source_filename(RANY(obj)->file);
+ 
+     if (lev > GC_LEVEL_MAX || (lev == 0 && ruby_stack_check())) {
+ 	if (!mark_stack_overflow) {
+Index: version.h
+===================================================================
+--- version.h	(revision 6439)
++++ version.h	(working copy)
+@@ -2,7 +2,7 @@
+ #define RUBY_RELEASE_DATE "2008-06-20"
+ #define RUBY_VERSION_CODE 186
+ #define RUBY_RELEASE_CODE 20080620
+-#define RUBY_PATCHLEVEL 230
++#define RUBY_PATCHLEVEL 902
+ 
+ #define RUBY_VERSION_MAJOR 1
+ #define RUBY_VERSION_MINOR 8