Metal: Implement EXT_occlusion_query_boolean.

- Metal's occlusion(called visibility) query operates per render pass.
  Implementation details are in
  src/libANGLE/renderer/metal/doc/OcclusionQueries.md.
- New tests:
  - OcclusionQueriesTest.ClearNotCounted.
  - OcclusionQueriesTest.MultiQueries (failure on OpenGL/D3D11
    back-end).

Bug: angleproject:2634
Change-Id: Idd1327b5472d0e8c2b69307a7f04a1da4a847a40
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2336121
Commit-Queue: Le Hoang Quyen <le.hoang.q@gmail.com>
Reviewed-by: back sept 10 - Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>

Author: kakashidinho

src/libANGLE/renderer/metal/BUILD.gn

@@ -23,6 +23,8 @@ _metal_backend_sources = [
   "FrameBufferMtl.mm",
   "ProgramMtl.h",
   "ProgramMtl.mm",
+  "QueryMtl.h",
+  "QueryMtl.mm",
   "RenderBufferMtl.h",
   "RenderBufferMtl.mm",
   "RenderTargetMtl.h",
@@ -46,6 +48,8 @@ _metal_backend_sources = [
   "mtl_format_utils.mm",
   "mtl_glslang_utils.h",
   "mtl_glslang_utils.mm",
+  "mtl_occlusion_query_pool.h",
+  "mtl_occlusion_query_pool.mm",
   "mtl_render_utils.h",
   "mtl_render_utils.mm",
   "mtl_resources.h",

src/libANGLE/renderer/metal/ContextMtl.h

@@ -17,6 +17,7 @@
 #include "libANGLE/renderer/ContextImpl.h"
 #include "libANGLE/renderer/metal/mtl_buffer_pool.h"
 #include "libANGLE/renderer/metal/mtl_command_buffer.h"
+#include "libANGLE/renderer/metal/mtl_occlusion_query_pool.h"
 #include "libANGLE/renderer/metal/mtl_resources.h"
 #include "libANGLE/renderer/metal/mtl_state_cache.h"
 #include "libANGLE/renderer/metal/mtl_utils.h"
@@ -272,6 +273,21 @@ class ContextMtl : public ContextImpl, public mtl::Context
                                        bool renderPassChanged);
     void onBackbufferResized(const gl::Context *context, WindowSurfaceMtl *backbuffer);
 
+    // Invoke by QueryMtl
+    angle::Result onOcclusionQueryBegin(const gl::Context *context, QueryMtl *query);
+    void onOcclusionQueryEnd(const gl::Context *context, QueryMtl *query);
+    void onOcclusionQueryDestroy(const gl::Context *context, QueryMtl *query);
+
+    // Useful for temporarily pause then restart occlusion query during clear/blit with draw.
+    bool hasActiveOcclusionQuery() const { return mOcclusionQuery; }
+    // Disable the occlusion query in the current render pass.
+    // The render pass must already started.
+    void disableActiveOcclusionQueryInRenderPass();
+    // Re-enable the occlusion query in the current render pass.
+    // The render pass must already started.
+    // NOTE: the old query's result will be retained and combined with the new result.
+    angle::Result restartActiveOcclusionQueryInRenderPass();
+
     const MTLClearColor &getClearColorValue() const;
     MTLColorWriteMask getColorMask() const;
     float getClearDepthValue() const;
@@ -292,7 +308,7 @@ class ContextMtl : public ContextImpl, public mtl::Context
 
     // Recommended to call these methods to end encoding instead of invoking the encoder's
     // endEncoding() directly.
-    void endEncoding(mtl::RenderCommandEncoder *encoder);
+    void endRenderEncoding(mtl::RenderCommandEncoder *encoder);
     // Ends any active command encoder
     void endEncoding(bool forceSaveRenderPassContent);
 
@@ -406,6 +422,8 @@ class ContextMtl : public ContextImpl, public mtl::Context
                                          gl::PrimitiveMode primitiveMode,
                                          Optional<mtl::RenderPipelineDesc> *changedPipelineDesc);
 
+    angle::Result startOcclusionQueryInRenderPass(QueryMtl *query, bool clearOldValue);
+
     // Dirty bits.
     enum DirtyBitType : size_t
     {
@@ -470,6 +488,8 @@ class ContextMtl : public ContextImpl, public mtl::Context
         float values[4];
     };
 
