static mempool_t *poolchain = NULL;
+void Mem_PrintStats(void);
+void Mem_PrintList(size_t minallocationsize);
+
#if MEMCLUMPING != 2
// some platforms have a malloc that returns NULL but succeeds later
// (Windows growing its swapfile for example)
}
if (pool == NULL)
Sys_Error("Mem_Alloc: pool == NULL (alloc at %s:%i)", filename, fileline);
- if (developer.integer && developer_memory.integer)
- Con_Printf("Mem_Alloc: pool %s, file %s:%i, size %i bytes\n", pool->name, filename, fileline, (int)size);
+ 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.integer && developer_memorydebug.integer)
// _Mem_CheckSentinelsGlobal(filename, fileline);
pool->totalsize += size;
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 at %s:%i)", 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;
Sys_Error("Mem_Free: trashed header sentinel 2 (alloc at %s:%i, free at %s:%i)", mem->filename, mem->fileline, filename, fileline);
pool = mem->pool;
- if (developer.integer && developer_memory.integer)
- Con_Printf("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));
+ 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->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);
return;
}
- if (developer.integer && developer_memorydebug.integer)
+ if (developer_memorydebug.integer)
{
//_Mem_CheckSentinelsGlobal(filename, fileline);
if (!Mem_IsAllocated(NULL, data))
mempool_t *_Mem_AllocPool(const char *name, int flags, mempool_t *parent, const char *filename, int fileline)
{
mempool_t *pool;
- //if (developer.integer && developer_memorydebug.integer)
- // _Mem_CheckSentinelsGlobal(filename, fileline);
+ 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);
mempool_t *pool = *poolpointer;
mempool_t **chainaddress, *iter, *temp;
- //if (developer.integer && developer_memorydebug.integer)
- // _Mem_CheckSentinelsGlobal(filename, fileline);
+ if (developer_memorydebug.integer)
+ _Mem_CheckSentinelsGlobal(filename, fileline);
if (pool)
{
// unlink pool from chain
{
mempool_t *chainaddress;
- if (developer.integer && developer_memorydebug.integer)
+ if (developer_memorydebug.integer)
{
//_Mem_CheckSentinelsGlobal(filename, fileline);
// check if this pool is in the poolchain
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;
"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" : "");
+ 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;
for (mem = pool->chain;mem;mem = mem->next)
if (mem->size >= minallocationsize)