Question

在过去的几个小时里，我一直在尝试追踪程序中的错误，这只会在发布模式下运行时出现。我已经解决了所有4级编译器警告，并且没有任何未初始化的变量（在这种情况下，这通常是我的第一个嫌疑人）。

这是一个很难解释的问题，因为我甚至都不知道到底发生了什么，所以请耐心等待。

经过大量的调试后，我已将错误的原因缩小到以下函数中的某个位置：

void CModelSubMesh::Update()
{
    ModelSubMesh::Update();

    auto bHasAlphas = (GetAlphaCount() > 0) ? true : false;
    auto bAnimated = (!m_vertexWeights.empty() || !m_weightBoneIDs.empty()) ? true : false;
    if(bHasAlphas == false && bAnimated == false)
        m_glMeshData = std::make_unique<GLMeshData>(m_vertices,m_normals,m_uvs,m_triangles);
    else
    {
        m_glmesh = GLMesh();
        auto bufVertex = OpenGL::GenerateBuffer();
        auto bufUV = OpenGL::GenerateBuffer();
        auto bufNormal = OpenGL::GenerateBuffer();
        auto bufIndices = OpenGL::GenerateBuffer();
        auto bufAlphas = 0;
        if(bHasAlphas == true)
            bufAlphas = OpenGL::GenerateBuffer();

        auto vao = OpenGL::GenerateVertexArray();

        m_glmesh.SetVertexArrayObject(vao);
        m_glmesh.SetVertexBuffer(bufVertex);
        m_glmesh.SetUVBuffer(bufUV);
        m_glmesh.SetNormalBuffer(bufNormal);
        if(bHasAlphas == true)
            m_glmesh.SetAlphaBuffer(bufAlphas);
        m_glmesh.SetIndexBuffer(bufIndices);
        m_glmesh.SetVertexCount(CUInt32(m_vertices.size()));
        auto numTriangles = CUInt32(m_triangles.size()); // CUInt32 is equivalent to static_cast<unsigned int>
        m_glmesh.SetTriangleCount(numTriangles);
        // PLACEHOLDER LINE

        OpenGL::BindVertexArray(vao);

        OpenGL::BindBuffer(bufVertex,GL_ARRAY_BUFFER);
        OpenGL::BindBufferData(CInt32(m_vertices.size()) *sizeof(glm::vec3),&m_vertices[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);

        OpenGL::EnableVertexAttribArray(SHADER_VERTEX_BUFFER_LOCATION);
        OpenGL::SetVertexAttribData(
            SHADER_VERTEX_BUFFER_LOCATION,
            3,
            GL_FLOAT,
            GL_FALSE,
            (void*)0
        );

        OpenGL::BindBuffer(bufUV,GL_ARRAY_BUFFER);
        OpenGL::BindBufferData(CInt32(m_uvs.size()) *sizeof(glm::vec2),&m_uvs[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);

        OpenGL::EnableVertexAttribArray(SHADER_UV_BUFFER_LOCATION);
        OpenGL::SetVertexAttribData(
            SHADER_UV_BUFFER_LOCATION,
            2,
            GL_FLOAT,
            GL_FALSE,
            (void*)0
        );

        OpenGL::BindBuffer(bufNormal,GL_ARRAY_BUFFER);
        OpenGL::BindBufferData(CInt32(m_normals.size()) *sizeof(glm::vec3),&m_normals[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);

        OpenGL::EnableVertexAttribArray(SHADER_NORMAL_BUFFER_LOCATION);
        OpenGL::SetVertexAttribData(
            SHADER_NORMAL_BUFFER_LOCATION,
            3,
            GL_FLOAT,
            GL_FALSE,
            (void*)0
        );

        if(!m_vertexWeights.empty())
        {
            m_bufVertWeights.bufWeights = OpenGL::GenerateBuffer();
            OpenGL::BindBuffer(m_bufVertWeights.bufWeights,GL_ARRAY_BUFFER);
            OpenGL::BindBufferData(CInt32(m_vertexWeights.size()) *sizeof(float),&m_vertexWeights[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);

            OpenGL::EnableVertexAttribArray(SHADER_BONE_WEIGHT_LOCATION);
            OpenGL::BindBuffer(m_bufVertWeights.bufWeights,GL_ARRAY_BUFFER);
            OpenGL::SetVertexAttribData(
                SHADER_BONE_WEIGHT_LOCATION,
                4,
                GL_FLOAT,
                GL_FALSE,
                (void*)0
            );
        }
        if(!m_weightBoneIDs.empty())
        {
            m_bufVertWeights.bufBoneIDs = OpenGL::GenerateBuffer();
            OpenGL::BindBuffer(m_bufVertWeights.bufBoneIDs,GL_ARRAY_BUFFER);
            OpenGL::BindBufferData(CInt32(m_weightBoneIDs.size()) *sizeof(int),&m_weightBoneIDs[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);

            OpenGL::EnableVertexAttribArray(SHADER_BONE_WEIGHT_ID_LOCATION);
            OpenGL::BindBuffer(m_bufVertWeights.bufBoneIDs,GL_ARRAY_BUFFER);
            glVertexAttribIPointer(
                SHADER_BONE_WEIGHT_ID_LOCATION,
                4,
                GL_INT,
                0,
                (void*)0
            );
        }

        if(bHasAlphas == true)
        {
            OpenGL::BindBuffer(bufAlphas,GL_ARRAY_BUFFER);
            OpenGL::BindBufferData(CInt32(m_alphas.size()) *sizeof(glm::vec2),&m_alphas[0],GL_STATIC_DRAW,GL_ARRAY_BUFFER);

            OpenGL::EnableVertexAttribArray(SHADER_USER_BUFFER1_LOCATION);
            OpenGL::SetVertexAttribData(
                SHADER_USER_BUFFER1_LOCATION,
                2,
                GL_FLOAT,
                GL_FALSE,
                (void*)0
            );
        }
        OpenGL::BindBuffer(bufIndices,GL_ELEMENT_ARRAY_BUFFER);
        OpenGL::BindBufferData(numTriangles *sizeof(unsigned int),&m_triangles[0],GL_STATIC_DRAW,GL_ELEMENT_ARRAY_BUFFER);

        OpenGL::BindVertexArray(0);
        OpenGL::BindBuffer(0,GL_ARRAY_BUFFER);
        OpenGL::BindBuffer(0,GL_ELEMENT_ARRAY_BUFFER);

    }
    ComputeTangentBasis(m_vertices,m_uvs,m_normals,m_triangles);
}

我的程序是一个图形应用程序，这段代码生成了稍后渲染所需的对象缓冲区。该错误基本上导致在满足某些条件时不正确地呈现特定网格的顶点。该错误是一致的，每次都发生在相同的网格上。

可悲的是，我无法进一步缩小代码范围，因为这会使错误消失，并解释每条线路的作用需要相当长的时间，并且在这里并不太重要。我几乎肯定这是编译器优化的一个问题，所以在这种情况下，实际的错误更多的是副作用。

使用上面的代码，会发生错误，但只有在发布模式下才会发生。有趣的部分是我标记为＆＃34; PLACEHOLDER LINE＆＃34;。

的行

如果我将代码更改为以下3种变体之一，则该错误将消失：

＃1 ：

void CModelSubMesh::Update()
{
    [...]
    // PLACEHOLDER LINE
    std::cout<<numTriangles<<std::endl;
    [...]
}

＃2 ：

#pragma optimize( "", off )
void CModelSubMesh::Update()
{
    [...] // No changes to the code
}
#pragma optimize( "", on )

＃3 ：

static void test()
{
    auto *f = new float; // Do something to make sure the compiler doesn't optimize this function away; Doesn't matter what
    delete f;
}
void CModelSubMesh::Update()
{
    [...]
    // PLACEHOLDER LINE
    test()
    [...]
}

特别是变体＃2 表示正在优化的内容不应该是。

我不希望任何人神奇地知道问题的根源是什么，因为这需要更深入的代码知识。但是，也许对编译器优化过程有更好理解的人可以给我一些提示，可以在这里发生什么？

由于几乎所有对代码的更改都摆脱了错误，我只是不确定我能做些什么才能真正找到它的原因。

Answer 1

大多数情况下，当我遇到一些在调试中工作而不是在发布时，它是一个未初始化的变量。大多数编译器在调试版本中将变量初始化为0x00，但是在启用优化时会丢失它。

这可以解释为什么修改程序会改变行为：通过调整应用程序的内存映射，最终得到一些随机不同的未初始化内存块，以某种方式掩盖了问题。

如果您保持良好的记忆管理卫生，您可能会使用valgrind等工具快速找到问题。从长远来看，您可能需要考虑利用自动检测内存滥用的内存管理框架（请参阅Ogre MemoryTracker，TCMalloc，Clang Memory Sanitizer）。

编译器优化打破了代码

1 个答案: