Why does accessing a uniform float make my shader more than twice as slow?

Question

My fragment shader was significantly slowed down by a recent change, and I've been trying to understand why.

I isolated the main slow-down to accessing a single particular uniform float. If I include this line:

float not_used = my_uniform;

then the shader runs more than twice as slowly as it does without this line. The not_used float is never referenced again.

Why would this be happening? I hope to understand it so that I can try to come up with a workaround that runs more quickly.

I'm running this on a mac with Intel HD Graphics 3000. I'm measuring the performance by making OpenGL timestamp queries before and after executing my glDraw calls and looking at the ms intervals. I can provide more specs / details if it would be helpful in diagnosing the problem.

Answer 1

Are you using glGetUniformLocation to get the uniform's location? If the uniform has been optimized out, this function will return -1, then when you give the -1 as the location argument to glUniform1f, nothing will be sent to the shader and this will likely save some time.

Answer 2

Sounds like an alignment or memory size issue. Perhaps with this one increased float your memory needs are being bumped up to some magic number that slows down the MAC (I don't use MACs myself) but most likely it is causing an alignment issue.

Consider a C++ type structure in pseudo code:

struct myStruct {
    char x;
    int y;
}

If this structure is allowed to be created normally with an int size of 4 bytes and a char size of 1 byte the structure would be 8 bytes, not the expected 5 bytes. This is because if a word (4 bytes in 32 bit systems) is not aligned on a 4 byte boundary then more work has to be done by the CPU to move this word around. It is a single assembly instruction to move a word (int in this case) if it is properly aligned. If it is not properly aligned then half the word is moved, a pointer is changed and then the other half and this slows things down. So, a structure will normally try to properly align itself when compiled.

If you were to do something like #pragma packed which would remove the unused padding bytes the size would be the expected 5 bytes and things would be slower.

So, I think you need to look at where you are declaring that float and what is declared immediately before it and after it to find out where your possible memory alignment issues are coming from.