git: bc1d9997f0 - main - update translation of articles/vm-design to Russian

The branch main has been updated by vladlen:

URL: https://cgit.FreeBSD.org/doc/commit/?id=bc1d9997f017caed0cb1634286b15aaae3d31c5c

commit bc1d9997f017caed0cb1634286b15aaae3d31c5c
Author:     Vladlen Popolitov <[email protected]>
AuthorDate: 2026-04-02 15:31:42 +0000
Commit:     Vladlen Popolitov <[email protected]>
CommitDate: 2026-04-02 15:31:42 +0000

    update translation of articles/vm-design to Russian
    
    Reviewed by: andy
    Differential Revision: https://reviews.freebsd.org/D56105
---
 .../content/ru/articles/vm-design/_index.adoc      |  46 ++---
 .../content/ru/articles/vm-design/_index.po        | 219 +++++++++++----------
 2 files changed, 136 insertions(+), 129 deletions(-)

diff --git a/documentation/content/ru/articles/vm-design/_index.adoc b/documentation/content/ru/articles/vm-design/_index.adoc
index d852955a4f..804913d6df 100644
--- a/documentation/content/ru/articles/vm-design/_index.adoc
+++ b/documentation/content/ru/articles/vm-design/_index.adoc
@@ -59,7 +59,7 @@ toc::[]
 [[introduction]]
 == Введение
 
-Перед тем, как перейти непосредственно к существующей архитектуре, потратим немного времени на рассмотрение вопроса о необходимости поддержки и модернизации любого длительно живущего кода. В мире программирования алгоритмы становятся более важными, чем код, и именно из-за академических корней BSD изначально большое внимание уделялось проработке алгоритмов. Внимание, уделенное архитектуре, в общем отражается на ясности и гибкости
  кода, который может быть достаточно легко изменен, расширен или с течением времени заменен. Хотя некотÐ
¾Ñ€Ñ‹Ðµ считают BSD "старой" операционной системой, те их нас, кто работает над ней, видят её скорее системой со "зрелым" кодом с различными компонентами, которые были заменены, расширены или изменены современным кодом. Он развивается, и FreeBSD остаётся передовой системой, вне зависимости от того, насколько старой может быть часть кода. Это важное отличие, которое, к сожалению, не всеми понимается. Самой большой ошибкой, которую может допустить
  программист, является игнорирование истории, и это именно та ошибка, которую сделали многие другие сов
ременные операционные системы. Самым ярки примером здесь является Windows NT(R), и последствия ужасны. Linux также в некоторой степени совершил эту ошибку-достаточно, чтобы мы, люди BSD, по крайней мере по разу отпустили по этому поводу шутку. Проблема Linux заключается просто в отсутствии опыта и истории для сравнения идей, проблема, которая легко и быстро решается сообществом Linux точно так же, как она решается в сообществе BSD-постоянной работой н
 ад кодом. Разработчики Windows NT(R), с другой стороны, постоянно совершают те же самые ошибки, что были решенÑ
‹ в UNIX(R) десятки лет назад, а затем тратят годы на их устранение. Снова и снова. Есть несколько случаев "проработка архитектуры отсутствует" и "мы всегда правы, потому что так говорит наш отдел продаж". Я плохо переношу тех, кого не учит история.
+Перед тем, как перейти непосредственно к существующей архитектуре, потратим немного времени на рассмотрение вопроса о необходимости поддержки и модернизации любого длительно живущего кода. В мире программирования алгоритмы становятся более важными, чем код, и именно из-за академических корней BSD изначально большое внимание уделялось проработке алгоритмов. Внимание, уделенное архитектуре, в общем отражается на ясности и гибкости
  кода, который может быть достаточно легко изменен, расширен или с течением времени заменен. Хотя некотÐ
¾Ñ€Ñ‹Ðµ считают BSD "старой" операционной системой, те их нас, кто работает над ней, видят её скорее системой со "зрелым" кодом с различными компонентами, которые были заменены, расширены или изменены современным кодом. Он развивается, и FreeBSD остаётся передовой системой, вне зависимости от того, насколько старой может быть часть кода. Это важное отличие, которое, к сожалению, не всеми понимается. Самой большой ошибкой, которую может допустить
  программист, является игнорирование истории, и это именно та ошибка, которую сделали многие другие сов
ременные операционные системы. Самым ярким примером здесь является Windows NT(R), и последствия ужасны. Linux также в некоторой степени совершил эту ошибку — достаточно, чтобы мы, люди BSD, по крайней мере по разу отпустили по этому поводу шутку. Проблема Linux заключается просто в отсутствии опыта и истории для сравнения идей, проблема, которая легко и быстро решается сообществом Linux точно так же, как она решается в сообществе BSD-постоянной работÐ
 ¾Ð¹ над кодом. Разработчики Windows NT(R), с другой стороны, постоянно совершают те же самые ошибки, что были реÑ
ˆÐµÐ½Ñ‹ в UNIX(R) десятки лет назад, а затем тратят годы на их устранение. Снова и снова. Есть несколько случаев "проработка архитектуры отсутствует" и "мы всегда правы, потому что так говорит наш отдел продаж". Я плохо переношу тех, кого не учит история.
 
 Большинство очевидной сложности архитектуры FreeBSD, особенно в подсистеме VM/Swap, является прямым следствием того, что она решает серьезные проблемы с производительностью, которые проявляются при различных условиях. Эти проблемы вызваны не плохой проработкой алгоритмов, а возникают из окружающих факторов. В любом прямом сравнении между платформами эти проблемы проявляются, когда системные ресурсы начинают истощаться. Так как я описы
 ваю подсистему VM/Swap во FreeBSD, то читатель должен всегда иметь в виду два обстоятельства:
 
@@ -71,55 +71,55 @@ toc::[]
 [[vm-objects]]
 == Объекты VM
 
-Лучше всего начать описание VM-системы FreeBSD с попытки взглянуть на нее с точки зрения пользовательского процесса. Каждый пользовательский процесс имеет единое, принадлежащее только ему и неразрывное адресное пространство VM, содержащее несколько типов объектов памяти. Эти объекты имеют различные характеристики. Код программы и её данные являются единым файлом, отображаемым в память (это выполняющийся двоичный файл), однако код прог
 раммы доступен только для чтения, когда как данные программы размещаются в режиме копирования-при-запи
си. BSS программы представляет собой всего лишь выделенную область памяти, заполненную, если это требовалось, нулями, что называется обнулением страниц памяти по требованию. Отдельные файлы могут также отображаться в адресное пространство, именно так работают динамические библиотеки. Такие отображения требуют изменений, чтобы оставаться принадлежащими процессу, который их выполнил. Системный вызов fork добавляет переводит проблему 
 управления VM полностью в новую плоскость, вдобавок к уже имеющимся сложностям.
+Лучше всего начать описание VM-системы FreeBSD с попытки взглянуть на нее с точки зрения пользовательского процесса. Каждый пользовательский процесс имеет единое, принадлежащее только ему и неразрывное адресное пространство VM, содержащее несколько типов объектов памяти. Эти объекты имеют различные характеристики. Код программы и её данные являются единым файлом, отображаемым в память (это выполняющийся двоичный файл), однако код прог
 раммы доступен только для чтения, тогда как данные программы размещаются в режиме копирования-при-запи
си. BSS программы представляет собой всего лишь выделенную область памяти, заполненную, если это требовалось, нулями, что называется обнулением страниц памяти по требованию. Отдельные файлы могут также отображаться в адресное пространство, именно так работают динамические библиотеки. Такие отображения требуют изменений, чтобы оставаться принадлежащими процессу, который их выполнил. Системный вызов fork переводит проблему управлениÑ
  VM полностью в новую плоскость, вдобавок к уже имеющимся сложностям.
 
