ZenHacks 1.0.0

data/lib/zenoptimize.rb

@@ -0,0 +1,149 @@
+require 'inline'
+require 'singleton'
+require 'ruby_to_c'
+require 'pp'
+
+module Inline
+  class Ruby < Inline::C
+    def optimize(meth)
+      src = RubyToC.translate(@mod, meth)
+      if $DEBUG then
+        STDERR.puts
+        STDERR.puts src
+        STDERR.puts
+      end
+      @mod.class_eval "alias :#{meth}_slow :#{meth}"
+      @mod.class_eval "remove_method :#{meth}"
+      c src
+    end
+  end
+end
+
+class ZenOptimizer
+
+  include Singleton
+
+  @@threshold = 500
+  @@sacred = {
+    Sexp => true,
+  }
+  @@skip = Hash.new(false)
+  @@data = Hash.new(0)
+
+  def self.start_optimizing
+    self.instance.add_event_hook
+  end
+
+  def self.stop_optimizing
+    self.instance.remove_event_hook
+    if $DEBUG then
+      STDERR.puts @@skip.inspect
+      STDERR.puts @@data.sort_by{|x,y| y}.reverse[0..4].inspect
+    end
+  end
+
+  def self.optimize(signature)
+    klass, meth = *signature
+
+    unless @@sacred.include? klass then
+      STDERR.puts "*** Optimizer threshold tripped!! Optimizing #{klass}.#{meth}"
+      
+      begin
+        klass.module_eval "inline(:Ruby) { |b| b.optimize(#{meth.inspect}) }"
+      rescue Exception => e
+        STDERR.puts "Failed to optimize #{klass}.#{meth}"
+        STDERR.puts "Exception = #{e.class}, message = #{e.message}"
+      end
+    end
+
+    @@skip[signature] = true
+  end
+
+  ############################################################
+  # Inlined Methods:
+
+  inline(:C) do |builder|
+
+    builder.add_type_converter("rb_event_t", '', '')
+    builder.add_type_converter("ID", '', '')
+
+    builder.include '"ruby.h"'
+    builder.include '"node.h"'
+
+    builder.prefix "static VALUE optimizer_klass = Qnil;
+static VALUE data = Qnil;
+static VALUE skip = Qnil;
+static unsigned long threshold = 0;"
+
+    builder.c_raw <<-'EOF'
+    static void
+    prof_event_hook(rb_event_t event, NODE *node,
+                    VALUE self, ID mid, VALUE klass) {
+
+      if (NIL_P(optimizer_klass))
+        optimizer_klass = rb_path2class("ZenOptimizer");
+      if (NIL_P(data))
+        data = rb_cv_get(optimizer_klass, "@@data");
+      if (NIL_P(skip))
+        skip = rb_cv_get(optimizer_klass, "@@skip");
+      if (threshold == 0)
+        threshold = NUM2ULONG(rb_cv_get(optimizer_klass, "@@threshold"));
+
+      switch (event) {
+      case RUBY_EVENT_CALL:
+        {
+          VALUE signature;
+    
+    #if 0
+          VALUE mod_name = rb_mod_name(klass);
+          if (NIL_P(mod_name))
+            signature = rb_str_new2("Unknown");
+          else
+            signature = mod_name;
+    
+          rb_str_cat(signature, ".", 1); // TODO: # or .
+
+          char * meth = rb_id2name(mid);
+          if (meth) {
+            size_t len = strlen(meth);
+            rb_str_cat(signature, meth, len);
+          } else {
+            rb_str_cat(signature, "unknown", 7);
+          }
+    #else
+          signature = rb_ary_new2(2);
+          rb_ary_store(signature, 0, klass);
+          rb_ary_store(signature, 1, ID2SYM(mid));
+    #endif
+
+          unsigned long count = NUM2ULONG(rb_hash_aref(data, signature)) + 1;
+
+          if (count > threshold) {
+            if (! RTEST(rb_hash_aref(skip, signature))) {
+              rb_funcall(optimizer_klass, rb_intern("optimize"), 1, signature);
+            }
+          }
+
+          rb_hash_aset(data, signature, ULONG2NUM(count));
+        }
+        break;
+      }
+    }
+    EOF
+
+    builder.c <<-'EOF'
+      void add_event_hook() {
+        rb_add_event_hook(prof_event_hook, RUBY_EVENT_CALL);
+      }
+    EOF
+
+    builder.c <<-'EOF'
+      void remove_event_hook() {
+        rb_remove_event_hook(prof_event_hook);
+      }
+    EOF
+  end
+end
+
+END { ZenOptimizer::stop_optimizing }
+ZenOptimizer::start_optimizing

data/lib/zenprofile.rb

@@ -0,0 +1,170 @@
+require 'inline'
+require 'singleton'
+
+require 'pp'
+
+class ZenProfiler
+
+  include Singleton
+
+  @@start = @@stack = @@map = nil
+
+  def self.start_profile
+    @@start = self.instance.time_now
+    @@stack = [[0, 0, [nil, :toplevel]], [0, 0, [nil, :dummy]]]
+    @@map = {"#toplevel" => [1, 0.0, 0.0, [nil, "#toplevel"]]}
+    self.instance.add_event_hook
+  end
+
+  def self.stop_profile
+    self.instance.remove_event_hook
+  end
+
+  def self.print_profile(f)
+    stop_profile
+    total = self.instance.time_now - @@start
+    if total == 0 then total = 0.01 end
+    @@map["#toplevel"][1] = total
+    data = @@map.values
+    data.sort!{|a,b| b[2] <=> a[2]} # TODO: change to sort_by
+    sum = 0
+
+    f.printf "  %%   cumulative   self              self     total\n"           
+    f.printf " time   seconds   seconds    calls  ms/call  ms/call  name\n"
+    for d in data
+      sum += d[2]
+      klass = d[3].first
+      meth  = d[3].last.to_s
+
+      signature = if klass.nil?
+                    meth
+                  elsif klass.kind_of?(Class)
+                    klass.to_s.sub(/#<\S+:(\S+)>/, '\\1') + "#" + meth
+                  else
+                    klass.class.name + "." + meth
+                  end
+
+      f.printf "%6.2f %8.2f  %8.2f %8d ", d[2]/total*100, sum, d[2], d[0]
+      f.printf "%8.2f %8.2f  %s\n", d[2]*1000/d[0], d[1]*1000/d[0], signature
+    end
+  end
+
+  ############################################################
+  # Inlined Methods:
+
+  inline(:C) do |builder|
+
+    builder.add_type_converter("rb_event_t", '', '')
+    builder.add_type_converter("ID", '', '')
+    builder.add_type_converter("NODE *", '', '')
+
+    builder.include '"ruby.h"'
+    builder.include '"node.h"'
+
+    builder.prefix "
+static VALUE profiler_klass = Qnil;
+static VALUE stack = Qnil;
+static VALUE map = Qnil;
+"
+
+    builder.c_raw <<-'EOF'
+    VALUE time_now() {
+      return rb_float_new(((double) clock() / CLOCKS_PER_SEC));
+    }
+    EOF
+
+    builder.c_raw <<-'EOF'
+    static void
+    prof_event_hook(rb_event_t event, NODE *node,
+                    VALUE self, ID mid, VALUE klass) {
+
+      static int profiling = 0;
+
+      if (mid == ID_ALLOCATOR) return;
+      if (profiling) return;
+      profiling++;
+
+      if (NIL_P(profiler_klass))
+        profiler_klass = rb_path2class("ZenProfiler");
+      if (NIL_P(stack))
+        stack = rb_cv_get(profiler_klass, "@@stack");
+      if (NIL_P(map))
+        map   = rb_cv_get(profiler_klass, "@@map");
+
+      switch (event) {
+      case RUBY_EVENT_CALL:
+      case RUBY_EVENT_C_CALL:
+        {
+          VALUE signature;
+          signature = rb_ary_new2(2);
+          rb_ary_store(signature, 0, klass);
+          rb_ary_store(signature, 1, ID2SYM(mid));
+          VALUE time = rb_ary_new();
+          rb_ary_push(time, time_now());
+          rb_ary_push(time, rb_float_new(0.0));
+          rb_ary_push(time, signature);
+          rb_ary_push(stack, time);
+        }
+        break;
+      case RUBY_EVENT_RETURN:
+      case RUBY_EVENT_C_RETURN:
+        {
+        VALUE now = time_now();
+        VALUE tick = rb_ary_pop(stack);
+
+        VALUE signature = rb_ary_entry(tick, -1);
+        
+        VALUE data = Qnil;
+        st_lookup(RHASH(map)->tbl, signature, &data);
+        if (NIL_P(data)) {
+          data = rb_ary_new();
+          rb_ary_push(data, INT2FIX(0));
+          rb_ary_push(data, rb_float_new(0.0));
+          rb_ary_push(data, rb_float_new(0.0));
+          rb_ary_push(data, signature);
+          rb_hash_aset(map, signature, data);
+        }
+
+        rb_ary_store(data, 0, ULONG2NUM(NUM2ULONG(rb_ary_entry(data, 0)) + 1));
+
+        double cost = NUM2DBL(now) - NUM2DBL(rb_ary_entry(tick, 0));
+
+        rb_ary_store(data, 1, rb_float_new(NUM2DBL(rb_ary_entry(data, 1))
+                                           + cost));
+        rb_ary_store(data, 2, rb_float_new(NUM2DBL(rb_ary_entry(data, 2))
+                                           + cost
+                                           - NUM2DBL(rb_ary_entry(tick, 1))));
+
+        VALUE toplevel = rb_ary_entry(stack, -1);
+        VALUE tl_stats = rb_ary_entry(toplevel, 1);
+        long n = NUM2DBL(tl_stats) + cost;
+        rb_ary_store(toplevel, 1, rb_float_new(n));
+        }
+        break;
+      }
+      profiling--;
+    }
+    EOF
+
+    builder.c <<-'EOF'
+      void add_event_hook() {
+        rb_add_event_hook(prof_event_hook,
+                          RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
+                          RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN);
+      }
+    EOF
+
+    builder.c <<-'EOF'
+      void remove_event_hook() {
+        rb_remove_event_hook(prof_event_hook);
+      }
+    EOF
+
+  end
+
+end
+
+END {
+  ZenProfiler::print_profile(STDOUT)
+}
+ZenProfiler::start_profile

data/misc/factorial.rb

@@ -0,0 +1,26 @@
+#!/usr/local/bin/ruby -w
+
+class Factorial
+
+  def factorial(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    return f
+  end
+
+end
+
+f = Factorial.new()
+
+max = ARGV.shift || 1000000
+max = max.to_i
+
+tstart = Time.now
+
+(1..max).each { |m| n = f.factorial(5); }
+
+tend = Time.now
+
+total = tend - tstart
+avg = total / max
+printf "Iter = #{max}, T = %.8f sec, %.8f sec / iter\n", total, avg

data/misc/find_c_methods

@@ -0,0 +1,49 @@
+#!/usr/local/bin/ruby -w
+
+require 'pp'
+
+class PP
+  module PPMethods
+    alias old_pp_hash pp_hash
+    def pp_hash(obj)
+      group(1, '{', '}') {
+        seplist(obj, nil, :each_pair) {|k, v|
+          group {
+            pp k
+            text ' => '
+            group(1) {
+              breakable ''
+              pp v
+            }
+          }
+        }
+      }
+    end
+  end
+end
+
+# KLASSES[klass] = c_name
+KLASSES = {}
+
+# METHODS[klass][ruby_name] = c_name
+METHODS = Hash.new { |h,k| h[k] = {} }
+
+Dir.chdir ARGV.shift do
+  Dir['*.c'].each do |c_file|
+    File.open c_file do |fp|
+      fp.each_line do |line|
+        case line
+        when /([^ ]+)\s+=\srb_define_class\("([^"]+)"/ then
+          KLASSES[$1] = $2
+        when /rb_define_method\(([^,]+),\s+"([^"]+)",\s+([^,]+), (-?\d+)/ then
+          klass = KLASSES[$1]
+          METHODS[klass][$2.intern] = $3, $4.to_i
+        end
+      end
+    end
+  end
+end
+
+print "RUBY_C_METHOD_MAP = "
+pp METHODS
+

data/misc/fixloops-bad.rb

@@ -0,0 +1,62 @@
+#!/usr/local/bin/ruby -w
+
+# Refax automatic refactoring system by Rudi Cilibrasi (cilibrar@gmail.com)
+# A simple example test of the new ParseTree library.
+#
+# This program is meant to suggest possible refactoring opportunities
+#
+# to convert loops of the form
+# stmt A
+# stmt B
+# stmt C
+# while cond
+#   stmt A
+#   stmt B
+#   stmt C
+# end
+#
+# to
+#
+# begin
+#   stmt A
+#   stmt B
+#   stmt C
+# end while cond
+#
+# to use this system, just put
+#
+# require 'fixloops'
+# at the bottom of your ruby source file after requiring all classes to check
+#
+# ParseTree notes:
+# 1) How can you distinguish while loops with preconditions
+# versus those with postconditional guards?  It looks like the parse tree
+# is showing them the same at this moment.
+# 2) Trying to parse_tree(Object) throws a nil ptr
+
+
+# And here is an example hastily.rb that can be refactored using it:
+# Example Ruby program to test automatic refactoring engine based on ParseTree
+# by Rudi Cilibrasi (cilibrar@gmail.com)
+
+class HastilyWritten
+  def keepgoing() rand(2) == 0 end
+  def doSomethingWeird() puts "zzzzz" end
+  def weirdfunc
+    puts "This is a weird loop"
+    doSomethingWeird()
+    while keepgoing
+      puts "This is a weird loop"
+      doSomethingWeird()
+    end
+  end
+  def finefunc
+    begin
+      puts "This is a weird loop"
+      doSomethingWeird()
+    end while keepgoing
+  end
+end
+
+# Here is the line you need to use Refax automatic refactoring system
+require 'fixloops'