Is glDrawArraysInstanced in OpenGL parallel when drawing those instances?

Question

Is glDrawArraysInstanced in OpenGL parallel when drawing those instances?

I cannot figure out by referring to its reference and numerous online tutorials.

[Update] To be more clear, I mean, for example, we have 100 instances. Are the drawing of those 100 instances parallel? For example, we have the 100 commands "glDrawArrays(mode, first, count);"? Is execution of those 100 commands sequential or parallel?

I think it should be sequential. GPU begins to draw the second instance, only AFTER the first instance drawing finished.

Or glDrawArraysInstanced just save the time for "giving your GPU the commands"?

[Update 2] The reason I wanted to know the answer, is that: If it is sequential, personally I think drawing thousands of tree leaves in this way is time consuming. I may draw them in one shader program with some algorithm tweak.

Answer 1

According to the docs, glDrawArraysInstanced has the same effect as:

if ( mode or count is invalid )
    generate appropriate error
else {
    for (int i = 0; i < primcount ; i++) {
        instanceID = i;
        glDrawArrays(mode, first, count);
    }
    instanceID = 0;
}

So it's basically a for-loop... But we need to take a step back and ask the real question, does the GPU draw things in parallel ? Roughly speaking what happens is the following:

1. The CPU batches draw commands to the GPU command buffer.
2. GPU starts parsing the commands at the same time with the CPU.
3. GPU executes the draw calls by fetching vertices from buffers
4. Data is managed in blocks so it can be processed by vertex shaders.
5. Vertex shader is executed per vertex in parallel.

It's not only about draw calls executed together, they may be executed together if they use the same shader for example. But in the end it's about making the GPU stages as busy as possible. The GPU is parallel in nature but many factors come into play to decide if two calls will be executed in parallel.

[Edit] Regarding your update, it's possible that the GPU execute multiple render calls together and only perform what is needed to be sequential in a sequential manner. For instance nothing prevents executing the vertex shader for two draw calls in parallel and only do the blending in a sequential order.

Answer 2

After your comment... not as good an answer as concept3D's but perhaps more to the point of what you're trying to achieve in a sense.

The trade-off you face is between hardware instancing, which allows for repeated but independently moving parts of a complex geometry such as a tree, or static batching which will allow massive vertex counts without necessarily repeating geometry, but which won't allow independently moving parts in a single batch (not without re-uploading the entire, massive batch).