zone.c File Reference

#include "darkplaces.h"
#include <unistd.h>

Include dependency graph for zone.c:

Go to the source code of this file.

Macros
#define	FILE_BACKED_MALLOC   0
#define	MEMCLUMPING   0
#define	MEMCLUMPING_FREECLUMPS   0
#define	MEMHEADER_SENTINEL_FOR_ADDRESS(p)

Functions
void *	_Mem_Alloc (mempool_t *pool, void *olddata, size_t size, size_t alignment, const char *filename, int fileline)
mempool_t *	_Mem_AllocPool (const char *name, unsigned flags, mempool_t *parent, const char *filename, int fileline)
void	_Mem_CheckSentinels (void *data, const char *filename, int fileline)
void	_Mem_CheckSentinelsGlobal (const char *filename, int fileline)
void	_Mem_EmptyPool (mempool_t *pool, const char *filename, int fileline)
void	_Mem_Free (void *data, const char *filename, int fileline)
static void	_Mem_FreeBlock (memheader_t *mem, const char *filename, int fileline)
void	_Mem_FreePool (mempool_t **poolpointer, const char *filename, int fileline)
char *	_Mem_strdup (mempool_t *pool, const char *s, const char *filename, int fileline)
static void *	attempt_malloc (size_t size)
static void *	Clump_AllocBlock (size_t size)
static void	Clump_FreeBlock (void *base, size_t size)
void *	Mem_ExpandableArray_AllocRecord (memexpandablearray_t *l)
void	Mem_ExpandableArray_FreeArray (memexpandablearray_t *l)
void	Mem_ExpandableArray_FreeRecord (memexpandablearray_t *l, void *record)
size_t	Mem_ExpandableArray_IndexRange (const memexpandablearray_t *l)
void	Mem_ExpandableArray_NewArray (memexpandablearray_t *l, mempool_t *mempool, size_t recordsize, int numrecordsperarray)
void *	Mem_ExpandableArray_RecordAtIndex (const memexpandablearray_t *l, size_t index)
qbool	Mem_IsAllocated (mempool_t *pool, const void *data)
void	Mem_PrintList (size_t minallocationsize)
void	Mem_PrintStats (void)
static void	MemList_f (cmd_state_t *cmd)
void	Memory_Init (void)
void	Memory_Init_Commands (void)
void	Memory_Shutdown (void)
static void	MemStats_f (cmd_state_t *cmd)

Variables
cvar_t	developer_memory = {CF_CLIENT | CF_SERVER, "developer_memory", "0", "prints debugging information about memory allocations"}
cvar_t	developer_memorydebug = {CF_CLIENT | CF_SERVER, "developer_memorydebug", "0", "enables memory corruption checks (very slow)"}
cvar_t	developer_memoryreportlargerthanmb = {CF_CLIENT | CF_SERVER, "developer_memorylargerthanmb", "16", "prints debugging information about memory allocations over this size"}
qbool	mem_bigendian = false
void *	mem_mutex = NULL
static mempool_t *	poolchain = NULL
unsigned int	sentinel_seed
cvar_t	sys_memsize_physical = {CF_CLIENT | CF_SERVER | CF_READONLY, "sys_memsize_physical", "", "physical memory size in MB (or empty if unknown)"}
cvar_t	sys_memsize_virtual = {CF_CLIENT | CF_SERVER | CF_READONLY, "sys_memsize_virtual", "", "virtual memory size in MB (or empty if unknown)"}
mempool_t *	tempmempool
mempool_t *	zonemempool

Macro Definition Documentation

FILE_BACKED_MALLOC

#define FILE_BACKED_MALLOC   0

Definition at line 39 of file zone.c.

MEMCLUMPING

#define MEMCLUMPING   0

Definition at line 44 of file zone.c.

MEMCLUMPING_FREECLUMPS

#define MEMCLUMPING_FREECLUMPS   0

Definition at line 47 of file zone.c.

MEMHEADER_SENTINEL_FOR_ADDRESS

#define MEMHEADER_SENTINEL_FOR_ADDRESS

(

p

)

Value:

((sentinel_seed ^ (unsigned int) (uintptr_t) (p)) + sentinel_seed)

Definition at line 31 of file zone.c.

Referenced by _Mem_Alloc(), _Mem_AllocPool(), _Mem_CheckSentinels(), _Mem_CheckSentinelsGlobal(), _Mem_EmptyPool(), _Mem_FreeBlock(), _Mem_FreePool(), Clump_AllocBlock(), and Clump_FreeBlock().

Function Documentation

_Mem_Alloc()

void * _Mem_Alloc	(	mempool_t *	pool,
		void *	olddata,
		size_t	size,
		size_t	alignment,
		const char *	filename,
		int	fileline )

Definition at line 369 of file zone.c.

{
    unsigned int sentinel1;
    unsigned int sentinel2;
    size_t realsize;
    size_t sharedsize;
    size_t remainsize;
    memheader_t *mem;
    memheader_t *oldmem;
    unsigned char *base;
 
    if (size <= 0)
    {
        if (olddata)
            _Mem_Free(olddata, filename, fileline);
        return NULL;
    }
    if (pool == NULL)
    {
        if(olddata)
            pool = ((memheader_t *)((unsigned char *) olddata - sizeof(memheader_t)))->pool;
        else
            Sys_Error("Mem_Alloc: pool == NULL (alloc at %s:%i)", filename, fileline);
    }
    if (mem_mutex)
        Thread_LockMutex(mem_mutex);
    if (developer_memory.integer || size >= developer_memoryreportlargerthanmb.value * 1048576)
        Con_DPrintf("Mem_Alloc: pool %s, file %s:%i, size %f bytes (%f MB)\n", pool->name, filename, fileline, (double)size, (double)size / 1048576.0f);
    //if (developer.integer > 0 && developer_memorydebug.integer)
    //  _Mem_CheckSentinelsGlobal(filename, fileline);
    pool->totalsize += size;
    realsize = alignment + sizeof(memheader_t) + size + sizeof(sentinel2);
    pool->realsize += realsize;
    base = (unsigned char *)Clump_AllocBlock(realsize);
    if (base == NULL)
    {
        Mem_PrintList(0);
        Mem_PrintStats();
        Mem_PrintList(1<<30);
        Mem_PrintStats();
        Sys_Error("Mem_Alloc: out of memory (alloc of size %f (%.3fMB) at %s:%i)", (double)realsize, (double)realsize / (1 << 20), filename, fileline);
    }
    // calculate address that aligns the end of the memheader_t to the specified alignment
    mem = (memheader_t*)((((size_t)base + sizeof(memheader_t) + (alignment-1)) & ~(alignment-1)) - sizeof(memheader_t));
    mem->baseaddress = (void*)base;
    mem->filename = filename;
    mem->fileline = fileline;
    mem->size = size;
    mem->pool = pool;
 
    // calculate sentinels (detects buffer overruns, in a way that is hard to exploit)
    sentinel1 = MEMHEADER_SENTINEL_FOR_ADDRESS(&mem->sentinel);
    sentinel2 = MEMHEADER_SENTINEL_FOR_ADDRESS((unsigned char *) mem + sizeof(memheader_t) + mem->size);
    mem->sentinel = sentinel1;
    memcpy((unsigned char *) mem + sizeof(memheader_t) + mem->size, &sentinel2, sizeof(sentinel2));
 
    // append to head of list
    List_Add(&mem->list, &pool->chain);
 
    if (mem_mutex)
        Thread_UnlockMutex(mem_mutex);
 
    // copy the shared portion in the case of a realloc, then memset the rest
    sharedsize = 0;
    remainsize = size;
    if (olddata)
    {
        oldmem = (memheader_t*)olddata - 1;
        sharedsize = min(oldmem->size, size);
        memcpy((void *)((unsigned char *) mem + sizeof(memheader_t)), olddata, sharedsize);
        remainsize -= sharedsize;
        _Mem_Free(olddata, filename, fileline);
    }
    memset((void *)((unsigned char *) mem + sizeof(memheader_t) + sharedsize), 0, remainsize);
    return (void *)((unsigned char *) mem + sizeof(memheader_t));
}

