Pull to refresh
Logo
Sashiko AI reviewer adds a performance check for Linux kernel patches

Sashiko AI reviewer adds a performance check for Linux kernel patches

New Capabilities

Version 0.9.5 traces side effects one or two hops past a patch, lifting detection of known regressions from 15% to 70% in the project's own 40-commit test

Overview

Updated 1 hour ago

Sashiko, Google's automated code reviewer for the Linux kernel, can now run a separate performance stage. Version 0.9.5 checks the changed code plus the functions that call it and the structures that embed it, up to two levels outward, because a slowdown is often caused by code the patch never touched.

On the project's 40-commit test set, detection of known regressions rose from 3 of 20 to 14 of 20. Median input tokens per review rose 11%. Median review time fell about 3%, because the stages run in parallel.

Why it matters

Kernel performance regressions usually arrive inside bug fixes. A reviewer that catches them before merge saves fleets from slowdowns no correctness test would flag.

Questions about this story

Free account needed to ask — your question is kept and asked for you right after sign-up. Answers are public.

No questions yet — be the first to ask.

Key Indicators

70%
Known regressions detected
14 of 20 historical kernel regressions caught with the performance stage enabled.
15%
Baseline detection rate
3 of the same 20 regressions caught before the stage was added.
40
Commits in the benchmark suite
20 confirmed regressions plus 20 neutral commits that had drawn no fix or revert in six months.
+11%
Median input tokens per review
6.61 million to 7.34 million per commit, 91.4% of it cached.
0
New false-positive neutral commits
The neutral clean rate rose from 11 of 20 to 12 of 20; unmatched findings fell from 52 to 51.

Voices

Curated perspectives — historical figures and your fellow readers.

Sign up to generate historical perspectives on this story.

People Involved

Organizations Involved

Timeline

3 events Latest: Yesterday
  1. Sashiko 0.9.5 adds a performance stage

    Latest Release

    Optional review stage traces callers and embedding structs one or two hops outward.

  2. Benchmark claims 14 of 20 regressions caught

    Benchmark

    A/B run on 40 commits; 3 of 20 baseline, 14 of 20 with the stage.

  3. Sashiko 0.9.4 ships

    Release

    Adds first-class e2fsprogs code review support.

Scenarios

1

An outside benchmark reproduces the detection gain

Possible Resolves by Q3 2027

Discussed by: Sashiko's release notes, which report the A/B run; kernel press has not run an independent test

The 70% figure comes from 40 commits chosen by the people who built the stage, using one model at high reasoning effort. A group outside the project assembles its own set of known kernel regressions, runs the tool, and publishes the hit rate. If the number holds above half, the stage looks like a general improvement rather than a fit to its own test set.

2

A maintainer credits a Sashiko performance finding

Likely Resolves by May 31, 2027

Discussed by: Phoronix and other release coverage, which frame the stage as a pre-merge check

The useful test is not a benchmark file but a review thread. A maintainer reads a performance warning, traces the caller the tool named, and changes the patch. One such thread on a subsystem with real traffic gives the stage a track record that a test suite cannot.

3

Noise complaints push the stage off the default path

Unlikely Resolves by End of 2027

Discussed by: The developers' own false-positive tracking, which they added in the same release

The stage is optional and can be skipped with a flag. If maintainers find the warnings distracting, or if a flagged patch turns out to be clean often enough, the project can demote the stage or make it opt-in only. The release already includes per-stage false-positive tracking, so the evidence for such a decision would be on hand.

Historical Context

2 moments from history that rhyme with this story — and how they unfolded.

2015 onward

Syzkaller fuzzing the Linux kernel (2015)

Dmitry Vyukov at Google built a coverage-guided fuzzer aimed at system calls, and kernel developers started running it against the mainline tree. It generated malformed inputs at a rate no human tester could match, then shrank each crash to a reproducible case.

Then

Reports arrived faster than maintainers could triage them, which forced automated dashboards and deduplication.

Now

Fuzzing became a standing part of kernel testing, and the reporting pipeline mattered as much as the bug-finding.

Why this matters now

Sashiko faces the same adoption test: a tool that finds real problems still has to keep its output readable enough that busy maintainers act on it.

2007 onward

checkpatch.pl in the Linux kernel (2007)

A script that mechanically checked patches against kernel coding style entered the development workflow. It flagged whitespace, line length and formatting, and developers were asked to run it before sending patches.

Then

It caught a large volume of trivial mistakes and drew complaints about rules that did not fit every subsystem.

Now

It stayed in use, with a documented way to waive warnings, because the false-positive rate was visible and arguable.

Why this matters now

A reviewer that files findings into a mailing list lives or dies on how it handles being wrong, which is why 0.9.5 ships per-stage false-positive tracking alongside the new checks.

Sources

(8)