Какую роль выполняет механизм подкачки paging в ос windows

«Paging» redirects here. For paging as a form of telecommunications, see pager. For other uses, see Page.

This article needs attention from an expert in computing. See the talk page for details. WikiProject Computing may be able to help recruit an expert. (June 2019)

In computer operating systems, memory paging (or swapping on some Unix-like systems) is a memory management scheme by which a computer stores and retrieves data from secondary storage^[a] for use in main memory.^{[citation needed]} In this scheme, the operating system retrieves data from secondary storage in same-size blocks called pages. Paging is an important part of virtual memory implementations in modern operating systems, using secondary storage to let programs exceed the size of available physical memory.

For simplicity, main memory is called «RAM» (an acronym of random-access memory) and secondary storage is called «disk» (a shorthand for hard disk drive, drum memory or solid-state drive, etc.), but as with many aspects of computing, the concepts are independent of the technology used.

Depending on the memory model, paged memory functionality is usually hardwired into a CPU/MCU by using a Memory Management Unit (MMU) or Memory Protection Unit (MPU) and separately enabled by privileged system code in the operating system’s kernel. In CPUs implementing the x86 instruction set architecture (ISA) for instance, the memory paging is enabled via the CR0 control register.

History[edit]

In the 1960s, swapping was an early virtual memory technique. An entire program or entire segment would be «swapped out» (or «rolled out») from RAM to disk or drum, and another one would be swapped in (or rolled in).^[1][2] A swapped-out program would be current but its execution would be suspended while its RAM was in use by another program; a program with a swapped-out segment could continue running until it needed that segment, at which point it would be suspended until the segment was swapped in.

A program might include multiple overlays that occupy the same memory at different times. Overlays are not a method of paging RAM to disk but merely of minimizing the program’s RAM use. Subsequent architectures used memory segmentation, and individual program segments became the units exchanged between disk and RAM. A segment was the program’s entire code segment or data segment, or sometimes other large data structures. These segments had to be contiguous when resident in RAM, requiring additional computation and movement to remedy fragmentation.^[3]

Ferranti’s Atlas, and the Atlas Supervisor developed at the University of Manchester,^[4] (1962), was the first system to implement memory paging. Subsequent early machines, and their operating systems, supporting paging include the IBM M44/44X and its MOS operating system (1964),^[5], the SDS 940^[6] and the Berkeley Timesharing System (1966), a modified IBM System/360 Model 40 and the CP-40 operating system (1967), the IBM System/360 Model 67 and operating systems such as TSS/360 and CP/CMS (1967), the RCA 70/46 and the Time Sharing Operating System (1967), the GE 645 and Multics (1969), and the PDP-10 with added BBN-designed paging hardware and the TENEX operating system (1969).

Those machines, and subsequent machines supporting memory paging, use either a set of page address registers or in-memory page tables^[d] to allow the processor to operate on arbitrary pages anywhere in RAM as a seemingly contiguous logical address space. These pages became the units exchanged between disk and RAM.

Page faults[edit]

When a process tries to reference a page not currently present in RAM, the processor treats this invalid memory reference as a page fault and transfers control from the program to the operating system. The operating system must:

1. Determine the location of the data on disk.
2. Obtain an empty page frame in RAM to use as a container for the data.
3. Load the requested data into the available page frame.
4. Update the page table to refer to the new page frame.
5. Return control to the program, transparently retrying the instruction that caused the page fault.

When all page frames are in use, the operating system must select a page frame to reuse for the page the program now needs. If the evicted page frame was dynamically allocated by a program to hold data, or if a program modified it since it was read into RAM (in other words, if it has become «dirty»), it must be written out to disk before being freed. If a program later references the evicted page, another page fault occurs and the page must be read back into RAM.

The method the operating system uses to select the page frame to reuse, which is its page replacement algorithm, is important to efficiency. The operating system predicts the page frame least likely to be needed soon, often through the least recently used (LRU) algorithm or an algorithm based on the program’s working set. To further increase responsiveness, paging systems may predict which pages will be needed soon, preemptively loading them into RAM before a program references them.

Page replacement techniques[edit]

Demand paging

When pure demand paging is used, pages are loaded only when they are referenced. A program from a memory mapped file begins execution with none of its pages in RAM. As the program commits page faults, the operating system copies the needed pages from a file, e.g., memory-mapped file, paging file, or a swap partition containing the page data into RAM.

Anticipatory paging

This technique, sometimes also called swap prefetch, predicts which pages will be referenced soon, to minimize future page faults. For example, after reading a page to service a page fault, the operating system may also read the next few pages even though they are not yet needed (a prediction using locality of reference). If a program ends, the operating system may delay freeing its pages, in case the user runs the same program again.

Free page queue, stealing, and reclamation

The free page queue is a list of page frames that are available for assignment. Preventing this queue from being empty minimizes the computing necessary to service a page fault. Some operating systems periodically look for pages that have not been recently referenced and then free the page frame and add it to the free page queue, a process known as «page stealing». Some operating systems^[e] support page reclamation; if a program commits a page fault by referencing a page that was stolen, the operating system detects this and restores the page frame without having to read the contents back into RAM.

Pre-cleaning

The operating system may periodically pre-clean dirty pages: write modified pages back to disk even though they might be further modified. This minimizes the amount of cleaning needed to obtain new page frames at the moment a new program starts or a new data file is opened, and improves responsiveness. (Unix operating systems periodically use sync to pre-clean all dirty pages; Windows operating systems use «modified page writer» threads.)

Thrashing[edit]

After completing initialization, most programs operate on a small number of code and data pages compared to the total memory the program requires. The pages most frequently accessed are called the working set.

When the working set is a small percentage of the system’s total number of pages, virtual memory systems work most efficiently and an insignificant amount of computing is spent resolving page faults. As the working set grows, resolving page faults remains manageable until the growth reaches a critical point. Then faults go up dramatically and the time spent resolving them overwhelms time spent on the computing the program was written to do. This condition is referred to as thrashing. Thrashing occurs on a program that works with huge data structures, as its large working set causes continual page faults that drastically slow down the system. Satisfying page faults may require freeing pages that will soon have to be re-read from disk. «Thrashing» is also used in contexts other than virtual memory systems; for example, to describe cache issues in computing or silly window syndrome in networking.

A worst case might occur on VAX processors. A single MOVL crossing a page boundary could have a source operand using a displacement deferred addressing mode, where the longword containing the operand address crosses a page boundary, and a destination operand using a displacement deferred addressing mode, where the longword containing the operand address crosses a page boundary, and the source and destination could both cross page boundaries. This single instruction references ten pages; if not all are in RAM, each will cause a page fault. As each fault occurs the operating system needs to go through the extensive memory management routines perhaps causing multiple I/Os which might include writing other process pages to disk and reading pages of the active process from disk. If the operating system could not allocate ten pages to this program, then remedying the page fault would discard another page the instruction needs, and any restart of the instruction would fault again.

To decrease excessive paging and resolve thrashing problems, a user can increase the number of pages available per program, either by running fewer programs concurrently or increasing the amount of RAM in the computer.

Sharing[edit]

In multi-programming or in a multi-user environment, many users may execute the same program, written so that its code and data are in separate pages. To minimize RAM use, all users share a single copy of the program. Each process’s page table is set up so that the pages that address code point to the single shared copy, while the pages that address data point to different physical pages for each process.

Different programs might also use the same libraries. To save space, only one copy of the shared library is loaded into physical memory. Programs which use the same library have virtual addresses that map to the same pages (which contain the library’s code and data). When programs want to modify the library’s code, they use copy-on-write, so memory is only allocated when needed.

Shared memory is an efficient way of communication between programs. Programs can share pages in memory, and then write and read to exchange data.

Implementations[edit]

Ferranti Atlas[edit]

The first computer to support paging was the supercomputer Atlas,^[7][8][9] jointly developed by Ferranti, the University of Manchester and Plessey in 1963. The machine had an associative (content-addressable) memory with one entry for each 512 word page. The Supervisor^[10] handled non-equivalence interruptions^[f] and managed the transfer of pages between core and drum in order to provide a one-level store^[11] to programs.

Microsoft Windows[edit]

Windows 3.x and Windows 9x[edit]

Paging has been a feature of Microsoft Windows since Windows 3.0 in 1990. Windows 3.x creates a hidden file named 386SPART.PAR or WIN386.SWP for use as a swap file. It is generally found in the root directory, but it may appear elsewhere (typically in the WINDOWS directory). Its size depends on how much swap space the system has (a setting selected by the user under Control Panel → Enhanced under «Virtual Memory»). If the user moves or deletes this file, a blue screen will appear the next time Windows is started, with the error message «The permanent swap file is corrupt». The user will be prompted to choose whether or not to delete the file (whether or not it exists).

Windows 95, Windows 98 and Windows Me use a similar file, and the settings for it are located under Control Panel → System → Performance tab → Virtual Memory. Windows automatically sets the size of the page file to start at 1.5× the size of physical memory, and expand up to 3× physical memory if necessary. If a user runs memory-intensive applications on a system with low physical memory, it is preferable to manually set these sizes to a value higher than default.

Windows NT[edit]

The file used for paging in the Windows NT family is pagefile.sys. The default location of the page file is in the root directory of the partition where Windows is installed. Windows can be configured to use free space on any available drives for page files. It is required, however, for the boot partition (i.e., the drive containing the Windows directory) to have a page file on it if the system is configured to write either kernel or full memory dumps after a Blue Screen of Death. Windows uses the paging file as temporary storage for the memory dump. When the system is rebooted, Windows copies the memory dump from the page file to a separate file and frees the space that was used in the page file.^[12]

