Dataset · computed table · no measured data

IOPS, bandwidth, queue depth and latency: a worked table from Little's law

How IOPS, bandwidth, queue depth and mean latency relate, as a worked table of 100 rows: four block sizes (4 KiB to 1 MiB), queue depths of 1 to 128 and mean latencies of 100 microseconds to 10 milliseconds. The rules are IOPS = queue depth / mean latency (Little's law) and bandwidth = IOPS x block size, in decimal MB/s and in MiB/s as fio prints them. Pure arithmetic, no measurement. For example, queue depth 1 at 100 microseconds is 10,000 IOPS and 40.96 MB/s at 4 KiB, and queue depth 32 at 1 millisecond is 32,000 IOPS.

Download CSV100 rows · 6 columns · CSV

File /data/datasets/fio-iops-bandwidth-latency-calc.csv · JSON metadata · Chart (SVG) · Interface payload ceilings · All datasets

Scope and rules

Scope: a conversion table, not a benchmark. It lists no device and no result. Little\u2019s law says the mean number of items in a system equals the arrival rate times the mean time an item spends there, L = \u03bbW. For storage I/O, L is the queue depth (the I/Os in flight, fio\u2019s iodepth), \u03bb is IOPS and W is the mean latency of one I/O. That gives:

IOPS = queue depth ÷ mean latency (seconds)
queue depth = IOPS × mean latency (seconds)
bandwidth = IOPS × block size, in MB/s (10⁶ bytes) and in MiB/s (2²⁰ bytes)

The table is a grid of 4 block sizes (4,096, 16,384, 131,072, 1,048,576 bytes), 5 queue depths (1, 4, 16, 32, 128) and 5 mean latencies (0.1, 0.5, 1, 5, 10 ms): 100 rows. The build recomputes every cell, checks that IOPS times latency returns the queue depth, and fails on a mismatch.

Conventions from the documentation

fio\u2019s iodepth is the number of I/O units kept in flight against the file, default 1. The documentation says raising it above 1 does not affect synchronous engines, and an async engine can be limited by the operating system so the depth reached is lower. For example, libaio without direct=1 is not asynchronous on Linux. fio prints the depth distribution to check this.
bs is in bytes, default 4096. With the default kb_base=1024, 4k means 4096, not 4000. That is why the block sizes here are powers of two.
fio prints bandwidth in both units side by side. Its documentation showsbw = 2383.3 kB/s (2327.4 KiB/s), one rate in two units: 2383.3 × 1000 ÷ 1024 = 2327.4. This table gives both, as MB/s and MiB/s.

Worked examples

Queue depth 1 at a mean latency of 100 \u00b5s is 10,000 IOPS, which at 4 KiB is 40.96 MB/s (39.06 MiB/s). Raising the queue depth to 32 at 1 ms mean latency gives 32,000 IOPS and 131.07 MB/s.
With 128 KiB blocks, queue depth 16 and 1 ms: 16,000 IOPS and 2097.15 MB/s (2000.00 MiB/s). With 1 MiB blocks, queue depth 4 and 5 ms: 800 IOPS and 838.86 MB/s.
The other direction, with the example in the Wikipedia article: a mean of 10 jobs in the system and a throughput of 50 per second give a mean response time of 10 ÷ 50 = 0.2 s. For storage, a mean queue depth of 16 at 32,000 IOPS means a mean latency of 16 ÷ 32,000 = 0.5 ms.

Chart

Log-log plot of IOPS against mean latency from 0.1 to 10 ms for queue depths 1 to 128. At 1 ms the lines run from 1,000 IOPS at queue depth 1 to 128,000 IOPS at queue depth 128. — Block size does not enter IOPS, so one block size is enough for the chart. Every point is a CSV row.

Limits

Little\u2019s law relates averages in a stable system. Mean latency hides the spread: a drive can have a low mean and a long tail, and the table says nothing about percentiles.
Latency is not independent of queue depth. On a real device the latency of one I/O usually rises as more are in flight, so a cell is a consistency check on three numbers, not a prediction that raising queue depth gives that many more IOPS.
Many cells are above what any one device or link can do, such as 1 MiB blocks at 128 outstanding I/Os and 100 \u00b5s. The table does not know the device limits. See the interface payload ceilings dataset for link limits.
W must be measured the same way as L. If latency is taken at the device and the queue depth at the application, the two will not satisfy the equation.

Table

Same 100 rows as the CSV.
Block size (bytes)	Queue depth	Mean latency (\u00b5s)	IOPS	MB/s	MiB/s
4,096	1	100	10,000	40.96	39.06
4,096	1	500	2,000	8.19	7.81
4,096	1	1,000	1,000	4.1	3.91
4,096	1	5,000	200	0.82	0.78
4,096	1	10,000	100	0.41	0.39
4,096	4	100	40,000	163.84	156.25
4,096	4	500	8,000	32.77	31.25
4,096	4	1,000	4,000	16.38	15.62
4,096	4	5,000	800	3.28	3.12
4,096	4	10,000	400	1.64	1.56
4,096	16	100	160,000	655.36	625
4,096	16	500	32,000	131.07	125
4,096	16	1,000	16,000	65.54	62.5
4,096	16	5,000	3,200	13.11	12.5
4,096	16	10,000	1,600	6.55	6.25
4,096	32	100	320,000	1,310.72	1,250
4,096	32	500	64,000	262.14	250
4,096	32	1,000	32,000	131.07	125
4,096	32	5,000	6,400	26.21	25
4,096	32	10,000	3,200	13.11	12.5
4,096	128	100	1,280,000	5,242.88	5,000
4,096	128	500	256,000	1,048.58	1,000
4,096	128	1,000	128,000	524.29	500
4,096	128	5,000	25,600	104.86	100
4,096	128	10,000	12,800	52.43	50
16,384	1	100	10,000	163.84	156.25
16,384	1	500	2,000	32.77	31.25
16,384	1	1,000	1,000	16.38	15.62
16,384	1	5,000	200	3.28	3.12
16,384	1	10,000	100	1.64	1.56
16,384	4	100	40,000	655.36	625
16,384	4	500	8,000	131.07	125
16,384	4	1,000	4,000	65.54	62.5
16,384	4	5,000	800	13.11	12.5
16,384	4	10,000	400	6.55	6.25
16,384	16	100	160,000	2,621.44	2,500
16,384	16	500	32,000	524.29	500
16,384	16	1,000	16,000	262.14	250
16,384	16	5,000	3,200	52.43	50
16,384	16	10,000	1,600	26.21	25
16,384	32	100	320,000	5,242.88	5,000
16,384	32	500	64,000	1,048.58	1,000
16,384	32	1,000	32,000	524.29	500
16,384	32	5,000	6,400	104.86	100
16,384	32	10,000	3,200	52.43	50
16,384	128	100	1,280,000	20,971.52	20,000
16,384	128	500	256,000	4,194.3	4,000
16,384	128	1,000	128,000	2,097.15	2,000
16,384	128	5,000	25,600	419.43	400
16,384	128	10,000	12,800	209.72	200
131,072	1	100	10,000	1,310.72	1,250
131,072	1	500	2,000	262.14	250
131,072	1	1,000	1,000	131.07	125
131,072	1	5,000	200	26.21	25
131,072	1	10,000	100	13.11	12.5
131,072	4	100	40,000	5,242.88	5,000
131,072	4	500	8,000	1,048.58	1,000
131,072	4	1,000	4,000	524.29	500
131,072	4	5,000	800	104.86	100
131,072	4	10,000	400	52.43	50
131,072	16	100	160,000	20,971.52	20,000
131,072	16	500	32,000	4,194.3	4,000
131,072	16	1,000	16,000	2,097.15	2,000
131,072	16	5,000	3,200	419.43	400
131,072	16	10,000	1,600	209.72	200
131,072	32	100	320,000	41,943.04	40,000
131,072	32	500	64,000	8,388.61	8,000
131,072	32	1,000	32,000	4,194.3	4,000
131,072	32	5,000	6,400	838.86	800
131,072	32	10,000	3,200	419.43	400
131,072	128	100	1,280,000	167,772.16	160,000
131,072	128	500	256,000	33,554.43	32,000
131,072	128	1,000	128,000	16,777.22	16,000
131,072	128	5,000	25,600	3,355.44	3,200
131,072	128	10,000	12,800	1,677.72	1,600
1,048,576	1	100	10,000	10,485.76	10,000
1,048,576	1	500	2,000	2,097.15	2,000
1,048,576	1	1,000	1,000	1,048.58	1,000
1,048,576	1	5,000	200	209.72	200
1,048,576	1	10,000	100	104.86	100
1,048,576	4	100	40,000	41,943.04	40,000
1,048,576	4	500	8,000	8,388.61	8,000
1,048,576	4	1,000	4,000	4,194.3	4,000
1,048,576	4	5,000	800	838.86	800
1,048,576	4	10,000	400	419.43	400
1,048,576	16	100	160,000	167,772.16	160,000
1,048,576	16	500	32,000	33,554.43	32,000
1,048,576	16	1,000	16,000	16,777.22	16,000
1,048,576	16	5,000	3,200	3,355.44	3,200
1,048,576	16	10,000	1,600	1,677.72	1,600
1,048,576	32	100	320,000	335,544.32	320,000
1,048,576	32	500	64,000	67,108.86	64,000
1,048,576	32	1,000	32,000	33,554.43	32,000
1,048,576	32	5,000	6,400	6,710.89	6,400
1,048,576	32	10,000	3,200	3,355.44	3,200
1,048,576	128	100	1,280,000	1,342,177.28	1,280,000
1,048,576	128	500	256,000	268,435.46	256,000
1,048,576	128	1,000	128,000	134,217.73	128,000
1,048,576	128	5,000	25,600	26,843.55	25,600
1,048,576	128	10,000	12,800	13,421.77	12,800

Columns

block_size_bytes (integer): I/O size in bytes: 4096, 16384, 131072, 1048576. These are the values fio reads from bs=4k, 16k, 128k, 1m with its default kb_base of 1024.
queue_depth (integer): I/Os in flight, the fio iodepth option, and L in Little's law.
mean_latency_us (integer): Mean time one I/O spends in the system, in microseconds, and W in Little's law.
iops (integer): queue_depth / mean_latency_us * 1e6, I/Os per second. Computed here.
bandwidth_mb_s (number): iops * block_size_bytes / 1e6, two decimals, decimal megabytes per second (the kB/s style fio prints).
bandwidth_mib_s (number): iops * block_size_bytes / 2^20, two decimals, mebibytes per second (the KiB/s style fio prints).

License

The table is arithmetic computed here from Little's law and from the unit conventions of fio. No third-party data or documentation text is copied. Reuse is fine with attribution to this site.

Wikipedia reuse terms · Little\u2019s law source

Sources

Little's law, Wikipedia: L = lambda W and the response-time example (accessed 2026-10-11)
fio documentation: iodepth, blocksize, kb_base and unit prefixes (accessed 2026-10-11)