-Иллюстрирует сложность страница данных двоичной программы (которая является страницей копируемой-при-записи). Двоичная программа содержит секцию предварительно инициализированных данных, которая первоначально отображается непосредственно из файла программы. Когда программа загружается в Vm-пространство процесса, эта область сначала отображается в память и поддерживается бинарным файлом программы, позволяя VM-системе освобождÐ
 °Ñ‚ÑŒ/повторно использовать страницу, а потом загружать её снова из бинарного файла. Однако в момент, когд
а процесс изменяет эти данные, VM-система должна сделать копию страницы, принадлежащую только этому процессу. Так как эта копия была изменена, то VM-система не может больше освобождать эту страницу, так как впоследствии её невозможно будет восстановить.
+Иллюстрирует сложность страница данных двоичной программы (которая является страницей копируемой-при-записи). Двоичная программа содержит секцию предварительно инициализированных данных, которая первоначально отображается непосредственно из файла программы. Когда программа загружается в виртуальную память процесса, эта область сначала отображается в память и поддерживается бинарным файлом программы, позволяя VM-системе освоÐ
 ±Ð¾Ð¶Ð´Ð°Ñ‚ÑŒ/повторно использовать страницу, а потом загружать её снова из бинарного файла. Однако в момент, 
когда процесс изменяет эти данные, VM-система должна сделать копию страницы, принадлежащую только этому процессу. Так как эта копия была изменена, то VM-система не может больше освобождать эту страницу, так как впоследствии её невозможно будет восстановить.
 
-Вы тут же заметите, что то, что сначала было простым отображением файла в память, становится гораздо более сложным предметом. Данные могут модифицироваться постранично, когда как отображение файла выполняется для многих страниц за раз. Сложность ещё более увеличивается, когда процесс выполняет вызов fork. При этом порождаются два процесса-каждый со с собственным адресным пространством, включающим все изменения, выполненные исходным
  процессом до вызова функции `fork()`. Было бы глупо для VM-системы делать полную копию данных во время вызов
а `fork()`, так как весьма вероятно, что один из двух процессов будет нужен только для чтения из той страницы, что позволяет использование исходной страницы. То, что было страницей, принадлежащей только процессу, сделается снова страницей, копируемой при записи, так как каждый из процессов (и родитель, и потомок) полагают, что их собственные изменения после разветвления будут принадлежать только им, и не затронут родственный процесс.
+Вы тут же заметите, что то, что сначала было простым отображением файла в память, становится гораздо более сложным предметом. Данные могут модифицироваться постранично, когда как отображение файла выполняется для многих страниц за раз. Сложность ещё более увеличивается, когда процесс выполняет вызов fork. При этом порождаются два процесса-каждый с собственным адресным пространством, включающим все изменения, выполненные исходным пр
 оцессом до вызова функции `fork()`. Было бы глупо для VM-системы делать полную копию данных во время вызова `f
ork()`, так как весьма вероятно, что один из двух процессов будет нужен только для чтения из той страницы, что позволяет использование исходной страницы. То, что было страницей, принадлежащей только процессу, сделается снова страницей, копируемой при записи, так как каждый из процессов (и родитель, и потомок) полагают, что их собственные изменения после разветвления будут принадлежать только им, и не затронут родственный процесс.
 
-FreeBSD управляет всем этим при помощи многоуровневой модели VM-объектов. Исходный файл с двоичной программой переносится на самый нижний уровень объектов VM. Уровень страниц, копируемых при записи, находится выше него, и хранит те страницы, которые были скопированы из исходного файла. Если программа модифицирует страницы данных, относящиеся к исходному файлу, то система VM обнаруживает это и переносит копию этой страницы на более высоки
 й уровень. Когда процесс разветвляется, добавляются новые уровни VM-объектов. Это можно показать на прос
том примере. Функция `fork()` является общей операцией для всех систем *BSD, так что в этом примере будет рассматриваться программа, которая запускается, а затем разветвляется. Когда процесс запускается, VM-система создает некоторый уровень объектов, обозначим его A:
+FreeBSD управляет всем этим при помощи многоуровневой модели VM-объектов. Исходный файл с двоичной программой переносится на самый нижний уровень объектов VM. Уровень страниц, копируемых при записи, находится выше него, и хранит те страницы, которые были скопированы из исходного файла. Если программа модифицирует страницы данных, относящиеся к исходному файлу, то система VM обнаруживает это и переносит копию этой страницы на более высоки
 й уровень. Когда процесс разветвляется, добавляются новые уровни VM-объектов. Это можно показать на прос
том примере. Функция `fork()` является общей операцией для всех систем *BSD, так что в этом примере будет рассматриваться программа, которая запускается, а затем разветвляется. Когда процесс запускается, VM-система создает некоторый уровень объектов, обозначим его **A**:
 
 image::fig1.png["Рисунок"]
 
-A соответствует файлу-по необходимости страницы памяти могут высвобождаться и подгружаться с носителя файла. Подгрузка с диска может потребоваться программе, однако на самом деле мы не хотим, чтобы она записывалась обратно в файл. Поэтому VM-система создает второй уровень, B, который физически поддерживается дисковым пространством подкачки:
+На рисунке *A* соответствует файлу — по необходимости страницы памяти могут высвобождаться и подгружаться с носителя файла. Подгрузка с диска может потребоваться программе, однако на самом деле мы не хотим, чтобы она записывалась обратно в файл. Поэтому VM-система создает второй уровень, **B**, который физически поддерживается дисковым пространством подкачки:
 
 image::fig2.png[]
 
-При первой записи в страницу после выполнения этой операции, в B создается новая страница, содержимое которой берется из A. Все страницы в B могут сбрасываться и считываться из устройства подкачки. Когда программа ветвится, VM-система создает два новых уровня объектов-C1 для порождающего процесса и C2 для порожденного-они располагаются поверх B:
+При первой записи в страницу после выполнения этой операции в **B** создается новая страница, содержимое которой берётся из **A**. Все страницы в **B** могут сбрасываться и считываться из устройства подкачки. Когда программа ветвится, VM-система создает два новых уровня объектов — **C1** для порождающего процесса и **C2** для порожденного — они располагаются поверх **B**:
 
 image::fig3.png[]
 
-В этом случае, допустим, что страница в B была изменена начальным родительским процессом. В процессе возникнет ситуация копирования при записи и страница скопируется в C1, при этом исходная страница останется в B нетронутой. Теперь допустим, что та же самая страница в B изменяется порожденным процессом. В процессе возникнет ситуация копирования при записи и страница скопируется в C2. Исходная страница в B теперь полностью скрыта, так каÐ
 º и C1, и C2 имеют копии, а B теоретически может быть уничтожена, если она не представляет собой "реального" Ñ
„айла). Однако такую оптимизацию не так уж просто осуществить, потому что она делается на уровне мелких единиц. Во FreeBSD такая оптимизация не выполняется. Теперь положим (а это часто случается), что порожденный процесс выполняет вызов `exec()`. Его текущее адресное пространство обычно заменяется новым адресным пространством, представляющим новый файл. В этом случае уровень C2 уничтожается:
+В этом случае, допустим, что страница в **B** была изменена начальным родительским процессом. В процессе возникнет ситуация копирования при записи, и страница скопируется в **C1**, при этом исходная страница останется в **B** нетронутой. Теперь допустим, что та же самая страница в **B** изменяется порожденным процессом. В процессе возникнет ситуация копирования при записи и страница скопируется в **C2**. Исходная страница в **B** теперь полностью Ñ
 ÐºÑ€Ñ‹Ñ‚а, так как и **C1**, и **C2** имеют копии, а уровень **B** теоретически может быть уничтожен, если он не предс
тавляет собой "реального" файла). Однако такую оптимизацию не так уж просто осуществить, потому что это надо делать на уровне слишком мелких единиц. Во FreeBSD такая оптимизация не выполняется. Теперь положим (а это часто случается), что порожденный процесс выполняет вызов `exec()`. Его текущее адресное пространство обычно заменяется новым адресным пространством, представляющим новый файл. В этом случае уровень **C2** уничтожается:
 
 image::fig4.png[]
 
