languages/cpython
languages/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython synced 2024-09-16 01:45:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

bpo-46235: Do all ref-counting at once during list/tuple multiplication (GH-30346)

Browse source 
When multiplying lists and tuples by `n`, increment each element's refcount, by `n`, just once.

Saves `n-1` increments per element, and allows for a leaner & faster copying loop.

Code by  sweeneyde (Dennis Sweeney).
This commit is contained in:
Dennis Sweeney 2022-01-07 22:47:58 -05:00 committed by GitHub
parent 6fa8b2ceee
commit ad1d5908ad
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 49 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Misc/NEWS.d/next/Core and Builtins/2022-01-02-23-55-13.bpo-46235.gUjp2v.rst Normal file
View file

@ -0,0 +1 @@
Certain sequence multiplication operations like ``[0] * 1_000`` are now faster due to reference-counting optimizations. Patch by Dennis Sweeney.

39
Objects/listobject.c
View file

@ -553,11 +553,8 @@ list_concat(PyListObject *a, PyObject *bb)
static PyObject *
list_repeat(PyListObject *a, Py_ssize_t n)
{
Py_ssize_t i, j;
Py_ssize_t size;
PyListObject *np;
PyObject **p, **items;
PyObject *elem;
if (n < 0)
n = 0;
if (n > 0 && Py_SIZE(a) > PY_SSIZE_T_MAX / n)
@ -568,24 +565,32 @@ list_repeat(PyListObject *a, Py_ssize_t n)
np = (PyListObject *) list_new_prealloc(size);
if (np == NULL)
return NULL;
PyObject **dest = np->ob_item;
PyObject **dest_end = dest + size;
if (Py_SIZE(a) == 1) {
items = np->ob_item;
elem = a->ob_item[0];
for (i = 0; i < n; i++) {
items[i] = elem;
Py_INCREF(elem);
PyObject *elem = a->ob_item[0];
Py_SET_REFCNT(elem, Py_REFCNT(elem) + n);
#ifdef Py_REF_DEBUG
_Py_RefTotal += n;
#endif
while (dest < dest_end) {
*dest++ = elem;
}
}
else {
p = np->ob_item;
items = a->ob_item;
for (i = 0; i < n; i++) {
for (j = 0; j < Py_SIZE(a); j++) {
*p = items[j];
Py_INCREF(*p);
p++;
}
PyObject **src = a->ob_item;
PyObject **src_end = src + Py_SIZE(a);
while (src < src_end) {
Py_SET_REFCNT(*src, Py_REFCNT(*src) + n);
#ifdef Py_REF_DEBUG
_Py_RefTotal += n;
#endif
*dest++ = *src++;
}
// Now src chases after dest in the same buffer
src = np->ob_item;
while (dest < dest_end) {
*dest++ = *src++;
}
}
Py_SET_SIZE(np, size);

35
Objects/tupleobject.c
View file

@ -589,10 +589,8 @@ tupleconcat(PyTupleObject *a, PyObject *bb)
static PyObject *
tuplerepeat(PyTupleObject *a, Py_ssize_t n)
{
Py_ssize_t i, j;
Py_ssize_t size;
PyTupleObject *np;
PyObject **p, **items;
if (Py_SIZE(a) == 0 || n == 1) {
if (PyTuple_CheckExact(a)) {
/* Since tuples are immutable, we can return a shared
@ -610,13 +608,32 @@ tuplerepeat(PyTupleObject *a, Py_ssize_t n)
np = tuple_alloc(size);
if (np == NULL)
return NULL;
p = np->ob_item;
items = a->ob_item;
for (i = 0; i < n; i++) {
for (j = 0; j < Py_SIZE(a); j++) {
*p = items[j];
Py_INCREF(*p);
p++;
PyObject **dest = np->ob_item;
PyObject **dest_end = dest + size;
if (Py_SIZE(a) == 1) {
PyObject *elem = a->ob_item[0];
Py_SET_REFCNT(elem, Py_REFCNT(elem) + n);
#ifdef Py_REF_DEBUG
_Py_RefTotal += n;
#endif
while (dest < dest_end) {
*dest++ = elem;
}
}
else {
PyObject **src = a->ob_item;
PyObject **src_end = src + Py_SIZE(a);
while (src < src_end) {
Py_SET_REFCNT(*src, Py_REFCNT(*src) + n);
#ifdef Py_REF_DEBUG
_Py_RefTotal += n;
#endif
*dest++ = *src++;
}
// Now src chases after dest in the same buffer
src = np->ob_item;
while (dest < dest_end) {
*dest++ = *src++;
}
}
_PyObject_GC_TRACK(np);