References _Mem_Free(), memheader_t::baseaddress, mempool_t::chain, Clump_AllocBlock(), Con_DPrintf(), developer_memory, developer_memoryreportlargerthanmb, memheader_t::fileline, memheader_t::filename, cvar_t::integer, memheader_t::list, List_Add(), mem_mutex, Mem_PrintList(), Mem_PrintStats(), MEMHEADER_SENTINEL_FOR_ADDRESS, min, mempool_t::name, NULL, olddata, memheader_t::pool, mempool_t::realsize, memheader_t::sentinel, memheader_t::size, size, Sys_Error(), Thread_LockMutex, Thread_UnlockMutex, mempool_t::totalsize, and cvar_t::value.

Referenced by _Mem_strdup().

_Mem_AllocPool()

mempool_t * _Mem_AllocPool	(	const char *	name,
		unsigned	flags,
		mempool_t *	parent,
		const char *	filename,
		int	fileline )

Definition at line 500 of file zone.c.

{
    mempool_t *pool;
    if (developer_memorydebug.integer)
        _Mem_CheckSentinelsGlobal(filename, fileline);
    pool = (mempool_t *)Clump_AllocBlock(sizeof(mempool_t));
    if (pool == NULL)
    {
        Mem_PrintList(0);
        Mem_PrintStats();
        Mem_PrintList(1<<30);
        Mem_PrintStats();
        Sys_Error("Mem_AllocPool: out of memory (allocpool at %s:%i)", filename, fileline);
    }
    memset(pool, 0, sizeof(mempool_t));
    pool->sentinel1 = MEMHEADER_SENTINEL_FOR_ADDRESS(&pool->sentinel1);
    pool->sentinel2 = MEMHEADER_SENTINEL_FOR_ADDRESS(&pool->sentinel2);
    pool->filename = filename;
    pool->fileline = fileline;
    pool->flags = flags;
    List_Create(&pool->chain);
    pool->totalsize = 0;
    pool->realsize = sizeof(mempool_t);
    dp_strlcpy (pool->name, name, sizeof (pool->name));
    pool->parent = parent;
    pool->next = poolchain;
    poolchain = pool;
    return pool;
}

References _Mem_CheckSentinelsGlobal(), mempool_t::chain, Clump_AllocBlock(), developer_memorydebug, dp_strlcpy, mempool_t::fileline, mempool_t::filename, flags, mempool_t::flags, cvar_t::integer, List_Create(), Mem_PrintList(), Mem_PrintStats(), MEMHEADER_SENTINEL_FOR_ADDRESS, mempool_t::name, name, mempool_t::next, NULL, mempool_t::parent, poolchain, mempool_t::realsize, mempool_t::sentinel1, mempool_t::sentinel2, Sys_Error(), and mempool_t::totalsize.

_Mem_CheckSentinels()

void _Mem_CheckSentinels	(	void *	data,
		const char *	filename,
		int	fileline )

Definition at line 599 of file zone.c.

{
    memheader_t *mem;
    unsigned int sentinel1;
    unsigned int sentinel2;
 
    if (data == NULL)
        Sys_Error("Mem_CheckSentinels: data == NULL (sentinel check at %s:%i)", filename, fileline);
 
    mem = (memheader_t *)((unsigned char *) data - sizeof(memheader_t));
    sentinel1 = MEMHEADER_SENTINEL_FOR_ADDRESS(&mem->sentinel);
    sentinel2 = MEMHEADER_SENTINEL_FOR_ADDRESS((unsigned char *) mem + sizeof(memheader_t) + mem->size);
    if (mem->sentinel != sentinel1)
        Sys_Error("Mem_Free: trashed head sentinel (alloc at %s:%i, sentinel check at %s:%i)", mem->filename, mem->fileline, filename, fileline);
    if (memcmp((unsigned char *) mem + sizeof(memheader_t) + mem->size, &sentinel2, sizeof(sentinel2)))
        Sys_Error("Mem_Free: trashed tail sentinel (alloc at %s:%i, sentinel check at %s:%i)", mem->filename, mem->fileline, filename, fileline);
}

References data, memheader_t::fileline, memheader_t::filename, MEMHEADER_SENTINEL_FOR_ADDRESS, NULL, memheader_t::sentinel, memheader_t::size, and Sys_Error().

Referenced by _Mem_CheckSentinelsGlobal().

_Mem_CheckSentinelsGlobal()

void _Mem_CheckSentinelsGlobal	(	const char *	filename,
		int	fileline )

Definition at line 628 of file zone.c.

{
    memheader_t *mem;
#if MEMCLUMPING
    memclump_t *clump;
#endif
    mempool_t *pool;
    for (pool = poolchain;pool;pool = pool->next)
    {
        if (pool->sentinel1 != MEMHEADER_SENTINEL_FOR_ADDRESS(&pool->sentinel1))
            Sys_Error("Mem_CheckSentinelsGlobal: trashed pool sentinel 1 (allocpool at %s:%i, sentinel check at %s:%i)", pool->filename, pool->fileline, filename, fileline);
        if (pool->sentinel2 != MEMHEADER_SENTINEL_FOR_ADDRESS(&pool->sentinel2))
            Sys_Error("Mem_CheckSentinelsGlobal: trashed pool sentinel 2 (allocpool at %s:%i, sentinel check at %s:%i)", pool->filename, pool->fileline, filename, fileline);
    }
    for (pool = poolchain;pool;pool = pool->next)
        List_For_Each_Entry(mem, &pool->chain, memheader_t, list)
            _Mem_CheckSentinels((void *)((unsigned char *) mem + sizeof(memheader_t)), filename, fileline);
#if MEMCLUMPING
    for (pool = poolchain;pool;pool = pool->next)
        for (clump = clumpchain;clump;clump = clump->chain)
            _Mem_CheckClumpSentinels(clump, filename, fileline);
#endif
}

References _Mem_CheckSentinels(), mempool_t::chain, mempool_t::fileline, mempool_t::filename, List_For_Each_Entry, MEMHEADER_SENTINEL_FOR_ADDRESS, mempool_t::next, poolchain, mempool_t::sentinel1, mempool_t::sentinel2, and Sys_Error().

Referenced by _Mem_AllocPool(), and _Mem_FreePool().

_Mem_EmptyPool()

void _Mem_EmptyPool	(	mempool_t *	pool,
		const char *	filename,
		int	fileline )

Definition at line 567 of file zone.c.

{
    mempool_t *chainaddress;
 
    if (developer_memorydebug.integer)
    {
        //_Mem_CheckSentinelsGlobal(filename, fileline);
        // check if this pool is in the poolchain
        for (chainaddress = poolchain;chainaddress;chainaddress = chainaddress->next)
            if (chainaddress == pool)
                break;
        if (!chainaddress)
            Sys_Error("Mem_EmptyPool: pool is already free (emptypool at %s:%i)", filename, fileline);
    }
    if (pool == NULL)
        Sys_Error("Mem_EmptyPool: pool == NULL (emptypool at %s:%i)", filename, fileline);
    if (pool->sentinel1 != MEMHEADER_SENTINEL_FOR_ADDRESS(&pool->sentinel1))
        Sys_Error("Mem_EmptyPool: trashed pool sentinel 1 (allocpool at %s:%i, emptypool at %s:%i)", pool->filename, pool->fileline, filename, fileline);
    if (pool->sentinel2 != MEMHEADER_SENTINEL_FOR_ADDRESS(&pool->sentinel2))
        Sys_Error("Mem_EmptyPool: trashed pool sentinel 2 (allocpool at %s:%i, emptypool at %s:%i)", pool->filename, pool->fileline, filename, fileline);
 
    // free memory owned by the pool
    while (!List_Is_Empty(&pool->chain))
        _Mem_FreeBlock(List_First_Entry(&pool->chain, memheader_t, list), filename, fileline);
 
    // empty child pools, too
    for(chainaddress = poolchain; chainaddress; chainaddress = chainaddress->next)
        if(chainaddress->parent == pool)
            _Mem_EmptyPool(chainaddress, filename, fileline);
 
}

References _Mem_EmptyPool(), _Mem_FreeBlock(), mempool_t::chain, developer_memorydebug, mempool_t::fileline, mempool_t::filename, cvar_t::integer, List_First_Entry, List_Is_Empty(), MEMHEADER_SENTINEL_FOR_ADDRESS, mempool_t::next, NULL, mempool_t::parent, poolchain, mempool_t::sentinel1, mempool_t::sentinel2, and Sys_Error().

Referenced by _Mem_EmptyPool().

_Mem_Free()

void _Mem_Free	(	void *	data,
		const char *	filename,
		int	fileline )

Definition at line 482 of file zone.c.

{
    if (data == NULL)
    {
        Con_DPrintf("Mem_Free: data == NULL (called at %s:%i)\n", filename, fileline);
        return;
    }
 
    if (developer_memorydebug.integer)
    {
        //_Mem_CheckSentinelsGlobal(filename, fileline);
        if (!Mem_IsAllocated(NULL, data))
            Sys_Error("Mem_Free: data is not allocated (called at %s:%i)", filename, fileline);
    }
 
    _Mem_FreeBlock((memheader_t *)((unsigned char *) data - sizeof(memheader_t)), filename, fileline);
}

References _Mem_FreeBlock(), Con_DPrintf(), data, developer_memorydebug, cvar_t::integer, Mem_IsAllocated(), NULL, and Sys_Error().

Referenced by _Mem_Alloc().

_Mem_FreeBlock()

static void _Mem_FreeBlock ( memheader_t * mem, const char * filename, int fileline )

static

Definition at line 447 of file zone.c.

{
    mempool_t *pool;
    size_t size;
    size_t realsize;
    unsigned int sentinel1;
    unsigned int sentinel2;
 
    // check sentinels (detects buffer overruns, in a way that is hard to exploit)
    sentinel1 = MEMHEADER_SENTINEL_FOR_ADDRESS(&mem->sentinel);
    sentinel2 = MEMHEADER_SENTINEL_FOR_ADDRESS((unsigned char *) mem + sizeof(memheader_t) + mem->size);
    if (mem->sentinel != sentinel1)
        Sys_Error("Mem_Free: trashed head sentinel (alloc at %s:%i, free at %s:%i)", mem->filename, mem->fileline, filename, fileline);
    if (memcmp((unsigned char *) mem + sizeof(memheader_t) + mem->size, &sentinel2, sizeof(sentinel2)))
        Sys_Error("Mem_Free: trashed tail sentinel (alloc at %s:%i, free at %s:%i)", mem->filename, mem->fileline, filename, fileline);
 
    pool = mem->pool;
    if (developer_memory.integer)
        Con_DPrintf("Mem_Free: pool %s, alloc %s:%i, free %s:%i, size %i bytes\n", pool->name, mem->filename, mem->fileline, filename, fileline, (int)(mem->size));
    // unlink memheader from doubly linked list
    if (mem->list.prev->next != &mem->list || mem->list.next->prev != &mem->list)
        Sys_Error("Mem_Free: not allocated or double freed (free at %s:%i)", filename, fileline);
    if (mem_mutex)
        Thread_LockMutex(mem_mutex);
    List_Delete(&mem->list);
    // memheader has been unlinked, do the actual free now
    size = mem->size;
    realsize = sizeof(memheader_t) + size + sizeof(sentinel2);
    pool->totalsize -= size;
    pool->realsize -= realsize;
    Clump_FreeBlock(mem->baseaddress, realsize);
    if (mem_mutex)
        Thread_UnlockMutex(mem_mutex);
}

References memheader_t::baseaddress, Clump_FreeBlock(), Con_DPrintf(), developer_memory, memheader_t::fileline, memheader_t::filename, cvar_t::integer, memheader_t::list, List_Delete(), mem_mutex, MEMHEADER_SENTINEL_FOR_ADDRESS, mempool_t::name, memheader_t::pool, mempool_t::realsize, memheader_t::sentinel, memheader_t::size, size, Sys_Error(), Thread_LockMutex, Thread_UnlockMutex, and mempool_t::totalsize.

Referenced by _Mem_EmptyPool(), _Mem_Free(), and _Mem_FreePool().

_Mem_FreePool()

void _Mem_FreePool	(	mempool_t **	poolpointer,
		const char *	filename,
		int	fileline )

Definition at line 530 of file zone.c.

{
    mempool_t *pool = *poolpointer;
    mempool_t **chainaddress, *iter, *temp;
 
    if (developer_memorydebug.integer)
        _Mem_CheckSentinelsGlobal(filename, fileline);
    if (pool)
    {
        // unlink pool from chain
        for (chainaddress = &poolchain;*chainaddress && *chainaddress != pool;chainaddress = &((*chainaddress)->next));
        if (*chainaddress != pool)
            Sys_Error("Mem_FreePool: pool already free (freepool at %s:%i)", filename, fileline);
        if (pool->sentinel1 != MEMHEADER_SENTINEL_FOR_ADDRESS(&pool->sentinel1))
            Sys_Error("Mem_FreePool: trashed pool sentinel 1 (allocpool at %s:%i, freepool at %s:%i)", pool->filename, pool->fileline, filename, fileline);
        if (pool->sentinel2 != MEMHEADER_SENTINEL_FOR_ADDRESS(&pool->sentinel2))
            Sys_Error("Mem_FreePool: trashed pool sentinel 2 (allocpool at %s:%i, freepool at %s:%i)", pool->filename, pool->fileline, filename, fileline);
        *chainaddress = pool->next;
 
        // free memory owned by the pool
        while (!List_Is_Empty(&pool->chain))
            _Mem_FreeBlock(List_First_Entry(&pool->chain, memheader_t, list), filename, fileline);
 
        // free child pools, too
        for(iter = poolchain; iter; iter = temp) {
            temp = iter->next;
            if(iter->parent == pool)
                _Mem_FreePool(&temp, filename, fileline);
        }
 
        // free the pool itself
        Clump_FreeBlock(pool, sizeof(*pool));
 
        *poolpointer = NULL;
    }
}

References _Mem_CheckSentinelsGlobal(), _Mem_FreeBlock(), _Mem_FreePool(), mempool_t::chain, Clump_FreeBlock(), developer_memorydebug, mempool_t::fileline, mempool_t::filename, cvar_t::integer, List_First_Entry, List_Is_Empty(), MEMHEADER_SENTINEL_FOR_ADDRESS, mempool_t::next, NULL, mempool_t::parent, poolchain, mempool_t::sentinel1, mempool_t::sentinel2, and Sys_Error().

Referenced by _Mem_FreePool().

_Mem_strdup()

char * _Mem_strdup	(	mempool_t *	pool,
		const char *	s,
		const char *	filename,
		int	fileline )

Definition at line 865 of file zone.c.

{
    char* p;
    size_t sz;
    if (s == NULL)
        return NULL;
    sz = strlen (s) + 1;
    p = (char*)_Mem_Alloc (pool, NULL, sz, alignof(char), filename, fileline);
    dp_strlcpy (p, s, sz);
    return p;
}

References _Mem_Alloc(), dp_strlcpy, NULL, and strlen().

attempt_malloc()

static void * attempt_malloc ( size_t size )

static

Definition at line 147 of file zone.c.

{
#ifndef WIN32
    return malloc(size);
#else
    void *base;
    // try for half a second or so
    unsigned int attempts = 500;
    while (attempts--)
    {
        base = (void *)malloc(size);
        if (base)
            return base;
        Sys_Sleep(1000);
    }
    return NULL;
#endif
}

References NULL, size, and Sys_Sleep().

Referenced by Clump_AllocBlock().

Clump_AllocBlock()

static void * Clump_AllocBlock ( size_t size )

static

Definition at line 202 of file zone.c.

{
    unsigned char *base;
#if MEMCLUMPING
    if (size <= MEMCLUMPSIZE)
    {
        intptr_t index;
        size_t bit;
        size_t needbits;
        size_t startbit;
        size_t endbit;
        size_t needints;
        intptr_t startindex;
        intptr_t endindex;
        unsigned int value;
        unsigned int mask;
        unsigned int *array;
        memclump_t **clumpchainpointer;
        memclump_t *clump;
        needbits = (size + MEMUNIT - 1) / MEMUNIT;
        needints = (needbits+31)>>5;
        for (clumpchainpointer = &clumpchain;;clumpchainpointer = &(*clumpchainpointer)->chain)
        {
            clump = *clumpchainpointer;
            if (!clump)
            {
                clump = Clump_NewClump();
                if (!clump)
                    return NULL;
            }
            if (clump->sentinel1 != MEMHEADER_SENTINEL_FOR_ADDRESS(&clump->sentinel1))
                Sys_Error("Clump_AllocBlock: trashed sentinel1\n");
            if (clump->sentinel2 != MEMHEADER_SENTINEL_FOR_ADDRESS(&clump->sentinel2))
                Sys_Error("Clump_AllocBlock: trashed sentinel2\n");
            startbit = 0;
            endbit = startbit + needbits;
            array = clump->bits;
            // do as fast a search as possible, even if it means crude alignment
            if (needbits >= 32)
            {
                // large allocations are aligned to large boundaries
                // furthermore, they are allocated downward from the top...
                endindex = MEMBITINTS;
                startindex = endindex - needints;
                index = endindex;
                while (--index >= startindex)
                {
                    if (array[index])
                    {
                        endindex = index;
                        startindex = endindex - needints;
                        if (startindex < 0)
                            goto nofreeblock;
                    }
                }
                startbit = startindex*32;
                goto foundblock;
            }
            else
            {
                // search for a multi-bit gap in a single int
                // (not dealing with the cases that cross two ints)
                mask = (1<<needbits)-1;
                endbit = 32-needbits;
                bit = endbit;
                for (index = 0;index < MEMBITINTS;index++)
                {
                    value = array[index];
                    if (value != 0xFFFFFFFFu)
                    {
                        // there may be room in this one...
                        for (bit = 0;bit < endbit;bit++)
                        {
                            if (!(value & (mask<<bit)))
                            {
                                startbit = index*32+bit;
                                goto foundblock;
                            }
                        }
                    }
                }
                goto nofreeblock;
            }
foundblock:
            endbit = startbit + needbits;
            // mark this range as used
            // TODO: optimize
            for (bit = startbit;bit < endbit;bit++)
                if (clump->bits[bit>>5] & (1<<(bit & 31)))
                    Sys_Error("Clump_AllocBlock: internal error (%i needbits)\n", needbits);
            for (bit = startbit;bit < endbit;bit++)
                clump->bits[bit>>5] |= (1<<(bit & 31));
            clump->blocksinuse += needbits;
            base = clump->block + startbit * MEMUNIT;
            if (developer_memorydebug.integer)
                memset(base, 0xBF, needbits * MEMUNIT);
            return base;
nofreeblock:
            ;
        }
        // never reached
        return NULL;
    }
    // too big, allocate it directly
#endif
#if MEMCLUMPING == 2
    return NULL;
#else
    base = (unsigned char *)attempt_malloc(size);
    if (base && developer_memorydebug.integer)
        memset(base, 0xAF, size);
    return base;
#endif
}

References attempt_malloc(), developer_memorydebug, index, cvar_t::integer, mask, MEMHEADER_SENTINEL_FOR_ADDRESS, NULL, size, Sys_Error(), and value.

Referenced by _Mem_Alloc(), and _Mem_AllocPool().

Clump_FreeBlock()

static void Clump_FreeBlock ( void * base, size_t size )

static

Definition at line 316 of file zone.c.

{
#if MEMCLUMPING
    size_t needbits;
    size_t startbit;
    size_t endbit;
    size_t bit;
    memclump_t **clumpchainpointer;
    memclump_t *clump;
    unsigned char *start = (unsigned char *)base;
    for (clumpchainpointer = &clumpchain;(clump = *clumpchainpointer);clumpchainpointer = &(*clumpchainpointer)->chain)
    {
        if (start >= clump->block && start < clump->block + MEMCLUMPSIZE)
        {
            if (clump->sentinel1 != MEMHEADER_SENTINEL_FOR_ADDRESS(&clump->sentinel1))
                Sys_Error("Clump_FreeBlock: trashed sentinel1\n");
            if (clump->sentinel2 != MEMHEADER_SENTINEL_FOR_ADDRESS(&clump->sentinel2))
                Sys_Error("Clump_FreeBlock: trashed sentinel2\n");
            if (start + size > clump->block + MEMCLUMPSIZE)
                Sys_Error("Clump_FreeBlock: block overrun\n");
            // the block belongs to this clump, clear the range
            needbits = (size + MEMUNIT - 1) / MEMUNIT;
            startbit = (start - clump->block) / MEMUNIT;
            endbit = startbit + needbits;
            // first verify all bits are set, otherwise this may be misaligned or a double free
            for (bit = startbit;bit < endbit;bit++)
                if ((clump->bits[bit>>5] & (1<<(bit & 31))) == 0)
                    Sys_Error("Clump_FreeBlock: double free\n");
            for (bit = startbit;bit < endbit;bit++)
                clump->bits[bit>>5] &= ~(1<<(bit & 31));
            clump->blocksinuse -= needbits;
            memset(base, 0xFF, needbits * MEMUNIT);
            // if all has been freed, free the clump itself
            if (clump->blocksinuse == 0)
            {
                *clumpchainpointer = clump->chain;
                if (developer_memorydebug.integer)
                    memset(clump, 0xFF, sizeof(*clump));
#if MEMCLUMPING != 2
                free(clump);
#endif
            }
            return;
        }
    }
    // does not belong to any known chunk...  assume it was a direct allocation
#endif
#if MEMCLUMPING != 2
    memset(base, 0xFF, size);
    free(base);
#endif
}

References developer_memorydebug, cvar_t::integer, MEMHEADER_SENTINEL_FOR_ADDRESS, size, and Sys_Error().

Referenced by _Mem_FreeBlock(), and _Mem_FreePool().

Mem_ExpandableArray_AllocRecord()

void * Mem_ExpandableArray_AllocRecord

(

memexpandablearray_t *

l

)

Definition at line 695 of file zone.c.

{
    size_t i, j;
    for (i = 0;;i++)
    {
        if (i == l->numarrays)
        {
            if (l->numarrays == l->maxarrays)
            {
                memexpandablearray_array_t *oldarrays = l->arrays;
                l->maxarrays = max(l->maxarrays * 2, 128);
                l->arrays = (memexpandablearray_array_t*) Mem_Alloc(l->mempool, l->maxarrays * sizeof(*l->arrays));
                if (oldarrays)
                {
                    memcpy(l->arrays, oldarrays, l->numarrays * sizeof(*l->arrays));
                    Mem_Free(oldarrays);
                }
            }
            l->arrays[i].numflaggedrecords = 0;
            l->arrays[i].data = (unsigned char *) Mem_Alloc(l->mempool, (l->recordsize + 1) * l->numrecordsperarray);
            l->arrays[i].allocflags = l->arrays[i].data + l->recordsize * l->numrecordsperarray;
            l->numarrays++;
        }
        if (l->arrays[i].numflaggedrecords < l->numrecordsperarray)
        {
            for (j = 0;j < l->numrecordsperarray;j++)
            {
                if (!l->arrays[i].allocflags[j])
                {
                    l->arrays[i].allocflags[j] = true;
                    l->arrays[i].numflaggedrecords++;
                    memset(l->arrays[i].data + l->recordsize * j, 0, l->recordsize);
                    return (void *)(l->arrays[i].data + l->recordsize * j);
                }
            }
        }
    }
}

References memexpandablearray_array_t::allocflags, memexpandablearray_t::arrays, memexpandablearray_array_t::data, i, max, memexpandablearray_t::maxarrays, Mem_Alloc, Mem_Free, memexpandablearray_t::mempool, memexpandablearray_t::numarrays, memexpandablearray_array_t::numflaggedrecords, memexpandablearray_t::numrecordsperarray, and memexpandablearray_t::recordsize.

Referenced by BufStr_FindCreateReplace(), Mod_BSP_RecursiveNodePortals(), Mod_FindName(), Mod_LoadQ3Shaders(), Q3Shader_AddToHash(), R_GLSL_FindPermutation(), R_LoadTextureDDSFile(), R_LoadTextureRenderBuffer(), R_Mesh_CreateMeshBuffer(), R_RenderTarget_Get(), R_SetupTexture(), R_Shadow_NewWorldLight(), R_SkinFrame_Find(), VM_buf_create(), and W_LoadTextureWadFile().

Mem_ExpandableArray_FreeArray()

void Mem_ExpandableArray_FreeArray

(

memexpandablearray_t *

l

)

Definition at line 683 of file zone.c.

{
    size_t i;
    if (l->maxarrays)
    {
        for (i = 0;i != l->numarrays;i++)
            Mem_Free(l->arrays[i].data);
        Mem_Free(l->arrays);
    }
    memset(l, 0, sizeof(*l));
}

References memexpandablearray_t::arrays, memexpandablearray_array_t::data, i, memexpandablearray_t::maxarrays, Mem_Free, and memexpandablearray_t::numarrays.

Referenced by gl_backend_shutdown(), gl_main_shutdown(), Mod_BSP_MakePortals(), r_textures_shutdown(), and W_UnloadAll().

Mem_ExpandableArray_FreeRecord()

void Mem_ExpandableArray_FreeRecord	(	memexpandablearray_t *	l,
		void *	record )

Definition at line 743 of file zone.c.

{
    size_t i, j;
    unsigned char *p = (unsigned char *)record;
    for (i = 0;i != l->numarrays;i++)
    {
        if (p >= l->arrays[i].data && p < (l->arrays[i].data + l->recordsize * l->numrecordsperarray))
        {
            j = (p - l->arrays[i].data) / l->recordsize;
            if (p != l->arrays[i].data + j * l->recordsize)
                Sys_Error("Mem_ExpandableArray_FreeRecord: no such record %p\n", (void *)p);
            if (!l->arrays[i].allocflags[j])
                Sys_Error("Mem_ExpandableArray_FreeRecord: record %p is already free!\n", (void *)p);
            l->arrays[i].allocflags[j] = false;
            l->arrays[i].numflaggedrecords--;
            return;
        }
    }
}

References memexpandablearray_array_t::allocflags, memexpandablearray_t::arrays, memexpandablearray_array_t::data, i, memexpandablearray_t::numarrays, memexpandablearray_array_t::numflaggedrecords, memexpandablearray_t::numrecordsperarray, memexpandablearray_t::recordsize, and Sys_Error().

Referenced by BufStr_Del(), Mod_PurgeUnused(), R_FreeTexture(), R_GLSL_Restart_f(), R_Mesh_DestroyMeshBuffer(), R_RenderTarget_FreeUnused(), and R_Shadow_FreeWorldLight().

Mem_ExpandableArray_IndexRange()

size_t Mem_ExpandableArray_IndexRange

(

const memexpandablearray_t *

l

)

Definition at line 763 of file zone.c.

{
    size_t i, j, k, end = 0;
    for (i = 0;i < l->numarrays;i++)
    {
        for (j = 0, k = 0;k < l->arrays[i].numflaggedrecords;j++)
        {
            if (l->arrays[i].allocflags[j])
            {
                end = l->numrecordsperarray * i + j + 1;
                k++;
            }
        }
    }
    return end;
}

References memexpandablearray_array_t::allocflags, memexpandablearray_t::arrays, i, memexpandablearray_t::numarrays, memexpandablearray_array_t::numflaggedrecords, and memexpandablearray_t::numrecordsperarray.

