Skip to content

Commit 098887e

Browse files
committed
pythongh-158585: Add bytes_alloc() helper function
Add bytes_alloc() and _PyBytes_FromStringAndSize() have less conditional branches and so may be a little bit faster. * Replace _PyBytes_FromSize(calloc=1) with _PyBytes_FromSizeZero(). * Rename existing bytes_alloc() to bytes_type_alloc(). * Replace PyBytes_FromStringAndSize(NULL, size) with bytes_alloc(size). * Add _PyBytes_FromStringAndSize(): similar to PyBytes_FromStringAndSize(), but str must not be NULL. * Use _PyBytes_FromStringAndSize().
1 parent 9a15440 commit 098887e

1 file changed

Lines changed: 85 additions & 47 deletions

File tree

‎Objects/bytesobject.c‎

Lines changed: 85 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -99,8 +99,36 @@ _Py_COMP_DIAG_POP
9999
PyBytes_FromStringAndSize()) or the length of the string in the 'str'
100100
parameter (for PyBytes_FromString()).
101101
*/
102+
103+
// Allocate a new bytes object with contents left uninitialized. The caller is
104+
// responsible to fill the contents. size must be greater than 0.
105+
static PyObject *
106+
bytes_alloc(Py_ssize_t size)
107+
{
108+
assert(size >= 1);
109+
110+
if ((size_t)size > (size_t)PY_SSIZE_T_MAX - PyBytesObject_SIZE) {
111+
PyErr_SetString(PyExc_OverflowError,
112+
"byte string is too large");
113+
return NULL;
114+
}
115+
size_t alloc = PyBytesObject_SIZE + size;
116+
117+
/* Inline PyObject_NewVar */
118+
PyBytesObject *op = (PyBytesObject *)PyObject_Malloc(alloc);
119+
if (op == NULL) {
120+
return PyErr_NoMemory();
121+
}
122+
123+
_PyObject_InitVar(_PyVarObject_CAST(op), &PyBytes_Type, size);
124+
set_ob_shash(op, -1);
125+
op->ob_sval[size] = '\0';
126+
return (PyObject *) op;
127+
}
128+
129+
// Create a new bytes object with contents initialized to 0. size can be 0.
102130
static PyObject *
103-
_PyBytes_FromSize(Py_ssize_t size, int use_calloc)
131+
_PyBytes_FromSizeZero(Py_ssize_t size)
104132
{
105133
PyBytesObject *op;
106134
assert(size >= 0);
@@ -114,47 +142,58 @@ _PyBytes_FromSize(Py_ssize_t size, int use_calloc)
114142
"byte string is too large");
115143
return NULL;
116144
}
145+
size_t alloc = PyBytesObject_SIZE + size;
117146

118147
/* Inline PyObject_NewVar */
119-
if (use_calloc)
120-
op = (PyBytesObject *)PyObject_Calloc(1, PyBytesObject_SIZE + size);
121-
else
122-
op = (PyBytesObject *)PyObject_Malloc(PyBytesObject_SIZE + size);
148+
op = (PyBytesObject *)PyObject_Calloc(1, alloc);
123149
if (op == NULL) {
124150
return PyErr_NoMemory();
125151
}
126152
_PyObject_InitVar((PyVarObject*)op, &PyBytes_Type, size);
127153
set_ob_shash(op, -1);
128-
if (!use_calloc) {
129-
op->ob_sval[size] = '\0';
154+
return (PyObject *) op;
155+
}
156+
157+
// Similar to PyBytes_FromStringAndSize(), but str must not be NULL.
158+
static PyObject *
159+
_PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
160+
{
161+
assert(str != NULL);
162+
assert(size >= 0);
163+
164+
if (size == 0) {
165+
return bytes_get_empty();
166+
}
167+
if (size == 1) {
168+
return bytes_get_char((uint8_t)str[0]);
130169
}
170+
171+
PyBytesObject *op = (PyBytesObject *)bytes_alloc(size);
172+
if (op == NULL) {
173+
return NULL;
174+
}
175+
memcpy(op->ob_sval, str, size);
131176
return (PyObject *) op;
132177
}
133178

