Управление памятью в linux реферат

Обновлено: 05.07.2024

В лекции рассмотрены: управление памятью и ресурсами в Linux; файловые системы Linux; драйверы устройств Linux, поддержка сетей в Linux, безопасность в Linux.

Управление физической памятью в Linux

Виртуальная память в Linux

Исполнение и загрузка пользовательских программ в Linux

Системы файлов Linux

Ввод и вывод в Linux

Взаимодействие процессов в Linux

Структура сети в Linux

Безопасность в Linux

Развитие и использование Linux

Набор для практики

Темы для курсовых работ, рефератов, эссе

В данной лекции, как и в "Обзор архитектуры и возможностей системы Linux: архитектура, ядро, распространение и лицензирование, принципы проектирования, управление процессами" рассматриваются архитектура и возможности системы Linux. В лекции описаны управление памятью, файловые системы, драйверы устройств, поддержка сетей, безопасность в Linux, перспективы Linux и разработки на основе Linux.

Управление физической памятью в Linux

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

Распределитель страниц размещает и освобождает физические страницы; он может также по запросу размещать группы смежных страниц.

Распределитель страниц Linux использует алгоритм buddy-heap (партнерской кучи) для слежения за доступными физическими страницами, принципы которого в следующем:

Каждая область памяти, подлежащая распределению, образует пару с ее смежным "партнером".

Когда обе области-партнера освобождаются, они сливаются и образуют смежную область вдвое большего размера [15].

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

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

Расщепление памяти в куче изображено на рис. 26.1.

Рис. 26.1. Расщепление памяти в куче в системе Linux.

Виртуальная память в Linux

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

Менеджер виртуальной памяти поддерживает две точки зрения на адресное пространство каждого процесса:

Логическую – поддержка команд управления адресным пространством. Адресное пространство рассматривается как совокупность непересекающихся смежных областей.

Физическую – с помощью таблицы страниц для каждого процесса.

Для управления виртуальной памятью используются:

Файл откачки (backing store), описывающий, откуда берутся страницы для заданного региона; регионы обычно поддерживаются либо файлом, либо не поддерживаются вообще (память, обнуляемая по требованию)

Реакция региона на запись (совместное использование страниц или копирование при записи - COW).

Ядро создает новое виртуальное адресное пространство:

Когда процесс запускает новую программу системным вызовом exec;

При создании нового процесса системным вызовом fork.

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

Создание нового процесса с помощью fork включает создание полной копии адресного пространства существующего процесса.

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

Таблицы страниц процесса-родителя копируются непосредственно в таблицы страниц дочернего, причем счетчик ссылок на каждую страницу увеличивается.

После исполнения fork родительский и дочерний процесс используют одни и те же физические страницы в своих виртуальных адресных пространствах.

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

Система управления страницами делится на две части:

Алгоритм откачки, который определяет, какие страницы и когда откачать на диск;

Механизм подкачки фактически выполняет передачу и подкачивает данные обратно в физическую память, если требуется.

Ядро Linux резервирует постоянный, зависящий от архитектуры регион виртуального адресного пространства каждого процесса для его собственного внутреннего использования.

Эта область виртуальной памяти ядра содержит два региона:

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

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

Исполнение и загрузка пользовательских программ в Linux

Linux поддерживает таблицу функций для загрузки программ. Каждой функции предоставляется возможность попытаться загрузить заданный файл, когда выполняется системный вызов exec.

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

Двоичный файл формата ELF (Executable and Linkage Format) состоит из заголовка, за которым следуют несколько выравненных до страницы секций; ELF-загрузчик читает заголовок и отображает секции файла в отдельные регионы виртуальной памяти.

Структура секций файла ELF для модуля ядра Linux показана в таблица 1.

Таблица 1. Структура секций файла ELF для модуля ядра Linux

изменения времени исполнения

инструкции инициализации модуля

выходные инструкции модуля

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

текст макросов модуля

данные о версии модуля

Распределение памяти для ELF-программ в Linux изображено на рис. 26.2.

Рис. 26.2. Распределение памяти для ELF-программ.

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

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

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

Системы файлов Linux

С точки зрения пользователя файловая система Linux представляет собой иерархическое дерево директорий, подчиняющееся семантике UNIX.

С внутренней точки зрения, ядро скрывает детали реализации и управляет многими различными файловыми системами через общий уровень абстракции, то есть виртуальную файловую систему (VFS).

Linux VFS спроектирована по объектно-ориентированным принципам и использует набор определений, задающий структуру файлов. Системные структуры inode-object и file-object представляют отдельные файлы. Объект file system object представляет файловую систему в целом. Существует уровень абстракции для манипулирования этими объектами.

Файловая система Ext2fs – основная файловая системы Linux. Она использует механизм, сходный с UNIX BSD Fast File System (ffs) для поиска блоков данных, принадлежащих некоторому файлу.

Основные различия между ext2fs и ffs касаются их политик распределения дисковой памяти.

В системе ffs диск делится на файлы, состоящие из блоков по 8Kb, а блоки разбиваются на фрагменты по 1Kb для хранения мал*еньких файлов или частично заполненных блоков в конце файла.

Система Ext2fs не использует фрагменты; она распределяет память более мелкими единицами. Размер блока по умолчанию в ext2fs -1Kb, хотя блоки в 2Kb и 4Kb также поддерживаются.

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

Структурная схема системы файлов Ext2fs показана в таблица 2.

Таблица 2. Структурная схема системы файлов Ext2fs в Linux

Описани группы блоков (Group Descriptors)

Битовая карта блоков (Block Bitmap)

Битовая карта индексных дескрипторов (Inode Bitmap)

Таблица индексных дескрипторов (Inode Table)

Группы блоков в Ext2fs. Все блоки ext2 разделяются на группы блоков. Для каждой группы блоков создается отдельная запись в глобальной дескрипторной таблице, в этой записи хранятся основные параметры:

номер блока битовый карты блоков

номер блока битовой карты inode

номер блока таблицы inode

число свободных блоков в группе

число inode, содержащих каталоги.

Битовая карта блоков — это структура, каждый бит которой показывает, отведён ли соответствующий ему блок какому-либо файлу. Если бит равен 1, то блок занят. Аналогичную функцию выполняет битовая карта индексных дескрипторов, показывая какие именно индексные дескрипторы заняты, а какие нет. Ядро Linux, используя число inode, содержащих каталоги, пытается равномерно распределить inode каталогов по группам, а inode файлов помещает, если это возможно, в группу с родительским каталогом.

Все оставшееся место, обозначенное в таблице как данные, отводится для хранения файлов.

Адресация файлов в Ext2fs. Система адресации данных — одна из самых существенных составных частей файловой системы. Именно система адресации позволяет находить нужный файл среди множества как пустых, так и занятых блоков на диске.

Файловая система ext2 использует следующую схему адресации блоков файла. Для хранения адреса файла выделено 15 полей, каждое из которых состоит из 4 байтов.

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

Таким образом, 13-й элемент адреса используется для косвенной адресации. При максимальном размере блока, равном 4096 байтов, 13-й элемент может содержать до 1024 номеров следующих кластеров данных файла. Если размер файла превышает 12+1024 блоков, то используется 14-е поле, в котором находится номер блока, содержащего 1024 номеров блоков, каждый из которых хранят 1024 номеров блоков данных файла. Здесь применяется уже двойная косвенная адресация. И, наконец, если файл включает более 12+1024+1048576 = 1049612 блоков, то используется последнее 15-е поле для тройной косвенной адресации.

Таким образом, описанная выше система адресации, позволяет при максимальном размере блока 4 Кб иметь файлы размера до 2 терабайт или больше.

Схема адресации файлов в системе Ext2fs изображена на рис. 26.3.

Рис. 26.3. Адресация файлов в системе Ext2fs.

Принципы размещения блоков в системе Ext2fs иллюстрируются на рис. 26.4.

Рис. 26.4. Принципы размещения блоков в системе Ext2fs.

Файловая система Linux Proc. Файловая система proc не хранит данные; вместо этого, их содержимое вычисляется по требованию, в соответствии с пользовательскими запросами на ввод-вывод.

Система proc реализует структуру директорий и файлы, находящиеся внутри них; затем она определяет уникальный и сохраняемый номер inode для каждой директории и файлов, которые в ней содержатся. Она использует этот номер inode для идентификации, какая операция требуется, когда пользователь пытается обратиться к конкретному inode файла или выполнить поиск в конкретном inode директории.

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

Ввод и вывод в Linux

Система файлов Linux, ориентированная на устройства, осуществляет доступ к дисковой памяти с помошью двух кэшей:

Данные хранятся в кэше страниц, который объединен с системой виртуальной памяти;

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

Linux разбивает устройства на три класса:

Блочные устройства допускают произвольный доступ к полностью независимым блокам данных фиксированного размера.

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

