Python3使用tracemalloc實現追蹤mmap記憶體變化

2023-03-15 06:01:37

技術背景

在前面一篇部落格中我們介紹了一些用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就是得益於記憶體對映技術。

到此這篇關於Python3使用tracemalloc實現追蹤mmap記憶體變化的文章就介紹到這了,更多相關Python tracemalloc追蹤mmap記憶體變化內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！

Python3使用tracemalloc實現追蹤mmap記憶體變化

目錄

技術背景

用tracemalloc跟蹤python程式記憶體佔用

用tracemalloc追蹤記憶體變化

記憶體佔用曲線

mmap記憶體佔用測試

將numpy陣列寫入txt檔案

numpy檔案讀取測試

mmap記憶體佔用測試

總結概要

熱門文章