Prezentacja koncentruje się na narzędziu iperf3 (oraz jego GUI nakładce jperf), będącym standardem w pomiarach przepustowości sieci TCP i UDP. Omówiono model klient-serwer, opcje testów TCP (okno, równoległość) i UDP (pasmo, datagramy) oraz zaawansowane funkcje, takie jak testy dwukierunkowe i format JSON. Przedstawiono również interpretację wyników, scenariusze testowe oraz automatyzację pomiarów.
iperf to narzędzie do aktywnego pomiaru maksymalnej przepustowości sieci TCP i UDP. Działa w modelu klient-serwer – klient wysyła dane, serwer je odbiera i raportuje statystyki.
Historia:
Obecnie iperf3 jest standardem w testach przepustowości w środowiskach badawczych i produkcyjnych.
| Cecha | iperf 2.x | iperf 3 |
|---|---|---|
| Developer | NLANR/DAST → community | ESnet / Lawrence Berkeley National Lab |
| Architektura | Pojedynczy wątek | Wielowątkowa (strumienie w osobnych wątkach) |
| Test obustronny | -d (wbudowany) | --bidir (od iperf 3.1) |
| JSON output | Nie | Tak (-J) |
| Kompatybilność | Klient/serwer 2.x | Klient/serwer 3.x |
| Rozwój | Utrzymywany (bugfixy) | Aktywny, nowe funkcje |
Oba narzędzia są nadal rozwijane, ale iperf3 jest zalecany dla nowych wdrożeń.
Większość dystrybucji Linux ma iperf3 w oficjalnych repozytoriach:
# Debian / Ubuntu / Linux Mint sudo apt update sudo apt install iperf3 # RHEL / CentOS / Fedora sudo dnf install iperf3 # Arch Linux sudo pacman -S iperf3 # openSUSE sudo zypper install iperf3
Sprawdzenie wersji: iperf3 --version.
Opcje instalacji:
choco install iperf3scoop install iperf3Po pobraniu ZIP – rozpakuj do folderu (np. C:\tools\iperf3) i dodaj do PATH.
iperf3 --version
iperf3 wykorzystuje architekturę klient-serwer:
Dla testu TCP – klient wysyła dane (lub odbiera, jeśli użyto -R). Dla testu UDP – klient wysyła datagramy, serwer raportuje straty i jitter.
Serwer można uruchomić także w trybie jednorazowym (-s) lub jako demona (-s -D).
-s -p 5201 i wielu serwerów na różnych portach dla wielu testów jednocześnie.
Najprostsze uruchomienie serwera iperf3:
iperf3 -s
Serwer nasłuchuje na domyślnym porcie TCP 5201.
Wyjście serwera po podłączeniu klienta:
----------------------------------------------------------- Server listening on 5201 ----------------------------------------------------------- Accepted connection from 192.168.1.100, port 54321 [ 5] local 192.168.1.1 port 5201 connected to 192.168.1.100 port 54322 [ ID] Interval Transfer Bandwidth [ 5] 0.00-10.00 sec 1.09 GBytes 938 Mbits/sec -----------------------------------------------------------
# Serwer na konkretnym porcie iperf3 -s -p 5202 # Serwer jako demon (background) iperf3 -s -D # Serwer z zapisem logu iperf3 -s --logfile /var/log/iperf3.log # Serwer z limitem czasu (auto-stop po N sekundach bez klienta) iperf3 -s --idle-timeout 60 # Serwer działający na wielu portach - wiele instancji iperf3 -s -p 5201 & iperf3 -s -p 5202 &
Opcja -D (daemon) uruchamia serwer w tle – idealne do długotrwałych testów.
Najprostsze wywołanie klienta:
iperf3 -c 192.168.1.100
Domyślnie: test trwa 10 sekund, raport co 1 sekundę, jeden strumień TCP.
Przykładowy wynik:
Connecting to host 192.168.1.100, port 5201 [ 4] local 192.168.1.1 port 54322 connected to 192.168.1.100 port 5201 [ ID] Interval Transfer Bandwidth [ 4] 0.00-1.00 sec 113 MBytes 945 Mbits/sec [ 4] 1.00-2.00 sec 112 MBytes 940 Mbits/sec [ 4] 2.00-3.00 sec 112 MBytes 940 Mbits/sec ... [ 4] 0.00-10.00 sec 1.09 GBytes 938 Mbits/sec [ ID] Interval Transfer Bandwidth Retr Cwnd [ 4] 0.00-10.00 sec 1.09 GBytes 938 Mbits/sec 0 552 KBytes
Ustawia czas testu w sekundach (domyślnie 10).
# Test trwający 30 sekund iperf3 -c 192.168.1.100 -t 30 # Test długotrwały – 300 sekund (5 minut) iperf3 -c 192.168.1.100 -t 300 # Krótki test – 2 sekundy (szybka weryfikacja) iperf3 -c 192.168.1.100 -t 2
Dlaczego czas testu ma znaczenie?
Ustawia co ile sekund wyświetlany jest raport cząstkowy (domyślnie 1).
# Raport co 0.5 sekundy (dwa raporty na sekundę) iperf3 -c 192.168.1.100 -i 0.5 # Raport co 5 sekund iperf3 -c 192.168.1.100 -i 5 # Raport co 10 sekund (czysty wynik końcowy) iperf3 -c 192.168.1.100 -i 10
Mniejszy interwał = więcej danych do analizy, ale większy narzut na wyjście.
W testach długotrwałych interwał 5–10s daje czytelne wyniki.
Ustawia port serwera (domyślnie 5201). Klient i serwer muszą używać tego samego portu.
# Serwer na porcie 5202 iperf3 -s -p 5202 # Klient łączący się na port 5202 iperf3 -c 192.168.1.100 -p 5202 # Test na niestandardowym porcie (np. 9000) iperf3 -c 192.168.1.100 -p 9000
Przydatne, gdy port 5201 jest zablokowany przez firewall lub chcemy uruchomić wiele serwerów.
Uruchamia równoległe strumienie TCP/UDP w jednym teście (domyślnie 1).
# 4 równoległe strumienie TCP iperf3 -c 192.168.1.100 -P 4 # 8 strumieni – większe obciążenie sieci iperf3 -c 192.168.1.100 -P 8 # 2 strumienie UDP z ograniczeniem pasma iperf3 -c 192.168.1.100 -u -b 100M -P 2
Zalety wielu strumieni:
Domyślnie klient wysyła dane do serwera. Opcja -R odwraca kierunek – serwer wysyła dane do klienta.
# Test odwrócony – serwer wysyła do klienta iperf3 -c 192.168.1.100 -R # Odwrócony z wieloma strumieniami iperf3 -c 192.168.1.100 -R -P 4
Przydatne do:
Od iperf3 3.1 dostępna jest opcja --bidir, która symultanicznie testuje oba kierunki.
# Test dwukierunkowy iperf3 -c 192.168.1.100 --bidir # Dwukierunkowo z wieloma strumieniami iperf3 -c 192.168.1.100 --bidir -P 2
Różnica między -R a --bidir:
Opcja -u przełącza na protokół UDP (zamiast domyślnego TCP).
# Podstawowy test UDP iperf3 -c 192.168.1.100 -u # Test UDP z określoną przepływnością iperf3 -c 192.168.1.100 -u -b 100M
Wynik testu UDP zawiera dodatkowe statystyki:
-b z oczekiwaną przepływnością.
Ustawia docelową przepływność wysyłania. Dla UDP jest to jedyna kontrola nad szybkością (TCP sam reguluje).
# UDP z limitem 10 Mbit/s iperf3 -c 192.168.1.100 -u -b 10M # UDP z limitem 500 Mbit/s iperf3 -c 192.168.1.100 -u -b 500M # UDP z limitem 1 Gbit/s (maks dla Fast Ethernet) iperf3 -c 192.168.1.100 -u -b 1000M # UDP z limitem w Kbit/s iperf3 -c 192.168.1.100 -u -b 512K
Jeśli ustawisz -b wyższe niż dostępna przepustowość – zaczną się straty pakietów.
Ustawia rozmiar bufora odczytu/zapisu. Dla TCP – rozmiar bloku danych, dla UDP – rozmiar datagramu.
# TCP: mniejszy bufor (8 KB) iperf3 -c 192.168.1.100 -l 8K # TCP: większy bufor (256 KB) iperf3 -c 192.168.1.100 -l 256K # UDP: większe datagramy (1470 B – MTU 1500 minus nagłówki) iperf3 -c 192.168.1.100 -u -b 100M -l 1470 # UDP: małe datagramy (100 B – symulacja VoIP) iperf3 -c 192.168.1.100 -u -b 1M -l 100
Domyślnie: TCP = 128 KB, UDP = 8 KB (8192 B) lub 1460 B zależnie od wersji.
Ustawia rozmiar okna TCP (socket buffer) w bajtach. To kluczowy parametr dla wydajności TCP.
# Okno TCP 64 KB – domyślne w starszych systemach iperf3 -c 192.168.1.100 -w 64K # Okno TCP 256 KB – dla łączy o większym BDP iperf3 -c 192.168.1.100 -w 256K # Okno TCP 1 MB – dla szybkich łączy WAN iperf3 -c 192.168.1.100 -w 1M
Bandwidth-Delay Product (BDP) = przepustowość × RTT. Okno TCP powinno być ≥ BDP dla pełnego wykorzystania łącza.
Dla 1 Gb/s i RTT 100 ms: BDP = 1e9 × 0.1 / 8 = 12.5 MB.
-w z wartością ≥ BDP dla maksymalnej wydajności.
Ustawia MTU (Maximum Transmission Unit) dla pakietów TCP/UDP. Opcja -M ustawia flagę DF (Don't Fragment) i sugeruje MTU.
# Standardowy MTU 1500 iperf3 -c 192.168.1.100 -M 1500 # Jumbo frames – wymaga obsługi po obu stronach iperf3 -c 192.168.1.100 -M 9000 # MTU 4000 – niestandardowe iperf3 -c 192.168.1.100 -M 4000
Jumbo frames (MTU 9000) mogą zwiększyć przepustowość nawet o 10–20% przez redukcję nagłówków.
-N wyłącza algorytm Nagle (TCP_NODELAY). Algorytm Nagle grupuje małe pakiety w większe dla oszczędności nagłówków.
# Wyłączenie algorytmu Nagle (mniejsze opóźnienie) iperf3 -c 192.168.1.100 -N
Kiedy używać -N:
Domyślnie algorytm Nagle jest włączony – może zafałszować wyniki w testach z małymi buforami.
Ustawia algorytm kontroli przeciążenia TCP dostępny w systemie.
# CUBIC – domyślny w Linux (od 2.6.19) iperf3 -c 192.168.1.100 -Z cubic # BBR – nowoczesny, Google, dobre na WAN iperf3 -c 192.168.1.100 -Z bbr # Reno – klasyczny (działający w każdym systemie) iperf3 -c 192.168.1.100 -Z reno # Sprawdzenie dostępnych algorytmów w systemie sysctl net.ipv4.tcp_available_congestion_control
Wybór algorytmu wpływa na:
Ustawia port źródłowy, z którego klient nawiązuje połączenie (domyślnie losowy).
# Ustawienie stałego portu źródłowego iperf3 -c 192.168.1.100 --cport 50000
Zastosowania:
Wymusza limit przepływności na poziomie warstwy transportowej przy użyciu mechanizmu Fair Queuing (FQ) w jądrze Linux.
# Ograniczenie do 100 Mbit/s (TCP lub UDP) iperf3 -c 192.168.1.100 --fq-rate 100M # Ograniczenie do 10 Mbit/s z 4 strumieniami iperf3 -c 192.168.1.100 --fq-rate 10M -P 4
Różnica między -b a --fq-rate:
--fq-rate wymaga obsługi FQ w jądrze (moduł sch_fq). Działa tylko w Linux.
Wypisuje wyniki w formacie JSON – idealne do parsowania przez skrypty i narzędzia.
iperf3 -c 192.168.1.100 -J
Przykładowy fragment wyniku JSON:
{
"start": {
"connected": [{"local_host": "192.168.1.1", "local_port": 54322, "remote_host": "192.168.1.100", "remote_port": 5201}]
},
"intervals": [
{"streams": [{"id": 4, "bytes": 118000000, "bits_per_second": 944000000, "retransmits": 0, "snd_cwnd": 565248}]}
],
"end": {
"sum_sent": {"bits_per_second": 938000000, "bytes": 1170000000, "retransmits": 0},
"cpu_utilization_percent": {"host_total": 12.5, "host_user": 8.3, "host_system": 4.2, "remote_total": 8.1}
}
}
Parsowanie JSON iperf3 w Python – prosta analiza przepustowości:
import json
import subprocess
result = subprocess.run(['iperf3', '-c', '192.168.1.100', '-J'],
capture_output=True, text=True)
data = json.loads(result.stdout)
bw = data['end']['sum_sent']['bits_per_second']
retr = data['end']['sum_sent']['retransmits']
cwnd = data['end']['streams'][0]['sender']['snd_cwnd']
print(f'Bandwidth: {bw/1e6:.2f} Mbps')
print(f'Retransmits: {retr}')
print(f'CWND: {cwnd} bytes')
Można rozszerzyć o zapis do bazy danych, wykresy (matplotlib), alerty.
Zapisuje wynik testu do pliku zamiast na stdout.
# Zapis do pliku tekstowego iperf3 -c 192.168.1.100 --logfile wynik.txt # Zapis z timestampem w nazwie pliku (przez skrypt) iperf3 -c 192.168.1.100 --logfile iperf_$(date +%Y%m%d_%H%M%S).log # Również dla serwera iperf3 -s --logfile serwer.log
Przydatne przy długotrwałych testach i automatyzacji – wyniki są automatycznie przechowywane.
Dołącza do wyniku klienta szczegółowe statystyki z serwera.
iperf3 -c 192.168.1.100 --get-server-output
W wynikach JSON pojawia się dodatkowe pole server_output_json zawierające m.in.:
Przydatne, gdy nie masz dostępu do konsoli serwera, ale chcesz zobaczyć jego perspektywę.
Wymusza opróżnienie bufora stdout po każdym interwale raportowania.
iperf3 -c 192.168.1.100 --forceflush
Domyślnie iperf3 buforuje wyjście – przy długich testach wyniki cząstkowe mogą nie być widoczne od razu.
Zastosowania:
Dodaje etykietę tekstową do wyników testu – ułatwia identyfikację w logach.
iperf3 -c 192.168.1.100 --title "Test_LAN_GbE_2026-05-23"
Etykieta pojawia się w nagłówku wyjścia:
iperf 3.16 (cJSON 1.7.15) Linux 6.8.0-amd64 Test_LAN_GbE_2026-05-23 -------------------------------------------------
Przydatne przy automatyzacji – wiele testów zapisanych do jednego pliku log.
Wynik testu TCP zawiera kluczowe kolumny:
| Pole | Znaczenie | Interpretacja |
|---|---|---|
| Transfer | Ilość danych przesłanych w interwale | Np. 1.09 GB w 10s = dobry wynik |
| Bandwidth | Przepustowość chwilowa/średnia | 938 Mbit/s – blisko 1 Gb/s |
| Retr | Liczba retransmisji w interwale | 0 = idealnie, >0 = możliwe problemy |
| Cwnd | Rozmiar okna przeciążenia TCP (bytes) | Większe = lepsza przepustowość |
Retr (retransmits) – liczba retransmisji TCP. Wartość > 0 wskazuje na utratę pakietów, przeciążenie lub problemy z łączem.
Retransmisje TCP występują, gdy:
Jak analizować Retr w iperf3:
Cwnd (congestion window) – rozmiar okna przeciążenia TCP pokazywany w wynikach iperf3 (w bajtach).
Znaczenie Cwnd:
Wynik Cwnd w iperf3:
[ 4] 0.00-10.00 sec 1.09 GBytes 938 Mbits/sec 0 552 KBytes
Cwnd = 552 KB na końcu testu – oznacza stabilne okno przeciążenia.
Jeśli Cwnd jest małe (np. 16 KB) – może oznaczać małe okno odbiorcy lub problemy z łączem.
Wynik testu UDP zawiera dodatkowe kolumny:
| Pole | Znaczenie | Interpretacja |
|---|---|---|
| Jitter | Odchylenie opóźnienia (ms) | Niski (<1 ms) = stabilne łącze |
| Lost/Total | Straty pakietów (utracone/całkowite) | 0% = idealnie, >1% = problem |
| Datagrams | Liczba datagramów w interwale | Zależy od -l i -b |
[ ID] Interval Transfer Bandwidth Jitter Lost/Total Datagrams [ 5] 0.00-10.00 sec 125 MBytes 105 Mbits/sec 0.034 ms 0/89286 (0%) 89286
Interpretacja: jitter 0.034 ms (świetny), 0% strat (brak utraty).
-b przekracza rzeczywistą przepustowość łącza.
Jitter to zmienność opóźnienia pakietów (delay variation). iperf3 oblicza jitter według RFC 3550 (RTP).
Wzór (uproszczony): jitter = średnie odchylenie różnicy opóźnień między kolejnymi datagramami.
Interpretacja wartości jitter:
Wysoki jitter = buforowanie odtwarzania (de-jitter buffer) w aplikacjach czasu rzeczywistego.
W teście UDP iperf3 raportuje liczbę utraconych datagramów (Lost) i procent strat.
[ ID] Interval Transfer Bandwidth Jitter Lost/Total Datagrams [ 5] 0.00-10.00 sec 125 MBytes 105 Mbits/sec 0.034 ms 0/89286 (0%) 89286
Strata 0% = brak utraty.
Jeśli strata > 0%:
Cel: zmierzyć maksymalną przepustowość TCP między dwoma hostami w sieci LAN.
# Serwer iperf3 -s # Klient – test 30s, interwał 1s, okno 256 KB iperf3 -c 192.168.1.100 -t 30 -i 1 -w 256K
Interpretacja:
Jeśli wynik jest znacząco niższy – sprawdź: okno TCP, RTT, retransmisje, MTU.
Cel: sprawdzić, jak łącze zachowuje się przy różnych poziomach obciążenia UDP.
# Testy UDP z rosnącą przepływnością iperf3 -c 192.168.1.100 -u -b 10M -t 10 iperf3 -c 192.168.1.100 -u -b 50M -t 10 iperf3 -c 192.168.1.100 -u -b 100M -t 10 iperf3 -c 192.168.1.100 -u -b 200M -t 10 iperf3 -c 192.168.1.100 -u -b 500M -t 10
Analiza:
Prosty skrypt bash do wykonywania cyklicznych testów:
#!/bin/bash
SERVER="192.168.1.100"
PORT=5201
LOGFILE="iperf_test_$(date +%Y%m%d).log"
for i in {1..5}; do
echo "Test $i: $(date)" >> $LOGFILE
iperf3 -c $SERVER -p $PORT -t 10 -i 1 -J >> $LOGFILE 2>&1
echo "---" >> $LOGFILE
sleep 5
done
Skrypt wykonuje 5 testów z 5-sekundową przerwą między nimi.
Można rozszerzyć o:
Parsowanie JSON iperf3 do gnuplot:
#!/bin/bash
# Ekstrakcja danych z JSON iperf3
iperf3 -c 192.168.1.100 -t 30 -i 1 -J > wynik.json
# Parsowanie z jq
cat wynik.json | jq -r '.intervals[].streams[0].bits_per_second' > bw_data.txt
# Gnuplot
gnuplot -e "
set terminal png size 1024,768;
set output 'wykres.png';
plot 'bw_data.txt' with lines title 'Throughput (bps)';
"
Alternatywy: Python + matplotlib, grafana + influxdb, excel.
Większość łączy (światłowód, Ethernet) jest symetryczna. ADSL, 5G, LTE, SAT mogą być asymetryczne.
# Test w obie strony iperf3 -c 192.168.1.100 -t 30 iperf3 -c 192.168.1.100 -t 30 -R # Test jednocześnie w obie strony iperf3 -c 192.168.1.100 -t 30 --bidir
Interpretacja:
Test dla 1, 2, 4, 8 strumieni TCP:
iperf3 -c 192.168.1.100 -P 1 -t 30 iperf3 -c 192.168.1.100 -P 2 -t 30 iperf3 -c 192.168.1.100 -P 4 -t 30 iperf3 -c 192.168.1.100 -P 8 -t 30
Efekt w sieci LAN:
Efekt w sieci z ECMP/LAG:
| Parametr | LAN (1 GbE) | WLAN (Wi-Fi 6) | WAN (Internet) |
|---|---|---|---|
| Przepustowość max | ~940 Mbit/s | ~600–900 Mbit/s | Zależy od łącza |
| RTT | < 1 ms | 1–5 ms | 10–200 ms |
| Jitter | < 0.1 ms | 1–10 ms | 1–50 ms |
| Retr | 0 | 0–5 | 0–50+ |
| Stabilność | Bardzo wysoka | Zmienna | Zmienna |
WLAN: interfejs współdzielony, interferencje, zasięg – wyniki zmieniają się w czasie.
WAN: większe RTT, większa zmienność, możliwe throttling przez ISP.
BDP = przepustowość × RTT (w bitach). To minimalny rozmiar okna TCP dla pełnego wykorzystania łącza.
Przykład:
| Łącze | Przepustowość | RTT | BDP |
|---|---|---|---|
| LAN | 1 Gb/s | 0.5 ms | 62.5 KB |
| WAN | 100 Mb/s | 50 ms | 625 KB |
| SAT | 50 Mb/s | 600 ms | 3.75 MB |
Jeśli okno TCP < BDP – łącze nie jest w pełni wykorzystane.
# Test z odpowiednim oknem dla łącza WAN iperf3 -c serwer -t 30 -w 1M
-w z wartością ≥ BDP. Komenda: iperf3 -c serwer -w $(bc <<< "przepustowsc_bps * rtt_sec / 8").
Większe MTU = mniej pakietów do wysłania = mniej nagłówków = wyższa przepustowość.
Porównanie dla 1 MB danych:
| MTU | Liczba pakietów | Narzut nagłówków |
|---|---|---|
| 1500 | ~710 | ~42 KB (4.2%) |
| 4000 | ~260 | ~15 KB (1.5%) |
| 9000 | ~117 | ~7 KB (0.7%) |
# Test z MTU 1500 iperf3 -c 192.168.1.100 -M 1500 # Test z jumbo frames (MTU 9000) iperf3 -c 192.168.1.100 -M 9000
jperf to graficzna nakładka na iperf napisana w Javie. Umożliwia konfigurację testów przez GUI i wyświetlanie wyników w czasie rzeczywistym.
Funkcje:
Wady:
Okno jperf dzieli się na sekcje:
Po skonfigurowaniu – przycisk Run Iperf! uruchamia test.
jperf wyświetla dwa wykresy w czasie rzeczywistym:
Zalety wizualizacji na żywo:
jperf zapisuje też surowe dane do pliku CSV – można je później analizować.
| Narzędzie | Cechy | Zastosowanie |
|---|---|---|
| iperf3 | Proste, standard, JSON, aktywny rozwój | Testy przepustowości ogólne |
| netperf | Bardziej zaawansowane testy (TCP_RR, UDP_STREAM, latency) | Benchmarki, testy wydajności |
| nuttcp | Lekki, szybki, mniej narzutów | Wbudowane systemy, automatyzacja |
| qperf | Pomiar przepustowości i opóźnienia | Testy RDMA, InfiniBand |
Porównanie:
Scenariusz: pomiar przepustowości między dwoma instancjami w różnych regionach AWS/Azure/GCP.
# Na instancji w regionie eu-west-1 (serwer) iperf3 -s -p 5201 # Na instancji w regionie us-east-1 (klient) iperf3 -c 10.0.1.100 -t 60 -i 5 -w 4M
Czego się spodziewać:
Konfiguracja:
# Serwer iperf3 -s # Klient – test standardowy iperf3 -c 192.168.1.100 -t 30 -i 1 -w 256K
Wynik:
[ ID] Interval Transfer Bandwidth Retr Cwnd [ 4] 0.00-30.00 sec 3.27 GBytes 938 Mbits/sec 0 552 KBytes
Wnioski:
Konfiguracja:
iperf3 -c vps.example.com -t 30 -i 1 -w 1M
Wynik:
[ ID] Interval Transfer Bandwidth Retr Cwnd [ 4] 0.00-30.00 sec 366 MBytes 102 Mbits/sec 2 462 KBytes
Wnioski:
Objaw: użytkownicy zgłaszają wolne działanie aplikacji przez VPN.
Test iperf3:
iperf3 -c 10.0.0.1 -t 30 -i 1 -w 256K
[ ID] Interval Transfer Bandwidth Retr Cwnd
[ 4] 0.00-1.00 sec 10.1 MBytes 84.7 Mbits/sec 12 128 KBytes
[ 4] 1.00-2.00 sec 9.8 MBytes 82.2 Mbits/sec 15 112 KBytes
[ 4] 2.00-3.00 sec 8.5 MBytes 71.3 Mbits/sec 18 96 KBytes
...
[ 4] 0.00-30.00 sec 285 MBytes 79.8 Mbits/sec 412 96 KBytes
Diagnoza:
| Opcja | Znaczenie | Przykład |
|---|---|---|
| -s | Tryb serwera | iperf3 -s |
| -c | Tryb klienta (adres serwera) | iperf3 -c 10.0.0.1 |
| -t | Czas testu (s) | -t 30 |
| -i | Interwał raportowania (s) | -i 1 |
| -p | Port serwera | -p 5201 |
| -P | Równoległe strumienie | -P 4 |
| -R | Odwrócony kierunek | -R |
| -u | Tryb UDP | -u -b 100M |
| -b | Docelowa przepływność | -b 100M |
| -w | Okno TCP (socket buffer) | -w 256K |
| -l | Rozmiar bufora | -l 128K |
| -M | MTU | -M 9000 |
| -J | Wynik JSON | -J |
Odpowiedź: iperf3 został przepisany od podstaw przez ESnet. Obsługuje JSON, wielowątkowość, nowe algorytmy. Nie jest zgodny z iperf2.
Odpowiedź: Odwraca kierunek testu – serwer wysyła dane do klienta zamiast klient do serwera (test download).
Odpowiedź: Liczba retransmisji TCP w interwale. Wysoka wartość wskazuje na utratę pakietów lub przeciążenie łącza.
Odpowiedź: UDP raportuje dodatkowo jitter (odchylenie opóźnienia) i procent utraty datagramów (Lost/Total).
Odpowiedź: Ustawia rozmiar okna TCP (socket buffer). Powinien być ≥ BDP (Bandwidth-Delay Product) dla pełnego wykorzystania łącza.
Odpowiedź: Graficzna nakładka na iperf napisana w Javie – umożliwia konfigurację testów przez GUI i podgląd wyników na wykresach.
Dziękujemy za uwagę. W następnej części poznamy zaawansowane techniki pomiarów logicznych z wykorzystaniem skryptów automatyzujących.
Praca własna:
