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

👤 Бизюк Андрей 📅 16.01.2025 ⏱️ 10 мин. чтения lecture

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

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

Виртуальная адресация

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

Физическая память и страничный файл

Виртуальная память Windows состоит из физической оперативной памяти (RAM) и страничного файла на диске. Если физическая память заполняется, то часть данных может быть перемещена в страничный файл, освобождая место для новых данных. Этот процесс называется “подкачкой” (paging).

Страницы памяти

Виртуальная память разбивается на небольшие блоки, называемые страницами памяти. Размер страницы обычно составляет 4 КБ. Windows использует систему управления таблицами страниц (Page Table) для отображения виртуальных адресов на физические адреса или на адреса в страничном файле.

Отображение виртуальной памяти

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

Защита памяти

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

Управление виртуальной памятью

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

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

Управление памятью в Windows может быть выполнено с использованием различных функций и API операционной системы. Давайте рассмотрим несколько примеров кода на языке C/C++ для выделения и освобождения памяти в Windows.

Выделение памяти с использованием `malloc` и `free` (C/C++)

 1#include <stdio.h>
 2#include <stdlib.h>
 3
 4int main() {
 5    // Выделение памяти под массив целых чисел
 6    int *arr = (int*)malloc(5 * sizeof(int));
 7
 8    if (arr == NULL) {
 9        printf("Не удалось выделить память\n");
10        return 1;
11    }
12
13    // Использование выделенной памяти
14    for (int i = 0; i < 5; i++) {
15        arr[i] = i * 10;
16    }
17
18    // Освобождение памяти после использования
19    free(arr);
20
21    return 0;
22}

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

Выделение памяти с использованием функции `VirtualAlloc` (WinAPI)

 1#include <Windows.h>
 2#include <stdio.h>
 3
 4int main() {
 5    // Выделение 1 мегабайта (1048576 байт) виртуальной памяти
 6    LPVOID mem = VirtualAlloc(NULL, 1048576, MEM_COMMIT, PAGE_READWRITE);
 7
 8    if (mem == NULL) {
 9        printf("Не удалось выделить виртуальную память\n");
10        return 1;
11    }
12
13    // Использование выделенной виртуальной памяти
14
15    // Освобождение виртуальной памяти
16    VirtualFree(mem, 0, MEM_RELEASE);
17
18    return 0;
19}

Здесь мы используем функцию VirtualAlloc из библиотеки WinAPI для выделения виртуальной памяти. После использования памяти мы освобождаем ее с помощью функции VirtualFree.

Выделение и освобождение памяти с использованием C++ операторов `new` и `delete`

 1#include <iostream>
 2#include <windows.h>
 3
 4int main() {
 5    SetConsoleOutputCP(1251);
 6    // Выделение памяти под одно целое число
 7    int *num = new int;
 8
 9    // Использование выделенной памяти
10    *num = 42;
11    std::cout << "Значение: " << *num << std::endl;
12
13    // Освобождение памяти
14    delete num;
15
16    return 0;
17}

Стек и куча

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

Стек (Stack)

Характеристики:
- Ограниченный по размеру.
- Доступ к данным выполняется в порядке “первым вошел, последним вышел” (LIFO - Last-In, First-Out).
- Часто фиксированный размер стека определяется на этапе компиляции.
Использование:
- Хранит локальные переменные функций и адреса возврата после вызова функций.
- Используется для управления вызовами функций (стек вызовов).
Жизненный цикл данных:
- Данные, хранящиеся в стеке, автоматически удаляются при завершении функции, в которой они определены.
- Ограниченное время жизни.
Примеры языков:
- Стек используется в C, C++, Java (для вызовов методов), Python (для вызовов функций).

Куча (Heap)

Характеристики:
- Динамически расширяемая область памяти.
- Доступ к данным происходит в произвольном порядке.
- Размер кучи ограничен объемом доступной физической и виртуальной памяти.
Использование:
- Хранит данные, которые могут иметь долгий или неопределенный срок жизни, такие как объекты, созданные динамически.
Жизненный цикл данных:
- Данные, хранящиеся в куче, существуют до тех пор, пока на них есть указатели, и могут быть освобождены вручную (например, с помощью free в C/C++ или сборщика мусора в других языках).
Примеры языков:
- Куча используется в C, C++, C#, Java (для объектов, созданных с помощью new), Python (с использованием модуля gc для сборки мусора).

Сравнение стека и кучи

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

Функции для работы со стеком

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

