kc3-lang/angle/src/tests/gl_tests/AtomicCounterBufferTest.cpp

• Show log

  Commit

• Hash : c13ca2af
  Author :
  Date : 2019-07-17T15:46:29
  

  Vulkan: Allow more than one atomic counter buffer binding
  
  dEQP assumes there are more than one atomic counter buffers available.
  This is technically not a requirement by the standard, but nevertheless
  could be what applications expect as well.
  
  This change adds support for multiple atomic counter buffer bindings.
  This is done by declaring an array of storage buffers for the atomic
  counter buffers (instead of declaring only one) and passing the
  (binding, offset) pair around to functions instead of just the offset.
  The atomic counter is found by indexing `binding` into the storage
  buffer array first before indexing `offset` into its `uint[]`.
  
  ProgramVk's default uniform collection is also fixed not to include
  atomic counter uniforms.
  
  A remaining issue is that atomic counter buffer offsets don't have
  alignment requirements in GLES, but Vulkan does for storage buffers.
  Similar to emulated transform feedback buffer offsets, these should be
  sent to the shader through uniform values.  This will be done in a
  follow up change.
  
  Bug: angleproject:3566
  Change-Id: I5600225c24c38f1a8ecf5c64388073055733197d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1707931
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/tests/gl_tests/AtomicCounterBufferTest.cpp

