Why is this code running over 100 times slower in Debug mode than Release?

Question

Reason for re-posting:

Originally I got only one reply, that only pointed out that the title was exaggerated. Hence trying again, maybe more people will see this question this time as I really do not know where else to look... I will make sure to delete the original question to avoid duplication, and keep this new one instead. I'm not trying to spam the forum.

Feel free to remove the text above upon editing, I just wanted to explain why I'm re-posting - but it's not really a part of the question.

So, the original question was:

I have a few functions in my program that run extremely slow in Debug mode, in Visual Studio Community, 2015. They are functions to "index" the verts of 3D models.

Normally, I'm prepared for Debug mode to be a little slower, maybe 2 -3 times slower. But...

In Release mode, the program starts and indexes the models in about 2 - 3 seconds. Perfect.

In Debug mode however, it takes over 7 MINUTES for my program to actually respond, to start rendering and take input. It is stuck indexing one model for over seven minutes. During this time the program is completely froze.

The same model loads and indexes in "Release" mode in less than 3 seconds. How is it possible that it takes so unbelievably long in Debug?

Both Debug & Release modes are the standard out of the box modes. I don't recall changing any of the settings in either of them.

Here's the code that's slowing the program down in Debug mode:

// Main Indexer Function
void indexVBO_TBN(
std::vector<glm::vec3> &in_vertices,
std::vector<glm::vec2> &in_uvs,
std::vector<glm::vec3> &in_normals,
std::vector<glm::vec3> &in_tangents,
std::vector<glm::vec3> &in_bitangents,

std::vector<unsigned short> & out_indices,
std::vector<glm::vec3> &out_vertices,
std::vector<glm::vec2> &out_uvs,
std::vector<glm::vec3> &out_normals,
std::vector<glm::vec3> &out_tangents,
std::vector<glm::vec3> &out_bitangents){

int count = 0;

// For each input vertex
for (unsigned int i = 0; i < in_vertices.size(); i++) {

    // Try to find a similar vertex in out_vertices, out_uvs, out_normals, out_tangents & out_bitangents
    unsigned int index;
    bool found = getSimilarVertexIndex(in_vertices[i], in_uvs[i], in_normals[i], out_vertices, out_uvs, out_normals, index);

    if (found) {
        // A similar vertex is already in the VBO, use it instead !
        out_indices.push_back(unsigned short(index));

        // Average the tangents and the bitangents
        out_tangents[index] += in_tangents[i];
        out_bitangents[index] += in_bitangents[i];
    } else {
        // If not, it needs to be added in the output data.
        out_vertices.push_back(in_vertices[i]);
        out_uvs.push_back(in_uvs[i]);
        out_normals.push_back(in_normals[i]);
        out_tangents.push_back(in_tangents[i]);
        out_bitangents.push_back(in_bitangents[i]);
        out_indices.push_back((unsigned short)out_vertices.size() - 1);
    }
    count++;
}
}

And then the 2 little "helper" functions it uses (isNear() and getSimilarVertexIndex()):

// Returns true if v1 can be considered equal to v2
bool is_near(float v1, float v2){
return fabs( v1-v2 ) < 0.01f;
}


bool getSimilarVertexIndex( glm::vec3 &in_vertex, glm::vec2 &in_uv, glm::vec3 &in_normal,
                        std::vector<glm::vec3> &out_vertices, std::vector<glm::vec2> &out_uvs, std::vector<glm::vec3> &out_normals,
                        unsigned int &result){
// Lame linear search
for (unsigned int i = 0; i < out_vertices.size(); i++) {

    if (is_near(in_vertex.x, out_vertices[i].x) &&
        is_near(in_vertex.y, out_vertices[i].y) &&
        is_near(in_vertex.z, out_vertices[i].z) &&
        is_near(in_uv.x, out_uvs[i].x) &&
        is_near(in_uv.y, out_uvs[i].y) &&
        is_near(in_normal.x, out_normals[i].x) &&
        is_near(in_normal.y, out_normals[i].y) &&
        is_near(in_normal.z, out_normals[i].z)
        ) {
        result = i;
        return true;
    }
}
return false;
}

All credit for the functions above goes to: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-9-vbo-indexing/

Could this be a:

1. Visual Studio Community 2015 issue?
2. VSC15 Debug Mode issue?
3. Slow Code? (But it's only slow in Debug?!)

Answer 1

There are multiple things that will/might be optimized:

1. iterating a vector with indices [] is slower than using iterators; in debug, this certainly is not optimized away but in release it might
2. additionally, accessing a vector via [] is slow because of runtime checks and debugging features when being in debug mode; this can be fairly easily seen when you go to the implementation of operator[]
3. push_back and size might also have some additional checks than fall away when using release mode

So, my main guess would be that you use [] too much. It might be even faster in release when you change the iteration by means of using real iterators. So, instead of:

for (unsigned int i = 0; i < in_vertices.size(); i++) {

use:

for(auto& vertex : in_vertices)

This indirectly uses iterators. You could also explicitly write:

   for(auto vertexIt = in_vertices.begin(); vertexIt != in_vertices.end(); ++vertexIt)
   {
      auto& vertex = *vertexIt;

Obviously, this is longer code that seems less readable and has no practical advantage, unless you need the iterator for some other functions.