Pushing the Limits of Windows: Virtual Memory – Microsoft Community Hub.is replace.me virus and how to remove it (3 steps)

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introduction; Related Links; Download. By Pavel Yosifovich Download CpuStres ( MB) Testlimit – Windows Sysinternals. replace.me · 1. Press and hold Windows key on your keyboard, then press button R. · 2. Enter the command “cmd” and press Enter · 3. In a command window.
 
 

Testlimit.exe sysinternals download. Testlimit v5.24

In my first Pushing the Limits of Windows post , I discussed physical memory limits, including the limits imposed by licensing, implementation, and driver compatibility. While they can stand on their own, they assume that you read them in order. Pushing the Limits of Windows: Physical Memory. Pushing the Limits of Windows: Virtual Memory.

Pushing the Limits of Windows: Processes and Threads. Pushing the Limits of Windows: Handles. The major advantage of virtual memory is that it allows more processes to execute concurrently than might otherwise fit in physical memory. While virtual memory has limits that are related to physical memory limits, virtual memory has limits that derive from different sources and that are different depending on the consumer. For example, there are virtual memory limits that apply to individual processes that run applications, the operating system, and for the system as a whole.

It’s important to remember as you read this that virtual memory, as the name implies, has no direct connection with physical memory. Windows assigning the file cache a certain amount of virtual memory does not dictate how much file data it actually caches in physical memory; it can be any amount from none to more than the amount that’s addressable via virtual memory.

Each process has its own virtual memory, called an address space, into which it maps the code that it executes and the data that the code references and manipulates. However, so that the operating system can reference its own code and data and the code and data of the currently-executing process without changing address spaces, the operating system makes its virtual memory visible in the address space of every process.

By default, bit versions of Windows split the process address space evenly between the system and the active process, creating a limit of 2GB for each:. Applications might use Heap APIs, the. When an application runs out of address space then VirtualAlloc, and therefore the memory managers layered on top of it, return errors represented by a NULL address.

The Testlimit utility, which I wrote for the 4th Edition of Windows Internals to demonstrate various Windows limits, calls VirtualAlloc repeatedly until it gets an error when you specify the —r switch. Thus, when you run the bit version of Testlimit on bit Windows, it will consume the entire 2GB of its address space:.

Some applications, like SQL Server and Active Directory, manage large data structures and perform better the more that they can load into their address space at the same time.

Since the high bit of a pointer referencing an address below 2GB is always zero, they would use the high bit in their pointers as a flag for their own data, clearing it of course before referencing the data. If they ran with a 3GB address space they would inadvertently truncate pointers that have values greater than 2GB, causing program errors including possible data corruption.

All Microsoft server products and data intensive executables in Windows are marked with the large address space awareness flag, including Chkdsk. You can see whether an image has the flag with the Dumpbin utility, which comes with Visual Studio:. The size of the process address space is different on IA64 and x64 versions of Windows where the sizes were chosen by balancing what applications need against the memory costs of the overhead page table pages and translation lookaside buffer – TLB – entries needed to support the address space.

On both IA64 and x64 versions of Windows, the size of the various resource address space regions is GB e. The address space of a bit process therefore looks something like this:. When a process commits a region of virtual memory, the operating system guarantees that it can maintain all the data the process stores in the memory either in physical memory or on disk.

That means that a process can run up against another limit: the commit limit. In reality, not quite all of physical memory counts toward the commit limit since the operating system reserves part of physical memory for its own use.

The amount of committed virtual memory for all the active processes, called the current commit charge , cannot exceed the system commit limit. When the commit limit is reached, virtual allocations that commit memory fail. That means that even a standard bit process may get virtual memory allocation failures before it hits the 2GB address space limit.

The current commit charge and commit limit is tracked by Process Explorer in its System Information window in the Commit Charge section and in the Commit History bar chart and graph:. Task Manager prior to Vista and Windows Server shows the current commit charge and limit similarly, but calls the current commit charge “PF Usage” in its graph:. On Vista and Server , Task Manager doesn’t show the commit charge graph and labels the current commit charge and limit values with “Page File” despite the fact that they will be non-zero values even if you have no paging file :.

You can stress the commit limit by running Testlimit with the -m switch, which directs it to allocate committed memory. The bit version of Testlimit may or may not hit its address space limit before hitting the commit limit, depending on the size of physical memory, the size of the paging files and the current commit charge when you run it.

If you’re running bit Windows and want to see how the system behaves when you hit the commit limit, simply run multiple instances of Testlimit until one hits the commit limit before exhausting its address space. Note that, by default, the paging file is configured to grow, which means that the commit limit will grow when the commit charge nears it.

