So I finally got to implementing my CS particle system. So I see that I can use the CopyStructureCount to copy the number of "alive" particles into a constant buffer and regular buffer (as the indirect argument buffer) for drawing.

However, when it comes to dispatching thread groups, I need to use a formula like: NumThreadGroups = (NumAliveParticles + 255) / 256, where 256 is my thread group size. This way I only dispatch as many thread groups as I actually need.

However, I don't really see a way to do this without CPU intervention. There is DispatchIndirect, but I only have NumAliveParticles in some d3d11 buffer, not the result of the calculation (NumAliveParticles + 255) / 256.

I noticed in Hieroglyph 3 ParticleStorm demo, he dispatches enough thread groups to handle the "maximum" particle count. This will result in "empty" thread groups if the particle system is not near maximum capacity. Is this a big deal or not? I assume the GPU overhead is loading the thread group into the multiprocessor, doing a conditional statement to see if any work needs to be done. If the thread group is "empty," all threads will have the same branch behavior in that no work needs to be done, and the thread group is done being processed. So it seems pretty negligible. But I wanted a 2nd opionion, and also to know if there is a way to do a calculation like (NumAliveParticles + 255) / 256 without CPU intervention.

Just run a very simple compute shader with 1 thread that reads the buffer count, calculates the number of thread groups needed to process that number of particle, and outputs it to a buffer. Then you can use that buffer as the args for a DispatchIndirect.

I had originally tried reading back to the CPU what the particle count was, and then using that number to dispatch an appropriate amount of thread groups. However, that was predictably slow, and I ended up coming to the solution that you mentioned (sending a fixed number of thread groups regardless of how many particles are present).

This solution works in particular for this example, since the particles have a fixed lifespan and can be reliably counted as dead after a certain time period. The number of particles that are created are specifically throttled to ensure that this is true. So after a startup period, there is always going to be nearly a full set of particles and there won't be any wasted thread groups anymore.

If you are able to have similar control on your particle system (i.e. you can reliably model the number of particles on the CPU side) then I would recommend the method used in ParticleStorm. The method that MJP mentioned sounds like a good solution if you can't easily model the particles, and it only has a very small performance penalty of a single dispatch. I would be interested to hear your results once you get it up and running though, and hear how your experience turns out.

To point #1, read: http://msdn.microsoft.com/en-us/library/windows/desktop/ff476406(v=vs.85).aspx

The buffer needs to be 12 bytes in size (one UINT for group count X, Y and Z) and specify the MiscFlag D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS.

To point #2, just call DispatchIndirect and pass in the 12 byte buffer created earlier and specify 0 for the offset to the args: http://msdn.microsoft.com/en-us/library/windows/desktop/ff476406(v=vs.85).aspx

As long as the buffer has these 3 UINTs stored within it in a contiguous fashion by the time the GPU gets around to executing the DispatchIndirect event, you'll get that many thread groups being executed.

^^^ what ajmiles said