100 physical memory errors. Device manager error codes. What do page out errors indicate?

In my last article "" I talked about the capabilities of the Windows 7 Resource Monitor (Resource Monitor), explained how to use it to monitor the distribution of system resources between processes and services, and also mentioned that it can be used to solve specific problems - for example, to analyze memory usage. This is what will be discussed in this article.

A little about memory

Before proceeding to the analysis, I will briefly talk about how memory manages. After that, it will be easier for you to understand what information is presented in the Windows 7 Resource Monitor.

The Windows 7 Memory Manager creates a virtual memory system that consists of the available physical RAM and the swap file on the hard drive. This allows the operating system to allocate fixed-length blocks of memory (pages) with consecutive addresses in physical and virtual memory.

Launching Windows 7 Resource Monitor

To launch the Windows 7 Resource Monitor, open the Start menu (Start), type "Resmon.exe" in the search bar and click . In the window that opens, select the "Memory" tab (Memory, Fig. A).

Figure A The Memory tab in Windows 7 Resource Monitor provides detailed memory allocation information.

Table "Processes"

The Memory tab has a Processes table (Figure B) that lists all the running processes, with the memory used broken down into several categories.

Figure B The memory usage information for each process is broken down into several categories.

Column "Image"

The Image column contains the name of the process's executable file. The processes started by applications are very easy to recognize - for example, the process "notepad.exe" obviously belongs to Notepad (Notepad). Processes named "svchost.exe" represent various operating system services. The name of the service is given in parentheses next to the process name.

Process ID column

The Process ID (PID) column contains the process number, a unique combination of numbers that identifies a running process.

Column "Completed"

The Commit column shows the amount of virtual memory, in kilobytes, that the system has reserved for this process. This includes both the physical memory used and the pages stored in the paging file.

Column "Working set"

The Working Set column shows the amount of physical memory, in kilobytes, that the process is currently using. The working set is made up of shared and private memory.

Column "General"

The Shareable column shows the amount of physical memory, in kilobytes, that this process is sharing with others. Using a single memory segment or swap page for related processes saves memory space. In this case, only one copy of the page is physically stored, which is then mapped to the virtual address space of other processes that access it. For example, all processes initiated by the system DLLs - Ntdll, Kernel32, Gdi32, and User32 - use shared memory.

Column "Private"

The Private column indicates the amount of physical memory, in kilobytes, that is exclusively used by this process. It is this value that allows you to determine how much memory a particular application needs to work.

Column "Errors of the absence of a page in memory / sec."

In the column "Page out of memory errors / sec." (Hard Faults/sec) indicates the average number of memory page faults per second over the last minute. If a process tries to use more physical memory than is currently available, the system writes some of the data from memory to disk - the paging file. The subsequent access to the data saved to disk is called a page out of memory error.

What do page out errors indicate?

Now that you have an idea of what information is collected in the Processes table, let's see how to use it to monitor memory allocation. As applications start and work with files, the memory manager keeps track of the working set for each process and captures requests for additional memory resources. As a process's working set increases, the dispatcher matches these requests to the needs of the kernel and other processes. If there is not enough available address space, the dispatcher shrinks the working set by saving data from memory to disk.

Later, when reading this data from disk, a page out of memory error occurs. This is quite normal, but if errors occur simultaneously for different processes, the system needs additional time to read data from disk. Too frequent page out of memory errors, respectively, reduce system performance. You have probably experienced an unexpected slowdown in all applications, which then also suddenly stopped. Almost certainly, this slowdown was due to the active reallocation of data between physical memory and swap.

The conclusion follows from this: if out-of-page errors for a particular process occur too often and moreover regularly, the computer does not have enough physical memory.

To make it easier to monitor processes that cause frequent page out of memory errors, you can mark them with flags. This will move the selected processes to the top of the list, and the page out of memory error graph will be represented by an orange curve.

Keep in mind that memory allocation depends on a number of other factors, and monitoring out-of-page errors is not the best or the only way to identify problems. However, it can serve as a good starting point for observation.

Table "Physical memory"

The Processes table provides detailed information about memory allocation between individual processes, while the Physical Memory table gives a general picture of RAM usage. Its key component is the unique histogram shown in Fig. C.

Figure C. The bar graph in the Physical Memory table provides an overview of memory allocation in Windows 7.

Each section of the histogram is marked with its own color and represents a specific group of memory pages. As the system is used, the memory manager moves data between these groups in the background, maintaining a delicate balance between physical and virtual memory to keep all applications running efficiently. Let's take a closer look at the histogram.

Section "Reserved Equipment"

On the left is the "Hardware Reserved" section, marked in gray: this is the memory allocated for the needs of the connected equipment, which it uses to interact with the operating system. Memory reserved for hardware is locked and cannot be accessed by the memory manager.

Usually, the amount of memory allocated to the hardware is between 10 and 70 MB, but this figure depends on the specific configuration of the system and in some cases can reach several hundred megabytes. Components that affect the amount of reserved memory include:

;
motherboard components - for example, an advanced programmable input / output interrupt controller (APIC);
sound cards and other devices that perform memory-mapped input/output;
PCI Express (PCIe) bus;
video cards;
various chipsets;
flash drives.

Some users complain that their systems have an abnormally large amount of memory reserved for hardware. I have never encountered such a situation, and therefore I cannot vouch for the effectiveness of the proposed solution, but many note that updating the BIOS version solves the problem.

Section "Used"

The In Use section, shown in green, represents the amount of memory used by the system, drivers, and running processes. The amount of memory used is calculated as the value of "Total" (Total) minus the sum of the indicators "Changed" (Modified), "Waiting" (Standby) and "Free" (Free). In turn, the value of "Total" is the indicator "Installed" (Installed RAM) minus the indicator "Reserved equipment".

Section "Changed"

Highlighted in orange is the "Modified" section, which shows modified but not used memory. In fact, it is not used, but can be activated at any time if needed again. If the memory has not been used for a long time, the data is transferred to the paging file, and the memory goes into the Standby category.

Section "Waiting"

The Pending section, shown in blue, represents memory pages that have been removed from the working sets but are still associated with them. In other words, the Pending category is actually a cache. Memory pages in this category are assigned a priority of 0 to 7 (maximum). Pages associated with high priority processes receive the highest priority. For example, shared processes have a high priority, so their associated pages are given the highest priority in the Pending category.

If a process needs data from a pending page, the memory manager immediately returns that page to the working set. However, all pages in the Pending category are available for writing data from other processes. When a process needs more memory and there is not enough free memory, the memory manager selects a pending page with the lowest priority, initializes it, and allocates it to the requesting process.

Section "Free"

The Blue Free category represents pages of memory that have not yet been allocated to any process or that have been freed after the process exits. This section shows both not yet used and already freed memory, but in fact, not yet used memory belongs to another category - "Zero Pages" (Zero Page), which is so called because these pages are initialized to zero and ready for use.

About the problem of free memory

Now that you have a basic idea of how the memory manager works, let's take a quick look at a common misconception about Windows 7's memory management system. C, the free memory section is one of the smallest in the histogram. However, it is a mistake to assume on this basis that Windows 7 consumes too much memory and that the system cannot work properly if there is so little free memory.

In fact, it's quite the opposite. In the context of the Windows 7 approach to memory management, free memory is useless. The more memory involved, the better. By filling up memory to the maximum and constantly moving pages from one category to another using a priority system, Windows 7 improves efficiency and prevents data from entering the page file, preventing out-of-memory page faults from slowing down performance.

Memory monitoring

Want to see the Windows 7 memory management system in action? Reboot your computer and open the Windows 7 Resource Monitor immediately after startup. Go to the Memory tab and pay attention to the ratio of sections in the physical memory histogram.

Then start running applications. As you run, watch the histogram change. After running as many applications as possible, start closing them one at a time and watch how the ratio of sections in the physical memory histogram changes.

By doing this extreme experiment, you will understand how Windows 7 manages memory on your particular computer and you can use the Windows 7 Resource Monitor to monitor memory allocation under normal day-to-day working conditions.

What do you think?

Do you like the idea of using the Windows 7 Resource Monitor to monitor memory allocation? Share your opinion in the comments!

Preemptive/nonpreemptive algorithms.

In the case of a preemptive algorithm, the operating system can at any time interrupt the execution of the current thread and switch the processor to another thread. In non-preemptive algorithms, the thread given the processor decides when to hand over control to the operating system.

Algorithms with quantization.

Each thread is given a time slice during which the thread can run on the processor. When the quantum expires, the operating system switches the processor to the next thread in the queue. The quantum is usually equal to an integer number of intervals of the system timer 1 .

Algorithms with priorities.

Each thread is assigned a priority (priority) - an integer indicating the degree of privilege of the thread. The operating system, if there are several threads ready to execute, selects the thread with the highest priority among them.

Windows implements a mixed scheduling algorithm - preemptive, based on quantization and priorities.

Multitasking type for DOS application
Service Guarantees
Scheduling foreground processes
Purpose of the swap file
Processes P1, P2, P3 allocate 100, 20, 80 MB of memory. The system has 128MB of OP. What is the amount of used memory in the swap file. What is the size of the swap file.

What is a "page fault"?

