Execute fragment shader for visible pixels only - opengl

Question

I have a computation to be done for each pixel of output, and it uses some data passed from earlier steps in shader pipeline - so it makes most sense to execute this computation in the fragment shader. To see whether it's possible at all I started with the simplest example - just count pixels for each primitive. This requires only two shaders - vertex shader:
#version 430
in vec3 position;
void main() {{
gl_Position = vec4(position, 1);
}}
and fragment shader:
#version 430
layout(early_fragment_tests) in;
out vec4 out_color;
layout(std430, binding = 3) buffer out_data {
int data[];
};
void main() {{
atomicAdd(data[gl_PrimitiveID], 1);
out_color = vec4(1, gl_PrimitiveID, 0, 1);
}}
As you can see it just increments an element of shader storage buffer object.
Then I feed it with two triangles (6 points): [-1, -1, 0], [-1, 1, 0], [1, 1, 0], [-1, -1, 0], [1, -1, 0], [-1, 1, -1]. It correctly displays a red triangle and a green triangle, each of them taking exactly a half of the window, but the green triangle is on top - so there is only half of the red triangle visible (1/4 of window).
Of course I expected that the counts will be about 1/4 of window size for red triangle and about 1/2 for green one - but they are both equal to 1/2! Btw, if I set all input Z coordinates to zero, then red triangle is on top and green is half-hidden - in that case counts are correct.
While reading OpenGL docs (where I found the option early_fragment_tests) I understood that fragments discarded for any reason (e.g. depth test as in my case) don't affect atomic counters and SSBOs - see here. But as my example show, they clearly affect them! Is there anything else which can fix the issue?
If that's important, I ran it under linux using an intel skylake iGPU, OpenGL 4.3.

Answer 1

The order of processing fragments from separate triangles is largely undefined. Early fragment tests do not force the fragments of each triangle to be processed in rasterizer order. While OpenGL does mostly work under the "as-if" rule (ie: everything works "as-if" it were processed in order), the incoherent nature of Image Load/Store and SSBO memory accesses means that you cannot rely on in-order processing.
If you want to issue a batch of work and have the FS execute only once for each fragment, then you're going to have to do a depth pre-pass. First, you render the scene, but without an FS at all; this means that the only thing that gets written are depth values. Next, you render the scene as normal.
Between the two of those should be some form of synchronization that ensures that all triangles in the first pass have finished before the second pass starts. Unfortunately, OpenGL doesn't have a decent way to ask for that. You could use a fence sync object with glWaitSync, but that requires an explicit glFlush call, which isn't exactly cheap.