2.01. Управление памятью в Linux

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВВ РАЗРАБОТКЕ

Разработчику Архитектору Инженеру

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

Как устроена память

Память в современных компьютерах представляет собой иерархическую систему, где каждый уровень отличается скоростью доступа, объёмом и стоимостью. На вершине этой иерархии находятся регистры процессора — самые быстрые, но крайне ограниченные по объёму ячейки хранения данных. Ниже располагаются кэш-память первого, второго и третьего уровней, которые служат буферами между регистрами и основной оперативной памятью. Оперативная память (RAM) обеспечивает временное хранение данных и инструкций, с которыми работает центральный процессор. Она значительно медленнее кэша, но обладает гораздо большим объёмом.

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

Виртуальная память разбивается на страницы — блоки фиксированного размера, обычно 4 килобайта на архитектуре x86-64. Соответствующие блоки в физической памяти называются фреймами. Связь между виртуальными страницами и физическими фреймами устанавливается с помощью таблиц страниц, управляемых аппаратно (через Memory Management Unit — MMU) и программно (через ядро операционной системы). Когда процесс обращается к виртуальному адресу, MMU преобразует его в физический с помощью этих таблиц. Если запрошенная страница отсутствует в оперативной памяти, возникает исключение — page fault — и ядро загружает нужную страницу с диска или выделяет новую.

Такая архитектура решает сразу несколько задач: изоляцию процессов, защиту памяти, эффективное использование ресурсов и поддержку адресных пространств, превышающих объём физической RAM. Память становится не просто хранилищем, а управляемым ресурсом, которым распоряжается операционная система в интересах стабильности, безопасности и производительности всей системы.

Как работает Linux с памятью

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

Центральным элементом управления памятью в Linux является подсистема управления памятью (Memory Management Subsystem), которая взаимодействует с аппаратным обеспечением через MMU и отвечает за распределение, защиту, маппинг и освобождение памяти. Linux использует многоуровневые таблицы страниц, что позволяет эффективно работать с разрежёнными адресными пространствами — когда большая часть виртуальной памяти не используется, и выделять физическую память только по мере необходимости.

Одной из ключевых особенностей Linux является подход «ленивой» (lazy) аллокации памяти. При вызове функции malloc() в пользовательском пространстве система не сразу выделяет физическую память. Вместо этого она лишь резервирует виртуальные адреса и обновляет метаданные процесса. Фактическое выделение физических страниц происходит только при первом обращении к этим адресам — в момент page fault. Это позволяет экономить ресурсы, особенно в случаях, когда программы резервируют большой объём памяти, но используют лишь его часть.

Linux также активно использует swap-пространство — область на диске, куда могут быть выгружены редко используемые страницы оперативной памяти. Это расширяет доступное адресное пространство и позволяет системе работать даже при нехватке RAM, хотя и с потерей производительности. Механизм замещения страниц (page replacement) определяет, какие страницы следует выгружать, основываясь на таких алгоритмах, как LRU (Least Recently Used) и его модификации.

Кроме того, Linux поддерживает shared memory — общий сегмент памяти, доступный нескольким процессам одновременно. Это один из самых быстрых способов межпроцессного взаимодействия, поскольку данные не копируются между процессами, а читаются и записываются напрямую в общую область. Такой механизм требует синхронизации, но крайне эффективен для передачи больших объёмов информации.

Как работает Windows с памятью

Windows также использует виртуальную память и страничную организацию, но с рядом отличий в деталях реализации. Адресное пространство процесса в Windows делится на пользовательскую и ядерную части. В 32-битных системах эта граница обычно проходит на отметке 2 ГБ, хотя может быть изменена до 3 ГБ. В 64-битных системах пользовательская часть значительно больше, достигая сотен терабайт.

Windows применяет двухуровневую модель управления памятью: виртуальная память и физическая память. Подсистема управления памятью Windows (Memory Manager) отвечает за выделение, защиту, совместное использование и освобождение памяти. Она тесно интегрирована с диспетчером процессов и планировщиком, чтобы обеспечивать справедливое распределение ресурсов.

Как и Linux, Windows использует lazy allocation: при запросе памяти через VirtualAlloc() или стандартные функции CRT (например, malloc()) система резервирует виртуальные адреса, но не выделяет физическую память до момента первого обращения. Этот механизм также сопровождается генерацией page fault, который обрабатывается ядром.

Windows активно использует файл подкачки (pagefile.sys) как аналог swap-пространства в Linux. Он может быть настроен вручную или управляться автоматически. Интересной особенностью Windows является то, что даже при достаточном объёме RAM система может использовать файл подкачки для оптимизации работы — например, перемещая в него неактивные страницы, чтобы освободить место для более активных процессов.

Windows также поддерживает shared memory через объекты секций (section objects), которые могут быть отображены в адресные пространства нескольких процессов. Для синхронизации доступа к таким областям используются примитивы синхронизации: мьютексы, семафоры, события.

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

Как происходит управление памятью

Управление памятью — это комплексная задача, охватывающая как аппаратные, так и программные аспекты. На аппаратном уровне MMU отвечает за трансляцию виртуальных адресов в физические с использованием таблиц страниц. Эти таблицы иерархичны: на x86-64 обычно используются четыре уровня (PML4, PDPT, PD, PT), что позволяет адресовать огромные объёмы памяти без избыточного потребления ресурсов.

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

Когда процесс запрашивает память, он взаимодействует с библиотекой времени выполнения (например, glibc в Linux), которая в свою очередь обращается к системным вызовам ядра (brk, sbrk, mmap). Ядро обновляет структуры данных процесса, резервирует виртуальные адреса и, при необходимости, выделяет физические страницы. При освобождении памяти (free()) библиотека может либо вернуть память ядру, либо сохранить её в пуле для последующих выделений, чтобы минимизировать системные вызовы.

Механизм page fault играет центральную роль. Он возникает в трёх основных случаях: при обращении к ещё не выделенной странице (demand paging), при обращении к странице, выгруженной в swap, и при нарушении прав доступа (например, запись в read-only страницу). Обработчик page fault в ядре анализирует причину и принимает решение: выделить новую страницу, загрузить её с диска или завершить процесс с ошибкой.

Для повышения эффективности используются такие техники, как copy-on-write (COW): при создании дочернего процесса через fork() страницы не копируются, а разделяются между родителем и потомком. Копирование происходит только при попытке записи, что экономит время и память. Также применяется memory mapping файлов — отображение содержимого файла непосредственно в адресное пространство процесса, что упрощает работу с большими файлами и позволяет использовать кэш ядра.

Программы управляют памятью через ОС

Программы не взаимодействуют с физической памятью напрямую. Вся работа с памятью осуществляется через абстракции, предоставляемые операционной системой. Это обеспечивает безопасность, стабильность и переносимость приложений. Даже низкоуровневые языки, такие как C или C++, при вызове malloc() или new обращаются к библиотеке времени выполнения, которая, в свою очередь, использует системные вызовы для взаимодействия с ядром.

Системные вызовы — это интерфейс между пользовательским пространством и ядром. В Linux основными вызовами для управления памятью являются brk/sbrk (для расширения кучи) и mmap (для отображения файлов или выделения анонимной памяти). Вызов mmap особенно гибок: он может создавать частные или разделяемые отображения, с файловой поддержкой или без неё, с различными флагами защиты.

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

Операционная система также предоставляет механизмы для мониторинга и отладки использования памяти. В Linux это /proc/[pid]/maps, /proc/meminfo, утилиты top, htop, vmstat, pmap, а также API вроде mallinfo() или malloc_stats(). Эти инструменты позволяют разработчикам анализировать потребление памяти, выявлять утечки и оптимизировать производительность.

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

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

Управление памятью в Linux — это результат эволюции, сочетающий проверенные временем подходы с современными оптимизациями. Ядро Linux использует зонную модель физической памяти (Zones), чтобы учитывать особенности архитектуры: например, DMA-устройства могут обращаться только к первым 16 МБ памяти, поэтому выделяется специальная зона ZONE_DMA. Основная память находится в ZONE_NORMAL, а на 32-битных системах с большим объёмом RAM — в ZONE_HIGHMEM.

Аллокатор памяти ядра (buddy allocator) управляет физическими страницами. Он группирует свободные страницы в блоки размером 2^n и быстро находит подходящий блок при запросе. При освобождении соседние блоки объединяются, чтобы уменьшить фрагментацию. Для мелких объектов используется slab allocator (или его современные реализации SLUB и SLOB), который кэширует часто используемые структуры ядра, минимизируя накладные расходы на выделение и освобождение.

В пользовательском пространстве управление памятью делегировано библиотекам. glibc по умолчанию использует ptmalloc, но возможна замена на другие аллокаторы, такие как jemalloc или tcmalloc, которые могут показывать лучшую производительность в многопоточных сценариях. Эти аллокаторы реализуют сложные стратегии: разделение по размеру, thread-local кэши, eager coalescing и другие техники для снижения contention и фрагментации.

Linux предоставляет гибкие настройки через sysctl-параметры. Например, vm.swappiness регулирует склонность системы к выгрузке страниц в swap, vm.overcommit_memory контролирует политику выделения памяти (строгая проверка или optimistic overcommit), а vm.dirty_ratio определяет, сколько dirty pages может быть в памяти до принудительной записи на диск.

Механизм OOM Killer (Out-Of-Memory Killer) срабатывает в критических ситуациях, когда система исчерпывает все ресурсы памяти. Он выбирает процесс для завершения на основе эвристики, учитывающей потребление памяти, приоритет и другие факторы. Это крайняя мера, направленная на предотвращение полного зависания системы.

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

Таблицы и примеры управления памятью

Системные вызовы для работы с памятью в Linux

Linux предоставляет несколько системных вызовов, через которые пользовательские программы взаимодействуют с подсистемой управления памятью. Эти вызовы лежат в основе всех высокоуровневых функций выделения памяти, таких как malloc() или new.

Системный вызов	Назначение	Особенности
`brk(addr)`	Устанавливает новую границу кучи (program break)	Работает только с непрерывным расширением кучи; устаревший, но всё ещё используется
`sbrk(incr)`	Увеличивает или уменьшает границу кучи на указанное количество байт	Обёртка над `brk`; не рекомендуется в новых программах
`mmap(addr, length, prot, flags, fd, offset)`	Отображает регион памяти (анонимный или связанный с файлом) в адресное пространство процесса	Гибкий, поддерживает разделяемую и частную память, файловое отображение, защиту
`munmap(addr, length)`	Удаляет отображение памяти	Освобождает виртуальное адресное пространство и, при необходимости, физические страницы
`mprotect(addr, len, prot)`	Изменяет права доступа к уже отображённому региону памяти	Полезно для реализации execute-only или read-only областей

Эти вызовы работают на уровне ядра. Библиотеки времени выполнения, такие как glibc, используют их для реализации удобных интерфейсов, например malloc().

Пример: ручное выделение памяти через `mmap`

Ниже приведён пример программы на C, которая выделяет 1 МБ анонимной памяти через mmap, записывает в неё данные, читает их обратно и освобождает память.

#include <sys/mman.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main() {
    size_t size = 1024 * 1024; // 1 МБ
    char *mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (mem == MAP_FAILED) {
        perror("mmap failed");
        return 1;
    }

    const char *message = "Hello from mmap!";
    strcpy(mem, message);
    printf("Read from mapped memory: %s\n", mem);

    if (munmap(mem, size) == -1) {
        perror("munmap failed");
        return 1;
    }

    return 0;
}

Этот код демонстрирует прямое управление виртуальной памятью без участия malloc. Память выделяется немедленно в виртуальном пространстве, но физические страницы появляются только при первом обращении — благодаря механизму demand paging.

Пример: использование `malloc` и поведение при page fault

Рассмотрим программу, которая запрашивает большой объём памяти через malloc, но использует лишь часть из него.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main() {
    size_t total = 1024 * 1024 * 100; // 100 МБ
    char *buffer = malloc(total);

    if (!buffer) {
        fprintf(stderr, "malloc failed\n");
        return 1;
    }

    // Используем только первые 4 КБ
    memset(buffer, 42, 4096);
    printf("First page initialized\n");

    // Остальная память не вызывает page fault
    free(buffer);
    return 0;
}

В этом случае malloc зарезервировал 100 МБ виртуального адресного пространства, но ядро выделило физическую память только для первой страницы (4096 байт). Остальные 99+ МБ существуют только как записи в таблицах страниц, но не потребляют RAM. Это поведение называется lazy allocation и характерно для большинства современных Unix-подобных систем.

Состояние памяти процесса: `/proc/[pid]/maps`

Linux предоставляет подробную информацию о виртуальном адресном пространстве каждого процесса через виртуальную файловую систему /proc. Файл /proc/[pid]/maps содержит список всех отображённых регионов памяти.

Пример содержимого /proc/self/maps для простой программы:

