video_core: Replace VKScheduler with Scheduler

src/video_core/renderer_vulkan/blit_image.cpp

@@ -349,7 +349,7 @@ VkExtent2D GetConversionExtent(const ImageView& src_image_view) {
 }
 } // Anonymous namespace
 
-BlitImageHelper::BlitImageHelper(const Device& device_, VKScheduler& scheduler_,
+BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
                                  StateTracker& state_tracker_, DescriptorPool& descriptor_pool)
     : device{device_}, scheduler{scheduler_}, state_tracker{state_tracker_},
       one_texture_set_layout(device.GetLogical().CreateDescriptorSetLayout(

src/video_core/renderer_vulkan/blit_image.h

@@ -16,7 +16,7 @@ class Device;
 class Framebuffer;
 class ImageView;
 class StateTracker;
-class VKScheduler;
+class Scheduler;
 
 struct BlitImagePipelineKey {
     constexpr auto operator<=>(const BlitImagePipelineKey&) const noexcept = default;
@@ -27,7 +27,7 @@ struct BlitImagePipelineKey {
 
 class BlitImageHelper {
 public:
-    explicit BlitImageHelper(const Device& device, VKScheduler& scheduler,
+    explicit BlitImageHelper(const Device& device, Scheduler& scheduler,
                              StateTracker& state_tracker, DescriptorPool& descriptor_pool);
     ~BlitImageHelper();
 
@@ -82,7 +82,7 @@ private:
                                       vk::ShaderModule& module);
 
     const Device& device;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     StateTracker& state_tracker;
 
     vk::DescriptorSetLayout one_texture_set_layout;

src/video_core/renderer_vulkan/renderer_vulkan.h

@@ -65,12 +65,12 @@ private:
     vk::DebugUtilsMessenger debug_callback;
     vk::SurfaceKHR surface;
 
-    VKScreenInfo screen_info;
+    ScreenInfo screen_info;
 
     Device device;
     MemoryAllocator memory_allocator;
     StateTracker state_tracker;
-    VKScheduler scheduler;
+    Scheduler scheduler;
     VKSwapchain swapchain;
     BlitScreen blit_screen;
     RasterizerVulkan rasterizer;

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -120,8 +120,8 @@ struct BlitScreen::BufferData {
 
 BlitScreen::BlitScreen(Core::Memory::Memory& cpu_memory_, Core::Frontend::EmuWindow& render_window_,
                        const Device& device_, MemoryAllocator& memory_allocator_,
-                       VKSwapchain& swapchain_, VKScheduler& scheduler_,
-                       const VKScreenInfo& screen_info_)
+                       VKSwapchain& swapchain_, Scheduler& scheduler_,
+                       const ScreenInfo& screen_info_)
     : cpu_memory{cpu_memory_}, render_window{render_window_}, device{device_},
       memory_allocator{memory_allocator_}, swapchain{swapchain_}, scheduler{scheduler_},
       image_count{swapchain.GetImageCount()}, screen_info{screen_info_} {

src/video_core/renderer_vulkan/vk_blit_screen.h

@@ -35,10 +35,10 @@ struct ScreenInfo;
 class Device;
 class FSR;
 class RasterizerVulkan;
-class VKScheduler;
+class Scheduler;
 class VKSwapchain;
 
-struct VKScreenInfo {
+struct ScreenInfo {
     VkImageView image_view{};
     u32 width{};
     u32 height{};
@@ -49,8 +49,8 @@ class BlitScreen {
 public:
     explicit BlitScreen(Core::Memory::Memory& cpu_memory, Core::Frontend::EmuWindow& render_window,
                         const Device& device, MemoryAllocator& memory_manager,
-                        VKSwapchain& swapchain, VKScheduler& scheduler,
-                        const VKScreenInfo& screen_info);
+                        VKSwapchain& swapchain, Scheduler& scheduler,
+                        const ScreenInfo& screen_info);
     ~BlitScreen();
 
     void Recreate();
@@ -109,9 +109,9 @@ private:
     const Device& device;
     MemoryAllocator& memory_allocator;
     VKSwapchain& swapchain;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     const std::size_t image_count;
-    const VKScreenInfo& screen_info;
+    const ScreenInfo& screen_info;
 
     vk::ShaderModule vertex_shader;
     vk::ShaderModule fxaa_vertex_shader;

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -124,7 +124,7 @@ VkBufferView Buffer::View(u32 offset, u32 size, VideoCore::Surface::PixelFormat
 }
 
 BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& memory_allocator_,
-                                       VKScheduler& scheduler_, StagingBufferPool& staging_pool_,
+                                       Scheduler& scheduler_, StagingBufferPool& staging_pool_,
                                        VKUpdateDescriptorQueue& update_descriptor_queue_,
                                        DescriptorPool& descriptor_pool)
     : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -16,7 +16,7 @@ namespace Vulkan {
 
 class Device;
 class DescriptorPool;
-class VKScheduler;
+class Scheduler;
 
 class BufferCacheRuntime;
 
@@ -58,7 +58,7 @@ class BufferCacheRuntime {
 
 public:
     explicit BufferCacheRuntime(const Device& device_, MemoryAllocator& memory_manager_,
-                                VKScheduler& scheduler_, StagingBufferPool& staging_pool_,
+                                Scheduler& scheduler_, StagingBufferPool& staging_pool_,
                                 VKUpdateDescriptorQueue& update_descriptor_queue_,
                                 DescriptorPool& descriptor_pool);
 
@@ -124,7 +124,7 @@ private:
 
     const Device& device;
     MemoryAllocator& memory_allocator;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     StagingBufferPool& staging_pool;
     VKUpdateDescriptorQueue& update_descriptor_queue;
 

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -200,8 +200,8 @@ ComputePass::ComputePass(const Device& device_, DescriptorPool& descriptor_pool,
 
 ComputePass::~ComputePass() = default;
 
-Uint8Pass::Uint8Pass(const Device& device_, VKScheduler& scheduler_,
-                     DescriptorPool& descriptor_pool, StagingBufferPool& staging_buffer_pool_,
+Uint8Pass::Uint8Pass(const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool,
+                     StagingBufferPool& staging_buffer_pool_,
                      VKUpdateDescriptorQueue& update_descriptor_queue_)
     : ComputePass(device_, descriptor_pool, INPUT_OUTPUT_DESCRIPTOR_SET_BINDINGS,
                   INPUT_OUTPUT_DESCRIPTOR_UPDATE_TEMPLATE, INPUT_OUTPUT_BANK_INFO, {},
@@ -241,7 +241,7 @@ std::pair<VkBuffer, VkDeviceSize> Uint8Pass::Assemble(u32 num_vertices, VkBuffer
     return {staging.buffer, staging.offset};
 }
 
-QuadIndexedPass::QuadIndexedPass(const Device& device_, VKScheduler& scheduler_,
+QuadIndexedPass::QuadIndexedPass(const Device& device_, Scheduler& scheduler_,
                                  DescriptorPool& descriptor_pool_,
                                  StagingBufferPool& staging_buffer_pool_,
                                  VKUpdateDescriptorQueue& update_descriptor_queue_)
@@ -303,7 +303,7 @@ std::pair<VkBuffer, VkDeviceSize> QuadIndexedPass::Assemble(
     return {staging.buffer, staging.offset};
 }
 
-ASTCDecoderPass::ASTCDecoderPass(const Device& device_, VKScheduler& scheduler_,
+ASTCDecoderPass::ASTCDecoderPass(const Device& device_, Scheduler& scheduler_,
                                  DescriptorPool& descriptor_pool_,
                                  StagingBufferPool& staging_buffer_pool_,
                                  VKUpdateDescriptorQueue& update_descriptor_queue_,

src/video_core/renderer_vulkan/vk_compute_pass.h

@@ -20,7 +20,7 @@ namespace Vulkan {
 
 class Device;
 class StagingBufferPool;
-class VKScheduler;
+class Scheduler;
 class VKUpdateDescriptorQueue;
 class Image;
 struct StagingBufferRef;
@@ -48,7 +48,7 @@ private:
 
 class Uint8Pass final : public ComputePass {
 public:
-    explicit Uint8Pass(const Device& device_, VKScheduler& scheduler_,
+    explicit Uint8Pass(const Device& device_, Scheduler& scheduler_,
                        DescriptorPool& descriptor_pool_, StagingBufferPool& staging_buffer_pool_,
                        VKUpdateDescriptorQueue& update_descriptor_queue_);
     ~Uint8Pass();
@@ -59,14 +59,14 @@ public:
                                                u32 src_offset);
 
 private:
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     StagingBufferPool& staging_buffer_pool;
     VKUpdateDescriptorQueue& update_descriptor_queue;
 };
 
 class QuadIndexedPass final : public ComputePass {
 public:
-    explicit QuadIndexedPass(const Device& device_, VKScheduler& scheduler_,
+    explicit QuadIndexedPass(const Device& device_, Scheduler& scheduler_,
                              DescriptorPool& descriptor_pool_,
                              StagingBufferPool& staging_buffer_pool_,
                              VKUpdateDescriptorQueue& update_descriptor_queue_);
@@ -77,14 +77,14 @@ public:
         u32 base_vertex, VkBuffer src_buffer, u32 src_offset);
 
 private:
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     StagingBufferPool& staging_buffer_pool;
     VKUpdateDescriptorQueue& update_descriptor_queue;
 };
 
 class ASTCDecoderPass final : public ComputePass {
 public:
-    explicit ASTCDecoderPass(const Device& device_, VKScheduler& scheduler_,
+    explicit ASTCDecoderPass(const Device& device_, Scheduler& scheduler_,
                              DescriptorPool& descriptor_pool_,
                              StagingBufferPool& staging_buffer_pool_,
                              VKUpdateDescriptorQueue& update_descriptor_queue_,
@@ -95,7 +95,7 @@ public:
                   std::span<const VideoCommon::SwizzleParameters> swizzles);
 
 private:
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     StagingBufferPool& staging_buffer_pool;
     VKUpdateDescriptorQueue& update_descriptor_queue;
     MemoryAllocator& memory_allocator;

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -91,7 +91,7 @@ ComputePipeline::ComputePipeline(const Device& device_, DescriptorPool& descript
 }
 
 void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
-                                Tegra::MemoryManager& gpu_memory, VKScheduler& scheduler,
+                                Tegra::MemoryManager& gpu_memory, Scheduler& scheduler,
                                 BufferCache& buffer_cache, TextureCache& texture_cache) {
     update_descriptor_queue.Acquire();
 

src/video_core/renderer_vulkan/vk_compute_pipeline.h

@@ -24,7 +24,7 @@ namespace Vulkan {
 
 class Device;
 class PipelineStatistics;
-class VKScheduler;
+class Scheduler;
 
 class ComputePipeline {
 public:
@@ -42,7 +42,7 @@ public:
     ComputePipeline(const ComputePipeline&) = delete;
 
     void Configure(Tegra::Engines::KeplerCompute& kepler_compute, Tegra::MemoryManager& gpu_memory,
-                   VKScheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache);
+                   Scheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache);
 
 private:
     const Device& device;

src/video_core/renderer_vulkan/vk_descriptor_pool.cpp

@@ -121,7 +121,7 @@ vk::DescriptorSets DescriptorAllocator::AllocateDescriptors(size_t count) {
     throw vk::Exception(VK_ERROR_OUT_OF_POOL_MEMORY);
 }
 
-DescriptorPool::DescriptorPool(const Device& device_, VKScheduler& scheduler)
+DescriptorPool::DescriptorPool(const Device& device_, Scheduler& scheduler)
     : device{device_}, master_semaphore{scheduler.GetMasterSemaphore()} {}
 
 DescriptorPool::~DescriptorPool() = default;

src/video_core/renderer_vulkan/vk_descriptor_pool.h

@@ -14,7 +14,7 @@
 namespace Vulkan {
 
 class Device;
-class VKScheduler;
+class Scheduler;
 
 struct DescriptorBank;
 
@@ -62,7 +62,7 @@ private:
 
 class DescriptorPool {
 public:
-    explicit DescriptorPool(const Device& device, VKScheduler& scheduler);
+    explicit DescriptorPool(const Device& device, Scheduler& scheduler);
     ~DescriptorPool();
 
     DescriptorPool& operator=(const DescriptorPool&) = delete;

src/video_core/renderer_vulkan/vk_fence_manager.cpp

@@ -11,10 +11,10 @@
 
 namespace Vulkan {
 
-InnerFence::InnerFence(VKScheduler& scheduler_, u32 payload_, bool is_stubbed_)
+InnerFence::InnerFence(Scheduler& scheduler_, u32 payload_, bool is_stubbed_)
     : FenceBase{payload_, is_stubbed_}, scheduler{scheduler_} {}
 
-InnerFence::InnerFence(VKScheduler& scheduler_, GPUVAddr address_, u32 payload_, bool is_stubbed_)
+InnerFence::InnerFence(Scheduler& scheduler_, GPUVAddr address_, u32 payload_, bool is_stubbed_)
     : FenceBase{address_, payload_, is_stubbed_}, scheduler{scheduler_} {}
 
 InnerFence::~InnerFence() = default;
@@ -44,8 +44,7 @@ void InnerFence::Wait() {
 
 FenceManager::FenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
                            TextureCache& texture_cache_, BufferCache& buffer_cache_,
-                           VKQueryCache& query_cache_, const Device& device_,
-                           VKScheduler& scheduler_)
+                           VKQueryCache& query_cache_, const Device& device_, Scheduler& scheduler_)
     : GenericFenceManager{rasterizer_, gpu_, texture_cache_, buffer_cache_, query_cache_},
       scheduler{scheduler_} {}
 

src/video_core/renderer_vulkan/vk_fence_manager.h

@@ -21,12 +21,12 @@ namespace Vulkan {
 
 class Device;
 class VKQueryCache;
-class VKScheduler;
+class Scheduler;
 
 class InnerFence : public VideoCommon::FenceBase {
 public:
-    explicit InnerFence(VKScheduler& scheduler_, u32 payload_, bool is_stubbed_);
-    explicit InnerFence(VKScheduler& scheduler_, GPUVAddr address_, u32 payload_, bool is_stubbed_);
+    explicit InnerFence(Scheduler& scheduler_, u32 payload_, bool is_stubbed_);
+    explicit InnerFence(Scheduler& scheduler_, GPUVAddr address_, u32 payload_, bool is_stubbed_);
     ~InnerFence();
 
     void Queue();
@@ -36,7 +36,7 @@ public:
     void Wait();
 
 private:
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     u64 wait_tick = 0;
 };
 using Fence = std::shared_ptr<InnerFence>;
@@ -48,7 +48,7 @@ class FenceManager final : public GenericFenceManager {
 public:
     explicit FenceManager(VideoCore::RasterizerInterface& rasterizer, Tegra::GPU& gpu,
                           TextureCache& texture_cache, BufferCache& buffer_cache,
-                          VKQueryCache& query_cache, const Device& device, VKScheduler& scheduler);
+                          VKQueryCache& query_cache, const Device& device, Scheduler& scheduler);
 
 protected:
     Fence CreateFence(u32 value, bool is_stubbed) override;
@@ -58,7 +58,7 @@ protected:
     void WaitFence(Fence& fence) override;
 
 private:
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_fsr.cpp

@@ -172,7 +172,7 @@ FSR::FSR(const Device& device_, MemoryAllocator& memory_allocator_, size_t image
     CreatePipeline();
 }
 
-VkImageView FSR::Draw(VKScheduler& scheduler, size_t image_index, VkImageView image_view,
+VkImageView FSR::Draw(Scheduler& scheduler, size_t image_index, VkImageView image_view,
                       VkExtent2D input_image_extent, const Common::Rectangle<int>& crop_rect) {
 
     UpdateDescriptorSet(image_index, image_view);

src/video_core/renderer_vulkan/vk_fsr.h

@@ -10,13 +10,13 @@
 namespace Vulkan {
 
 class Device;
-class VKScheduler;
+class Scheduler;
 
 class FSR {
 public:
     explicit FSR(const Device& device, MemoryAllocator& memory_allocator, size_t image_count,
                  VkExtent2D output_size);
-    VkImageView Draw(VKScheduler& scheduler, size_t image_index, VkImageView image_view,
+    VkImageView Draw(Scheduler& scheduler, size_t image_index, VkImageView image_view,
                      VkExtent2D input_image_extent, const Common::Rectangle<int>& crop_rect);
 
 private:

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -215,8 +215,8 @@ ConfigureFuncPtr ConfigureFunc(const std::array<vk::ShaderModule, NUM_STAGES>& m
 } // Anonymous namespace
 
 GraphicsPipeline::GraphicsPipeline(
-    Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-    VKScheduler& scheduler_, BufferCache& buffer_cache_, TextureCache& texture_cache_,
+    Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_, Scheduler& scheduler_,
+    BufferCache& buffer_cache_, TextureCache& texture_cache_,
     VideoCore::ShaderNotify* shader_notify, const Device& device_, DescriptorPool& descriptor_pool,
     VKUpdateDescriptorQueue& update_descriptor_queue_, Common::ThreadWorker* worker_thread,
     PipelineStatistics* pipeline_statistics, RenderPassCache& render_pass_cache,

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -62,7 +62,7 @@ class Device;
 class PipelineStatistics;
 class RenderPassCache;
 class RescalingPushConstant;
-class VKScheduler;
+class Scheduler;
 class VKUpdateDescriptorQueue;
 
 class GraphicsPipeline {
@@ -71,7 +71,7 @@ class GraphicsPipeline {
 public:
     explicit GraphicsPipeline(
         Tegra::Engines::Maxwell3D& maxwell3d, Tegra::MemoryManager& gpu_memory,
-        VKScheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache,
+        Scheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache,
         VideoCore::ShaderNotify* shader_notify, const Device& device,
         DescriptorPool& descriptor_pool, VKUpdateDescriptorQueue& update_descriptor_queue,
         Common::ThreadWorker* worker_thread, PipelineStatistics* pipeline_statistics,
@@ -125,7 +125,7 @@ private:
     const Device& device;
     TextureCache& texture_cache;
     BufferCache& buffer_cache;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     VKUpdateDescriptorQueue& update_descriptor_queue;
 
     void (*configure_func)(GraphicsPipeline*, bool){};

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -262,7 +262,7 @@ bool GraphicsPipelineCacheKey::operator==(const GraphicsPipelineCacheKey& rhs) c
 PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, Tegra::Engines::Maxwell3D& maxwell3d_,
                              Tegra::Engines::KeplerCompute& kepler_compute_,
                              Tegra::MemoryManager& gpu_memory_, const Device& device_,
-                             VKScheduler& scheduler_, DescriptorPool& descriptor_pool_,
+                             Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
                              VKUpdateDescriptorQueue& update_descriptor_queue_,
                              RenderPassCache& render_pass_cache_, BufferCache& buffer_cache_,
                              TextureCache& texture_cache_, VideoCore::ShaderNotify& shader_notify_)

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -81,7 +81,7 @@ class Device;
 class PipelineStatistics;
 class RasterizerVulkan;
 class RenderPassCache;
-class VKScheduler;
+class Scheduler;
 class VKUpdateDescriptorQueue;
 
 using VideoCommon::ShaderInfo;
@@ -103,7 +103,7 @@ public:
     explicit PipelineCache(RasterizerVulkan& rasterizer, Tegra::Engines::Maxwell3D& maxwell3d,
                            Tegra::Engines::KeplerCompute& kepler_compute,
                            Tegra::MemoryManager& gpu_memory, const Device& device,
-                           VKScheduler& scheduler, DescriptorPool& descriptor_pool,
+                           Scheduler& scheduler, DescriptorPool& descriptor_pool,
                            VKUpdateDescriptorQueue& update_descriptor_queue,
                            RenderPassCache& render_pass_cache, BufferCache& buffer_cache,
                            TextureCache& texture_cache, VideoCore::ShaderNotify& shader_notify_);
@@ -138,7 +138,7 @@ private:
                                                            bool build_in_parallel);
 
     const Device& device;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     DescriptorPool& descriptor_pool;
     VKUpdateDescriptorQueue& update_descriptor_queue;
     RenderPassCache& render_pass_cache;

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -26,7 +26,7 @@ constexpr VkQueryType GetTarget(QueryType type) {
 
 } // Anonymous namespace
 
-QueryPool::QueryPool(const Device& device_, VKScheduler& scheduler, QueryType type_)
+QueryPool::QueryPool(const Device& device_, Scheduler& scheduler, QueryType type_)
     : ResourcePool{scheduler.GetMasterSemaphore(), GROW_STEP}, device{device_}, type{type_} {}
 
 QueryPool::~QueryPool() = default;
@@ -67,7 +67,7 @@ void QueryPool::Reserve(std::pair<VkQueryPool, u32> query) {
 
 VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
                            Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-                           const Device& device_, VKScheduler& scheduler_)
+                           const Device& device_, Scheduler& scheduler_)
     : QueryCacheBase{rasterizer_, maxwell3d_, gpu_memory_}, device{device_}, scheduler{scheduler_},
       query_pools{
           QueryPool{device_, scheduler_, QueryType::SamplesPassed},

src/video_core/renderer_vulkan/vk_query_cache.h

@@ -23,13 +23,13 @@ class CachedQuery;
 class Device;
 class HostCounter;
 class VKQueryCache;
-class VKScheduler;
+class Scheduler;
 
 using CounterStream = VideoCommon::CounterStreamBase<VKQueryCache, HostCounter>;
 
 class QueryPool final : public ResourcePool {
 public:
-    explicit QueryPool(const Device& device, VKScheduler& scheduler, VideoCore::QueryType type);
+    explicit QueryPool(const Device& device, Scheduler& scheduler, VideoCore::QueryType type);
     ~QueryPool() override;
 
     std::pair<VkQueryPool, u32> Commit();
@@ -54,7 +54,7 @@ class VKQueryCache final
 public:
     explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
                           Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-                          const Device& device_, VKScheduler& scheduler_);
+                          const Device& device_, Scheduler& scheduler_);
     ~VKQueryCache();
 
     std::pair<VkQueryPool, u32> AllocateQuery(VideoCore::QueryType type);
@@ -65,13 +65,13 @@ public:
         return device;
     }
 
-    VKScheduler& GetScheduler() const noexcept {
+    Scheduler& GetScheduler() const noexcept {
         return scheduler;
     }
 
 private:
     const Device& device;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     std::array<QueryPool, VideoCore::NumQueryTypes> query_pools;
 };
 

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -142,9 +142,9 @@ DrawParams MakeDrawParams(const Maxwell& regs, u32 num_instances, bool is_instan
 
 RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                                    Tegra::MemoryManager& gpu_memory_,
-                                   Core::Memory::Memory& cpu_memory_, VKScreenInfo& screen_info_,
+                                   Core::Memory::Memory& cpu_memory_, ScreenInfo& screen_info_,
                                    const Device& device_, MemoryAllocator& memory_allocator_,
-                                   StateTracker& state_tracker_, VKScheduler& scheduler_)
+                                   StateTracker& state_tracker_, Scheduler& scheduler_)
     : RasterizerAccelerated{cpu_memory_}, gpu{gpu_},
       gpu_memory{gpu_memory_}, maxwell3d{gpu.Maxwell3D()}, kepler_compute{gpu.KeplerCompute()},
       screen_info{screen_info_}, device{device_}, memory_allocator{memory_allocator_},

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -38,7 +38,7 @@ class Maxwell3D;
 
 namespace Vulkan {
 
-struct VKScreenInfo;
+struct ScreenInfo;
 
 class StateTracker;
 
@@ -58,9 +58,9 @@ class RasterizerVulkan final : public VideoCore::RasterizerAccelerated {
 public:
     explicit RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                               Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
-                              VKScreenInfo& screen_info_, const Device& device_,
+                              ScreenInfo& screen_info_, const Device& device_,
                               MemoryAllocator& memory_allocator_, StateTracker& state_tracker_,
-                              VKScheduler& scheduler_);
+                              Scheduler& scheduler_);
     ~RasterizerVulkan() override;
 
     void Draw(bool is_indexed, bool is_instanced) override;
@@ -138,11 +138,11 @@ private:
     Tegra::Engines::Maxwell3D& maxwell3d;
     Tegra::Engines::KeplerCompute& kepler_compute;
 
-    VKScreenInfo& screen_info;
+    ScreenInfo& screen_info;
     const Device& device;
     MemoryAllocator& memory_allocator;
     StateTracker& state_tracker;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
 
     StagingBufferPool staging_pool;
     DescriptorPool descriptor_pool;

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -21,7 +21,7 @@ namespace Vulkan {
 
 MICROPROFILE_DECLARE(Vulkan_WaitForWorker);
 
-void VKScheduler::CommandChunk::ExecuteAll(vk::CommandBuffer cmdbuf) {
+void Scheduler::CommandChunk::ExecuteAll(vk::CommandBuffer cmdbuf) {
     auto command = first;
     while (command != nullptr) {
         auto next = command->GetNext();
@@ -35,7 +35,7 @@ void VKScheduler::CommandChunk::ExecuteAll(vk::CommandBuffer cmdbuf) {
     last = nullptr;
 }
 
-VKScheduler::VKScheduler(const Device& device_, StateTracker& state_tracker_)
+Scheduler::Scheduler(const Device& device_, StateTracker& state_tracker_)
     : device{device_}, state_tracker{state_tracker_},
       master_semaphore{std::make_unique<MasterSemaphore>(device)},
       command_pool{std::make_unique<CommandPool>(*master_semaphore, device)} {
@@ -44,14 +44,14 @@ VKScheduler::VKScheduler(const Device& device_, StateTracker& state_tracker_)
     worker_thread = std::jthread([this](std::stop_token token) { WorkerThread(token); });
 }
 
-VKScheduler::~VKScheduler() = default;
+Scheduler::~Scheduler() = default;
 
-void VKScheduler::Flush(VkSemaphore signal_semaphore, VkSemaphore wait_semaphore) {
+void Scheduler::Flush(VkSemaphore signal_semaphore, VkSemaphore wait_semaphore) {
     SubmitExecution(signal_semaphore, wait_semaphore);
     AllocateNewContext();
 }
 
-void VKScheduler::Finish(VkSemaphore signal_semaphore, VkSemaphore wait_semaphore) {
+void Scheduler::Finish(VkSemaphore signal_semaphore, VkSemaphore wait_semaphore) {
     const u64 presubmit_tick = CurrentTick();
     SubmitExecution(signal_semaphore, wait_semaphore);
     WaitWorker();
@@ -59,7 +59,7 @@ void VKScheduler::Finish(VkSemaphore signal_semaphore, VkSemaphore wait_semaphor
     AllocateNewContext();
 }
 
-void VKScheduler::WaitWorker() {
+void Scheduler::WaitWorker() {
     MICROPROFILE_SCOPE(Vulkan_WaitForWorker);
     DispatchWork();
 
@@ -67,7 +67,7 @@ void VKScheduler::WaitWorker() {
     wait_cv.wait(lock, [this] { return work_queue.empty(); });
 }
 
-void VKScheduler::DispatchWork() {
+void Scheduler::DispatchWork() {
     if (chunk->Empty()) {
         return;
     }
@@ -79,7 +79,7 @@ void VKScheduler::DispatchWork() {
     AcquireNewChunk();
 }
 
-void VKScheduler::RequestRenderpass(const Framebuffer* framebuffer) {
+void Scheduler::RequestRenderpass(const Framebuffer* framebuffer) {
     const VkRenderPass renderpass = framebuffer->RenderPass();
     const VkFramebuffer framebuffer_handle = framebuffer->Handle();
     const VkExtent2D render_area = framebuffer->RenderArea();
@@ -114,11 +114,11 @@ void VKScheduler::RequestRenderpass(const Framebuffer* framebuffer) {
     renderpass_image_ranges = framebuffer->ImageRanges();
 }
 
-void VKScheduler::RequestOutsideRenderPassOperationContext() {
+void Scheduler::RequestOutsideRenderPassOperationContext() {
     EndRenderPass();
 }
 
-bool VKScheduler::UpdateGraphicsPipeline(GraphicsPipeline* pipeline) {
+bool Scheduler::UpdateGraphicsPipeline(GraphicsPipeline* pipeline) {
     if (state.graphics_pipeline == pipeline) {
         return false;
     }
@@ -126,7 +126,7 @@ bool VKScheduler::UpdateGraphicsPipeline(GraphicsPipeline* pipeline) {
     return true;
 }
 
-bool VKScheduler::UpdateRescaling(bool is_rescaling) {
+bool Scheduler::UpdateRescaling(bool is_rescaling) {
     if (state.rescaling_defined && is_rescaling == state.is_rescaling) {
         return false;
     }
@@ -135,7 +135,7 @@ bool VKScheduler::UpdateRescaling(bool is_rescaling) {
     return true;
 }
 
-void VKScheduler::WorkerThread(std::stop_token stop_token) {
+void Scheduler::WorkerThread(std::stop_token stop_token) {
     Common::SetCurrentThreadName("yuzu:VulkanWorker");
     do {
         std::unique_ptr<CommandChunk> work;
@@ -161,7 +161,7 @@ void VKScheduler::WorkerThread(std::stop_token stop_token) {
     } while (!stop_token.stop_requested());
 }
 
-void VKScheduler::AllocateWorkerCommandBuffer() {
+void Scheduler::AllocateWorkerCommandBuffer() {
     current_cmdbuf = vk::CommandBuffer(command_pool->Commit(), device.GetDispatchLoader());
     current_cmdbuf.Begin({
         .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
@@ -171,7 +171,7 @@ void VKScheduler::AllocateWorkerCommandBuffer() {
     });
 }
 
-void VKScheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_semaphore) {
+void Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_semaphore) {
     EndPendingOperations();
     InvalidateState();
 
@@ -225,25 +225,25 @@ void VKScheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait
     DispatchWork();
 }
 
-void VKScheduler::AllocateNewContext() {
+void Scheduler::AllocateNewContext() {
     // Enable counters once again. These are disabled when a command buffer is finished.
     if (query_cache) {
         query_cache->UpdateCounters();
     }
 }
 
-void VKScheduler::InvalidateState() {
+void Scheduler::InvalidateState() {
     state.graphics_pipeline = nullptr;
     state.rescaling_defined = false;
     state_tracker.InvalidateCommandBufferState();
 }
 
-void VKScheduler::EndPendingOperations() {
+void Scheduler::EndPendingOperations() {
     query_cache->DisableStreams();
     EndRenderPass();
 }
 
-void VKScheduler::EndRenderPass() {
+void Scheduler::EndRenderPass() {
     if (!state.renderpass) {
         return;
     }
@@ -280,7 +280,7 @@ void VKScheduler::EndRenderPass() {
     num_renderpass_images = 0;
 }
 
-void VKScheduler::AcquireNewChunk() {
+void Scheduler::AcquireNewChunk() {
     std::scoped_lock lock{reserve_mutex};
     if (chunk_reserve.empty()) {
         chunk = std::make_unique<CommandChunk>();

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -26,10 +26,10 @@ class VKQueryCache;
 
 /// The scheduler abstracts command buffer and fence management with an interface that's able to do
 /// OpenGL-like operations on Vulkan command buffers.
-class VKScheduler {
+class Scheduler {
 public:
-    explicit VKScheduler(const Device& device, StateTracker& state_tracker);
-    ~VKScheduler();
+    explicit Scheduler(const Device& device, StateTracker& state_tracker);
+    ~Scheduler();
 
     /// Sends the current execution context to the GPU.
     void Flush(VkSemaphore signal_semaphore = nullptr, VkSemaphore wait_semaphore = nullptr);

src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp

@@ -85,7 +85,7 @@ size_t Region(size_t iterator) noexcept {
 } // Anonymous namespace
 
 StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& memory_allocator_,
-                                     VKScheduler& scheduler_)
+                                     Scheduler& scheduler_)
     : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_} {
     const vk::Device& dev = device.GetLogical();
     stream_buffer = dev.CreateBuffer(VkBufferCreateInfo{

src/video_core/renderer_vulkan/vk_staging_buffer_pool.h

@@ -14,7 +14,7 @@
 namespace Vulkan {
 
 class Device;
-class VKScheduler;
+class Scheduler;
 
 struct StagingBufferRef {
     VkBuffer buffer;
@@ -27,7 +27,7 @@ public:
     static constexpr size_t NUM_SYNCS = 16;
 
     explicit StagingBufferPool(const Device& device, MemoryAllocator& memory_allocator,
-                               VKScheduler& scheduler);
+                               Scheduler& scheduler);
     ~StagingBufferPool();
 
     StagingBufferRef Request(size_t size, MemoryUsage usage);
@@ -82,7 +82,7 @@ private:
 
     const Device& device;
     MemoryAllocator& memory_allocator;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
 
     vk::Buffer stream_buffer;
     vk::DeviceMemory stream_memory;

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -64,7 +64,7 @@ VkExtent2D ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, u32 wi
 
 } // Anonymous namespace
 
-VKSwapchain::VKSwapchain(VkSurfaceKHR surface_, const Device& device_, VKScheduler& scheduler_,
+VKSwapchain::VKSwapchain(VkSurfaceKHR surface_, const Device& device_, Scheduler& scheduler_,
                          u32 width, u32 height, bool srgb)
     : surface{surface_}, device{device_}, scheduler{scheduler_} {
     Create(width, height, srgb);

src/video_core/renderer_vulkan/vk_swapchain.h

@@ -15,11 +15,11 @@ struct FramebufferLayout;
 namespace Vulkan {
 
 class Device;
-class VKScheduler;
+class Scheduler;
 
 class VKSwapchain {
 public:
-    explicit VKSwapchain(VkSurfaceKHR surface, const Device& device, VKScheduler& scheduler,
+    explicit VKSwapchain(VkSurfaceKHR surface, const Device& device, Scheduler& scheduler,
                          u32 width, u32 height, bool srgb);
     ~VKSwapchain();
 
@@ -94,7 +94,7 @@ private:
 
     const VkSurfaceKHR surface;
     const Device& device;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
 
     vk::SwapchainKHR swapchain;
 

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -648,7 +648,7 @@ struct RangedBarrierRange {
     return VK_FORMAT_R32_UINT;
 }
 
-void BlitScale(VKScheduler& scheduler, VkImage src_image, VkImage dst_image, const ImageInfo& info,
+void BlitScale(Scheduler& scheduler, VkImage src_image, VkImage dst_image, const ImageInfo& info,
                VkImageAspectFlags aspect_mask, const Settings::ResolutionScalingInfo& resolution,
                bool up_scaling = true) {
     const bool is_2d = info.type == ImageType::e2D;
@@ -788,7 +788,7 @@ void BlitScale(VKScheduler& scheduler, VkImage src_image, VkImage dst_image, con
 }
 } // Anonymous namespace
 
-TextureCacheRuntime::TextureCacheRuntime(const Device& device_, VKScheduler& scheduler_,
+TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& scheduler_,
                                          MemoryAllocator& memory_allocator_,
                                          StagingBufferPool& staging_buffer_pool_,
                                          BlitImageHelper& blit_image_helper_,

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -33,11 +33,11 @@ class ImageView;
 class Framebuffer;
 class RenderPassCache;
 class StagingBufferPool;
-class VKScheduler;
+class Scheduler;
 
 class TextureCacheRuntime {
 public:
-    explicit TextureCacheRuntime(const Device& device_, VKScheduler& scheduler_,
+    explicit TextureCacheRuntime(const Device& device_, Scheduler& scheduler_,
                                  MemoryAllocator& memory_allocator_,
                                  StagingBufferPool& staging_buffer_pool_,
                                  BlitImageHelper& blit_image_helper_,
@@ -93,7 +93,7 @@ public:
     [[nodiscard]] VkBuffer GetTemporaryBuffer(size_t needed_size);
 
     const Device& device;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
     MemoryAllocator& memory_allocator;
     StagingBufferPool& staging_buffer_pool;
     BlitImageHelper& blit_image_helper;
@@ -154,7 +154,7 @@ private:
 
     bool NeedsScaleHelper() const;
 
-    VKScheduler* scheduler{};
+    Scheduler* scheduler{};
     TextureCacheRuntime* runtime{};
 
     vk::Image original_image;

src/video_core/renderer_vulkan/vk_update_descriptor.cpp

@@ -12,7 +12,7 @@
 
 namespace Vulkan {
 
-VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const Device& device_, VKScheduler& scheduler_)
+VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const Device& device_, Scheduler& scheduler_)
     : device{device_}, scheduler{scheduler_} {
     payload_cursor = payload.data();
 }

src/video_core/renderer_vulkan/vk_update_descriptor.h

@@ -10,7 +10,7 @@
 namespace Vulkan {
 
 class Device;
-class VKScheduler;
+class Scheduler;
 
 struct DescriptorUpdateEntry {
     struct Empty {};
@@ -30,7 +30,7 @@ struct DescriptorUpdateEntry {
 
 class VKUpdateDescriptorQueue final {
 public:
-    explicit VKUpdateDescriptorQueue(const Device& device_, VKScheduler& scheduler_);
+    explicit VKUpdateDescriptorQueue(const Device& device_, Scheduler& scheduler_);
     ~VKUpdateDescriptorQueue();
 
     void TickFrame();
@@ -71,7 +71,7 @@ public:
 
 private:
     const Device& device;
-    VKScheduler& scheduler;
+    Scheduler& scheduler;
 
     DescriptorUpdateEntry* payload_cursor = nullptr;
     const DescriptorUpdateEntry* upload_start = nullptr;