Что такое hugepages linux
Обновлено: 03.07.2024
Для больших размеров SGA HugePages может дать существенные преимущества в управлении виртуальной памятью. Без HugePages память SGA делится на страницы по 4 КБ, которыми должно управлять ядро Linux. Используя HugePages, размер страницы увеличивается до 2 МБ (можно настроить до 1 ГБ, если поддерживается аппаратным обеспечением), тем самым уменьшая общее количество страниц, которыми должно управлять ядро, и, следовательно, уменьшая объем памяти, необходимый для хранения таблицы страниц в памяти. В дополнение к этим изменениям память, связанная с HugePages, не может быть выгружена, что вынуждает SGA оставаться резидентной в памяти. Экономия памяти и усилия по управлению страницами делают HugePages практически обязательными для систем Oracle 11g, работающих на архитектурах x86-64.
Тот факт, что у вас большой SGA, не означает автоматически, что у вас возникнут проблемы, если вы не будете использовать HugePages. Обычно к проблемам приводит сочетание большого SGA и большого количества подключений к базе данных. Чтобы определить, сколько памяти вы в настоящее время используете для поддержки таблицы страниц, выполните следующую команду в то время, когда сервер испытывает нормальную/высокую нагрузку.
Автоматическое управление памятью (AMM) несовместимо с Linux HugePages, поэтому, за исключением экземпляров ASM и небольших неважных баз данных, вам, вероятно, не понадобится AMM для реальной базы данных, работающей в Linux. Вместо этого следует использовать автоматическое управление общей памятью и автоматическое управление PGA, поскольку они совместимы с HugePages.
Настройка огромных страниц
Выполните следующую команду, чтобы определить текущее использование HugePage. Размер HugePage по умолчанию составляет 2 МБ в Oracle Linux 5.x, и, как видно из приведенного ниже вывода, по умолчанию HugePage не определены.
В зависимости от размера вашего SGA вы можете увеличить значение Hugepagesize до 1 ГБ.
Создайте файл Hugepages_setting.sh со следующим содержимым.
Спасибо Бьорну Росту за указание на проблему при использовании скрипта против UEK3 и предложенное исправление. Впоследствии я добавил поддержку 3.10 и 4.1. В MOS доступна более новая версия этого скрипта (идентификатор документа 401749.1), которая также включает эти версии ядра.
Сделайте файл исполняемым.
Убедитесь, что все службы Oracle работают на сервере в обычном режиме, затем запустите сценарий и запишите рекомендуемое значение "vm.nr_hugepages".
Отредактируйте файл "/etc/sysctl.conf" в качестве пользователя "root", добавив следующую запись, скорректированную на основе выходных данных скрипта. Вы должны установить значение больше или равно значению, отображаемому сценарием. Вам понадобится всего 1 или 2 запасные страницы.
Один человек сообщил, что также нуждается в параметре hugetlb_shm_group в Oracle Linux 6.5. Я этого не делал, и это указано как требование только для SUSE. Если вы хотите установить его, получите идентификатор группы dba.
Используйте полученный идентификатор группы в файле "/etc/sysctl.conf".
Выполните следующую команду от имени пользователя root.
В качестве альтернативы отредактируйте файл "/etc/grub.conf", добавив "hugepages=306" в конец строки ядра для ядра по умолчанию и перезагрузите компьютер.
Теперь вы можете видеть, что HugePages были созданы, но в настоящее время не используются.
Добавьте следующие записи в сценарий "/etc/security/limits.conf" или "/etc/security/limits.d/99-grid-oracle-limits.conf", где значение параметра не ниже размер выделения HugePages в КБ (HugePages * Hugepagesize). В данном случае значение равно 306*2048=626688.
При желании вы можете установить для этих параметров значение чуть меньше размера физической памяти сервера. Таким образом, вы можете забыть об этом, если только вы не добавите больше физической памяти.
Убедитесь, что параметры MEMORY_TARGET не установлены для базы данных, а вместо них используются параметры SGA_TARGET и PGA_AGGREGATE_TARGET.
Перезапустите сервер и перезапустите службы базы данных по мере необходимости.
Еще раз проверьте информацию HugePages.
Вы можете видеть, что HugePages сейчас используются.
Помните, что если вы увеличиваете выделение памяти или добавляете новые экземпляры, вам необходимо повторно протестировать необходимое количество HugePage, иначе Oracle будет работать без них.
Заставить Oracle использовать HugePages (USE_LARGE_PAGES)
Правильный размер количества HugePages важен, поскольку до версии 11.2.0.3, если весь SGA не помещается в доступные HugePages, экземпляр запускается без использования каких-либо. Начиная с версии 11.2.0.3, SGA может частично работать в HugePages, а частично — нет, поэтому влияние этой проблемы не так велико. Неправильный размер может быть незаметен. Более поздние выпуски базы данных отображают раздел «Информация о больших страницах» в журнале предупреждений во время запуска.
Если вы используете Oracle 11.2.0.2 или более позднюю версию, вы можете установить для параметра инициализации USE_LARGE_PAGES значение «только», чтобы база данных не запускалась, если она не поддерживается огромными страницами. Подробнее об этом можно прочитать здесь.
При запуске "Информация о большой странице" в журнале предупреждений отражает использование этого параметра.
Попытка запустить базу данных, когда не хватает HugePages для хранения SGA, теперь будет возвращать следующую ошибку.
В разделе "Информация о больших страницах" выходных данных журнала предупреждений описывается ошибка запуска и соответствующие действия, которые необходимо предпринять.
Отключение прозрачных огромных страниц (RHEL6/OL6 и RHEL7/OL7)
Начиная с RHEL6/OL6, прозрачные огромные страницы реализованы и включены по умолчанию. Они предназначены для улучшения управления памятью, позволяя динамически выделять HugePages потоком ядра «khugepaged», а не во время загрузки, как обычные HugePages. Звучит как хорошая идея, но, к сожалению, Transparent HugePages плохо работает с базами данных Oracle и связана с перезагрузкой узлов в установках RAC и проблемами с производительностью как в одиночных экземплярах, так и в установках RAC. В связи с этим Oracle рекомендует отключать Transparent HugePages на всех серверах с базами данных Oracle, как описано в этом примечании MOS.
В следующих примерах используется базовый путь «/sys/kernel/mm/transparent_hugepage/», используемый OL6/OL7. Для RHEL6/RHEL7 используйте «/sys/kernel/mm/redhat_transparent_hugepage/» в качестве базового пути.
Вы можете проверить текущую настройку с помощью следующей команды, которая отображает значение по умолчанию "enabled=[always]".
Для Oracle Linux 6 предпочтительным способом отключения прозрачных огромных страниц является добавление «transparent_hugepage=never» в строку загрузки ядра в файле «/boot/grub/grub.conf».
Oracle Linux 7 аналогичен, но использует GRUB2, поэтому вам нужно отредактировать файл "/boot/grub2/grub.cfg" с помощью команды grubby.
Чтобы это вступило в силу, необходимо перезагрузить сервер.
В качестве альтернативы добавьте следующие строки в файл "/etc/rc.local" и перезагрузите сервер.
Какой бы метод вы ни выбрали, не забудьте проверить, работает ли изменение после перезагрузки.
В OL7/RHEL7 также необходимо учитывать «настроенный профиль». В следующем сценарии показано, как создать и включить измененную версию текущего активного настроенного профиля.
Спасибо, Мор, что указал на это и направил меня к примечаниям здесь и здесь.
Отключив прозрачные огромные страницы, вы должны перейти к настройке обычных огромных страниц, как описано выше.
Настройка размера страницы 1 ГБ
Как упомянул Юджин в комментариях, Oracle в настоящее время не рекомендует использовать 1G Hugepagesize. Подробнее об этом можно прочитать в документе MOS Doc ID 1607545.1. Имея это в виду, остальную часть этого раздела, вероятно, следует рассматривать как академическое упражнение.
Проверьте, поддерживает ли ваше текущее оборудование размер Hugepagesize, равный 1 ГБ. Если следующая команда производит какие-либо выходные данные, она может.
Спасибо Кевину Клоссону за указание на необходимость поддержки оборудования.
В этой главе представлен обзор Hugepages и приведены инструкции для системных администраторов Linux по настройке HugePages в Linux.
G.1 Обзор огромных страниц
HugePages — это функция, интегрированная в ядро Linux 2.6. Включение HugePages позволяет операционной системе поддерживать страницы памяти больше, чем по умолчанию (обычно 4 КБ). Использование очень больших размеров страниц может повысить производительность системы за счет уменьшения количества системных ресурсов, необходимых для доступа к записям таблицы страниц. HugePages полезен как для 32-битных, так и для 64-битных конфигураций. Размеры HugePage варьируются от 2 МБ до 256 МБ в зависимости от версии ядра и аппаратной архитектуры. Для баз данных Oracle использование HugePages сокращает объем операций по обслуживанию состояния страниц операционной системой и увеличивает коэффициент попадания в резервный буфер перевода (TLB).
Прозрачный Hugepages в настоящее время не является альтернативой ручной настройке HugePages.
Этот раздел включает следующие темы:
G.1.1 Настройка SGA с помощью HugePages
Без HugePages операционная система сохраняет каждые 4 КБ памяти как страницу. При размещении страниц в системной глобальной области базы данных (SGA) ядро операционной системы должно постоянно обновлять свою таблицу страниц с указанием жизненного цикла страницы (грязная, свободная, сопоставленная с процессом и т. д.) для каждой страницы размером 4 КБ, выделенной для СГА.
При использовании HugePages таблица страниц операционной системы (сопоставление виртуальной и физической памяти) меньше, поскольку каждая запись в таблице страниц указывает на страницы размером от 2 МБ до 256 МБ.
Кроме того, в ядре меньше страниц, жизненный цикл которых необходимо отслеживать. Например, если вы используете HugePages с 64-разрядным оборудованием и хотите отобразить 256 МБ памяти, вам может понадобиться одна запись в таблице страниц (PTE). Если вы не используете HugePages и хотите отобразить 256 МБ памяти, вам потребуется 256 МБ * 1024 КБ/4 КБ = 65 536 PTE.
HugePages предоставляет следующие преимущества:
Повышение производительности за счет увеличения количества обращений к TLB
Страницы блокируются в памяти и никогда не выгружаются, что обеспечивает ОЗУ для структур общей памяти, таких как SGA
Непрерывные страницы выделяются заранее и не могут использоваться ни для чего другого, кроме как для разделяемой памяти System V (например, SGA)
Для ядра меньше работы по учету этой части виртуальной памяти из-за больших размеров страниц
G.1.2 Настройка HugePages в Linux
Выполните следующие шаги, чтобы настроить HugePages на компьютере:
Выполните следующую команду, чтобы определить, поддерживает ли ядро HugePages:
Некоторые системы Linux не поддерживают HugePages по умолчанию. Для таких систем соберите ядро Linux, используя параметры конфигурации CONFIG_HUGETLBFS и CONFIG_HUGETLB_PAGE. CONFIG_HUGETLBFS находится в разделе «Файловые системы», а CONFIG_HUGETLB_PAGE выбирается при выборе CONFIG_HUGETLBFS .
Измените параметр memlock в файле /etc/security/limits.conf. Параметр memlock указывается в КБ, а максимальное ограничение заблокированной памяти должно быть установлено как минимум на 90 процентов от текущего объема ОЗУ, когда память HugePages включена, и не менее 3145728 КБ (3 ГБ), когда память HugePages отключена. Например, если у вас установлено 64 ГБ ОЗУ, добавьте следующие записи, чтобы увеличить максимальное адресное пространство заблокированной памяти:
Вы также можете установить значение memlock выше требований SGA.
Снова войдите в систему как пользователь oracle и выполните команду ulimit -l, чтобы проверить новую настройку memlock:
Выполните следующую команду, чтобы отобразить значение переменной Hugepagesize:
Выполните следующую процедуру, чтобы создать сценарий, вычисляющий рекомендуемые значения для конфигурации огромных страниц для текущих сегментов общей памяти:
Создайте текстовый файл с именем hugepages_settings.sh .
Добавьте в файл следующее содержимое:
Выполните следующую команду, чтобы изменить права доступа к файлу:
Запустите скрипт hugepages_settings.sh, чтобы вычислить значения для конфигурации hugepages:
Перед запуском этого скрипта убедитесь, что запущены все приложения, использующие огромные страницы.
Установите следующий параметр ядра, где значение — это значение HugePages, которое вы определили на шаге 7:
Чтобы обеспечить выделение HugePages после перезагрузки системы, добавьте следующую запись в файл /etc/sysctl.conf, где value — это значение HugePages, которое вы определили на шаге 7:
Выполните следующую команду, чтобы проверить доступные огромные страницы:
Перезапустите экземпляр.
Выполните следующую команду, чтобы проверить доступные огромные страницы (1 или 2 страницы свободны):
Если вы не можете установить выделение HugePages с помощью nr_hugepages , доступная память может быть фрагментирована. Перезагрузите сервер, чтобы выделение Hugepages вступило в силу.
G.1.3 Ограничения для конфигураций HugePages
HugePages имеет следующие ограничения:
Необходимо отменить оба параметра инициализации MEMORY_TARGET и MEMORY_MAX_TARGET. Например, чтобы сбросить параметры экземпляра базы данных, используйте команду ALTER SYSTEM RESET .
Автоматическое управление памятью (AMM) и HugePages несовместимы. Когда вы используете AMM, вся память SGA выделяется путем создания файлов в каталоге /dev/shm. Когда Oracle Database выделяет SGA с помощью AMM, HugePages не резервируются. Чтобы использовать HugePages в Oracle Database 12c, необходимо отключить AMM.
Если вы используете VLM в 32-разрядной среде, вы не можете использовать HugePages для кэша буфера базы данных. Вы можете использовать HugePages для других частей SGA, таких как shared_pool, large_pool и так далее. Выделение памяти для VLM (буферный кеш) выполняется с использованием файловых систем с общей памятью ( ramfs/tmpfs/shmfs ). Файловые системы памяти не резервируют и не используют огромные страницы.
HugePages не подлежат выделению или освобождению после запуска системы, если только системный администратор не изменит конфигурацию HugePages, либо изменив количество доступных страниц, либо изменив размер пула. Если требуемое пространство не зарезервировано в памяти во время запуска системы, выделение HugePages завершается ошибкой.
Убедитесь, что HugePages настроены правильно, так как системе может не хватить памяти, если приложение не использует избыток HugePages.
Если при запуске экземпляра не хватает HugePages и для параметра инициализации use_large_pages задано значение only , база данных не запускается, и в сообщении журнала предупреждений содержится необходимая информация об Hugepages.
G.1.4 Отключение прозрачных огромных страниц
Прозрачная память HugePages включена по умолчанию в Red Hat Enterprise Linux 6, SUSE 11 и Oracle Linux 6 с более ранними выпусками ядер Oracle Linux Unbreakable Enterprise Kernel 2 (UEK2). Прозрачная память HugePages отключена по умолчанию в более поздних версиях ядер UEK2.
Прозрачные огромные страницы могут вызывать задержки выделения памяти во время выполнения. Чтобы избежать проблем с производительностью, Oracle рекомендует отключать Transparent HugePages на всех серверах Oracle Database. Oracle рекомендует вместо этого использовать стандартные HugePages для повышения производительности.
Прозрачная память HugePages отличается от стандартной памяти HugePages тем, что поток ядра khugepaged динамически выделяет память во время выполнения. Стандартная память HugePages предварительно выделяется при запуске и не изменяется во время выполнения.
Чтобы проверить, включены ли прозрачные огромные страницы, выполните одну из следующих команд от имени пользователя root:
Ядра Red Hat Enterprise Linux:
Ниже приведен пример вывода, показывающий, что прозрачные огромные страницы используются, поскольку флаг [всегда] включен.
Если Transparent HugePages удален из ядра, файлы /sys/kernel/mm/transparent_hugepage или /sys/kernel/mm/redhat_transparent_hugepage не существуют.
< /p>
Огромные страницы в Linux
В этой статье мы подробно расскажем вам об огромных страницах, чтобы вы могли ответить: что такое огромные страницы в Linux? Как включить/отключить огромные страницы? Как определить огромную ценность страницы? в Linux, например RHEL6, RHEL7, Ubuntu и т. д.
Давайте начнем с основ Huge Pages.
Что такое огромная страница в Linux?
Огромные страницы полезны при управлении виртуальной памятью в системе Linux. Как следует из названия, они помогают управлять страницами огромного размера в памяти в дополнение к стандартному размеру страницы 4 КБ. С помощью огромных страниц можно определить размер страницы размером до 1 ГБ.
Во время загрузки системы вы резервируете часть памяти с огромными страницами для своего приложения. Эта часть памяти, то есть эта память, занятая огромными страницами, никогда не выгружается из памяти. Он будет оставаться там до тех пор, пока вы не измените конфигурацию. Это в значительной степени повышает производительность приложений, например базу данных Oracle с довольно большими требованиями к памяти.
Зачем использовать огромную страницу?
При управлении виртуальной памятью ядро поддерживает таблицу, в которой имеется сопоставление адреса виртуальной памяти с физическим адресом. Для каждой транзакции страницы ядру необходимо загрузить соответствующее сопоставление. Если у вас есть страницы небольшого размера, вам нужно загрузить больше страниц, в результате чего ядро загрузит больше таблиц сопоставления. Это снижает производительность.
Использование больших страниц означает, что вам понадобится меньше страниц. Это значительно уменьшает количество таблиц отображения, загружаемых ядром. Это повышает производительность на уровне ядра, что в конечном итоге приносит пользу вашему приложению.
Короче говоря, за счет включения огромных страниц в системе остается меньше таблиц страниц, с которыми приходится иметь дело, и, следовательно, меньше накладных расходов на доступ к ним и их обслуживание!
Как настроить огромные страницы?
Выполните приведенную ниже команду, чтобы проверить информацию о текущих огромных страницах.
В приведенном выше выводе видно, что размер одной страницы составляет 2 МБ. Hugepagesize и всего 0 страниц в системе HugePages_Total . Этот огромный размер страницы можно увеличить с 2 МБ до 1 ГБ.
Запустите приведенный ниже скрипт, чтобы узнать, сколько огромных страниц требуется вашей системе в настоящее время. Сценарий принадлежит Oracle, и его можно найти.
Вы можете сохранить его в /tmp как hugepages_settings.sh, а затем запустить, как показано ниже:
Вывод будет похож на некоторое число, как показано в примере выше.
Это означает, что вашей системе требуется 124 огромных страницы по 2 МБ каждая! Если бы вы установили размер страницы 4 МБ, на выходе было бы 62 байта. Вы поняли, верно?
Настроить огромные страницы в ядре
Теперь последняя часть — настроить вышеуказанный параметр ядра и перезагрузить его. Добавьте приведенное ниже значение в /etc/sysctl.conf и перезагрузите конфигурацию, введя команду sysctl -p.
Обратите внимание, что мы добавили 2 дополнительные страницы в ядро, так как хотим сохранить пару лишних страниц, чем фактически требуемое количество.
Теперь в ядре настроены огромные страницы, но чтобы ваше приложение могло их использовать, вам также необходимо увеличить лимиты памяти. Новый лимит памяти должен составлять 126 страниц по 2 МБ каждая = 252 МБ, т. е. 258048 КБ.
Вам необходимо отредактировать следующие настройки в файле /etc/security/limits.conf
Иногда эти параметры настраиваются в файлах, специфичных для приложения, например, для БД Oracle в файле /etc/security/limits.d/99-grid-oracle-limits.conf
Вот оно! Вы можете перезапустить приложение, чтобы использовать эти новые огромные страницы.
Как отключить огромные страницы?
Обычно огромные страницы включены по умолчанию. Используйте приведенную ниже команду, чтобы проверить текущее состояние огромных страниц.
Флаг [всегда] в выводе показывает, что в системе включены огромные страницы.
Для систем на основе RedHat путь к файлу: /sys/kernel/mm/redhat_transparent_hugepage/enabled
Память управляется блоками, известными как страницы. Страница составляет 4096 байт. 1 МБ памяти соответствует 256 страницам; 1 ГБ памяти равен 256 000 страниц и т. д. В ЦП встроена модуль управления памятью, который содержит список этих страниц, причем ссылка на каждую страницу осуществляется через запись в таблице страниц .
Первый метод является дорогостоящим, поскольку аппаратный блок управления памятью в современном процессоре поддерживает только сотни или тысячи записей в таблице страниц.Кроме того, алгоритмы управления аппаратным обеспечением и памятью, которые хорошо работают с тысячами страниц (мегабайтами памяти), могут плохо работать с миллионами (или даже миллиардами) страниц. Это приводит к проблемам с производительностью: когда приложению требуется использовать больше страниц памяти, чем поддерживает блок управления памятью, система переключается на более медленное программное управление памятью, что приводит к замедлению работы всей системы.
Проще говоря, огромные страницы – это блоки памяти размером 2 МБ и 1 ГБ. Таблицы страниц, используемые страницами размером 2 МБ, подходят для управления несколькими гигабайтами памяти, тогда как таблицы страниц страниц размером 1 ГБ лучше всего подходят для масштабирования до терабайт памяти. Подробнее о настройке огромных страниц см. Раздел 5.2.1, «Настройка огромных страниц»
.Большими страницами может быть сложно управлять вручную, и для их эффективного использования часто требуются значительные изменения в коде. Таким образом, в Red Hat Enterprise Linux 6 также реализовано использование прозрачных огромных страниц (THP). THP – это уровень абстракции, который автоматизирует большинство аспектов создания, управления и использования огромных страниц.
THP скрывает большую часть сложности использования огромных страниц от системных администраторов и разработчиков. Поскольку целью THP является повышение производительности, его разработчики (как из сообщества, так и из Red Hat) протестировали и оптимизировали THP для широкого спектра систем, конфигураций, приложений и рабочих нагрузок. Это позволяет использовать настройки THP по умолчанию для повышения производительности большинства системных конфигураций. Однако THP не рекомендуется для рабочих нагрузок баз данных.
5.2.1. Настройка больших страниц
Огромным страницам требуются непрерывные области памяти, поэтому выделение их при загрузке является наиболее надежным методом, поскольку память еще не стала фрагментированной. Для этого добавьте в командную строку загрузки ядра следующие параметры:
Опции ядра огромных страниц
Определяет количество постоянных огромных страниц, настроенных в ядре во время загрузки. Значение по умолчанию — 0 . Выделить (или освободить) огромные страницы можно только в том случае, если в системе достаточно физически смежных свободных страниц. Страницы, зарезервированные этим параметром, нельзя использовать для других целей.
Огромные страницы размера по умолчанию можно динамически выделить или освободить, изменив значение файла /proc/sys/vm/nr_hugepages.
В системе NUMA огромные страницы, которым назначен этот параметр, поровну делятся между узлами. Вы можете назначить огромные страницы определенным узлам во время выполнения, изменив значение файла узла /sys/devices/system/node/node_id/hugepages/hugepages-1048576kB/nr_hugepages.
Для получения дополнительной информации прочитайте соответствующую документацию по ядру, которая по умолчанию устанавливается в /usr/share/doc/kernel-doc-kernel_version/Documentation/vm/hugetlbpage.txt. Эта документация доступна, только если установлен пакет kernel-doc.
Определяет размер постоянных огромных страниц, настроенных в ядре во время загрузки. Допустимые значения: 2 МБ и 1 ГБ. Значение по умолчанию – 2 МБ.
Определяет размер по умолчанию постоянных огромных страниц, настроенных в ядре во время загрузки. Допустимые значения: 2 МБ и 1 ГБ. Значение по умолчанию – 2 МБ.
В этой статье мы поговорим и узнаем о системе управления в Linux, которая в основном управляет управлением памятью. В этой статье мы поговорим о способах включения и отключения огромных страниц в Linux, о том, как определить значение огромных страниц и много другой сложной информации. Таким образом, формально определяя огромную страницу, это утилита, управляющая виртуальной памятью в системе Linux. И, как следует из самого названия, с помощью этой концепции можно управлять страницами «огромного» размера, которые в дополнение к стандартному размеру страницы 4 КБ. Можно легко обрабатывать страницы размером до 1 ГБ. Теперь нужно задаться вопросом, какие именно страницы требуют такого большого размера, и ответить, что у нас есть пример специально для вас! Подумайте об использовании базы данных с высокими требованиями к памяти.
Синтаксис огромных страниц Linux
Для огромных страниц нет определенного фиксированного синтаксиса. Но в соответствии с удобством использования для пользователя их куча, которые мы обсудим в этом разделе. Первый относится к удобству использования проверки текущей огромной информации о странице. Синтаксис для того же:
Веб-разработка, языки программирования, тестирование программного обеспечения и другое
grep Огромный /proc/meminfo
После того, как пользователь проверит детали, ему нужно будет узнать количество огромных страниц, которые в настоящее время потребуются системе. Существует сценарий, также присутствующий в Oracle, который мы опишем в разделе примеров. Теперь, когда пользователь проверил детали, это влечет за собой их настройку в случае необходимости. Это можно сделать в /etc/sysctl.conf, и как только переменная будет изменена, для перезагрузки конфигурации можно использовать следующий синтаксис:
Помимо синтаксисов, следует также с осторожностью относиться к конфигурации при ее изменении. Например, в случае изменения количества огромных страниц необходимо также изменить соответствующую заблокированную память. Кроме того, после внесения изменений в конфигурацию очень важно перезапустить приложение, чтобы изменения вступили в силу.
Как HugePages работает в Linux?
Теперь пришло время понять, как работают огромные страницы в Linux. В современной архитектуре обеспечивается поддержка нескольких размеров страниц, например, процессоры x86 могут поддерживать размеры страниц 4K и 2M (если присутствует архитектурная поддержка, также поддерживается размер страницы 1G), а ia64 поддерживает 4K, 8K, 64K, 256К и так далее. Таких примеров много. Огромные страницы имеют что-то, известное как резервный буфер перевода (сокращенно TLB), который облегчает кэширование виртуальных переводов в физические. С появлением все большего и большего объема физической памяти оптимизация скудного ресурса TLB для поддержки огромных страниц становится все более и более важной.
Теперь, когда у нас есть четкое представление о важности, очень важно знать некоторые общие параметры, чтобы поток информации в следующем абзаце был беспрепятственным. HugePages_Total — один из таких параметров, который указывает размер пула огромных страниц. HugePages_Free обозначает количество огромных страниц из пула, которые еще не выделены. HugePages_Rsvd обозначает зарезервированное количество огромных страниц, но эти страницы еще не выделены и просто «зарезервированы». HugePages_Surp – это "лишние" страницы, которые на несколько единиц превышают текущие огромные страницы, необходимые системе в данный момент.
Обучение Kali Linux (3 курса, 3+ проекта) 3 онлайн-курса | 3 практических проекта | 21+ часов | Поддающийся проверке сертификат об окончании | Пожизненный доступ
4,5 (7 956 оценок)
Теперь зарезервированные огромные страницы возвращаются в пул огромных страниц при освобождении задачей, а также зарезервированная память огромных страниц внутри ядра не может использоваться для каких-либо других целей вместе с невозможностью выгрузки при нехватке памяти. Теперь предварительное выделение огромных страниц выполняется в ядре, и после завершения выделения пользователь с соответствующими привилегиями может использовать либо системный вызов карты, либо вызовы из системы с общей памятью для использования огромных страниц. Постоянные огромные страницы могут быть выделены администратором в строке загрузки ядра при изменении параметра nr_hugepages. Это распределение также может освободить огромные страницы, если это необходимо.
Теперь, как только предварительное выделение будет выполнено, ядро попытается распределить пул огромных страниц по набору разрешенных узлов. Эти узлы определяются политикой памяти NUMA. Любой разрешенный узел с недостаточным объемом непрерывной памяти будет автоматически пропущен при выделении постоянных огромных страниц. В случае недоступности непрерывной памяти при выделении больших страниц может произойти успех или неудача выделения больших страниц. Таким образом, выделение или освобождение места на огромных страницах Linux выполняется следующим образом.
Одна важная вещь, которую следует сохранить в качестве предупреждения или примечания, заключается в том, что в случае, если администратор сократит огромные страницы с помощью nr_hugepages до числа, которое меньше, чем количество огромных страниц, используемых в настоящее время, преобразует баланс -использовать огромные страницы для избытка огромных страниц до точки, где она равна сумме nr_hugepages, и перегружать огромные страницы. Как только он пересекает это значение, больше не будет выделяться лишних огромных страниц.
Примеры огромных страниц Linux
В этом разделе мы рассмотрим все варианты, о которых мы говорили ранее, на конкретном примере.
Код:
grep Огромный /proc/meminfo
Вывод:
Объяснение: с помощью команды grep мы получаем все детали, соответствующие огромным страницам, где все свойства, такие как общее количество огромных страниц, свободные огромные страницы и т. д., равны нулю, а если для огромной страницы выделяется какой-то размер, она будет иметь 2048 КБ. по умолчанию.
Код:
Введите команду:
В файле конфигурации:
Закройте предыдущий файл и введите команду:
В файле конфигурации:
мягкий мемлок 262144
жесткий мемлок 262144
После внесения всех изменений выполните команду:
Вывод:
Объяснение. Это необходимо для увеличения числа огромных страниц с любого до необходимого нам числа 128. Теперь, как мы обсуждали ранее, ограничение памяти также должно быть увеличено или уменьшено в соответствии с файлом limit.conf.
Заключение
В этой статье мы обсудили использование огромных страниц в современной архитектуре и то, как становится все более важным иметь уверенные знания о них, чтобы использовать возможности огромных страниц в повседневной работе. С постоянно увеличивающимся размером базы данных знание огромных страниц становится скрытым благом.
Рекомендуемые статьи
Это руководство по Linux HugePages. Здесь мы обсуждаем определение и как работают огромные страницы в Linux? вместе с различными примерами и реализацией кода. Вы также можете ознакомиться со следующими статьями, чтобы узнать больше –
Читайте также: