gh-145192: Improve performance of PySequence_GetSlice

[eendebakpt]

• Improve performance of PySequence_GetSlice by avoiding an incref/decref pairs in _PySlice_FromIndices
• The internal method _PyBuildSlice_Consume2 is refactored so that in consumes references. Before it had the funny property of consuming refs of the the first 2 two slice arguments, but not of the last.
• _PyBuildSlice_ConsumeRefs (used in the opcode _BINARY_SLICE) avoids an incref on Py_None

The PySequence_GetSlice is part of the C api, with no direct equivalent from Python, so the benchmark is in C.

Main:

PySequence_GetSlice benchmark (2000000 iterations)
==============================================

list[1200:1204]      : 0.1314 s  (65.7 ns/call)
list[1500:1800]: 0.9673 s  (480.7 ns/call)
list[1500:1500]: 0.1138 s  (56.9 ns/call)

tuple[1200:1204]     : 0.1216 s  (60.8 ns/call)
tuple[1500:1800]: 1.0420 s  (501.0 ns/call)
tuple[1500:1500]  : 0.0873 s  (43.6 ns/call)

bytes[1200:1204]     : 0.1179 s  (58.9 ns/call)
bytes[1500:1800]: 0.1254 s  (62.7 ns/call)
bytes[1500:1500]  : 0.0905 s  (45.3 ns/call)

PR

PySequence_GetSlice benchmark (2000000 iterations)
==============================================

list[1200:1204]      : 0.1213 s  (60.6 ns/call)
list[1500:1800]: 0.9424 s  (471.2 ns/call)
list[1500:1500]: 0.1006 s  (50.3 ns/call)

tuple[1200:1204]     : 0.1026 s  (51.3 ns/call)
tuple[1500:1800]: 0.9769 s  (488.5 ns/call)
tuple[1500:1500]  : 0.0724 s  (36.2 ns/call)

bytes[1200:1204]     : 0.1001 s  (50.1 ns/call)
bytes[1500:1800]: 0.1093 s  (54.6 ns/call)
bytes[1500:1500]  : 0.0744 s  (37.2 ns/call)

Benchmark details

Run with optimized FT build.

Code:

#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <time.h>

#define ITERATIONS 2000000
#define SIZE 2000

static double
bench_getslice(PyObject *seq, Py_ssize_t i1, Py_ssize_t i2, int iterations)
{
    clock_t start = clock();
    for (int i = 0; i < iterations; i++) {
        PyObject *slice = PySequence_GetSlice(seq, i1, i2);
        if (slice == NULL) {
            PyErr_Print();
            return -1.0;
        }
        Py_DECREF(slice);
    }
    clock_t end = clock();
    return (double)(end - start) / CLOCKS_PER_SEC;
}

int
main(int argc, char *argv[])
{
    Py_Initialize();

    /* Benchmark with a list */
    PyObject *list = PyList_New(SIZE);
    if (list == NULL) {
        PyErr_Print();
        return 1;
    }
    for (Py_ssize_t i = 0; i < SIZE; i++) {
        PyObject *val = PyLong_FromSsize_t(i);
        if (val == NULL) {
            PyErr_Print();
            return 1;
        }
        PyList_SET_ITEM(list, i, val);  /* steals reference */
    }

    printf("PySequence_GetSlice benchmark (%d iterations)\n", ITERATIONS);
    printf("==============================================\n\n");

    /* Small slice */
    double t = bench_getslice(list, 1200, 1204, ITERATIONS);
    printf("list[1200:1204]      : %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    /* Medium slice */
    t = bench_getslice(list, 1500, 1800, ITERATIONS);
    printf("list[1500:1800]: %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    /* Empty slice */
    t = bench_getslice(list, 1500, 1500, ITERATIONS);
    printf("list[1500:1500]: %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    Py_DECREF(list);

    /* Benchmark with a tuple */
    PyObject *tuple = PyTuple_New(SIZE);
    if (tuple == NULL) {
        PyErr_Print();
        return 1;
    }
    for (Py_ssize_t i = 0; i < SIZE; i++) {
        PyObject *val = PyLong_FromSsize_t(i);
        if (val == NULL) {
            PyErr_Print();
            return 1;
        }
        PyTuple_SET_ITEM(tuple, i, val);  /* steals reference */
    }

    printf("\n");

    t = bench_getslice(tuple, 1200, 1204, ITERATIONS);
    printf("tuple[1200:1204]     : %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    t = bench_getslice(tuple, 1500, 1800, ITERATIONS);
    printf("tuple[1500:1800]: %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    t = bench_getslice(tuple, 1500, 1500, ITERATIONS);
    printf("tuple[1500:1500]  : %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    Py_DECREF(tuple);

    /* Benchmark with a bytes object */
    PyObject *bytes = PyBytes_FromStringAndSize(NULL, SIZE);
    if (bytes == NULL) {
        PyErr_Print();
        return 1;
    }
    char *buf = PyBytes_AS_STRING(bytes);
    for (int i = 0; i < SIZE; i++) {
        buf[i] = (char)i;
    }

    printf("\n");

    t = bench_getslice(bytes, 1200, 1204, ITERATIONS);
    printf("bytes[1200:1204]     : %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    t = bench_getslice(bytes, 1500, 1800, ITERATIONS);
    printf("bytes[1500:1800]: %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    t = bench_getslice(bytes, 1500, 1500, ITERATIONS);
    printf("bytes[1500:1500]  : %.4f s  (%.1f ns/call)\n",
           t, t / ITERATIONS * 1e9);

    Py_DECREF(bytes);

    if (Py_FinalizeEx() < 0) {
        return 120;
    }
    return 0;
}

• Issue: Improve performance of PySequence_GetSlice #145192

[markshannon]

Looks good.
Can you drop the news entry, otherwise we end up with many news entries claiming improved performance and no real relation between the volume of claims and the observable speed up.

[markshannon]

Since this consumes all its argument references, the 3 is unnecessary

[markshannon]

In fact, this is now the same as _PyBuildSlice_ConsumeRefs, so you can rename this function and delete the other definition of _PyBuildSlice_ConsumeRefs

[eendebakpt]

The _PyBuildSlice_ConsumeRefs only takes 2 arguments. I can delete it, but it would involve some churn (e.g. in bytecodes.c) because we have to add Py_None as a third argument.

[eendebakpt]

@markshannon I merged the two methods!

[github-actions]

This PR is stale because it has been open for 30 days with no activity.