55d8b3a5a000-55d8b3a5b000 r--p 00000000 08:02 1234567 /home/user/test
55d8b3a5b000-55d8b3a5c000 r-xp 00001000 08:02 1234567 /home/user/test
55d8b3a5c000-55d8b3a5d000 r--p 00002000 08:02 1234567 /home/user/test
55d8b3a5d000-55d8b3a5e000 r--p 00002000 08:02 1234567 /home/user/test
55d8b3a5e000-55d8b3a5f000 rw-p 00003000 08:02 1234567 /home/user/test
55d8b4c00000-55d8b4c21000 rw-p 00000000 00:00 0       [heap]
7f8b2c000000-7f8b2c021000 rw-p 00000000 00:00 0
7f8b2c021000-7f8b30000000 ---p 00000000 00:00 0
7f8b30e00000-7f8b30e25000 r--p 00000000 08:02 789012 /usr/lib/x86_64-linux-gnu/libc.so.6
7f8b30e25000-7f8b30f9d000 r-xp 00025000 08:02 789012 /usr/lib/x86_64-linux-gnu/libc.so.6
7f8b3119d000-7f8b311a1000 r--p 0019d000 08:02 789012 /usr/lib/x86_64-linux-gnu/libc.so.6
7f8b311a1000-7f8b311a3000 rw-p 001a1000 08:02 789012 /usr/lib/x86_64-linux-gnu/libc.so.6
7ffcb1a00000-7ffcb1a21000 rw-p 00000000 00:00 0       [stack]
7ffcb1bfe000-7ffcb1c00000 r--p 00000000 00:00 0       [vvar]
7ffcb1c00000-7ffcb1c02000 r-xp 00000000 00:00 0       [vdso]

Каждая строка содержит:

Диапазон виртуальных адресов
Права доступа (r — чтение, w — запись, x — исполнение, p — private, s — shared)
Смещение в файле
Устройство и inode
Путь к файлу (если применимо)

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

Пример: shared memory через `mmap`

Shared memory — один из самых быстрых способов межпроцессного взаимодействия. Ниже пример двух процессов, обменивающихся данными через общую память.

Создание и запись (writer.c):

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main() {
    const char *name = "/my_shm";
    const size_t size = 4096;

    int fd = shm_open(name, O_CREAT | O_RDWR, 0666);
    ftruncate(fd, size);

    char *mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    strcpy(mem, "Data from writer process");
    printf("Writer: wrote message\n");

    sleep(2); // даём время читателю
    munmap(mem, size);
    close(fd);
    shm_unlink(name);
    return 0;
}

Чтение (reader.c):

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    const char *name = "/my_shm";
    const size_t size = 4096;

    int fd = shm_open(name, O_RDONLY, 0666);
    char *mem = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
    printf("Reader: received '%s'\n", mem);

    munmap(mem, size);
    close(fd);
    return 0;
}

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

Параметры ядра, влияющие на управление памятью

Linux позволяет настраивать поведение подсистемы памяти через файлы в /proc/sys/vm/. Ниже ключевые параметры.

Параметр	Описание	Типичное значение
`vm.swappiness`	Склонность системы выгружать страницы в swap (0–100)	60 (по умолчанию)
`vm.overcommit_memory`	Политика выделения памяти: 0 — эвристическая, 1 — всегда разрешать, 2 — строгая проверка	0
`vm.overcommit_ratio`	Процент RAM, который можно «перевыделить» при `overcommit_memory=2`	50
`vm.dirty_ratio`	Максимальный процент dirty pages в памяти до принудительной записи на диск	20
`vm.min_free_kbytes`	Минимальный объём свободной памяти, который ядро старается поддерживать	Зависит от RAM

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

Пример: проверка использования памяти через `/proc/meminfo`

Файл /proc/meminfo содержит сводку по всей памяти системы:

MemTotal:        8023456 kB
MemFree:         1234567 kB
MemAvailable:    3456789 kB
Buffers:          123456 kB
Cached:          2345678 kB
SwapTotal:       2097148 kB
SwapFree:        2097148 kB
Active:          3000000 kB
Inactive:        1500000 kB
...

MemTotal — общий объём RAM.
MemFree — полностью неиспользуемая память.
MemAvailable — оценка памяти, доступной для новых приложений без подкачки.
Cached — память, используемая для кэширования файлов (может быть освобождена при необходимости).
Active/Inactive — страницы, которые активно используются или редко трогаются.

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

Аллокаторы памяти в пользовательском пространстве

ptmalloc: стандартный аллокатор в glibc

Аллокатор ptmalloc — это реализация, встроенная в библиотеку glibc, и используется по умолчанию в большинстве дистрибутивов Linux. Он основан на алгоритме dlmalloc (Doug Lea’s malloc), но расширен поддержкой многопоточности через механизм arenas.

Каждый поток может иметь свою arena — область управления памятью, которая минимизирует конкуренцию за общий ресурс. При первом вызове malloc() в потоке создаётся новая arena, если общая arena занята. Это снижает contention, но может привести к фрагментации памяти, так как каждая arena управляет своим пулом страниц.

ptmalloc делит выделения на три категории:

Малые блоки (до 512 байт) — обслуживаются через fast bins и small bins.
Средние блоки — используют unsorted bins и large bins.
Большие блоки (обычно свыше 128 КБ) — выделяются напрямую через mmap.

При освобождении памяти (free()) блоки не сразу возвращаются ядру. Они помещаются в корзины (bins) и могут быть переиспользованы при последующих запросах. Только при явном вызове malloc_trim() или при завершении программы память может быть возвращена ОС.

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

jemalloc: аллокатор от FreeBSD и Facebook

jemalloc разработан для снижения фрагментации и contention в многопоточных средах. Он стал популярным благодаря использованию в таких проектах, как Firefox, Redis и Rust.

Основные принципы:

Чёткое разделение памяти на arenas, chunks, runs и regions.
Каждый поток привязан к своей arena, что исключает блокировки.
Используется size classing: все запросы округляются до ближайшего размера из фиксированного набора, что упрощает повторное использование.
Поддержка profiling и introspection через API.

Пример подключения jemalloc к программе на C:

// Компиляция с jemalloc
// gcc -o app app.c -ljemalloc

#include <stdlib.h>
#include <stdio.h>

int main() {
    char *buf = malloc(1024);
    if (buf) {
        printf("Выделено 1 КБ через jemalloc\n");
        free(buf);
    }
    return 0;
}

Для замены аллокатора без перекомпиляции можно использовать переменную окружения:

LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so.2 ./my_program

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

tcmalloc: Thread-Caching Malloc от Google

tcmalloc (Thread-Caching Malloc) — часть проекта Google Performance Tools. Он оптимизирован для низкой задержки и высокой скорости в многопоточных программах.

Особенности:

Каждый поток имеет thread-local cache — небольшой пул готовых блоков.
Маленькие выделения (до ~32 КБ) обслуживаются из кэша без системных вызовов.
Большие выделения передаются напрямую ядру через mmap.
Минимальные накладные расходы на синхронизацию.

tcmalloc также предоставляет интерфейс для сбора статистики:

#include <gperftools/malloc_extension.h>
#include <stdio.h>

int main() {
    size_t heap_size;
    MallocExtension::instance()->GetNumericProperty("generic.heap_size", &heap_size);
    printf("Текущий размер кучи: %zu байт\n", heap_size);
    return 0;
}

Компиляция:

g++ -o app app.cpp -ltcmalloc

tcmalloc особенно эффективен в C++-приложениях с частыми выделениями мелких объектов.

Huge Pages: ускорение работы с памятью

Стандартный размер страницы в Linux — 4 КБ. Однако при работе с большими объёмами данных (например, в базах данных или HPC) накладные расходы на обход многоуровневых таблиц страниц становятся значительными. Для решения этой проблемы Linux поддерживает huge pages — страницы увеличенного размера (обычно 2 МБ или 1 ГБ на x86-64).

Преимущества:

Снижение количества записей в TLB (Translation Lookaside Buffer).
Уменьшение числа page faults.
Повышение производительности при сканировании больших массивов.

Настройка transparent huge pages (THP)

Linux предоставляет механизм Transparent Huge Pages (THP), который автоматически объединяет обычные страницы в huge pages без изменений в коде приложения.

Проверить статус:

cat /sys/kernel/mm/transparent_hugepage/enabled

Возможные значения:

always — всегда использовать THP.
madvise — использовать только для регионов, помеченных madvise(MADV_HUGEPAGE).
never — отключить.

Рекомендуется использовать madvise в production, так как always может вызывать задержки при компактификации памяти.

Явное использование huge pages

Для полного контроля можно выделять huge pages вручную:

#define _GNU_SOURCE
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    size_t size = 2 * 1024 * 1024; // 2 МБ
    void *addr = mmap(NULL, size, PROT_READ | PROT_WRITE,
                      MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);

    if (addr == MAP_FAILED) {
        perror("mmap hugepage failed");
        return 1;
    }

    printf("Huge page выделена по адресу %p\n", addr);
    munmap(addr, size);
    return 0;
}

Перед запуском необходимо выделить huge pages в системе:

