rwa*_*ace 229 python memory-management
有没有办法让Python程序确定它当前使用了多少内存？我已经看过有关单个对象的内存使用情况的讨论,但我需要的是进程的总内存使用量,以便我可以确定何时需要开始丢弃缓存数据.
Bas*_*asj 265
这是一个适用于各种操作系统的有用解决方案,包括Linux,Windows 7等:
import os
import psutil
process = psutil.Process(os.getpid())
print(process.memory_info().rss) # in bytes
在我目前的Python 2.7安装中,最后一行应该是
print(process.memory_info()[0])
相反(API有变化).
注意:pip install psutil如果尚未安装,请执行操作.
Nat*_*ike 193
对于基于Unix的系统(Linux,Mac OS X,Solaris),您可以使用getrusage()标准库模块中的功能resource.生成的对象具有属性ru_maxrss,该属性为调用进程提供峰值内存使用情况:
>>> resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
2656 # peak memory usage (kilobytes on Linux, bytes on OS X)
在Python文档不记单位.请参阅特定系统的man getrusage.2页面以检查设备的值.在Ubuntu 18.04上,该单位以千字节为单位.在Mac OS X上,它是字节.
该getrusage()函数还可以resource.RUSAGE_CHILDREN用于获取子进程的使用,并且(在某些系统上)resource.RUSAGE_BOTH用于总(自身和子进程)进程使用.
如果你只关心Linux的,则可以选择阅读/proc/self/status或/proc/self/statm在其他的答案对这个问题,并描述文件这一个了.
cod*_*ape 64
在Windows上,您可以使用WMI(主页,cheeseshop):
def memory():
import os
from wmi import WMI
w = WMI('.')
result = w.query("SELECT WorkingSet FROM Win32_PerfRawData_PerfProc_Process WHERE IDProcess=%d" % os.getpid())
return int(result[0].WorkingSet)
在Linux上(来自python cookbook http://code.activestate.com/recipes/286222/:
import os
_proc_status = '/proc/%d/status' % os.getpid()
_scale = {'kB': 1024.0, 'mB': 1024.0*1024.0,
'KB': 1024.0, 'MB': 1024.0*1024.0}
def _VmB(VmKey):
'''Private.
'''
global _proc_status, _scale
# get pseudo file /proc/<pid>/status
try:
t = open(_proc_status)
v = t.read()
t.close()
except:
return 0.0 # non-Linux?
# get VmKey line e.g. 'VmRSS: 9999 kB\n ...'
i = v.index(VmKey)
v = v[i:].split(None, 3) # whitespace
if len(v) < 3:
return 0.0 # invalid format?
# convert Vm value to bytes
return float(v[1]) * _scale[v[2]]
def memory(since=0.0):
'''Return memory usage in bytes.
'''
return _VmB('VmSize:') - since
def resident(since=0.0):
'''Return resident memory usage in bytes.
'''
return _VmB('VmRSS:') - since
def stacksize(since=0.0):
'''Return stack size in bytes.
'''
return _VmB('VmStk:') - since
bay*_*yer 30
在unix上,您可以使用该ps工具对其进行监控:
$ ps u -p 1347 | awk '{sum=sum+$6}; END {print sum/1024}'
其中1347是某个进程ID.此外,结果是以MB为单位.
Luc*_*Luc 15
当前进程在 Linux 上的当前内存使用情况，用于 Python 2、 Python 3和pypy，没有任何导入：
def getCurrentMemoryUsage():
''' Memory usage in kB '''
with open('/proc/self/status') as f:
memusage = f.read().split('VmRSS:')[1].split('\n')[0][:-3]
return int(memusage.strip())
它读取当前进程的状态文件，取 之后的所有内容VmRSS:，然后取第一个换行符之前的所有内容（隔离 VmRSS 的值），最后切掉最后 3 个字节，即空格和单位 (kB)。
要返回，它会去除任何空格并将其作为数字返回。
在 Linux 4.4 和 4.9 上进行了测试，但即使是早期的 Linux 版本也应该可以工作：查看man proc并搜索/proc/$PID/status文件上的信息，它提到了某些领域的最低版本（如 Linux 2.6.10 的“VmPTE”），但“VmRSS " 字段（我在这里使用）没有这样的提及。因此，我认为它自早期版本以来一直存在。
我喜欢它，谢谢@bayer。我现在得到了一个特定的进程计数工具。
# Megabyte.
$ ps aux | grep python | awk '{sum=sum+$6}; END {print sum/1024 " MB"}'
87.9492 MB
# Byte.
$ ps aux | grep python | awk '{sum=sum+$6}; END {print sum " KB"}'
90064 KB
附上我的进程列表。
$ ps aux | grep python
root 943 0.0 0.1 53252 9524 ? Ss Aug19 52:01 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
root 950 0.6 0.4 299680 34220 ? Sl Aug19 568:52 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
root 3803 0.2 0.4 315692 36576 ? S 12:43 0:54 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
jonny 23325 0.0 0.1 47460 9076 pts/0 S+ 17:40 0:00 python
jonny 24651 0.0 0.0 13076 924 pts/4 S+ 18:06 0:00 grep python
下面是我的函数装饰器，它允许跟踪这个进程在函数调用之前消耗了多少内存，在函数调用之后它使用了多少内存，以及函数执行了多长时间。
import time
import os
import psutil
def elapsed_since(start):
return time.strftime("%H:%M:%S", time.gmtime(time.time() - start))
def get_process_memory():
process = psutil.Process(os.getpid())
return process.memory_info().rss
def track(func):
def wrapper(*args, **kwargs):
mem_before = get_process_memory()
start = time.time()
result = func(*args, **kwargs)
elapsed_time = elapsed_since(start)
mem_after = get_process_memory()
print("{}: memory before: {:,}, after: {:,}, consumed: {:,}; exec time: {}".format(
func.__name__,
mem_before, mem_after, mem_after - mem_before,
elapsed_time))
return result
return wrapper
所以，当你有一些用它装饰的函数时
from utils import track
@track
def list_create(n):
print("inside list create")
return [1] * n
您将能够看到此输出：
inside list create
list_create: memory before: 45,928,448, after: 46,211,072, consumed: 282,624; exec time: 00:00:00
对于 Python 3.6 和 psutil 5.4.5，使用此处memory_percent()列出的函数更容易。
import os
import psutil
process = psutil.Process(os.getpid())
print(process.memory_percent())
import os, win32api, win32con, win32process
han = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION|win32con.PROCESS_VM_READ, 0, os.getpid())
process_memory = int(win32process.GetProcessMemoryInfo(han)['WorkingSetSize'])
比/proc/self/status:更容易使用/proc/self/statm。这只是几个统计信息的空格分隔列表。我无法判断这两个文件是否始终存在。
/proc/[pid]/statm
提供有关内存使用情况的信息，以页为单位。列是：
- size (1) 程序总大小（与 /proc/[pid]/status 中的 VmSize 相同）
- resident (2) 常驻集大小（与/proc/[pid]/status中的VmRSS相同）
- shared (3) 常驻共享页面的数量（即由文件支持）（与 /proc/[pid]/status 中的 RssFile+RssShmem 相同）
- 文字（4）文字（代码）
- lib (5) 库（自 Linux 2.6 起未使用；始终为 0）
- 数据（6）数据+堆栈
- dt (7) 脏页（自 Linux 2.6 起未使用；始终为 0）
这是一个简单的例子：
from pathlib import Path
from resource import getpagesize
PAGESIZE = getpagesize()
PATH = Path('/proc/self/statm')
def get_resident_set_size() -> int:
"""Return the current resident set size in bytes."""
# statm columns are: size resident shared text lib data dt
statm = PATH.read_text()
fields = statm.split()
return int(fields[1]) * PAGESIZE
data = []
start_memory = get_resident_set_size()
for _ in range(10):
data.append('X' * 100000)
print(get_resident_set_size() - start_memory)
这会产生一个看起来像这样的列表：
0
0
368640
368640
368640
638976
638976
909312
909312
909312
您可以看到，在大约 3 次 100,000 字节的分配后，它跳跃了大约 300,000 字节。