-В этом случае количество потомков B становится равным одному и все обращения к B теперь выполняются через C1. Это означает, что B и C1 могут быть объединены. Все страницы в B, которые также существуют и в C1, во время объединения из B удаляются. Таким образом, хотя оптимизация на предыдущем шаге может не делаться, мы можем восстановить мертвые страницы при окончании работы процессов или при вызове `exec()`.
+В этом случае количество потомков **B** становится равным одному и все обращения к **B** теперь выполняются через **C1**. Это означает, что **B** и **C1** могут быть объединены. Все страницы в **B**, которые также существуют и в **C1**, во время объединения из** B** удаляются. Таким образом, хотя оптимизация на предыдущем шаге может не делаться, мы можем восстановить мертвые страницы при окончании работы процессов или при вызове `exec()`.
 
-Такая модель создает некоторое количество потенциальных проблем. Первая, с которой вы можете столкнуться, заключается в сравнительно большой последовательности уровней объектов VM, на сканирование которых тратится время и память. Большое количество уровней может возникнуть, когда процессы разветвляются, а затем разветвляются ещё раз (как порожденные, так и порождающие). Вторая проблема заключается в том, что вы можете столкнуться 
 с мертвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем последнем примере если как р
одитель, так и потомок изменяют одну и ту же страницу, они оба получают собственные копии страницы, а исходная страница в B становится никому не доступной. такая страница в B может быть высвобождена.
+Такая модель создает некоторое количество потенциальных проблем. Первая, с которой вы можете столкнуться, заключается в сравнительно большой последовательности уровней объектов VM, на сканирование которых тратится время и память. Большое количество уровней может возникнуть, когда процессы разветвляются, а затем разветвляются ещё раз (как порожденные, так и порождающие). Вторая проблема заключается в том, что вы можете столкнуться 
 с мертвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем последнем примере если как р
одитель, так и потомок изменяют одну и ту же страницу, они оба получают собственные копии страницы, а исходная страница на уровне **B** становится никому не доступной. Такая страница в **B** может быть высвобождена.
 
-FreeBSD решает проблему с глубиной вложенности с помощью приема оптимизации, который называется "All Shadowed Case". Этот случай возникает, если в C1 либо C2 возникает столько случаев копирования страниц при записи, что они полностью закрывают все страницы в B. Допустим, что такое произошло в C1. C1 может теперь полностью заменить B, так что вместо цепочек C1->B->A и C2->B->A мы теперь имеем цепочки C1->A и C2->B->A. Но посмотрите, что получается-теперь B имеет только
  одну ссылку (C2), так что мы можем объединить B и C2. В конечном итоге B будет полностью удален и мы имеем цеÐ
¿Ð¾Ñ‡ÐºÐ¸ C1->A и C2->A. Часто B будет содержать большое количество страниц, и ни C1, ни C2 не смогут полностью их заменить. Если мы снова породим процесс и создадим набор уровней D, при этом, однако, более вероятно, что один из уровней D постепенно сможет полностью заместить гораздо меньший набор данных, представленный C1 и C2. Та же самая оптимизация будет работать в любой точке графа и главным результатом этого является то, что даже на сильно загруже
 нной машине с множеством порождаемых процессов стеки объектов VM не часто бывают глубже четырёх уровнеÐ
¹. Это так как для порождающего, так и для порожденного процессов, и остаётся в силе как в случае, когда ветвление делает родитель, так и в случае, когда ветвление выполняет потомок.
+FreeBSD решает проблему с глубиной вложенности с помощью приёма оптимизации, который называется "All Shadowed Case". Этот случай возникает, если в **C1** либо *C2* происходит столько случаев копирования страниц при записи, что они полностью перекрывают все страницы в *B*. Допустим, что такое произошло в *C1*. Уровень *C1* может теперь полностью пропускать уровень *B*, так что вместо цепочек *C1* -> *B* -> *A* и *C2* -> *B* -> *A* мы теперь имеем цепочки *C1* -> *A* и *C2* -> *B* -> *A*. НÐ
 ¾ посмотрите, что получается — теперь *B* имеет только одну ссылку (*C2*), так что мы можем объединить *B* и *C2*
. В конечном итоге *B* будет полностью удалён, и мы получим цепочки *C1*-> *A* и *C2*-> *A*. Часто *B* будет содержать большое количество страниц, и ни *C1*, ни *C2* не смогут полностью его заменить. Если мы снова породим процесс и создадим набор уровней *D*, при этом, однако, более вероятно, что один из уровней *D* постепенно сможет полностью заместить гораздо меньший набор данных, представленный *C1* и *C2*. Та же самая оптимизация работает в любой точке графа
  и её главным результатом является то, что даже на сильно загруженной машине с множеством порождаемых п
роцессов стеки объектов VM не часто бывают глубже четырёх уровней. Это верно как для порождающего, так и для порождённого процессов, и остаётся справедливым как в случае, когда ветвление выполняет родитель, так и в случае, когда ветвление выполняет его потомок.
 
-Проблема с мертвой страницей все ещё имеет место, когда C1 или C2 не полностью перекрывают B. Из-за других применяемых нами методов оптимизации этот случай не представляет большой проблемы и мы просто позволяем таким страницам существовать. Если система испытывает нехватку оперативной памяти, она выполняет их выгрузку в область подкачки, что занимает некоторое пространство в области подкачки, но это все.
+Проблема с мертвой страницей все ещё имеет место, когда *C1* или *C2* не полностью перекрывают *B*. Из-за других применяемых нами методов оптимизации этот случай не представляет большой проблемы и мы просто позволяем таким страницам существовать. Если система испытывает нехватку оперативной памяти, она выполняет их выгрузку в область подкачки, что занимает некоторое пространство в области подкачки, но это всё.
 
-Преимущество модели VM-объектов заключается в очень быстром выполнении функции `fork()`, так как при этом не выполняется реального копирования данных. Минусом этого подхода является то, что вы можете построить сравнительно сложную иерархию объектов VM, которая несколько замедляет обработку ситуаций отсутствия страниц памяти, и к тому же тратится память на управление структурами объектов VM. Приемы оптимизации, применяемые во FreeBSD, позво
 ляют снизить значимость этих проблем до степени, когда их можно без особых потерь игнорировать.
+Преимущество модели VM-объектов заключается в очень быстром выполнении функции `fork()`, так как при этом не выполняется реального копирования данных. Минусом этого подхода является то, что вы можете построить сравнительно сложную иерархию объектов VM, которая несколько замедляет обработку ситуаций отсутствия страниц памяти, и к тому же тратится память на управление структурами объектов VM. Приёмы оптимизации, применяемые во FreeBSD, позво
 ляют снизить значимость этих проблем до степени, когда их можно без особых потерь игнорировать.
 
 [[swap-layers]]
 == Уровни области подкачки
 
-Страницы с собственными данными первоначально являются страницами, копируемыми при записи или заполняемыми нулями. Когда выполняется изменение, и, соответственно, копирование, начальное хранилище объекта (обычно файл) не может больше использоваться для хранения копии страницы, когда VM-системе нужно использовать её повторно для других целей. В этот момент на помощь приходит область подкачки. Область подкачки выделяется для органи
 зации хранилища памяти, которая иначе не может быть доступна. FreeBSD создает структуру управления подкачÐ
ºÐ¾Ð¹ для объекта VM, только когда это действительно нужно. Однако структура управления подкачкой исторически имела некоторые проблемы:
+Страницы с собственными данными первоначально являются страницами, копируемыми-при-записи или заполняемыми нулями. Когда выполняется изменение, и, соответственно, копирование, начальное хранилище объекта (обычно файл) не может больше использоваться для хранения копии страницы, когда VM-системе нужно использовать её повторно для других целей. В этот момент на помощь приходит область подкачки. Область подкачки выделяется для органи
 зации хранилища памяти, которая иначе не может быть доступна. FreeBSD создает структуру управления подкачÐ
ºÐ¾Ð¹ для объекта VM, только когда это действительно нужно. Однако структура управления подкачкой исторически имела некоторые проблемы:
 
