ruby-prof 0.8.1-x86-mingw32

data/ext/ruby_prof/ruby_prof.h

@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2008  Shugo Maeda <shugo@ruby-lang.org>
+ *                     Charlie Savage <cfis@savagexi.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* ruby-prof tracks the time spent executing every method in ruby programming.
+   The main players are:
+
+     prof_result_t     - Its one field, values,  contains the overall results
+     thread_data_t     - Stores data about a single thread.  
+     prof_stack_t      - The method call stack in a particular thread
+     prof_method_t     - Profiling information for each method
+     prof_call_info_t  - Keeps track a method's callers and callees. 
+
+  The final resulut is a hash table of thread_data_t, keyed on the thread
+  id.  Each thread has an hash a table of prof_method_t, keyed on the
+  method id.  A hash table is used for quick look up when doing a profile.
+  However, it is exposed to Ruby as an array.
+  
+  Each prof_method_t has two hash tables, parent and children, of prof_call_info_t.
+  These objects keep track of a method's callers (who called the method) and its
+  callees (who the method called).  These are keyed the method id, but once again,
+  are exposed to Ruby as arrays.  Each prof_call_into_t maintains a pointer to the
+  caller or callee method, thereby making it easy to navigate through the call 
+  hierarchy in ruby - which is very helpful for creating call graphs.      
+*/
+
+/* #define DEBUG */
+
+#ifndef RUBY_PROF_H
+#define RUBY_PROF_H
+
+#include <stdio.h>
+
+#include <ruby.h>
+
+#ifndef RUBY_VM
+#include <node.h>
+#include <st.h>
+typedef rb_event_t rb_event_flag_t;
+#define rb_sourcefile() (node ? node->nd_file : 0)
+#define rb_sourceline() (node ? nd_line(node) : 0)
+#endif
+
+#include "version.h"
+
+/* ================  Constants  =================*/
+#define INITIAL_STACK_SIZE 8
+#define INITIAL_CALL_INFOS_SIZE 2
+
+
+/* ================  Measurement  =================*/
+#ifdef HAVE_LONG_LONG
+typedef unsigned LONG_LONG prof_measure_t; // long long is 8 bytes on 32-bit
+#else
+typedef unsigned long prof_measure_t;
+#endif
+
+#include "measure_process_time.h"
+#include "measure_wall_time.h"
+#include "measure_cpu_time.h"
+#include "measure_allocations.h"
+#include "measure_memory.h"
+#include "measure_gc_runs.h"
+#include "measure_gc_time.h"
+
+static prof_measure_t (*get_measurement)() = measure_process_time;
+static double (*convert_measurement)(prof_measure_t) = convert_process_time;
+
+/* ================  DataTypes  =================*/
+static VALUE mProf;
+static VALUE cResult;
+static VALUE cMethodInfo;
+static VALUE cCallInfo;
+
+/* Profiling information for each method. */
+typedef struct {
+    VALUE klass;                            /* The method's class. */
+    ID mid;                                 /* The method id. */
+    int depth;                              /* The recursion depth. */
+    int key;                                /* Cache calculated key */
+} prof_method_key_t;
+
+struct prof_call_infos_t;
+
+/* Profiling information for each method. */
+typedef struct {
+    prof_method_key_t *key;                 /* Method key */
+    const char *source_file;                /* The method's source file */
+    int line;                               /* The method's line number. */
+    int active;                             /* Is this  recursion depth. */
+    struct prof_call_infos_t *call_infos;   /* Call info objects for this method */
+    VALUE object;                           /* Cahced ruby object */
+} prof_method_t;
+
+/* Callers and callee information for a method. */
+typedef struct prof_call_info_t {
+    prof_method_t *target; /* Use target instead of method to avoid conflict with Ruby method */
+    struct prof_call_info_t *parent;
+    st_table *call_infos;
+    int called;
+    prof_measure_t total_time;
+    prof_measure_t self_time;
+    prof_measure_t wait_time;
+    int line;  
+    VALUE object;
+    VALUE children;
+} prof_call_info_t;
+
+/* Array of call_info objects */
+typedef struct prof_call_infos_t {
+    prof_call_info_t **start;
+    prof_call_info_t **end;
+    prof_call_info_t **ptr;
+    VALUE object;
+} prof_call_infos_t;
+
+
+/* Temporary object that maintains profiling information
+   for active methods - there is one per method.*/
+typedef struct {
+    /* Caching prof_method_t values significantly
+       increases performance. */
+    prof_call_info_t *call_info;
+    prof_measure_t start_time;
+    prof_measure_t wait_time;
+    prof_measure_t child_time;
+    unsigned int line;
+} prof_frame_t;
+
+/* Current stack of active methods.*/
+typedef struct {
+    prof_frame_t *start;
+    prof_frame_t *end;
+    prof_frame_t *ptr;
+} prof_stack_t;
+
+/* Profiling information for a thread. */
+typedef struct {
+    VALUE thread_id;                  /* Thread id */
+    st_table* method_table;           /* Methods called in the thread */
+    prof_stack_t* stack;              /* Active methods */
+    prof_measure_t last_switch;       /* Point of last context switch */
+} thread_data_t;
+
+typedef struct {
+    VALUE threads;
+} prof_result_t;
+
+
+/* ================  Variables  =================*/
+static int measure_mode;
+static st_table *threads_tbl = NULL;
+static st_table *exclude_threads_tbl = NULL;
+
+/* TODO - If Ruby become multi-threaded this has to turn into
+   a separate stack since this isn't thread safe! */
+static thread_data_t* last_thread_data = NULL;
+
+
+/* Forward declarations */
+static VALUE prof_call_infos_wrap(prof_call_infos_t *call_infos);
+static VALUE prof_call_info_wrap(prof_call_info_t *call_info);
+static VALUE prof_method_wrap(prof_method_t *result);
+
+#endif

