Python 进程使用的总内存？

问题描述 投票：0回答：12

Python 程序有没有办法确定它当前使用了多少内存？我看过关于单个对象的内存使用情况的讨论，但我需要的是该进程的总内存使用情况，以便我可以确定何时需要开始丢弃缓存数据。

python memory-management
12个回答
548
投票

这里是一个有用的解决方案，适用于各种操作系统，包括Linux、Windows等：

import psutil
process = psutil.Process()
print(process.memory_info().rss)  # in bytes

备注：

    如果尚未安装，请

  • 执行

    pip install psutil

  • 如果您想快速了解您的进程需要多少 MiB，可以使用方便的单行代码：

    import os, psutil; print(psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)

  • 使用Python 2.7和psutil 5.6.3，它是

    process.memory_info()[0]
    （后来API发生了变化）。

291
投票

对于基于 Unix 的系统（Linux、Mac OS X、Solaris），您可以使用标准库模块 

getrusage()
 中的 
resource 函数。生成的对象具有属性 
ru_maxrss
，它给出了调用进程的 peak 内存使用量：



>>> 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
 来获取总（自身和子）进程的使用情况。



如果您只关心 Linux，您也可以阅读 
resource.RUSAGE_BOTH
 或 
/proc/self/status
 文件，如该问题的其他答案中所述，也可以阅读 
this
。

    


在 Windows 上，您可以使用 WMI（

    

    
    
    

    

        

            

                

                    
69
投票

                    
                

            

        

        
、
cheeseshop）：
/proc/self/statm

在 Linux 上（来自 python 食谱 
http://code.activestate.com/recipes/286222/
:

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)

    


在unix上，可以使用

    

    
    
    

    

        

            

                

                    
45
投票

                    
                

            

        

        
工具来监控：



ps



其中 1347 是某个进程 ID。另外，结果以 MB 为单位。
    




Linux 上

    

    
    
    

    

        

            

                

                    
27
投票

                    
                

            

        

        
2
、Python 3 和 pypy，没有任何导入：
$ ps u -p 1347 | awk '{sum=sum+$6}; END {print sum/1024}'

它读取当前进程的状态文件，取出
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的值），最后截掉最后3个字节，即空格和单位（kB） ).

要返回，它会去除所有空格并将其作为数字返回。


在 Linux 4.4 和 4.9 上进行了测试，但即使是早期的 Linux 版本也应该可以工作：查看 
VmRSS:
 并搜索 
man proc
 文件上的信息，它提到了某些字段的最低版本（例如 Linux 2.6.10 的“VmPTE”） ”），但“VmRSS”字段（我在这里使用的）没有这样的提及。因此我认为它从早期版本就已经存在了。
    


下面是我的函数装饰器，它允许跟踪该进程在函数调用之前消耗了多少内存，在函数调用之后使用了多少内存，以及函数执行了多长时间。 




    

    
    
    

    

        

            

                

                    
12
投票

                    
                

            

        

        



所以，当你有一些用它装饰的函数时



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


    




对于 Python 3.6 和 psutil 5.4.5，使用
inside list create
list_create: memory before: 45,928,448, after: 46,211,072, consumed: 282,624; exec time: 00:00:00


    

    
    
    

    

        

            

                

                    
8
投票

                    
                

            

        

        
这里
。


memory_percent()
    



甚至比
import os
import psutil
process = psutil.Process(os.getpid())
print(process.memory_percent())


    

    
    
    

    

        

            

                

                    
8
投票

                    
                

            

        

        
/proc/self/status
。它只是一个以空格分隔的多个
统计数据
列表。我无法判断这两个文件是否始终存在。



  /proc/[pid]/statm
  
  
提供有关内存使用情况的信息（以页为单位）。
                这些列是：

  
  

  
size (1) 程序总大小
                           （与 /proc/[pid]/status 中的 VmSize 相同）

  
居民（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）
    • 
  
  • 

    • 


  • 这是一个简单的例子：
    • 


/proc/self/statm



这会产生一个看起来像这样的列表：



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)




您可以看到，在大约 3 次 100,000 字节的分配之后，它跳跃了大约 300,000 字节。

    


我喜欢
它

    

    
    
    

    

        

            

                

                    
7
投票

                    
                

            

        

        



0
0
368640
368640
368640
638976
638976
909312
909312
909312


附上我的进程列表。



# 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




参考



内存 - Linux：找出哪个进程正在使用所有 RAM？ - 超级用户



    

    
    
    

    

        

            

                

                    
5
投票

                    
                

            

        

        
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'])

 (/usr/bin/time) 如果您传递 -v，则会为您提供该信息。请参阅下面的
time

    

    
    
    

    

        

            

                

                    
4
投票

                    
                

            

        

        
最大
（峰值）
真实
（不是虚拟）
内存：


Maximum resident set size
    

使用 sh 和 os 进入 python bayer 的答案。


$ /usr/bin/time -v ls /

    Command being timed: "ls /"
    User time (seconds): 0.00
    System time (seconds): 0.01
    Percent of CPU this job got: 250%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 0
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 0
    Minor (reclaiming a frame) page faults: 315
    Voluntary context switches: 2
    Involuntary context switches: 0
    Swaps: 0
    File system inputs: 0
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0



答案以兆字节为单位。

    

    
    
    

    

        

            

                

                    
3
投票

                    
                

            

        

        





    

    


  

  

    
最新问题


  





  

    © www.soinside.com 2019 - 2024. All rights reserved.