Why isn't more culling being done on the GPU?

Question

I'm interested in game development and 3D graphics; however, I'm not very experienced, so I apologize in advance if this comes across as ignorant or overly general.

The impression I get is that quite often the bottleneck in 3D games comes from the CPU having to make draw calls to the GPU. Culling seems to generally be performed on the CPU and then, for each frame, the CPU has to transfer the culled scene graph over to the GPU memory for rendering and display.

However, why can't culling be done on the GPU? It seems to be a very repetitive and predictable task that has to be done for every frame and would benefit from parallelization. Why not store the whole active scene graph in the GPU RAM; let the CPU just update what needs to be updated each frame (due to physics, animation, scripting, whatever); then fire a single 'draw' call to the GPU and have it cull and render everything? It seems to me it should be more efficient, because it would hugely reduce the amount of data transfer going on between CPU/GPU.

Answer 1

Non-optimality in terms of architecture. Wrong tool for the job.

GPU-optimal tasks are highly parallel: vertex processing, texture processing, computing boid motion, with all kernel-threads running in parallel from start to finish.

Culling, OTOH, is all about questions / conditionals e.g. "is this object in this view at this time given these conditions?". There are severe performance impacts when one GPU thread fails while all the others pass, because GPUs expect all pipelines to execute a kernel in parallel from start to finish.

So culling has tended to be better suited to calculation on the CPU, which is built for branching without stalling the entire pipeline (c.f. branch prediction, which GPUs lack) on a failed branch.

Think of it like this: GPU's processing profile is "many small things at once without branches"; CPU's domain is "give me any problem large or small, conditional or not, and I will crack it quickly."

And every time the GPU pipeline stalls because you were executing non-optimal tasks on it, all those threads are sitting twiddling their thumbs, which is like losing man-years of work you could have been applying to a better-suited problem, with no stalls at all.

Answer 2

To add to Engineer's answer the reason you can't easily parallelize culling is because it's not 'embarrassingly parallel'. If you know the view frustum does not pass x = 5 then you can eliminate everything that does not pass that line pretty easily. And there are even algorithms to do this using an octree and quadtree.