Interrupt 14 -page fault (#PF): Intel386 ...

It is generated if the paging mechanism is activated (CR0.PG = 1) and one of the following situations occurs when translating a linear address into a physical one:

element of the page table or page catalog used in address translation, has zero presence bit, i.e. the desired page table or page is not present in physical memory;
procedure does not have privilege level, sufficient to access the selected page, or attempts to write to a page that is write-protected for the current privilege level.

The page fault handler obtains information about its cause from two sources: the error code pushed onto the stack, and the contents of CR2, which contains the linear address that caused the error. The page error code has a special format (Fig. 3.7.).

An interrupted program, after eliminating the causes that caused the page fault (for example, a page load in physical memory), can be continued without any additional adjustments.

If a page fault was caused due to a violation of page security privileges, then the access bit (A) in the corresponding page directory entry is set. The behavior of the access bit in the corresponding page table entry for this case is not regulated in Intel processors and may be different in different models.

A high page fault rate indicates:

Unreliability of the program

Unreliability of RAM

Other: explain

Column "Errors of the absence of a page in memory / sec."

What do page out errors indicate?

Later, when reading this data from disk, a page out of memory error occurs. This is quite normal, but if errors occur simultaneously for different processes, the system needs additional time to read data from disk. Too frequent page out of memory errors, respectively, reduce system performance.. You have probably experienced an unexpected slowdown in all applications, which then also suddenly stopped. Almost certainly, this slowdown was due to the active reallocation of data between physical memory and swap.

The conclusion follows from this: if out-of-page errors for a particular process occur too often and moreover regularly, The computer does not have enough physical memory.

To make it easier to monitor processes that cause frequent page out of memory errors, you can mark them with flags. This will move the selected processes to the top of the list, and the page out of memory error graph will be represented by an orange curve.

How Thread Priority is Formed in Windows

Priorities

Windows implements preemptive priority scheduling, when each thread is assigned a certain numerical value - a priority, according to which a processor is allocated to it. Threads with the same priorities are scheduled according to the Round Robin algorithm (carousel). An important advantage of the system is the ability to preempt threads running in kernel mode - the code of the executive system is completely reentrant. Only threads holding the spinlock are not preempted (see "Thread Synchronization"). Therefore, spinlocks are used with great care and set to a minimum time.

The system has 32 priority levels. Sixteen priority values (16-31) correspond to the real-time priority group, fifteen values (1-15) are for normal threads, and a value of 0 is reserved for the system page-zeroing thread (see Figure 6.2).

Rice. 6.2. Thread Priorities

To save the user from having to remember the numerical values of priorities and be able to modify the scheduler, the developers introduced into the system priority abstraction layer. For example, the priority class for all threads of a particular process can be set using the set of constant parameters of the SetPriorityClass function, which can have the following values:

real time (REALTIME_PRIORITY_CLASS) - 24
high (HIGH_PRIORITY_CLASS) - 13
above normal (ABOVE_NORMAL_PRIORITY_CLASS) 10
normal (NORMAL_PRIORITY_CLASS) - 8
below normal (BELOW_NORMAL_PRIORITY_CLASS) - 6
and broken (IDLE_PRIORITY_CLASS) 4

The relative thread priority is set by the same parameters of the SetThreadPriority function:

The combination of six process priority classes and seven thread priority classes forms 42 possible combinations and allows forming the so-called basic thread priority.

The base priority of a process and the primary thread defaults to a value in the middle of the process priority ranges ( 24, 13, 10, 8, 6 or 4). Changing a process's priority changes the priorities of all of its threads, leaving their relative priorities unchanged.

Priorities 16 through 31 are not really real-time priorities, because under Windows' soft real-time support, no guarantees are made about the timing of threads. These are simply higher priorities that are reserved for system threads and those threads that are given such priority by a user with administrative rights. Nevertheless, the presence of real-time priorities, as well as the preemptibility of the kernel code, the localization of memory pages (see "Memory manager operation") and a number of additional features - all this allows you to run soft real-time applications, such as multimedia, in the Windows OS environment. The system thread with zero priority is engaged in zeroing memory pages. Regular user threads can have priorities from 1 to 15.

Similar information.

Memory allocation in Windows 9x and in Windows NT. Windows 7 Resource Monitor. Explore memory-related items and tabs. Using the Windows 7 Resource Monitor to monitor memory allocation. Increasing the size of the paging file (virtual memory). Checking memory using Windows.

3.1. Memory allocation in Windows 9x

Windows 9x is a 32-bit multi-threaded OS with preemptive multitasking and a graphical user interface. For their boot, they use MS-DOS 7.0, which provides two modes of processor operation - real (in the MSDOS.SYS file, BootGUI=0 is written in the section) and protected (BootGUI=1). Protected mode is set just before Windows 9x boots, causing the processor to manage memory using the virtual-to-physical address paging mechanism. The area of the virtual address space consists of 4 kilobyte pages, which are placed in RAM or on disk.

The lower addresses of the virtual address space are shared by all processes to ensure compatibility with real-time device drivers, Windows resident programs, etc. On the one hand, this is convenient, but, on the other hand, reduces reliability (one of the main qualities of the OS), because any process can corrupt the components located at these addresses.

Each 32-bit Windows application program runs in its own address space, however, access to the desired addresses is possible, i.e. the organization of virtual addresses does not use all the hardware protections built into the microprocessor. 16-bit programs share a common address space and are also vulnerable to each other. The Windows 9x memory model is shown in Figure 3.1.

Rice. 3.1. OP distributions in Windows 9x

The bottom 64 KB of RAM is inaccessible to 32-bit programs, but 16-bit programs can write their data here. Addresses below 4 MB are mapped to the address space of each application and are shared by all processes. This makes this area unprotected from accidental writing.

The minimum required amount of memory for the operation of Windows 9x is 4 MB, but in practice it is impossible to work with this amount of memory. page file , which implements the virtual memory mechanism, is located in the Windows directory and has a variable size, changed if necessary by the system itself. Its dimensions can be set using system tools (Control Panel → System → Performance → File system), or set in the section of the SYSTEM.INI file - a line indicating the drive and file name:

Pagingfive=c:\PageFile.sys

MinPagingFileSize=65536 (64 MB)

MaxPagingFileSize=262144 (256 MB)

The first and second lines define the file name and its location, and the last two - the initial and limit size of the page file in KB.

You can obtain the minimum paging file size by running SysMon (system monitor) and selecting the paging file size and free memory as required parameters to estimate the memory requirements of the most commonly used applications.

3.2. Memory allocation in Windows NT

The differences between the distribution scheme and Windows 9x are as follows:

1) more serious use of memory protection hardware provided in the microprocessor;

2) all system program modules are located in their own virtual address spaces and application programs cannot access them.

The distribution of address space in Windows NT is shown in Fig. 3.2.

Rice. 3.2. OP distributions in Windows NT

Application programs are allocated 2 GB of local (native) linear (unstructured) address space (the first 64 KB are inaccessible). They are isolated from each other and can communicate with each other only through the clipboard (clipboard), or through the DDE (Dynamic Data Exchange - dynamic data exchange) and OLE (Object Linking and Embedding) mechanisms.

At the top of the 2 GB area is the code for system DLLs (dynamically linked libraries) that act as server processes. They check the values of query parameters, execute the requested function, and send the results back to the address space of the calling program.

In the 2-4 GB address range, there are system (low-level) Windows components (ie the highest level of protection against unauthorized access: kernel, thread scheduler, memory manager).

For 16-bit Windows application programs, WOW (Windows On Windows) sessions are implemented in preemptive multitasking mode individually in their own address spaces or jointly in a shared address space.

When the application is launched, a process is created with its own information structure, within which the task is launched. It can run other tasks. As a result, a multitasking mode of operation is organized.

Memory management (allocation, reservation, deallocation, paging) is performed by the Virtual Memory Manager (VMM). Each virtual page is transferred to a physical page - a page frame (page frame), filled in the initial state with zeros (this is the main requirement of the standard for C2 security systems, which determines the impossibility of using their previous contents by other processes). The space for page unloading is reserved in the page file Pagefile.sys, which is a reserved block of disk space.

All Windows NT memory is subdivided into reserved(for dynamic use by processes when executing tasks), dedicated(for unloading which is reserved in Pagefile.sys) and affordable(the rest of the free memory).

Virtual Memory in Windows

The most common reason for slowing down a Windows-based system is filling up physical memory. At the same time, Windows begins the so-called "paging" (paging) - moving blocks of code and program data (each such block is called a page - page) from physical memory to the hard disk. Accessing the paging file from time to time is normal and does not degrade system performance, but frequent requests for data from a file on disk can significantly slow down the overall speed of the system. This issue becomes especially noticeable when switching between multiple memory-intensive programs on a computer that doesn't have enough physical memory. As a result, the disk is almost constantly in use, because the system is trying to "pump" data from it to memory and back.

If the total amount of allocated memory exceeds the total amount of physical memory, Windows has to "pump" pages between fast RAM and much slower virtual memory in the pagefile, slowing the system down.

During the installation of Windows XP, a swap file is automatically created in the root folder on the same drive where the Windows system files are located. The paging file size is determined based on the amount of physical memory in the system. By default, the minimum page file size is 1.5 times the amount of physical memory and the maximum size is 3 times the size. The paging file can be seen in the Explorer window if you turn on the display mode of hidden and system files (Fig. 3.3).

Rice. 3.3. Enabling the display of hidden and system files

Usually, the Windows operating system itself sets the optimal amount of virtual memory and it is enough for most tasks, but if the computer is running applications that require a lot of memory, then the amount of virtual memory can be changed.

To do this, perform the following sequence of actions:

1. Log in with an account from the Administrators group and open the "Control Panel - System" window.

2. On the "Advanced" tab, click the "Settings" button in the "Performance" section (Fig. 3.4).

3. In the "Performance Options" dialog box, select the "Advanced" tab and click the "Change" button (Fig. 3.5) to display the "Virtual Memory" dialog box, as shown in Fig. 3.5. 3.6 for Windows XP and in fig. 3.7 for Windows7.

The current paging file settings are reflected in the "Total paging file size across all drives" field.

