Entdecken Sie die Geheimnisse der IO-Leistungsoptimierung in Linux-Systemen

Im heutigen Kontext von Big Data und künstlicher Intelligenz ist die IO-Leistung für jedes Computersystem von entscheidender Bedeutung. Für Linux-Systeme benötigen wir ein tiefgreifendes Verständnis des IO-Leistungsmodells und der Optimierungsstrategien. In diesem Artikel werden das E/A-Modell des Linux-Systems und Methoden zur Leistungsoptimierung für verschiedene E/A-Vorgänge ausführlich vorgestellt.

Zu den aktuellen gängigen IO-Testtools von Drittanbietern gehören [neiqian]fio[/neiqian], [neiqian]iometer[/neiqian] und [neiqian]Orion[/neiqian].

fio ist bequemer unter einem Linux-System zu verwenden, iometer ist bequemer unter einem Windows-System zu verwenden, Orion ist die IO-Testsoftware von Oracle, die das Lesen und Schreiben von Oracle-Datenbankszenarien simulieren kann, ohne eine Oracle-Datenbank zu installieren.

Das Folgende ist ein IO-Test für SAN-Speicher mit dem Fio-Tool auf einem Linux-System.

1. Installieren Sie fio

Methode 1: Laden Sie die Datei fio-2.1.10.tar von der offiziellen fio-Website herunter. Nach dem Dekomprimieren können Sie fio nach ./configure, make und make installieren.

Methode 2: Installation über yum unter einem Linux-System, yum install -y fio

2. [neiqian]fio[/neiqian] Parametererklärung

Sie können fio -help verwenden, um die einzelnen Parameter anzuzeigen. Auf der offiziellen Website finden Sie die Anleitungen für die einzelnen Parameter.

filename=/dev/emcpowerb 支持文件系统或者裸设备，-filename=/dev/sda2或-filename=/dev/sdb
direct=1 测试过程绕过机器自带的buffer，使测试结果更真实
rw=randwread 测试随机读的I/O
rw=randwrite 测试随机写的I/O
rw=randrw 测试随机混合写和读的I/O
rw=read 测试顺序读的I/O
rw=write 测试顺序写的I/O
rw=rw 测试顺序混合写和读的I/O
bs=4k 单次io的块文件大小为4k
bsrange=512-2048 同上，提定数据块的大小范围
size=5g 本次的测试文件大小为5g，以每次4k的io进行测试
numjobs=30 本次的测试线程为30
runtime=1000 测试时间为1000秒，如果不写则一直将5g文件分4k每次写完为止
ioengine=psync io引擎使用pync方式，如果要使用libaio引擎，需要yum install libaio-devel包
rwmixwrite=30 在混合读写的模式下，写占30%
group_reporting 关于显示结果的，汇总每个进程的信息
此外
lockmem=1g 只使用1g内存进行测试
zero_buffers 用0初始化系统buffer
nrfiles=8 每个进程生成文件的数量

3. Detaillierte Erläuterung der FIO-Testszenarien und Berichtserstellung

Testszenario:

100 % zufällig, 100 % gelesen, 4K

fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=randread -ioengine=psync -

bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=rand_100read_4k

100 % zufällig, 100 % geschrieben, 4K

fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -

bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=rand_100write_4k

100 % sequentiell, 100 % gelesen, 4K

fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -

bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=sqe_100read_4k

100 % sequentiell, 100 % geschrieben, 4K

fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -

bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=sqe_100write_4k

100 % zufällig, 70 % lesen, 30 % schreiben 4K

fio -filename=/dev/emcpowerb -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -

ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=randrw_70read_4k

Ergebnisberichtansicht:

[root@rac01-node02]# fio -filename=/dev/sdc4 -direct=1 -iodepth 1 -thread -rw=randrw -rwmixre
ad=70 -ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=r
andrw_70read_4k_local
randrw_70read_4k_local: (g=0): rw=randrw, bs=4K-4K/4K-4K/4K-4K, ioengine=psync, iodepth=1
...
fio-2.1.10
Starting 50 threads
Jobs: 21 (f=21): [mm_m_m__mmmmmm__mm_m_mmm_mm__m_m_m] [3.4% done] [7004KB/2768KB/0KB /s]
 [1751/692/0 iops] [eta 01h:27m:00s]
randrw_70read_4k_local: (groupid=0, jobs=50): err= 0: pid=13710: Wed May 31 10:23:31 2017
read : io=1394.2MB, bw=7926.4KB/s, iops=1981, runt=180113msec

clat (usec): min=39, max=567873, avg=24323.79, stdev=25645.98
lat (usec): min=39, max=567874, avg=24324.23, stdev=25645.98
clat percentiles (msec):
| 1.00th=[ 3], 5.00th=[ 5], 10.00th=[ 6], 20.00th=[ 7],
| 30.00th=[ 9], 40.00th=[ 12], 50.00th=[ 16], 60.00th=[ 21],
| 70.00th=[ 27], 80.00th=[ 38], 90.00th=[ 56], 95.00th=[ 75],
| 99.00th=[ 124], 99.50th=[ 147], 99.90th=[ 208], 99.95th=[ 235],
| 99.99th=[ 314]
bw (KB /s): min= 15, max= 537, per=2.00%, avg=158.68, stdev=38.08

write: io=615280KB, bw=3416.8KB/s, iops=854, runt=180113msec

clat (usec): min=167, max=162537, avg=2054.79, stdev=7665.24
lat (usec): min=167, max=162537, avg=2055.38, stdev=7665.23
clat percentiles (usec):
| 1.00th=[ 201], 5.00th=[ 227], 10.00th=[ 249], 20.00th=[ 378],
| 30.00th=[ 548], 40.00th=[ 692], 50.00th=[ 844], 60.00th=[ 996],
| 70.00th=[ 1160], 80.00th=[ 1304], 90.00th=[ 1720], 95.00th=[ 3856],
| 99.00th=[40192], 99.50th=[58624], 99.90th=[98816], 99.95th=[123392],
| 99.99th=[148480]
bw (KB /s): min= 6, max= 251, per=2.00%, avg=68.16, stdev=29.18
lat (usec) : 50=0.01%, 100=0.03%, 250=3.15%, 500=5.00%, 750=5.09%
lat (usec) : 1000=4.87%
lat (msec) : 2=9.64%, 4=4.06%, 10=21.42%, 20=18.08%, 50=19.91%
lat (msec) : 100=7.24%, 250=1.47%, 500=0.03%, 750=0.01%

cpu : usr=0.07%, sys=0.21%, ctx=522490, majf=0, minf=7
IO depths : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%

submit : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
complete : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
issued : total=r=356911/w=153820/d=0, short=r=0/w=0/d=0
latency : target=0, window=0, percentile=100.00%, depth=1

Run status group 0 (all jobs):
READ: io=1394.2MB, aggrb=7926KB/s, minb=7926KB/s, maxb=7926KB/s, mint=180113msec,
 maxt=180113msec
WRITE: io=615280KB, aggrb=3416KB/s, minb=3416KB/s, maxb=3416KB/s, mint=180113msec, 
maxt=180113msec

Disk stats (read/write):
sdc: ios=356874/153927, merge=0/10, ticks=8668598/310288, in_queue=8978582, util=99.99%
io=执行了多少M的IO

bw=平均IO带宽
iops=IOPS
runt=线程运行时间
slat=提交延迟
clat=完成延迟
lat=响应时间
bw=带宽
cpu=利用率
IO depths=io队列
IO submit=单个IO提交要提交的IO数
IO complete=Like the above submit number, but for completions instead.
IO issued=The number of read/write requests issued, and how many of them were short.
IO latencies=IO完延迟的分布

io=总共执行了多少size的IO
aggrb=group总带宽
minb=最小.平均带宽.
maxb=最大平均带宽.
mint=group中线程的最短运行时间.
maxt=group中线程的最长运行时间.

ios=所有group总共执行的IO数.
merge=总共发生的IO合并数.
ticks=Number of ticks we kept the disk busy.
io_queue=花费在队列上的总共时间.
util=磁盘利用率

4. Erweiterte IO-Warteschlangentiefe

Zu einem bestimmten Zeitpunkt gibt es N IO-Anfragen im Flug, einschließlich IO-Anfragen in der Warteschlange und IO-Anfragen, die von der Festplatte verarbeitet werden. N ist die Warteschlangentiefe.
Durch Erhöhen der Festplattenwarteschlangentiefe soll die Festplatte kontinuierlich arbeiten und die Leerlaufzeit der Festplatte verkürzt werden.
Erhöhen Sie die Warteschlangentiefe -> Verbessern Sie die Auslastung -> Erhalten Sie Spitzen-IOPS und MBPS -> Beachten Sie, dass die Antwortzeit in einem akzeptablen Bereich liegt,
Es gibt viele Möglichkeiten, die Warteschlangentiefe zu erhöhen und mehrere E/A-Anforderungen gleichzeitig zu initiieren. Mehrere Threads, die synchrone E/A-Anforderungen initiieren, sind gleichbedeutend mit mehreren E/A-Anforderungen in der Warteschlange.
Erhöhen Sie die E/A-Größe der Anwendung, nachdem Sie die unterste Ebene erreicht haben. Dies entspricht mehreren E/A-Anforderungen in der Warteschlange.
Mit zunehmender Warteschlangentiefe nimmt auch die Wartezeit der E/A in der Warteschlange zu, was zu einer längeren E/A-Antwortzeit führt, was einen Kompromiss erfordert.

Warum müssen wir Festplatten-I/O parallelisieren? Der Hauptzweck besteht darin, die Leistung der Anwendung zu verbessern. Dies ist besonders wichtig für virtuelle Festplatten (oder LUNs), die aus mehreren physischen Festplatten bestehen.
Wenn E/A einzeln übermittelt werden, ist die Antwortzeit zwar kürzer, der Systemdurchsatz jedoch sehr gering.
Im Vergleich dazu verkürzt die gleichzeitige Übermittlung mehrerer I/Os nicht nur die Kopfbewegungsdistanz (durch den Aufzugsalgorithmus), sondern verbessert auch die IOPS.
Wenn ein Aufzug jeweils nur eine Person transportieren kann, können alle, sobald sie den Aufzug nehmen, ihr Ziel schnell erreichen (Reaktionszeit), aber die Wartezeit ist länger (Warteschlangenlänge).
Durch die gleichzeitige Übermittlung mehrerer E/A-Vorgänge an das Festplattensystem werden Durchsatz und Gesamtantwortzeit ausgeglichen.

Linux-System zum Anzeigen der Standardwarteschlangentiefe:

[root@qsdb ~]# lsscsi -l
[0:0:0:0] disk DGC VRAID 0533 /dev/sda

state=running queue_depth=30 scsi_level=5 type=0 device_blocked=0 timeout=30
[0:0:1:0] disk DGC VRAID 0533 /dev/sdb

state=running queue_depth=30 scsi_level=5 type=0 device_blocked=0 timeout=30
[2:0:0:0] disk DGC VRAID 0533 /dev/sdd

state=running queue_depth=30 scsi_level=5 type=0 device_blocked=0 timeout=30
[2:0:1:0] disk DGC VRAID 0533 /dev/sde

state=running queue_depth=30 scsi_level=5 type=0 device_blocked=0 timeout=30
[4:2:0:0] disk IBM ServeRAID M5210 4.27 /dev/sdc

state=running queue_depth=256 scsi_level=6 type=0 device_blocked=0 timeout=90
[9:0:0:0] cd/dvd Lenovo SATA ODD 81Y3677 IB00 /dev/sr0

state=running queue_depth=1 scsi_level=6 type=5 device_blocked=0 timeout=30

Verwenden Sie den dd-Befehl, um bs=2M zum Testen festzulegen:

dd if=/dev/zero of=/dev/sdd bs=2M count=1000 oflag=direct

1000+0 Lesevorgänge aufgezeichnet, 1000+0 Schreibvorgänge aufgezeichnet, 2097152000 Bytes (2,1 GB) kopiert, 10,6663 Sekunden, 197 MB/Sekunde

Device: rrqm/s wrqm/s r/s w/s rsec/s wsec/s avgrq-sz avgqu-sz await svctm %util

sdd 0.00 0.00 0.00 380.60 0.00 389734.40 1024.00 2.39 6.28 2.56 97.42

Sie können sehen, dass nach Erreichen der untersten Ebene 2 MB IOs zu mehreren 512 KB werden. Die durchschnittliche Warteschlangenlänge beträgt 97 % und die MBPS erreicht 197 MB/s.
(Warum wird daraus 512 KB IO? Sie können Google verwenden, um die Bedeutung und Verwendung des Kernel-Parameters max_sectors_kb zu überprüfen.) Mit anderen Worten: Durch Erhöhen der Warteschlangentiefe kann der Spitzenwert der Festplatte getestet werden.

5. Detaillierte Erklärung zum Anzeigen des IO-Befehls iostat im Linux-System

[root@rac01-node01 /]# iostat -xd 3
Linux 3.8.13-16.2.1.el6uek.x86_64 (rac01-node01) 05/27/2017 _x8664 (40 CPU)
Device: rrqm/s wrqm/s r/s w/s rsec/s wsec/s avgrq-sz avgqu-sz await svctm %util
sda 0.05 0.75 2.50 0.50 76.59 69.83 48.96 0.00 1.17 0.47 0.14
scd0 0.00 0.00 0.02 0.00 0.11 0.00 5.25 0.00 21.37 20.94 0.05
dm-0 0.00 0.00 2.40 1.24 75.88 69.83 40.00 0.01 1.38 0.38 0.14
dm-1 0.00 0.00 0.02 0.00 0.14 0.00 8.00 0.00 0.65 0.39 0.00
sdc 0.00 0.00 0.01 0.00 0.11 0.00 10.20 0.00 0.28 0.28 0.00
sdb 0.00 0.00 0.01 0.00 0.11 0.00 10.20 0.00 0.15 0.15 0.00
sdd 0.00 0.00 0.01 0.00 0.11 0.00 10.20 0.00 0.25 0.25 0.00
sde 0.00 0.00 0.01 0.00 0.11 0.00 10.20 0.00 0.14 0.14 0.00

Beschreibung der Ausgabeparameter:

rrqms：每秒这个设备相关的读取请求有多少被Merge了（当系统调用需要读取数据的时候，VFS将请求发到各个FS，如果FS发现不同的读取请求读取的是相同Block的数据，FS会将这个请求合并Merge）
wrqm/s：每秒这个设备相关的写入请求有多少被Merge了。
rsec/s：The number of sectors read from the device per second.
wsec/s：The number of sectors written to the device per second.
rKB/s：The number of kilobytes read from the device per second.
wKB/s：The number of kilobytes written to the device per second.
avgrq-sz：平均请求扇区的大小,The average size (in sectors) of the requests that were issued to the device.
avgqu-sz：是平均请求队列的长度。毫无疑问，队列长度越短越好,The average queue length of the requests that were issued to the device.

await：每一个IO请求的处理的平均时间（单位是微秒毫秒）。这里可以理解为IO的响应时间，一般地系统IO响应时间应该低于5ms，如果大于10ms就比较大了。
这个时间包括了队列时间和服务时间，也就是说，一般情况下，await大于svctm，它们的差值越小，则说明队列时间越短，反之差值越大，队列时间越长，说明系统出了问题。
svctm：表示平均每次设备I/O操作的服务时间（以毫秒为单位）。如果svctm的值与await很接近，表示几乎没有I/O等待，磁盘性能很好。
如果await的值远高于svctm的值，则表示I/O队列等待太长，系统上运行的应用程序将变慢。
%util： 在统计时间内所有处理IO时间，除以总共统计时间。例如，如果统计间隔1秒，该设备有0.8秒在处理IO，而0.2秒闲置，那么该设备的%util = 0.8/1 = 80%，
所以该参数暗示了设备的繁忙程度，一般地，如果该参数是100%表示磁盘设备已经接近满负荷运行了（当然如果是多磁盘，即使%util是100%，因为磁盘的并发能力，所以磁盘使用未必就到了瓶颈）。

Durch die Untersuchungen und Experimente in diesem Artikel können wir erkennen, dass die Optimierung der E/A-Leistung eines Linux-Systems kein Problem ist, das einfach durch eine Verbesserung der Systemhardwarekonfiguration gelöst werden kann, sondern eine umfassende Betrachtung und Optimierung für bestimmte Anwendungsszenarien und E/A-Vorgänge erfordert. Wir können verschiedene Methoden und Tools verwenden, um die E/A-Leistung in Linux-Systemen zu optimieren, z. B. die Verwendung eines E/A-Schedulers, die Verwendung eines RAID-Arrays, die Verwendung eines Festplatten-Cache usw. Wir hoffen, dass unsere Untersuchung für die Mehrheit der Benutzer aufschlussreich und hilfreich sein kann, damit die IO-Leistung Ihres Linux-Systems auf ein höheres Niveau verbessert werden kann.

Das obige ist der detaillierte Inhalt vonEntdecken Sie die Geheimnisse der IO-Leistungsoptimierung in Linux-Systemen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!