If you've ever used Chrome for Android, you know it can be an obnoxiously slow browser at times - especially on pages with tons of elements. Part of that, according to Google, has to do with how Chrome currently renders web content, using a pipeline that goes from the CPU to the GPU before content appears on the display. The draw commands from the web page go to the CPU, the CPU turns that code into pixels (textures), and the pixels then go to the GPU which displays them on the screen.

The CPU part of the equation is what causes slowdowns - because the process of rasterizing the page elements is very computationally expensive for even a multi-core CPU, this creates a bottleneck. While the GPU is able to keep up with the rasterized textures the CPU is uploading, the CPU is nowhere near performance parity with the GPU in this task, and this is where things like scroll "jank" and incomplete rendering of elements when you scroll down a web page quickly come into play. Basically, a lot of the weirdness you experience while a web page is still rendering or when you're scrolling, things that are especially noticeable on a mobile device, is a result of this bottleneck, at least according to Google.

pipeline

Project Ganesh is Google's attempt at hardware-accelerating the rasterization process, that is, removing the CPU from the pipeline in almost all situations and instead feeding those draw commands directly into the GPU. The GPU is suited for this task because modern GPUs are based on a shader core architecture that gives them many, many very low-power cores capable of doing simple computing operations relatively quickly. But because there are so many of them (192 on NVIDIA's Tegra K1 and newer PowerVR chips, for example), they excel at tasks that have very high input volume in which many unrelated operations (or multiple pieces of a single operation) can be completed simultaneously. (Note: this also explains the name - Ganesh is a many-armed Hindu deity.) This is as opposed to a high-power, billion-plus transistor CPU core which excels at completing very complex and time-intensive operations quickly, but isn't nearly as good as a GPU when you're throwing it an army of small operations that should ideally complete around the same time as one another.

How exactly Google is doing this was not explained, but it marks just another example of GPU-accelerated computing making its way out of the gaming and professional worlds and into consumer software. Google's internal Chrome Canary build for Android already has a working version of Project Ganesh, and you can see it in a 0.25x speed video below. Well, you could if it would embed properly - the session is still live so the timestamp is kind of broken. It's about 40-50 minutes into the presentation.

So, let's step back a second and rein in those expectations. First, this is only working right now on a few "modern" devices. Google apparently has to do a fair bit of work to get this running on all of the myriad GPUs and Chrome platforms out there in the world currently, though the scrolling demo appears to be on a Nexus 5, so I think we can assume Qualcomm is on board and Android is getting it fairly soon. It's also apparently only compatible with about 15% of existing web content, so it sounds like this isn't entirely in Google's hands to fix.

Either way, exciting stuff - Chrome for Android could definitely use a speed boost.

Thanks, Dominic!