Measured Comparisons: 30 Head-to-Head Guides, November 9–10, 2026
This index covers the 30 measured guides published November 9–10, 2026 — 4 C++ and 26 sysadmin / command-line. Nine earlier measured guides on the site are not listed here; they predate this index.
Written November 11, 2026 · Tested with GCC 16.2 · 11 min read
- What this page is
- C++ — 4 guides
- Sysadmin and command line — 26 guides
What this page is
An index of the 30 measured guides published on November 9–10, 2026.
C++ — 4 guides
- GCC 16.2: std::print, ranges::to, and from_range — What Actually Compiles, and the Macro That Does Not Exist — std::print, ranges::to, and the from_range constructor all compile and run on GCC 16.2.0; std::hazard_pointer fails at the include because the header is not shipped; the from_range feature-test macro is
__cpp_lib_containers_ranges, not__cpp_lib_ranges_from_range. - C++20 Coroutines + io_uring: A co_await File Read That Actually Runs — one pump, 36 bytes, content verified (content_match=1, PROBE_OK) — a co_await file read that actually runs, on liburing 2.16, GCC 13.3.0.
- What Does std::generator Cost, Measured? — summing 10 million values costs 0.024 s through std::generator vs 0.014 s through a plain loop (1.57–1.80x); a views::iota pipeline ties the loop at zero allocations; a second pass over a consumed generator segfaults (rc=-11) on GCC 14 / libstdc++ 14.
- How Fast Do std::latch and std::barrier Wake Threads? Measured — 9 to 68 Times Faster Than a Condition Variable — std::latch wakes a waiting thread in 364 ns vs 4,342 ns for a mutex and condition_variable at 2 threads (11.9x), 68.1x at 8 threads; std::barrier beats a hand-rolled condition-variable barrier by 1.39x / 1.70x / 1.84x per phase at 2 / 8 / 32 threads.
Sysadmin and command line — 26 guides
- inotify vs Polling: Measured Wake Latency, Queue Overflow, and the Non-Recursive Trap — inotify wakes in 0.087 ms (median); a 10 ms poller takes 6.1 ms and a 100 ms poller 40.9 ms; the queue holds exactly 16,384 events before it overflows; a directory watch never sees a grandchild change.
- epoll vs poll vs select, Measured: Where the Crossover Actually Is — one wait call over 10,000 idle file descriptors costs poll 0.3000 ms and epoll 0.0003 ms; wake latency ties at 10 fds and differs 31.8x at 10,000; only 511 read ends fit under FD_SETSIZE.
- cgroup v2 CPU Quota: What Actually Happens When the Throttle Bites, Measured — a 50% CPU quota makes the same fixed work take 1.92x as long; a 25% quota makes it 3.95x as long; CPU time is nearly flat and almost every 100 ms period is throttled.
- Copying a File Without read() and write() Is About Twice as Fast: sendfile vs copy_file_range vs splice, Measured — at 1 GiB the kernel-side copies are about twice as fast as a read/write loop (fresh best kernel median 2.34x, sendfile 1.83x); at 64 MiB the edge shrinks to 1.16x / 1.11x / 1.08x; at 1 MiB it is noise.
- Waking a Thread: pipe vs eventfd vs signalfd, Measured — all three wake a blocked thread in ~0.04 ms, no latency winner (signalfd 6–18% slower across four runs); 1,000 rapid events: pipe keeps all 1,000, eventfd returns one counter of 1,000, signalfd keeps one.
- Pulling One Field Out of a Million JSON Lines: jq vs Python vs grep, Measured — grep pulls one field from a million JSON lines in 0.349 s vs jq 1.492 s and Python 1.783 s (4.28x / 5.11x); a nested duplicate key makes grep return 101,000 lines instead of 100,000.
- Copying a 1 GiB File: dd at bs=512 Is 9x Slower — and cp Ties dd Once the Block Size Is Right — dd at bs=512 takes ~3.5 s to copy a 1 GiB file; at bs=1M it takes ~0.39 s (9.1x / 8.8x slower at bs=512); plain cp ties tuned dd — the block size is the decision, not the tool.
- Are These Two Files the Same? cmp vs diff, Measured — Plain diff Costs 100x on Text and Nothing Extra on Binary — on a 1 GiB binary file cmp -s, diff -q and plain diff cost the same (IDENT 0.445 / 0.433 / 0.431 s); on a million-line text file plain diff costs 100x diff -q when the difference is on line 1 (EARLY 0.201 s vs 0.002 s).
- Which Lines Are in Both Files? comm vs grep vs sort|uniq vs Python, Measured — comm -12 on pre-sorted files finds the 500,000 shared lines in 0.14 s; grep -xF -f takes 2.60 s; sort|uniq -d is wrong unless both files are already deduplicated (2 lines where the true intersection is 1).
- mv Across Filesystems, Measured: One Rename or a Full Copy — mv on one filesystem takes 0.0026 s for a 1 GiB file and 0.0025 s for a 10,000-file tree; across filesystems it is a copy (file 0.789 s banked, 1.046 s fresh; tree 1.077 s banked, 0.868 s fresh) — no tree penalty; mv preserves mtime across filesystems, plain cp does not.
- paste vs join, Measured: Fast by Position, Wrong by Key — paste merges a million lines in 0.087 s vs join 0.155 s pre-sorted (0.410 s with the sort paid); on shuffled files all 1,000,000 paste pairings are wrong; with 1,000 keys missing from B, 997,204 rows carry the wrong value.
- grep -F vs -E vs -P, Measured: Same Pattern, Three Engines, One Silent Trap — on a plain literal grep -F and grep -E tie at 0.040 s while grep -P costs 0.099 s (2.5x); LC_ALL=C halves -P (47%); on a dotted service name -E and -P silently return 10,058 extra lines (2.5%) that -F does not.
- Copying a Sparse File, Measured: Which Tools Preserve the Holes — plain cp copies a 1 GiB sparse file in 0.0042 s and keeps it at 3 MiB on disk; plain rsync takes 1.7098 s and expands it to the full 1 GiB; dd conv=sparse preserves the holes at 0.0520 s.
- Cutting a Million-Line File Into Ten, Measured: split vs csplit vs awk — split -l cuts a million-line file into ten in 0.0425 s; csplit takes 0.1694 s (3.99x) and awk 0.3052 s (7.18x); split -n r/10 scrambles the order and split -b makes an eleventh chunk.
- Hex-Dumping a 64 MiB Binary, Measured: xxd vs hexdump vs od — xxd -p hex-dumps a 64 MiB binary in 0.6848 s; hexdump -C takes 6.5670 s; the same visual output costs 5.31x (hexdump -C) and 4.89x (od -A x -t x1z) over xxd; default od and hexdump collapse 4,194,304 lines of zeros into 3.
- Copying a Directory Tree, Measured: cp -a vs rsync -a vs tar-pipe — on a 10,000-file tree the tar-pipe is fastest (1.75x over cp-a, 2.41x over rsync-a); on a single 1 GiB file cp-a is fastest (2.00x over tar-pipe, 4.00x over rsync-a); rsync -a without a trailing slash nests the whole tree one level down.
- Numbering a Million Lines, Measured: cat -n vs nl vs awk vs grep -n — cat -n numbers a million lines in 0.0768 s; nl takes 0.2123 s (2.76x) and numbers only 950,000 of the 1,000,000 lines by default; nl -ba output is byte-identical to cat -n at 2.76x the cost.
- Seeing the Hidden Characters, Measured: cat -A vs sed -n l vs od -c — cat -A shows every hidden character in a million-line file in 0.0552 s; sed -n l costs 14.0x and folds the file to 1,001,020 lines; od -c costs 103x (5.7099 s) and silently drops 97 lines to
*elision; cat -v leaves all 50,000 tabs literal. - Converting CRLF to LF, Measured: tr vs sed vs perl vs awk — tr converts a million CRLF lines in 0.1166 s; sed takes 0.2711 s, perl 0.4095 s, awk 0.4782 s; tr deletes 1,000 mid-line carriage returns the other three preserve; sed, perl and awk produce byte-identical output.
- Tabs to Spaces and Back, Measured: expand vs unexpand vs sed vs awk vs perl — expand converts a million tabbed lines to spaces in 0.1088 s; sed costs 2.6–2.8x, perl 3.3–3.6x, awk 4.4–5.1x; a naive substitution misaligns 266,335 of 1,000,000 lines; unexpand -t 8 silently converts mid-line blanks exactly like -a.
- Wrapping Long Lines, Measured: fold vs fmt vs awk — wrapping 510,000 lines to 80 columns costs 0.23 s with fold and 0.72 s with fmt (3.15x); fmt silently joins short lines, fold cuts a 200-character word in half and fmt refuses to break it at all.
- Editing a File In Place, Measured: sed -i vs perl -pi vs awk — sed -i edits a million-line log in 0.18 s and perl -pi in 0.23 s; the backup costs nothing; the awk temp-file form costs about twice as much; every one of the six forms replaces the file — new inode on all 18 reps — breaking symlinks and hard links.
- Joining Two Files on a Key: join vs awk, Measured — join on pre-sorted inputs merges a million fact rows against a 100,000-key lookup in 0.0688 s; the awk hash merge takes 0.4629 s; even paying for both sorts (0.2677 s total) join still wins 1.73x; join on unsorted input exits rc=1 after 1 line.
- Finding Lines by Prefix: look vs grep vs rg vs awk vs sed, Measured — look finds 1,000 lines by prefix in 0.0013 s vs rg 0.0051 s and grep 0.0088 s (6.8x faster than grep); on unsorted input look returns rc=1 with 0 lines and empty stderr; its -b flag does not exist on Linux (util-linux 2.39.3).
- How Fast Does systemd Restart a Crashed Service? Restart=always vs on-failure, Measured — and the Crash Loop It Refuses — with RestartSec at its 100 ms default, systemd takes 0.2520 s to restart a crashing service (always-1s: 1.2481 s; always-5s: 5.2440 s); the delay is a minimum — systemd adds about 0.15 s of its own; on-failure restarts a crashing service exactly like always (0.2482 s); the default start limit stops the loop after 5 restarts.
- Rust Lazy Statics, Measured: OnceLock vs LazyLock vs lazy_static — and the 2x Claim That Does Not Reproduce — steady-state access costs OnceLock 1.121 ns, LazyLock 1.349 ns, lazy_static 1.386 ns (1.203x / 1.236x) — the "2x" claim does not reproduce (1.24x); first init has no consistent winner (max/min 1.245x / 1.242x / 1.046x at N=2/8/32); LazyLock poisoning is unrecoverable, OnceLock retries.
Related guides on this site
Keep Exploring
Paste a [Service] section and get a plain-language verdict on every sandboxing setting it finds.
Paste sshd -G output and get a hardening verdict on the values your server actually runs.
Paste a server block and get WebSocket, TLS, HSTS, and proxy-header verdicts.
Paste a systemd timer expression and get the specific reason it fails, the normalized form, and the past-date traps the built-in check hides.
The full sysadmin hub \u2014 systemd, cgroups, file tools, and measured Linux comparisons.