This is good news! Androids will be a bit faster and offer longer battery life thanks to Google

When phone manufacturers want to impress customers with speed, they usually opt for a more powerful chipset. Google is trying a different approach — instead of stronger hardware, it’s fine-tuning how Android actually works under the hood. And while the result may not sound as sexy as „new Snapdragon”, in practice, it will manifest on every Android phone.

What is AutoFDO and why should you care

The Android LLVM toolchain team this week announced the deployment of a technique called AutoFDO — Automatic Feedback-Directed Optimization — directly into the Android kernel. Simply put, it means that the compiler, which builds the system’s kernel, stops guessing how the code will behave and instead relies on data about how you actually use your phone.

During a standard kernel build, the compiler has to make thousands of decisions — whether to inline a function, which branch of a condition is likely to be executed more often, and so on. It does this based on general rules, which don’t always correspond to reality. AutoFDO reverses this approach: Google collected data on the behavior of the 100 most used applications in a laboratory environment, and based on these patterns, the compiler knows exactly which parts of the code are „hot” (constantly used) and which are „cold” (rarely used).

Two percent is negligible? Wrong

The measured figures on Pixel devices might seem modest at first glance: 2.1% faster boot, 4.3% faster cold app startup, and other metric improvements that the end-user doesn’t directly perceive.

But here, context matters. The Android kernel consumes approximately 40% of all CPU time. Every percentage of optimization at this level translates into energy savings, responsiveness, and overall system fluidity. And most importantly — these optimizations are cumulative. Google previously deployed AutoFDO to user libraries, achieving a 4% acceleration in app startup and a 1% acceleration in boot time. Now, it’s adding the system kernel, so the effect is multiplied.

How it works in practice

Google has built an entire pipeline that keeps the optimization up-to-date. On test devices, it uploads the latest kernel, runs the 100 most popular applications on it, and uses the simpleperf profiler to capture where the code runs most frequently. It leverages ARM processor hardware features for this — specifically, Embedded Trace Extension and Trace Buffer Extension on Pixels.

The collected data is then cleaned, combined from multiple devices into a single entity, and trimmed of cold functions that are used exceptionally. The resulting profile is packaged into a new kernel build and tested to ensure that performance has indeed increased and nothing has broken. And because the code is continuously changing, Google regularly repeats the entire process with each kernel release.

Who and when will benefit

AutoFDO optimization is currently being deployed to kernels android16-6.12 and android15-6.6, with support also extending to the upcoming android17-6.18. For now, it’s an optimization of the main kernel binary (vmlinux), but Google plans to expand it to GKI modules and potentially to vendor modules from phone manufacturers.

It’s important to note that AutoFDO doesn’t change the code’s logic — it only affects how the compiler arranges and translates the code. Functions not captured by the profile are compiled in the traditional way. The risk of regressions is therefore minimal, which is why Google has been using the same approach for years in ChromeOS and on its own server infrastructure.

On the user side, this means one thing: your phone should be a bit snappier and a bit more power-efficient, without you having to do anything. No revolution, but precisely the kind of work that should be done under the hood.

What do you think of this move by Google?

Source: Android Developers Blog