And even when when the paging file hits its maximum size, Windows is holding back some memory and its internal tuning, as well as that of applications that cache data, might free up more. Testlimit anticipates this and when it reaches the commit limit, it sleeps for a few seconds and then tries to allocate more memory, repeating this indefinitely until you terminate it.

If you run the bit version of Testlimit, it will almost certainly will hit the commit limit before exhausting its address space, unless physical memory and the paging files sum to more than 8TB, which as described previously is the size of the bit application-accessible address space.

Here’s the partial output of the bit Testlimit running on my 8GB system I specified an allocation size of MB to make it leak more quickly :. And here’s the commit history graph with steps when Testlimit paused to allow the paging file to grow:. When system virtual memory runs low, applications may fail and you might get strange error messages when attempting routine operations. In most cases, though, Windows will be able present you the low-memory resolution dialog, like it did for me when I ran this test:.

After you exit Testlimit, the commit limit will likely drop again when the memory manager truncates the tail of the paging file that it created to accommodate Testlimit’s extreme commit requests.

Here, Process Explorer shows that the current limit is well below the peak that was achieved when Testlimit was running:. Because the commit limit is a global resource whose consumption can lead to poor performance, application failures and even system failure, a natural question is ‘how much are processes contributing the commit charge’? To answer that question accurately, you need to understand the different types of virtual memory that an application can allocate.

Not all the virtual memory that a process allocates counts toward the commit limit. As you’ve seen, reserved virtual memory doesn’t. Virtual memory that represents a file on disk, called a file mapping view, also doesn’t count toward the limit unless the application asks for copy-on-write semantics, because Windows can discard any data associated with the view from physical memory and then retrieve it from the file.

The virtual memory in Testlimit’s address space where its executable and system DLL images are mapped therefore don’t count toward the commit limit.

There are two types of process virtual memory that do count toward the commit limit: private and pagefile-backed. Private virtual memory is the kind that underlies the garbage collector heap, native heap and language allocators.

It’s called private because by definition it can’t be shared between processes. For that reason, it’s easy to attribute to a process and Windows tracks its usage with the Private Bytes performance counter.

Process Explorer displays a process private bytes usage in the Private Bytes column, in the Virtual Memory section of the Performance page of the process properties dialog, and displays it in graphical form on the Performance Graph page of the process properties dialog. Here’s what Testlimit64 looked like when it hit the commit limit:. Pagefile-backed virtual memory is harder to attribute, because it can be shared between processes.

In fact, there’s no process-specific counter you can look at to see how much a process has allocated or is referencing. When you run Testlimit with the -s switch, it allocates pagefile-backed virtual memory until it hits the commit limit, but even after consuming over 29GB of commit, the virtual memory statistics for the process don’t provide any indication that it’s the one responsible:.

For that reason, I added the -l switch to Handle a while ago. A process must open a pagefile-backed virtual memory object, called a section, for it to create a mapping of pagefile-backed virtual memory in its address space. While Windows preserves existing virtual memory even if an application closes the handle to the section that it was made from, most applications keep the handle open.

The -l switch prints the size of the allocation for pagefile-backed sections that processes have open. Here’s partial output for the handles open by Testlimit after it has run with the -s switch:. You can see that Testlimit is allocating pagefile-backed memory in 1MB blocks and if you summed the size of all the sections it had opened, you’d see that it was at least one of the processes contributing large amounts to the commit charge.

Perhaps one of the most commonly asked questions related to virtual memory is, how big should I make the paging file? Almost all the suggestions are based on multiplying RAM size by some factor, with common values being 1. Since the commit limit sets an upper bound on how much private and pagefile-backed virtual memory can be allocated concurrently by running processes, the only way to reasonably size the paging file is to know the maximum total commit charge for the programs you like to have running at the same time.

So how do you know how much commit charge your workloads require? You might have noticed in the screenshots that Windows tracks that number and Process Explorer shows it: Peak Commit Charge. To optimally size your paging file you should start all the applications you run at the same time, load typical data sets, and then note the commit charge peak or look at this value after a period of time where you know maximum load was attained. Set the paging file minimum to be that value minus the amount of RAM in your system if the value is negative, pick a minimum size to permit the kind of crash dump you are configured for.

If you want to have some breathing room for potentially large commit demands, set the maximum to double that number. I guess whoever wrote that code got their guidance from one of those magazines I mentioned! A couple of final limits related to virtual memory are the maximum size and number of paging files supported by Windows. For all versions, Windows supports up to 16 paging files, where each must be on a separate volume.

Limit on ARM. Limit on x Limit on IA