134179
PyObject *
135180
PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
136181
{
137-
PyBytesObject *op;
138182
if (size < 0) {
139183
PyErr_SetString(PyExc_SystemError,
140184
"Negative size passed to PyBytes_FromStringAndSize");
141185
return NULL;
142186
}
143-
if (size == 1 && str != NULL) {
144-
return bytes_get_char((uint8_t)*str);
187+
188+
if (str != NULL) {
189+
return _PyBytes_FromStringAndSize(str, size);
145190
}
146-
if (size == 0) {
147-
return bytes_get_empty();
191+
else {
192+
if (size == 0) {
193+
return bytes_get_empty();
194+
}
195+
return bytes_alloc(size);
148196
}
149-
150-
op = (PyBytesObject *)_PyBytes_FromSize(size, 0);
151-
if (op == NULL)
152-
return NULL;
153-
if (str == NULL)
154-
return (PyObject *) op;
155-
156-
memcpy(op->ob_sval, str, size);
157-
return (PyObject *) op;
158197
}
159198

160199
PyObject *
@@ -489,7 +528,7 @@ formatfloat(PyObject *v, Py_ssize_t argidx, PyObject *key,
489528
return str;
490529
}
491530

492-
result = PyBytes_FromStringAndSize(p, len);
531+
result = _PyBytes_FromStringAndSize(p, len);
493532
PyMem_Free(p);
494533
*p_result = result;
495534
return result != NULL ? str : NULL;
@@ -743,8 +782,7 @@ _PyBytes_FormatEx(const char *format, Py_ssize_t format_len,
743782
(Py_ssize_t)(fmtstart - format - 1));
744783
goto error;
745784
}
746-
key = PyBytes_FromStringAndSize(keystart,
747-
keylen);
785+
key = _PyBytes_FromStringAndSize(keystart, keylen);
748786
if (key == NULL)
749787
goto error;
750788
if (args_owned) {
@@ -1572,7 +1610,7 @@ _PyBytes_Concat(PyObject *a, PyObject *b)
15721610
goto done;
15731611
}
15741612

1575-
result = PyBytes_FromStringAndSize(NULL, va.len + vb.len);
1613+
result = bytes_alloc(va.len + vb.len);
15761614
if (result != NULL) {
15771615
memcpy(PyBytes_AS_STRING(result), va.buf, va.len);
15781616
memcpy(PyBytes_AS_STRING(result) + va.len, vb.buf, vb.len);
@@ -1755,7 +1793,6 @@ bytes_subscript(PyObject *op, PyObject* item)
17551793
size_t cur;
17561794
const char* source_buf;
17571795
char* result_buf;
1758-
PyObject* result;
17591796

17601797
if (PySlice_Unpack(item, &start, &stop, &step) < 0) {
17611798
return NULL;
@@ -1772,22 +1809,22 @@ bytes_subscript(PyObject *op, PyObject* item)
17721809
return Py_NewRef(self);
17731810
}
17741811
else if (step == 1) {
1775-
return PyBytes_FromStringAndSize(
1812+
return _PyBytes_FromStringAndSize(
17761813
PyBytes_AS_STRING(self) + start,
17771814
slicelength);
17781815
}
17791816
else {
17801817
source_buf = PyBytes_AS_STRING(self);
1781-
result = PyBytes_FromStringAndSize(NULL, slicelength);
1782-
if (result == NULL)
1818+
PyObject* result = bytes_alloc(slicelength);
1819+
if (result == NULL) {
17831820
return NULL;
1821+
}
17841822

17851823
result_buf = PyBytes_AS_STRING(result);
17861824
for (cur = start, i = 0; i < slicelength;
17871825
cur += step, i++) {
17881826
result_buf[i] = source_buf[cur];
17891827
}
1790-
17911828
return result;
17921829
}
17931830
}
@@ -1843,7 +1880,7 @@ bytes___bytes___impl(PyBytesObject *self)
18431880
return Py_NewRef(self);
18441881
}
18451882
else {
1846-
return PyBytes_FromStringAndSize(self->ob_sval, Py_SIZE(self));
1883+
return _PyBytes_FromStringAndSize(self->ob_sval, Py_SIZE(self));
18471884
}
18481885
}
18491886

@@ -2134,7 +2171,7 @@ do_xstrip(PyBytesObject *self, int striptype, PyObject *sepobj)
21342171
return Py_NewRef(self);
21352172
}
21362173
else
2137-
return PyBytes_FromStringAndSize(s+i, j-i);
2174+
return _PyBytes_FromStringAndSize(s+i, j-i);
21382175
}
21392176

21402177

@@ -2163,7 +2200,7 @@ do_strip(PyBytesObject *self, int striptype)
21632200
return Py_NewRef(self);
21642201
}
21652202
else
2166-
return PyBytes_FromStringAndSize(s+i, j-i);
2203+
return _PyBytes_FromStringAndSize(s+i, j-i);
21672204
}
21682205

21692206

@@ -2468,15 +2505,15 @@ bytes_removeprefix_impl(PyBytesObject *self, Py_buffer *prefix)
24682505
&& prefix_len > 0
24692506
&& memcmp(self_start, prefix_start, prefix_len) == 0)
24702507
{
2471-
return PyBytes_FromStringAndSize(self_start + prefix_len,
2472-
self_len - prefix_len);
2508+
return _PyBytes_FromStringAndSize(self_start + prefix_len,
2509+
self_len - prefix_len);
24732510
}
24742511

24752512
if (PyBytes_CheckExact(self)) {
24762513
return Py_NewRef(self);
24772514
}
24782515

