GLSL, semaphores?

by

Basically, you’re just implementing a spinlock. Only instead of one lock variable, you have an entire texture’s worth of locks.

Logically, what you’re doing makes sense. But as far as OpenGL is concerned, this won’t actually work.

See, the OpenGL shader execution model states that invocations execute in an order which is largely undefined relative to one another. But spinlocks only work if there is a guarantee of forward progress among the various threads. Basically, spinlocks require that the thread which is spinning not be able to starve the execution system from executing the thread that it is waiting on.

OpenGL provides no such guarantee. Which means that it is entirely possible for one thread to lock a pixel, then stop executing (for whatever reason), while another thread comes along and blocks on that pixel. The blocked thread never stops executing, and the thread that owns the lock never restarts execution.

How might this happen in a real system? Well, let’s say you have a fragment shader invocation group executing on some fragments from a triangle. They all lock their pixels. But then they diverge in execution due to a conditional branch within the locking region. Divergence of execution can mean that some of those invocations get transferred to a different execution unit. If there are none available at the moment, then they effectively pause until one becomes available.

Now, let’s say that some other fragment shader invocation group comes along and gets assigned an execution unit before the divergent group. If that group tries to spinlock on pixels from the divergent group, it is essentially starving the divergent group of execution time, waiting on an event that will never happen.

Now obviously, in real GPUs there is more than one execution unit, but you can imagine that with lots of invocation groups out there, it is entirely possible for such a scenario to occasionally jam up the works.

More Related Contents:

  1. Should I ever use a `vec3` inside of a uniform buffer or shader storage buffer object?
  2. How to render depth linearly in modern OpenGL with gl_FragCoord.z in fragment shader?
  3. Why transform normals with the transpose of the inverse of the modelview matrix?
  4. How to implement 2D raycasting light effect in GLSL
  5. Do conditional statements slow down shaders?
  6. GLSL fixed function fragment program replacement
  7. Passing a list of values to fragment shader
  8. In a fragment shader, why can’t I use a flat input integer to index a uniform array of sampler2D?
  9. What is state-of-the-art for text rendering in OpenGL as of version 4.1? [closed]
  10. How to debug a GLSL shader?
  11. Why does GL divide `gl_Position` by W for you rather than letting you do it yourself?
  12. How to use Pivot Point in Transformations
  13. glLineStipple deprecated in OpenGL 3.1
  14. How to Using the #include in glsl support ARB_shading_language_include
  15. From RGB to HSV in OpenGL GLSL
  16. How do you get the modelview and projection matrices in OpenGL?
  17. Multiple textures in GLSL – only one works
  18. GLSL – Using custom output attribute instead of gl_Position
  19. Frequency of shader invocations in rendering commands
  20. how openGL handles data service like socket service or http service? [closed]
  21. How does OpenGL work at the lowest level? [closed]
  22. What does “immediate mode” mean in OpenGL?
  23. Is OpenGL coordinate system left-handed or right-handed?
  24. Render OpenGL scene to texture using FBO in fixed function pipeline drawing
  25. What exactly are eye space coordinates?
  26. Failing to map a simple unsigned byte rgb texture to a quad:
  27. Initializing OpenGL without GLUT
  28. How to cast int to const GLvoid*?
  29. glVertexAttribPointer clarification
  30. What are shaders in OpenGL and what do we need them for? [closed]

Leave a Comment