#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"

_Py_DECLARE_STR(anon_unknown, "<unknown>");

#define TRACE_RAW_MALLOC

static void tracemalloc_stop(void);

static void* raw_malloc(size_t size);

static void raw_free(void *ptr);

#ifdef Py_DEBUG

# define TRACE_DEBUG

#define TO_PTR(key) ((const void *)(uintptr_t)(key))

#define FROM_PTR(key) ((uintptr_t)(key))

static struct {

PyMemAllocatorEx mem;

PyMemAllocatorEx raw;

PyMemAllocatorEx obj;

} allocators;

#if defined(TRACE_RAW_MALLOC)

static PyThread_type_lock tables_lock;

# define TABLES_LOCK() PyThread_acquire_lock(tables_lock, 1)

# define TABLES_UNLOCK() PyThread_release_lock(tables_lock)

/* variables are protected by the GIL */

# define TABLES_LOCK()

# define TABLES_UNLOCK()

#define DEFAULT_DOMAIN 0

typedef struct

#ifdef __GNUC__

__attribute__((packed))

#elif defined(_MSC_VER)

#pragma pack(push, 4)

{

/* filename cannot be NULL: "<unknown>" is used if the Python frame

PyObject *filename;

unsigned int lineno;

} frame_t;

#ifdef _MSC_VER

#pragma pack(pop)

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))

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;

typedef struct {

/* Size of the memory block in bytes */

size_t size;

/* Traceback where the memory block was allocated */

traceback_t *traceback;

} trace_t;

static size_t tracemalloc_traced_memory = 0;

static size_t tracemalloc_peak_traced_memory = 0;

static _Py_hashtable_t *tracemalloc_filenames = NULL;

static traceback_t *tracemalloc_traceback = NULL;

static _Py_hashtable_t *tracemalloc_tracebacks = NULL;

static _Py_hashtable_t *tracemalloc_traces = NULL;

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);

}

#if defined(TRACE_RAW_MALLOC)

#define REENTRANT_THREADLOCAL

static Py_tss_t tracemalloc_reentrant_key = Py_tss_NEEDS_INIT;

#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);

}

}

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;

}

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");

return;

}

if (!PyUnicode_Check(filename)) {

#ifdef TRACE_DEBUG

tracemalloc_error("filename is not a unicode string");

return;

}

if (!PyUnicode_IS_READY(filename)) {

/* Don't make a Unicode string ready to avoid reentrant calls

#ifdef TRACE_DEBUG

tracemalloc_error("filename is not a ready unicode string");

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

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");

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");

return;

}

_PyInterpreterFrame *pyframe = tstate->cframe->current_frame;

for (;;) {

while (pyframe && _PyFrame_IsIncomplete(pyframe)) {

pyframe = pyframe->previous;

}

if (pyframe == NULL) {

break;

}

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++;

}

pyframe = pyframe->previous;

}

}

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");

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");

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

if (ptr2 != ptr) {

REMOVE_TRACE(ptr);

}

if (ADD_TRACE(ptr2, new_size) < 0) {

/* Memory allocation failed. The error cannot be reported to

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

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

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().

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

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()

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()

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);

}

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);

PyErr_SetFromErrno(PyExc_OSError);

return -1;

}

#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;

}

}

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;

}

#ifdef REENTRANT_THREADLOCAL

PyThread_tss_delete(&tracemalloc_reentrant_key);

}

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);

alloc.malloc = tracemalloc_malloc_gil;

alloc.calloc = tracemalloc_calloc_gil;