mirror of
https://github.com/id-Software/Quake.git
synced 2026-03-19 16:39:38 +01:00
The Quake sources as originally release under the GPL license on December 21, 1999
This commit is contained in:
Travis Bradshaw
935
WinQuake/zone.c
Normal file
935
WinQuake/zone.c
Normal file
@@ -0,0 +1,935 @@
|
||||
/*
|
||||
Copyright (C) 1996-1997 Id Software, Inc.
|
||||
|
||||
This program is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU General Public License
|
||||
as published by the Free Software Foundation; either version 2
|
||||
of the License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
See the GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
*/
|
||||
// Z_zone.c
|
||||
|
||||
#include "quakedef.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)
|
||||
Sys_Error ("Z_Free: NULL pointer");
|
||||
|
||||
block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
|
||||
if (block->id != ZONEID)
|
||||
Sys_Error ("Z_Free: freed a pointer without ZONEID");
|
||||
if (block->tag == 0)
|
||||
Sys_Error ("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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
========================
|
||||
Z_Malloc
|
||||
========================
|
||||
*/
|
||||
void *Z_Malloc (int size)
|
||||
{
|
||||
void *buf;
|
||||
|
||||
Z_CheckHeap (); // DEBUG
|
||||
buf = Z_TagMalloc (size, 1);
|
||||
if (!buf)
|
||||
Sys_Error ("Z_Malloc: failed on allocation of %i bytes",size);
|
||||
Q_memset (buf, 0, size);
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
void *Z_TagMalloc (int size, int tag)
|
||||
{
|
||||
int extra;
|
||||
memblock_t *start, *rover, *new, *base;
|
||||
|
||||
if (!tag)
|
||||
Sys_Error ("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 NULL;
|
||||
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: %i location: %p\n",mainzone->size,mainzone);
|
||||
|
||||
for (block = zone->blocklist.next ; ; block = block->next)
|
||||
{
|
||||
Con_Printf ("block:%p size:%7i tag:%3i\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)
|
||||
Sys_Error ("Z_CheckHeap: block size does not touch the next block\n");
|
||||
if ( block->next->prev != block)
|
||||
Sys_Error ("Z_CheckHeap: next block doesn't have proper back link\n");
|
||||
if (!block->tag && !block->next->tag)
|
||||
Sys_Error ("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;
|
||||
|
||||
byte *hunk_base;
|
||||
int hunk_size;
|
||||
|
||||
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 *)hunk_base ; (byte *)h != hunk_base + hunk_low_used ; )
|
||||
{
|
||||
if (h->sentinal != HUNK_SENTINAL)
|
||||
Sys_Error ("Hunk_Check: trahsed sentinal");
|
||||
if (h->size < 16 || h->size + (byte *)h - hunk_base > hunk_size)
|
||||
Sys_Error ("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 *)hunk_base;
|
||||
endlow = (hunk_t *)(hunk_base + hunk_low_used);
|
||||
starthigh = (hunk_t *)(hunk_base + hunk_size - hunk_high_used);
|
||||
endhigh = (hunk_t *)(hunk_base + hunk_size);
|
||||
|
||||
Con_Printf (" :%8i total hunk size\n", hunk_size);
|
||||
Con_Printf ("-------------------------\n");
|
||||
|
||||
while (1)
|
||||
{
|
||||
//
|
||||
// skip to the high hunk if done with low hunk
|
||||
//
|
||||
if ( h == endlow )
|
||||
{
|
||||
Con_Printf ("-------------------------\n");
|
||||
Con_Printf (" :%8i REMAINING\n", hunk_size - 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)
|
||||
Sys_Error ("Hunk_Check: trahsed sentinal");
|
||||
if (h->size < 16 || h->size + (byte *)h - hunk_base > hunk_size)
|
||||
Sys_Error ("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 :%8i %8s\n",h, h->size, name);
|
||||
|
||||
//
|
||||
// print the total
|
||||
//
|
||||
if (next == endlow || next == endhigh ||
|
||||
strncmp (h->name, next->name, 8) )
|
||||
{
|
||||
if (!all)
|
||||
Con_Printf (" :%8i %8s (TOTAL)\n",sum, name);
|
||||
count = 0;
|
||||
sum = 0;
|
||||
}
|
||||
|
||||
h = next;
|
||||
}
|
||||
|
||||
Con_Printf ("-------------------------\n");
|
||||
Con_Printf ("%8i total blocks\n", totalblocks);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
Hunk_AllocName
|
||||
===================
|
||||
*/
|
||||
void *Hunk_AllocName (int size, char *name)
|
||||
{
|
||||
hunk_t *h;
|
||||
|
||||
#ifdef PARANOID
|
||||
Hunk_Check ();
|
||||
#endif
|
||||
|
||||
if (size < 0)
|
||||
Sys_Error ("Hunk_Alloc: bad size: %i", size);
|
||||
|
||||
size = sizeof(hunk_t) + ((size+15)&~15);
|
||||
|
||||
if (hunk_size - hunk_low_used - hunk_high_used < size)
|
||||
Sys_Error ("Hunk_Alloc: failed on %i bytes",size);
|
||||
|
||||
h = (hunk_t *)(hunk_base + hunk_low_used);
|
||||
hunk_low_used += size;
|
||||
|
||||
Cache_FreeLow (hunk_low_used);
|
||||
|
||||
memset (h, 0, size);
|
||||
|
||||
h->size = size;
|
||||
h->sentinal = HUNK_SENTINAL;
|
||||
Q_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)
|
||||
Sys_Error ("Hunk_FreeToLowMark: bad mark %i", mark);
|
||||
memset (hunk_base + 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)
|
||||
Sys_Error ("Hunk_FreeToHighMark: bad mark %i", mark);
|
||||
memset (hunk_base + hunk_size - 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)
|
||||
Sys_Error ("Hunk_HighAllocName: bad size: %i", size);
|
||||
|
||||
if (hunk_tempactive)
|
||||
{
|
||||
Hunk_FreeToHighMark (hunk_tempmark);
|
||||
hunk_tempactive = false;
|
||||
}
|
||||
|
||||
#ifdef PARANOID
|
||||
Hunk_Check ();
|
||||
#endif
|
||||
|
||||
size = sizeof(hunk_t) + ((size+15)&~15);
|
||||
|
||||
if (hunk_size - hunk_low_used - hunk_high_used < size)
|
||||
{
|
||||
Con_Printf ("Hunk_HighAlloc: failed on %i bytes\n",size);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
hunk_high_used += size;
|
||||
Cache_FreeHigh (hunk_high_used);
|
||||
|
||||
h = (hunk_t *)(hunk_base + hunk_size - hunk_high_used);
|
||||
|
||||
memset (h, 0, size);
|
||||
h->size = size;
|
||||
h->sentinal = HUNK_SENTINAL;
|
||||
Q_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");
|
||||
|
||||
Q_memcpy ( new+1, c+1, c->size - sizeof(cache_system_t) );
|
||||
new->user = c->user;
|
||||
Q_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 >= hunk_base + 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 = NULL;
|
||||
while (1)
|
||||
{
|
||||
c = cache_head.prev;
|
||||
if (c == &cache_head)
|
||||
return; // nothing in cache at all
|
||||
if ( (byte *)c + c->size <= hunk_base + hunk_size - 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)
|
||||
Sys_Error ("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 = NULL;
|
||||
}
|
||||
|
||||
void Cache_MakeLRU (cache_system_t *cs)
|
||||
{
|
||||
if (cs->lru_next || cs->lru_prev)
|
||||
Sys_Error ("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 (hunk_size - hunk_high_used - hunk_low_used < size)
|
||||
Sys_Error ("Cache_TryAlloc: %i is greater then free hunk", size);
|
||||
|
||||
new = (cache_system_t *) (hunk_base + 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 *) (hunk_base + 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 ( hunk_base + hunk_size - 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 NULL; // 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
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
============
|
||||
Cache_Print
|
||||
|
||||
============
|
||||
*/
|
||||
void Cache_Print (void)
|
||||
{
|
||||
cache_system_t *cd;
|
||||
|
||||
for (cd = cache_head.next ; cd != &cache_head ; cd = cd->next)
|
||||
{
|
||||
Con_Printf ("%8i : %s\n", cd->size, cd->name);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
Cache_Report
|
||||
|
||||
============
|
||||
*/
|
||||
void Cache_Report (void)
|
||||
{
|
||||
Con_DPrintf ("%4.1f megabyte data cache\n", (hunk_size - hunk_high_used - hunk_low_used) / (float)(1024*1024) );
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
Cache_Compact
|
||||
|
||||
============
|
||||
*/
|
||||
void Cache_Compact (void)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
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)
|
||||
Sys_Error ("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 = NULL;
|
||||
|
||||
c->data = NULL;
|
||||
|
||||
Cache_UnlinkLRU (cs);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
==============
|
||||
Cache_Check
|
||||
==============
|
||||
*/
|
||||
void *Cache_Check (cache_user_t *c)
|
||||
{
|
||||
cache_system_t *cs;
|
||||
|
||||
if (!c->data)
|
||||
return NULL;
|
||||
|
||||
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)
|
||||
Sys_Error ("Cache_Alloc: allready allocated");
|
||||
|
||||
if (size <= 0)
|
||||
Sys_Error ("Cache_Alloc: size %i", size);
|
||||
|
||||
size = (size + sizeof(cache_system_t) + 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)
|
||||
Sys_Error ("Cache_Alloc: out of memory");
|
||||
// not enough memory at all
|
||||
Cache_Free ( cache_head.lru_prev->user );
|
||||
}
|
||||
|
||||
return Cache_Check (c);
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
|
||||
/*
|
||||
========================
|
||||
Memory_Init
|
||||
========================
|
||||
*/
|
||||
void Memory_Init (void *buf, int size)
|
||||
{
|
||||
int p;
|
||||
int zonesize = DYNAMIC_SIZE;
|
||||
|
||||
hunk_base = buf;
|
||||
hunk_size = size;
|
||||
hunk_low_used = 0;
|
||||
hunk_high_used = 0;
|
||||
|
||||
Cache_Init ();
|
||||
p = COM_CheckParm ("-zone");
|
||||
if (p)
|
||||
{
|
||||
if (p < com_argc-1)
|
||||
zonesize = Q_atoi (com_argv[p+1]) * 1024;
|
||||
else
|
||||
Sys_Error ("Memory_Init: you must specify a size in KB after -zone");
|
||||
}
|
||||
mainzone = Hunk_AllocName (zonesize, "zone" );
|
||||
Z_ClearZone (mainzone, zonesize);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user