GetCurrentThreadStackLimits (Windows 8.1 и более поздние версии)

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

Пример использования:

1void GetStackLimits() {
2    ULONG_PTR lowLimit, highLimit;
3    GetCurrentThreadStackLimits(&lowLimit, &highLimit);
4    printf("Low Limit: 0x%llx\n", lowLimit);
5    printf("High Limit: 0x%llx\n", highLimit);
6}

RtlCaptureContext (Windows XP и более поздние версии)

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

Пример использования:

1CONTEXT context;
2RtlCaptureContext(&context);
3// Теперь у вас есть информация о контексте выполнения текущего потока

VirtualQuery (Windows XP и более поздние версии)

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

Пример использования:

1MEMORY_BASIC_INFORMATION mbi;
2VirtualQuery(&someAddress, &mbi, sizeof(mbi));
3// Теперь вы можете получить информацию о найденной памяти, включая стек

SetThreadStackGuarantee (Windows 8 и более поздние версии)

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

Пример использования:

1DWORD stackSize = 0x10000; // 64 КБ
2SetThreadStackGuarantee(&stackSize);

StackWalk64 (DbgHelp API)

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

Пример использования:

1STACKFRAME64 stackFrame;
2// Настройка параметров и выполнение обхода стека

Функции для работы с кучей

WinAPI предоставляет ряд функций для работы с кучей (памятью, выделяемой в куче). Основные функции включают в себя HeapCreate, HeapAlloc, HeapFree, HeapReAlloc и HeapDestroy. Давайте рассмотрим эти функции более подробно:

HeapCreate

Создает новую кучу.
Синтаксис: HANDLE HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize);
Пример:
```
1HANDLE hHeap = HeapCreate(0, 0, 0);
```

HeapAlloc

Выделяет блок памяти из кучи.
Синтаксис: LPVOID HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes);

Пример:

1int* pData = (int*)HeapAlloc(hHeap, 0, sizeof(int) * 10);

HeapFree

Освобождает блок памяти, выделенный ранее с помощью HeapAlloc.
Синтаксис: BOOL HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);
Пример:
```
1HeapFree(hHeap, 0, pData);
```

HeapReAlloc

Изменяет размер выделенного блока памяти в куче.
Синтаксис: LPVOID HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes);

Пример:

1pData = (int*)HeapReAlloc(hHeap, 0, pData, sizeof(int) * 20);

HeapDestroy

Уничтожает кучу и освобождает все связанные с ней ресурсы.
Синтаксис: BOOL HeapDestroy(HANDLE hHeap);
Пример:
```
1HeapDestroy(hHeap);
```

HeapSize

Возвращает размер выделенного блока памяти в куче.
Синтаксис: SIZE_T HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);

Пример:

1SIZE_T size = HeapSize(hHeap, 0, pData);

HeapValidate

Проверяет целостность кучи и выделенных блоков.
Синтаксис: BOOL HeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);

Пример:

1if (HeapValidate(hHeap, 0, pData)) {
2    printf("Куча валидна.\n");
3} else {
4    printf("Куча повреждена.\n");
5}

Пример 1: Создание кучи и выделение памяти

 1#include <Windows.h>
 2#include <stdio.h>
 3
 4int main() {
 5    SetConsoleOutputCP(1251);
 6    // Создание кучи
 7    HANDLE hHeap = HeapCreate(0, 0, 0);
 8
 9    if (hHeap == NULL) {
10        printf("Не удалось создать кучу\n");
11        return 1;
12    }
13
14    // Выделение памяти из кучи
15    int *data = (int*)HeapAlloc(hHeap, 0, sizeof(int) * 5);
16
17    if (data == NULL) {
18        printf("Не удалось выделить память из кучи\n");
19        HeapDestroy(hHeap);
20        return 1;
21    }
22
23    // Использование выделенной памяти
24    for (int i = 0; i < 5; i++) {
25        data[i] = i * 10;
26    }
27
28    // Освобождение памяти
29    HeapFree(hHeap, 0, data);
30
31    // Уничтожение кучи
32    HeapDestroy(hHeap);
33
34    return 0;
35}

В этом примере мы создаем кучу с помощью HeapCreate, выделяем память из кучи с помощью HeapAlloc, используем эту память и освобождаем ее с помощью HeapFree, а затем уничтожаем кучу с помощью HeapDestroy.

