python3使用tracemalloc追蹤mmap內存變化

技術背景

在前面一篇博客中我們介紹了一些用python3處理表格數據的方法，其中重點包含了vaex這樣一個大規模數據處理的方案。這個數據處理的方案是基於內存映射（memory map）的技術，通過創建內存映射文件來避免在內存中直接加載源數據而導致的大規模內存占用問題，這使得我們可以在本地電腦內存規模並不是很大的條件下對大規模的數據進行處理。python3中提供了mmap這樣一個倉庫，可以直接創建內存映射文件。

用tracemalloc跟蹤python程序內存占用

這里我們希望能夠對比內存映射技術的實際內存占用，因此我們需要引入一個基於python的內存追蹤工具：tracemalloc。我們先看一個簡單的案例，創建一個隨機數組，觀察這個數組的內存占用大小：

# tracem.py

import tracemalloc
import numpy as np
tracemalloc.start()

length=10000
test_array=np.random.randn(length) # 分配一個定長隨機數組
snapshot=tracemalloc.take_snapshot() # 內存攝像
top_stats=snapshot.statistics('lineno') # 內存占用數據獲取

print ('[Top 10]')
for stat in top_stats[:10]: # 打印占用內存最大的10個子進程
    print (stat)

輸出結果如下：

[dechin@dechin-manjaro mmap]$ python3 tracem.py 
[Top 10]
tracem.py:8: size=78.2 KiB, count=2, average=39.1 KiB

假如我們是使用top指令來直接檢測內存的話，毫無疑問占比內存最高的還是谷歌瀏覽器：

top - 10:04:08 up 6 days, 15:18,  5 users,  load average: 0.23, 0.33, 0.27
任務: 309 total,   1 running, 264 sleeping,  23 stopped,  21 zombie
%Cpu(s):  0.6 us,  0.2 sy,  0.0 ni, 99.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :  39913.6 total,  25450.8 free,   1875.7 used,  12587.1 buff/cache
MiB Swap:  16384.0 total,  16384.0 free,      0.0 used.  36775.8 avail Mem 

 進程號 USER      PR  NI    VIRT    RES    SHR    %CPU  %MEM     TIME+ COMMAND               
 286734 dechin    20   0   36.6g 175832 117544 S   4.0   0.4   1:02.32 chromium 

因此根據進程號來追蹤子進程的內存占用才是使用tracemalloc的一個重點，這里我們發現一個10000大小的numpy矢量的內存占用約為39.1 KiB，這其實是符合我們的預期的：

In [3]: 39.1*1024/4
Out[3]: 10009.6

因為這幾乎就是10000個float32浮點數的內存占用大小，這表明所有的元素都已經存儲在內存中。

用tracemalloc追蹤內存變化

在上面一個章節中我們介紹了snapshot內存快照的使用方法，那么我們很容易可以想到，通過“拍攝”兩張內存快照，然后對比一下快照中的變化，不就可以得到內存變化的大小么？接下來做一個簡單嘗試：

# comp_tracem.py

import tracemalloc
import numpy as np
tracemalloc.start()

snapshot0=tracemalloc.take_snapshot() # 第一張快照
length=10000
test_array=np.random.randn(length)
snapshot1=tracemalloc.take_snapshot() # 第二張快照
top_stats=snapshot1.compare_to(snapshot0,'lineno') # 快照對比

print ('[Top 10 differences]')
for stat in top_stats[:10]:
    print (stat)

執行結果如下：

[dechin@dechin-manjaro mmap]$ python3 comp_tracem.py 
[Top 10 differences]
comp_tracem.py:9: size=78.2 KiB (+78.2 KiB), count=2 (+2), average=39.1 KiB

可以看到這個快照前后的平均內存大小差異就是在39.1 KiB，假如我們把矢量的維度改為1000000：

length=1000000

再執行一遍看看效果：

[dechin@dechin-manjaro mmap]$ python3 comp_tracem.py  
[Top 10 differences]
comp_tracem.py:9: size=7813 KiB (+7813 KiB), count=2 (+2), average=3906 KiB

我們發現結果是3906,相當於被放大了100倍，是比較符合預期的。當然如果我們仔細去算一下：

In [4]: 3906*1024/4
Out[4]: 999936.0

我們發現這里面並不完全是float32的類型，相比於完全的float32類型缺失了一部分內存大小，這里懷疑是否是中間產生了一些0,被自動的壓縮了大小？不過這個問題並不是我們所要重點關注的，我們繼續向下測試內存的變化曲線。

內存占用曲線

延續前面兩個章節的內容，我們主要測試一下不同維度的隨機數組所需要占用的內存空間，在上述代碼模塊的基礎上增加了一個for循環：

# comp_tracem.py

