Merge pull request #21 from denofevil/disabling-enabling-tps

Disabling enabling trace points to improve performance

Author: denofevil

ext/context.c

@@ -147,6 +147,7 @@ context_create(VALUE thread, VALUE cDebugThread) {
   context->last_line = -1;
   context->stop_frame = -1;
   context->thread_pause = 0;
+  context->stop_reason = CTX_STOP_NONE;
   reset_stepping_stop_points(context);
   if(rb_obj_class(thread) == cDebugThread) CTX_FL_SET(context, CTX_FL_IGNORE);
   return Data_Wrap_Struct(cContext, Context_mark, Context_free, context);
@@ -272,6 +273,7 @@ Context_pause(VALUE self)
     return Qfalse;
   }
 
+  enable_trace_points();
   context->thread_pause = 1;
   return Qtrue;
 }

ext/debase_internals.c

@@ -23,6 +23,17 @@ static VALUE idAtCatchpoint;
 static VALUE idFileFilter;
 static VALUE idAccept;
 
+static void
+print_debug(const char *message, ...)
+{
+  va_list ap;
+
+  if (verbose == Qfalse) return;
+  va_start(ap, message);
+  vfprintf(stderr, message, ap);
+  va_end(ap);
+}
+
 static VALUE
 is_path_accepted(VALUE path) {
   VALUE filter;
@@ -49,6 +60,82 @@ Debase_current_context(VALUE self)
   return Debase_thread_context(self, rb_thread_current());
 }
 
+static int
+set_recalc_flag(VALUE thread, VALUE context_object, VALUE ignored)
+{
+  debug_context_t *context;
+
+  Data_Get_Struct(context_object, debug_context_t, context);
+  CTX_FL_SET(context, CTX_FL_UPDATE_STACK);
+
+  return ST_CONTINUE;
+}
+
+static int
+can_disable_trace_points(VALUE thread, VALUE context_object, VALUE result)
+{
+  debug_context_t *context;
+
+  Data_Get_Struct(context_object, debug_context_t, context);
+
+  if (-1 != context->dest_frame
+      || context->stop_line >= 0
+      || -1 != context->stop_next
+      || context->stop_reason != CTX_STOP_NONE
+      || context->thread_pause != 0)
+  {
+    print_debug("can_disable_tp: %d %d %d %d\n", context->dest_frame, context->stop_line,
+                                                 context->stop_next, context->stop_reason);
+    *((VALUE *) result) = Qfalse;
+    return ST_STOP;
+  }
+  return ST_CONTINUE;
+}
+
+static void
+try_disable_trace_points()
+{
+  VALUE can_disable = Qtrue;
+
+  if (RARRAY_LEN(breakpoints) != 0) return;
+  print_debug("disable_tps: no breakpoints\n");
+  if (RHASH_EMPTY_P(catchpoints)) return;
+  print_debug("disable_tps: no catchpoints\n");
+  if (rb_tracepoint_enabled_p(tpLine) == Qfalse) return;
+  print_debug("disable_tps: tps are enabled\n");
+
+  rb_hash_foreach(contexts, can_disable_trace_points, (VALUE)&can_disable);
+  if (can_disable == Qfalse) return;
+  print_debug("disable_tps: can disable contexts\n");
+
+  rb_tracepoint_disable(tpLine);
+  rb_tracepoint_disable(tpCall);
+  rb_tracepoint_disable(tpReturn);
+  rb_tracepoint_disable(tpRaise);
+  rb_hash_foreach(contexts, set_recalc_flag, 0);
+}
+
+extern VALUE
+enable_trace_points()
+{
+  print_debug("enable_tps: \n");
+  if (rb_tracepoint_enabled_p(tpLine) == Qtrue) return Qtrue;
+  print_debug("enable_tps: need to enable\n");
+
+  rb_tracepoint_enable(tpLine);
+  rb_tracepoint_enable(tpCall);
+  rb_tracepoint_enable(tpReturn);
+  rb_tracepoint_enable(tpRaise);
+
+  return Qfalse;
+}
+
+static VALUE
+Debase_enable_trace_points(VALUE self)
+{
+  return enable_trace_points();
+}
+
 static int
 remove_dead_threads(VALUE thread, VALUE context, VALUE ignored)
 {
@@ -71,6 +158,8 @@ cleanup(debug_context_t *context)
   thread = remove_from_locked();
   if(thread != Qnil)
     rb_thread_run(thread);
+
+  try_disable_trace_points();
 }
 
 static int
@@ -377,15 +466,18 @@ Debase_setup_tracepoints(VALUE self)
   catchpoints = rb_hash_new();
 
   tpLine = rb_tracepoint_new(Qnil, RUBY_EVENT_LINE, process_line_event, NULL);