+    mtl::OcclusionQueryPool mOcclusionQueryPool;
+
     mtl::CommandBuffer mCmdBuffer;
     mtl::RenderCommandEncoder mRenderEncoder;
     mtl::BlitCommandEncoder mBlitEncoder;
@@ -479,6 +499,7 @@ class ContextMtl : public ContextImpl, public mtl::Context
     FramebufferMtl *mDrawFramebuffer = nullptr;
     VertexArrayMtl *mVertexArray     = nullptr;
     ProgramMtl *mProgram             = nullptr;
+    QueryMtl *mOcclusionQuery        = nullptr;
 
     using DirtyBits = angle::BitSet<DIRTY_BIT_MAX>;
 

src/libANGLE/renderer/metal/ContextMtl.mm

@@ -17,6 +17,7 @@
 #include "libANGLE/renderer/metal/DisplayMtl.h"
 #include "libANGLE/renderer/metal/FrameBufferMtl.h"
 #include "libANGLE/renderer/metal/ProgramMtl.h"
+#include "libANGLE/renderer/metal/QueryMtl.h"
 #include "libANGLE/renderer/metal/RenderBufferMtl.h"
 #include "libANGLE/renderer/metal/RenderTargetMtl.h"
 #include "libANGLE/renderer/metal/ShaderMtl.h"
@@ -97,7 +98,7 @@ bool NeedToInvertDepthRange(float near, float far)
     : ContextImpl(state, errorSet),
       mtl::Context(display),
       mCmdBuffer(&display->cmdQueue()),
-      mRenderEncoder(&mCmdBuffer),
+      mRenderEncoder(&mCmdBuffer, mOcclusionQueryPool),
       mBlitEncoder(&mCmdBuffer),
       mComputeEncoder(&mCmdBuffer)
 {}
@@ -122,6 +123,7 @@ bool NeedToInvertDepthRange(float near, float far)
 {
     mTriFanIndexBuffer.destroy(this);
     mLineLoopIndexBuffer.destroy(this);
+    mOcclusionQueryPool.destroy(this);
 
     mIncompleteTextures.onDestroy(context);
     mIncompleteTexturesInitialized = false;
@@ -927,9 +929,7 @@ bool NeedToInvertDepthRange(float near, float far)
 // Query and Fence creation
 QueryImpl *ContextMtl::createQuery(gl::QueryType type)
 {
-    // NOTE(hqle): ES 3.0
-    UNIMPLEMENTED();
-    return nullptr;
+    return new QueryMtl(type);
 }
 FenceNVImpl *ContextMtl::createFenceNV()
 {
@@ -1131,9 +1131,18 @@ bool NeedToInvertDepthRange(float near, float far)
     return mIncompleteTextures.getIncompleteTexture(context, type, nullptr, textureOut);
 }
 
-void ContextMtl::endEncoding(mtl::RenderCommandEncoder *encoder)
+void ContextMtl::endRenderEncoding(mtl::RenderCommandEncoder *encoder)
 {
+    // End any pending visibility query in the render pass
+    if (mOcclusionQuery)
+    {
+        disableActiveOcclusionQueryInRenderPass();
+    }
+
     encoder->endEncoding();
+
+    // Resolve visibility results
+    mOcclusionQueryPool.resolveVisibilityResults(this);
 }
 
 void ContextMtl::endEncoding(bool forceSaveRenderPassContent)
@@ -1146,7 +1155,7 @@ bool NeedToInvertDepthRange(float near, float far)
             mRenderEncoder.setStoreAction(MTLStoreActionStore);
         }
 
-        mRenderEncoder.endEncoding();
+        endRenderEncoding(&mRenderEncoder);
     }
 
     if (mBlitEncoder.valid())
@@ -1461,6 +1470,87 @@ bool NeedToInvertDepthRange(float near, float far)
     onDrawFrameBufferChangedState(context, framebuffer, true);
 }
 
