rammap process private что значит
Here be dragons: Управление памятью в Windows как оно есть [1/3]
Каталог:
Один
Два
Три
Менеджер памяти (и связанные с ним вопросы контроллера кеша, менеджера ввода/вывода и пр) — одна из вещей, в которой (наряду с медициной и политикой) «разбираются все». Но даже люди «изучившие винду досконально» нет-нет, да и начинают писать чепуху вроде (не говоря уже о другой чепухе, написанной там же):
Грамотная работа с памятью. За все время использования у меня своп файл не увеличился ни на Килобайт. По этому Фаерфокс с 10-20 окнами сворачивается / разворачивается в/из трея как пуля. Такого эффекта я на винде добивался с отключенным свопом и с переносом tmp файлов на RAM диск.
Цель данной статьи — не полное описание работы менеджера памяти (не хватит ни места ни опыта), а попытка пролить хоть немного света на темное царство мифов и суеверий, окружающих вопросы управления памятью в Windows.
Disclaimer
Сам я не претендую на то, чтобы знать все и никогда не ошибаться, поэтому с радостью приму любые сообщения о неточностях и ошибках.
Введение
С чего начать не знаю, поэтому начну с определений.
Commit Size — количество памяти, которое приложение запросило под собственные нужды.
Working Set (на картинке выше он так и называется Working Set) — это набор страниц физической памяти, которые в данный момент «впечатаны» в адресное пространство процесса. Рабочий набор процесса System принято выделять в отдельный «Системный рабочий набор», хотя механизмы работы с ним практически не отличаются от механизмов работы с рабочими наборами остальных процессов.
И уже здесь зачастую начинается непонимание. Если присмотреться, можно увидеть, что Commit у многих процессов меньше Working Set-а. То есть если понимать буквально, «запрошено» меньше памяти, чем реально используется. Так что уточню, Commit — это виртуальная память, «подкрепленная» (backed) только физической памятью или pagefile-ом, в то время как Working Set содержит еще и страницы из memory mapped файлов. Зачем это делается? Когда делается NtAllocateVirtualMemory (или любые обертки над heap manager-ом, например malloc или new) — память как бы резервируется (чтоб еще больше запутать, это не имеет никакого отношения к MEM_RESERVE, который резервирует адресное пространство, в данном же случае речь идет о резервировании именно физических страниц, которые система действительно может выделить), но физические страницы впечатываются только при фактическом обращении по выделенному адресу виртуальной памяти. Если позволить приложениям выделить больше памяти, чем система реально может предоставить — рано или поздно может случиться так, что все они попросят реальную страницу, а системе неоткуда будет ее взять (вернее некуда будет сохранить данные). Это не касается memory mapped файлов, так как в любой момент система может перечитать/записать нужную страницу прямо с/на диск(а).
В общем, суммарный Commit Charge в любой момент времени не должен превышать системный Commit Limit (грубо, суммарный объем физической памяти и всех pagefile-ов) и с этим связана одна из неверно понимаемых цифр на Task Manager-ах до Висты включительно.
Commit Limit не является неизменным — он может увеличиваться с ростом pagefile-ов. Вообще говоря, можно считать, что pagefile — это такой очень специальный memory mapped файл: привязка физической страницы в виртуальной памяти к конкретному месту в pagefile-е происходит в самый последний момент перед сбросом, в остальном же механизмы memory mapping-а и swapping-а очень схожи.
Working Set процесса делится на Shareable и Private. Shareable — это memory mapped файлы (в том числе и pagefile backed), вернее те части, которые в данный момент действительно представлены в адресном пространстве процесса физической страницей (это же Working Set в конце концов), а Private — это куча, стеки, внутренние структуры данных типа PEB/TEB и т.д. (опять таки, повторюсь на всякий случай: речь идет только той части кучи и прочих структур, которые физически находятся в адресном пространстве процесса). Это тот минимум информации, с которой уже можно что то делать. Для сильных духом есть Process Explorer, который показывает еще больше подробностей (в частности какая часть вот той Shareable действительно Shared).
И, самое главное, ни один из этих параметров по отдельности не позволяет сделать более менее полноценных выводов о происходящем в программе/системе.
Task Manager
Столбец «Memory» в списке процессов и практически вся вкладка «Performance» настолько часто понимаются неправильно, что у меня есть желание, чтоб Task Manager вообще удалили из системы: те, кому надо смогут воспользоваться Process Explorer-ом или хотя бы Resource Monitor-ом, всем остальным Task Manager только вредит. Для начала, собственно о чем речь 
Начну с того, о чем я уже упоминал: Page File usage. XP показывает текущее использование pagefile-а и историю (самое забавное, что в статус баре те же цифры названы правильно), Виста — показывает Page File (в виде дроби Current/Limit), и только Win7 называет его так, чем оно на самом деле является: Commit Charge/Commit Limit.
Эксперимент. Открываем таск менеджер на вкладке с «использованием пейджфайла», открываем PowerShell и копируем в него следующее (для систем, у которых Commit Limit ближе, чем на 3 Гб от Commit Charge можно в последней строчке уменьшить 3Gb, а лучше увеличить pagefile):
Это приводит к мгновенному повышению «использования свопфайла» на 3 гигабайта. Повторная вставка «использует» еще 3 Гб. Закрытие процесса мгновенно освобождает весь «занятый свопфайл». Самое интересное, что, как я уже говорил memory mapped файлы (в том числе и pagefile backed) являются shareable и не относятся к какому либо конкретному процессу, поэтому не учитываются в Commit Size никакого из процессов, с другой стороны pagefile backed секции используют (charged against) commit, потому что именно физическая память или пейджфайл, а не какой нибудь посторонний файл, будут использоваться для того, чтобы хранить данные, которые приложение захочет разместить в этой секции. С третьей стороны, после меппинга секции себе в адресное пространство, процесс не трогает ее — следовательно, физические страницы по этим адресам не впечатываются и никаких изменений в Working Set процесса не происходит.
Строго говоря, пейджфайл действительно «используется» — в нем резервируется место (не конкретное положение, а именно место, как размер), но при этом реальная страница, для которой это место было зарезервировано может находиться в физической памяти, на диске или И ТАМ И ТАМ одновременно. Вот такая вот циферка, признайтесь честно, сколько раз глядя на «Page File usage» в Task Manager-е Вы действительно понимали, что она означает.
Что же до Processes таба — там все еще по дефолту показывается Memory (Private Working Set) и несмотря на то, что он называется совершенно правильно и не должен вызывать недоразумений у знающих людей — проблема в том, что подавляющее большинство людей, которые смотрят на эти цифры совершенно не понимают, что они означают. Простой эксперимент: запускаем утилилиту RamMap (советую скачать весь комплект), запускаете Task Manager со списком процессов. В RamMap выбираете в меню Empty->Empty Working Sets и смотрите на то, что происходит с памятью процессов.
Если кого-то все еще раздражают циферки в Task Manager-е, можете поместить следующий код в профайл павершелла:
В первую очередь отмечу, что кеш в Windows не блочный, а файловый. Это дает довольно много преимуществ, начиная от более простого поддержания когерентности кеша например при онлайн дефрагментации и простого механизма очистки кеша при удалении файла и заканчивая более консистентными механизмами его реализации (кеш контроллер реализован на основе механизма memory mapping-а), возможностью более интеллектуальных решений на основе более высокоуровневой информации о читаемых данных (к примеру интеллектуальный read-ahead для файлов открытых на последовательный доступ или возможность назначать приоритеты отдельным файловым хендлам).
В принципе из недостатков я могу назвать только значительно более сложную жизнь разработчиков файловых систем: слышали о том, что написание драйверов — это для психов? Так вот, написание драйверов файловых систем — для тех, кого даже психи считают психами.
Страница из лекции какого то токийского университета (эх, мне бы так):
На этом работа собственно кеш-менеджера заканчивается и начинается работа менедера памяти. Когда выше мы делали EmptyWorkingSet это не приводило ни к какой дисковой активности, но тем не менее, физическая память используемая процессом сокращалась (и все физические страницы действительно уходили из адресного пространства процесса делая его почти полностью невалидным). Так куда же она уходит после того, как отбирается у процесса? А уходит она, в зависимости от того, соответствует ли ее содержимое тому, что было прочитано с диска, в один из двух списков: Standby (начиная с Висты это не один список, а 8, о чем позже) или Modified:
Standby список таким образом — это свободная память, содержащая какие то данные с диска (в том числе возможно и pagefile-а).
Если Page Fault происходит по адресу, который спроецирован на часть файла, которая все еще есть в одном из этих списков — она просто возвращается обратно в рабочий набор процесса и впечатывается по искомому адресу (этот процесс называется softfault). Если нет — то, как и в случае со слотами кеш менеджера, выполняется PAGING_IO запрос (называется hardfault).
Modified список может содержать «грязные» страницы достаточно долго, но либо когда размер этого списка чрезмерно вырастает, либо по когда система видит недостаток свободной памяти, либо по таймеру, просыпается modified page writer thread и начинает частями сбрасывать этот список на диск, и перемещая страницы из modified списка в standby (ведь эти страницы опять содержат неизмененную копию данных с диска).
Upd:
Пользователь m17 дал ссылки на выступление Руссиновича на последнем PDC на ту же тему (хм, я честно его до этого не смотрел, хотя пост во много перекликается). Если понимание английского на слух позволяет, то чтение данного топика можно заменить прослушиванием презентаций:
Mysteries of Windows Memory Management Revealed, Part 1 of 2
Mysteries of Windows Memory Management Revealed, Part 2 of 2
Пользователь DmitryKoterov подсказывает, что перенос пейджфайла на RAM диск иногда действительно может иметь смысл (вот уж никогда б наверное и не догадался, если б не написал топик), а именно, если RAM-диск использует физическую память, недоступную остальной системе (PAE + x86 + 4+Gb RAM).
Пользователь Vir2o в свою очередь подсказывает что хотя при некоторых условиях и пожертвовав стабильностью системы ram-диск, использующий физическую память, невидимую остальной системе написать можно, но такое очень маловероятно.
Mapped file занимает всю память
Очень важно без перезагрузки сервера суметь освободить оперативную память, особенно когда ее не много
Вот, как это можно сделать:
Перейду сразу к решению проблемы:
Из сайта Microsoft скачиваете утилитку RAMMap:
При запуске она покажет все процесы, даже системние, которих не увидите в диспетчере задач:
Если какой-то софт не освобождает память после себя, чтобы не перегружать из-за этого сервер, в RAMMap нужно по очереди выбрать следуюющие функции:
И нажать F5 чтобы увидить разницу.
Вот, что получиться после этого:
Видим, что системние ресурси (Metafile, Mapped File), которие использовались системой освободили память. На скриншоте из диспетчером задач видно, что освободилось больше, чем полтора ГБ на сервере, которий и так нре был загружен под завязку.
Собственно, что и было нужно!
Данная статья не подлежит комментированию, поскольку её автор ещё не является полноправным участником сообщества. Вы сможете связаться с автором только после того, как он получит приглашение от кого-либо из участников сообщества. До этого момента его username будет скрыт псевдонимом.
Программа RAMMap представляет собой утилиту, которая позволяет увидеть как Windows действительно распределяет оперативную память. Благодаря программе на оперативную память компьютера можно взглянуть как не на абстрактную сущность, а действительно составить представление о том, для чего и какими файлами она используется. Работает в версиях от Windows Vista и позднее.
Наиболее интересными для рядового пользователя, наверное, окажутся лишь некоторые из вкладок. Это Use Counts и File Details. Однако для полноты понимания как программа работает, от пользователя требуется понимание работы RAM в принципе.
Теоретические абзацы
Все процессы пользовательского режима и большинство процессов от имени ядра получают доступ к данным через адреса виртуальной памяти. Эти данные и исполняемый код могут находиться как в ячейках физической памяти планок RAM, так и в файле подкачки жёсткого диска, но все они объединены одним условием – в момент запуска система приклеивает их к рабочему набору конкретного процесса, который в данный момент чем-то занимается (то есть читает, записывает и выполняет). И утилита RAMMap подходит к памяти как к общесистемному источнику памяти, который распределяется между запущенными в Windows процессами.
Интерфейс RAMMap
Окно программы представляет из себя интерфейс, напоминающий чем-то Диспетчер задач Windows NT, и включает в себя вкладки (во время работы обновляем состояние позиций клавишей F5):
Посмотрим на каждую из вкладок RAMMap внимательнее.
Use counts
Посмотрим на столбцы вкладки Use Counts
Processes
Вкладка содержит анализ страниц физической памяти, которые ассоциируются с конкретным процессом. Здесь мы можем увидеть номер сессии процесса в текущем сеансе (Session), присвоенный процессу номер (PID). Остальные столбцы вдоль каждого процесса показывают какую часть RAM, выделяемого для этого процесса, занимают страницы пользователя или/и системы: по показаниям в этой вкладке можно судить о том, от чьего имени процесс запущен, не “кривит” ли память. Столбец Page Table показывает общее количество памяти, выделяемой ядром этому процессу. Total суммирует показания по столбцам с Private по Page Table (именно показатель Total и отображается в Windows-ском Диспетчере задач). Однако Диспетчер в окне по умолчанию суммирует всё, что запущено от имени одной службы/программы. Надо лишь развернуть характерный столбец:
Priority Summary
Вкладка отображает объёмы памяти, выделяемые/выделяемых на процессы по присвоенному системой приоритету с момента включения компьютера. Самая интересная здесь вкладка – Repurposed. Она показывает, сколько памяти было отозвано у других задач для удовлетворения нужд более приоритетных процессов с момента запуска Windows. Идеальный вариант с эффективно работающей системой – этот столбец по “нолям”. Этого достичь, однако, почти нереально. Более того, высокие числа в этом столбце с процессами в высоком приоритете (с 5-го и выше) говорят о том, что ресурсов системе либо не хватало, либо не хватает до сих пор: впору задуматься о приобретении дополнительной планки:
установленного объёма RAM явно недостаточно для выполнения некоторых задач
Physical Ranges
Следующая вкладка (чисто информационная) отображает эффективные диапазоны адресов физической памяти. Разрывы в диапазонах отображают физические адреса, закреплённые за определёнными устройствами.
File Summary
В этой вкладке отображается полный путь к файлам, отнесённым системой в память. Столбцов несколько: Total – общая сумма, Active – на данный момент, Standby – готовая примкнуть и т.д. Сюда попадает всё: от файлов загрузчика до драйверов для мыши и клавиатуры. Можно взглянуть пристальнее, проранжировав столбцы по имени, месту запуска и т.п.
File Details
Одна из самых информативных. Именно здесь можно увидеть информацию из предыдущих вкладок, но для каждого отнесённого в память системой файла. Здесь и диапазон адресов, и рабочий набор страниц и назначенный приоритет. Стоит лишь развернуть крестик слева от имени файла:
Помимо информативной части вкладок, по которым можно судить о том, как Windows справляется с запускаемыми процессами, разнося задачи по страницам памяти, и выискивая пропажу гигабайт оперативки, в шапке RAMMap имеется кнопка действий, позволяющая принудительно “изымать” страницы памяти. Как вы понимаете, этот процесс ничего общего с принудительной остановкой какого-то процесса через Диспетчер задач не имеет. Так, нажав по кнопке Empty (Очистить) программы:
взору откроются пять основных команд очистки страниц памяти RAM, работа с которыми сейчас конкретными процессами не ведётся, и которым после очистки может быть присвоен иной статус, что, в свою очередь, позволит им включиться в работу уже в составе приложения, которому, быть может, как раз сейчас памяти и не хватает. Далее по списку вниз:
Помните, что выполнение задач по очистке потребует загрузки процессора и переорганизации памяти, что может занять некоторое время. Обновлённые данные по результатам оптимизации можно наблюдать во всех вкладках по нажатию, напомню, клавиши F5.
RAMMap – анализ и сохранение результатов
Для работы с системой не обязательно работать с окном непосредственно до эксперимента и после. Разработчики предлагают поместить исполнительный файл программы в папку с другими системными утилитами Windows/System32 и запускайте через cmd от имени администратора:
RAMMap фоном проверит состояние памяти и сохранит данные в файл 1.rmp в той же директории. Чтобы открыть сохранённый вами или присланный на анализ файл, можно запустить cmd с таким скриптом:
или для владельцев Windows 64-x, помогающим 32-х битным соратникам (а вот из 32-х битной версии файлы с 64-х-“битки” уже не прочитать):
Впрочем, команды чтения и записи в файл доступны из окна самой команды.
Есть два типа отображенных в память файлов: There are two types of memory-mapped files:
Постоянные отображенные в память файлы. Persisted memory-mapped files
В контексте отображения в память постоянными называются файлы, сопоставленные с исходным файлом на диске. Persisted files are memory-mapped files that are associated with a source file on a disk. Когда последний процесс завершит работу с таким файлом, все данные сохраняются в исходный файл на диске. When the last process has finished working with the file, the data is saved to the source file on the disk. Такие отображенные в память файлы удобны для работы с очень большими исходными файлами. These memory-mapped files are suitable for working with extremely large source files.
Непостоянные отображенные в память файлы. Non-persisted memory-mapped files
Непостоянными называются отображенные в память файлы, которые не сопоставлены с файлом на диске. Non-persisted files are memory-mapped files that are not associated with a file on a disk. Когда последний процесс закончит работу с таким файлом, данные не сохраняются, а файл удаляется при сборке мусора. When the last process has finished working with the file, the data is lost and the file is reclaimed by garbage collection. Такие файлы позволяют создать общую область памяти для межпроцессного взаимодействия (IPC). These files are suitable for creating shared memory for inter-process communications (IPC).
Процессы, представления и управление памятью Processes, Views, and Managing Memory
Отображенные в память файлы можно сделать общими для нескольких процессов. Memory-mapped files can be shared across multiple processes. Процессы могут обращаться к одному отображенному в память файлу по единому имени, которое назначается процессом, создающим этот файл. Processes can map to the same memory-mapped file by using a common name that is assigned by the process that created the file.
Для работы с отображенным в память файлом следует создать представление всего файла или его части. To work with a memory-mapped file, you must create a view of the entire memory-mapped file or a part of it. Также вы можете создать несколько представлений для одной части отображенного в память файла, фактически применяя одновременно используемую память. You can also create multiple views to the same part of the memory-mapped file, thereby creating concurrent memory. Чтобы два представления оставались согласованными, их нужно создавать из одного отображенного в память файла. For two views to remain concurrent, they have to be created from the same memory-mapped file.
Несколько представлений потребуются еще и в том случае, если размер файла превышает размер пространства логической памяти, доступной приложению для отображения в память (например, 2 ГБ на 32-разрядном компьютере). Multiple views may also be necessary if the file is greater than the size of the application’s logical memory space available for memory mapping (2 GB on a 32-bit computer).
Есть два типа представлений: представление потокового доступа и представление произвольного доступа. There are two types of views: stream access view and random access view. Представления потокового доступа удобны для последовательного доступа к файлу (чаще всего это непостоянные файлы и IPC). Use stream access views for sequential access to a file; this is recommended for non-persisted files and IPC. Представления произвольного доступа предпочтительны для работы с постоянными файлами. Random access views are preferred for working with persisted files.
Доступ к отображенным в память файлам осуществляется через диспетчер памяти операционной системы, который автоматически разделяет файл на несколько страниц и предоставляет их по мере необходимости. Memory-mapped files are accessed through the operating system’s memory manager, so the file is automatically partitioned into a number of pages and accessed as needed. Вам не придется самостоятельно осуществлять управление памятью. You do not have to handle the memory management yourself.
На следующем изображении показано, как несколько процессов могут одновременно использовать несколько перекрывающихся представлений для одного отображенного в память файла: The following illustration shows how multiple processes can have multiple and overlapping views to the same memory-mapped file at the same time.
На следующем рисунке показано несколько перекрывающихся представлений для отображенного в память файла: The following image shows multiple and overlapped views to a memory-mapped file:
Программирование с использованием отображенных в память файлов Programming with Memory-Mapped Files
В следующей таблице содержатся инструкции по использованию объектов и элементов для отображенных в память файлов. The following table provides a guide for using memory-mapped file objects and their members.
| Задача Task | Применимые методы или свойства Methods or properties to use |
|---|---|
| Получение объекта MemoryMappedFile, который представляет постоянный файл, отображенный в память из файла на диске. To obtain a MemoryMappedFile object that represents a persisted memory-mapped file from a file on disk. | Метод MemoryMappedFile.CreateFromFile. MemoryMappedFile.CreateFromFile method. |
| Получение объекта MemoryMappedFile, который представляет непостоянный файл, отображенный в память из файла на диске. To obtain a MemoryMappedFile object that represents a non-persisted memory-mapped file (not associated with a file on disk). | Метод MemoryMappedFile.CreateNew. MemoryMappedFile.CreateNew method. |
Метод MemoryMappedFile.CreateOrOpen. MemoryMappedFile.CreateOrOpen method.
Свойство MemoryMappedViewStream.SafeMemoryMappedViewHandle. MemoryMappedViewStream.SafeMemoryMappedViewHandle property.
(Чтобы определить текущий размер системной страницы, используйте свойство Environment.SystemPageSize.) (To determine the current system page size, use the Environment.SystemPageSize property.)
Методы CreateOrOpen, которые принимают в качестве параметра перечисление MemoryMappedFileOptions. CreateOrOpen methods that have a MemoryMappedFileOptions enumeration as a parameter.
Безопасность Security
При создании отображенного в память файла вы можете применить к нему права доступа. Для этого используйте следующие методы, которые принимают в качестве параметра перечисление MemoryMappedFileAccess: You can apply access rights when you create a memory-mapped file, by using the following methods that take a MemoryMappedFileAccess enumeration as a parameter:
Вы можете указать права доступа для открытия существующего отображенного в память файла, используя методы OpenExisting, которые принимают MemoryMappedFileRights в качестве параметра. You can specify access rights for opening an existing memory-mapped file by using the OpenExisting methods that take an MemoryMappedFileRights as a parameter.
Кроме того, можно включить объект MemoryMappedFileSecurity с предварительно определенными правилами доступа. In addition, you can include a MemoryMappedFileSecurity object that contains predefined access rules.
Чтобы применить к отображенному в память файлу новые или измененные правила доступа, используйте метод SetAccessControl. To apply new or changed access rules to a memory-mapped file, use the SetAccessControl method. Чтобы получить доступ или проверить правила для существующего файла, используйте метод GetAccessControl. To retrieve access or audit rules from an existing file, use the GetAccessControl method.
Примеры Examples
Постоянные отображенные в память файлы Persisted Memory-Mapped Files
Метод CreateFromFile позволяет создать отображенный в память файл из существующего файла на диске. The CreateFromFile methods create a memory-mapped file from an existing file on disk.
В следующем примере создается отображенное в память представление для части очень большого файла, с которым выполняются определенные действия: The following example creates a memory-mapped view of a part of an extremely large file and manipulates a portion of it.
В следующем примере тот же отображенный в память файл открывается для другого процесса: The following example opens the same memory-mapped file for another process.
Непостоянные отображенные в память файлы Non-Persisted Memory-Mapped Files
Методы CreateNew и CreateOrOpen позволяют создать отображенный в память файл, который не сопоставлен ни с каким файлом на диске. The CreateNew and CreateOrOpen methods create a memory-mapped file that is not mapped to an existing file on disk.
Приведенный ниже пример состоит из трех отдельных процессов (консольных приложений), при которых логические значения записываются в отображенный в память файл. The following example consists of three separate processes (console applications) that write Boolean values to a memory-mapped file. Последовательность действий следующая: The following sequence of actions occur:
Process A — создается отображенный в память файл и в него записывается значение. Process A creates the memory-mapped file and writes a value to it.
Process B — открывается отображенный в память файл и в него записывается значение. Process B opens the memory-mapped file and writes a value to it.
Process C — открывается отображенный в память файл и в него записывается значение. Process C opens the memory-mapped file and writes a value to it.
Process A — из отображенного в память файла считываются значения, затем значения отображаются. Process A reads and displays the values from the memory-mapped file.
Когда в Process A завершается работа с отображенным в память файлом, он немедленно уничтожается при сборке мусора. After Process A is finished with the memory-mapped file, the file is immediately reclaimed by garbage collection.
Чтобы выполнить этот пример, сделайте следующее: To run this example, do the following:
Скомпилируйте приложение и откройте три окна командной строки. Compile the applications and open three Command Prompt windows.
Вернитесь к Process A и нажмите клавишу ВВОД. Return to Process A and press ENTER.
Вернитесь к Process A и нажмите клавишу ВВОД. Return to Process A and press ENTER.
Выходные данные Process A выглядят следующим образом: The output of Process A is as follows:
Process A Process A
Process B Process B
Process C Process C