]> 4ch.mooo.com Git - 16.git/blob - 16/sod8086/id_pm.c
added a simpler mmtest.c
[16.git] / 16 / sod8086 / id_pm.c
1 //\r
2 //      ID_PM.C\r
3 //      Id Engine's Page Manager v1.0\r
4 //      Primary coder: Jason Blochowiak\r
5 //\r
6 \r
7 #include "ID_HEADS.H"\r
8 #pragma hdrstop\r
9 \r
10 //      Main Mem specific variables\r
11         boolean                 MainPresent;\r
12         memptr                  MainMemPages[PMMaxMainMem];\r
13         PMBlockAttr             MainMemUsed[PMMaxMainMem];\r
14         int                             MainPagesAvail;\r
15 \r
16 //      EMS specific variables\r
17         boolean                 EMSPresent;\r
18         word                    EMSAvail,EMSPagesAvail,EMSHandle,\r
19                                         EMSPageFrame,EMSPhysicalPage;\r
20         EMSListStruct   EMSList[EMSFrameCount];\r
21 \r
22 //      XMS specific variables\r
23         boolean                 XMSPresent;\r
24         word                    XMSAvail,XMSPagesAvail,XMSHandle;\r
25         longword                XMSDriver;\r
26         int                             XMSProtectPage = -1;\r
27 \r
28 //      File specific variables\r
29         char                    PageFileName[13] = {"VSWAP."};\r
30         int                             PageFile = -1;\r
31         word                    ChunksInFile;\r
32         word                    PMSpriteStart,PMSoundStart;\r
33 \r
34 //      General usage variables\r
35         boolean                 PMStarted,\r
36                                         PMPanicMode,\r
37                                         PMThrashing;\r
38         word                    XMSPagesUsed,\r
39                                         EMSPagesUsed,\r
40                                         MainPagesUsed,\r
41                                         PMNumBlocks;\r
42         long                    PMFrameCount;\r
43         PageListStruct  far *PMPages,\r
44                                         _seg *PMSegPages;\r
45 \r
46 static  char            *ParmStrings[] = {"nomain","noems","noxms",nil};\r
47 \r
48 /////////////////////////////////////////////////////////////////////////////\r
49 //\r
50 //      EMS Management code\r
51 //\r
52 /////////////////////////////////////////////////////////////////////////////\r
53 \r
54 //\r
55 //      PML_MapEMS() - Maps a logical page to a physical page\r
56 //\r
57 void\r
58 PML_MapEMS(word logical,word physical)\r
59 {\r
60         _AL = physical;\r
61         _BX = logical;\r
62         _DX = EMSHandle;\r
63         _AH = EMS_MAPPAGE;\r
64 asm     int     EMS_INT\r
65 \r
66         if (_AH)\r
67                 Quit("PML_MapEMS: Page mapping failed");\r
68 }\r
69 \r
70 //\r
71 //      PML_StartupEMS() - Sets up EMS for Page Mgr's use\r
72 //              Checks to see if EMS driver is present\r
73 //      Verifies that EMS hardware is present\r
74 //              Make sure that EMS version is 3.2 or later\r
75 //              If there's more than our minimum (2 pages) available, allocate it (up\r
76 //                      to the maximum we need)\r
77 //\r
78 \r
79         char    EMMDriverName[9] = "EMMXXXX0";\r
80 \r
81 boolean\r
82 PML_StartupEMS(void)\r
83 {\r
84         int             i;\r
85         long    size;\r
86 \r
87         EMSPresent = false;                     // Assume that we'll fail\r
88         EMSAvail = 0;\r
89 \r
90         _DX = (word)EMMDriverName;\r
91         _AX = 0x3d00;\r
92         geninterrupt(0x21);                     // try to open EMMXXXX0 device\r
93 asm     jnc     gothandle\r
94         goto error;\r
95 \r
96 gothandle:\r
97         _BX = _AX;\r
98         _AX = 0x4400;\r
99         geninterrupt(0x21);                     // get device info\r
100 asm     jnc     gotinfo;\r
101         goto error;\r
102 \r
103 gotinfo:\r
104 asm     and     dx,0x80\r
105         if (!_DX)\r
106                 goto error;\r
107 \r
108         _AX = 0x4407;\r
109         geninterrupt(0x21);                     // get status\r
110 asm     jc      error\r
111         if (!_AL)\r
112                 goto error;\r
113 \r
114         _AH = 0x3e;\r
115         geninterrupt(0x21);                     // close handle\r
116 \r
117         _AH = EMS_STATUS;\r
118         geninterrupt(EMS_INT);\r
119         if (_AH)\r
120                 goto error;                             // make sure EMS hardware is present\r
121 \r
122         _AH = EMS_VERSION;\r
123         geninterrupt(EMS_INT);\r
124         if (_AH || (_AL < 0x32))        // only work on EMS 3.2 or greater (silly, but...)\r
125                 goto error;\r
126 \r
127         _AH = EMS_GETFRAME;\r
128         geninterrupt(EMS_INT);\r
129         if (_AH)\r
130                 goto error;                             // find the page frame address\r
131         EMSPageFrame = _BX;\r
132 \r
133         _AH = EMS_GETPAGES;\r
134         geninterrupt(EMS_INT);\r
135         if (_AH)\r
136                 goto error;\r
137         if (_BX < 2)\r
138                 goto error;             // Require at least 2 pages (32k)\r
139         EMSAvail = _BX;\r
140 \r
141         // Don't hog all available EMS\r
142         size = EMSAvail * (long)EMSPageSize;\r
143         if (size - (EMSPageSize * 2) > (ChunksInFile * (long)PMPageSize))\r
144         {\r
145                 size = (ChunksInFile * (long)PMPageSize) + EMSPageSize;\r
146                 EMSAvail = size / EMSPageSize;\r
147         }\r
148 \r
149         _AH = EMS_ALLOCPAGES;\r
150         _BX = EMSAvail;\r
151         geninterrupt(EMS_INT);\r
152         if (_AH)\r
153                 goto error;\r
154         EMSHandle = _DX;\r
155 \r
156         mminfo.EMSmem += EMSAvail * (long)EMSPageSize;\r
157 \r
158         // Initialize EMS mapping cache\r
159         for (i = 0;i < EMSFrameCount;i++)\r
160                 EMSList[i].baseEMSPage = -1;\r
161 \r
162         EMSPresent = true;                      // We have EMS\r
163 \r
164 error:\r
165         return(EMSPresent);\r
166 }\r
167 \r
168 //\r
169 //      PML_ShutdownEMS() - If EMS was used, deallocate it\r
170 //\r
171 void\r
172 PML_ShutdownEMS(void)\r
173 {\r
174         if (EMSPresent)\r
175         {\r
176         asm     mov     ah,EMS_FREEPAGES\r
177         asm     mov     dx,[EMSHandle]\r
178         asm     int     EMS_INT\r
179                 if (_AH)\r
180                         Quit ("PML_ShutdownEMS: Error freeing EMS");\r
181         }\r
182 }\r
183 \r
184 /////////////////////////////////////////////////////////////////////////////\r
185 //\r
186 //      XMS Management code\r
187 //\r
188 /////////////////////////////////////////////////////////////////////////////\r
189 \r
190 //\r
191 //      PML_StartupXMS() - Starts up XMS for the Page Mgr's use\r
192 //              Checks for presence of an XMS driver\r
193 //              Makes sure that there's at least a page of XMS available\r
194 //              Allocates any remaining XMS (rounded down to the nearest page size)\r
195 //\r
196 boolean\r
197 PML_StartupXMS(void)\r
198 {\r
199         XMSPresent = false;                                     // Assume failure\r
200         XMSAvail = 0;\r
201 \r
202 asm     mov     ax,0x4300\r
203 asm     int     XMS_INT                                         // Check for presence of XMS driver\r
204         if (_AL != 0x80)\r
205                 goto error;\r
206 \r
207 \r
208 asm     mov     ax,0x4310\r
209 asm     int     XMS_INT                                                 // Get address of XMS driver\r
210 asm     mov     [WORD PTR XMSDriver],bx\r
211 asm     mov     [WORD PTR XMSDriver+2],es               // function pointer to XMS driver\r
212 \r
213         XMS_CALL(XMS_QUERYFREE);                        // Find out how much XMS is available\r
214         XMSAvail = _AX;\r
215         if (!_AX)                               // AJR: bugfix 10/8/92\r
216                 goto error;\r
217 \r
218         XMSAvail &= ~(PMPageSizeKB - 1);        // Round off to nearest page size\r
219         if (XMSAvail < (PMPageSizeKB * 2))      // Need at least 2 pages\r
220                 goto error;\r
221 \r
222         _DX = XMSAvail;\r
223         XMS_CALL(XMS_ALLOC);                            // And do the allocation\r
224         XMSHandle = _DX;\r
225 \r
226         if (!_AX)                               // AJR: bugfix 10/8/92\r
227         {\r
228                 XMSAvail = 0;\r
229                 goto error;\r
230         }\r
231 \r
232         mminfo.XMSmem += XMSAvail * 1024;\r
233 \r
234         XMSPresent = true;\r
235 error:\r
236         return(XMSPresent);\r
237 }\r
238 \r
239 //\r
240 //      PML_XMSCopy() - Copies a main/EMS page to or from XMS\r
241 //              Will round an odd-length request up to the next even value\r
242 //\r
243 void\r
244 PML_XMSCopy(boolean toxms,byte far *addr,word xmspage,word length)\r
245 {\r
246         longword        xoffset;\r
247         struct\r
248         {\r
249                 longword        length;\r
250                 word            source_handle;\r
251                 longword        source_offset;\r
252                 word            target_handle;\r
253                 longword        target_offset;\r
254         } copy;\r
255 \r
256         if (!addr)\r
257                 Quit("PML_XMSCopy: zero address");\r
258 \r
259         xoffset = (longword)xmspage * PMPageSize;\r
260 \r
261         copy.length = (length + 1) & ~1;\r
262         copy.source_handle = toxms? 0 : XMSHandle;\r
263         copy.source_offset = toxms? (long)addr : xoffset;\r
264         copy.target_handle = toxms? XMSHandle : 0;\r
265         copy.target_offset = toxms? xoffset : (long)addr;\r
266 \r
267 asm     push si\r
268         _SI = (word)&copy;\r
269         XMS_CALL(XMS_MOVE);\r
270 asm     pop     si\r
271         if (!_AX)\r
272                 Quit("PML_XMSCopy: Error on copy");\r
273 }\r
274 \r
275 #if 1\r
276 #define PML_CopyToXMS(s,t,l)    PML_XMSCopy(true,(s),(t),(l))\r
277 #define PML_CopyFromXMS(t,s,l)  PML_XMSCopy(false,(t),(s),(l))\r
278 #else\r
279 //\r
280 //      PML_CopyToXMS() - Copies the specified number of bytes from the real mode\r
281 //              segment address to the specified XMS page\r
282 //\r
283 void\r
284 PML_CopyToXMS(byte far *source,int targetpage,word length)\r
285 {\r
286         PML_XMSCopy(true,source,targetpage,length);\r
287 }\r
288 \r
289 //\r
290 //      PML_CopyFromXMS() - Copies the specified number of bytes from an XMS\r
291 //              page to the specified real mode address\r
292 //\r
293 void\r
294 PML_CopyFromXMS(byte far *target,int sourcepage,word length)\r
295 {\r
296         PML_XMSCopy(false,target,sourcepage,length);\r
297 }\r
298 #endif\r
299 \r
300 //\r
301 //      PML_ShutdownXMS()\r
302 //\r
303 void\r
304 PML_ShutdownXMS(void)\r
305 {\r
306         if (XMSPresent)\r
307         {\r
308                 _DX = XMSHandle;\r
309                 XMS_CALL(XMS_FREE);\r
310                 if (_BL)\r
311                         Quit("PML_ShutdownXMS: Error freeing XMS");\r
312         }\r
313 }\r
314 \r
315 /////////////////////////////////////////////////////////////////////////////\r
316 //\r
317 //      Main memory code\r
318 //\r
319 /////////////////////////////////////////////////////////////////////////////\r
320 \r
321 //\r
322 //      PM_SetMainMemPurge() - Sets the purge level for all allocated main memory\r
323 //              blocks. This shouldn't be called directly - the PM_LockMainMem() and\r
324 //              PM_UnlockMainMem() macros should be used instead.\r
325 //\r
326 void\r
327 PM_SetMainMemPurge(int level)\r
328 {\r
329         int     i;\r
330 \r
331         for (i = 0;i < PMMaxMainMem;i++)\r
332                 if (MainMemPages[i])\r
333                         MM_SetPurge(&MainMemPages[i],level);\r
334 }\r
335 \r
336 //\r
337 //      PM_CheckMainMem() - If something besides the Page Mgr makes requests of\r
338 //              the Memory Mgr, some of the Page Mgr's blocks may have been purged,\r
339 //              so this function runs through the block list and checks to see if\r
340 //              any of the blocks have been purged. If so, it marks the corresponding\r
341 //              page as purged & unlocked, then goes through the block list and\r
342 //              tries to reallocate any blocks that have been purged.\r
343 //      This routine now calls PM_LockMainMem() to make sure that any allocation\r
344 //              attempts made during the block reallocation sweep don't purge any\r
345 //              of the other blocks. Because PM_LockMainMem() is called,\r
346 //              PM_UnlockMainMem() needs to be called before any other part of the\r
347 //              program makes allocation requests of the Memory Mgr.\r
348 //\r
349 void\r
350 PM_CheckMainMem(void)\r
351 {\r
352         boolean                 allocfailed;\r
353         int                             i,n;\r
354         memptr                  *p;\r
355         PMBlockAttr             *used;\r
356         PageListStruct  far *page;\r
357 \r
358         if (!MainPresent)\r
359                 return;\r
360 \r
361         for (i = 0,page = PMPages;i < ChunksInFile;i++,page++)\r
362         {\r
363                 n = page->mainPage;\r
364                 if (n != -1)                                            // Is the page using main memory?\r
365                 {\r
366                         if (!MainMemPages[n])                   // Yep, was the block purged?\r
367                         {\r
368                                 page->mainPage = -1;            // Yes, mark page as purged & unlocked\r
369                                 page->locked = pml_Unlocked;\r
370                         }\r
371                 }\r
372         }\r
373 \r
374         // Prevent allocation attempts from purging any of our other blocks\r
375         PM_LockMainMem();\r
376         allocfailed = false;\r
377         for (i = 0,p = MainMemPages,used = MainMemUsed;i < PMMaxMainMem;i++,p++,used++)\r
378         {\r
379                 if (!*p)                                                        // If the page got purged\r
380                 {\r
381                         if (*used & pmba_Allocated)             // If it was allocated\r
382                         {\r
383                                 *used &= ~pmba_Allocated;       // Mark as unallocated\r
384                                 MainPagesAvail--;                       // and decrease available count\r
385                         }\r
386 \r
387                         if (*used & pmba_Used)                  // If it was used\r
388                         {\r
389                                 *used &= ~pmba_Used;            // Mark as unused\r
390                                 MainPagesUsed--;                        // and decrease used count\r
391                         }\r
392 \r
393                         if (!allocfailed)\r
394                         {\r
395                                 MM_BombOnError(false);\r
396                                 MM_GetPtr(p,PMPageSize);                // Try to reallocate\r
397                                 if (mmerror)                                    // If it failed,\r
398                                         allocfailed = true;                     //  don't try any more allocations\r
399                                 else                                                    // If it worked,\r
400                                 {\r
401                                         *used |= pmba_Allocated;        // Mark as allocated\r
402                                         MainPagesAvail++;                       // and increase available count\r
403                                 }\r
404                                 MM_BombOnError(true);\r
405                         }\r
406                 }\r
407         }\r
408         if (mmerror)\r
409                 mmerror = false;\r
410 }\r
411 \r
412 //\r
413 //      PML_StartupMainMem() - Allocates as much main memory as is possible for\r
414 //              the Page Mgr. The memory is allocated as non-purgeable, so if it's\r
415 //              necessary to make requests of the Memory Mgr, PM_UnlockMainMem()\r
416 //              needs to be called.\r
417 //\r
418 void\r
419 PML_StartupMainMem(void)\r
420 {\r
421         int             i,n;\r
422         memptr  *p;\r
423 \r
424         MainPagesAvail = 0;\r
425         MM_BombOnError(false);\r
426         for (i = 0,p = MainMemPages;i < PMMaxMainMem;i++,p++)\r
427         {\r
428                 MM_GetPtr(p,PMPageSize);\r
429                 if (mmerror)\r
430                         break;\r
431 \r
432                 MainPagesAvail++;\r
433                 MainMemUsed[i] = pmba_Allocated;\r
434         }\r
435         MM_BombOnError(true);\r
436         if (mmerror)\r
437                 mmerror = false;\r
438         if (MainPagesAvail < PMMinMainMem)\r
439                 Quit("PM_SetupMainMem: Not enough main memory");\r
440         MainPresent = true;\r
441 }\r
442 \r
443 //\r
444 //      PML_ShutdownMainMem() - Frees all of the main memory blocks used by the\r
445 //              Page Mgr.\r
446 //\r
447 void\r
448 PML_ShutdownMainMem(void)\r
449 {\r
450         int             i;\r
451         memptr  *p;\r
452 \r
453         // DEBUG - mark pages as unallocated & decrease page count as appropriate\r
454         for (i = 0,p = MainMemPages;i < PMMaxMainMem;i++,p++)\r
455                 if (*p)\r
456                         MM_FreePtr(p);\r
457 }\r
458 \r
459 /////////////////////////////////////////////////////////////////////////////\r
460 //\r
461 //      File management code\r
462 //\r
463 /////////////////////////////////////////////////////////////////////////////\r
464 \r
465 //\r
466 //      PML_ReadFromFile() - Reads some data in from the page file\r
467 //\r
468 void\r
469 PML_ReadFromFile(byte far *buf,long offset,word length)\r
470 {\r
471         if (!buf)\r
472                 Quit("PML_ReadFromFile: Null pointer");\r
473         if (!offset)\r
474                 Quit("PML_ReadFromFile: Zero offset");\r
475         if (lseek(PageFile,offset,SEEK_SET) != offset)\r
476                 Quit("PML_ReadFromFile: Seek failed");\r
477         if (!CA_FarRead(PageFile,buf,length))\r
478                 Quit("PML_ReadFromFile: Read failed");\r
479 }\r
480 \r
481 //\r
482 //      PML_OpenPageFile() - Opens the page file and sets up the page info\r
483 //\r
484 void\r
485 PML_OpenPageFile(void)\r
486 {\r
487         int                             i;\r
488         long                    size;\r
489         void                    _seg *buf;\r
490         longword                far *offsetptr;\r
491         word                    far *lengthptr;\r
492         PageListStruct  far *page;\r
493 \r
494         PageFile = open(PageFileName,O_RDONLY + O_BINARY);\r
495         if (PageFile == -1)\r
496                 Quit("PML_OpenPageFile: Unable to open page file");\r
497 \r
498         // Read in header variables\r
499         read(PageFile,&ChunksInFile,sizeof(ChunksInFile));\r
500         read(PageFile,&PMSpriteStart,sizeof(PMSpriteStart));\r
501         read(PageFile,&PMSoundStart,sizeof(PMSoundStart));\r
502 \r
503         // Allocate and clear the page list\r
504         PMNumBlocks = ChunksInFile;\r
505         MM_GetPtr(&(memptr)PMSegPages,sizeof(PageListStruct) * PMNumBlocks);\r
506         MM_SetLock(&(memptr)PMSegPages,true);\r
507         PMPages = (PageListStruct far *)PMSegPages;\r
508         _fmemset(PMPages,0,sizeof(PageListStruct) * PMNumBlocks);\r
509 \r
510         // Read in the chunk offsets\r
511         size = sizeof(longword) * ChunksInFile;\r
512         MM_GetPtr(&buf,size);\r
513         if (!CA_FarRead(PageFile,(byte far *)buf,size))\r
514                 Quit("PML_OpenPageFile: Offset read failed");\r
515         offsetptr = (longword far *)buf;\r
516         for (i = 0,page = PMPages;i < ChunksInFile;i++,page++)\r
517                 page->offset = *offsetptr++;\r
518         MM_FreePtr(&buf);\r
519 \r
520         // Read in the chunk lengths\r
521         size = sizeof(word) * ChunksInFile;\r
522         MM_GetPtr(&buf,size);\r
523         if (!CA_FarRead(PageFile,(byte far *)buf,size))\r
524                 Quit("PML_OpenPageFile: Length read failed");\r
525         lengthptr = (word far *)buf;\r
526         for (i = 0,page = PMPages;i < ChunksInFile;i++,page++)\r
527                 page->length = *lengthptr++;\r
528         MM_FreePtr(&buf);\r
529 }\r
530 \r
531 //\r
532 //  PML_ClosePageFile() - Closes the page file\r
533 //\r
534 void\r
535 PML_ClosePageFile(void)\r
536 {\r
537         if (PageFile != -1)\r
538                 close(PageFile);\r
539         if (PMSegPages)\r
540         {\r
541                 MM_SetLock(&(memptr)PMSegPages,false);\r
542                 MM_FreePtr(&(void _seg *)PMSegPages);\r
543         }\r
544 }\r
545 \r
546 /////////////////////////////////////////////////////////////////////////////\r
547 //\r
548 //      Allocation, etc., code\r
549 //\r
550 /////////////////////////////////////////////////////////////////////////////\r
551 \r
552 //\r
553 //      PML_GetEMSAddress()\r
554 //\r
555 //              Page is in EMS, so figure out which EMS physical page should be used\r
556 //              to map our page in. If normal page, use EMS physical page 3, else\r
557 //              use the physical page specified by the lock type\r
558 //\r
559 #if 1\r
560 #pragma argsused        // DEBUG - remove lock parameter\r
561 memptr\r
562 PML_GetEMSAddress(int page,PMLockType lock)\r
563 {\r
564         int             i,emspage;\r
565         word    emsoff,emsbase,offset;\r
566 \r
567         emsoff = page & (PMEMSSubPage - 1);\r
568         emsbase = page - emsoff;\r
569 \r
570         emspage = -1;\r
571         // See if this page is already mapped in\r
572         for (i = 0;i < EMSFrameCount;i++)\r
573         {\r
574                 if (EMSList[i].baseEMSPage == emsbase)\r
575                 {\r
576                         emspage = i;    // Yep - don't do a redundant remapping\r
577                         break;\r
578                 }\r
579         }\r
580 \r
581         // If page isn't already mapped in, find LRU EMS frame, and use it\r
582         if (emspage == -1)\r
583         {\r
584                 longword last = MAXLONG;\r
585                 for (i = 0;i < EMSFrameCount;i++)\r
586                 {\r
587                         if (EMSList[i].lastHit < last)\r
588                         {\r
589                                 emspage = i;\r
590                                 last = EMSList[i].lastHit;\r
591                         }\r
592                 }\r
593 \r
594                 EMSList[emspage].baseEMSPage = emsbase;\r
595                 PML_MapEMS(page / PMEMSSubPage,emspage);\r
596         }\r
597 \r
598         if (emspage == -1)\r
599                 Quit("PML_GetEMSAddress: EMS find failed");\r
600 \r
601         EMSList[emspage].lastHit = PMFrameCount;\r
602         offset = emspage * EMSPageSizeSeg;\r
603         offset += emsoff * PMPageSizeSeg;\r
604         return((memptr)(EMSPageFrame + offset));\r
605 }\r
606 #else\r
607 memptr\r
608 PML_GetEMSAddress(int page,PMLockType lock)\r
609 {\r
610         word    emspage;\r
611 \r
612         emspage = (lock < pml_EMSLock)? 3 : (lock - pml_EMSLock);\r
613 \r
614         PML_MapEMS(page / PMEMSSubPage,emspage);\r
615 \r
616         return((memptr)(EMSPageFrame + (emspage * EMSPageSizeSeg)\r
617                         + ((page & (PMEMSSubPage - 1)) * PMPageSizeSeg)));\r
618 }\r
619 #endif\r
620 \r
621 //\r
622 //      PM_GetPageAddress() - Returns the address of a given page\r
623 //              Maps in EMS if necessary\r
624 //              Returns nil if block isn't cached into Main Memory or EMS\r
625 //\r
626 //\r
627 memptr\r
628 PM_GetPageAddress(int pagenum)\r
629 {\r
630         PageListStruct  far *page;\r
631 \r
632         page = &PMPages[pagenum];\r
633         if (page->mainPage != -1)\r
634                 return(MainMemPages[page->mainPage]);\r
635         else if (page->emsPage != -1)\r
636                 return(PML_GetEMSAddress(page->emsPage,page->locked));\r
637         else\r
638                 return(nil);\r
639 }\r
640 \r
641 //\r
642 //      PML_GiveLRUPage() - Returns the page # of the least recently used\r
643 //              present & unlocked main/EMS page (or main page if mainonly is true)\r
644 //\r
645 int\r
646 PML_GiveLRUPage(boolean mainonly)\r
647 {\r
648         int                             i,lru;\r
649         long                    last;\r
650         PageListStruct  far *page;\r
651 \r
652         for (i = 0,page = PMPages,lru = -1,last = MAXLONG;i < ChunksInFile;i++,page++)\r
653         {\r
654                 if\r
655                 (\r
656                         (page->lastHit < last)\r
657                 &&      ((page->emsPage != -1) || (page->mainPage != -1))\r
658                 &&      (page->locked == pml_Unlocked)\r
659                 &&      (!(mainonly && (page->mainPage == -1)))\r
660                 )\r
661                 {\r
662                         last = page->lastHit;\r
663                         lru = i;\r
664                 }\r
665         }\r
666 \r
667         if (lru == -1)\r
668                 Quit("PML_GiveLRUPage: LRU Search failed");\r
669         return(lru);\r
670 }\r
671 \r
672 //\r
673 //      PML_GiveLRUXMSPage() - Returns the page # of the least recently used\r
674 //              (and present) XMS page.\r
675 //      This routine won't return the XMS page protected (by XMSProtectPage)\r
676 //\r
677 int\r
678 PML_GiveLRUXMSPage(void)\r
679 {\r
680         int                             i,lru;\r
681         long                    last;\r
682         PageListStruct  far *page;\r
683 \r
684         for (i = 0,page = PMPages,lru = -1,last = MAXLONG;i < ChunksInFile;i++,page++)\r
685         {\r
686                 if\r
687                 (\r
688                         (page->xmsPage != -1)\r
689                 &&      (page->lastHit < last)\r
690                 &&      (i != XMSProtectPage)\r
691                 )\r
692                 {\r
693                         last = page->lastHit;\r
694                         lru = i;\r
695                 }\r
696         }\r
697         return(lru);\r
698 }\r
699 \r
700 //\r
701 //      PML_PutPageInXMS() - If page isn't in XMS, find LRU XMS page and replace\r
702 //              it with the main/EMS page\r
703 //\r
704 void\r
705 PML_PutPageInXMS(int pagenum)\r
706 {\r
707         int                             usexms;\r
708         PageListStruct  far *page;\r
709 \r
710         if (!XMSPresent)\r
711                 return;\r
712 \r
713         page = &PMPages[pagenum];\r
714         if (page->xmsPage != -1)\r
715                 return;                                 // Already in XMS\r
716 \r
717         if (XMSPagesUsed < XMSPagesAvail)\r
718                 page->xmsPage = XMSPagesUsed++;\r
719         else\r
720         {\r
721                 usexms = PML_GiveLRUXMSPage();\r
722                 if (usexms == -1)\r
723                         Quit("PML_PutPageInXMS: No XMS LRU");\r
724                 page->xmsPage = PMPages[usexms].xmsPage;\r
725                 PMPages[usexms].xmsPage = -1;\r
726         }\r
727         PML_CopyToXMS(PM_GetPageAddress(pagenum),page->xmsPage,page->length);\r
728 }\r
729 \r
730 //\r
731 //      PML_TransferPageSpace() - A page is being replaced, so give the new page\r
732 //              the old one's address space. Returns the address of the new page.\r
733 //\r
734 memptr\r
735 PML_TransferPageSpace(int orig,int new)\r
736 {\r
737         memptr                  addr;\r
738         PageListStruct  far *origpage,far *newpage;\r
739 \r
740         if (orig == new)\r
741                 Quit("PML_TransferPageSpace: Identity replacement");\r
742 \r
743         origpage = &PMPages[orig];\r
744         newpage = &PMPages[new];\r
745 \r
746         if (origpage->locked != pml_Unlocked)\r
747                 Quit("PML_TransferPageSpace: Killing locked page");\r
748 \r
749         if ((origpage->emsPage == -1) && (origpage->mainPage == -1))\r
750                 Quit("PML_TransferPageSpace: Reusing non-existent page");\r
751 \r
752         // Copy page that's about to be purged into XMS\r
753         PML_PutPageInXMS(orig);\r
754 \r
755         // Get the address, and force EMS into a physical page if necessary\r
756         addr = PM_GetPageAddress(orig);\r
757 \r
758         // Steal the address\r
759         newpage->emsPage = origpage->emsPage;\r
760         newpage->mainPage = origpage->mainPage;\r
761 \r
762         // Mark replaced page as purged\r
763         origpage->mainPage = origpage->emsPage = -1;\r
764 \r
765         if (!addr)\r
766                 Quit("PML_TransferPageSpace: Zero replacement");\r
767 \r
768         return(addr);\r
769 }\r
770 \r
771 //\r
772 //      PML_GetAPageBuffer() - A page buffer is needed. Either get it from the\r
773 //              main/EMS free pool, or use PML_GiveLRUPage() to find which page to\r
774 //              steal the buffer from. Returns a far pointer to the page buffer, and\r
775 //              sets the fields inside the given page structure appropriately.\r
776 //              If mainonly is true, free EMS will be ignored, and only main pages\r
777 //              will be looked at by PML_GiveLRUPage().\r
778 //\r
779 byte far *\r
780 PML_GetAPageBuffer(int pagenum,boolean mainonly)\r
781 {\r
782         byte                    far *addr = nil;\r
783         int                             i,n;\r
784         PMBlockAttr             *used;\r
785         PageListStruct  far *page;\r
786 \r
787         page = &PMPages[pagenum];\r
788         if ((EMSPagesUsed < EMSPagesAvail) && !mainonly)\r
789         {\r
790                 // There's remaining EMS - use it\r
791                 page->emsPage = EMSPagesUsed++;\r
792                 addr = PML_GetEMSAddress(page->emsPage,page->locked);\r
793         }\r
794         else if (MainPagesUsed < MainPagesAvail)\r
795         {\r
796                 // There's remaining main memory - use it\r
797                 for (i = 0,n = -1,used = MainMemUsed;i < PMMaxMainMem;i++,used++)\r
798                 {\r
799                         if ((*used & pmba_Allocated) && !(*used & pmba_Used))\r
800                         {\r
801                                 n = i;\r
802                                 *used |= pmba_Used;\r
803                                 break;\r
804                         }\r
805                 }\r
806                 if (n == -1)\r
807                         Quit("PML_GetPageBuffer: MainPagesAvail lied");\r
808                 addr = MainMemPages[n];\r
809                 if (!addr)\r
810                         Quit("PML_GetPageBuffer: Purged main block");\r
811                 page->mainPage = n;\r
812                 MainPagesUsed++;\r
813         }\r
814         else\r
815                 addr = PML_TransferPageSpace(PML_GiveLRUPage(mainonly),pagenum);\r
816 \r
817         if (!addr)\r
818                 Quit("PML_GetPageBuffer: Search failed");\r
819         return(addr);\r
820 }\r
821 \r
822 //\r
823 //      PML_GetPageFromXMS() - If page is in XMS, find LRU main/EMS page and\r
824 //              replace it with the page from XMS. If mainonly is true, will only\r
825 //              search for LRU main page.\r
826 //      XMSProtectPage is set to the page to be retrieved from XMS, so that if\r
827 //              the page from which we're stealing the main/EMS from isn't in XMS,\r
828 //              it won't copy over the page that we're trying to get from XMS.\r
829 //              (pages that are being purged are copied into XMS, if possible)\r
830 //\r
831 memptr\r
832 PML_GetPageFromXMS(int pagenum,boolean mainonly)\r
833 {\r
834         byte                    far *checkaddr;\r
835         memptr                  addr = nil;\r
836         PageListStruct  far *page;\r
837 \r
838         page = &PMPages[pagenum];\r
839         if (XMSPresent && (page->xmsPage != -1))\r
840         {\r
841                 XMSProtectPage = pagenum;\r
842                 checkaddr = PML_GetAPageBuffer(pagenum,mainonly);\r
843                 if (FP_OFF(checkaddr))\r
844                         Quit("PML_GetPageFromXMS: Non segment pointer");\r
845                 addr = (memptr)FP_SEG(checkaddr);\r
846                 PML_CopyFromXMS(addr,page->xmsPage,page->length);\r
847                 XMSProtectPage = -1;\r
848         }\r
849 \r
850         return(addr);\r
851 }\r
852 \r
853 //\r
854 //      PML_LoadPage() - A page is not in main/EMS memory, and it's not in XMS.\r
855 //              Load it into either main or EMS. If mainonly is true, the page will\r
856 //              only be loaded into main.\r
857 //\r
858 void\r
859 PML_LoadPage(int pagenum,boolean mainonly)\r
860 {\r
861         byte                    far *addr;\r
862         PageListStruct  far *page;\r
863 \r
864         addr = PML_GetAPageBuffer(pagenum,mainonly);\r
865         page = &PMPages[pagenum];\r
866         PML_ReadFromFile(addr,page->offset,page->length);\r
867 }\r
868 \r
869 //\r
870 //      PM_GetPage() - Returns the address of the page, loading it if necessary\r
871 //              First, check if in Main Memory or EMS\r
872 //              Then, check XMS\r
873 //              If not in XMS, load into Main Memory or EMS\r
874 //\r
875 #pragma warn -pia\r
876 memptr\r
877 PM_GetPage(int pagenum)\r
878 {\r
879         memptr  result;\r
880 \r
881         if (pagenum >= ChunksInFile)\r
882                 Quit("PM_GetPage: Invalid page request");\r
883 \r
884 #if 0   // for debugging\r
885 asm     mov     dx,STATUS_REGISTER_1\r
886 asm     in      al,dx\r
887 asm     mov     dx,ATR_INDEX\r
888 asm     mov     al,ATR_OVERSCAN\r
889 asm     out     dx,al\r
890 asm     mov     al,10   // bright green\r
891 asm     out     dx,al\r
892 #endif\r
893 \r
894         if (!(result = PM_GetPageAddress(pagenum)))\r
895         {\r
896                 boolean mainonly = (pagenum >= PMSoundStart);\r
897 if (!PMPages[pagenum].offset)   // JDC: sparse page\r
898         Quit ("Tried to load a sparse page!");\r
899                 if (!(result = PML_GetPageFromXMS(pagenum,mainonly)))\r
900                 {\r
901                         if (PMPages[pagenum].lastHit == PMFrameCount)\r
902                                 PMThrashing++;\r
903 \r
904                         PML_LoadPage(pagenum,mainonly);\r
905                         result = PM_GetPageAddress(pagenum);\r
906                 }\r
907         }\r
908         PMPages[pagenum].lastHit = PMFrameCount;\r
909 \r
910 #if 0   // for debugging\r
911 asm     mov     dx,STATUS_REGISTER_1\r
912 asm     in      al,dx\r
913 asm     mov     dx,ATR_INDEX\r
914 asm     mov     al,ATR_OVERSCAN\r
915 asm     out     dx,al\r
916 asm     mov     al,3    // blue\r
917 asm     out     dx,al\r
918 asm     mov     al,0x20 // normal\r
919 asm     out     dx,al\r
920 #endif\r
921 \r
922         return(result);\r
923 }\r
924 #pragma warn +pia\r
925 \r
926 //\r
927 //      PM_SetPageLock() - Sets the lock type on a given page\r
928 //              pml_Unlocked: Normal, page can be purged\r
929 //              pml_Locked: Cannot be purged\r
930 //              pml_EMS?: Same as pml_Locked, but if in EMS, use the physical page\r
931 //                                      specified when returning the address. For sound stuff.\r
932 //\r
933 void\r
934 PM_SetPageLock(int pagenum,PMLockType lock)\r
935 {\r
936         if (pagenum < PMSoundStart)\r
937                 Quit("PM_SetPageLock: Locking/unlocking non-sound page");\r
938 \r
939         PMPages[pagenum].locked = lock;\r
940 }\r
941 \r
942 //\r
943 //      PM_Preload() - Loads as many pages as possible into all types of memory.\r
944 //              Calls the update function after each load, indicating the current\r
945 //              page, and the total pages that need to be loaded (for thermometer).\r
946 //\r
947 void\r
948 PM_Preload(boolean (*update)(word current,word total))\r
949 {\r
950         int                             i,j,\r
951                                         page,oogypage;\r
952         word                    current,total,\r
953                                         totalnonxms,totalxms,\r
954                                         mainfree,maintotal,\r
955                                         emsfree,emstotal,\r
956                                         xmsfree,xmstotal;\r
957         memptr                  addr;\r
958         PageListStruct  far *p;\r
959 \r
960         mainfree = (MainPagesAvail - MainPagesUsed) + (EMSPagesAvail - EMSPagesUsed);\r
961         xmsfree = (XMSPagesAvail - XMSPagesUsed);\r
962 \r
963         xmstotal = maintotal = 0;\r
964 \r
965         for (i = 0;i < ChunksInFile;i++)\r
966         {\r
967                 if (!PMPages[i].offset)\r
968                         continue;                       // sparse\r
969 \r
970                 if ( PMPages[i].emsPage != -1 || PMPages[i].mainPage != -1 )\r
971                         continue;                       // already in main mem\r
972 \r
973                 if ( mainfree )\r
974                 {\r
975                         maintotal++;\r
976                         mainfree--;\r
977                 }\r
978                 else if ( xmsfree && (PMPages[i].xmsPage == -1) )\r
979                 {\r
980                         xmstotal++;\r
981                         xmsfree--;\r
982                 }\r
983         }\r
984 \r
985 \r
986         total = maintotal + xmstotal;\r
987 \r
988         if (!total)\r
989                 return;\r
990 \r
991         page = 0;\r
992         current = 0;\r
993 \r
994 //\r
995 // cache main/ems blocks\r
996 //\r
997         while (maintotal)\r
998         {\r
999                 while ( !PMPages[page].offset || PMPages[page].mainPage != -1\r
1000                         ||      PMPages[page].emsPage != -1 )\r
1001                         page++;\r
1002 \r
1003                 if (page >= ChunksInFile)\r
1004                         Quit ("PM_Preload: Pages>=ChunksInFile");\r
1005 \r
1006                 PM_GetPage(page);\r
1007 \r
1008                 page++;\r
1009                 current++;\r
1010                 maintotal--;\r
1011                 update(current,total);\r
1012         }\r
1013 \r
1014 //\r
1015 // load stuff to XMS\r
1016 //\r
1017         if (xmstotal)\r
1018         {\r
1019                 for (oogypage = 0 ; PMPages[oogypage].mainPage == -1 ; oogypage++)\r
1020                 ;\r
1021                 addr = PM_GetPage(oogypage);\r
1022                 if (!addr)\r
1023                         Quit("PM_Preload: XMS buffer failed");\r
1024 \r
1025                 while (xmstotal)\r
1026                 {\r
1027                         while ( !PMPages[page].offset || PMPages[page].xmsPage != -1 )\r
1028                                 page++;\r
1029 \r
1030                         if (page >= ChunksInFile)\r
1031                                 Quit ("PM_Preload: Pages>=ChunksInFile");\r
1032 \r
1033                         p = &PMPages[page];\r
1034 \r
1035                         p->xmsPage = XMSPagesUsed++;\r
1036                         if (XMSPagesUsed > XMSPagesAvail)\r
1037                                 Quit("PM_Preload: Exceeded XMS pages");\r
1038                         if (p->length > PMPageSize)\r
1039                                 Quit("PM_Preload: Page too long");\r
1040 \r
1041                         PML_ReadFromFile((byte far *)addr,p->offset,p->length);\r
1042                         PML_CopyToXMS((byte far *)addr,p->xmsPage,p->length);\r
1043 \r
1044                         page++;\r
1045                         current++;\r
1046                         xmstotal--;\r
1047                         update(current,total);\r
1048                 }\r
1049 \r
1050                 p = &PMPages[oogypage];\r
1051                 PML_ReadFromFile((byte far *)addr,p->offset,p->length);\r
1052         }\r
1053 \r
1054         update(total,total);\r
1055 }\r
1056 \r
1057 /////////////////////////////////////////////////////////////////////////////\r
1058 //\r
1059 //      General code\r
1060 //\r
1061 /////////////////////////////////////////////////////////////////////////////\r
1062 \r
1063 //\r
1064 //      PM_NextFrame() - Increments the frame counter and adjusts the thrash\r
1065 //              avoidence variables\r
1066 //\r
1067 //              If currently in panic mode (to avoid thrashing), check to see if the\r
1068 //                      appropriate number of frames have passed since the last time that\r
1069 //                      we would have thrashed. If so, take us out of panic mode.\r
1070 //\r
1071 //\r
1072 void\r
1073 PM_NextFrame(void)\r
1074 {\r
1075         int     i;\r
1076 \r
1077         // Frame count overrun - kill the LRU hit entries & reset frame count\r
1078         if (++PMFrameCount >= MAXLONG - 4)\r
1079         {\r
1080                 for (i = 0;i < PMNumBlocks;i++)\r
1081                         PMPages[i].lastHit = 0;\r
1082                 PMFrameCount = 0;\r
1083         }\r
1084 \r
1085 #if 0\r
1086         for (i = 0;i < PMSoundStart;i++)\r
1087         {\r
1088                 if (PMPages[i].locked)\r
1089                 {\r
1090                         char buf[40];\r
1091                         sprintf(buf,"PM_NextFrame: Page %d is locked",i);\r
1092                         Quit(buf);\r
1093                 }\r
1094         }\r
1095 #endif\r
1096 \r
1097         if (PMPanicMode)\r
1098         {\r
1099                 // DEBUG - set border color\r
1100                 if ((!PMThrashing) && (!--PMPanicMode))\r
1101                 {\r
1102                         // DEBUG - reset border color\r
1103                 }\r
1104         }\r
1105         if (PMThrashing >= PMThrashThreshold)\r
1106                 PMPanicMode = PMUnThrashThreshold;\r
1107         PMThrashing = false;\r
1108 }\r
1109 \r
1110 //\r
1111 //      PM_Reset() - Sets up caching structures\r
1112 //\r
1113 void\r
1114 PM_Reset(void)\r
1115 {\r
1116         int                             i;\r
1117         PageListStruct  far *page;\r
1118 \r
1119         XMSPagesAvail = XMSAvail / PMPageSizeKB;\r
1120 \r
1121         EMSPagesAvail = EMSAvail * (EMSPageSizeKB / PMPageSizeKB);\r
1122         EMSPhysicalPage = 0;\r
1123 \r
1124         MainPagesUsed = EMSPagesUsed = XMSPagesUsed = 0;\r
1125 \r
1126         PMPanicMode = false;\r
1127 \r
1128         // Initialize page list\r
1129         for (i = 0,page = PMPages;i < PMNumBlocks;i++,page++)\r
1130         {\r
1131                 page->mainPage = -1;\r
1132                 page->emsPage = -1;\r
1133                 page->xmsPage = -1;\r
1134                 page->locked = false;\r
1135         }\r
1136 }\r
1137 \r
1138 //\r
1139 //      PM_Startup() - Start up the Page Mgr\r
1140 //\r
1141 void\r
1142 PM_Startup(void)\r
1143 {\r
1144         boolean nomain,noems,noxms;\r
1145         int             i;\r
1146 \r
1147         if (PMStarted)\r
1148                 return;\r
1149 \r
1150         nomain = noems = noxms = false;\r
1151         for (i = 1;i < _argc;i++)\r
1152         {\r
1153                 switch (US_CheckParm(_argv[i],ParmStrings))\r
1154                 {\r
1155                 case 0:\r
1156                         nomain = true;\r
1157                         break;\r
1158                 case 1:\r
1159                         noems = true;\r
1160                         break;\r
1161                 case 2:\r
1162                         noxms = true;\r
1163                         break;\r
1164                 }\r
1165         }\r
1166 \r
1167         PML_OpenPageFile();\r
1168 \r
1169         if (!noems)\r
1170                 PML_StartupEMS();\r
1171         if (!noxms)\r
1172                 PML_StartupXMS();\r
1173 \r
1174         if (nomain && !EMSPresent)\r
1175                 Quit("PM_Startup: No main or EMS");\r
1176         else\r
1177                 PML_StartupMainMem();\r
1178 \r
1179         PM_Reset();\r
1180 \r
1181         PMStarted = true;\r
1182 }\r
1183 \r
1184 //\r
1185 //      PM_Shutdown() - Shut down the Page Mgr\r
1186 //\r
1187 void\r
1188 PM_Shutdown(void)\r
1189 {\r
1190         PML_ShutdownXMS();\r
1191         PML_ShutdownEMS();\r
1192 \r
1193         if (!PMStarted)\r
1194                 return;\r
1195 \r
1196         PML_ClosePageFile();\r
1197 \r
1198         PML_ShutdownMainMem();\r
1199 }\r