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