C++ local uninitialized structure caused performance drop? - c++

Question

I'm working on a 3d software renderer. In my code, I've declared a structure Arti3DVSOutput with no default constructor. It's like this:
struct Arti3DVSOutput {
vec4 vPosition; // vec4 has a default ctor that sets all 4 floats 0.0f.
float Varyings[g_ciMaxVaryingNum];
};
void Arti3DDevice::GetTransformedVertex(uint32_t i_iVertexIndex, Arti3DTransformedVertex *out)
{
// Try to fetch result from cache.
uint32_t iCacheIndex = i_iVertexIndex&(g_ciCacheSize - 1);
if (vCache[iCacheIndex].tag == i_iVertexIndex)
{
*out = *(vCache[iCacheIndex].v);
}
else
{
// Cache miss. Need calculation.
Arti3DVSInput vsinput;
// omit some codes that fill in "vsinput"..........
Arti3DVSOutput vs_output;
// Whether comment the following line makes a big difference.
//memset(&vs_output, 0, sizeof(Arti3DVSOutput));
mRC.pfnVS(&vsinput, &mRC.globals, &vs_output);
*out = vs_output;
// Store results in cache.
vCache[iCacheIndex].tag = i_iVertexIndex;
vCache[iCacheIndex].v = &tvBuffer[i_iVertexIndex];
tvBuffer[i_iVertexIndex] = vs_output;
}
}
mRC.pfnVS is a function pointer and the function it's pointing is implemented like this:
void NewCubeVS(Arti3DVSInput *i_pVSInput, Arti3DShaderUniform* i_pUniform, Arti3DVSOutput *o_pVSOutput)
{
o_pVSOutput->vPosition = i_pUniform->mvp * i_pVSInput->ShaderInputs[0];
o_pVSOutput->Varyings[0] = i_pVSInput->ShaderInputs[1].x;
o_pVSOutput->Varyings[1] = i_pVSInput->ShaderInputs[1].y;
o_pVSOutput->Varyings[2] = i_pVSInput->ShaderInputs[1].z;
}
As you can see, what I do in this function is just fill in some members of "o_pVSOutput". No read operation is performed.
Here comes the problem: The pefermance of the renderer has a great drop from 400+ fps to 60+ fps when the local variable "vsoutput" is not set to 0 before I pass its address to the function("NewCubeVS" in this case) as the third parameters.
The image rendered is exactly the same. When I turn off the optimization(-O0), the perfermance of two versions are the same. Once I turn on the optimaztion(-O1 or -O2 or -O3), the performance difference shows again.
I profiled this program and found something very strange. The increase of time costs of "vsoutput uninitialized" version does not take place in the function "GetTransformedVertex",not even near from it. The time increase is caused by some SSE intrinsics functions way after the "GetTransformedVertex" is called. I'm really confused...
FYI,I'm using Visual Studio 2013 Community.
Now I do know that this performance drop is caused by unitialized structure. But I don't know how. Does it implicitly turned off some compiler's optimization options?
If necessary, I will post my source code to my github for your reference.
Any opinions are appreciated! Thank you in advance.
Update: Enlighted by #KerrekSB, I did some more tests.
Call memset() with different values, the perfermance could be quite different!
1: With 0, fps 400+.
2: With 1,2,3,4,5.... fps 40~60.
Then I removed the memset() and explicitly implemented a ctor for Arti3DOutput. The ctor did nothing but set all floats in Varyings[] to one valid float-point value(eg. 0.0f,1.5f,100.0f....). Haha, 400+ fps.
Till now, it seems that the values/content in Arti3DVSOutput have a great effect on the perfermance.
Then I did some more tests to find out which piece of memory of Arti3DVSOutput does really matters. Here comes the code.
Arti3DVSOutput vs_output; // No explict default ctor in this version.
// Comment the following 12 lines of code one by one to find out which piece of unitialized memory really matters.
vs_output.Varyings[0] = 0.0f;
vs_output.Varyings[1] = 0.0f;
vs_output.Varyings[2] = 0.0f;
vs_output.Varyings[3] = 0.0f;
vs_output.Varyings[4] = 0.0f;
vs_output.Varyings[5] = 0.0f;
vs_output.Varyings[6] = 0.0f;
vs_output.Varyings[7] = 0.0f;
vs_output.Varyings[8] = 0.0f;
vs_output.Varyings[9] = 0.0f;
vs_output.Varyings[10] = 0.0f;
vs_output.Varyings[11] = 0.0f;
mRC.pfnVS(&vsinput, &mRC.globals, &vs_output);
Comment that 12 lines of code one by one and run the program.
The result is shown as follows:
comment line# FPS
0 420
1 420
2 420
3 420
4 200
5 420
6 280
7 195
8 197
9 200
10 200
11 420
0,1,2,3,5,11 420
4,6,7,8,9,10 60
It seems the 4th,6th,7th,8th,9th and the 10th elements of Varyings[] all make some contibutions to the perfermance drop.
I really got confused by what the compiler does behind my back. Is there some kind of value check the compiler has to do?
Solution:
I figured it out!
The source of the problem is that uninitialized or improperly initialized float point values are used as parameters by SSE intrinsics afterwards. Those invalid floats generate exceptions and slow down the SSE intrinsics greatly.