Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Merge

This commit is contained in:
Antoine Pitrou 2012-06-22 21:13:34 +02:00
parent f7338f65fb 49526f48fc
commit 5f6213be2d
26 changed files with 239 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Doc/library/sys.rst
View File

@ -106,6 +106,22 @@ always available.
This function should be used for internal and specialized purposes only.
.. function:: _debugmallocstats()
Print low-level information to stderr about the state of CPython's memory
allocator.
If Python is configured --with-pydebug, it also performs some expensive
internal consistency checks.
.. versionadded:: 3.3
.. impl-detail::
This function is specific to CPython. The exact output format is not
defined here, and may change.
.. data:: dllhandle
Integer specifying the handle of the Python DLL. Availability: Windows.

1
Include/dictobject.h
View File

@ -111,6 +111,7 @@ PyAPI_FUNC(int) PyDict_DelItemString(PyObject *dp, const char *key);
#ifndef Py_LIMITED_API
int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, PyObject *name, PyObject *value);
PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *);
PyAPI_FUNC(void) _PyDict_DebugMallocStats(FILE *out);
#endif
#ifdef __cplusplus

2
Include/floatobject.h
View File

@ -110,6 +110,8 @@ PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le);
/* free list api */
PyAPI_FUNC(int) PyFloat_ClearFreeList(void);
PyAPI_FUNC(void) _PyFloat_DebugMallocStats(FILE* out);
/* Format the object based on the format_spec, as defined in PEP 3101
(Advanced String Formatting). */
PyAPI_FUNC(int) _PyFloat_FormatAdvancedWriter(

2
Include/frameobject.h
View File

@ -79,6 +79,8 @@ PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
PyAPI_FUNC(int) PyFrame_ClearFreeList(void);
PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out);
/* Return the line of code the frame is currently executing. */
PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *);

1
Include/listobject.h
View File

@ -64,6 +64,7 @@ PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *);
PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *);
PyAPI_FUNC(int) PyList_ClearFreeList(void);
PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out);
#endif
/* Macro, trading safety for speed */

5
Include/methodobject.h
View File

@ -82,6 +82,11 @@ typedef struct {
PyAPI_FUNC(int) PyCFunction_ClearFreeList(void);
#ifndef Py_LIMITED_API
PyAPI_FUNC(void) _PyCFunction_DebugMallocStats(FILE *out);
PyAPI_FUNC(void) _PyMethod_DebugMallocStats(FILE *out);
#endif
#ifdef __cplusplus
}
#endif

8
Include/object.h
View File

@ -977,6 +977,14 @@ PyAPI_DATA(PyObject *) _PyTrash_delete_later;
else \
_PyTrash_deposit_object((PyObject*)op);
#ifndef Py_LIMITED_API
PyAPI_FUNC(void)
_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks,
size_t sizeof_block);
PyAPI_FUNC(void)
_PyObject_DebugTypeStats(FILE *out);
#endif /* ifndef Py_LIMITED_API */
#ifdef __cplusplus
}
#endif

4
Include/objimpl.h
View File

@ -101,13 +101,15 @@ PyAPI_FUNC(void) PyObject_Free(void *);
/* Macros */
#ifdef WITH_PYMALLOC
#ifndef Py_LIMITED_API
PyAPI_FUNC(void) _PyObject_DebugMallocStats(FILE *out);
#endif /* #ifndef Py_LIMITED_API */
#ifdef PYMALLOC_DEBUG /* WITH_PYMALLOC && PYMALLOC_DEBUG */
PyAPI_FUNC(void *) _PyObject_DebugMalloc(size_t nbytes);
PyAPI_FUNC(void *) _PyObject_DebugRealloc(void *p, size_t nbytes);
PyAPI_FUNC(void) _PyObject_DebugFree(void *p);
PyAPI_FUNC(void) _PyObject_DebugDumpAddress(const void *p);
PyAPI_FUNC(void) _PyObject_DebugCheckAddress(const void *p);
PyAPI_FUNC(void) _PyObject_DebugMallocStats(void);
PyAPI_FUNC(void *) _PyObject_DebugMallocApi(char api, size_t nbytes);
PyAPI_FUNC(void *) _PyObject_DebugReallocApi(char api, void *p, size_t nbytes);
PyAPI_FUNC(void) _PyObject_DebugFreeApi(char api, void *p);

1
Include/setobject.h
View File

@ -101,6 +101,7 @@ PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set);
PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable);
PyAPI_FUNC(int) PySet_ClearFreeList(void);
PyAPI_FUNC(void) _PySet_DebugMallocStats(FILE *out);
#endif
#ifdef __cplusplus

3
Include/tupleobject.h
View File

@ -63,6 +63,9 @@ PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *);
#endif
PyAPI_FUNC(int) PyTuple_ClearFreeList(void);
#ifndef Py_LIMITED_API
PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out);
#endif /* Py_LIMITED_API */
#ifdef __cplusplus
}

6
Lib/test/test_sys.py
View File

@ -603,6 +603,12 @@ class SysModuleTest(unittest.TestCase):
self.assertEqual(sys.implementation.name,
sys.implementation.name.lower())
def test_debugmallocstats(self):
# Test sys._debugmallocstats()
from test.script_helper import assert_python_ok
args = ['-c', 'import sys; sys._debugmallocstats()']
ret, out, err = assert_python_ok(*args)
self.assertIn(b"free PyDictObjects", err)
class SizeofTest(unittest.TestCase):

3
Misc/NEWS
View File

@ -151,6 +151,9 @@ Library
- Issue #14963: Convert contextlib.ExitStack.__exit__ to use an iterative
algorithm (Patch by Alon Horev)
- Issue #14785: Add sys._debugmallocstats() to help debug low-level memory
allocation issues
C-API
-----

9
Modules/_datetimemodule.c
View File

@ -4754,7 +4754,7 @@ local_timezone(PyDateTime_DateTime *utc_time)
return result;
}
static PyObject *
static PyDateTime_DateTime *
datetime_astimezone(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
{
PyDateTime_DateTime *result;
@ -4777,7 +4777,7 @@ datetime_astimezone(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
/* Conversion to self's own time zone is a NOP. */
if (self->tzinfo == tzinfo) {
Py_INCREF(self);
return (PyObject *)self;
return self;
}
/* Convert self to UTC. */
@ -4814,10 +4814,11 @@ datetime_astimezone(PyDateTime_DateTime *self, PyObject *args, PyObject *kw)
Py_DECREF(temp);
temp = (PyObject *)result;
result = _PyObject_CallMethodId(tzinfo, &PyId_fromutc, "O", temp);
result = (PyDateTime_DateTime *)
_PyObject_CallMethodId(tzinfo, &PyId_fromutc, "O", temp);
Py_DECREF(temp);
return (PyObject *)result;
return result;
}
static PyObject *

38
Modules/_threadmodule.c
View File

@ -23,6 +23,7 @@ typedef struct {
PyObject_HEAD
PyThread_type_lock lock_lock;
PyObject *in_weakreflist;
char locked; /* for sanity checking */
} lockobject;
static void
@ -32,9 +33,8 @@ lock_dealloc(lockobject *self)
PyObject_ClearWeakRefs((PyObject *) self);
if (self->lock_lock != NULL) {
/* Unlock the lock so it's safe to free it */
PyThread_acquire_lock(self->lock_lock, 0);
PyThread_release_lock(self->lock_lock);
if (self->locked)
PyThread_release_lock(self->lock_lock);
PyThread_free_lock(self->lock_lock);
}
PyObject_Del(self);
@ -62,9 +62,13 @@ acquire_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds)
do {
Py_BEGIN_ALLOW_THREADS
r = PyThread_acquire_lock_timed(lock, microseconds, 1);
Py_END_ALLOW_THREADS
/* first a simple non-blocking try without releasing the GIL */
r = PyThread_acquire_lock_timed(lock, 0, 0);
if (r == PY_LOCK_FAILURE && microseconds != 0) {
Py_BEGIN_ALLOW_THREADS
r = PyThread_acquire_lock_timed(lock, microseconds, 1);
Py_END_ALLOW_THREADS
}
if (r == PY_LOCK_INTR) {
/* Run signal handlers if we were interrupted. Propagate
@ -135,6 +139,8 @@ lock_PyThread_acquire_lock(lockobject *self, PyObject *args, PyObject *kwds)
return NULL;
}
if (r == PY_LOCK_ACQUIRED)
self->locked = 1;
return PyBool_FromLong(r == PY_LOCK_ACQUIRED);
}
@ -153,13 +159,13 @@ static PyObject *
lock_PyThread_release_lock(lockobject *self)
{
/* Sanity check: the lock must be locked */
if (PyThread_acquire_lock(self->lock_lock, 0)) {
PyThread_release_lock(self->lock_lock);
if (!self->locked) {
PyErr_SetString(ThreadError, "release unlocked lock");
return NULL;
}
PyThread_release_lock(self->lock_lock);
self->locked = 0;
Py_INCREF(Py_None);
return Py_None;
}
@ -175,11 +181,7 @@ but it needn't be locked by the same thread that unlocks it.");
static PyObject *
lock_locked_lock(lockobject *self)
{
if (PyThread_acquire_lock(self->lock_lock, 0)) {
PyThread_release_lock(self->lock_lock);
return PyBool_FromLong(0L);
}
return PyBool_FromLong(1L);
return PyBool_FromLong((long)self->locked);
}
PyDoc_STRVAR(locked_doc,
@ -313,14 +315,7 @@ rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds)
self->rlock_count = count;
Py_RETURN_TRUE;
}
if (self->rlock_count > 0 ||
!PyThread_acquire_lock(self->rlock_lock, 0)) {
if (microseconds == 0) {
Py_RETURN_FALSE;
}
r = acquire_timed(self->rlock_lock, microseconds);
}
r = acquire_timed(self->rlock_lock, microseconds);
if (r == PY_LOCK_ACQUIRED) {
assert(self->rlock_count == 0);
self->rlock_owner = tid;
@ -548,6 +543,7 @@ newlockobject(void)
if (self == NULL)
return NULL;
self->lock_lock = PyThread_allocate_lock();
self->locked = 0;
self->in_weakreflist = NULL;
if (self->lock_lock == NULL) {
Py_DECREF(self);

9
Objects/classobject.c
View File

@ -400,6 +400,15 @@ PyMethod_Fini(void)
(void)PyMethod_ClearFreeList();
}
/* Print summary info about the state of the optimized allocator */
void
_PyMethod_DebugMallocStats(FILE *out)
{
_PyDebugAllocatorStats(out,
"free PyMethodObject",
numfree, sizeof(PyMethodObject));
}
/* ------------------------------------------------------------------------
* instance method
*/

9
Objects/dictobject.c
View File

@ -255,6 +255,15 @@ PyDict_ClearFreeList(void)
return ret;
}
/* Print summary info about the state of the optimized allocator */
void
_PyDict_DebugMallocStats(FILE *out)
{
_PyDebugAllocatorStats(out,
"free PyDictObject", numfree, sizeof(PyDictObject));
}
void
PyDict_Fini(void)
{

10
Objects/floatobject.c
View File

@ -1933,6 +1933,16 @@ PyFloat_Fini(void)
(void)PyFloat_ClearFreeList();
}
/* Print summary info about the state of the optimized allocator */
void
_PyFloat_DebugMallocStats(FILE *out)
{
_PyDebugAllocatorStats(out,
"free PyFloatObject",
numfree, sizeof(PyFloatObject));
}
/*----------------------------------------------------------------------------
* _PyFloat_{Pack,Unpack}{4,8}. See floatobject.h.
*/

10
Objects/frameobject.c
View File

@ -955,3 +955,13 @@ PyFrame_Fini(void)
Py_XDECREF(builtin_object);
builtin_object = NULL;
}
/* Print summary info about the state of the optimized allocator */
void
_PyFrame_DebugMallocStats(FILE *out)
{
_PyDebugAllocatorStats(out,
"free PyFrameObject",
numfree, sizeof(PyFrameObject));
}

9
Objects/listobject.c
View File

@ -117,6 +117,15 @@ PyList_Fini(void)
PyList_ClearFreeList();
}
/* Print summary info about the state of the optimized allocator */
void
_PyList_DebugMallocStats(FILE *out)
{
_PyDebugAllocatorStats(out,
"free PyListObject",
numfree, sizeof(PyListObject));
}
PyObject *
PyList_New(Py_ssize_t size)
{

9
Objects/methodobject.c
View File

@ -338,6 +338,15 @@ PyCFunction_Fini(void)
(void)PyCFunction_ClearFreeList();
}
/* Print summary info about the state of the optimized allocator */
void
_PyCFunction_DebugMallocStats(FILE *out)
{
_PyDebugAllocatorStats(out,
"free PyCFunction",
numfree, sizeof(PyCFunction));
}
/* PyCFunction_New() is now just a macro that calls PyCFunction_NewEx(),
but it's part of the API so we need to keep a function around that
existing C extensions can call.

12
Objects/object.c
View File

@ -1852,6 +1852,18 @@ PyMem_Free(void *p)
PyMem_FREE(p);
}
void
_PyObject_DebugTypeStats(FILE *out)
{
_PyCFunction_DebugMallocStats(out);
_PyDict_DebugMallocStats(out);
_PyFloat_DebugMallocStats(out);
_PyFrame_DebugMallocStats(out);
_PyList_DebugMallocStats(out);
_PyMethod_DebugMallocStats(out);
_PySet_DebugMallocStats(out);
_PyTuple_DebugMallocStats(out);
}
/* These methods are used to control infinite recursion in repr, str, print,
etc. Container objects that may recursively contain themselves,

81
Objects/obmalloc.c
View File

@ -523,12 +523,10 @@ static struct arena_object* usable_arenas = NULL;
/* Number of arenas allocated that haven't been free()'d. */
static size_t narenas_currently_allocated = 0;
#ifdef PYMALLOC_DEBUG
/* Total number of times malloc() called to allocate an arena. */
static size_t ntimes_arena_allocated = 0;
/* High water mark (max value ever seen) for narenas_currently_allocated. */
static size_t narenas_highwater = 0;
#endif
/* Allocate a new arena. If we run out of memory, return NULL. Else
* allocate a new arena, and return the address of an arena_object
@ -545,7 +543,7 @@ new_arena(void)
#ifdef PYMALLOC_DEBUG
if (Py_GETENV("PYTHONMALLOCSTATS"))
_PyObject_DebugMallocStats();
_PyObject_DebugMallocStats(stderr);
#endif
if (unused_arena_objects == NULL) {
uint i;
@ -613,11 +611,9 @@ new_arena(void)
arenaobj->address = (uptr)address;
++narenas_currently_allocated;
#ifdef PYMALLOC_DEBUG
++ntimes_arena_allocated;
if (narenas_currently_allocated > narenas_highwater)
narenas_highwater = narenas_currently_allocated;
#endif
arenaobj->freepools = NULL;
/* pool_address <- first pool-aligned address in the arena
nfreepools <- number of whole pools that fit after alignment */
@ -1723,17 +1719,19 @@ _PyObject_DebugDumpAddress(const void *p)
}
}
#endif /* PYMALLOC_DEBUG */
static size_t
printone(const char* msg, size_t value)
printone(FILE *out, const char* msg, size_t value)
{
int i, k;
char buf[100];
size_t origvalue = value;
fputs(msg, stderr);
fputs(msg, out);
for (i = (int)strlen(msg); i < 35; ++i)
fputc(' ', stderr);
fputc('=', stderr);
fputc(' ', out);
fputc('=', out);
/* Write the value with commas. */
i = 22;
@ -1754,17 +1752,33 @@ printone(const char* msg, size_t value)
while (i >= 0)
buf[i--] = ' ';
fputs(buf, stderr);
fputs(buf, out);
return origvalue;
}
/* Print summary info to stderr about the state of pymalloc's structures.
void
_PyDebugAllocatorStats(FILE *out,
const char *block_name, int num_blocks, size_t sizeof_block)
{
char buf1[128];
char buf2[128];
PyOS_snprintf(buf1, sizeof(buf1),
"%d %ss * %zd bytes each",
num_blocks, block_name, sizeof_block);
PyOS_snprintf(buf2, sizeof(buf2),
"%48s ", buf1);
(void)printone(out, buf2, num_blocks * sizeof_block);
}
#ifdef WITH_PYMALLOC
/* Print summary info to "out" about the state of pymalloc's structures.
* In Py_DEBUG mode, also perform some expensive internal consistency
* checks.
*/
void
_PyObject_DebugMallocStats(void)
_PyObject_DebugMallocStats(FILE *out)
{
uint i;
const uint numclasses = SMALL_REQUEST_THRESHOLD >> ALIGNMENT_SHIFT;
@ -1793,7 +1807,7 @@ _PyObject_DebugMallocStats(void)
size_t total;
char buf[128];
fprintf(stderr, "Small block threshold = %d, in %u size classes.\n",
fprintf(out, "Small block threshold = %d, in %u size classes.\n",
SMALL_REQUEST_THRESHOLD, numclasses);
for (i = 0; i < numclasses; ++i)
@ -1847,10 +1861,10 @@ _PyObject_DebugMallocStats(void)
}
assert(narenas == narenas_currently_allocated);
fputc('\n', stderr);
fputc('\n', out);
fputs("class size num pools blocks in use avail blocks\n"
"----- ---- --------- ------------- ------------\n",
stderr);
out);
for (i = 0; i < numclasses; ++i) {
size_t p = numpools[i];
@ -1861,7 +1875,7 @@ _PyObject_DebugMallocStats(void)
assert(b == 0 && f == 0);
continue;
}
fprintf(stderr, "%5u %6u "
fprintf(out, "%5u %6u "
"%11" PY_FORMAT_SIZE_T "u "
"%15" PY_FORMAT_SIZE_T "u "
"%13" PY_FORMAT_SIZE_T "u\n",
@ -1871,35 +1885,36 @@ _PyObject_DebugMallocStats(void)
pool_header_bytes += p * POOL_OVERHEAD;
quantization += p * ((POOL_SIZE - POOL_OVERHEAD) % size);
}
fputc('\n', stderr);
(void)printone("# times object malloc called", serialno);
(void)printone("# arenas allocated total", ntimes_arena_allocated);
(void)printone("# arenas reclaimed", ntimes_arena_allocated - narenas);
(void)printone("# arenas highwater mark", narenas_highwater);
(void)printone("# arenas allocated current", narenas);
fputc('\n', out);
#ifdef PYMALLOC_DEBUG
(void)printone(out, "# times object malloc called", serialno);
#endif
(void)printone(out, "# arenas allocated total", ntimes_arena_allocated);
(void)printone(out, "# arenas reclaimed", ntimes_arena_allocated - narenas);
(void)printone(out, "# arenas highwater mark", narenas_highwater);
(void)printone(out, "# arenas allocated current", narenas);
PyOS_snprintf(buf, sizeof(buf),
"%" PY_FORMAT_SIZE_T "u arenas * %d bytes/arena",
narenas, ARENA_SIZE);
(void)printone(buf, narenas * ARENA_SIZE);
(void)printone(out, buf, narenas * ARENA_SIZE);
fputc('\n', stderr);
fputc('\n', out);
total = printone("# bytes in allocated blocks", allocated_bytes);
total += printone("# bytes in available blocks", available_bytes);
total = printone(out, "# bytes in allocated blocks", allocated_bytes);
total += printone(out, "# bytes in available blocks", available_bytes);
PyOS_snprintf(buf, sizeof(buf),
"%u unused pools * %d bytes", numfreepools, POOL_SIZE);
total += printone(buf, (size_t)numfreepools * POOL_SIZE);
total += printone(out, buf, (size_t)numfreepools * POOL_SIZE);
total += printone("# bytes lost to pool headers", pool_header_bytes);
total += printone("# bytes lost to quantization", quantization);
total += printone("# bytes lost to arena alignment", arena_alignment);
(void)printone("Total", total);
total += printone(out, "# bytes lost to pool headers", pool_header_bytes);
total += printone(out, "# bytes lost to quantization", quantization);
total += printone(out, "# bytes lost to arena alignment", arena_alignment);
(void)printone(out, "Total", total);
}
#endif /* PYMALLOC_DEBUG */
#endif /* #ifdef WITH_PYMALLOC */
#ifdef Py_USING_MEMORY_DEBUGGER
/* Make this function last so gcc won't inline it since the definition is

10
Objects/setobject.c
View File

@ -1133,6 +1133,16 @@ PySet_Fini(void)
Py_CLEAR(emptyfrozenset);
}
/* Print summary info about the state of the optimized allocator */
void
_PySet_DebugMallocStats(FILE *out)
{
_PyDebugAllocatorStats(out,
"free PySetObject",
numfree, sizeof(PySetObject));
}
static PyObject *
set_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{

16
Objects/tupleobject.c
View File

@ -45,6 +45,22 @@ show_track(void)
}
#endif
/* Print summary info about the state of the optimized allocator */
void
_PyTuple_DebugMallocStats(FILE *out)
{
#if PyTuple_MAXSAVESIZE > 0
int i;
char buf[128];
for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
PyOS_snprintf(buf, sizeof(buf),
"free %d-sized PyTupleObject", i);
_PyDebugAllocatorStats(out,
buf,
numfree[i], _PyObject_VAR_SIZE(&PyTuple_Type, i));
}
#endif
}
PyObject *
PyTuple_New(register Py_ssize_t size)

