X-Git-Url: http://4ch.mooo.com/gitweb/?a=blobdiff_plain;f=16%2Fwf3d8086%2Fid_mm.c;fp=16%2Fwf3d8086%2Fid_mm.c;h=8d44c050fe3d64e6b76816c1e7909e423d8c6ab8;hb=d564176a4080e188751df2ae2363f272c62bf452;hp=0000000000000000000000000000000000000000;hpb=e3dc8b5d9b956b94d22e8e1d8dd13ab4dd912f3a;p=16.git

diff --git a/16/wf3d8086/id_mm.c b/16/wf3d8086/id_mm.c
new file mode 100755
index 00000000..8d44c050
--- /dev/null
+++ b/16/wf3d8086/id_mm.c
@@ -0,0 +1,953 @@
+// NEWMM.C
+
+/*
+=============================================================================
+
+		   ID software memory manager
+		   --------------------------
+
+Primary coder: John Carmack
+
+RELIES ON
+---------
+Quit (char *error) function
+
+
+WORK TO DO
+----------
+MM_SizePtr to change the size of a given pointer
+
+Multiple purge levels utilized
+
+EMS / XMS unmanaged routines
+
+=============================================================================
+*/
+
+#include "ID_HEADS.H"
+#pragma hdrstop
+
+#pragma warn -pro
+#pragma warn -use
+
+/*
+=============================================================================
+
+							LOCAL INFO
+
+=============================================================================
+*/
+
+#define LOCKBIT		0x80	// if set in attributes, block cannot be moved
+#define PURGEBITS	3		// 0-3 level, 0= unpurgable, 3= purge first
+#define PURGEMASK	0xfffc
+#define BASEATTRIBUTES	0	// unlocked, non purgable
+
+#define MAXUMBS		10
+
+typedef struct mmblockstruct
+{
+	unsigned	start,length;
+	unsigned	attributes;
+	memptr		*useptr;	// pointer to the segment start
+	struct mmblockstruct far *next;
+} mmblocktype;
+
+
+//#define GETNEWBLOCK {if(!(mmnew=mmfree))Quit("MM_GETNEWBLOCK: No free blocks!")\
+//	;mmfree=mmfree->next;}
+
+#define GETNEWBLOCK {if(!mmfree)MML_ClearBlock();mmnew=mmfree;mmfree=mmfree->next;}
+
+#define FREEBLOCK(x) {*x->useptr=NULL;x->next=mmfree;mmfree=x;}
+
+/*
+=============================================================================
+
+						 GLOBAL VARIABLES
+
+=============================================================================
+*/
+
+mminfotype	mminfo;
+memptr		bufferseg;
+boolean		mmerror;
+
+void		(* beforesort) (void);
+void		(* aftersort) (void);
+
+/*
+=============================================================================
+
+						 LOCAL VARIABLES
+
+=============================================================================
+*/
+
+boolean		mmstarted;
+
+void far	*farheap;
+void		*nearheap;
+
+mmblocktype	far mmblocks[MAXBLOCKS]
+			,far *mmhead,far *mmfree,far *mmrover,far *mmnew;
+
+boolean		bombonerror;
+
+//unsigned	totalEMSpages,freeEMSpages,EMSpageframe,EMSpagesmapped,EMShandle;
+
+void		(* XMSaddr) (void);		// far pointer to XMS driver
+
+unsigned	numUMBs,UMBbase[MAXUMBS];
+
+//==========================================================================
+
+//
+// local prototypes
+//
+
+boolean		MML_CheckForEMS (void);
+void 		MML_ShutdownEMS (void);
+void 		MM_MapEMS (void);
+boolean 	MML_CheckForXMS (void);
+void 		MML_ShutdownXMS (void);
+void		MML_UseSpace (unsigned segstart, unsigned seglength);
+void 		MML_ClearBlock (void);
+
+//==========================================================================
+
+/*
+======================
+=
+= MML_CheckForXMS
+=
+= Check for XMM driver
+=
+=======================
+*/
+
+boolean MML_CheckForXMS (void)
+{
+	numUMBs = 0;
+
+asm {
+	mov	ax,0x4300
+	int	0x2f				// query status of installed diver
+	cmp	al,0x80
+	je	good
+	}
+
+	return false;
+good:
+	return true;
+}
+
+
+/*
+======================
+=
+= MML_SetupXMS
+=
+= Try to allocate all upper memory block
+=
+=======================
+*/
+
+void MML_SetupXMS (void)
+{
+	unsigned	base,size;
+
+asm	{
+	mov	ax,0x4310
+	int	0x2f
+	mov	[WORD PTR XMSaddr],bx
+	mov	[WORD PTR XMSaddr+2],es		// function pointer to XMS driver
+	}
+
+getmemory:
+asm	{
+	mov	ah,XMS_ALLOCUMB
+	mov	dx,0xffff					// try for largest block possible
+	call	[DWORD PTR XMSaddr]
+	or	ax,ax
+	jnz	gotone
+
+	cmp	bl,0xb0						// error: smaller UMB is available
+	jne	done;
+
+	mov	ah,XMS_ALLOCUMB
+	call	[DWORD PTR XMSaddr]		// DX holds largest available UMB
+	or	ax,ax
+	jz	done						// another error...
+	}
+
+gotone:
+asm	{
+	mov	[base],bx
+	mov	[size],dx
+	}
+	MML_UseSpace (base,size);
+	mminfo.XMSmem += size*16;
+	UMBbase[numUMBs] = base;
+	numUMBs++;
+	if (numUMBs < MAXUMBS)
+		goto getmemory;
+
+done:;
+}
+
+
+/*
+======================
+=
+= MML_ShutdownXMS
+=
+======================
+*/
+
+void MML_ShutdownXMS (void)
+{
+	int	i;
+	unsigned	base;
+
+	for (i=0;i<numUMBs;i++)
+	{
+		base = UMBbase[i];
+
+asm	mov	ah,XMS_FREEUMB
+asm	mov	dx,[base]
+asm	call	[DWORD PTR XMSaddr]
+	}
+}
+
+//==========================================================================
+
+/*
+======================
+=
+= MML_UseSpace
+=
+= Marks a range of paragraphs as usable by the memory manager
+= This is used to mark space for the near heap, far heap, ems page frame,
+= and upper memory blocks
+=
+======================
+*/
+
+void MML_UseSpace (unsigned segstart, unsigned seglength)
+{
+	mmblocktype far *scan,far *last;
+	unsigned	oldend;
+	long		extra;
+
+	scan = last = mmhead;
+	mmrover = mmhead;		// reset rover to start of memory
+
+//
+// search for the block that contains the range of segments
+//
+	while (scan->start+scan->length < segstart)
+	{
+		last = scan;
+		scan = scan->next;
+	}
+
+//
+// take the given range out of the block
+//
+	oldend = scan->start + scan->length;
+	extra = oldend - (segstart+seglength);
+	if (extra < 0)
+		Quit ("MML_UseSpace: Segment spans two blocks!");
+
+	if (segstart == scan->start)
+	{
+		last->next = scan->next;			// unlink block
+		FREEBLOCK(scan);
+		scan = last;
+	}
+	else
+		scan->length = segstart-scan->start;	// shorten block
+
+	if (extra > 0)
+	{
+		GETNEWBLOCK;
+		mmnew->useptr = NULL;
+
+		mmnew->next = scan->next;
+		scan->next = mmnew;
+		mmnew->start = segstart+seglength;
+		mmnew->length = extra;
+		mmnew->attributes = LOCKBIT;
+	}
+
+}
+
+//==========================================================================
+
+/*
+====================
+=
+= MML_ClearBlock
+=
+= We are out of blocks, so free a purgable block
+=
+====================
+*/
+
+void MML_ClearBlock (void)
+{
+	mmblocktype far *scan,far *last;
+
+	scan = mmhead->next;
+
+	while (scan)
+	{
+		if (!(scan->attributes&LOCKBIT) && (scan->attributes&PURGEBITS) )
+		{
+			MM_FreePtr(scan->useptr);
+			return;
+		}
+		scan = scan->next;
+	}
+
+	Quit ("MM_ClearBlock: No purgable blocks!");
+}
+
+
+//==========================================================================
+
+/*
+===================
+=
+= MM_Startup
+=
+= Grabs all space from turbo with malloc/farmalloc
+= Allocates bufferseg misc buffer
+=
+===================
+*/
+
+static	char *ParmStrings[] = {"noems","noxms",""};
+
+void MM_Startup (void)
+{
+	int i;
+	unsigned 	long length;
+	void far 	*start;
+	unsigned 	segstart,seglength,endfree;
+
+	if (mmstarted)
+		MM_Shutdown ();
+
+
+	mmstarted = true;
+	bombonerror = true;
+//
+// set up the linked list (everything in the free list;
+//
+	mmhead = NULL;
+	mmfree = &mmblocks[0];
+	for (i=0;i<MAXBLOCKS-1;i++)
+		mmblocks[i].next = &mmblocks[i+1];
+	mmblocks[i].next = NULL;
+
+//
+// locked block of all memory until we punch out free space
+//
+	GETNEWBLOCK;
+	mmhead = mmnew;				// this will allways be the first node
+	mmnew->start = 0;
+	mmnew->length = 0xffff;
+	mmnew->attributes = LOCKBIT;
+	mmnew->next = NULL;
+	mmrover = mmhead;
+
+
+//
+// get all available near conventional memory segments
+//
+	length=coreleft();
+	start = (void far *)(nearheap = malloc(length));
+
+	length -= 16-(FP_OFF(start)&15);
+	length -= SAVENEARHEAP;
+	seglength = length / 16;			// now in paragraphs
+	segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;
+	MML_UseSpace (segstart,seglength);
+	mminfo.nearheap = length;
+
+//
+// get all available far conventional memory segments
+//
+	length=farcoreleft();
+	start = farheap = farmalloc(length);
+	length -= 16-(FP_OFF(start)&15);
+	length -= SAVEFARHEAP;
+	seglength = length / 16;			// now in paragraphs
+	segstart = FP_SEG(start)+(FP_OFF(start)+15)/16;
+	MML_UseSpace (segstart,seglength);
+	mminfo.farheap = length;
+	mminfo.mainmem = mminfo.nearheap + mminfo.farheap;
+
+//
+// allocate the misc buffer
+//
+	mmrover = mmhead;		// start looking for space after low block
+
+	MM_GetPtr (&bufferseg,BUFFERSIZE);
+}
+
+//==========================================================================
+
+/*
+====================
+=
+= MM_Shutdown
+=
+= Frees all conventional, EMS, and XMS allocated
+=
+====================
+*/
+
+void MM_Shutdown (void)
+{
+  if (!mmstarted)
+	return;
+
+  farfree (farheap);
+  free (nearheap);
+//  MML_ShutdownXMS ();
+}
+
+//==========================================================================
+
+/*
+====================
+=
+= MM_GetPtr
+=
+= Allocates an unlocked, unpurgable block
+=
+====================
+*/
+
+void MM_GetPtr (memptr *baseptr,unsigned long size)
+{
+	mmblocktype far *scan,far *lastscan,far *endscan
+				,far *purge,far *next;
+	int			search;
+	unsigned	needed,startseg;
+
+	needed = (size+15)/16;		// convert size from bytes to paragraphs
+
+	GETNEWBLOCK;				// fill in start and next after a spot is found
+	mmnew->length = needed;
+	mmnew->useptr = baseptr;
+	mmnew->attributes = BASEATTRIBUTES;
+
+tryagain:
+	for (search = 0; search<3; search++)
+	{
+	//
+	// first search:	try to allocate right after the rover, then on up
+	// second search: 	search from the head pointer up to the rover
+	// third search:	compress memory, then scan from start
+		if (search == 1 && mmrover == mmhead)
+			search++;
+
+		switch (search)
+		{
+		case 0:
+			lastscan = mmrover;
+			scan = mmrover->next;
+			endscan = NULL;
+			break;
+		case 1:
+			lastscan = mmhead;
+			scan = mmhead->next;
+			endscan = mmrover;
+			break;
+		case 2:
+			MM_SortMem ();
+			lastscan = mmhead;
+			scan = mmhead->next;
+			endscan = NULL;
+			break;
+		}
+
+		startseg = lastscan->start + lastscan->length;
+
+		while (scan != endscan)
+		{
+			if (scan->start - startseg >= needed)
+			{
+			//
+			// got enough space between the end of lastscan and
+			// the start of scan, so throw out anything in the middle
+			// and allocate the new block
+			//
+				purge = lastscan->next;
+				lastscan->next = mmnew;
+				mmnew->start = *(unsigned *)baseptr = startseg;
+				mmnew->next = scan;
+				while ( purge != scan)
+				{	// free the purgable block
+					next = purge->next;
+					FREEBLOCK(purge);
+					purge = next;		// purge another if not at scan
+				}
+				mmrover = mmnew;
+				return;	// good allocation!
+			}
+
+			//
+			// if this block is purge level zero or locked, skip past it
+			//
+			if ( (scan->attributes & LOCKBIT)
+				|| !(scan->attributes & PURGEBITS) )
+			{
+				lastscan = scan;
+				startseg = lastscan->start + lastscan->length;
+			}
+
+
+			scan=scan->next;		// look at next line
+		}
+	}
+
+	if (bombonerror)
+	{
+
+extern char configname[];
+extern	boolean	insetupscaling;
+extern	int	viewsize;
+boolean SetViewSize (unsigned width, unsigned height);
+#define HEIGHTRATIO		0.50
+//
+// wolf hack -- size the view down
+//
+		if (!insetupscaling && viewsize>10)
+		{
+mmblocktype	far *savedmmnew;
+			savedmmnew = mmnew;
+			viewsize -= 2;
+			SetViewSize (viewsize*16,viewsize*16*HEIGHTRATIO);
+			mmnew = savedmmnew;
+			goto tryagain;
+		}
+
+//		unlink(configname);
+		Quit ("MM_GetPtr: Out of memory!");
+	}
+	else
+		mmerror = true;
+}
+
+//==========================================================================
+
+/*
+====================
+=
+= MM_FreePtr
+=
+= Deallocates an unlocked, purgable block
+=
+====================
+*/
+
+void MM_FreePtr (memptr *baseptr)
+{
+	mmblocktype far *scan,far *last;
+
+	last = mmhead;
+	scan = last->next;
+
+	if (baseptr == mmrover->useptr)	// removed the last allocated block
+		mmrover = mmhead;
+
+	while (scan->useptr != baseptr && scan)
+	{
+		last = scan;
+		scan = scan->next;
+	}
+
+	if (!scan)
+		Quit ("MM_FreePtr: Block not found!");
+
+	last->next = scan->next;
+
+	FREEBLOCK(scan);
+}
+//==========================================================================
+
+/*
+=====================
+=
+= MM_SetPurge
+=
+= Sets the purge level for a block (locked blocks cannot be made purgable)
+=
+=====================
+*/
+
+void MM_SetPurge (memptr *baseptr, int purge)
+{
+	mmblocktype far *start;
+
+	start = mmrover;
+
+	do
+	{
+		if (mmrover->useptr == baseptr)
+			break;
+
+		mmrover = mmrover->next;
+
+		if (!mmrover)
+			mmrover = mmhead;
+		else if (mmrover == start)
+			Quit ("MM_SetPurge: Block not found!");
+
+	} while (1);
+
+	mmrover->attributes &= ~PURGEBITS;
+	mmrover->attributes |= purge;
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_SetLock
+=
+= Locks / unlocks the block
+=
+=====================
+*/
+
+void MM_SetLock (memptr *baseptr, boolean locked)
+{
+	mmblocktype far *start;
+
+	start = mmrover;
+
+	do
+	{
+		if (mmrover->useptr == baseptr)
+			break;
+
+		mmrover = mmrover->next;
+
+		if (!mmrover)
+			mmrover = mmhead;
+		else if (mmrover == start)
+			Quit ("MM_SetLock: Block not found!");
+
+	} while (1);
+
+	mmrover->attributes &= ~LOCKBIT;
+	mmrover->attributes |= locked*LOCKBIT;
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_SortMem
+=
+= Throws out all purgable stuff and compresses movable blocks
+=
+=====================
+*/
+
+void MM_SortMem (void)
+{
+	mmblocktype far *scan,far *last,far *next;
+	unsigned	start,length,source,dest;
+	int			playing;
+
+	//
+	// lock down a currently playing sound
+	//
+	playing = SD_SoundPlaying ();
+	if (playing)
+	{
+		switch (SoundMode)
+		{
+		case sdm_PC:
+			playing += STARTPCSOUNDS;
+			break;
+		case sdm_AdLib:
+			playing += STARTADLIBSOUNDS;
+			break;
+		}
+		MM_SetLock(&(memptr)audiosegs[playing],true);
+	}
+
+
+	SD_StopSound();
+
+	if (beforesort)
+		beforesort();
+
+	scan = mmhead;
+
+	last = NULL;		// shut up compiler warning
+
+	while (scan)
+	{
+		if (scan->attributes & LOCKBIT)
+		{
+		//
+		// block is locked, so try to pile later blocks right after it
+		//
+			start = scan->start + scan->length;
+		}
+		else
+		{
+			if (scan->attributes & PURGEBITS)
+			{
+			//
+			// throw out the purgable block
+			//
+				next = scan->next;
+				FREEBLOCK(scan);
+				last->next = next;
+				scan = next;
+				continue;
+			}
+			else
+			{
+			//
+			// push the non purgable block on top of the last moved block
+			//
+				if (scan->start != start)
+				{
+					length = scan->length;
+					source = scan->start;
+					dest = start;
+					while (length > 0xf00)
+					{
+						movedata(source,0,dest,0,0xf00*16);
+						length -= 0xf00;
+						source += 0xf00;
+						dest += 0xf00;
+					}
+					movedata(source,0,dest,0,length*16);
+
+					scan->start = start;
+					*(unsigned *)scan->useptr = start;
+				}
+				start = scan->start + scan->length;
+			}
+		}
+
+		last = scan;
+		scan = scan->next;		// go to next block
+	}
+
+	mmrover = mmhead;
+
+	if (aftersort)
+		aftersort();
+
+	if (playing)
+		MM_SetLock(&(memptr)audiosegs[playing],false);
+}
+
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_ShowMemory
+=
+=====================
+*/
+
+void MM_ShowMemory (void)
+{
+	mmblocktype far *scan;
+	unsigned color,temp,x,y;
+	long	end,owner;
+	char    scratch[80],str[10];
+
+	temp = bufferofs;
+	bufferofs = displayofs;
+	scan = mmhead;
+
+	end = -1;
+
+	while (scan)
+	{
+		if (scan->attributes & PURGEBITS)
+			color = 5;		// dark purple = purgable
+		else
+			color = 9;		// medium blue = non purgable
+		if (scan->attributes & LOCKBIT)
+			color = 12;		// red = locked
+		if (scan->start<=end)
+			Quit ("MM_ShowMemory: Memory block order currupted!");
+		end = scan->length-1;
+		y = scan->start/320;
+		x = scan->start%320;
+		VW_Hlin(x,x+end,y,color);
+		VW_Plot(x,y,15);
+		if (scan->next && scan->next->start > end+1)
+			VW_Hlin(x+end+1,x+(scan->next->start-scan->start),y,0);	// black = free
+
+		scan = scan->next;
+	}
+
+	VW_FadeIn ();
+	IN_Ack();
+
+	bufferofs = temp;
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_DumpData
+=
+=====================
+*/
+
+void MM_DumpData (void)
+{
+	mmblocktype far *scan,far *best;
+	long	lowest,oldlowest;
+	unsigned	owner;
+	char	lock,purge;
+	FILE	*dumpfile;
+
+
+	free (nearheap);
+	dumpfile = fopen ("MMDUMP.TXT","w");
+	if (!dumpfile)
+		Quit ("MM_DumpData: Couldn't open MMDUMP.TXT!");
+
+	lowest = -1;
+	do
+	{
+		oldlowest = lowest;
+		lowest = 0xffff;
+
+		scan = mmhead;
+		while (scan)
+		{
+			owner = (unsigned)scan->useptr;
+
+			if (owner && owner<lowest && owner > oldlowest)
+			{
+				best = scan;
+				lowest = owner;
+			}
+
+			scan = scan->next;
+		}
+
+		if (lowest != 0xffff)
+		{
+			if (best->attributes & PURGEBITS)
+				purge = 'P';
+			else
+				purge = '-';
+			if (best->attributes & LOCKBIT)
+				lock = 'L';
+			else
+				lock = '-';
+			fprintf (dumpfile,"0x%p (%c%c) = %u\n"
+			,(unsigned)lowest,lock,purge,best->length);
+		}
+
+	} while (lowest != 0xffff);
+
+	fclose (dumpfile);
+	Quit ("MMDUMP.TXT created.");
+}
+
+//==========================================================================
+
+
+/*
+======================
+=
+= MM_UnusedMemory
+=
+= Returns the total free space without purging
+=
+======================
+*/
+
+long MM_UnusedMemory (void)
+{
+	unsigned free;
+	mmblocktype far *scan;
+
+	free = 0;
+	scan = mmhead;
+
+	while (scan->next)
+	{
+		free += scan->next->start - (scan->start + scan->length);
+		scan = scan->next;
+	}
+
+	return free*16l;
+}
+
+//==========================================================================
+
+
+/*
+======================
+=
+= MM_TotalFree
+=
+= Returns the total free space with purging
+=
+======================
+*/
+
+long MM_TotalFree (void)
+{
+	unsigned free;
+	mmblocktype far *scan;
+
+	free = 0;
+	scan = mmhead;
+
+	while (scan->next)
+	{
+		if ((scan->attributes&PURGEBITS) && !(scan->attributes&LOCKBIT))
+			free += scan->length;
+		free += scan->next->start - (scan->start + scan->length);
+		scan = scan->next;
+	}
+
+	return free*16l;
+}
+
+//==========================================================================
+
+/*
+=====================
+=
+= MM_BombOnError
+=
+=====================
+*/
+
+void MM_BombOnError (boolean bomb)
+{
+	bombonerror = bomb;
+}
+
+