v4k-git-backup/demos/ports/doom/src/z_zone.c

481 lines
11 KiB
C

// Emacs style mode select -*- C++ -*-
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
// Zone Memory Allocation. Neat.
//
//-----------------------------------------------------------------------------
#include "doom_config.h"
#include "z_zone.h"
#include "i_system.h"
#include "doomdef.h"
//
// 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.
//
// It is of no value to free a cachable block,
// because it will get overwritten automatically if needed.
//
#define ZONEID 0x1d4a11
#define MINFRAGMENT 64
typedef struct
{
// total bytes malloced, including header
int size;
// start / end cap for linked list
memblock_t blocklist;
memblock_t* rover;
} memzone_t;
memzone_t* mainzone;
//
// Z_ClearZone
//
void Z_ClearZone(memzone_t* zone)
{
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.user = (void*)zone;
zone->blocklist.tag = PU_STATIC;
zone->rover = block;
block->prev = block->next = &zone->blocklist;
// 0 indicates a free block.
block->user = 0;
block->size = zone->size - sizeof(memzone_t);
}
//
// Z_Init
//
void Z_Init(void)
{
memblock_t* block;
int size;
mainzone = (memzone_t*)I_ZoneBase(&size);
mainzone->size = size;
// set the entire zone to one free block
mainzone->blocklist.next =
mainzone->blocklist.prev =
block = (memblock_t*)((byte*)mainzone + sizeof(memzone_t));
mainzone->blocklist.user = (void*)mainzone;
mainzone->blocklist.tag = PU_STATIC;
mainzone->rover = block;
block->prev = block->next = &mainzone->blocklist;
// 0 indicates a free block.
block->user = 0;
block->size = mainzone->size - sizeof(memzone_t);
}
//
// Z_Free
//
void Z_Free(void* ptr)
{
memblock_t* block;
memblock_t* other;
block = (memblock_t*)((byte*)ptr - sizeof(memblock_t));
if (block->id != ZONEID)
I_Error("Error: Z_Free: freed a pointer without ZONEID");
if (block->user > (void**)0x100)
{
// smaller values are not pointers
// Note: OS-dependend?
// clear the user's mark
*block->user = 0;
}
// mark as free
block->user = 0;
block->tag = 0;
block->id = 0;
other = block->prev;
if (!other->user)
{
// 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->user)
{
// 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
// You can pass a 0 user if the tag is < PU_PURGELEVEL.
//
void* Z_Malloc(int size, int tag, void* user)
{
int extra;
memblock_t* start;
memblock_t* rover;
memblock_t* newblock;
memblock_t* base;
size = (size + 3) & ~3;
// scan through the block list,
// looking for the first free block
// of sufficient size,
// throwing out any purgable blocks along the way.
// account for size of block header
size += sizeof(memblock_t);
// if there is a free block behind the rover,
// back up over them
base = mainzone->rover;
if (!base->prev->user)
base = base->prev;
rover = base;
start = base->prev;
do
{
if (rover == start)
{
// scanned all the way around the list
//I_Error("Error: Z_Malloc: failed on allocation of %i bytes", size);
doom_strcpy(error_buf, "Error: Z_Malloc: failed on allocation of ");
doom_concat(error_buf, doom_itoa(size, 10));
doom_concat(error_buf, " bytes");
I_Error(error_buf);
}
if (rover->user)
{
if (rover->tag < PU_PURGELEVEL)
{
// hit a block that can't be purged,
// so move base past it
base = rover = rover->next;
}
else
{
// free the rover block (adding the size to base)
// the rover can be the base block
base = base->prev;
Z_Free((byte*)rover + sizeof(memblock_t));
base = base->next;
rover = base->next;
}
}
else
rover = rover->next;
} while (base->user || 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
newblock = (memblock_t*)((byte*)base + size);
newblock->size = extra;
// 0 indicates free block.
newblock->user = 0;
newblock->tag = 0;
newblock->prev = base;
newblock->next = base->next;
newblock->next->prev = newblock;
base->next = newblock;
base->size = size;
}
if (user)
{
// mark as an in use block
base->user = user;
*(void**)user = (void*)((byte*)base + sizeof(memblock_t));
}
else
{
if (tag >= PU_PURGELEVEL)
I_Error("Error: Z_Malloc: an owner is required for purgable blocks");
// mark as in use, but unowned
base->user = (void*)2;
}
base->tag = tag;
// next allocation will start looking here
mainzone->rover = base->next;
base->id = ZONEID;
return (void*)((byte*)base + sizeof(memblock_t));
}
//
// Z_FreeTags
//
void Z_FreeTags(int lowtag, int hightag)
{
memblock_t* block;
memblock_t* next;
for (block = mainzone->blocklist.next;
block != &mainzone->blocklist;
block = next)
{
// get link before freeing
next = block->next;
// free block?
if (!block->user)
continue;
if (block->tag >= lowtag && block->tag <= hightag)
Z_Free((byte*)block + sizeof(memblock_t));
}
}
//
// Z_DumpHeap
// Note: TFileDumpHeap( stdout ) ?
//
void Z_DumpHeap(int lowtag, int hightag)
{
memblock_t* block;
//doom_print("zone size: %i location: %p\n",
// mainzone->size, mainzone);
doom_print("zone size: ");
doom_print(doom_itoa(mainzone->size, 10));
doom_print(" location: ");
doom_print(doom_ptoa(mainzone));
doom_print("\n");
//doom_print("tag range: %i to %i\n",
// lowtag, hightag);
doom_print("tag range: ");
doom_print(doom_itoa(lowtag, 10));
doom_print(" to ");
doom_print(doom_itoa(hightag, 10));
doom_print("\n");
for (block = mainzone->blocklist.next; ; block = block->next)
{
if (block->tag >= lowtag && block->tag <= hightag)
{
//doom_print("block:%p size:%7i user:%p tag:%3i\n", block, block->size, block->user, block->tag);
doom_print("block");
doom_print(doom_ptoa(block));
doom_print(" size:");
doom_print(doom_itoa(block->size, 10));
doom_print(" user:");
doom_print(doom_ptoa(block->user));
doom_print(" tag:");
doom_print(doom_itoa(block->tag, 10));
doom_print("\n");
}
if (block->next == &mainzone->blocklist)
{
// all blocks have been hit
break;
}
if ((byte*)block + block->size != (byte*)block->next)
doom_print("ERROR: block size does not touch the next block\n");
if (block->next->prev != block)
doom_print("ERROR: next block doesn't have proper back link\n");
if (!block->user && !block->next->user)
doom_print("ERROR: two consecutive free blocks\n");
}
}
//
// Z_FileDumpHeap
//
void Z_FileDumpHeap(void* f)
{
memblock_t* block;
//fprintf(f, "zone size: %i location: %p\n", mainzone->size, mainzone);
doom_fprint(f, "zone size: ");
doom_fprint(f, doom_itoa(mainzone->size, 10));
doom_fprint(f, " location: ");
doom_fprint(f, doom_ptoa(mainzone));
doom_fprint(f, "\n");
for (block = mainzone->blocklist.next; ; block = block->next)
{
//fprintf(f, "block:%p size:%7i user:%p tag:%3i\n",
// block, block->size, block->user, block->tag);
doom_fprint(f, "block:");
doom_fprint(f, doom_ptoa(block));
doom_fprint(f, " size:");
doom_fprint(f, doom_itoa(block->size, 10)); // Supposed to alignt 7, this is not worth the trouble
doom_fprint(f, " user:");
doom_fprint(f, doom_ptoa(block->user));
doom_fprint(f, " tag:");
doom_fprint(f, doom_itoa(block->tag, 10));
doom_fprint(f, "\n");
if (block->next == &mainzone->blocklist)
{
// all blocks have been hit
break;
}
if ((byte*)block + block->size != (byte*)block->next)
doom_fprint(f, "ERROR: block size does not touch the next block\n");
if (block->next->prev != block)
doom_fprint(f, "ERROR: next block doesn't have proper back link\n");
if (!block->user && !block->next->user)
doom_fprint(f, "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)
{
// all blocks have been hit
break;
}
if ((byte*)block + block->size != (byte*)block->next)
I_Error("Error: Z_CheckHeap: block size does not touch the next block\n");
if (block->next->prev != block)
I_Error("Error: Z_CheckHeap: next block doesn't have proper back link\n");
if (!block->user && !block->next->user)
I_Error("Error: Z_CheckHeap: two consecutive free blocks\n");
}
}
//
// Z_ChangeTag
//
void Z_ChangeTag2(void* ptr, int tag)
{
memblock_t* block;
block = (memblock_t*)((byte*)ptr - sizeof(memblock_t));
if (block->id != ZONEID)
I_Error("Error: Z_ChangeTag: freed a pointer without ZONEID");
if (tag >= PU_PURGELEVEL && (unsigned long long)block->user < 0x100)
I_Error("Error: Z_ChangeTag: an owner is required for purgable blocks");
block->tag = tag;
}
//
// Z_FreeMemory
//
int Z_FreeMemory(void)
{
memblock_t* block;
int free;
free = 0;
for (block = mainzone->blocklist.next;
block != &mainzone->blocklist;
block = block->next)
{
if (!block->user || block->tag >= PU_PURGELEVEL)
free += block->size;
}
return free;
}