-* Во FreeBSD 3.X в структуре управления областью подкачки предварительно выделяется массив, который представляет целый объект, требующий хранения в области подкачки-даже если только несколько страниц этого объекта хранятся в области подкачки. Это создает проблему фрагментации памяти ядра в случае, когда в память отображаются большие объекты или когда ветвятся процессы, занимающие большой объём памяти при работе (RSS).
-* Также для отслеживания памяти подкачки в памяти ядра поддерживается "список дыр", и он также несколько фрагментирован. Так как "список дыр" является последовательным списком, то производительность при распределении и высвобождении памяти в области подкачки неоптимально и её сложность зависит от количества страниц как O(n).
-* Также в процессе высвобождения памяти в области подкачки требуется выделение памяти в ядре, и это приводит к проблемам блокировки при недостатке памяти.
+* Во FreeBSD 3.X в структуре управления областью подкачки предварительно выделяется массив, который представляет целый объект, требующий хранения в области подкачки — даже если только несколько страниц этого объекта хранятся в области подкачки. Это создает проблему фрагментации памяти ядра в случае, когда в память отображаются большие объекты или когда ветвятся процессы, занимающие большой объём памяти при работе (RSS).
+* Также для отслеживания памяти подкачки в памяти ядра поддерживается "список дыр", и он также несколько фрагментирован. Так как "список дыр" является последовательным списком, то производительность при распределении и высвобождении памяти в области подкачки неоптимальна, и её сложность зависит от количества страниц как O(n).
+* Также в процессе высвобождения памяти из области подкачки требуется выделение памяти в ядре, и это приводит к проблемам блокировки при недостатке памяти.
 * Проблема ещё более обостряется из-за дыр, создаваемых по чередующемуся алгоритму.
 * Кроме того, список распределения блоков в области подкачки легко оказывается фрагментированным, что приводит к распределению непоследовательных областей.
-* Память ядра также должна распределяться по ходу работы для дополнительных структур по управлению областью подкачки при выгрузке страниц памяти в эту область.
+* Память ядра также должна выделяться на лету для дополнительных структур управления подкачкой при выгрузке страниц в область подкачки.
 
 Очевидно, что мест для усовершенствований предостаточно. Во FreeBSD 4.X подсистема управления областью подкачки была полностью переписана мною:
 
 * Структуры управления областью подкачки распределяются при помощи хэш-таблицы, а не через линейный массив, что даёт им фиксированный размер при распределении и работу с гораздо меньшими структурами.
 * Вместо того, чтобы использовать однонаправленный связный список для отслеживания выделения пространства в области подкачки, теперь используется побитовая карта блоков области подкачки, выполненная в основном в виде древовидной структуры с информацией о свободном пространстве, находящейся в узлах структур. Это приводит к тому, что выделение и высвобождение памяти в области подкачки становится операцией сложности O(1).
-* Все дерево также распределяется заранее для того, чтобы избежать распределения памяти ядра во время операций с областью подкачки при критически малом объёме свободной памяти. В конце концов, система обращается к области подкачки при нехватке памяти, так что мы должны избежать распределения памяти ядра в такие моменты для избежания потенциальных блокировок.
+* Всё дерево также распределяется заранее для того, чтобы избежать распределения памяти ядра во время операций с областью подкачки при критически малом объёме свободной памяти. В конце концов, система обращается к области подкачки при нехватке памяти, так что мы должны избежать распределения памяти ядра в такие моменты для избежания потенциальных блокировок.
 * Для уменьшения фрагментации дерево может распределять большой последовательный кусок за раз, пропуская меньшие фрагментированные области.
 
 Я не сделал последний шаг к заведению "указателя на распределение", который будет передвигаться по участку области подкачки при выделении памяти для обеспечения в будущем распределения последовательных участков, или по крайней мере местоположения ссылки, но я убежден, что это может быть сделано.
@@ -129,7 +129,7 @@ FreeBSD решает проблему с глубиной вложенности
 
 Так как система VM использует всю доступную память для кэширования диска, то обычно действительно незанятых страниц очень мало. Система VM зависит от того, как она точно выбирает незанятые страницы для повторного использования для новых распределений. Оптимальный выбор страниц для высвобождения, возможно, является самой важной функцией любой VM-системы, из тех, что она может выполнять, потому что при неправильном выборе система VM вынÑ
 ƒÐ¶Ð´ÐµÐ½Ð° будет запрашивать страницы с диска, значительно снижая производительность всей системы.
 
-Какую дополнительную нагрузку мы может выделить в критическом пути для избежания высвобождения не той страницы? Каждый неправильный выбор будет стоить нам сотни тысяч тактов работы центрального процессора и заметное замедление работы затронутых процессов, так что мы должны смириться со значительными издержками для того, чтобы была заведомо выбрана правильная страница. Вот почему FreeBSD превосходит другие системы в производительн
 ости при нехватке ресурсов памяти.
+Какую дополнительную нагрузку мы может выделить в критическом пути для избежания высвобождения не той страницы? Каждый неправильный выбор будет стоить нам сотни тысяч тактов работы центрального процессора и заметное замедление работы затронутых процессов, так что мы должны смириться со значительными издержками для того, чтобы была выбрана правильная страница. Вот почему FreeBSD превосходит другие системы в производительности при Ð
 ½ÐµÑ…ватке ресурсов памяти.
 
 Алгоритм определения свободной страницы написан на основе истории использования страниц памяти. Для получения этой истории система использует возможности бита использования памяти, которые имеются в большинстве аппаратных таблицах страниц памяти.
 
@@ -137,7 +137,7 @@ FreeBSD решает проблему с глубиной вложенности
 
 Для тех платформ, что не имеют этой возможности, система эмулирует этот бит. Она снимает отображение или защищает страницу, что приводит к ошибке доступа к странице, если к странице выполняется повторное обращение. При возникновении этой ошибки система просто помечает страницу как используемую и снимает защиту со страницы, так что она может использоваться. Хотя использование такого приема только для определения использования стра
 ницы весьма накладно, это выгоднее, чем повторно использовать страницу для других целей и обнаружить, ч
то она снова нужна процессу и подгружать её с диска.
 
-FreeBSD использует несколько очередей страниц для обновления выбора страниц для повторного использования, а также для определения того, когда же грязные страницы должны быть сброшены в хранилище. Так как таблицы страниц во FreeBSD являются динамическими объектами, практически ничего не стоит вырезать страницу из адресного пространства любого использующего её процесса. После того, как подходящая страница, на основе счетчика использован
 ия, выбрана, именно это и выполняется. Система должна отличать между чистыми страницами, которые теорет
ически могут быть высвобождены в любое время, и грязными страницами, которые сначала должны быть переписаны в хранилище перед тем, как их можно будет использовать повторно. После нахождения подходящей страницы она перемещается в неактивную очередь, если она является грязной, или в очередь кэша, если она чистая. Отдельный алгоритм, основывающийся на отношении количества грязных страниц к чистым, определяет, когда грязные страницы в Ð
 ½ÐµÐ°ÐºÑ‚ивной очереди должны быть сброшены на диск. Когда это выполнится, сброшенные страницы перемещаютс
я из неактивной очереди в очередь кэша. В этот момент страницы в очереди кэша могут быть повторно активизированы VM со сравнительно малыми накладными расходами. Однако страницы в очереди кэша предполагается "высвобождать немедленно" и повторно использовать в LRU-порядке (меньше всего используемый), когда системе потребуется выделение дополнительной памяти.
+FreeBSD использует несколько очередей страниц для обновления выбора страниц для повторного использования, а также для определения того, когда же грязные страницы должны быть сброшены в хранилище. Так как таблицы страниц во FreeBSD являются динамическими объектами, практически ничего не стоит вырезать страницу из адресного пространства любого использующего её процесса. После того, как подходящая страница, на основе счетчика использован
 ия, выбрана, именно это и выполняется. Система должна различать чистые страницы, которые теоретически м
огут быть высвобождены в любое время, и грязные страницы, которые сначала должны быть переписаны в хранилище перед тем, как их можно будет использовать повторно. После нахождения подходящей страницы она перемещается в неактивную очередь, если она является грязной, или в очередь кэша, если она чистая. Отдельный алгоритм, основывающийся на отношении количества грязных страниц к чистым, определяет, когда грязные страницы в неактивной Ð
 ¾Ñ‡ÐµÑ€ÐµÐ´Ð¸ должны быть сброшены на диск. Когда это выполнится, сброшенные страницы перемещаются из неактиÐ
²Ð½Ð¾Ð¹ очереди в очередь кэша. В этот момент страницы в очереди кэша могут быть повторно активизированы VM со сравнительно малыми накладными расходами. Однако страницы в очереди кэша предполагается "высвобождать немедленно" и повторно использовать в LRU-порядке (меньше всего используемый), когда системе потребуется выделение дополнительной памяти.
 
 Стоит отметить, что во FreeBSD VM-система пытается разделить чистые и грязные страницы во избежание срочной необходимости в ненужных сбросах грязных страниц (что отражается на пропускной способности ввода/вывода) и не перемещает беспричинно страницы между разными очередями, когда подсистема управления памятью не испытывает нехватку ресурсов. Вот почему вы можете видеть, что при выполнении команды `systat -vm` в некоторых системах значение
  счетчика очереди кэша мало, а счетчик активной очереди большой. При повышении нагрузки на VM-систему онÐ
° прилагает большие усилия на поддержку различных очередей страниц в соотношениях, которые являются наиболее эффективными.
 
@@ -146,7 +146,7 @@ FreeBSD использует несколько очередей страниц
 [[prefault-optimizations]]
 == Оптимизация ошибок доступа к страницам и их обнуления
 
-Полагая, что ошибка доступа к странице памяти в VM не является операцией с большими накладными расходами, если страница уже находится в основной памяти и может быть просто отображена в адресное пространство процесса, может оказаться, что это станет весьма накладно, если их будет оказываться регулярно много. Хорошим примером этой ситуации является запуск таких программ, как man:ls[1] или man:ps[1], снова и снова. Если бинарный файл программы о
 тображен в память, но не отображен в таблицу страниц, то все страницы, к которым обращалась программа, оÐ
ºÐ°Ð¶ÑƒÑ‚ся недоступными при каждом запуске программы. Это не так уж необходимо, если эти страницы уже присутствуют в кэше VM, так что FreeBSD будет пытаться восстанавливать таблицы страниц процесса из тех страниц, что уже располагаются в VM-кэше. Однако во FreeBSD пока не выполняется предварительное копирование при записи определённых страниц при выполнении вызова exec. Например, если вы запускаете программу man:ls[1] одновременно с работающей `vmstat 1`,
  то заметите, что она всегда выдает некоторое количество ошибок доступа к страницам, даже когда вы запуÑ
ÐºÐ°ÐµÑ‚е её снова и снова. Это ошибки заполнения нулями, а не ошибки кода программы (которые уже были обработаны). Предварительное копирование страниц при выполнении вызовов exec или fork находятся в области, требующей более тщательного изучения.
+Полагая, что ошибка доступа к странице памяти в VM не является операцией с большими накладными расходами, если страница уже находится в основной памяти и может быть просто отображена в адресное пространство процесса, может оказаться, что это станет весьма накладно, если их будет оказываться регулярно много. Хорошим примером этой ситуации является запуск таких программ, как man:ls[1] или man:ps[1], снова и снова. Если бинарный файл программы о
 тображен в память, но не отображен в таблицу страниц, то все страницы, к которым обращалась программа, оÐ
ºÐ°Ð¶ÑƒÑ‚ся недоступными при каждом запуске программы. Это не так уж необходимо, если эти страницы уже присутствуют в кэше VM, так что FreeBSD будет пытаться восстанавливать таблицы страниц процесса из тех страниц, что уже располагаются в VM-кэше. Однако во FreeBSD пока не выполняется предварительное копирование при записи определённых страниц при выполнении вызова exec. Например, если вы запускаете программу man:ls[1] одновременно с работающей `vmstat 1`,
  то заметите, что она всегда выдает некоторое количество ошибок доступа к страницам, даже когда вы запуÑ
ÐºÐ°ÐµÑ‚е её снова и снова. Эти ошибки относятся к типу zero-fill и не связаны с доступом к коду программы (который уже был предварительно отображён). Предварительное копирование страниц при выполнении вызовов exec или fork находятся в области, требующей более тщательного изучения.
 
 Большой процент ошибок доступа к страницам, относится к ошибкам при заполнении нулями. Вы можете обычно видеть это, просматривая вывод команды `vmstat -s`. Это происходит, когда процесс обращается к страницам в своей области BSS. Область BSS предполагается изначально заполненной нулями, но VM-система не заботится о выделении памяти до тех пор, пока процесс реально к ней не обратится. При возникновении ошибки VM-система должна не только выделиÑ
 ‚ÑŒ новую страницу, но и заполнить её нулями. Для оптимизации операции по заполнению нулями в системе VM иÐ
¼ÐµÐµÑ‚ся возможность предварительно обнулять страницы и помечать их, и запрашивать уже обнуленные страницы при возникновении ошибок заполнения нулями. Предварительное заполнение нулями происходит, когда CPU простаивает, однако количество страниц, которые система заранее заполняет нулями, ограничено, для того, чтобы не переполнить кэши памяти. Это прекрасный пример добавления сложности в VM-систему ради оптимизации критического пути.
 
 
@@ -187,7 +187,7 @@ FreeBSD 3.X использует "последовательный список
 
 Это означает, что FreeBSD не будет очень сильно стараться над отделением грязных страниц (неактивная очередь) от чистых страниц (очередь кэша), когда система не находится под нагрузкой, и не будет деактивировать страницы (активная очередь -> неактивная очередь), когда система не нагружена, даже если они не используются.
 
-=== В примере с / vmstat 1 могут ли некоторые ошибки доступа к странице быть ошибками страниц данных (COW из выполнимого файла в приватные страницы)? То есть я полагаю, что ошибки доступа к страницам являются частично ошибками при заполнении нулями, а частично данных программы. Или вы гарантируете, что FreeBSD выполняет предварительно COW для данных программы?
+=== В примере с man:ls(1) и `vmstat 1` выше могут ли некоторые ошибки доступа к странице быть ошибками страниц данных (COW из выполнимого файла в приватные страницы)? То есть я полагаю, что ошибки доступа к страницам являются частично ошибками при заполнении нулями, а частично данных программы. Или вы гарантируете, что FreeBSD выполняет предварительно COW для данных программы?
 
 Ошибка COW может быть ошибкой при заполнении нулями или данных программы. Механизм в любом случае один и тот же, потому что хранилище данных программы уже в кэше. Я на самом деле не рад ни тому, ни другому. FreeBSD не выполняет предварительное COW данных программы и заполнение нулями, но она _выполняет_ предварительно отображение страниц, которые имеются в её кэше.
 
diff --git a/documentation/content/ru/articles/vm-design/_index.po b/documentation/content/ru/articles/vm-design/_index.po
index 5127516f19..adf0052a38 100644
--- a/documentation/content/ru/articles/vm-design/_index.po
+++ b/documentation/content/ru/articles/vm-design/_index.po
@@ -6,7 +6,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: FreeBSD Documentation VERSION\n"
 "POT-Creation-Date: 2025-06-29 21:20+0100\n"
-"PO-Revision-Date: 2026-03-08 09:11+0000\n"
+"PO-Revision-Date: 2026-03-23 04:45+0000\n"
 "Last-Translator: Vladlen Popolitov <[email protected]>\n"
 "Language-Team: Russian <https://translate-dev.freebsd.org/projects/"
 "documentation/articlesvm-design_index/ru/>\n"