Пример 2: Выделение строки в куче

 1#include <Windows.h>
 2#include <stdio.h>
 3
 4int main() {
 5    SetConsoleOutputCP(1251);
 6    // Создание кучи
 7    HANDLE hHeap = HeapCreate(0, 0, 0);
 8
 9    if (hHeap == NULL) {
10        printf("Не удалось создать кучу\n");
11        return 1;
12    }
13
14    // Выделение строки в куче
15    char *str = (char*)HeapAlloc(hHeap, 0, 256);
16
17    if (str == NULL) {
18        printf("Не удалось выделить память для строки\n");
19        HeapDestroy(hHeap);
20        return 1;
21    }
22
23    // Копирование строки в выделенную память
24    strcpy_s(str, 256, "Пример строки в куче");
25
26    // Использование строки
27
28    // Освобождение памяти
29    HeapFree(hHeap, 0, str);
30
31    // Уничтожение кучи
32    HeapDestroy(hHeap);
33
34    return 0;
35}

В этом примере мы выделяем память для строки в куче, копируем строку в эту память, используем ее и освобождаем память.

Отображение файлов на адресное пространство

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

Создание файла для сопоставления

Сначала необходимо создать или открыть файл, который вы хотите сопоставить. Это можно сделать с помощью функций, таких как CreateFile или OpenFile. Например:

1HANDLE hFile = CreateFile(
2    L"C:\\example.txt",           // Имя файла
3    GENERIC_READ | GENERIC_WRITE, // Режим доступа
4    0,                            // Атрибуты файла
5    NULL,                         // Дескриптор безопасности
6    OPEN_ALWAYS,                  // Действие при открытии (создать, если не существует)
7    FILE_ATTRIBUTE_NORMAL,        // Атрибуты файла
8    NULL                          // Шаблон для атрибутов
9);

Создание отображения файла в памяти

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

1HANDLE hMapFile = CreateFileMapping(
2    hFile,                   // Дескриптор файла
3    NULL,                    // Атрибуты безопасности (можно использовать NULL)
4    PAGE_READWRITE,          // Режим доступа к файлу в отображении
5    0,                       // Размер отображения файла (0 - весь файл)
6    0,                       // Высший значащий байт размера файла
7    NULL                     // Имя отображения файла (можно использовать NULL)
8);

Отображение файла в виртуальную память

Завершите процесс сопоставления файла, отображая его в виртуальную память с помощью функции MapViewOfFile:

1LPVOID pData = MapViewOfFile(
2    hMapFile,              // Дескриптор отображения файла
3    FILE_MAP_ALL_ACCESS,   // Режим доступа к отображению
4    0,                     // Смещение в файле
5    0,                     // Начальный байт отображения
6    0                      // Размер отображения (0 - весь файл)
7);

Использование данных

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

Освобождение ресурсов

После завершения работы с данными не забудьте освободить ресурсы:

1UnmapViewOfFile(pData);  // Освобождение отображения файла
2CloseHandle(hFile);      // Закрытие дескриптора файла
3CloseHandle(hMapFile);   // Закрытие дескриптора отображения файла

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

Виртуальная адресация

Физическая память и страничный файл

Страницы памяти

Отображение виртуальной памяти

Защита памяти

Управление виртуальной памятью

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

Выделение памяти с использованием malloc и free (C/C++)

Выделение памяти с использованием функции VirtualAlloc (WinAPI)

Выделение и освобождение памяти с использованием C++ операторов new и delete

Стек и куча

Стек (Stack)

Куча (Heap)

Сравнение стека и кучи

Функции для работы со стеком

GetCurrentThreadStackLimits (Windows 8.1 и более поздние версии)

RtlCaptureContext (Windows XP и более поздние версии)

VirtualQuery (Windows XP и более поздние версии)

SetThreadStackGuarantee (Windows 8 и более поздние версии)

StackWalk64 (DbgHelp API)

Функции для работы с кучей

HeapCreate

HeapAlloc

HeapFree

HeapReAlloc

HeapDestroy

HeapSize

HeapValidate

Пример 1: Создание кучи и выделение памяти

Пример 2: Выделение строки в куче

Отображение файлов на адресное пространство

Создание файла для сопоставления

Создание отображения файла в памяти

Отображение файла в виртуальную память

Использование данных

Освобождение ресурсов

Выделение памяти с использованием `malloc` и `free` (C/C++)

Выделение памяти с использованием функции `VirtualAlloc` (WinAPI)

Выделение и освобождение памяти с использованием C++ операторов `new` и `delete`