4. Select any drive from the list at the top of the dialog box to configure the settings for that drive.

You can change the following options:

- Special size. Enter a value in the field original size to set the initial size of the pagefile.sys file on the specified drive (in megabytes). In field Maximum size enter a number not less than the value in the field original size, but not exceeding 4096 MB (4 GB).

- Size at the choice of the system. Select this item to enable dynamic paging file size management for this drive. Select this option if you do not want to change the default settings offered by Windows.

- No swap file. Use for all drives where you don't need a swap file. Make sure the swap file is on at least one drive.

5. After making any changes, click Ask to record changes.

6. Repeat steps 4 and 5 for other drives (if necessary). Click OK to close the dialog box when you're done with it.

Rice. 3.4. "Options" button to go to view and/or

changing virtual memory settings

Rice. 3.5. "Change" button to go to changing virtual memory settings in Windows XP (left) and in Windows 7

Rice. 3.6. View window and settings for virtual memory size

Rice. 3.7. Window for viewing and setting the size of virtual memory in Windows7

If your computer has more than one physical drive, it is best to place the paging file on the fastest, and it is preferable if the Windows system files are located on a different drive. It is even better to split the swap file into several physical disks because the disk controller can handle multiple write and read requests in parallel.

Do not try to place the paging file on several logical drives of one physical drive!!!

If the system has a single hard drive partitioned into C, D, and E partitions, and the swap file is partitioned into multiple partitions, the system may even slow down, because in this configuration, the magnetic heads of the hard drive have to read data from several areas, and not sequentially from one area of the disk.

If you decrease the minimum or maximum page file size and create a new page file on disk, the system must be rebooted for the changes to take effect. Increasing the page file size usually does not require a computer restart.

If you have a lot of physical memory, you may be tempted to disable the swap file altogether. Do not do this! !!

Windows XP was designed so that the paging file is used to perform some kernel tasks, so some third-party programs may report an out-of-memory message when attempting to completely disable virtual memory.

Windows does not use the swap file until it is needed, so disabling virtual memory will not improve performance!!!

Windows can dynamically increase the size of the paging file as needed. This function only works when you select " System selectable size”, as well as when setting a maximum size greater than the current size of the paging file.

Based on experience with previous versions of Windows, some users try to create a fixed size paging file with equal initial and maximum sizes. Theoretically, this should improve performance, as it eliminates the possibility of page file fragmentation. However, the swap subsystem is designed in such a way that, in practice, a file only occupies large blocks of disk space, which keeps fragmentation to a minimum. You may notice a slight drop in performance when Windows increases the size of the paging file, but this is a one-time operation and does not affect average performance in any way.

Controlling memory usage in Windows

The easiest way to find out how much RAM is being used at a given time is to open the Task Manager by pressing ++ and go to the Performance tab (Fig. 3.8). A detailed description of the information on the "Performance" tab for Windows XP is presented in Table. 3.1.

Table 3.1. Decrypting Task Manager Data

The "Performance" tab for Windows7 has significant innovations compared to the corresponding tab Task Manager in Windows XP.

The number in the "Total" column of the "Physical Memory" section indicates the total amount of RAM for this system. The Cached column shows the amount of physical memory that was recently used by system resources. It remains in the cache in case the system needs it again, but is available to other processes. The new column "Available" (Available) indicates the amount of currently unused physical memory, and in the column "Free" (Free) - the amount of memory that is used by the cache, but does not contain useful information.

The Kernel Memory section contains two columns - Paged and Nonpaged. Together they indicate how much memory the kernel is using. Paged is virtual memory, and nonpaged is physical.

In the "System" (System) column appeared "Descriptors" (Handles) and "Threads" (Threads), associated with the composite components of processes. The "Descriptors" column indicates the number of object identifiers (handles) that are used by currently running processes. The "Threads" column shows the number of subprocesses running within larger processes. The number in the "Processes" column, of course, indicates the total number of running processes, which can be seen on the "Processes" tab.

