mirror of
https://github.com/python/cpython
synced 2024-09-05 08:17:45 +00:00
1821 lines
45 KiB
C
1821 lines
45 KiB
C
#include "Python.h"
|
|
#include "pycore_fileutils.h" // _Py_write_noraise()
|
|
#include "pycore_gc.h" // PyGC_Head
|
|
#include "pycore_hashtable.h" // _Py_hashtable_t
|
|
#include "pycore_pymem.h" // _Py_tracemalloc_config
|
|
#include "pycore_runtime.h" // _Py_ID()
|
|
#include "pycore_traceback.h"
|
|
#include <pycore_frame.h>
|
|
|
|
#include <stdlib.h> // malloc()
|
|
|
|
#include "clinic/_tracemalloc.c.h"
|
|
|
|
/*[clinic input]
|
|
module _tracemalloc
|
|
[clinic start generated code]*/
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=708a98302fc46e5f]*/
|
|
|
|
_Py_DECLARE_STR(anon_unknown, "<unknown>");
|
|
|
|
/* Trace memory blocks allocated by PyMem_RawMalloc() */
|
|
#define TRACE_RAW_MALLOC
|
|
|
|
/* Forward declaration */
|
|
static void tracemalloc_stop(void);
|
|
static void* raw_malloc(size_t size);
|
|
static void raw_free(void *ptr);
|
|
|
|
#ifdef Py_DEBUG
|
|
# define TRACE_DEBUG
|
|
#endif
|
|
|
|
#define TO_PTR(key) ((const void *)(uintptr_t)(key))
|
|
#define FROM_PTR(key) ((uintptr_t)(key))
|
|
|
|
/* Protected by the GIL */
|
|
static struct {
|
|
PyMemAllocatorEx mem;
|
|
PyMemAllocatorEx raw;
|
|
PyMemAllocatorEx obj;
|
|
} allocators;
|
|
|
|
|
|
#if defined(TRACE_RAW_MALLOC)
|
|
/* This lock is needed because tracemalloc_free() is called without
|
|
the GIL held from PyMem_RawFree(). It cannot acquire the lock because it
|
|
would introduce a deadlock in _PyThreadState_DeleteCurrent(). */
|
|
static PyThread_type_lock tables_lock;
|
|
# define TABLES_LOCK() PyThread_acquire_lock(tables_lock, 1)
|
|
# define TABLES_UNLOCK() PyThread_release_lock(tables_lock)
|
|
#else
|
|
/* variables are protected by the GIL */
|
|
# define TABLES_LOCK()
|
|
# define TABLES_UNLOCK()
|
|
#endif
|
|
|
|
|
|
#define DEFAULT_DOMAIN 0
|
|
|
|
/* Pack the frame_t structure to reduce the memory footprint on 64-bit
|
|
architectures: 12 bytes instead of 16. */
|
|
typedef struct
|
|
#ifdef __GNUC__
|
|
__attribute__((packed))
|
|
#elif defined(_MSC_VER)
|
|
#pragma pack(push, 4)
|
|
#endif
|
|
{
|
|
/* filename cannot be NULL: "<unknown>" is used if the Python frame
|
|
filename is NULL */
|
|
PyObject *filename;
|
|
unsigned int lineno;
|
|
} frame_t;
|
|
#ifdef _MSC_VER
|
|
#pragma pack(pop)
|
|
#endif
|
|
|
|
|
|
typedef struct {
|
|
Py_uhash_t hash;
|
|
/* Number of frames stored */
|
|
uint16_t nframe;
|
|
/* Total number of frames the traceback had */
|
|
uint16_t total_nframe;
|
|
frame_t frames[1];
|
|
} traceback_t;
|
|
|
|
#define TRACEBACK_SIZE(NFRAME) \
|
|
(sizeof(traceback_t) + sizeof(frame_t) * (NFRAME - 1))
|
|
|
|
/* The maximum number of frames is either:
|
|
- The maximum number of frames we can store in `traceback_t.nframe`
|
|
- The maximum memory size_t we can allocate */
|
|
static const unsigned long MAX_NFRAME = Py_MIN(UINT16_MAX, ((SIZE_MAX - sizeof(traceback_t)) / sizeof(frame_t) + 1));
|
|
|
|
|
|
static traceback_t tracemalloc_empty_traceback;
|
|
|
|
/* Trace of a memory block */
|
|
typedef struct {
|
|
/* Size of the memory block in bytes */
|
|
size_t size;
|
|
|
|
/* Traceback where the memory block was allocated */
|
|
traceback_t *traceback;
|
|
} trace_t;
|
|
|
|
|
|
/* Size in bytes of currently traced memory.
|
|
Protected by TABLES_LOCK(). */
|
|
static size_t tracemalloc_traced_memory = 0;
|
|
|
|
/* Peak size in bytes of traced memory.
|
|
Protected by TABLES_LOCK(). */
|
|
static size_t tracemalloc_peak_traced_memory = 0;
|
|
|
|
/* Hash table used as a set to intern filenames:
|
|
PyObject* => PyObject*.
|
|
Protected by the GIL */
|
|
static _Py_hashtable_t *tracemalloc_filenames = NULL;
|
|
|
|
/* Buffer to store a new traceback in traceback_new().
|
|
Protected by the GIL. */
|
|
static traceback_t *tracemalloc_traceback = NULL;
|
|
|
|
/* Hash table used as a set to intern tracebacks:
|
|
traceback_t* => traceback_t*
|
|
Protected by the GIL */
|
|
static _Py_hashtable_t *tracemalloc_tracebacks = NULL;
|
|
|
|
/* pointer (void*) => trace (trace_t*).
|
|
Protected by TABLES_LOCK(). */
|
|
static _Py_hashtable_t *tracemalloc_traces = NULL;
|
|
|
|
/* domain (unsigned int) => traces (_Py_hashtable_t).
|
|
Protected by TABLES_LOCK(). */
|
|
static _Py_hashtable_t *tracemalloc_domains = NULL;
|
|
|
|
|
|
#ifdef TRACE_DEBUG
|
|
static void
|
|
tracemalloc_error(const char *format, ...)
|
|
{
|
|
va_list ap;
|
|
fprintf(stderr, "tracemalloc: ");
|
|
va_start(ap, format);
|
|
vfprintf(stderr, format, ap);
|
|
va_end(ap);
|
|
fprintf(stderr, "\n");
|
|
fflush(stderr);
|
|
}
|
|
#endif
|
|
|
|
|
|
#if defined(TRACE_RAW_MALLOC)
|
|
#define REENTRANT_THREADLOCAL
|
|
|
|
static Py_tss_t tracemalloc_reentrant_key = Py_tss_NEEDS_INIT;
|
|
|
|
/* Any non-NULL pointer can be used */
|
|
#define REENTRANT Py_True
|
|
|
|
static int
|
|
get_reentrant(void)
|
|
{
|
|
void *ptr;
|
|
|
|
assert(PyThread_tss_is_created(&tracemalloc_reentrant_key));
|
|
ptr = PyThread_tss_get(&tracemalloc_reentrant_key);
|
|
if (ptr != NULL) {
|
|
assert(ptr == REENTRANT);
|
|
return 1;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
set_reentrant(int reentrant)
|
|
{
|
|
assert(reentrant == 0 || reentrant == 1);
|
|
assert(PyThread_tss_is_created(&tracemalloc_reentrant_key));
|
|
|
|
if (reentrant) {
|
|
assert(!get_reentrant());
|
|
PyThread_tss_set(&tracemalloc_reentrant_key, REENTRANT);
|
|
}
|
|
else {
|
|
assert(get_reentrant());
|
|
PyThread_tss_set(&tracemalloc_reentrant_key, NULL);
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
/* TRACE_RAW_MALLOC not defined: variable protected by the GIL */
|
|
static int tracemalloc_reentrant = 0;
|
|
|
|
static int
|
|
get_reentrant(void)
|
|
{
|
|
return tracemalloc_reentrant;
|
|
}
|
|
|
|
static void
|
|
set_reentrant(int reentrant)
|
|
{
|
|
assert(reentrant != tracemalloc_reentrant);
|
|
tracemalloc_reentrant = reentrant;
|
|
}
|
|
#endif
|
|
|
|
|
|
static Py_uhash_t
|
|
hashtable_hash_pyobject(const void *key)
|
|
{
|
|
PyObject *obj = (PyObject *)key;
|
|
return PyObject_Hash(obj);
|
|
}
|
|
|
|
|
|
static int
|
|
hashtable_compare_unicode(const void *key1, const void *key2)
|
|
{
|
|
PyObject *obj1 = (PyObject *)key1;
|
|
PyObject *obj2 = (PyObject *)key2;
|
|
if (obj1 != NULL && obj2 != NULL) {
|
|
return (PyUnicode_Compare(obj1, obj2) == 0);
|
|
}
|
|
else {
|
|
return obj1 == obj2;
|
|
}
|
|
}
|
|
|
|
|
|
static Py_uhash_t
|
|
hashtable_hash_uint(const void *key_raw)
|
|
{
|
|
unsigned int key = (unsigned int)FROM_PTR(key_raw);
|
|
return (Py_uhash_t)key;
|
|
}
|
|
|
|
|
|
static _Py_hashtable_t *
|
|
hashtable_new(_Py_hashtable_hash_func hash_func,
|
|
_Py_hashtable_compare_func compare_func,
|
|
_Py_hashtable_destroy_func key_destroy_func,
|
|
_Py_hashtable_destroy_func value_destroy_func)
|
|
{
|
|
_Py_hashtable_allocator_t hashtable_alloc = {malloc, free};
|
|
return _Py_hashtable_new_full(hash_func, compare_func,
|
|
key_destroy_func, value_destroy_func,
|
|
&hashtable_alloc);
|
|
}
|
|
|
|
|
|
static void*
|
|
raw_malloc(size_t size)
|
|
{
|
|
return allocators.raw.malloc(allocators.raw.ctx, size);
|
|
}
|
|
|
|
static void
|
|
raw_free(void *ptr)
|
|
{
|
|
allocators.raw.free(allocators.raw.ctx, ptr);
|
|
}
|
|
|
|
|
|
static Py_uhash_t
|
|
hashtable_hash_traceback(const void *key)
|
|
{
|
|
const traceback_t *traceback = (const traceback_t *)key;
|
|
return traceback->hash;
|
|
}
|
|
|
|
|
|
static int
|
|
hashtable_compare_traceback(const void *key1, const void *key2)
|
|
{
|
|
const traceback_t *traceback1 = (const traceback_t *)key1;
|
|
const traceback_t *traceback2 = (const traceback_t *)key2;
|
|
|
|
if (traceback1->nframe != traceback2->nframe) {
|
|
return 0;
|
|
}
|
|
if (traceback1->total_nframe != traceback2->total_nframe) {
|
|
return 0;
|
|
}
|
|
|
|
for (int i=0; i < traceback1->nframe; i++) {
|
|
const frame_t *frame1 = &traceback1->frames[i];
|
|
const frame_t *frame2 = &traceback2->frames[i];
|
|
|
|
if (frame1->lineno != frame2->lineno) {
|
|
return 0;
|
|
}
|
|
if (frame1->filename != frame2->filename) {
|
|
assert(PyUnicode_Compare(frame1->filename, frame2->filename) != 0);
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
static void
|
|
tracemalloc_get_frame(_PyInterpreterFrame *pyframe, frame_t *frame)
|
|
{
|
|
frame->filename = &_Py_STR(anon_unknown);
|
|
int lineno = _PyInterpreterFrame_GetLine(pyframe);
|
|
if (lineno < 0) {
|
|
lineno = 0;
|
|
}
|
|
frame->lineno = (unsigned int)lineno;
|
|
|
|
PyObject *filename = pyframe->f_code->co_filename;
|
|
|
|
if (filename == NULL) {
|
|
#ifdef TRACE_DEBUG
|
|
tracemalloc_error("failed to get the filename of the code object");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (!PyUnicode_Check(filename)) {
|
|
#ifdef TRACE_DEBUG
|
|
tracemalloc_error("filename is not a unicode string");
|
|
#endif
|
|
return;
|
|
}
|
|
if (!PyUnicode_IS_READY(filename)) {
|
|
/* Don't make a Unicode string ready to avoid reentrant calls
|
|
to tracemalloc_malloc() or tracemalloc_realloc() */
|
|
#ifdef TRACE_DEBUG
|
|
tracemalloc_error("filename is not a ready unicode string");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
/* intern the filename */
|
|
_Py_hashtable_entry_t *entry;
|
|
entry = _Py_hashtable_get_entry(tracemalloc_filenames, filename);
|
|
if (entry != NULL) {
|
|
filename = (PyObject *)entry->key;
|
|
}
|
|
else {
|
|
/* tracemalloc_filenames is responsible to keep a reference
|
|
to the filename */
|
|
Py_INCREF(filename);
|
|
if (_Py_hashtable_set(tracemalloc_filenames, filename, NULL) < 0) {
|
|
Py_DECREF(filename);
|
|
#ifdef TRACE_DEBUG
|
|
tracemalloc_error("failed to intern the filename");
|
|
#endif
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* the tracemalloc_filenames table keeps a reference to the filename */
|
|
frame->filename = filename;
|
|
}
|
|
|
|
|
|
static Py_uhash_t
|
|
traceback_hash(traceback_t *traceback)
|
|
{
|
|
/* code based on tuplehash() of Objects/tupleobject.c */
|
|
Py_uhash_t x, y; /* Unsigned for defined overflow behavior. */
|
|
int len = traceback->nframe;
|
|
Py_uhash_t mult = _PyHASH_MULTIPLIER;
|
|
frame_t *frame;
|
|
|
|
x = 0x345678UL;
|
|
frame = traceback->frames;
|
|
while (--len >= 0) {
|
|
y = (Py_uhash_t)PyObject_Hash(frame->filename);
|
|
y ^= (Py_uhash_t)frame->lineno;
|
|
frame++;
|
|
|
|
x = (x ^ y) * mult;
|
|
/* the cast might truncate len; that doesn't change hash stability */
|
|
mult += (Py_uhash_t)(82520UL + len + len);
|
|
}
|
|
x ^= traceback->total_nframe;
|
|
x += 97531UL;
|
|
return x;
|
|
}
|
|
|
|
|
|
static void
|
|
traceback_get_frames(traceback_t *traceback)
|
|
{
|
|
PyThreadState *tstate = PyGILState_GetThisThreadState();
|
|
if (tstate == NULL) {
|
|
#ifdef TRACE_DEBUG
|
|
tracemalloc_error("failed to get the current thread state");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
_PyInterpreterFrame *pyframe = tstate->cframe->current_frame;
|
|
for (; pyframe != NULL;) {
|
|
if (traceback->nframe < _Py_tracemalloc_config.max_nframe) {
|
|
tracemalloc_get_frame(pyframe, &traceback->frames[traceback->nframe]);
|
|
assert(traceback->frames[traceback->nframe].filename != NULL);
|
|
traceback->nframe++;
|
|
}
|
|
if (traceback->total_nframe < UINT16_MAX) {
|
|
traceback->total_nframe++;
|
|
}
|
|
|
|
_PyInterpreterFrame *back = pyframe->previous;
|
|
pyframe = back;
|
|
}
|
|
}
|
|
|
|
|
|
static traceback_t *
|
|
traceback_new(void)
|
|
{
|
|
traceback_t *traceback;
|
|
_Py_hashtable_entry_t *entry;
|
|
|
|
assert(PyGILState_Check());
|
|
|
|
/* get frames */
|
|
traceback = tracemalloc_traceback;
|
|
traceback->nframe = 0;
|
|
traceback->total_nframe = 0;
|
|
traceback_get_frames(traceback);
|
|
if (traceback->nframe == 0)
|
|
return &tracemalloc_empty_traceback;
|
|
traceback->hash = traceback_hash(traceback);
|
|
|
|
/* intern the traceback */
|
|
entry = _Py_hashtable_get_entry(tracemalloc_tracebacks, traceback);
|
|
if (entry != NULL) {
|
|
traceback = (traceback_t *)entry->key;
|
|
}
|
|
else {
|
|
traceback_t *copy;
|
|
size_t traceback_size;
|
|
|
|
traceback_size = TRACEBACK_SIZE(traceback->nframe);
|
|
|
|
copy = raw_malloc(traceback_size);
|
|
if (copy == NULL) {
|
|
#ifdef TRACE_DEBUG
|
|
tracemalloc_error("failed to intern the traceback: malloc failed");
|
|
#endif
|
|
return NULL;
|
|
}
|
|
memcpy(copy, traceback, traceback_size);
|
|
|
|
if (_Py_hashtable_set(tracemalloc_tracebacks, copy, NULL) < 0) {
|
|
raw_free(copy);
|
|
#ifdef TRACE_DEBUG
|
|
tracemalloc_error("failed to intern the traceback: putdata failed");
|
|
#endif
|
|
return NULL;
|
|
}
|
|
traceback = copy;
|
|
}
|
|
return traceback;
|
|
}
|
|
|
|
|
|
static _Py_hashtable_t*
|
|
tracemalloc_create_traces_table(void)
|
|
{
|
|
return hashtable_new(_Py_hashtable_hash_ptr,
|
|
_Py_hashtable_compare_direct,
|
|
NULL, raw_free);
|
|
}
|
|
|
|
|
|
static _Py_hashtable_t*
|
|
tracemalloc_create_domains_table(void)
|
|
{
|
|
return hashtable_new(hashtable_hash_uint,
|
|
_Py_hashtable_compare_direct,
|
|
NULL,
|
|
(_Py_hashtable_destroy_func)_Py_hashtable_destroy);
|
|
}
|
|
|
|
|
|
static _Py_hashtable_t*
|
|
tracemalloc_get_traces_table(unsigned int domain)
|
|
{
|
|
if (domain == DEFAULT_DOMAIN) {
|
|
return tracemalloc_traces;
|
|
}
|
|
else {
|
|
return _Py_hashtable_get(tracemalloc_domains, TO_PTR(domain));
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
tracemalloc_remove_trace(unsigned int domain, uintptr_t ptr)
|
|
{
|
|
assert(_Py_tracemalloc_config.tracing);
|
|
|
|
_Py_hashtable_t *traces = tracemalloc_get_traces_table(domain);
|
|
if (!traces) {
|
|
return;
|
|
}
|
|
|
|
trace_t *trace = _Py_hashtable_steal(traces, TO_PTR(ptr));
|
|
if (!trace) {
|
|
return;
|
|
}
|
|
assert(tracemalloc_traced_memory >= trace->size);
|
|
tracemalloc_traced_memory -= trace->size;
|
|
raw_free(trace);
|
|
}
|
|
|
|
#define REMOVE_TRACE(ptr) \
|
|
tracemalloc_remove_trace(DEFAULT_DOMAIN, (uintptr_t)(ptr))
|
|
|
|
|
|
static int
|
|
tracemalloc_add_trace(unsigned int domain, uintptr_t ptr,
|
|
size_t size)
|
|
{
|
|
assert(_Py_tracemalloc_config.tracing);
|
|
|
|
traceback_t *traceback = traceback_new();
|
|
if (traceback == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
_Py_hashtable_t *traces = tracemalloc_get_traces_table(domain);
|
|
if (traces == NULL) {
|
|
traces = tracemalloc_create_traces_table();
|
|
if (traces == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
if (_Py_hashtable_set(tracemalloc_domains, TO_PTR(domain), traces) < 0) {
|
|
_Py_hashtable_destroy(traces);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
trace_t *trace = _Py_hashtable_get(traces, TO_PTR(ptr));
|
|
if (trace != NULL) {
|
|
/* the memory block is already tracked */
|
|
assert(tracemalloc_traced_memory >= trace->size);
|
|
tracemalloc_traced_memory -= trace->size;
|
|
|
|
trace->size = size;
|
|
trace->traceback = traceback;
|
|
}
|
|
else {
|
|
trace = raw_malloc(sizeof(trace_t));
|
|
if (trace == NULL) {
|
|
return -1;
|
|
}
|
|
trace->size = size;
|
|
trace->traceback = traceback;
|
|
|
|
int res = _Py_hashtable_set(traces, TO_PTR(ptr), trace);
|
|
if (res != 0) {
|
|
raw_free(trace);
|
|
return res;
|
|
}
|
|
}
|
|
|
|
assert(tracemalloc_traced_memory <= SIZE_MAX - size);
|
|
tracemalloc_traced_memory += size;
|
|
if (tracemalloc_traced_memory > tracemalloc_peak_traced_memory) {
|
|
tracemalloc_peak_traced_memory = tracemalloc_traced_memory;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define ADD_TRACE(ptr, size) \
|
|
tracemalloc_add_trace(DEFAULT_DOMAIN, (uintptr_t)(ptr), size)
|
|
|
|
|
|
static void*
|
|
tracemalloc_alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize)
|
|
{
|
|
PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
|
|
void *ptr;
|
|
|
|
assert(elsize == 0 || nelem <= SIZE_MAX / elsize);
|
|
|
|
if (use_calloc)
|
|
ptr = alloc->calloc(alloc->ctx, nelem, elsize);
|
|
else
|
|
ptr = alloc->malloc(alloc->ctx, nelem * elsize);
|
|
if (ptr == NULL)
|
|
return NULL;
|
|
|
|
TABLES_LOCK();
|
|
if (ADD_TRACE(ptr, nelem * elsize) < 0) {
|
|
/* Failed to allocate a trace for the new memory block */
|
|
TABLES_UNLOCK();
|
|
alloc->free(alloc->ctx, ptr);
|
|
return NULL;
|
|
}
|
|
TABLES_UNLOCK();
|
|
return ptr;
|
|
}
|
|
|
|
|
|
static void*
|
|
tracemalloc_realloc(void *ctx, void *ptr, size_t new_size)
|
|
{
|
|
PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
|
|
void *ptr2;
|
|
|
|
ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);
|
|
if (ptr2 == NULL)
|
|
return NULL;
|
|
|
|
if (ptr != NULL) {
|
|
/* an existing memory block has been resized */
|
|
|
|
TABLES_LOCK();
|
|
|
|
/* tracemalloc_add_trace() updates the trace if there is already
|
|
a trace at address ptr2 */
|
|
if (ptr2 != ptr) {
|
|
REMOVE_TRACE(ptr);
|
|
}
|
|
|
|
if (ADD_TRACE(ptr2, new_size) < 0) {
|
|
/* Memory allocation failed. The error cannot be reported to
|
|
the caller, because realloc() may already have shrunk the
|
|
memory block and so removed bytes.
|
|
|
|
This case is very unlikely: a hash entry has just been
|
|
released, so the hash table should have at least one free entry.
|
|
|
|
The GIL and the table lock ensures that only one thread is
|
|
allocating memory. */
|
|
Py_FatalError("tracemalloc_realloc() failed to allocate a trace");
|
|
}
|
|
TABLES_UNLOCK();
|
|
}
|
|
else {
|
|
/* new allocation */
|
|
|
|
TABLES_LOCK();
|
|
if (ADD_TRACE(ptr2, new_size) < 0) {
|
|
/* Failed to allocate a trace for the new memory block */
|
|
TABLES_UNLOCK();
|
|
alloc->free(alloc->ctx, ptr2);
|
|
return NULL;
|
|
}
|
|
TABLES_UNLOCK();
|
|
}
|
|
return ptr2;
|
|
}
|
|
|
|
|
|
static void
|
|
tracemalloc_free(void *ctx, void *ptr)
|
|
{
|
|
PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
|
|
|
|
if (ptr == NULL)
|
|
return;
|
|
|
|
/* GIL cannot be locked in PyMem_RawFree() because it would introduce
|
|
a deadlock in _PyThreadState_DeleteCurrent(). */
|
|
|
|
alloc->free(alloc->ctx, ptr);
|
|
|
|
TABLES_LOCK();
|
|
REMOVE_TRACE(ptr);
|
|
TABLES_UNLOCK();
|
|
}
|
|
|
|
|
|
static void*
|
|
tracemalloc_alloc_gil(int use_calloc, void *ctx, size_t nelem, size_t elsize)
|
|
{
|
|
void *ptr;
|
|
|
|
if (get_reentrant()) {
|
|
PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
|
|
if (use_calloc)
|
|
return alloc->calloc(alloc->ctx, nelem, elsize);
|
|
else
|
|
return alloc->malloc(alloc->ctx, nelem * elsize);
|
|
}
|
|
|
|
/* Ignore reentrant call. PyObjet_Malloc() calls PyMem_Malloc() for
|
|
allocations larger than 512 bytes, don't trace the same memory
|
|
allocation twice. */
|
|
set_reentrant(1);
|
|
|
|
ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize);
|
|
|
|
set_reentrant(0);
|
|
return ptr;
|
|
}
|
|
|
|
|
|
static void*
|
|
tracemalloc_malloc_gil(void *ctx, size_t size)
|
|
{
|
|
return tracemalloc_alloc_gil(0, ctx, 1, size);
|
|
}
|
|
|
|
|
|
static void*
|
|
tracemalloc_calloc_gil(void *ctx, size_t nelem, size_t elsize)
|
|
{
|
|
return tracemalloc_alloc_gil(1, ctx, nelem, elsize);
|
|
}
|
|
|
|
|
|
static void*
|
|
tracemalloc_realloc_gil(void *ctx, void *ptr, size_t new_size)
|
|
{
|
|
void *ptr2;
|
|
|
|
if (get_reentrant()) {
|
|
/* Reentrant call to PyMem_Realloc() and PyMem_RawRealloc().
|
|
Example: PyMem_RawRealloc() is called internally by pymalloc
|
|
(_PyObject_Malloc() and _PyObject_Realloc()) to allocate a new
|
|
arena (new_arena()). */
|
|
PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
|
|
|
|
ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);
|
|
if (ptr2 != NULL && ptr != NULL) {
|
|
TABLES_LOCK();
|
|
REMOVE_TRACE(ptr);
|
|
TABLES_UNLOCK();
|
|
}
|
|
return ptr2;
|
|
}
|
|
|
|
/* Ignore reentrant call. PyObjet_Realloc() calls PyMem_Realloc() for
|
|
allocations larger than 512 bytes. Don't trace the same memory
|
|
allocation twice. */
|
|
set_reentrant(1);
|
|
|
|
ptr2 = tracemalloc_realloc(ctx, ptr, new_size);
|
|
|
|
set_reentrant(0);
|
|
return ptr2;
|
|
}
|
|
|
|
|
|
#ifdef TRACE_RAW_MALLOC
|
|
static void*
|
|
tracemalloc_raw_alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize)
|
|
{
|
|
PyGILState_STATE gil_state;
|
|
void *ptr;
|
|
|
|
if (get_reentrant()) {
|
|
PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
|
|
if (use_calloc)
|
|
return alloc->calloc(alloc->ctx, nelem, elsize);
|
|
else
|
|
return alloc->malloc(alloc->ctx, nelem * elsize);
|
|
}
|
|
|
|
/* Ignore reentrant call. PyGILState_Ensure() may call PyMem_RawMalloc()
|
|
indirectly which would call PyGILState_Ensure() if reentrant are not
|
|
disabled. */
|
|
set_reentrant(1);
|
|
|
|
gil_state = PyGILState_Ensure();
|
|
ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize);
|
|
PyGILState_Release(gil_state);
|
|
|
|
set_reentrant(0);
|
|
return ptr;
|
|
}
|
|
|
|
|
|
static void*
|
|
tracemalloc_raw_malloc(void *ctx, size_t size)
|
|
{
|
|
return tracemalloc_raw_alloc(0, ctx, 1, size);
|
|
}
|
|
|
|
|
|
static void*
|
|
tracemalloc_raw_calloc(void *ctx, size_t nelem, size_t elsize)
|
|
{
|
|
return tracemalloc_raw_alloc(1, ctx, nelem, elsize);
|
|
}
|
|
|
|
|
|
static void*
|
|
tracemalloc_raw_realloc(void *ctx, void *ptr, size_t new_size)
|
|
{
|
|
PyGILState_STATE gil_state;
|
|
void *ptr2;
|
|
|
|
if (get_reentrant()) {
|
|
/* Reentrant call to PyMem_RawRealloc(). */
|
|
PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
|
|
|
|
ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);
|
|
|
|
if (ptr2 != NULL && ptr != NULL) {
|
|
TABLES_LOCK();
|
|
REMOVE_TRACE(ptr);
|
|
TABLES_UNLOCK();
|
|
}
|
|
return ptr2;
|
|
}
|
|
|
|
/* Ignore reentrant call. PyGILState_Ensure() may call PyMem_RawMalloc()
|
|
indirectly which would call PyGILState_Ensure() if reentrant calls are
|
|
not disabled. */
|
|
set_reentrant(1);
|
|
|
|
gil_state = PyGILState_Ensure();
|
|
ptr2 = tracemalloc_realloc(ctx, ptr, new_size);
|
|
PyGILState_Release(gil_state);
|
|
|
|
set_reentrant(0);
|
|
return ptr2;
|
|
}
|
|
#endif /* TRACE_RAW_MALLOC */
|
|
|
|
|
|
static void
|
|
tracemalloc_clear_filename(void *value)
|
|
{
|
|
PyObject *filename = (PyObject *)value;
|
|
Py_DECREF(filename);
|
|
}
|
|
|
|
|
|
/* reentrant flag must be set to call this function and GIL must be held */
|
|
static void
|
|
tracemalloc_clear_traces(void)
|
|
{
|
|
/* The GIL protects variables against concurrent access */
|
|
assert(PyGILState_Check());
|
|
|
|
TABLES_LOCK();
|
|
_Py_hashtable_clear(tracemalloc_traces);
|
|
_Py_hashtable_clear(tracemalloc_domains);
|
|
tracemalloc_traced_memory = 0;
|
|
tracemalloc_peak_traced_memory = 0;
|
|
TABLES_UNLOCK();
|
|
|
|
_Py_hashtable_clear(tracemalloc_tracebacks);
|
|
|
|
_Py_hashtable_clear(tracemalloc_filenames);
|
|
}
|
|
|
|
|
|
static int
|
|
tracemalloc_init(void)
|
|
{
|
|
if (_Py_tracemalloc_config.initialized == TRACEMALLOC_FINALIZED) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"the tracemalloc module has been unloaded");
|
|
return -1;
|
|
}
|
|
|
|
if (_Py_tracemalloc_config.initialized == TRACEMALLOC_INITIALIZED)
|
|
return 0;
|
|
|
|
PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);
|
|
|
|
#ifdef REENTRANT_THREADLOCAL
|
|
if (PyThread_tss_create(&tracemalloc_reentrant_key) != 0) {
|
|
#ifdef MS_WINDOWS
|
|
PyErr_SetFromWindowsErr(0);
|
|
#else
|
|
PyErr_SetFromErrno(PyExc_OSError);
|
|
#endif
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
#if defined(TRACE_RAW_MALLOC)
|
|
if (tables_lock == NULL) {
|
|
tables_lock = PyThread_allocate_lock();
|
|
if (tables_lock == NULL) {
|
|
PyErr_SetString(PyExc_RuntimeError, "cannot allocate lock");
|
|
return -1;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
tracemalloc_filenames = hashtable_new(hashtable_hash_pyobject,
|
|
hashtable_compare_unicode,
|
|
tracemalloc_clear_filename, NULL);
|
|
|
|
tracemalloc_tracebacks = hashtable_new(hashtable_hash_traceback,
|
|
hashtable_compare_traceback,
|
|
NULL, raw_free);
|
|
|
|
tracemalloc_traces = tracemalloc_create_traces_table();
|
|
tracemalloc_domains = tracemalloc_create_domains_table();
|
|
|
|
if (tracemalloc_filenames == NULL || tracemalloc_tracebacks == NULL
|
|
|| tracemalloc_traces == NULL || tracemalloc_domains == NULL) {
|
|
PyErr_NoMemory();
|
|
return -1;
|
|
}
|
|
|
|
tracemalloc_empty_traceback.nframe = 1;
|
|
tracemalloc_empty_traceback.total_nframe = 1;
|
|
/* borrowed reference */
|
|
tracemalloc_empty_traceback.frames[0].filename = &_Py_STR(anon_unknown);
|
|
tracemalloc_empty_traceback.frames[0].lineno = 0;
|
|
tracemalloc_empty_traceback.hash = traceback_hash(&tracemalloc_empty_traceback);
|
|
|
|
_Py_tracemalloc_config.initialized = TRACEMALLOC_INITIALIZED;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void
|
|
tracemalloc_deinit(void)
|
|
{
|
|
if (_Py_tracemalloc_config.initialized != TRACEMALLOC_INITIALIZED)
|
|
return;
|
|
_Py_tracemalloc_config.initialized = TRACEMALLOC_FINALIZED;
|
|
|
|
tracemalloc_stop();
|
|
|
|
/* destroy hash tables */
|
|
_Py_hashtable_destroy(tracemalloc_domains);
|
|
_Py_hashtable_destroy(tracemalloc_traces);
|
|
_Py_hashtable_destroy(tracemalloc_tracebacks);
|
|
_Py_hashtable_destroy(tracemalloc_filenames);
|
|
|
|
#if defined(TRACE_RAW_MALLOC)
|
|
if (tables_lock != NULL) {
|
|
PyThread_free_lock(tables_lock);
|
|
tables_lock = NULL;
|
|
}
|
|
#endif
|
|
|
|
#ifdef REENTRANT_THREADLOCAL
|
|
PyThread_tss_delete(&tracemalloc_reentrant_key);
|
|
#endif
|
|
}
|
|
|
|
|
|
static int
|
|
tracemalloc_start(int max_nframe)
|
|
{
|
|
PyMemAllocatorEx alloc;
|
|
size_t size;
|
|
|
|
if (max_nframe < 1 || (unsigned long) max_nframe > MAX_NFRAME) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"the number of frames must be in range [1; %lu]",
|
|
MAX_NFRAME);
|
|
return -1;
|
|
}
|
|
|
|
if (tracemalloc_init() < 0) {
|
|
return -1;
|
|
}
|
|
|
|
if (_Py_tracemalloc_config.tracing) {
|
|
/* hook already installed: do nothing */
|
|
return 0;
|
|
}
|
|
|
|
_Py_tracemalloc_config.max_nframe = max_nframe;
|
|
|
|
/* allocate a buffer to store a new traceback */
|
|
size = TRACEBACK_SIZE(max_nframe);
|
|
assert(tracemalloc_traceback == NULL);
|
|
tracemalloc_traceback = raw_malloc(size);
|
|
if (tracemalloc_traceback == NULL) {
|
|
PyErr_NoMemory();
|
|
return -1;
|
|
}
|
|
|
|
#ifdef TRACE_RAW_MALLOC
|
|
alloc.malloc = tracemalloc_raw_malloc;
|
|
alloc.calloc = tracemalloc_raw_calloc;
|
|
alloc.realloc = tracemalloc_raw_realloc;
|
|
alloc.free = tracemalloc_free;
|
|
|
|
alloc.ctx = &allocators.raw;
|
|
PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);
|
|
PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);
|
|
#endif
|
|
|
|
alloc.malloc = tracemalloc_malloc_gil;
|
|
alloc.calloc = tracemalloc_calloc_gil;
|
|
alloc.realloc = tracemalloc_realloc_gil;
|
|
alloc.free = tracemalloc_free;
|
|
|
|
alloc.ctx = &allocators.mem;
|
|
PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &allocators.mem);
|
|
PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);
|
|
|
|
alloc.ctx = &allocators.obj;
|
|
PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &allocators.obj);
|
|
PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc);
|
|
|
|
/* everything is ready: start tracing Python memory allocations */
|
|
_Py_tracemalloc_config.tracing = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void
|
|
tracemalloc_stop(void)
|
|
{
|
|
if (!_Py_tracemalloc_config.tracing)
|
|
return;
|
|
|
|
/* stop tracing Python memory allocations */
|
|
_Py_tracemalloc_config.tracing = 0;
|
|
|
|
/* unregister the hook on memory allocators */
|
|
#ifdef TRACE_RAW_MALLOC
|
|
PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);
|
|
#endif
|
|
PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &allocators.mem);
|
|
PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &allocators.obj);
|
|
|
|
tracemalloc_clear_traces();
|
|
|
|
/* release memory */
|
|
raw_free(tracemalloc_traceback);
|
|
tracemalloc_traceback = NULL;
|
|
}
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc.is_tracing
|
|
|
|
Return True if the tracemalloc module is tracing Python memory allocations.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc_is_tracing_impl(PyObject *module)
|
|
/*[clinic end generated code: output=2d763b42601cd3ef input=af104b0a00192f63]*/
|
|
{
|
|
return PyBool_FromLong(_Py_tracemalloc_config.tracing);
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc.clear_traces
|
|
|
|
Clear traces of memory blocks allocated by Python.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc_clear_traces_impl(PyObject *module)
|
|
/*[clinic end generated code: output=a86080ee41b84197 input=0dab5b6c785183a5]*/
|
|
{
|
|
if (!_Py_tracemalloc_config.tracing)
|
|
Py_RETURN_NONE;
|
|
|
|
set_reentrant(1);
|
|
tracemalloc_clear_traces();
|
|
set_reentrant(0);
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
frame_to_pyobject(frame_t *frame)
|
|
{
|
|
PyObject *frame_obj, *lineno_obj;
|
|
|
|
frame_obj = PyTuple_New(2);
|
|
if (frame_obj == NULL)
|
|
return NULL;
|
|
|
|
Py_INCREF(frame->filename);
|
|
PyTuple_SET_ITEM(frame_obj, 0, frame->filename);
|
|
|
|
lineno_obj = PyLong_FromUnsignedLong(frame->lineno);
|
|
if (lineno_obj == NULL) {
|
|
Py_DECREF(frame_obj);
|
|
return NULL;
|
|
}
|
|
PyTuple_SET_ITEM(frame_obj, 1, lineno_obj);
|
|
|
|
return frame_obj;
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)
|
|
{
|
|
PyObject *frames;
|
|
|
|
if (intern_table != NULL) {
|
|
frames = _Py_hashtable_get(intern_table, (const void *)traceback);
|
|
if (frames) {
|
|
Py_INCREF(frames);
|
|
return frames;
|
|
}
|
|
}
|
|
|
|
frames = PyTuple_New(traceback->nframe);
|
|
if (frames == NULL)
|
|
return NULL;
|
|
|
|
for (int i=0; i < traceback->nframe; i++) {
|
|
PyObject *frame = frame_to_pyobject(&traceback->frames[i]);
|
|
if (frame == NULL) {
|
|
Py_DECREF(frames);
|
|
return NULL;
|
|
}
|
|
PyTuple_SET_ITEM(frames, i, frame);
|
|
}
|
|
|
|
if (intern_table != NULL) {
|
|
if (_Py_hashtable_set(intern_table, traceback, frames) < 0) {
|
|
Py_DECREF(frames);
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
/* intern_table keeps a new reference to frames */
|
|
Py_INCREF(frames);
|
|
}
|
|
return frames;
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
trace_to_pyobject(unsigned int domain, const trace_t *trace,
|
|
_Py_hashtable_t *intern_tracebacks)
|
|
{
|
|
PyObject *trace_obj = NULL;
|
|
PyObject *obj;
|
|
|
|
trace_obj = PyTuple_New(4);
|
|
if (trace_obj == NULL)
|
|
return NULL;
|
|
|
|
obj = PyLong_FromSize_t(domain);
|
|
if (obj == NULL) {
|
|
Py_DECREF(trace_obj);
|
|
return NULL;
|
|
}
|
|
PyTuple_SET_ITEM(trace_obj, 0, obj);
|
|
|
|
obj = PyLong_FromSize_t(trace->size);
|
|
if (obj == NULL) {
|
|
Py_DECREF(trace_obj);
|
|
return NULL;
|
|
}
|
|
PyTuple_SET_ITEM(trace_obj, 1, obj);
|
|
|
|
obj = traceback_to_pyobject(trace->traceback, intern_tracebacks);
|
|
if (obj == NULL) {
|
|
Py_DECREF(trace_obj);
|
|
return NULL;
|
|
}
|
|
PyTuple_SET_ITEM(trace_obj, 2, obj);
|
|
|
|
obj = PyLong_FromUnsignedLong(trace->traceback->total_nframe);
|
|
if (obj == NULL) {
|
|
Py_DECREF(trace_obj);
|
|
return NULL;
|
|
}
|
|
PyTuple_SET_ITEM(trace_obj, 3, obj);
|
|
|
|
return trace_obj;
|
|
}
|
|
|
|
|
|
typedef struct {
|
|
_Py_hashtable_t *traces;
|
|
_Py_hashtable_t *domains;
|
|
_Py_hashtable_t *tracebacks;
|
|
PyObject *list;
|
|
unsigned int domain;
|
|
} get_traces_t;
|
|
|
|
|
|
static int
|
|
tracemalloc_copy_trace(_Py_hashtable_t *traces,
|
|
const void *key, const void *value,
|
|
void *user_data)
|
|
{
|
|
_Py_hashtable_t *traces2 = (_Py_hashtable_t *)user_data;
|
|
|
|
trace_t *trace = (trace_t *)value;
|
|
|
|
trace_t *trace2 = raw_malloc(sizeof(trace_t));
|
|
if (trace2 == NULL) {
|
|
return -1;
|
|
}
|
|
*trace2 = *trace;
|
|
if (_Py_hashtable_set(traces2, key, trace2) < 0) {
|
|
raw_free(trace2);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static _Py_hashtable_t*
|
|
tracemalloc_copy_traces(_Py_hashtable_t *traces)
|
|
{
|
|
_Py_hashtable_t *traces2 = tracemalloc_create_traces_table();
|
|
if (traces2 == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
int err = _Py_hashtable_foreach(traces,
|
|
tracemalloc_copy_trace,
|
|
traces2);
|
|
if (err) {
|
|
_Py_hashtable_destroy(traces2);
|
|
return NULL;
|
|
}
|
|
return traces2;
|
|
}
|
|
|
|
|
|
static int
|
|
tracemalloc_copy_domain(_Py_hashtable_t *domains,
|
|
const void *key, const void *value,
|
|
void *user_data)
|
|
{
|
|
_Py_hashtable_t *domains2 = (_Py_hashtable_t *)user_data;
|
|
|
|
unsigned int domain = (unsigned int)FROM_PTR(key);
|
|
_Py_hashtable_t *traces = (_Py_hashtable_t *)value;
|
|
|
|
_Py_hashtable_t *traces2 = tracemalloc_copy_traces(traces);
|
|
if (traces2 == NULL) {
|
|
return -1;
|
|
}
|
|
if (_Py_hashtable_set(domains2, TO_PTR(domain), traces2) < 0) {
|
|
_Py_hashtable_destroy(traces2);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static _Py_hashtable_t*
|
|
tracemalloc_copy_domains(_Py_hashtable_t *domains)
|
|
{
|
|
_Py_hashtable_t *domains2 = tracemalloc_create_domains_table();
|
|
if (domains2 == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
int err = _Py_hashtable_foreach(domains,
|
|
tracemalloc_copy_domain,
|
|
domains2);
|
|
if (err) {
|
|
_Py_hashtable_destroy(domains2);
|
|
return NULL;
|
|
}
|
|
return domains2;
|
|
}
|
|
|
|
|
|
static int
|
|
tracemalloc_get_traces_fill(_Py_hashtable_t *traces,
|
|
const void *key, const void *value,
|
|
void *user_data)
|
|
{
|
|
get_traces_t *get_traces = user_data;
|
|
|
|
const trace_t *trace = (const trace_t *)value;
|
|
|
|
PyObject *tuple = trace_to_pyobject(get_traces->domain, trace,
|
|
get_traces->tracebacks);
|
|
if (tuple == NULL) {
|
|
return 1;
|
|
}
|
|
|
|
int res = PyList_Append(get_traces->list, tuple);
|
|
Py_DECREF(tuple);
|
|
if (res < 0) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
tracemalloc_get_traces_domain(_Py_hashtable_t *domains,
|
|
const void *key, const void *value,
|
|
void *user_data)
|
|
{
|
|
get_traces_t *get_traces = user_data;
|
|
|
|
unsigned int domain = (unsigned int)FROM_PTR(key);
|
|
_Py_hashtable_t *traces = (_Py_hashtable_t *)value;
|
|
|
|
get_traces->domain = domain;
|
|
return _Py_hashtable_foreach(traces,
|
|
tracemalloc_get_traces_fill,
|
|
get_traces);
|
|
}
|
|
|
|
|
|
static void
|
|
tracemalloc_pyobject_decref(void *value)
|
|
{
|
|
PyObject *obj = (PyObject *)value;
|
|
Py_DECREF(obj);
|
|
}
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc._get_traces
|
|
|
|
Get traces of all memory blocks allocated by Python.
|
|
|
|
Return a list of (size: int, traceback: tuple) tuples.
|
|
traceback is a tuple of (filename: str, lineno: int) tuples.
|
|
|
|
Return an empty list if the tracemalloc module is disabled.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc__get_traces_impl(PyObject *module)
|
|
/*[clinic end generated code: output=e9929876ced4b5cc input=6c7d2230b24255aa]*/
|
|
{
|
|
get_traces_t get_traces;
|
|
get_traces.domain = DEFAULT_DOMAIN;
|
|
get_traces.traces = NULL;
|
|
get_traces.domains = NULL;
|
|
get_traces.tracebacks = NULL;
|
|
get_traces.list = PyList_New(0);
|
|
if (get_traces.list == NULL)
|
|
goto error;
|
|
|
|
if (!_Py_tracemalloc_config.tracing)
|
|
return get_traces.list;
|
|
|
|
/* the traceback hash table is used temporarily to intern traceback tuple
|
|
of (filename, lineno) tuples */
|
|
get_traces.tracebacks = hashtable_new(_Py_hashtable_hash_ptr,
|
|
_Py_hashtable_compare_direct,
|
|
NULL, tracemalloc_pyobject_decref);
|
|
if (get_traces.tracebacks == NULL) {
|
|
goto no_memory;
|
|
}
|
|
|
|
// Copy all traces so tracemalloc_get_traces_fill() doesn't have to disable
|
|
// temporarily tracemalloc which would impact other threads and so would
|
|
// miss allocations while get_traces() is called.
|
|
TABLES_LOCK();
|
|
get_traces.traces = tracemalloc_copy_traces(tracemalloc_traces);
|
|
TABLES_UNLOCK();
|
|
|
|
if (get_traces.traces == NULL) {
|
|
goto no_memory;
|
|
}
|
|
|
|
TABLES_LOCK();
|
|
get_traces.domains = tracemalloc_copy_domains(tracemalloc_domains);
|
|
TABLES_UNLOCK();
|
|
|
|
if (get_traces.domains == NULL) {
|
|
goto no_memory;
|
|
}
|
|
|
|
// Convert traces to a list of tuples
|
|
set_reentrant(1);
|
|
int err = _Py_hashtable_foreach(get_traces.traces,
|
|
tracemalloc_get_traces_fill,
|
|
&get_traces);
|
|
if (!err) {
|
|
err = _Py_hashtable_foreach(get_traces.domains,
|
|
tracemalloc_get_traces_domain,
|
|
&get_traces);
|
|
}
|
|
set_reentrant(0);
|
|
if (err) {
|
|
goto error;
|
|
}
|
|
|
|
goto finally;
|
|
|
|
no_memory:
|
|
PyErr_NoMemory();
|
|
|
|
error:
|
|
Py_CLEAR(get_traces.list);
|
|
|
|
finally:
|
|
if (get_traces.tracebacks != NULL) {
|
|
_Py_hashtable_destroy(get_traces.tracebacks);
|
|
}
|
|
if (get_traces.traces != NULL) {
|
|
_Py_hashtable_destroy(get_traces.traces);
|
|
}
|
|
if (get_traces.domains != NULL) {
|
|
_Py_hashtable_destroy(get_traces.domains);
|
|
}
|
|
|
|
return get_traces.list;
|
|
}
|
|
|
|
|
|
static traceback_t*
|
|
tracemalloc_get_traceback(unsigned int domain, uintptr_t ptr)
|
|
{
|
|
|
|
if (!_Py_tracemalloc_config.tracing)
|
|
return NULL;
|
|
|
|
trace_t *trace;
|
|
TABLES_LOCK();
|
|
_Py_hashtable_t *traces = tracemalloc_get_traces_table(domain);
|
|
if (traces) {
|
|
trace = _Py_hashtable_get(traces, TO_PTR(ptr));
|
|
}
|
|
else {
|
|
trace = NULL;
|
|
}
|
|
TABLES_UNLOCK();
|
|
|
|
if (!trace) {
|
|
return NULL;
|
|
}
|
|
|
|
return trace->traceback;
|
|
}
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc._get_object_traceback
|
|
|
|
obj: object
|
|
/
|
|
|
|
Get the traceback where the Python object obj was allocated.
|
|
|
|
Return a tuple of (filename: str, lineno: int) tuples.
|
|
Return None if the tracemalloc module is disabled or did not
|
|
trace the allocation of the object.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc__get_object_traceback(PyObject *module, PyObject *obj)
|
|
/*[clinic end generated code: output=41ee0553a658b0aa input=29495f1b21c53212]*/
|
|
{
|
|
PyTypeObject *type;
|
|
void *ptr;
|
|
traceback_t *traceback;
|
|
|
|
type = Py_TYPE(obj);
|
|
if (PyType_IS_GC(type)) {
|
|
ptr = (void *)((char *)obj - sizeof(PyGC_Head));
|
|
}
|
|
else {
|
|
ptr = (void *)obj;
|
|
}
|
|
|
|
traceback = tracemalloc_get_traceback(DEFAULT_DOMAIN, (uintptr_t)ptr);
|
|
if (traceback == NULL)
|
|
Py_RETURN_NONE;
|
|
|
|
return traceback_to_pyobject(traceback, NULL);
|
|
}
|
|
|
|
|
|
#define PUTS(fd, str) _Py_write_noraise(fd, str, (int)strlen(str))
|
|
|
|
static void
|
|
_PyMem_DumpFrame(int fd, frame_t * frame)
|
|
{
|
|
PUTS(fd, " File \"");
|
|
_Py_DumpASCII(fd, frame->filename);
|
|
PUTS(fd, "\", line ");
|
|
_Py_DumpDecimal(fd, frame->lineno);
|
|
PUTS(fd, "\n");
|
|
}
|
|
|
|
/* Dump the traceback where a memory block was allocated into file descriptor
|
|
fd. The function may block on TABLES_LOCK() but it is unlikely. */
|
|
void
|
|
_PyMem_DumpTraceback(int fd, const void *ptr)
|
|
{
|
|
traceback_t *traceback;
|
|
int i;
|
|
|
|
if (!_Py_tracemalloc_config.tracing) {
|
|
PUTS(fd, "Enable tracemalloc to get the memory block "
|
|
"allocation traceback\n\n");
|
|
return;
|
|
}
|
|
|
|
traceback = tracemalloc_get_traceback(DEFAULT_DOMAIN, (uintptr_t)ptr);
|
|
if (traceback == NULL)
|
|
return;
|
|
|
|
PUTS(fd, "Memory block allocated at (most recent call first):\n");
|
|
for (i=0; i < traceback->nframe; i++) {
|
|
_PyMem_DumpFrame(fd, &traceback->frames[i]);
|
|
}
|
|
PUTS(fd, "\n");
|
|
}
|
|
|
|
#undef PUTS
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc.start
|
|
|
|
nframe: int = 1
|
|
/
|
|
|
|
Start tracing Python memory allocations.
|
|
|
|
Also set the maximum number of frames stored in the traceback of a
|
|
trace to nframe.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc_start_impl(PyObject *module, int nframe)
|
|
/*[clinic end generated code: output=caae05c23c159d3c input=40d849b5b29d1933]*/
|
|
{
|
|
if (tracemalloc_start(nframe) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc.stop
|
|
|
|
Stop tracing Python memory allocations.
|
|
|
|
Also clear traces of memory blocks allocated by Python.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc_stop_impl(PyObject *module)
|
|
/*[clinic end generated code: output=c3c42ae03e3955cd input=7478f075e51dae18]*/
|
|
{
|
|
tracemalloc_stop();
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc.get_traceback_limit
|
|
|
|
Get the maximum number of frames stored in the traceback of a trace.
|
|
|
|
By default, a trace of an allocated memory block only stores
|
|
the most recent frame: the limit is 1.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc_get_traceback_limit_impl(PyObject *module)
|
|
/*[clinic end generated code: output=d556d9306ba95567 input=da3cd977fc68ae3b]*/
|
|
{
|
|
return PyLong_FromLong(_Py_tracemalloc_config.max_nframe);
|
|
}
|
|
|
|
|
|
static int
|
|
tracemalloc_get_tracemalloc_memory_cb(_Py_hashtable_t *domains,
|
|
const void *key, const void *value,
|
|
void *user_data)
|
|
{
|
|
const _Py_hashtable_t *traces = value;
|
|
size_t *size = (size_t*)user_data;
|
|
*size += _Py_hashtable_size(traces);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc.get_tracemalloc_memory
|
|
|
|
Get the memory usage in bytes of the tracemalloc module.
|
|
|
|
This memory is used internally to trace memory allocations.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc_get_tracemalloc_memory_impl(PyObject *module)
|
|
/*[clinic end generated code: output=e3f14e280a55f5aa input=5d919c0f4d5132ad]*/
|
|
{
|
|
size_t size;
|
|
|
|
size = _Py_hashtable_size(tracemalloc_tracebacks);
|
|
size += _Py_hashtable_size(tracemalloc_filenames);
|
|
|
|
TABLES_LOCK();
|
|
size += _Py_hashtable_size(tracemalloc_traces);
|
|
_Py_hashtable_foreach(tracemalloc_domains,
|
|
tracemalloc_get_tracemalloc_memory_cb, &size);
|
|
TABLES_UNLOCK();
|
|
|
|
return PyLong_FromSize_t(size);
|
|
}
|
|
|
|
|
|
|
|
/*[clinic input]
|
|
_tracemalloc.get_traced_memory
|
|
|
|
Get the current size and peak size of memory blocks traced by tracemalloc.
|
|
|
|
Returns a tuple: (current: int, peak: int).
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc_get_traced_memory_impl(PyObject *module)
|
|
/*[clinic end generated code: output=5b167189adb9e782 input=61ddb5478400ff66]*/
|
|
{
|
|
Py_ssize_t size, peak_size;
|
|
|
|
if (!_Py_tracemalloc_config.tracing)
|
|
return Py_BuildValue("ii", 0, 0);
|
|
|
|
TABLES_LOCK();
|
|
size = tracemalloc_traced_memory;
|
|
peak_size = tracemalloc_peak_traced_memory;
|
|
TABLES_UNLOCK();
|
|
|
|
return Py_BuildValue("nn", size, peak_size);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_tracemalloc.reset_peak
|
|
|
|
Set the peak size of memory blocks traced by tracemalloc to the current size.
|
|
|
|
Do nothing if the tracemalloc module is not tracing memory allocations.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_tracemalloc_reset_peak_impl(PyObject *module)
|
|
/*[clinic end generated code: output=140c2870f691dbb2 input=18afd0635066e9ce]*/
|
|
{
|
|
if (!_Py_tracemalloc_config.tracing) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
TABLES_LOCK();
|
|
tracemalloc_peak_traced_memory = tracemalloc_traced_memory;
|
|
TABLES_UNLOCK();
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
static PyMethodDef module_methods[] = {
|
|
_TRACEMALLOC_IS_TRACING_METHODDEF
|
|
_TRACEMALLOC_CLEAR_TRACES_METHODDEF
|
|
_TRACEMALLOC__GET_TRACES_METHODDEF
|
|
_TRACEMALLOC__GET_OBJECT_TRACEBACK_METHODDEF
|
|
_TRACEMALLOC_START_METHODDEF
|
|
_TRACEMALLOC_STOP_METHODDEF
|
|
_TRACEMALLOC_GET_TRACEBACK_LIMIT_METHODDEF
|
|
_TRACEMALLOC_GET_TRACEMALLOC_MEMORY_METHODDEF
|
|
_TRACEMALLOC_GET_TRACED_MEMORY_METHODDEF
|
|
_TRACEMALLOC_RESET_PEAK_METHODDEF
|
|
/* sentinel */
|
|
{NULL, NULL}
|
|
};
|
|
|
|
PyDoc_STRVAR(module_doc,
|
|
"Debug module to trace memory blocks allocated by Python.");
|
|
|
|
static struct PyModuleDef module_def = {
|
|
PyModuleDef_HEAD_INIT,
|
|
"_tracemalloc",
|
|
module_doc,
|
|
0, /* non-negative size to be able to unload the module */
|
|
module_methods,
|
|
NULL,
|
|
};
|
|
|
|
PyMODINIT_FUNC
|
|
PyInit__tracemalloc(void)
|
|
{
|
|
PyObject *m;
|
|
m = PyModule_Create(&module_def);
|
|
if (m == NULL)
|
|
return NULL;
|
|
|
|
if (tracemalloc_init() < 0) {
|
|
Py_DECREF(m);
|
|
return NULL;
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
|
|
int
|
|
_PyTraceMalloc_Init(int nframe)
|
|
{
|
|
assert(PyGILState_Check());
|
|
if (nframe == 0) {
|
|
return 0;
|
|
}
|
|
return tracemalloc_start(nframe);
|
|
}
|
|
|
|
|
|
void
|
|
_PyTraceMalloc_Fini(void)
|
|
{
|
|
assert(PyGILState_Check());
|
|
tracemalloc_deinit();
|
|
}
|
|
|
|
int
|
|
PyTraceMalloc_Track(unsigned int domain, uintptr_t ptr,
|
|
size_t size)
|
|
{
|
|
int res;
|
|
PyGILState_STATE gil_state;
|
|
|
|
if (!_Py_tracemalloc_config.tracing) {
|
|
/* tracemalloc is not tracing: do nothing */
|
|
return -2;
|
|
}
|
|
|
|
gil_state = PyGILState_Ensure();
|
|
|
|
TABLES_LOCK();
|
|
res = tracemalloc_add_trace(domain, ptr, size);
|
|
TABLES_UNLOCK();
|
|
|
|
PyGILState_Release(gil_state);
|
|
return res;
|
|
}
|
|
|
|
|
|
int
|
|
PyTraceMalloc_Untrack(unsigned int domain, uintptr_t ptr)
|
|
{
|
|
if (!_Py_tracemalloc_config.tracing) {
|
|
/* tracemalloc is not tracing: do nothing */
|
|
return -2;
|
|
}
|
|
|
|
TABLES_LOCK();
|
|
tracemalloc_remove_trace(domain, ptr);
|
|
TABLES_UNLOCK();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* If the object memory block is already traced, update its trace
|
|
with the current Python traceback.
|
|
|
|
Do nothing if tracemalloc is not tracing memory allocations
|
|
or if the object memory block is not already traced. */
|
|
int
|
|
_PyTraceMalloc_NewReference(PyObject *op)
|
|
{
|
|
assert(PyGILState_Check());
|
|
|
|
if (!_Py_tracemalloc_config.tracing) {
|
|
/* tracemalloc is not tracing: do nothing */
|
|
return -1;
|
|
}
|
|
|
|
uintptr_t ptr;
|
|
PyTypeObject *type = Py_TYPE(op);
|
|
if (PyType_IS_GC(type)) {
|
|
ptr = (uintptr_t)((char *)op - sizeof(PyGC_Head));
|
|
}
|
|
else {
|
|
ptr = (uintptr_t)op;
|
|
}
|
|
|
|
int res = -1;
|
|
|
|
TABLES_LOCK();
|
|
trace_t *trace = _Py_hashtable_get(tracemalloc_traces, TO_PTR(ptr));
|
|
if (trace != NULL) {
|
|
/* update the traceback of the memory block */
|
|
traceback_t *traceback = traceback_new();
|
|
if (traceback != NULL) {
|
|
trace->traceback = traceback;
|
|
res = 0;
|
|
}
|
|
}
|
|
/* else: cannot track the object, its memory block size is unknown */
|
|
TABLES_UNLOCK();
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
PyObject*
|
|
_PyTraceMalloc_GetTraceback(unsigned int domain, uintptr_t ptr)
|
|
{
|
|
traceback_t *traceback;
|
|
|
|
traceback = tracemalloc_get_traceback(domain, ptr);
|
|
if (traceback == NULL)
|
|
Py_RETURN_NONE;
|
|
|
|
return traceback_to_pyobject(traceback, NULL);
|
|
}
|