gh-121459: Deferred LOAD_ATTR (methods)

Include/internal/pycore_dict.h

@@ -121,7 +121,9 @@ PyAPI_FUNC(int) _PyDict_SetItem_KnownHash_LockHeld(PyDictObject *mp, PyObject *k
 PyAPI_FUNC(int) _PyDict_GetItemRef_KnownHash_LockHeld(PyDictObject *op, PyObject *key, Py_hash_t hash, PyObject **result);
 extern int _PyDict_GetItemRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, PyObject **result);
 extern int _PyDict_GetItemRef_Unicode_LockHeld(PyDictObject *op, PyObject *key, PyObject **result);
+extern int _PyDict_GetItemStackRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, _PyStackRef *result);
 extern int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject *obj, PyObject **dictptr, PyObject *name, PyObject *value);
+extern int _PyDict_GetItemStackRef(PyObject *op, PyObject *key, _PyStackRef *result);
 
 extern int _PyDict_Pop_KnownHash(
  PyDictObject *dict,

Include/internal/pycore_object.h

@@ -623,6 +623,24 @@ _Py_TryXGetRef(PyObject **ptr)
  return NULL;
 }
 
+// This belongs here rather than pycore_stackref.h because including pycore_object.h
+// there causes a circular include.
+static inline _PyStackRef
+_Py_TryXGetStackRef(PyObject **ptr)
+{
+ PyObject *value = _Py_atomic_load_ptr(ptr);
+ if (value == NULL) {
+ return PyStackRef_NULL;
+ }
+ if (_Py_IsImmortal(value) || _PyObject_HasDeferredRefcount(value)) {
+ return (_PyStackRef){ .bits = (uintptr_t)value | Py_TAG_DEFERRED };
+ }
+ if (_Py_TryIncrefCompare(ptr, value)) {
+ return PyStackRef_FromPyObjectSteal(value);
+ }
+ return PyStackRef_NULL;
+}
+
 /* Like Py_NewRef but also optimistically sets _Py_REF_MAYBE_WEAKREF
  on objects owned by a different thread. */
 static inline PyObject *
@@ -816,7 +834,8 @@ extern int _PyObject_StoreInstanceAttribute(PyObject *obj,
  PyObject *name, PyObject *value);
 extern bool _PyObject_TryGetInstanceAttribute(PyObject *obj, PyObject *name,
  PyObject **attr);
-
+extern bool _PyObject_TryGetInstanceAttributeStackRef(PyObject *obj, PyObject *name,
+ _PyStackRef *attr);
 #ifdef Py_GIL_DISABLED
 # define MANAGED_DICT_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-1)
 # define MANAGED_WEAKREF_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-2)
@@ -863,6 +882,7 @@ PyAPI_FUNC(PyObject*) _PyObject_LookupSpecialMethod(PyObject *self, PyObject *at
 extern int _PyObject_IsAbstract(PyObject *);
 
 PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+PyAPI_FUNC(int) _PyObject_GetMethodStackRef(PyObject *obj, PyObject *name, _PyStackRef *method, _PyStackRef *spare);
 extern PyObject* _PyObject_NextNotImplemented(PyObject *);
 
 // Pickle support.
@@ -900,6 +920,8 @@ PyAPI_DATA(int) _Py_SwappedOp[];
 
 extern void _Py_GetConstant_Init(void);
 
+extern void _PyType_LookupStackRef(PyTypeObject *type, PyObject *name, _PyStackRef *result);
+
 #ifdef __cplusplus
 }
 #endif

Objects/dictobject.c

@@ -2336,6 +2336,21 @@ _PyDict_GetItemRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, Py
  return 1; // key is present
 }
 
+int
+_PyDict_GetItemStackRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, _PyStackRef *result)
+{
+ Py_ssize_t ix = _Py_dict_lookup_threadsafe_stackref(op, key, hash, result);
+ assert(ix >= 0 || PyStackRef_IsNull(*result));
+ if (ix == DKIX_ERROR) {
+ *result = PyStackRef_NULL;
+ return -1;
+ }
+ if (PyStackRef_IsNull(*result)) {
+ return 0; // missing key
+ }
+ return 1; // key is present
+}
+
 int
 PyDict_GetItemRef(PyObject *op, PyObject *key, PyObject **result)
 {
@@ -2354,6 +2369,24 @@ PyDict_GetItemRef(PyObject *op, PyObject *key, PyObject **result)
  return _PyDict_GetItemRef_KnownHash((PyDictObject *)op, key, hash, result);
 }
 
