diff --git a/Misc/NEWS.d/next/Library/2021-08-16-17-52-26.bpo-44850.r8jx5u.rst b/Misc/NEWS.d/next/Library/2021-08-16-17-52-26.bpo-44850.r8jx5u.rst
new file mode 100644
index 00000000000000..97aff42c521af5
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2021-08-16-17-52-26.bpo-44850.r8jx5u.rst
@@ -0,0 +1 @@
+Improve performance of ``operator.methodcaller`` by use of the the vectorcall protocol. Patch by Anthony Lee and Pieter Eendebak.
diff --git a/Modules/_operator.c b/Modules/_operator.c
index 108f45fb6dad93..df1fba421aba41 100644
--- a/Modules/_operator.c
+++ b/Modules/_operator.c
@@ -1549,16 +1549,34 @@ static PyType_Spec attrgetter_type_spec = {
typedef struct {
PyObject_HEAD
PyObject *name;
- PyObject *args;
+ PyObject *xargs; // reference to arguments passed in constructor
PyObject *kwds;
+ PyObject **vectorcall_args; /* Borrowed references */
+ PyObject *vectorcall_kwnames;
+ vectorcallfunc vectorcall;
} methodcallerobject;
+static PyObject *
+methodcaller_vectorcall(
+ methodcallerobject *mc, PyObject *const *args, size_t nargsf, PyObject* kwnames)
+{
+ if (!_PyArg_CheckPositional("methodcaller", PyVectorcall_NARGS(nargsf), 1, 1)
+ || !_PyArg_NoKwnames("methodcaller", kwnames)) {
+ return NULL;
+ }
+ mc->vectorcall_args[0] = args[0];
+ return PyObject_VectorcallMethod(
+ mc->name, mc->vectorcall_args,
+ (PyTuple_GET_SIZE(mc->xargs)) | PY_VECTORCALL_ARGUMENTS_OFFSET,
+ mc->vectorcall_kwnames);
+}
+
/* AC 3.5: variable number of arguments, not currently support by AC */
static PyObject *
methodcaller_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
methodcallerobject *mc;
- PyObject *name;
+ PyObject *name, *key, *value;
if (PyTuple_GET_SIZE(args) < 1) {
PyErr_SetString(PyExc_TypeError, "methodcaller needs at least "
@@ -1580,30 +1598,55 @@ methodcaller_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
return NULL;
}
- name = PyTuple_GET_ITEM(args, 0);
Py_INCREF(name);
PyUnicode_InternInPlace(&name);
mc->name = name;
+ mc->xargs = Py_XNewRef(args); // allows us to use borrowed references
mc->kwds = Py_XNewRef(kwds);
- mc->args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
- if (mc->args == NULL) {
- Py_DECREF(mc);
- return NULL;
+ Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+ mc->vectorcall_args = PyMem_Calloc(
+ nargs + (kwds ? PyDict_Size(kwds) : 0),
+ sizeof(PyObject *));
+ if (!mc->vectorcall_args) {
+ return PyErr_NoMemory();
+ }
+ /* The first item of vectorcall_args will be filled with obj later */
+ if (nargs>1) {
+ memcpy(mc->vectorcall_args, PySequence_Fast_ITEMS(args),
+ nargs * sizeof(PyObject *));
}
+ if (kwds) {
+ const Py_ssize_t nkwds = PyDict_Size(kwds);
+
+ mc->vectorcall_kwnames = PyTuple_New(nkwds);
+ if (!mc->vectorcall_kwnames) {
+ return NULL;
+ }
+ Py_ssize_t i = 0, ppos = 0;
+ while (PyDict_Next(kwds, &ppos, &key, &value)) {
+ PyTuple_SET_ITEM(mc->vectorcall_kwnames, i, Py_NewRef(key));
+ mc->vectorcall_args[nargs + i] = value; // borrowed reference
+ ++i;
+ }
+ }
+ else {
+ mc->vectorcall_kwnames = NULL;
+ }
+ mc->vectorcall = (vectorcallfunc)methodcaller_vectorcall;
PyObject_GC_Track(mc);
return (PyObject *)mc;
}
-static int
+static void
methodcaller_clear(methodcallerobject *mc)
{
Py_CLEAR(mc->name);
- Py_CLEAR(mc->args);
+ Py_CLEAR(mc->xargs);
Py_CLEAR(mc->kwds);
- return 0;
+ Py_CLEAR(mc->vectorcall_kwnames);
}
static void
@@ -1612,6 +1655,7 @@ methodcaller_dealloc(methodcallerobject *mc)
PyTypeObject *tp = Py_TYPE(mc);
PyObject_GC_UnTrack(mc);
(void)methodcaller_clear(mc);
+ PyMem_Free(mc->vectorcall_args);
tp->tp_free(mc);
Py_DECREF(tp);
}
@@ -1620,7 +1664,7 @@ static int
methodcaller_traverse(methodcallerobject *mc, visitproc visit, void *arg)
{
Py_VISIT(mc->name);
- Py_VISIT(mc->args);
+ Py_VISIT(mc->xargs);
Py_VISIT(mc->kwds);
Py_VISIT(Py_TYPE(mc));
return 0;
@@ -1639,7 +1683,16 @@ methodcaller_call(methodcallerobject *mc, PyObject *args, PyObject *kw)
method = PyObject_GetAttr(obj, mc->name);
if (method == NULL)
return NULL;
- result = PyObject_Call(method, mc->args, mc->kwds);
+
+
+ PyObject *cargs = PyTuple_GetSlice(mc->xargs, 1, PyTuple_GET_SIZE(mc->xargs));
+ if (cargs == NULL) {
+ Py_DECREF(method);
+ return NULL;
+ }
+
+ result = PyObject_Call(method, cargs, mc->kwds);
+ Py_DECREF(cargs);
Py_DECREF(method);
return result;
}
@@ -1657,7 +1710,7 @@ methodcaller_repr(methodcallerobject *mc)
}
numkwdargs = mc->kwds != NULL ? PyDict_GET_SIZE(mc->kwds) : 0;
- numposargs = PyTuple_GET_SIZE(mc->args);
+ numposargs = PyTuple_GET_SIZE(mc->xargs) - 1;
numtotalargs = numposargs + numkwdargs;
if (numtotalargs == 0) {
@@ -1673,7 +1726,7 @@ methodcaller_repr(methodcallerobject *mc)
}
for (i = 0; i < numposargs; ++i) {
- PyObject *onerepr = PyObject_Repr(PyTuple_GET_ITEM(mc->args, i));
+ PyObject *onerepr = PyObject_Repr(PyTuple_GET_ITEM(mc->xargs, i+1));
if (onerepr == NULL)
goto done;
PyTuple_SET_ITEM(argreprs, i, onerepr);
@@ -1723,17 +1776,16 @@ methodcaller_repr(methodcallerobject *mc)
static PyObject *
methodcaller_reduce(methodcallerobject *mc, PyObject *Py_UNUSED(ignored))
{
- PyObject *newargs;
if (!mc->kwds || PyDict_GET_SIZE(mc->kwds) == 0) {
Py_ssize_t i;
- Py_ssize_t callargcount = PyTuple_GET_SIZE(mc->args);
- newargs = PyTuple_New(1 + callargcount);
+ Py_ssize_t newarg_size = PyTuple_GET_SIZE(mc->xargs);
+ PyObject * newargs = PyTuple_New(newarg_size);
if (newargs == NULL)
return NULL;
PyTuple_SET_ITEM(newargs, 0, Py_NewRef(mc->name));
- for (i = 0; i < callargcount; ++i) {
- PyObject *arg = PyTuple_GET_ITEM(mc->args, i);
- PyTuple_SET_ITEM(newargs, i + 1, Py_NewRef(arg));
+ for (i = 1; i < newarg_size; ++i) {
+ PyObject *arg = PyTuple_GET_ITEM(mc->xargs, i);
+ PyTuple_SET_ITEM(newargs, i, Py_NewRef(arg));
}
return Py_BuildValue("ON", Py_TYPE(mc), newargs);
}
@@ -1751,7 +1803,12 @@ methodcaller_reduce(methodcallerobject *mc, PyObject *Py_UNUSED(ignored))
constructor = PyObject_VectorcallDict(partial, newargs, 2, mc->kwds);
Py_DECREF(partial);
- return Py_BuildValue("NO", constructor, mc->args);
+ PyObject *args = PyTuple_GetSlice(mc->xargs, 1, PyTuple_GET_SIZE(mc->xargs));
+ if (!args) {
+ Py_DECREF(constructor);
+ return NULL;
+ }
+ return Py_BuildValue("NO", constructor, args);
}
}
@@ -1760,6 +1817,12 @@ static PyMethodDef methodcaller_methods[] = {
reduce_doc},
{NULL}
};
+
+static PyMemberDef methodcaller_members[] = {
+ {"__vectorcalloffset__", T_PYSSIZET, offsetof(methodcallerobject, vectorcall), READONLY},
+ {NULL}
+};
+
PyDoc_STRVAR(methodcaller_doc,
"methodcaller(name, /, *args, **kwargs)\n--\n\n\
Return a callable object that calls the given method on its operand.\n\
@@ -1774,6 +1837,7 @@ static PyType_Slot methodcaller_type_slots[] = {
{Py_tp_traverse, methodcaller_traverse},
{Py_tp_clear, methodcaller_clear},
{Py_tp_methods, methodcaller_methods},
+ {Py_tp_members, methodcaller_members},
{Py_tp_new, methodcaller_new},
{Py_tp_getattro, PyObject_GenericGetAttr},
{Py_tp_repr, methodcaller_repr},
@@ -1785,7 +1849,7 @@ static PyType_Spec methodcaller_type_spec = {
.basicsize = sizeof(methodcallerobject),
.itemsize = 0,
.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
- Py_TPFLAGS_IMMUTABLETYPE),
+ Py_TPFLAGS_HAVE_VECTORCALL | Py_TPFLAGS_IMMUTABLETYPE),
.slots = methodcaller_type_slots,
};
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy