Continuing the trend started with Windows 7 of each new Windows version placing lighter demands on the system than its predecessor, Microsoft has been talking up some of Windows 8's new approaches to saving memory.

Some changes continue work started in Windows 7. Windows depends on a considerable number of system services to provide key functionality, and many of these system services start when the system boots and continue to run for as long as the operating system is running. This has two effects; it makes booting take longer, because the services all have to start before the operating system will log in, and these services use system memory.

Start on demand

To counteract this first issue, Windows Vista introduced the notion of a delay-started service. These services still start when the operating system itself is started, but later on in the boot process; they no longer delay the ability to log in and start using the computer. The memory load, however, remains an issue.

Windows 8 addresses that by including a new "start on demand" model. Services such as Windows Update and Plug-and-Play will only be started when needed—for example, when it's time for the daily check for updates, or when new hardware has been connected—and will stop running when no longer necessary. The result is that, most of the time, memory usage is reduced.

This ability to start services on demand is not new as such—Windows has long had the facility—and UNIX users will no doubt find it peculiar that periodic tasks such as Windows Update ran persistently rather than being run on a schedule. Nonetheless, the change is welcome, both for the reduced memory impact, and the further reduction of processing that needs to occur at boot time.

In the same theme of "only using memory when you really need to," the "classic" Windows desktop wll only be initiated when needed. Systems such as tablets, which will tend to use the immersive Metro desktop exclusively, need never run the traditional desktop. The Explorer shell and desktop wallpaper, for example, will only be loaded if users venture beyond the Metro world.

For desktop machines, this is unlikely to provide any real difference in memory usage. However, for those tablets, Microsoft is claiming a net saving of about 23 MB, with the implication that the Metro environment is quite a bit more lightweight than the desktop.

Virtual memory

Both of these changes are quite high-level, tapping into existing operating system mechanisms to achieve reductions in memory usage. but Windows 8 also contains lower-level modifications that are rather more invasive. The lower level changes all revolve around the virtual memory facilities of the operating system: Windows 8's virtual memory facilities are more powerful than those of previous versions, and the operating system has been altered to make better use of virtual memory.

Contrary to popular belief, virtual memory is not the same as "the pagefile," and cannot ever be disabled when Windows is running. Virtual memory is the system by which the processor and operating system conspire to lie to applications about the memory in the system. On 32-bit operating systems, the main lie is that every individual process has 2 GiB of private memory available to it, and that memory is linear: every byte of that memory has an address and these addresses are contiguous, starting at zero, and going all the way up to 231. This address space is larger on 64-bit systems, but the basic principles are the same.

The processor divides this address space into blocks called pages; usually each page is 4 kiB, though other sizes are possible in certain circumstances. Pages are the units that the operating system mainly deals with; whenever memory is "paged out"—that is, written to disk, to free up physical memory—this activity happens a page at a time. Conversely, when data needs to be "paged in"—read from disk into physical memory—that too happens with page granularity.

Almost all memory in Windows can be paged out to disk. This is where the pagefile comes into play; it's where most pages are placed when they're not resident in physical memory. However, not everything gets written to the pagefile. Most operating systems, including Windows, have a concept of memory-mapped files. Memory-mapped files allow the creation of pages of memory that correspond to specific named files in the filesystem. When these pages are paged out, they don't get written to the pagefile; they get written to the specific mapped file. Better than that, the pages only get written if they have been modified. If they have not been altered since they were read from the file, Windows doesn't have to write the pages back out; it can just discard them. If it ever needs the pages again, they can be safely reread from the file.

Memory-mapped files are most commonly used for loading program executables and DLLs; Windows creates memory-mapped files for each EXE and DLL. These mappings are almost always read-only. Page in operations hence come from the EXE and DLL files, and for page out operations, Windows can simply discard the pages.

Sharing pages

Memory pages can be shared between different processes. Again, memory-mapped files are the most common candidates for this kind of sharing; if two different processes both have the same DLL memory mapped, the pages of that DLL don't need to be duplicated. Since their content is the same—because it originates from the same DLL—the same physical memory can be used. The result is that while system DLLs are loaded by almost every process on the system, they only need to be loaded into memory once.

This memory sharing is useful, especially on low-memory systems, but it has its limits. The big one is that Windows only shares memory that corresponds to memory-mapped files. That's because this is the only time that Windows knows that the pages are all identical. For regular data—anything that gets written to the pagefile—there's no sharing.

Windows 8 will include a new mechanism to allow these pages to be shared. The system will periodically scan memory, and when it finds two pages that are identical, it will share them, reducing the memory usage. If a process then tries to modify a shared page, it will be given its own private copy, ending the sharing.

The gains this produces in normal day-to-day desktop usage may not be enormous. In demonstrations at BUILD last month, forcing a scan of memory to share anything possible only freed a few MB, but one scenario in particular can achieve huge gains from this kind of memory deduplication: virtualization. When virtualizing, the same operating system may be running multiple times, meaning that the same EXEs and DLLs are loaded several times over. However, the traditional memory-mapped file approach to memory sharing can't kick in here: each virtual operating system is loading its own files from its own disk image. This is where memory deduplication is useful; it can see that the pages are all identical, and hence it can allow sharing even between virtual machines.

Splitting data structures

Another change being made is a reorganization of internal data structures used by the operating system. Data that isn't used often is a good candidate for being paged out, in order to make more physical memory available. However, if even a single byte of a page stored in the pagefile is needed, the entire page has to be read from disk. If the data the operating system needs is scattered throughout memory—a few bytes in one page, a few more in the next, and so on—Windows is unable to move those pages to disk, thereby increasing the memory load.

In Windows 8, Microsoft says it has tried to split data structures so that data that is used often is kept separately from data that's used only infrequently; this way, the parts that aren't used often can be readily moved out to disk. This work involved modifying low-level components that are some of the very oldest parts of the operating system. Surprisingly, the company says that it did this work two years ago, and has been testing it on employee desktops since then. It was done so early in Windows 8's development to ensure that there was plenty of time for testing and gathering of data.

The results Redmond is claiming are impressive; consolidating often-used data on average saves "tens of MB" per machine. That's a big gain for what's essentially just a neater, tighter packing of data.

When an operating system does run out of physical memory, and has to page information out to disk, it has something of a problem: it doesn't know which memory is the best thing to page out. The best page to move to disk is the one that is least likely to be accessed (that is, the one that will be able to stay on disk as long as possible), but the operating system cannot predict the future, so it can never know for sure which page it should pick. Typically, operating systems guess: they assume that the pages that have not been used recently will probably not be used in the future either. These least-recently used pages are then preferentially written out to disk to make more physical memory available.

Least-recently used is a good guess, but it's not always right. Windows 8 will provide a new way for applications to give hints to the virtual memory system to mark some memory as "low priority." Low priority memory will be preferentially paged out even if it has been recently used. The example the company gives is of an anti-virus application. The malware scanner might need to allocate memory during a scan, but scans are relatively infrequent. This makes the scanner's memory a good candidate for being "low priority"; the system can write it out to disk aggressively, because it's probably not going to be needed, even if the memory has been recently used.

Taken together—services and a desktop that don't run unless needed, memory deduplication, memory prioritization, and better packing of operating system structures—Microsoft is claiming that Windows 8 could end up with memory usage 100 MB or more lower than Windows 7's, on the same hardware. For desktops and laptops, this may not be such a big deal, but of course, Microsoft has its eye on tablets. Every improvement made in Windows 8 will apply to ARM as well as x86 hardware, and reducing the memory load on ARM machines is critical. The work done on Windows 8 should make running on 512 MB machines a practical possibility; still tight, but viable.