+int
+_PyDict_GetItemStackRef(PyObject *op, PyObject *key, _PyStackRef *result)
+{
+ if (!PyDict_Check(op)) {
+ PyErr_BadInternalCall();
+ *result = PyStackRef_NULL;
+ return -1;
+ }
+
+ Py_hash_t hash = _PyObject_HashFast(key);
+ if (hash == -1) {
+ *result = PyStackRef_NULL;
+ return -1;
+ }
+
+ return _PyDict_GetItemStackRef_KnownHash((PyDictObject *)op, key, hash, result);
+}
+
 int
 _PyDict_GetItemRef_Unicode_LockHeld(PyDictObject *op, PyObject *key, PyObject **result)
 {
@@ -7097,6 +7130,81 @@ _PyObject_TryGetInstanceAttribute(PyObject *obj, PyObject *name, PyObject **attr
 #endif
 }
 
+bool
+_PyObject_TryGetInstanceAttributeStackRef(PyObject *obj, PyObject *name, _PyStackRef *attr)
+{
+ assert(PyUnicode_CheckExact(name));
+ PyDictValues *values = _PyObject_InlineValues(obj);
+ if (!FT_ATOMIC_LOAD_UINT8(values->valid)) {
+ return false;
+ }
+
+ PyDictKeysObject *keys = CACHED_KEYS(Py_TYPE(obj));
+ assert(keys != NULL);
+ Py_ssize_t ix = _PyDictKeys_StringLookup(keys, name);
+ if (ix == DKIX_EMPTY) {
+ *attr = PyStackRef_NULL;
+ return true;
+ }
+
+#ifdef Py_GIL_DISABLED
+ *attr = _Py_TryXGetStackRef(&values->values[ix]);
+ if (PyStackRef_AsPyObjectBorrow(*attr) == _Py_atomic_load_ptr_acquire(&values->values[ix])) {
+ return true;
+ }
+
+ PyDictObject *dict = _PyObject_GetManagedDict(obj);
+ if (dict == NULL) {
+ // No dict, lock the object to prevent one from being
+ // materialized...
+ bool success = false;
+ Py_BEGIN_CRITICAL_SECTION(obj);
+
+ dict = _PyObject_GetManagedDict(obj);
+ if (dict == NULL) {
+ // Still no dict, we can read from the values
+ assert(values->valid);
+ *attr = _Py_TryXGetStackRef(&values->values[ix]);
+ success = true;
+ }
+
+ Py_END_CRITICAL_SECTION();
+
+ if (success) {
+ return true;
+ }
+ }
+
+ // We have a dictionary, we'll need to lock it to prevent
+ // the values from being resized.
+ assert(dict != NULL);
+
+ bool success;
+ Py_BEGIN_CRITICAL_SECTION(dict);
+
+ if (dict->ma_values == values && FT_ATOMIC_LOAD_UINT8(values->valid)) {
+ *attr = _Py_TryXGetStackRef(&values->values[ix]);
+ success = true;
+ } else {
+ // Caller needs to lookup from the dictionary
+ success = false;
+ }
+
+ Py_END_CRITICAL_SECTION();
+
+ return success;
+#else
+ PyObject *value = values->values[ix];
+ if (value != NULL) {
+ *attr = PyStackRef_FromPyObjectNew(value);
+ }
+ else {
+ *attr = PyStackRef_NULL;
+ }
+ return true;
+#endif
+}
+
 int
 _PyObject_IsInstanceDictEmpty(PyObject *obj)
 {

Objects/object.c

@@ -1620,6 +1620,129 @@ _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method)
  return 0;
 }
 
+int
+_PyObject_GetMethodStackRef(PyObject *obj, PyObject *name, _PyStackRef *method, _PyStackRef *spare)
+{
+#ifdef Py_GIL_DISABLED
+ int meth_found = 0;
+
+ assert(PyStackRef_IsNull(*method));
+
+ PyTypeObject *tp = Py_TYPE(obj);
+ if (!_PyType_IsReady(tp)) {
+ if (PyType_Ready(tp) < 0) {
+ return 0;
+ }
+ }
+
+ if (tp->tp_getattro != PyObject_GenericGetAttr || !PyUnicode_CheckExact(name)) {
+ PyObject *attr_o = PyObject_GetAttr(obj, name);
+ if (attr_o != NULL) {
+ *method = PyStackRef_FromPyObjectSteal(attr_o);
+ }
+ else {
+ *method = PyStackRef_NULL;
+ }
+ return 0;
+ }
+
+ _PyType_LookupStackRef(tp, name, method);
+ *spare = *method;
+ _PyStackRef descr_st = *method;
+ descrgetfunc f = NULL;
+ if (!PyStackRef_IsNull(descr_st)) {
+ if (_PyType_HasFeature(PyStackRef_TYPE(descr_st), Py_TPFLAGS_METHOD_DESCRIPTOR)) {
+ meth_found = 1;
+ } else {
+ f = PyStackRef_TYPE(descr_st)->tp_descr_get;
+ if (f != NULL && PyDescr_IsData(PyStackRef_AsPyObjectBorrow(descr_st))) {
+ PyObject *call_res_o = f(PyStackRef_AsPyObjectBorrow(descr_st), obj, (PyObject *)Py_TYPE(obj));
+ if (call_res_o != NULL) {
+ *method = PyStackRef_FromPyObjectSteal(call_res_o);
+ }
+ else {
+ *method = PyStackRef_NULL;
+ }
+ PyStackRef_CLOSE(descr_st);
+ return 0;
+ }
+ }
+ }
+ PyObject *dict;
+ if ((tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&
+ _PyObject_TryGetInstanceAttributeStackRef(obj, name, method)) {
+ if (!PyStackRef_IsNull(*method)) {
+ PyStackRef_XCLOSE(descr_st);
+ return 0;
+ }
+ dict = NULL;
+ }
+ else if ((tp->tp_flags & Py_TPFLAGS_MANAGED_DICT)) {
+ dict = (PyObject *)_PyObject_GetManagedDict(obj);
+ }
+ else {
+ PyObject **dictptr = _PyObject_ComputedDictPointer(obj);
+ if (dictptr != NULL) {
+ dict = *dictptr;
+ }
+ else {
+ dict = NULL;
+ }
+ }
+ if (dict != NULL) {
+ Py_INCREF(dict);
+ if (_PyDict_GetItemStackRef(dict, name, method) != 0) {
+ // found or error
+ Py_DECREF(dict);
+ PyStackRef_CLOSE(descr_st);
+ return 0;
+ }
+ // not found
+ Py_DECREF(dict);
+ }
+
+ if (meth_found) {
+ *method = descr_st;
+ return 1;
+ }
+
+ if (f != NULL) {
+ PyObject *call_res_o = f(PyStackRef_AsPyObjectBorrow(descr_st), obj, (PyObject *)Py_TYPE(obj));
+ if (call_res_o != NULL) {
+ *method = PyStackRef_FromPyObjectSteal(call_res_o);
+ }
+ else {
+ *method = PyStackRef_NULL;
+ }
+ PyStackRef_CLOSE(descr_st);
+ return 0;
+ }
+
+ if (!PyStackRef_IsNull(descr_st)) {
+ *method = descr_st;
+ return 0;
+ }
+
+ *method = PyStackRef_NULL;
+ PyErr_Format(PyExc_AttributeError,
+ "'%.100s' object has no attribute '%U'",
+ tp->tp_name, name);
+
+ _PyObject_SetAttributeErrorContext(obj, name);
+ return 0;
+#else
+ PyObject *res = NULL;
+ int err = _PyObject_GetMethod(obj, name, &res);
+ if (res == NULL) {
+ *method = PyStackRef_NULL;
+ }
+ else {
+ *method = PyStackRef_FromPyObjectSteal(res);
+ }
+ return err;
+#endif
+}
+
 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot. */
 
 PyObject *