bleak_house 7.1 → 7.2

data/ext/build_snapshot.rb

@@ -0,0 +1,5 @@
+RUBY_VERSION = `ruby -v`.split(" ")[1]
+require 'mkmf'
+$CFLAGS = ENV['CFLAGS']
+dir_config('snapshot')
+create_makefile('snapshot')

data/ext/extconf.rb

@@ -0,0 +1,26 @@
+require 'fileutils'
+
+module BleakHouse
+
+  LOGDIR = File.expand_path('../../log', __FILE__)
+  LOGFILE = File.join(LOGDIR, 'bleak_house.log')
+  
+  FileUtils.mkdir_p(LOGDIR)
+  
+  def self.write_to_log(message)
+    File.open(LOGFILE, 'a') { |f| f.puts message }
+  end
+
+  def self.execute(command)    
+    unless system(command)
+      puts File.open(LOGFILE).read
+      exit -1 
+    end
+  end
+end
+
+BleakHouse.write_to_log('-%{ BUILDING RUBY }%-')
+BleakHouse.execute("ruby build_ruby.rb >> #{BleakHouse::LOGFILE} 2>&1")
+
+BleakHouse.write_to_log('-%{ BUILDING SNAPSHOT }%-')
+BleakHouse.execute("ruby-bleak-house build_snapshot.rb >> #{BleakHouse::LOGFILE} 2>&1")

data/ext/snapshot.c

@@ -0,0 +1,153 @@
+#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());
+}
+
+/* Inner method; call BleakHouse.snapshot instead. */
+static VALUE ext_snapshot(VALUE self, VALUE _logfile, VALUE _gc_runs) {
+  Check_Type(_logfile, T_STRING);
+  Check_Type(_gc_runs, T_FIXNUM);
+
+  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;
+  int gc_runs = FIX2INT(_gc_runs);
+  char * chr;
+
+  for (i = 0; i < gc_runs; i++) {
+    /* request GC run */
+    rb_funcall(rb_mGC, rb_intern("start"), 0);
+    rb_thread_schedule();
+  }
+  fprintf(logfile, "%i GC runs performed before dump\n", gc_runs);
+
+  /* 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, "ext_snapshot", ext_snapshot, 2);
+  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.rb

@@ -1,17 +1,22 @@
 
-if ENV['BLEAK_HOUSE']
+unless RUBY_PATCHLEVEL >= 905
+  raise "This build of Ruby has not been successfully patched for BleakHouse."
+end
 
-  # rails  
-  require 'dispatcher'
-  
-  # logger
-  require 'bleak_house/c'
-  require 'bleak_house/bleak_house'
+RUBY_VERSION = `ruby -v`.split(" ")[1]
+require 'snapshot'
+require 'bleak_house/hook'
 
-  # overrides
-  require 'bleak_house/dispatcher'
-  require 'bleak_house/action_controller'
+class << BleakHouse
+  private :ext_snapshot
+end
+  
+module BleakHouse
 
-  BleakHouse.warn "enabled (log/bleak_house_#{RAILS_ENV}.dump)"
-    
+  # Walk the live, instrumented objects on the heap and write them to 
+  # <tt>logfile</tt>. Accepts an optional number of GC runs to perform
+  # before dumping the heap.
+  def self.snapshot(logfile, gc_runs = 3)
+    ext_snapshot(logfile, gc_runs)
+  end
 end

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,24 @@
+
+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(gc_runs = 3)
+    @count ||= 0
+    filename = "/tmp/bleak.%s.%03i.dump" % [Process.pid,@count]
+    STDERR.puts "** BleakHouse: working..."
+    BleakHouse.snapshot(filename, gc_runs)
+    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
+  STDERR.puts "** BleakHouse: we get signal."
+  BleakHouse.hook
+end

data/ruby/ruby-1.8.7.patch

@@ -0,0 +1,483 @@
+diff --git a/Makefile.in b/Makefile.in
+index a37bcf6..52f723c 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -34,7 +34,7 @@ RIDATADIR = $(DESTDIR)$(datadir)/ri/$(MAJOR).$(MINOR)/system
+ 
+ empty =
+ OUTFLAG = @OUTFLAG@$(empty)
+-CFLAGS = @CFLAGS@ @XCFLAGS@ @ARCH_FLAG@
++CFLAGS = @CFLAGS@ @XCFLAGS@ @ARCH_FLAG@ @VALGRIND_CFLAGS@
+ cflags = @cflags@
+ optflags = @optflags@
+ debugflags = @debugflags@
+diff --git a/configure b/configure
+index faf2b45..16287ca 100755
+--- a/configure
++++ b/configure
+@@ -724,6 +724,7 @@ cflags
+ optflags
+ debugflags
+ XCFLAGS
++VALGRIND_CFLAGS
+ XLDFLAGS
+ LIBRUBY_LDSHARED
+ LIBRUBY_DLDFLAGS
+@@ -1353,6 +1354,7 @@ Optional Features:
+   --enable-setreuid       use setreuid()/setregid() according to need even if obsolete.
+   --disable-rpath         embed run path into extension libraries.
+   --enable-shared         build a shared library for Ruby.
++  --enable-valgrind       Use valgrind support
+   --enable-install-doc    build and install rdoc indexes during install
+ 
+ Optional Packages:
+@@ -13012,12 +13014,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;
+ }
+@@ -16462,6 +16463,173 @@ done
+     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"
+ 
+ 
+@@ -18588,6 +18756,7 @@ cflags!$cflags$ac_delim
+ optflags!$optflags$ac_delim
+ debugflags!$debugflags$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
+@@ -18622,7 +18791,7 @@ MANTYPE!$MANTYPE$ac_delim
+ LTLIBOBJS!$LTLIBOBJS$ac_delim
+ _ACEOF
+ 
+-  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 47; then
++  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 48; then
+     break
+   elif $ac_last_try; then
+     { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
+diff --git a/configure.in b/configure.in
+index fe63c0c..e0cdcdd 100644
+--- a/configure.in
++++ b/configure.in
+@@ -1043,6 +1043,23 @@ if test x"$ac_cv_header_ucontext_h" = xyes; then
+     fi
+ fi
+ 
++AC_ARG_ENABLE(valgrind,
++       [  --enable-valgrind       use valgrind support],
++       [want_valgrind=$enableval], [want_valgrind=auto])
++
++if test x"$want_valgrind" != xno; then
++  AC_CHECK_HEADERS(valgrind/memcheck.h, have_valgrind=yes, have_valgrind=no)
++	if test x"$have_valgrind" = xyes; then
++		AC_DEFINE(HAVE_VALGRIND)
++		VALGRIND_CFLAGS="";
++	elif test x"$want_valgrind" = xyes -a x"$have_valgrind" = xno; then
++		AC_MSG_ERROR(valgrind support requested but valgrind not found)
++	else
++	  VALGRIND_CFLAGS="";
++	fi
++fi
++
++
+ dnl default value for $KANJI
+ DEFAULT_KCODE="KCODE_NONE"
+ 
+@@ -1663,6 +1680,7 @@ AC_SUBST(cflags, ['${optflags} ${debugflags}'])dnl
+ AC_SUBST(optflags)dnl
+ AC_SUBST(debugflags)dnl
+ AC_SUBST(XCFLAGS)dnl
++AC_SUBST(VALGRIND_CFLAGS)dnl
+ AC_SUBST(XLDFLAGS)dnl
+ AC_SUBST(LIBRUBY_LDSHARED)
+ AC_SUBST(LIBRUBY_DLDFLAGS)
+diff --git a/eval.c b/eval.c
+index 11264f7..09ec7a6 100644
+--- a/eval.c
++++ b/eval.c
+@@ -28,6 +28,12 @@
+ #define EXIT_FAILURE 1
+ #endif
+ 
++#ifdef HAVE_VALGRIND
++#include <valgrind/memcheck.h>
++#else
++#define VALGRIND_MAKE_MEM_DEFINED(p, n) /* empty */
++#endif
++
+ #include <stdio.h>
+ 
+ #include "st.h"
+@@ -1149,7 +1149,7 @@ static VALUE trace_func = 0;
+ static int tracing = 0;
+ static void call_trace_func _((rb_event_t,NODE*,VALUE,ID,VALUE));
+ 
+-#if 0
++#if 1
+ #define SET_CURRENT_SOURCE() (ruby_sourcefile = ruby_current_node->nd_file, \
+ 			      ruby_sourceline = nd_line(ruby_current_node))
+ #else
+@@ -5290,6 +5296,9 @@ assign(self, lhs, val, pcall)
+     int pcall;
+ {
+     ruby_current_node = lhs;
++
++    VALGRIND_MAKE_MEM_DEFINED(&val, sizeof(val));
++
+     if (val == Qundef) {
+ 	rb_warning("assigning void value");
+ 	val = Qnil;
+diff --git a/gc.c b/gc.c
+index 45facf0..933b76e 100644
+--- a/gc.c
++++ b/gc.c
+@@ -30,6 +30,12 @@
+ #include <sys/resource.h>
+ #endif
+ 
++#ifdef HAVE_VALGRIND
++#include <valgrind/memcheck.h>
++#else
++#define VALGRIND_MAKE_MEM_DEFINED(p, n) /* empty */
++#endif
++
+ #if defined _WIN32 || defined __CYGWIN__
+ #include <windows.h>
+ #endif
+@@ -138,6 +144,9 @@ ruby_xmalloc(size)
+ {
+     void *mem;
+ 
++    VALGRIND_MAKE_MEM_DEFINED(&malloc_increase, sizeof(malloc_increase));
++    VALGRIND_MAKE_MEM_DEFINED(&malloc_limit, sizeof(malloc_limit));
++
+     if (size < 0) {
+ 	rb_raise(rb_eNoMemError, "negative allocation size (or too big)");
+     }
+@@ -297,8 +306,6 @@ rb_gc_unregister_address(addr)
+     }
+ }
+ 
+-#undef GC_DEBUG
+-
+ void
+ rb_global_variable(var)
+     VALUE *var;
+@@ -333,10 +340,8 @@ typedef struct RVALUE {
+ 	struct RVarmap varmap;
+ 	struct SCOPE   scope;
+     } as;
+-#ifdef GC_DEBUG
+     char *file;
+     int   line;
+-#endif
+ } RVALUE;
+ 
+ #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)
+@@ -355,6 +360,22 @@ static struct heaps_slot {
+ 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;
+ 
+@@ -438,10 +438,8 @@ rb_newobj()
+     obj = (VALUE)freelist;
+     freelist = freelist->as.free.next;
+     MEMZERO((void*)obj, RVALUE, 1);
+-#ifdef GC_DEBUG
+     RANY(obj)->file = ruby_sourcefile;
+     RANY(obj)->line = ruby_sourceline;
+-#endif
+     return obj;
+ }
+
+@@ -678,6 +704,9 @@ mark_locations_array(x, n)
+     register long n;
+ {
+     VALUE v;
++
++    VALGRIND_MAKE_MEM_DEFINED(x, sizeof(*x) * n);
++
+     while (n--) {
+         v = *x;
+ 	if (is_pointer_to_heap((void *)v)) {
+@@ -768,12 +797,18 @@ gc_mark(ptr, lev)
+ {
+     register RVALUE *obj;
+ 
++    VALGRIND_MAKE_MEM_DEFINED(&ptr, sizeof(ptr));
+     obj = RANY(ptr);
++    VALGRIND_MAKE_MEM_DEFINED(obj, sizeof(*obj));
++
+     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) {
+ 	    if (mark_stack_ptr - mark_stack < MARK_STACK_MAX) {
+@@ -1077,6 +1078,10 @@ gc_mark(ptr, lev)
+     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) {
+@@ -1115,6 +1120,10 @@ gc_mark_children(ptr, lev)
+     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);
++
+ 
+   marking:
+     if (FL_TEST(obj, FL_EXIVAR)) {
+diff --git a/parse.c b/parse.c
+index 6b3d80d..b320cf2 100644
+--- a/parse.c
++++ b/parse.c
+@@ -11403,6 +11403,11 @@ symbols_i(key, value, ary)
+  *                                     :wait2, :$>]
+  */
+ 
++struct st_table *
++rb_parse_sym_tbl() {
++  return sym_tbl;
++}
++
+ VALUE
+ rb_sym_all_symbols()
+ {
+diff --git a/parse.y b/parse.y
+index ab0b83c..3ce1dfb 100644
+--- a/parse.y
++++ b/parse.y
+@@ -6263,6 +6263,11 @@ symbols_i(key, value, ary)
+  *                                     :wait2, :$>]
+  */
+ 
++struct st_table *
++rb_parse_sym_tbl() {
++  return sym_tbl;
++}
++
+ VALUE
+ rb_sym_all_symbols()
+ {
+diff --git a/version.h b/version.h
+index 70fc28a..76aa188 100644
+--- a/version.h
++++ b/version.h
+@@ -5,2 +5,2 @@
+-#define RUBY_PATCHLEVEL 174
++#define RUBY_PATCHLEVEL 905
+