silhouette 1.0.0

data/Manifest.txt

@@ -0,0 +1,10 @@
+bin/silhouette
+extconf.rb
+lib/silhouette/processor.rb
+lib/silhouette.rb
+Manifest.txt
+Rakefile
+README
+silhouette_ext.c
+test/silhouette.out
+test/test.rb

data/README

@@ -0,0 +1,57 @@
+
+Here is an example of a generated profile report:
+
+$ silhouette silhouette.out
+Number of threads: 1
+Profiling based on method call.
+Cost of profiler: 0.45 seconds.
+
+Flat profile (0.76 total seconds):
+  %      total     self              self     total
+ time   seconds   seconds    calls  ms/call  ms/call  name
+ 19.74     0.15     0.15     1228     0.12     0.28 Silhouette::DefaultProfiler#process_return
+ 10.53     0.23     0.08        1    80.00   640.00 Silhouette::BinaryEmitter#parse
+  6.58     0.28     0.05     6151     0.01     0.01 Array#[]
+  5.26     0.32     0.04     1229     0.03     0.07 Silhouette::DefaultProfiler#process_call
+  5.26     0.36     0.04     4966     0.01     0.01 IO#read
+  5.26     0.40     0.04     3842     0.01     0.01 Object#===
+  3.95     0.43     0.03     4474     0.01     0.01 Hash#[]
+  ...
+
+Call Tree Profile: 
+index       calls      ms/     self    total
+                      call     sec      sec
+           1228/1        -        -        -    Silhouette::BinaryEmitter#parse [243]
+[256]        1228     0.12     0.15     0.34  Silhouette::DefaultProfiler#process_return
+                2     0.01     0.00     0.02    Array#[] [4]
+                2     0.01     0.00     0.02    Hash#[] [162]
+                1     0.05     0.00     0.06    Silhouette::ProfileNode#add_cost [265]
+                1     0.02     0.00     0.02    Silhouette::ProfileNode#inc_call! [263]
+                2     0.01     0.00     0.02    Array#last [260]
+                1     0.01     0.00     0.02    Hash#[]= [37]
+----------------------------------------------------------------------
+...
+
+ parent called/called child  -    -        -    Parent method name [parent_id]
+              ...
+[method_id] calls     0.03     0.04     0.08  Method name
+     called child     0.02     0.00     0.02    Child method name [child_id]
+              ...
+
+
+Explanation of Call Tree Profile:
+
+For each method profiled, there is an entry that describes the method, it's parents
+and it's direct children. Above we've shown a real world output from the profiler and
+and explanation of each field.
+
+First are listed all the parent methods that called the current method. The only stat
+available for the parent is the number of times the parent was called and the number
+of times the parent called the current method.
+
+Next listed is the current method.
+
+Finally, all the methods directly called by the current method are listed. The calls
+column is only the number of times the current method called the child, not the 
+total number of calls the child received.
+

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+
+$VERBOSE = nil
+
+spec = Gem::Specification.new do |s|
+  s.name = 'silhouette'
+  s.version = '1.0.0'
+  s.summary = 'A 2 stage profiler'
+  s.author = 'Evan Webb'
+  s.email = 'evan@fallingsnow.net'
+
+  s.has_rdoc = true
+  s.files = File.read('Manifest.txt').split($/)
+  s.require_path = 'lib'
+  s.executables = ['silhouette']
+  s.default_executable = 'silhouette'
+  s.extensions = ['extconf.rb']
+end
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]
+
+# vim: syntax=Ruby
+