• //
  // Copyright 2017 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // AtomicCounterBufferTest:
  //   Various tests related for atomic counter buffers.
  //
  
  #include "test_utils/ANGLETest.h"
  #include "test_utils/gl_raii.h"
  
  using namespace angle;
  
  namespace
  {
  
  class AtomicCounterBufferTest : public ANGLETest
  {
    protected:
      AtomicCounterBufferTest()
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
      }
  };
  
  // Test GL_ATOMIC_COUNTER_BUFFER is not supported with version lower than ES31.
  TEST_P(AtomicCounterBufferTest, AtomicCounterBufferBindings)
  {
      // Crashes in older drivers.  http://anglebug.com/3738
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsWindows() && IsAMD());
  
      ASSERT_EQ(3, getClientMajorVersion());
      GLBuffer atomicCounterBuffer;
      glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, atomicCounterBuffer.get());
      if (getClientMinorVersion() < 1)
      {
          EXPECT_GL_ERROR(GL_INVALID_ENUM);
      }
      else
      {
          EXPECT_GL_NO_ERROR();
      }
  }
  
  class AtomicCounterBufferTest31 : public AtomicCounterBufferTest
  {};
  
  // Linking should fail if counters in vertex shader exceed gl_MaxVertexAtomicCounters.
  TEST_P(AtomicCounterBufferTest31, ExceedMaxVertexAtomicCounters)
  {
      // Crashes in older drivers.  http://anglebug.com/3738
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsWindows() && IsAMD());
  
      constexpr char kVS[] =
          "#version 310 es\n"
          "layout(binding = 0) uniform atomic_uint foo[gl_MaxVertexAtomicCounters + 1];\n"
          "void main()\n"
          "{\n"
          "    atomicCounterIncrement(foo[0]);\n"
          "}\n";
      constexpr char kFS[] =
          "#version 310 es\n"
          "void main()\n"
          "{\n"
          "}\n";
  
      GLuint program = CompileProgram(kVS, kFS);
      EXPECT_EQ(0u, program);
  }
  
  // Counters matching across shader stages should fail if offsets aren't all specified.
  // GLSL ES Spec 3.10.4, section 9.2.1.
  TEST_P(AtomicCounterBufferTest31, OffsetNotAllSpecified)
  {
      // Crashes in older drivers.  http://anglebug.com/3738
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsWindows() && IsAMD());
  
      constexpr char kVS[] =
          "#version 310 es\n"
          "layout(binding = 0, offset = 4) uniform atomic_uint foo;\n"
          "void main()\n"
          "{\n"
          "    atomicCounterIncrement(foo);\n"
          "}\n";
      constexpr char kFS[] =
          "#version 310 es\n"
          "layout(binding = 0) uniform atomic_uint foo;\n"
          "void main()\n"
          "{\n"
          "}\n";
  
      GLuint program = CompileProgram(kVS, kFS);
      EXPECT_EQ(0u, program);
  }
  
  // Counters matching across shader stages should fail if offsets aren't all specified with same
  // value.
  TEST_P(AtomicCounterBufferTest31, OffsetNotAllSpecifiedWithSameValue)
  {
      // Crashes in older drivers.  http://anglebug.com/3738
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsWindows() && IsAMD());
  
      constexpr char kVS[] =
          "#version 310 es\n"
          "layout(binding = 0, offset = 4) uniform atomic_uint foo;\n"
          "void main()\n"
          "{\n"
          "    atomicCounterIncrement(foo);\n"
          "}\n";
      constexpr char kFS[] =
          "#version 310 es\n"
          "layout(binding = 0, offset = 8) uniform atomic_uint foo;\n"
          "void main()\n"
          "{\n"
          "}\n";
  
      GLuint program = CompileProgram(kVS, kFS);
      EXPECT_EQ(0u, program);
  }
  
  // Tests atomic counter reads using compute shaders. Used as a sanity check for the translator.
  TEST_P(AtomicCounterBufferTest31, AtomicCounterReadCompute)
  {
      // Crashes in older drivers.  http://anglebug.com/3738
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsWindows() && IsAMD());
  
      // Skipping due to a bug on the Qualcomm Vulkan Android driver.
      // http://anglebug.com/3726
      ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
  
      // Skipping due to a bug on the Adreno OpenGLES Android driver.
      // http://anglebug.com/2925
      ANGLE_SKIP_TEST_IF(IsAndroid() && IsAdreno() && IsOpenGLES());
  
      constexpr char kComputeShaderSource[] = R"(#version 310 es
  layout(local_size_x=1, local_size_y=1, local_size_z=1) in;
  
  void atomicCounterInFunction(in atomic_uint counter[3]);
  
  layout(binding = 0, offset = 8) uniform atomic_uint ac[3];
  
  void atomicCounterInFunction(in atomic_uint counter[3])
  {
      atomicCounter(counter[0]);
  }
  
  void main()
  {
      atomicCounterInFunction(ac);
      atomicCounter(ac[gl_LocalInvocationIndex + 1u]);
  })";
  
      ANGLE_GL_COMPUTE_PROGRAM(program, kComputeShaderSource);
      EXPECT_GL_NO_ERROR();
  }
  
  // Test atomic counter read.
  TEST_P(AtomicCounterBufferTest31, AtomicCounterRead)
  {
      // Crashes in older drivers.  http://anglebug.com/3738
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsWindows() && IsAMD());
  
      // Skipping due to a bug on the Qualcomm Vulkan Android driver.
      // http://anglebug.com/3726
      ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
  
      // Skipping test while we work on enabling atomic counter buffer support in th D3D renderer.
      // http://anglebug.com/1729
      ANGLE_SKIP_TEST_IF(IsD3D11());
  
      constexpr char kFS[] =
          "#version 310 es\n"
          "precision highp float;\n"
          "layout(binding = 0, offset = 4) uniform atomic_uint ac;\n"
          "out highp vec4 my_color;\n"
          "void main()\n"
          "{\n"
          "    my_color = vec4(0.0);\n"
          "    uint a1 = atomicCounter(ac);\n"
          "    if (a1 == 3u) my_color = vec4(1.0);\n"
          "}\n";
  
      ANGLE_GL_PROGRAM(program, essl31_shaders::vs::Simple(), kFS);
  
      glUseProgram(program.get());
  
      // The initial value of counter 'ac' is 3u.
      unsigned int bufferData[3] = {11u, 3u, 1u};
      GLBuffer atomicCounterBuffer;
      glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicCounterBuffer);
      glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(bufferData), bufferData, GL_STATIC_DRAW);
  
      glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, atomicCounterBuffer);
  
      drawQuad(program.get(), essl31_shaders::PositionAttrib(), 0.0f);
      ASSERT_GL_NO_ERROR();
      EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::white);
  }
  
  // Test atomic counter increment and decrement.
  TEST_P(AtomicCounterBufferTest31, AtomicCounterIncrementAndDecrement)
  {
      // Crashes in older drivers.  http://anglebug.com/3738
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsWindows() && IsAMD());
  
      // Skipping due to a bug on the Qualcomm Vulkan Android driver.
      // http://anglebug.com/3726
      ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
  
      constexpr char kCS[] =
          "#version 310 es\n"
          "layout(local_size_x=1, local_size_y=1, local_size_z=1) in;\n"
          "layout(binding = 0, offset = 4) uniform atomic_uint ac[2];\n"
          "void main()\n"
          "{\n"
          "    atomicCounterIncrement(ac[0]);\n"
          "    atomicCounterDecrement(ac[1]);\n"
          "}\n";
  
      ANGLE_GL_COMPUTE_PROGRAM(program, kCS);
  
      glUseProgram(program.get());
  
      // The initial value of 'ac[0]' is 3u, 'ac[1]' is 1u.
      unsigned int bufferData[3] = {11u, 3u, 1u};
      GLBuffer atomicCounterBuffer;
      glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicCounterBuffer);
      glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(bufferData), bufferData, GL_STATIC_DRAW);
  
      glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, atomicCounterBuffer);
  
      glDispatchCompute(1, 1, 1);
      EXPECT_GL_NO_ERROR();
  
      glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
  
      glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicCounterBuffer);
      void *mappedBuffer =
          glMapBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(GLuint) * 3, GL_MAP_READ_BIT);
      memcpy(bufferData, mappedBuffer, sizeof(bufferData));
      glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
  
      EXPECT_EQ(11u, bufferData[0]);
      EXPECT_EQ(4u, bufferData[1]);
      EXPECT_EQ(0u, bufferData[2]);
  }
  
  // Tests multiple atomic counter buffers.
  TEST_P(AtomicCounterBufferTest31, AtomicCounterMultipleBuffers)
  {
      // Crashes in older drivers.  http://anglebug.com/3738
      ANGLE_SKIP_TEST_IF(IsOpenGL() && IsWindows() && IsAMD());
  
      // Skipping due to a bug on the Qualcomm Vulkan Android driver.
      // http://anglebug.com/3726
      ANGLE_SKIP_TEST_IF(IsAndroid() && IsVulkan());
  
      GLint maxAtomicCounterBuffers = 0;
      glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, &maxAtomicCounterBuffers);
      constexpr unsigned int kBufferCount = 3;
      // ES 3.1 table 20.45 only guarantees 1 atomic counter buffer
      ANGLE_SKIP_TEST_IF(maxAtomicCounterBuffers < static_cast<int>(kBufferCount));
  
      constexpr char kComputeShaderSource[] = R"(#version 310 es
  layout(local_size_x=1, local_size_y=1, local_size_z=1) in;
  layout(binding = 0) uniform atomic_uint ac1;
  layout(binding = 1) uniform atomic_uint ac2;
  layout(binding = 2) uniform atomic_uint ac3;
  
  void main()
  {
      atomicCounterIncrement(ac1);
      atomicCounterIncrement(ac2);
      atomicCounterIncrement(ac3);
  })";
  
      ANGLE_GL_COMPUTE_PROGRAM(program, kComputeShaderSource);
  
      glUseProgram(program);
  
      GLBuffer atomicCounterBuffers[kBufferCount];
  
      for (unsigned int ii = 0; ii < kBufferCount; ++ii)
      {
          GLuint initialData[1] = {ii};
          glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicCounterBuffers[ii]);
          glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(initialData), initialData, GL_STATIC_DRAW);
  
          glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, ii, atomicCounterBuffers[ii]);
      }
  
      glDispatchCompute(1, 1, 1);
      EXPECT_GL_NO_ERROR();
  
      glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
  
      for (unsigned int ii = 0; ii < kBufferCount; ++ii)
      {
          glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicCounterBuffers[ii]);
          GLuint *mappedBuffer = static_cast<GLuint *>(
              glMapBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(GLuint), GL_MAP_READ_BIT));
          EXPECT_EQ(ii + 1, mappedBuffer[0]);
          glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
      }
  }
  
  ANGLE_INSTANTIATE_TEST(AtomicCounterBufferTest,
                         ES3_OPENGL(),
                         ES3_OPENGLES(),
                         ES31_OPENGL(),
                         ES31_OPENGLES(),
                         ES31_D3D11(),
                         ES31_VULKAN());
  ANGLE_INSTANTIATE_TEST(AtomicCounterBufferTest31,
                         ES31_OPENGL(),
                         ES31_OPENGLES(),
                         ES31_D3D11(),
                         ES31_VULKAN());
  
  }  // namespace
  

Download