bpo-46939: Specialize calls to Python classes

Include/cpython/object.h

@@ -234,6 +234,7 @@ struct _typeobject{
  * by code other than the specializer and interpreter. */
 struct _specialization_cache{
  PyObject *getitem;
+ PyObject *init;
 };
 
 /* The *real* layout of a type object when allocated on the heap */

Include/internal/pycore_code.h

@@ -82,6 +82,7 @@ typedef struct{
 
 typedef struct{
  _Py_CODEUNIT counter;
+ _Py_CODEUNIT type_version[2];
 } _PyPrecallCache;
 
 #define INLINE_CACHE_ENTRIES_PRECALL CACHE_ENTRIES(_PyPrecallCache)

Include/internal/pycore_frame.h

@@ -61,6 +61,7 @@ typedef struct _PyInterpreterFrame{
  PyFrameState f_state; /* What state the frame is in */
  bool is_entry; // Whether this is the "root" frame for the current _PyCFrame.
  bool is_generator;
+ PyObject *self; /* Borrowed reference used by __init__ frames to return self in RETURN_VALUE */
  PyObject *localsplus[1];
 } _PyInterpreterFrame;
 
@@ -118,6 +119,7 @@ _PyFrame_InitializeSpecials(
  frame->f_state = FRAME_CREATED;
  frame->is_entry = false;
  frame->is_generator = false;
+ frame->self = NULL;
 }
 
 /* Gets the pointer to the locals array

Include/internal/pycore_typeobject.h

@@ -43,6 +43,8 @@ extern PyStatus _PyTypes_InitSlotDefs(void);
 
 extern void _PyStaticType_Dealloc(PyTypeObject *type);
 
+extern PyObject *_PyObject_New_Vector(PyTypeObject *type,
+ PyObject *const *args, Py_ssize_t nargs, PyObject *kwds);
 
 #ifdef __cplusplus
 }

Lib/importlib/_bootstrap_external.py

@@ -395,6 +395,7 @@ def _write_atomic(path, data, mode=0o666):
 # Python 3.11a5 3485 (Add an oparg to GET_AWAITABLE)
 # Python 3.11a6 3486 (Use inline caching for PRECALL and CALL)
 # Python 3.11a6 3487 (Remove the adaptive "oparg counter" mechanism)
+# Python 3.11a6 3488 (Specialize PRECALL for Python classes)
 
 # Python 3.12 will start with magic number 3500
 
@@ -409,7 +410,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3487).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3488).to_bytes(2, 'little') + b'\r\n'
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little') # For import.c
 
 _PYCACHE = '__pycache__'

Lib/opcode.py

@@ -191,7 +191,7 @@ def jabs_op(name, op, entries=0):
 def_op('SET_UPDATE', 163)
 def_op('DICT_MERGE', 164)
 def_op('DICT_UPDATE', 165)
-def_op('PRECALL', 166, 1)
+def_op('PRECALL', 166, 3)
 
 def_op('CALL', 171, 4)
 def_op('KW_NAMES', 172)
@@ -285,6 +285,7 @@ def jabs_op(name, op, entries=0):
  "PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST",
  "PRECALL_BOUND_METHOD",
  "PRECALL_PYFUNC",
+ "PRECALL_PY_CLASS",
  "RESUME_QUICK",
  "STORE_ATTR_ADAPTIVE",
  "STORE_ATTR_INSTANCE_VALUE",

Lib/test/test_sys.py

@@ -1397,7 +1397,7 @@ class C(object): pass
  def func():
  return sys._getframe()
  x = func()
- check(x, size('3Pi3c7P2ic??2P'))
+ check(x, size('3Pi3c7P2ic??3P'))
  # function
  def func(): pass
  check(func, size('14Pi'))
@@ -1414,7 +1414,7 @@ def bar(cls):
  check(bar, size('PP'))
  # generator
  def get_gen(): yield 1
- check(get_gen(), size('P2P4P4c7P2ic??P'))
+ check(get_gen(), size('P2P4P4c7P2ic??2P'))
  # iterator
  check(iter('abc'), size('lP'))
  # callable-iterator
@@ -1506,7 +1506,7 @@ def delx(self): del self.__x
  '10P' # PySequenceMethods
  '2P' # PyBufferProcs
  '6P'
- '1P' # Specializer cache
+ '2P' # Specializer cache
  )
  class newstyleclass(object): pass
  # Separate block for PyDictKeysObject with 8 keys and 5 entries

Misc/NEWS.d/next/Core and Builtins/2022-03-06-21-50-36.bpo-46939.nlQEGG.rst

@@ -0,0 +1,2 @@
+Calls to Python classes are now specialized. Creating objects from Python
+classes should now be faster. Patch by Ken Jin.

Objects/typeobject.c

@@ -4514,7 +4514,15 @@ object_init(PyObject *self, PyObject *args, PyObject *kwds)
 static PyObject *
 object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
- if (excess_args(args, kwds)){
+ return _PyObject_New_Vector(type, (_PyTuple_CAST(args)->ob_item),
+ PyTuple_GET_SIZE(args), kwds);
+}
+
+PyObject *
+_PyObject_New_Vector(PyTypeObject *type, PyObject *const *args,
+ Py_ssize_t nargs, PyObject *kwds)
+{
+ if (nargs || (kwds && PyDict_Check(kwds) && PyDict_GET_SIZE(kwds))){
  if (type->tp_new != object_new){
  PyErr_SetString(PyExc_TypeError,
  "object.__new__() takes exactly one argument (the type to instantiate)");

Python/ceval.c

@@ -1463,6 +1463,13 @@ eval_frame_handle_pending(PyThreadState *tstate)
  STAT_INC(LOAD_##attr_or_method, hit); \
  Py_INCREF(res);
 
+#define CALL_PY_FRAME_PASS_SELF() \
+ if (call_shape.init_pass_self){\
+ assert(frame->self == NULL); \
+ frame->self = Py_NewRef(frame->localsplus[0]); \
+ call_shape.init_pass_self = false; \
+ }
+
 #define TRACE_FUNCTION_EXIT() \
  if (cframe.use_tracing){\
  if (trace_function_exit(tstate, frame, retval)){\
@@ -1588,6 +1595,11 @@ pop_frame(PyThreadState *tstate, _PyInterpreterFrame *frame)
  */
 typedef struct{
  PyObject *kwnames;
+ /* __init__ is special because while it returns None, we need to return self
+ This tells CALL to pass the current self to the new frame (the __init__ frame).
+ Where it is eventually consumed by RETURN_VALUE.
+ */
+ bool init_pass_self;
 } CallShape;
 
 static inline bool
@@ -1619,6 +1631,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
  _PyCFrame cframe;
  CallShape call_shape;
  call_shape.kwnames = NULL; // Borrowed reference. Reset by CALL instructions.
+ call_shape.init_pass_self = 0;
 
  /* WARNING: Because the _PyCFrame lives on the C stack,
  * but can be accessed from a heap allocated object (tstate)
@@ -2391,6 +2404,18 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
 
  TARGET(RETURN_VALUE){
  PyObject *retval = POP();
+ if (frame->self != NULL){
+ if (Py_IsNone(retval)){
+ Py_SETREF(retval, frame->self);
+ frame->self = NULL;
+ }
+ /* We need this to continue raising errors when bad-practice
+ __init__s return their non-None values. This is later
+ caught by the interpreter. */
+ else{
+ Py_CLEAR(frame->self);
+ }
+ }
  assert(EMPTY());
  frame->f_state = FRAME_RETURNED;
  _PyFrame_SetStackPointer(frame, stack_pointer);
@@ -4611,6 +4636,37 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
  DISPATCH();
  }
 
