CodeMirror/CnC_Remastered_Collection
1
0
Fork 0
mirror of https://github.com/electronicarts/CnC_Remastered_Collection synced 2024-05-12 00:02:37 +12:00
Code Issues Releases Wiki Activity
CnC_Remastered_Collection/TIBERIANDAWN/WIN32LIB/MEM.CPP
PG-SteveT 03416d24e1 Initial Source Code commit 
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
2020-05-27 12:16:20 -07:00

1087 lines
43 KiB
C++
Raw Blame History

//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code 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 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/***************************************************************************
** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S **
***************************************************************************
* *
* Project Name : Westwood Library *
* *
* File Name : MEM.C *
* *
* Programmer : Joe L. Bostic *
* Scott K. Bowen *
* *
* Start Date : March 31, 1993 *
* *
* Last Update : September 8, 1994 [IML] *
* *
*-------------------------------------------------------------------------*
* Functions: *
* Mem_Free -- Free a block of memory from system. *
* Mem_Alloc -- Allocate a block of memory from the special memory pool. *
* Mem_Init -- Initialize the private memory allocation pool. *
* Mem_Reference -- Updates the reference time for the specified memory blo*
* Mem_Find -- Returns with pointer to specified memory block. *
* Mem_Find_Oldest -- Returns with the memory block with the oldest time st*
* Mem_Free_Oldest -- Find and free the oldest memory block. *
* Mem_Avail -- Returns the amount of free memory available in the cache.*
* Mem_Cleanup -- Performes a garbage collection on the memory cache. *
* MemNode_Unlink -- Unlinks a node from the cache. *
* MemNode_Insert -- Inserts a node into a cache chain. *
* Mem_Largest_Avail -- Largest free block available. *
* Mem_Lock_Block -- Locks a block so that it cannot be moved in cleanup.*
* Mem_In_Use -- Makes it so a block will never be returned as oldest*
* Mem_Pool_Size -- Returns total amount of memory in pool. *
* Mem_Get_ID -- Returns ID of node. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include <wwstd.h>
#include "wwmem.h"
#include <timer.h>
#include <stddef.h>
//#include <mem.h>
#define DEBUG_FILL FALSE
////////////////////////////////////////////////////////////////////////////
/*******************************************************************************
** A allocated block may have one of three meanings in the Time field. The first
** is the time stamp of the last time it was referenced. The other two values
** are defined below. MEM_BLOCK_IN_USE means that it will never be returned as the
** oldest since there is no valid time stamp. LOCKED_BLOCK has the same meaning as
** MEM_BLOCK_IN_USE with the added feature that the block will not be moved in a
** Mem_Cleanup(). Therefore, there may be some fragmentation after the cleanup
** if any blocks are LOCKED. It would be good practice to seldomly lock blocks,
** for instance, only when a sample is being played.
** WARNING: If these values change to anything else, logic will need to be changed
** in Mem_Find_Oldest since it relies on these being small values.
*/
#define MEM_BLOCK_IN_USE 0x00
#define MEM_BLOCK_LOCKED 0x01
/*
** Each block of memory in the pool is headed by this structure.
*/
typedef struct MemChain {
struct MemChain *Next; // Pointer to next memory chain node.
struct MemChain *Prev; // Pointer to previous memory chain node.
unsigned long ID; // ID number of block.
unsigned short Time; // TickCount of latest reference.
unsigned long Size; // Size of memory block (in paragraphs).
} MemChain_Type;
/*
** Holding tank memory management data.
*/
typedef struct MemPool {
MemChain_Type *FreeChain; // Pointer to first node in free chain.
MemChain_Type *UsedChain; // Pointer to first node in used chain.
unsigned long FreeMem; // Current amount of free ram (in paragraphs).
unsigned long TotalMem; // Total quantity of memory.
long pad2;
} MemPool_Type;
/*=========================================================================*/
/* The following PRIVATE functions are in this file: */
/*=========================================================================*/
PRIVATE void MemNode_Unlink(MemPool_Type *pool, int freechain, MemChain_Type *node);
PRIVATE void MemNode_Insert(MemPool_Type *pool, int freechain, MemChain_Type *node, unsigned int size, unsigned long id, int merge);
/*= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =*/
/***************************************************************************
* Mem_Init -- Initialize the private memory allocation pool. *
* *
* This routine is used to initialize the private memory allocation *
* pool. *
* *
* INPUT: buffer -- Pointer to the buffer that is the allocation pool. *
* *
* size -- Size of the buffer in bytes. *
* *
* OUTPUT: TRUE/FALSE; Was it initialized successfully? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/31/1993 JLB : Created. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
int Mem_Init(void *buffer, long size)
{
MemChain_Type *mem; // Working memory chain node.
MemPool_Type *pool; // Memory pool control structure.
/*
** The buffer is rounded down to the nearest paragraph.
*/
size = size & 0xFFFFFFF0L;
if (!buffer || !size) return(FALSE);
/*
** Initialize the pool control structure.
*/
pool = (MemPool_Type *)buffer;
pool->FreeMem = (size - sizeof(MemPool_Type)) >> 4;
pool->UsedChain = NULL;
pool->TotalMem = pool->FreeMem;
mem = pool->FreeChain = (MemChain_Type *) (pool + 1);
/*
** Initialize the free memory chain.
*/
mem->Next = NULL;
mem->Prev = NULL;
mem->Size = pool->FreeMem;
mem->ID = -1;
mem->Time = 0;
return(TRUE);
}
/***************************************************************************
* Mem_Alloc -- Allocate a block of memory from the special memory pool. *
* *
* This routine will allocate a block of memory from the special *
* memory allocation pool. *
* *
* INPUT: poolptr -- Pointer to the memory pool base address. *
* *
* size -- The size of the memory block to allocate. *
* *
* id -- ID number to give this memory block. *
* *
* OUTPUT: Returns with a pointer to the allocated block. If there was *
* insufficient room, then NULL is returned. *
* *
* WARNINGS: Be sure to check for the NULL return case. *
* *
* HISTORY: *
* 03/31/1993 JLB : Created. *
* 08/06/1993 JLB : Optimized for low memory caches. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
void *Mem_Alloc(void *poolptr, long lsize, unsigned long id)
{
MemPool_Type *pool;
MemChain_Type *node; // Pointer to current memory node.
unsigned int remainder=0; // Remaining bytes that are still free.
int found;
unsigned int size; // Paragraph size of allocation.
/*
** If there is no free memory then the allocation will
** always fail.
*/
if (!poolptr || !lsize) return(NULL);
pool = (MemPool_Type *) poolptr;
/*
** Allocations are forced to be paragraph sized.
*/
lsize += sizeof(MemChain_Type); // Account for header.
lsize = (lsize + 0x0FL) & 0xFFFFFFF0L;
size = lsize >> 4;
/*
** If the total free is less than the size of the desired allocation,
** then we KNOW that an allocation will fail -- just return.
*/
if (pool->TotalMem < size) {
return(NULL);
}
/*
** Walk down free chain looking for the first block that will
** accomodate the allocation.
*/
node = pool->FreeChain;
found = FALSE;
while (!found && node) {
/*
** Fetch free memory chunk block and see if it is big enough.
*/
if (node->Size >= size) {
found = TRUE;
break;
}
node = node->Next;
}
if (!found) {
return(NULL);
}
/*
** Determine if this allocation would split the block.
*/
remainder = node->Size - size;
/*
** If only a very small free chunk would remain, just tack it on
** to the current allocation.
*/
if (remainder <= 2) {
remainder = 0;
size = node->Size;
}
/*
** Remove the primary block from the free memory list.
*/
MemNode_Unlink(pool, TRUE, node);
/*
** If a smaller block remains, then link it back into
** the free memory list.
*/
if (remainder) {
MemNode_Insert(pool, TRUE, (MemChain_Type *)Add_Long_To_Pointer(node, (long)size << 4), remainder, -1, FALSE);
}
/*
** Link in the allocated node into the used memory list.
*/
MemNode_Insert(pool, FALSE, node, size, id, FALSE);
/*
** Reflect the change to the total free count.
*/
pool->FreeMem -= size;
/*
** Return a pointer to the block of allocated memory just past
** the header.
*/
#if DEBUG_FILL
memset(node + 1, id, (size-1) << 4);
#endif
return((void *) (node + 1));
}
/***************************************************************************
* Mem_Free -- Free a block of memory from system. *
* *
* This routine will free a block of memory from the special memory *
* buffer. *
* *
* INPUT: poolptr -- Pointer to the memory pool base address. *
* *
* buffer -- Pointer to memory block to free. *
* *
* OUTPUT: TRUE/FALSE; Was the deallocation successful? *
* *
* WARNINGS: Be sure to only pass in to this routine a buffer that was *
* returned from Mem_Alloc(). *
* *
* HISTORY: *
* 03/31/1993 JLB : Created. *
* 08/06/1993 JLB : Optimized for low memory caches. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
int Mem_Free(void *poolptr, void *buffer)
{
MemPool_Type *pool; // pointer to structure.
MemChain_Type *node; // Copy of current memory node.
unsigned int size; // Size of the block being freed.
/*
** One can't free what isn't there.
*/
if (!buffer || !poolptr) {
return(FALSE);
}
pool = (MemPool_Type *) poolptr;
/*
** The node pointer is actually back a bit from the "normal" pointer.
*/
node = (MemChain_Type *) buffer;
node--;
/*
** Get pointer to actual allocated node and unlink it from the used
** memory chain.
*/
size = node->Size;
MemNode_Unlink(pool, FALSE, node);
MemNode_Insert(pool, TRUE, node, size, -1, TRUE);
/*
** Reflect the new free memory into the total memory count.
*/
pool->FreeMem += size;
return(TRUE);
}
/***************************************************************************
* Mem_Reference -- Updates the reference time for the specified memory blo*
* *
* This routine is used to update the memory reference time for the *
* specified memory node. Typically, this is called every time a *
* memory block is used in order to make sure the memory block time *
* tracking (Last Recently Used) system works properly. *
* *
* INPUT: node -- Pointer to memory block returned from Mem_Find. *
* *
* OUTPUT: none *
* *
* WARNINGS: The node pointer must be valid. For maximum safety this *
* routine should be called right after Mem_Find(). *
* *
* HISTORY: *
* 08/06/1993 JLB : Created. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
void Mem_Reference(void *node)
{
MemChain_Type *nodeptr; // Pointer of current memory node.
if (!node) return;
// Get to the node header.
nodeptr = (MemChain_Type *) node;
nodeptr--;
nodeptr->Time = (unsigned short)(TickCount.Time() >> 4);
}
/***************************************************************************
* MEM_LOCK_BLOCK -- Locks a block so that it cannot be moved in cleanup. *
* By marking a memory block in use, the memory system will never return*
* it as the oldest memory block. It also makes it so that the block *
* will never be moved during a Cleanup process. *
* *
* INPUT: node -- Pointer to memory block returned from Mem_Find. *
* *
* OUTPUT: none *
* *
* WARNINGS: If one or more blocks are locked in a heap, Mem_Avail might *
* not equal Mem_Largest_Avail after a call to Mem_Cleanup. *
* *
* HISTORY: *
* 04/15/1994 SKB : Created. *
*=========================================================================*/
void Mem_Lock_Block(void *node)
{
MemChain_Type *nodeptr; // Pointer of current memory node.
if (!node) return;
// Get to the node header.
nodeptr = (MemChain_Type *) node;
nodeptr--;
nodeptr->Time = MEM_BLOCK_LOCKED;
}
/***************************************************************************
* MEM_IN_USE -- Makes it so a block will never be returned as oldest *
* By marking a memory block in use, the memory system will never return*
* it as the oldest memory block. It still can be moved in the Cleanup *
* code. *
* *
* INPUT: node -- Pointer to memory block returned from Mem_Find. *
* *
* OUTPUT: none *
* *
* WARNINGS: Mem_Find_Oldest() will return NULL if only IN_USE blocks are *
* in memory. *
* HISTORY: *
* 04/15/1994 SKB : Created. *
*=========================================================================*/
void Mem_In_Use(void *node)
{
MemChain_Type *nodeptr; // Pointer of current memory node.
if (!node) return;
// Get to the node header.
nodeptr = (MemChain_Type *) node - 1;
nodeptr->Time = MEM_BLOCK_IN_USE;
}
/***************************************************************************
* Mem_Find -- Returns with pointer to specified memory block. *
* *
* Use this routine to convert a memory ID value into an actual memory *
* pointer. It sweeps through all of the 'cached' memory blocks and *
* returns with the matching block pointer. *
* *
* INPUT: poolptr -- Pointer to the memory cache block. *
* *
* id -- The ID of the block desired. *
* *
* OUTPUT: Returns with the pointer to the memory block. If NULL is *
* returned then the desired block is not in the memory cache. *
* *
* WARNINGS: This routine may return NULL if the memory block is not *
* present in the cache. *
* *
* HISTORY: *
* 08/06/1993 JLB : Created. *
* 08/06/1993 JLB : Optimized for low memory caches. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
void *Mem_Find(void *poolptr, unsigned long id)
{
MemPool_Type *pool; // pointer to structure.
MemChain_Type *node; // Working node structure.
if (!poolptr) return(NULL);
pool = (MemPool_Type *) poolptr;
/*
** Cannot free a node that is not on the UsedChain list.
*/
if (!pool->UsedChain) {
return(NULL);
}
/*
** Sweep through entire allocation chain to find
** the one with the matching ID.
*/
node = pool->UsedChain;
while (node) {
if (node->ID == id) {
return(node + 1);
}
node = node->Next;
}
return(NULL);
}
/***************************************************************************
* MEM_GET_ID -- Returns ID of node. *
* *
* INPUT: void *node - pointer to node. *
* *
* OUTPUT: The ID of the node that was supplied by user during Mem_Alloc().*
* *
* WARNINGS: pointer to node must be one that Mem_Alloc or *
* Mem_Find returned. **
* *
* HISTORY: *
* 04/18/1994 SKB : Created. *
*=========================================================================*/
unsigned long Mem_Get_ID(void *node)
{
MemChain_Type *nodeptr; // Pointer of current memory node.
if (!node) return (0L);
// Get to the node header.
nodeptr = (MemChain_Type *) node - 1;
return (nodeptr->ID);
}
/***************************************************************************
* Mem_Find_Oldest -- Returns with the memory block with the oldest time st*
* *
* Use this routine to find the memory block with the oldest time stamp *
* value. Typically, this is used when freeing memory blocks in the *
* cache in order to make room for a new memory block. *
* *
* INPUT: poolptr -- Pointer to the memory cache. *
* *
* OUTPUT: Returns with the pointer to the oldest memory block. If NULL *
* is returned, then the memory cache is empty. *
* *
* WARNINGS: This routine could return NULL. *
* *
* HISTORY: *
* 08/06/1993 JLB : Created. *
* 08/06/1993 JLB : Optimized for low memory caches. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
* 04/15/1994 SKB : Handle time wrap, locked blocks, and no_refenece blocks*
*=========================================================================*/
void *Mem_Find_Oldest(void *poolptr)
{
MemChain_Type *node; // Working node pointer.
MemChain_Type *oldnode; // Pointer to oldest block.
unsigned int oldtime; // Time of oldest block.
unsigned int basetime; // Time to mark our base time with.
unsigned int time; // basetime + time of node.
if (!poolptr) return(NULL);
/*
** Sweep through entire allocation chain to find
** the oldest referenced memory block.
*/
oldnode = NULL;
oldtime = 0;
node = ((MemPool_Type*) poolptr)->UsedChain;
basetime = (unsigned int)(TickCount.Time() >> 4);
while (node) {
/*
** Don't allow MEM_BLOCK_IN_USE or MEM_BLOCK_LOCKED to be returned.
*/
if (node->Time > MEM_BLOCK_LOCKED) {
/*
** Adjust time for wrap around (after about 5 hrs).
** times less then the base time will wrap up high while
** and times greater then base time will then be lower since
** any time greater has been on the thing a long time.
*/
time = node->Time - basetime ;
if (time < oldtime || !oldnode) {
oldtime = time;
oldnode = node;
}
}
node = node->Next;
}
/*
** Return with the value that matches the pointer that
** was allocated by the system previously.
*/
if (oldnode) {
oldnode++;
}
return(oldnode);
}
/***************************************************************************
* Mem_Free_Oldest -- Find and free the oldest memory block. *
* *
* This routine is used to free the oldest memory block in the memory *
* cache. This routine is typcially used in order to create more room *
* in the cache for a new allocation. *
* *
* INPUT: poolptr -- Pointer to the memory cache. *
* *
* OUTPUT: Returns with the node that it freed. Although this node is *
* is no longer valid, it may be used to mark that pointer as *
* invalid in the main code. *
* *
* WARNINGS: If this routine returns NULL, then no memory was freed. *
* *
* HISTORY: *
* 08/06/1993 JLB : Created. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
void *Mem_Free_Oldest(void *poolptr)
{
MemChain_Type *node; // Copy of pointer to oldest node.
if (!poolptr) return(NULL);
node = (MemChain *) Mem_Find_Oldest(poolptr);
if (Mem_Free(poolptr, node)) {
return(node);
}
return(NULL);
}
/***************************************************************************
* MEM_POOL_SIZE -- Returns total amount of memory in pool. *
* *
* INPUT: poolptr -- Pointer to the memory cache. *
* *
* OUTPUT: long total size of pool. i.e. largest possible allocation if *
* no memory was allocated. *
* *
* WARNINGS: *
* *
* HISTORY: *
* 04/18/1994 SKB : Created. *
*=========================================================================*/
long Mem_Pool_Size(void *poolptr)
{
MemPool_Type *pool; // Memory pool control structure.
long memtotal; // Total amount of memory free.
if (!poolptr) return(NULL);
pool = (MemPool_Type *) poolptr;
memtotal = ((long)pool->TotalMem) << 4;
memtotal -= sizeof(MemChain_Type);
memtotal = MAX(memtotal, (long)0);
return(memtotal);
}
/***************************************************************************
* Mem_Avail -- Returns the amount of free memory available in the cache. *
* *
* This routine examines the memory cache and returns the amount of *
* free memory available. This memory total MAY be fragmented but *
* after Mem_Cleanup() is called, an allocation of the amount returned *
* by this function is guaranteed. *
* *
* INPUT: poolptr -- Pointer to the memory cache. *
* *
* OUTPUT: Returns the largest allocation possible from the memory cache. *
* *
* WARNINGS: The value returned may represent the FRAGMENTED total *
* amount of memory free in the cache. *
* *
* HISTORY: *
* 08/06/1993 JLB : Created. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
long Mem_Avail(void *poolptr)
{
MemPool_Type *pool; // Memory pool control structure.
long memtotal; // Total amount of memory free.
if (!poolptr) return(NULL);
pool = (MemPool_Type *) poolptr;
memtotal = ((long)pool->FreeMem) << 4;
memtotal -= sizeof(MemChain_Type);
//memtotal -= sizeof(MemChain_Type) + 15;
memtotal = MAX(memtotal, (long)0);
return(memtotal);
}
/***************************************************************************
* MEM_LARGEST_AVAIL -- Largest free block available. *
* This routine examines the free node list to find the largest block *
* available. User can Mem_Alloc() this return size successfully. *
* *
* INPUT: poolptr -- Pointer to the memory cache. *
* *
* OUTPUT: Returns largest allocation currently possible from the cache. *
* *
* WARNINGS: *
* *
* HISTORY: *
* 04/15/1994 SKB : Created. *
*=========================================================================*/
long Mem_Largest_Avail(void *poolptr)
{
MemChain_Type *node; // Pointer to current memory node.
unsigned int size;
long truesize;
/*
** Make sure that it is a buffer.
*/
if (!poolptr) return(NULL);
/*
** Go through the entire free chain looking for the largest block.
*/
node = ((MemPool_Type *)poolptr)->FreeChain;
size = 0;
while (node) {
/*
** Fetch free memory chunk block and see if it is big enough.
*/
if (node->Size >= size) {
size = node->Size;
}
node = node->Next;
}
truesize = (long)size << 4;
truesize -= sizeof(MemChain_Type);
truesize = MAX(truesize, 0L);
return (truesize);
}
/***************************************************************************
* Mem_Cleanup -- Performs a garbage collection on the memory cache. *
* *
* This routine is used to coalesce all adjacent free blocks of *
* memory in the specified cache. As a result, all previous pointers *
* provided by Mem_Find() are invalidated. This routine consumes a *
* fair amount of time and should be called as infrequently as *
* possible. *
* *
* INPUT: poolptr -- Pointer to the memory cache. *
* *
* OUTPUT: none *
* *
* WARNINGS: This routine takes a significant amount of time! *
* If there are locked block in memory, the pool may still *
* be fragmented. *
* *
* HISTORY: *
* 08/06/1993 JLB : Created. *
* 08/06/1993 JLB : Updated for low memory caches. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
void Mem_Cleanup(void *poolptr)
{
MemPool_Type *pool; // Memory pool control structure.
MemChain_Type *free, // Pointer to first free area.
*cur; // Pointer to first used block that is after free.
unsigned long size;
unsigned long freesize;// Size of free heap at the end of the block.
if (!poolptr) return;
/*
** Fetch working copy of pool control structure.
*/
pool = (MemPool_Type *) poolptr;
/*
** Basic parameter and condition legality checks. If the memory pool
** has no free space, no free blocks, or no allocated blocks, then
** memory cleanup is unnecessary -- just exit.
*/
if (!pool->FreeMem || !pool->FreeChain || !pool->UsedChain) return;
freesize = pool->FreeMem;
free = pool->FreeChain;
pool->FreeChain = NULL;
cur = pool->UsedChain;
while (TRUE) {
/*
** Setup pointers so that free points to the first free block and cur
** points to the next used block after the free block.
*/
while (cur < free && cur) {
cur = cur->Next;
}
// All used blocks are at the front of the free. We are done.
if (!cur) {
break;
}
/*
** Do not allow a locked block to be moved.
*/
if (cur->Time == MEM_BLOCK_LOCKED) {
/*
** Figure the size of the new free block that we are creating.
** Subtract off the total block size.
** Add the node to the free list.
*/
size = (char *) cur - (char *) free;
size >>= 4;
freesize -= size;
MemNode_Insert(pool, TRUE, free, (unsigned int) size, -1, FALSE);
/*
** Time to find a new free position to start working from.
** Cur will be in the position just following.
*/
free = (MemChain_Type *) Add_Long_To_Pointer(cur, (unsigned long)cur->Size << 4);
cur = cur->Next;
while (free == cur) {
free = (MemChain_Type *) Add_Long_To_Pointer(cur, (unsigned long)cur->Size << 4);
cur = cur->Next;
}
// All used blocks are at the front of the free. We are done.
if (!cur) {
break;
}
} else {
// Copy the block up.
size = (unsigned long)cur->Size << 4;
Mem_Copy(cur, free, size);
cur = free;
// Change pointers of surrounding blocks.
if (cur->Next) {
cur->Next->Prev = cur;
}
if (cur->Prev) {
cur->Prev->Next = cur;
} else {
pool->UsedChain = cur;
}
// Change to next new free area.
free = (MemChain_Type *) Add_Long_To_Pointer(cur, size);
}
}
/*
** Now build the single free chunk.
*/
MemNode_Insert(pool, TRUE, free, freesize, -1, FALSE);
}
/***************************************************************************
* MemNode_Unlink -- Unlinks a node from the cache. *
* *
* A private routine the actually unlinks a memory block from the *
* memory cache. It doesn't perform a complete update of the memory *
* cache. *
* *
* INPUT: pool -- Pointer to the memory cache header (copy in real *
* memory). *
* *
* freechain-- Is the block part of the free memory chain? *
* *
* node -- Pointer to the node that will be unlinked. *
* *
* OUTPUT: none *
* *
* WARNINGS: This routine doesn't update memory totals. It is a support *
* function. *
* *
* HISTORY: *
* 08/06/1993 JLB : Created. *
* 04/13/1994 SKB : Update for 32 bit library, removed XMS calls, *
* optimized for low memory only. *
*=========================================================================*/
PRIVATE void MemNode_Unlink(MemPool_Type *pool, int freechain, MemChain_Type *node)
{
MemChain_Type *other; // Copy of node data to unlink.
MemChain_Type **chain; // A pointer to one of the chains pointer.
/*
** Check for parameter validity.
*/
if (!pool || !node) return;
/*
** Setup working pointer for the particular chain desired.
*/
if (freechain) {
chain = &pool->FreeChain;
} else {
chain = &pool->UsedChain;
}
/*
** Make adjustments to the previous node. If the pointer
** to the previous node is NULL then this indicates the
** first node in the list and thus the chain pointer needs
** to be updated instead.
*/
if (node->Prev) {
other = node->Prev;
other->Next = node->Next;
} else {
*chain = node->Next;
}
if (node->Next) {
other = node->Next;
other->Prev = node->Prev;
}
}
/***************************************************************************
* MemNode_Insert -- Inserts a node into a cache chain. *
* *
* This routine is used to add a node to a cache chain. Since nodes *
* do not contain double links, they must be placed in sequence. *
* *
* INPUT: pool -- Pointer to memory pool (must be in real memory). *
* *
* freechain-- Is the node to be inserted into the free chain? *
* *
* node -- Pointer to the node to insert. *
* *
* size -- Size of the memory block (in paragraphs). *
* *
* id -- The ID number to associate with this block. *
* *
* merge -- Merge inserted block with adjacent blocks. *
* *
* OUTPUT: return *
* *
* WARNINGS: This is a support routine. *
* *
* HISTORY: *
* 08/06/1993 JLB : Created. *
*=========================================================================*/
PRIVATE void MemNode_Insert(MemPool_Type *pool, int freechain, MemChain_Type *node, unsigned int size, unsigned long id, int merge)
{
MemChain_Type **chain; // Pointer to chain that will be linked.
MemChain_Type *prev, // Successor node pointer.
*next; // Predecessor node pointer.
int doit=TRUE; // Link the node into the list.
/*
** Determine if the parameters are valid.
*/
if (!pool || !node || !size) return;
/*
** Setup working pointer for the particular chain desired.
*/
if (freechain) {
chain = &pool->FreeChain;
} else {
chain = &pool->UsedChain;
}
/*
** Handle the "no node in list" condition (easiest).
*/
if (!*chain) {
node->Next = NULL;
node->Prev = NULL;
node->Size = size;
node->Time = (unsigned short)(TickCount.Time() >> 4);
node->ID = id;
*chain = node;
return;
}
/*
** Sweep through the memory chain looking for a likely spot
** to insert the new node. It will stop with "next" pointing
** to the node to come after the block to be inserted and "prev"
** will point to the node right before.
*/
prev = NULL;
next = *chain;
while (next && (next < node)) {
/*
** Move up the memory chain.
*/
prev = next;
next = next->Next;
}
/*
** Coallescing of adjacent blocks (if requested).
*/
if (merge) {
/*
** If the previous block is touching the block to insert
** then merely adjust the size of the previous block and
** that is all that is necessary.
*/
if (prev) {
if (((char *)prev + ((long)prev->Size << 4)) == ((char *) node)) {
prev->Size += size;
size = prev->Size;
node = prev;
prev = prev->Prev;
doit = FALSE;
}
}
/*
** If the following block is touching the block to insert
** then remove the following block and increase the size of
** the original insertion block by the size of the other
** block.
*/
if (next) {
if (((char *)node + ((long)size << 4)) == (char *)next) {
if (!doit) {
/*
** If the node was already merged with the previous block
** then merely increase the previous block's size
** and adjust it's next pointer appropriately.
*/
node->Size += next->Size;
node->Next = next->Next;
next = next->Next;
} else {
/*
** Increase the size of the current block and adjust
** the "next" pointer so that it gets fixed up
** accordingly.
*/
size += next->Size;
next = next->Next;
}
}
}
}
#if DEBUG_FILL
if (doit) {
memset(node + 1, 0xFF, (size - 1) << 4);
} else {
memset(node + 1, 0xFF, (node->Size - 1) << 4);
}
#endif
/*
** Fixup the node pointers.
*/
if (prev) {
prev->Next = node;
}else{
*chain = node;
}
if (next) {
next->Prev = node;
}
if (doit) {
node->Prev = prev;
node->Next = next;
node->Size = size;
node->Time = (unsigned short)(TickCount.Time() >> 4);
node->ID = id;
}
}
Reference in a new issue View git blame Copy permalink