{"count":1597,"next":null,"previous":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/changes/?format=json&page=31","results":[{"unit":"https://translate-dev.freebsd.org/api/units/1811479/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-03-27T02:50:21.161631Z","action":2,"target":"На рисунке *A* соответствует файлу — по необходимости страницы памяти могут высвобождаться и подгружаться с носителя файла. Подгрузка с диска может потребоваться программе, однако на самом деле мы не хотим, чтобы она записывалась обратно в файл. Поэтому VM-система создает второй уровень, **B**, который физически поддерживается дисковым пространством подкачки:","id":950047,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950047/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811487/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-03-27T02:54:46.222270Z","action":2,"target":"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 не часто бывают глубже четырёх уровней. Это верно как для порождающего, так и для порождённого процессов, и остаётся справедливым как в случае, когда ветвление выполняет родитель, так и в случае, когда ветвление выполняет его потомок.","id":950048,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950048/?format=json"},{"unit":null,"component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":null,"author":null,"timestamp":"2026-03-27T04:45:00.927697Z","action":17,"target":"","id":950060,"action_name":"提交了更改","url":"https://translate-dev.freebsd.org/api/changes/950060/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/824686/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/tr_TR/?format=json","user":"https://translate-dev.freebsd.org/api/users/demirkolak/?format=json","author":"https://translate-dev.freebsd.org/api/users/demirkolak/?format=json","timestamp":"2026-03-29T15:37:58.083768Z","action":5,"target":"Giriş","id":950140,"action_name":"新译文","url":"https://translate-dev.freebsd.org/api/changes/950140/?format=json"},{"unit":null,"component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/tr_TR/?format=json","user":null,"author":null,"timestamp":"2026-03-30T03:11:21.291222Z","action":17,"target":"","id":950268,"action_name":"提交了更改","url":"https://translate-dev.freebsd.org/api/changes/950268/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811473/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:02:46.402230Z","action":27,"target":"Лучше всего начать описание VM-системы FreeBSD с попытки взглянуть на неё с точки зрения пользовательского процесса. Каждый пользовательский процесс имеет единое, принадлежащее только ему и неразрывное адресное пространство VM, содержащее несколько типов объектов памяти. Эти объекты имеют различные характеристики. Код программы и её данные являются единым файлом, отображаемым в память (это выполняющийся двоичный файл), однако код программы доступен только для чтения, тогда как данные программы размещаются в режиме копирования-при-записи. BSS программы представляет собой всего лишь выделенную область памяти, заполненную, если это требовалось, нулями, что называется обнулением страниц памяти по требованию. Отдельные файлы могут также отображаться в адресное пространство, именно так работают динамические библиотеки. Такие отображения требуют изменений, чтобы оставаться принадлежащими процессу, который их выполнил. Системный вызов fork переводит проблему управления VM полностью в новую плоскость, вдобавок к уже имеющимся сложностям.","id":950469,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950469/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811476/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:08:58.597853Z","action":27,"target":"FreeBSD управляет всем этим при помощи многоуровневой модели VM-объектов. Исходный файл с двоичной программой переносится на самый нижний уровень объектов VM. Уровень страниц, копируемых при записи, находится выше него, и хранит те страницы, которые были скопированы из исходного файла. Если программа модифицирует страницы данных, относящиеся к исходному файлу, то система VM обнаруживает это и переносит копию этой страницы на более высокий уровень. Когда процесс разветвляется, добавляются новые уровни VM-объектов. Это можно показать на простом примере. Функция `fork()` является общей операцией для всех систем *BSD, так что в этом примере будет рассматриваться программа, которая запускается, а затем разветвляется. Когда процесс запускается, VM-система создаёт некоторый уровень объектов, обозначим его **A**:","id":950599,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950599/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811479/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:08:58.611254Z","action":27,"target":"На рисунке *A* соответствует файлу — по необходимости страницы памяти могут высвобождаться и подгружаться с носителя файла. Подгрузка с диска может потребоваться программе, однако на самом деле мы не хотим, чтобы она записывалась обратно в файл. Поэтому VM-система создаёт второй уровень, **B**, который физически поддерживается дисковым пространством подкачки:","id":950600,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950600/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811481/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:08:58.624262Z","action":27,"target":"При первой записи в страницу после выполнения этой операции в **B** создаётся новая страница, содержимое которой берётся из **A**. Все страницы в **B** могут сбрасываться и считываться из устройства подкачки. Когда программа ветвится, VM-система создаёт два новых уровня объектов — **C1** для порождающего процесса и **C2** для порожденного — они располагаются поверх **B**:","id":950601,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950601/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811486/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:08:58.637455Z","action":27,"target":"Такая модель создаёт некоторое количество потенциальных проблем. Первая, с которой вы можете столкнуться, заключается в сравнительно большой последовательности уровней объектов VM, на сканирование которых тратится время и память. Большое количество уровней может возникнуть, когда процессы разветвляются, а затем разветвляются ещё раз (как порожденные, так и порождающие). Вторая проблема заключается в том, что вы можете столкнуться с мертвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем последнем примере если как родитель, так и потомок изменяют одну и ту же страницу, они оба получают собственные копии страницы, а исходная страница на уровне **B** становится никому не доступной. Такая страница в **B** может быть высвобождена.","id":950602,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950602/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811491/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:08:58.650382Z","action":27,"target":"Страницы с собственными данными первоначально являются страницами, копируемыми-при-записи или заполняемыми нулями. Когда выполняется изменение, и, соответственно, копирование, начальное хранилище объекта (обычно файл) не может больше использоваться для хранения копии страницы, когда VM-системе нужно использовать её повторно для других целей. В этот момент на помощь приходит область подкачки. Область подкачки выделяется для организации хранилища памяти, которая иначе не может быть доступна. FreeBSD создаёт структуру управления подкачкой для объекта VM, только когда это действительно нужно. Однако структура управления подкачкой исторически имела некоторые проблемы:","id":950603,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950603/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811492/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:08:58.663000Z","action":27,"target":"Во FreeBSD 3.X в структуре управления областью подкачки предварительно выделяется массив, который представляет целый объект, требующий хранения в области подкачки — даже если только несколько страниц этого объекта хранятся в области подкачки. Это создаёт проблему фрагментации памяти ядра в случае, когда в память отображаются большие объекты или когда ветвятся процессы, занимающие большой объём памяти при работе (RSS).","id":950604,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950604/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811481/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:11:09.855984Z","action":27,"target":"При первой записи в страницу после выполнения этой операции в **B** создаётся новая страница, содержимое которой берётся из **A**. Все страницы в **B** могут сбрасываться и считываться из устройства подкачки. Когда программа ветвится, VM-система создаёт два новых уровня объектов — **C1** для порождающего процесса и **C2** для порождённого — они располагаются поверх **B**:","id":950625,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950625/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811483/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:11:09.870055Z","action":27,"target":"В этом случае, допустим, что страница в **B** была изменена начальным родительским процессом. В процессе возникнет ситуация копирования при записи, и страница скопируется в **C1**, при этом исходная страница останется в **B** нетронутой. Теперь допустим, что та же самая страница в **B** изменяется порождённым процессом. В процессе возникнет ситуация копирования при записи и страница скопируется в **C2**. Исходная страница в **B** теперь полностью скрыта, так как и **C1**, и **C2** имеют копии, а уровень **B** теоретически может быть уничтожен, если он не представляет собой \"реального\" файла). Однако такую оптимизацию не так уж просто осуществить, потому что это надо делать на уровне слишком мелких единиц. Во FreeBSD такая оптимизация не выполняется. Теперь положим (а это часто случается), что порождённый процесс выполняет вызов `exec()`. Его текущее адресное пространство обычно заменяется новым адресным пространством, представляющим новый файл. В этом случае уровень **C2** уничтожается:","id":950626,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950626/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811486/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:11:09.885131Z","action":27,"target":"Такая модель создаёт некоторое количество потенциальных проблем. Первая, с которой вы можете столкнуться, заключается в сравнительно большой последовательности уровней объектов VM, на сканирование которых тратится время и память. Большое количество уровней может возникнуть, когда процессы разветвляются, а затем разветвляются ещё раз (как порождённые, так и порождающие). Вторая проблема заключается в том, что вы можете столкнуться с мертвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем последнем примере если как родитель, так и потомок изменяют одну и ту же страницу, они оба получают собственные копии страницы, а исходная страница на уровне **B** становится никому не доступной. Такая страница в **B** может быть высвобождена.","id":950627,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950627/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811485/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:14:28.996004Z","action":27,"target":"В этом случае количество потомков **B** становится равным одному и все обращения к **B** теперь выполняются через **C1**. Это означает, что **B** и **C1** могут быть объединены. Все страницы в **B**, которые также существуют и в **C1**, во время объединения из** B** удаляются. Таким образом, хотя оптимизация на предыдущем шаге может не делаться, мы можем восстановить мёртвые страницы при окончании работы процессов или при вызове `exec()`.","id":950629,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950629/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811486/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:14:29.012724Z","action":27,"target":"Такая модель создаёт некоторое количество потенциальных проблем. Первая, с которой вы можете столкнуться, заключается в сравнительно большой последовательности уровней объектов VM, на сканирование которых тратится время и память. Большое количество уровней может возникнуть, когда процессы разветвляются, а затем разветвляются ещё раз (как порождённые, так и порождающие). Вторая проблема заключается в том, что вы можете столкнуться с мёртвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем последнем примере если как родитель, так и потомок изменяют одну и ту же страницу, они оба получают собственные копии страницы, а исходная страница на уровне **B** становится никому не доступной. Такая страница в **B** может быть высвобождена.","id":950630,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950630/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811488/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:14:29.027164Z","action":27,"target":"Проблема с мёртвой страницей все ещё имеет место, когда *C1* или *C2* не полностью перекрывают *B*. Из-за других применяемых нами методов оптимизации этот случай не представляет большой проблемы и мы просто позволяем таким страницам существовать. Если система испытывает нехватку оперативной памяти, она выполняет их выгрузку в область подкачки, что занимает некоторое пространство в области подкачки, но это всё.","id":950631,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950631/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811514/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:16:00.783058Z","action":27,"target":"Полагая, что ошибка доступа к странице памяти в VM не является операцией с большими накладными расходами, если страница уже находится в основной памяти и может быть просто отображена в адресное пространство процесса, может оказаться, что это станет весьма накладно, если их будет оказываться регулярно много. Хорошим примером этой ситуации является запуск таких программ, как man:ls[1] или man:ps[1], снова и снова. Если бинарный файл программы отображён в память, но не отображён в таблицу страниц, то все страницы, к которым обращалась программа, окажутся недоступными при каждом запуске программы. Это не так уж необходимо, если эти страницы уже присутствуют в кэше VM, так что FreeBSD будет пытаться восстанавливать таблицы страниц процесса из тех страниц, что уже располагаются в VM-кэше. Однако во FreeBSD пока не выполняется предварительное копирование при записи определённых страниц при выполнении вызова exec. Например, если вы запускаете программу man:ls[1] одновременно с работающей `vmstat 1`, то заметите, что она всегда выдает некоторое количество ошибок доступа к страницам, даже когда вы запускаете её снова и снова. Эти ошибки относятся к типу zero-fill и не связаны с доступом к коду программы (который уже был предварительно отображён). Предварительное копирование страниц при выполнении вызовов exec или fork находятся в области, требующей более тщательного изучения.","id":950636,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950636/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811514/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:17:09.011428Z","action":27,"target":"Полагая, что ошибка доступа к странице памяти в VM не является операцией с большими накладными расходами, если страница уже находится в основной памяти и может быть просто отображена в адресное пространство процесса, может оказаться, что это станет весьма накладно, если их будет оказываться регулярно много. Хорошим примером этой ситуации является запуск таких программ, как man:ls[1] или man:ps[1], снова и снова. Если бинарный файл программы отображён в память, но не отображён в таблицу страниц, то все страницы, к которым обращалась программа, окажутся недоступными при каждом запуске программы. Это не так уж необходимо, если эти страницы уже присутствуют в кэше VM, так что FreeBSD будет пытаться восстанавливать таблицы страниц процесса из тех страниц, что уже располагаются в VM-кэше. Однако во FreeBSD пока не выполняется предварительное копирование при записи определённых страниц при выполнении вызова exec. Например, если вы запускаете программу man:ls[1] одновременно с работающей `vmstat 1`, то заметите, что она всегда выдаёт некоторое количество ошибок доступа к страницам, даже когда вы запускаете её снова и снова. Эти ошибки относятся к типу zero-fill и не связаны с доступом к коду программы (который уже был предварительно отображён). Предварительное копирование страниц при выполнении вызовов exec или fork находятся в области, требующей более тщательного изучения.","id":950641,"action_name":"搜索并替换","url":"https://translate-dev.freebsd.org/api/changes/950641/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811467/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:21:02.208303Z","action":2,"target":"Перед тем, как перейти непосредственно к существующей архитектуре, потратим немного времени на рассмотрение вопроса о необходимости поддержки и модернизации любого длительно живущего кода. В мире программирования алгоритмы становятся более важными, чем код, и именно из-за академических корней BSD изначально большое внимание уделялось проработке алгоритмов. Более тщательное внимание к проектированию в целом приводит к созданию чистой и гибкой кодовой базы, которую со временем можно достаточно легко модифицировать, расширять или заменять. Хотя некоторые считают BSD \"старой\" операционной системой, те их нас, кто работает над ней, видят её скорее системой со \"зрелым\" кодом с различными компонентами, которые были заменены, расширены или изменены современным кодом. Он развивается, и FreeBSD остаётся передовой системой, вне зависимости от того, насколько старой может быть часть кода. Это важное отличие, которое, к сожалению, не всеми понимается. Самой большой ошибкой, которую может допустить программист, является игнорирование истории, и это именно та ошибка, которую сделали многие другие современные операционные системы. Самым ярким примером здесь является Windows NT(R), и последствия ужасны. Linux также в некоторой степени совершил эту ошибку — достаточно, чтобы мы, люди BSD, по крайней мере по разу отпустили по этому поводу шутку. Проблема Linux заключается просто в отсутствии опыта и истории для сравнения идей, проблема, которая легко и быстро решается сообществом Linux точно так же, как она решается в сообществе BSD-постоянной работой над кодом. Разработчики Windows NT(R), с другой стороны, постоянно совершают те же самые ошибки, что были решены в UNIX(R) десятки лет назад, а затем тратят годы на их устранение. Снова и снова. Есть несколько случаев \"проработка архитектуры отсутствует\" и \"мы всегда правы, потому что так говорит наш отдел продаж\". Я плохо переношу тех, кого не учит история.","id":950643,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950643/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811467/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:43:47.680082Z","action":2,"target":"Перед тем, как перейти непосредственно к существующей архитектуре, потратим немного времени на рассмотрение вопроса о необходимости поддержки и модернизации любого длительно живущего кода. В мире программирования алгоритмы становятся более важными, чем код, и именно из-за академических корней BSD изначально большое внимание уделялось проработке алгоритмов. Более тщательное внимание к проектированию в целом приводит к созданию чистой и гибкой кодовой базы, которую со временем можно достаточно легко модифицировать, расширять или заменять. Хотя некоторые считают BSD \"старой\" операционной системой, те их нас, кто работает над ней, видят её скорее системой со \"зрелым\" кодом с различными компонентами, которые были заменены, расширены или изменены современным кодом. Он развивается, и FreeBSD остаётся передовой системой, вне зависимости от того, насколько старой может быть часть кода. Это важное отличие, которое, к сожалению, не всеми понимается. Самой большой ошибкой, которую может допустить программист, является игнорирование истории, и это именно та ошибка, которую сделали многие другие современные операционные системы. Самым ярким примером здесь является Windows NT(R), и последствия ужасны. Linux также в некоторой степени совершил эту ошибку — достаточно, чтобы мы, люди BSD, по крайней мере по разу отпустили по этому поводу шутку. Проблема Linux заключается просто в отсутствии опыта и истории для сравнения идей, проблема, которая легко и быстро решается сообществом Linux точно так же, как она решается в сообществе BSD — постоянной работой над кодом. Разработчики Windows NT(R), с другой стороны, постоянно совершают те же самые ошибки, что были решены в UNIX(R) десятки лет назад, а затем тратят годы на их устранение. Снова и снова. У них тяжёлый случай синдрома „не нами разработано“ и „мы всегда правы, потому что так говорит наш отдел маркетинга“. Я плохо переношу тех, кого не учит история.","id":950644,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950644/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811475/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:55:06.037876Z","action":2,"target":"Вы тут же заметите, что то, что сначала было простым отображением файла в память, становится гораздо более сложным предметом. Данные могут модифицироваться постранично, когда как отображение файла выполняется для многих страниц за раз. Сложность ещё более увеличивается, когда процесс выполняет вызов fork. При этом порождаются два процесса, и каждый с собственным адресным пространством, включающим все изменения, выполненные исходным процессом до вызова функции `fork()`. Было бы глупо для VM-системы делать полную копию данных во время вызова `fork()`, так как весьма вероятно, что один из двух процессов будет нужен только для чтения из той страницы, что позволяет использование исходной страницы. То, что было страницей, принадлежащей только процессу, снова становится страницей, копируемой при записи, поскольку каждый из процессов (родительский и дочерний) рассчитывает на то, что его собственные изменения после вызова fork() останутся приватными и не повлияют на другой процесс.","id":950645,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950645/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811476/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T06:57:35.808176Z","action":2,"target":"FreeBSD управляет всем этим при помощи многоуровневой модели VM-объектов. Исходный файл с двоичной программой переносится на самый нижний уровень объектов VM. Уровень страниц, копируемых при записи, находится выше него, и хранит те страницы, которые были скопированы из исходного файла. Если программа модифицирует страницы данных, относящиеся к исходному файлу, то система VM обнаруживает это и переносит копию этой страницы на более высокий уровень. Когда процесс разветвляется, добавляются новые уровни VM-объектов. Понять это поможет достаточно простой пример. Функция `fork()` является общей операцией для всех систем *BSD, так что в этом примере будет рассматриваться программа, которая запускается, а затем разветвляется. Когда процесс запускается, VM-система создаёт некоторый уровень объектов, обозначим его **A**:","id":950646,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950646/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811483/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:00:19.229047Z","action":2,"target":"В этом случае, допустим, что страница в **B** была изменена начальным родительским процессом. В процессе возникнет ситуация копирования при записи, и страница скопируется в **C1**, при этом исходная страница останется в **B** нетронутой. Теперь допустим, что та же самая страница в **B** изменяется дочерним процессом. В процессе возникнет ситуация копирования при записи и страница скопируется в **C2**. Исходная страница в **B** теперь полностью скрыта, так как и **C1**, и **C2** имеют копии, а уровень **B** теоретически может быть уничтожен, если он не представляет собой \"реального\" файла). Однако такую оптимизацию не так уж просто осуществить, потому что это надо делать на уровне слишком мелких единиц. Во FreeBSD такая оптимизация не выполняется. Теперь положим (а это часто случается), что порождённый процесс выполняет вызов `exec()`. Его текущее адресное пространство обычно заменяется новым адресным пространством, представляющим новый файл. В этом случае уровень **C2** уничтожается:","id":950647,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950647/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811483/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:01:09.742959Z","action":2,"target":"В этом случае, допустим, что страница в **B** была изменена начальным родительским процессом. В процессе возникнет ситуация копирования при записи, и страница скопируется в **C1**, при этом исходная страница останется в **B** нетронутой. Теперь допустим, что та же самая страница в **B** изменяется дочерним процессом. В процессе возникнет ситуация копирования при записи и страница скопируется в **C2**. Исходная страница в **B** теперь полностью скрыта, так как и **C1**, и **C2** имеют копии, а уровень **B** теоретически может быть уничтожен, если он не представляет собой \"реального\" файла). Однако такую оптимизацию не так уж просто осуществить, потому что это надо делать на уровне слишком мелких единиц. Во FreeBSD такая оптимизация не выполняется. Теперь положим (а это часто случается), что дочерний процесс выполняет вызов `exec()`. Его текущее адресное пространство обычно заменяется новым адресным пространством, представляющим новый файл. В этом случае уровень **C2** уничтожается:","id":950648,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950648/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811486/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:06:42.545858Z","action":2,"target":"Такая модель создаёт некоторое количество потенциальных проблем. Во-первых, можно получить относительно глубокий стек наслоённых объектов виртуальной памяти, что может увеличить время сканирования и расход памяти при обращении к отсутствующей странице. Большое количество уровней может возникнуть, когда процессы разветвляются, а затем разветвляются ещё раз (как порождённые, так и порождающие). Вторая проблема заключается в том, что вы можете столкнуться с мёртвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем последнем примере если как родитель, так и потомок изменяют одну и ту же страницу, они оба получают собственные копии страницы, а исходная страница на уровне **B** становится никому не доступной. Такая страница в **B** может быть высвобождена.","id":950649,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950649/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811476/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:12:41.163349Z","action":2,"target":"FreeBSD управляет всем этим при помощи многоуровневой модели VM-объектов. Исходный файл с двоичной программой переносится на самый нижний уровень объектов VM. Уровень страниц, копируемых при записи, находится выше него, и хранит те страницы, которые были скопированы из исходного файла. Если программа изменяет страницу данных, принадлежащую исходному файлу, подсистема виртуальной памяти обрабатывает страничное нарушение (page fault) и создаёт копию этой страницы на вышележащем уровне. Когда процесс разветвляется, добавляются новые уровни VM-объектов. Понять это поможет достаточно простой пример. Функция `fork()` является общей операцией для всех систем *BSD, так что в этом примере будет рассматриваться программа, которая запускается, а затем разветвляется. Когда процесс запускается, VM-система создаёт некоторый уровень объектов, обозначим его **A**:","id":950650,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950650/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811483/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:16:56.443690Z","action":2,"target":"В этом случае, допустим, что страница в **B** была изменена начальным родительским процессом. Процесс вызовет страничное нарушение копирования-при-записи и продублирует страницу в **C1**, при этом исходная страница останется в **B** нетронутой. Теперь допустим, что та же самая страница в **B** изменяется дочерним процессом. В процессе возникнет ситуация копирования при записи и страница скопируется в **C2**. Исходная страница в **B** теперь полностью скрыта, так как и **C1**, и **C2** имеют копии, а уровень **B** теоретически может быть уничтожен, если он не представляет собой \"реального\" файла). Однако такую оптимизацию не так уж просто осуществить, потому что это надо делать на уровне слишком мелких единиц. Во FreeBSD такая оптимизация не выполняется. Теперь положим (а это часто случается), что дочерний процесс выполняет вызов `exec()`. Его текущее адресное пространство обычно заменяется новым адресным пространством, представляющим новый файл. В этом случае уровень **C2** уничтожается:","id":950651,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950651/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811486/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:18:43.607021Z","action":2,"target":"Такая модель создаёт некоторое количество потенциальных проблем. Во-первых, можно получить относительно глубокий стек наслоённых объектов виртуальной памяти, что может увеличить время сканирования и расход памяти при обработке страничного исключения. Большое количество уровней может возникнуть, когда процессы разветвляются, а затем разветвляются ещё раз (как порождённые, так и порождающие). Вторая проблема заключается в том, что вы можете столкнуться с мёртвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем последнем примере если как родитель, так и потомок изменяют одну и ту же страницу, они оба получают собственные копии страницы, а исходная страница на уровне **B** становится никому не доступной. Такая страница в **B** может быть высвобождена.","id":950652,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950652/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811489/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:30:03.514610Z","action":2,"target":"Преимущество модели VM-объектов заключается в очень быстром выполнении функции `fork()`, так как при этом не выполняется реального копирования данных. Минусом этого подхода является то, что вы можете построить сравнительно сложную иерархию объектов VM, которая несколько замедляет обработку страничных нарушений, и к тому же тратится память на управление структурами объектов VM. Приёмы оптимизации, применяемые во FreeBSD, позволяют снизить значимость этих проблем до степени, когда их можно без особых потерь игнорировать.","id":950656,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950656/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811509/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:31:11.459687Z","action":2,"target":"Для тех платформ, что не имеют этой возможности, система эмулирует этот бит. Она снимает отображение или защищает страницу, что приводит к страничному нарушению, если к странице выполняется повторное обращение. При возникновении этого страничного нарушения система просто помечает страницу как используемую и снимает защиту со страницы, так что она может использоваться. Хотя использование такого приема только для определения использования страницы весьма накладно, это выгоднее, чем повторно использовать страницу для других целей и обнаружить, что она снова нужна процессу и подгружать её с диска.","id":950657,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950657/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811510/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:33:59.627509Z","action":2,"target":"FreeBSD использует несколько очередей страниц для обновления выбора страниц для повторного использования, а также для определения того, когда же грязные страницы должны быть сброшены в хранилище. Так как таблицы страниц во FreeBSD являются динамическими объектами, практически ничего не стоит вырезать страницу из адресного пространства любого использующего её процесса. После того, как подходящая страница, на основе счетчика использования, выбрана, именно это и выполняется. Система должна различать чистые страницы, которые теоретически могут быть высвобождены в любое время, и грязные страницы, которые сначала должны быть переписаны в хранилище перед тем, как их можно будет использовать повторно. После нахождения подходящей страницы она перемещается в неактивную очередь, если она является грязной, или в очередь кэша, если она чистая. Отдельный алгоритм, основывающийся на отношении количества грязных страниц к чистым, определяет, когда грязные страницы в неактивной очереди должны быть сброшены на диск. Когда это выполнится, сброшенные страницы перемещаются из неактивной очереди в очередь кэша. В этот момент страницы в очереди кэша могут быть повторно активизированы страничными нарушениями VM со сравнительно малыми накладными расходами. Однако страницы в очереди кэша предполагается \"высвобождать немедленно\" и повторно использовать в LRU-порядке (наименее давно используемый), когда системе потребуется выделение дополнительной памяти.","id":950658,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950658/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811513/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:38:01.973763Z","action":2,"target":"Упреждающая оптимизация страничных нарушений и обнуления","id":950659,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950659/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811514/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:39:22.268165Z","action":2,"target":"Полагая, что страничное нарушение в VM не является операцией с большими накладными расходами, если страница уже находится в основной памяти и может быть просто отображена в адресное пространство процесса, может оказаться, что это станет весьма накладно, если их будет оказываться регулярно много. Хорошим примером этой ситуации является запуск таких программ, как man:ls[1] или man:ps[1], снова и снова. Если бинарный файл программы отображён в память, но не отображён в таблицу страниц, то все страницы, к которым обращалась программа, окажутся недоступными при каждом запуске программы. Это не так уж необходимо, если эти страницы уже присутствуют в кэше VM, так что FreeBSD будет пытаться восстанавливать таблицы страниц процесса из тех страниц, что уже располагаются в VM-кэше. Однако во FreeBSD пока не выполняется предварительное копирование при записи определённых страниц при выполнении вызова exec. Например, если вы запускаете программу man:ls[1] одновременно с работающей `vmstat 1`, то заметите, что она всегда выдаёт некоторое количество ошибок доступа к страницам, даже когда вы запускаете её снова и снова. Эти ошибки относятся к типу zero-fill и не связаны с доступом к коду программы (который уже был предварительно отображён). Предварительное копирование страниц при выполнении вызовов exec или fork находятся в области, требующей более тщательного изучения.","id":950660,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950660/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811515/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:41:49.525249Z","action":2,"target":"Большой процент страничных нарушений относится к страничным нарушениям при заполнении нулями. Вы можете обычно видеть это, просматривая вывод команды `vmstat -s`. Это происходит, когда процесс обращается к страницам в своей области BSS. Область BSS предполагается изначально заполненной нулями, но VM-система не заботится о выделении памяти до тех пор, пока процесс реально к ней не обратится. При страничном нарушении VM-система должна не только выделить новую страницу, но и заполнить её нулями. Для оптимизации операции по заполнению нулями в системе VM имеется возможность предварительно обнулять страницы и помечать их, и запрашивать уже обнуленные страницы при возникновении страничных нарушений заполнения нулями. Предварительное заполнение нулями происходит, когда CPU простаивает, однако количество страниц, которые система заранее заполняет нулями, ограничено, для того, чтобы не переполнить кэши памяти. Это прекрасный пример добавления сложности в VM-систему ради оптимизации критического пути.","id":950661,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950661/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811535/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:44:02.665045Z","action":2,"target":"В примере с man:ls(1) и `vmstat 1` выше могут ли некоторые страничные нарушения быть страничными нарушениями данных (COW из выполнимого файла в приватные страницы)? То есть я полагаю, что ошибки доступа к страницам являются частично ошибками при заполнении нулями, а частично данных программы. Или вы гарантируете, что FreeBSD выполняет предварительно COW для данных программы?","id":950662,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950662/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811535/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:45:55.577755Z","action":2,"target":"В примере с man:ls(1) и `vmstat 1` выше могут ли некоторые страничные нарушения быть страничными нарушениями данных (COW из выполнимого файла в приватные страницы)? Иными словами, я ожидаю, что часть страничных нарушений будет связана с заполнением нулями, а часть — с программными данными. Или вы гарантируете, что FreeBSD выполняет предварительно COW для данных программы?","id":950663,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950663/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811536/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:47:06.195730Z","action":2,"target":"Страничное нарушение COW может быть или заполнении нулями или данных программы. Механизм в любом случае один и тот же, потому что хранилище данных программы уже в кэше. Я на самом деле не рад ни тому, ни другому. FreeBSD не выполняет предварительное COW данных программы и заполнение нулями, но она _выполняет_ предварительно отображение страниц, которые имеются в её кэше.","id":950664,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950664/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811536/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:48:29.712291Z","action":2,"target":"Страничное нарушение COW может быть связано или с заполнением нулями, или с данными программы. Механизм в любом случае один и тот же, потому что хранилище данных программы уже в кэше. Я на самом деле не рад ни тому, ни другому. FreeBSD не выполняет предварительное COW данных программы и заполнение нулями, но она _выполняет_ предварительно отображение страниц, которые имеются в её кэше.","id":950665,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950665/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811488/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:49:08.289379Z","action":2,"target":"Проблема с мёртвой страницей все ещё имеет место, когда *C1* или *C2* не полностью перекрывают *B*. Из-за других применяемых нами методов оптимизации этот случай не представляет большой проблемы, и мы просто позволяем таким страницам существовать. Если система испытывает нехватку оперативной памяти, она выполняет их выгрузку в область подкачки, что занимает некоторое пространство в области подкачки, но это всё.","id":950666,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950666/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811492/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T07:52:03.802644Z","action":2,"target":"В FreeBSD 3.X в структуре управления областью подкачки предварительно выделяется массив, который представляет собой целый объект, требующий хранения в области подкачки — даже если только несколько страниц этого объекта хранятся в области подкачки. Это создаёт проблему фрагментации памяти ядра в случае, когда в память отображаются большие объекты или когда ветвятся процессы, занимающие большой объём памяти при работе (RSS).","id":950667,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950667/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811506/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T08:13:42.477954Z","action":2,"target":"Какую дополнительную нагрузку мы может выделить в критическом пути для избежания высвобождения неверно выбранной страницы? Каждый неправильный выбор будет стоить нам сотни тысяч тактов работы центрального процессора и заметное замедление работы затронутых процессов, так что мы должны смириться со значительными издержками для того, чтобы была выбрана правильная страница. Вот почему FreeBSD превосходит другие системы в производительности при нехватке ресурсов памяти.","id":950669,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950669/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811506/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T08:15:54.443185Z","action":2,"target":"Какую дополнительную нагрузку мы может выделить в критическом пути для избежания высвобождения неверно выбранной страницы? Каждый неправильный выбор будет стоить нам сотен тысяч тактов работы центрального процессора и заметного замедления работы затронутых процессов, так что мы должны смириться со значительными издержками ради того, чтобы была выбрана правильная страница. Вот почему FreeBSD превосходит другие системы в производительности при нехватке ресурсов памяти.","id":950670,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950670/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811510/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T08:17:55.706768Z","action":2,"target":"FreeBSD использует несколько очередей страниц для обновления выбора страниц для повторного использования, а также для определения того, когда же грязные страницы должны быть сброшены в хранилище. Так как таблицы страниц во FreeBSD являются динамическими объектами, практически ничего не стоит вырезать страницу из адресного пространства любого использующего её процесса. После того как подходящая страница на основе счётчика использования выбрана, именно это и выполняется. Система должна различать чистые страницы, которые теоретически могут быть высвобождены в любое время, и грязные страницы, которые сначала должны быть переписаны в хранилище перед тем, как их можно будет использовать повторно. После нахождения подходящей страницы она перемещается в неактивную очередь, если она является грязной, или в очередь кэша, если она чистая. Отдельный алгоритм, основывающийся на отношении количества грязных страниц к чистым, определяет, когда грязные страницы в неактивной очереди должны быть сброшены на диск. Когда это выполнится, сброшенные страницы перемещаются из неактивной очереди в очередь кэша. В этот момент страницы в очереди кэша могут быть повторно активизированы страничными нарушениями VM со сравнительно малыми накладными расходами. Однако страницы в очереди кэша предполагается \"высвобождать немедленно\" и повторно использовать в LRU-порядке (наименее давно используемый), когда системе потребуется выделение дополнительной памяти.","id":950671,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950671/?format=json"},{"unit":"https://translate-dev.freebsd.org/api/units/1811486/?format=json","component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","author":"https://translate-dev.freebsd.org/api/users/v.popolitov/?format=json","timestamp":"2026-04-04T08:20:50.799310Z","action":2,"target":"Такая модель создаёт некоторое количество потенциальных проблем. Во-первых, можно получить относительно глубокий стек наслоённых объектов виртуальной памяти, что может увеличить время сканирования и расход памяти при обработке страничного исключения. Большое количество уровней может возникнуть, когда процессы разветвляются, а затем разветвляются ещё раз (как порождённые, так и порождающие). Вторая проблема заключается в том, что вы можете столкнуться с мёртвыми, недоступными страницами глубоко в иерархии объектов VM. В нашем последнем примере, если и родитель, и потомок изменяют одну и ту же страницу, они оба получают собственные копии, а исходная страница на уровне **B** становится недоступной ни для одного из них. Такая страница в **B** может быть высвобождена.","id":950672,"action_name":"修改了译文","url":"https://translate-dev.freebsd.org/api/changes/950672/?format=json"},{"unit":null,"component":"https://translate-dev.freebsd.org/api/components/documentation/articlesvm-design_index/?format=json","translation":"https://translate-dev.freebsd.org/api/translations/documentation/articlesvm-design_index/ru/?format=json","user":null,"author":null,"timestamp":"2026-04-05T04:45:05.897815Z","action":17,"target":"","id":950735,"action_name":"提交了更改","url":"https://translate-dev.freebsd.org/api/changes/950735/?format=json"}]}