X-Git-Url: http://git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=zone.c;h=b357a013aeec18f0c7d491a081608c37c6c764c7;hp=e90df30bff1283333b035af9e8cea2f007c527b4;hb=ca767b6a14085cfd278eaf6999c0177f75bf19fa;hpb=36bcd3b371a113ce5cf3e91f7143e18672fe9c93 diff --git a/zone.c b/zone.c index e90df30b..b357a013 100644 --- a/zone.c +++ b/zone.c @@ -19,33 +19,41 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ // Z_zone.c -#include "quakedef.h" +#include "darkplaces.h" #ifdef WIN32 #include +#include #else #include #endif -#ifdef _MSC_VER -#include -#else -#include -#endif #define MEMHEADER_SENTINEL_FOR_ADDRESS(p) ((sentinel_seed ^ (unsigned int) (uintptr_t) (p)) + sentinel_seed) unsigned int sentinel_seed; -qboolean mem_bigendian = false; +qbool mem_bigendian = false; +void *mem_mutex = NULL; -// LordHavoc: enables our own low-level allocator (instead of malloc) -#define MEMCLUMPING 0 -#define MEMCLUMPING_FREECLUMPS 0 +// divVerent: enables file backed malloc using mmap to conserve swap space (instead of malloc) +#ifndef FILE_BACKED_MALLOC +# define FILE_BACKED_MALLOC 0 +#endif + +// LadyHavoc: enables our own low-level allocator (instead of malloc) +#ifndef MEMCLUMPING +# define MEMCLUMPING 0 +#endif +#ifndef MEMCLUMPING_FREECLUMPS +# define MEMCLUMPING_FREECLUMPS 0 +#endif #if MEMCLUMPING // smallest unit we care about is this many bytes #define MEMUNIT 128 // try to do 32MB clumps, but overhead eats into this -#define MEMWANTCLUMPSIZE (1<<27) +#ifndef MEMWANTCLUMPSIZE +# define MEMWANTCLUMPSIZE (1<<27) +#endif // give malloc padding so we can't waste most of a page at the end #define MEMCLUMPSIZE (MEMWANTCLUMPSIZE - MEMWANTCLUMPSIZE/MEMUNIT/32 - 128) #define MEMBITS (MEMCLUMPSIZE / MEMUNIT) @@ -79,16 +87,60 @@ static memclump_t *clumpchain = NULL; #endif -cvar_t developer_memory = {0, "developer_memory", "0", "prints debugging information about memory allocations"}; -cvar_t developer_memorydebug = {0, "developer_memorydebug", "0", "enables memory corruption checks (very slow)"}; -cvar_t sys_memsize_physical = {CVAR_READONLY, "sys_memsize_physical", "", "physical memory size in MB (or empty if unknown)"}; -cvar_t sys_memsize_virtual = {CVAR_READONLY, "sys_memsize_virtual", "", "virtual memory size in MB (or empty if unknown)"}; +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"}; +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)"}; static mempool_t *poolchain = NULL; void Mem_PrintStats(void); void Mem_PrintList(size_t minallocationsize); +#if FILE_BACKED_MALLOC +#include +#include +#ifndef MAP_NORESERVE +#define MAP_NORESERVE 0 +#endif +typedef struct mmap_data_s +{ + size_t len; +} +mmap_data_t; +static void *mmap_malloc(size_t size) +{ + char vabuf[MAX_OSPATH + 1]; + char *tmpdir = getenv("TEMP"); + mmap_data_t *data; + int fd; + size += sizeof(mmap_data_t); // waste block + dpsnprintf(vabuf, sizeof(vabuf), "%s/darkplaces.XXXXXX", tmpdir ? tmpdir : "/tmp"); + fd = mkstemp(vabuf); + if(fd < 0) + return NULL; + ftruncate(fd, size); + data = (unsigned char *) mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE, fd, 0); + close(fd); + unlink(vabuf); + if(!data || data == (void *)-1) + return NULL; + data->len = size; + return (void *) (data + 1); +} +static void mmap_free(void *mem) +{ + mmap_data_t *data; + if(!mem) + return; + data = ((mmap_data_t *) mem) - 1; + munmap(data, data->len); +} +#define malloc mmap_malloc +#define free mmap_free +#endif + #if MEMCLUMPING != 2 // some platforms have a malloc that returns NULL but succeeds later // (Windows growing its swapfile for example) @@ -149,14 +201,14 @@ static void *Clump_AllocBlock(size_t size) #if MEMCLUMPING if (size <= MEMCLUMPSIZE) { - int index; - unsigned int bit; - unsigned int needbits; - unsigned int startbit; - unsigned int endbit; - unsigned int needints; - int startindex; - int endindex; + 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; @@ -260,10 +312,10 @@ nofreeblock: static void Clump_FreeBlock(void *base, size_t size) { #if MEMCLUMPING - unsigned int needbits; - unsigned int startbit; - unsigned int endbit; - unsigned int bit; + size_t needbits; + size_t startbit; + size_t endbit; + size_t bit; memclump_t **clumpchainpointer; memclump_t *clump; unsigned char *start = (unsigned char *)base; @@ -328,22 +380,29 @@ void *_Mem_Alloc(mempool_t *pool, void *olddata, size_t size, size_t alignment, return NULL; } if (pool == NULL) - Sys_Error("Mem_Alloc: pool == NULL (alloc at %s:%i)", filename, fileline); - if (developer_memory.integer) - Con_DPrintf("Mem_Alloc: pool %s, file %s:%i, size %i bytes\n", pool->name, filename, fileline, (int)size); + { + 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) + if (base == NULL) { Mem_PrintList(0); Mem_PrintStats(); Mem_PrintList(1<<30); Mem_PrintStats(); - Sys_Error("Mem_Alloc: out of memory (alloc at %s:%i)", filename, fileline); + 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)); @@ -366,6 +425,9 @@ void *_Mem_Alloc(mempool_t *pool, void *olddata, size_t size, size_t alignment, if (mem->next) mem->next->prev = mem; + 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; @@ -404,6 +466,8 @@ static void _Mem_FreeBlock(memheader_t *mem, const char *filename, int fileline) // unlink memheader from doubly linked list if ((mem->prev ? mem->prev->next != mem : pool->chain != mem) || (mem->next && mem->next->prev != mem)) Sys_Error("Mem_Free: not allocated or double freed (free at %s:%i)", filename, fileline); + if (mem_mutex) + Thread_LockMutex(mem_mutex); if (mem->prev) mem->prev->next = mem->next; else @@ -416,6 +480,8 @@ static void _Mem_FreeBlock(memheader_t *mem, const char *filename, int fileline) pool->totalsize -= size; pool->realsize -= realsize; Clump_FreeBlock(mem->baseaddress, realsize); + if (mem_mutex) + Thread_UnlockMutex(mem_mutex); } void _Mem_Free(void *data, const char *filename, int fileline) @@ -490,9 +556,11 @@ void _Mem_FreePool(mempool_t **poolpointer, const char *filename, int fileline) _Mem_FreeBlock(pool->chain, filename, fileline); // free child pools, too - for(iter = poolchain; iter; temp = iter = iter->next) + 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)); @@ -586,7 +654,7 @@ void _Mem_CheckSentinelsGlobal(const char *filename, int fileline) #endif } -qboolean Mem_IsAllocated(mempool_t *pool, void *data) +qbool Mem_IsAllocated(mempool_t *pool, void *data) { memheader_t *header; memheader_t *target; @@ -629,44 +697,6 @@ void Mem_ExpandableArray_FreeArray(memexpandablearray_t *l) memset(l, 0, sizeof(*l)); } -// VorteX: hacked Mem_ExpandableArray_AllocRecord, it does allocate record at certain index -void *Mem_ExpandableArray_AllocRecordAtIndex(memexpandablearray_t *l, size_t index) -{ - size_t j; - if (index == 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[index].numflaggedrecords = 0; - l->arrays[index].data = (unsigned char *) Mem_Alloc(l->mempool, (l->recordsize + 1) * l->numrecordsperarray); - l->arrays[index].allocflags = l->arrays[index].data + l->recordsize * l->numrecordsperarray; - l->numarrays++; - } - if (l->arrays[index].numflaggedrecords < l->numrecordsperarray) - { - for (j = 0;j < l->numrecordsperarray;j++) - { - if (!l->arrays[index].allocflags[j]) - { - l->arrays[index].allocflags[j] = true; - l->arrays[index].numflaggedrecords++; - memset(l->arrays[index].data + l->recordsize * j, 0, l->recordsize); - return (void *)(l->arrays[index].data + l->recordsize * j); - } - } - } - return NULL; -} - void *Mem_ExpandableArray_AllocRecord(memexpandablearray_t *l) { size_t i, j; @@ -725,9 +755,9 @@ void Mem_ExpandableArray_FreeRecord(memexpandablearray_t *l, void *record) // co { 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", p); + 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", p); + Sys_Error("Mem_ExpandableArray_FreeRecord: record %p is already free!\n", (void *)p); l->arrays[i].allocflags[j] = false; l->arrays[i].numflaggedrecords--; return; @@ -812,16 +842,16 @@ void Mem_PrintList(size_t minallocationsize) } } -void MemList_f(void) +static void MemList_f(cmd_state_t *cmd) { - switch(Cmd_Argc()) + switch(Cmd_Argc(cmd)) { case 1: Mem_PrintList(1<<30); Mem_PrintStats(); break; case 2: - Mem_PrintList(atoi(Cmd_Argv(1)) * 1024); + Mem_PrintList(atoi(Cmd_Argv(cmd, 1)) * 1024); Mem_PrintStats(); break; default: @@ -830,12 +860,9 @@ void MemList_f(void) } } -extern void R_TextureStats_Print(qboolean printeach, qboolean printpool, qboolean printtotal); -void MemStats_f(void) +static void MemStats_f(cmd_state_t *cmd) { Mem_CheckSentinelsGlobal(); - R_TextureStats_Print(false, false, true); - GL_Mesh_ListVBOs(false); Mem_PrintStats(); } @@ -843,8 +870,10 @@ void MemStats_f(void) char* Mem_strdup (mempool_t *pool, const char* s) { char* p; - size_t sz = strlen (s) + 1; - if (s == NULL) return NULL; + size_t sz; + if (s == NULL) + return NULL; + sz = strlen (s) + 1; p = (char*)Mem_Alloc (pool, sz); strlcpy (p, s, sz); return p; @@ -865,36 +894,58 @@ void Memory_Init (void) poolchain = NULL; tempmempool = Mem_AllocPool("Temporary Memory", POOLFLAG_TEMP, NULL); zonemempool = Mem_AllocPool("Zone", 0, NULL); + + if (Thread_HasThreads()) + mem_mutex = Thread_CreateMutex(); } void Memory_Shutdown (void) { // Mem_FreePool (&zonemempool); // Mem_FreePool (&tempmempool); + + if (mem_mutex) + Thread_DestroyMutex(mem_mutex); + mem_mutex = NULL; } void Memory_Init_Commands (void) { - Cmd_AddCommand ("memstats", MemStats_f, "prints memory system statistics"); - Cmd_AddCommand ("memlist", MemList_f, "prints memory pool information (or if used as memlist 5 lists individual allocations of 5K or larger, 0 lists all allocations)"); + 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_SetQuick(&sys_memsize_virtual, (sizeof(void*) == 4) ? 2048 : 8388608); + Cvar_SetValueQuick(&sys_memsize_virtual, 8388608); // then improve status.dwLength = sizeof(status); - if(!GlobalMemoryStatusEx(&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