redcar 0.3.4.3 → 0.3.5

data/plugins/redcar_debug/vendor/jruby-prof/src/org/jruby/prof/Invocation.java

@@ -0,0 +1,14 @@
+
+package org.jruby.prof;
+
+import java.util.*;
+public class Invocation {
+    public String className;
+    public String methodName;
+    public Invocation parent;
+    public boolean returned = false;
+    public long duration = 0;
+    public long count = 0;
+    public long startTimeCurrent;
+    public ArrayList<Invocation> children = new ArrayList<Invocation>();
+}

data/plugins/redcar_debug/vendor/jruby-prof/src/org/jruby/prof/JRubyProf.java

@@ -0,0 +1,94 @@
+
+package org.jruby.prof;
+
+import java.util.*;
+import org.jruby.Ruby;
+import org.jruby.runtime.ThreadContext;
+
+public class JRubyProf {
+
+    private static Map<ThreadContext, Invocation> currentInvocations;
+
+    public static ProfEventHook hook = null;
+    public static long startedTracingTime;
+    public static long lastTracingDuration;
+    
+    public static void startTracing() {
+        hook = new ProfEventHook();
+        Ruby.getGlobalRuntime().addEventHook(hook);
+        currentInvocations = Collections.synchronizedMap(new HashMap<ThreadContext, Invocation>());
+        shouldProfile = true;
+        startedTracingTime = System.currentTimeMillis();
+    }
+    
+    public static Map<ThreadContext, Invocation> stopTracing() {
+        shouldProfile = false;
+        Ruby.getGlobalRuntime().removeEventHook(hook);
+        hook = null;
+        lastTracingDuration = System.currentTimeMillis() - startedTracingTime;
+        for (ThreadContext context : currentInvocations.keySet()) {
+            Invocation inv = currentInvocations.get(context);
+            while (inv.parent != null)
+                inv = inv.parent;
+            currentInvocations.put(context, inv);
+        }
+        return currentInvocations;
+    }
+    
+    public static boolean isRunning() {
+        return shouldProfile;
+    }
+
+    private static boolean shouldProfile = false;
+    private boolean initProfileMethod = false;
+
+    public static synchronized void before(ThreadContext context, String className, String methodName) {
+        if (!shouldProfile) return;
+        Invocation inv = null;
+        if (currentInvocations.containsKey(context)) {
+            Invocation parent = currentInvocations.get(context);
+            for (Invocation subinv : parent.children) {
+                if (subinv.className.equals(className) && subinv.methodName.equals(methodName)) {
+                    inv = subinv;
+                }
+            }
+            if (inv == null) {
+                inv = new Invocation();
+                inv.parent = parent;
+                inv.className = className;
+                inv.methodName = methodName;
+                parent.children.add(inv);
+            }
+            currentInvocations.put(context, inv);
+            //System.out.printf("pushing %s %s to %s %s in %s\n", inv.className, inv.methodName, parent.className, parent.methodName, context.toString());
+            //System.out.printf("current for %s is %s %s\n", context.toString(), inv.className, inv.methodName);
+        }
+        else {
+            inv = new Invocation();
+            currentInvocations.put(context, inv);
+            //System.out.printf("current for %s is %s %s\n", context.toString(), inv.className, inv.methodName);
+            before(context, className, methodName);
+        }
+        inv.startTimeCurrent = System.currentTimeMillis();
+    }
+    
+    public static synchronized void after(ThreadContext context, String className, String methodName) {
+        if (!shouldProfile) return;
+        Invocation current = currentInvocations.get(context);
+        long time;
+        if (current == null) return;
+        time = System.currentTimeMillis() - current.startTimeCurrent;
+        if (current.startTimeCurrent == 0)
+            System.out.printf("warning, startTimeCurrent is 0 in after\n");
+        current.startTimeCurrent = 0;
+        current.duration += time;
+        current.returned = true;
+        current.count += 1;
+        if (current.parent != null) {
+            currentInvocations.put(context, current.parent);
+            //System.out.printf("popping: %s %s took %dms, now at %s %s\n", current.className, current.methodName, time, current.parent.className, current.parent.methodName);
+        }
+        //System.out.printf("current for %s is %s %s\n", context.toString(), current.parent.className, current.parent.methodName);
+    }
+
+}