The Up Time column shows how much time has passed since the computer was last started. The Commit column contains information about the paging file. The first number indicates the total amount of physical and virtual memory currently in use, and the second number indicates the total amount of memory for this computer in general.

Even more detailed information can be obtained by clicking the "Resource Monitor" button and selecting the "Memory" tab (Fig. 3.9).

Rice. 3.9. Memory tab of the Windows Resource Monitor window

The "Memory" tab has a "Processes" table that lists all running processes, and information about the memory used for each process is divided into several categories (Fig. 3.10).

Rice. 3.10. Table "Processes"

In a collumn " Image» indicates the name of the process executable file. The processes started by applications are very easy to recognize - for example, the "Winword.exe" process obviously belongs to the Word text editor. Processes named "svchost.exe" represent various operating system services. The name of the service is given in parentheses next to the process name.

In a collumn " Process ID» indicates the process number - a unique combination of numbers that allows you to identify the running process.

In the column " Completed» indicates the amount of virtual memory in kilobytes reserved by the system for this process. This includes both the physical memory used and the pages stored in the paging file.

In the column " Working set» indicates the amount of physical memory in kilobytes currently used by the process. The working set is made up of shared and private memory.

In a collumn " General» specifies the amount of physical memory, in kilobytes, that this process is sharing with others. Using a single memory segment or swap page for related processes saves memory space. In this case, only one copy of the page is physically stored, which is then mapped to the virtual address space of other processes that access it. For example, all processes initiated by the system DLLs - Ntdll, Kernel32, Gdi32, and User32 - use shared memory.

In the column " Private» indicates the amount of physical memory in kilobytes used exclusively by this process. It is this value that allows you to determine how much memory a particular application needs to work.

In the column " Page Out of Memory Errors/sec.' shows the average number of out of memory page faults per second over the last minute. If a process tries to use more physical memory than is currently available, the system writes some of the data from memory to disk - the paging file. The subsequent access to the data saved to disk is called a page out of memory error.

As applications start and work with files, the memory manager keeps track of the working set for each process and captures requests for additional memory resources. As a process's working set increases, the dispatcher matches these requests to the needs of the kernel and other processes. If there is not enough available address space, the dispatcher shrinks the working set by saving data from memory to disk.

Later, when reading this data from disk, a page out of memory error occurs. This is quite normal, but if errors occur simultaneously for different processes, the system needs additional time to read data from disk. Too frequent page out of memory errors, respectively, reduce system performance. This manifests itself in an unexpected slowdown in all applications, which then also stops unexpectedly. The slowdown is due to the active redistribution of data between physical memory and paging.

The conclusion follows from this: if out-of-page errors for a particular process occur too often and moreover regularly, the computer does not have enough physical memory.

The Processes table provides detailed information about the allocation of memory between individual processes, while the Physical Memory table gives an overall picture of RAM usage. Its key component is the unique histogram shown in Fig. 3.11.

Figure 3.11. The bar graph in the Physical Memory table gives you a general idea of memory allocation in Windows 7

On the left is the section Reserved Equipment”, marked in gray: this is the memory allocated for the needs of the connected equipment, which it uses to interact with the operating system. Memory reserved for hardware is locked and cannot be accessed by the memory manager. Usually, the amount of memory allocated to the hardware is between 10 and 70 MB, but this figure depends on the specific configuration of the system and in some cases can reach several hundred megabytes.

Components that affect the amount of reserved memory include:

Motherboard components - such as the Advanced Programmable Input/Output Interrupt Controller (APIC);

Sound cards and other devices that perform memory-mapped input/output;

PCI Express (PCIe) bus;

Video cards;

Various chipsets;

Flash drives.

Section " used”, marked in green, represents the amount of memory used by the system, drivers, and running processes. The amount of memory used is calculated as the value of " Total» minus the sum of indicators « Changed», « Expectation" and " Free". In turn, the value Total" is an indicator of " Installed» minus the indicator « Reserved Equipment».