Memory page error

From Wikipedia, the free encyclopedia

In computing, a page fault (sometimes called PF or hard fault)^[a] is an exception that the memory management unit (MMU) raises when a process accesses a memory page without proper preparations. Accessing the page requires a mapping to be added to the process’s virtual address space. Besides, the actual page contents may need to be loaded from a backing store, such as a disk. The MMU detects the page fault, but the operating system’s kernel handles the exception by making the required page accessible in the physical memory or denying an illegal memory access.

Valid page faults are common and necessary to increase the amount of memory available to programs in any operating system that uses virtual memory, such as Windows, macOS, and the Linux kernel.^[1]

Types[edit]

Minor[edit]

If the page is loaded in memory at the time the fault is generated, but is not marked in the memory management unit as being loaded in memory, then it is called a minor or soft page fault. The page fault handler in the operating system merely needs to make the entry for that page in the memory management unit point to the page in memory and indicate that the page is loaded in memory; it does not need to read the page into memory. This could happen if the memory is shared by different programs and the page is already brought into memory for other programs.

The page could also have been removed from the working set of a process, but not yet written to disk or erased, such as in operating systems that use Secondary Page Caching. For example, HP OpenVMS may remove a page that does not need to be written to disk (if it has remained unchanged since it was last read from disk, for example) and place it on a Free Page List if the working set is deemed too large. However, the page contents are not overwritten until the page is assigned elsewhere, meaning it is still available if it is referenced by the original process before being allocated. Since these faults do not involve disk latency, they are faster and less expensive than major page faults.

Major[edit]

This is the mechanism used by an operating system to increase the amount of program memory available on demand. The operating system delays loading parts of the program from disk until the program attempts to use it and the page fault is generated. If the page is not loaded in memory at the time of the fault, then it is called a major or hard page fault. The page fault handler in the OS needs to find a free location: either a free page in memory, or a non-free page in memory. This latter might be used by another process, in which case the OS needs to write out the data in that page (if it has not been written out since it was last modified) and mark that page as not being loaded in memory in its process page table. Once the space has been made available, the OS can read the data for the new page into memory, add an entry to its location in the memory management unit, and indicate that the page is loaded. Thus major faults are more expensive than minor faults and add storage access latency to the interrupted program’s execution.

Invalid[edit]

If a page fault occurs for a reference to an address that is not part of the virtual address space, meaning there cannot be a page in memory corresponding to it, then it is called an invalid page fault. The page fault handler in the operating system will then generally pass a segmentation fault to the offending process, indicating that the access was invalid; this usually results in abnormal termination of the code that made the invalid reference. A null pointer is usually represented as a pointer to address 0 in the address space; many operating systems set up the MMU to indicate that the page that contains that address is not in memory, and do not include that page in the virtual address space, so that attempts to read or write the memory referenced by a null pointer get an invalid page fault.

Invalid conditions[edit]

Illegal accesses and invalid page faults can result in a segmentation fault or bus error, resulting in an app or OS crash. Software bugs are often the causes of these problems, but hardware memory errors, such as those caused by overclocking, may corrupt pointers and cause healthy codes to fail.

Operating systems provide differing mechanisms for reporting page fault errors. Microsoft Windows uses structured exception handling to report invalid page faults as access violation exceptions. UNIX-like systems typically use signals, such as SIGSEGV, to report these error conditions to programs. If the program receiving the error does not handle it, the operating system performs a default action, typically involving the termination of the running process that caused the error condition, and notifying the user that the program has malfunctioned. Windows often reports such crashes without going to any details. An experienced user can retrieve detailed information using WinDbg and the minidump that Windows creates during the crash. UNIX-like operating systems report these conditions with such error messages as «segmentation violation» or «bus error», and may produce a core dump.

Performance impact[edit]

Page faults degrade system performance and can cause thrashing. Major page faults on conventional computers using hard disk drives can have a significant impact on their performance, as an average hard disk drive has an average rotational latency of 3 ms, a seek time of 5 ms, and a transfer time of 0.05 ms/page. Therefore, the total time for paging is near 8 ms (= 8,000 μs). If the memory access time is 0.2 μs, then the page fault would make the operation about 40,000 times slower.

Performance optimization of programs or operating systems often involves reducing the number of page faults. Two primary focuses of the optimization are reducing overall memory usage and improving memory locality. To reduce the page faults, developers must use an appropriate page replacement algorithm that maximizes the page hits. Many have been proposed, such as implementing heuristic algorithms to reduce the incidence of page faults.

A larger physical memory also reduces page faults.

See also[edit]

• Bélády’s anomaly

Notes[edit]

References[edit]

External links[edit]

• «So What Is A Page Fault?(subscription required)» from OSR Online (a Windows-specific explanation)
• «Virtual Memory Details» from the Red Hat website.
• «UnhandledExceptionFilter (Windows)» from MSDN Online.
• «Page fault overhead» for information about how page faults can crucially affect processing time.

First published on TECHNET on Jun 10, 2008

In our last post, we talked about Pages and Page Tables.  Today, we’re going to take a look at one of the most common problems when dealing with virtual memory – the Page Fault.  A page fault occurs when a program requests an address on a page that is not in the current set of memory resident pages.  What happens when a page fault occurs is that the thread that experienced the page fault is put into a Wait state while the operating system finds the specific page on disk and restores it to physical memory.

When a thread attempts to reference a nonresident memory page, a hardware interrupt occurs that halts the executing program.  The instruction that referenced the page fails and generates an addressing exception that generates an interrupt.  There is an Interrupt Service Routine that gains control at this point and determines that the address is valid, but that the page is not resident.  The OS then locates a copy of the desired page on the page file, and copies the page from disk into a free page in RAM.  Once the copy has completed successfully, the OS allows the program thread to continue on.  One quick note here – if the program accesses an invalid memory location due to a logic error an addressing exception similar to a page fault occurs.  The same hardware interrupt is raised.  It is up to the Memory Manager’s Interrupt Service Routine that gets control to distinguish between the two situations.

It is also important to distinguish between hard page faults and soft page faults.  Hard page faults occur when the page is not located in physical memory or a memory-mapped file created by the process (the situation we discussed above).  The performance of applications will suffer when there is insufficient RAM and excessive hard page faults occur.  It is imperative that hard page faults are resolved in a timely fashion so that the process of resolving the fault does not unnecessarily delay the program’s execution.  On the other hand, a soft page fault occurs when the page is resident elsewhere in memory.  For example, the page may be in the working set of another process.  Soft page faults may also occur when the page is in a transitional state because it has been removed from the working sets of the processes that were using it, or it is resident as the result of a prefetch operation.

We also need to quickly discuss the role of the system file cache and cache faults.  The system file cache uses Virtual Memory Manager functions to manage application file data.  The system file cache maps open files into a portion of the system virtual address range and uses the process working set memory management mechanisms to keep the most active portions of current files resident in physical memory.  Cache faults are a type of page fault that occur when a program references a section of an open file that is not currently resident in physical memory.  Cache faults are resolved by reading the appropriate file data from disk, or in the case of a remotely stored file – accessing it across the network.  On many file servers, the system file cache is one of the leading consumers of virtual and physical memory.

Finally, when investigating page fault issues, it is important to understand whether the page faults are hard faults or soft faults.  The page fault counters in Performance Monitor do not distinguish between hard and soft faults, so you have to do a little bit of work to determine the number of hard faults.  To track paging, you should use the following counters: Memory Page Faults /sec, Memory Cache Faults /sec and Memory Page Reads /sec.  The first two counters track the working sets and the file system cache.  The Page Reads counter allows you to track hard page faults.  If you have a high rate of page faults combined with a high rate of page reads (which also show up in the Disk counters) then you may have an issue where you have insufficient RAM given the high rate of hard faults.

OK, that will do it for this post.  Until next time …

Additional Resources:

• MSDN: Working Set (Windows)

• TechNet: Memory Monitoring Specifics

—

CC Hameed

Share this post :

Imagine this: your library is trying to step up its game and compete in the Internet age. Rather than you browsing the shelfs, trying to remember how the Dewey Decimal works, you’ll enter your book selections from your phone. A librarian will then bring your books to the front desk.

You place your book order on a busy weekend morning. Rather than getting all of your books, the librarian just brings one back. Sometimes the librarian even asks for your book back, tells you to walk out the door to make room for others, and lets someone else read their book for a bit. They then call you back in, shuffling you and the other book readers in-and-out.

What’s going on? Is the librarian insane?

This is the life of the Linux’s memory management unit (librarian) and processes (you and the other book readers). A page fault happens when the librarian needs to fetch a book.

How can you tell if page faults are slowing you down, and — above all — how can you avoid being shuffled in-and-out of the library?

More about pages