-  rb_tracepoint_enable(tpLine);
-  tpReturn = rb_tracepoint_new(Qnil, RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_C_RETURN | RUBY_EVENT_END, 
+  rb_global_variable(&tpLine);
+
+  tpReturn = rb_tracepoint_new(Qnil, RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_C_RETURN | RUBY_EVENT_END,
                                process_return_event, NULL);
-  rb_tracepoint_enable(tpReturn);
-  tpCall = rb_tracepoint_new(Qnil, RUBY_EVENT_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_C_CALL | RUBY_EVENT_CLASS, 
+  rb_global_variable(&tpReturn);
+
+  tpCall = rb_tracepoint_new(Qnil, RUBY_EVENT_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_C_CALL | RUBY_EVENT_CLASS,
                              process_call_event, NULL);
-  rb_tracepoint_enable(tpCall);
+  rb_global_variable(&tpCall);
+
   tpRaise = rb_tracepoint_new(Qnil, RUBY_EVENT_RAISE, process_raise_event, NULL);
-  Debase_current_context(self);
+  rb_global_variable(&tpRaise);
 
   return Qnil;
 }
@@ -418,7 +510,10 @@ debase_prepare_context(VALUE self, VALUE file, VALUE stop)
   context_object = Debase_current_context(self);
   Data_Get_Struct(context_object, debug_context_t, context);
 
-  if(RTEST(stop)) context->stop_next = 1;
+  if(RTEST(stop)) {
+    context->stop_next = 1;
+    Debase_enable_trace_points(self);
+  }
   ruby_script(RSTRING_PTR(file));
   return self;
 }
@@ -510,18 +605,6 @@ Debase_set_verbose(VALUE self, VALUE value)
   return value;
 }
 
-/*
- *  call-seq:
- *    Debase.tp_raise -> TracePoint
- *
- *  Returns trace point we use to track :raise events
- */
-static VALUE
-Debase_get_tp_raise(VALUE self)
-{
-  return tpRaise;
-}
-
 /*
  *   Document-class: Debase
  *
@@ -541,10 +624,10 @@ Init_debase_internals()
   rb_define_module_function(mDebase, "contexts", Debase_contexts, 0);
   rb_define_module_function(mDebase, "breakpoints", Debase_breakpoints, 0);
   rb_define_module_function(mDebase, "catchpoints", Debase_catchpoints, 0);
-  rb_define_module_function(mDebase, "tp_raise", Debase_get_tp_raise, 0);
   rb_define_module_function(mDebase, "started?", Debase_started, 0);
   rb_define_module_function(mDebase, "verbose?", Debase_verbose, 0);
   rb_define_module_function(mDebase, "verbose=", Debase_set_verbose, 1);
+  rb_define_module_function(mDebase, "enable_trace_points", Debase_enable_trace_points, 0);
 
   idAlive = rb_intern("alive?");
   idAtLine = rb_intern("at_line");

ext/debase_internals.h

@@ -18,6 +18,7 @@ typedef struct rb_trace_arg_struct rb_trace_point_t;
 #define CTX_FL_STEPPED      (1<<8)
 #define CTX_FL_FORCE_MOVE   (1<<9)
 #define CTX_FL_CATCHING     (1<<10)
+#define CTX_FL_UPDATE_STACK (1<<11)
 
 /* macro functions */
 #define CTX_FL_TEST(c,f)  ((c)->flags & (f))
@@ -88,6 +89,7 @@ typedef struct locked_thread_t {
 extern int is_in_locked(VALUE thread_id);
 extern void add_to_locked(VALUE thread);
 extern VALUE remove_from_locked();
+extern VALUE enable_trace_points();
 
 /* breakpoints and catchpoints */
 /* types */

ext/hacks.h

@@ -10,4 +10,8 @@ update_stack_size(debug_context_t *context)
   thread = ruby_current_thread;
   /* see backtrace_each in vm_backtrace.c */
   context->stack_size = (int)(RUBY_VM_END_CONTROL_FRAME(thread) - thread->cfp - 1);
+  if (CTX_FL_TEST(context, CTX_FL_UPDATE_STACK)) {
+    context->calced_stack_size = context->stack_size;
+    CTX_FL_UNSET(context, CTX_FL_UPDATE_STACK);
+  }
 }

lib/debase.rb

@@ -29,6 +29,7 @@ def start(options={}, &block)
     def add_breakpoint(file, line, expr=nil)
       breakpoint = Breakpoint.new(file, line, expr)
       breakpoints << breakpoint
+      enable_trace_points
       breakpoint
     end
 
@@ -48,17 +49,15 @@ def debug
 
     def add_catchpoint(exception)
       catchpoints[exception] = 0
-      tp_raise.enable
+      enable_trace_points
     end
 
     def remove_catchpoint(exception)
       catchpoints.delete(exception)
-      tp_raise.disable if catchpoints.empty?
     end
 
     def clear_catchpoints
       catchpoints.clear
-      tp_raise.disable
     end
 
     #call-seq:

test/test_base.rb

@@ -12,6 +12,8 @@ def test_current_context
     assert_equal(false, Debugger.started?, 
                  'debugger should not initially be started.')
     Debugger.start_
+    # we need to add the breakpoint to force enabling trace points
+    Debugger.add_breakpoint(__FILE__, 1)
     assert(Debugger.started?, 
            'debugger should now be started.')
     # assert_equal(__LINE__, Debugger.current_context.frame_line)
@@ -37,6 +39,8 @@ def test_debugger_base
     assert_equal(false, Debugger.started?, 
                  'Debugger should not initially be started.')
     Debugger.start_
+    # we need to add the breakpoint to force enabling trace points
+    Debugger.add_breakpoint(__FILE__, 1)
     assert(Debugger.started?, 
            'Debugger should now be started.')
     assert_equal(false, Debugger.debug,