Mirrors
/
cpython
mirror of https://github.com/python/cpython
3
0
Fork 0
Code Releases Activity
Browse Source

replace obmalloc's homegrown uptr and uchar types with standard ones

pull/9921/head
Benjamin Peterson 10 years ago
parent
3924f93794
commit
19517e4da7
1 changed files with 31 additions and 42 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 73
      Objects/obmalloc.c

73
Objects/obmalloc.c
View File

@ -9,19 +9,9 @@ extern void _PyMem_DumpTraceback(int fd, const void *ptr);
/* Python's malloc wrappers (see pymem.h) */
/*
* Basic types
* I don't care if these are defined in <sys/types.h> or elsewhere. Axiom.
*/
#undef uchar
#define uchar unsigned char /* assuming == 8 bits */
#undef uint
#define uint unsigned int /* assuming >= 16 bits */
#undef uptr
#define uptr uintptr_t
/* Forward declaration */
static void* _PyMem_DebugRawMalloc(void *ctx, size_t size);
static void* _PyMem_DebugRawCalloc(void *ctx, size_t nelem, size_t elsize);
@ -746,7 +736,7 @@ static int running_on_valgrind = -1;
#define SIMPLELOCK_UNLOCK(lock) /* release acquired lock */
/* When you say memory, my mind reasons in terms of (pointers to) blocks */
typedef uchar block;
typedef uint8_t block;
/* Pool for small blocks. */
struct pool_header {
@ -770,7 +760,7 @@ struct arena_object {
* here to mark an arena_object that doesn't correspond to an
* allocated arena.
*/
uptr address;
uinptr_t address;
/* Pool-aligned pointer to the next pool to be carved off. */
block* pool_address;
@ -921,7 +911,7 @@ on that C doesn't insert any padding anywhere in a pool_header at or before
the prevpool member.
**************************************************************************** */
#define PTA(x) ((poolp )((uchar *)&(usedpools[2*(x)]) - 2*sizeof(block *)))
#define PTA(x) ((poolp )((uint8_t *)&(usedpools[2*(x)]) - 2*sizeof(block *)))
#define PT(x) PTA(x), PTA(x)
static poolp usedpools[2 * ((NB_SMALL_SIZE_CLASSES + 7) / 8) * 8] = {
@ -1101,7 +1091,7 @@ new_arena(void)
unused_arena_objects = arenaobj;
return NULL;
}
arenaobj->address = (uptr)address;
arenaobj->address = (uinptr_t)address;
++narenas_currently_allocated;
++ntimes_arena_allocated;
@ -1208,7 +1198,7 @@ address_in_range(void *p, poolp pool)
// only once.
uint arenaindex = *((volatile uint *)&pool->arenaindex);
return arenaindex < maxarenas &&
(uptr)p - arenas[arenaindex].address < ARENA_SIZE &&
(uinptr_t)p - arenas[arenaindex].address < ARENA_SIZE &&
arenas[arenaindex].address != 0;
}
@ -1796,7 +1786,7 @@ bumpserialno(void)
static size_t
read_size_t(const void *p)
{
const uchar *q = (const uchar *)p;
const uint8_t *q = (const uint8_t *)p;
size_t result = *q++;
int i;
@ -1811,11 +1801,11 @@ read_size_t(const void *p)
static void
write_size_t(void *p, size_t n)
{
uchar *q = (uchar *)p + SST - 1;
uint8_t *q = (uint8_t *)p + SST - 1;
int i;
for (i = SST; --i >= 0; --q) {
*q = (uchar)(n & 0xff);
*q = (uint8_t)(n & 0xff);
n >>= 8;
}
}
@ -1850,8 +1840,8 @@ static void *
_PyMem_DebugRawAlloc(int use_calloc, void *ctx, size_t nbytes)
{
debug_alloc_api_t *api = (debug_alloc_api_t *)ctx;
uchar *p; /* base address of malloc'ed block */
uchar *tail; /* p + 2*SST + nbytes == pointer to tail pad bytes */
uint8_t *p; /* base address of malloc'ed block */
uint8_t *tail; /* p + 2*SST + nbytes == pointer to tail pad bytes */
size_t total; /* nbytes + 4*SST */
bumpserialno();
@ -1861,15 +1851,15 @@ _PyMem_DebugRawAlloc(int use_calloc, void *ctx, size_t nbytes)
return NULL;
if (use_calloc)
p = (uchar *)api->alloc.calloc(api->alloc.ctx, 1, total);
p = (uint8_t *)api->alloc.calloc(api->alloc.ctx, 1, total);
else
p = (uchar *)api->alloc.malloc(api->alloc.ctx, total);
p = (uint8_t *)api->alloc.malloc(api->alloc.ctx, total);
if (p == NULL)
return NULL;
/* at p, write size (SST bytes), id (1 byte), pad (SST-1 bytes) */
write_size_t(p, nbytes);
p[SST] = (uchar)api->api_id;
p[SST] = (uint8_t)api->api_id;
memset(p + SST + 1, FORBIDDENBYTE, SST-1);
if (nbytes > 0 && !use_calloc)
@ -1907,7 +1897,7 @@ static void
_PyMem_DebugRawFree(void *ctx, void *p)
{
debug_alloc_api_t *api = (debug_alloc_api_t *)ctx;
uchar *q = (uchar *)p - 2*SST; /* address returned from malloc */
uint8_t *q = (uint8_t *)p - 2*SST; /* address returned from malloc */
size_t nbytes;
if (p == NULL)
@ -1924,8 +1914,8 @@ static void *
_PyMem_DebugRawRealloc(void *ctx, void *p, size_t nbytes)
{
debug_alloc_api_t *api = (debug_alloc_api_t *)ctx;
uchar *q = (uchar *)p, *oldq;
uchar *tail;
uint8_t *q = (uint8_t *)p, *oldq;
uint8_t *tail;
size_t total; /* nbytes + 4*SST */
size_t original_nbytes;
int i;
@ -1946,7 +1936,7 @@ _PyMem_DebugRawRealloc(void *ctx, void *p, size_t nbytes)
* but we live with that.
*/
oldq = q;
q = (uchar *)api->alloc.realloc(api->alloc.ctx, q - 2*SST, total);
q = (uint8_t *)api->alloc.realloc(api->alloc.ctx, q - 2*SST, total);
if (q == NULL)
return NULL;
@ -1956,7 +1946,7 @@ _PyMem_DebugRawRealloc(void *ctx, void *p, size_t nbytes)
}
write_size_t(q, nbytes);
assert(q[SST] == (uchar)api->api_id);
assert(q[SST] == (uint8_t)api->api_id);
for (i = 1; i < SST; ++i)
assert(q[SST + i] == FORBIDDENBYTE);
q += 2*SST;
@ -2020,11 +2010,11 @@ _PyMem_DebugRealloc(void *ctx, void *ptr, size_t nbytes)
static void
_PyMem_DebugCheckAddress(char api, const void *p)
{
const uchar *q = (const uchar *)p;
const uint8_t *q = (const uint8_t *)p;
char msgbuf[64];
char *msg;
size_t nbytes;
const uchar *tail;
const uint8_t *tail;
int i;
char id;
@ -2073,8 +2063,8 @@ error:
static void
_PyObject_DebugDumpAddress(const void *p)
{
const uchar *q = (const uchar *)p;
const uchar *tail;
const uint8_t *q = (const uint8_t *)p;
const uint8_t *tail;
size_t nbytes, serial;
int i;
int ok;
@ -2107,7 +2097,7 @@ _PyObject_DebugDumpAddress(const void *p)
fprintf(stderr, "not all FORBIDDENBYTE (0x%02x):\n",
FORBIDDENBYTE);
for (i = SST-1; i >= 1; --i) {
const uchar byte = *(q-i);
const uint8_t byte = *(q-i);
fprintf(stderr, " at p-%d: 0x%02x", i, byte);
if (byte != FORBIDDENBYTE)
fputs(" *** OUCH", stderr);
@ -2135,7 +2125,7 @@ _PyObject_DebugDumpAddress(const void *p)
fprintf(stderr, "not all FORBIDDENBYTE (0x%02x):\n",
FORBIDDENBYTE);
for (i = 0; i < SST; ++i) {
const uchar byte = tail[i];
const uint8_t byte = tail[i];
fprintf(stderr, " at tail+%d: 0x%02x",
i, byte);
if (byte != FORBIDDENBYTE)
@ -2297,27 +2287,26 @@ _PyObject_DebugMallocStats(FILE *out)
*/
for (i = 0; i < maxarenas; ++i) {
uint j;
uptr base = arenas[i].address;
uinptr_t base = arenas[i].address;
/* Skip arenas which are not allocated. */
if (arenas[i].address == (uptr)NULL)
if (arenas[i].address == (uinptr_t)NULL)
continue;
narenas += 1;
numfreepools += arenas[i].nfreepools;
/* round up to pool alignment */
if (base & (uptr)POOL_SIZE_MASK) {
if (base & (uinptr_t)POOL_SIZE_MASK) {
arena_alignment += POOL_SIZE;
base &= ~(uptr)POOL_SIZE_MASK;
base &= ~(uinptr_t)POOL_SIZE_MASK;
base += POOL_SIZE;
}
/* visit every pool in the arena */
assert(base <= (uptr) arenas[i].pool_address);
for (j = 0;
base < (uptr) arenas[i].pool_address;
++j, base += POOL_SIZE) {
assert(base <= (uinptr_t) arenas[i].pool_address);
for (j = 0; base < (uinptr_t) arenas[i].pool_address;
++j, base += POOL_SIZE) {
poolp p = (poolp)base;
const uint sz = p->szidx;
uint freeblocks;

Write Preview
Loading…
Cancel
Save