There are (under win32), two situations in which a page fault can occur.

1. The first is when an attempt is made to access a reserved and commited page that has been relegated to the system pagefile (or other backing file) due to overall system memory exhaustion.

   This is scenario you have based your post upon.

2. The second is when an attempt is made to access a page of memory that has been reserved, but not yet commited.

   Win32 memory management schemes frequently use VirtualAlloc( baseAddr, someLargeSize, MEM_RESERVE, PAGE_READWRITE|PAGE_WRITECOPY|PAGE_GUARD ) to reserve a large address space to the process, but without actually allocating physical memory or pagefile space.

   This memory can then be managed using the Heap* functions APIs which will automatically commit previously reserved pages on-demand.

   Once reserved memory has been commited, it is also possible to MEM_RESET that memory. This indicates to the OS that the pages in question are no longer being used and so need not be written to the pagefile when their physical pages are to be reused for other processes, but the virtual pages are not decommited, because they will be reused at a later point.

   A quote from the documentation spells this out more clearly:

   The HeapCreate function creates a private heap object from which the calling process can allocate memory blocks by using the HeapAlloc function. HeapCreate specifies both an initial size and a maximum size for the heap. The initial size determines the number of committed, read/write pages initially allocated for the heap. The maximum size determines the total number of reserved pages. These pages create a contiguous block in the virtual address space of a process into which the heap can grow. Additional pages are automatically committed from this reserved space if requests by HeapAlloc exceed the current size of committed pages, assuming that the physical storage for it is available. Once the pages are committed, they are not decommitted until the process is terminated or until the heap is destroyed by calling the HeapDestroy function.

   So you see, by preallocating a large chunk of memory and then freeing it back to the heap, the pages commited by that large allocation are commited (backed by physical memory and/or pagefile space), but then returned to the heap manager for reallocation. They are therefore already commited (to the process/physical memory/pagefile) but free for reallocation for subsequent calls to HeapAlloc. This means that new calls to HeapAlloc can be satisfied in user mode as there is no need for transition to kernel mode to commit new pages to the process.

This extract from Win32.c is one example of the manipulations Perl does with MEM_RESERVED and MEM_COMMIT:

static char *committed = NULL;      /* XXX threadead */
static char *base      = NULL;      /* XXX threadead */
static char *reserved  = NULL;      /* XXX threadead */
static char *brk       = NULL;      /* XXX threadead */
static DWORD pagesize  = 0;     /* XXX threadead */

void *
sbrk(ptrdiff_t need)
{
 void *result;
 if (!pagesize)
  {SYSTEM_INFO info;
   GetSystemInfo(&info);
   /* Pretend page size is larger so we don't perpetually
    * call the OS to commit just one page ...
    */
   pagesize = info.dwPageSize << 3;
  }
 if (brk+need >= reserved)
  {
   DWORD size = brk+need-reserved;
   char *addr;
   char *prev_committed = NULL;
   if (committed && reserved && committed < reserved)
    {
     /* Commit last of previous chunk cannot span allocations */
     addr = (char *) VirtualAlloc(committed,reserved-committed,MEM_COM
+MIT,PAGE_READWRITE);
     if (addr)
      {
      /* Remember where we committed from in case we want to decommit 
+later */
      prev_committed = committed;
      committed = reserved;
      }
    }
   /* Reserve some (more) space
    * Contiguous blocks give us greater efficiency, so reserve big blo
+cks -
    * this is only address space not memory...
    * Note this is a little sneaky, 1st call passes NULL as reserved
    * so lets system choose where we start, subsequent calls pass
    * the old end address so ask for a contiguous block
    */
sbrk_reserve:
   if (size < 64*1024*1024)
    size = 64*1024*1024;
   size = ((size + pagesize - 1) / pagesize) * pagesize;
   addr  = (char *) VirtualAlloc(reserved,size,MEM_RESERVE,PAGE_NOACCE
+SS);
   if (addr)
    {
     reserved = addr+size;
     if (!base)
      base = addr;
     if (!committed)
      committed = base;
     if (!brk)
      brk = committed;
    }
   else if (reserved)
    {
      /* The existing block could not be extended far enough, so decom
+mit
       * anything that was just committed above and start anew */
      if (prev_committed)
       {
       if (!VirtualFree(prev_committed,reserved-prev_committed,MEM_DEC
+OMMIT))
        return (void *) -1;
       }
      reserved = base = committed = brk = NULL;
      size = need;
      goto sbrk_reserve;
    }
   else
    {
     return (void *) -1;
    }
  }
 result = brk;
 brk += need;
 if (brk > committed)
  {
   DWORD size = ((brk-committed + pagesize -1)/pagesize) * pagesize;
   char *addr;
   if (committed+size > reserved)
    size = reserved-committed;
   addr = (char *) VirtualAlloc(committed,size,MEM_COMMIT,PAGE_READWRI
+TE);
   if (addr)
    committed += size;
   else
    return (void *) -1;
  }
 return result;
}
[download]

And here are some references to the Heap* calls from vmem.h:

#define WALKHEAP() WalkHeap(0)
#define WALKHEAPTRACE() WalkHeap(1)
 * HeapRec - a list of all non-contiguous heap areas
const int maxHeaps = 32; /* 64 was overkill */
 * Use VirtualAlloc() for blocks bigger than nMaxHeapAllocSize since
const int nMaxHeapAllocSize = (1024*512);  /* don't allocate anything 
+larger than this from the heap */
    int HeapAdd(void* ptr, size_t size
    BOOL bRet = (NULL != (m_hHeap = HeapCreate(HEAP_NO_SERIALIZE,
    ASSERT(HeapValidate(m_hHeap, HEAP_NO_SERIALIZE, NULL));
    BOOL bRet = HeapDestroy(m_hHeap);
        HeapFree(m_hHeap, HEAP_NO_SERIALIZE, m_heaps[index].base);
    ptr = HeapReAlloc(m_hHeap, HEAP_REALLOC_IN_PLACE_ONLY|HEAP_NO_SERI
+ALIZE,
        HeapAdd(((char*)ptr) + m_heaps[m_nHeaps-1].len, size
    ptr = HeapAlloc(m_hHeap, HEAP_NO_SERIALIZE, size);
    if (HeapAdd(ptr, size)) {
    if (HeapAdd(ptr, size, bBigBlock)) {
    HeapAdd(ptr, size);
int VMem::HeapAdd(void* p, size_t size
void VMem::WalkHeap(int complete)
    MemoryUsageMessage("VMem heaps used %d. Total memory %08x\n", m_nH
+eaps, total, 0);
        ASSERT(HeapValidate(m_hHeap, HEAP_NO_SERIALIZE, ptr));
[download]

So yes. Even accesses to commited memory can cause a pagefault in low memory situations, but when you know you are about to allocate a large number of small pieces of memory--as when filling a large hash or array for the first time--preallocating a large chunk in a single allocation and then freeing it means that space is commited as the result of a single page fault and then returned to the heap for reallocation by the many small alloctions without the need for further page faults.

What say you now of my "confusion"?