import tracemalloc
import numpy as np
tracemalloc.start()

x=[]
y=[]
multiplier={'B':1,'KiB':1024,'MiB':1048576}
snapshot0=tracemalloc.take_snapshot()
for length in range(1,1000000,100000):
    np.random.seed(1)
    test_array=np.random.randn(length)
    snapshot1=tracemalloc.take_snapshot()
    top_stats=snapshot1.compare_to(snapshot0,'lineno')
    for stat in top_stats[:10]:
        if 'comp_tracem.py' in str(stat): # 判斷是否屬於當前文件所產生的內存占用
            x.append(length)
            mem=str(stat).split('average=')[1].split(' ')
            y.append(float(m曲線em[0])*multiplier[mem[1]])
            break

import matplotlib.pyplot as plt
plt.figure()
plt.plot(x,y,'D',color='black',label='Experiment')
plt.plot(x,np.dot(x,4),color='red',label='Expect') # float32的預期占用空間
plt.title('Memery Difference vs Array Length')
plt.xlabel('Number Array Length')
plt.ylabel('Memory Difference')
plt.legend()
plt.savefig('comp_mem.png')

畫出來的效果圖如下所示：

這里我們又發現，雖然大部分情況下是符合內存占用預期的，但有很多個點比預期占用的要少，我們懷疑是因為存在0元素，因此稍微修改了一下代碼，在原代碼的基礎上增加了一個操作來盡可能的避免0的出現：

# comp_tracem.py

import tracemalloc
import numpy as np
tracemalloc.start()

x=[]
y=[]
multiplier={'B':1,'KiB':1024,'MiB':1048576}
snapshot0=tracemalloc.take_snapshot()
for length in range(1,1000000,100000):
    np.random.seed(1)
    test_array=np.random.randn(length)
    test_array+=np.ones(length)*np.pi # 在原數組基礎上加一個圓周率，內存不變
    snapshot1=tracemalloc.take_snapshot()
    top_stats=snapshot1.compare_to(snapshot0,'lineno')
    for stat in top_stats[:10]:
        if 'comp_tracem.py' in str(stat):
            x.append(length)
            mem=str(stat).split('average=')[1].split(' ')
            y.append(float(mem[0])*multiplier[mem[1]])
            break

import matplotlib.pyplot as plt
plt.figure()
plt.plot(x,y,'D',color='black',label='Experiment')
plt.plot(x,np.dot(x,4),color='red',label='Expect')
plt.title('Memery Difference vs Array Length')
plt.xlabel('Number Array Length')
plt.ylabel('Memory Difference')
plt.legend()
plt.savefig('comp_mem.png')

經過更新后，得到的結果圖如下所示：

雖然不符合預期的點數少了，但是這里還是有兩個點不符合預期的內存占用大小，疑似數據被壓縮了。

mmap內存占用測試

在上面幾個章節之后，我們已經基本掌握了內存追蹤技術的使用，這里我們將其應用在mmap內存映射技術上，看看有什么樣的效果。

將numpy數組寫入txt文件

因為內存映射本質上是一個對系統文件的讀寫操作，因此這里我們首先將前面用到的numpy數組存儲到txt文件中：

# write_array.py

import numpy as np

x=[]
y=[]
for length in range(1,1000000,100000):
    np.random.seed(1)
    test_array=np.random.randn(length)
    test_array+=np.ones(length)*np.pi
    np.savetxt('numpy_array_length_'+str(length)+'.txt',test_array)

寫入完成后，在當前目錄下會生成一系列的txt文件：

-rw-r--r-- 1 dechin dechin  2500119  4月 12 10:09 numpy_array_length_100001.txt
-rw-r--r-- 1 dechin dechin       25  4月 12 10:09 numpy_array_length_1.txt
-rw-r--r-- 1 dechin dechin  5000203  4月 12 10:09 numpy_array_length_200001.txt
-rw-r--r-- 1 dechin dechin  7500290  4月 12 10:09 numpy_array_length_300001.txt
-rw-r--r-- 1 dechin dechin 10000356  4月 12 10:09 numpy_array_length_400001.txt
-rw-r--r-- 1 dechin dechin 12500443  4月 12 10:09 numpy_array_length_500001.txt
-rw-r--r-- 1 dechin dechin 15000526  4月 12 10:09 numpy_array_length_600001.txt
-rw-r--r-- 1 dechin dechin 17500606  4月 12 10:09 numpy_array_length_700001.txt
-rw-r--r-- 1 dechin dechin 20000685  4月 12 10:09 numpy_array_length_800001.txt
-rw-r--r-- 1 dechin dechin 22500788  4月 12 10:09 numpy_array_length_900001.txt

我們可以用head或者tail查看前n個或者后n個的元素：