Linux allocates memory to processes by dividing the physical memory into pages, and then mapping those physical pages to the virtual memory needed by a process. It does this in conjunction with the Memory Management Unit (MMU) in the CPU. Typically a page will represent 4KB of physical memory. Statistics and flags are kept about each page to tell Linux the status of that chunk of memory.

These pages can be in different states. Some will be free (unused), some will be used to hold executable code, and some will be allocated as data for a program. There are lots of clever algorithms that manage this list of pages and control how they are cached, freed and loaded.

What’s a page fault? An example.

Imagine a large running program on a Linux system. The program executable size could be measured in megabytes, but not all that code will run at once. Some of the code will only be run during initialization or when a special condition occurs. Over time Linux can discard the pages of memory which hold executable code, if it thinks that they are no longer needed or will be used rarely. As a result not all of the machine code will be held in memory even when the program is running.

A program is executed by the CPU as it steps its way through the machine code. Each instruction is stored in physical memory at a certain address. The MMU handles the mapping from the physical address space to the virtual address space. At some point in the program’s execution the CPU may need to address code which isn’t in memory. The MMU knows that the page for that code isn’t available (because Linux told it) and so the CPU will raise a page fault.

The name sounds more serious than it really is. It isn’t an error, but rather a known event where the CPU is telling the operating system that it needs physical access to some more of the code.

Linux will respond by allocating more pages to the process, filling those pages with the code from the binary file, configuring the MMU, and telling the CPU to continue.

A page fault is you requesting the next book in the Lord of the Rings Trilogy from the librarian, the librarian retrieving the book from the shelfs, and notifying you that the book is now at the front desk.

Minor page faults?

There is also a special case scenario called a minor page fault which occurs when the code (or data) needed is actually already in memory, but it isn’t allocated to that process. For example, if a user is running a web browser then the memory pages with the browser executable code can be shared across multiple users (since the binary is read-only and can’t change). If a second user starts the same web browser then Linux won’t load all the binary again from disk, it will map the shareable pages from the first user and give the second process access to them. In other words, a minor page fault occurs only when the page list is updated (and the MMU configured) without actually needing to access the disk.

A minor page fault is your friend requesting to read your checked out copy of The Two Towers and you saying «hey, lets just make a copy of mine!» OR you returning a book, but then immediately checking it out again before the book was even returned to a shelf.

Copy on Write?

A similar thing happens for data memory used by a program. An executable can ask Linux for some memory, say 8 megabytes, so that it can perform some task or other. Linux doesn’t actually give the process 8 megabytes of physical memory. Instead it allocates 8 megabytes of virtual memory and marks those pages as «copy on write.» This means that while they are unused there is no need to actually physically allocate them, but the moment the process writes to that page, a real physical page is allocated and the page assigned to the process.

This happens all the time on a multi-user, multitasking system. The physical memory is used in the most efficient way possible to hold the parts of memory that are actually needed for processes to run.

Copy on Write is you telling the librarian you’ll be there in 15 minutes and you want your The Return of the King book when you get there. The librarian notes where the book is so they can quickly find it when you arrive.

How frequent are page faults?

One of the easiest ways to see the number of major and minor page faults on a Linux system is with the ps command. Try the following:

ps -eo min_flt,maj_flt,cmd

This will list the current running processes on the system along with the number of minor and major page faults that each process has generated.

The way to see the page faults that are generated by an executable is the use the /usr/bin/time command with the -v option. Note: It is important to specify /usr/bin/time rather than just typing time because your shell likely has a time command, which although similar won’t do exactly the same thing.

Try this:

/usr/bin/time -v firefox

After you exit Firefox you will be presented with a set of statistics about how the program ran. Among them will be «Major (requiring I/O) page faults» and «Minor (reclaiming a frame) page faults». The first time you run the browser you will likely see a number of major page faults. On my test machine it was around 40. However the minor page faults is quite large, around 30000 on my test setup.

Now if you run the command again you will see that the number of major faults has dropped to zero, but the minor page faults remains high. This is because on the second go around there were no page faults generated which required the kernel to fetch the executable code from the disk, as they were still somewhere in memory from the first go around. However the number of minor page faults remained the same as the kernel found the pages of memory needed for various shareable libraries etc., and quickly made them available to the process.

Swapping

Under normal operation, the kernel is managing pages of memory so that the virtual address space is mapped onto the physical memory and every process has access to the data and code that it needs. But what happens when the kernel doesn’t have any more physical memory left? Assuming that we would like the system to keep running then the kernel has a trick it can use. The kernel will start to write to disk some of the pages which it is holding in memory, and use the newly freed pages to satisfy the current page faults.

