In glBindImageTexture()
, access
can be GL_READ_ONLY
, GL_WRITE_ONLY
, or GL_READ_WRITE
.
I assume that these should match the readonly
and writeonly
qualifiers on image units (eg. image2D
or imageBuffer
) in GLSL.
I haven't noticed any difference when setting readonly or writeonly (2013, NVIDIA 319.49 drivers). Granted, I might not be doing anything that would otherwise cause a slowdown and hence don't see any improvement. These qualifiers may also simply be ignored by current GL implementations.
- In what cases could a GL implementation make use of readonly/writeonly, why do they exist?
Cache coherency comes to mind, but don't the coherent
/volatile
qualifiers cover this already? I've used these and they appear to work.
- Has anyone experienced a difference in performance or results when using readonly/writeonly, how important are they?
Don't be afraid to reply if it's been years, I'm interested to know and I'm sure others are too.
See, the thing is there is no actual enforcement of these access policies. OpenGL intentionally leaves the behavior of writing to a read-only image undefined for reasons that will be explained below. Among other things, this allows a lot of flexibility on the end of the implementation to use the read-only attribute for a number of different optimization strategies (think of it more like a hint than a strict rule). Because the behavior is undefined, you are right, they could be ignored by the implementation, but should not be ignored by the application developer. Invoking undefined behavior is a ticking time bomb.
To that end, there exists no mechanism in GLSL (or shaders in general) to emit an error when you try to store something in a read-only image, making enforcing this policy significantly more difficult. The best you could hope for is some kind of static analysis at compile-time that is later verified against the access policies of the bound image texture at runtime. That is not to say it may not happen in the future, but at present no such feature exists. The only thing that GLSL provides is a compile-time guarantee that
readonly
variables cannot be used in conjunction withimageStore (...)
in the shader. In short, the GLSL qualifier is enforced at compile-time, but the access policy of the bound image is not at run-time.The fact that you are not seeing any performance improvement is not surprising. This is a pretty new feature, you will have to give it years before drivers do anything profound with the access policy. It does not hurt anything to provide the hint, so long as you yourself do not violate it.