Structured Buffers vs. Constant Buffers?

Hi!

As you probably have noticed, from a programmer perspective structured and constant buffers are used quite similar, though there are some major differences between them.

Firstly their memory access work differently.
A constant buffer is extremely fast if all threads in a warp access the same value. But, if all threads read from different spots the reads are serialized – a phenomenon called constant waterfalling, which makes the reading slow (causes headache for people doing bone animations). In all the scenarios you described above, every threads reads from the same address, so I’d go with constant buffers, except maybe for the third scenario (in case you have many, many lights).
Structured buffers on the other hand utilize the unified cache architecture, which means the first read is slow, but all subsequent reads are very fast (if the requested data is already in the cache).

Secondly, their usage is limited.
Constant buffers are so fast, because they are in special registers (constant registers) of which we don’t have much (about 64KB). Structured buffers are not placed in constant registers, which means we generally have more space available. Thus, if the data you want to read gets big, you have to move from constant buffers to structured buffers (e.g. for accessing a huge light list).
Structured buffers can’t be bound to any point in the pipeline, which means not as a vertex buffer etc. They were introduced for DirectCompute on Dx10 hardware, since Dx10 hardware doesn’t allow random-access writes on typed resources (textures, vertex buffers etc). Though, you can read from them in every shader stage.
A structured buffer has some really nice candy. It can have a “hidden counter”, which can be accessed by multiple threads (even from different thread groups) to count things. Curiously this counter is a little bit faster than using an interlockedAdd on a byte address buffer (another untyped resource with much more applications, since it can be bound everywhere, unlike structured buffers.)

Cheers!

Thanks for the update, that's a really in-depth and helpful response. I think I'll go with StructuredBuffers when I eventually get around to lighting my engine, because I really can't be sure how many lights I'll need.

Thanks very much

The word "constant" refers to the fact that the values are constant during the execution of a shader program, and doesn't imply that the values can't be changed by CPU. The term comes from the pre-DX10 days when you just had a handful of constant values defined in a shader, which were referred to as "shader constants".

The intended use case for constant buffers is small amounts of heterogeneous values that you want to be directly accessible by name within your shader. So your example of having a view and projection matrix is perfect for a constant buffer. A structured buffer is essentially an array of homogeneous structures, just like an array of structs. So if you have a lot of elements that you want to be indexable in the shader, then you want to use a structured buffer. Your example of a list of lights is a good candidate for a structured buffer.

For your DOF shader you could do either, although it will be a bit more expensive if your shader contains an actual loop with an indexed read from a buffer. In the case of an indexed read all threads will repeat the memory access, while for a static constant buffer read it will be more optimized. To get a static read you need to ensure that the loop is unrolled, which may require different permutations of the shader for different loop iterations.

At any rate, modern GPU hardware is pretty generic and there isn't always going to a big difference between different abstractions provided by the API. Things are much different than the older days of GPU's from DX9 and earlier, when the hardware was less flexible. And of course when it comes to performance, you should be sure to profile if you want to know for sure what approach is faster.