zone.c

quake1 dos源代码最新版本

/*
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	// 48K	// 2001-09-20 Increased default zone by Maddes

#define	ZONEID	0x1d4a11
#define MINFRAGMENT	64

// 2001-09-20 Enhanced zone handling by Maddes  start
/*
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;
*/
// 2001-09-20 Enhanced zone handling by Maddes  end

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);	// 2001-09-20 Enhanced zone handling by Maddes

// 2001-09-20 Enhanced zone handling by Maddes  start
typedef struct
{
	int		sentinal;
	int		size;		// including sizeof(hunk_t), -1 = not allocated
	char	name[8];
} hunk_t;
// 2001-09-20 Enhanced zone handling by Maddes  end

/*
========================
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 (memzone_t *zone, void *ptr)	// 2001-09-20 Enhanced zone handling by Maddes
{
	memblock_t	*block, *other;
// 2001-09-20 Enhanced zone handling by Maddes  start
	hunk_t	*h;

	h = (hunk_t *)zone;
	h--;
// 2001-09-20 Enhanced zone handling by Maddes  end

	if (!ptr)
		Sys_Error ("Z_Free: NULL pointer");

	block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
	if (block->id != ZONEID)
// 2001-09-20 Enhanced zone handling by Maddes  start
	{
//		Sys_Error ("Z_Free: freed a pointer without ZONEID");
// 2001-09-20 QuakeC string manipulation by FrikaC/Maddes  start
//		Sys_Error ("Z_Free: freed a pointer without ZONEID in \"%s\"", h->name);
		Con_DPrintf("Z_Free: freed a pointer without ZONEID in \"%s\"\n", h->name);
		return;
// 2001-09-20 QuakeC string manipulation by FrikaC/Maddes  end
	}
// 2001-09-20 Enhanced zone handling by Maddes  end
	if (block->tag == 0)
// 2001-09-20 Enhanced zone handling by Maddes  start
	{
//		Sys_Error ("Z_Free: freed a freed pointer");
		Sys_Error ("Z_Free: freed a freed pointer in \"%s\"", h->name);
	}
// 2001-09-20 Enhanced zone handling by Maddes  end

// 2001-09-20 Enhanced zone handling by Maddes  start
	if (block->zone != zone)
	{
		Sys_Error ("Z_Free: freed a foreign pointer in \"%s\"\n", h->name);
	}
// 2001-09-20 Enhanced zone handling by Maddes  end

	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 == zone->rover)	// 2001-09-20 Enhanced zone handling by Maddes
			zone->rover = other;	// 2001-09-20 Enhanced zone handling by Maddes
		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 == zone->rover)	// 2001-09-20 Enhanced zone handling by Maddes
			zone->rover = block;	// 2001-09-20 Enhanced zone handling by Maddes
	}
}


/*
========================
Z_Malloc
========================
*/
void *Z_Malloc (memzone_t *zone, int size)	// 2001-09-20 Enhanced zone handling by Maddes
{
	void	*buf;

	Z_CheckHeap (zone);	// DEBUG	// 2001-09-20 Enhanced zone handling by Maddes
	buf = Z_TagMalloc (zone, size, 1);	// 2001-09-20 Enhanced zone handling by Maddes
	if (!buf)
// 2001-09-20 Enhanced zone handling by Maddes  start
	{
		hunk_t	*h;

		h = (hunk_t *)zone;
		h--;

//		Sys_Error ("Z_Malloc: failed on allocation of %i bytes",size);
		Sys_Error ("Z_Malloc: failed on allocation of %i bytes in \"%s\"", size, h->name);
	}
// 2001-09-20 Enhanced zone handling by Maddes  end

	Q_memset (buf, 0, size);

	return buf;
}

void *Z_TagMalloc (memzone_t *zone, int size, int tag)	// 2001-09-20 Enhanced zone handling by Maddes
{
	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 = zone->rover;	// 2001-09-20 Enhanced zone handling by Maddes
	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

	zone->rover = base->next;	// next allocation will start looking here
								// 2001-09-20 Enhanced zone handling by Maddes

	base->id = ZONEID;

	base->zone = zone;		// 2001-09-20 Enhanced zone handling by Maddes

// 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", zone->size, zone);	// 2001-09-20 Enhanced zone handling by Maddes

	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 (memzone_t *zone)	// 2001-09-20 Enhanced zone handling by Maddes
{
	memblock_t	*block;

	for (block = zone->blocklist.next ; ; block = block->next)	// 2001-09-20 Enhanced zone handling by Maddes
	{
		if (block->next == &zone->blocklist)	// 2001-09-20 Enhanced zone handling by Maddes
			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

// 2001-09-20 Enhanced zone handling by Maddes  start
/*
typedef struct
{
	int		sentinal;
	int		size;		// including sizeof(hunk_t), -1 = not allocated
	char	name[8];
} hunk_t;
*/
// 2001-09-20 Enhanced zone handling by Maddes  end

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 trashing 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: trashed 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: trashed 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);
}

// 2001-09-20 Hunklist command by Maddes  start
/*
===================
Hunk_Print_f
===================
*/
void Hunk_Print_f(void)
{
	qboolean	showall;

	showall = 0;
	if (Cmd_Argc() > 1)
	{
		showall = Q_atoi(Cmd_Argv(1));
	}

	Hunk_Print(showall);
}
// 2001-09-20 Hunklist command by Maddes  end

/*
===================
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;
	strncpy (h->name, name, 8);

	return (void *)(h+1);
}

/*
===================
Hunk_Alloc
===================
*/
void *Hunk_Alloc (int size)
{
	return Hunk_AllocName (size, "unknown");
}