4 replies to this topic

[_Slin_]

I am trying to realize tiled lighting (http://www.cse.chalmers.se/~olaolss/papers/tiled_shading_preprint.pdf), my problem is that my fragment shader is extremely slow due to dynamic branching.

The fragment shader looks like this:

#version 150
precision highp float;

uniform sampler2D mTexture0;

uniform isamplerBuffer lightListOffset;
uniform vec4 lightTileSize;

in vec2 outTexcoord;
out vec4 fragColor0;

void main()
{
	fragColor0 = texture(mTexture0, outTexcoord);
	vec3 light = vec3(0.1);
	int tileindex = int(int(gl_FragCoord.y/lightTileSize.y)*lightTileSize.z+int(gl_FragCoord.x/lightTileSize.x));
	ivec2 listoffset = texelFetch(lightListOffset, tileindex).xy;
	for(int i = 0; i < listoffset.y; i++)
	{
		light += 0.1;
	}
	
	fragColor0.rgb *= light;
}

 

The problem is the loop which is even extremely slow if there is only one or even no iteration at all.

So my question is: What is the optimal way to provide the information for the dynamic branching to be as fast as possible?

Should the tileindex be calculated in another way? Is it a bad idea to provide the lightListOffset as a buffer texture?

I tried a couple of variations and actually this works great on my NVIDIA GeForce GT 650M, but not on the AMD Radeon HD 6770M we are also testing it on. With slow I am talking about 15fps compared to 60fps on the nvidia card, just by the existence of the loop with the dependency on the texelFetch.

 

Just to show what I am talking about (just very basic diffuse point lights):

 

Thanks!

[mhagain]

"light += 0.1 * listoffset.y" will be identical to your current looping version.  If listoffset.y can ever be negative, use "light += 0.1 * max (0.0, listoffset.y)" instead.

[_Slin_]

Well, yes, but that is not what this is about, as I want to do more complex calculations within the loop.

[Sik_the_hedgehog]

First of all, remember that SIMD works by running the same instruction on multiple sets of data at the same time. GPUs can get around this for conditional branching by ignoring the operation in the shader threads where it doesn't apply, but those threads will be completely idle until the conditional path is over (effectively wasting time).

 

In other words: the largest amount of iterations for any pixel will be the amount of iterations that will run for all pixels, at least of the batch being currently processed. So rewrite the code taking this into account.

 

Why do you mention texelFetch, though? Can you get a loop that runs a lot faster without it?

[Ashaman73]

Is it faster if you have a static loop count, e.g. 8 or 16 iterations ?

If this is the case, you could subdivide your shader in multiple of X fix iterations and render a single tile multiple times (with an offset as parameter into your light array).

 

NVIDIA GeForce GT 650M, but not on the AMD Radeon HD 6770M

Parts should be explained by the performance difference of these two GPUs, the 650M seems to outperform the 6770, though not by 4x, still you need to consider this.