2479-
return PyBytes_FromStringAndSize(self_start, self_len);
2516+
return _PyBytes_FromStringAndSize(self_start, self_len);
24802517
}
24812518

24822519
/*[clinic input]
@@ -2507,15 +2544,15 @@ bytes_removesuffix_impl(PyBytesObject *self, Py_buffer *suffix)
25072544
&& memcmp(self_start + self_len - suffix_len,
25082545
suffix_start, suffix_len) == 0)
25092546
{
2510-
return PyBytes_FromStringAndSize(self_start,
2511-
self_len - suffix_len);
2547+
return _PyBytes_FromStringAndSize(self_start,
2548+
self_len - suffix_len);
25122549
}
25132550

25142551
if (PyBytes_CheckExact(self)) {
25152552
return Py_NewRef(self);
25162553
}
25172554

2518-
return PyBytes_FromStringAndSize(self_start, self_len);
2555+
return _PyBytes_FromStringAndSize(self_start, self_len);
25192556
}
25202557

25212558
/*[clinic input]
@@ -2953,7 +2990,7 @@ bytes_new_impl(PyTypeObject *type, PyObject *x, const char *encoding,
29532990
PyErr_SetString(PyExc_ValueError, "negative count");
29542991
return NULL;
29552992
}
2956-
bytes = _PyBytes_FromSize(size, 1);
2993+
bytes = _PyBytes_FromSizeZero(size);
29572994
}
29582995
}
29592996
else {
@@ -3142,8 +3179,9 @@ PyBytes_FromObject(PyObject *x)
31423179
* This allocator will be removed when ob_shash is removed.
31433180
*/
31443181
static PyObject *
3145-
bytes_alloc(PyTypeObject *self, Py_ssize_t nitems)
3182+
bytes_type_alloc(PyTypeObject *self, Py_ssize_t nitems)
31463183
{
3184+
// Initialize memory to zero
31473185
PyBytesObject *obj = (PyBytesObject*)PyType_GenericAlloc(self, nitems);
31483186
if (obj == NULL) {
31493187
return NULL;
@@ -3267,7 +3305,7 @@ PyTypeObject PyBytes_Type = {
32673305
0, /* tp_descr_set */
32683306
0, /* tp_dictoffset */
32693307
0, /* tp_init */
3270-
bytes_alloc, /* tp_alloc */
3308+
bytes_type_alloc, /* tp_alloc */
32713309
bytes_new, /* tp_new */
32723310
PyObject_Free, /* tp_free */
32733311
.tp_version_tag = _Py_TYPE_VERSION_BYTES,
@@ -3428,7 +3466,6 @@ int
34283466
_PyBytes_ResizeKeepOnError(PyObject **pv, Py_ssize_t newsize)
34293467
{
34303468
PyObject *v = *pv;
3431-
PyObject *result;
34323469

34333470
if (!PyBytes_Check(v) || newsize < 0) {
34343471
PyErr_BadInternalCall();
@@ -3442,7 +3479,8 @@ _PyBytes_ResizeKeepOnError(PyObject **pv, Py_ssize_t newsize)
34423479
}
34433480

34443481
if (oldsize == 0) {
3445-
result = _PyBytes_FromSize(newsize, 0);
3482+
assert(newsize >= 1);
3483+
PyObject *result = bytes_alloc(newsize);
34463484
if (result == NULL) {
34473485
return -1;
34483486
}
@@ -3461,7 +3499,7 @@ _PyBytes_ResizeKeepOnError(PyObject **pv, Py_ssize_t newsize)
34613499
if (!_PyObject_IsUniquelyReferenced(v)) {
34623500
// Allocate and then copy so we don't get a shared immortal
34633501
// one-character singleton!
3464-
result = _PyBytes_FromSize(newsize, 0);
3502+
PyObject *result = bytes_alloc(newsize);
34653503
if (!result) {
34663504
return -1;
34673505
}
@@ -3824,7 +3862,7 @@ byteswriter_resize(PyBytesWriter *writer, Py_ssize_t new_size, int resize)
38243862
data = PyByteArray_AS_STRING(writer->obj);
38253863
}
38263864
else {
3827-
writer->obj = PyBytes_FromStringAndSize(NULL, alloc);
3865+
writer->obj = bytes_alloc(alloc);
38283866
if (writer->obj == NULL) {
38293867
return -1;
38303868
}
@@ -3994,7 +4032,7 @@ PyBytesWriter_FinishWithSize(PyBytesWriter *writer, Py_ssize_t size)
39944032
result = bytes_get_char((uint8_t)buffer[0]);
39954033
}
39964034
else {
3997-
result = _PyBytes_FromSize(size, 0);
4035+
result = bytes_alloc(size);
39984036
if (result == NULL) {
39994037
goto error;
40004038
}

0 commit comments

Comments
 (0)