video_core: Replace VKQueryCache with QueryCache

src/video_core/renderer_vulkan/vk_fence_manager.cpp

@@ -44,7 +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_, Scheduler& scheduler_)
+                           QueryCache& 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

@@ -20,7 +20,7 @@ class RasterizerInterface;
 namespace Vulkan {
 
 class Device;
-class VKQueryCache;
+class QueryCache;
 class Scheduler;
 
 class InnerFence : public VideoCommon::FenceBase {
@@ -41,14 +41,13 @@ private:
 };
 using Fence = std::shared_ptr<InnerFence>;
 
-using GenericFenceManager =
-    VideoCommon::FenceManager<Fence, TextureCache, BufferCache, VKQueryCache>;
+using GenericFenceManager = VideoCommon::FenceManager<Fence, TextureCache, BufferCache, QueryCache>;
 
 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, Scheduler& scheduler);
+                          QueryCache& query_cache, const Device& device, Scheduler& scheduler);
 
 protected:
     Fence CreateFence(u32 value, bool is_stubbed) override;

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -65,15 +65,15 @@ void QueryPool::Reserve(std::pair<VkQueryPool, u32> query) {
     usage[pool_index * GROW_STEP + static_cast<std::ptrdiff_t>(query.second)] = false;
 }
 
-VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
-                           Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-                           const Device& device_, Scheduler& scheduler_)
+QueryCache::QueryCache(VideoCore::RasterizerInterface& rasterizer_,
+                       Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
+                       const Device& device_, Scheduler& scheduler_)
     : QueryCacheBase{rasterizer_, maxwell3d_, gpu_memory_}, device{device_}, scheduler{scheduler_},
       query_pools{
           QueryPool{device_, scheduler_, QueryType::SamplesPassed},
       } {}
 
-VKQueryCache::~VKQueryCache() {
+QueryCache::~QueryCache() {
     // TODO(Rodrigo): This is a hack to destroy all HostCounter instances before the base class
     // destructor is called. The query cache should be redesigned to have a proper ownership model
     // instead of using shared pointers.
@@ -84,15 +84,15 @@ VKQueryCache::~VKQueryCache() {
     }
 }
 
-std::pair<VkQueryPool, u32> VKQueryCache::AllocateQuery(QueryType type) {
+std::pair<VkQueryPool, u32> QueryCache::AllocateQuery(QueryType type) {
     return query_pools[static_cast<std::size_t>(type)].Commit();
 }
 
-void VKQueryCache::Reserve(QueryType type, std::pair<VkQueryPool, u32> query) {
+void QueryCache::Reserve(QueryType type, std::pair<VkQueryPool, u32> query) {
     query_pools[static_cast<std::size_t>(type)].Reserve(query);
 }
 
-HostCounter::HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
+HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
                          QueryType type_)
     : HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_},
       query{cache_.AllocateQuery(type_)}, tick{cache_.GetScheduler().CurrentTick()} {

src/video_core/renderer_vulkan/vk_query_cache.h

@@ -22,10 +22,10 @@ namespace Vulkan {
 class CachedQuery;
 class Device;
 class HostCounter;
-class VKQueryCache;
+class QueryCache;
 class Scheduler;
 
-using CounterStream = VideoCommon::CounterStreamBase<VKQueryCache, HostCounter>;
+using CounterStream = VideoCommon::CounterStreamBase<QueryCache, HostCounter>;
 
 class QueryPool final : public ResourcePool {
 public:
@@ -49,13 +49,13 @@ private:
     std::vector<bool> usage;
 };
 
-class VKQueryCache final
-    : public VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter> {
+class QueryCache final
+    : public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter> {
 public:
-    explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
-                          Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-                          const Device& device_, Scheduler& scheduler_);
-    ~VKQueryCache();
+    explicit QueryCache(VideoCore::RasterizerInterface& rasterizer_,
+                        Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
+                        const Device& device_, Scheduler& scheduler_);
+    ~QueryCache();
 
     std::pair<VkQueryPool, u32> AllocateQuery(VideoCore::QueryType type);
 
@@ -75,9 +75,9 @@ private:
     std::array<QueryPool, VideoCore::NumQueryTypes> query_pools;
 };
 
-class HostCounter final : public VideoCommon::HostCounterBase<VKQueryCache, HostCounter> {
+class HostCounter final : public VideoCommon::HostCounterBase<QueryCache, HostCounter> {
 public:
-    explicit HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
+    explicit HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
                          VideoCore::QueryType type_);
     ~HostCounter();
 
@@ -86,7 +86,7 @@ public:
 private:
     u64 BlockingQuery() const override;
 
-    VKQueryCache& cache;
+    QueryCache& cache;
     const VideoCore::QueryType type;
     const std::pair<VkQueryPool, u32> query;
     const u64 tick;
@@ -94,7 +94,7 @@ private:
 
 class CachedQuery : public VideoCommon::CachedQueryBase<HostCounter> {
 public:
-    explicit CachedQuery(VKQueryCache&, VideoCore::QueryType, VAddr cpu_addr_, u8* host_ptr_)
+    explicit CachedQuery(QueryCache&, VideoCore::QueryType, VAddr cpu_addr_, u8* host_ptr_)
         : CachedQueryBase{cpu_addr_, host_ptr_} {}
 };
 

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -156,7 +156,7 @@ private:
     BufferCacheRuntime buffer_cache_runtime;
     BufferCache buffer_cache;
     PipelineCache pipeline_cache;
-    VKQueryCache query_cache;
+    QueryCache query_cache;
     AccelerateDMA accelerate_dma;
     FenceManager fence_manager;
 

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -22,7 +22,7 @@ class Device;
 class Framebuffer;
 class GraphicsPipeline;
 class StateTracker;
-class VKQueryCache;
+class QueryCache;
 
 /// The scheduler abstracts command buffer and fence management with an interface that's able to do
 /// OpenGL-like operations on Vulkan command buffers.
@@ -61,7 +61,7 @@ public:
     void InvalidateState();
 
     /// Assigns the query cache.
-    void SetQueryCache(VKQueryCache& query_cache_) {
+    void SetQueryCache(QueryCache& query_cache_) {
         query_cache = &query_cache_;
     }
 
@@ -212,7 +212,7 @@ private:
     std::unique_ptr<MasterSemaphore> master_semaphore;
     std::unique_ptr<CommandPool> command_pool;
 
-    VKQueryCache* query_cache = nullptr;
+    QueryCache* query_cache = nullptr;
 
     vk::CommandBuffer current_cmdbuf;