data/ext/ruby_prof/version.h

@@ -0,0 +1,4 @@
+#define RUBY_PROF_VERSION  "0.8.1"
+#define RUBY_PROF_VERSION_MAJ   0
+#define RUBY_PROF_VERSION_MIN   8
+#define RUBY_PROF_VERSION_MIC   1

data/lib/ruby-prof.rb

@@ -0,0 +1,56 @@
+# require the  .so file
+me = File.dirname(__FILE__) + '/'
+begin
+  # fat binaries
+  require "#{me}/#{RUBY_VERSION[0..2]}/ruby_prof"
+rescue Exception
+  require "#{me}/../ext/ruby_prof/ruby_prof"
+end
+
+require "ruby-prof/method_info"
+require "ruby-prof/call_info"
+require "ruby-prof/aggregate_call_info"
+require "ruby-prof/flat_printer"
+require "ruby-prof/flat_printer_with_line_numbers"
+require "ruby-prof/graph_printer"
+require "ruby-prof/graph_html_printer"
+require "ruby-prof/call_tree_printer"
+require "ruby-prof/symbol_to_proc" # for 1.8's benefit
+#require "ruby-prof/result"
+
+module RubyProf
+  # See if the user specified the clock mode via 
+  # the RUBY_PROF_MEASURE_MODE environment variable
+  def self.figure_measure_mode
+    case ENV["RUBY_PROF_MEASURE_MODE"]
+    when "wall" || "wall_time"
+      RubyProf.measure_mode = RubyProf::WALL_TIME
+    when "cpu" || "cpu_time"
+      if ENV.key?("RUBY_PROF_CPU_FREQUENCY")
+        RubyProf.cpu_frequency = ENV["RUBY_PROF_CPU_FREQUENCY"].to_f
+      else
+        begin
+          open("/proc/cpuinfo") do |f|
+            f.each_line do |line|
+              s = line.slice(/cpu MHz\s*:\s*(.*)/, 1)
+              if s
+                RubyProf.cpu_frequency = s.to_f * 1000000
+                break
+              end
+            end
+          end
+        rescue Errno::ENOENT
+        end
+      end
+      RubyProf.measure_mode = RubyProf::CPU_TIME
+    when "allocations"
+      RubyProf.measure_mode = RubyProf::ALLOCATIONS
+    when "memory"
+      RubyProf.measure_mode = RubyProf::MEMORY
+    else
+      RubyProf.measure_mode = RubyProf::PROCESS_TIME
+    end
+  end
+end
+
+RubyProf::figure_measure_mode

data/lib/ruby-prof/abstract_printer.rb

@@ -0,0 +1,41 @@
+module RubyProf
+  class AbstractPrinter
+    def initialize(result)
+      @result = result
+      @output = nil
+      @options = {}
+    end
+
+    # Specify print options.
+    # 
+    # options - Hash table
+    #   :min_percent - Number 0 to 100 that specifes the minimum
+    #                  %self (the methods self time divided by the
+    #                  overall total time) that a method must take
+    #                  for it to be printed out in the report.
+    #                  Default value is 0.
+    #
+    #   :print_file  - True or false. Specifies if a method's source
+    #                  file should be printed.  Default value if false.
+    #
+    def setup_options(options = {})
+      @options = options
+    end      
+
+    def min_percent
+      @options[:min_percent] || 0
+    end
+    
+    def print_file
+      @options[:print_file] || false
+    end
+    
+    def method_name(method)
+      name = method.full_name
+      if print_file
+        name += " (#{method.source_file}:#{method.line}}"
+      end
+      name
+    end
+  end
+end 

data/lib/ruby-prof/aggregate_call_info.rb

@@ -0,0 +1,62 @@
+module RubyProf
+  class AggregateCallInfo
+    attr_reader :call_infos
+    def initialize(call_infos)
+      if call_infos.length == 0
+        raise(ArgumentError, "Must specify at least one call info.")
+      end
+      @call_infos = call_infos
+    end
+
+    def target
+      call_infos.first.target
+    end
+
+    def parent
+      call_infos.first.parent
+    end
+
+    def line
+      call_infos.first.line
+    end
+
+    def children
+      call_infos.inject(Array.new) do |result, call_info|
+        result.concat(call_info.children)
+      end
+    end
+
+    def total_time
+      aggregate(:total_time)
+    end
+
+    def self_time
+      aggregate(:self_time)
+    end
+
+    def wait_time
+      aggregate(:wait_time)
+    end
+
+    def children_time
+      aggregate(:children_time)
+    end
+
+    def called
+      aggregate(:called)
+    end
+
+    def to_s
+      "#{call_infos.first.full_name}"
+    end
+
+    private
+
+    def aggregate(method_name)
+      self.call_infos.inject(0) do |sum, call_info|
+        sum += call_info.send(method_name)
+        sum
+      end
+    end
+  end
+end

data/lib/ruby-prof/call_info.rb

@@ -0,0 +1,47 @@
+module RubyProf
+  class CallInfo
+    def depth
+      result = 0
+      call_info = self.parent
+
+      while call_info
+        result += 1
+        call_info = call_info.parent
+      end
+      result
+    end
+
+    def children_time
+      children.inject(0) do |sum, call_info|
+        sum += call_info.total_time
+      end
+    end
+
+    def stack
+      @stack ||= begin
+        methods = Array.new
+        call_info = self
+
+        while call_info
+          methods << call_info.target
+          call_info = call_info.parent
+        end
+        methods.reverse
+      end
+    end
+
+    def call_sequence
+      @call_sequence ||= begin
+        stack.map {|method| method.full_name}.join('->')
+      end
+    end
+
+    def root?
+      self.parent.nil?
+    end
+
+    def to_s
+      "#{call_sequence}"
+    end
+  end
+end

data/lib/ruby-prof/call_tree_printer.rb

@@ -0,0 +1,84 @@
+require 'ruby-prof/abstract_printer'
+
+module RubyProf
+  # Generate profiling information in calltree format
+  # for use by kcachegrind and similar tools.
+
+  class CallTreePrinter  < AbstractPrinter
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+        
+      # add a header - this information is somewhat arbitrary
+      @output << "events: "
+      case RubyProf.measure_mode
+        when RubyProf::PROCESS_TIME
+          @value_scale = RubyProf::CLOCKS_PER_SEC;
+          @output << 'process_time'
+        when RubyProf::WALL_TIME
+          @value_scale = 1_000_000
+          @output << 'wall_time'
+        when RubyProf.const_defined?(:CPU_TIME) && RubyProf::CPU_TIME
+          @value_scale = RubyProf.cpu_frequency
+          @output << 'cpu_time'
+        when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
+          @value_scale = 1
+          @output << 'allocations'
+        when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
+          @value_scale = 1
+          @output << 'memory'
+        when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
+          @value_scale = 1
+          @output << 'gc_runs'
+        when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
+          @value_scale = 1000000
+          @output << 'gc_time'
+        else
+          raise "Unknown measure mode: #{RubyProf.measure_mode}"
+      end
+      @output << "\n\n"
+
+      print_threads
+    end
+
+    def print_threads
+      @result.threads.each do |thread_id, methods|
+        print_methods(thread_id, methods)
+      end
+    end
+
+    def convert(value)
+      (value * @value_scale).round
+    end
+
+    def file(method)
+      File.expand_path(method.source_file)
+    end
+
+    def name(method)
+      "#{method.klass_name}::#{method.method_name}"
+    end
+
+    def print_methods(thread_id, methods)
+      methods.reverse_each do |method| 
+        # Print out the file and method name
+        @output << "fl=#{file(method)}\n"
+        @output << "fn=#{name(method)}\n"
+
+        # Now print out the function line number and its self time
+        @output << "#{method.line} #{convert(method.self_time)}\n"
+
+        # Now print out all the children methods
+        method.children.each do |callee|
+          @output << "cfl=#{file(callee.target)}\n"
+          @output << "cfn=#{name(callee.target)}\n"
+          @output << "calls=#{callee.called} #{callee.line}\n"
+
+          # Print out total times here!
+          @output << "#{callee.line} #{convert(callee.total_time)}\n"
+        end
+      @output << "\n"
+      end
+    end #end print_methods
+  end # end class
+end # end packages