To test a 10Gbps dedicated server with iperf3, connect it to a second capable host and measure TCP throughput in both directions. Compare one stream with four parallel streams, then save the results with the test conditions. This shows how much traffic the selected endpoints and network path can carry during the test.
A port speed alone cannot tell you how fast a backup, download, or replication job will run. This guide explains how to set up a controlled Linux test, read the output, check unexpected results, and close the temporary listener afterward.
The 10Gbps Test Plan at a Glance
A useful 10Gbps network bandwidth test compares four cases: one outgoing stream, one incoming stream, four outgoing streams, and four incoming streams. Keep the endpoints and settings fixed so the results are comparable.
- Prepare two capable hosts and record their starting state.
- Start a listener with access limited to the test source.
- Measure one TCP stream in each direction.
- Compare parallel streams, with optional UDP or full-duplex tests.
- Read the receiver results alongside CPU and network counters.
- Save a report and check any result that misses your target.
- Stop the listener and remove temporary access rules.
Use this matrix as the baseline:
| Test | Traffic direction | TCP streams | Initial duration | Question answered |
|---|---|---|---|---|
| T1 | Dedicated server to peer | 1 | 30 seconds | How fast is one outgoing flow? |
| T2 | Peer to dedicated server | 1 | 30 seconds | How fast is one incoming flow? |
| T3 | Dedicated server to peer | 4 | 30 seconds | How much outgoing traffic can several flows carry? |
| T4 | Peer to dedicated server | 4 | 30 seconds | How much incoming traffic can several flows carry? |
Thirty seconds and four streams are starting choices for this procedure, not universal pass criteria. The commands below are documentation-based examples. No figures in this guide represent a completed Atal Networks hardware benchmark.
What iperf3 Measures, and What It Leaves Out
iperf3 measures traffic between a client and a listening server. A normal test generates data in memory, which helps separate network transfer performance from disk reads and writes. A file copy adds storage and application work that this test does not reproduce.
Keep three terms separate:
- Link rate: The capacity reported for a network interface, such as 10Gbps.
- Throughput: The transfer rate achieved during a stated test.
- Transfer volume: The amount of data moved, such as 50GB.
A physical 10Gbps network port is also different from TCP or UDP port 5201. The physical port carries traffic; the numbered transport port directs traffic to the test application.
Choose a Path That Answers Your Question
A nearby peer helps establish a baseline with fewer Internet-path variables. A distant peer helps measure delivery to that destination. Neither test isolates every component between the hosts.
| Test path | Useful for | Main limit |
|---|---|---|
| Two capable hosts on a nearby network | Initial throughput baseline | Does not establish remote Internet performance |
| Two hosts in different regions | Regional transfer planning | Includes both endpoints and the wider route |
| A public test endpoint | An additional path comparison | Capacity and current load may be unknown |
| Loopback on one host | Local software checks | Does not test the physical NIC or uplink |
Do not use 127.0.0.1 to measure a dedicated server’s external connection. Loopback traffic stays on the host.
Step 1: Prepare Both Hosts Before Generating Traffic
Use two authorized hosts with enough spare CPU and network capacity for the rate you want to measure. A slow peer can limit the result even when the dedicated server has spare capacity.
The guide uses consistent roles:
- Server A: The dedicated server under test. Run all client commands here.
- Server B: The peer. Run the listener here.
- A to B: Traffic leaving the dedicated server.
- B to A: Traffic entering the dedicated server.
If B is a VM, check its guest bandwidth and CPU allocation. A host’s 10Gbps uplink does not establish how much capacity one guest can use.
Install iperf3 and record the Versions
On Debian or Ubuntu, install the package on both hosts:
sudo apt update
sudo apt install iperf3
On an RPM-based distribution that provides the package in its enabled repositories:
sudo dnf install iperf3
Record the installed version on each host:
iperf3 –version
iperf3 3.16 and later use a separate thread for each test stream. Older builds handle streams differently, so record both versions before comparing results. iperf2 and iperf3 are not compatible endpoints for the same test.
If installation offers to start a permanent server, decline for this temporary procedure. Preserve any existing service configuration that other users need.
Check the Interface and Starting Load
On A, identify the route to B:
ip route get LISTENER_IP
Replace LISTENER_IP with B’s reachable IPv4 address. Replace INTERFACE below with the interface shown by that route lookup:
ip -s link show dev INTERFACE
ethtool INTERFACE
ethtool -i INTERFACE
Check B’s interface as well. Record the reported speed, MTU, driver, and counter values. Some virtual interfaces do not expose physical-link information, and some queries need elevated permissions.
A reported 10000Mb/s confirms only the local link rate when the driver reports it correctly. It does not establish throughput across the route.
Budget for the Whole Test, Not One Command
A 10Gbps rate sustained for 30 seconds corresponds to 37.5GB before accounting for how payload and billing are measured:
10,000,000,000 bits/s × 30 seconds ÷ 8 = 37,500,000,000 bytes
| Test plan | Raw rate-time volume at 10Gbps |
|---|---|
| One 30-second, one-way run | 37.5GB |
| Four baseline runs, executed separately | 150GB |
| Three repeats of all four baseline runs | 450GB |
These calculations assume each run sustains 10Gbps. Actual useful payload can be lower. Retransmissions, framing, warm-up traffic, and billing rules affect other traffic totals. Optional tests add more traffic.
Choose an agreed test window. A full-rate test can consume capacity needed by live applications.
Step 2: Start a Listener with Restricted Access
Start the listener on B and allow only the intended source through the active firewall. Keep existing security controls in place while testing.
For an existing UFW-managed firewall, inspect its current policy:
sudo ufw status verbose
If UFW is active, an example source-specific TCP rule is:
sudo ufw allow proto tcp from CLIENT_IP to LISTENER_IP port 5201
Replace CLIENT_IP with A’s source address as B sees it. NAT can change that address. Replace LISTENER_IP with B’s local listening address. UFW supports source, destination, protocol, and port conditions in its rules.
A narrow allow rule does not cancel an existing broad allow rule. Check the complete policy, provider firewall, and any network access controls. Use your current firewall manager rather than enabling a second one for this test.
On B, start the listener:
iperf3 -s -B LISTENER_IP
Leave that terminal open. The default application port is TCP 5201.
Check Connectivity at a Limited Rate
On A, run a short check before attempting full throughput:
iperf3 -c LISTENER_IP -P 1 -b 100M -t 10
This requests a 100Mbps TCP rate for 10 seconds. Use a lower target if that load would affect other traffic.
Expected result: The connection opens, data transfers, and the run completes. This checks the setup; it does not establish 10Gbps capacity.
| Setup problem | First checks |
|---|---|
| Connection refused | Listener process, address, port, and rejecting rules |
| Connection timeout | Reachability, routing, filtering, and actual source address |
| Address already in use | An existing service on the selected address and port |
| Server busy | Another active test; coordinate before retrying |
| Cannot bind address | Whether the requested local address belongs to B |
Resolve setup errors before interpreting performance.
Step 3: Measure a Single TCP Stream in Both Directions
Run one stream from A to B, then reverse the data direction from the same client. These tests establish whether one flow behaves differently when sending or receiving.
Create a results directory on A. Choose a new directory name for each test session:
mkdir -p iperf-results-session-01
Run the forward test:
iperf3 -c LISTENER_IP -P 1 -t 30 | tee iperf-results-session-01/t1-forward-one.txt
Run the reverse test after the first one finishes:
iperf3 -c LISTENER_IP -P 1 -t 30 -R | tee iperf-results-session-01/t2-reverse-one.txt
The commands display the output and save it. Existing files with the same names are replaced, so use new names for repeat runs. Check that each test completed successfully before accepting its output.
These baseline commands have no explicit rate cap. Run them only within the agreed capacity and traffic budget.
Keep Direction Labels Clear
Reverse mode changes the data direction, not which host starts the test. A initiates both commands. In T1, A sends; in T2, A receives.
Write “A to B” and “B to A” in the report. Labels such as upload and download become confusing when the operator switches between hosts.
Include Startup in the First Baseline
The first baseline includes startup behavior. If you later use an omitted warm-up period to study steady-state performance, record that choice and compare it only with matching runs.
Short transfers and long transfers answer different operational questions. A backup may need sustained throughput, while a small download may finish before a long test reaches its steady state.
Step 4: Compare Parallel Streams and Optional UDP Tests
Compare four TCP streams with the single-stream baseline to see how the endpoints and path handle several flows. Keep full-duplex and UDP tests separate because they change the workload.
On A, run four streams in each direction:
iperf3 -c LISTENER_IP -P 4 -t 30 | tee iperf-results-session-01/t3-forward-four.txt
iperf3 -c LISTENER_IP -P 4 -t 30 -R | tee iperf-results-session-01/t4-reverse-four.txt
Let the first command finish before the second starts. A higher aggregate rate does not mean that every individual connection can reach that rate.
Parallel flows can distribute work differently across CPUs and network paths. Keep the one-stream result even if the parallel result looks better.
Optional: Test Both Directions at Once
Use a separate bidirectional run when the application sends and receives heavily at the same time:
iperf3 -c LISTENER_IP -P 1 -t 30 –bidir
Check support on both builds. Record incoming and outgoing rates separately. Adding both rates does not produce a one-way throughput figure.
Optional: Measure UDP Loss and Jitter
UDP testing helps compare offered traffic with received traffic under a specified load. It is useful for workloads where packet delivery and timing variation matter.
Keep TCP access for the control connection and permit UDP test traffic. If the earlier UFW example applies to B:
sudo ufw allow proto udp from CLIENT_IP to LISTENER_IP port 5201
Start with a bounded rate on A:
iperf3 -c LISTENER_IP -u -P 1 -b 100M -l 1200 -t 10
The example requests 100Mbps with a 1,200-byte UDP payload. Confirm that the payload plus headers fits the path MTU, including any tunnel overhead. Increase the offered rate only within the agreed budget and after reviewing endpoint load.
Keep the first UDP comparison to one stream. With parallel streams, the bitrate target applies to each stream. Record requested rate, actual sender and receiver rates, payload size, lost datagrams, and jitter.
A requested rate is not proof that the host generated or delivered that rate. Jitter describes timing variation; it does not replace a website response-time test.
Step 5: Read the Receiver Rate Alongside Host Load
Use the final receiver summary for received throughput, then check intervals, retransmissions, and host load for context. A peak interval alone cannot describe the completed run.
| Field | What it tells you | Reading rule |
|---|---|---|
| Interval | Time covered by the row | Separate whole-run results from short intervals |
| Transfer | Data counted over that interval | Check the displayed unit |
| Bitrate | Rate over the interval | Do not select only the highest row |
| Sender/receiver | Endpoint perspective | Match the role to the test direction |
| SUM | Combined streams | Compare with another aggregate result |
| Retr | TCP retransmissions where available | Review with load and counter changes |
| Cwnd | Congestion-window information where available | Treat as TCP context, not link capacity |
Available fields vary by protocol, platform, and build. Keep the complete output rather than copying only the largest number.
Do Not Treat Sender-Receiver Differences as a Loss Formula
TCP sender and receiver summaries can differ because their measurement boundaries and data in flight differ. Subtracting one rate from the other does not calculate packet loss.
Retransmissions also need context. A count without the transfer duration, traffic volume, and path conditions cannot identify a failed component.
Check Both Hosts During the Run
A single busy CPU core can limit a transfer while average server CPU use looks low. If the sysstat tools are installed, run this in a separate session on each host:
mpstat -P ALL 1 35
Compare interface counters before and after the same run:
ip -s link show dev INTERFACE
An increasing drop counter deserves investigation, but its meaning depends on the interface and driver. Do not assume every drop is a physical fault.
Keep the first baseline on the existing configuration. Changes to buffers, offloads, or congestion control belong in separate comparisons with recorded starting values and a recovery plan.
Step 6: Decide Whether the Result Meets Your Requirement
Judge a test against a target that names the path, direction, stream count, and workload. A 10Gbps port does not create one universal acceptance threshold for all Internet destinations.
10Gbps equals 1,250MB/s before overhead in decimal units. Ethernet, IP, transport headers, and other processing reduce useful payload. MB/s and MiB/s also use different byte units.
The 10Gbps vs. 1Gbps dedicated server comparison explains the capacity difference. For this test, agree on the required received rate and permitted variation before judging the result.
Use Repeat Runs Without Hiding Variation
If the traffic budget permits, repeat each baseline case three times. Report the median and minimum-to-maximum range for each case. Three repeats are a practical first check, not evidence of performance throughout a day or month.
Keep different destinations, IP families, stream counts, and directions in separate rows.
| Test | Direction | Streams | Median receiver rate | Min–max range | CPU / counter notes |
|---|---|---|---|---|---|
| T1 | A to B | 1 | Record result | Record range | Record observations |
| T2 | B to A | 1 | Record result | Record range | Record observations |
| T3 | A to B | 4 | Record result | Record range | Record observations |
| T4 | B to A | 4 | Record result | Record range | Record observations |
Preserve OS, kernel, iperf3 version, CPU, NIC, driver, link rate, MTU, addresses, locations, exact command, timestamp, and background load with the table.
Save JSON When You Need Machine-Readable Results
Add JSON output for a separately recorded run:
iperf3 -c LISTENER_IP -P 1 -t 30 -J > iperf-results-session-01/t1-forward-one-json-run.json
The usual JSON document is completed at the end of the test. Review errors and interrupted runs before using them in a summary. This extra command creates another transfer, so include it in the traffic budget.
Follow the Result Pattern to the Next Check
| Pattern | What to check next |
|---|---|
| One stream is slow; four are faster | Per-core CPU use, TCP behavior, and flow distribution |
| Only one direction is slow | Both host roles, directional policies, and routing |
| Nearby is fast; remote is slow | Remote endpoint capacity, latency, and route |
| CPU reaches a limit during low throughput | Host processing capacity and tool version |
| Retransmissions or drops rise with load | Endpoint counters, queues, and possible path loss |
| iperf3 is fast; file copies are slow | Storage, encryption, application settings, and differing traffic policies |
A second authorized endpoint can help determine whether a result follows one peer or path. Change one variable at a time.
For example, a backup job may need fast disk writes at B even when B receives memory-based test traffic well. Repeat the actual backup task before deciding that the service meets its operational target.
Step 7: Close the Listener and Restore Temporary Rules
Stop the test process and remove only the access rules added for this procedure. Keep the evidence files so future tests have a baseline.
On B, press Ctrl+C in the listener terminal. If you created the UFW rules shown earlier, remove them with their matching descriptions:
sudo ufw delete allow proto tcp from CLIENT_IP to LISTENER_IP port 5201
sudo ufw delete allow proto udp from CLIENT_IP to LISTENER_IP port 5201
Remove the UDP rule only if you added it. Do not remove pre-existing service access. UFW supports deletion by the original rule description.
Check for a remaining TCP listener:
ss -ltnp ‘sport = :5201’
If the test was the only service on that port, no matching row is expected. Identify any remaining process before stopping it.
On a systemd host, check whether an iperf3 service exists:
systemctl status iperf3
A missing unit can be normal. Stop and disable a service only if this test created it and no other work requires it. Restore any other settings changed during diagnosis.
الأسئلة الشائعة
Can one TCP stream fill a 10Gbps connection?
One TCP stream can achieve high throughput when the hosts and path support it. CPU processing, TCP behavior, latency, and loss affect the result. Compare one stream with several flows to see whether a single-flow limit matters to your workload. Do not discard the single-stream result just because the aggregate number is higher.
Do I need a second 10Gbps dedicated server?
You need a peer and path capable of the rate you want to measure. The peer does not need the same server model, but it needs enough available network and processing capacity. A slower peer can measure lower-rate performance; it cannot establish the first server’s capacity against a capable 10Gbps endpoint.
Can I use a public iperf3 server?
A public endpoint can provide an additional comparison if its operator permits the test. Check usage rules, ports, rate limits, and allowed duration first. Its current load may be unknown. Treat the result as performance to that endpoint, and use controlled peers when you need a repeatable acceptance check.
Does iperf3 measure disk speed?
The normal commands in this guide generate memory-based traffic and do not reproduce disk reads or writes. A file copy adds storage, filesystem, and application work. Use iperf3 to establish the network baseline, then run a representative file transfer to check the complete task. Separate those results in your report.
What is the difference between reverse and bidirectional tests?
A reverse test sends data from the listener back to the client. A bidirectional test sends data both ways at once. The client starts either test, but the load differs. Record each direction independently and compare bidirectional results only with other runs that use the same combined load.
Why does a UDP test also need TCP access?
iperf3 uses a TCP control connection to coordinate a UDP test. The test data uses UDP, so both paths need the required access through the relevant firewalls. Allow the specific test source and destination rather than opening the listener broadly, and remove temporary access when the test finishes.
How do I test IPv6 with iperf3?
Use the peer’s reachable IPv6 address and select IPv6 with the -6 option. Confirm listener binding and IPv6 firewall access on that path. Keep IPv6 and IPv4 results separate because the address families may follow different routes or policies. Record the family beside each test result so later comparisons remain clear.
Can I compare Windows and Linux iperf3 results?
Compare them only after recording the exact builds and networking environments. ESnet does not officially support native Windows iperf3, and third-party builds can differ. A WSL test also includes a virtual networking layer. Use comparable Linux endpoints for the baseline when possible, then measure the actual client environment separately.
Recommended Next Steps
Keep the four-case baseline and use it to check the real workload. If a backup, download, or replication job still misses its target, review application and storage behavior alongside the network results.
For an unexplained network result, send support the raw logs, timestamps, endpoint details, commands, and host observations. A specific, repeatable test gives the team a useful starting point.
If the workload needs more capacity, use the 10Gbps server selection guide to review hardware and network requirements. Then compare Atal Networks 10Gbps dedicated servers and share the measured requirements with our team.