@@ -140,8 +140,8 @@ msgstr ""
 "Это важное отличие, которое, к сожалению, не всеми понимается. Самой большой "
 "ошибкой, которую может допустить программист, является игнорирование "
 "истории, и это именно та ошибка, которую сделали многие другие современные "
-"операционные системы. Самым ярки примером здесь является Windows NT(R), и "
-"последствия ужасны. Linux также в некоторой степени совершил эту ошибку-"
+"операционные системы. Самым ярким примером здесь является Windows NT(R), и "
+"последствия ужасны. Linux также в некоторой степени совершил эту ошибку — "
 "достаточно, чтобы мы, люди BSD, по крайней мере по разу отпустили по этому "
 "поводу шутку. Проблема Linux заключается просто в отсутствии опыта и истории "
 "для сравнения идей, проблема, которая легко и быстро решается сообществом "
@@ -246,15 +246,15 @@ msgstr ""
 "VM, содержащее несколько типов объектов памяти. Эти объекты имеют различные "
 "характеристики. Код программы и её данные являются единым файлом, "
 "отображаемым в память (это выполняющийся двоичный файл), однако код "
-"программы доступен только для чтения, когда как данные программы размещаются "
+"программы доступен только для чтения, тогда как данные программы размещаются "
 "в режиме копирования-при-записи. BSS программы представляет собой всего лишь "
 "выделенную область памяти, заполненную, если это требовалось, нулями, что "
 "называется обнулением страниц памяти по требованию. Отдельные файлы могут "
 "также отображаться в адресное пространство, именно так работают динамические "
 "библиотеки. Такие отображения требуют изменений, чтобы оставаться "
-"принадлежащими процессу, который их выполнил. Системный вызов fork добавляет "
-"переводит проблему управления VM полностью в новую плоскость, вдобавок к уже "
-"имеющимся сложностям."
+"принадлежащими процессу, который их выполнил. Системный вызов fork переводит "
+"проблему управления VM полностью в новую плоскость, вдобавок к уже имеющимся "
+"сложностям."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:111
@@ -273,8 +273,8 @@ msgstr ""
 "Иллюстрирует сложность страница данных двоичной программы (которая является "
 "страницей копируемой-при-записи). Двоичная программа содержит секцию "
 "предварительно инициализированных данных, которая первоначально отображается "
-"непосредственно из файла программы. Когда программа загружается в Vm-"
-"пространство процесса, эта область сначала отображается в память и "
+"непосредственно из файла программы. Когда программа загружается в "
+"виртуальную память процесса, эта область сначала отображается в память и "
 "поддерживается бинарным файлом программы, позволяя VM-системе освобождать/"
 "повторно использовать страницу, а потом загружать её снова из бинарного "
 "файла. Однако в момент, когда процесс изменяет эти данные, VM-система должна "
@@ -303,16 +303,16 @@ msgstr ""
 "память, становится гораздо более сложным предметом. Данные могут "
 "модифицироваться постранично, когда как отображение файла выполняется для "
 "многих страниц за раз. Сложность ещё более увеличивается, когда процесс "
-"выполняет вызов fork. При этом порождаются два процесса-каждый со с "
-"собственным адресным пространством, включающим все изменения, выполненные "
-"исходным процессом до вызова функции `fork()`. Было бы глупо для VM-системы "
-"делать полную копию данных во время вызова `fork()`, так как весьма "
-"вероятно, что один из двух процессов будет нужен только для чтения из той "
-"страницы, что позволяет использование исходной страницы. То, что было "
-"страницей, принадлежащей только процессу, сделается снова страницей, "
-"копируемой при записи, так как каждый из процессов (и родитель, и потомок) "
-"полагают, что их собственные изменения после разветвления будут принадлежать "
-"только им, и не затронут родственный процесс."
+"выполняет вызов fork. При этом порождаются два процесса-каждый с собственным "
+"адресным пространством, включающим все изменения, выполненные исходным "
+"процессом до вызова функции `fork()`. Было бы глупо для VM-системы делать "
+"полную копию данных во время вызова `fork()`, так как весьма вероятно, что "
+"один из двух процессов будет нужен только для чтения из той страницы, что "
+"позволяет использование исходной страницы. То, что было страницей, "
+"принадлежащей только процессу, сделается снова страницей, копируемой при "
+"записи, так как каждый из процессов (и родитель, и потомок) полагают, что их "
+"собственные изменения после разветвления будут принадлежать только им, и не "
+"затронут родственный процесс."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:127
@@ -338,7 +338,8 @@ msgstr ""
 "Это можно показать на простом примере. Функция `fork()` является общей "
 "операцией для всех систем *BSD, так что в этом примере будет рассматриваться "
 "программа, которая запускается, а затем разветвляется. Когда процесс "
-"запускается, VM-система создает некоторый уровень объектов, обозначим его A:"
+"запускается, VM-система создает некоторый уровень объектов, обозначим его "
+"**A**:"
 
 #. type: Positional ($1) AttributeList argument for macro 'image'
 #: documentation/content/en/articles/vm-design/_index.adoc:128
@@ -361,11 +362,11 @@ msgid ""
 "The VM system therefore creates a second layer, B, that will be physically "
 "backed by swap space:"
 msgstr ""
-"A соответствует файлу-по необходимости страницы памяти могут высвобождаться "
-"и подгружаться с носителя файла. Подгрузка с диска может потребоваться "
-"программе, однако на самом деле мы не хотим, чтобы она записывалась обратно "
-"в файл. Поэтому VM-система создает второй уровень, B, который физически "
-"поддерживается дисковым пространством подкачки:"
+"На рисунке *A* соответствует файлу — по необходимости страницы памяти могут "
+"высвобождаться и подгружаться с носителя файла. Подгрузка с диска может "
+"потребоваться программе, однако на самом деле мы не хотим, чтобы она "
+"записывалась обратно в файл. Поэтому VM-система создает второй уровень, **B**"
+", который физически поддерживается дисковым пространством подкачки:"
 
 #. type: Target for macro image
 #: documentation/content/en/articles/vm-design/_index.adoc:134
@@ -381,11 +382,12 @@ msgid ""
 "swap device.  When the program forks, the VM system creates two new object "
 "layers-C1 for the parent, and C2 for the child-that rest on top of B:"
 msgstr ""
-"При первой записи в страницу после выполнения этой операции, в B создается "
-"новая страница, содержимое которой берется из A. Все страницы в B могут "
-"сбрасываться и считываться из устройства подкачки. Когда программа ветвится, "
-"VM-система создает два новых уровня объектов-C1 для порождающего процесса и "
-"C2 для порожденного-они располагаются поверх B:"
+"При первой записи в страницу после выполнения этой операции в **B** "
+"создается новая страница, содержимое которой берётся из **A**. Все страницы "
+"в **B** могут сбрасываться и считываться из устройства подкачки. Когда "
+"программа ветвится, VM-система создает два новых уровня объектов — **C1** "
+"для порождающего процесса и **C2** для порожденного — они располагаются "
+"поверх **B**:"
 
 #. type: Target for macro image
 #: documentation/content/en/articles/vm-design/_index.adoc:140
@@ -409,19 +411,20 @@ msgid ""
 "replaced by a new address space representing a new file.  In this case, the "
 "C2 layer is destroyed:"
 msgstr ""