data/plugins/redcar_debug/vendor/jruby-prof/src/org/jruby/prof/ProfEventHook.java

@@ -0,0 +1,49 @@
+
+package org.jruby.prof;
+
+import org.jruby.prof.JRubyProf;
+
+import org.jruby.RubyObject;
+import org.jruby.RubyModule;
+import org.jruby.MetaClass;
+import org.jruby.runtime.EventHook;
+import org.jruby.runtime.RubyEvent;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class ProfEventHook extends EventHook {
+    public void eventHandler(ThreadContext context, String eventName, String file, int line, String methodName, IRubyObject type) {
+        RubyModule module = (RubyModule) type;
+        String className;
+        if (module == null) {
+            className = "null";
+        }
+        else {
+            if (module instanceof MetaClass) {
+                IRubyObject obj = ((MetaClass) module).getAttached();
+                if (obj instanceof RubyModule) {
+                    module = (RubyModule) obj;
+                    className = "<Class::" + module.getName() + ">";
+                }
+                else if (obj instanceof RubyObject) {
+                    className = "<Instance::" + ((RubyObject) obj).getType().getName() + ">";
+                }
+                else {
+                    className = "unknown";
+                }
+            }
+            else {
+                className = module.getName();
+            }
+        }
+        //System.out.printf("eventHandler(_, %s, %s, %d, %s, %s)\n", eventName, file, line, methodName, className);
+        if (className.equals("<Class::Java::OrgJrubyProf::JRubyProf>")) return;
+        if (eventName.equals("call") || eventName.equals("c-call")) {
+            JRubyProf.before(context, className, methodName);
+        }
+        else if (eventName.equals("return") || eventName.equals("c-return")) {
+             JRubyProf.after(context, className, methodName);
+       }
+    }
+    public boolean isInterestedInEvent(RubyEvent event) { return true; }
+}

data/plugins/redcar_debug/vendor/jruby-prof/templates/graph_row.html.erb

@@ -0,0 +1,18 @@
+
+
+<tr class="<%= major_row ? "method" : "" %>">
+  <td><%= ("%2.2f%" % total_pc) if major_row %></td>
+  <td><%= ("%2.2f%" % self_pc) if major_row %></td>
+  <td><%= total/1000.0 %></td>
+  <td><%= self_/1000.0 %></td>
+  <td><%= children/1000.0 %></td>
+  <td><%= calls %></td>
+  <td>
+    <% if major_row %>
+      <a name="<%= safe_name(name) + (inv_id ? "_#{inv_id}" : "") %>"><%= name %></a>
+    <% else %>
+      <a href="#<%= safe_name(name) + (inv_id ? "_#{inv_id}" : "") %>"><%= name %></a>
+    <% end %>
+  </td>
+</tr>
+

data/plugins/redcar_debug/vendor/jruby-prof/test/basic_test.rb

