Efficiency of multple glDrawElements commands

[letslearn]

Let's say I have a buffer object with vertex data on the GPU. And I also have a buffer object with indices on the GPU, in preparation for use of glDrawElements.

Let's also say the geometry I am working with very precisely defined and simple enough so that I can do this kind of thing:

Multiple calls to glDrawElements, using different modes of primitive generation (GL_QUAD_STRIP, then GL_TRIANGLES).

Doing this will allow me to use a smaller buffer object for the indices. But is there a performance penalty for sending multiple commands rather than just one?

[mhagain]

A single call with GL_TRIANGLES will always be better. Don't worry about memory usage and buffer sizes (at least not in this context) - they're not as important as you might think.

[thokra]

But is there a performance penalty for sending multiple commands rather than just one?

Depends on the number of calls. Multiple can mean 10, 100 or a fews thousand and so on. If the general number of batches is low enough, you don't need to bother reducing draw calls since your app will most likely not be CPU limited anyway. This means that even if you condense all calls into a single call, you will probably get nothing out of it performance wise since your bottleneck is somewhere else.

As with any optimization in programming: first profile your app, then change the parts of your code which you figure are reducing performance, then profile and see if anything changed.

[mhagain]

Most of the performance impact is not going to come from multiple calls, but from switching your primitive type, switching between indexed and non-indexed modes, and doing triangle setup. Any type of primitive needs to be converted to triangles for the GPU to process it, and - obviously - GL_TRIANGLES have the win here because they're already triangles.

Just using GL_TRIANGLES will give you much much simpler code too, with a single path for everything. That means less bugs, more maintainability and easier to expand/enhance in the future. A miniscule bit of extra index bandwidth is a small enough price to pay for that alone.

I would encourage you to set up both a multi-type version and a GL_TRIANGLES-only version, add a switch to toggle at runtime, and do a performance comparison.

[Alfonse Reinheart]

Most of the performance impact is not going to come from multiple calls, but from switching your primitive type, switching between indexed and non-indexed modes, and doing triangle setup.

Do you have some evidence that issuing multiple draw calls for different primitive types actually impacts performance compared to using the same primitive type? Or are you just speculating?

Because I seriously doubt that any of what you said is true.

Any type of primitive needs to be converted to triangles for the GPU to process it, and - obviously - GL_TRIANGLES have the win here because they're already triangles.

... what? It costs nothing to render with GL_TRIANGLE_STRIP in terms of what the hardware has to do. You can make a case for using TRIANGLES based on indexing and building post-T&L buffer optimized lists. But just in terms of the basic effort the hardware has to do, they're equivalent.

Just using GL_TRIANGLES will give you much much simpler code too, with a single path for everything.

By "single path", you mean "not having to read from a variable and pass it to glDrawElements". Somehow, I don't think that's a major performance bottleneck.

[aqnuep]

Most of the performance impact is not going to come from multiple calls, but from switching your primitive type, switching between indexed and non-indexed modes, and doing triangle setup.

Switching your primitive type should not involve any performance hit, neither should changing between indexed and non-indexed modes. Actually the only reason you should stick with a single setup if you would like to submit all your draw calls in a single MultiDraw* command which can actually be faster.

Any type of primitive needs to be converted to triangles for the GPU to process it, and - obviously - GL_TRIANGLES have the win here because they're already triangles.

GL_POINTS, GL_LINES, GL_TRIANGLES and GL_TRIANGLE_STRIP are native on all GPUs that I'm aware of, however, you should probably avoid the other ones.

[mhagain]

Do you have some evidence that issuing multiple draw calls for different primitive types actually impacts performance compared to using the same primitive type? Or are you just speculating?

Benchmarking. I suggest you try it before going off on a rant. Go on.