Move the vk Serial class to renderer_utils.

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -11,15 +11,15 @@
 
 #include <array>
 
-#include "common/debug.h"
 #include "common/MemoryBuffer.h"
+#include "common/debug.h"
 #include "libANGLE/ContextState.h"
 #include "libANGLE/Device.h"
+#include "libANGLE/Version.h"
+#include "libANGLE/WorkerThread.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
 #include "libANGLE/renderer/d3d/formatutilsD3D.h"
-#include "libANGLE/Version.h"
-#include "libANGLE/WorkerThread.h"
 #include "platform/WorkaroundsD3D.h"
 
 namespace egl

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

@@ -11,6 +11,7 @@
 
 #include "common/bitset_utils.h"
 #include "libANGLE/renderer/d3d/d3d11/Buffer11.h"
+#include "libANGLE/renderer/d3d/d3d11/Context11.h"
 
 using namespace angle;
 

src/libANGLE/renderer/renderer_utils.h

@@ -15,6 +15,7 @@
 #include <limits>
 #include <map>
 
+#include "common/angleutils.h"
 #include "libANGLE/angletypes.h"
 
 namespace angle
@@ -47,6 +48,43 @@ class ResourceSerial
     uintptr_t mValue;
 };
 
+class SerialFactory;
+
+class Serial final
+{
+  public:
+    constexpr Serial() : mValue(0) {}
+    constexpr Serial(const Serial &other) = default;
+    Serial &operator=(const Serial &other) = default;
+
+    constexpr bool operator==(const Serial &other) const { return mValue == other.mValue; }
+    constexpr bool operator!=(const Serial &other) const { return mValue != other.mValue; }
+    constexpr bool operator>(const Serial &other) const { return mValue > other.mValue; }
+    constexpr bool operator>=(const Serial &other) const { return mValue >= other.mValue; }
+    constexpr bool operator<(const Serial &other) const { return mValue < other.mValue; }
+    constexpr bool operator<=(const Serial &other) const { return mValue <= other.mValue; }
+
+  private:
+    friend class SerialFactory;
+    constexpr explicit Serial(uint64_t value) : mValue(value) {}
+    uint64_t mValue;
+};
+
+class SerialFactory final : angle::NonCopyable
+{
+  public:
+    SerialFactory() : mSerial(1) {}
+
+    Serial generate()
+    {
+        ASSERT(mSerial != std::numeric_limits<uint64_t>::max());
+        return Serial(mSerial++);
+    }
+
+  private:
+    uint64_t mSerial;
+};
+
 using MipGenerationFunction = void (*)(size_t sourceWidth,
                                        size_t sourceHeight,
                                        size_t sourceDepth,

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -95,11 +95,10 @@ RendererVk::RendererVk()
       mDevice(VK_NULL_HANDLE),
       mHostVisibleMemoryIndex(std::numeric_limits<uint32_t>::max()),
       mGlslangWrapper(nullptr),
-      mCurrentQueueSerial(),
-      mLastCompletedQueueSerial(),
+      mLastCompletedQueueSerial(mQueueSerialFactory.generate()),
+      mCurrentQueueSerial(mQueueSerialFactory.generate()),
       mInFlightCommands()
 {
-    ++mCurrentQueueSerial;
 }
 
 RendererVk::~RendererVk()
@@ -732,7 +731,8 @@ vk::Error RendererVk::submit(const VkSubmitInfo &submitInfo)
     ASSERT(mInFlightCommands.size() < 1000u);
 
     // Increment the queue serial. If this fails, we should restart ANGLE.
-    ANGLE_VK_CHECK(++mCurrentQueueSerial, VK_ERROR_OUT_OF_HOST_MEMORY);
+    // TODO(jmadill): Overflow check.
+    mCurrentQueueSerial = mQueueSerialFactory.generate();
 
     return vk::NoError();
 }
@@ -757,7 +757,8 @@ vk::Error RendererVk::submitFrame(const VkSubmitInfo &submitInfo)
     ASSERT(mInFlightCommands.size() < 1000u);
 
     // Increment the queue serial. If this fails, we should restart ANGLE.
-    ANGLE_VK_CHECK(++mCurrentQueueSerial, VK_ERROR_OUT_OF_HOST_MEMORY);
+    // TODO(jmadill): Overflow check.
+    mCurrentQueueSerial = mQueueSerialFactory.generate();
 
     ANGLE_TRY(checkInFlightCommands());
 

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -124,8 +124,9 @@ class RendererVk : angle::NonCopyable
     vk::CommandBuffer mCommandBuffer;
     uint32_t mHostVisibleMemoryIndex;
     GlslangWrapper *mGlslangWrapper;
-    Serial mCurrentQueueSerial;
+    SerialFactory mQueueSerialFactory;
     Serial mLastCompletedQueueSerial;
+    Serial mCurrentQueueSerial;
     std::vector<vk::CommandBufferAndSerial> mInFlightCommands;
     std::vector<vk::FenceAndSerial> mInFlightFences;
     std::vector<std::unique_ptr<vk::IGarbageObject>> mGarbage;

src/libANGLE/renderer/vulkan/renderervk_utils.h

@@ -14,9 +14,10 @@
 
 #include <vulkan/vulkan.h>
 
-#include "common/debug.h"
 #include "common/Optional.h"
+#include "common/debug.h"
 #include "libANGLE/Error.h"
+#include "libANGLE/renderer/renderer_utils.h"
 
 namespace gl
 {
@@ -47,35 +48,6 @@ enum DeleteSchedule
     LATER,
 };
 
-// A serial supports a few operations - comparison, increment, and assignment.
-// TODO(jmadill): Verify it's not easy to overflow the queue serial.
-class Serial final
-{
-  public:
-    Serial() : mValue(0) {}
-    Serial(const Serial &other) : mValue(other.mValue) {}
-    Serial(Serial &&other) : mValue(other.mValue) { other.mValue = 0; }
-    Serial &operator=(const Serial &other)
-    {
-        mValue = other.mValue;
-        return *this;
-    }
-    bool operator>=(Serial other) const { return mValue >= other.mValue; }
-    bool operator>(Serial other) const { return mValue > other.mValue; }
-
-    // This function fails if we're at the limits of our counting.
-    bool operator++()
-    {
-        if (mValue == std::numeric_limits<uint32_t>::max())
-            return false;
-        mValue++;
-        return true;
-    }
-
-  private:
-    uint32_t mValue;
-};
-
 // This is a small helper mixin for any GL object used in Vk command buffers. It records a serial
 // at command submission times indicating it's order in the queue. We will use Fences to detect
 // when commands are finished, and then handle lifetime management for the resources.