data/bin/silhouette

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'silhouette/processor'
+
+output = nil
+max = nil
+entry = nil
+depth = nil
+ascii = nil
+long = false
+callsite = false
+gzip = false
+processed = nil
+load = false
+
+STDOUT.sync = true
+
+opt = OptionParser.new do |opt|
+=begin
+    opt.on("-o FILE", "Where to output data") { |output| }
+    opt.on("-c", "--combine", "Combine multiple data files.") do
+        data = Hash.new
+        ARGV.each do |file|
+            print "#{file}: "
+            rp = Silhouette.new(file)
+            rp.data = data
+            rp.parse
+            puts "done."
+        end
+        
+        File.open(output, "w") do |f|
+            f << Marshal.dump(data)
+        end
+        puts "Data saved to #{output}. #{data.keys.size} data points."
+        exit
+    end
+=end
+    opt.on("-m", "--max MAX", "Only show the top N call sites") do |m|
+        max = m.to_i
+    end
+
+    opt.on("-e SIG","Only profile calls made from +SIG+") do |e|
+        entry = e
+    end
+
+    opt.on("-d DEPTH", "Only process calls +DEPTH+ levels down") do |o|
+        depth = o.to_i
+    end
+    
+    opt.on("-s", "--site", "Profile based on method call and call site") do |o|
+        callsite = true 
+    end
+    
+    opt.on("-a OUT", "Convert a binary profile file to an ASCII one") do |a|
+        ascii = a
+    end
+    
+    opt.on("-l", "Use the long format for the ASCII profile") do |l|
+        long = true
+    end
+    
+    opt.on("-z", "Use GZIP when reading data") do |z|
+        gzip = z
+    end
+    
+    opt.on("-p FILE", "Process the profile data and save the processed data") do |o|
+        processed = o
+        STDERR.puts "Saving processed data to #{processed}"
+    end
+    
+    opt.on("-r FILE", "Load data and process directly") do |o|
+        load = o
+    end
+    
+    opt.on("-h", "--help") do
+        puts opt
+        exit 1
+    end
+end
+
+opt.parse!
+
+if load
+    rp = Marshal.load(File.open(load))
+    rp.print(STDOUT, max)
+    exit
+end
+
+
+unless file = ARGV.shift
+    STDERR.puts "Please specify a file to process."
+end
+
+io = File.open(file)
+
+if gzip
+    require 'zlib'
+    io = Zlib::GzipReader.new(io)
+end
+
+emit = Silhouette.find_emitter(io)
+
+if ascii
+    if long
+        ap = Silhouette::ASCIIConverterLong.new(ascii)
+    else
+        ap = Silhouette::ASCIIConverter.new(ascii)
+    end
+    puts "Saving ASCII profile to #{ascii} using #{ap.class}"
+    emit.processor = ap
+    emit.parse
+    ap.close
+    puts "Saved."
+    exit
+end
+
+if entry
+    rp = Silhouette::EntryPointProfiler.new(file, entry, depth)
+else
+    rp = Silhouette::DefaultProfiler.new(callsite)
+end
+emit.processor = rp
+emit.parse
+if processed
+    rp.save(processed)
+    STDERR.puts "Saved data to #{processed}."
+end
+rp.print(STDOUT,max)

data/extconf.rb

@@ -0,0 +1,18 @@
+require "mkmf"
+
+if RUBY_VERSION >= "1.9"
+  if RUBY_RELEASE_DATE < "2005-03-17"
+    STDERR.print("Ruby version is too old\n")
+    exit(1)
+  end
+elsif RUBY_VERSION >= "1.8"
+  if RUBY_RELEASE_DATE < "2005-03-22"
+    STDERR.print("Ruby version is too old #{RUBY_RELEASE_DATE}\n")
+    exit(1)
+  end
+else
+  STDERR.print("Ruby version is too old\n")
+  exit(1)
+end
+
+create_makefile("silhouette_ext")

data/lib/silhouette.rb

@@ -0,0 +1,16 @@
+
+require "silhouette_ext"
+
+at_exit {
+    STDERR.puts "Flushing profile information..."
+    Silhouette.stop_profile
+}
+
+if ENV["SILHOUETTE_FILE"]
+    file = ENV["SILHOUETTE_FILE"]
+else
+    file = "silhouette.out"
+end
+
+STDERR.puts "Logging profile information to #{file}"
+Silhouette.start_profile file

data/lib/silhouette/processor.rb

@@ -0,0 +1,653 @@
+require 'pp'
+
+module Silhouette
+    
+    class InvalidFormat < Exception; end
+    
+    def self.emitters
+        out = []
+        constants.each do |name|
+            con = const_get(name)
+            if Class === con and con.superclass == Emitter
+                out << con
+            end
+        end
+        out
+    end
+    
+    def self.find_emitter(io)
+        if io.kind_of? String
+            raise "Unknown file" unless File.exists?(io)
+            io = File.open(io)
+        end
+        
+        emitters.each do |em|
+            begin
+                return em.new(io)
+            rescue InvalidFormat
+            end
+        end
+        
+        raise InvalidFormat, "Unable to find valid emitter"
+    end
+    
+    class Emitter
+        def initialize(processor=nil)
+            @processor = processor
+        end
+        
+        attr_accessor :processor
+    end 
+    
+    class BinaryEmitter < Emitter
+        MAGIC = "<>"
+        
+        def initialize(file, processor=nil)
+            if file.kind_of? String
+                raise "Unknown file" unless File.exists?(file)
+                @io = File.open(file)
+            else
+                @io = file
+            end
+            
+            magic = @io.read(2)
+            raise InvalidFormat unless magic == MAGIC
+            
+            @method_size = "S"
+            @file_size = "S"
+            @ret_call_fmt = "i#{@method_size}#{@file_size}ii"
+            @ret_call_size = 16
+            super(processor)
+        end
+    
+        class DoneParsing < Exception; end
+    
+        def parse
+            begin
+                loop { emit }
+            rescue DoneParsing
+            end
+        end
+        
+        FIXED_SIZE = {
+            ?c => 20,
+            ?r => 20,
+            ?@ => 8
+        }
+    
+        def next_cmd
+            str = @io.read(1)
+            raise DoneParsing unless str
+        
+            cmd = str[0]
+            if [?!, ?*, ?&].include? cmd
+                size = @io.read(4).unpack("i").first
+            else
+                size = FIXED_SIZE[cmd]
+            end
+                
+            [cmd, size, @io.read(size)]
+        end
+        
+        def parse
+            begin
+            # Use "while true" instead of "loop" because loop is
+            # really a method call.
+            while true
+                data = @io.read(1)
+                raise DoneParsing unless data
+        
+                cmd = data[0]
+            
+                # These are hardcoded in here for speed.
+                if cmd == ?r or cmd == ?c
+                    size = @ret_call_size
+                elsif cmd == ?@
+                    size = 8
+                else
+                    size = @io.read(4).unpack("i").first
+                end
+            
+                proc = @processor
+                data = @io.read(size)
+            
+                case cmd
+                when ?r
+                    parts = data.unpack(@ret_call_fmt)
+                    @processor.process_return(*parts)
+                    # return [:return, *parts]
+                when ?c
+                    parts = data.unpack(@ret_call_fmt)
+                    @processor.process_call(*parts)
+                    # return [:call, *parts]
+                when ?!
+                    parts = data.unpack("Z#{size - 8}ii")
+                    @processor.process_start(*parts)
+                    # return [:start, *parts]
+                when ?@
+                    parts = data.unpack("ii")
+                    @processor.process_end(*parts)
+                    # return [:end, *parts]
+                when ?&
+                    parts = data.unpack("ia#{size - 4}")
+                    parts += parts.pop.split("\0")
+                    @processor.process_method(*parts)
+                    # return [:method, *parts]
+                when ?*
+                    parts = data.unpack("iZ#{size - 4}")
+                    @processor.process_file(*parts)
+                    # return [:file, *parts]
+                when ?(
+                    @method_size = "I"
+                    @ret_call_size += 2
+                    @ret_call_fmt = "i#{@method_size}#{@file_size}ii"
+                when ?)
+                    @file_size = "I"
+                    @ret_call_size += 2
+                    @ret_call_fmt = "i#{@method_size}#{@file_size}ii"
+                else
+                    raise "Unknown type '#{cmd.chr}'"
+                end
+            end
+            
+            # This means we're done.
+            rescue DoneParsing
+            end
+        end
+    end
+    
+    class Processor
+        def initialize(emitter)
+            @emitter = emitter
+            @processors = Hash.new
+            methods.grep(/^process_(.*)/) do |meth|
+                @processors[$1.to_sym] = meth.to_sym 
+            end
+        end
+        
+        def run
+            @emitter.parse do |kind, *args|
+                if meth = @processors[kind]
+                    __send__(meth, *args) 
+                end
+            end
+        end
+    end
+    
+    # NOTE: This uses IO#write instead of IO#puts
+    # because IO#write is faster as it does a quick test
+    # to see if the argument is already a string and just
+    # writes it if it is. IO#puts calls respond_to? on 
+    # all arguments to see if they are strings, which is
+    # a lot slower if you do this 20,000 times.
+    class ASCIIConverter < Processor
+        def initialize(file)
+            @io = File.open(file, "w")
+        end
+        
+        def process_start(*args)
+            @io.write "! #{args.join(' ')}\n"
+        end
+        
+        def process_end(*args)
+            @io.write "@ #{args.join(' ')}\n"
+        end
+        
+        def process_method(*args)
+            @io.write "& #{args.join(' ')}\n"
+        end
+        
+        def process_file(*args)
+            @io.write "* #{args.join(' ')}\n"
+        end
+        
+        def process_call(*args)
+            @io.write "c #{args.join(' ')}\n"
+        end
+        
+        def process_return(*args)
+            @io.write "r #{args.join(' ')}\n"
+        end
+        
+        def close
+            @io.close
+        end
+    end
+    
+    class ASCIIConverterLong < ASCIIConverter
+
+        def initialize(file)
+            @methods = Hash.new
+            @files = Hash.new
+            @last_method = nil
+            @last_series = nil
+            @skip_return = false
+            super(file)
+        end
+        def process_method(idx, klass, kind, meth)
+            @methods[idx] = [klass, kind, meth].to_s
+        end
+        
+        def process_file(idx, file)
+            @files[idx] = file
+        end
+
+        def process_call(thread, meth, file, line, clock)
+            @io.puts "c #{thread} #{@methods[meth]} #{@files[file]} #{line} #{clock}"
+        end        
+        
+        def process_return(thread, meth, file, line, clock)
+            @io.puts "r #{thread} #{@methods[meth]} #{clock}"
+        end        
+        
+        def process_call_rep(thread, meth, file, line, clock)
+            if @last_method == [thread, meth, file, line] and @last_series
+                @last_series += 1
+                @skip_return = true
+            else
+                @io.puts "cal #{thread} #{@methods[meth]} #{meth} #{@files[file]} #{line} #{clock}"
+            end
+            
+            @last_method = [thread, meth, file, line]
+        end
+                
+        def process_return_rep(thread, meth, file, line, clock)
+            if @last_method == [thread, meth, file, line]
+                @last_series = 1 unless @last_series
+            elsif @last_series
+                p [thread, meth, @methods[meth]]
+                p @last_method
+                @io.puts "rep #{@last_series}"
+                @last_series = nil
+                @skip_return = false
+            end
+            return if @skip_return
+            @io.puts "ret #{thread} #{@methods[meth]} #{clock}"
+        end
+    end
+
+    class CallTree
+        def initialize
+        end 
+    end
+    
+    class CallNode
+        def initialize
+        end 
+    end
+    
+    class ProfileNode
+        attr_accessor :total_sec, :self_sec, :calls
+        attr_accessor :callers, :children
+        
+        attr_reader :key
+        def initialize(key, children=[])
+            @key = key
+            @total_sec = 0.0
+            @self_sec = 0.0
+            @calls = 0
+            @callers = []
+            @children = children
+        end
+        
+        def inc_call!
+            @calls += 1
+        end
+        
+        def add_cost(cost, last)
+            @total_sec += cost
+            @self_sec += (cost - last)
+        end
+        
+        def percentage(total)
+            @self_sec / total * 100.0
+        end
+        
+        def self_ms_per_call
+            (@self_sec * 1000.0 / @calls)
+        end
+        
+        def total_ms_per_call
+            (@total_sec * 1000.0 / @calls)
+        end
+        
+        alias method key
+    end
+
+    class DefaultProfiler < Processor
+        
+        def initialize(per_callsite=false)
+            @threads = Hash.new
+            @map = Hash.new
+            @cs_map = Hash.new
+            @timestamps = []
+            @clocks = []
+            @pid = nil
+            @total = 0.0
+            @filters = []
+            @methods = Hash.new
+            @files = Hash.new
+            @per_callsite = per_callsite
+        end
+    
+        def stack(thread)
+            @threads[thread] ||= []
+        end
+    
+        attr_reader :directory, :timestamps
+    
+        def data
+            @map
+        end
+    
+        def data=(d)
+            @map = d
+        end
+        
+        def run
+            @emitter.parse do |kind, *args|
+                case kind
+                when :start
+                    @directory, @clock_per_sec, @start_clock = *args
+                when :end
+                    @final_clock, @profiler_cost = *args
+                when :method
+                    idx = args.shift
+                    @methods[idx] = args
+                when :file
+                    idx = args.shift
+                    @files[idx] = args
+                when :call
+                    thread, method, file, line, clock = *args
+                    stack(thread).push [clock, 0.0, method]
+                when :return
+                    thread, method, file, line, clock = *args
+                    if tick = stack(thread).pop
+                        if tick.last != method
+                            STDERR.puts "Unmatched return for #{method} (#{tick.last})"
+                            return
+                        end
+
+                        if @per_callsite
+                            key = [method, loc]
+                        else
+                            key = method
+                        end
+
+                        data = (@map[key] ||= [0, 0.0, 0.0, key])
+                        data[0] += 1
+                        cost = (clock.to_f - tick[0]) / @clock_per_sec
+                        data[2] += cost
+                        data[1] += cost - tick[1]
+                        @total += cost
+
+                        # Add to the callers callee cost.
+                        if last = stack(thread).last
+                            last[1] += cost
+                        end
+                    end
+                end
+            end
+        end
+    
+        def save(file)
+            File.open(file, "w") do |f|
+                f << Marshal.dump(self)
+            end
+        end
+        
+        def process_start(*args)
+            @directory, @clock_per_sec, @start_clock = *args
+        end
+    
+        def process_end(*args)
+            @final_clock, @profiler_cost = *args
+        end
+    
+        def process_method(*args)
+            idx = args.shift
+            @methods[idx] = args
+        end
+    
+        def process_file(*args)
+            idx = args.shift
+            @files[idx] = args
+        end
+    
+        def process_call(thread, method, file, line, clock)
+            st = (@threads[thread] ||= [])
+            st.push [clock, 0.0, [method, file, line], []]
+        end
+    
+        def process_return(thread, method, file, line, clock)
+            st = (@threads[thread] ||= [])
+            if tick = st.pop
+=begin
+                if tick.last != method
+                    STDERR.puts "Unmatched return for #{method} (#{tick.last})"
+                    return
+                end
+                if @per_callsite
+                    key = [method, loc]
+                else
+                    key = method
+                end
+=end
+                cost = (clock.to_f - tick[0]) / @clock_per_sec
+
+                # Add to the callers callee cost and child list.
+                if last = st.last
+                    last[1] += cost
+                    last[3] << method
+                    caller = last[2]
+                else
+                    caller = nil
+                end
+
+                # Record the data for the method.
+                key = method
+                node = (@map[key] ||= ProfileNode.new(key, tick.last))
+                node.inc_call!
+                node.add_cost cost, tick[1]
+                node.callers << caller.first if caller
+                
+#                 data = (@map[key] ||= [0, 0.0, 0.0, key, tick.last, []])
+#                 data[0] += 1
+#                 data[2] += cost
+#                 data[1] += cost - tick[1]
+#                 data[5] << caller.first if caller # Just the method index
+
+                # Record the data for the method at callsite
+#                 key = [method, file, line]
+#                 data = (@cs_map[key] ||= [0, 0.0, 0.0, key, tick.last, caller])
+#                 data[0] += 1
+#                 data[2] += cost
+#                 data[1] += cost - tick[1]
+            
+            end
+        end
+        
+        def print(f=STDERR, max=nil)
+            print_flat_profile(f, max)
+            print_tree_profile(f, max)
+        end
+        
+        def total_seconds
+            (@final_clock - @start_clock  ).to_f / @clock_per_sec
+        end
+        
+        def print_flat_profile(f=STDERR, max=nil)
+            f.puts "Number of threads: #{@threads.size}"
+            if @per_callsite
+                f.puts "Profiling based on method call and call site."
+            else
+                f.puts "Profiling based on method call." 
+            end
+            f.puts "Cost of profiler: #{@profiler_cost.to_f / @clock_per_sec} seconds."
+            
+            total = total_seconds
+            total = 0.01 if total == 0
+            f.puts "\nFlat profile (#{total} total seconds):"
+            data = @map.values
+            data.sort! { |a,b| b.self_sec <=> a.self_sec }
+            # data.sort! { |a,b| b[1] <=> a[1] }
+            sum = 0
+            f.puts "  %      total     self              self     total"
+            f.puts " time   seconds   seconds    calls  ms/call  ms/call  name"
+            count = 0
+            data.each do |node|
+            #data.each do |calls, self_ms, total_ms, sig|
+                sum += node.self_sec
+                
+                prec = node.percentage(total)
+                next if prec < 0.01
+                
+                f.printf "%6.2f ",  prec
+                f.printf "%8.2f ",  sum
+                f.printf "%8.2f ",  node.self_sec
+                f.printf "%8d ",    node.calls
+                f.printf "%8.2f ",  node.self_ms_per_call
+                f.printf "%8.2f ",  node.total_ms_per_call
+                f.puts get_name(node.method)
+            
+                count += 1
+                return if max and count > max
+            end
+        end
+        
+        def collapse_children(cl, map)
+            out = Hash.new { |h,k| h[k] = 0 }
+
+            # p cl
+            cl.each do |c|
+                out[c] += 1
+            end
+            
+            data = []
+            out.each do |meth,times|
+                # ch_ms = (map[meth][1] * 1000) / map[meth][0]
+                data << [meth, times, map[meth]]
+            end
+            
+            data.sort! { |a,b| b[2].self_sec <=> a[2].self_sec }
+            data
+        end
+        
+        def show_callers(callers, map)
+        end
+        
+        def print_tree_profile(f=STDERR, max=nil)
+            width = 40
+            f.puts
+            f.puts "Call Tree Profile: "
+            f.puts "index       calls      ms/     self    total"
+            f.puts "                      call     sec      sec"
+            map = @map
+
+            data = map.values
+            data.sort! { |a,b| b.self_sec <=> a.self_sec }
+            data.each do |pn|
+                next if pn.total_ms_per_call < 0.01
+                data = collapse_children(pn.callers, map)
+
+                data.each do |meth, called_times, cn|
+                    times = map[meth].children.find_all { |i| i == pn.method }.size
+                    if times == 0
+                        times = "?"
+                    else
+                        called_times = called_times / times
+                    end
+                    vars = ["", "#{times}/#{called_times}", "-", "-", 
+                        "-", get_name(cn.method)]
+                    f.puts "%-2s %14s %8s %8s %8s    %s [#{meth}]" % vars
+                end
+
+                cl = collapse_children(pn.children, map)
+                chlines = []
+                sum = 0
+                cl.each do |meth, times, cn|
+                    self_ms = cn.total_ms_per_call * times
+                    sum += self_ms
+                    self_sec = self_ms.to_f / 1000
+                    total = self_sec * pn.calls
+                    
+                    next if total < 0.01
+                    vars = ["", times, cn.total_ms_per_call, 
+                        self_sec, total, get_name(cn.method)]
+                    chlines << "%-8s %8d %8.2f %8.2f %8.2f    %s [#{meth}]" % vars
+                end
+                vars = ["[#{pn.method}]", pn.calls, 
+                    pn.self_ms_per_call, pn.self_sec, pn.total_sec, 
+                    get_name(pn.method)]
+                f.puts "%-8s %8d %8.2f %8.2f %8.2f  %s" % vars
+                f.puts *chlines if chlines.size > 0
+                f.puts "-" * 70
+            end
+        end
+    
+        def get_name(info, per_cs=false)
+            if per_cs
+                @methods[info.first].to_s + " @ " + @files[info[1]].to_s + ":#{info[2]}"
+            else
+                @methods[info].to_s
+            end
+        end
+    end
+
+    class EntryPointProfiler < DefaultProfiler
+        def initialize(file, sig, depth=nil)
+            super(file)
+            @entry = sig
+            @start = Hash.new { |h,k| h[k] = false }
+            @max_depth = depth
+            @depth = Hash.new { |h,k| h[k] = 0 }
+        end
+
+        def process_call(thread, klass, kind, method, time)
+            #return unless thread == "b7533c3c"
+            if @entry == [klass, kind, method].to_s
+                @start[thread] = true
+                STDERR.puts "entered #{@entry} at #{time} in #{thread}"
+                return
+            end
+            
+            return unless @start[thread]
+           
+            # puts "#{[klass, kind, method]} (#{@depth[thread]})"
+
+            @depth[thread] += 1
+
+            #puts "call"
+            #p @depth
+            return if @max_depth and @depth[thread] > @max_depth
+            # puts "call: #{@depth} #{[klass, kind, method]}"
+            super
+        end
+
+        def process_return(thread, klass, kind, method, time)
+            #return unless thread == "b7533c3c"
+            if @entry == [klass, kind, method].to_s
+                @start[thread] = false
+                STDERR.puts "exitted #{@entry} at #{time} in #{thread}"
+                return
+            end
+
+            return unless @start[thread]
+            
+            if !@max_depth or @depth[thread] <= @max_depth
+                super
+            end
+            
+            @depth[thread] -= 1
+        end
+
+        def print(f=STDERR,max=nil)
+            f.puts "Calls only shown if performed from #{@entry}."
+            if @max_depth
+                f.puts "Calls only processed #{@max_depth} level(s) deep."
+            end
+            f.puts
+            super
+        end
+    end
+end