Fragmentation[edit]

This section needs to be updated. Please help update this article to reflect recent events or newly available information. (July 2014)

In the default configuration of Windows, the page file is allowed to expand beyond its initial allocation when necessary. If this happens gradually, it can become heavily fragmented which can potentially cause performance problems.^[13] The common advice given to avoid this is to set a single «locked» page file size so that Windows will not expand it. However, the page file only expands when it has been filled, which, in its default configuration, is 150% of the total amount of physical memory.^{[citation needed]} Thus the total demand for page file-backed virtual memory must exceed 250% of the computer’s physical memory before the page file will expand.

The fragmentation of the page file that occurs when it expands is temporary. As soon as the expanded regions are no longer in use (at the next reboot, if not sooner) the additional disk space allocations are freed and the page file is back to its original state.

Locking a page file size can be problematic if a Windows application requests more memory than the total size of physical memory and the page file, leading to failed requests to allocate memory that may cause applications and system processes to fail. Also, the page file is rarely read or written in sequential order, so the performance advantage of having a completely sequential page file is minimal. However, a large page file generally allows the use of memory-heavy applications, with no penalties besides using more disk space. While a fragmented page file may not be an issue by itself, fragmentation of a variable size page file will over time create several fragmented blocks on the drive, causing other files to become fragmented. For this reason, a fixed-size contiguous page file is better, providing that the size allocated is large enough to accommodate the needs of all applications.

The required disk space may be easily allocated on systems with more recent specifications (i.e. a system with 3  GB of memory having a 6  GB fixed-size page file on a 750  GB disk drive, or a system with 6  GB of memory and a 16  GB fixed-size page file and 2  TB of disk space). In both examples, the system uses about 0.8% of the disk space with the page file pre-extended to its maximum.

Defragmenting the page file is also occasionally recommended to improve performance when a Windows system is chronically using much more memory than its total physical memory.^{[citation needed]} This view ignores the fact that, aside from the temporary results of expansion, the page file does not become fragmented over time. In general, performance concerns related to page file access are much more effectively dealt with by adding more physical memory.

Unix and Unix-like systems[edit]

Unix systems, and other Unix-like operating systems, use the term «swap» to describe the act of substituting disk space for RAM when physical RAM is full.^[14] In some of those systems, it is common to dedicate an entire partition of a hard disk to swapping. These partitions are called swap partitions. Many systems have an entire hard drive dedicated to swapping, separate from the data drive(s), containing only a swap partition. A hard drive dedicated to swapping is called a «swap drive» or a «scratch drive» or a «scratch disk». Some of those systems only support swapping to a swap partition; others also support swapping to files.

Linux[edit]

The Linux kernel supports a virtually unlimited number of swap backends (devices or files), and also supports assignment of backend priorities. When the kernel swaps pages out of physical memory, it uses the highest-priority backend with available free space. If multiple swap backends are assigned the same priority, they are used in a round-robin fashion (which is somewhat similar to RAID 0 storage layouts), providing improved performance as long as the underlying devices can be efficiently accessed in parallel.^[15]

Swap files and partitions[edit]

From the end-user perspective, swap files in versions 2.6.x and later of the Linux kernel are virtually as fast as swap partitions; the limitation is that swap files should be contiguously allocated on their underlying file systems. To increase performance of swap files, the kernel keeps a map of where they are placed on underlying devices and accesses them directly, thus bypassing the cache and avoiding filesystem overhead.^[16][17] When residing on HDDs, which are rotational magnetic media devices, one benefit of using swap partitions is the ability to place them on contiguous HDD areas that provide higher data throughput or faster seek time. However, the administrative flexibility of swap files can outweigh certain advantages of swap partitions. For example, a swap file can be placed on any mounted file system, can be set to any desired size, and can be added or changed as needed. Swap partitions are not as flexible; they cannot be enlarged without using partitioning or volume management tools, which introduce various complexities and potential downtimes.

Swappiness[edit]

Swappiness is a Linux kernel parameter that controls the relative weight given to swapping out of runtime memory, as opposed to dropping pages from the system page cache, whenever a memory allocation request cannot be met from free memory. Swappiness can be set to a value from 0 to 200.^[18] A low value causes the kernel to prefer to evict pages from the page cache while a higher value causes the kernel to prefer to swap out «cold» memory pages. The default value is 60; setting it higher can cause high latency if cold pages need to be swapped back in (when interacting with a program that had been idle for example), while setting it lower (even 0) may cause high latency when files that had been evicted from the cache need to be read again, but will make interactive programs more responsive as they will be less likely to need to swap back cold pages. Swapping can also slow down HDDs further because it involves a lot of random writes, while SSDs do not have this problem. Certainly the default values work well in most workloads, but desktops and interactive systems for any expected task may want to lower the setting while batch processing and less interactive systems may want to increase it.^[19]

Swap death[edit]

When the system memory is highly insufficient for the current tasks and a large portion of memory activity goes through a slow swap, the system can become practically unable to execute any task, even if the CPU is idle. When every process is waiting on the swap, the system is considered to be in swap death.^[20][21]

Swap death can happen due to incorrectly configured memory overcommitment.^[22][23][24]

The original description of the «swapping to death» problem relates to the X server. If code or data used by the X server to respond to a keystroke is not in main memory, then if the user enters a keystroke, the server will take one or more page faults, requiring those pages to read from swap before the keystroke can be processed, slowing the response to it. If those pages don’t remain in memory, they will have to be faulted in again to handle the next keystroke, making the system practically unresponsive even if it’s actually executing other tasks normally.^[25]

macOS[edit]

macOS uses multiple swap files. The default (and Apple-recommended) installation places them on the root partition, though it is possible to place them instead on a separate partition or device.^[26]

AmigaOS 4[edit]

AmigaOS 4.0 introduced a new system for allocating RAM and defragmenting physical memory. It still uses flat shared address space that cannot be defragmented. It is based on slab allocation method and paging memory that allows swapping. Paging was implemented in AmigaOS 4.1 but may lock up system if all physical memory is used up.^[27] Swap memory could be activated and deactivated any moment allowing the user to choose to use only physical RAM.

Performance[edit]

The backing store for a virtual memory operating system is typically many orders of magnitude slower than RAM. Additionally, using mechanical storage devices introduces delay, several milliseconds for a hard disk. Therefore, it is desirable to reduce or eliminate swapping, where practical. Some operating systems offer settings to influence the kernel’s decisions.

• Linux offers the /proc/sys/vm/swappiness parameter, which changes the balance between swapping out runtime memory, as opposed to dropping pages from the system page cache.
• Windows 2000, XP, and Vista offer the DisablePagingExecutive registry setting, which controls whether kernel-mode code and data can be eligible for paging out.
• Mainframe computers frequently used head-per-track disk drives or drums for page and swap storage to eliminate seek time, and several technologies^[28] to have multiple concurrent requests to the same device in order to reduce rotational latency.
• Flash memory has a finite number of erase-write cycles (see limitations of flash memory), and the smallest amount of data that can be erased at once might be very large (128 KiB for an Intel X25-M SSD ^[29]), seldom coinciding with pagesize. Therefore, flash memory may wear out quickly if used as swap space under tight memory conditions. On the attractive side, flash memory is practically delayless compared to hard disks, and not volatile as RAM chips. Schemes like ReadyBoost and Intel Turbo Memory are made to exploit these characteristics.

Many Unix-like operating systems (for example AIX, Linux, and Solaris) allow using multiple storage devices for swap space in parallel, to increase performance.

Swap space size[edit]

In some older virtual memory operating systems, space in swap backing store is reserved when programs allocate memory for runtime data. Operating system vendors typically issue guidelines about how much swap space should be allocated.

Addressing limits on 32-bit hardware[edit]

Paging is one way of allowing the size of the addresses used by a process, which is the process’s «virtual address space» or «logical address space», to be different from the amount of main memory actually installed on a particular computer, which is the physical address space.

Main memory smaller than virtual memory[edit]

In most systems, the size of a process’s virtual address space is much larger than the available main memory.^[30] For example:

• The address bus that connects the CPU to main memory may be limited. The i386SX CPU’s 32-bit internal addresses can address 4 GB, but it has only 24 pins connected to the address bus, limiting installed physical memory to 16 MB. There may be other hardware restrictions on the maximum amount of RAM that can be installed.
• The maximum memory might not be installed because of cost, because the model’s standard configuration omits it, or because the buyer did not believe it would be advantageous.
• Sometimes not all internal addresses can be used for memory anyway, because the hardware architecture may reserve large regions for I/O or other features.

Main memory the same size as virtual memory[edit]

A computer with true n-bit addressing may have 2ⁿ addressable units of RAM installed. An example is a 32-bit x86 processor with 4 GB and without Physical Address Extension (PAE). In this case, the processor is able to address all the RAM installed and no more.

However, even in this case, paging can be used to create a virtual memory of over 4 GB. For instance, many programs may be running concurrently. Together, they may require more than 4 GB, but not all of it will have to be in RAM at once. A paging system makes efficient decisions on which memory to relegate to secondary storage, leading to the best use of the installed RAM.

Although the processor in this example cannot address RAM beyond 4 GB, the operating system may provide services to programs that envision a larger memory, such as files that can grow beyond the limit of installed RAM. The operating system lets a program manipulate data in the file arbitrarily, using paging to bring parts of the file into RAM when necessary.

Main memory larger than virtual address space[edit]

