Skip to content

Commit c5b6a73

Browse files
author
christian.heimes
committed
Unified naming convention for free lists and their limits. All free lists
in Object/ are named ``free_list``, the counter ``numfree`` and the upper limit is a macro ``PyName_MAXFREELIST`` inside an #ifndef block. The chances should make it easier to adjust Python for platforms with less memory, e.g. mobile phones. git-svn-id: http://svn.python.org/projects/python/trunk@60616 6015fed2-1504-0410-9fe1-9d1591cc4771
1 parent ef0485b commit c5b6a73

9 files changed

Lines changed: 99 additions & 84 deletions

File tree

‎Misc/NEWS‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1487,6 +1487,10 @@ Build
14871487
C API
14881488
-----
14891489

1490+
- Unified naming convention for free lists and their limits. All free lists
1491+
in Object/ are named ``free_list``, the counter ``numfree`` and the upper
1492+
limit is a macro ``PyName_MAXFREELIST`` inside an #ifndef block.
1493+
14901494
- ``PySet_Add()`` can now modify a newly created frozenset. Similarly to
14911495
``PyTuple_SetItem``, it can be used to populate a brand new frozenset; but
14921496
it does not steal a reference to the added item.

‎Objects/classobject.c‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,9 @@
99
*/
1010
static PyMethodObject *free_list;
1111
static int numfree = 0;
12-
#define MAXFREELIST 256
12+
#ifndef PyMethod_MAXFREELIST
13+
#define PyMethod_MAXFREELIST 256
14+
#endif
1315

