eric: comparison src/eric7/DebugClients/Python/coverage/pytracer.py

-:e0f98cc25bf5
+:32dd11232e06
 self._activity = False
 self.in_atexit = False
 # On exit, self.in_atexit = True
 atexit.register(setattr, self, 'in_atexit', True)
+# Cache a bound method on the instance, so that we don't have to
+# re-create a bound method object all the time.
+self._cached_bound_method_trace = self._trace
 def __repr__(self):
 return "<PyTracer at 0x{:x}: {} lines in {} files>".format(
 id(self),
 sum(len(v) for v in self.data.values()),
 if THIS_FILE in frame.f_code.co_filename:
 return None
 #self.log(":", frame.f_code.co_filename, frame.f_lineno, frame.f_code.co_name + "()", event)
-if (self.stopped and sys.gettrace() == self._trace):    # pylint: disable=comparison-with-callable
+if (self.stopped and sys.gettrace() == self._cached_bound_method_trace):    # pylint: disable=comparison-with-callable
 # The PyTrace.stop() method has been called, possibly by another
 # thread, let's deactivate ourselves now.
 if 0:
 self.log("---\nX", frame.f_code.co_filename, frame.f_lineno)
 f = frame
 # Should we start a new context?
 if self.should_start_context and self.context is None:
 context_maybe = self.should_start_context(frame)
 if context_maybe is not None:
 self.context = context_maybe
-self.started_context = True
+started_context = True
 self.switch_context(self.context)
 else:
-self.started_context = False
+started_context = False
 else:
-self.started_context = False
+started_context = False
+self.started_context = started_context
 # Entering a new frame.  Decide if we should trace in this file.
 self._activity = True
 self.data_stack.append(
 (
 self.cur_file_data,
 self.cur_file_name,
 self.last_line,
-self.started_context,
+started_context,
 )
 )
+# Improve tracing performance: when calling a function, both caller
+# and callee are often within the same file. if that's the case, we
+# don't have to re-check whether to trace the corresponding
+# function (which is a little bit espensive since it involves
+# dictionary lookups). This optimization is only correct if we
+# didn't start a context.
 filename = frame.f_code.co_filename
-self.cur_file_name = filename
+if filename != self.cur_file_name or started_context:
-disp = self.should_trace_cache.get(filename)
+self.cur_file_name = filename
-if disp is None:
+disp = self.should_trace_cache.get(filename)
-disp = self.should_trace(filename, frame)
+if disp is None:
-self.should_trace_cache[filename] = disp
+disp = self.should_trace(filename, frame)
+self.should_trace_cache[filename] = disp
-self.cur_file_data = None
-if disp.trace:
+self.cur_file_data = None
-tracename = disp.source_filename
+if disp.trace:
-if tracename not in self.data:
+tracename = disp.source_filename
-self.data[tracename] = set()
+if tracename not in self.data:
-self.cur_file_data = self.data[tracename]
+self.data[tracename] = set()
+self.cur_file_data = self.data[tracename]
+else:
+frame.f_trace_lines = False
+elif not self.cur_file_data:
+frame.f_trace_lines = False
 # The call event is really a "start frame" event, and happens for
 # function calls and re-entering generators.  The f_lasti field is
 # -1 for calls, and a real offset for generators.  Use <0 as the
 # line number for calls, and the real line number for generators.
 if RESUME is not None:
 real_call = (getattr(frame, 'f_lasti', -1) < 0)
 if real_call:
 self.last_line = -frame.f_code.co_firstlineno
 else:
 self.last_line = frame.f_lineno
 elif event == 'line':
 # Record an executed line.
 if self.cur_file_data is not None:
 lineno = frame.f_lineno
 if self.trace_arcs:
 self.cur_file_data.add((self.last_line, lineno))
 else:
 self.cur_file_data.add(lineno)
 self.last_line = lineno
 elif event == 'return':
 if self.trace_arcs and self.cur_file_data:
 # Record an arc leaving the function, but beware that a
 # "return" event might just mean yielding from a generator.
 code = frame.f_code.co_code
 else:
 real_return = True
 if real_return:
 first = frame.f_code.co_firstlineno
 self.cur_file_data.add((self.last_line, -first))
 # Leaving this function, pop the filename stack.
 self.cur_file_data, self.cur_file_name, self.last_line, self.started_context = (
 self.data_stack.pop()
 )
 # Leaving a context?
 if self.started_context:
 self.context = None
 self.switch_context(None)
-return self._trace
+return self._cached_bound_method_trace
 def start(self):
 """Start this Tracer.
 Return a Python function suitable for use with sys.settrace().
 if self.thread.ident != self.threading.current_thread().ident:
 # Re-starting from a different thread!? Don't set the trace
 # function, but we are marked as running again, so maybe it
 # will be ok?
 #self.log("~", "starting on different threads")
-return self._trace
+return self._cached_bound_method_trace
-sys.settrace(self._trace)
+sys.settrace(self._cached_bound_method_trace)
-return self._trace
+return self._cached_bound_method_trace
 def stop(self):
 """Stop this Tracer."""
 # Get the active tracer callback before setting the stop flag to be
 # able to detect if the tracer was changed prior to stopping it.
 if self.warn:
 # PyPy clears the trace function before running atexit functions,
 # so don't warn if we are in atexit on PyPy and the trace function
 # has changed to None.
 dont_warn = (env.PYPY and env.PYPYVERSION >= (5, 4) and self.in_atexit and tf is None)
-if (not dont_warn) and tf != self._trace:   # pylint: disable=comparison-with-callable
+if (not dont_warn) and tf != self._cached_bound_method_trace:   # pylint: disable=comparison-with-callable
 self.warn(
-f"Trace function changed, data is likely wrong: {tf!r} != {self._trace!r}",
+"Trace function changed, data is likely wrong: " +
+f"{tf!r} != {self._cached_bound_method_trace!r}",
 slug="trace-changed",
 )
 def activity(self):
 """Has there been any activity?"""

Mercurial Repositories > eric / file comparison

comparison: src/eric7/DebugClients/Python/coverage/pytracer.py

src/eric7/DebugClients/Python/coverage/pytracer.py