The classic problem with not having a page file is that the commit kills you.
For many kinds of memory allocations, windows commits to providing the memory asked for, meaning that if the program really goes and touches all the pages that it asked for, the system will be able to provide the memory.
With a page file, this is easy - it merely has to make sure it never commits to more than the sum of the physical memory plus the page file size.
Without a page file, it can never commit more memory than you have physical memory.
Why’s that a problem? Well I was told by a guy I know who years back used to work for SCO (remember when that was a brand of UNIX, rather than a lawsuit factory?) that the OS typically needs to commit a whole lot more than is normally used.
So the net result is that turning off the page file means that 10-20% of your memory goes unused because the OS had to commit it just in case the application used all the space it asked for.
First, I’m not sure if the commit:actual usage ratio in Windows happens to match the circa 1990 ration in SCO Unix.
But more importantly, Windows is able to use memory which is technically committed but not actually in use. It uses it it in at least two ways. First, when DLLs get unloaded, the memory they used goes onto the free list, but the OS tracks the fact that the memory still contains the DLL image. (Unless the memory ends up being used, in which case it gets zeroed and then moved out of the free list…)
Second, this committed but unused memory can be used for the filesystem cache. SCO UNIX couldn’t do that. (Or at least it couldn’t back in 1990.) File system caching was done in a fixed-size preallocated chunk of memory.
The file system cache is a pretty significant performance feature, and in practice, I would expect it usually uses a much higher proportion of your memory than the committed-but-unused memory. (Right now, my filesystem cache has about 1GB in it!)
So in practice, the classic concerns about why you need a pagefile to get the most out of your physical memory probably no longer apply.
The possible exceptions you describe would correspond to an abnormally high commit : used ratio.