@@ -0,0 +1,291 @@
+require 'test/unit'
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'jruby-prof'
+
+class C1
+  def C1.hello
+    sleep(0.1)
+  end
+  
+  def hello
+    sleep(0.2)
+  end
+end
+
+module M1
+  def hello
+    sleep(0.3)
+  end
+end
+
+class C2
+  include M1
+  extend M1
+end
+
+class C3
+  def hello
+    sleep(0.4)
+  end
+end
+
+module M4
+  def hello
+    sleep(0.5)
+  end
+end
+
+module M5
+  include M4
+  def goodbye
+    hello
+  end
+end
+
+class C6
+  include M5
+  def test
+    goodbye
+  end
+end
+
+class BasicTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    #RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_running
+    assert(!JRubyProf.running?)
+    JRubyProf.start
+    assert(JRubyProf.running?)
+    JRubyProf.stop
+    assert(!JRubyProf.running?)
+  end
+
+  def test_double_profile
+    JRubyProf.start
+    assert_raise(RuntimeError) do
+      JRubyProf.start
+    end
+  
+    assert_raise(RuntimeError) do
+      JRubyProf.profile do
+        puts 1
+      end
+    end
+    JRubyProf.stop
+  end
+  
+  def test_no_block
+    assert_raise(ArgumentError) do
+      JRubyProf.profile
+    end
+  end
+  
+  def test_class_methods
+    result = JRubyProf.profile do
+      C1.hello
+    end
+  
+    # Length should be 3:
+    #   BasicTest#test_class_methods
+    #   <Class::C1>#hello
+    #   Kernel#sleep
+  
+    methods = result.values.to_a.first.get_methods.values.sort_by {|m| m.name}
+    p methods
+    assert_equal(3, methods.length)
+  
+    # Check the names
+    assert_equal('BasicTest#test_class_methods', methods[0].name)
+    assert_equal('<Class::C1>#hello', methods[1].name)
+    assert_equal('Kernel#sleep', methods[2].name)
+  
+    # Check times
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+  
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+  
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+  end
+  #
+  #if RUBY_VERSION < '1.9'
+  #  PARENT = Object
+  #else
+  #  PARENT = BasicObject
+  #end
+  #
+  #def test_instance_methods
+  #  result = RubyProf.profile do
+  #    C1.new.hello
+  #  end
+  #
+  #  # Methods called
+  #  #   BasicTest#test_instance_methods
+  #  #   Class.new
+  #  #   Class:Object#allocate
+  #  #   for Object#initialize
+  #  #   C1#hello
+  #  #   Kernel#sleep
+  #
+  #  methods = result.threads.values.first.sort.reverse
+  #  assert_equal(6, methods.length)
+  #  names = methods.map(&:full_name)
+  #  assert_equal('BasicTest#test_instance_methods', names[0])
+  #  assert_equal('C1#hello', names[1])
+  #  assert_equal('Kernel#sleep', names[2])
+  #  assert_equal('Class#new', names[3])
+  #  # order can differ
+  #  assert(names.include?("<Class::#{PARENT}>#allocate"))
+  #  assert(names.include?("#{PARENT}#initialize"))
+  #
+  #  # Check times
+  #  assert_in_delta(0.2, methods[0].total_time, 0.02)
+  #  assert_in_delta(0, methods[0].wait_time, 0.02)
+  #  assert_in_delta(0, methods[0].self_time, 0.02)
+  #
+  #  assert_in_delta(0.2, methods[1].total_time, 0.02)
+  #  assert_in_delta(0, methods[1].wait_time, 0.02)
+  #  assert_in_delta(0, methods[1].self_time, 0.02)
+  #
+  #  assert_in_delta(0.2, methods[2].total_time, 0.02)
+  #  assert_in_delta(0, methods[2].wait_time, 0.02)
+  #  assert_in_delta(0.2, methods[2].self_time, 0.02)
+  #
+  #  assert_in_delta(0, methods[3].total_time, 0.01)
+  #  assert_in_delta(0, methods[3].wait_time, 0.01)
+  #  assert_in_delta(0, methods[3].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[4].total_time, 0.01)
+  #  assert_in_delta(0, methods[4].wait_time, 0.01)
+  #  assert_in_delta(0, methods[4].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[5].total_time, 0.01)
+  #  assert_in_delta(0, methods[5].wait_time, 0.01)
+  #  assert_in_delta(0, methods[5].self_time, 0.01)
+  #end
+  #
+  #def test_module_methods
+  #  result = RubyProf.profile do
+  #    C2.hello
+  #  end
+  #
+  #  # Methods:
+  #  #   BasicTest#test_module_methods
+  #  #   M1#hello
+  #  #   Kernel#sleep
+  #
+  #  methods = result.threads.values.first.sort.reverse
+  #  assert_equal(3, methods.length)
+  #
+  #  assert_equal('BasicTest#test_module_methods', methods[0].full_name)
+  #  assert_equal('M1#hello', methods[1].full_name)
+  #  assert_equal('Kernel#sleep', methods[2].full_name)
+  #
+  #  # Check times
+  #  assert_in_delta(0.3, methods[0].total_time, 0.1)
+  #  assert_in_delta(0, methods[0].wait_time, 0.02)
+  #  assert_in_delta(0, methods[0].self_time, 0.02)
+  #
+  #  assert_in_delta(0.3, methods[1].total_time, 0.1)
+  #  assert_in_delta(0, methods[1].wait_time, 0.02)
+  #  assert_in_delta(0, methods[1].self_time, 0.02)
+  #
+  #  assert_in_delta(0.3, methods[2].total_time, 0.1)
+  #  assert_in_delta(0, methods[2].wait_time, 0.02)
+  #  assert_in_delta(0.3, methods[2].self_time, 0.1)
+  #end
+  #
+  #def test_module_instance_methods
+  #  result = RubyProf.profile do
+  #    C2.new.hello
+  #  end
+  #
+  #  # Methods:
+  #  #   BasicTest#test_module_instance_methods
+  #  #   Class#new
+  #  #   <Class::Object>#allocate
+  #  #   Object#initialize
+  #  #   M1#hello
+  #  #   Kernel#sleep
+  #
+  #  methods = result.threads.values.first.sort.reverse
+  #  assert_equal(6, methods.length)
+  #  names = methods.map(&:full_name)
+  #  assert_equal('BasicTest#test_module_instance_methods', names[0])
+  #  assert_equal('M1#hello', names[1])
+  #  assert_equal('Kernel#sleep', names[2])
+  #  assert_equal('Class#new', names[3])
+  #  assert(names.include?("<Class::#{PARENT}>#allocate"))
+  #  assert(names.include?("#{PARENT}#initialize"))
+  #  
+  #  # Check times
+  #  assert_in_delta(0.3, methods[0].total_time, 0.1)
+  #  assert_in_delta(0, methods[0].wait_time, 0.1)
+  #  assert_in_delta(0, methods[0].self_time, 0.1)
+  #
+  #  assert_in_delta(0.3, methods[1].total_time, 0.02)
+  #  assert_in_delta(0, methods[1].wait_time, 0.01)
+  #  assert_in_delta(0, methods[1].self_time, 0.01)
+  #
+  #  assert_in_delta(0.3, methods[2].total_time, 0.02)
+  #  assert_in_delta(0, methods[2].wait_time, 0.01)
+  #  assert_in_delta(0.3, methods[2].self_time, 0.02)
+  #
+  #  assert_in_delta(0, methods[3].total_time, 0.01)
+  #  assert_in_delta(0, methods[3].wait_time, 0.01)
+  #  assert_in_delta(0, methods[3].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[4].total_time, 0.01)
+  #  assert_in_delta(0, methods[4].wait_time, 0.01)
+  #  assert_in_delta(0, methods[4].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[5].total_time, 0.01)
+  #  assert_in_delta(0, methods[5].wait_time, 0.01)
+  #  assert_in_delta(0, methods[5].self_time, 0.01)
+  #end
+  #
+  #def test_singleton
+  #  c3 = C3.new
+  #
+  #  class << c3
+  #    def hello
+  #    end
+  #  end
+  #
+  #  result = RubyProf.profile do
+  #    c3.hello
+  #  end
+  #
+  #  methods = result.threads.values.first.sort.reverse
+  #  assert_equal(2, methods.length)
+  #
+  #  assert_equal('BasicTest#test_singleton', methods[0].full_name)
+  #  assert_equal('<Object::C3>#hello', methods[1].full_name)
+  #
+  #  assert_in_delta(0, methods[0].total_time, 0.01)
+  #  assert_in_delta(0, methods[0].wait_time, 0.01)
+  #  assert_in_delta(0, methods[0].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[1].total_time, 0.01)
+  #  assert_in_delta(0, methods[1].wait_time, 0.01)
+  #  assert_in_delta(0, methods[1].self_time, 0.01)
+  #end
+  #
+  #def test_traceback
+  #  RubyProf.start
+  #  assert_raise(NoMethodError) do
+  #    RubyProf.xxx
+  #  end
+  #
+  #  RubyProf.stop
+  #end
+end