A few computers have a main memory larger than the virtual address space of a process, such as the Magic-1,^[30] some PDP-11 machines, and some systems using 32-bit x86 processors with Physical Address Extension. This nullifies a significant advantage of paging, since a single process cannot use more main memory than the amount of its virtual address space. Such systems often use paging techniques to obtain secondary benefits:

• The «extra memory» can be used in the page cache to cache frequently used files and metadata, such as directory information, from secondary storage.
• If the processor and operating system support multiple virtual address spaces, the «extra memory» can be used to run more processes. Paging allows the cumulative total of virtual address spaces to exceed physical main memory.
• A process can store data in memory-mapped files on memory-backed file systems, such as the tmpfs file system or file systems on a RAM drive, and map files into and out of the address space as needed.
• A set of processes may still depend upon the enhanced security features page-based isolation may bring to a multitasking environment.

The size of the cumulative total of virtual address spaces is still limited by the amount of secondary storage available.

See also[edit]

Notes[edit]

References[edit]

External links[edit]

• Swap Facts and questions by Ubuntu Documentation
• Windows Server — Moving Pagefile to another partition or disk by David Nudelman
• How Virtual Memory Works from HowStuffWorks.com (in fact explains only swapping concept, and not virtual memory concept)
• Linux swap space management (outdated, as the author admits)
• Guide On Optimizing Virtual Memory Speed (outdated, and contradicts section 1.4 of this wiki page, and (at least) references 8, 9, and 11.)
• Virtual Memory Page Replacement Algorithms
• Windows XP: How to manually change the size of the virtual memory paging file
• Windows XP: Factors that may deplete the supply of paged pool memory
• SwapFs driver that can be used to save the paging file of Windows on a swap partition of Linux

«Paging» redirects here. For paging as a form of telecommunications, see pager. For other uses, see Page.

This article needs attention from an expert in computing. See the talk page for details. WikiProject Computing may be able to help recruit an expert. (June 2019)

In computer operating systems, memory paging (or swapping on some Unix-like systems) is a memory management scheme by which a computer stores and retrieves data from secondary storage^[a] for use in main memory.^{[citation needed]} In this scheme, the operating system retrieves data from secondary storage in same-size blocks called pages. Paging is an important part of virtual memory implementations in modern operating systems, using secondary storage to let programs exceed the size of available physical memory.

For simplicity, main memory is called «RAM» (an acronym of random-access memory) and secondary storage is called «disk» (a shorthand for hard disk drive, drum memory or solid-state drive, etc.), but as with many aspects of computing, the concepts are independent of the technology used.

Depending on the memory model, paged memory functionality is usually hardwired into a CPU/MCU by using a Memory Management Unit (MMU) or Memory Protection Unit (MPU) and separately enabled by privileged system code in the operating system’s kernel. In CPUs implementing the x86 instruction set architecture (ISA) for instance, the memory paging is enabled via the CR0 control register.

History[edit]

In the 1960s, swapping was an early virtual memory technique. An entire program or entire segment would be «swapped out» (or «rolled out») from RAM to disk or drum, and another one would be swapped in (or rolled in).^[1][2] A swapped-out program would be current but its execution would be suspended while its RAM was in use by another program; a program with a swapped-out segment could continue running until it needed that segment, at which point it would be suspended until the segment was swapped in.

A program might include multiple overlays that occupy the same memory at different times. Overlays are not a method of paging RAM to disk but merely of minimizing the program’s RAM use. Subsequent architectures used memory segmentation, and individual program segments became the units exchanged between disk and RAM. A segment was the program’s entire code segment or data segment, or sometimes other large data structures. These segments had to be contiguous when resident in RAM, requiring additional computation and movement to remedy fragmentation.^[3]

Ferranti’s Atlas, and the Atlas Supervisor developed at the University of Manchester,^[4] (1962), was the first system to implement memory paging. Subsequent early machines, and their operating systems, supporting paging include the IBM M44/44X and its MOS operating system (1964),^[5], the SDS 940^[6] and the Berkeley Timesharing System (1966), a modified IBM System/360 Model 40 and the CP-40 operating system (1967), the IBM System/360 Model 67 and operating systems such as TSS/360 and CP/CMS (1967), the RCA 70/46 and the Time Sharing Operating System (1967), the GE 645 and Multics (1969), and the PDP-10 with added BBN-designed paging hardware and the TENEX operating system (1969).

Those machines, and subsequent machines supporting memory paging, use either a set of page address registers or in-memory page tables^[d] to allow the processor to operate on arbitrary pages anywhere in RAM as a seemingly contiguous logical address space. These pages became the units exchanged between disk and RAM.

Page faults[edit]

When a process tries to reference a page not currently present in RAM, the processor treats this invalid memory reference as a page fault and transfers control from the program to the operating system. The operating system must:

1. Determine the location of the data on disk.
2. Obtain an empty page frame in RAM to use as a container for the data.
3. Load the requested data into the available page frame.
4. Update the page table to refer to the new page frame.
5. Return control to the program, transparently retrying the instruction that caused the page fault.

When all page frames are in use, the operating system must select a page frame to reuse for the page the program now needs. If the evicted page frame was dynamically allocated by a program to hold data, or if a program modified it since it was read into RAM (in other words, if it has become «dirty»), it must be written out to disk before being freed. If a program later references the evicted page, another page fault occurs and the page must be read back into RAM.

The method the operating system uses to select the page frame to reuse, which is its page replacement algorithm, is important to efficiency. The operating system predicts the page frame least likely to be needed soon, often through the least recently used (LRU) algorithm or an algorithm based on the program’s working set. To further increase responsiveness, paging systems may predict which pages will be needed soon, preemptively loading them into RAM before a program references them.

Page replacement techniques[edit]

Demand paging

When pure demand paging is used, pages are loaded only when they are referenced. A program from a memory mapped file begins execution with none of its pages in RAM. As the program commits page faults, the operating system copies the needed pages from a file, e.g., memory-mapped file, paging file, or a swap partition containing the page data into RAM.

Anticipatory paging

This technique, sometimes also called swap prefetch, predicts which pages will be referenced soon, to minimize future page faults. For example, after reading a page to service a page fault, the operating system may also read the next few pages even though they are not yet needed (a prediction using locality of reference). If a program ends, the operating system may delay freeing its pages, in case the user runs the same program again.

Free page queue, stealing, and reclamation

The free page queue is a list of page frames that are available for assignment. Preventing this queue from being empty minimizes the computing necessary to service a page fault. Some operating systems periodically look for pages that have not been recently referenced and then free the page frame and add it to the free page queue, a process known as «page stealing». Some operating systems^[e] support page reclamation; if a program commits a page fault by referencing a page that was stolen, the operating system detects this and restores the page frame without having to read the contents back into RAM.

Pre-cleaning

The operating system may periodically pre-clean dirty pages: write modified pages back to disk even though they might be further modified. This minimizes the amount of cleaning needed to obtain new page frames at the moment a new program starts or a new data file is opened, and improves responsiveness. (Unix operating systems periodically use sync to pre-clean all dirty pages; Windows operating systems use «modified page writer» threads.)

Thrashing[edit]

After completing initialization, most programs operate on a small number of code and data pages compared to the total memory the program requires. The pages most frequently accessed are called the working set.

When the working set is a small percentage of the system’s total number of pages, virtual memory systems work most efficiently and an insignificant amount of computing is spent resolving page faults. As the working set grows, resolving page faults remains manageable until the growth reaches a critical point. Then faults go up dramatically and the time spent resolving them overwhelms time spent on the computing the program was written to do. This condition is referred to as thrashing. Thrashing occurs on a program that works with huge data structures, as its large working set causes continual page faults that drastically slow down the system. Satisfying page faults may require freeing pages that will soon have to be re-read from disk. «Thrashing» is also used in contexts other than virtual memory systems; for example, to describe cache issues in computing or silly window syndrome in networking.

A worst case might occur on VAX processors. A single MOVL crossing a page boundary could have a source operand using a displacement deferred addressing mode, where the longword containing the operand address crosses a page boundary, and a destination operand using a displacement deferred addressing mode, where the longword containing the operand address crosses a page boundary, and the source and destination could both cross page boundaries. This single instruction references ten pages; if not all are in RAM, each will cause a page fault. As each fault occurs the operating system needs to go through the extensive memory management routines perhaps causing multiple I/Os which might include writing other process pages to disk and reading pages of the active process from disk. If the operating system could not allocate ten pages to this program, then remedying the page fault would discard another page the instruction needs, and any restart of the instruction would fault again.

To decrease excessive paging and resolve thrashing problems, a user can increase the number of pages available per program, either by running fewer programs concurrently or increasing the amount of RAM in the computer.

Sharing[edit]

In multi-programming or in a multi-user environment, many users may execute the same program, written so that its code and data are in separate pages. To minimize RAM use, all users share a single copy of the program. Each process’s page table is set up so that the pages that address code point to the single shared copy, while the pages that address data point to different physical pages for each process.

Different programs might also use the same libraries. To save space, only one copy of the shared library is loaded into physical memory. Programs which use the same library have virtual addresses that map to the same pages (which contain the library’s code and data). When programs want to modify the library’s code, they use copy-on-write, so memory is only allocated when needed.

Shared memory is an efficient way of communication between programs. Programs can share pages in memory, and then write and read to exchange data.

Implementations[edit]

Ferranti Atlas[edit]