echo 10 > /proc/sys/vm/nr_hugepages  # 10 страниц по 2 МБ

Учёт NUMA-топологии

На многопроцессорных системах с архитектурой NUMA (Non-Uniform Memory Access) время доступа к памяти зависит от того, к какому процессору подключён модуль RAM. Доступ к «локальной» памяти быстрее, чем к «удалённой».

Linux предоставляет инструменты для управления NUMA-политиками:

numactl — запуск процесса с заданной политикой.
libnuma — API для управления памятью в коде.

Пример политики:

# Запустить программу, привязав её к CPU 0 и локальной памяти
numactl --cpunodebind=0 --membind=0 ./my_app

В коде:

#include <numa.h>
#include <stdio.h>

int main() {
    if (numa_available() == -1) {
        printf("NUMA не поддерживается\n");
        return 1;
    }

    numa_set_preferred(0); // предпочитать узел 0
    char *data = numa_alloc_onnode(1024 * 1024, 0); // выделить на узле 0
    if (data) {
        printf("Память выделена на NUMA-узле 0\n");
        numa_free(data, 1024 * 1024);
    }
    return 0;
}

Компиляция:

gcc -o numa_app numa_app.c -lnuma

Правильное учёт NUMA критичен для высокопроизводительных систем, таких как СУБД или HPC-кластеры.

Профилирование и отладка использования памяти

Valgrind: обнаружение утечек и ошибок

Valgrind — мощный инструмент для анализа использования памяти. Его компонент memcheck отслеживает:

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

Пример:

#include <stdlib.h>

int main() {
    char *p = malloc(100);
    // free(p); // закомментировано — утечка
    return 0;
}

Запуск:

gcc -g -o leak leak.c
valgrind --leak-check=full ./leak

Вывод покажет точное место утечки, размер и стек вызовов.

Perf и eBPF: анализ на уровне ядра

Современные инструменты, такие как perf и bpftrace, позволяют отслеживать события управления памятью на уровне ядра:

# Отслеживать page faults
perf stat -e page-faults,minor-faults,major-faults ./my_app

# Анализ с помощью bpftrace
bpftrace -e 'tracepoint:syscalls:sys_enter_mmap { printf("mmap called\n"); }'

Эти инструменты полезны для глубокого анализа производительности без изменения кода.

Управление памятью в Linux​

Как устроена память​

Как работает Linux с памятью​

Как работает Windows с памятью​

Как происходит управление памятью​

Программы управляют памятью через ОС​

Управление памятью в Linux​

Таблицы и примеры управления памятью​

Системные вызовы для работы с памятью в Linux​

Пример: ручное выделение памяти через mmap​

Пример: использование malloc и поведение при page fault​

Состояние памяти процесса: /proc/[pid]/maps​

Пример: shared memory через mmap​

Параметры ядра, влияющие на управление памятью​

Пример: проверка использования памяти через /proc/meminfo​

Аллокаторы памяти в пользовательском пространстве​

ptmalloc: стандартный аллокатор в glibc​

jemalloc: аллокатор от FreeBSD и Facebook​

tcmalloc: Thread-Caching Malloc от Google​

Huge Pages: ускорение работы с памятью​

Настройка transparent huge pages (THP)​

Явное использование huge pages​

Учёт NUMA-топологии​

Профилирование и отладка использования памяти​

Valgrind: обнаружение утечек и ошибок​

Perf и eBPF: анализ на уровне ядра​

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

Как устроена память

Как работает Linux с памятью

Как работает Windows с памятью

Как происходит управление памятью

Программы управляют памятью через ОС

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

Таблицы и примеры управления памятью

Системные вызовы для работы с памятью в Linux

Пример: ручное выделение памяти через `mmap`

Пример: использование `malloc` и поведение при page fault

Состояние памяти процесса: `/proc/[pid]/maps`

Пример: shared memory через `mmap`

Параметры ядра, влияющие на управление памятью

Пример: проверка использования памяти через `/proc/meminfo`

Аллокаторы памяти в пользовательском пространстве

ptmalloc: стандартный аллокатор в glibc

jemalloc: аллокатор от FreeBSD и Facebook

tcmalloc: Thread-Caching Malloc от Google

Huge Pages: ускорение работы с памятью

Настройка transparent huge pages (THP)

Явное использование huge pages

Учёт NUMA-топологии

Профилирование и отладка использования памяти

Valgrind: обнаружение утечек и ошибок

Perf и eBPF: анализ на уровне ядра