Implement overhead-free sequenced buffer updates with megabuffers

Previously constant buffer updates would be handled on the CPU and only the end result would be synced to the GPU before execute. This caused issues as if the constant buffer contents was changed between each draw in a renderpass (e.g. text rendering) the draws themselves would only see the final resulting constant buffer.

We had earlier tried to fix this by using vkCmdUpdateBuffer however this caused significant performance loss due to an oversight in Adreno drivers. We could have worked around this simply by using vkCmdCopy buffer however there would still be a performance loss due to renderpasses being split up with copies inbetween.

To avoid this we introduce 'megabuffers', a brand new technique not done before in any other switch emulators. Rather than replaying the copies in sequence on the GPU, we take advantage of the fact that buffers are generally small in order to replay buffers on the GPU instead. Each write and subsequent usage of a buffer will cause a copy of the buffer with that write, and all prior applied to be pushed into the megabuffer, this way at the start of execute the megabuffer will hold all used states of the buffer simultaneously. Draws then reference these individual states in sequence to allow everything to work without any copies. In order to support this buffers have been moved to an immediate sync model, with synchronisation being done at usage-time rather than execute (in order to keep contents properly sequenced) and GPU-side writes now need to be explictly marked (since they prevent megabuffering). It should also be noted that a fallback path using cmdCopyBuffer exists for the cases where buffers are too large or GPU dirty.

app/src/main/cpp/skyline/gpu/buffer_manager.h

@@ -6,6 +6,37 @@
 #include "buffer.h"
 
 namespace skyline::gpu {
+    /**
+     * @brief A simple linearly allocated GPU-side buffer used to temporarily store buffer modifications allowing them to be replayed in-sequence on the GPU
+     */
+    class MegaBuffer {
+      private:
+        constexpr static vk::DeviceSize Size{0x6'400'000}; //!< Size in bytes of the megabuffer (100MiB)
+
+        memory::Buffer backing; //!< The backing GPU buffer
+        std::mutex mutex; //!< Synchronizes access to freeRegion
+        span<u8> freeRegion; //!< Span of unallocated space in the megabuffer
+
+      public:
+        MegaBuffer(GPU &gpu);
+
+        /**
+         * @brief Resets the free region of the megabuffer to its initial state, data is left intact but may be overwritten
+         */
+        void Reset();
+
+        /**
+         * @brief Returns the underlying Vulkan buffer for the megabuffer
+         */
+        vk::Buffer GetBacking() const;
+
+        /**
+         * @brief Pushes data to the megabuffer and returns the offset at which it was written
+         * @param pageAlign Whether the pushed data should be page aligned in the megabuffer
+         */
+        vk::DeviceSize Push(span<u8> data, bool pageAlign = false);
+    };
+
     /**
      * @brief The Buffer Manager is responsible for maintaining a global view of buffers being mapped from the guest to the host, any lookups and creation of host buffer from equivalent guest buffer alongside reconciliation of any overlaps with existing textures
      */
@@ -21,6 +52,8 @@ namespace skyline::gpu {
         static bool BufferLessThan(const std::shared_ptr<Buffer> &it, u8 *pointer);
 
       public:
+        MegaBuffer megaBuffer; //!< The megabuffer used to temporarily store buffer modifications allowing them to be replayed in-sequence on the GPU
+
         BufferManager(GPU &gpu);
 
         /**