1 files changed, 58 insertions, 49 deletions

diff --git a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp
index 53fac65f2a..082f28d794 100644
--- a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp
+++ b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp
@@ -4,7 +4,8 @@
 // found in the LICENSE file.
 //
 
-// Fence11.cpp: Defines the rx::FenceNV11 and rx::FenceSync11 classes which implement rx::FenceNVImpl and rx::FenceSyncImpl.
+// Fence11.cpp: Defines the rx::FenceNV11 and rx::Sync11 classes which implement
+// rx::FenceNVImpl and rx::SyncImpl.
 
 #include "libANGLE/renderer/d3d/d3d11/Fence11.h"
 #include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
@@ -14,28 +15,30 @@
 namespace rx
 {
 
+static const int kDeviceLostCheckPeriod = 64;
+
 //
 // Template helpers for set and test operations.
 //
 
-template<class FenceClass>
+template <class FenceClass>
 gl::Error FenceSetHelper(FenceClass *fence)
 {
     if (!fence->mQuery)
     {
         D3D11_QUERY_DESC queryDesc;
-        queryDesc.Query = D3D11_QUERY_EVENT;
+        queryDesc.Query     = D3D11_QUERY_EVENT;
         queryDesc.MiscFlags = 0;
 
         HRESULT result = fence->mRenderer->getDevice()->CreateQuery(&queryDesc, &fence->mQuery);
         if (FAILED(result))
         {
-            return gl::Error(GL_OUT_OF_MEMORY, "Failed to create event query, result: 0x%X.", result);
+            return gl::OutOfMemory() << "Failed to create event query, " << gl::FmtHR(result);
         }
     }
 
     fence->mRenderer->getDeviceContext()->End(fence->mQuery);
-    return gl::Error(GL_NO_ERROR);
+    return gl::NoError();
 }
 
 template <class FenceClass>
@@ -44,30 +47,24 @@ gl::Error FenceTestHelper(FenceClass *fence, bool flushCommandBuffer, GLboolean
     ASSERT(fence->mQuery);
 
     UINT getDataFlags = (flushCommandBuffer ? 0 : D3D11_ASYNC_GETDATA_DONOTFLUSH);
-    HRESULT result = fence->mRenderer->getDeviceContext()->GetData(fence->mQuery, NULL, 0, getDataFlags);
+    HRESULT result =
+        fence->mRenderer->getDeviceContext()->GetData(fence->mQuery, nullptr, 0, getDataFlags);
 
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to get query data, result: 0x%X.", result);
-    }
-    else if (fence->mRenderer->isDeviceLost())
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Device was lost while querying result of an event query.");
+        return gl::OutOfMemory() << "Failed to get query data, " << gl::FmtHR(result);
     }
 
     ASSERT(result == S_OK || result == S_FALSE);
     *outFinished = ((result == S_OK) ? GL_TRUE : GL_FALSE);
-    return gl::Error(GL_NO_ERROR);
+    return gl::NoError();
 }
 
 //
 // FenceNV11
 //
 
-FenceNV11::FenceNV11(Renderer11 *renderer)
-    : FenceNVImpl(),
-      mRenderer(renderer),
-      mQuery(NULL)
+FenceNV11::FenceNV11(Renderer11 *renderer) : FenceNVImpl(), mRenderer(renderer), mQuery(nullptr)
 {
 }
 
@@ -89,22 +86,26 @@ gl::Error FenceNV11::test(GLboolean *outFinished)
 gl::Error FenceNV11::finish()
 {
     GLboolean finished = GL_FALSE;
+
+    int loopCount = 0;
     while (finished != GL_TRUE)
     {
-        gl::Error error = FenceTestHelper(this, true, &finished);
-        if (error.isError())
+        loopCount++;
+        ANGLE_TRY(FenceTestHelper(this, true, &finished));
+
+        if (loopCount % kDeviceLostCheckPeriod == 0 && mRenderer->testDeviceLost())
         {
-            return error;
+            return gl::OutOfMemory() << "Device was lost while querying result of an event query.";
         }
 
         ScheduleYield();
     }
 
-    return gl::Error(GL_NO_ERROR);
+    return gl::NoError();
 }
 
 //
-// FenceSync11
+// Sync11
 //
 
 // Important note on accurate timers in Windows:
@@ -118,38 +119,34 @@ gl::Error FenceNV11::finish()
 // We still opt to use QPC. In the present and moving forward, most newer systems will not suffer
 // from buggy implementations.
 
-FenceSync11::FenceSync11(Renderer11 *renderer)
-    : FenceSyncImpl(),
-      mRenderer(renderer),
-      mQuery(NULL)
+Sync11::Sync11(Renderer11 *renderer) : SyncImpl(), mRenderer(renderer), mQuery(nullptr)
 {
     LARGE_INTEGER counterFreqency = {};
-    BOOL success = QueryPerformanceFrequency(&counterFreqency);
-    UNUSED_ASSERTION_VARIABLE(success);
+    BOOL success                  = QueryPerformanceFrequency(&counterFreqency);
     ASSERT(success);
 
     mCounterFrequency = counterFreqency.QuadPart;
 }
 
-FenceSync11::~FenceSync11()
+Sync11::~Sync11()
 {
     SafeRelease(mQuery);
 }
 
-gl::Error FenceSync11::set(GLenum condition, GLbitfield flags)
+gl::Error Sync11::set(GLenum condition, GLbitfield flags)
 {
     ASSERT(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0);
     return FenceSetHelper(this);
 }
 
-gl::Error FenceSync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
+gl::Error Sync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
 {
     ASSERT(outResult);
 
     bool flushCommandBuffer = ((flags & GL_SYNC_FLUSH_COMMANDS_BIT) != 0);
 
     GLboolean result = GL_FALSE;
-    gl::Error error = FenceTestHelper(this, flushCommandBuffer, &result);
+    gl::Error error  = FenceTestHelper(this, flushCommandBuffer, &result);
     if (error.isError())
     {
         *outResult = GL_WAIT_FAILED;
@@ -159,28 +156,34 @@ gl::Error FenceSync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *ou
     if (result == GL_TRUE)
     {
         *outResult = GL_ALREADY_SIGNALED;
-        return gl::Error(GL_NO_ERROR);
+        return gl::NoError();
     }
 
     if (timeout == 0)
     {
         *outResult = GL_TIMEOUT_EXPIRED;
-        return gl::Error(GL_NO_ERROR);
+        return gl::NoError();
     }
 
     LARGE_INTEGER currentCounter = {};
-    BOOL success = QueryPerformanceCounter(&currentCounter);
-    UNUSED_ASSERTION_VARIABLE(success);
+    BOOL success                 = QueryPerformanceCounter(&currentCounter);
     ASSERT(success);
 
-    LONGLONG timeoutInSeconds = static_cast<LONGLONG>(timeout) * static_cast<LONGLONG>(1000000ll);
-    LONGLONG endCounter = currentCounter.QuadPart + mCounterFrequency * timeoutInSeconds;
+    LONGLONG timeoutInSeconds = static_cast<LONGLONG>(timeout / 1000000000ull);
+    LONGLONG endCounter       = currentCounter.QuadPart + mCounterFrequency * timeoutInSeconds;
 
+    // Extremely unlikely, but if mCounterFrequency is large enough, endCounter can wrap
+    if (endCounter < currentCounter.QuadPart)
+    {
+        endCounter = MAXLONGLONG;
+    }
+
+    int loopCount = 0;
     while (currentCounter.QuadPart < endCounter && !result)
     {
+        loopCount++;
         ScheduleYield();
         success = QueryPerformanceCounter(&currentCounter);
-        UNUSED_ASSERTION_VARIABLE(success);
         ASSERT(success);
 
         error = FenceTestHelper(this, flushCommandBuffer, &result);
@@ -189,6 +192,12 @@ gl::Error FenceSync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *ou
             *outResult = GL_WAIT_FAILED;
             return error;
         }
+
+        if ((loopCount % kDeviceLostCheckPeriod) == 0 && mRenderer->testDeviceLost())
+        {
+            *outResult = GL_WAIT_FAILED;
+            return gl::OutOfMemory() << "Device was lost while querying result of an event query.";
+        }
     }
 
     if (currentCounter.QuadPart >= endCounter)
@@ -200,32 +209,32 @@ gl::Error FenceSync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *ou
         *outResult = GL_CONDITION_SATISFIED;
     }
 
-    return gl::Error(GL_NO_ERROR);
+    return gl::NoError();
 }
 
-gl::Error FenceSync11::serverWait(GLbitfield flags, GLuint64 timeout)
+gl::Error Sync11::serverWait(GLbitfield flags, GLuint64 timeout)
 {
     // Because our API is currently designed to be called from a single thread, we don't need to do
-    // extra work for a server-side fence. GPU commands issued after the fence is created will always
-    // be processed after the fence is signaled.
-    return gl::Error(GL_NO_ERROR);
+    // extra work for a server-side fence. GPU commands issued after the fence is created will
+    // always be processed after the fence is signaled.
+    return gl::NoError();
 }
 
-gl::Error FenceSync11::getStatus(GLint *outResult)
+gl::Error Sync11::getStatus(GLint *outResult)
 {
     GLboolean result = GL_FALSE;
-    gl::Error error = FenceTestHelper(this, false, &result);
+    gl::Error error  = FenceTestHelper(this, false, &result);
     if (error.isError())
     {
-        // The spec does not specify any way to report errors during the status test (e.g. device lost)
-        // so we report the fence is unblocked in case of error or signaled.
+        // The spec does not specify any way to report errors during the status test (e.g. device
+        // lost) so we report the fence is unblocked in case of error or signaled.
         *outResult = GL_SIGNALED;
 
         return error;
     }
 
     *outResult = (result ? GL_SIGNALED : GL_UNSIGNALED);
-    return gl::Error(GL_NO_ERROR);
+    return gl::NoError();
 }
 
-} // namespace rx
+}  // namespace rx