silhouette 1.0.0 → 2.0.0

data/lib/silhouette/processor.rb

@@ -1,161 +1,7 @@
 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
@@ -172,97 +18,26 @@ module Silhouette
                 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"
+        def process_start(*a)
         end
         
-        def process_end(*args)
-            @io.write "@ #{args.join(' ')}\n"
+        def process_end(*a)
         end
         
-        def process_method(*args)
-            @io.write "& #{args.join(' ')}\n"
+        def process_method(*a)
         end
         
-        def process_file(*args)
-            @io.write "* #{args.join(' ')}\n"
+        def process_file(*a)
         end
         
-        def process_call(*args)
-            @io.write "c #{args.join(' ')}\n"
+        def process_line(*a)
         end
         
-        def process_return(*args)
-            @io.write "r #{args.join(' ')}\n"
+        def process_call(*a)
         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}"
+        def process_return(*a)
         end
     end
 
@@ -343,53 +118,7 @@ module Silhouette
         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)

data/lib/silhouette/setup.rb

@@ -0,0 +1,102 @@
+require "silhouette_ext"
+
+class Silhouette::Options
+  
+  def initialize
+    @compress = true
+    @follow_lines = false
+    @file = "silhouette.out"
+    @coverage = false
+    @all = false
+    @describe = false
+    @location = false
+  end
+  
+  attr_accessor :compress, :follow_lines, :file, :coverage
+  attr_accessor :all, :describe, :location
+  
+  def detect_compressor(file)
+    `which bzip2`
+    if $?.exitstatus == 0
+      file.replace "#{file}.bz2"
+      return "bzip2 -c > #{file}"
+    end
+    
+    `which gzip`
+    if $?.exitstatus == 0
+      file.replace "#{file}.gz"
+      return "gzip -c > #{file}"
+    end
+    return nil
+  end
+  
+  def import_env
+    if ENV["SILHOUETTE_FILE"]
+      @file = ENV["SILHOUETTE_FILE"]
+    end
+    
+    if ENV["NO_COMPRESS"]
+      @compress = false
+    end
+    
+    if ENV["FOLLOW_LINES"]
+      @follow_lines = true
+    end
+    
+    if ENV["COVERAGE"]
+      @coverage = true
+    end
+    
+    if ENV["ALL"]
+      @all = true
+    end
+  end
+  
+  def setup_args
+    args = []
+
+    gzip = nil
+    
+    output = @file
+    
+    unless IO === @file
+      if @compress
+        compress = detect_compressor(file)
+        if compress
+          gzip = IO.popen(compress, "w")
+          output = gzip
+        else
+          # Couldn't auto detect a compressor.
+        end
+      end
+    end
+    
+    args << output
+
+    if @follow_lines
+      args << true
+    end
+
+    if @coverage
+      if @describe
+        STDERR.puts "Generating coverage information only."
+      end
+      args << Silhouette::COVERAGE
+    end
+
+    if @all
+      args << Silhouette::ALL
+    end
+    
+    unless @location
+      @location = @file
+    end
+
+    at_exit {
+      Silhouette.stop_profile
+      STDERR.puts "Flushed profile information to #{@location}"
+    }
+    
+    return [args, @location]
+  end
+end

data/silhouette_ext.c

@@ -21,12 +21,16 @@ static char *method_magic = "&";
 static char *file_magic = "*";
 static char *call_magic = "c";
 static char *return_magic = "r";
+static char *line_magic = "l";
 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;
+static int emit_lines = 0;
+static int last_file = -1;
+static int last_line = -1;
 
 #define PER_TIME 10
 #define HASH_SIZE 128
