So verwenden Sie Tracemalloc in Python3, um mmap-Speicheränderungen zu verfolgen

Technischer Hintergrund

Im vorherigen Blog haben wir einige Methoden zur Verarbeitung tabellarischer Daten mit Python3 vorgestellt, die sich auf eine groß angelegte Datenverarbeitungslösung wie vaex konzentrierten. Diese Datenverarbeitungslösung basiert auf der Speicherzuordnungstechnologie. Durch die Erstellung von Speicherzuordnungsdateien vermeiden wir große Speichernutzungsprobleme, die durch das direkte Laden von Quelldaten in den Speicher entstehen. Dadurch können wir die Speichergröße des lokalen Computers nutzen, die nicht groß ist Daten unter sehr großen Bedingungen. In Python 3 gibt es eine Bibliothek namens mmap, mit der sich direkt Speicherzuordnungsdateien erstellen lassen.

Verwenden Sie Tracemalloc, um die Speichernutzung von Python-Programmen zu verfolgen.

Hier hoffen wir, die tatsächliche Speichernutzung der Speicherzuordnungstechnologie vergleichen zu können. Daher müssen wir ein Python-basiertes Speicherverfolgungstool einführen: Tracemalloc. Nehmen wir zunächst ein einfaches Beispiel: Erstellen Sie ein zufälliges Array und beobachten Sie dann die vom Array belegte Speichergröße. Das Ausgabeergebnis lautet wie folgt:

[dechin@dechin-manjaro mmap]$ python3 Tracem. py

[Top 10 ]

tracem.py:8: Größe=78,2 KiB, Anzahl=2, Durchschnitt=39,1 KiB

Wenn wir den Befehl top verwenden, um den Speicher direkt zu erkennen, besteht kein Zweifel daran, dass Google Chrome den höchsten Wert hat Speicherfreigabe:

top - 10:04:08 up 6 Tage, 15:18, 5 Benutzer, Lastdurchschnitt: 0,23, 0,33, 0,27

Aufgaben: 309 insgesamt, 1 läuft, 264 schlafend, 23 gestoppt, 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 : 16384,0 insgesamt, 16384,0 frei, 0,0 verwendet. 36775,8 verfügbar Mem

Prozess-ID 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 Chrom


Also verfolgen Das Kind basierend auf der Prozessnummer Die Speichernutzung des Prozesses ist ein wichtiger Punkt bei der Verwendung von Tracemalloc. Hier stellen wir fest, dass die Speichernutzung eines Numpy-Vektors der Größe 10000 etwa 39,1 KiB beträgt, was tatsächlich unseren Erwartungen entspricht:

In [3]: 39,1*1024/ 4

Out[3]: 10009,6

Weil dies fast der Speicherbedarf von 10000 float32-Gleitkommazahlen ist, was darauf hinweist, dass alle Elemente im Speicher gespeichert wurden.

Verwenden Sie Tracemalloc, um Speicheränderungen zu verfolgen.

Im vorherigen Kapitel haben wir die Verwendung von Snapshot-Speicher-Snapshots vorgestellt. Dann können wir uns leicht vorstellen, zwei Speicher-Snapshots zu „machen“ und dann die Änderungen in den Snapshots zu vergleichen. Kann ich die Größe ermitteln? die Erinnerungsveränderung? Machen Sie als nächstes einen einfachen Versuch:

# 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)

Die Ausführungsergebnisse sind wie folgt:

[dechin@dechin-manjaro mmap]$ python3 comp_tracem.py

[Top 10 Unterschiede]

comp_tracem.py:9: size=78,2 KiB (+78,2 KiB), Anzahl=2 (+2), Durchschnitt=39,1 KiB

Sie können sehen, dass der durchschnittliche Speichergrößenunterschied vor und nach diesem Schnappschuss 39,1 KiB beträgt. Wenn wir die Dimension des Vektors auf 1000000 ändern:

# 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)

Führen Sie es erneut aus. Schauen Sie sich den Effekt an:

[dechin@dechin-manjaro mmap]$ python3 comp_tracem.py

[Top 10 Unterschiede]

comp_tracem.py:9: size=7813 KiB (+7813 KiB ), count=2 (+2) , Durchschnitt=3906 KiB

Wir haben festgestellt, dass das Ergebnis 3906 war, was einer 100-fachen Verstärkung entspricht, was eher den Erwartungen entspricht. Wenn wir es sorgfältig berechnen:

In [4]: ​​​​3906 * 1024/4

Out[4]: 999936,0

Wir stellen fest, dass es sich im Vergleich zum vollständigen Float32 nicht vollständig um einen Float32-Typ handelt Typ Ein Teil der Speichergröße fehlt. Ich frage mich, ob in der Mitte einige Nullen generiert wurden und die Größe automatisch komprimiert wurde. Auf dieses Problem wollen wir uns jedoch nicht konzentrieren. Wir testen weiterhin die Gedächtnisänderungskurve nach unten.

Speichernutzungskurve

Setzt den Inhalt der beiden vorherigen Kapitel fort. Wir testen hauptsächlich den Speicherplatz, der von zufälligen Arrays unterschiedlicher Dimensionen benötigt wird. Basierend auf dem obigen Codemodul wird eine for-Schleife hinzugefügt: Gezeichnet von

length=1000000

Das Rendering ist wie folgt:

Hier stellen wir auch fest, dass die Speichernutzung zwar in den meisten Fällen den Erwartungen entspricht, es aber viele Punkte gibt, die weniger als erwartet belegen. Wir vermuten, dass dies daran liegt, dass es 0 Elemente gibt Ich habe den Code leicht geändert und eine Operation basierend auf dem Originalcode hinzugefügt, um das Auftreten von 0 so weit wie möglich zu vermeiden:

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

Nach dem Update sieht das Ergebnisbild wie folgt aus:

虽然不符合预期的点数少了，但是这里还是有两个点不符合预期的内存占用大小，疑似数据被压缩了。

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数量是需要保持不变的，否则内存映射就会发生错误。

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Tracemalloc in Python3, um mmap-Speicheränderungen zu verfolgen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!