ref: ab06b0ebe671252f7fc1b517d2c2d3f1f00ee5bc
dir: /zone.c/
#include <u.h>
#include <libc.h>
#include "dat.h"
#include "quakedef.h"
#include "fns.h"
#define DYNAMIC_SIZE 0xc000
#define ZONEID 0x1d4a11
#define MINFRAGMENT 64
typedef struct memblock_s
{
int size; // including the header and possibly tiny fragments
int tag; // a tag of 0 is a free block
int id; // should be ZONEID
struct memblock_s *next, *prev;
int pad; // pad to 64 bit boundary
} memblock_t;
typedef struct
{
int size; // total bytes malloced, including header
memblock_t blocklist; // start / end cap for linked list
memblock_t *rover;
} memzone_t;
void Cache_FreeLow (int new_low_hunk);
void Cache_FreeHigh (int new_high_hunk);
/*
==============================================================================
ZONE MEMORY ALLOCATION
There is never any space between memblocks, and there will never be two
contiguous free memblocks.
The rover can be left pointing at a non-empty block
The zone calls are pretty much only used for small strings and structures,
all big things are allocated on the hunk.
==============================================================================
*/
memzone_t *mainzone;
void Z_ClearZone (memzone_t *zone, int size);
/*
========================
Z_ClearZone
========================
*/
void Z_ClearZone (memzone_t *zone, int size)
{
memblock_t *block;
// set the entire zone to one free block
zone->blocklist.next = zone->blocklist.prev = block =
(memblock_t *)((byte *)zone + sizeof(memzone_t));
zone->blocklist.tag = 1; // in use block
zone->blocklist.id = 0;
zone->blocklist.size = 0;
zone->rover = block;
block->prev = block->next = &zone->blocklist;
block->tag = 0; // free block
block->id = ZONEID;
block->size = size - sizeof(memzone_t);
}
/*
========================
Z_Free
========================
*/
void Z_Free (void *ptr)
{
memblock_t *block, *other;
if (!ptr)
fatal ("Z_Free: NULL pointer");
block = (memblock_t *)((uchar *)ptr - sizeof(memblock_t));
if (block->id != ZONEID)
fatal ("Z_Free: freed a pointer without ZONEID");
if (block->tag == 0)
fatal ("Z_Free: freed a freed pointer");
block->tag = 0; // mark as free
other = block->prev;
if (!other->tag)
{ // merge with previous free block
other->size += block->size;
other->next = block->next;
other->next->prev = other;
if (block == mainzone->rover)
mainzone->rover = other;
block = other;
}
other = block->next;
if (!other->tag)
{ // merge the next free block onto the end
block->size += other->size;
block->next = other->next;
block->next->prev = block;
if (other == mainzone->rover)
mainzone->rover = block;
}
}
void *
Z_Malloc(int size)
{
void *buf;
Z_CheckHeap(); // DEBUG
if((buf = Z_TagMalloc(size, 1)) == nil)
fatal("Z_Malloc: failed on allocation of %d bytes", size);
memset(buf, 0, size);
return buf;
}
void *Z_TagMalloc (int size, int tag)
{
int extra;
memblock_t *start, *rover, *new, *base;
if (!tag)
fatal ("Z_TagMalloc: tried to use a 0 tag");
//
// scan through the block list looking for the first free block
// of sufficient size
//
size += sizeof(memblock_t); // account for size of block header
size += 4; // space for memory trash tester
size = (size + 7) & ~7; // align to 8-byte boundary
base = rover = mainzone->rover;
start = base->prev;
do
{
if (rover == start) // scaned all the way around the list
return nil;
if (rover->tag)
base = rover = rover->next;
else
rover = rover->next;
} while (base->tag || base->size < size);
//
// found a block big enough
//
extra = base->size - size;
if (extra > MINFRAGMENT)
{ // there will be a free fragment after the allocated block
new = (memblock_t *) ((byte *)base + size );
new->size = extra;
new->tag = 0; // free block
new->prev = base;
new->id = ZONEID;
new->next = base->next;
new->next->prev = new;
base->next = new;
base->size = size;
}
base->tag = tag; // no longer a free block
mainzone->rover = base->next; // next allocation will start looking here
base->id = ZONEID;
// marker for memory trash testing
*(int *)((byte *)base + base->size - 4) = ZONEID;
return (void *) ((byte *)base + sizeof(memblock_t));
}
/*
========================
Z_Print
========================
*/
void Z_Print (memzone_t *zone)
{
memblock_t *block;
Con_Printf ("zone size: %d location: %p\n",mainzone->size,mainzone);
for (block = zone->blocklist.next ; ; block = block->next)
{
Con_Printf ("block:%p size:%7d tag:%3d\n",
block, block->size, block->tag);
if (block->next == &zone->blocklist)
break; // all blocks have been hit
if ( (byte *)block + block->size != (byte *)block->next)
Con_Printf ("ERROR: block size does not touch the next block\n");
if ( block->next->prev != block)
Con_Printf ("ERROR: next block doesn't have proper back link\n");
if (!block->tag && !block->next->tag)
Con_Printf ("ERROR: two consecutive free blocks\n");
}
}
/*
========================
Z_CheckHeap
========================
*/
void Z_CheckHeap (void)
{
memblock_t *block;
for (block = mainzone->blocklist.next ; ; block = block->next)
{
if (block->next == &mainzone->blocklist)
break; // all blocks have been hit
if ( (byte *)block + block->size != (byte *)block->next)
fatal ("Z_CheckHeap: block size does not touch the next block\n");
if ( block->next->prev != block)
fatal ("Z_CheckHeap: next block doesn't have proper back link\n");
if (!block->tag && !block->next->tag)
fatal ("Z_CheckHeap: two consecutive free blocks\n");
}
}
//============================================================================
#define HUNK_SENTINAL 0x1df001ed
typedef struct
{
int sentinal;
int size; // including sizeof(hunk_t), -1 = not allocated
char name[8];
} hunk_t;
int hunk_low_used;
int hunk_high_used;
qboolean hunk_tempactive;
int hunk_tempmark;
void R_FreeTextures (void);
/*
==============
Hunk_Check
Run consistancy and sentinal trahing checks
==============
*/
void Hunk_Check (void)
{
hunk_t *h;
for (h = (hunk_t *)membase ; (byte *)h != membase + hunk_low_used ; )
{
if (h->sentinal != HUNK_SENTINAL)
fatal ("Hunk_Check: trahsed sentinal");
if (h->size < 16 || h->size + (byte *)h - membase > memsize)
fatal ("Hunk_Check: bad size");
h = (hunk_t *)((byte *)h+h->size);
}
}
/*
==============
Hunk_Print
If "all" is specified, every single allocation is printed.
Otherwise, allocations with the same name will be totaled up before printing.
==============
*/
void Hunk_Print (qboolean all)
{
hunk_t *h, *next, *endlow, *starthigh, *endhigh;
int count, sum;
int totalblocks;
char name[9];
name[8] = 0;
count = 0;
sum = 0;
totalblocks = 0;
h = (hunk_t *)membase;
endlow = (hunk_t *)(membase + hunk_low_used);
starthigh = (hunk_t *)(membase + memsize - hunk_high_used);
endhigh = (hunk_t *)(membase + memsize);
Con_Printf (" :%8d total hunk size\n", memsize);
Con_Printf ("-------------------------\n");
while (1)
{
//
// skip to the high hunk if done with low hunk
//
if ( h == endlow )
{
Con_Printf ("-------------------------\n");
Con_Printf (" :%8d REMAINING\n", memsize - hunk_low_used - hunk_high_used);
Con_Printf ("-------------------------\n");
h = starthigh;
}
//
// if totally done, break
//
if ( h == endhigh )
break;
//
// run consistancy checks
//
if (h->sentinal != HUNK_SENTINAL)
fatal ("Hunk_Check: trahsed sentinal");
if (h->size < 16 || h->size + (byte *)h - membase > memsize)
fatal ("Hunk_Check: bad size");
next = (hunk_t *)((byte *)h+h->size);
count++;
totalblocks++;
sum += h->size;
//
// print the single block
//
memcpy(name, h->name, 8);
if (all)
Con_Printf ("%8p :%8d %8s\n",h, h->size, name);
//
// print the total
//
if (next == endlow || next == endhigh ||
strncmp (h->name, next->name, 8) )
{
if (!all)
Con_Printf (" :%8d %8s (TOTAL)\n",sum, name);
count = 0;
sum = 0;
}
h = next;
}
Con_Printf ("-------------------------\n");
Con_Printf ("%8d total blocks\n", totalblocks);
}
/*
===================
Hunk_AllocName
===================
*/
void *Hunk_AllocName (int size, char *name)
{
hunk_t *h;
#ifdef PARANOID
Hunk_Check ();
#endif
if (size < 0)
fatal ("Hunk_Alloc: bad size: %d", size);
size = sizeof(hunk_t) + ((size+15)&~15);
if (memsize - hunk_low_used - hunk_high_used < size)
fatal ("Hunk_Alloc: failed on %d bytes",size);
h = (hunk_t *)(membase + hunk_low_used);
hunk_low_used += size;
Cache_FreeLow (hunk_low_used);
memset(h, 0, size);
h->size = size;
h->sentinal = HUNK_SENTINAL;
strncpy(h->name, name, 8);
return (void *)(h+1);
}
/*
===================
Hunk_Alloc
===================
*/
void *Hunk_Alloc (int size)
{
return Hunk_AllocName (size, "unknown");
}
int Hunk_LowMark (void)
{
return hunk_low_used;
}
void Hunk_FreeToLowMark (int mark)
{
if (mark < 0 || mark > hunk_low_used)
fatal ("Hunk_FreeToLowMark: bad mark %d", mark);
memset(membase + mark, 0, hunk_low_used - mark);
hunk_low_used = mark;
}
int Hunk_HighMark (void)
{
if (hunk_tempactive)
{
hunk_tempactive = false;
Hunk_FreeToHighMark (hunk_tempmark);
}
return hunk_high_used;
}
void Hunk_FreeToHighMark (int mark)
{
if (hunk_tempactive)
{
hunk_tempactive = false;
Hunk_FreeToHighMark (hunk_tempmark);
}
if (mark < 0 || mark > hunk_high_used)
fatal ("Hunk_FreeToHighMark: bad mark %d", mark);
memset(membase + memsize - hunk_high_used, 0, hunk_high_used - mark);
hunk_high_used = mark;
}
/*
===================
Hunk_HighAllocName
===================
*/
void *Hunk_HighAllocName (int size, char *name)
{
hunk_t *h;
if (size < 0)
fatal ("Hunk_HighAllocName: bad size: %d", size);
if (hunk_tempactive)
{
Hunk_FreeToHighMark (hunk_tempmark);
hunk_tempactive = false;
}
#ifdef PARANOID
Hunk_Check ();
#endif
size = sizeof(hunk_t) + ((size+15)&~15);
if (memsize - hunk_low_used - hunk_high_used < size)
{
Con_Printf ("Hunk_HighAlloc: failed on %d bytes\n",size);
return nil;
}
hunk_high_used += size;
Cache_FreeHigh (hunk_high_used);
h = (hunk_t *)(membase + memsize - hunk_high_used);
memset(h, 0, size);
h->size = size;
h->sentinal = HUNK_SENTINAL;
strncpy(h->name, name, 8);
return (void *)(h+1);
}
/*
=================
Hunk_TempAlloc
Return space from the top of the hunk
=================
*/
void *Hunk_TempAlloc (int size)
{
void *buf;
size = (size+15)&~15;
if (hunk_tempactive)
{
Hunk_FreeToHighMark (hunk_tempmark);
hunk_tempactive = false;
}
hunk_tempmark = Hunk_HighMark ();
buf = Hunk_HighAllocName (size, "temp");
hunk_tempactive = true;
return buf;
}
/*
===============================================================================
CACHE MEMORY
===============================================================================
*/
typedef struct cache_system_s
{
int size; // including this header
cache_user_t *user;
char name[16];
struct cache_system_s *prev, *next;
struct cache_system_s *lru_prev, *lru_next; // for LRU flushing
} cache_system_t;
cache_system_t *Cache_TryAlloc (int size, qboolean nobottom);
cache_system_t cache_head;
/*
===========
Cache_Move
===========
*/
void Cache_Move ( cache_system_t *c)
{
cache_system_t *new;
// we are clearing up space at the bottom, so only allocate it late
new = Cache_TryAlloc (c->size, true);
if (new)
{
// Con_Printf ("cache_move ok\n");
memcpy(new+1, c+1, c->size - sizeof *new);
new->user = c->user;
memcpy(new->name, c->name, sizeof new->name);
Cache_Free (c->user);
new->user->data = (void *)(new+1);
}
else
{
// Con_Printf ("cache_move failed\n");
Cache_Free (c->user); // tough luck...
}
}
/*
============
Cache_FreeLow
Throw things out until the hunk can be expanded to the given point
============
*/
void Cache_FreeLow (int new_low_hunk)
{
cache_system_t *c;
while (1)
{
c = cache_head.next;
if (c == &cache_head)
return; // nothing in cache at all
if ((byte *)c >= membase + new_low_hunk)
return; // there is space to grow the hunk
Cache_Move ( c ); // reclaim the space
}
}
/*
============
Cache_FreeHigh
Throw things out until the hunk can be expanded to the given point
============
*/
void Cache_FreeHigh (int new_high_hunk)
{
cache_system_t *c, *prev;
prev = nil;
while (1)
{
c = cache_head.prev;
if (c == &cache_head)
return; // nothing in cache at all
if ( (byte *)c + c->size <= membase + memsize - new_high_hunk)
return; // there is space to grow the hunk
if (c == prev)
Cache_Free (c->user); // didn't move out of the way
else
{
Cache_Move (c); // try to move it
prev = c;
}
}
}
void Cache_UnlinkLRU (cache_system_t *cs)
{
if (!cs->lru_next || !cs->lru_prev)
fatal ("Cache_UnlinkLRU: NULL link");
cs->lru_next->lru_prev = cs->lru_prev;
cs->lru_prev->lru_next = cs->lru_next;
cs->lru_prev = cs->lru_next = nil;
}
void Cache_MakeLRU (cache_system_t *cs)
{
if (cs->lru_next || cs->lru_prev)
fatal ("Cache_MakeLRU: active link");
cache_head.lru_next->lru_prev = cs;
cs->lru_next = cache_head.lru_next;
cs->lru_prev = &cache_head;
cache_head.lru_next = cs;
}
/*
============
Cache_TryAlloc
Looks for a free block of memory between the high and low hunk marks
Size should already include the header and padding
============
*/
cache_system_t *Cache_TryAlloc (int size, qboolean nobottom)
{
cache_system_t *cs, *new;
// is the cache completely empty?
if (!nobottom && cache_head.prev == &cache_head)
{
if (memsize - hunk_high_used - hunk_low_used < size)
fatal ("Cache_TryAlloc: %d is greater then free hunk", size);
new = (cache_system_t *) (membase + hunk_low_used);
memset(new, 0, sizeof *new);
new->size = size;
cache_head.prev = cache_head.next = new;
new->prev = new->next = &cache_head;
Cache_MakeLRU (new);
return new;
}
// search from the bottom up for space
new = (cache_system_t *) (membase + hunk_low_used);
cs = cache_head.next;
do
{
if (!nobottom || cs != cache_head.next)
{
if ( (byte *)cs - (byte *)new >= size)
{ // found space
memset(new, 0, sizeof *new);
new->size = size;
new->next = cs;
new->prev = cs->prev;
cs->prev->next = new;
cs->prev = new;
Cache_MakeLRU (new);
return new;
}
}
// continue looking
new = (cache_system_t *)((byte *)cs + cs->size);
cs = cs->next;
} while (cs != &cache_head);
// try to allocate one at the very end
if ( membase + memsize - hunk_high_used - (byte *)new >= size)
{
memset(new, 0, sizeof *new);
new->size = size;
new->next = &cache_head;
new->prev = cache_head.prev;
cache_head.prev->next = new;
cache_head.prev = new;
Cache_MakeLRU (new);
return new;
}
return nil; // couldn't allocate
}
/*
============
Cache_Flush
Throw everything out, so new data will be demand cached
============
*/
void Cache_Flush (void)
{
while (cache_head.next != &cache_head)
Cache_Free ( cache_head.next->user ); // reclaim the space
}
void
Cache_Report(void)
{
print("%4.1f megabyte data cache\n",
(memsize - hunk_high_used - hunk_low_used)
/ (float)(1024*1024));
}
/*
============
Cache_Init
============
*/
void Cache_Init (void)
{
cache_head.next = cache_head.prev = &cache_head;
cache_head.lru_next = cache_head.lru_prev = &cache_head;
Cmd_AddCommand ("flush", Cache_Flush);
}
/*
==============
Cache_Free
Frees the memory and removes it from the LRU list
==============
*/
void Cache_Free (cache_user_t *c)
{
cache_system_t *cs;
if (!c->data)
fatal ("Cache_Free: not allocated");
cs = ((cache_system_t *)c->data) - 1;
cs->prev->next = cs->next;
cs->next->prev = cs->prev;
cs->next = cs->prev = nil;
c->data = nil;
Cache_UnlinkLRU (cs);
}
/*
==============
Cache_Check
==============
*/
void *Cache_Check (cache_user_t *c)
{
cache_system_t *cs;
if (!c->data)
return nil;
cs = ((cache_system_t *)c->data) - 1;
// move to head of LRU
Cache_UnlinkLRU (cs);
Cache_MakeLRU (cs);
return c->data;
}
/*
==============
Cache_Alloc
==============
*/
void *Cache_Alloc (cache_user_t *c, int size, char *name)
{
cache_system_t *cs;
if (c->data)
fatal ("Cache_Alloc: allready allocated");
if (size <= 0)
fatal ("Cache_Alloc: size %d", size);
size = (size + sizeof(*cs) + 15) & ~15;
// find memory for it
while (1)
{
cs = Cache_TryAlloc (size, false);
if (cs)
{
strncpy (cs->name, name, sizeof(cs->name)-1);
c->data = (void *)(cs+1);
cs->user = c;
break;
}
// free the least recently used cahedat
if (cache_head.lru_prev == &cache_head)
fatal ("Cache_Alloc: out of memory");
// not enough memory at all
Cache_Free ( cache_head.lru_prev->user );
}
return Cache_Check (c);
}
void Memory_Init (void)
{
int p;
int zonesize = DYNAMIC_SIZE;
hunk_low_used = 0;
hunk_high_used = 0;
Cache_Init ();
p = COM_CheckParm ("-zone");
if (p)
{
if (p < com_argc-1)
zonesize = atoi(com_argv[p+1]) * 1024;
else
fatal ("Memory_Init: you must specify a size in KB after -zone");
}
mainzone = Hunk_AllocName (zonesize, "zone" );
Z_ClearZone (mainzone, zonesize);
}