Общая память, используемая процессом Python?
есть ли способ для программы Python определить, сколько памяти она использует в настоящее время? Я видел дискуссии об использовании памяти для одного объекта, но мне нужно полное использование памяти для процесса, чтобы я мог определить, когда необходимо начать отбрасывать кэшированные данные.
10 ответов
здесь полезное решение, которое работает для различных операционных систем, включая Linux, ОС Windows 7, и т. д.:
в моей текущей установке Python 2.7 последняя строка должна быть
вместо этого (произошло изменение в API).
для Unixes (Linux, Mac OS X, Solaris) вы также можете использовать getrusage() функция из стандартного библиотечного модуля resource . Результирующий объект имеет атрибут ru_maxrss , что дает пик использование памяти для процесса вызова:
на Python docs не ясно, какие именно единицы, но Mac OS X man page на getrusage(2) описывает единицы как байт. Man-страница Linux не ясно, но это, кажется, эквивалентно информации из /proc/self/status , который в КБ.
в unix вы можете использовать это:
где 1347 — некоторый идентификатор процесса. Также, в результате, в МБ.
бесформенный (и друзей) может быть то, что вы ищете.
кроме того, кэши обычно имеют фиксированный верхний предел их размера, чтобы решить проблему, о которой вы говорите. Например, проверьте это декоратор кэша LRU.
мне нравится это, спасибо за @bayer. Теперь я получаю конкретный инструмент подсчета процессов.
добавить список процессов.
ссылка
использование sh и os для получения ответа python bayer.
ответ в мегабайтах.
текущее использование памяти текущего процесса в Linux, для python 2 и 3 и pypy:
Я тестировал его на Linux 4.4 и 4.9, но любая версия Linux должна работать.
ищем в man proc и поиск информации о /proc/$PID/status файл, он упоминает минимальные версии для некоторых полей (например, Linux 2.6.10 для «VmPTE»), но поле «VmRSS» (которое я использую здесь) не имеет такого упоминания. Поэтому я предполагаю, что он был там с ранней версией.
ниже мой декоратор функций, который позволяет отслеживать, сколько памяти этот процесс потребляется до вызова функции, сколько памяти он использует после вызова функции и как долго функция выполняется.
Поймите, сколько памяти используют ваши объекты Python
Python – это фантастический язык программирования. Он также известен как довольно медленный, в основном из-за его огромной гибкости и динамических характеристик. Для многих приложений и областей это не проблема из-за их требований и различных методов оптимизации. Менее известно, что графы объектов Python (вложенные словари списков, кортежей и примитивных типов) занимают значительный объем памяти. Это может быть гораздо более серьезным ограничивающим фактором из-за его влияния на кеширование, виртуальную память, многопользовательскую работу с другими программами и в целом более быстрое исчерпание доступной памяти, которая является дефицитным и дорогим ресурсом.
Оказывается, нетривиально выяснить, сколько памяти фактически потребляется. В этой статье я расскажу о тонкостях управления памятью объекта Python и покажу, как точно измерить потребляемую память.
В этой статье я остановлюсь исключительно на CPython – основной реализации языка программирования Python. Эксперименты и выводы здесь не относятся к другим реализациям Python, таким как IronPython, Jython и PyPy.
Также я запустил числа на 64-битном Python 2.7. В Python 3 числа иногда немного отличаются (особенно для строк, которые всегда являются Unicode), но концепции одинаковы.
Практическое исследование использования памяти Python
Сначала давайте немного разберемся и получим конкретное представление о фактическом использовании памяти объектами Python.
Встроенная функция sys.getsizeof ()
Модуль sys стандартной библиотеки предоставляет функцию getsizeof () . Эта функция принимает объект (и необязательный параметр по умолчанию), вызывает метод sizeof () объекта и возвращает результат, поэтому вы также можете сделать ваши объекты инспектируемыми.
Измерение памяти объектов Python
Давайте начнем с некоторых числовых типов:
“ `python import sys
sys.getsizeof (5) 24 “ `
Интересный. Целое число занимает 24 байта.
python sys.getsizeof(5.3) 24
Хм … float также занимает 24 байта.
python from decimal import Decimal sys.getsizeof(Decimal(5.3)) 80
Вау. 80 байт! Это действительно заставляет задуматься о том, хотите ли вы представлять большое количество вещественных чисел как числа с плавающей запятой или десятичные дроби.
Давайте перейдем к строкам и коллекциям:
“ `python sys.getsizeof (”) 37 sys.getsizeof (‘1’) 38 sys.getsizeof (‘1234’) 41
sys.getsizeof (u ”) 50 sys.getsizeof (u’1 ‘) 52 sys.getsizeof (u’1234’) 58 “ `
OK. Пустая строка занимает 37 байтов, и каждый дополнительный символ добавляет еще один байт. Это многое говорит о компромиссе между сохранением нескольких коротких строк, когда вы будете платить 37 байтов за каждую, и одной длинной строкой, где вы платите только один раз.
Строки Unicode ведут себя аналогично, за исключением того, что служебные данные составляют 50 байтов, и каждый дополнительный символ добавляет 2 байта. Это нужно учитывать, если вы используете библиотеки, которые возвращают строки Unicode, но ваш текст может быть представлен в виде простых строк.
Кстати, в Python 3 строки всегда имеют Unicode, а служебные данные составляют 49 байт (они где-то сохранили байт). Объект байтов имеет служебную информацию только 33 байта. Если у вас есть программа, которая обрабатывает много коротких строк в памяти, и вы заботитесь о производительности, рассмотрите Python 3.
python sys.getsizeof([]) 72 sys.getsizeof([1]) 88 sys.getsizeof([1, 2, 3, 4]) 104 sys.getsizeof([‘a long longlong string’])
В чем дело? Пустой список занимает 72 байта, но каждое дополнительное int добавляет всего 8 байтов, где размер int составляет 24 байта. Список, который содержит длинную строку, занимает всего 80 байтов.
Ответ прост. Список не содержит сами объекты int. Он просто содержит 8-байтовый (в 64-битных версиях CPython) указатель на фактический объект int. Это означает, что функция getsizeof () не возвращает фактическую память списка и всех объектов, которые он содержит, а только память списка и указатели на его объекты. В следующем разделе я представлю функцию deep_getsizeof (), которая решает эту проблему.
python sys.getsizeof(()) 56 sys.getsizeof((1,)) 64 sys.getsizeof((1, 2, 3, 4)) 88 sys.getsizeof((‘a long longlong string’,)) 64
История похожа на кортежи. Накладные расходы пустого кортежа составляют 56 байтов против 72 списка. Опять же, эта разница в 16 байтов на последовательность – это низко висящий плод, если у вас есть структура данных с большим количеством небольших неизменяемых последовательностей.
“ `python sys.getsizeof (set ()) 232 sys.getsizeof (set ([1)) 232 sys.getsizeof (set ([1, 2, 3, 4])) 232
sys.getsizeof (<>) 280 sys.getsizeof (dict (a = 1)) 280 sys.getsizeof (dict (a = 1, b = 2, c = 3)) 280 “ `
Наборы и словари якобы вообще не растут, когда вы добавляете предметы, но обратите внимание на огромные накладные расходы.
Суть в том, что у объектов Python огромные фиксированные накладные расходы. Если ваша структура данных состоит из большого количества объектов коллекций, таких как строки, списки и словари, которые содержат небольшое количество элементов каждый, вы платите много.
Функция deep_getsizeof ()
Теперь, когда я напугал вас до полусмерти и продемонстрировал, что sys.getsizeof () может только сказать вам, сколько памяти занимает примитивный объект, давайте посмотрим на более адекватное решение. Функция deep_getsizeof () рекурсивно выполняет детализацию и вычисляет фактическое использование памяти графом объектов Python.
“ `python из импорта коллекций Mapping, контейнер из sys import getsizeof
def deep_getsizeof (o, ids): «” »Найти объем памяти объекта Python
У этой функции есть несколько интересных аспектов. Он учитывает объекты, на которые ссылаются несколько раз, и учитывает их только один раз, отслеживая идентификаторы объектов. Другая интересная особенность реализации заключается в том, что она в полной мере использует абстрактные базовые классы модуля коллекций. Это позволяет функции очень лаконично обрабатывать любую коллекцию, которая реализует базовые классы Mapping или Container, вместо непосредственного обращения к множеству типов коллекций, таких как: строка, Unicode, байты, список, кортеж, dict, frozendict, OrderedDict, set, frozenset и т. Д. ,
Давайте посмотрим на это в действии:
python x = ‘1234567’ deep_getsizeof(x, set()) 44
Строка длиной 7 занимает 44 байта (37 служебных данных + 7 байтов для каждого символа).
python deep_getsizeof([], set()) 72
Пустой список занимает 72 байта (только накладные расходы).
python deep_getsizeof([x], set()) 124
Список, содержащий строку x, занимает 124 байта (72 + 8 + 44).
python deep_getsizeof([x, x, x, x, x], set()) 156
Список, содержащий строку x 5 раз, занимает 156 байтов (72 + 5 * 8 + 44).
Последний пример показывает, что deep_getsizeof () подсчитывает ссылки на один и тот же объект (строку x) только один раз, но подсчитывается указатель каждой ссылки.
Лечит или хитрости
Оказывается, что у CPython есть несколько хитростей, поэтому числа, которые вы получаете из deep_getsizeof (), не полностью отражают использование памяти программой Python.
Подсчет ссылок
Python управляет памятью, используя семантику подсчета ссылок. Когда на объект больше не ссылаются, его память освобождается. Но пока есть ссылка, объект не будет освобожден. Такие вещи, как циклические ссылки, могут вас сильно укусить.
Маленькие объекты
CPython управляет небольшими объектами (менее 256 байтов) в специальных пулах на 8-байтовых границах. Есть пулы для 1-8 байтов, 9-16 байтов и вплоть до 249-256 байтов. Когда выделяется объект размером 10, он выделяется из 16-байтового пула для объектов размером 9-16 байт. Таким образом, даже если он содержит только 10 байтов данных, он будет стоить 16 байтов памяти. Если вы выделяете 1 000 000 объектов размером 10, вы фактически используете 16 000 000 байтов, а не 10 000 000 байтов, как вы можете предположить. Эти 60% накладных расходов явно не тривиальны.
Целые
CPython хранит глобальный список всех целых чисел в диапазоне [-5, 256]. Эта стратегия оптимизации имеет смысл, потому что маленькие целые числа всплывают повсюду, и, учитывая, что каждое целое число занимает 24 байта, оно экономит много памяти для типичной программы.
Это также означает, что CPython предварительно выделяет 266 * 24 = 6384 байта для всех этих целых чисел, даже если вы не используете большинство из них. Вы можете проверить это с помощью функции id (), которая дает указатель на фактический объект. Если вы называете id (x) несколько для любого x в диапазоне [-5, 256], вы будете каждый раз получать один и тот же результат (для одного и того же целого числа). Но если вы попробуете это для целых чисел вне этого диапазона, каждый из них будет отличаться (новый объект создается на лету каждый раз).
Вот несколько примеров из этого диапазона:
“ `python id (-3) 140251817361752
id (-3) 140251817361752
id (-3) 140251817361752
id (201) 140251817366736
id (201) 140251817366736
id (201) 140251817366736 “ `
Вот несколько примеров за пределами диапазона:
“ `python id (301) 140251846945800
id (301) 140251846945776
id (-6) 140251846946960
id (-6) 140251846946936 “ `
Память Python против системной памяти
CPython является своего рода притяжательным. Во многих случаях, когда на объекты памяти в вашей программе больше нет ссылок, они не возвращаются в систему (например, небольшие объекты). Это хорошо для вашей программы, если вы выделяете и освобождаете много объектов (которые принадлежат одному и тому же 8-байтовому пулу), потому что Python не должен беспокоить систему, что относительно дорого. Но это не так хорошо, если ваша программа обычно использует X байтов и при некоторых временных условиях она использует в 100 раз больше (например, анализирует и обрабатывает большой файл конфигурации только при запуске).
Теперь эта память 100X может оказаться бесполезной в вашей программе, которая никогда больше не будет использоваться, и система не сможет выделить ее другим программам. Ирония заключается в том, что если вы используете модуль обработки для запуска нескольких экземпляров вашей программы, вы строго ограничите количество экземпляров, которые вы можете запускать на данном компьютере.
Профилировщик памяти
Чтобы измерить и измерить фактическое использование памяти вашей программой, вы можете использовать модуль memory_profiler . Я немного поиграл с этим, и я не уверен, что доверяю результатам. Используя это очень просто. Вы декорируете функцию (может быть основной (функция 0)) с помощью декоратора @profiler, и, когда программа завершает работу, профилировщик памяти выводит на стандартный вывод удобный отчет, который показывает общее количество и изменения в памяти для каждой строки. Вот пример Программа, которую я запускал под профилировщиком:
“ `python из профиля импорта memory_profiler
@profile def main (): a = [] b = [] c = [] для i в диапазоне (100000): a.append (5) для i в диапазоне (100000): b.append (300) для i в диапазон (100000): c.append (‘123456789012345678901234567890’) del del del del c
Как вы можете видеть, 22,9 МБ дополнительной памяти занимают. Причина, по которой память не увеличивается при добавлении целых чисел как внутри, так и вне диапазона [-5, 256], а также при добавлении строки, заключается в том, что во всех случаях используется один объект. Непонятно, почему первый цикл диапазона (100000) в строке 8 добавляет 4,2 МБ, а второй в строке 10 добавляет всего 0,4 МБ, а третий цикл в строке 12 добавляет 0,8 МБ. Наконец, при удалении списков a, b и c освобождается -0.6MB для a и c, но для b добавляется 0.2MB. Я не могу иметь много смысла из этих результатов.
Вывод
CPython использует много памяти для своих объектов. Он использует различные приемы и оптимизации для управления памятью. Отслеживая использование памяти вашим объектом и зная модель управления памятью, вы можете значительно уменьшить объем памяти вашей программы.
Выучить питон
Изучите Python с нашим полным руководством по питону, независимо от того, начинаете ли вы или начинающий программист, ищущий новые навыки.
Monitoring memory usage of a running Python program
Managing memory is important in any programming logic but this becomes necessary for python. As python is used in Ml and AI where vast data are used which needs to be managed. Memory leaks,i.e, the program is out of memory after running for several hours. To manage these memory leaks memory monitoring is essential. Monitoring memory is also called profiling. As a developer, it’s a necessity that we profile our program and use less memory allocation as much as possible.
Method 1: Using Tracemalloc
Tracemalloc is a library module that traces every memory block in python. The tracing starts by using the start() during runtime. This library module can also give information about the total size, number, and average size of allocated memory blocks. Lets its function with a proper example-