GH-93516: Speedup line number checks when tracing.

Include/cpython/code.h

@@ -62,7 +62,8 @@ typedef uint16_t _Py_CODEUNIT;
  PyObject *co_exceptiontable; /* Byte string encoding exception handling \
  table */ \
  int co_flags; /* CO_..., see below */ \
- int co_warmup; /* Warmup counter for quickening */ \
+ short co_warmup; /* Warmup counter for quickening */ \
+ short _co_linearray_entry_size; /* Size of each entry in _co_linearray */ \
  \
  /* The rest are not so impactful on performance. */ \
  int co_argcount; /* #arguments, except *args */ \
@@ -90,6 +91,7 @@ typedef uint16_t _Py_CODEUNIT;
  PyObject *co_weakreflist; /* to support weakrefs to code objects */ \
  void *_co_code; /* cached co_code object/attribute */ \
  int _co_firsttraceable; /* index of first traceable instruction */ \
+ char *_co_linearray; /* array of line offsets */ \
  /* Scratch space for extra data relating to the code object. \
  Type is a void* to keep the format private in codeobject.c to force \
  people to go through the proper APIs. */ \

Include/internal/pycore_code.h

@@ -463,6 +463,34 @@ adaptive_counter_backoff(uint16_t counter) {
 }
 
 
+/* Line array cache for tracing */
+
+extern int _PyCode_CreateLineArray(PyCodeObject *co);
+
+static inline int
+_PyCode_InitLineArray(PyCodeObject *co)
+{
+ if (co->_co_linearray) {
+ return 0;
+ }
+ return _PyCode_CreateLineArray(co);
+}
+
+static inline int
+_PyCode_LineNumberFromArray(PyCodeObject *co, int index)
+{
+ assert(co->_co_linearray != NULL);
+ assert(index >= 0);
+ if (co->_co_linearray_entry_size == 2) {
+ return ((int16_t *)co->_co_linearray)[index];
+ }
+ else {
+ assert(co->_co_linearray_entry_size == 4);
+ return ((int32_t *)co->_co_linearray)[index];
+ }
+}
+
+
 #ifdef __cplusplus
 }
 #endif

Misc/NEWS.d/next/Core and Builtins/2022-06-13-10-48-09.gh-issue-93516.yJSait.rst

@@ -0,0 +1,2 @@
+Lazily create a table mapping bytecode offsets to line numbers to speed up
+calculation of line numbers when tracing.

Objects/codeobject.c

@@ -337,6 +337,8 @@ init_code(PyCodeObject *co, struct _PyCodeConstructor *con)
  co->_co_code = NULL;
 
  co->co_warmup = QUICKENING_INITIAL_WARMUP_VALUE;
+ co->_co_linearray_entry_size = 0;
+ co->_co_linearray = NULL;
  memcpy(_PyCode_CODE(co), PyBytes_AS_STRING(con->code),
  PyBytes_GET_SIZE(con->code));
  int entry_point = 0;
@@ -701,13 +703,68 @@ PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno)
  lnotab_notes.txt for the details of the lnotab representation.
 */
 
+
+int
+_PyCode_CreateLineArray(PyCodeObject *co)
+{
+ assert(co->_co_linearray == NULL);
+ PyCodeAddressRange bounds;
+ int size;
+ int max_line = 0;
+ _PyCode_InitAddressRange(co, &bounds);
+ while (1) {
+ if (!_PyLineTable_NextAddressRange(&bounds)) {
+ break;
+ }
+ if (bounds.ar_line > max_line) {
+ max_line = bounds.ar_line;
+ }
+ }
+ if (max_line < (1 << 15)) {
+ size = 2;
+ }
+ else {
+ size = 4;
+ }
+ co->_co_linearray = PyMem_Malloc(Py_SIZE(co)*size);
+ if (co->_co_linearray == NULL) {
+ PyErr_NoMemory();
+ return -1;
+ }
+ co->_co_linearray_entry_size = size;
+ _PyCode_InitAddressRange(co, &bounds);
+ while (1) {
+ if (!_PyLineTable_NextAddressRange(&bounds)) {
+ break;
+ }
+ int addr = bounds.ar_start;
+ while (addr < bounds.ar_end) {
+ assert(addr < (int)(Py_SIZE(co) * sizeof(_Py_CODEUNIT)));
+ int index = addr / sizeof(_Py_CODEUNIT);
+ if (size == 2) {
+ assert(((int16_t)bounds.ar_line) == bounds.ar_line);
+ ((int16_t *)co->_co_linearray)[index] = bounds.ar_line;
+ }
+ else {
+ assert(size == 4);
+ ((int32_t *)co->_co_linearray)[index] = bounds.ar_line;
+ }
+ addr += sizeof(_Py_CODEUNIT);
+ }
+ }
+ return 0;
+}
+
 int
 PyCode_Addr2Line(PyCodeObject *co, int addrq)
 {
  if (addrq < 0) {
  return co->co_firstlineno;
  }
  assert(addrq >= 0 && addrq < _PyCode_NBYTES(co));
+ if (co->_co_linearray) {
+ return _PyCode_LineNumberFromArray(co, addrq / sizeof(_Py_CODEUNIT));
+ }
  PyCodeAddressRange bounds;
  _PyCode_InitAddressRange(co, &bounds);
  return _PyCode_CheckLineNumber(addrq, &bounds);
@@ -1547,6 +1604,9 @@ code_dealloc(PyCodeObject *co)
  if (co->co_weakreflist != NULL) {
  PyObject_ClearWeakRefs((PyObject*)co);
  }
+ if (co->_co_linearray) {
+ PyMem_Free(co->_co_linearray);
+ }
  if (co->co_warmup == 0) {
  _Py_QuickenedCount--;
  }
@@ -2104,6 +2164,10 @@ _PyStaticCode_Dealloc(PyCodeObject *co)
  PyObject_ClearWeakRefs((PyObject *)co);
  co->co_weakreflist = NULL;
  }
+ if (co->_co_linearray) {
+ PyMem_Free(co->_co_linearray);
+ co->_co_linearray = NULL;
+ }
 }
 
 int

Python/ceval.c

@@ -6805,9 +6805,10 @@ call_trace(Py_tracefunc func, PyObject *obj,
  tstate->tracing_what = what;
  PyThreadState_EnterTracing(tstate);
  assert(_PyInterpreterFrame_LASTI(frame) >= 0);
- initialize_trace_info(&tstate->trace_info, frame);
- int addr = _PyInterpreterFrame_LASTI(frame) * sizeof(_Py_CODEUNIT);
- f->f_lineno = _PyCode_CheckLineNumber(addr, &tstate->trace_info.bounds);
+ if (_PyCode_InitLineArray(frame->f_code)) {
+ return -1;
+ }
+ f->f_lineno = _PyCode_LineNumberFromArray(frame->f_code, _PyInterpreterFrame_LASTI(frame));
  result = func(obj, f, what, arg);
  f->f_lineno = 0;
  PyThreadState_LeaveTracing(tstate);
@@ -6844,16 +6845,17 @@ maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
  represents a jump backwards, update the frame's line number and
  then call the trace function if we're tracing source lines.
  */
- initialize_trace_info(&tstate->trace_info, frame);
+ if (_PyCode_InitLineArray(frame->f_code)) {
+ return -1;
+ }
  int lastline;
  if (instr_prev <= frame->f_code->_co_firsttraceable) {
  lastline = -1;
  }
  else {
- lastline = _PyCode_CheckLineNumber(instr_prev*sizeof(_Py_CODEUNIT), &tstate->trace_info.bounds);
+ lastline = _PyCode_LineNumberFromArray(frame->f_code, instr_prev);
  }
- int addr = _PyInterpreterFrame_LASTI(frame) * sizeof(_Py_CODEUNIT);
- int line = _PyCode_CheckLineNumber(addr, &tstate->trace_info.bounds);
+ int line = _PyCode_LineNumberFromArray(frame->f_code, _PyInterpreterFrame_LASTI(frame));
  PyFrameObject *f = _PyFrame_GetFrameObject(frame);
  if (f == NULL) {
  return -1;

Tools/scripts/deepfreeze.py

@@ -253,6 +253,7 @@ def generate_code(self, name: str, code: types.CodeType) -> str:
  self.write(f".co_exceptiontable = {co_exceptiontable},")
  self.field(code, "co_flags")
  self.write(".co_warmup = QUICKENING_INITIAL_WARMUP_VALUE,")
+ self.write("._co_linearray_entry_size = 0,")
  self.field(code, "co_argcount")
  self.field(code, "co_posonlyargcount")
  self.field(code, "co_kwonlyargcount")
@@ -269,6 +270,7 @@ def generate_code(self, name: str, code: types.CodeType) -> str:
  self.write(f".co_name = {co_name},")
  self.write(f".co_qualname = {co_qualname},")
  self.write(f".co_linetable = {co_linetable},")
+ self.write("._co_linearray = NULL,")
  self.write(f".co_code_adaptive = {co_code_adaptive},")
  for i, op in enumerate(code.co_code[::2]):
  if op == RESUME: