Fix setinfo.
[xonotic/darkplaces.git] / zone.c
diff --git a/zone.c b/zone.c
index 85a3b21..2aa575e 100644 (file)
--- a/zone.c
+++ b/zone.c
@@ -95,6 +95,7 @@ static memclump_t *clumpchain = NULL;
 
 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 developer_memoryreportlargerthanmb = {0, "developer_memorylargerthanmb", "16", "prints debugging information about memory allocations over this size"};
 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)"};
 
@@ -111,16 +112,13 @@ typedef struct mmap_data_s
        size_t len;
 }
 mmap_data_t;
-#define MMAP_PAGE_SIZE max(sizeof(mmap_data_t), (size_t)sysconf(_SC_PAGE_SIZE))
 static void *mmap_malloc(size_t size)
 {
        char vabuf[MAX_OSPATH + 1];
        char *tmpdir = getenv("TEMP");
-       unsigned char *data;
+       mmap_data_t *data;
        int fd;
-       size += MMAP_PAGE_SIZE; // waste block
-       size += MMAP_PAGE_SIZE - 1; // also, waste up to this amount for management info
-       size -= (size % MMAP_PAGE_SIZE); // round down
+       size += sizeof(mmap_data_t); // waste block
        dpsnprintf(vabuf, sizeof(vabuf), "%s/darkplaces.XXXXXX", tmpdir ? tmpdir : "/tmp");
        fd = mkstemp(vabuf);
        if(fd < 0)
@@ -131,16 +129,16 @@ static void *mmap_malloc(size_t size)
        unlink(vabuf);
        if(!data)
                return NULL;
-       ((mmap_data_t *) data)->len = size;
-       return (void *) (data + MMAP_PAGE_SIZE);
+       data->len = size;
+       return (void *) (data + 1);
 }
 static void mmap_free(void *mem)
 {
-       unsigned char *data;
+       mmap_data_t *data;
        if(!mem)
                return;
-       data = (unsigned char *) mem - MMAP_PAGE_SIZE;
-       munmap(data, ((mmap_data_t *) data)->len);
+       data = ((mmap_data_t *) mem) - 1;
+       munmap(data, data->len);
 }
 #define malloc mmap_malloc
 #define free mmap_free
@@ -385,24 +383,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(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)
-               Con_DPrintf("Mem_Alloc: pool %s, file %s:%i, size %i bytes\n", pool->name, filename, fileline, (int)size);
+       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));
@@ -556,9 +559,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));
@@ -695,44 +700,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;
@@ -953,6 +920,7 @@ void Memory_Init_Commands (void)
        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)");
        Cvar_RegisterVariable (&developer_memory);
        Cvar_RegisterVariable (&developer_memorydebug);
+       Cvar_RegisterVariable (&developer_memoryreportlargerthanmb);
        Cvar_RegisterVariable (&sys_memsize_physical);
        Cvar_RegisterVariable (&sys_memsize_virtual);