HN Explorer

Ask HN: Is there any tool for benchmarking responsiveness for Linux?

100 points by c0deR3D ↗ HN
System76 recently announced their responsiveness optimizer, System76 Scheduler [0], which basically works as a daemon, adjusting the nice value and the CFS knobs for processes in the box for increased responsiveness. They've claimed that the responsiveness is therefore increased, which I'm also believed so.

However, this got me wondering, is there exists any tool that can report the "numbers" (e.g., scheduling latency) regarding to the responsivenss? Maybe Google has such tool for testing regression for Android or Chrome OS, sadly, I didn't managed to find one.

Thanks!

[0] https://github.com/pop-os/system76-scheduler

47 comments

[ 3.2 ms ] story [ 124 ms ] thread
ahartmetz
For input device to screen measurement, high frame rate camera on your phone. Accuracy isn't the best, but what you measure is as real as it gets.
jrockway
To me the question is how do you use that method to measure keyboard responsiveness? On the camera, you can't quite tell when the key was "supposed" to trigger. I've done these measurements by having a keypress toggle an LED on the keyboard (in firmware), but that glosses over the matrix scan (and potentially debouncing if you implement that wrong). All in all, I've never been fully satisfied there. Maybe you need a one-key keyboard that triggers the LED from an interrupt, and then handles the keypress normally. (Only one key, so no matrix. Triggers on the first edge, so no debounce latency.)
Underphil
Or use the caps lock key and have that reflected on screen.
jrockway
Caps lock doesn't magically skip the matrix scan.
Underphil
Nothing on the keyboard does. I'm trying to suggest an alternative that already has visual feedback.
gfd
Is the caps lock LED even implemented in hardware? I feel like I remember them not responding if my computer freezes but I could be wrong.
eulers_secret
I can confirm the LED is not controlled by only keyboard firmware.

I very often use num lock and caps lock responsiveness to check if my PC has hard-locked, and I just recently suffered hard locks while testing S3 on Linux on a new PC. So I am very sure at this point :)

Underphil
I only really suggested that because any OS can detect the presence of the CAPS LOCK key (see 'CAPS LOCK is on' during Windows login) and it would make a potentially good marker.
ahartmetz
AFAIK you'd have to have a pretty bad keyboard for it to have a significant role in latency. I guess specialized hardware (based on a microcontroller with built-in USB host support) wouldn't be too hard to construct if you really needed to know.

For the camera measurement, I would just press the key as fast as possible and pick about 3/4 of the way down as the trigger point.

jcelerier
> AFAIK you'd have to have a pretty bad keyboard for it to have a significant role in latency

https://danluu.com/keyboard-latency/ puts a lot of keyboards >= 30 ms which is an insane amount of latency

squeaky-clean
So if you check the appendix section, they say they're measuring latency not when the keyswitch makes contact, but when the finger first begins pressing on the key. So they're taking key travel time into account, and that ends up being the majority of the "latency".

It's a fair point for the gaming argument they make, if you want to jump 30ms quicker you'll need shorter keys. But it's not really correct to say the keyboard is adding so much latency when it's actually the user.

andi999
What about fpga which issues a (fake) ps2 keypressed signal and synchronous trigger (led in this case) for the camera?
[deleted]
(comment deleted)
c0balt
NVIDIA published LDAT[1] for click-to-photon latency measurements a while ago. The 'Intended' purpose was to measure input latency for gaming but it could probably be reused for measuring responsivity. This would implicitly also measure the hardware but that shouldn't matter when a constant hardware/driver combo is used.

[1]: https://www.nvidia.com/en-us/geforce/news/nvidia-reviewer-to...

ziggus
I believe the question is less about input latency than (as mentioned,) scheduling latency or the amount of time from when the scheduler marks a process as 'ready to execute' to the time it actually starts executing.

SchedLat (https://tanelpoder.com/posts/schedlat-low-tech-script-for-me...) is one tool/approach to doing this, but it's a bit out of date.

Animats
Tracy? It's mostly used by game devs.
assemblylang
IIRC the Zen Linux kernel[0] is designed to be more responsive for desktop usage than the mainline Linux kernel. I wonder what metrics these tools would provide on the same exact system except with the 2 different kernels. (also see Liquorix patch set for additional patches on top of Zen[1])

[0] https://github.com/zen-kernel/zen-kernel

[1] https://liquorix.net/

sgc
Anybody out there using this? Thinking of trying it on my older thinkpad.
timetraveller26
I use it on my w530. It feels fast and responsive, but I haven't done a proper test or anything.

One of the good things it's that includes patches that allow Anbox to run so I can use Android apps.

sgc
The Anbox support is a big plus. Do you find it is actually fast enough for daily use of any android apps? I have one I use all the time on a tablet, but have not had luck getting a performant solution on my laptop.
seanw444
I hear it doesn't yield considerable differences on beefier hardware, but you can tell the difference on older stuff. Thinkpad may benefit.

Note that Liqourix is not the Zen kernel though.

MonaroVXR
I'm using Pop!_OS, I dont know if I have the update installed or not. For me Pop!_OS is the best distro, since Fedora keeps bugging me out. I'm mostly a RHEL person.
beardog
I use it on a "just works" Garuda install. No issues for it that i haven't experienced with standard Linux
techietim
I use Zen on a newer Thinkpad T14, but I feel there is a difference. Applications like Firefox and Intellij feel snappier than with the standard Kernel.
[deleted]
(comment deleted)
[deleted]
(comment deleted)
throwaway8582
I've used `cyclictest` for this before, it's a simple command line application that measures how long it takes to wake up and run a user space process in response to an interrupt. I've used it in the context of minimizing latency for network and audio applications. I'm not sure how much this relates to desktop application responsiveness as there are additional layers involved.
AtlasBarfed
That would be some tough things to measure.

How much can you slow down a cpu anyway? Can you slow it to 1/10th its clock speed? I would think the best way to measure things like this is to slow down the overall system speed as much as possible.

timpattinson
Yeah you can generally underclock a modern intel or amd chip down to 400MHz, but of course other bottlenecks (storage, RAM, networking) will be massively out of proportion
unwind
I wonder if Ben Heck's "Controller Monitor" [1] would help. It's a dedicated low-level (microcontroller-driven) high-speed input sampling/logging platform, with support for reading a light sensor which I believe is used to sense on-screen changes.

It has the advantage of using game console joypads as inputs, and hacking them to read the buttons etc directly, i.e. without relying on USB. I imagine a specialized version that just sampled a mouse button would be more useful in the context of a computer running desktop apps.

Apologies if I completely misunderstood the intent of this post.

[1] https://www.benheck.com/xbox1monitor/

halz
Weird, the measurement scale they use does not jive with the scale of the knobs being tweaked. For example, `sched_cfs_bandwidth_slice_us` is adjusted by the project's `bandwidth_size` knob. The default is 5000 us, or 5 ms. But the knob they mention it being '5 us'. Same goes for scheduling latency-- its not `us`, its `ms`.

And afaik, the 'sauce' used in Liquorix is MuQSS, by Con Kolivas. But the project has been put on ice somewhat recently[0].

[0]https://ck-hack.blogspot.com/2021/08/514-and-future-of-muqss...

tanelpoder
In addition to what others have said:

- eBPF script: https://www.brendangregg.com/blog/2016-10-08/linux-bcc-runql...

- perf sched: https://www.brendangregg.com/blog/2017-03-16/perf-sched.html

- schedlat: https://tanelpoder.com/posts/schedlat-low-tech-script-for-me...

The last one (written by me) is using /proc/PID/schedstat pseudofile for monitoring % time spent in the CPU runqueue of a single process (not systemwide). I don't always have (root) access for running perf or eBPF scripts (or the old Linux/kernel version don't allow that). But I can still measure how much time a process on a request's critical path (like a RDBMS transaction log writer on commit) spent waiting to get back onto CPU before doing any work.

Like others have already said, the OS CPU queuing/scheduling latency is just one component contributing to the total responsiveness/reaction latency of your app.

ahub
Not sure if it's relevant but I liked the approach of Pavel Fatin in measuring editor latency [0]. It uses OS level input events and actual rendering on screen. So testing the same editor/file with different settings might yield results that are different depending on your scheduling config, while staying close to a "real world" example. He shared [1] the tool he made for the tests.

I'd be curious to know your results regardless of the technique used.

[0] https://pavelfatin.com/typing-with-pleasure/ [1] https://github.com/pavelfatin/typometer

Bancakes
Consider also compiling a realtime configuration of the kernel with the periodic timer ticks.
jonahbenton
My major latency hangups are not around happy path input to response in a single app but around memory management across multiple apps including multiple browser hosted apps. Optimizing swap to occur AHEAD of the user's next task switch is an entirely unsolved problem.