tests/spec/intel_shader_atomic_float_minmax/execution/shared-atomicExchange-float.shader_test

   1 [require]
   2 GL >= 3.3
   3 GLSL >= 3.30
   4 GL_ARB_compute_shader
   5 GL_ARB_shader_atomic_counters
   6 GL_INTEL_shader_atomic_float_minmax
   7
   8 [compute shader]
   9 #version 330
  10 #extension GL_ARB_compute_shader: require
  11 #extension GL_ARB_shader_atomic_counters: require
  12 #extension GL_INTEL_shader_atomic_float_minmax: require
  13
  14 layout(local_size_x = 32) in;
  15
  16 shared float value;
  17 shared uint mask;
  18
  19 layout(binding = 0) uniform atomic_uint pass;
  20 layout(binding = 0) uniform atomic_uint fail;
  21
  22 void main()
  23 {
  24         if (gl_LocalInvocationIndex == 0u) {
  25                 /* Bootstrapping this with zero is unavoidable, but it
  26                  * also causes problems later.  Namely it means that
  27                  * bit 0 will get set twice and invocation 0 can see a
  28                  * zero value.  Note the explicit checks for bit != 0
  29                  * and gl_LocalInvocationIndex != 0 below.
  30                  */
  31                 value = 0.0;
  32                 mask = 0u;
  33         }
  34
  35         barrier();
  36
  37         float f = atomicExchange(value, .5 * float(gl_LocalInvocationIndex));
  38         uint i = uint(f * 2.);
  39         uint bit = i % 32u;
  40         uint m = 1u << bit;
  41
  42         if (i < 32u) {
  43                 /* If the bit was already set, the test fails. */
  44                 uint r = atomicOr(mask, m);
  45                 if (bit != 0u && (r & m) != 0u)
  46                         atomicCounterIncrement(fail);
  47
  48                 /* Invocation index 0 can read it's own index (due to
  49                  * bootstrapping with zero), but no other invocation should.
  50                  */
  51                 if (gl_LocalInvocationIndex != 0u &&
  52                     bit == gl_LocalInvocationIndex)
  53                         atomicCounterIncrement(fail);
  54         } else {
  55                 atomicCounterIncrement(fail);
  56         }
  57
  58         barrier();
  59
  60         if (gl_LocalInvocationIndex == 0u) {
  61                 uint i = uint(value * 2.);
  62                 uint bit = i % 32u;
  63                 uint m = 1u << bit;
  64
  65                 uint final = m | mask;
  66
  67                 /* If all 32 bits are set, the test passes. */
  68                 if (final == 0xffffffffu)
  69                         atomicCounterIncrement(pass);
  70         }
  71 }
  72
  73 [test]
  74 atomic counters 2
  75 compute 2 3 4
  76 probe atomic counter 0 == 24
  77 probe atomic counter 1 == 0