The first computer to support paging was the supercomputer Atlas,^[7][8][9] jointly developed by Ferranti, the University of Manchester and Plessey in 1963. The machine had an associative (content-addressable) memory with one entry for each 512 word page. The Supervisor^[10] handled non-equivalence interruptions^[f] and managed the transfer of pages between core and drum in order to provide a one-level store^[11] to programs.

Microsoft Windows[edit]

Windows 3.x and Windows 9x[edit]

Paging has been a feature of Microsoft Windows since Windows 3.0 in 1990. Windows 3.x creates a hidden file named 386SPART.PAR or WIN386.SWP for use as a swap file. It is generally found in the root directory, but it may appear elsewhere (typically in the WINDOWS directory). Its size depends on how much swap space the system has (a setting selected by the user under Control Panel → Enhanced under «Virtual Memory»). If the user moves or deletes this file, a blue screen will appear the next time Windows is started, with the error message «The permanent swap file is corrupt». The user will be prompted to choose whether or not to delete the file (whether or not it exists).

Windows 95, Windows 98 and Windows Me use a similar file, and the settings for it are located under Control Panel → System → Performance tab → Virtual Memory. Windows automatically sets the size of the page file to start at 1.5× the size of physical memory, and expand up to 3× physical memory if necessary. If a user runs memory-intensive applications on a system with low physical memory, it is preferable to manually set these sizes to a value higher than default.

Windows NT[edit]

The file used for paging in the Windows NT family is pagefile.sys. The default location of the page file is in the root directory of the partition where Windows is installed. Windows can be configured to use free space on any available drives for page files. It is required, however, for the boot partition (i.e., the drive containing the Windows directory) to have a page file on it if the system is configured to write either kernel or full memory dumps after a Blue Screen of Death. Windows uses the paging file as temporary storage for the memory dump. When the system is rebooted, Windows copies the memory dump from the page file to a separate file and frees the space that was used in the page file.^[12]

Fragmentation[edit]

This section needs to be updated. Please help update this article to reflect recent events or newly available information. (July 2014)

In the default configuration of Windows, the page file is allowed to expand beyond its initial allocation when necessary. If this happens gradually, it can become heavily fragmented which can potentially cause performance problems.^[13] The common advice given to avoid this is to set a single «locked» page file size so that Windows will not expand it. However, the page file only expands when it has been filled, which, in its default configuration, is 150% of the total amount of physical memory.^{[citation needed]} Thus the total demand for page file-backed virtual memory must exceed 250% of the computer’s physical memory before the page file will expand.

The fragmentation of the page file that occurs when it expands is temporary. As soon as the expanded regions are no longer in use (at the next reboot, if not sooner) the additional disk space allocations are freed and the page file is back to its original state.

Locking a page file size can be problematic if a Windows application requests more memory than the total size of physical memory and the page file, leading to failed requests to allocate memory that may cause applications and system processes to fail. Also, the page file is rarely read or written in sequential order, so the performance advantage of having a completely sequential page file is minimal. However, a large page file generally allows the use of memory-heavy applications, with no penalties besides using more disk space. While a fragmented page file may not be an issue by itself, fragmentation of a variable size page file will over time create several fragmented blocks on the drive, causing other files to become fragmented. For this reason, a fixed-size contiguous page file is better, providing that the size allocated is large enough to accommodate the needs of all applications.

The required disk space may be easily allocated on systems with more recent specifications (i.e. a system with 3  GB of memory having a 6  GB fixed-size page file on a 750  GB disk drive, or a system with 6  GB of memory and a 16  GB fixed-size page file and 2  TB of disk space). In both examples, the system uses about 0.8% of the disk space with the page file pre-extended to its maximum.

Defragmenting the page file is also occasionally recommended to improve performance when a Windows system is chronically using much more memory than its total physical memory.^{[citation needed]} This view ignores the fact that, aside from the temporary results of expansion, the page file does not become fragmented over time. In general, performance concerns related to page file access are much more effectively dealt with by adding more physical memory.

Unix and Unix-like systems[edit]

Unix systems, and other Unix-like operating systems, use the term «swap» to describe the act of substituting disk space for RAM when physical RAM is full.^[14] In some of those systems, it is common to dedicate an entire partition of a hard disk to swapping. These partitions are called swap partitions. Many systems have an entire hard drive dedicated to swapping, separate from the data drive(s), containing only a swap partition. A hard drive dedicated to swapping is called a «swap drive» or a «scratch drive» or a «scratch disk». Some of those systems only support swapping to a swap partition; others also support swapping to files.

Linux[edit]

The Linux kernel supports a virtually unlimited number of swap backends (devices or files), and also supports assignment of backend priorities. When the kernel swaps pages out of physical memory, it uses the highest-priority backend with available free space. If multiple swap backends are assigned the same priority, they are used in a round-robin fashion (which is somewhat similar to RAID 0 storage layouts), providing improved performance as long as the underlying devices can be efficiently accessed in parallel.^[15]

Swap files and partitions[edit]

From the end-user perspective, swap files in versions 2.6.x and later of the Linux kernel are virtually as fast as swap partitions; the limitation is that swap files should be contiguously allocated on their underlying file systems. To increase performance of swap files, the kernel keeps a map of where they are placed on underlying devices and accesses them directly, thus bypassing the cache and avoiding filesystem overhead.^[16][17] When residing on HDDs, which are rotational magnetic media devices, one benefit of using swap partitions is the ability to place them on contiguous HDD areas that provide higher data throughput or faster seek time. However, the administrative flexibility of swap files can outweigh certain advantages of swap partitions. For example, a swap file can be placed on any mounted file system, can be set to any desired size, and can be added or changed as needed. Swap partitions are not as flexible; they cannot be enlarged without using partitioning or volume management tools, which introduce various complexities and potential downtimes.

Swappiness[edit]

Swappiness is a Linux kernel parameter that controls the relative weight given to swapping out of runtime memory, as opposed to dropping pages from the system page cache, whenever a memory allocation request cannot be met from free memory. Swappiness can be set to a value from 0 to 200.^[18] A low value causes the kernel to prefer to evict pages from the page cache while a higher value causes the kernel to prefer to swap out «cold» memory pages. The default value is 60; setting it higher can cause high latency if cold pages need to be swapped back in (when interacting with a program that had been idle for example), while setting it lower (even 0) may cause high latency when files that had been evicted from the cache need to be read again, but will make interactive programs more responsive as they will be less likely to need to swap back cold pages. Swapping can also slow down HDDs further because it involves a lot of random writes, while SSDs do not have this problem. Certainly the default values work well in most workloads, but desktops and interactive systems for any expected task may want to lower the setting while batch processing and less interactive systems may want to increase it.^[19]

Swap death[edit]

When the system memory is highly insufficient for the current tasks and a large portion of memory activity goes through a slow swap, the system can become practically unable to execute any task, even if the CPU is idle. When every process is waiting on the swap, the system is considered to be in swap death.^[20][21]

Swap death can happen due to incorrectly configured memory overcommitment.^[22][23][24]

The original description of the «swapping to death» problem relates to the X server. If code or data used by the X server to respond to a keystroke is not in main memory, then if the user enters a keystroke, the server will take one or more page faults, requiring those pages to read from swap before the keystroke can be processed, slowing the response to it. If those pages don’t remain in memory, they will have to be faulted in again to handle the next keystroke, making the system practically unresponsive even if it’s actually executing other tasks normally.^[25]

macOS[edit]

macOS uses multiple swap files. The default (and Apple-recommended) installation places them on the root partition, though it is possible to place them instead on a separate partition or device.^[26]

AmigaOS 4[edit]

AmigaOS 4.0 introduced a new system for allocating RAM and defragmenting physical memory. It still uses flat shared address space that cannot be defragmented. It is based on slab allocation method and paging memory that allows swapping. Paging was implemented in AmigaOS 4.1 but may lock up system if all physical memory is used up.^[27] Swap memory could be activated and deactivated any moment allowing the user to choose to use only physical RAM.

Performance[edit]

The backing store for a virtual memory operating system is typically many orders of magnitude slower than RAM. Additionally, using mechanical storage devices introduces delay, several milliseconds for a hard disk. Therefore, it is desirable to reduce or eliminate swapping, where practical. Some operating systems offer settings to influence the kernel’s decisions.

• Linux offers the /proc/sys/vm/swappiness parameter, which changes the balance between swapping out runtime memory, as opposed to dropping pages from the system page cache.
• Windows 2000, XP, and Vista offer the DisablePagingExecutive registry setting, which controls whether kernel-mode code and data can be eligible for paging out.
• Mainframe computers frequently used head-per-track disk drives or drums for page and swap storage to eliminate seek time, and several technologies^[28] to have multiple concurrent requests to the same device in order to reduce rotational latency.
• Flash memory has a finite number of erase-write cycles (see limitations of flash memory), and the smallest amount of data that can be erased at once might be very large (128 KiB for an Intel X25-M SSD ^[29]), seldom coinciding with pagesize. Therefore, flash memory may wear out quickly if used as swap space under tight memory conditions. On the attractive side, flash memory is practically delayless compared to hard disks, and not volatile as RAM chips. Schemes like ReadyBoost and Intel Turbo Memory are made to exploit these characteristics.

Many Unix-like operating systems (for example AIX, Linux, and Solaris) allow using multiple storage devices for swap space in parallel, to increase performance.

Swap space size[edit]

In some older virtual memory operating systems, space in swap backing store is reserved when programs allocate memory for runtime data. Operating system vendors typically issue guidelines about how much swap space should be allocated.

Addressing limits on 32-bit hardware[edit]

Paging is one way of allowing the size of the addresses used by a process, which is the process’s «virtual address space» or «logical address space», to be different from the amount of main memory actually installed on a particular computer, which is the physical address space.