1416
#define TP_DESCR_GET(t) \
1517
(PyType_HasFeature(t, Py_TPFLAGS_HAVE_CLASS) ? (t)->tp_descr_get : NULL)
@@ -2337,7 +2339,7 @@ instancemethod_dealloc(register PyMethodObject *im)
23372339
Py_DECREF(im->im_func);
23382340
Py_XDECREF(im->im_self);
23392341
Py_XDECREF(im->im_class);
2340-
if (numfree < MAXFREELIST) {
2342+
if (numfree < PyMethod_MAXFREELIST) {
23412343
im->im_self = (PyObject *)free_list;
23422344
free_list = im;
23432345
numfree++;

‎Objects/dictobject.c‎

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -183,9 +183,11 @@ show_counts(void)
183183
} while(0)
184184

185185
/* Dictionary reuse scheme to save calls to malloc, free, and memset */
186-
#define MAXFREEDICTS 80
187-
static PyDictObject *free_dicts[MAXFREEDICTS];
188-
static int num_free_dicts = 0;
186+
#ifndef PyDict_MAXFREELIST
187+
#define PyDict_MAXFREELIST 80
188+
#endif
189+
static PyDictObject *free_list[PyDict_MAXFREELIST];
190+
static int numfree = 0;
189191

190192
PyObject *
191193
PyDict_New(void)
@@ -199,8 +201,8 @@ PyDict_New(void)
199201
Py_AtExit(show_counts);
200202
#endif
201203
}
202-
if (num_free_dicts) {
203-
mp = free_dicts[--num_free_dicts];
204+
if (numfree) {
205+
mp = free_list[--numfree];
204206
assert (mp != NULL);
205207
assert (Py_TYPE(mp) == &PyDict_Type);
206208
_Py_NewReference((PyObject *)mp);
@@ -868,8 +870,8 @@ dict_dealloc(register PyDictObject *mp)
868870
}
869871
if (mp->ma_table != mp->ma_smalltable)
870872
PyMem_DEL(mp->ma_table);
871-
if (num_free_dicts < MAXFREEDICTS && Py_TYPE(mp) == &PyDict_Type)
872-
free_dicts[num_free_dicts++] = mp;
873+
if (numfree < PyDict_MAXFREELIST && Py_TYPE(mp) == &PyDict_Type)
874+
free_list[numfree++] = mp;
873875
else
874876
Py_TYPE(mp)->tp_free((PyObject *)mp);
875877
Py_TRASHCAN_SAFE_END(mp)

‎Objects/frameobject.c‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -393,14 +393,15 @@ static PyGetSetDef frame_getsetlist[] = {
393393
call depth of more than 20 or 30 is probably already exceptional
394394
unless the program contains run-away recursion. I hope.
395395
396-
Later, MAXFREELIST was added to bound the # of frames saved on
396+
Later, PyFrame_MAXFREELIST was added to bound the # of frames saved on
397397
free_list. Else programs creating lots of cyclic trash involving
398398
frames could provoke free_list into growing without bound.
399399
*/
400400

401401
static PyFrameObject *free_list = NULL;
402402
static int numfree = 0; /* number of frames currently in free_list */
403-
#define MAXFREELIST 200 /* max value for numfree */
403+
/* max value for numfree */
404+
#define PyFrame_MAXFREELIST 200
404405

405406
static void
406407
frame_dealloc(PyFrameObject *f)
@@ -433,7 +434,7 @@ frame_dealloc(PyFrameObject *f)
433434
co = f->f_code;
434435
if (co->co_zombieframe == NULL)
435436
co->co_zombieframe = f;
436-
else if (numfree < MAXFREELIST) {
437+
else if (numfree < PyFrame_MAXFREELIST) {
437438
++numfree;
438439
f->f_back = free_list;
439440
free_list = f;

‎Objects/listobject.c‎

Lines changed: 13 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -64,18 +64,20 @@ list_resize(PyListObject *self, Py_ssize_t newsize)
6464
}
6565

6666
/* Empty list reuse scheme to save calls to malloc and free */
67-
#define MAXFREELISTS 80
68-
static PyListObject *free_lists[MAXFREELISTS];
69-
static int num_free_lists = 0;
67+
#ifndef PyList_MAXFREELIST
68+
#define PyList_MAXFREELIST 80
69+
#endif
70+
static PyListObject *free_list[PyList_MAXFREELIST];
71+
static int numfree = 0;
7072

7173
void
7274
PyList_Fini(void)
7375
{
7476
PyListObject *op;
7577

76-
while (num_free_lists) {
77-
num_free_lists--;
78-
op = free_lists[num_free_lists];
78+
while (numfree) {
79+
numfree--;
80+
op = free_list[numfree];
7981
assert(PyList_CheckExact(op));
8082
PyObject_GC_Del(op);
8183
}
@@ -95,9 +97,9 @@ PyList_New(Py_ssize_t size)
9597
/* Check for overflow */
9698
if (nbytes / sizeof(PyObject *) != (size_t)size)
9799
return PyErr_NoMemory();
98-
if (num_free_lists) {
99-
num_free_lists--;
100-
op = free_lists[num_free_lists];
100+
if (numfree) {
101+
numfree--;
102+
op = free_list[numfree];
101103
_Py_NewReference((PyObject *)op);
102104
} else {
103105
op = PyObject_GC_New(PyListObject, &PyList_Type);
@@ -265,8 +267,8 @@ list_dealloc(PyListObject *op)
265267
}
266268
PyMem_FREE(op->ob_item);
267269
}
268-
if (num_free_lists < MAXFREELISTS && PyList_CheckExact(op))
269-
free_lists[num_free_lists++] = op;
270+
if (numfree < PyList_MAXFREELIST && PyList_CheckExact(op))
271+
free_list[numfree++] = op;
270272
else
271273
Py_TYPE(op)->tp_free((PyObject *)op);
272274
Py_TRASHCAN_SAFE_END(op)

‎Objects/methodobject.c‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,9 @@
99
*/
1010
static PyCFunctionObject *free_list = NULL;
1111
static int numfree = 0;
12-
#define MAXFREELIST 256
12+
#ifndef PyCFunction_MAXFREELIST
13+
#define PyCFunction_MAXFREELIST 256
14+
#endif
1315

1416
PyObject *
1517
PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)
@@ -131,7 +133,7 @@ meth_dealloc(PyCFunctionObject *m)
131133
_PyObject_GC_UNTRACK(m);
132134
Py_XDECREF(m->m_self);
133135
Py_XDECREF(m->m_module);
134-
if (numfree < MAXFREELIST) {
136+
if (numfree < PyCFunction_MAXFREELIST) {
135137
m->m_self = (PyObject *)free_list;
136138
free_list = m;
137139
numfree++;

‎Objects/setobject.c‎

Lines changed: 12 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -51,9 +51,11 @@ _PySet_Dummy(void)
5151
} while(0)
5252

5353
/* Reuse scheme to save calls to malloc, free, and memset */
54-
#define MAXFREESETS 80
55-
static PySetObject *free_sets[MAXFREESETS];
56-
static int num_free_sets = 0;
54+
#ifndef PySet_MAXFREELIST
55+
#define PySet_MAXFREELIST 80
56+
#endif
57+
static PySetObject *free_list[PySet_MAXFREELIST];
58+
static int numfree = 0;
5759

5860
/*
5961
The basic lookup function used by all operations.
@@ -558,8 +560,8 @@ set_dealloc(PySetObject *so)
558560
}
559561
if (so->table != so->smalltable)
560562
PyMem_DEL(so->table);
561-
if (num_free_sets < MAXFREESETS && PyAnySet_CheckExact(so))
562-
free_sets[num_free_sets++] = so;
563+
if (numfree < PySet_MAXFREELIST && PyAnySet_CheckExact(so))
564+
free_list[numfree++] = so;
563565
else
564566
Py_TYPE(so)->tp_free(so);
565567
Py_TRASHCAN_SAFE_END(so)
@@ -983,9 +985,9 @@ make_new_set(PyTypeObject *type, PyObject *iterable)
983985
}
984986

985987
/* create PySetObject structure */
986-
if (num_free_sets &&
988+
if (numfree &&
987989
(type == &PySet_Type || type == &PyFrozenSet_Type)) {
988-
so = free_sets[--num_free_sets];
990+
so = free_list[--numfree];
989991
assert (so != NULL && PyAnySet_CheckExact(so));
990992
Py_TYPE(so) = type;
991993
_Py_NewReference((PyObject *)so);
@@ -1053,9 +1055,9 @@ PySet_Fini(void)
10531055
{
10541056
PySetObject *so;
10551057

1056-
while (num_free_sets) {
1057-
num_free_sets--;
1058-
so = free_sets[num_free_sets];
1058+
while (numfree) {
1059+
numfree--;
1060+
so = free_list[numfree];
10591061
PyObject_GC_Del(so);
10601062
}
10611063
Py_CLEAR(dummy);

‎Objects/tupleobject.c‎

Lines changed: 29 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -4,19 +4,19 @@
44
#include "Python.h"
55

66
/* Speed optimization to avoid frequent malloc/free of small tuples */
7-
#ifndef MAXSAVESIZE
8-
#define MAXSAVESIZE 20 /* Largest tuple to save on free list */
7+
#ifndef PyTuple_MAXSAVESIZE
8+
#define PyTuple_MAXSAVESIZE 20 /* Largest tuple to save on free list */
99
#endif
10-
#ifndef MAXSAVEDTUPLES
11-
#define MAXSAVEDTUPLES 2000 /* Maximum number of tuples of each size to save */
10+
#ifndef PyTuple_MAXFREELIST
11+
#define PyTuple_MAXFREELIST 2000 /* Maximum number of tuples of each size to save */
1212
#endif
1313

14-
#if MAXSAVESIZE > 0
15-
/* Entries 1 up to MAXSAVESIZE are free lists, entry 0 is the empty
14+
#if PyTuple_MAXSAVESIZE > 0
15+
/* Entries 1 up to PyTuple_MAXSAVESIZE are free lists, entry 0 is the empty
1616
tuple () of which at most one instance will be allocated.
1717
*/
18-
static PyTupleObject *free_tuples[MAXSAVESIZE];
19-
static int num_free_tuples[MAXSAVESIZE];
18+
static PyTupleObject *free_list[PyTuple_MAXSAVESIZE];
19+
static int numfree[PyTuple_MAXSAVESIZE];
2020
#endif
2121
#ifdef COUNT_ALLOCS
2222
int fast_tuple_allocs;
@@ -32,18 +32,18 @@ PyTuple_New(register Py_ssize_t size)
3232
PyErr_BadInternalCall();
3333
return NULL;
3434
}
35-
#if MAXSAVESIZE > 0
36-
if (size == 0 && free_tuples[0]) {
37-
op = free_tuples[0];
35+
#if PyTuple_MAXSAVESIZE > 0
36+
if (size == 0 && free_list[0]) {
37+
op = free_list[0];
3838
Py_INCREF(op);
3939
#ifdef COUNT_ALLOCS
4040
tuple_zero_allocs++;
4141
#endif
4242
return (PyObject *) op;
4343
}
44-
if (size < MAXSAVESIZE && (op = free_tuples[size]) != NULL) {
45-
free_tuples[size] = (PyTupleObject *) op->ob_item[0];
46-
num_free_tuples[size]--;
44+
if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
45+
free_list[size] = (PyTupleObject *) op->ob_item[0];
46+
numfree[size]--;
4747
#ifdef COUNT_ALLOCS
4848
fast_tuple_allocs++;
4949
#endif
@@ -71,10 +71,10 @@ PyTuple_New(register Py_ssize_t size)
7171
}
7272
for (i=0; i < size; i++)
7373
op->ob_item[i] = NULL;
74-
#if MAXSAVESIZE > 0
74+
#if PyTuple_MAXSAVESIZE > 0
7575
if (size == 0) {
76-
free_tuples[0] = op;
77-
++num_free_tuples[0];
76+
free_list[0] = op;
77+
++numfree[0];
7878
Py_INCREF(op); /* extra INCREF so that this is never freed */
7979
}
8080
#endif
@@ -167,14 +167,14 @@ tupledealloc(register PyTupleObject *op)
167167
i = len;
168168
while (--i >= 0)
169169
Py_XDECREF(op->ob_item[i]);
170-
#if MAXSAVESIZE > 0
171-
if (len < MAXSAVESIZE &&
172-
num_free_tuples[len] < MAXSAVEDTUPLES &&
170+
#if PyTuple_MAXSAVESIZE > 0
171+
if (len < PyTuple_MAXSAVESIZE &&
172+
numfree[len] < PyTuple_MAXFREELIST &&
173173
Py_TYPE(op) == &PyTuple_Type)
174174
{
175-
op->ob_item[0] = (PyObject *) free_tuples[len];
176-
num_free_tuples[len]++;
177-
free_tuples[len] = op;
175+
op->ob_item[0] = (PyObject *) free_list[len];
176+
numfree[len]++;
177+
free_list[len] = op;
178178
goto done; /* return */
179179
}
180180
#endif
@@ -781,16 +781,16 @@ _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
781781
void
782782
PyTuple_Fini(void)
783783
{
784-
#if MAXSAVESIZE > 0
784+
#if PyTuple_MAXSAVESIZE > 0
785785
int i;
786786

787-
Py_XDECREF(free_tuples[0]);
788-
free_tuples[0] = NULL;
787+
Py_XDECREF(free_list[0]);
788+
free_list[0] = NULL;
789789

790-
for (i = 1; i < MAXSAVESIZE; i++) {
790+
for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
791791
PyTupleObject *p, *q;
792-
p = free_tuples[i];
793-
free_tuples[i] = NULL;
792+
p = free_list[i];
793+
free_list[i] = NULL;
794794
while (p) {
795795
q = p;
796796
p = (PyTupleObject *)(p->ob_item[0]);

0 commit comments

Comments
 (0)