Branches - how expensive are they?

Hi,

As you might know from showcase I'm doing GPU particles, with potentially millions of particles on screen. I need performance to be as high as possible, but I end up frequently with a question: To branch or not to branch? Take the following:

Code (csharp):

1.  
2. if (someValue != 0)
3. {
4. //complicated calculation and such
5. }
6. else
7. {
8. //simplified calculation, for this scenario (And let's say more than 40% of branches take this path.
9. }
10.  

On CPU I'm sure this would be faster, however, on GPU people seem to stress alot over branches. Would they be slower than doing the actualy calculation? In my case, a example would be:

Code (csharp):

1.  
2. //shortened and simplified a bit
3. float3 dif = somePos - someOtherPos;
4.  
5. if (rotated)//let's say this happens between 40-60% of the time
6. {
7. dif = float3(dot(dif, axisX), dot(dif, axisY), dot(dif, axisZ));
8. }
9.  
10.  

Would this be slower of faster without the branch?

Thanks!
-Arthur


(O, and I'm talking about CG)

 

In my limited understanding the answer depends very much on your GPU. Old GPUs always computed all branches of an if-else block, more recent GPUs don't (always) do this. This means that in the worst case, your first solution shows the same performance as the second. But there are GPUs which should execute the first solution faster than the second.

 

If I understand the description by Imagination Technologies correctly, the "block" size is 1 fragment for PowerVR's SGX GPU: "The branching granularity on SGX is one fragment or one vertex. This means you don’t have to worry a lot about making branching coherent for an area of fragments." from page 22 in http://www.imgtec.com/powervr/insid...Development Recommendations.1.8f.External.pdf

EDIT: OK, I got curious. Here is what NVIDIA writes: "GeForce 8800 Series GPUs are designed to process complex DX10 shaders. Programmers will enjoy as fine 16-pixel branching granularity up to 32 pixels in some cases. Compared to the ATI X1900 series, which uses 48 pixel granularity, the GeForce 8800 architecture is far more efficient with 32 pixel granularity for pixel shader programs." from page 32 in http://www.cse.ohio-state.edu/~agrawal/788-su08/Papers/week2/GPU.pdf

It also says that Series 7 had a granularity of 880 fragments.

 

Thank you for the extensive answer Aras! That clarifies a lot. I read the paper with great intrest

So, I will definitely try to remove some branches in the shader I use to draw the particles.

However, the small snippet comes from a compute shader. I think those couple of dot products will be to little no matter what, but it raises some questions.

That code is in a (dynamic)for loop, if rotate is false, all particles skip that part of the for loop. Is that considered to be static? Also, in the sense of compute shaders, coherency means a thread group?

Also, dynamic for loops work like branches, afaik? Even if the number of iterations is globally static?

 

Maybe; I guess we will know as soon as PowerVR updates its documentation for the PowerVR Series 6 later this year or next year. (I always assumed that the shader engine in Series 5 has already multiple shader execution units. In that case I don't see a reason why adding more of them would make a difference. But since Series 6 appears to include major changes, anything can happen. If it doesn't happen with Series 6, then we probably won't see increasing granularity for a couple of years as they usually increase the number of GPU cores for faster GPUs.)

 

Out of curiosity, how does the compiler "flatten" the branch?

Is it essentially the same thing as the GPU would do (compute both paths, then result1 * step(condition) + result2 * 1-step(condition))?

 

Yes.

If you can read ARB vertex and fragment programs (documented here: http://www.opengl.org/registry/specs/ARB/vertex_program.txt and here: http://www.opengl.org/registry/specs/ARB/fragment_program.txt ), look at the compiled shader for this code:

Code (csharp):

1.  
2.  Shader "Custom/NewShader" {
3.    SubShader {
4.       Pass {
5.          CGPROGRAM
6.  
7.          #pragma vertex vert
8.          #pragma fragment frag
9.  
10.          float4 vert(float4 vertexPos : POSITION) : SV_POSITION
11.          {
12.             if (vertexPos.z > 0)
13.             {
14.                return mul(UNITY_MATRIX_MVP, vertexPos);
15.             }
16.             else
17.             {
18.                return mul(UNITY_MATRIX_P, -vertexPos);
19.             }
20.          }
21.  
22.          float4 frag(void) : COLOR
23.          {
24.             return float4(1.0, 0.0, 0.0, 1.0);
25.          }
26.  
27.          ENDCG
28.       }
29.    }
30. }
31.  

 

You are right about coarser granularity for Series 6 PowerVR GPUs, see page 24 of the updated PowerVR performance recommendations:
http://www.imgtec.com/downloadconfi...le=PowerVR.Performance Recommendations.1.0.28