data/silhouette_ext.c

@@ -0,0 +1,254 @@
+
+#include <time.h>
+#ifdef HAVE_SYS_TIMES_H
+#include <sys/times.h>
+#endif
+#include <unistd.h>
+#include <ruby.h>
+#include <node.h>
+#include <st.h>
+#include <limits.h>
+
+static FILE *pro_file;
+static struct timeval global_tv;
+static int profiling_pid;
+static st_table *method_tbl;
+static st_table *file_tbl;
+static char *time_magic = "@";
+static char *start_magic = "!";
+static char *binary_magic = "<>";
+static char *method_magic = "&";
+static char *file_magic = "*";
+static char *call_magic = "c";
+static char *return_magic = "r";
+static char *null_ptr = "\0";
+static int profiler_cost = 0;
+static char *method_size_magic = "(";
+static char *file_size_magic = ")";
+static int method_idx_size = 0;
+static int file_idx_size = 0;
+
+#define PER_TIME 10
+#define HASH_SIZE 128
+
+#define CLOCK clock()
+#define STR(x) RSTRING(x)->ptr
+
+static void
+extprof_event_hook(rb_event_t event, NODE *node,
+	VALUE self, ID mid, VALUE in_klass) {
+
+    static int profiling = 0;
+	static char *method, *s_klass;
+	static char *kind, *file;
+	static int line;
+	static VALUE klass;
+	static char method_ent[1024];
+	static char file_ent[1024];
+	static int method_idx = 1;
+	static int file_idx = 1;
+	unsigned int current_clock = CLOCK;
+	unsigned int i, j, m_idx, f_idx, size;
+	unsigned short s_m_idx, s_f_idx;
+
+	if(!mid) return;
+
+	method = rb_id2name(mid);
+	if(!method) {
+		method = "<undefined>";
+	}
+
+	/* If we've forked, dont profile anymore. */
+	if(getpid() != profiling_pid) {
+		return;
+	}
+
+    if (mid == ID_ALLOCATOR) return;
+    if (profiling) return;
+    profiling++;
+    
+	if(rb_obj_is_kind_of(self, rb_cModule)) {
+	    kind = ".";
+	    klass = rb_class_name(self);
+	    i = RSTRING(klass)->len;
+	    s_klass = RSTRING(klass)->ptr;
+	    memcpy(method_ent, s_klass, i);
+	    *(method_ent + i) = '.';
+	} else {
+	    kind = "#";
+	    klass = rb_class_name(in_klass);
+	    i = RSTRING(klass)->len;
+	    s_klass = RSTRING(klass)->ptr;
+	    memcpy(method_ent, s_klass, i);
+	    *(method_ent + i) = '#';
+	}
+	
+	j = strlen(method);
+	
+	memcpy(method_ent + i + 1, method, j);
+	*(method_ent + i + 1 + j) = 0;
+		
+	// sprintf(method_ent, "%s%s%s", s_klass, kind, method);
+	if(!st_lookup(method_tbl, (st_data_t)method_ent, (st_data_t*)&m_idx)) {
+	    m_idx = ++method_idx;
+	    if(method_idx > USHRT_MAX) {
+	        method_idx_size = 1;
+	        fwrite(&method_size_magic, 1, 1, pro_file);
+	    }
+	    st_insert(method_tbl, (st_data_t)method_ent, method_idx);
+	    fwrite(method_magic, 1, 1, pro_file);
+	    size = 4 + RSTRING(klass)->len + 4 + j;
+	    fwrite(&size, 4, 1, pro_file);
+	    fwrite(&method_idx, 4, 1, pro_file);
+	    fwrite(RSTRING(klass)->ptr, RSTRING(klass)->len, 1, pro_file);
+	    fwrite(null_ptr, 1, 1, pro_file);
+	    fwrite(kind, 1, 1, pro_file);
+	    fwrite(null_ptr, 1, 1, pro_file);
+	    fwrite(method, j, 1, pro_file);
+	    fwrite(null_ptr, 1, 1, pro_file);
+	    // fprintf(pro_file, "& %d %s %s %s\n", method_idx, s_klass, kind, method);
+	}
+	
+	if(node) {
+	    file = node->nd_file;
+	    line = nd_line(node);
+	    // sprintf(file_ent, "%s:%d", node->nd_file, nd_line(node));
+	    if(!st_lookup(file_tbl, (st_data_t)(node->nd_file), (st_data_t*)&f_idx)) {
+    	    f_idx = ++file_idx;
+    	    if(file_idx > USHRT_MAX) {
+    	        file_idx_size = 1;
+    	        fwrite(&file_size_magic, 1, 1, pro_file);
+    	    }
+    	    st_insert(file_tbl, (st_data_t)(node->nd_file), file_idx);
+    	    fwrite(file_magic, 1, 1, pro_file);
+    	    j = strlen(node->nd_file);
+    	    size = j + 5;
+    	    fwrite(&size, 4, 1, pro_file);
+    	    fwrite(&file_idx, 4, 1, pro_file);
+    	    fwrite(node->nd_file, j + 1, 1, pro_file);
+    	    //fprintf(pro_file, "* %d %s\n", file_idx, node->nd_file);
+    	}
+    } else {
+        file = "<unknown>";
+        line = 0;
+        f_idx = 0;
+	}
+#define PL_S(type) fprintf(pro_file, #type " %x %d %d %d\n", (int)rb_thread_current(), \
+            m_idx, f_idx, CLOCK);
+#define PL(type) fprintf(pro_file, #type " %x %s %s %s %d\n", (int)rb_thread_current(), \
+		    STR(rb_class_name(klass)), kind, method, CLOCK)
+#define PL_EXT(type) fprintf(pro_file, #type " %x %s %x %s %s %s %d %f\n", (int)rb_thread_current(), \
+		    STR(rb_class_name(klass)), (int)self, kind, method, file, line, CLOCK)
+    
+    switch(event) {
+    case RUBY_EVENT_RETURN:
+    case RUBY_EVENT_C_RETURN:
+    	fwrite(return_magic, 1, 1, pro_file);
+    	goto output;	
+	case RUBY_EVENT_CALL:
+	case RUBY_EVENT_C_CALL:
+	    fwrite(call_magic, 1, 1, pro_file);
+output:
+	    j = (int)rb_thread_current();
+	    fwrite(&j, 4, 1, pro_file);
+	    
+	    if(method_idx_size) {
+	        fwrite(&m_idx, sizeof(m_idx), 1, pro_file);
+        } else {
+            s_m_idx = m_idx;
+            fwrite(&s_m_idx, sizeof(s_m_idx), 1, pro_file);
+        }
+        
+        if(file_idx_size) {
+	        fwrite(&f_idx, sizeof(f_idx), 1, pro_file);
+	    } else {
+	        s_f_idx = f_idx;
+	        fwrite(&s_f_idx, sizeof(s_f_idx), 1, pro_file);
+	    }
+	    
+	    if(node) {
+	        j = nd_line(node);
+        } else {
+            j = 0;
+        }
+	    fwrite(&j, 4, 1, pro_file);
+	    fwrite(&current_clock, 4, 1, pro_file);
+		break;
+    }
+    
+    profiler_cost = profiler_cost + (CLOCK - current_clock);
+    profiling--;
+}
+
+static VALUE extprof_start(int argc, VALUE *argv, VALUE self) {
+	struct timeval tv;
+	char path[1024];
+	int size, i;
+
+	if(argc == 0) {
+		pro_file = fopen("silhouette.out","w");
+	} else {
+		StringValue(argv[0]);
+		pro_file = fopen(STR(argv[0]), "w");
+	}
+
+	profiling_pid = getpid();
+
+	method_tbl = st_init_strtable_with_size(HASH_SIZE);
+	file_tbl = st_init_strtable_with_size(HASH_SIZE);
+
+	getcwd(path, 1023);
+	size = strlen(path);
+	path[size] = 0;
+	
+	fwrite(binary_magic, 2 ,1 , pro_file);
+	fwrite(start_magic, 1, 1, pro_file);
+	i = size + 9;
+	fwrite(&i, 4, 1, pro_file);
+	fwrite(path, size + 1, 1, pro_file);
+	i = CLOCKS_PER_SEC;
+	fwrite(&i, 4, 1, pro_file);
+	i = CLOCK;
+	fwrite(&i, 4, 1, pro_file);
+	// fprintf(pro_file, "! %s %d %d\n", getcwd(path, 1023), getpid(),
+	//    CLOCKS_PER_SEC);
+	/*
+	gettimeofday(&tv, NULL);
+	fprintf(pro_file, "@ %d %d %d\n", (int)tv.tv_sec, 
+	    (int)tv.tv_usec, CLOCK);
+	 */   
+    rb_add_event_hook(extprof_event_hook,
+	    RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
+	    RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN);
+	    
+	return Qtrue;
+}
+
+static VALUE extprof_end(VALUE self) {
+	struct timeval tv;
+	int i;
+    
+	rb_remove_event_hook(extprof_event_hook);
+	
+	fwrite(time_magic, 1, 1, pro_file);
+	i = CLOCK;
+	fwrite(&i, 4, 1, pro_file);
+	fwrite(&profiler_cost, 4, 1, pro_file);
+	/*
+	gettimeofday(&tv, NULL);
+	fprintf(pro_file, "@ %d %d %d\n", (int)tv.tv_sec,
+	    (int)tv.tv_usec, CLOCK);
+	*/    
+	fflush(pro_file);
+	fclose(pro_file);
+	return Qtrue;
+}
+
+void Init_silhouette_ext() {
+	VALUE extprof;
+	extprof = rb_define_module("Silhouette");
+	rb_define_singleton_method(extprof, "start_profile", extprof_start, -1);
+	rb_define_singleton_method(extprof, "stop_profile", extprof_end, 0);
+}
+
+/* vim: set filetype=c ts=4 sw=4 noexpandtab : */

data/test/test.rb

@@ -0,0 +1,33 @@
+
+def plus
+    1 + 1
+end
+
+def blah
+    100.times { plus }
+    100.times { plus }
+    bleh
+end
+
+def bleh
+    bloh
+end
+
+def bloh
+end
+
+
+def one
+    blah
+end
+
+def two
+    blah
+end
+
+begin
+    one
+    two
+    two
+rescue
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: silhouette
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2005-12-06 00:00:00 -08:00
+summary: A 2 stage profiler
+require_paths: 
+  - lib
+email: evan@fallingsnow.net
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: silhouette
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Evan Webb
+files: 
+  - bin/silhouette
+  - extconf.rb
+  - lib/silhouette/processor.rb
+  - lib/silhouette.rb
+  - Manifest.txt
+  - Rakefile
+  - README
+  - silhouette_ext.c
+  - test/silhouette.out
+  - test/test.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: 
+  - silhouette
+extensions: 
+  - extconf.rb
+requirements: []
+dependencies: []