Add GL_ExtensionSupported in vid_null.c because vid_shared.c relies on

[xonotic/darkplaces.git] / zone.c

diff --git a/zone.c b/zone.c
index fb314e4b535375280c024f7c41f7b7b940b60af3..2aa575e786b442cd96a59f683c856f4f89bac3da 100644 (file)
--- a/zone.c
+++ b/zone.c
@@ -20,6 +20,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 // Z_zone.c
 
 #include "quakedef.h"
 // Z_zone.c
 
 #include "quakedef.h"

+#include "thread.h"

 
 #ifdef WIN32
 #include <windows.h>
 
 #ifdef WIN32
 #include <windows.h>


@@ -37,16 +38,28 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 unsigned int sentinel_seed;
 
 qboolean mem_bigendian = false;
 unsigned int sentinel_seed;
 
 qboolean mem_bigendian = false;

+void *mem_mutex = NULL;
+
+// divVerent: enables file backed malloc using mmap to conserve swap space (instead of malloc)
+#ifndef FILE_BACKED_MALLOC
+# define FILE_BACKED_MALLOC 0
+#endif

 
 // LordHavoc: enables our own low-level allocator (instead of malloc)
 
 // LordHavoc: enables our own low-level allocator (instead of malloc)

-#define MEMCLUMPING 0
-#define MEMCLUMPING_FREECLUMPS 0
+#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
 
 #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)
 // 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)


@@ -82,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_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)"};
 
 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)"};
 


@@ -90,6 +104,46 @@ static mempool_t *poolchain = NULL;
 void Mem_PrintStats(void);
 void Mem_PrintList(size_t minallocationsize);
 
 void Mem_PrintStats(void);
 void Mem_PrintList(size_t minallocationsize);
 

+#if FILE_BACKED_MALLOC
+#include <stdlib.h>
+#include <sys/mman.h>
+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)
+               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)
 #if MEMCLUMPING != 2
 // some platforms have a malloc that returns NULL but succeeds later
 // (Windows growing its swapfile for example)


@@ -329,22 +383,29 @@ void *_Mem_Alloc(mempool_t *pool, void *olddata, size_t size, size_t alignment,
                return NULL;
        }
        if (pool == NULL)
                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 (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();
        {
                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));
        }
        // 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));


@@ -367,6 +428,9 @@ void *_Mem_Alloc(mempool_t *pool, void *olddata, size_t size, size_t alignment,
        if (mem->next)
                mem->next->prev = mem;
 
        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;
        // copy the shared portion in the case of a realloc, then memset the rest
        sharedsize = 0;
        remainsize = size;


@@ -405,6 +469,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);
        // 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
        if (mem->prev)
                mem->prev->next = mem->next;
        else


@@ -417,6 +483,8 @@ static void _Mem_FreeBlock(memheader_t *mem, const char *filename, int fileline)
        pool->totalsize -= size;
        pool->realsize -= realsize;
        Clump_FreeBlock(mem->baseaddress, realsize);
        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)
 }
 
 void _Mem_Free(void *data, const char *filename, int fileline)


@@ -491,9 +559,11 @@ void _Mem_FreePool(mempool_t **poolpointer, const char *filename, int fileline)
                        _Mem_FreeBlock(pool->chain, filename, fileline);
 
                // free child pools, too
                        _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);
                        if(iter->parent == pool)
                                _Mem_FreePool(&temp, filename, fileline);

+               }

 
                // free the pool itself
                Clump_FreeBlock(pool, sizeof(*pool));
 
                // free the pool itself
                Clump_FreeBlock(pool, sizeof(*pool));


@@ -630,44 +700,6 @@ void Mem_ExpandableArray_FreeArray(memexpandablearray_t *l)
        memset(l, 0, sizeof(*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;
 void *Mem_ExpandableArray_AllocRecord(memexpandablearray_t *l)
 {
        size_t i, j;


@@ -813,7 +845,7 @@ void Mem_PrintList(size_t minallocationsize)
        }
 }
 
        }
 }
 

-void MemList_f(void)
+static void MemList_f(void)

 {
        switch(Cmd_Argc())
        {
 {
        switch(Cmd_Argc())
        {


@@ -831,8 +863,7 @@ void MemList_f(void)
        }
 }
 
        }
 }
 

-extern void R_TextureStats_Print(qboolean printeach, qboolean printpool, qboolean printtotal);
-void MemStats_f(void)
+static void MemStats_f(void)

 {
        Mem_CheckSentinelsGlobal();
        R_TextureStats_Print(false, false, true);
 {
        Mem_CheckSentinelsGlobal();
        R_TextureStats_Print(false, false, true);


@@ -844,8 +875,10 @@ void MemStats_f(void)
 char* Mem_strdup (mempool_t *pool, const char* s)
 {
        char* p;
 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;
        p = (char*)Mem_Alloc (pool, sz);
        strlcpy (p, s, sz);
        return p;


@@ -866,12 +899,19 @@ void Memory_Init (void)
        poolchain = NULL;
        tempmempool = Mem_AllocPool("Temporary Memory", POOLFLAG_TEMP, NULL);
        zonemempool = Mem_AllocPool("Zone", 0, NULL);
        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);
 }
 
 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)
 }
 
 void Memory_Init_Commands (void)


@@ -880,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);
        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);
 
        Cvar_RegisterVariable (&sys_memsize_physical);
        Cvar_RegisterVariable (&sys_memsize_virtual);
 


@@ -891,7 +932,7 @@ void Memory_Init_Commands (void)
                Cvar_SetValueQuick(&sys_memsize_virtual, 8388608);
                // then improve
                status.dwLength = sizeof(status);
                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));
                {
                        Cvar_SetValueQuick(&sys_memsize_physical, status.ullTotalPhys / 1048576.0);
                        Cvar_SetValueQuick(&sys_memsize_virtual, min(sys_memsize_virtual.value, status.ullTotalVirtual / 1048576.0));