2
Python/pythonrun.c
View File

@ -642,7 +642,7 @@ Py_Finalize(void)
#endif /* Py_TRACE_REFS */
#ifdef PYMALLOC_DEBUG
if (Py_GETENV("PYTHONMALLOCSTATS"))
_PyObject_DebugMallocStats();
_PyObject_DebugMallocStats(stderr);
#endif
call_ll_exitfuncs();

23
Python/sysmodule.c
View File

@ -997,6 +997,27 @@ a 11-tuple where the entries in the tuple are counts of:\n\
extern "C" {
#endif
static PyObject *
sys_debugmallocstats(PyObject *self, PyObject *args)
{
#ifdef WITH_PYMALLOC
_PyObject_DebugMallocStats(stderr);
fputc('\n', stderr);
#endif
_PyObject_DebugTypeStats(stderr);
Py_RETURN_NONE;
}
PyDoc_STRVAR(debugmallocstats_doc,
"_debugmallocstats()\n\
\n\
Print summary info to stderr about the state of\n\
pymalloc's structures.\n\
\n\
In Py_DEBUG mode, also perform some expensive internal consistency\n\
checks.\n\
");
#ifdef Py_TRACE_REFS
/* Defined in objects.c because it uses static globals if that file */
extern PyObject *_Py_GetObjects(PyObject *, PyObject *);
@ -1093,6 +1114,8 @@ static PyMethodDef sys_methods[] = {
{"settrace", sys_settrace, METH_O, settrace_doc},
{"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc},
{"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
{"_debugmallocstats", sys_debugmallocstats, METH_VARARGS,
debugmallocstats_doc},
{NULL, NULL} /* sentinel */
};