// Assuming there are some fast memory available on a platform at
physical 
// address 0x40000000, of size 0x80000.
// The following code creates a heap on using this memory when
possible.
//
#define  PHYS_MEM_ADDR 0x40000000
#define  PHYS_MEM_SIZE 0x00080000
//
BOOL g_fPhysMemUsed;
//
// The allocator
LPVOID MyAllocMem (LPVOID pAddr, DWORD cbSize, DWORD fdwAction,
LPDWORD pdwData)
{
   LPVOID lpRet = NULL;
   switch (fdwAction) {
	case MEM_RESERVE:
	// Reserve VM using VirtualAlloc
	if (!(lpRet = VirtualAlloc (pAddr, cbSize, MEM_RESERVE,
PAGE_NOACCESS))) {
		 SetLastError (ERROR_OUTOFMEMORY);
		 break;
}
	// Use the physical memory if possible
	if (!g_fPhysMemUsed && (cbSize <= PHYS_MEM_SIZE))
{
		 // Yes, physical memory is available, use VirtualCopy
		 if (!VirtualCopy (lpRet, (LPVOID) (PHYS_MEM_ADDR >>
8), cbSize, PAGE_READWRITE|PAGE_PHYSICAL)) {
			 SetLastError (ERROR_OUTOFMEMORY);
			 break;
		 }
		 g_fPhysMemUsed = TRUE;
		 *pdwData = PHYS_MEM_ADDR;
} 
	else {
		 *pdwData = 0;   // Indicates this is not using physical
memory
}
	break;
	case MEM_COMMIT:
	// MEM_COMMIT should not change the content of *pdwData, as
the data
	// is a 'per-reservation' information.
	if (PHYS_MEM_ADDR  == *pdwData) {
		 // This is using physical memory, already committed
		 lpRet = pAddr;
} 
	else {
		 lpRet = VirtualAlloc (pAddr, cbSize, MEM_COMMIT,
PAGE_READWRITE);
}
	break;
	default:
	// This should never happen
		 DEBUGCHK (0);
		 break;
   }
return lpRet;
}
//
// The de-allocator
//
BOOL MyFreeMem (LPVOID pAddr, DWORD cbSize, DWORD fdwAction, DWORD
dwData)
{
   BOOL fRet = FALSE;
   switch (fdwAction) {
	case MEM_DECOMMIT:
		 if (PHYS_MEM_ADDR  == dwData) {
			// This is using physical memory; never needs to
decommit
			break;
		 }
		 // VirtualAlloc'd data, decommit the memory
		 fRet = VirtualFree (pAddr, cbSize, MEM_DECOMMIT);
		 break;
	case MEM_RELEASE:
		 // Release the reservation
		 fRet = VirtualFree (pAddr, 0, MEM_RELEASE);
		 if (fRet && (PHYS_MEM_ADDR  == dwData)) {
			// Physical memory is released and is available again
			g_fPhysMemUsed = TRUE;
		 }
		 break;
	default:
	// This should never happen
		 DEBUGCHK (0);
		 break;
}
   return fRet;
}
//
// To create a heap with the custom allocator/de-allocator
int MyFunc ()
{
   HANDLE hHeap = CeHeapCreate (0, 0, 0, MyAllocMem, MyFreeMem);
   LPVOID p;
   if (hHeap) {
	// Heap creation failed
	// ErrorHandling ();
	return 0;
   }
   // Ordinary heap operation can be performed on the heap
   p = HeapAlloc (hHeap, 0, 100);  
   HeapFree (hHeap, 0, p);
   //...
   // Finish using the heap, destroy it
   HeapDestroy (hHeap);
	return 0;
}