+ TARGET(PRECALL_PY_CLASS){
+ _PyPrecallCache *cache = (_PyPrecallCache *)next_instr;
+ int is_method = (PEEK(oparg + 2) != NULL);
+ DEOPT_IF(is_method, PRECALL);
+ PyObject *cls = PEEK(oparg + 1);
+ DEOPT_IF(!PyType_Check(cls), PRECALL);
+ PyTypeObject *cls_t = (PyTypeObject *)cls;
+ DEOPT_IF(cls_t->tp_version_tag != read_u32(cache->type_version), PRECALL);
+ assert(cls_t->tp_flags & Py_TPFLAGS_HEAPTYPE);
+ PyObject *init = ((PyHeapTypeObject *)cls_t)->_spec_cache.init;
+ assert(PyFunction_Check(init));
+ DEOPT_IF(cls_t->tp_new != PyBaseObject_Type.tp_new, PRECALL);
+ STAT_INC(PRECALL, hit);
+
+ PyObject *self = _PyObject_New_Vector(cls_t, &PEEK(oparg),
+ (Py_ssize_t)oparg, call_shape.kwnames);
+ if (self == NULL){
+ goto error;
+ }
+ Py_INCREF(init);
+ PEEK(oparg+1) = self;
+ PEEK(oparg+2) = init;
+ Py_DECREF(cls);
+
+ /* For use in RETURN_VALUE later */
+ assert(call_shape.init_pass_self == false);
+ call_shape.init_pass_self = true;
+ JUMPBY(INLINE_CACHE_ENTRIES_PRECALL);
+ DISPATCH();
+ }
+
  TARGET(KW_NAMES){
  assert(call_shape.kwnames == NULL);
  assert(oparg < PyTuple_GET_SIZE(consts));
@@ -4646,6 +4702,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
  frame->f_lasti += INLINE_CACHE_ENTRIES_CALL;
  new_frame->previous = frame;
  cframe.current_frame = frame = new_frame;
+ CALL_PY_FRAME_PASS_SELF();
  CALL_STAT_INC(inlined_py_calls);
  goto start_frame;
  }
@@ -4751,6 +4808,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
  frame->f_lasti += INLINE_CACHE_ENTRIES_CALL;
  new_frame->previous = frame;
  frame = cframe.current_frame = new_frame;
+ CALL_PY_FRAME_PASS_SELF();
  goto start_frame;
  }
 
@@ -4791,6 +4849,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
  frame->f_lasti += INLINE_CACHE_ENTRIES_CALL;
  new_frame->previous = frame;
  frame = cframe.current_frame = new_frame;
+ CALL_PY_FRAME_PASS_SELF();
  goto start_frame;
  }
 
@@ -5557,6 +5616,7 @@ MISS_WITH_INLINE_CACHE(STORE_SUBSCR)
 
 error:
  call_shape.kwnames = NULL;
+ call_shape.init_pass_self = false;
  /* Double-check exception status. */
 #ifdef NDEBUG
  if (!_PyErr_Occurred(tstate)){
@@ -5598,6 +5658,7 @@ MISS_WITH_INLINE_CACHE(STORE_SUBSCR)
  assert(STACK_LEVEL() == 0);
  _PyFrame_SetStackPointer(frame, stack_pointer);
  frame->f_state = FRAME_RAISED;
+ Py_CLEAR(frame->self);
  TRACE_FUNCTION_UNWIND();
  DTRACE_FUNCTION_EXIT();
  goto exit_unwind;