+angle::Result ContextMtl::onOcclusionQueryBegin(const gl::Context *context, QueryMtl *query)
+{
+    ASSERT(mOcclusionQuery == nullptr);
+    mOcclusionQuery = query;
+
+    if (mRenderEncoder.valid())
+    {
+        // if render pass has started, start the query in the encoder
+        return startOcclusionQueryInRenderPass(query, true);
+    }
+    else
+    {
+        query->resetVisibilityResult(this);
+    }
+
+    return angle::Result::Continue;
+}
+void ContextMtl::onOcclusionQueryEnd(const gl::Context *context, QueryMtl *query)
+{
+    ASSERT(mOcclusionQuery == query);
+
+    if (mRenderEncoder.valid())
+    {
+        // if render pass has started, end the query in the encoder
+        disableActiveOcclusionQueryInRenderPass();
+    }
+
+    mOcclusionQuery = nullptr;
+}
+void ContextMtl::onOcclusionQueryDestroy(const gl::Context *context, QueryMtl *query)
+{
+    if (query->getAllocatedVisibilityOffsets().empty())
+    {
+        return;
+    }
+    if (mOcclusionQuery == query)
+    {
+        onOcclusionQueryEnd(context, query);
+    }
+    mOcclusionQueryPool.deallocateQueryOffset(this, query);
+}
+
+void ContextMtl::disableActiveOcclusionQueryInRenderPass()
+{
+    if (!mOcclusionQuery || mOcclusionQuery->getAllocatedVisibilityOffsets().empty())
+    {
+        return;
+    }
+
+    ASSERT(mRenderEncoder.valid());
+    mRenderEncoder.setVisibilityResultMode(MTLVisibilityResultModeDisabled,
+                                           mOcclusionQuery->getAllocatedVisibilityOffsets().back());
+}
+
+angle::Result ContextMtl::restartActiveOcclusionQueryInRenderPass()
+{
+    if (!mOcclusionQuery || mOcclusionQuery->getAllocatedVisibilityOffsets().empty())
+    {
+        return angle::Result::Continue;
+    }
+
+    return startOcclusionQueryInRenderPass(mOcclusionQuery, false);
+}
+
+angle::Result ContextMtl::startOcclusionQueryInRenderPass(QueryMtl *query, bool clearOldValue)
+{
+    ASSERT(mRenderEncoder.valid());
+
+    ANGLE_TRY(mOcclusionQueryPool.allocateQueryOffset(this, query, clearOldValue));
+
+    mRenderEncoder.setVisibilityResultMode(MTLVisibilityResultModeBoolean,
+                                           query->getAllocatedVisibilityOffsets().back());
+
+    // We need to mark the query's buffer as being written in this command buffer now. Since the
+    // actual writing is deferred until the render pass ends and user could try to read the query
+    // result before the render pass ends.
+    mCmdBuffer.setWriteDependency(query->getVisibilityResultBuffer());
+
+    return angle::Result::Continue;
+}
+
 void ContextMtl::updateProgramExecutable(const gl::Context *context)
 {
     // Need to rebind textures
@@ -1547,6 +1637,13 @@ bool NeedToInvertDepthRange(float near, float far)
         invalidateState(context);
     }
 
+    if (mOcclusionQuery && mOcclusionQueryPool.getNumRenderPassAllocatedQueries() == 0)
+    {
+        // The occlusion query is still active, and a new render pass has started.
+        // We need to continue the querying process in the new render encoder.
+        ANGLE_TRY(startOcclusionQueryInRenderPass(mOcclusionQuery, false));
+    }
+
     Optional<mtl::RenderPipelineDesc> changedPipelineDesc;
     ANGLE_TRY(checkIfPipelineChanged(context, mode, &changedPipelineDesc));
 

src/libANGLE/renderer/metal/DisplayMtl.mm

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2019 The ANGLE Project Authors. All rights reserved.
+// Copyright 2019 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.
 //
@@ -627,8 +627,7 @@ bool IsMetalDisplayAvailable()
 
     mNativeExtensions.eglSyncOES = false;
 
-    // NOTE(hqle): support occlusion query
-    mNativeExtensions.occlusionQueryBoolean = false;
+    mNativeExtensions.occlusionQueryBoolean = true;
 
     mNativeExtensions.disjointTimerQuery          = false;
     mNativeExtensions.queryCounterBitsTimeElapsed = false;

src/libANGLE/renderer/metal/QueryMtl.h

@@ -0,0 +1,113 @@
+//
+// Copyright 2020 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.
+//
+// QueryMtl.h:
+//    Defines the class interface for QueryMtl, implementing QueryImpl.
+//
+
+#ifndef LIBANGLE_RENDERER_METAL_QUERYMTL_H_
+#define LIBANGLE_RENDERER_METAL_QUERYMTL_H_
+
+#include "libANGLE/renderer/QueryImpl.h"
+#include "libANGLE/renderer/metal/mtl_common.h"
+#include "libANGLE/renderer/metal/mtl_resources.h"
+
+namespace rx
+{
+
+class ContextMtl;
+
+// The class represents offset(s) allocated in the visiblity buffer for an occlusion query.
+// See doc/OcclusionQuery.md.
+// An occlusion query might have more than one offsets allocated, but all of them must be adjacent
+// to each other. Multiple offsets typically allocated when the query is paused and resumed during
+// viewport clear emulation with draw operations. In such case, Metal doesn't allow an offset to
+// be reused in a render pass, hence multiple offsets will be allocated, and their values will
+// be accumulated.
+class VisibilityBufferOffsetsMtl
+{
+  public:
+    void clear() { mStartOffset = mNumOffsets = 0; }
+    bool empty() const { return mNumOffsets == 0; }
+    uint32_t size() const { return mNumOffsets; }
+
+    // Return last offset
+    uint32_t back() const
+    {
+        ASSERT(!empty());
+        return mStartOffset + (mNumOffsets - 1) * mtl::kOcclusionQueryResultSize;
+    }
+
+    uint32_t front() const
+    {
+        ASSERT(!empty());
+        return mStartOffset;
+    }
+
+    void setStartOffset(uint32_t offset)
+    {
+        ASSERT(empty());
+        mStartOffset = offset;
+        mNumOffsets  = 1;
+    }
+    void addOffset()
+    {
+        ASSERT(!empty());
+        mNumOffsets++;
+    }
+
+  private:
+    uint32_t mStartOffset = 0;
+    uint32_t mNumOffsets  = 0;
+};
+
+class QueryMtl : public QueryImpl
+{
+  public:
+    QueryMtl(gl::QueryType type);
+    ~QueryMtl() override;
+
+    void onDestroy(const gl::Context *context) override;
+
+    angle::Result begin(const gl::Context *context) override;
+    angle::Result end(const gl::Context *context) override;
+    angle::Result queryCounter(const gl::Context *context) override;
+    angle::Result getResult(const gl::Context *context, GLint *params) override;
+    angle::Result getResult(const gl::Context *context, GLuint *params) override;
+    angle::Result getResult(const gl::Context *context, GLint64 *params) override;
+    angle::Result getResult(const gl::Context *context, GLuint64 *params) override;
+    angle::Result isResultAvailable(const gl::Context *context, bool *available) override;
+
+    // Get allocated offsets in the render pass's occlusion query pool.
+    const VisibilityBufferOffsetsMtl &getAllocatedVisibilityOffsets() const
+    {
+        return mVisibilityBufferOffsets;
+    }
+    // Set first allocated offset in the render pass's occlusion query pool.
+    void setFirstAllocatedVisibilityOffset(uint32_t off)
+    {
+        mVisibilityBufferOffsets.setStartOffset(off);
+    }
+    // Add more offset allocated for the occlusion query
+    void addAllocatedVisibilityOffset() { mVisibilityBufferOffsets.addOffset(); }
+
+    void clearAllocatedVisibilityOffsets() { mVisibilityBufferOffsets.clear(); }
+    // Returns the buffer containing the final occlusion query result.
+    const mtl::BufferRef &getVisibilityResultBuffer() const { return mVisibilityResultBuffer; }
+    // Reset the occlusion query result stored in buffer to zero
+    void resetVisibilityResult(ContextMtl *contextMtl);
+
+  private:
+    template <typename T>
+    angle::Result waitAndGetResult(const gl::Context *context, T *params);
+
+    // List of offsets in the render pass's occlusion query pool buffer allocated for this query
+    VisibilityBufferOffsetsMtl mVisibilityBufferOffsets;
+    mtl::BufferRef mVisibilityResultBuffer;
+};
+
+}  // namespace rx
+
+#endif /* LIBANGLE_RENDERER_METAL_QUERYMTL_H_ */