Main memory smaller than virtual memory[edit]

In most systems, the size of a process’s virtual address space is much larger than the available main memory.^[30] For example:

• The address bus that connects the CPU to main memory may be limited. The i386SX CPU’s 32-bit internal addresses can address 4 GB, but it has only 24 pins connected to the address bus, limiting installed physical memory to 16 MB. There may be other hardware restrictions on the maximum amount of RAM that can be installed.
• The maximum memory might not be installed because of cost, because the model’s standard configuration omits it, or because the buyer did not believe it would be advantageous.
• Sometimes not all internal addresses can be used for memory anyway, because the hardware architecture may reserve large regions for I/O or other features.

Main memory the same size as virtual memory[edit]

A computer with true n-bit addressing may have 2ⁿ addressable units of RAM installed. An example is a 32-bit x86 processor with 4 GB and without Physical Address Extension (PAE). In this case, the processor is able to address all the RAM installed and no more.

However, even in this case, paging can be used to create a virtual memory of over 4 GB. For instance, many programs may be running concurrently. Together, they may require more than 4 GB, but not all of it will have to be in RAM at once. A paging system makes efficient decisions on which memory to relegate to secondary storage, leading to the best use of the installed RAM.

Although the processor in this example cannot address RAM beyond 4 GB, the operating system may provide services to programs that envision a larger memory, such as files that can grow beyond the limit of installed RAM. The operating system lets a program manipulate data in the file arbitrarily, using paging to bring parts of the file into RAM when necessary.

Main memory larger than virtual address space[edit]

A few computers have a main memory larger than the virtual address space of a process, such as the Magic-1,^[30] some PDP-11 machines, and some systems using 32-bit x86 processors with Physical Address Extension. This nullifies a significant advantage of paging, since a single process cannot use more main memory than the amount of its virtual address space. Such systems often use paging techniques to obtain secondary benefits:

• The «extra memory» can be used in the page cache to cache frequently used files and metadata, such as directory information, from secondary storage.
• If the processor and operating system support multiple virtual address spaces, the «extra memory» can be used to run more processes. Paging allows the cumulative total of virtual address spaces to exceed physical main memory.
• A process can store data in memory-mapped files on memory-backed file systems, such as the tmpfs file system or file systems on a RAM drive, and map files into and out of the address space as needed.
• A set of processes may still depend upon the enhanced security features page-based isolation may bring to a multitasking environment.

The size of the cumulative total of virtual address spaces is still limited by the amount of secondary storage available.

See also[edit]

Notes[edit]

References[edit]

External links[edit]

• Swap Facts and questions by Ubuntu Documentation
• Windows Server — Moving Pagefile to another partition or disk by David Nudelman
• How Virtual Memory Works from HowStuffWorks.com (in fact explains only swapping concept, and not virtual memory concept)
• Linux swap space management (outdated, as the author admits)
• Guide On Optimizing Virtual Memory Speed (outdated, and contradicts section 1.4 of this wiki page, and (at least) references 8, 9, and 11.)
• Virtual Memory Page Replacement Algorithms
• Windows XP: How to manually change the size of the virtual memory paging file
• Windows XP: Factors that may deplete the supply of paged pool memory
• SwapFs driver that can be used to save the paging file of Windows on a swap partition of Linux

Файл подкачки, или виртуальная память — это системный файл на жестком диске компьютера, который Windows использует, чтобы компенсировать нехватку оперативной памяти, если приложениям ее не хватает. Что это за файл, как он работает, что о нем нужно знать, как увеличить файл подкачки в Windows 10, или, наоборот — как отключить файл подкачки в Windows 10, читайте в нашей шпаргалке. В конце статьи — короткое видео, в котором все показано. 

Файл подкачки в Windows: зачем он нужен и как работает?

Всем известно, что запущенные приложения на компьютере выполняются в оперативной памяти (ОЗУ, RAM). Выражаясь образно, при запуске приложения считываются с жесткого диска и временно «переписываются» в оперативную память. Вся информация в приложениях тоже хранится в оперативной памяти до тех пор, пока вы их не закроете.

Файл подкачки. Правильная настройка файла подкачки и его оптимальный размер.

Эта статья требует внимания эксперта в области вычислений. Увидеть страница обсуждения для подробностей. WikiProject Computing может помочь нанять эксперта. (Июнь 2019)

Эта статья о подкачке памяти компьютера. Информацию о пейджинге как форме телекоммуникаций см. пейджер. Для использования в других целях см. Страница.

В компьютер операционные системы, пейджинг это управление памятью схема, по которой компьютер хранит и извлекает данные из вторичное хранилище^[а] для использования в основная память.^[1] В этой схеме операционная система извлекает данные из вторичного хранилища в том же размере. блоки называется страницы. Пейджинг — важная часть виртуальная память реализации в современных операционных системах с использованием вторичного хранилища, чтобы программы превышали размер доступной физической памяти.

Для простоты основная память называется «ОЗУ» (сокращение от «оперативная память «), а вторичное хранилище называется» диск «(сокращение от»привод жесткого диска, барабанная память или же твердотельный накопитель «), но концепции не зависят от того, применимы ли эти термины буквально к конкретной компьютерной системе.

История

Ферранти ввел пейджинг на Атлас, но первые страницы памяти для массового рынка были концепциями компьютерной архитектуры, независимо от того, перемещалась ли страница между RAM и диском.^[2][3] Например, на PDP-8, 7 битов инструкции содержали адрес памяти, который выбирал один из 128 (2⁷) слова. Эта зона памяти получила название страница. Сейчас этот термин используется редко. В 1960-х годах свопинг был одним из первых методов виртуальной памяти. Вся программа будет «выгружена» (или «развернута») из ОЗУ на диск, а другая будет заменен (или же катился в).^[4][5] Выгруженная программа будет текущей, но ее выполнение будет приостановлено, пока ее оперативная память используется другой программой.

Программа может включать несколько накладки которые занимают одну и ту же память в разное время. Наложения — это не метод подкачки RAM на диск, а просто минимизация использования RAM программой. Последующие использованные архитектуры сегментация памяти, а отдельные программные сегменты стали единицами обмена между диском и ОЗУ. Сегмент представлял собой весь сегмент кода программы или сегмент данных, а иногда и другие большие структуры данных. Эти сегменты должны были быть смежный когда находится в ОЗУ, требуя дополнительных вычислений и перемещения для исправления фрагментация.^[6]

Изобретение таблица страниц позволить процессору работать с произвольными страницами в любом месте ОЗУ как с кажущимся непрерывным логический адрес Космос. Эти страницы стали единицами обмена между диском и ОЗУ.

Ошибки страницы

Когда процесс пытается ссылаться на страницу, которая в настоящее время отсутствует в ОЗУ, процессор рассматривает эту недопустимую ссылку на память как ошибка страницы и передает управление от программы операционной системе. Операционная система должна:

1. Определите расположение данных на диске.
2. Получите пустой рамка страницы в ОЗУ для использования в качестве контейнера для данных.
3. Загрузите запрошенные данные в доступный фрейм страницы.
4. Обновите таблица страниц для ссылки на новый фрейм страницы.
5. Вернуть управление программе, прозрачно повторив попытку инструкция это вызвало ошибку страницы.

Когда все страничные фреймы используются, операционная система должна выбрать страничный фрейм для повторного использования для страницы, которая теперь нужна программе. Если исключенный фрейм страницы был динамически распределяется программой для хранения данных или если программа изменила их с момента чтения в ОЗУ (другими словами, если они стали «грязными»), они должны быть записаны на диск перед освобождением. Если программа позже ссылается на удаленную страницу, возникает еще одна ошибка страницы, и страница должна быть считана обратно в ОЗУ.

Метод, используемый операционной системой для выбора фрейма страницы для повторного использования, т.е. алгоритм замены страницы, важно для эффективности. Операционная система прогнозирует, что фрейм страницы с наименьшей вероятностью понадобится в ближайшее время, часто через наименее недавно использованный (LRU) алгоритм или алгоритм, основанный на программном рабочий набор. Чтобы еще больше повысить скорость отклика, системы подкачки могут предсказать, какие страницы потребуются в ближайшее время, предварительно загружая их в оперативную память до того, как программа обратится к ним.

Методы замены страниц

Пейджинг по запросу

Когда используется подкачка по запросу, страницы загружаются только тогда, когда на них есть ссылки. Программа из файла с отображением в память начинает выполнение, и ни одна из ее страниц не находится в ОЗУ. Поскольку программа фиксирует ошибки страниц, операционная система копирует необходимые страницы из файла, например, файл с отображением памяти, файл подкачки или раздел подкачки, содержащий данные страницы в ОЗУ.

Предварительный пейджинг

Этот метод, иногда также называемый предварительная выборка подкачки, предсказывает, на какие страницы будут ссылаться в ближайшее время, чтобы минимизировать ошибки страниц в будущем. Например, после чтения страницы для обслуживания ошибки страницы операционная система может также прочитать следующие несколько страниц, даже если они еще не нужны (прогноз с использованием местонахождение ссылки ). Если программа завершается, операционная система может отложить освобождение ее страниц, если пользователь снова запустит ту же программу.

Бесплатная очередь страниц, кража и возврат

