Expanded Memory Management

• What the Expanded Memory Manager is
• How expanded memory works
• How an application uses expanded memory
• How the sample program uses emm_functions
• Expanded Memory functions
  • emm_allocpages
  • emm_deallocpages
  • emm_gethandlecount
  • emm_gethandlespages
  • emm_getpagemap
  • emm_getpagemapsize
  • emm_getsetpagemap
  • emm_gettotal
  • emm_getunalloc
  • emm_getversion
  • emm_init
  • emm_maphandle
  • emm_physpage
  • emm_restorepagemap
  • emm_savepagemap
  • emm_setpagemap
  • emm_term

The current implementation uses the facilities of Expanded Memory Specification (EMS) 3.2 to ensure the widest possible compatibility. Applications written using the EMM functions or the __handle pointer system are therefore compatible with expanded memory managers for both EMS 3.2 and the newer EMS 4.0, as well as with the EMS facilities provided by MS-DOS versions 4.x and 5.0.

What is Expanded Memory

Expanded memory provides real-mode MS-DOS with access to bank-switched memory. It is not required in protected mode programs; these functions are not available when compiling for DOSX. EMS version 3.2 allows a maximum of 8MB of expanded memory to be used whereas version 4.0 allows up to 32MB (2048 logical pages) to be made available to applications or the operating system.

Blocks of the expanded memory are overlaid on a region of conventional memory, known as a page frame, and swapped in and out of the normal addressing space, as needed. When a block of expanded memory is swapped into the page frame it can be used to store and retrieve data just as if it were conventional memory. Data stored within the blocks is retained even when not swapped in.

An expanded memory system normally consists of two components:

° An expansion board containing extra memory and some special control chips
° An MS-DOS device driver known as the Expanded Memory Manager (EMM).

However, a number of other methods can implement expanded memory. Some software-only systems are designed to emulate expanded memory in the 16MB address space of 80286 based computers (known as extended memory). Other systems emulate expanded memory using hard disk storage.

1. Test whether an Expanded Memory Manager is installed.
   
2. Determine if enough expanded memory pages are available for the application's purposes.
   
3. Request EMM to allocate the required number of expanded memory (logical) pages.
   
4. Use a unique EMM handle, supplied by EMM, to refer to the application's allocated pages.
   
5. Obtain, from EMM, the base address of the various physical pages in order to know which memory addresses to use to access the expanded memory.
   
6. Map some of the expanded memory (logical) pages into the physical pages within the page frame.
   
7. Write data to and read data from these logical pages, just as if it were using conventional memory.
   
8. Repeat steps 6 and 7 as necessary.
   
9. Return (deallocate) the expanded memory pages, when it finishes using expanded memory, to the EMM pool.
   
10. Terminate the use of EMM so other applications can use expanded memory.
    
    

 
	#include <stdio.h>
	#include <stdlib.h>
	#include <EMM.h>

	#define HANDLES 4 

	/* 	chkout: make sure an EMM supervisor is 
	installed. */ 
	void chkout(void)
	{ 
	   int i, version; 
	   float ver_no; 

	   if (EMM_init()) { 
	      printf("Unable to initiate EMS driver\n"); 
  	      exit(EXIT_FAILURE); 
	   } 

	   version = EMM_getversion(); 
	   ver_no = version/ 16+ version% 16/ 10.0; 

	   printf("EMS driver detected, 
	   	     version %1.1f\n", ver_no); 

	   printf("\tlogical page\t\tsegment\n"); 
	   for (i = 0; i < 4; i++) { 

	printf("\t% d\t\t\t% lp\n", i, EMM_physpage(i)); 
	   } 
	   printf("\n"); 
	} 

	/* 	check that allocation worked */
	void check_aloc(void) 
	{ 
	   int i, noh; 
	   struct EMM_handle_s *hp; 

	   noh = EMM_gethandlecount(); 

	   if ((hp = calloc(noh, sizeof(struct 
		  EMM_handle_s))) == NULL) { 
	   printf("Insufficient Memory: function 
		    check_aloc\n"); 
	   exit(EXIT_FAILURE);
	} 

	   EMM_gethandlespages(hp); 

	   printf("\thandle no.\t\tpages\n"); 
	   for (i = 0; i < noh; i++) { 
	      printf("\t% d\t\t\t% d\n", hp[i]. handle, 
		        hp[i]. pages); 
	   } 
	   printf("\n"); 

	} 

	use_EMM(unsigned h, int logical) 
	{ 
	   char message[128], *s; 
	   char __far *src, far *dst; 

	   src = EMM_physpage(0); 
	   dst = EMM_physpage(1); 

	   printf("Writing string to physical page 0 at " 
		"% lp\n", src); 
	   sprintf(message,"Hello, from physical page 1 
		   at "
		"% lp", dst); 
	   EMM_maphandle(h, logical, 0); 
	   s = message; 
	   while (* s) 
	      *src++ = *s++; 

	   printf("Reading String from EMM buffer:\n"); 
	   EMM_maphandle(h, logical, 1); 
	   s = message; 
	   while (* s) 
	      *s++ = *dst++; 
	   printf("Handle %d message= '% s'.\n", h, message); 
	} 
	int main() 
	{ 
	   unsigned i, usedp, thandle[HANDLES]; 

	   chkout() ; 

	   printf("No. of active handles is %d \n", 
		   EMM_gethandlecount()); 

	   for (i= 0; i< HANDLES; i++) { 
	      /* Take half of what is available */ 
	      usedp = (EMM_getunalloc()+ 1)>> 1; 
	      thandle[i] = EMM_allocpages(usedp); 
	      printf("% d pages allocated to handle 
	              %d\n", usedp, thandle[i]); 
	   } 

	   printf("No. of active handles is %d \n", 
	            EMM_gethandlecount()); 
	   printf("Total size is %d pages\n", 
	            EMM_gettotal()); 
	   printf("Free size is %d pages\n", 
		    EMM_getunalloc()); 

	   check_aloc(); 
	   use_EMM(thandle[0], 0); 

	   for (i= 0; i< HANDLES; i++) { 
	      EMM_deallocpages(thandle[i]); 
	      printf("[% d] H=% d freed\n", i, thandle[i]); 
	   } 
	   printf("Total size is %d pages\n", 
	            EMM_gettotal()); 
	   printf("Free size is %d pages\n", 
		    EMM_getunalloc()); 
	   printf("Done with EMM test.\n"); 
	   EMM_term(); 
	   return EXIT_SUCCESS; 
	}