-"В этом случае, допустим, что страница в B была изменена начальным "
-"родительским процессом. В процессе возникнет ситуация копирования при записи "
-"и страница скопируется в C1, при этом исходная страница останется в B "
-"нетронутой. Теперь допустим, что та же самая страница в B изменяется "
-"порожденным процессом. В процессе возникнет ситуация копирования при записи "
-"и страница скопируется в C2. Исходная страница в B теперь полностью скрыта, "
-"так как и C1, и C2 имеют копии, а B теоретически может быть уничтожена, если "
-"она не представляет собой \"реального\" файла). Однако такую оптимизацию не "
-"так уж просто осуществить, потому что она делается на уровне мелких единиц. "
-"Во FreeBSD такая оптимизация не выполняется. Теперь положим (а это часто "
+"В этом случае, допустим, что страница в **B** была изменена начальным "
+"родительским процессом. В процессе возникнет ситуация копирования при "
+"записи, и страница скопируется в **C1**, при этом исходная страница "
+"останется в **B** нетронутой. Теперь допустим, что та же самая страница в "
+"**B** изменяется порожденным процессом. В процессе возникнет ситуация "
+"копирования при записи и страница скопируется в **C2**. Исходная страница в "
+"**B** теперь полностью скрыта, так как и **C1**, и **C2** имеют копии, а "
+"уровень **B** теоретически может быть уничтожен, если он не представляет "
+"собой \"реального\" файла). Однако такую оптимизацию не так уж просто "
+"осуществить, потому что это надо делать на уровне слишком мелких единиц. Во "
+"FreeBSD такая оптимизация не выполняется. Теперь положим (а это часто "
 "случается), что порожденный процесс выполняет вызов `exec()`. Его текущее "
 "адресное пространство обычно заменяется новым адресным пространством, "
-"представляющим новый файл. В этом случае уровень C2 уничтожается:"
+"представляющим новый файл. В этом случае уровень **C2** уничтожается:"
 
 #. type: Target for macro image
 #: documentation/content/en/articles/vm-design/_index.adoc:152
@@ -439,12 +442,12 @@ msgid ""
 "be made, we can recover the dead pages when either of the processes exit or "
 "`exec()`."
 msgstr ""
-"В этом случае количество потомков B становится равным одному и все обращения "
-"к B теперь выполняются через C1. Это означает, что B и C1 могут быть "
-"объединены. Все страницы в B, которые также существуют и в C1, во время "
-"объединения из B удаляются. Таким образом, хотя оптимизация на предыдущем "
-"шаге может не делаться, мы можем восстановить мертвые страницы при окончании "
-"работы процессов или при вызове `exec()`."
+"В этом случае количество потомков **B** становится равным одному и все "
+"обращения к **B** теперь выполняются через **C1**. Это означает, что **B** и "
+"**C1** могут быть объединены. Все страницы в **B**, которые также существуют "
+"и в **C1**, во время объединения из** B** удаляются. Таким образом, хотя "
+"оптимизация на предыдущем шаге может не делаться, мы можем восстановить "
+"мертвые страницы при окончании работы процессов или при вызове `exec()`."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:165
@@ -467,8 +470,9 @@ msgstr ""
 "порождающие). Вторая проблема заключается в том, что вы можете столкнуться с "
 "мертвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем "
 "последнем примере если как родитель, так и потомок изменяют одну и ту же "
-"страницу, они оба получают собственные копии страницы, а исходная страница в "
-"B становится никому не доступной. такая страница в B может быть высвобождена."
+"страницу, они оба получают собственные копии страницы, а исходная страница "
+"на уровне **B** становится никому не доступной. Такая страница в **B** может "
+"быть высвобождена."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:176
@@ -490,24 +494,26 @@ msgid ""
 "true of both the parent and the children and true whether the parent is "
 "doing the forking or whether the children cascade forks."
 msgstr ""
-"FreeBSD решает проблему с глубиной вложенности с помощью приема оптимизации, "
-"который называется \"All Shadowed Case\". Этот случай возникает, если в C1 "
-"либо C2 возникает столько случаев копирования страниц при записи, что они "
-"полностью закрывают все страницы в B. Допустим, что такое произошло в C1. C1 "
-"может теперь полностью заменить B, так что вместо цепочек C1->B->A и C2->B-"
-">A мы теперь имеем цепочки C1->A и C2->B->A. Но посмотрите, что получается-"
-"теперь B имеет только одну ссылку (C2), так что мы можем объединить B и C2. "
-"В конечном итоге B будет полностью удален и мы имеем цепочки C1->A и C2->A. "
-"Часто B будет содержать большое количество страниц, и ни C1, ни C2 не смогут "
-"полностью их заменить. Если мы снова породим процесс и создадим набор "
-"уровней D, при этом, однако, более вероятно, что один из уровней D "
-"постепенно сможет полностью заместить гораздо меньший набор данных, "
-"представленный C1 и C2. Та же самая оптимизация будет работать в любой точке "
-"графа и главным результатом этого является то, что даже на сильно "
+"FreeBSD решает проблему с глубиной вложенности с помощью приёма оптимизации, "
+"который называется \"All Shadowed Case\". Этот случай возникает, если в "
+"**C1** либо *C2* происходит столько случаев копирования страниц при записи, "
+"что они полностью перекрывают все страницы в *B*. Допустим, что такое "
+"произошло в *C1*. Уровень *C1* может теперь полностью пропускать уровень *B*"
+", так что вместо цепочек *C1* -> *B* -> *A* и *C2* -> *B* -> *A* мы теперь имеем "
+"цепочки *C1* -> *A* и *C2* -> *B* -> *A*. Но посмотрите, что получается — теперь "
+"*B* имеет только одну ссылку (*C2*), так что мы можем объединить *B* и *C2*. "
+"В конечном итоге *B* будет полностью удалён, и мы получим цепочки *C1* -> *A* и "
+"*C2* -> *A*. Часто *B* будет содержать большое количество страниц, и ни *C1*, ни "
+"*C2* не смогут полностью его заменить. Если мы снова породим процесс и "
+"создадим набор уровней *D*, при этом, однако, более вероятно, что один из "
+"уровней *D* постепенно сможет полностью заместить гораздо меньший набор "
+"данных, представленный *C1* и *C2*. Та же самая оптимизация работает в любой "
+"точке графа и её главным результатом является то, что даже на сильно "
 "загруженной машине с множеством порождаемых процессов стеки объектов VM не "
-"часто бывают глубже четырёх уровней. Это так как для порождающего, так и для "
-"порожденного процессов, и остаётся в силе как в случае, когда ветвление "
-"делает родитель, так и в случае, когда ветвление выполняет потомок."
+"часто бывают глубже четырёх уровней. Это верно как для порождающего, так и "
+"для порождённого процессов, и остаётся справедливым как в случае, когда "
+"ветвление выполняет родитель, так и в случае, когда ветвление выполняет его "
+"потомок."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:180
@@ -518,12 +524,12 @@ msgid ""
 "the system runs low on memory it will swap them out, eating a little swap, "
 "but that is it."
 msgstr ""
-"Проблема с мертвой страницей все ещё имеет место, когда C1 или C2 не "
-"полностью перекрывают B. Из-за других применяемых нами методов оптимизации "
+"Проблема с мертвой страницей все ещё имеет место, когда *C1* или *C2* не "
+"полностью перекрывают *B*. Из-за других применяемых нами методов оптимизации "
 "этот случай не представляет большой проблемы и мы просто позволяем таким "
 "страницам существовать. Если система испытывает нехватку оперативной памяти, "
 "она выполняет их выгрузку в область подкачки, что занимает некоторое "
-"пространство в области подкачки, но это все."
+"пространство в области подкачки, но это всё."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:184
@@ -540,7 +546,7 @@ msgstr ""
 "данных. Минусом этого подхода является то, что вы можете построить "
 "сравнительно сложную иерархию объектов VM, которая несколько замедляет "
 "обработку ситуаций отсутствия страниц памяти, и к тому же тратится память на "
-"управление структурами объектов VM. Приемы оптимизации, применяемые во "
+"управление структурами объектов VM. Приёмы оптимизации, применяемые во "
 "FreeBSD, позволяют снизить значимость этих проблем до степени, когда их "
 "можно без особых потерь игнорировать."
 
@@ -563,7 +569,7 @@ msgid ""
 "structure has had problems historically:"
 msgstr ""
 "Страницы с собственными данными первоначально являются страницами, "
-"копируемыми при записи или заполняемыми нулями. Когда выполняется изменение, "
+"копируемыми-при-записи или заполняемыми нулями. Когда выполняется изменение, "
 "и, соответственно, копирование, начальное хранилище объекта (обычно файл) не "
 "может больше использоваться для хранения копии страницы, когда VM-системе "
 "нужно использовать её повторно для других целей. В этот момент на помощь "