Writing pages out to disk is a relatively slow process (compared to the speed of the CPU and the main memory), however it is a better option than just crashing or killing off processes.

The process of writing pages out to disk to free memory is called swapping-out. If later a page fault is raised because the page is on disk, in the swap area rather than in memory, then the kernel will read back in the page from the disk and satisfy the page fault. This is swapping-in.

If a system is heavily loaded then an undesirable situation can occur when the latest page fault requires a page to be swapped-in but there still isn’t enough free memory. So to satisfy the swap-in the kernel must first swap-out. At this stage there is a danger that the system performance will degrade. If this is only a temporary situation and more free system memory becomes available, then this isn’t a problem.

However, there is a worse scenario. Imagine a situation where the kernel must first swap-out some pages in order to free some memory for a swap-in. But then the pages which were just swapped-out are needed again (because of a new page fault) and so must be swapped-in again. To satisfy this swap-in the previous pages that were just swapped-in are now swapped-out. And so on. This is known as thrashing. When a computer system starts thrashing it spends more time trying to satisfy major page faults than it does in actually running processes. The result is an unresponsive system and a very busy hard disk.

You can use the top command to see how much swap space is being used on your system and the vmstat command to see the current numbers of swap-in si and swap-out so operations.

Try:

vmstat 1

Swapping is you requesting a lot of books — too many to hold at the front desk. The librarian needs to keep the rest in a storage room in the basement, and it takes a long time to go back-and-forth.

When should you worry about page faults and swapping?

Most of the time, your primary performance worry is a high rate of swap-in/out’s. This means your host doesn’t have physical memory to store the needed pages and is using the disk often, which is significantly slower than physical memory.

What metrics should you monitor?

• Swap Activity (swap-ins and swap outs)
• Amount of swap space used

Swap activity is the major performance factor with memory access; simply using a moderate amount of swap space isn’t necessarily an issue if the pages swapped out belong to a mostly idle process. However when you begin to use a large amount of swap space there is a greater chance of swap activity impacting your server performance.

One more thing

The kernel’s aggressiveness in preemptively swapping-out pages is governed by a kernel parameter called swappiness. It can be set to a number from 0 to 100, where 0 means that more is kept in memory and 100 means that the kernel should try and swap-out as many pages as possible. The default value is 60. Kernel maintainer Andrew Morton has stated that he uses a swappiness of 100 on his desktop machines, «my point is that decreasing the tendency of the kernel to swap stuff out is wrong. You really don’t want hundreds of megabytes of BloatyApp’s untouched memory floating about in the machine. Get it out on the disk, use the memory for something useful.»

TL;DR

• The total amount of virtual address space for all the running processes far exceeds the amount of physical memory.
• The mapping between the virtual address space and physical memory is handled by the Linux kernel and by the CPU’s MMU using pages of memory.
• When the CPU needs to access a page that isn’t in memory it raises a page fault.
• A major page fault is one that can only be satisfied by accessing the disk.
• A minor page fault can be satisfied by sharing pages that are already in memory.
• Swapping occurs when pages are written to the disk to free memory so that a major page fault can be satisfied.
• Swap activity is the primary performance concern when it comes to page faults.

More servers? Or faster code?

Adding servers can be a band-aid for slow code. Scout APM helps you find and fix your inefficient and costly code. We automatically identify N+1 SQL calls, memory bloat, and other code-related issues so you can spend less time debugging and more time programming. 

Ready to optimize your site? Sign up for a free trial.

Also see

• Restricting process CPU usage using nice, cpulimit, and cgroups
• Slow Server? This is the Flow Chart You’re Looking For
• Understanding CPU Steal Time — when should you be worried?
• Understanding Linux CPU Load — when should you be worried?

Updated version of an article first published in 2015.

In Windows, the nonpaged area is the part of the memory that contains critical files your computer needs to function properly.

Those critical files are stored in the nonpaged area so the RAM won’t switch them back and forth between itself and the paged area.

Once there’s an issue with this part of the RAM, the system runs a PAGE_FAULT_IN_NONPAGED_AREA error and shows a BSOD (blue screen of death). The stop code for this error is 0x00000050.

Image source

What We’ll Cover

• What Causes the Page Fault in Nonpaged Area Error?
• How to Fix the Page Fault in Nonpaged Area Error
  • Restart your Computer
  • Check your Computer’s RAM
  • Update all Outdated Drivers
  • Perform an SFC Scan
  • Run the Windows Disk Checker Scan
• Final Thoughts

The «page fault in nonpaged area» error can be caused by one or any combination of the following issues:

• Corrupt or damaged RAM
• Faulty driver
• Windows’ inability to find files that are supposed to be in the nonpaged area

How to Fix the Page Fault in Nonpaged Area Error

Restart your Computer

You can solve many Windows problems by simply restarting your PC. And this error is not an exception.

This is because when you restart your computer, temporary files are cleared and every task eating up too much RAM is killed – making your computer faster.

Check your Computer’s RAM

Since this issue is mostly caused by RAM and driver issues, the first thing I would advise you do is to check the computer’s RAM.

If you can’t check it yourself, you should take the computer to an accredited engineer.

Sometimes, the solution to this issue could be clearing dust from the RAM or reconnecting it.

If checking your RAM fails to fix the error and you still see the BSOD (blue screen of death), start your computer in safe mode and proceed to the remaining fixes in this article.

Update all Outdated Drivers

An outdated or corrupt driver is also one of the major causes of the page fault in nonpaged area error. So looking for outdated drivers and updating them can solve the problem for you.

To update your computer’s outdated drivers, right-click on Start and select “Device Manger”:

Once you see the drivers, a warning symbol will appear beside any outdated driver(s).

Expand the device that has an outdated driver:

Right click on any outdated driver and select “Update driver”:

Select “Search automatically for drivers” so Windows can check the internet for new drivers:

If a new driver is found, install it and restart your computer system.

Perform an SFC Scan

In Windows, the system file checker (SFC) scan checks your computer for corrupt system files and restores them. So, it can help you get rid of the page fault in nonpaged area error.

To perform the SFC scan, you need to open the command line as an administrator, then type in sfc/scannow and hit ENTER:

Run the Windows Disk Checker Scan

Search for CMD and select “Run as Administrator” on the right:

In the command line, enter chkdsk C: /f /r and press ENTER.

If you get a message that says “Cannot run because volume is in use by another process”, type y and press ENTER so the scan can run when the system restarts the next time.

N.B.: This scan takes a very long time, especially if you have a filled-up disk space or when it is done on startup. So, be patient.

Final Thoughts

This article showed you what the page fault in nonpaged area error is, its causes, and how to fix it.

I hope the solutions discussed in this article help you fix the issue and get rid of the BSOD for you.

If all of the fixes fail to fix the issue for you, then the last resort is to reset your PC.

---

---

Learn to code for free. freeCodeCamp’s open source curriculum has helped more than 40,000 people get jobs as developers. Get started

PAGE_FAULT_IN_NONPAGED_AREA — распространенная проблема Windows, которая обычно связана со сбоями в работе ОЗУ. Её можно встретить во всех версиях Windows, таких как 10 / 8.1 / 8 и 7. Ошибка появляется в виде синего экрана смерти после сбоя системы. Выскакивающая ошибка означает, что ПК не смог запросить страницу памяти, что препятствовало правильной работе Windows. После этого Windows автоматически начнет сбор данных и устранение проблемы, что приведет к перезагрузке. К сожалению, процесс автоматического восстановления не всегда оказывается успешным. Вместо этого иногда люди не могут войти в систему, так как синий экран постоянно появляется при попытке запустить компьютер. Ошибка «PAGE_FAULT_IN_NONPAGED_AREA» часто связана со сбоями конфигурации памяти или повреждением оборудования. Однако, поскольку этот тип проблемы существует и затрагивает большинство пользователей Windows уже на протяжении длительного времени, мы собрали набор наиболее эффективных и проверенных инструментов, которые помогут вам устранить эту проблему в статье ниже.

Автоматическое восстановление

Скачать утилиту восстановления Windows

1. Проверьте диск на наличие повреждений.

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

1. Найдите Командная строка , введя cmd во вкладку поиска. Затем щелкните на неё правой кнопкой мыши и выберите Запуск от имени администратора.
2. В черной консоли вы должны вставить chkdsk /f /r C: команду и нажмите Enter. При необходимости замените «C» буквой вашего жесткого диска.
3. Система выполнит сканирование на правильность конфигурации и физические ошибки, после чего автоматически исправит их.

Скорее всего проблема будет исправлена. Если нет, следуйте приведенным ниже методам, чтобы избавиться от проблемы.

2. Откат к предыдущей конфигурации

Если вы начали сталкиваться с ошибкой «PAGE_FAULT_IN_NONPAGED_AREA» внезапно после новых обновлений системы или непреднамеренных изменений, которые привели к этой проблеме, вы можете попытаться вернуться к предыдущим настройкам, которые раньше работали без сбоев. Использование опции «Последняя удачная конфигурация» возможно только в Windows 7. Для этого мы собираемся использовать дополнительные параметры Windows, которые описаны ниже:

1. Полностью выключите компьютер.
2. Затем включите компьютер, нажмите и удерживайте F8 (или F2 если F8 не работает) сразу после того, как увидите черный экран в начале загрузки.
3. После этого вы должны увидеть появившееся Дополнительные параметры Windows меню.
4. В меню, используйте клавиши со стрелками на клавиатуре, чтобы найти Последняя удачная конфигурация и затем нажмите Enter.

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

Для пользователей Windows 10:

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

Для пользователей Windows 7 / 8 / 8.1:

1. Как и выше, при перезагрузке ПК удерживайте F8 or F2 для входа в Дополнительные параметры Windows. Если вы используете Windows 8, попробуйте удерживать F8 с Shift. Обратите внимание, что для этого может потребоваться несколько попыток.
2. Затем выберите Безопасный режим вариант и нажмите Enter.

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

3. Запустите средство диагностики памяти Windows.

Ошибка «PAGE FAULT IN NONPAGED AREA» может быть спровоцирована неисправностью ОЗУ. Это не обязательно означает, что вам следует спешить с покупкой и заменой памяти. Вместо этого следует сначала попытаться просканировать свою оперативную память на предмет целостности и позволить Windows решить найденную проблему. Приведенные ниже инструкции доступны и идентичны для всех версий Windows:

1. Тип mdsched в строку поиска рядом с Меню Пуск.
2. После открытия вы увидите новую вкладку с двумя вариантами.
3. В зависимости от того, какой из них вы выберете, Windows просканирует вашу оперативную память на наличие ошибок и мгновенно восстановит их.

Наконец, вы можете посмотреть, исчезла ли ошибка.

4. Обновите драйверы

Устаревшие или неисправные драйверы также считаются частыми причинами сбоев, связанных с памятью. Именно поэтому следует попытаться проверить драйверы на наличие новых обновлений и установить их последовательно.

Вы можете обновить их вручную или с помощью утилиты IObit Driver Booster, которая автоматически найдет устаревшие или отсутствующие драйверы и заменит их.

Скачать Driver Booster

 
Чтобы запустить обновление вручную, следуйте инструкциям, приведенным ниже:

1. Щелкните левой кнопкой мыши на Меню Пуск и выберите Диспетчер устройств.
2. Если вы не знаете, какой драйвер вызывает проблему, обновите их один за другим. Щелкните на каждый из них правой кнопкой мыши и выберите Обновить драйвер. Иногда неисправные драйверы помечаются желтым треугольником.
3. Позвольте Windows найти новые драйверы и загрузить их, следуя инструкциям на экране.

Перезагрузите компьютер и посмотрите, не изменилось ли что-нибудь после обновления. Если нет, перейдите к следующему способу ниже.

4. Отключите Автоматическое определение Файла подкачки

Если ни один из предыдущих методов не устранил проблему, то отключение автоматического определения файла подкачки может помочь в исправлении ошибки «PAGE_FAULT_IN_NONPAGED_AREA». И вот как это сделать:

1. Какую бы версию Windows вы ни использовали, перейдите в Мой компьютер и щелкните правой кнопкой мыши в пустом месте.
2. Затем выберите Объявления и перейти в Дополнительные параметры системы.
3. Перейдите в Производительность настройки и выберите Дополнительно меню.
4. В открывшемся окне выберите Изменить , а затем снимите флажок с Автоматически выбирать объем файла подкачки.
5. В конечном итоге нажмите OK чтобы сохранить настройки и перезагрузите компьютер. Надеемся, проблема исчезнет.

Как видите, ошибку «PAGE FAULT IN NONPAGED AREA» можно легко устранить, следуя вышеупомянутым шагам. В других случаях вам следует разобрать компьютер и проверить жесткий диск на наличие физических повреждений. Если вы не уверены, повреждена ли оперативная память или жесткий диск, вам обязательно следует обратиться за дополнительной помощью к профессионалам, чтобы самостоятельно не повредить устройства.