Synchronizing successive OpenGL Compute Shader invocations

Question

I have a couple of compute shaders that need to be executed in a certain order and whose outputs depend on previous inputs. Ideally, I'll never need to copy a buffer client-side and do all of my work on the GPU.

Consider I have two compute shaders compiled and linked as program_one and program_two. Suppose I also have a GL_SHADER_STORAGE_BUFFER that contains the data that is written to by program_one and read by program_two. Can I simply do the following:

glUseProgram(program_one);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, buffer);
glDispatchCompute(16, 16, 1);

glUseProgram(program_two);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, buffer);
glDispatchCompute(16, 16, 1);

Is it guaranteed that all invocations of the first compute shader will finish before any invocations of the second (to avoid data races between reading and writing buffer)? If not, how do I synchronize them?

Answer 1

No it is not guaranteed, since the OpenGL specification allows that two Compute Shader run concurrently or even in different order.

You need to call glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT) before the second glDispatchCompute to ensure visibility of the writes from program_one.

---

From the OpenGL.org wiki article on the memory model:

[...] invocations between stages may be executed in any order. This includes invocations launched by different rendering commands. While it is perhaps unlikely that two vertex shaders from different rendering operations could be running at the same time, it is also possible, so OpenGL provides no guarantees.

From the Opengl.org wiki article on Shader Storage Buffer:

SSBOs reads and writes use incoherent memory accesses, so they need the appropriate barriers, just as Image Load Store operations.