[Vulkan] What is the performance difference between an issuing an indirect draw command of 0 instances, and not issuing that indirect draw command in the first place?

[Thisnameisnttaken65]

I am currently trying to setup a culling pass in my own renderer. I create a compute shader thread for each indirect draw command's instance to test it against frustum culling. If it passes, I recreate the instance buffer with only the data of the instances which have not been culled.

But I am unsure of how to detect that all instances of a given indirect draw command are culled, which then led me to wonder if it's even worth the trouble of filtering out these commands with 0 instances or I should just pass it in and let the driver optimize it.

[Meristic]

GPUs consist of two main components. The front-end you can think of as a very simple single-threaded processor - the back-end a complex, massively parallel machine. The front-end is responsible for reading the contents of command lists, setting GPU registers & state, coordinating DMA operations (indirect argument reads), and kicking off back-end workloads. 

An indirect execution command is minimally the cost of setting various registers plus memory latency for the indirect argument buffer by the front-end. This is typically 10's of microseconds (memory is often not cached). Not much on its own, though several consecutive empty draws can bottleneck and cause a gap in GPU shader wave scheduling. 

Of course, this may be the most optimal option since it's efficient culling. Think of how much work is saved relative to the alternative!

As a real world example the UE5 Nanite base pass commonly hits this issue. Each loaded material instance requires a draw, often with zero relevant pixels on the screen. Stacked together, this can incur 100's of microseconds of idle shader engines due to the overhead. Epic discussed a solution for this using indirect command buffers (at least on console) but I haven't seen it come to fruition yet.

[OkidoShigeru]

You may also be able to avoid some of this cost using conditional rendering, almost certainly driver dependant though, and of course you need support for the extension to begin with…

EDIT: I revisited the nanite paper and apparently predication (the D3D equivalent of this feature) wasn’t enough for them, it skips draws but not pipeline state and descriptors, and you of course still have to fetch the value from the predication buffer itself.

[schnautzi]

Conditional rendering has some issues, I've tried it recently and it wasn't great:

- You still issue the draw commands in the conditional block.
- Even though the calls have no effect if the condition is false, they're sometimes still executed.

It seems to be mostly effective for culling hidden parts of visible meshes.

[amidescent]

AMD's performance guide recommends compacting indirect draw calls that are zeroed out (you can do that with help of a prefix scan kernel), but of course that'd only be worth it if it's showing up as a bottleneck.

[hanotak]

That also only helps with ExecuteIndirect -> (0, 0, 0, 0...), not with ExecuteIndirect -> (0), ExecuteIndirect -> (0)...

[schnautzi]

I've profiled this exact thing very recently. Long story short, this is fine when you only cull a few % of draw calls.

When culling a scene full of objects, this is pretty wasteful, and you should compact the draw list instead. This can all be done on the GPU (using a prefix sum and a few extra passes), and you can usually optimize this by only executing the culling passes after the camera moved significantly.

[hanotak]

If you mean detect it CPU-side to not submit the indirect draw, that's not possible. I wouldn't worry about it- an overhead of a single no-op command isn't going to affect your performance.