@@ -51,13 +55,6 @@ extprof_event_hook(rb_event_t event, NODE *node,
 	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;
@@ -67,6 +64,15 @@ extprof_event_hook(rb_event_t event, NODE *node,
     if (profiling) return;
     profiling++;
     
+    if(!mid) {
+	    method = "(main)";
+    } else {
+    	method = rb_id2name(mid);
+    	if(!method) {
+    		method = "<undefined>";
+    	}
+	}
+    
 	if(rb_obj_is_kind_of(self, rb_cModule)) {
 	    kind = ".";
 	    klass = rb_class_name(self);
@@ -76,6 +82,9 @@ extprof_event_hook(rb_event_t event, NODE *node,
 	    *(method_ent + i) = '.';
 	} else {
 	    kind = "#";
+	    if(!in_klass) {
+	        in_klass = rb_cObject;
+	    }
 	    klass = rb_class_name(in_klass);
 	    i = RSTRING(klass)->len;
 	    s_klass = RSTRING(klass)->ptr;
@@ -112,7 +121,7 @@ extprof_event_hook(rb_event_t event, NODE *node,
 	if(node) {
 	    file = node->nd_file;
 	    line = nd_line(node);
-	    // sprintf(file_ent, "%s:%d", node->nd_file, nd_line(node));
+	    // printf("%s:%d\n", file, line);
 	    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) {
@@ -139,8 +148,16 @@ extprof_event_hook(rb_event_t event, NODE *node,
 		    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_LINE:
+        /* Suppress double hits on the same file and line. */
+        if(last_file == f_idx && last_line == line)
+            goto done;
+        last_file = f_idx;
+        last_line = line;
+        fwrite(line_magic, 1, 1, pro_file);
+        goto output;
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_C_RETURN:
     	fwrite(return_magic, 1, 1, pro_file);
@@ -166,16 +183,11 @@ output:
 	        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(&line, 4, 1, pro_file);
 	    fwrite(&current_clock, 4, 1, pro_file);
 		break;
     }
-    
+done:
     profiler_cost = profiler_cost + (CLOCK - current_clock);
     profiling--;
 }
@@ -183,13 +195,29 @@ output:
 static VALUE extprof_start(int argc, VALUE *argv, VALUE self) {
 	struct timeval tv;
 	char path[1024];
-	int size, i;
+	int size, i, mask;
+	
+	mask = -1;
+	
+	emit_lines = 0;
 
 	if(argc == 0) {
 		pro_file = fopen("silhouette.out","w");
 	} else {
-		StringValue(argv[0]);
-		pro_file = fopen(STR(argv[0]), "w");
+	    if(rb_obj_is_kind_of(argv[0], rb_cIO)) {
+	        pro_file = fdopen(NUM2INT(
+	            rb_funcall(argv[0], rb_intern("fileno"), 0)), "w");
+	    } else {
+		    StringValue(argv[0]);
+		    pro_file = fopen(STR(argv[0]), "w");
+	    }
+		if(argc == 2) {
+		    if(argv[1] == Qfalse || argv[1] == Qtrue) {
+    		    emit_lines = RTEST(argv[1]);		        
+		    } else {
+		        mask = NUM2INT(argv[1]);
+		    }
+		}
 	}
 
 	profiling_pid = getpid();
@@ -216,10 +244,17 @@ static VALUE extprof_start(int argc, VALUE *argv, VALUE self) {
 	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);
+	 */
+	if(mask == -1) {
+    	mask = RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
+            RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN;
+    
+        if(emit_lines) {
+            mask = mask | RUBY_EVENT_LINE;
+        }
+    }
+    
+    rb_add_event_hook(extprof_event_hook, mask);
 	    
 	return Qtrue;
 }
@@ -247,6 +282,14 @@ static VALUE extprof_end(VALUE self) {
 void Init_silhouette_ext() {
 	VALUE extprof;
 	extprof = rb_define_module("Silhouette");
+	rb_define_const(extprof, "CALL", INT2NUM(RUBY_EVENT_CALL | RUBY_EVENT_RETURN));
+	rb_define_const(extprof, "C_CALL", INT2NUM(RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN));
+	rb_define_const(extprof, "LINE", INT2NUM(RUBY_EVENT_LINE));
+	rb_define_const(extprof, "COVERAGE", INT2NUM(RUBY_EVENT_LINE | RUBY_EVENT_END));
+	rb_define_const(extprof, "CALLS", INT2NUM(RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
+        RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN));
+    rb_define_const(extprof, "ALL", INT2NUM(RUBY_EVENT_ALL));
+    	
 	rb_define_singleton_method(extprof, "start_profile", extprof_start, -1);
 	rb_define_singleton_method(extprof, "stop_profile", extprof_end, 0);
 }