Очередь свободных страниц — это список страничных фреймов, доступных для назначения. Предотвращение опустошения этой очереди сводит к минимуму вычисления, необходимые для обслуживания ошибки страницы. Некоторые операционные системы периодически ищут страницы, на которые в последнее время не ссылались, а затем освобождают фрейм страницы и добавляют его в очередь свободных страниц — процесс, известный как «кража страниц». Некоторые операционные системы^[b] поддерживать восстановление страницы; если программа совершает ошибку страницы, ссылаясь на украденную страницу, операционная система обнаруживает это и восстанавливает кадр страницы без необходимости считывать содержимое обратно в ОЗУ.

Предварительная очистка

Операционная система может периодически предварительно очищать грязные страницы: записывать измененные страницы обратно на диск, даже если они могут быть изменены. Это сводит к минимуму объем очистки, необходимый для получения новых страничных фреймов в момент запуска новой программы или открытия нового файла данных, и повышает скорость отклика. (Операционные системы Unix периодически используют синхронизировать предварительно очистить все грязные страницы; В операционных системах Windows используются потоки «модифицированного модуля записи страниц».)

Взбучка

После завершения инициализации большинство программ работают с небольшим количеством страниц кода и данных по сравнению с общим объемом памяти, который требуется программе. Наиболее часто используемые страницы называются рабочий набор.

Когда рабочий набор составляет небольшой процент от общего числа страниц системы, системы виртуальной памяти работают наиболее эффективно, и незначительное количество вычислений тратится на устранение ошибок страниц. По мере роста рабочего набора устранение ошибок страниц остается управляемым, пока рост не достигнет критической точки. Затем количество ошибок резко возрастает, и время, затрачиваемое на их устранение, превышает время, потраченное на вычисления, для которых была написана программа. Это состояние называется взбучка. Переработка происходит в программе, которая работает с огромными структурами данных, поскольку ее большой рабочий набор вызывает постоянные сбои страниц, которые резко замедляют работу системы. Для устранения ошибок страниц может потребоваться освобождение страниц, которые вскоре придется перечитывать с диска. «Обмолачивание» также используется в контекстах, отличных от систем виртуальной памяти; например, чтобы описать тайник проблемы в вычислениях или синдром глупого окна в сети.

Худший случай может произойти на VAX процессоры. Один MOVL, пересекающий границу страницы, может иметь исходный операнд, использующий режим отложенной адресации смещения, где длинное слово, содержащее адрес операнда, пересекает границу страницы, и операнд назначения, использующий режим отложенной адресации смещения, где длинное слово, содержащее адрес операнда, пересекает граница страницы, а источник и место назначения могут пересекать границы страницы. Эта единственная инструкция ссылается на десять страниц; если не все находятся в ОЗУ, каждый вызовет ошибку страницы. При возникновении каждого сбоя операционная система должна выполнять обширные процедуры управления памятью, что может вызвать несколько операций ввода-вывода, которые могут включать запись других страниц процесса на диск и чтение страниц активного процесса с диска. Если операционная система не может выделить десять страниц для этой программы, то при устранении ошибки страницы будет отброшена другая страница, в которой нуждается инструкция, и любой перезапуск инструкции снова приведет к ошибке.

Чтобы уменьшить чрезмерное количество страниц и решить проблемы с перегрузкой, пользователь может увеличить количество страниц, доступных для каждой программы, либо за счет одновременного запуска меньшего числа программ, либо за счет увеличения объема ОЗУ на компьютере.

Обмен

В мультипрограммирование или в многопользовательский среды, многие пользователи могут выполнять одну и ту же программу, написанную так, что ее код и данные находятся на разных страницах. Чтобы минимизировать использование ОЗУ, все пользователи используют одну копию программы. Каждый процесс таблица страниц настроен таким образом, что страницы с адресным кодом указывают на одну общую копию, а страницы, которые адресуют данные, указывают на разные физические страницы для каждого процесса.

Различные программы также могут использовать одни и те же библиотеки. Для экономии места в физическую память загружается только одна копия разделяемой библиотеки. Программы, использующие одну и ту же библиотеку, имеют виртуальные адреса, которые соответствуют одним и тем же страницам (которые содержат код и данные библиотеки). Когда программы хотят изменить код библиотеки, они используют копирование при записи, поэтому память выделяется только при необходимости.

Общая память — это эффективный способ связи между программами. Программы могут совместно использовать страницы в памяти, а затем записывать и читать для обмена данными.

Реализации

Ферранти Атлас

Первым компьютером, поддерживающим пейджинг, был суперкомпьютер. Атлас,^[7][8][9] совместно разработан Ферранти, то Манчестерский университет и Плесси в 1963 году. Машина имела ассоциативный (адресный по содержанию ) память с одной записью на каждую страницу размером 512 слов. Наблюдатель^[10] обработанные неэквивалентные прерывания^[c] и управлял переносом страниц между ядром и барабаном, чтобы обеспечить одноуровневое хранилище^[11] программам.

Майкрософт Виндоус

Windows 3.x и Windows 9x

Пейджинг был особенностью Майкрософт Виндоус поскольку Windows 3.0 в 1990 году. Windows 3.x создает скрытый файл названный 386SPART.PAR или же WIN386.SWP для использования в качестве файла подкачки. Обычно встречается в корневая директория, но он может появиться в другом месте (обычно в каталоге WINDOWS). Его размер зависит от того, сколько места подкачки имеется в системе (параметр, выбранный пользователем в разделе Панель управления → Улучшено в разделе «Виртуальная память»). Если пользователь перемещает или удаляет этот файл, синий экран появится при следующем запуске Windows с сообщение об ошибке «Постоянный файл подкачки поврежден». Пользователю будет предложено выбрать, следует ли удалить файл (независимо от того, существует он или нет).

Windows 95, Windows 98 и Windows Me используйте аналогичный файл, и его настройки находятся в Панели управления → Система → вкладка Производительность → Виртуальная память. Windows автоматически устанавливает размер файла подкачки, чтобы он начинался с 1,5-кратного размера физической памяти и при необходимости расширялся до 3-кратного размера физической памяти. Если пользователь запускает приложения с интенсивным использованием памяти в системе с небольшим объемом физической памяти, желательно вручную установить для этих размеров значение выше, чем по умолчанию.

Windows NT

Файл, используемый для подкачки в Windows NT семья это pagefile.sys. По умолчанию файл подкачки находится в корневом каталоге раздела, где установлена ​​Windows. Windows можно настроить на использование свободного места на любых доступных дисках для файлов подкачки. Однако требуется, чтобы в загрузочном разделе (т. Е. На диске, содержащем каталог Windows) был файл подкачки, если система настроена на запись дампов ядра или полных дампов памяти после Синий экран смерти. Windows использует файл подкачки как временное хранилище для дампа памяти. Когда система перезагружается, Windows копирует дамп памяти из файла подкачки в отдельный файл и освобождает место, которое использовалось в файле подкачки.^[12]

Фрагментация

Этот раздел должен быть обновлено. Обновите эту статью, чтобы отразить недавние события или новую доступную информацию. (Июль 2014 г.)

В конфигурации Windows по умолчанию файлу подкачки разрешено при необходимости расширяться за пределы своего первоначального выделения. Если это происходит постепенно, это может сильно затруднить фрагментированный что потенциально может вызвать проблемы с производительностью.^[13] Обычный совет, чтобы избежать этого, — установить единый «заблокированный» размер файла подкачки, чтобы Windows не расширяла его. Однако файл подкачки расширяется только после заполнения, что в конфигурации по умолчанию составляет 150% от общего объема физической памяти.^{[нужна цитата ]} Таким образом, общая потребность в виртуальной памяти с поддержкой файла подкачки должна превышать 250% физической памяти компьютера, прежде чем файл подкачки будет расширяться.

Фрагментация файла подкачки, возникающая при его расширении, носит временный характер. Как только расширенные области больше не используются (при следующей перезагрузке, если не раньше), дополнительное выделенное дисковое пространство освобождается, и файл подкачки возвращается в исходное состояние.

Блокировка размера файла подкачки может быть проблематичной, если приложение Windows запрашивает больше памяти, чем общий размер физической памяти и файла подкачки, что приводит к неудачным запросам на выделение памяти, что может привести к сбою приложений и системных процессов. Кроме того, файл подкачки редко читается или записывается в последовательном порядке, поэтому преимущество в производительности от наличия полностью последовательного файла подкачки минимально. Однако большой файл подкачки обычно позволяет использовать приложения с большим объемом памяти без каких-либо штрафов, кроме использования большего дискового пространства. Хотя фрагментированный файл подкачки не может быть проблемой сам по себе, фрагментация файла подкачки переменного размера со временем приведет к созданию ряда фрагментированных блоков на диске, вызывая фрагментацию других файлов. По этой причине лучше использовать непрерывный файл подкачки фиксированного размера при условии, что выделенный размер достаточно велик, чтобы удовлетворить потребности всех приложений.

Требуемое дисковое пространство может быть легко выделено в системах с более поздними спецификациями (т. Е. В системе с 3 ГБ памяти, имеющей файл подкачки фиксированного размера 6 ГБ на диске 750 ГБ, или в системе с 6 ГБ памяти и 16 ГБ файл подкачки фиксированного размера и 2 ТБ дискового пространства). В обоих примерах система использует около 0,8% дискового пространства с предварительно расширенным до максимума файлом подкачки.

Дефрагментация файл подкачки также иногда рекомендуется для повышения производительности, когда система Windows постоянно использует гораздо больше памяти, чем ее общая физическая память.^{[нужна цитата ]} Это представление игнорирует тот факт, что, за исключением временных результатов расширения, файл подкачки не становится фрагментированным с течением времени. В целом проблемы производительности, связанные с доступом к файлам подкачки, гораздо эффективнее решаются путем добавления дополнительной физической памяти.

Unix и Unix-подобные системы

Unix системы и другие Unix-подобный операционные системы, используйте термин «своп» для описания процесса перемещения страниц памяти между ОЗУ и диском,^{[нужна цитата ]} и регион диска, на котором хранятся страницы. В некоторых из этих систем для подкачки обычно выделяют целый раздел жесткого диска. Эти перегородки называются поменять местами разделы. Многие системы имеют целый жесткий диск, предназначенный для подкачки, отдельно от диска (ов) с данными, содержащий только раздел подкачки. Жесткий диск, предназначенный для подкачки, называется «подкачка», «рабочий диск» или «рабочий диск «. Некоторые из этих систем поддерживают только переключение на раздел подкачки, другие также поддерживают обмен файлами.

Linux

Ядро Linux поддерживает практически неограниченное количество серверных модулей подкачки (устройств или файлов), а также поддерживает назначение внутренних приоритетов. Когда ядро ​​подкачивает страницы из физической памяти, оно использует серверную часть с наивысшим приоритетом и доступным свободным пространством. Если нескольким бэкэндам подкачки назначен одинаковый приоритет, они используются в по-круговой мода (которая чем-то похожа на RAID 0 схемы хранения), обеспечивая повышенную производительность, если к базовым устройствам можно эффективно обращаться параллельно.^[14]

Файлы подкачки и разделы

С точки зрения конечного пользователя файлы подкачки в версиях 2.6.x и новее ядра Linux работают практически так же быстро, как разделы подкачки; ограничение состоит в том, что файлы подкачки должны размещаться непрерывно в своих файловых системах. Чтобы повысить производительность файлов подкачки, ядро ​​хранит карту их размещения на базовых устройствах и обращается к ним напрямую, таким образом обходя кеш и избегая накладных расходов файловой системы.^[15][16] Несмотря на, Красная шляпа рекомендует использовать разделы подкачки.^[17] При размещении на жестких дисках, которые представляют собой вращающиеся магнитные носители, одним из преимуществ использования разделов подкачки является возможность размещать их на смежных областях жесткого диска, что обеспечивает более высокую пропускную способность данных или более быстрое время поиска. Однако административная гибкость файлов подкачки может перевесить определенные преимущества разделов подкачки. Например, файл подкачки может быть размещен в любой смонтированной файловой системе, может иметь любой желаемый размер и может быть добавлен или изменен по мере необходимости. Разделы подкачки не такие гибкие; их нельзя увеличить без использования разделения или управление томом инструменты, которые привносят различные сложности и потенциальные простои.

Подкачка

Подкачка это Ядро Linux параметр, который контролирует относительный вес, присвоенный замена из оперативная память, а не отбрасывать страницы из системы кеш страницы, всякий раз, когда запрос на выделение памяти не может быть удовлетворен из свободной памяти. Для подкачки можно установить значения от 0 до 100 (включительно). Низкое значение приводит к тому, что ядро ​​предпочитает удалять страницы из кеша страниц, в то время как более высокое значение заставляет ядро ​​предпочитать выгружать «холодные» страницы памяти. В значение по умолчанию является 60; установка более высокого значения может вызвать высокую задержку, если холодные страницы необходимо вернуть обратно (например, при взаимодействии с программой, которая бездействовала), а установка более низкого значения (даже 0) может вызвать высокую задержку, когда файлы, которые были вытеснены из кеш нужно читать заново, но более отзывчивые программы. Свопинг тоже может замедлить Жесткие диски далее, потому что он включает в себя множество случайных записей, а SSD нет этой проблемы. Конечно, значения по умолчанию хорошо работают в большинстве рабочих нагрузок, но настольные компьютеры и интерактивные системы для любой ожидаемой задачи могут захотеть снизить значение параметра, а пакетная обработка, а менее интерактивные системы могут захотеть его увеличить.^[18]

Заменить смерть

Когда системной памяти крайне недостаточно для текущих задач и большая часть активности памяти проходит через медленную подкачку, система может стать практически неспособной выполнять какие-либо задачи, даже если процессор простаивает. Когда каждый процесс ожидает свопа, система считается находящейся в обменять смерть.^[19][20]

Смерть свопа может произойти из-за неправильно настроенной чрезмерное использование памяти.^[21][22][23]

Первоначальное описание проблемы «подмены смерти» относится к X сервер. Если код или данные, используемые X-сервером для ответа на нажатие клавиши, не находятся в основной памяти, тогда, если пользователь вводит нажатие клавиши, сервер принимает одну или несколько ошибок страницы, требуя, чтобы эти страницы были прочитаны из свопа, прежде чем нажатие клавиши может быть обрабатывается, замедляя реакцию на него. Если эти страницы не остаются в памяти, для обработки следующего нажатия клавиши их придется снова вызвать, в результате чего система практически не отвечает, даже если она фактически выполняет другие задачи в обычном режиме.^[24]

macOS

macOS использует несколько файлов подкачки. При установке по умолчанию (и рекомендуется Apple) они помещаются в корневой раздел, хотя вместо этого можно разместить их на отдельном разделе или устройстве.^[25]

AmigaOS 4

AmigaOS 4.0 представила новую систему выделения оперативной памяти и дефрагментации физической памяти. Он по-прежнему использует плоское общее адресное пространство, которое нельзя дефрагментировать. Он основан на метод размещения плит и память подкачки, которая позволяет осуществлять подкачку. Пейджинг был реализован в AmigaOS 4.1 но может заблокировать систему, если вся физическая память израсходована.^[26] Память подкачки может быть активирована и деактивирована в любой момент, позволяя пользователю использовать только физическую RAM.

Спектакль

Резервное хранилище для операционной системы виртуальной памяти обычно много порядки величины медленнее чем баран. Кроме того, использование механических запоминающих устройств вводит задерживать, несколько миллисекунд для жесткого диска. Следовательно, желательно уменьшить или исключить подкачку, где это возможно. Некоторые операционные системы предлагают настройки, влияющие на решения ядра.

• Linux предлагает / proc / sys / vm /обмен параметр, который изменяет баланс между выгрузкой оперативной памяти, в отличие от удаления страниц из системы кеш страницы.
• Windows 2000, XP и Vista предлагают DisablePagingExecutive параметр реестра, который определяет, могут ли код и данные режима ядра быть выгруженными.
• В мэйнфрейм-компьютерах часто использовались жесткие диски или барабаны для хранения страниц и подкачки, чтобы сократить время поиска, а также несколько технологий^[27] иметь несколько одновременных запросов к одному и тому же устройству, чтобы уменьшить задержка вращения.
• Флэш-память имеет конечное количество циклов стирания-записи (см. ограничения флеш-памяти ), а наименьший объем данных, который можно стереть за один раз, может оказаться очень большим (128 КБ для твердотельного накопителя Intel X25-M ^[28]), редко совпадающего с размером страницы. Следовательно, флэш-память может быстро изнашиваться, если она используется в качестве места подкачки в условиях ограниченного объема памяти. С другой стороны, флеш-память практически без задержек по сравнению с жесткими дисками, а не летучий как чипы RAM. Схемы вроде ReadyBoost и Память Intel Turbo созданы для использования этих характеристик.

Много Unix-подобный операционные системы (например AIX, Linux, и Солярис ) позволяют использовать несколько запоминающих устройств для пространства подкачки параллельно, чтобы повысить производительность.

Размер пространства подкачки

В некоторых старых операционных системах с виртуальной памятью пространство в резервном хранилище подкачки резервируется, когда программы выделяют память для данных времени выполнения. Поставщики операционных систем обычно издают рекомендации о том, сколько места подкачки следует выделить.

Ограничения адресации на 32-битном оборудовании

Пейджинг — это один из способов разрешить размеру адресов, используемых процессом, который является «виртуальным адресным пространством» или «логическим адресным пространством» процесса, отличаться от объема основной памяти, фактически установленной на конкретном компьютере, который является физическое адресное пространство.

Оперативная память меньше виртуальной памяти

В большинстве систем размер виртуального адресного пространства процесса намного больше доступной основной памяти.^[29] Например:

• В адресная шина , который подключает ЦП к основной памяти, может быть ограничен. В i386SX процессор 32-битные внутренние адреса могут адресовать 4 ГБ, но он имеет только 24 контакта, подключенных к адресной шине, что ограничивает размер установленной физической памяти до 16 МБ. Могут быть другие аппаратные ограничения на максимальный объем устанавливаемой оперативной памяти.
• Максимальный объем памяти может быть не установлен из-за стоимости, из-за того, что в стандартной конфигурации модели он отсутствует, или из-за того, что покупатель не считал это выгодным.
• Иногда в любом случае не все внутренние адреса можно использовать для памяти, поскольку аппаратная архитектура может резервировать большие области для ввода-вывода или других функций.

Основная память того же размера, что и виртуальная память

Компьютер с истинным п-битовая адресация может иметь 2^п установлены адресные блоки ОЗУ. Пример — 32-битный x86 процессор с 4ГБ и без Расширение физического адреса (PAE). В этом случае процессор может обращаться ко всей установленной оперативной памяти и не более того.

Однако даже в этом случае подкачку можно использовать для создания виртуальной памяти размером более 4 ГБ. Например, многие программы могут работать одновременно. Вместе им может потребоваться более 4 ГБ, но не все из них сразу должны быть в ОЗУ. Система подкачки принимает эффективные решения о том, какую память передать вторичной памяти, что приводит к наилучшему использованию установленной оперативной памяти.