[dechin@dechin-manjaro mmap]$ head -n 5 numpy_array_length_100001.txt 
4.765938017253034786e+00
2.529836239939717846e+00
2.613420901326337642e+00
2.068624031433622612e+00
4.007000282914471967e+00

numpy文件讀取測試

前面幾個測試我們是直接在內存中生成的numpy的數組並進行內存監測，這里我們為了嚴格對比，統一采用文件讀取的方式，首先我們需要看一下numpy的文件讀取的內存曲線如何：

# npopen_tracem.py

import tracemalloc
import numpy as np
tracemalloc.start()

x=[]
y=[]
multiplier={'B':1,'KiB':1024,'MiB':1048576}
snapshot0=tracemalloc.take_snapshot()
for length in range(1,1000000,100000):
    test_array=np.loadtxt('numpy_array_length_'+str(length)+'.txt',delimiter=',')
    snapshot1=tracemalloc.take_snapshot()
    top_stats=snapshot1.compare_to(snapshot0,'lineno')
    for stat in top_stats[:10]:
        if '/home/dechin/anaconda3/lib/python3.8/site-packages/numpy/lib/npyio.py:1153' in str(stat):
            x.append(length)
            mem=str(stat).split('average=')[1].split(' ')
            y.append(float(mem[0])*multiplier[mem[1]])
            break

import matplotlib.pyplot as plt
plt.figure()
plt.plot(x,y,'D',color='black',label='Experiment')
plt.plot(x,np.dot(x,8),color='red',label='Expect')
plt.title('Memery Difference vs Array Length')
plt.xlabel('Number Array Length')
plt.ylabel('Memory Difference')
plt.legend()
plt.savefig('open_mem.png')

需要注意的一點是，這里雖然還是使用numpy對文件進行讀取，但是內存占用已經不是名為npopen_tracem.py的源文件了，而是被保存在了npyio.py:1153這個文件中，因此我們在進行內存跟蹤的時候，需要調整一下對應的統計位置。最后的輸出結果如下：

由於讀入之后是默認以float64來讀取的，因此預期的內存占用大小是元素數量×8，這里讀入的數據內存占用是幾乎完全符合預期的。

mmap內存占用測試

伏筆了一大篇幅的文章，最后終於到了內存映射技術的測試，其實內存映射模塊mmap的使用方式倒也不難，就是配合os模塊進行文件讀取，基本上就是一行的代碼：

# mmap_tracem.py

import tracemalloc
import numpy as np
import mmap
import os
tracemalloc.start()

x=[]
y=[]
multiplier={'B':1,'KiB':1024,'MiB':1048576}
snapshot0=tracemalloc.take_snapshot()
for length in range(1,1000000,100000):
    test_array=mmap.mmap(os.open('numpy_array_length_'+str(length)+'.txt',os.O_RDWR),0) # 創建內存映射文件
    snapshot1=tracemalloc.take_snapshot()
    top_stats=snapshot1.compare_to(snapshot0,'lineno')
    for stat in top_stats[:10]:
        print (stat)
        if 'mmap_tracem.py' in str(stat):
            x.append(length)
            mem=str(stat).split('average=')[1].split(' ')
            y.append(float(mem[0])*multiplier[mem[1]])
            break

import matplotlib.pyplot as plt
plt.figure()
plt.plot(x,y,'D',color='black',label='Experiment')
plt.title('Memery Difference vs Array Length')
plt.xlabel('Number Array Length')
plt.ylabel('Memory Difference')
plt.legend()
plt.savefig('mmap.png')

運行結果如下：

我們可以看到內存上是幾乎沒有波動的，因為我們並未把整個數組加載到內存中，而是在內存中加載了其內存映射的文件。使得我們可以讀取文件中的任何一個位置的byte，但是不用耗費太大的內存資源。當我們去修改寫入文件的時候需要額外的小心，因為對於內存映射技術來說，byte數量是需要保持不變的，否則內存映射就會發生錯誤。

總結概要

本文介紹了用tracemalloc來進行python程序的內存追蹤的技術，以及簡單的文件映射技術mmap的使用方法介紹和演示。通過這些案例，我們了解到，對於小規模的計算場景，可以將整個的需要計算的元素包含在內存中，這比較方便也比較快速。而對於大規模的文件場景，還是使用內存映射技術更加的快速，這個速度在本文中介紹的幾個案例的運行中也能夠體會到。內存映射技術已經有很多應用場景，比如前面介紹過的vaex就是得益於內存映射技術。

版權聲明

本文首發鏈接為：https://www.cnblogs.com/dechinphy/p/mmap.html
作者ID：DechinPhy
更多原著文章請參考：https://www.cnblogs.com/dechinphy/