Implement GL_CHROMIUM_sync_query for D3D9 and D3D11.

extensions/CHROMIUM_sync_query.txt

+Name
+
+    CHROMIUM_sync_query
+
+Name Strings
+
+    GL_CHROMIUM_sync_query
+
+Version
+
+    Last Modifed Date: April 15, 2014
+
+Dependencies
+
+    OpenGL ES 2.0 is required.
+
+    EXT_occlusion_query_boolean is required.
+
+Overview
+
+    This extension provides a query mechanism that allow for synchronization
+    between the host CPU and the GPU, which may be accessing the same
+    resources (typically memory).
+
+    This extension is useful in conjunction with CHROMIUM_map_image to
+    determine when it is safe to access a mapped image. Once the result of
+    a COMMANDS_COMPLETED_CHROMIUM query is available, all drawing commands
+    issued before the query must have finished. This ensures that the memory
+    corresponding to the issued commands can be safely modified (assuming no
+    other outstanding drawing commands are issued subsequent to the query).
+
+New Procedures and Functions
+
+    None.
+
+Errors
+
+    None.
+
+New Tokens
+
+    Accepted by the <target> parameter of BeginQueryEXT, EndQueryEXT,
+    and GetQueryivEXT:
+
+        COMMANDS_COMPLETED_CHROMIUM                     0x84F7
+
+New State
+
+    None.
+
+Revision History
+
+    4/15/2014   Documented the extension

include/GLES2/gl2ext.h

@@ -1009,6 +1009,11 @@ GL_APICALL void GL_APIENTRY glGetSyncivAPPLE (GLsync sync, GLenum pname, GLsizei
 #define GL_ARM_shader_framebuffer_fetch_depth_stencil 1
 #endif /* GL_ARM_shader_framebuffer_fetch_depth_stencil */
 
+#ifndef GL_CHROMIUM_sync_query
+#define GL_CHROMIUM_sync_query 1
+#define GL_COMMANDS_COMPLETED_CHROMIUM    0x84F7
+#endif  /* GL_CHROMIUM_sync_query */
+
 #ifndef GL_DMP_program_binary
 #define GL_DMP_program_binary 1
 #define GL_SMAPHS30_PROGRAM_BINARY_DMP    0x9251

src/libANGLE/Caps.cpp

@@ -159,6 +159,7 @@ Extensions::Extensions()
       noError(false),
       lossyETCDecode(false),
       bindUniformLocation(false),
+      syncQuery(false),
       colorBufferFloat(false)
 {
 }
@@ -232,6 +233,7 @@ std::vector<std::string> Extensions::getStrings() const
 
     InsertExtensionString("GL_ANGLE_lossy_etc_decode",           lossyETCDecode,            &extensionStrings);
     InsertExtensionString("GL_CHROMIUM_bind_uniform_location",   bindUniformLocation,       &extensionStrings);
+    InsertExtensionString("GL_CHROMIUM_sync_query",              syncQuery,                 &extensionStrings);
     // clang-format on
 
     return extensionStrings;

src/libANGLE/Caps.h

@@ -284,6 +284,9 @@ struct Extensions
     // GL_CHROMIUM_bind_uniform_location
     bool bindUniformLocation;
 
+    // GL_CHROMIUM_sync_query
+    bool syncQuery;
+
     // ES3 Extension support
 
     // GL_EXT_color_buffer_float

src/libANGLE/State.cpp

@@ -159,6 +159,7 @@ void State::initialize(const Caps &caps,
     mActiveQueries[GL_ANY_SAMPLES_PASSED_CONSERVATIVE].set(nullptr);
     mActiveQueries[GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN].set(nullptr);
     mActiveQueries[GL_TIME_ELAPSED_EXT].set(nullptr);
+    mActiveQueries[GL_COMMANDS_COMPLETED_CHROMIUM].set(nullptr);
 
     mProgram = nullptr;
 

src/libANGLE/renderer/d3d/d3d11/Query11.cpp

@@ -33,6 +33,9 @@ GLuint64 MergeQueryResults(GLenum type, GLuint64 currentResult, GLuint64 newResu
         case GL_TIMESTAMP_EXT:
             return newResult;
 
+        case GL_COMMANDS_COMPLETED_CHROMIUM:
+            return newResult;
+
         default:
             UNREACHABLE();
             return 0;
@@ -142,9 +145,10 @@ gl::Error Query11::pause()
     if (mActiveQuery->query != nullptr)
     {
         ID3D11DeviceContext *context = mRenderer->getDeviceContext();
+        GLenum queryType             = getType();
 
         // If we are doing time elapsed query the end timestamp
-        if (getType() == GL_TIME_ELAPSED_EXT)
+        if (queryType == GL_TIME_ELAPSED_EXT)
         {
             context->End(mActiveQuery->endTimestamp);
         }
@@ -168,8 +172,11 @@ gl::Error Query11::resume()
             return error;
         }
 
+        GLenum queryType         = getType();
+        D3D11_QUERY d3dQueryType = gl_d3d11::ConvertQueryType(queryType);
+
         D3D11_QUERY_DESC queryDesc;
-        queryDesc.Query     = gl_d3d11::ConvertQueryType(getType());
+        queryDesc.Query     = d3dQueryType;
         queryDesc.MiscFlags = 0;
 
         ID3D11Device *device = mRenderer->getDevice();
@@ -182,7 +189,7 @@ gl::Error Query11::resume()
         }
 
         // If we are doing time elapsed we also need a query to actually query the timestamp
-        if (getType() == GL_TIME_ELAPSED_EXT)
+        if (queryType == GL_TIME_ELAPSED_EXT)
         {
             D3D11_QUERY_DESC desc;
             desc.Query     = D3D11_QUERY_TIMESTAMP;
@@ -203,10 +210,13 @@ gl::Error Query11::resume()
 
         ID3D11DeviceContext *context = mRenderer->getDeviceContext();
 
-        context->Begin(mActiveQuery->query);
+        if (d3dQueryType != D3D11_QUERY_EVENT)
+        {
+            context->Begin(mActiveQuery->query);
+        }
 
         // If we are doing time elapsed, query the begin timestamp
-        if (getType() == GL_TIME_ELAPSED_EXT)
+        if (queryType == GL_TIME_ELAPSED_EXT)
         {
             context->End(mActiveQuery->beginTimestamp);
         }
@@ -358,6 +368,28 @@ gl::Error Query11::testQuery(QueryState *queryState)
             }
             break;
 
+            case GL_COMMANDS_COMPLETED_CHROMIUM:
+            {
+                ASSERT(queryState->query);
+                BOOL completed = 0;
+                HRESULT result =
+                    context->GetData(queryState->query, &completed, sizeof(completed), 0);
+                if (FAILED(result))
+                {
+                    return gl::Error(GL_OUT_OF_MEMORY,
+                                     "Failed to get the data of an internal query, result: 0x%X.",
+                                     result);
+                }
+
+                if (result == S_OK)
+                {
+                    queryState->finished = true;
+                    ASSERT(completed == TRUE);
+                    mResult = (completed == TRUE) ? GL_TRUE : GL_FALSE;
+                }
+            }
+            break;
+
         default:
             UNREACHABLE();
             break;

src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp

@@ -130,7 +130,8 @@ void StateManager11::SRVCache::clear()
 }
 
 static const GLenum QueryTypes[] = {GL_ANY_SAMPLES_PASSED, GL_ANY_SAMPLES_PASSED_CONSERVATIVE,
-                                    GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_TIME_ELAPSED_EXT};
+                                    GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_TIME_ELAPSED_EXT,
+                                    GL_COMMANDS_COMPLETED_CHROMIUM};
 
 StateManager11::StateManager11(Renderer11 *renderer)
     : mRenderer(renderer),

src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp

@@ -224,6 +224,8 @@ D3D11_QUERY ConvertQueryType(GLenum queryType)
       case GL_TIME_ELAPSED_EXT:
           // Two internal queries are also created for begin/end timestamps
           return D3D11_QUERY_TIMESTAMP_DISJOINT;
+      case GL_COMMANDS_COMPLETED_CHROMIUM:
+          return D3D11_QUERY_EVENT;
       default: UNREACHABLE();                        return D3D11_QUERY_EVENT;
     }
 }
@@ -1236,6 +1238,7 @@ void GenerateCaps(ID3D11Device *device, ID3D11DeviceContext *deviceContext, cons
     extensions->noError                  = true;
     extensions->lossyETCDecode           = true;
     extensions->bindUniformLocation      = true;
+    extensions->syncQuery                 = GetEventQuerySupport(featureLevel);
 
     // D3D11 Feature Level 10_0+ uses SV_IsFrontFace in HLSL to emulate gl_FrontFacing.
     // D3D11 Feature Level 9_3 doesn't support SV_IsFrontFace, and has no equivalent, so can't support gl_FrontFacing.

src/libANGLE/renderer/d3d/d3d9/Query9.cpp

@@ -30,20 +30,25 @@ Query9::~Query9()
 
 gl::Error Query9::begin()
 {
-    if (mQuery == NULL)
+    D3DQUERYTYPE d3dQueryType = gl_d3d9::ConvertQueryType(getType());
+    if (mQuery == nullptr)
     {
-        HRESULT result = mRenderer->getDevice()->CreateQuery(D3DQUERYTYPE_OCCLUSION, &mQuery);
+        HRESULT result = mRenderer->getDevice()->CreateQuery(d3dQueryType, &mQuery);
         if (FAILED(result))
         {
             return gl::Error(GL_OUT_OF_MEMORY, "Internal query creation failed, result: 0x%X.", result);
         }
     }
 
-    HRESULT result = mQuery->Issue(D3DISSUE_BEGIN);
-    ASSERT(SUCCEEDED(result));
-    if (FAILED(result))
+    if (d3dQueryType != D3DQUERYTYPE_EVENT)
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to begin internal query, result: 0x%X.", result);
+        HRESULT result = mQuery->Issue(D3DISSUE_BEGIN);
+        ASSERT(SUCCEEDED(result));
+        if (FAILED(result))
+        {
+            return gl::Error(GL_OUT_OF_MEMORY, "Failed to begin internal query, result: 0x%X.",
+                             result);
+        }
     }
 
     return gl::Error(GL_NO_ERROR);
@@ -133,26 +138,40 @@ gl::Error Query9::testQuery()
     {
         ASSERT(mQuery);
 
-        DWORD numPixels = 0;
-
-        HRESULT hres = mQuery->GetData(&numPixels, sizeof(DWORD), D3DGETDATA_FLUSH);
-        if (hres == S_OK)
+        HRESULT result = S_OK;
+        switch (getType())
         {
-            mQueryFinished = true;
+            case GL_ANY_SAMPLES_PASSED_EXT:
+            case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+            {
+                DWORD numPixels = 0;
+                result = mQuery->GetData(&numPixels, sizeof(numPixels), D3DGETDATA_FLUSH);
+                if (result == S_OK)
+                {
+                    mQueryFinished = true;
+                    mResult        = (numPixels > 0) ? GL_TRUE : GL_FALSE;
+                }
+                break;
+            }
 
-            switch (getType())
+            case GL_COMMANDS_COMPLETED_CHROMIUM:
             {
-              case GL_ANY_SAMPLES_PASSED_EXT:
-              case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
-                mResult = (numPixels > 0) ? GL_TRUE : GL_FALSE;
+                BOOL completed = FALSE;
+                result = mQuery->GetData(&completed, sizeof(completed), D3DGETDATA_FLUSH);
+                if (result == S_OK)
+                {
+                    mQueryFinished = true;
+                    mResult        = (completed == TRUE) ? GL_TRUE : GL_FALSE;
+                }
                 break;
+            }
 
-              default:
+            default:
                 UNREACHABLE();
                 break;
-            }
         }
-        else if (d3d9::isDeviceLostError(hres))
+
+        if (d3d9::isDeviceLostError(result))
         {
             mRenderer->notifyDeviceLost();
             return gl::Error(GL_OUT_OF_MEMORY, "Failed to test get query result, device is lost.");

src/libANGLE/renderer/d3d/d3d9/renderer9_utils.cpp

@@ -264,6 +264,21 @@ void ConvertMinFilter(GLenum minFilter, D3DTEXTUREFILTERTYPE *d3dMinFilter, D3DT
     }
 }
 
+D3DQUERYTYPE ConvertQueryType(GLenum queryType)
+{
+    switch (queryType)
+    {
+        case GL_ANY_SAMPLES_PASSED_EXT:
+        case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
+            return D3DQUERYTYPE_OCCLUSION;
+        case GL_COMMANDS_COMPLETED_CHROMIUM:
+            return D3DQUERYTYPE_EVENT;
+        default:
+            UNREACHABLE();
+            return static_cast<D3DQUERYTYPE>(0);
+    }
+}
+
 D3DMULTISAMPLE_TYPE GetMultisampleType(GLuint samples)
 {
     return (samples > 1) ? static_cast<D3DMULTISAMPLE_TYPE>(samples) : D3DMULTISAMPLE_NONE;
@@ -580,6 +595,7 @@ void GenerateCaps(IDirect3D9 *d3d9,
     extensions->vertexArrayObject      = true;
     extensions->noError                = true;
     extensions->bindUniformLocation    = true;
+    extensions->syncQuery              = extensions->fence;
 
     // D3D9 has no concept of separate masks and refs for front and back faces in the depth stencil
     // state.

src/libANGLE/renderer/d3d/d3d9/renderer9_utils.h

@@ -39,6 +39,7 @@ DWORD ConvertColorMask(bool red, bool green, bool blue, bool alpha);
 D3DTEXTUREFILTERTYPE ConvertMagFilter(GLenum magFilter, float maxAnisotropy);
 void ConvertMinFilter(GLenum minFilter, D3DTEXTUREFILTERTYPE *d3dMinFilter, D3DTEXTUREFILTERTYPE *d3dMipFilter,
                       float *d3dLodBias, float maxAnisotropy, size_t baseLevel);
+D3DQUERYTYPE ConvertQueryType(GLenum queryType);
 
 D3DMULTISAMPLE_TYPE GetMultisampleType(GLuint samples);
 

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -28,7 +28,8 @@ namespace rx
 {
 
 static const GLenum QueryTypes[] = {GL_ANY_SAMPLES_PASSED, GL_ANY_SAMPLES_PASSED_CONSERVATIVE,
-                                    GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_TIME_ELAPSED};
+                                    GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_TIME_ELAPSED,
+                                    GL_COMMANDS_COMPLETED_CHROMIUM};
 
 StateManagerGL::IndexedBufferBinding::IndexedBufferBinding() : offset(0), size(0), buffer(0)
 {

src/libANGLE/validationES.cpp

@@ -398,6 +398,8 @@ bool ValidQueryType(const Context *context, GLenum queryType)
         return (context->getClientVersion() >= 3);
       case GL_TIME_ELAPSED_EXT:
           return context->getExtensions().disjointTimerQuery;
+      case GL_COMMANDS_COMPLETED_CHROMIUM:
+          return context->getExtensions().syncQuery;
       default:
         return false;
     }
@@ -1220,7 +1222,7 @@ bool ValidateBeginQueryBase(gl::Context *context, GLenum target, GLuint id)
 bool ValidateBeginQueryEXT(gl::Context *context, GLenum target, GLuint id)
 {
     if (!context->getExtensions().occlusionQueryBoolean &&
-        !context->getExtensions().disjointTimerQuery)
+        !context->getExtensions().disjointTimerQuery && !context->getExtensions().syncQuery)
     {
         context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
@@ -1251,7 +1253,7 @@ bool ValidateEndQueryBase(gl::Context *context, GLenum target)
 bool ValidateEndQueryEXT(gl::Context *context, GLenum target)
 {
     if (!context->getExtensions().occlusionQueryBoolean &&
-        !context->getExtensions().disjointTimerQuery)
+        !context->getExtensions().disjointTimerQuery && !context->getExtensions().syncQuery)
     {
         context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
@@ -1327,7 +1329,7 @@ bool ValidateGetQueryivBase(Context *context, GLenum target, GLenum pname)
 bool ValidateGetQueryivEXT(Context *context, GLenum target, GLenum pname, GLint *params)
 {
     if (!context->getExtensions().occlusionQueryBoolean &&
-        !context->getExtensions().disjointTimerQuery)
+        !context->getExtensions().disjointTimerQuery && !context->getExtensions().syncQuery)
     {
         context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;
@@ -1379,7 +1381,7 @@ bool ValidateGetQueryObjectivEXT(Context *context, GLuint id, GLenum pname, GLin
 bool ValidateGetQueryObjectuivEXT(Context *context, GLuint id, GLenum pname, GLuint *params)
 {
     if (!context->getExtensions().disjointTimerQuery &&
-        !context->getExtensions().occlusionQueryBoolean)
+        !context->getExtensions().occlusionQueryBoolean && !context->getExtensions().syncQuery)
     {
         context->handleError(Error(GL_INVALID_OPERATION, "Query extension not enabled"));
         return false;

src/tests/angle_end2end_tests.gypi

@@ -60,6 +60,7 @@
             '<(angle_path)/src/tests/gl_tests/SRGBTextureTest.cpp',
             '<(angle_path)/src/tests/gl_tests/StateChangeTest.cpp',
             '<(angle_path)/src/tests/gl_tests/SwizzleTest.cpp',
+            '<(angle_path)/src/tests/gl_tests/SyncQueriesTest.cpp',
             '<(angle_path)/src/tests/gl_tests/TextureTest.cpp',
             '<(angle_path)/src/tests/gl_tests/TimerQueriesTest.cpp',
             '<(angle_path)/src/tests/gl_tests/TransformFeedbackTest.cpp',

src/tests/gl_tests/SyncQueriesTest.cpp

+//
+// Copyright 2016 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.
+//
+
+// SyncQueriesTest.cpp: Tests of the GL_CHROMIUM_sync_query extension
+
+#include "test_utils/ANGLETest.h"
+
+namespace angle
+{
+
+class SyncQueriesTest : public ANGLETest
+{
+  protected:
+    SyncQueriesTest()
+    {
+        setWindowWidth(128);
+        setWindowHeight(128);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+        setConfigDepthBits(24);
+    }
+
+    void TearDown() override
+    {
+        if (mQuery != 0)
+        {
+            glDeleteQueriesEXT(1, &mQuery);
+            mQuery = 0;
+        }
+
+        ANGLETest::TearDown();
+    }
+
+    GLuint mQuery = 0;
+};
+
+// Test basic usage of sync queries
+TEST_P(SyncQueriesTest, Basic)
+{
+    if (!extensionEnabled("GL_CHROMIUM_sync_query"))
+    {
+        std::cout << "Test skipped because GL_CHROMIUM_sync_query is not available." << std::endl;
+        return;
+    }
+
+    glGenQueriesEXT(1, &mQuery);
+    glBeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, mQuery);
+    EXPECT_GL_NO_ERROR();
+
+    glClearColor(0.0, 0.0, 1.0, 1.0);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glEndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
+
+    glFlush();
+    GLuint result = 0;
+    glGetQueryObjectuivEXT(mQuery, GL_QUERY_RESULT_EXT, &result);
+    EXPECT_EQ(static_cast<GLuint>(GL_TRUE), result);
+    EXPECT_GL_NO_ERROR();
+}
+
+// Test that the sync query enums are not accepted unless the extension is available
+TEST_P(SyncQueriesTest, Validation)
+{
+    // Need the GL_EXT_occlusion_query_boolean extension for the entry points
+    if (!extensionEnabled("GL_EXT_occlusion_query_boolean"))
+    {
+        std::cout << "Test skipped because GL_EXT_occlusion_query_boolean is not available."
+                  << std::endl;
+        return;
+    }
+
+    bool extensionAvailable = extensionEnabled("GL_CHROMIUM_sync_query");
+
+    glGenQueriesEXT(1, &mQuery);
+
+    glBeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, mQuery);
+    if (extensionAvailable)
+    {
+        EXPECT_GL_NO_ERROR();
+    }
+    else
+    {
+        EXPECT_GL_ERROR(GL_INVALID_ENUM);
+    }
+
+    glDeleteQueriesEXT(1, &mQuery);
+
+    EXPECT_GL_NO_ERROR();
+}
+
+// Use this to select which configurations (e.g. which renderer, which GLES major version) these
+// tests should be run against.
+ANGLE_INSTANTIATE_TEST(SyncQueriesTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
+
+}  // namespace angle