Хотя процессор в этом примере не может обращаться к ОЗУ за пределами 4 ГБ, операционная система может предоставлять услуги программам, которые предполагают больший объем памяти, например файлы, размер которых может превышать предел установленной ОЗУ. Операционная система позволяет программе произвольно манипулировать данными в файле, используя разбиение на страницы для переноса частей файла в ОЗУ, когда это необходимо.

Основная память больше, чем виртуальное адресное пространство

У некоторых компьютеров основная память больше, чем виртуальное адресное пространство процесса, например Magic-1,^[29] немного PDP-11 машины и некоторые системы, использующие 32-битные x86 процессоры с Расширение физического адреса. Это сводит на нет значительное преимущество разбиения на страницы, поскольку отдельный процесс не может использовать больше оперативной памяти, чем объем его виртуального адресного пространства. Такие системы часто используют методы подкачки для получения дополнительных преимуществ:

• «Дополнительная память» может быть использована в кеш страницы для кэширования часто используемых файлов и метаданных, таких как информация каталога, из вторичного хранилища.
• Если процессор и операционная система поддерживают несколько виртуальных адресных пространств, «дополнительная память» может использоваться для запуска большего количества процессов. Пейджинг позволяет совокупному количеству виртуальных адресных пространств превышать физическую основную память.
• Процесс может хранить данные в файлы с отображением памяти в файловых системах с поддержкой памяти, таких как tmpfs файловая система или файловые системы на RAM диск и отображать файлы в адресное пространство и из него по мере необходимости.
• Набор процессов может по-прежнему зависеть от улучшенных функций безопасности, которые изоляция на основе страниц может привнести в среду многозадачности.

Общий размер виртуальных адресных пространств по-прежнему ограничен объемом доступной вторичной памяти.

Смотрите также

Примечания

Рекомендации

внешняя ссылка

• Своп Факты и вопросы по документации Ubuntu
• Windows Server — перемещение файла подкачки на другой раздел или диск Дэвид Нудельман
• Как работает виртуальная память от HowStuffWorks.com (фактически объясняет только концепцию подкачки, а не концепцию виртуальной памяти)
• Управление пространством подкачки Linux (устарело, по признанию автора)
• Руководство по оптимизации скорости виртуальной памяти (устарело и противоречит разделу 1.4 этой вики-страницы и (по крайней мере) ссылкам 8, 9 и 11.)
• Алгоритмы замены страниц виртуальной памяти
• Windows XP: Как вручную изменить размер файла подкачки виртуальной памяти
• Windows XP: факторы, которые могут истощить запас памяти выгружаемого пула
• SwapFs драйвер, который можно использовать для сохранения файла подкачки Windows в разделе подкачки Linux

Подкачка страниц (англ. Paging; иногда используется термин swapping от swap, /swɔp/) — один из механизмов виртуальной памяти, при котором отдельные фрагменты памяти (обычно неактивные) перемещаются из ОЗУ на жёсткий диск (или другой внешний накопитель, такой как Флеш-память), освобождая ОЗУ для загрузки других фрагментов памяти. Такими фрагментами в современных ЭВМ являются страницы памяти.

Временно выгруженные из памяти страницы могут сохраняться на внешних запоминающих устройствах как в файле, так и в специальном разделе на жёстком диске (partition), называемые соответственно swap-файл и swap-раздел. В случае откачки страниц, соответствующих содержимому какого-либо файла (например, memory-mapped files), они могут удаляться. При запросе такой страницы она может быть считана из оригинального файла.

Когда приложение обратится к откаченной странице, произойдет исключительная ситуация PageFault. Обработчик этого события должен проверить, была ли ранее откачена запрошенная страница, и, если она есть в свопе, загрузить ее обратно в память.

История

Изначально под свопингом понималась выгрузка процесса из оперативной памяти целиком, в результате чего неактивные процессы могли полностью отсутствовать в ОЗУ. При наступлении условий активизации процесса диспетчер памяти загружал образ процесса обратно.

Смысл термина изменился в 60-х годах, когда в операционных системах появилась поддержка виртуальной памяти: под свопингом стали понимать загрузку и выгрузку отдельных страниц.

Алгоритмы определения устаревших страниц

При выделении места для новой страницы бывает необходимо удалить какую-либо страницу, в данный момент находящуюся в памяти. Правила замещения страниц служат для принятия решения о том, какую именно страницу следует удалить из памяти. Идеальным кандидатом является «мёртвая» страница, которая больше не потребуется кому-либо (например, относится к завершённому процессу). Если же таких страниц нет в памяти (или их количества недостаточно), используется правило локального или глобального замещения страниц:

• Правило локального замещения выделяет каждому процессу или группе взаимосвязанных процессов определённое количество страниц. Если процессу нужна новая страница, он должен заменить одну из собственных.
• Правило глобального замещения страниц позволяет брать страницы любого процесса, используя глобальные критерии выбора. Для реализации данного подхода необходимо выбрать критерий, по которому будет приниматься решение о страницах, хранимых в памяти.

Наиболее часто используемые критерии поиска:

• Least Recently Used. Удаляются те страницы, доступ к которым производился наиболее давно. Считается, что в последующем к таким страницам будет происходить минимум обращений.
• Last Recently Used. Удаляются недавно освободившиеся страницы. Подразумеваются страницы только что завершившихся процессов.

Недостатки и возможность их преодоления

В случае расположения данных виртуальной памяти на внешних запоминающих устройствах (например, жестких дисках), как чаще всего и происходит — доступ к памяти замедляется (по сравнению с оперативными запоминающими устройствами).

С большой вероятностью, использование свопинга на SSD накопителях (имеют ограниченное количество циклов перезаписи) уменьшает срок их службы.

В 32-разрядной Windows XP, Vista, 7 для своп-файла можно использовать оперативную память за пределами 3-его гигабайта, используя сторонние программы по созданию дисков, хранящихся в памяти.

Файлы и разделы подкачки

Реализация хранения виртуальных данных в различных операционных системах различается в силу архитектурных особенностей их ядер и файловых систем.

Фрагментация файла подкачки

В процессе работы файл (раздел диска, или файл на разделе) подкачки может стать фрагментированым, то есть непрерывные виртуальные области памяти будут состоять из многочисленных отдельных (разрывных) областей в файле подкачки. При считывании и записи данных страниц, расположенных линейно в виртуальной памяти, но рассеянных по файлу подкачки, много времени будет уходить на перепозиционирование головок жёсткого диска на начало очередной области. Это может привести к падению производительности всей системы из-за обилия медленных запросов на ввод-вывод.

Рекомендации по размещению файла подкачки

• Одним из способов выделения места для swap‐файла (раздела), рекомендуемом в течение многих лет, является кратное выделение памяти, когда объём этого файла равен объёму оперативной памяти, умноженному на константу от 0,5 до 2 или 3.
• Если на компьютере имеется более одного жёсткого диска, то для более быстрого обращения к файлу подкачки его желательно разместить на наименее нагруженном запросами чтения/записи физическом диске. Хорошим выбором будет физический файл подкачки на диске, который имеет наибольшую скорость чтения/записи.
• В Windows скорость чтения из небольших разделов больше у FAT32 по сравнению с NTFS, однако, благодаря более высокой устойчивости NTFS к сбоям и значительным объёмам современных жестких дисков, разделы с FAT32 ныне редко используются.

Безопасность при работе с swap файлом

Из файла (раздела) подкачки зачастую можно извлечь конфиденциальную информацию, используемую при работе вычислительной системы. Поэтому при работе с секретными данными обычно производится очистка swap — например, с помощью утилиты sswap из комплекта secure remove.

Также, многие программы, работающие с ценной информацией или с шифрованием, могут выборочно отключать возможность откачки фрагментов памяти.

В Linux можно зашифровать swap-файл или раздел (например в дистрибутиве Ubuntu это делается автоматически при выборе опции шифрования домашнего каталога пользователя в процессе установки ОС). Такое решение несколько повышает нагрузку на процессор, но гарантирует сохранность конфиденциальной информации даже при внезапном отключении питания.

Использование файла подкачки может приводить к заражению некоторых ОС компьютерными вирусами, так как существует уязвимость^{[источник не указан 463 дня]}, позволяющая вытеснить выполняемые программы в виртуальную память и изменить выполняемый код с помощью прямого доступа к жёсткому диску.

Unix

В ОС Unix, и подобных ей, swap обычно помещается на отдельный раздел жёсткого диска, что ранее ускоряло доступ к данным, по сравнению с расположением swap на обычном разделе. В ядрах Linux 2.6 и новее работа swap-файла не уступает по производительности swap-разделу^[1][2].

Пример создания swap-файла для GNU/Linux:

# dd if=/dev/zero of=/swap bs=1024 count=128K
# mkswap /swap
# sync
# swapon /swap

Oracle Solaris может использовать тома ZFS в качестве разделов подкачки:

# zfs create -V 2G pool/swap
# swap -a /dev/zvol/dsk/pool/swap

ОС Microsoft Windows и Windows NT

Область жёсткого диска, предназначенная для свопинга, располагается в отдельном файле, который называется файл подкачки, своп-файл (от англ. swap file). Он называется pagefile.sys и по умолчанию создаётся системой в корневом каталоге диска C:. В дальнейшем пользователь может управлять размером и размещением файла подкачки, например, используя Панель управления, пункт Система.

В Windows 9x файл подкачки называется win386.swp и располагается в каталоге Windows. Однако правкой файла System.INI его можно перенести в корневой каталог для последующего совместного использования с Windows NT.

Примечания