@@ -584,8 +590,8 @@ msgid ""
 msgstr ""
 "Во FreeBSD 3.X в структуре управления областью подкачки предварительно "
 "выделяется массив, который представляет целый объект, требующий хранения в "
-"области подкачки-даже если только несколько страниц этого объекта хранятся в "
-"области подкачки. Это создает проблему фрагментации памяти ядра в случае, "
+"области подкачки — даже если только несколько страниц этого объекта хранятся "
+"в области подкачки. Это создает проблему фрагментации памяти ядра в случае, "
 "когда в память отображаются большие объекты или когда ветвятся процессы, "
 "занимающие большой объём памяти при работе (RSS)."
 
@@ -600,7 +606,7 @@ msgstr ""
 "Также для отслеживания памяти подкачки в памяти ядра поддерживается \"список "
 "дыр\", и он также несколько фрагментирован. Так как \"список дыр\" является "
 "последовательным списком, то производительность при распределении и "
-"высвобождении памяти в области подкачки неоптимально и её сложность зависит "
+"высвобождении памяти в области подкачки неоптимальна, и её сложность зависит "
 "от количества страниц как O(n)."
 
 #. type: Plain text
@@ -609,8 +615,9 @@ msgid ""
 "It requires kernel memory allocations to take place during the swap freeing "
 "process, and that creates low memory deadlock problems."
 msgstr ""
-"Также в процессе высвобождения памяти в области подкачки требуется выделение "
-"памяти в ядре, и это приводит к проблемам блокировки при недостатке памяти."
+"Также в процессе высвобождения памяти из области подкачки требуется "
+"выделение памяти в ядре, и это приводит к проблемам блокировки при "
+"недостатке памяти."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:199
@@ -636,9 +643,8 @@ msgid ""
 "Kernel memory must also be allocated on the fly for additional swap "
 "management structures when a swapout occurs."
 msgstr ""
-"Память ядра также должна распределяться по ходу работы для дополнительных "
-"структур по управлению областью подкачки при выгрузке страниц памяти в эту "
-"область."
+"Память ядра также должна выделяться на лету для дополнительных структур "
+"управления подкачкой при выгрузке страниц в область подкачки."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:204
@@ -682,7 +688,7 @@ msgid ""
 "all, the system tends to swap when it is low on memory so we should avoid "
 "allocating kernel memory at such times to avoid potential deadlocks."
 msgstr ""
-"Все дерево также распределяется заранее для того, чтобы избежать "
+"Всё дерево также распределяется заранее для того, чтобы избежать "
 "распределения памяти ядра во время операций с областью подкачки при "
 "критически малом объёме свободной памяти. В конце концов, система обращается "
 "к области подкачки при нехватке памяти, так что мы должны избежать "
@@ -751,9 +757,9 @@ msgstr ""
 "избежания высвобождения не той страницы? Каждый неправильный выбор будет "
 "стоить нам сотни тысяч тактов работы центрального процессора и заметное "
 "замедление работы затронутых процессов, так что мы должны смириться со "
-"значительными издержками для того, чтобы была заведомо выбрана правильная "
-"страница. Вот почему FreeBSD превосходит другие системы в производительности "
-"при нехватке ресурсов памяти."
+"значительными издержками для того, чтобы была выбрана правильная страница. "
+"Вот почему FreeBSD превосходит другие системы в производительности при "
+"нехватке ресурсов памяти."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:224
@@ -836,20 +842,20 @@ msgstr ""
 "FreeBSD являются динамическими объектами, практически ничего не стоит "
 "вырезать страницу из адресного пространства любого использующего её "
 "процесса. После того, как подходящая страница, на основе счетчика "
-"использования, выбрана, именно это и выполняется. Система должна отличать "
-"между чистыми страницами, которые теоретически могут быть высвобождены в "
-"любое время, и грязными страницами, которые сначала должны быть переписаны в "
-"хранилище перед тем, как их можно будет использовать повторно. После "
-"нахождения подходящей страницы она перемещается в неактивную очередь, если "
-"она является грязной, или в очередь кэша, если она чистая. Отдельный "
-"алгоритм, основывающийся на отношении количества грязных страниц к чистым, "
-"определяет, когда грязные страницы в неактивной очереди должны быть сброшены "
-"на диск. Когда это выполнится, сброшенные страницы перемещаются из "
-"неактивной очереди в очередь кэша. В этот момент страницы в очереди кэша "
-"могут быть повторно активизированы VM со сравнительно малыми накладными "
-"расходами. Однако страницы в очереди кэша предполагается \"высвобождать "
-"немедленно\" и повторно использовать в LRU-порядке (меньше всего "
-"используемый), когда системе потребуется выделение дополнительной памяти."
+"использования, выбрана, именно это и выполняется. Система должна различать "
+"чистые страницы, которые теоретически могут быть высвобождены в любое время, "
+"и грязные страницы, которые сначала должны быть переписаны в хранилище перед "
+"тем, как их можно будет использовать повторно. После нахождения подходящей "
+"страницы она перемещается в неактивную очередь, если она является грязной, "
+"или в очередь кэша, если она чистая. Отдельный алгоритм, основывающийся на "
+"отношении количества грязных страниц к чистым, определяет, когда грязные "
+"страницы в неактивной очереди должны быть сброшены на диск. Когда это "
+"выполнится, сброшенные страницы перемещаются из неактивной очереди в очередь "
+"кэша. В этот момент страницы в очереди кэша могут быть повторно "
+"активизированы VM со сравнительно малыми накладными расходами. Однако "
+"страницы в очереди кэша предполагается \"высвобождать немедленно\" и "
+"повторно использовать в LRU-порядке (меньше всего используемый), когда "
+"системе потребуется выделение дополнительной памяти."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:249
@@ -931,10 +937,11 @@ msgstr ""
 "определённых страниц при выполнении вызова exec. Например, если вы "
 "запускаете программу man:ls[1] одновременно с работающей `vmstat 1`, то "
 "заметите, что она всегда выдает некоторое количество ошибок доступа к "
-"страницам, даже когда вы запускаете её снова и снова. Это ошибки заполнения "
-"нулями, а не ошибки кода программы (которые уже были обработаны). "
-"Предварительное копирование страниц при выполнении вызовов exec или fork "
-"находятся в области, требующей более тщательного изучения."
+"страницам, даже когда вы запускаете её снова и снова. Эти ошибки относятся к "
+"типу zero-fill и не связаны с доступом к коду программы (который уже был "
+"предварительно отображён). Предварительное копирование страниц при "
+"выполнении вызовов exec или fork находятся в области, требующей более "
+"тщательного изучения."
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:274
@@ -1225,11 +1232,11 @@ msgstr ""
 #, no-wrap
 msgid "In man:ls[1] the / vmstat 1 example, would not some of the page faults be data page faults (COW from executable file to private page)? I.e., I would expect the page faults to be some zero-fill and some program data. Or are you implying that FreeBSD does do pre-COW for the program data?"
 msgstr ""
-"В примере с / vmstat 1 могут ли некоторые ошибки доступа к странице быть "
-"ошибками страниц данных (COW из выполнимого файла в приватные страницы)? То "
-"есть я полагаю, что ошибки доступа к страницам являются частично ошибками "
-"при заполнении нулями, а частично данных программы. Или вы гарантируете, что "
-"FreeBSD выполняет предварительно COW для данных программы?"
+"В примере с man:ls(1) и `vmstat 1` выше могут ли некоторые ошибки доступа к "
+"странице быть ошибками страниц данных (COW из выполнимого файла в приватные "
+"страницы)? То есть я полагаю, что ошибки доступа к страницам являются "
+"частично ошибками при заполнении нулями, а частично данных программы. Или вы "
+"гарантируете, что FreeBSD выполняет предварительно COW для данных программы?"
 
 #. type: Plain text
 #: documentation/content/en/articles/vm-design/_index.adoc:345