Сетевые устройства взаимодействуют с сетевой системой ядра.

Модульная структура драйверов устройств в Linux изображена на рис. 26.5.

Рис. 26.5. Модульная структура драйверов устройств.

Блочные устройства обеспечивают основной интерфейс ко всем дисковым устройствам в системе. Блочный буферный кэш служит для двух основных целей:

Как буферный пул для активного ввода-вывода

Как кэш для завершенного ввода-вывода.

Менеджер запросов управляет чтением и записью содержимого буферов с помощью драйвера блочного устройства.

Символьные устройства. Драйвер символьного устройства не поддерживает произвольный доступ к фиксированным блокам данных.

Драйвер символьного устройства регистрирует набор функций, реализующих разнообразные требуемые операции ввода-вывода.

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

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

Взаимодействие процессов в Linux

Как и UNIX, Linux информирует процессы о наступлении событий с помощью сигналов.

Существует ограниченный набор сигналов, и они не могут нести какую-либо информацию: только факт, что сигнал имеет место, доступен процессу.

Ядро Linux не использует сигналы для коммуникации процессов, исполняемых в режиме ядра. Коммуникация внутри ядра осуществляется с помощью структур планировщика – states (состояния) и wait.queue (очередь ожидания).

Механизм конвейера (pipe) позволяет дочернему процессу наследовать коммуникационный канал от процесса-родителя. Данные, записываемые с одного конца конвейера, могут быть прочитаны на другом конце.

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

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

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

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

Разделяемые объекты помнят свое содержимое, даже если в данный момент никакие процессы не отображают их в свои виртуальные пространства памяти.

Структура сети в Linux

Работа в сети – ключевая область функциональности в Linux.

Сетевая система Linux поддерживает основные Интернет-протоколы для коммуникаций UNIX - UNIX. Она также реализует протоколы, характерные для ОС, отличных от UNIX, в частности, протоколы, используемые в сетях PC, таких как Appletalk и IPX.

Сетевая система Linux реализована в виде трех уровней абстракции:

Драйверы сетевых устройств.

Наиболее важный набор сетевых протоколов в Linux – это набор протоколов Интернета.

Сетевая система Linux обеспечивает маршрутизацию между различными машинами на любом участке сети. На верхнем уровне протокола маршрутизации поддерживаются UDP-, TCP- и ICMP-протоколы.

Безопасность в Linux

