gh-87613: Use AC vectorcall for bytes and bytearray

Speeds up common construction of both objects. Enables optimizing
construction off uniquely referenced temporary objects.

Previously the argument tuples / dictionaries required by the call
protocol resulted in arguments never being unique temporaries. With
vectorcall they can be. Avoid copying by adopting the existing
allocation when possible.

Benchmark
Run on my linux dev machine: PGO+LTO, clang 23, --with-tail-call-interp

(note: AI Written, but I think sufficiently representative)
```python
"""bytes() and bytearray() construction.

temp/ passes a unique temporary (adopted, no copy); named/ binds the same
source to a name first so it is always copied.
"""
import pyperf

runner = pyperf.Runner()

runner.timeit('call/bytes()', 'bytes()')
runner.timeit('call/bytes(int)', 'bytes(16)')
runner.timeit('call/bytes(bytes)', "bytes(b'abcdefghabcdefgh')")
runner.timeit("call/bytes(str, 'ascii')", "bytes('abcdefgh', 'ascii')")
runner.timeit('call/bytearray()', 'bytearray()')
runner.timeit('call/bytearray(int)', 'bytearray(16)')
runner.timeit('call/bytearray(bytes)', "bytearray(b'abcdefghabcdefgh')")
runner.timeit("call/bytearray(str, 'ascii')",
              "bytearray('abcdefgh', 'ascii')")

for size_name, size in (('16B', 16), ('4KiB', 4096), ('1MiB', 1 << 20)):
    # Slicing in the statement makes a fresh unique temporary.
    setup = f"b = b'x' * {size}; ba = bytearray(b)"
    runner.timeit(f'temp/bytes(bytearray) {size_name}',
                  'bytes(ba[1:])', setup)
    runner.timeit(f'named/bytes(bytearray) {size_name}',
                  'x = ba[1:]; bytes(x); del x', setup)
    runner.timeit(f'temp/bytearray(bytes) {size_name}',
                  'bytearray(b[1:])', setup)
    runner.timeit(f'named/bytearray(bytes) {size_name}',
                  'x = b[1:]; bytearray(x); del x', setup)
    runner.timeit(f'temp/bytearray(bytearray) {size_name}',
                  'bytearray(ba[1:])', setup)
    runner.timeit(f'named/bytearray(bytearray) {size_name}',
                  'x = ba[1:]; bytearray(x); del x', setup)
```

| Benchmark                       | main    | patch                  |
|---------------------------------|:-------:|:----------------------:|
| temp/bytearray(bytearray) 1MiB  | 515 us  | 14.9 us: 34.53x faster |
| temp/bytearray(bytes) 1MiB      | 508 us  | 14.8 us: 34.27x faster |
| temp/bytes(bytearray) 1MiB      | 507 us  | 14.9 us: 34.05x faster |
| temp/bytearray(bytes) 4KiB      | 144 ns  | 79.5 ns: 1.81x faster  |
| temp/bytearray(bytearray) 4KiB  | 155 ns  | 94.7 ns: 1.63x faster  |
| temp/bytearray(bytes) 16B       | 56.4 ns | 36.1 ns: 1.56x faster  |
| temp/bytes(bytearray) 4KiB      | 150 ns  | 96.4 ns: 1.55x faster  |
| temp/bytearray(bytearray) 16B   | 64.1 ns | 47.3 ns: 1.35x faster  |
| call/bytes()                    | 14.7 ns | 11.1 ns: 1.32x faster  |
| call/bytes(int)                 | 31.5 ns | 24.3 ns: 1.29x faster  |
| call/bytes(str, 'ascii')        | 36.9 ns | 28.7 ns: 1.28x faster  |
| call/bytes(bytes)               | 34.3 ns | 27.3 ns: 1.26x faster  |
| temp/bytes(bytearray) 16B       | 59.4 ns | 49.5 ns: 1.20x faster  |
| call/bytearray(str, 'ascii')    | 45.6 ns | 39.1 ns: 1.17x faster  |
| call/bytearray(bytes)           | 44.3 ns | 38.9 ns: 1.14x faster  |
| call/bytearray(int)             | 41.7 ns | 37.3 ns: 1.12x faster  |
| named/bytearray(bytes) 16B      | 59.6 ns | 54.4 ns: 1.10x faster  |
| named/bytes(bytearray) 16B      | 61.3 ns | 56.2 ns: 1.09x faster  |
| named/bytearray(bytearray) 16B  | 65.3 ns | 60.9 ns: 1.07x faster  |
| named/bytes(bytearray) 4KiB     | 154 ns  | 148 ns: 1.04x faster   |
| call/bytearray()                | 22.1 ns | 21.4 ns: 1.03x faster  |
| named/bytearray(bytearray) 4KiB | 156 ns  | 151 ns: 1.03x faster   |
| named/bytearray(bytes) 4KiB     | 146 ns  | 143 ns: 1.02x faster   |
| Geometric mean                  | (ref)   | 1.77x faster           |

Benchmark hidden because not significant (3): named/bytes(bytearray) 1MiB,
named/bytearray(bytes) 1MiB, named/bytearray(bytearray) 1MiB

Author: cmaloney

Lib/test/test_bytes.py

@@ -16,6 +16,7 @@
 import sys
 import tempfile
 import textwrap
+lazy import tracemalloc
 import threading
 import unittest
 from _codecs import _unregister_error as _codecs_unregister_error
@@ -1809,6 +1810,23 @@ def hashing_codec(name):
         self.assertEqual(taken, b'Hello')
         self.assertEqual(hash(taken), hash(b'Hello'))
 
+    @support.cpython_only
+    @support.bigmemtest(size=support._1G, memuse=1)
+    def test_unique_temporary_take_memory(self, size):
+        # Optimization: When passed a unique temporary adopt it rather than
+        # allocate + copy + deallocate.
+        def peak(func):
+            tracemalloc.start()
+            try:
+                func()
+                return tracemalloc.get_traced_memory()[1]
+            finally:
+                tracemalloc.stop()
+        # Copy would be 2.0, 1.5 gives space for other allocations.
+        self.assertLess(peak(lambda: bytearray(bytes(size))), size * 1.5)
+        self.assertLess(peak(lambda: bytearray(bytearray(size))), size * 1.5)
+        self.assertLess(peak(lambda: bytes(bytearray(size))), size * 1.5)
+
     def test_take_bytes_reentrant_resize(self):
         # gh-153570: n.__index__() can resize the bytearray, so take_bytes()
         # must re-read the size afterwards.  It cached the size before the

Misc/NEWS.d/next/Core_and_Builtins/2026-10-05-13-19-49.gh-issue-87613.JLTGBy.rst

@@ -0,0 +1,2 @@
+Speed up :class:`bytes` and :class:`bytearray` construction by adding
+:ref:`vectorcall` support.

Objects/bytearrayobject.c

@@ -977,6 +977,7 @@ bytearray_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 }
 
 /*[clinic input]
+@vectorcall
 bytearray.__init__
 
     source as arg: object = NULL
@@ -988,7 +989,7 @@ bytearray.__init__
 static int
 bytearray___init___impl(PyByteArrayObject *self, PyObject *arg,
                         const char *encoding, const char *errors)
-/*[clinic end generated code: output=4ce1304649c2f8b3 input=1141a7122eefd7b9]*/
+/*[clinic end generated code: output=4ce1304649c2f8b3 input=24ddb84055f432dd]*/
 {
     Py_ssize_t count;
     PyObject *it;
@@ -1082,6 +1083,33 @@ bytearray___init___impl(PyByteArrayObject *self, PyObject *arg,
         }
     }
 
+    /* optimization: Adopt bytes rather than copying. */
+    if (PyBytes_CheckExact(arg)
+        && PyUnstable_Object_IsUniqueReferencedTemporary(arg)
+        && _PyBytes_GET_CACHED_HASH((PyBytesObject *)arg) == -1)
+    {
+        /* Reinit before taking a reference: it asserts the bytes is
+           uniquely referenced. */
+        self->ob_bytes_object = arg;
+        bytearray_reinit_from_bytes(self, PyBytes_GET_SIZE(arg));
+        Py_INCREF(arg);
+        return 0;
+    }
+
+    /* optimization: Adopt bytearray rather than copying. */
+    if (PyByteArray_CheckExact(arg)
+        && PyUnstable_Object_IsUniqueReferencedTemporary(arg))
+    {
+        PyObject *bytes = bytearray_take_bytes_impl((PyByteArrayObject *)arg,
+                                                    Py_None);
+        if (bytes == NULL) {
+            return -1;
+        }
+        self->ob_bytes_object = bytes;
+        bytearray_reinit_from_bytes(self, PyBytes_GET_SIZE(bytes));
+        return 0;
+    }
+
     /* Use the buffer API */
     if (PyObject_CheckBuffer(arg)) {
         Py_ssize_t size;
@@ -3027,6 +3055,7 @@ PyTypeObject PyByteArray_Type = {
     PyType_GenericAlloc,                /* tp_alloc */
     bytearray_new,                      /* tp_new */
     PyObject_Free,                      /* tp_free */
+    .tp_vectorcall = bytearray_vectorcall,
     .tp_version_tag = _Py_TYPE_VERSION_BYTEARRAY,
 };
 

Objects/bytesobject.c

@@ -2918,6 +2918,7 @@ static PyObject *
 bytes_subtype_new(PyTypeObject *, PyObject *);
 
 /*[clinic input]
+@vectorcall
 @classmethod
 bytes.__new__ as bytes_new
 
@@ -2930,7 +2931,7 @@ bytes.__new__ as bytes_new
 static PyObject *
 bytes_new_impl(PyTypeObject *type, PyObject *x, const char *encoding,
                const char *errors)
-/*[clinic end generated code: output=1e0c471be311a425 input=f0a966d19b7262b4]*/
+/*[clinic end generated code: output=1e0c471be311a425 input=b0248d22e221a095]*/
 {
     PyObject *bytes;
     PyObject *func;
@@ -3002,6 +3003,11 @@ bytes_new_impl(PyTypeObject *type, PyObject *x, const char *encoding,
             bytes = _PyBytes_FromSizeZero(size);
         }
     }
+    /* Adopt unique temporary bytearray rather than copying. */
+    else if (PyByteArray_CheckExact(x)
+             && PyUnstable_Object_IsUniqueReferencedTemporary(x)) {
+        bytes = PyObject_CallMethodNoArgs(x, &_Py_ID(take_bytes));
+    }
     else {
         bytes = PyBytes_FromObject(x);
     }
@@ -3316,6 +3322,7 @@ PyTypeObject PyBytes_Type = {
     bytes_type_alloc,                           /* tp_alloc */
     bytes_new,                                  /* tp_new */
     PyObject_Free,                              /* tp_free */
+    .tp_vectorcall = bytes_vectorcall,
     .tp_version_tag = _Py_TYPE_VERSION_BYTES,
     ._tp_iteritem = bytes_iteritem,
 };