Referenced by BufStr_FindCreateReplace(), BufStr_Flush(), gl_backend_devicelost(), GL_Mesh_ListVBOs(), Mod_BSP_FinalizePortals(), Mod_ClearUsed(), Mod_FindName(), mod_newmap(), Mod_Print_f(), Mod_PurgeUnused(), Mod_Reload(), mod_shutdown(), mod_start(), PRVM_LeakTest(), R_CompleteLightPoint(), R_GLSL_Restart_f(), R_RenderTarget_FreeUnused(), R_RenderTarget_Get(), R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_BounceGrid_CheckEnable(), R_Shadow_BounceGrid_UpdateSpacing(), R_Shadow_ClearWorldLights(), R_Shadow_DrawCoronas(), R_Shadow_DrawLightSprites(), R_Shadow_EditLights_DrawSelectedLightProperties(), R_Shadow_EditLights_EditAll_f(), R_Shadow_EditLights_Reload_f(), R_Shadow_GetRTLightInfo(), R_Shadow_PrepareLights(), R_Shadow_SaveWorldLights(), R_Shadow_SelectLightInView(), R_Shadow_UncompileWorldLights(), r_textures_devicelost(), r_textures_devicerestored(), SV_Loadgame_f(), SV_Savegame_to(), W_GetTextureBGRA(), and W_UnloadAll().

Mem_ExpandableArray_NewArray()

void Mem_ExpandableArray_NewArray	(	memexpandablearray_t *	l,
		mempool_t *	mempool,
		size_t	recordsize,
		int	numrecordsperarray )

Definition at line 675 of file zone.c.

{
    memset(l, 0, sizeof(*l));
    l->mempool = mempool;
    l->recordsize = recordsize;
    l->numrecordsperarray = numrecordsperarray;
}

References memexpandablearray_t::mempool, memexpandablearray_t::numrecordsperarray, and memexpandablearray_t::recordsize.

Referenced by BufStr_Flush(), gl_backend_start(), gl_main_start(), Mod_BSP_MakePortals(), Mod_Init(), Mod_LoadQ3Shaders(), PRVM_Prog_Load(), R_Shadow_Init(), r_textures_start(), W_GetTextureBGRA(), and W_LoadTextureWadFile().

Mem_ExpandableArray_RecordAtIndex()

void * Mem_ExpandableArray_RecordAtIndex	(	const memexpandablearray_t *	l,
		size_t	index )

Definition at line 780 of file zone.c.

{
    size_t i, j;
    i = index / l->numrecordsperarray;
    j = index % l->numrecordsperarray;
    if (i >= l->numarrays || !l->arrays[i].allocflags[j])
        return NULL;
    return (void *)(l->arrays[i].data + j * l->recordsize);
}

References memexpandablearray_array_t::allocflags, memexpandablearray_t::arrays, memexpandablearray_array_t::data, i, index, NULL, memexpandablearray_t::numarrays, memexpandablearray_t::numrecordsperarray, and memexpandablearray_t::recordsize.

Referenced by BufStr_FindCreateReplace(), BufStr_Flush(), gl_backend_devicelost(), GL_Mesh_ListVBOs(), Mod_BSP_FinalizePortals(), Mod_ClearUsed(), Mod_FindName(), mod_newmap(), Mod_Print_f(), Mod_PurgeUnused(), Mod_Reload(), mod_shutdown(), mod_start(), PRVM_LeakTest(), R_BlendView(), R_CompleteLightPoint(), R_GLSL_Restart_f(), R_RenderTarget_FreeUnused(), R_RenderTarget_Get(), R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_BounceGrid_CheckEnable(), R_Shadow_BounceGrid_UpdateSpacing(), R_Shadow_ClearWorldLights(), R_Shadow_DrawCoronas(), R_Shadow_DrawLightSprites(), R_Shadow_EditLights_DrawSelectedLightProperties(), R_Shadow_EditLights_EditAll_f(), R_Shadow_GetRTLightInfo(), R_Shadow_PrepareLights(), R_Shadow_SaveWorldLights(), R_Shadow_SelectLightInView(), R_Shadow_UncompileWorldLights(), r_textures_devicelost(), r_textures_devicerestored(), SV_Loadgame_f(), SV_Savegame_to(), VM_buf_copy(), VM_buf_create(), VM_buf_cvarlist(), VM_buf_del(), VM_buf_getsize(), VM_buf_implode(), VM_buf_loadfile(), VM_buf_sort(), VM_buf_writefile(), VM_bufstr_add(), VM_bufstr_find(), VM_bufstr_free(), VM_bufstr_get(), VM_bufstr_set(), VM_uri_get(), W_GetTextureBGRA(), and W_UnloadAll().

Mem_IsAllocated()

qbool Mem_IsAllocated	(	mempool_t *	pool,
		const void *	data )

Definition at line 652 of file zone.c.

{
    memheader_t *header;
    memheader_t *target;
 
    if (pool)
    {
        // search only one pool
        target = (memheader_t *)((unsigned char *) data - sizeof(memheader_t));
        List_For_Each_Entry(header, &pool->chain, memheader_t, list)
            if( header == target )
                return true;
    }
    else
    {
        // search all pools
        for (pool = poolchain;pool;pool = pool->next)
            if (Mem_IsAllocated(pool, data))
                return true;
    }
    return false;
}

References mempool_t::chain, data, List_For_Each_Entry, Mem_IsAllocated(), mempool_t::next, poolchain, and target.

Referenced by _Mem_Free(), and Mem_IsAllocated().

Mem_PrintList()

void Mem_PrintList

(

size_t

minallocationsize

)

Definition at line 823 of file zone.c.

{
    mempool_t *pool;
    memheader_t *mem;
    Mem_CheckSentinelsGlobal();
    Con_Print("memory pool list:\n"
               "size    name\n");
    for (pool = poolchain;pool;pool = pool->next)
    {
        Con_Printf("%10luk (%10luk actual) %s (%+li byte change) %s\n", (unsigned long) ((pool->totalsize + 1023) / 1024), (unsigned long)((pool->realsize + 1023) / 1024), pool->name, (long)(pool->totalsize - pool->lastchecksize), (pool->flags & POOLFLAG_TEMP) ? "TEMP" : "");
        pool->lastchecksize = pool->totalsize;
        List_For_Each_Entry(mem, &pool->chain, memheader_t, list)
            if (mem->size >= minallocationsize)
                Con_Printf("%10lu bytes allocated at %s:%i\n", (unsigned long)mem->size, mem->filename, mem->fileline);
    }
}

References mempool_t::chain, Con_Print(), Con_Printf(), memheader_t::fileline, memheader_t::filename, mempool_t::flags, mempool_t::lastchecksize, List_For_Each_Entry, Mem_CheckSentinelsGlobal, mempool_t::name, mempool_t::next, poolchain, POOLFLAG_TEMP, mempool_t::realsize, memheader_t::size, and mempool_t::totalsize.

Referenced by _Mem_Alloc(), _Mem_AllocPool(), and MemList_f().

Mem_PrintStats()

void Mem_PrintStats

(

void

)

Definition at line 798 of file zone.c.

{
    size_t count = 0, size = 0, realsize = 0;
    mempool_t *pool;
    memheader_t *mem;
    Mem_CheckSentinelsGlobal();
    for (pool = poolchain;pool;pool = pool->next)
    {
        count++;
        size += pool->totalsize;
        realsize += pool->realsize;
    }
    Con_Printf("%lu memory pools, totalling %lu bytes (%.3fMB)\n", (unsigned long)count, (unsigned long)size, size / 1048576.0);
    Con_Printf("total allocated size: %lu bytes (%.3fMB)\n", (unsigned long)realsize, realsize / 1048576.0);
    for (pool = poolchain;pool;pool = pool->next)
    {
        if ((pool->flags & POOLFLAG_TEMP) && !List_Is_Empty(&pool->chain))
        {
            Con_Printf(CON_WARN "Memory pool %p has sprung a leak totalling %lu bytes (%.3fMB)!  Listing contents...\n", (void *)pool, (unsigned long)pool->totalsize, pool->totalsize / 1048576.0);
            List_For_Each_Entry(mem, &pool->chain, memheader_t, list)
                Con_Printf("%10lu bytes allocated at %s:%i\n", (unsigned long)mem->size, mem->filename, mem->fileline);
        }
    }
}

References mempool_t::chain, Con_Printf(), CON_WARN, count, memheader_t::fileline, memheader_t::filename, mempool_t::flags, List_For_Each_Entry, List_Is_Empty(), Mem_CheckSentinelsGlobal, mempool_t::next, poolchain, POOLFLAG_TEMP, mempool_t::realsize, memheader_t::size, size, and mempool_t::totalsize.

Referenced by _Mem_Alloc(), _Mem_AllocPool(), MemList_f(), and MemStats_f().

MemList_f()

static void MemList_f ( cmd_state_t * cmd )

static

Definition at line 840 of file zone.c.

