WikiDer > Алгоритм замены страниц - Википедия

Было предложено, чтобы эта статья была слился в Политики замены кеша. (Обсуждать) Предлагается с июля 2020 года.

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

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

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

История

Алгоритмы замены страниц были горячей темой исследований и дебатов в 1960-х и 1970-х годах, которые в основном закончились разработкой сложных LRU (наименее использованные в последнее время) приближения и рабочий набор алгоритмы. С тех пор некоторые базовые предположения, сделанные традиционными алгоритмами замены страниц, были признаны недействительными, что привело к возрождению исследований. В частности, на производительность алгоритмов замены страниц повлияли следующие тенденции в поведении основного оборудования и программного обеспечения на уровне пользователя:

• Размер первичного хранилища увеличился на несколько порядков. При наличии нескольких гигабайт первичной памяти алгоритмы, требующие периодической проверки каждого кадра памяти, становятся все менее практичными.
• Иерархия памяти выросла. Стоимость Кеш процессора Мисс намного дороже. Это усугубляет предыдущую проблему.
• Местонахождение ссылки пользовательского ПО ослабла. В основном это связано с распространением объектно-ориентированного программирования методы, которые предпочитают большое количество небольших функций, использование сложных структур данных, таких как деревья и хеш-таблицы которые имеют тенденцию приводить к хаотическим образцам обращения к памяти и появлению вывоз мусора это резко изменило поведение приложений при доступе к памяти.

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

Локальная или глобальная замена

Алгоритмы замены могут быть местный или же Глобальный.

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

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

Определение страниц, на которые есть ссылки и которые изменяются

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

• Очистив бит доступа на страницах, присутствующих в таблице страниц процесса. Через некоторое время ОС просматривает таблицу страниц в поисках страниц, для которых ЦП установлен бит доступа. Это быстро, потому что бит доступа устанавливается автоматически ЦП, и неточно, потому что ОС не сразу получает уведомление о доступе и не имеет информации о порядке, в котором процесс обращался к этим страницам.
• Удаляя страницы из таблицы страниц процесса, не обязательно удаляя их из физической памяти. Следующий доступ к этой странице обнаруживается немедленно, потому что он вызывает ошибка страницы. Это медленно, потому что ошибка страницы включает переключение контекста в ОС, программный поиск соответствующего физического адреса, изменение таблицы страниц и переключение контекста обратно в процесс, и является точным, потому что доступ обнаруживается сразу после его возникновения.
• Непосредственно, когда процесс выполняет системные вызовы, потенциально обращающиеся к кешу страниц, например читать и записывать в POSIX.

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

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

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

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

Некоторые системы используют пейджинг по запросу- ожидание фактического запроса страницы перед ее загрузкой в ​​ОЗУ.

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

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

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

Эта статья может быть сбивает с толку или неясно читателям. Пожалуйста, помоги нам прояснить статью. Возможно обсуждение этого вопроса на страница обсуждения. (Январь 2018) (Узнайте, как и когда удалить этот шаблон сообщения)

Проблема (h, k) -пейджинга