В системе Linux реализованы подключаемые аутентификационные модули (pluggable authentication modules - PAMPAM основаны на общей библиотеке, которая может быть использована любыми компонентами, где требуется аутентифицировать пользователя.

Управление доступом в системах типа UNIX, включая и Linux, осуществляется с помощью уникальных числовых идентификаторов пользователя и группы (uid и gid).

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

Linux дополняет стандартный механизм UNIX (setuid) двумя способами:

Реализует этот механизм по спецификации POSIX, что позволяет каждому процессу многократно освобождать и вновь получать свой действующий uid.

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

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

Развитие и использование Linux

Система Linux, как активно используемая и изучаемая, используется также для известных разработок. Например, все большую популярность приобретает ОС Google Android – ОС для мобильных устройств на основе ядра Linux (разработка фирмы Google).

Кроме того, в России на основе Linux разработана отечественная ОС для школьников - Альт- Линукс.

ELF (Executable and Linkage Format) – популярный формат файла исполняемого кода в UNIX и в Linux, основанный на представлении файла в виде совокупности секций.

Ext2FS – файловая система в Linux, основанная на использовании блоков небольшого размера и многоуровневой косвенной адресации .

Linux proc – файловая системы в Linux, основанная на отсутствии явного хранения данных и вычислении данных при выполнении запросов на ввод-вывод.

TTY – традиционное обозначение терминальных устройств в UNIX и Linux.

Конвейер (pipe) - механизм взаимодействия процессов в UNIX и Linux, позволяющий дочернему процессу наследовать коммуникационный канал от процесса-родителя.

Партнерская куча (buddy-heap) - метод распределения физической памяти в Linux, основанный на расщеплении блоков памяти и объединении соседних свободных блоков.

Подключаемые аутентификационные модули (pluggable authentication modules - PAM) – динамически подключаемые модули аутентификации пользователей, используемые в Linux.

Краткие итоги

Система распределения физической памяти в Linux использует механизм партнерской кучи , основанный на расщеплении свободных блоков и на объединении соседних свободных блоков памяти .

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

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

Для управления страницами используется механизм откачки и подкачки.

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

Linux поддерживает как a.out- , так и ELF -форматы файлов исполняемого кода ; статическую и динамическую линковку.

В Linux реализована виртуальная файловая система (VFS), скрывающая различие между разными системами файлов. Основная файловая система Linux – Ext2fs, основанная на использовании блоков небольшого размера, битовой карты блоков и многоуровневой косвенной адресации . Другая файловая система – Linux proc – не хранит данные явно, а генерирует их при выполнении запросов на ввод-вывод.

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

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

Для взаимодействия процессов используются конвейер ( pipe ) и разделяемые объекты в общей памяти.

Сетевая система Linux поддерживает как сетевые протоколы связи UNIX – UNIX , так и протоколы ОС, отличных от UNIX . Реализация сетевой системы Linux имеет три уровня абстракции: сокетный интерфейс , драйверы протоколов и драйверы сетевых устройств. Поддерживается набор протоколов Интернета. Обеспечивается маршрутизация пакетов на любом участке сети. На верхнем уровне протокола маршрутизации поддерживаются протоколы UDP , TCP , ICMP .

Безопасность в Linux реализована на основе динамически подключаемых аутентификационных модулей. Управление доступом , как и в UNIX , осуществляется с помощью уникальных идентификаторов пользователя и группы и масок защиты. Реализована совместимость с POSIX – возможность многократно освобождать и получать uid процесса. Кроме того, реализована возможность выборочно передавать доступ к файлу любому серверному процессу .

Направления развития и использования Linux: новые ОС на основе ядра Linux (например, ОС для мобильных устройств Google Android ) и обучение на основе Linux (российская ОС для школьников Альт Линукс).

Привет. Меня зовут Вячеслав Бирюков. В Яндексе я руковожу группой эксплуатации поиска. Недавно для студентов Курсов информационных технологий Яндекса я прочитал лекцию о работе с памятью в Linux. Почему именно память? Главный ответ: работа с памятью мне нравится. Кроме того, информации о ней довольно мало, а та, что есть, как правило, нерелевантна, потому что эта часть ядра Linux меняется достаточно быстро и не успевает попасть в книги. Рассказывать я буду про архитектуру x86_64 и про Linux-ядро версии 2.6.32. Местами будет версия ядра 3.х.

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

Термины

Резидентная память – это тот объем памяти, который сейчас находится в оперативной памяти сервера, компьютера, ноутбука.
Анонимная память – это память без учёта файлового кеша и памяти, которая имеет файловый бэкенд на диске.
Page fault – ловушка обращения памяти. Штатный механизм при работе с виртуальной памятью.

Работа с памятью организована через страницы. Объём памяти, как правило, большой, присутствует адресация, но операционной системе и железу не очень удобно работать с каждым из адресов отдельно, поэтому вся память и разбита на страницы. Размер страницы – 4 KБ. Также существуют страницы другого размера: так называемые Huge Pages размером 2 MБ и страницы размером 1 ГБ (о них мы говорить сегодня не будем).

Виртуальная память – это адресное пространство процесса. Процесс работает не с физической памятью напрямую, а с виртуальной. Такая абстракция позволяет проще писать код приложений, не думать о том, что можно случайно обратиться не на те адреса памяти или адреса другого процесса. Это упрощает разработку приложений, а также позволяет превышать размер основной оперативной памяти за счёт описанных ниже механизмов. Виртуальная память состоит из основной памяти и swap-устройства. То есть объём виртуальной памяти может быть в принципе неограниченного размера.

0 – значение по умолчанию. В этом случае используется эвристика, которая следит за тем, чтобы мы не смогли выделить виртуальной памяти в процессе намного больше, чем есть в системе;
1 – говорит о том, что мы никак не следим за объёмом выделяемой памяти. Это полезно, например, в программах для вычислений, которые выделяют большие массивы данных и работают с ними особым способом;
2 – параметр, который позволяет строго ограничивать объем виртуальной памяти процесса.

Memory Zones и NUMA

В современных системах вся виртуальная память делится на NUMA-ноды. Когда-то у нас были компьютеры с одним процессором и одним банком памяти (memory bank). Называлась такая архитектура UMA (SMP). Всё было предельно понятно: одна системная шина для общения всех компонентов. В последствии это стало неудобно, начало ограничивать развитие архитектуры, и, как следствие, была придумана NUMA.

Как видно из слайда, у нас есть два процессора, которые общаются между собой по какому-то каналу, и у каждого из них есть свои шины, через которые они общаются со своими банками памяти. Если мы посмотрим на картинку, то задержка от CPU 1 к RAM 1 в NUMA-ноде будет в два раза меньше, чем от CPU 1 на RAM 2. Получить эти данные и прочую информацию мы можем, используя команду numactl hardware .

Мы видим, что сервер имеет две ноды и информацию по ним (сколько в каждой ноде свободной физической памяти). Память выделяется на каждой ноде отдельно. Поэтому можно потребить всю свободную память на одной ноде, а другую — недогрузить. Чтобы такого не было (это свойственно базам данных), можно запускать процесс с командой numactl interleave=all. Это позволяет распределять выделение памяти между двумя нодам равномерно. В противном случае ядро выбирает ноду, на которой был запланирован запуск этого процесса (CPU scheduling) и всегда пытается выделить память на ней.

Также память в системе поделена на Memory Zones. Каждая NUMA-нода делится на какое-то количество таких зон. Они служат для поддержки специального железа, которое не может общаться по всему диапазону адресов. К примеру, ZONE_DMA – это 16 MБ первых адресов, ZONE_DMA32 – это 4 ГБ. Смотрим на зоны памяти и их состояние через файл /proc/zoneinfo .

Page Cache

Через Page Cache в Linux по умолчанию идут все операции чтения и записи. Он динамического размера, то есть именно он съест всю вашу память, если она свободна. Как гласит старая шутка, если вам нужна свободная память в сервере, просто вытащите ее из сервера. Page Cache делит все файлы, которые мы читаем, на страницы (страница, как мы сказали, – 4 KБ). Посмотреть, есть ли в Page Cache какие-то страницы какого-то конкретного файла, можно с помощью системного вызова mincore() . Или с помощью утилиты vmtouch, которая написана с использованием этого системного вызова.

Память процесса

Процесс состоит из следующих сегментов. У нас есть stack, который растет вниз; у него есть лимит дальше котрого он расти не может.

Затем идет регион mmap: там находятся все отображенные на память файлы процесса, которые мы открыли или создали через системный вызов mmap() . Далее идет большое пространство невыделенной виртуальной памяти, которую мы можем использовать. Снизу вверх растет heap – это область анонимной памяти. Внизу идут области бинарника, который мы запускаем.

Выделение памяти

Выделение памяти можно поделить на четыре случая: есть выделение приватной памяти и памяти, которой можем с кем-то поделиться (share); двумя другими категорями являются разделение на анонимную память и ту, у которая связана с файлом на диске. Самые частые функции выделения памяти – это malloc и free. Если мы говорим о glibc malloc() , то он выделяет анонимную память таким интересным способом: использует heap для аллокации маленьких объемов (менее 128 KБ) и mmap() для больших объемов. Такое выделение необходимо для того, чтобы память расходовалась оптимальнее и её можно было запросто отдавать в систему. Если в heap не хватает памяти для выделения, вызывается системный вызов brk() , который расширяет границы heap. Системный вызов mmap() занимается тем, что отображает содержимое файла на адресное пространство. munmap() в свою очередь освобождает отображение. У mmap() есть флаги, которые регулируют видимость изменений и уровень доступа.

На самом деле, Linux не выделяет всю запрошенную память сразу. Процесс выделения памяти — Demand Paging — начинается с того, что мы запрашиваем у ядра системы страничку памяти, и она попадает в область Only Allocated. Ядро отвечает процессу: вот твоя страница памяти, ты можешь её использовать. И больше ничего происходит. Никакой физической аллокации не происходит. А произойдет она только в том случае, если мы попробуем в эту страницу произвести запись. В этот момент пойдёт обращение в Page Table – эта структура транслирует виртуальные адреса процесса в физические адреса оперативной памяти. При этом будут задействованы также два блока: MMU и TLB, как видно из рисунка. Они позволяют ускорять выделение и служат для трансляции виртуальных адресов в физические.

После того, как мы понимаем, что этой странице в Page Table ничего не соответствует, то есть нет связи с физической памятью, мы получаем Page Fault – в данном случае минорный (minor), так как отсутствует обращение в диск. После этого процесса система может производить запись в выделенную страницу памяти. Для процесса все это происходит прозрачно. А мы можем наблюдать увеличение счетчика минорных Page Fault для процесса на одну единицу. Также бывает мажорный Page Fault – в случае, когда происходит обращение в диск за содержимым страницы (в случае mmpa() ).

Один из трюков в работе с памятью в Linux – Copy On Write – позволяет делать очень быстрые порождения процессов (fork).

Работа с файлами и с памятью

Подсистема памяти и подсистема работы с файлами тесно связаны. Так как работа с диском напрямую очень медленна, ядро использует в качестве прослойки оперативную память.

malloc() использует больше памяти: происходит копирование в user space. Также потребляется больше CPU, и мы получаем больше переключений контекста, чем если бы мы работали с файлом через mmap() .

Какие выводы можно сделать? Мы можем работать с файлами, как с памятью. У нас есть lazy lоading, то есть мы можем замапить очень-очень большой файл, и он будет подгружаться в память процесса через Page Cache только по мере надобности. Всё также происходит быстрее, потому что мы используем меньше системных вызовов и, в конце концов, это экономит память. Ещё стоит отметить, что при завершении программы память никуда не девается и остается в Page Cache.

В начале было сказано, что вся запись и чтение идут через Page Cache, но иногда по какой-то причине, есть необходимость в отходе от такого поведения. Некоторые программные продукты работают таким способом, например MySQL с InnoDB.

posix_fadvide();
madvise();
mincore().

Readahead

Поговорим про Readahead. Если читать файлы с диска через Page Cache каждый раз постранично, то у нас будет достаточно много Page Fault и мы будем часто ходить на диск за данными. Поэтому мы можем управлять размером Readahead: если мы прочитали первую и вторую страничку, то ядро понимает, что, скорее всего, нам нужна и третья. И так как ходить на диск дорого, мы можем прочитать немного больше заранее, загрузив файл наперёд в Page Cache и отвечать в будущем из него. Таким образом происходит замена будущих тяжёлых мажорных (major) Page Faults на минорные (minor) page fault.

Итак мы выдали всем память, все процессы довольны, и внезапно память у нас закончилась. Теперь нам нужно ее как-то освобождать. Процесс поиска и выделения свободной памяти в ядре называется Page Reclaiming. В памяти могут находится страницы памяти, которые нельзя забирать, – залокированные страницы (locked). Помимо них есть ещё четыре категории страниц. Cтраницы ядра, которые выгружать не стоит, потому что это затормозит всю работу системы; cтраницы Swappable – это такие страницы анонимной памяти, которые никуда, кроме как в swap устройство выгрузить нельзя; Syncable Pages – те, которые могут быть синхронизированы с диском, а в случае открытого файла только на чтение – такие страницы можно с лёгкостью выбросить из памяти; и Discardable Pages – это те страницы, от которых можно просто отказаться.

Источники пополнения Free List

Если говорить упрощённо, то у ядра есть один большой Free List (на самом деле, это не так), в котором хранятся страницы памяти, которые можно выдавать процессам. Ядро пытается поддерживать размер этого списка в каком-то не нулевом состоянии, чтобы быстро выдавать память процессам. Пополняется этот список за счёт четырех источников: Page Cache, Swap, Kernel Memory и OOM Killer.

Мы должны различать участки памяти на горячую и холодную и как-то пополнять за счет них наши Free Lists. Page Cache устроен по принципу LRU/2 очереди. Есть активный список страниц (Active List) и инактивный список (Inactive List) страничек, между которыми есть какая-то связь. В Free List прилетают запросы на выделение памяти (allocation). Система отдаёт страницы из головы этого списка, а в хвост списка попадают страницы из хвоста инактивного (inactive) списка. Новые страницы, когда мы читаем файл через Page Cache, всегда попадают в голову и проходят до конца инактивного списка, если в эти страницы не было еще хотя бы одного обращения. Если такое обращение было в любом месте инактивного списка, то страницы попадают сразу в голову активного списка и начинают двигаться в сторону его хвоста. Если же в этот момент опять к ним происходит обращение, то страницы вновь пробиваются в верх списка. Таким образом система пытается сбалансировать списки: самые горячие данные всегда находятся в Page Cache в активном списке, и Free List никогда не пополняется за их счет.

Также тут стоит отметить интересное поведение: страницы, за счет которых пополняется Free List, которые в свою очередь прилетают из инактивного списка, но до сих пор не отданные для аллокации, могут быть возвращены обратно в инактивный списка (в данном случае в голову инактивного списка).

Итого у нас получается пять таких листов: Active Anon, Inactive Anon, Active File, Inactive File, Unevictable. Такие списки создаются для каждой NUMA ноды и для каждой Memory Zone.

Оригинал: "Linux memory management"
Автор: Riccardo Capecchi
Дата публикации: June 22, 2012
Перевод: Н.Ромоданов
Дата перевода: август 2012 г.

Я думаю, что обычно у каждого пользователя Linux рано или поздно возникает следующий вопрос, задаваемый при администрировании рабочей станции или сервера - "Почему в Linux используется вся моя оперативная память, хотя никакой большой работы не выполняется? ". К нему сегодня я добавлю еще один вопрос, который, я уверен, обычен для многих системных администраторов Linux - "Почему команда free показывает память swap и почему у меня так много свободной оперативной памяти?", так что сегодняшнее мое исследование SwapCached, которое я представляю вам, может оказаться полезным, либо, по крайней мере, ознакомит, как я надеюсь, с информацией об управлении памятью в системе Linux.

В Linux применяется следующее основное правило: неиспользуемая страница оперативной памяти считается потерянной памятью. Оперативная память тратится не только для данных, используемых прикладными приложениями. В ней также хранятся данные для самого ядра и, самое главное, в эту память могут отображаться данные, хранящиеся на жестком диске, что используется для супер-быстрого к ним доступа - команда top указывает об этом в столбцах "buffers/cache" ("буферы / кэш"), "disk cache" ("дисковый кэш)" или "cached" ("кэшировано"). Кэшированная память по сути свободна, поскольку ее можно быстро освободить в случае, если работающей (или только что запущенной) программе потребуется память.

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

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

Ниже приведены данные, выдаваемые на моем старом ноутбуке с системой Xubuntu:

В строке -/+ buffers/cache показывается, сколько памяти используется и сколько памяти свободно с точки зрения ее использования в приложениях. В этом примере приложениями уже используется 972 Мб памяти и еще 534 МБ памяти могут быть использованы.

Вообще говоря, если используется хотя бы немного памяти подкачки swap, то использование памяти вообще не повлияет на производительность системы.

Но если вы хотите получить более подробную информацию о вашей памяти, то вы должны проверить файл /proc/meminfo; в моей системе Xubuntu с ядром 3.2.0-25-generic результат будет следующим:

Что означает MemTotal (Всего памяти) и MemFree (Свободная память), понятно для всех; остальные значения поясняются дальше:

Cached

Страничный кэш в системе Linux ("Cached:" в meminfo) является в большинстве систем самым крупным потребителем памяти. Каждый раз, когда вы выполняете операцию чтения read () из файла, расположенного на диске, данные считываются в память и помещаются в страничный кэш. После того, как операция read() завершается, ядро может просто выбросить страницу памяти, так как она не используется. Однако, если вы второй раз выполняете операцию чтения той же самой части файла, данные будут считываться непосредственно из памяти и обращения к диску не будет. Это невероятно ускоряет работу и, поэтому, в Linux так интенсивно используется кэширование страниц: ставка делается на то, что если вы обратились к некоторой странице дисковой памяти, то вскоре вы обратитесь к ней снова.

dentry/inode caches

Каждый раз, когда вы в файловой системе выполняете операцию "ls"" (или любую другую операцию: open(), stat() и т.д.), ядру требуются данные, которые находятся на диске. Ядро анализирует эти данные, находящиеся на диске, и помещает его в некоторых структуры данных, независимые от файловой системы, с тем, чтобы они могли в различных файловых системах обрабатываться одним и тем же образом. Таким же самым образом, как кэширование страниц в приведенных выше примерах, ядро может после того, как будет завершена команда "ls", стереть эти структуры. Тем не менее, делается такое же предположение, как и раньше: если вы однажды считали эти данные, вы обязательно прочитаете их еще раз. Ядро хранит эту информацию в нескольких местах "кэша", которые называются кэш памятью dentry и inode. Кэш память dentries являются общей для всех файловых систем, но каждая файловая система имеет свой собственный кэш inodes.

Эта оперативная память является в meminfo составной частью "Slab:"

Вы можете просмотреть различную кэш память и узнать ее размеры с помощью следующей команды:

Buffer Cache

Кэш буфера ("Buffers:" в meminfo) является близким родственником кэш памяти dentry/inode. Данные dentries и inodes, размещаемые в памяти, представляют собой описание структур на диске, но располагаются они по-разному. Это, возможно, связано с тем, что у нас в копии, расположенной в памяти, используется такая структура, как указатель, но на диске ее нет. Может также случиться, что на диске байты будут располагаться не в том порядке, как это нужно процессору.

Отображение памяти в команде top: VIRT, RES и SHR

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

VIRT является сокращением от virtual size of a process (виртуальный размер процесса) и представляет собой общий объем используемой памяти: памяти, отображаемой самой в себя (например, памяти видеокарты для сервера X), файлов на диске, которые отображаются в память (особенно это касается разделяемых библиотек) и памяти, разделяемой совместно с другими процессами. Значение VIRT указывает, сколько памяти в настоящий момент доступно программе.

RES является сокращением от resident size (размер резидентной части) и является точным указателем того, сколько в действительности потребляется процессом реальной физической памяти. (Что также соответствует значению, находящемуся непосредственно в колонке %MEM). Это значение практически всегда меньше, чем размер VIRT, т.к. большинство программ зависит от библиотеки C.

SHR показывает, какая величина от значения VIRT является в действительности разделяемой (по памяти или за счет использования библиотек). В случае библиотек, это не обязательно означает, что вся библиотека находится в резидентной памяти. Например, если программа использует только несколько функций библиотеки, то при отображении в память будет использована вся библиотека, что будет учтено в значениях VIRT и SHR, но, на самом деле, будет загружена часть библиотеки, содержащая используемые функции, и это будет учтено в значении RES.

Подкачка памяти - swap

Теперь мы видим некоторую информацию о нашей оперативной памяти, но что происходит, когда больше нет свободной оперативной памяти? Если у меня нет свободной памяти, а мне нужна память для страничного кэширования, кэширования inode или кэширования dentry, то где я ее могу получить?

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

На основании общего объема оперативной памяти и соотношения ее различных типов (память high/low), ядро эвристически определяет то количество памяти в качестве рабочего пространства, при котором оно чувствует себя комфортно. Когда эта величина достигается, ядро начинает возвращать память для других различных задач, описанных выше. Ядро может вернуть себе память из любой из этих задач.

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

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

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

Вы можете с помощью команды free проверить, используется ли память swap; для примера, который я уже использовал выше, в последней строке выдаваемых данных показывается информация о размере памяти swap:

Мы видим, что на этом компьютере уже используется 24 мегабайта памяти swap и для использования доступно еще 462 Мб.

Таким образом, сам факт использования памяти swap не является доказательством того, что в системе при ее текущей рабочей нагрузке слишком мало оперативной памяти. Лучший способ это определить с помощью команды vmstat - если вы увидите, что много страниц памяти swap перемещаются на диск и обратно, то это означает, что память swap используется активно, что система "пробуксовывает" или что ей нужна новая оперативная память поскольку это ускорит подкачку данных приложений.

На моем ноутбуке Gentoo, когда он простаивает, это выглядит следующим образом:

Обратите внимание на то, что в выходных данных команды free у вас есть только 2 значения, относящихся к памяти swap: free (свободная память) и used (используемая память), но для памяти подкачки swap также есть еще одно важное значение: Swap cache (показатель кэширования памяти подкачки).

Кэширование памяти swap (Swap Cach)

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

Поэтому, чтобы узнать, что память swap действительно используется, мы должны из значения SwapUsed вычесть значение SwapCached, вы можете найти эту информацию в /proc/meminfo.

Подкачка памяти

Когда приложению нужна память, а вся оперативная память полностью занята, то в распоряжении ядра есть два способа освободить память: оно может либо уменьшить размер дискового кэша в оперативной памяти, убирая устаревшие данные, либо оно может сбросить на диск в swap раздел несколько достаточно редко используемых порций (страниц) программы. Трудно предсказать, какой из способов будет более эффективным. Ядро, исходя из недавней истории действий в системе, делает попытку приблизительно отгадать на данный момент эффективность каждого из этих двух методов.

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

Подкачке памяти назначается значение от 0 до 100, которое изменяет баланс между подкачкой памяти приложений и освобождением кэш памяти. При значении 100 ядро всегда предпочтет найти неактивные страницы и сбросить их на диск в раздел swap; в других случаях этот сброс будет осуществляться в зависимости от того, сколько памяти занимает приложение и насколько трудно выпонять кэширование при поиске и удалении неактивных элементов.

По умолчанию для этого устанавливается значение 60. Значение 0 дает нечто близкое к старому поведению, когда приложения, которым нужна память, заставляли немного уменьшить размер кэша оперативной памяти. Для ноутбуков, для которых предпочтительно иметь диски с меньшей скоростью вращения, рекомендуется использовать значение 20 или меньше.

Заключение

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

Читайте также: