cpython-lru_cache-weakref: Objects/obmalloc.c annotate

annotate Objects/obmalloc.c @ 87690:66c1c9f32567 default tip

Add use_weakref option to functools.lru_cache The use_weakref option makes lru_cache create weak references to the function arguments when creating the cache key, which prevents them from staying in the memory forever even after all other references to them are gone. This is a proof of concept for http://bugs.python.org/issue19859

author	Radomir Dopieralski <devel@sheep.art.pl>
date	Tue, 03 Dec 2013 16:02:48 +0100
parents	ba27cba3ae20
children

rev	line source
22469 8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	1 #include "Python.h"
8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	2
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	3 /* Python's malloc wrappers (see pymem.h) */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	4
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	5 #ifdef PYMALLOC_DEBUG /* WITH_PYMALLOC && PYMALLOC_DEBUG */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	6 /* Forward declaration */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	7 static void* _PyMem_DebugMalloc(void *ctx, size_t size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	8 static void _PyMem_DebugFree(void ctx, void p);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	9 static void* _PyMem_DebugRealloc(void ctx, void ptr, size_t size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	10
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	11 static void _PyObject_DebugDumpAddress(const void *p);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	12 static void _PyMem_DebugCheckAddress(char api_id, const void *p);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	13 #endif
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	14
85818 f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	15 #if defined(__has_feature) /* Clang */
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	16 #if __has_feature(address_sanitizer) /* is ASAN enabled? */
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	17 #define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS \
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	18 __attribute__((no_address_safety_analysis)) \
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	19 __attribute__ ((noinline))
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	20 #else
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	21 #define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	22 #endif
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	23 #else
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	24 #if defined(__SANITIZE_ADDRESS__) /* GCC 4.8.x, is ASAN enabled? */
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	25 #define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS \
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	26 __attribute__((no_address_safety_analysis)) \
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	27 __attribute__ ((noinline))
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	28 #else
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	29 #define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	30 #endif
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	31 #endif
f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	32
22469 8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	33 #ifdef WITH_PYMALLOC
8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	34
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	35 #ifdef MS_WINDOWS
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	36 # include <windows.h>
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	37 #elif defined(HAVE_MMAP)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	38 # include <sys/mman.h>
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	39 # ifdef MAP_ANONYMOUS
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	40 # define ARENAS_USE_MMAP
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	41 # endif
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	42 #endif
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	43
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	44 /* Forward declaration */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	45 static void* _PyObject_Malloc(void *ctx, size_t size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	46 static void _PyObject_Free(void ctx, void p);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	47 static void* _PyObject_Realloc(void ctx, void ptr, size_t size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	48 #endif
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	49
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	50
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	51 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	52 _PyMem_RawMalloc(void *ctx, size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	53 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	54 /* PyMem_Malloc(0) means malloc(1). Some systems would return NULL
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	55 for malloc(0), which would be treated as an error. Some platforms would
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	56 return a pointer with no memory behind it, which would break pymalloc.
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	57 To solve these problems, allocate an extra byte. */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	58 if (size == 0)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	59 size = 1;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	60 return malloc(size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	61 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	62
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	63 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	64 _PyMem_RawRealloc(void ctx, void ptr, size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	65 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	66 if (size == 0)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	67 size = 1;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	68 return realloc(ptr, size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	69 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	70
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	71 static void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	72 _PyMem_RawFree(void ctx, void ptr)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	73 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	74 free(ptr);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	75 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	76
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	77
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	78 #ifdef MS_WINDOWS
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	79 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	80 _PyObject_ArenaVirtualAlloc(void *ctx, size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	81 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	82 return VirtualAlloc(NULL, size,
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	83 MEM_COMMIT \| MEM_RESERVE, PAGE_READWRITE);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	84 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	85
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	86 static void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	87 _PyObject_ArenaVirtualFree(void ctx, void ptr, size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	88 {
84473 51ed51d10e60 Issue #3329: Fix _PyObject_ArenaVirtualFree() Victor Stinner <victor.stinner@gmail.com> parents: 84471 diff changeset	89 VirtualFree(ptr, 0, MEM_RELEASE);
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	90 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	91
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	92 #elif defined(ARENAS_USE_MMAP)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	93 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	94 _PyObject_ArenaMmap(void *ctx, size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	95 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	96 void *ptr;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	97 ptr = mmap(NULL, size, PROT_READ\|PROT_WRITE,
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	98 MAP_PRIVATE\|MAP_ANONYMOUS, -1, 0);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	99 if (ptr == MAP_FAILED)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	100 return NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	101 assert(ptr != NULL);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	102 return ptr;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	103 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	104
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	105 static void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	106 _PyObject_ArenaMunmap(void ctx, void ptr, size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	107 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	108 munmap(ptr, size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	109 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	110
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	111 #else
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	112 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	113 _PyObject_ArenaMalloc(void *ctx, size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	114 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	115 return malloc(size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	116 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	117
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	118 static void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	119 _PyObject_ArenaFree(void ctx, void ptr, size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	120 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	121 free(ptr);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	122 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	123 #endif
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	124
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	125
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	126 #define PYRAW_FUNCS _PyMem_RawMalloc, _PyMem_RawRealloc, _PyMem_RawFree
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	127 #ifdef WITH_PYMALLOC
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	128 # define PYOBJ_FUNCS _PyObject_Malloc, _PyObject_Realloc, _PyObject_Free
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	129 #else
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	130 # define PYOBJ_FUNCS PYRAW_FUNCS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	131 #endif
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	132 #define PYMEM_FUNCS PYRAW_FUNCS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	133
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	134 #ifdef PYMALLOC_DEBUG
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	135 typedef struct {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	136 /* We tag each block with an API ID in order to tag API violations */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	137 char api_id;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	138 PyMemAllocator alloc;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	139 } debug_alloc_api_t;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	140 static struct {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	141 debug_alloc_api_t raw;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	142 debug_alloc_api_t mem;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	143 debug_alloc_api_t obj;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	144 } _PyMem_Debug = {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	145 {'r', {NULL, PYRAW_FUNCS}},
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	146 {'m', {NULL, PYMEM_FUNCS}},
ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	147 {'o', {NULL, PYOBJ_FUNCS}}
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	148 };
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	149
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	150 #define PYDBG_FUNCS _PyMem_DebugMalloc, _PyMem_DebugRealloc, _PyMem_DebugFree
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	151 #endif
f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	152
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	153 static PyMemAllocator _PyMem_Raw = {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	154 #ifdef PYMALLOC_DEBUG
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	155 &_PyMem_Debug.raw, PYDBG_FUNCS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	156 #else
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	157 NULL, PYRAW_FUNCS
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	158 #endif
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	159 };
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	160
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	161 static PyMemAllocator _PyMem = {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	162 #ifdef PYMALLOC_DEBUG
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	163 &_PyMem_Debug.mem, PYDBG_FUNCS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	164 #else
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	165 NULL, PYMEM_FUNCS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	166 #endif
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	167 };
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	168
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	169 static PyMemAllocator _PyObject = {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	170 #ifdef PYMALLOC_DEBUG
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	171 &_PyMem_Debug.obj, PYDBG_FUNCS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	172 #else
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	173 NULL, PYOBJ_FUNCS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	174 #endif
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	175 };
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	176
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	177 #undef PYRAW_FUNCS
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	178 #undef PYMEM_FUNCS
ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	179 #undef PYOBJ_FUNCS
ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	180 #undef PYDBG_FUNCS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	181
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	182 static PyObjectArenaAllocator _PyObject_Arena = {NULL,
84352 44f455e6163d Issue #13483: Use VirtualAlloc in obmalloc on Windows. Martin v. Löwis <martin@v.loewis.de> parents: 84131 diff changeset	183 #ifdef MS_WINDOWS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	184 _PyObject_ArenaVirtualAlloc, _PyObject_ArenaVirtualFree
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	185 #elif defined(ARENAS_USE_MMAP)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	186 _PyObject_ArenaMmap, _PyObject_ArenaMunmap
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	187 #else
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	188 _PyObject_ArenaMalloc, _PyObject_ArenaFree
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	189 #endif
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	190 };
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	191
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	192 void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	193 PyMem_SetupDebugHooks(void)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	194 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	195 #ifdef PYMALLOC_DEBUG
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	196 PyMemAllocator alloc;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	197
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	198 alloc.malloc = _PyMem_DebugMalloc;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	199 alloc.realloc = _PyMem_DebugRealloc;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	200 alloc.free = _PyMem_DebugFree;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	201
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	202 if (_PyMem_Raw.malloc != _PyMem_DebugMalloc) {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	203 alloc.ctx = &_PyMem_Debug.raw;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	204 PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &_PyMem_Debug.raw.alloc);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	205 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	206 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	207
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	208 if (_PyMem.malloc != _PyMem_DebugMalloc) {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	209 alloc.ctx = &_PyMem_Debug.mem;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	210 PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &_PyMem_Debug.mem.alloc);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	211 PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	212 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	213
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	214 if (_PyObject.malloc != _PyMem_DebugMalloc) {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	215 alloc.ctx = &_PyMem_Debug.obj;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	216 PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &_PyMem_Debug.obj.alloc);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	217 PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	218 }
84352 44f455e6163d Issue #13483: Use VirtualAlloc in obmalloc on Windows. Martin v. Löwis <martin@v.loewis.de> parents: 84131 diff changeset	219 #endif
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	220 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	221
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	222 void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	223 PyMem_GetAllocator(PyMemAllocatorDomain domain, PyMemAllocator *allocator)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	224 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	225 switch(domain)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	226 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	227 case PYMEM_DOMAIN_RAW: *allocator = _PyMem_Raw; break;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	228 case PYMEM_DOMAIN_MEM: *allocator = _PyMem; break;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	229 case PYMEM_DOMAIN_OBJ: *allocator = _PyObject; break;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	230 default:
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	231 /* unknown domain */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	232 allocator->ctx = NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	233 allocator->malloc = NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	234 allocator->realloc = NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	235 allocator->free = NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	236 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	237 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	238
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	239 void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	240 PyMem_SetAllocator(PyMemAllocatorDomain domain, PyMemAllocator *allocator)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	241 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	242 switch(domain)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	243 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	244 case PYMEM_DOMAIN_RAW: _PyMem_Raw = *allocator; break;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	245 case PYMEM_DOMAIN_MEM: _PyMem = *allocator; break;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	246 case PYMEM_DOMAIN_OBJ: _PyObject = *allocator; break;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	247 /* ignore unknown domain */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	248 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	249
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	250 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	251
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	252 void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	253 PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	254 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	255 *allocator = _PyObject_Arena;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	256 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	257
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	258 void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	259 PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	260 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	261 _PyObject_Arena = *allocator;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	262 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	263
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	264 void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	265 PyMem_RawMalloc(size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	266 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	267 /*
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	268 * Limit ourselves to PY_SSIZE_T_MAX bytes to prevent security holes.
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	269 * Most python internals blindly use a signed Py_ssize_t to track
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	270 * things without checking for overflows or negatives.
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	271 * As size_t is unsigned, checking for size < 0 is not required.
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	272 */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	273 if (size > (size_t)PY_SSIZE_T_MAX)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	274 return NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	275
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	276 return _PyMem_Raw.malloc(_PyMem_Raw.ctx, size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	277 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	278
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	279 void*
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	280 PyMem_RawRealloc(void *ptr, size_t new_size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	281 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	282 /* see PyMem_RawMalloc() */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	283 if (new_size > (size_t)PY_SSIZE_T_MAX)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	284 return NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	285 return _PyMem_Raw.realloc(_PyMem_Raw.ctx, ptr, new_size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	286 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	287
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	288 void PyMem_RawFree(void *ptr)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	289 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	290 _PyMem_Raw.free(_PyMem_Raw.ctx, ptr);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	291 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	292
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	293 void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	294 PyMem_Malloc(size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	295 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	296 /* see PyMem_RawMalloc() */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	297 if (size > (size_t)PY_SSIZE_T_MAX)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	298 return NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	299 return _PyMem.malloc(_PyMem.ctx, size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	300 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	301
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	302 void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	303 PyMem_Realloc(void *ptr, size_t new_size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	304 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	305 /* see PyMem_RawMalloc() */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	306 if (new_size > (size_t)PY_SSIZE_T_MAX)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	307 return NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	308 return _PyMem.realloc(_PyMem.ctx, ptr, new_size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	309 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	310
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	311 void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	312 PyMem_Free(void *ptr)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	313 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	314 _PyMem.free(_PyMem.ctx, ptr);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	315 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	316
84502 65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	317 char *
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	318 _PyMem_RawStrdup(const char *str)
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	319 {
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	320 size_t size;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	321 char *copy;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	322
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	323 size = strlen(str) + 1;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	324 copy = PyMem_RawMalloc(size);
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	325 if (copy == NULL)
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	326 return NULL;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	327 memcpy(copy, str, size);
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	328 return copy;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	329 }
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	330
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	331 char *
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	332 _PyMem_Strdup(const char *str)
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	333 {
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	334 size_t size;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	335 char *copy;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	336
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	337 size = strlen(str) + 1;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	338 copy = PyMem_Malloc(size);
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	339 if (copy == NULL)
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	340 return NULL;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	341 memcpy(copy, str, size);
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	342 return copy;
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	343 }
65f2c92ed079 Issue #18203: Add _PyMem_RawStrdup() and _PyMem_Strdup() Victor Stinner <victor.stinner@gmail.com> parents: 84473 diff changeset	344
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	345 void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	346 PyObject_Malloc(size_t size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	347 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	348 /* see PyMem_RawMalloc() */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	349 if (size > (size_t)PY_SSIZE_T_MAX)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	350 return NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	351 return _PyObject.malloc(_PyObject.ctx, size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	352 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	353
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	354 void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	355 PyObject_Realloc(void *ptr, size_t new_size)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	356 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	357 /* see PyMem_RawMalloc() */
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	358 if (new_size > (size_t)PY_SSIZE_T_MAX)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	359 return NULL;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	360 return _PyObject.realloc(_PyObject.ctx, ptr, new_size);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	361 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	362
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	363 void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	364 PyObject_Free(void *ptr)
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	365 {
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	366 _PyObject.free(_PyObject.ctx, ptr);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	367 }
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	368
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	369
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	370 #ifdef WITH_PYMALLOC
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	371
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	372 #ifdef WITH_VALGRIND
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	373 #include <valgrind/valgrind.h>
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	374
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	375 /* If we're using GCC, use __builtin_expect() to reduce overhead of
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	376 the valgrind checks */
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	377 #if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	378 # define UNLIKELY(value) __builtin_expect((value), 0)
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	379 #else
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	380 # define UNLIKELY(value) (value)
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	381 #endif
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	382
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	383 /* -1 indicates that we haven't checked that we're running on valgrind yet. */
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	384 static int running_on_valgrind = -1;
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	385 #endif
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	386
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	387 /* An object allocator for Python.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	388
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	389 Here is an introduction to the layers of the Python memory architecture,
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	390 showing where the object allocator is actually used (layer +2), It is
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	391 called for every object allocation and deallocation (PyObject_New/Del),
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	392 unless the object-specific allocators implement a proprietary allocation
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	393 scheme (ex.: ints use a simple free list). This is also the place where
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	394 the cyclic garbage collector operates selectively on container objects.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	395
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	396
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	397 Object-specific allocators
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	398 _____ ______ ______ ________
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	399 [ int ] [ dict ] [ list ] ... [ string ] Python core \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	400 +3 \| <----- Object-specific memory -----> \| <-- Non-object memory --> \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	401 _______________________________ \| \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	402 [ Python's object allocator ] \| \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	403 +2 \| ####### Object memory ####### \| <------ Internal buffers ------> \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	404 ______________________________________________________________ \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	405 [ Python's raw memory allocator (PyMem_ API) ] \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	406 +1 \| <----- Python memory (under PyMem manager's control) ------> \| \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	407 __________________________________________________________________
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	408 [ Underlying general-purpose allocator (ex: C library malloc) ]
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	409 0 \| <------ Virtual memory allocated for the python process -------> \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	410
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	411 =========================================================================
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	412 _______________________________________________________________________
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	413 [ OS-specific Virtual Memory Manager (VMM) ]
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	414 -1 \| <--- Kernel dynamic storage allocation & management (page-based) ---> \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	415 __________________________________ __________________________________
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	416 [ ] [ ]
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	417 -2 \| <-- Physical memory: ROM/RAM --> \| \| <-- Secondary storage (swap) --> \|
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	418
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	419 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	420 /==========================================================================/
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	421
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	422 /* A fast, special-purpose memory allocator for small blocks, to be used
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	423 on top of a general-purpose malloc -- heavily based on previous art. */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	424
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	425 /* Vladimir Marangozov -- August 2000 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	426
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	427 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	428 * "Memory management is where the rubber meets the road -- if we do the wrong
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	429 * thing at any level, the results will not be good. And if we don't make the
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	430 * levels work well together, we are in serious trouble." (1)
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	431 *
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	432 * (1) Paul R. Wilson, Mark S. Johnstone, Michael Neely, and David Boles,
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	433 * "Dynamic Storage Allocation: A Survey and Critical Review",
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	434 * in Proc. 1995 Int'l. Workshop on Memory Management, September 1995.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	435 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	436
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	437 /* #undef WITH_MEMORY_LIMITS / / disable mem limit checks */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	438
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	439 /==========================================================================/
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	440
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	441 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	442 * Allocation strategy abstract:
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	443 *
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	444 * For small requests, the allocator sub-allocates <Big> blocks of memory.
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	445 * Requests greater than SMALL_REQUEST_THRESHOLD bytes are routed to the
f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	446 * system's allocator.
22470 0e4758ccfe2b Just whitespace fiddling. Tim Peters <tim.peters@gmail.com> parents: 22469 diff changeset	447 *
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	448 * Small requests are grouped in size classes spaced 8 bytes apart, due
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	449 * to the required valid alignment of the returned address. Requests of
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	450 * a particular size are serviced from memory pools of 4K (one VMM page).
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	451 * Pools are fragmented on demand and contain free lists of blocks of one
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	452 * particular size class. In other words, there is a fixed-size allocator
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	453 * for each size class. Free pools are shared by the different allocators
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	454 * thus minimizing the space reserved for a particular size class.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	455 *
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	456 * This allocation strategy is a variant of what is known as "simple
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	457 * segregated storage based on array of free lists". The main drawback of
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	458 * simple segregated storage is that we might end up with lot of reserved
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	459 * memory for the different free lists, which degenerate in time. To avoid
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	460 * this, we partition each free list in pools and we share dynamically the
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	461 * reserved space between all free lists. This technique is quite efficient
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	462 * for memory intensive programs which allocate mainly small-sized blocks.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	463 *
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	464 * For small requests we have the following table:
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	465 *
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	466 * Request in bytes Size of allocated block Size class idx
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	467 * ----------------------------------------------------------------
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	468 * 1-8 8 0
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	469 * 9-16 16 1
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	470 * 17-24 24 2
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	471 * 25-32 32 3
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	472 * 33-40 40 4
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	473 * 41-48 48 5
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	474 * 49-56 56 6
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	475 * 57-64 64 7
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	476 * 65-72 72 8
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	477 * ... ... ...
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	478 * 497-504 504 62
f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	479 * 505-512 512 63
22470 0e4758ccfe2b Just whitespace fiddling. Tim Peters <tim.peters@gmail.com> parents: 22469 diff changeset	480 *
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	481 * 0, SMALL_REQUEST_THRESHOLD + 1 and up: routed to the underlying
f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	482 * allocator.
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	483 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	484
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	485 /==========================================================================/
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	486
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	487 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	488 * -- Main tunable settings section --
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	489 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	490
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	491 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	492 * Alignment of addresses returned to the user. 8-bytes alignment works
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	493 * on most current architectures (with 32-bit or 64-bit address busses).
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	494 * The alignment value is also used for grouping small requests in size
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	495 * classes spaced ALIGNMENT bytes apart.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	496 *
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	497 * You shouldn't change this unless you know what you are doing.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	498 */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	499 #define ALIGNMENT 8 /* must be 2^N */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	500 #define ALIGNMENT_SHIFT 3
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	501
22836 f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	502 /* Return the number of bytes in size class I, as a uint. */
f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	503 #define INDEX2SIZE(I) (((uint)(I) + 1) << ALIGNMENT_SHIFT)
f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	504
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	505 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	506 * Max size threshold below which malloc requests are considered to be
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	507 * small enough in order to use preallocated memory pools. You can tune
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	508 * this value according to your application behaviour and memory needs.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	509 *
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	510 * Note: a size threshold of 512 guarantees that newly created dictionaries
f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	511 * will be allocated from preallocated memory pools on 64-bit.
f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	512 *
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	513 * The following invariants must hold:
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	514 * 1) ALIGNMENT <= SMALL_REQUEST_THRESHOLD <= 512
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	515 * 2) SMALL_REQUEST_THRESHOLD is evenly divisible by ALIGNMENT
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	516 *
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	517 * Although not required, for better performance and space efficiency,
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	518 * it is recommended that SMALL_REQUEST_THRESHOLD is set to a power of 2.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	519 */
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	520 #define SMALL_REQUEST_THRESHOLD 512
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	521 #define NB_SMALL_SIZE_CLASSES (SMALL_REQUEST_THRESHOLD / ALIGNMENT)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	522
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	523 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	524 * The system's VMM page size can be obtained on most unices with a
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	525 * getpagesize() call or deduced from various header files. To make
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	526 * things simpler, we assume that it is 4K, which is OK for most systems.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	527 * It is probably better if this is the native page size, but it doesn't
35222 8d0d395c211e Backport: Georg Brandl <georg@python.org> parents: 32279 diff changeset	528 * have to be. In theory, if SYSTEM_PAGE_SIZE is larger than the native page
8d0d395c211e Backport: Georg Brandl <georg@python.org> parents: 32279 diff changeset	529 * size, then `POOL_ADDR(p)->arenaindex' could rarely cause a segmentation
8d0d395c211e Backport: Georg Brandl <georg@python.org> parents: 32279 diff changeset	530 * violation fault. 4K is apparently OK for all the platforms that python
25928 75756c8558bd Patch #627105: Document that SYSTEM_PAGE_SIZE really should not be Martin v. Löwis <martin@v.loewis.de> parents: 25233 diff changeset	531 * currently targets.
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	532 */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	533 #define SYSTEM_PAGE_SIZE (4 * 1024)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	534 #define SYSTEM_PAGE_SIZE_MASK (SYSTEM_PAGE_SIZE - 1)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	535
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	536 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	537 * Maximum amount of memory managed by the allocator for small requests.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	538 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	539 #ifdef WITH_MEMORY_LIMITS
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	540 #ifndef SMALL_MEMORY_LIMIT
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	541 #define SMALL_MEMORY_LIMIT (64 * 1024 * 1024) /* 64 MB -- more? */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	542 #endif
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	543 #endif
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	544
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	545 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	546 * The allocator sub-allocates <Big> blocks of memory (called arenas) aligned
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	547 * on a page boundary. This is a reserved virtual address space for the
73747 e7aa72e6aad4 Better resolution for issue #11849: Ensure that free()d memory arenas are really released Antoine Pitrou <solipsis@pitrou.net> parents: 69805 diff changeset	548 * current process (obtained through a malloc()/mmap() call). In no way this
e7aa72e6aad4 Better resolution for issue #11849: Ensure that free()d memory arenas are really released Antoine Pitrou <solipsis@pitrou.net> parents: 69805 diff changeset	549 * means that the memory arenas will be used entirely. A malloc(<Big>) is
e7aa72e6aad4 Better resolution for issue #11849: Ensure that free()d memory arenas are really released Antoine Pitrou <solipsis@pitrou.net> parents: 69805 diff changeset	550 * usually an address range reservation for <Big> bytes, unless all pages within
e7aa72e6aad4 Better resolution for issue #11849: Ensure that free()d memory arenas are really released Antoine Pitrou <solipsis@pitrou.net> parents: 69805 diff changeset	551 * this space are referenced subsequently. So malloc'ing big blocks and not
e7aa72e6aad4 Better resolution for issue #11849: Ensure that free()d memory arenas are really released Antoine Pitrou <solipsis@pitrou.net> parents: 69805 diff changeset	552 * using them does not mean "wasting memory". It's an addressable range
e7aa72e6aad4 Better resolution for issue #11849: Ensure that free()d memory arenas are really released Antoine Pitrou <solipsis@pitrou.net> parents: 69805 diff changeset	553 * wastage...
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	554 *
73747 e7aa72e6aad4 Better resolution for issue #11849: Ensure that free()d memory arenas are really released Antoine Pitrou <solipsis@pitrou.net> parents: 69805 diff changeset	555 * Arenas are allocated with mmap() on systems supporting anonymous memory
e7aa72e6aad4 Better resolution for issue #11849: Ensure that free()d memory arenas are really released Antoine Pitrou <solipsis@pitrou.net> parents: 69805 diff changeset	556 * mappings to reduce heap fragmentation.
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	557 */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	558 #define ARENA_SIZE (256 << 10) /* 256KB */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	559
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	560 #ifdef WITH_MEMORY_LIMITS
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	561 #define MAX_ARENAS (SMALL_MEMORY_LIMIT / ARENA_SIZE)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	562 #endif
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	563
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	564 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	565 * Size of the pools used for small blocks. Should be a power of 2,
22692 2c02cf278f02 It's once again thought safe to call the pymalloc free/realloc with an Tim Peters <tim.peters@gmail.com> parents: 22691 diff changeset	566 * between 1K and SYSTEM_PAGE_SIZE, that is: 1k, 2k, 4k.
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	567 */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	568 #define POOL_SIZE SYSTEM_PAGE_SIZE /* must be 2^N */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	569 #define POOL_SIZE_MASK SYSTEM_PAGE_SIZE_MASK
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	570
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	571 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	572 * -- End of tunable settings section --
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	573 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	574
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	575 /==========================================================================/
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	576
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	577 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	578 * Locking
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	579 *
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	580 * To reduce lock contention, it would probably be better to refine the
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	581 * crude function locking with per size class locking. I'm not positive
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	582 * however, whether it's worth switching to such locking policy because
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	583 * of the performance penalty it might introduce.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	584 *
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	585 * The following macros describe the simplest (should also be the fastest)
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	586 * lock object on a particular platform and the init/fini/lock/unlock
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	587 * operations on it. The locks defined here are not expected to be recursive
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	588 * because it is assumed that they will always be called in the order:
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	589 * INIT, [LOCK, UNLOCK]*, FINI.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	590 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	591
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	592 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	593 * Python's threads are serialized, so object malloc locking is disabled.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	594 */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	595 #define SIMPLELOCK_DECL(lock) /* simple lock declaration */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	596 #define SIMPLELOCK_INIT(lock) /* allocate (if needed) and initialize */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	597 #define SIMPLELOCK_FINI(lock) /* free/destroy an existing lock */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	598 #define SIMPLELOCK_LOCK(lock) /* acquire released lock */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	599 #define SIMPLELOCK_UNLOCK(lock) /* release acquired lock */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	600
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	601 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	602 * Basic types
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	603 * I don't care if these are defined in <sys/types.h> or elsewhere. Axiom.
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	604 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	605 #undef uchar
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	606 #define uchar unsigned char /* assuming == 8 bits */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	607
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	608 #undef uint
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	609 #define uint unsigned int /* assuming >= 16 bits */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	610
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	611 #undef ulong
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	612 #define ulong unsigned long /* assuming >= 32 bits */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	613
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	614 #undef uptr
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	615 #define uptr Py_uintptr_t
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	616
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	617 /* When you say memory, my mind reasons in terms of (pointers to) blocks */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	618 typedef uchar block;
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	619
22836 f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	620 /* Pool for small blocks. */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	621 struct pool_header {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	622 union { block *_padding;
66482 0000bbab08b4 Merged revisions 86791 via svnmerge from Stefan Krah <stefan@bytereef.org> parents: 61467 diff changeset	623 uint count; } ref; /* number of allocated blocks */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	624 block freeblock; / pool's free list head */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	625 struct pool_header nextpool; / next pool of this size class */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	626 struct pool_header prevpool; / previous pool "" */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	627 uint arenaindex; /* index into arenas of base adr */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	628 uint szidx; /* block size class index */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	629 uint nextoffset; /* bytes to virgin block */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	630 uint maxnextoffset; /* largest valid nextoffset */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	631 };
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	632
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	633 typedef struct pool_header *poolp;
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	634
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	635 /* Record keeping for arenas. */
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	636 struct arena_object {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	637 /* The address of the arena, as returned by malloc. Note that 0
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	638 * will never be returned by a successful malloc, and is used
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	639 * here to mark an arena_object that doesn't correspond to an
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	640 * allocated arena.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	641 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	642 uptr address;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	643
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	644 /* Pool-aligned pointer to the next pool to be carved off. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	645 block* pool_address;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	646
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	647 /* The number of available pools in the arena: free pools + never-
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	648 * allocated pools.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	649 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	650 uint nfreepools;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	651
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	652 /* The total number of pools in the arena, whether or not available. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	653 uint ntotalpools;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	654
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	655 /* Singly-linked list of available pools. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	656 struct pool_header* freepools;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	657
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	658 /* Whenever this arena_object is not associated with an allocated
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	659 * arena, the nextarena member is used to link all unassociated
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	660 * arena_objects in the singly-linked `unused_arena_objects` list.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	661 * The prevarena member is unused in this case.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	662 *
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	663 * When this arena_object is associated with an allocated arena
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	664 * with at least one available pool, both members are used in the
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	665 * doubly-linked `usable_arenas` list, which is maintained in
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	666 * increasing order of `nfreepools` values.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	667 *
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	668 * Else this arena_object is associated with an allocated arena
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	669 * all of whose pools are in use. `nextarena` and `prevarena`
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	670 * are both meaningless in this case.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	671 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	672 struct arena_object* nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	673 struct arena_object* prevarena;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	674 };
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	675
79065 99112b851b25 Issue #15144: Fix possible integer overflow when handling pointers as integer values, by using Py_uintptr_t instead of size_t. Antoine Pitrou <solipsis@pitrou.net> parents: 77577 diff changeset	676 #define POOL_OVERHEAD _Py_SIZE_ROUND_UP(sizeof(struct pool_header), ALIGNMENT)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	677
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	678 #define DUMMY_SIZE_IDX 0xffff /* size class of newly cached pools */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	679
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	680 /* Round pointer P down to the closest pool-aligned address <= P, as a poolp */
79065 99112b851b25 Issue #15144: Fix possible integer overflow when handling pointers as integer values, by using Py_uintptr_t instead of size_t. Antoine Pitrou <solipsis@pitrou.net> parents: 77577 diff changeset	681 #define POOL_ADDR(P) ((poolp)_Py_ALIGN_DOWN((P), POOL_SIZE))
22836 f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	682
22837 ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	683 /* Return total number of blocks in pool of size index I, as a uint. */
ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	684 #define NUMBLOCKS(I) ((uint)(POOL_SIZE - POOL_OVERHEAD) / INDEX2SIZE(I))
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	685
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	686 /==========================================================================/
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	687
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	688 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	689 * This malloc lock
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	690 */
24294 0a08ed05bd42 Remove extraneous semicolon. Jeremy Hylton <jeremy@alum.mit.edu> parents: 24177 diff changeset	691 SIMPLELOCK_DECL(_malloc_lock)
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	692 #define LOCK() SIMPLELOCK_LOCK(_malloc_lock)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	693 #define UNLOCK() SIMPLELOCK_UNLOCK(_malloc_lock)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	694 #define LOCK_INIT() SIMPLELOCK_INIT(_malloc_lock)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	695 #define LOCK_FINI() SIMPLELOCK_FINI(_malloc_lock)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	696
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	697 /*
22697 6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	698 * Pool table -- headed, circular, doubly-linked lists of partially used pools.
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	699
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	700 This is involved. For an index i, usedpools[i+i] is the header for a list of
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	701 all partially used pools holding small blocks with "size class idx" i. So
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	702 usedpools[0] corresponds to blocks of size 8, usedpools[2] to blocks of size
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	703 16, and so on: index 2*i <-> blocks of size (i+1)<<ALIGNMENT_SHIFT.
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	704
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	705 Pools are carved off an arena's highwater mark (an arena_object's pool_address
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	706 member) as needed. Once carved off, a pool is in one of three states forever
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	707 after:
22697 6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	708
22741 771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	709 used == partially used, neither empty nor full
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	710 At least one block in the pool is currently allocated, and at least one
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	711 block in the pool is not currently allocated (note this implies a pool
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	712 has room for at least two blocks).
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	713 This is a pool's initial state, as a pool is created only when malloc
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	714 needs space.
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	715 The pool holds blocks of a fixed size, and is in the circular list headed
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	716 at usedpools[i] (see above). It's linked to the other used pools of the
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	717 same size class via the pool_header's nextpool and prevpool members.
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	718 If all but one block is currently allocated, a malloc can cause a
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	719 transition to the full state. If all but one block is not currently
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	720 allocated, a free can cause a transition to the empty state.
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	721
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	722 full == all the pool's blocks are currently allocated
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	723 On transition to full, a pool is unlinked from its usedpools[] list.
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	724 It's not linked to from anything then anymore, and its nextpool and
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	725 prevpool members are meaningless until it transitions back to used.
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	726 A free of a block in a full pool puts the pool back in the used state.
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	727 Then it's linked in at the front of the appropriate usedpools[] list, so
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	728 that the next allocation for its size class will reuse the freed block.
22697 6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	729
22741 771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	730 empty == all the pool's blocks are currently available for allocation
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	731 On transition to empty, a pool is unlinked from its usedpools[] list,
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	732 and linked to the front of its arena_object's singly-linked freepools list,
22741 771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	733 via its nextpool member. The prevpool member has no meaning in this case.
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	734 Empty pools have no inherent size class: the next time a malloc finds
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	735 an empty list in usedpools[], it takes the first pool off of freepools.
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	736 If the size class needed happens to be the same as the size class the pool
22836 f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	737 last had, some pool initialization can be skipped.
22741 771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	738
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	739
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	740 Block Management
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	741
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	742 Blocks within pools are again carved out as needed. pool->freeblock points to
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	743 the start of a singly-linked list of free blocks within the pool. When a
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	744 block is freed, it's inserted at the front of its pool's freeblock list. Note
771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	745 that the available blocks in a pool are not linked all together when a pool
22836 f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	746 is initialized. Instead only "the first two" (lowest addresses) blocks are
f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	747 set up, returning the first such block, and setting pool->freeblock to a
f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	748 one-block list holding the second such block. This is consistent with that
f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	749 pymalloc strives at all levels (arena, pool, and block) never to touch a piece
f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	750 of memory until it's actually needed.
f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	751
f1f57bf09092 Widespread, but mostly in _PyMalloc_Malloc: optimize away all expensive Tim Peters <tim.peters@gmail.com> parents: 22795 diff changeset	752 So long as a pool is in the used state, we're certain there is a block
22948 6cb52829da1a SF bug 542181: Realloc behavior Tim Peters <tim.peters@gmail.com> parents: 22860 diff changeset	753 available for allocating, and pool->freeblock is not NULL. If pool->freeblock
6cb52829da1a SF bug 542181: Realloc behavior Tim Peters <tim.peters@gmail.com> parents: 22860 diff changeset	754 points to the end of the free list before we've carved the entire pool into
6cb52829da1a SF bug 542181: Realloc behavior Tim Peters <tim.peters@gmail.com> parents: 22860 diff changeset	755 blocks, that means we simply haven't yet gotten to one of the higher-address
6cb52829da1a SF bug 542181: Realloc behavior Tim Peters <tim.peters@gmail.com> parents: 22860 diff changeset	756 blocks. The offset from the pool_header to the start of "the next" virgin
6cb52829da1a SF bug 542181: Realloc behavior Tim Peters <tim.peters@gmail.com> parents: 22860 diff changeset	757 block is stored in the pool_header nextoffset member, and the largest value
6cb52829da1a SF bug 542181: Realloc behavior Tim Peters <tim.peters@gmail.com> parents: 22860 diff changeset	758 of nextoffset that makes sense is stored in the maxnextoffset member when a
6cb52829da1a SF bug 542181: Realloc behavior Tim Peters <tim.peters@gmail.com> parents: 22860 diff changeset	759 pool is initialized. All the blocks in a pool have been passed out at least
6cb52829da1a SF bug 542181: Realloc behavior Tim Peters <tim.peters@gmail.com> parents: 22860 diff changeset	760 once when and only when nextoffset > maxnextoffset.
22741 771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	761
22697 6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	762
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	763 Major obscurity: While the usedpools vector is declared to have poolp
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	764 entries, it doesn't really. It really contains two pointers per (conceptual)
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	765 poolp entry, the nextpool and prevpool members of a pool_header. The
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	766 excruciating initialization code below fools C so that
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	767
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	768 usedpool[i+i]
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	769
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	770 "acts like" a genuine poolp, but only so long as you only reference its
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	771 nextpool and prevpool members. The "- 2sizeof(block )" gibberish is
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	772 compensating for that a pool_header's nextpool and prevpool members
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	773 immediately follow a pool_header's first two members:
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	774
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	775 union { block *_padding;
66482 0000bbab08b4 Merged revisions 86791 via svnmerge from Stefan Krah <stefan@bytereef.org> parents: 61467 diff changeset	776 uint count; } ref;
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	777 block *freeblock;
22697 6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	778
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	779 each of which consume sizeof(block *) bytes. So what usedpools[i+i] really
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	780 contains is a fudged-up pointer p such that if C believes it's a poolp
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	781 pointer, then p->nextpool and p->prevpool are both p (meaning that the headed
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	782 circular list is empty).
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	783
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	784 It's unclear why the usedpools setup is so convoluted. It could be to
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	785 minimize the amount of cache required to hold this heavily-referenced table
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	786 (which only needs the two interpool pointer members of a pool_header). OTOH,
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	787 referencing code has to remember to "double the index" and doing so isn't
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	788 free, usedpools[0] isn't a strictly legal pointer, and we're crucially relying
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	789 on that C doesn't insert any padding anywhere in a pool_header at or before
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	790 the prevpool member.
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	791 **************************************************************************** */
6bb4386b1111 Added a long-overdue comment block giving an overview of pool operations Tim Peters <tim.peters@gmail.com> parents: 22692 diff changeset	792
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	793 #define PTA(x) ((poolp )((uchar )&(usedpools[2(x)]) - 2sizeof(block )))
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	794 #define PT(x) PTA(x), PTA(x)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	795
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	796 static poolp usedpools[2 * ((NB_SMALL_SIZE_CLASSES + 7) / 8) * 8] = {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	797 PT(0), PT(1), PT(2), PT(3), PT(4), PT(5), PT(6), PT(7)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	798 #if NB_SMALL_SIZE_CLASSES > 8
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	799 , PT(8), PT(9), PT(10), PT(11), PT(12), PT(13), PT(14), PT(15)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	800 #if NB_SMALL_SIZE_CLASSES > 16
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	801 , PT(16), PT(17), PT(18), PT(19), PT(20), PT(21), PT(22), PT(23)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	802 #if NB_SMALL_SIZE_CLASSES > 24
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	803 , PT(24), PT(25), PT(26), PT(27), PT(28), PT(29), PT(30), PT(31)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	804 #if NB_SMALL_SIZE_CLASSES > 32
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	805 , PT(32), PT(33), PT(34), PT(35), PT(36), PT(37), PT(38), PT(39)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	806 #if NB_SMALL_SIZE_CLASSES > 40
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	807 , PT(40), PT(41), PT(42), PT(43), PT(44), PT(45), PT(46), PT(47)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	808 #if NB_SMALL_SIZE_CLASSES > 48
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	809 , PT(48), PT(49), PT(50), PT(51), PT(52), PT(53), PT(54), PT(55)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	810 #if NB_SMALL_SIZE_CLASSES > 56
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	811 , PT(56), PT(57), PT(58), PT(59), PT(60), PT(61), PT(62), PT(63)
69805 f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	812 #if NB_SMALL_SIZE_CLASSES > 64
f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	813 #error "NB_SMALL_SIZE_CLASSES should be less than 64"
f8a697bc3ca8 Issue #11849: Make it more likely for the system allocator to release Antoine Pitrou <solipsis@pitrou.net> parents: 68258 diff changeset	814 #endif /* NB_SMALL_SIZE_CLASSES > 64 */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	815 #endif /* NB_SMALL_SIZE_CLASSES > 56 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	816 #endif /* NB_SMALL_SIZE_CLASSES > 48 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	817 #endif /* NB_SMALL_SIZE_CLASSES > 40 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	818 #endif /* NB_SMALL_SIZE_CLASSES > 32 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	819 #endif /* NB_SMALL_SIZE_CLASSES > 24 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	820 #endif /* NB_SMALL_SIZE_CLASSES > 16 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	821 #endif /* NB_SMALL_SIZE_CLASSES > 8 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	822 };
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	823
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	824 /*==========================================================================
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	825 Arena management.
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	826
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	827 `arenas` is a vector of arena_objects. It contains maxarenas entries, some of
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	828 which may not be currently used (== they're arena_objects that aren't
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	829 currently associated with an allocated arena). Note that arenas proper are
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	830 separately malloc'ed.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	831
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	832 Prior to Python 2.5, arenas were never free()'ed. Starting with Python 2.5,
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	833 we do try to free() arenas, and use some mild heuristic strategies to increase
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	834 the likelihood that arenas eventually can be freed.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	835
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	836 unused_arena_objects
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	837
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	838 This is a singly-linked list of the arena_objects that are currently not
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	839 being used (no arena is associated with them). Objects are taken off the
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	840 head of the list in new_arena(), and are pushed on the head of the list in
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	841 PyObject_Free() when the arena is empty. Key invariant: an arena_object
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	842 is on this list if and only if its .address member is 0.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	843
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	844 usable_arenas
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	845
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	846 This is a doubly-linked list of the arena_objects associated with arenas
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	847 that have pools available. These pools are either waiting to be reused,
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	848 or have not been used before. The list is sorted to have the most-
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	849 allocated arenas first (ascending order based on the nfreepools member).
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	850 This means that the next allocation will come from a heavily used arena,
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	851 which gives the nearly empty arenas a chance to be returned to the system.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	852 In my unscientific tests this dramatically improved the number of arenas
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	853 that could be freed.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	854
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	855 Note that an arena_object associated with an arena all of whose pools are
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	856 currently in use isn't on either list.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	857 */
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	858
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	859 /* Array of objects used to track chunks of memory (arenas). */
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	860 static struct arena_object* arenas = NULL;
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	861 /* Number of slots currently allocated in the `arenas` vector. */
22690 00b2972ab4a4 Changed the #-of-arenas counters to uints -- no need to be insane about Tim Peters <tim.peters@gmail.com> parents: 22687 diff changeset	862 static uint maxarenas = 0;
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	863
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	864 /* The head of the singly-linked, NULL-terminated list of available
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	865 * arena_objects.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	866 */
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	867 static struct arena_object* unused_arena_objects = NULL;
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	868
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	869 /* The head of the doubly-linked, NULL-terminated at each end, list of
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	870 * arena_objects associated with arenas that have pools available.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	871 */
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	872 static struct arena_object* usable_arenas = NULL;
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	873
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	874 /* How many arena_objects do we initially allocate?
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	875 * 16 = can allocate 16 arenas = 16 * ARENA_SIZE = 4MB before growing the
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	876 * `arenas` vector.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	877 */
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	878 #define INITIAL_ARENA_OBJECTS 16
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	879
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	880 /* Number of arenas allocated that haven't been free()'d. */
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	881 static size_t narenas_currently_allocated = 0;
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	882
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	883 /* Total number of times malloc() called to allocate an arena. */
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	884 static size_t ntimes_arena_allocated = 0;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	885 /* High water mark (max value ever seen) for narenas_currently_allocated. */
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	886 static size_t narenas_highwater = 0;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	887
80777 c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	888 static Py_ssize_t _Py_AllocatedBlocks = 0;
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	889
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	890 Py_ssize_t
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	891 _Py_GetAllocatedBlocks(void)
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	892 {
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	893 return _Py_AllocatedBlocks;
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	894 }
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	895
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	896
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	897 /* Allocate a new arena. If we run out of memory, return NULL. Else
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	898 * allocate a new arena, and return the address of an arena_object
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	899 * describing the new arena. It's expected that the caller will set
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	900 * `usable_arenas` to the return value.
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	901 */
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	902 static struct arena_object*
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	903 new_arena(void)
fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	904 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	905 struct arena_object* arenaobj;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	906 uint excess; /* number of bytes above pool alignment */
75511 ba8f85e16dd9 Close #14232: catch mmap() failure in new_arena() of obmalloc Victor Stinner <victor.stinner@gmail.com> parents: 73747 diff changeset	907 void *address;
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	908
23020 e2848618bd19 _PyObject_DebugDumpStats: renamed to _PyObject_DebugMallocStats. Tim Peters <tim.peters@gmail.com> parents: 23009 diff changeset	909 #ifdef PYMALLOC_DEBUG
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	910 if (Py_GETENV("PYTHONMALLOCSTATS"))
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	911 _PyObject_DebugMallocStats(stderr);
23020 e2848618bd19 _PyObject_DebugDumpStats: renamed to _PyObject_DebugMallocStats. Tim Peters <tim.peters@gmail.com> parents: 23009 diff changeset	912 #endif
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	913 if (unused_arena_objects == NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	914 uint i;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	915 uint numarenas;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	916 size_t nbytes;
23020 e2848618bd19 _PyObject_DebugDumpStats: renamed to _PyObject_DebugMallocStats. Tim Peters <tim.peters@gmail.com> parents: 23009 diff changeset	917
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	918 /* Double the number of arena objects on each allocation.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	919 * Note that it's possible for `numarenas` to overflow.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	920 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	921 numarenas = maxarenas ? maxarenas << 1 : INITIAL_ARENA_OBJECTS;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	922 if (numarenas <= maxarenas)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	923 return NULL; /* overflow */
49145 96d6276d80e2 Merged revisions 66383 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 48825 diff changeset	924 #if SIZEOF_SIZE_T <= SIZEOF_INT
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	925 if (numarenas > PY_SIZE_MAX / sizeof(*arenas))
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	926 return NULL; /* overflow */
49145 96d6276d80e2 Merged revisions 66383 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 48825 diff changeset	927 #endif
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	928 nbytes = numarenas * sizeof(*arenas);
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	929 arenaobj = (struct arena_object *)PyMem_RawRealloc(arenas, nbytes);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	930 if (arenaobj == NULL)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	931 return NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	932 arenas = arenaobj;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	933
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	934 /* We might need to fix pointers that were copied. However,
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	935 * new_arena only gets called when all the pages in the
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	936 * previous arenas are full. Thus, there are no pointers
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	937 * into the old array. Thus, we don't have to worry about
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	938 * invalid pointers. Just to be sure, some asserts:
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	939 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	940 assert(usable_arenas == NULL);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	941 assert(unused_arena_objects == NULL);
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	942
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	943 /* Put the new arenas on the unused_arena_objects list. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	944 for (i = maxarenas; i < numarenas; ++i) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	945 arenas[i].address = 0; /* mark as unassociated */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	946 arenas[i].nextarena = i < numarenas - 1 ?
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	947 &arenas[i+1] : NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	948 }
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	949
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	950 /* Update globals. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	951 unused_arena_objects = &arenas[maxarenas];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	952 maxarenas = numarenas;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	953 }
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	954
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	955 /* Take the next available arena object off the head of the list. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	956 assert(unused_arena_objects != NULL);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	957 arenaobj = unused_arena_objects;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	958 unused_arena_objects = arenaobj->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	959 assert(arenaobj->address == 0);
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	960 address = _PyObject_Arena.alloc(_PyObject_Arena.ctx, ARENA_SIZE);
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	961 if (address == NULL) {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	962 /* The allocation failed: return NULL after putting the
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	963 * arenaobj back.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	964 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	965 arenaobj->nextarena = unused_arena_objects;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	966 unused_arena_objects = arenaobj;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	967 return NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	968 }
75511 ba8f85e16dd9 Close #14232: catch mmap() failure in new_arena() of obmalloc Victor Stinner <victor.stinner@gmail.com> parents: 73747 diff changeset	969 arenaobj->address = (uptr)address;
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	970
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	971 ++narenas_currently_allocated;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	972 ++ntimes_arena_allocated;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	973 if (narenas_currently_allocated > narenas_highwater)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	974 narenas_highwater = narenas_currently_allocated;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	975 arenaobj->freepools = NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	976 /* pool_address <- first pool-aligned address in the arena
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	977 nfreepools <- number of whole pools that fit after alignment */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	978 arenaobj->pool_address = (block*)arenaobj->address;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	979 arenaobj->nfreepools = ARENA_SIZE / POOL_SIZE;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	980 assert(POOL_SIZE * arenaobj->nfreepools == ARENA_SIZE);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	981 excess = (uint)(arenaobj->address & POOL_SIZE_MASK);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	982 if (excess != 0) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	983 --arenaobj->nfreepools;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	984 arenaobj->pool_address += POOL_SIZE - excess;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	985 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	986 arenaobj->ntotalpools = arenaobj->nfreepools;
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	987
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	988 return arenaobj;
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	989 }
fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	990
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	991 /*
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	992 Py_ADDRESS_IN_RANGE(P, POOL)
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	993
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	994 Return true if and only if P is an address that was allocated by pymalloc.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	995 POOL must be the pool address associated with P, i.e., POOL = POOL_ADDR(P)
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	996 (the caller is asked to compute this because the macro expands POOL more than
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	997 once, and for efficiency it's best for the caller to assign POOL_ADDR(P) to a
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	998 variable and pass the latter to the macro; because Py_ADDRESS_IN_RANGE is
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	999 called on every alloc/realloc/free, micro-efficiency is important here).
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1000
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1001 Tricky: Let B be the arena base address associated with the pool, B =
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1002 arenas[(POOL)->arenaindex].address. Then P belongs to the arena if and only if
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1003
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1004 B <= P < B + ARENA_SIZE
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1005
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1006 Subtracting B throughout, this is true iff
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1007
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1008 0 <= P-B < ARENA_SIZE
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1009
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1010 By using unsigned arithmetic, the "0 <=" half of the test can be skipped.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1011
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1012 Obscure: A PyMem "free memory" function can call the pymalloc free or realloc
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1013 before the first arena has been allocated. `arenas` is still NULL in that
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1014 case. We're relying on that maxarenas is also 0 in that case, so that
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1015 (POOL)->arenaindex < maxarenas must be false, saving us from trying to index
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1016 into a NULL arenas.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1017
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1018 Details: given P and POOL, the arena_object corresponding to P is AO =
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1019 arenas[(POOL)->arenaindex]. Suppose obmalloc controls P. Then (barring wild
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1020 stores, etc), POOL is the correct address of P's pool, AO.address is the
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1021 correct base address of the pool's arena, and P must be within ARENA_SIZE of
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1022 AO.address. In addition, AO.address is not 0 (no arena can start at address 0
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1023 (NULL)). Therefore Py_ADDRESS_IN_RANGE correctly reports that obmalloc
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1024 controls P.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1025
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1026 Now suppose obmalloc does not control P (e.g., P was obtained via a direct
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1027 call to the system malloc() or realloc()). (POOL)->arenaindex may be anything
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1028 in this case -- it may even be uninitialized trash. If the trash arenaindex
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1029 is >= maxarenas, the macro correctly concludes at once that obmalloc doesn't
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1030 control P.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1031
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1032 Else arenaindex is < maxarena, and AO is read up. If AO corresponds to an
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1033 allocated arena, obmalloc controls all the memory in slice AO.address :
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1034 AO.address+ARENA_SIZE. By case assumption, P is not controlled by obmalloc,
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1035 so P doesn't lie in that slice, so the macro correctly reports that P is not
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1036 controlled by obmalloc.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1037
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1038 Finally, if P is not controlled by obmalloc and AO corresponds to an unused
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1039 arena_object (one not currently associated with an allocated arena),
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1040 AO.address is 0, and the second test in the macro reduces to:
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1041
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1042 P < ARENA_SIZE
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1043
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1044 If P >= ARENA_SIZE (extremely likely), the macro again correctly concludes
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1045 that P is not controlled by obmalloc. However, if P < ARENA_SIZE, this part
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1046 of the test still passes, and the third clause (AO.address != 0) is necessary
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1047 to get the correct result: AO.address is 0 in this case, so the macro
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1048 correctly reports that P is not controlled by obmalloc (despite that P lies in
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1049 slice AO.address : AO.address + ARENA_SIZE).
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1050
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1051 Note: The third (AO.address != 0) clause was added in Python 2.5. Before
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1052 2.5, arenas were never free()'ed, and an arenaindex < maxarena always
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1053 corresponded to a currently-allocated arena, so the "P is not controlled by
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1054 obmalloc, AO corresponds to an unused arena_object, and P < ARENA_SIZE" case
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1055 was impossible.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1056
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1057 Note that the logic is excruciating, and reading up possibly uninitialized
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1058 memory when P is not controlled by obmalloc (to get at (POOL)->arenaindex)
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1059 creates problems for some memory debuggers. The overwhelming advantage is
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1060 that this test determines whether an arbitrary address is controlled by
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1061 obmalloc in a small constant time, independent of the number of arenas
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1062 obmalloc controls. Since this test is needed at every entry point, it's
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1063 extremely desirable that it be this fast.
67443 54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1064
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1065 Since Py_ADDRESS_IN_RANGE may be reading from memory which was not allocated
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1066 by Python, it is important that (POOL)->arenaindex is read only once, as
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1067 another thread may be concurrently modifying the value without holding the
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1068 GIL. To accomplish this, the arenaindex_temp variable is used to store
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1069 (POOL)->arenaindex for the duration of the Py_ADDRESS_IN_RANGE macro's
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1070 execution. The caller of the macro is responsible for declaring this
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1071 variable.
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1072 */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1073 #define Py_ADDRESS_IN_RANGE(P, POOL) \
67443 54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1074 ((arenaindex_temp = (POOL)->arenaindex) < maxarenas && \
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1075 (uptr)(P) - arenas[arenaindex_temp].address < (uptr)ARENA_SIZE && \
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1076 arenas[arenaindex_temp].address != 0)
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1077
32278 c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1078
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1079 /* This is only useful when running memory debuggers such as
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1080 * Purify or Valgrind. Uncomment to use.
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1081 *
49294 091a6c5227a9 Merged revisions 66616 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 49145 diff changeset	1082 #define Py_USING_MEMORY_DEBUGGER
42334 e70cdce0e8b2 Merged revisions 56467-56482 via svnmerge from Martin v. Löwis <martin@v.loewis.de> parents: 40450 diff changeset	1083 */
32278 c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1084
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1085 #ifdef Py_USING_MEMORY_DEBUGGER
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1086
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1087 /* Py_ADDRESS_IN_RANGE may access uninitialized memory by design
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1088 * This leads to thousands of spurious warnings when using
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1089 * Purify or Valgrind. By making a function, we can easily
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1090 * suppress the uninitialized memory reads in this one function.
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1091 * So we won't ignore real errors elsewhere.
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1092 *
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1093 * Disable the macro and use a function.
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1094 */
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1095
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1096 #undef Py_ADDRESS_IN_RANGE
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1097
40450 cc992d75d5b3 Four months of trunk changes (including a few releases...) Thomas Wouters <thomas@python.org> parents: 38673 diff changeset	1098 #if defined(__GNUC__) && ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) \|\| \
66482 0000bbab08b4 Merged revisions 86791 via svnmerge from Stefan Krah <stefan@bytereef.org> parents: 61467 diff changeset	1099 (__GNUC__ >= 4))
35864 dbc93ee53e2f Do a better job of not inlining Py_ADDRESS_IN_RANGE() for newer gcc's. Neal Norwitz <nnorwitz@gmail.com> parents: 35222 diff changeset	1100 #define Py_NO_INLINE __attribute__((__noinline__))
dbc93ee53e2f Do a better job of not inlining Py_ADDRESS_IN_RANGE() for newer gcc's. Neal Norwitz <nnorwitz@gmail.com> parents: 35222 diff changeset	1101 #else
dbc93ee53e2f Do a better job of not inlining Py_ADDRESS_IN_RANGE() for newer gcc's. Neal Norwitz <nnorwitz@gmail.com> parents: 35222 diff changeset	1102 #define Py_NO_INLINE
dbc93ee53e2f Do a better job of not inlining Py_ADDRESS_IN_RANGE() for newer gcc's. Neal Norwitz <nnorwitz@gmail.com> parents: 35222 diff changeset	1103 #endif
dbc93ee53e2f Do a better job of not inlining Py_ADDRESS_IN_RANGE() for newer gcc's. Neal Norwitz <nnorwitz@gmail.com> parents: 35222 diff changeset	1104
dbc93ee53e2f Do a better job of not inlining Py_ADDRESS_IN_RANGE() for newer gcc's. Neal Norwitz <nnorwitz@gmail.com> parents: 35222 diff changeset	1105 /* Don't make static, to try to ensure this isn't inlined. */
dbc93ee53e2f Do a better job of not inlining Py_ADDRESS_IN_RANGE() for newer gcc's. Neal Norwitz <nnorwitz@gmail.com> parents: 35222 diff changeset	1106 int Py_ADDRESS_IN_RANGE(void *P, poolp pool) Py_NO_INLINE;
dbc93ee53e2f Do a better job of not inlining Py_ADDRESS_IN_RANGE() for newer gcc's. Neal Norwitz <nnorwitz@gmail.com> parents: 35222 diff changeset	1107 #undef Py_NO_INLINE
32278 c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	1108 #endif
22741 771b2a8d445d Restructured my pool-management overview in terms of the three Tim Peters <tim.peters@gmail.com> parents: 22724 diff changeset	1109
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1110 /==========================================================================/
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1111
22794 f663ffbe9e5c _PyMalloc_{Malloc, Realloc}: Strive to meet the doc's promises about Tim Peters <tim.peters@gmail.com> parents: 22743 diff changeset	1112 /* malloc. Note that nbytes==0 tries to return a non-NULL pointer, distinct
f663ffbe9e5c _PyMalloc_{Malloc, Realloc}: Strive to meet the doc's promises about Tim Peters <tim.peters@gmail.com> parents: 22743 diff changeset	1113 * from all other currently live pointers. This may not be possible.
f663ffbe9e5c _PyMalloc_{Malloc, Realloc}: Strive to meet the doc's promises about Tim Peters <tim.peters@gmail.com> parents: 22743 diff changeset	1114 */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1115
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1116 /*
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1117 * The basic blocks are ordered by decreasing execution frequency,
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1118 * which minimizes the number of jumps in the most common cases,
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1119 * improves branching prediction and instruction scheduling (small
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1120 * block allocations typically result in a couple of instructions).
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1121 * Unless the optimizer reorders everything, being too smart...
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1122 */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1123
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1124 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1125 _PyObject_Malloc(void *ctx, size_t nbytes)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1126 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1127 block *bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1128 poolp pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1129 poolp next;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1130 uint size;
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1131
83114 2bf154ca43c6 Issue #17469: Fix _Py_GetAllocatedBlocks() and sys.getallocatedblocks() when running on valgrind. Antoine Pitrou <solipsis@pitrou.net> parents: 82284 diff changeset	1132 _Py_AllocatedBlocks++;
2bf154ca43c6 Issue #17469: Fix _Py_GetAllocatedBlocks() and sys.getallocatedblocks() when running on valgrind. Antoine Pitrou <solipsis@pitrou.net> parents: 82284 diff changeset	1133
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1134 #ifdef WITH_VALGRIND
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1135 if (UNLIKELY(running_on_valgrind == -1))
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1136 running_on_valgrind = RUNNING_ON_VALGRIND;
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1137 if (UNLIKELY(running_on_valgrind))
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1138 goto redirect;
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1139 #endif
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1140
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1141 /*
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1142 * This implicitly redirects malloc(0).
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1143 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1144 if ((nbytes - 1) < SMALL_REQUEST_THRESHOLD) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1145 LOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1146 /*
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1147 * Most frequent paths first
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1148 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1149 size = (uint)(nbytes - 1) >> ALIGNMENT_SHIFT;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1150 pool = usedpools[size + size];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1151 if (pool != pool->nextpool) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1152 /*
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1153 * There is a used pool for this size class.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1154 * Pick up the head block of its free list.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1155 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1156 ++pool->ref.count;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1157 bp = pool->freeblock;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1158 assert(bp != NULL);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1159 if ((pool->freeblock = (block *)bp) != NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1160 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1161 return (void *)bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1162 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1163 /*
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1164 * Reached the end of the free list, try to extend it.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1165 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1166 if (pool->nextoffset <= pool->maxnextoffset) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1167 /* There is room for another block. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1168 pool->freeblock = (block*)pool +
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1169 pool->nextoffset;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1170 pool->nextoffset += INDEX2SIZE(size);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1171 (block *)(pool->freeblock) = NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1172 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1173 return (void *)bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1174 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1175 /* Pool is full, unlink from used pools. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1176 next = pool->nextpool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1177 pool = pool->prevpool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1178 next->prevpool = pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1179 pool->nextpool = next;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1180 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1181 return (void *)bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1182 }
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1183
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1184 /* There isn't a pool of the right size class immediately
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1185 * available: use a free pool.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1186 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1187 if (usable_arenas == NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1188 /* No arena has a free pool: allocate a new arena. */
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1189 #ifdef WITH_MEMORY_LIMITS
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1190 if (narenas_currently_allocated >= MAX_ARENAS) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1191 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1192 goto redirect;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1193 }
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1194 #endif
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1195 usable_arenas = new_arena();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1196 if (usable_arenas == NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1197 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1198 goto redirect;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1199 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1200 usable_arenas->nextarena =
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1201 usable_arenas->prevarena = NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1202 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1203 assert(usable_arenas->address != 0);
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1204
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1205 /* Try to get a cached free pool. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1206 pool = usable_arenas->freepools;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1207 if (pool != NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1208 /* Unlink from cached pools. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1209 usable_arenas->freepools = pool->nextpool;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1210
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1211 /* This arena already had the smallest nfreepools
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1212 * value, so decreasing nfreepools doesn't change
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1213 * that, and we don't need to rearrange the
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1214 * usable_arenas list. However, if the arena has
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1215 * become wholly allocated, we need to remove its
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1216 * arena_object from usable_arenas.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1217 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1218 --usable_arenas->nfreepools;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1219 if (usable_arenas->nfreepools == 0) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1220 /* Wholly allocated: remove. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1221 assert(usable_arenas->freepools == NULL);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1222 assert(usable_arenas->nextarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1223 usable_arenas->nextarena->prevarena ==
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1224 usable_arenas);
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1225
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1226 usable_arenas = usable_arenas->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1227 if (usable_arenas != NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1228 usable_arenas->prevarena = NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1229 assert(usable_arenas->address != 0);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1230 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1231 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1232 else {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1233 /* nfreepools > 0: it must be that freepools
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1234 * isn't NULL, or that we haven't yet carved
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1235 * off all the arena's pools for the first
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1236 * time.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1237 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1238 assert(usable_arenas->freepools != NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1239 usable_arenas->pool_address <=
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1240 (block*)usable_arenas->address +
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1241 ARENA_SIZE - POOL_SIZE);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1242 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1243 init_pool:
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1244 /* Frontlink to used pools. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1245 next = usedpools[size + size]; /* == prev */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1246 pool->nextpool = next;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1247 pool->prevpool = next;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1248 next->nextpool = pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1249 next->prevpool = pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1250 pool->ref.count = 1;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1251 if (pool->szidx == size) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1252 /* Luckily, this pool last contained blocks
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1253 * of the same size class, so its header
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1254 * and free list are already initialized.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1255 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1256 bp = pool->freeblock;
80777 c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	1257 assert(bp != NULL);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1258 pool->freeblock = (block *)bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1259 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1260 return (void *)bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1261 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1262 /*
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1263 * Initialize the pool header, set up the free list to
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1264 * contain just the second block, and return the first
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1265 * block.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1266 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1267 pool->szidx = size;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1268 size = INDEX2SIZE(size);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1269 bp = (block *)pool + POOL_OVERHEAD;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1270 pool->nextoffset = POOL_OVERHEAD + (size << 1);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1271 pool->maxnextoffset = POOL_SIZE - size;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1272 pool->freeblock = bp + size;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1273 (block *)(pool->freeblock) = NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1274 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1275 return (void *)bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1276 }
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1277
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1278 /* Carve off a new pool. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1279 assert(usable_arenas->nfreepools > 0);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1280 assert(usable_arenas->freepools == NULL);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1281 pool = (poolp)usable_arenas->pool_address;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1282 assert((block)pool <= (block)usable_arenas->address +
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1283 ARENA_SIZE - POOL_SIZE);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1284 pool->arenaindex = usable_arenas - arenas;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1285 assert(&arenas[pool->arenaindex] == usable_arenas);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1286 pool->szidx = DUMMY_SIZE_IDX;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1287 usable_arenas->pool_address += POOL_SIZE;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1288 --usable_arenas->nfreepools;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1289
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1290 if (usable_arenas->nfreepools == 0) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1291 assert(usable_arenas->nextarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1292 usable_arenas->nextarena->prevarena ==
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1293 usable_arenas);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1294 /* Unlink the arena: it is completely allocated. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1295 usable_arenas = usable_arenas->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1296 if (usable_arenas != NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1297 usable_arenas->prevarena = NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1298 assert(usable_arenas->address != 0);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1299 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1300 }
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1301
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1302 goto init_pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1303 }
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1304
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1305 /* The small block allocator ends here. */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1306
22684 fd1b8ebe4eae Lots of changes: Tim Peters <tim.peters@gmail.com> parents: 22631 diff changeset	1307 redirect:
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1308 /* Redirect the original request to the underlying (libc) allocator.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1309 * We jump here on bigger requests, on error in the code above (as a
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1310 * last chance to serve the request) or when the max memory limit
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1311 * has been reached.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1312 */
80777 c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	1313 {
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	1314 void *result = PyMem_RawMalloc(nbytes);
80777 c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	1315 if (!result)
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	1316 _Py_AllocatedBlocks--;
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	1317 return result;
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	1318 }
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1319 }
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1320
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1321 /* free */
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1322
85818 f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	1323 ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1324 static void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1325 _PyObject_Free(void ctx, void p)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1326 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1327 poolp pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1328 block *lastfree;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1329 poolp next, prev;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1330 uint size;
67443 54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1331 #ifndef Py_USING_MEMORY_DEBUGGER
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1332 uint arenaindex_temp;
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1333 #endif
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1334
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1335 if (p == NULL) /* free(NULL) has no effect */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1336 return;
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1337
80777 c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	1338 _Py_AllocatedBlocks--;
c40f4c19d20b Issue #13390: New function :func:`sys.getallocatedblocks()` returns the number of memory blocks currently allocated. Antoine Pitrou <solipsis@pitrou.net> parents: 79065 diff changeset	1339
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1340 #ifdef WITH_VALGRIND
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1341 if (UNLIKELY(running_on_valgrind > 0))
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1342 goto redirect;
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1343 #endif
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1344
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1345 pool = POOL_ADDR(p);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1346 if (Py_ADDRESS_IN_RANGE(p, pool)) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1347 /* We allocated this address. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1348 LOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1349 /* Link p to the start of the pool's freeblock list. Since
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1350 * the pool had at least the p block outstanding, the pool
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1351 * wasn't empty (so it's already in a usedpools[] list, or
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1352 * was full and is in no list -- it's not in the freeblocks
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1353 * list in any case).
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1354 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1355 assert(pool->ref.count > 0); /* else it was empty */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1356 (block *)p = lastfree = pool->freeblock;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1357 pool->freeblock = (block *)p;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1358 if (lastfree) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1359 struct arena_object* ao;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1360 uint nf; /* ao->nfreepools */
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1361
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1362 /* freeblock wasn't NULL, so the pool wasn't full,
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1363 * and the pool is in a usedpools[] list.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1364 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1365 if (--pool->ref.count != 0) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1366 /* pool isn't empty: leave it in usedpools */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1367 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1368 return;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1369 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1370 /* Pool is now empty: unlink from usedpools, and
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1371 * link to the front of freepools. This ensures that
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1372 * previously freed pools will be allocated later
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1373 * (being not referenced, they are perhaps paged out).
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1374 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1375 next = pool->nextpool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1376 prev = pool->prevpool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1377 next->prevpool = prev;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1378 prev->nextpool = next;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1379
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1380 /* Link the pool to freepools. This is a singly-linked
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1381 * list, and pool->prevpool isn't used there.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1382 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1383 ao = &arenas[pool->arenaindex];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1384 pool->nextpool = ao->freepools;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1385 ao->freepools = pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1386 nf = ++ao->nfreepools;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1387
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1388 /* All the rest is arena management. We just freed
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1389 * a pool, and there are 4 cases for arena mgmt:
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1390 * 1. If all the pools are free, return the arena to
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1391 * the system free().
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1392 * 2. If this is the only free pool in the arena,
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1393 * add the arena back to the `usable_arenas` list.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1394 * 3. If the "next" arena has a smaller count of free
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1395 * pools, we have to "slide this arena right" to
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1396 * restore that usable_arenas is sorted in order of
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1397 * nfreepools.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1398 * 4. Else there's nothing more to do.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1399 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1400 if (nf == ao->ntotalpools) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1401 /* Case 1. First unlink ao from usable_arenas.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1402 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1403 assert(ao->prevarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1404 ao->prevarena->address != 0);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1405 assert(ao ->nextarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1406 ao->nextarena->address != 0);
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1407
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1408 /* Fix the pointer in the prevarena, or the
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1409 * usable_arenas pointer.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1410 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1411 if (ao->prevarena == NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1412 usable_arenas = ao->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1413 assert(usable_arenas == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1414 usable_arenas->address != 0);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1415 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1416 else {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1417 assert(ao->prevarena->nextarena == ao);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1418 ao->prevarena->nextarena =
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1419 ao->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1420 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1421 /* Fix the pointer in the nextarena. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1422 if (ao->nextarena != NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1423 assert(ao->nextarena->prevarena == ao);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1424 ao->nextarena->prevarena =
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1425 ao->prevarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1426 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1427 /* Record that this arena_object slot is
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1428 * available to be reused.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1429 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1430 ao->nextarena = unused_arena_objects;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1431 unused_arena_objects = ao;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1432
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1433 /* Free the entire arena. */
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1434 _PyObject_Arena.free(_PyObject_Arena.ctx,
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1435 (void *)ao->address, ARENA_SIZE);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1436 ao->address = 0; /* mark unassociated */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1437 --narenas_currently_allocated;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1438
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1439 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1440 return;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1441 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1442 if (nf == 1) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1443 /* Case 2. Put ao at the head of
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1444 * usable_arenas. Note that because
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1445 * ao->nfreepools was 0 before, ao isn't
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1446 * currently on the usable_arenas list.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1447 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1448 ao->nextarena = usable_arenas;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1449 ao->prevarena = NULL;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1450 if (usable_arenas)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1451 usable_arenas->prevarena = ao;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1452 usable_arenas = ao;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1453 assert(usable_arenas->address != 0);
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1454
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1455 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1456 return;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1457 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1458 /* If this arena is now out of order, we need to keep
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1459 * the list sorted. The list is kept sorted so that
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1460 * the "most full" arenas are used first, which allows
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1461 * the nearly empty arenas to be completely freed. In
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1462 * a few un-scientific tests, it seems like this
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1463 * approach allowed a lot more memory to be freed.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1464 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1465 if (ao->nextarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1466 nf <= ao->nextarena->nfreepools) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1467 /* Case 4. Nothing to do. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1468 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1469 return;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1470 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1471 /* Case 3: We have to move the arena towards the end
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1472 * of the list, because it has more free pools than
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1473 * the arena to its right.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1474 * First unlink ao from usable_arenas.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1475 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1476 if (ao->prevarena != NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1477 /* ao isn't at the head of the list */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1478 assert(ao->prevarena->nextarena == ao);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1479 ao->prevarena->nextarena = ao->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1480 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1481 else {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1482 /* ao is at the head of the list */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1483 assert(usable_arenas == ao);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1484 usable_arenas = ao->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1485 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1486 ao->nextarena->prevarena = ao->prevarena;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1487
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1488 /* Locate the new insertion point by iterating over
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1489 * the list, using our nextarena pointer.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1490 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1491 while (ao->nextarena != NULL &&
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1492 nf > ao->nextarena->nfreepools) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1493 ao->prevarena = ao->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1494 ao->nextarena = ao->nextarena->nextarena;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1495 }
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1496
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1497 /* Insert ao at this point. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1498 assert(ao->nextarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1499 ao->prevarena == ao->nextarena->prevarena);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1500 assert(ao->prevarena->nextarena == ao->nextarena);
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1501
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1502 ao->prevarena->nextarena = ao;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1503 if (ao->nextarena != NULL)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1504 ao->nextarena->prevarena = ao;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1505
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1506 /* Verify that the swaps worked. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1507 assert(ao->nextarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1508 nf <= ao->nextarena->nfreepools);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1509 assert(ao->prevarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1510 nf > ao->prevarena->nfreepools);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1511 assert(ao->nextarena == NULL \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1512 ao->nextarena->prevarena == ao);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1513 assert((usable_arenas == ao &&
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1514 ao->prevarena == NULL) \|\|
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1515 ao->prevarena->nextarena == ao);
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	1516
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1517 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1518 return;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1519 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1520 /* Pool was full, so doesn't currently live in any list:
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1521 * link it to the front of the appropriate usedpools[] list.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1522 * This mimics LRU pool usage for new allocations and
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1523 * targets optimal filling when several pools contain
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1524 * blocks of the same size class.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1525 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1526 --pool->ref.count;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1527 assert(pool->ref.count > 0); /* else the pool is empty */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1528 size = pool->szidx;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1529 next = usedpools[size + size];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1530 prev = next->prevpool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1531 /* insert pool before next: prev <-> pool <-> next */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1532 pool->nextpool = next;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1533 pool->prevpool = prev;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1534 next->prevpool = pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1535 prev->nextpool = pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1536 UNLOCK();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1537 return;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1538 }
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1539
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1540 #ifdef WITH_VALGRIND
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1541 redirect:
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1542 #endif
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1543 /* We didn't allocate this address. */
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	1544 PyMem_RawFree(p);
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1545 }
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1546
22794 f663ffbe9e5c _PyMalloc_{Malloc, Realloc}: Strive to meet the doc's promises about Tim Peters <tim.peters@gmail.com> parents: 22743 diff changeset	1547 /* realloc. If p is NULL, this acts like malloc(nbytes). Else if nbytes==0,
f663ffbe9e5c _PyMalloc_{Malloc, Realloc}: Strive to meet the doc's promises about Tim Peters <tim.peters@gmail.com> parents: 22743 diff changeset	1548 * then as the Python docs promise, we do not treat this like free(p), and
f663ffbe9e5c _PyMalloc_{Malloc, Realloc}: Strive to meet the doc's promises about Tim Peters <tim.peters@gmail.com> parents: 22743 diff changeset	1549 * return a non-NULL result.
f663ffbe9e5c _PyMalloc_{Malloc, Realloc}: Strive to meet the doc's promises about Tim Peters <tim.peters@gmail.com> parents: 22743 diff changeset	1550 */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1551
85818 f6792f734fcc Close #18596: Support address sanity checking in clang/GCC Nick Coghlan <ncoghlan@gmail.com> parents: 85795 diff changeset	1552 ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1553 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1554 _PyObject_Realloc(void ctx, void p, size_t nbytes)
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1555 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1556 void *bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1557 poolp pool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1558 size_t size;
67443 54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1559 #ifndef Py_USING_MEMORY_DEBUGGER
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1560 uint arenaindex_temp;
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	1561 #endif
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1562
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1563 if (p == NULL)
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1564 return _PyObject_Malloc(ctx, nbytes);
48565 887ee6bd9284 Merged revisions 65182 via svnmerge from Georg Brandl <georg@python.org> parents: 48330 diff changeset	1565
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1566 #ifdef WITH_VALGRIND
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1567 /* Treat running_on_valgrind == -1 the same as 0 */
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1568 if (UNLIKELY(running_on_valgrind > 0))
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1569 goto redirect;
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1570 #endif
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1571
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1572 pool = POOL_ADDR(p);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1573 if (Py_ADDRESS_IN_RANGE(p, pool)) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1574 /* We're in charge of this block */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1575 size = INDEX2SIZE(pool->szidx);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1576 if (nbytes <= size) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1577 /* The block is staying the same or shrinking. If
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1578 * it's shrinking, there's a tradeoff: it costs
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1579 * cycles to copy the block to a smaller size class,
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1580 * but it wastes memory not to copy it. The
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1581 * compromise here is to copy on shrink only if at
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1582 * least 25% of size can be shaved off.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1583 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1584 if (4 * nbytes > 3 * size) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1585 /* It's the same,
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1586 * or shrinking and new/old > 3/4.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1587 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1588 return p;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1589 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1590 size = nbytes;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1591 }
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1592 bp = _PyObject_Malloc(ctx, nbytes);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1593 if (bp != NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1594 memcpy(bp, p, size);
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1595 _PyObject_Free(ctx, p);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1596 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1597 return bp;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1598 }
57547 b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1599 #ifdef WITH_VALGRIND
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1600 redirect:
b79d0420c204 Merged revisions 76644 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 56258 diff changeset	1601 #endif
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1602 /* We're not managing this block. If nbytes <=
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1603 * SMALL_REQUEST_THRESHOLD, it's tempting to try to take over this
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1604 * block. However, if we do, we need to copy the valid data from
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1605 * the C-managed block to one of our blocks, and there's no portable
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1606 * way to know how much of the memory space starting at p is valid.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1607 * As bug 1185883 pointed out the hard way, it's possible that the
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1608 * C-managed block is "at the end" of allocated VM space, so that
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1609 * a memory fault can occur if we try to copy nbytes bytes starting
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1610 * at p. Instead we punt: let C continue to manage this block.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1611 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1612 if (nbytes)
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	1613 return PyMem_RawRealloc(p, nbytes);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1614 /* C doesn't define the result of realloc(p, 0) (it may or may not
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1615 * return NULL then), but Python's docs promise that nbytes==0 never
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1616 * returns NULL. We don't pass 0 to realloc(), to avoid that endcase
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1617 * to begin with. Even then, we can't be sure that realloc() won't
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1618 * return NULL.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1619 */
86197 ba27cba3ae20 Issue #18874: _PyObject_Malloc/Realloc/Free() now falls back on Victor Stinner <victor.stinner@gmail.com> parents: 85818 diff changeset	1620 bp = PyMem_RawRealloc(p, 1);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1621 return bp ? bp : p;
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1622 }
5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1623
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1624 #else /* ! WITH_PYMALLOC */
16782 5864a9c58c81 Add Vladimir Marangozov's object allocator. It is disabled by default. This Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: diff changeset	1625
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1626 /==========================================================================/
22983 1c26a3106653 Move PyObject_Malloc and PyObject_Free here from object.c. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22948 diff changeset	1627 /* pymalloc not enabled: Redirect the entry points to malloc. These will
1c26a3106653 Move PyObject_Malloc and PyObject_Free here from object.c. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22948 diff changeset	1628 * only be used by extensions that are compiled with pymalloc enabled. */
22484 ffcb2fd2947e Minor code cleanup -- no semantic changes. Tim Peters <tim.peters@gmail.com> parents: 22479 diff changeset	1629
80923 a85673b55177 Following issue #13390, fix compilation --without-pymalloc, and make sys.getallocatedblocks() return 0 in that situation. Antoine Pitrou <solipsis@pitrou.net> parents: 80777 diff changeset	1630 Py_ssize_t
a85673b55177 Following issue #13390, fix compilation --without-pymalloc, and make sys.getallocatedblocks() return 0 in that situation. Antoine Pitrou <solipsis@pitrou.net> parents: 80777 diff changeset	1631 _Py_GetAllocatedBlocks(void)
22469 8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	1632 {
80923 a85673b55177 Following issue #13390, fix compilation --without-pymalloc, and make sys.getallocatedblocks() return 0 in that situation. Antoine Pitrou <solipsis@pitrou.net> parents: 80777 diff changeset	1633 return 0;
22469 8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	1634 }
8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	1635
8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	1636 #endif /* WITH_PYMALLOC */
8d0061493c57 Build obmalloc.c directly instead of #include'ing from object.c. Tim Peters <tim.peters@gmail.com> parents: 22465 diff changeset	1637
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1638 #ifdef PYMALLOC_DEBUG
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1639 /==========================================================================/
22484 ffcb2fd2947e Minor code cleanup -- no semantic changes. Tim Peters <tim.peters@gmail.com> parents: 22479 diff changeset	1640 /* A x-platform debugging allocator. This doesn't manage memory directly,
ffcb2fd2947e Minor code cleanup -- no semantic changes. Tim Peters <tim.peters@gmail.com> parents: 22479 diff changeset	1641 * it wraps a real allocator, adding extra debugging info to the memory blocks.
ffcb2fd2947e Minor code cleanup -- no semantic changes. Tim Peters <tim.peters@gmail.com> parents: 22479 diff changeset	1642 */
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1643
22986 298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1644 /* Special bytes broadcast into debug memory blocks at appropriate times.
298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1645 * Strings of these are unlikely to be valid addresses, floats, ints or
298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1646 * 7-bit ASCII.
298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1647 */
298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1648 #undef CLEANBYTE
298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1649 #undef DEADBYTE
298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1650 #undef FORBIDDENBYTE
298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1651 #define CLEANBYTE 0xCB /* clean (newly allocated) memory */
24177 a038abd08e4a Documented PYMALLOC_DEBUG. This completes primary coverage of all the Tim Peters <tim.peters@gmail.com> parents: 23363 diff changeset	1652 #define DEADBYTE 0xDB /* dead (newly freed) memory */
22986 298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1653 #define FORBIDDENBYTE 0xFB /* untouchable bytes at each end of a block */
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1654
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1655 static size_t serialno = 0; /* incremented on each debug {m,re}alloc */
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1656
22487 f02cdb2bc17a _PyMalloc_DebugRealloc(): simplify decl of "fresh". Tim Peters <tim.peters@gmail.com> parents: 22484 diff changeset	1657 /* serialno is always incremented via calling this routine. The point is
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1658 * to supply a single place to set a breakpoint.
a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1659 */
22487 f02cdb2bc17a _PyMalloc_DebugRealloc(): simplify decl of "fresh". Tim Peters <tim.peters@gmail.com> parents: 22484 diff changeset	1660 static void
22631 7870fac049f7 Add missing "void" to function. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22614 diff changeset	1661 bumpserialno(void)
22487 f02cdb2bc17a _PyMalloc_DebugRealloc(): simplify decl of "fresh". Tim Peters <tim.peters@gmail.com> parents: 22484 diff changeset	1662 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1663 ++serialno;
22487 f02cdb2bc17a _PyMalloc_DebugRealloc(): simplify decl of "fresh". Tim Peters <tim.peters@gmail.com> parents: 22484 diff changeset	1664 }
f02cdb2bc17a _PyMalloc_DebugRealloc(): simplify decl of "fresh". Tim Peters <tim.peters@gmail.com> parents: 22484 diff changeset	1665
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1666 #define SST SIZEOF_SIZE_T
22487 f02cdb2bc17a _PyMalloc_DebugRealloc(): simplify decl of "fresh". Tim Peters <tim.peters@gmail.com> parents: 22484 diff changeset	1667
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1668 /* Read sizeof(size_t) bytes at p as a big-endian size_t. */
a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1669 static size_t
a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1670 read_size_t(const void *p)
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1671 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1672 const uchar q = (const uchar )p;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1673 size_t result = *q++;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1674 int i;
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1675
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1676 for (i = SST; --i > 0; ++q)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1677 result = (result << 8) \| *q;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1678 return result;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1679 }
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1680
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1681 /* Write n as a big-endian size_t, MSB at address p, LSB at
a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1682 * p + sizeof(size_t) - 1.
a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1683 */
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1684 static void
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1685 write_size_t(void *p, size_t n)
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1686 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1687 uchar q = (uchar )p + SST - 1;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1688 int i;
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1689
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1690 for (i = SST; --i >= 0; --q) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1691 *q = (uchar)(n & 0xff);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1692 n >>= 8;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1693 }
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1694 }
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1695
23159 fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1696 #ifdef Py_DEBUG
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1697 /* Is target in the list? The list is traversed via the nextpool pointers.
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1698 * The list may be NULL-terminated, or circular. Return 1 if target is in
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1699 * list, else 0.
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1700 */
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1701 static int
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1702 pool_is_in_list(const poolp target, poolp list)
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1703 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1704 poolp origlist = list;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1705 assert(target != NULL);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1706 if (list == NULL)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1707 return 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1708 do {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1709 if (target == list)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1710 return 1;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1711 list = list->nextpool;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1712 } while (list != NULL && list != origlist);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1713 return 0;
23159 fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1714 }
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1715
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1716 #else
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1717 #define pool_is_in_list(X, Y) 1
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1718
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1719 #endif /* Py_DEBUG */
23159 fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	1720
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1721 /* Let S = sizeof(size_t). The debug malloc asks for 4*S extra bytes and
a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1722 fills them with useful stuff, here calling the underlying malloc's result p:
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1723
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1724 p[0: S]
a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1725 Number of bytes originally asked for. This is a size_t, big-endian (easier
a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1726 to read in a memory dump).
85795 d5d5b363967e Fix minor typo. Georg Brandl <georg@python.org> parents: 85757 diff changeset	1727 p[S]
85757 84658272e923 Update internal comments to say _something_ about the "API ID". Tim Peters <tim@python.org> parents: 85556 diff changeset	1728 API ID. See PEP 445. This is a character, but seems undocumented.
84658272e923 Update internal comments to say _something_ about the "API ID". Tim Peters <tim@python.org> parents: 85556 diff changeset	1729 p[S+1: 2*S]
22986 298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1730 Copies of FORBIDDENBYTE. Used to catch under- writes and reads.
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1731 p[2S: 2S+n]
22986 298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1732 The requested memory, filled with copies of CLEANBYTE.
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1733 Used to catch reference to uninitialized memory.
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1734 &p[2*S] is returned. Note that this is 8-byte aligned if pymalloc
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1735 handled the request itself.
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1736 p[2S+n: 2S+n+S]
22986 298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1737 Copies of FORBIDDENBYTE. Used to catch over- writes and reads.
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1738 p[2S+n+S: 2S+n+2*S]
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1739 A serial number, incremented by 1 on each call to _PyMem_DebugMalloc
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1740 and _PyMem_DebugRealloc.
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1741 This is a big-endian size_t.
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1742 If "bad memory" is detected later, the serial number gives an
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1743 excellent way to set a breakpoint on the next run, to capture the
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1744 instant at which this block was passed out.
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1745 */
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1746
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1747 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1748 _PyMem_DebugMalloc(void *ctx, size_t nbytes)
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1749 {
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1750 debug_alloc_api_t api = (debug_alloc_api_t )ctx;
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1751 uchar p; / base address of malloc'ed block */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1752 uchar tail; / p + 2SST + nbytes == pointer to tail pad bytes /
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1753 size_t total; /* nbytes + 4SST /
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1754
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1755 bumpserialno();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1756 total = nbytes + 4*SST;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1757 if (total < nbytes)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1758 /* overflow: can't represent total as a size_t */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1759 return NULL;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1760
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1761 p = (uchar *)api->alloc.malloc(api->alloc.ctx, total);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1762 if (p == NULL)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1763 return NULL;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1764
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1765 /* at p, write size (SST bytes), id (1 byte), pad (SST-1 bytes) */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1766 write_size_t(p, nbytes);
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1767 p[SST] = (uchar)api->api_id;
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1768 memset(p + SST + 1, FORBIDDENBYTE, SST-1);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1769
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1770 if (nbytes > 0)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1771 memset(p + 2*SST, CLEANBYTE, nbytes);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1772
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1773 /* at tail, write pad (SST bytes) and serialno (SST bytes) */
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1774 tail = p + 2*SST + nbytes;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1775 memset(tail, FORBIDDENBYTE, SST);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1776 write_size_t(tail + SST, serialno);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1777
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1778 return p + 2*SST;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1779 }
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1780
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	1781 /* The debug free first checks the 2*SST bytes on each end for sanity (in
56256 b6aff7a59803 http://bugs.python.org/issue6836 Kristján Valur Jónsson <kristjan@ccpgames.com> parents: 49294 diff changeset	1782 particular, that the FORBIDDENBYTEs with the api ID are still intact).
22986 298a7c51d2c0 PYMALLOC_{CLEAN, DEAD, FORBIDDEN}BYTE symbols: remove the PYMALLOC_ Tim Peters <tim.peters@gmail.com> parents: 22983 diff changeset	1783 Then fills the original bytes with DEADBYTE.
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1784 Then calls the underlying free.
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1785 */
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1786 static void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1787 _PyMem_DebugFree(void ctx, void p)
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1788 {
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1789 debug_alloc_api_t api = (debug_alloc_api_t )ctx;
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1790 uchar q = (uchar )p - 2SST; / address returned from malloc */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1791 size_t nbytes;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1792
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1793 if (p == NULL)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1794 return;
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1795 _PyMem_DebugCheckAddress(api->api_id, p);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1796 nbytes = read_size_t(q);
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1797 nbytes += 4*SST;
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1798 if (nbytes > 0)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1799 memset(q, DEADBYTE, nbytes);
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1800 api->alloc.free(api->alloc.ctx, q);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1801 }
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1802
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1803 static void *
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1804 _PyMem_DebugRealloc(void ctx, void p, size_t nbytes)
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1805 {
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1806 debug_alloc_api_t api = (debug_alloc_api_t )ctx;
84522 549d8d3297f2 Issue #18408: Fix _PyMem_DebugRealloc() Victor Stinner <victor.stinner@gmail.com> parents: 84502 diff changeset	1807 uchar q = (uchar )p, *oldq;
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1808 uchar *tail;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1809 size_t total; /* nbytes + 4SST /
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1810 size_t original_nbytes;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1811 int i;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1812
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1813 if (p == NULL)
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1814 return _PyMem_DebugMalloc(ctx, nbytes);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1815
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1816 _PyMem_DebugCheckAddress(api->api_id, p);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1817 bumpserialno();
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1818 original_nbytes = read_size_t(q - 2*SST);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1819 total = nbytes + 4*SST;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1820 if (total < nbytes)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1821 /* overflow: can't represent total as a size_t */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1822 return NULL;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1823
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1824 /* Resize and add decorations. We may get a new pointer here, in which
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1825 * case we didn't get the chance to mark the old memory with DEADBYTE,
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1826 * but we live with that.
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1827 */
84522 549d8d3297f2 Issue #18408: Fix _PyMem_DebugRealloc() Victor Stinner <victor.stinner@gmail.com> parents: 84502 diff changeset	1828 oldq = q;
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1829 q = (uchar )api->alloc.realloc(api->alloc.ctx, q - 2SST, total);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1830 if (q == NULL)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1831 return NULL;
22988 be54465a39c4 _PyObject_DebugRealloc(): rewritten to let the underlying realloc do Tim Peters <tim.peters@gmail.com> parents: 22987 diff changeset	1832
84522 549d8d3297f2 Issue #18408: Fix _PyMem_DebugRealloc() Victor Stinner <victor.stinner@gmail.com> parents: 84502 diff changeset	1833 if (q == oldq && nbytes < original_nbytes) {
549d8d3297f2 Issue #18408: Fix _PyMem_DebugRealloc() Victor Stinner <victor.stinner@gmail.com> parents: 84502 diff changeset	1834 /* shrinking: mark old extra memory dead */
549d8d3297f2 Issue #18408: Fix _PyMem_DebugRealloc() Victor Stinner <victor.stinner@gmail.com> parents: 84502 diff changeset	1835 memset(q + nbytes, DEADBYTE, original_nbytes - nbytes);
549d8d3297f2 Issue #18408: Fix _PyMem_DebugRealloc() Victor Stinner <victor.stinner@gmail.com> parents: 84502 diff changeset	1836 }
549d8d3297f2 Issue #18408: Fix _PyMem_DebugRealloc() Victor Stinner <victor.stinner@gmail.com> parents: 84502 diff changeset	1837
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1838 write_size_t(q, nbytes);
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1839 assert(q[SST] == (uchar)api->api_id);
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1840 for (i = 1; i < SST; ++i)
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1841 assert(q[SST + i] == FORBIDDENBYTE);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1842 q += 2*SST;
84522 549d8d3297f2 Issue #18408: Fix _PyMem_DebugRealloc() Victor Stinner <victor.stinner@gmail.com> parents: 84502 diff changeset	1843
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1844 tail = q + nbytes;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1845 memset(tail, FORBIDDENBYTE, SST);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1846 write_size_t(tail + SST, serialno);
22988 be54465a39c4 _PyObject_DebugRealloc(): rewritten to let the underlying realloc do Tim Peters <tim.peters@gmail.com> parents: 22987 diff changeset	1847
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1848 if (nbytes > original_nbytes) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1849 /* growing: mark new extra memory clean */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1850 memset(q + original_nbytes, CLEANBYTE,
66482 0000bbab08b4 Merged revisions 86791 via svnmerge from Stefan Krah <stefan@bytereef.org> parents: 61467 diff changeset	1851 nbytes - original_nbytes);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1852 }
22988 be54465a39c4 _PyObject_DebugRealloc(): rewritten to let the underlying realloc do Tim Peters <tim.peters@gmail.com> parents: 22987 diff changeset	1853
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1854 return q;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1855 }
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1856
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	1857 /* Check the forbidden bytes on both ends of the memory allocated for p.
22983 1c26a3106653 Move PyObject_Malloc and PyObject_Free here from object.c. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22948 diff changeset	1858 * If anything is wrong, print info to stderr via _PyObject_DebugDumpAddress,
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	1859 * and call Py_FatalError to kill the program.
56256 b6aff7a59803 http://bugs.python.org/issue6836 Kristján Valur Jónsson <kristjan@ccpgames.com> parents: 49294 diff changeset	1860 * The API id, is also checked.
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	1861 */
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1862 static void
ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1863 _PyMem_DebugCheckAddress(char api, const void *p)
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1864 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1865 const uchar q = (const uchar )p;
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1866 char msgbuf[64];
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1867 char *msg;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1868 size_t nbytes;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1869 const uchar *tail;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1870 int i;
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1871 char id;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1872
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1873 if (p == NULL) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1874 msg = "didn't expect a NULL pointer";
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1875 goto error;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1876 }
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1877
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1878 /* Check the API id */
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1879 id = (char)q[-SST];
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1880 if (id != api) {
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1881 msg = msgbuf;
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1882 snprintf(msg, sizeof(msgbuf), "bad ID: Allocated using API '%c', verified using API '%c'", id, api);
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1883 msgbuf[sizeof(msgbuf)-1] = 0;
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1884 goto error;
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1885 }
56256 b6aff7a59803 http://bugs.python.org/issue6836 Kristján Valur Jónsson <kristjan@ccpgames.com> parents: 49294 diff changeset	1886
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1887 /* Check the stuff at the start of p first: if there's underwrite
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1888 * corruption, the number-of-bytes field may be nuts, and checking
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1889 * the tail could lead to a segfault then.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1890 */
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1891 for (i = SST-1; i >= 1; --i) {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1892 if (*(q-i) != FORBIDDENBYTE) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1893 msg = "bad leading pad byte";
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1894 goto error;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1895 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1896 }
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1897
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1898 nbytes = read_size_t(q - 2*SST);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1899 tail = q + nbytes;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1900 for (i = 0; i < SST; ++i) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1901 if (tail[i] != FORBIDDENBYTE) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1902 msg = "bad trailing pad byte";
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1903 goto error;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1904 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1905 }
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1906
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1907 return;
22614 f294fdd18b5b PYMALLOC_DEBUG routines: The "check API family" gimmick was going nowhere Tim Peters <tim.peters@gmail.com> parents: 22487 diff changeset	1908
f294fdd18b5b PYMALLOC_DEBUG routines: The "check API family" gimmick was going nowhere Tim Peters <tim.peters@gmail.com> parents: 22487 diff changeset	1909 error:
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1910 _PyObject_DebugDumpAddress(p);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1911 Py_FatalError(msg);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1912 }
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1913
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	1914 /* Display info to stderr about the memory block at p. */
84471 ca78c974e938 Issue #3329: Implement the PEP 445 Victor Stinner <victor.stinner@gmail.com> parents: 84352 diff changeset	1915 static void
22983 1c26a3106653 Move PyObject_Malloc and PyObject_Free here from object.c. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22948 diff changeset	1916 _PyObject_DebugDumpAddress(const void *p)
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1917 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1918 const uchar q = (const uchar )p;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1919 const uchar *tail;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1920 size_t nbytes, serial;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1921 int i;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1922 int ok;
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1923 char id;
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1924
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1925 fprintf(stderr, "Debug memory block at address p=%p:", p);
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1926 if (p == NULL) {
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1927 fprintf(stderr, "\n");
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1928 return;
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1929 }
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1930 id = (char)q[-SST];
cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1931 fprintf(stderr, " API '%c'\n", id);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1932
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1933 nbytes = read_size_t(q - 2*SST);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1934 fprintf(stderr, " %" PY_FORMAT_SIZE_T "u bytes originally "
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1935 "requested\n", nbytes);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1936
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1937 /* In case this is nuts, check the leading pad bytes first. */
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1938 fprintf(stderr, " The %d pad bytes at p-%d are ", SST-1, SST-1);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1939 ok = 1;
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1940 for (i = 1; i <= SST-1; ++i) {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1941 if (*(q-i) != FORBIDDENBYTE) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1942 ok = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1943 break;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1944 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1945 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1946 if (ok)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1947 fputs("FORBIDDENBYTE, as expected.\n", stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1948 else {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1949 fprintf(stderr, "not all FORBIDDENBYTE (0x%02x):\n",
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1950 FORBIDDENBYTE);
61466 cab14be0ada1 Recorded merge of revisions 81029 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 57547 diff changeset	1951 for (i = SST-1; i >= 1; --i) {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1952 const uchar byte = *(q-i);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1953 fprintf(stderr, " at p-%d: 0x%02x", i, byte);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1954 if (byte != FORBIDDENBYTE)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1955 fputs(" *** OUCH", stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1956 fputc('\n', stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1957 }
23298 5a6be8fa8de2 _PyObject_DebugCheckAddress(): If the leading pad bytes are corrupt, Tim Peters <tim.peters@gmail.com> parents: 23159 diff changeset	1958
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1959 fputs(" Because memory is corrupted at the start, the "
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1960 "count of bytes requested\n"
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1961 " may be bogus, and checking the trailing pad "
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1962 "bytes may segfault.\n", stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1963 }
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1964
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1965 tail = q + nbytes;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1966 fprintf(stderr, " The %d pad bytes at tail=%p are ", SST, tail);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1967 ok = 1;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1968 for (i = 0; i < SST; ++i) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1969 if (tail[i] != FORBIDDENBYTE) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1970 ok = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1971 break;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1972 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1973 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1974 if (ok)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1975 fputs("FORBIDDENBYTE, as expected.\n", stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1976 else {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1977 fprintf(stderr, "not all FORBIDDENBYTE (0x%02x):\n",
66482 0000bbab08b4 Merged revisions 86791 via svnmerge from Stefan Krah <stefan@bytereef.org> parents: 61467 diff changeset	1978 FORBIDDENBYTE);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1979 for (i = 0; i < SST; ++i) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1980 const uchar byte = tail[i];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1981 fprintf(stderr, " at tail+%d: 0x%02x",
66482 0000bbab08b4 Merged revisions 86791 via svnmerge from Stefan Krah <stefan@bytereef.org> parents: 61467 diff changeset	1982 i, byte);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1983 if (byte != FORBIDDENBYTE)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1984 fputs(" *** OUCH", stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1985 fputc('\n', stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1986 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1987 }
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1988
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1989 serial = read_size_t(tail + SST);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1990 fprintf(stderr, " The block was made by call #%" PY_FORMAT_SIZE_T
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1991 "u to debug malloc/realloc.\n", serial);
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	1992
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1993 if (nbytes > 0) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1994 i = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1995 fputs(" Data at p:", stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1996 /* print up to 8 bytes at the start */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1997 while (q < tail && i < 8) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1998 fprintf(stderr, " %02x", *q);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	1999 ++i;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2000 ++q;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2001 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2002 /* and up to 8 at the end */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2003 if (q < tail) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2004 if (tail - q > 8) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2005 fputs(" ...", stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2006 q = tail - 8;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2007 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2008 while (q < tail) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2009 fprintf(stderr, " %02x", *q);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2010 ++q;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2011 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2012 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2013 fputc('\n', stderr);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2014 }
22479 fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	2015 }
fb45791150d1 Give Python a debug-mode pymalloc, much as sketched on Python-Dev. Tim Peters <tim.peters@gmail.com> parents: 22470 diff changeset	2016
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2017 #endif /* PYMALLOC_DEBUG */
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2018
38673 a19c20c5e5c7 Merge the rest of the trunk. Thomas Wouters <thomas@python.org> parents: 37879 diff changeset	2019 static size_t
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2020 printone(FILE out, const char msg, size_t value)
22837 ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	2021 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2022 int i, k;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2023 char buf[100];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2024 size_t origvalue = value;
22837 ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	2025
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2026 fputs(msg, out);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2027 for (i = (int)strlen(msg); i < 35; ++i)
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2028 fputc(' ', out);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2029 fputc('=', out);
22860 04367cff8689 Minor improvements to the stats output dump, including adding commas to Tim Peters <tim.peters@gmail.com> parents: 22838 diff changeset	2030
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2031 /* Write the value with commas. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2032 i = 22;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2033 buf[i--] = '\0';
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2034 buf[i--] = '\n';
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2035 k = 3;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2036 do {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2037 size_t nextvalue = value / 10;
82282 470350fd2831 fix building without pymalloc (closes #17228) Benjamin Peterson <benjamin@python.org> parents: 79065 diff changeset	2038 unsigned int digit = (unsigned int)(value - nextvalue * 10);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2039 value = nextvalue;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2040 buf[i--] = (char)(digit + '0');
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2041 --k;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2042 if (k == 0 && value && i >= 0) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2043 k = 3;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2044 buf[i--] = ',';
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2045 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2046 } while (value && i >= 0);
22860 04367cff8689 Minor improvements to the stats output dump, including adding commas to Tim Peters <tim.peters@gmail.com> parents: 22838 diff changeset	2047
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2048 while (i >= 0)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2049 buf[i--] = ' ';
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2050 fputs(buf, out);
22860 04367cff8689 Minor improvements to the stats output dump, including adding commas to Tim Peters <tim.peters@gmail.com> parents: 22838 diff changeset	2051
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2052 return origvalue;
22837 ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	2053 }
ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	2054
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2055 void
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2056 _PyDebugAllocatorStats(FILE *out,
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2057 const char *block_name, int num_blocks, size_t sizeof_block)
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2058 {
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2059 char buf1[128];
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2060 char buf2[128];
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2061 PyOS_snprintf(buf1, sizeof(buf1),
85555 d95cc29ea94e Issue #18942: sys._debugmallocstats() output was damaged on Windows. Tim Peters <tim@python.org> parents: 82282 diff changeset	2062 "%d %ss * %" PY_FORMAT_SIZE_T "d bytes each",
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2063 num_blocks, block_name, sizeof_block);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2064 PyOS_snprintf(buf2, sizeof(buf2),
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2065 "%48s ", buf1);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2066 (void)printone(out, buf2, num_blocks * sizeof_block);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2067 }
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2068
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2069 #ifdef WITH_PYMALLOC
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2070
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2071 /* Print summary info to "out" about the state of pymalloc's structures.
23159 fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	2072 * In Py_DEBUG mode, also perform some expensive internal consistency
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	2073 * checks.
fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	2074 */
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2075 void
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2076 _PyObject_DebugMallocStats(FILE *out)
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2077 {
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2078 uint i;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2079 const uint numclasses = SMALL_REQUEST_THRESHOLD >> ALIGNMENT_SHIFT;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2080 /* # of pools, allocated blocks, and free blocks per class index */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2081 size_t numpools[SMALL_REQUEST_THRESHOLD >> ALIGNMENT_SHIFT];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2082 size_t numblocks[SMALL_REQUEST_THRESHOLD >> ALIGNMENT_SHIFT];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2083 size_t numfreeblocks[SMALL_REQUEST_THRESHOLD >> ALIGNMENT_SHIFT];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2084 /* total # of allocated bytes in used and full pools */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2085 size_t allocated_bytes = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2086 /* total # of available bytes in used pools */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2087 size_t available_bytes = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2088 /* # of free pools + pools not yet carved out of current arena */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2089 uint numfreepools = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2090 /* # of bytes for arena alignment padding */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2091 size_t arena_alignment = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2092 /* # of bytes in used and full pools used for pool_headers */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2093 size_t pool_header_bytes = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2094 /* # of bytes in used and full pools wasted due to quantization,
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2095 * i.e. the necessarily leftover space at the ends of used and
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2096 * full pools.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2097 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2098 size_t quantization = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2099 /* # of arenas actually allocated. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2100 size_t narenas = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2101 /* running total -- should equal narenas * ARENA_SIZE */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2102 size_t total;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2103 char buf[128];
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2104
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2105 fprintf(out, "Small block threshold = %d, in %u size classes.\n",
66482 0000bbab08b4 Merged revisions 86791 via svnmerge from Stefan Krah <stefan@bytereef.org> parents: 61467 diff changeset	2106 SMALL_REQUEST_THRESHOLD, numclasses);
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2107
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2108 for (i = 0; i < numclasses; ++i)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2109 numpools[i] = numblocks[i] = numfreeblocks[i] = 0;
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2110
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2111 /* Because full pools aren't linked to from anything, it's easiest
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2112 * to march over all the arenas. If we're lucky, most of the memory
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2113 * will be living in full pools -- would be a shame to miss them.
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2114 */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2115 for (i = 0; i < maxarenas; ++i) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2116 uint j;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2117 uptr base = arenas[i].address;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	2118
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2119 /* Skip arenas which are not allocated. */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2120 if (arenas[i].address == (uptr)NULL)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2121 continue;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2122 narenas += 1;
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	2123
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2124 numfreepools += arenas[i].nfreepools;
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2125
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2126 /* round up to pool alignment */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2127 if (base & (uptr)POOL_SIZE_MASK) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2128 arena_alignment += POOL_SIZE;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2129 base &= ~(uptr)POOL_SIZE_MASK;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2130 base += POOL_SIZE;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2131 }
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2132
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2133 /* visit every pool in the arena */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2134 assert(base <= (uptr) arenas[i].pool_address);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2135 for (j = 0;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2136 base < (uptr) arenas[i].pool_address;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2137 ++j, base += POOL_SIZE) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2138 poolp p = (poolp)base;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2139 const uint sz = p->szidx;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2140 uint freeblocks;
23159 fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	2141
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2142 if (p->ref.count == 0) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2143 /* currently unused */
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2144 assert(pool_is_in_list(p, arenas[i].freepools));
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2145 continue;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2146 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2147 ++numpools[sz];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2148 numblocks[sz] += p->ref.count;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2149 freeblocks = NUMBLOCKS(sz) - p->ref.count;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2150 numfreeblocks[sz] += freeblocks;
23159 fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	2151 #ifdef Py_DEBUG
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2152 if (freeblocks > 0)
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2153 assert(pool_is_in_list(p, usedpools[sz + sz]));
23159 fca379c30906 _PyObject_DebugMallocStats(): Added some potentially expensive internal Tim Peters <tim.peters@gmail.com> parents: 23158 diff changeset	2154 #endif
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2155 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2156 }
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2157 assert(narenas == narenas_currently_allocated);
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2158
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2159 fputc('\n', out);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2160 fputs("class size num pools blocks in use avail blocks\n"
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2161 "----- ---- --------- ------------- ------------\n",
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2162 out);
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2163
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2164 for (i = 0; i < numclasses; ++i) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2165 size_t p = numpools[i];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2166 size_t b = numblocks[i];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2167 size_t f = numfreeblocks[i];
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2168 uint size = INDEX2SIZE(i);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2169 if (p == 0) {
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2170 assert(b == 0 && f == 0);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2171 continue;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2172 }
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2173 fprintf(out, "%5u %6u "
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2174 "%11" PY_FORMAT_SIZE_T "u "
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2175 "%15" PY_FORMAT_SIZE_T "u "
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2176 "%13" PY_FORMAT_SIZE_T "u\n",
66482 0000bbab08b4 Merged revisions 86791 via svnmerge from Stefan Krah <stefan@bytereef.org> parents: 61467 diff changeset	2177 i, size, p, b, f);
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2178 allocated_bytes += b * size;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2179 available_bytes += f * size;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2180 pool_header_bytes += p * POOL_OVERHEAD;
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2181 quantization += p * ((POOL_SIZE - POOL_OVERHEAD) % size);
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2182 }
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2183 fputc('\n', out);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2184 #ifdef PYMALLOC_DEBUG
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2185 (void)printone(out, "# times object malloc called", serialno);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2186 #endif
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2187 (void)printone(out, "# arenas allocated total", ntimes_arena_allocated);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2188 (void)printone(out, "# arenas reclaimed", ntimes_arena_allocated - narenas);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2189 (void)printone(out, "# arenas highwater mark", narenas_highwater);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2190 (void)printone(out, "# arenas allocated current", narenas);
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	2191
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2192 PyOS_snprintf(buf, sizeof(buf),
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2193 "%" PY_FORMAT_SIZE_T "u arenas * %d bytes/arena",
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2194 narenas, ARENA_SIZE);
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2195 (void)printone(out, buf, narenas * ARENA_SIZE);
22837 ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	2196
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2197 fputc('\n', out);
22837 ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	2198
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2199 total = printone(out, "# bytes in allocated blocks", allocated_bytes);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2200 total += printone(out, "# bytes in available blocks", available_bytes);
22860 04367cff8689 Minor improvements to the stats output dump, including adding commas to Tim Peters <tim.peters@gmail.com> parents: 22838 diff changeset	2201
61467 f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2202 PyOS_snprintf(buf, sizeof(buf),
f197407bdba2 Recorded merge of revisions 81032 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 49294 diff changeset	2203 "%u unused pools * %d bytes", numfreepools, POOL_SIZE);
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2204 total += printone(out, buf, (size_t)numfreepools * POOL_SIZE);
22837 ef2fbce71736 _PyMalloc_DebugDumpStats(): vastly improved the output, and it now Tim Peters <tim.peters@gmail.com> parents: 22836 diff changeset	2205
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2206 total += printone(out, "# bytes lost to pool headers", pool_header_bytes);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2207 total += printone(out, "# bytes lost to quantization", quantization);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2208 total += printone(out, "# bytes lost to arena alignment", arena_alignment);
d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2209 (void)printone(out, "Total", total);
22724 9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2210 }
9baa8c9a1e84 New PYMALLOC_DEBUG function void _PyMalloc_DebugDumpStats(void). Tim Peters <tim.peters@gmail.com> parents: 22701 diff changeset	2211
77577 d63a80abfbec Issue #14785: Add sys._debugmallocstats() to help debug low-level memory allocation issues David Malcolm <dmalcolm@redhat.com> parents: 75511 diff changeset	2212 #endif /* #ifdef WITH_PYMALLOC */
32278 c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	2213
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	2214 #ifdef Py_USING_MEMORY_DEBUGGER
37008 685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	2215 /* Make this function last so gcc won't inline it since the definition is
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	2216 * after the reference.
685849bd905c Merge the tim-obmalloc branch to the trunk. Tim Peters <tim.peters@gmail.com> parents: 36514 diff changeset	2217 */
32278 c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	2218 int
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	2219 Py_ADDRESS_IN_RANGE(void *P, poolp pool)
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	2220 {
67443 54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	2221 uint arenaindex_temp = pool->arenaindex;
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	2222
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	2223 return arenaindex_temp < maxarenas &&
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	2224 (uptr)P - arenas[arenaindex_temp].address < (uptr)ARENA_SIZE &&
54fa62165853 Merged revisions 87834 via svnmerge from Antoine Pitrou <solipsis@pitrou.net> parents: 66482 diff changeset	2225 arenas[arenaindex_temp].address != 0;
32278 c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	2226 }
c2bc248d3e9c SF bug 881641, make it easier to use valgrind Neal Norwitz <nnorwitz@gmail.com> parents: 29515 diff changeset	2227 #endif

Mercurial > cpython-lru_cache-weakref

annotate Objects/obmalloc.c @ 87690:66c1c9f32567 default tip