Why is std::vector so much slower then array pointer [closed] - c++

Question

Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.
This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.
Closed 4 years ago.
Improve this question
Im creating a Opengl font batch draw.
I want to know why my std::vector is so much slower then using a array pointer.
I have tried adding vector reserve and everything i can think of.
My FPS drops just over half when using vectors.
Vectors seem easier to manage and look nicer in code, but im really stuck on this.
Not sure if its something simple that i have missed?
Or is it better to just use array pointers?
#ifdef USE_VECTORS
std::vector<Vertex> m_vertices;
#else
Vertex *m_pVertex;
Vertex m_vertices[MAX_VERTICES];
#endif
drawing char function
void GLFont::drawChar(char c, int x, int y)
{
// 1------4
// | | 1 = (x, y)
// | | 2 = (x, y + charHeight)
// | | 3 = (x + charWidth, y + charHeight)
// | | 4 = (x + charWidth, y)
// | |
// | |
// 2------3
//
const Glyph &glyph = getChar(c);
int charWidth = glyph.width;
int charHeight = m_charHeight;
#ifdef USE_VECTORS
Vertex vert[] = {
x, y,
glyph.upperLeft[0], glyph.upperLeft[1],
m_color[0], m_color[1], m_color[2], m_color[3],
x, y + charHeight,
glyph.lowerLeft[0], glyph.lowerLeft[1],
m_color[0], m_color[1], m_color[2], m_color[3],
x + charWidth, y + charHeight,
glyph.lowerRight[0], glyph.lowerRight[1],
m_color[0], m_color[1], m_color[2], m_color[3],
x + charWidth, y,
glyph.upperRight[0], glyph.upperRight[1],
m_color[0], m_color[1], m_color[2], m_color[3]
};
//unsigned dataArraySize = sizeof(vert) / sizeof(Vertex);
m_vertices.insert(m_vertices.end(), &vert[0], &vert[4]);
++m_numCharsToDraw;
#else
//1
m_pVertex->x = x;
m_pVertex->y = y;
m_pVertex->s = glyph.upperLeft[0];
m_pVertex->t = glyph.upperLeft[1];
m_pVertex->r = m_color[0];
m_pVertex->g = m_color[1];
m_pVertex->b = m_color[2];
m_pVertex->a = m_color[3];
++m_pVertex;
// 2
m_pVertex->x = x;
m_pVertex->y = y + charHeight;
m_pVertex->s = glyph.lowerLeft[0];
m_pVertex->t = glyph.lowerLeft[1];
m_pVertex->r = m_color[0];
m_pVertex->g = m_color[1];
m_pVertex->b = m_color[2];
m_pVertex->a = m_color[3];
++m_pVertex;
// 3
m_pVertex->x = x + charWidth;
m_pVertex->y = y + charHeight;
m_pVertex->s = glyph.lowerRight[0];
m_pVertex->t = glyph.lowerRight[1];
m_pVertex->r = m_color[0];
m_pVertex->g = m_color[1];
m_pVertex->b = m_color[2];
m_pVertex->a = m_color[3];
++m_pVertex;
// 4
m_pVertex->x = x + charWidth;
m_pVertex->y = y;
m_pVertex->s = glyph.upperRight[0];
m_pVertex->t = glyph.upperRight[1];
m_pVertex->r = m_color[0];
m_pVertex->g = m_color[1];
m_pVertex->b = m_color[2];
m_pVertex->a = m_color[3];
++m_pVertex;
if (++m_numCharsToDraw == MAX_CHARS_PER_BATCH)
{
drawTextEnd();
drawBatchOfChars();
drawTextBegin();
}
#endif
}
void GLFont::drawBatchOfChars()
{
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
#ifdef USE_VECTORS
glVertexPointer(2, GL_INT, sizeof(Vertex), &m_vertices[0].x);
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), &m_vertices[0].s);
glColorPointer(4, GL_FLOAT, sizeof(Vertex), &m_vertices[0].r);
#else
glVertexPointer(2, GL_INT, sizeof(Vertex), &m_vertices->x);
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), &m_vertices->s);
glColorPointer(4, GL_FLOAT, sizeof(Vertex), &m_vertices->r);
#endif
glDrawArrays(GL_QUADS, 0, m_numCharsToDraw * 4);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}

Answer 1

You are comparing apples to oranges:
Containers contain pointers themselves, reducing locality of data.
Containers need to reallocate storage when changing size.
Microsoft's Visual Studio enables additional diagnostics in their standardlibrary containers. For example, accessing via vec[123] causes undefined behaviour per standard if the index is out of range. This allows implementing this as simple indexing via the pointer to the array's payload. With additional diagnostics, the index is validated, which is just a small comparison and a branch, but in tight loops it makes a difference.
That said, your approach to prove something is flawed. You'd first have to implement equivalent code that is reduced as far as possible (in the spirit of an MCVE). Hooking an OpenGL backend onto it isn't going to make things reproducible.

Answer 2

The main reason for you to see a large performance difference is Debug mode.
In Debug mode MSVC by default inlines nothing, does not store any variable in registers and always allocates and validates a stack frame, no name a few.
The extra abstractions when using a vector in Debug mode directly translate to more work for the CPU.