{
    switch(Cmd_Argc(cmd))
    {
    case 1:
        Mem_PrintList(1<<30);
        Mem_PrintStats();
        break;
    case 2:
        Mem_PrintList(atoi(Cmd_Argv(cmd, 1)) * 1024);
        Mem_PrintStats();
        break;
    default:
        Con_Print("MemList_f: unrecognized options\nusage: memlist [all]\n");
        break;
    }
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Mem_PrintList(), and Mem_PrintStats().

Referenced by Memory_Init_Commands().

Memory_Init()

void Memory_Init

(

void

)

Definition at line 882 of file zone.c.

{
    static union {unsigned short s;unsigned char b[2];} u;
    u.s = 0x100;
    mem_bigendian = u.b[0] != 0;
 
    sentinel_seed = rand();
    poolchain = NULL;
    tempmempool = Mem_AllocPool("Temporary Memory", POOLFLAG_TEMP, NULL);
    zonemempool = Mem_AllocPool("Zone", 0, NULL);
 
    if (Thread_HasThreads())
        mem_mutex = Thread_CreateMutex();
}

References b, Mem_AllocPool, mem_bigendian, mem_mutex, NULL, poolchain, POOLFLAG_TEMP, sentinel_seed, tempmempool, Thread_CreateMutex, Thread_HasThreads(), and zonemempool.

Referenced by Host_Init().

Memory_Init_Commands()

void Memory_Init_Commands

(

void

)

Definition at line 907 of file zone.c.

{
    Cmd_AddCommand(CF_SHARED, "memstats", MemStats_f, "prints memory system statistics");
    Cmd_AddCommand(CF_SHARED, "memlist", MemList_f, "prints memory pool information (or if used as memlist 5 lists individual allocations of 5K or larger, 0 lists all allocations)");
 
    Cvar_RegisterVariable (&developer_memory);
    Cvar_RegisterVariable (&developer_memorydebug);
    Cvar_RegisterVariable (&developer_memoryreportlargerthanmb);
    Cvar_RegisterVariable (&sys_memsize_physical);
    Cvar_RegisterVariable (&sys_memsize_virtual);
 
#if defined(WIN32)
#ifdef _WIN64
    {
        MEMORYSTATUSEX status;
        // first guess
        Cvar_SetValueQuick(&sys_memsize_virtual, 8388608);
        // then improve
        status.dwLength = sizeof(status);
        if(GlobalMemoryStatusEx(&status))
        {
            Cvar_SetValueQuick(&sys_memsize_physical, status.ullTotalPhys / 1048576.0);
            Cvar_SetValueQuick(&sys_memsize_virtual, min(sys_memsize_virtual.value, status.ullTotalVirtual / 1048576.0));
        }
    }
#else
    {
        MEMORYSTATUS status;
        // first guess
        Cvar_SetValueQuick(&sys_memsize_virtual, 2048);
        // then improve
        status.dwLength = sizeof(status);
        GlobalMemoryStatus(&status);
        Cvar_SetValueQuick(&sys_memsize_physical, status.dwTotalPhys / 1048576.0);
        Cvar_SetValueQuick(&sys_memsize_virtual, min(sys_memsize_virtual.value, status.dwTotalVirtual / 1048576.0));
    }
#endif
#else
    {
        // first guess
        Cvar_SetValueQuick(&sys_memsize_virtual, (sizeof(void*) == 4) ? 2048 : 268435456);
        // then improve
        {
            // Linux, and BSD with linprocfs mounted
            FILE *f = fopen("/proc/meminfo", "r");
            if(f)
            {
                static char buf[1024];
                while(fgets(buf, sizeof(buf), f))
                {
                    const char *p = buf;
                    if(!COM_ParseToken_Console(&p))
                        continue;
                    if(!strcmp(com_token, "MemTotal:"))
                    {
                        if(!COM_ParseToken_Console(&p))
                            continue;
                        Cvar_SetValueQuick(&sys_memsize_physical, atof(com_token) / 1024.0);
                    }
                    if(!strcmp(com_token, "SwapTotal:"))
                    {
                        if(!COM_ParseToken_Console(&p))
                            continue;
                        Cvar_SetValueQuick(&sys_memsize_virtual, min(sys_memsize_virtual.value , atof(com_token) / 1024.0 + sys_memsize_physical.value));
                    }
                }
                fclose(f);
            }
        }
    }
#endif
}

References buf, CF_SHARED, Cmd_AddCommand(), COM_ParseToken_Console(), com_token, Cvar_RegisterVariable(), Cvar_SetValueQuick(), developer_memory, developer_memorydebug, developer_memoryreportlargerthanmb, f, fclose(), fgets(), fopen(), MemList_f(), MemStats_f(), min, sys_memsize_physical, sys_memsize_virtual, and cvar_t::value.

Referenced by Host_Init().

Memory_Shutdown()

void Memory_Shutdown

(

void

)

Definition at line 897 of file zone.c.

{
//  Mem_FreePool (&zonemempool);
//  Mem_FreePool (&tempmempool);
 
    if (mem_mutex)
        Thread_DestroyMutex(mem_mutex);
    mem_mutex = NULL;
}

References mem_mutex, NULL, and Thread_DestroyMutex.

Referenced by Host_Shutdown().

MemStats_f()

static void MemStats_f ( cmd_state_t * cmd )

static

Definition at line 858 of file zone.c.

{
    Mem_CheckSentinelsGlobal();
    Mem_PrintStats();
}

References Mem_CheckSentinelsGlobal, and Mem_PrintStats().

Referenced by Memory_Init_Commands().

Variable Documentation

developer_memory

cvar_t developer_memory = {CF_CLIENT | CF_SERVER, "developer_memory", "0", "prints debugging information about memory allocations"}

Definition at line 90 of file zone.c.

{CF_CLIENT | CF_SERVER, "developer_memory", "0", "prints debugging information about memory allocations"};

Referenced by _Mem_Alloc(), _Mem_FreeBlock(), Host_Init(), and Memory_Init_Commands().

developer_memorydebug

cvar_t developer_memorydebug = {CF_CLIENT | CF_SERVER, "developer_memorydebug", "0", "enables memory corruption checks (very slow)"}

Definition at line 91 of file zone.c.

{CF_CLIENT | CF_SERVER, "developer_memorydebug", "0", "enables memory corruption checks (very slow)"};

Referenced by _Mem_AllocPool(), _Mem_EmptyPool(), _Mem_Free(), _Mem_FreePool(), Clump_AllocBlock(), Clump_FreeBlock(), Host_Init(), and Memory_Init_Commands().

developer_memoryreportlargerthanmb

cvar_t developer_memoryreportlargerthanmb = {CF_CLIENT | CF_SERVER, "developer_memorylargerthanmb", "16", "prints debugging information about memory allocations over this size"}

Definition at line 92 of file zone.c.

{CF_CLIENT | CF_SERVER, "developer_memorylargerthanmb", "16", "prints debugging information about memory allocations over this size"};

Referenced by _Mem_Alloc(), and Memory_Init_Commands().

mem_bigendian

qbool mem_bigendian = false

Definition at line 34 of file zone.c.

Referenced by Memory_Init(), OGG_GetSamplesFloat(), OGG_LoadVorbisFile(), and S_LoadWavFile().

mem_mutex

void* mem_mutex = NULL

Definition at line 35 of file zone.c.

Referenced by _Mem_Alloc(), _Mem_FreeBlock(), Memory_Init(), and Memory_Shutdown().

poolchain

mempool_t* poolchain = NULL

static

Definition at line 96 of file zone.c.

Referenced by _Mem_AllocPool(), _Mem_CheckSentinelsGlobal(), _Mem_EmptyPool(), _Mem_FreePool(), Mem_IsAllocated(), Mem_PrintList(), Mem_PrintStats(), and Memory_Init().

sentinel_seed

unsigned int sentinel_seed

Definition at line 32 of file zone.c.

Referenced by Memory_Init().

sys_memsize_physical

cvar_t sys_memsize_physical = {CF_CLIENT | CF_SERVER | CF_READONLY, "sys_memsize_physical", "", "physical memory size in MB (or empty if unknown)"}

Definition at line 93 of file zone.c.

{CF_CLIENT | CF_SERVER | CF_READONLY, "sys_memsize_physical", "", "physical memory size in MB (or empty if unknown)"};

Referenced by Memory_Init_Commands().

sys_memsize_virtual

cvar_t sys_memsize_virtual = {CF_CLIENT | CF_SERVER | CF_READONLY, "sys_memsize_virtual", "", "virtual memory size in MB (or empty if unknown)"}

Definition at line 94 of file zone.c.

{CF_CLIENT | CF_SERVER | CF_READONLY, "sys_memsize_virtual", "", "virtual memory size in MB (or empty if unknown)"};

Referenced by Memory_Init_Commands().

tempmempool

mempool_t* tempmempool

Definition at line 794 of file zone.c.

Referenced by AssertBufsize(), CheckPendingDownloads(), CL_Beams_SetupBuiltinTexture(), CL_CutDemo(), CL_IPLog_Load(), CL_Particles_LoadEffectInfo(), CL_ReadPointFile_f(), CL_StopDownload(), CL_VM_Init(), Cmd_AddInterpreter(), Cmd_CompleteAliasBuildList(), Cmd_CompleteBuildList(), Cmd_Exec(), Cmd_Init(), Con_ConDump_f(), Con_Init(), Curl_FindPackURL(), Cvar_CompleteBuildList(), decode_image(), fixtransparentpixels(), fractalnoise(), FS_CRCFile(), FS_Deflate(), FS_Inflate(), FS_Init_SelfPack(), FS_LoadPackPAK(), FS_Search(), FS_Seek(), FS_VPrintf(), GetMapList(), gl_main_newmap(), GrowBuf(), hmac(), Image_Compress(), Image_GenerateDitherPattern(), Image_GenerateNoTexture(), Image_GenerateWhite(), Image_GetEmbeddedPicBGRA(), Image_GetStockPicSize(), Image_Resample32Lerp(), Image_WriteTGABGRA(), JPEG_LoadImage_BGRA(), JPEG_SaveImage_to_Buffer(), listdirectory(), LoadConChars_BGRA(), LoadFont(), loadimagepixelsbgra(), LoadLMP_BGRA(), LoadPCX_BGRA(), LoadTGA_BGRA(), LoadWAL_BGRA(), Log_ConPrint(), M_Setup_Draw(), Memory_Init(), Mod_BuildBaseBonePoses(), Mod_BuildVBOs(), Mod_BuildVertexRemapTableFromElements(), Mod_GenerateLightmaps_CreateLightmaps(), Mod_GenerateLightmaps_CreateLights(), Mod_GenerateLightmaps_CreateLights_ComputeSVBSP(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_LoadModel(), Mod_LoadQ3Shaders(), Mod_LoadSkinFiles(), Mod_MDLMD2MD3_TraceBox(), Mod_MDLMD2MD3_TraceLine(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q1BSP_LoadSplitSky(), Mod_Q2BSP_LoadBrushes(), Mod_Q2BSP_LoadTexinfo(), Mod_Q3BSP_LoadBrushes(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLightmaps(), Nicks_CompleteBuildList(), Palette_Load(), Palette_LoadQ2Colormap(), Palette_SetupSpecialPalettes(), PK3_BuildFileList(), PK3_GetEndOfCentralDir(), PNG_LoadImage_BGRA(), PRVM_Fields_f(), PRVM_LoadLNO(), R_BuildNormalizationCube(), R_Envmap_f(), R_InitBloodTextures(), R_InitParticleTexture(), R_LoadCubemap(), R_LoadQWSkin(), R_LoadSkyBox(), R_LoadTextureDDSFile(), R_SaveTextureDDSFile(), R_SetupTexture(), R_Shadow_LoadLightsFile(), R_Shadow_LoadWorldLights(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), R_Shadow_MakeTextures(), R_Shadow_SaveWorldLights(), R_SkinFrame_GenerateTexturesFromQPixels(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternalBGRA(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_DrawScreen(), SCR_ScreenShot_f(), SV_Loadgame_f(), SV_ParticleEffectIndex(), SV_ReadClientMessage(), SV_SpawnServer(), VM_CL_ReadPicture(), VM_loadfromfile(), W_ConvertWAD3TextureBGRA(), and W_GetTextureBGRA().

zonemempool

mempool_t* zonemempool

Definition at line 796 of file zone.c.

Referenced by Cmd_RestoreInitState(), Cmd_SaveInitState(), Con_Init(), Key_History_Init(), Memory_Init(), and TaskQueue_Enqueue().