Задача (h, k) -пейджинга является обобщением модели проблемы пейджинга: пусть h, k - натуральные числа такие, что ${ displaystyle h leq k}$. Мы измеряем производительность алгоритма с размером кэша ${ displaystyle h leq k}$ относительно теоретически оптимальный алгоритм замены страницы. Если ${ displaystyle h$, мы обеспечиваем оптимальный алгоритм замены страниц с значительно меньшими ресурсами.

Задача (h, k) -пейджинга - это способ измерить, как работает онлайн-алгоритм, сравнивая его с производительностью оптимального алгоритма, в частности, отдельно параметрируя размер кеш-памяти онлайн-алгоритма и оптимального алгоритма.

Алгоритмы маркировки

Алгоритмы маркировки - это общий класс алгоритмов разбиения на страницы. Для каждой страницы мы связываем ее с меткой. Изначально мы устанавливаем все страницы как неотмеченные. На этапе запросов страниц мы помечаем страницу при первом запросе на этом этапе. Алгоритм маркировки - это такой алгоритм, который никогда не выгружает отмеченную страницу.

Если ALG - это алгоритм маркировки с размером кэша k, а OPT - оптимальный алгоритм с кешем размера h, где ${ displaystyle h leq k}$, то ALG ${ displaystyle { dfrac {k} {k-h + 1}}}$-конкурентный. Таким образом, каждый алгоритм маркировки достигает ${ displaystyle { dfrac {k} {k-h + 1}}}$-конкурентоспособность.

LRU - это алгоритм маркировки, тогда как FIFO - это не алгоритм маркировки.

Эта статья может быть сбивает с толку или неясно читателям. Пожалуйста, помоги нам прояснить статью. Возможно обсуждение этого вопроса на страница обсуждения. (Декабрь 2015 г.) (Узнайте, как и когда удалить этот шаблон сообщения)

Консервативные алгоритмы

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

Если ALG - консервативный алгоритм с размером кэша k, а OPT - оптимальный алгоритм с размером кэша ${ displaystyle h leq k}$, то ALG ${ displaystyle { dfrac {k} {k-h + 1}}}$-конкурентный. Таким образом, каждый консервативный алгоритм достигает ${ displaystyle { dfrac {k} {k-h + 1}}}$-конкурентоспособность.

LRU, FIFO и CLOCK - консервативные алгоритмы.

Алгоритмы замены страниц

Существуют различные алгоритмы замены страниц:^[2]

Теоретически оптимальный алгоритм замены страницы

Теоретически оптимальный алгоритм замены страниц (также известный как OPT, ясновидящий алгоритм замены, или Bélády's оптимальная политика замены страниц)^[3][4][2] это алгоритм, который работает следующим образом: когда страницу нужно заменить, Операционная система заменяет страницу, следующее использование которой произойдет дальше всего в будущем. Например, страница, которая не будет использоваться в течение следующих 6 секунд, будет заменена страницей, которая будет использоваться в течение следующих 0,4 секунды.

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

Анализ проблемы пейджинга также проводился в области онлайн-алгоритмы. Эффективность рандомизированных онлайн-алгоритмов для задачи пейджинга измеряется с помощью амортизированный анализ.

Не использовался недавно

Алгоритм замены неиспользованных недавно страниц (NRU) - это алгоритм, который поддерживает сохранение в памяти недавно использованных страниц. Этот алгоритм работает по следующему принципу: когда на страницу ссылаются, для этой страницы устанавливается бит ссылки, помечающий ее как указанную. Точно так же, когда страница модифицируется (записывается), устанавливается модифицированный бит. Установка битов обычно выполняется аппаратно, хотя это возможно и на программном уровне.

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

3. упомянутые, измененные

2. упомянутые, не измененные

1. не упоминается, изменено

0. не упоминается, не изменяется

Хотя не представляется возможным изменить страницу, но на нее нет ссылки, это происходит, когда у страницы класса 3 бит ссылки сброшен прерыванием таймера. Алгоритм NRU выбирает для удаления случайную страницу из самой низкой категории. Таким образом, из четырех вышеперечисленных категорий страниц алгоритм NRU заменит страницу без ссылок и без изменений, если такая страница существует. Обратите внимание, что этот алгоритм подразумевает, что измененная, но не упоминаемая (в пределах последнего интервала таймера) страница менее важна, чем не измененная страница, на которую часто ссылаются.

NRU - это алгоритм маркировки, поэтому он ${ displaystyle { dfrac {k} {k-h + 1}}}$-конкурентный.

Первым пришел-первым вышел

Самый простой алгоритм замены страниц - это алгоритм FIFO. Алгоритм замены страниц по принципу "первым пришел - первым обслужен" (FIFO) - это алгоритм с низкими накладными расходами, который требует небольшого учета со стороны Операционная система. Идея очевидна из названия - операционная система отслеживает все страницы в памяти в очереди, причем самые свежие поступления находятся сзади, а самые старые - впереди. Когда страницу необходимо заменить, выбирается страница в начале очереди (самая старая страница). Хотя FIFO дешев и интуитивно понятен, он плохо работает на практике. Таким образом, он редко используется в неизмененном виде. Этот алгоритм испытывает Аномалия БеладиПроще говоря, при отказе страницы заменяется фрейм, который дольше всех находился в памяти.

Алгоритм замены страницы FIFO используется VAX / VMS операционная система, с некоторыми модификациями.^[5] Частичный второй шанс обеспечивается пропуском ограниченного числа записей с действительными ссылками на таблицу перевода,^[6] кроме того, страницы перемещаются из рабочего набора процесса в общесистемный пул, из которого они могут быть восстановлены, если они еще не использовались повторно.

FIFO - консервативный алгоритм, поэтому он ${ displaystyle { dfrac {k} {k-h + 1}}}$-конкурентный.

Второй шанс

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

Как следует из названия, «Второй шанс» дает каждой странице «второй шанс» - старая страница, на которую была сделана ссылка, вероятно, уже используется, и ее не следует заменять новой страницей, на которую не ссылались.

Часы

Clock - более эффективная версия FIFO, чем Second-Chance, потому что страницы не нужно постоянно перемещать в конец списка, но они выполняют ту же общую функцию, что и Second-Chance. Алгоритм часов хранит в памяти круговой список страниц, при этом «рука» (итератор) указывает на последний проверенный страничный фрейм в списке. Когда происходит сбой страницы и пустые кадры отсутствуют, то бит R (указанный) проверяется в местоположении руки. Если R равно 0, новая страница помещается на место страницы, на которую указывает «рука», и рука перемещается на одну позицию вперед. В противном случае бит R очищается, затем стрелка часов увеличивается, и процесс повторяется, пока страница не будет заменена.^[7] Этот алгоритм был впервые описан в 1969 г. Ф. Х. Корбато.^[8]

Варианты часов

• GCLOCK: Обобщенный алгоритм замены страницы часов.^[9]
• Clock-Pro хранит круговой список информации о недавно использованных страницах, включая все M страниц в памяти, а также самые последние M страниц, которые были выгружены. Эта дополнительная информация на выгружаемых страницах, как и аналогичная информация, поддерживаемая ARC, помогает работать лучше, чем LRU при больших циклах и одноразовых сканированиях.^[10]
• WSclock.^[11] Комбинируя алгоритм Clock с концепцией рабочего набора (т.е. набора страниц, которые, как ожидается, будут использоваться этим процессом в течение некоторого интервала времени), производительность алгоритма может быть улучшена. На практике, вероятно, наиболее важными алгоритмами замены страниц являются алгоритм «старения» и алгоритм «WSClock».^[12][13]
• Часы с адаптивной заменой (CAR) - это алгоритм замены страниц, производительность которого сопоставима с ARC, и существенно превосходит LRU и CLOCK.^[14] Алгоритм CAR самонастраивается и не требует заданных пользователем магических параметров.

ЧАСЫ - консервативный алгоритм, поэтому он ${ displaystyle { dfrac {k} {k-h + 1}}}$-конкурентный.

Наименее недавно использованный

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

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

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

Из-за затрат на реализацию можно рассмотреть алгоритмы (подобные приведенным ниже), которые похожи на LRU, но предлагают более дешевые реализации.

Одним из важных преимуществ алгоритма LRU является то, что он поддается полному статистическому анализу. Например, было доказано, что LRU никогда не может привести к более чем N раз большему количеству ошибок страниц, чем алгоритм OPT, где N пропорционально количеству страниц в управляемом пуле.

С другой стороны, слабость LRU заключается в том, что его производительность имеет тенденцию к ухудшению под многими довольно распространенными эталонными шаблонами. Например, если в пуле LRU есть N страниц, приложение, выполняющее цикл по массиву из N + 1 страниц, вызовет отказ страницы при каждом доступе. Поскольку циклы для больших массивов являются обычным явлением, было приложено много усилий для изменения LRU, чтобы лучше работать в таких ситуациях. Многие из предлагаемых модификаций LRU пытаются обнаружить циклические эталонные шаблоны и переключиться на подходящий алгоритм замены, такой как Most Recently Used (MRU).

Варианты на LRU

1. LRU-K^[15] удаляет страницу, K-й доступ к которой самый последний в прошлом. Например, LRU-1 - это просто LRU, тогда как LRU-2 удаляет страницы согласно времени их предпоследнего доступа. LRU-K значительно улучшает LRU в отношении местоположения во времени.
2. В ARC^[16] Алгоритм расширяет LRU, сохраняя историю недавно удаленных страниц и используя это, чтобы изменить предпочтение на недавний или частый доступ. Он особенно устойчив к последовательному сканированию.

Сравнение ARC с другими алгоритмами (LRU, MQ, 2Q, LRU-2, LRFU, LIRS) можно найти в Megiddo & Modha 2004.^[17]

LRU - это алгоритм маркировки, поэтому он ${ displaystyle { dfrac {k} {k-h + 1}}}$-конкурентный.

Случайный

Алгоритм случайной замены заменяет случайную страницу в памяти. Это исключает накладные расходы на отслеживание ссылок на страницы. Обычно он работает лучше, чем FIFO, а для циклических обращений к памяти он лучше, чем LRU, хотя в целом LRU на практике работает лучше. OS / 390 использует глобальное приближение LRU и возвращается к случайной замене, когда производительность LRU ухудшается, а Intel i860 процессор использовал политику случайной замены (Rhodehamel 1989^[18]).

Не часто используется (NFU)

Алгоритм замены нечасто используемых страниц (NFU) требует счетчика, и каждая страница имеет свой собственный счетчик, который изначально установлен на 0. В каждом тактовом интервале счетчик всех страниц, на которые имеется ссылка в этом интервале, будет увеличиваться на 1. Фактически, счетчики отслеживают, как часто страница была использована. Таким образом, при необходимости страницу с наименьшим счетчиком можно заменить.

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

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

Старение

Алгоритм устаревания является потомком алгоритма NFU с модификациями, чтобы он знал о временном промежутке использования. Вместо того, чтобы просто увеличивать счетчики страниц, на которые есть ссылки, уделяя одинаковое внимание ссылкам на страницы независимо от времени, счетчик ссылок на странице сначала сдвигается вправо (делится на 2), а затем добавляется бит, на который указывает ссылка, слева от этого двоичного числа. Например, если страница ссылалась на биты 1,0,0,1,1,0 за последние 6 тактов часов, ее счетчик, на который ссылаются, будет выглядеть следующим образом: 10000000, 01000000, 00100000, 10010000, 11001000, 01100100. Ссылки на страницы ближе в настоящее время имеют большее влияние, чем ссылки на страницы давным-давно. Это гарантирует, что страницы, на которые ссылаются позже, хотя и реже, будут иметь более высокий приоритет по сравнению со страницами, на которые чаще ссылались в прошлом. Таким образом, когда страницу необходимо заменить, будет выбрана страница с наименьшим счетчиком.

Следующее Python код моделирует алгоритм старения. ${ displaystyle V_ {i}}$ инициализируются ${ displaystyle 0}$ и обновляется, как описано выше, через ${ Displaystyle V_ {i} leftarrow (R_ {i} ll (k-1)) | (V_ {i} gg 1)}$, с помощью операторы арифметического сдвига.

def simulate_aging(Рупий, k: int) -> Никто:    "" "Имитация старения" ""    Против = [0] * len(Рупий[0])    за т, р в перечислять(Рупий):        за я в классифицировать(len(Против)):            Против[я] = р[я] << k - 1 | Против[я] >> 1        Распечатать('% 02d  |  % s  |  [% s]' % (т, р, ', '.присоединиться([формат(V, '0% dб ' % k) за V в Против])))Рупий = [[1,0,1,0,1,1], [1,1,0,0,1,0], [1,1,0,1,0,1], [1,0,0,0,1,0], [0,1,1,0,0,0]]k = 8simulate_aging(Рупий, k)

В данном примере R-битов для 6 страниц за 5 тактов тактовой частоты функция выводит следующий вывод, в котором перечислены R-биты для каждого такта. ${ displaystyle t}$ и отдельные значения счетчиков ${ displaystyle V_ {i}}$ для каждой страницы в двоичный представление.^[19]

 т | R-биты (0-5) | Счетчики страниц 0-500 | [1, 0, 1, 0, 1, 1] | [10000000, 00000000, 10000000, 00000000, 10000000, 10000000] 01 | [1, 1, 0, 0, 1, 0] | [11000000, 10000000, 01000000, 00000000, 11000000, 01000000] 02 | [1, 1, 0, 1, 0, 1] | [11100000, 11000000, 00100000, 10000000, 01100000, 10100000] 03 | [1, 0, 0, 0, 1, 0] | [11110000, 01100000, 00010000, 01000000, 10110000, 01010000] 04 | [0, 1, 1, 0, 0, 0] | [01111000, 10110000, 10001000, 00100000, 01011000, 00101000]

Обратите внимание, что старение отличается от LRU в том смысле, что старение может отслеживать ссылки только в последних 16/32 (в зависимости от размера битов целых чисел процессора) временных интервалов. Следовательно, две страницы могут иметь счетчики ссылок на 00000000, даже если на одну страницу ссылались 9 интервалов назад, а на другую 1000 интервалов назад. Вообще говоря, информации об использовании за последние 16 интервалов достаточно для принятия правильного решения о том, какую страницу заменить. Таким образом, старение может предложить почти оптимальную производительность по умеренной цене.

Алгоритм замены страницы сначала на наибольшее расстояние (LDF)

Основная идея, лежащая в основе этого алгоритма, - это локальность ссылки, используемая в LRU, но разница в том, что в LDF локальность основана на расстоянии, а не на используемых ссылках. В LDF замените страницу, которая находится на самом большом расстоянии от текущей страницы. Если две страницы находятся на одинаковом расстоянии, то страница, которая находится рядом с текущей страницей при повороте против часовой стрелки, будет заменена.^[20]

Детали реализации

Методы аппаратной без ссылки бит

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

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

Страницы могут быть выбраны для удаления рабочего набора по существу случайным образом, с ожиданием, что, если будет сделан неправильный выбор, будущая ссылка может извлечь эту страницу из списка Free или Modified до того, как она будет удалена из физической памяти. Страница, на которую ссылаются таким образом, будет удалена из списка Free или Modified и помещена обратно в рабочий набор процесса. Измененный список страниц дополнительно предоставляет возможность записывать страницы в резервное хранилище группами по несколько страниц, повышая эффективность. Эти страницы могут быть затем помещены в список бесплатных страниц. Последовательность страниц, которая продвигается к началу списка бесплатных страниц, напоминает результаты работы механизма LRU или NRU, а общий эффект имеет сходство с алгоритмом второго шанса, описанным ранее.

Другой пример используется Ядро Linux на РУКА. Отсутствие аппаратной функциональности компенсируется наличием двух таблиц страниц - таблиц страниц для процессора, без битов, на которые есть ссылки, и грязные биты, и таблицы страниц, поддерживаемые программным обеспечением, с необходимыми битами. Эмулируемые биты в таблице, поддерживаемой программным обеспечением, устанавливаются ошибками страниц. Чтобы получить ошибки страниц, очистка эмулированных битов во второй таблице отменяет некоторые права доступа к соответствующей странице, что реализуется путем изменения собственной таблицы.

Кеш страницы в Linux

Linux использует единый кеш страниц для

• BRK и анонимный mmapред-регионы. Это включает куча и куча из пользовательское пространство программы. Написано для подкачки при выгрузке.
• Неанонимный (с файловой поддержкой) mmapред регионы. Если физическая страница присутствует в памяти и не изменена частным образом, она используется совместно с файловым кешем или буфером.
• Общая память, полученная через shm_open.
• В tmpfs файловая система в памяти; написано для обмена при выгрузке.
• Файловый кеш, в том числе; записывается в базовое блочное хранилище (возможно, проходит через буфер, см. ниже) при подкачке.
• Тайник блочные устройства, который в Linux называется «буфером» (не путать с другими структурами, также называемыми буферами, например, используемыми для трубы и буферы, используемые внутри Linux); записывается в базовое хранилище при выгрузке.

Унифицированный кеш страницы работает с модулями наименьшего размера страницы, поддерживаемыми ЦП (4 КиБ в ARMv8, x86 и x86-64) с некоторыми страницами следующего большего размера (2 МБ в x86-64) Линукс назвал "огромными страницами". Страницы в кэше страниц делятся на «активный» набор и «неактивный» набор. Оба набора содержат список страниц LRU. В основном случае, когда к странице обращается программа пользовательского пространства, она помещается в заголовок неактивного набора. При повторном обращении к нему он перемещается в активный список. Linux перемещает страницы из активного набора в неактивный по мере необходимости, так что активный набор меньше, чем неактивный набор. Когда страница перемещается в неактивный набор, она удаляется из таблицы страниц любого адресного пространства процесса без подкачки из физической памяти.^[21][22] Когда страница удаляется из неактивного набора, она выгружается из физической памяти. Размер «активного» и «неактивного» списка можно узнать из / proc / meminfo в полях «Активный», «Неактивный», «Активный (анонимный)», «Неактивный (анонсированный)», «Активный (файл)» и «Неактивный (анонсированный)».

Рабочий набор

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

«Модель рабочего набора» не является алгоритмом замены страниц в строгом смысле слова (на самом деле это своего рода среднесрочный планировщик)^{[требуется разъяснение]}

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

дальнейшее чтение