Merge branch 'master' into fix-cmake-sdl2

CMakeLists.txt

@@ -151,15 +151,16 @@ if (ENABLE_SDL2)
         set(SDL2_INCLUDE_DIR "${SDL2_PREFIX}/include" CACHE PATH "Path to SDL2 headers")
         set(SDL2_LIBRARY "${SDL2_PREFIX}/lib/x64/SDL2.lib" CACHE PATH "Path to SDL2 library")
         set(SDL2_DLL_DIR "${SDL2_PREFIX}/lib/x64/" CACHE PATH "Path to SDL2.dll")
-    else()
-        find_package(SDL2 REQUIRED)
-    endif()
 
-    if (SDL2_FOUND)
-        # TODO(yuriks): Make FindSDL2.cmake export an IMPORTED library instead
         add_library(SDL2 INTERFACE)
         target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARY}")
         target_include_directories(SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
+    else()
+        find_package(SDL2 REQUIRED)
+        include_directories(${SDL2_INCLUDE_DIRS})
+
+        add_library(SDL2 INTERFACE)
+        target_link_libraries(SDL2 INTERFACE "${SDL2_LIBRARIES}")
     endif()
 else()
     set(SDL2_FOUND NO)

externals/cmake-modules/FindSDL2.cmake

@@ -1,239 +0,0 @@
-
-# This module defines
-# SDL2_LIBRARY, the name of the library to link against
-# SDL2_FOUND, if false, do not try to link to SDL2
-# SDL2_INCLUDE_DIR, where to find SDL.h
-# SDL2_DLL_DIR, where to find SDL2.dll if it exists
-#
-# This module responds to the the flag:
-# SDL2_BUILDING_LIBRARY
-# If this is defined, then no SDL2main will be linked in because
-# only applications need main().
-# Otherwise, it is assumed you are building an application and this
-# module will attempt to locate and set the the proper link flags
-# as part of the returned SDL2_LIBRARY variable.
-#
-# Don't forget to include SDLmain.h and SDLmain.m your project for the
-# OS X framework based version. (Other versions link to -lSDL2main which
-# this module will try to find on your behalf.) Also for OS X, this
-# module will automatically add the -framework Cocoa on your behalf.
-#
-#
-# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
-# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
-# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
-# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
-# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
-# as appropriate. These values are used to generate the final SDL2_LIBRARY
-# variable, but when these values are unset, SDL2_LIBRARY does not get created.
-#
-#
-# $SDL2DIR is an environment variable that would
-# correspond to the ./configure --prefix=$SDL2DIR
-# used in building SDL2.
-# l.e.galup  9-20-02
-#
-# Modified by Eric Wing.
-# Added code to assist with automated building by using environmental variables
-# and providing a more controlled/consistent search behavior.
-# Added new modifications to recognize OS X frameworks and
-# additional Unix paths (FreeBSD, etc).
-# Also corrected the header search path to follow "proper" SDL guidelines.
-# Added a search for SDL2main which is needed by some platforms.
-# Added a search for threads which is needed by some platforms.
-# Added needed compile switches for MinGW.
-#
-# On OSX, this will prefer the Framework version (if found) over others.
-# People will have to manually change the cache values of
-# SDL2_LIBRARY to override this selection or set the CMake environment
-# CMAKE_INCLUDE_PATH to modify the search paths.
-#
-# Note that the header path has changed from SDL2/SDL.h to just SDL.h
-# This needed to change because "proper" SDL convention
-# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
-# reasons because not all systems place things in SDL2/ (see FreeBSD).
-
-#=============================================================================
-# Copyright 2003-2009 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License").
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# CMake - Cross Platform Makefile Generator
-# Copyright 2000-2016 Kitware, Inc.
-# Copyright 2000-2011 Insight Software Consortium
-# All rights reserved.
-# 
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-# 
-# * Redistributions of source code must retain the above copyright
-#   notice, this list of conditions and the following disclaimer.
-# 
-# * Redistributions in binary form must reproduce the above copyright
-#   notice, this list of conditions and the following disclaimer in the
-#   documentation and/or other materials provided with the distribution.
-# 
-# * Neither the names of Kitware, Inc., the Insight Software Consortium,
-#   nor the names of their contributors may be used to endorse or promote
-#   products derived from this software without specific prior written
-#   permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-# 
-# ------------------------------------------------------------------------------
-# 
-# The above copyright and license notice applies to distributions of
-# CMake in source and binary form.  Some source files contain additional
-# notices of original copyright by their contributors; see each source
-# for details.  Third-party software packages supplied with CMake under
-# compatible licenses provide their own copyright notices documented in
-# corresponding subdirectories.
-# 
-# ------------------------------------------------------------------------------
-# 
-# CMake was initially developed by Kitware with the following sponsorship:
-# 
-#  * National Library of Medicine at the National Institutes of Health
-#    as part of the Insight Segmentation and Registration Toolkit (ITK).
-# 
-#  * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel
-#    Visualization Initiative.
-# 
-#  * National Alliance for Medical Image Computing (NAMIC) is funded by the
-#    National Institutes of Health through the NIH Roadmap for Medical Research,
-#    Grant U54 EB005149.
-# 
-#  * Kitware, Inc.
-#
-
-message("<FindSDL2.cmake>")
-
-SET(SDL2_SEARCH_PATHS
-    ~/Library/Frameworks
-    /Library/Frameworks
-    /usr/local
-    /usr
-    /sw # Fink
-    /opt/local # DarwinPorts
-    /opt/csw # Blastwave
-    /opt
-    ${SDL2_PATH}
-)
-
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    set(VC_LIB_PATH_SUFFIX lib/x64)
-else()
-    set(VC_LIB_PATH_SUFFIX lib/x86)
-endif()
-
-FIND_LIBRARY(SDL2_LIBRARY_TEMP
-    NAMES SDL2
-    HINTS
-    $ENV{SDL2DIR}
-    PATH_SUFFIXES lib64 lib ${VC_LIB_PATH_SUFFIX}
-    PATHS ${SDL2_SEARCH_PATHS}
-)
-
-IF(SDL2_LIBRARY_TEMP)
-    if(MSVC)
-        get_filename_component(SDL2_DLL_DIR_TEMP ${SDL2_LIBRARY_TEMP} DIRECTORY)
-        if(EXISTS ${SDL2_DLL_DIR_TEMP}/SDL2.dll)
-            set(SDL2_DLL_DIR ${SDL2_DLL_DIR_TEMP})
-            unset(SDL2_DLL_DIR_TEMP)
-        endif()
-    endif()
-
-    FIND_PATH(SDL2_INCLUDE_DIR SDL.h
-        HINTS
-        $ENV{SDL2DIR}
-        PATH_SUFFIXES include/SDL2 include
-        PATHS ${SDL2_SEARCH_PATHS}
-    )
-
-    IF(NOT SDL2_BUILDING_LIBRARY)
-        IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
-            # Non-OS X framework versions expect you to also dynamically link to
-            # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
-            # seem to provide SDL2main for compatibility even though they don't
-            # necessarily need it.
-            FIND_LIBRARY(SDL2MAIN_LIBRARY
-                NAMES SDL2main
-                HINTS
-                $ENV{SDL2DIR}
-                PATH_SUFFIXES lib64 lib
-                PATHS ${SDL2_SEARCH_PATHS}
-            )
-        ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
-    ENDIF(NOT SDL2_BUILDING_LIBRARY)
-
-    # SDL2 may require threads on your system.
-    # The Apple build may not need an explicit flag because one of the
-    # frameworks may already provide it.
-    # But for non-OSX systems, I will use the CMake Threads package.
-    IF(NOT APPLE)
-        FIND_PACKAGE(Threads)
-    ENDIF(NOT APPLE)
-
-    # MinGW needs an additional library, mwindows
-    # It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
-    # (Actually on second look, I think it only needs one of the m* libraries.)
-    IF(MINGW)
-        SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
-    ENDIF(MINGW)
-
-    # For SDL2main
-    IF(NOT SDL2_BUILDING_LIBRARY)
-        IF(SDL2MAIN_LIBRARY)
-            SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
-        ENDIF(SDL2MAIN_LIBRARY)
-    ENDIF(NOT SDL2_BUILDING_LIBRARY)
-
-    # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
-    # CMake doesn't display the -framework Cocoa string in the UI even
-    # though it actually is there if I modify a pre-used variable.
-    # I think it has something to do with the CACHE STRING.
-    # So I use a temporary variable until the end so I can set the
-    # "real" variable in one-shot.
-    IF(APPLE)
-        SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
-    ENDIF(APPLE)
-
-    # For threads, as mentioned Apple doesn't need this.
-    # In fact, there seems to be a problem if I used the Threads package
-    # and try using this line, so I'm just skipping it entirely for OS X.
-    IF(NOT APPLE)
-        SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
-    ENDIF(NOT APPLE)
-
-    # For MinGW library
-    IF(MINGW)
-        SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
-    ENDIF(MINGW)
-
-    # Set the final string here so the GUI reflects the final state.
-    SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
-
-    # Unset the temp variable to INTERNAL so it is not seen in the CMake GUI
-    UNSET(SDL2_LIBRARY_TEMP)
-ENDIF(SDL2_LIBRARY_TEMP)
-
-message("</FindSDL2.cmake>")
-
-INCLUDE(FindPackageHandleStandardArgs)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2 REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)

src/core/hle/kernel/address_arbiter.cpp

@@ -201,39 +201,42 @@ void AddressArbiter::HandleWakeupThread(std::shared_ptr<Thread> thread) {
 void AddressArbiter::InsertThread(std::shared_ptr<Thread> thread) {
     const VAddr arb_addr = thread->GetArbiterWaitAddress();
     std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[arb_addr];
-
-    const auto iter =
-        std::find_if(thread_list.cbegin(), thread_list.cend(), [&thread](const auto& entry) {
-            return entry->GetPriority() >= thread->GetPriority();
-        });
-
-    if (iter == thread_list.cend()) {
-        thread_list.push_back(std::move(thread));
-    } else {
-        thread_list.insert(iter, std::move(thread));
+    auto it = thread_list.begin();
+    while (it != thread_list.end()) {
+        const std::shared_ptr<Thread>& current_thread = *it;
+        if (current_thread->GetPriority() >= thread->GetPriority()) {
+            thread_list.insert(it, thread);
+            return;
+        }
+        ++it;
     }
+    thread_list.push_back(std::move(thread));
 }
 
 void AddressArbiter::RemoveThread(std::shared_ptr<Thread> thread) {
     const VAddr arb_addr = thread->GetArbiterWaitAddress();
     std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[arb_addr];
-
-    const auto iter = std::find_if(thread_list.cbegin(), thread_list.cend(),
-                                   [&thread](const auto& entry) { return thread == entry; });
-
-    ASSERT(iter != thread_list.cend());
-
-    thread_list.erase(iter);
+    auto it = thread_list.begin();
+    while (it != thread_list.end()) {
+        const std::shared_ptr<Thread>& current_thread = *it;
+        if (current_thread.get() == thread.get()) {
+            thread_list.erase(it);
+            return;
+        }
+        ++it;
+    }
+    UNREACHABLE();
 }
 
-std::vector<std::shared_ptr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(
-    VAddr address) const {
-    const auto iter = arb_threads.find(address);
-    if (iter == arb_threads.cend()) {
-        return {};
+std::vector<std::shared_ptr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) {
+    std::vector<std::shared_ptr<Thread>> result;
+    std::list<std::shared_ptr<Thread>>& thread_list = arb_threads[address];
+    auto it = thread_list.begin();
+    while (it != thread_list.end()) {
+        std::shared_ptr<Thread> current_thread = *it;
+        result.push_back(std::move(current_thread));
+        ++it;
     }
-
-    const std::list<std::shared_ptr<Thread>>& thread_list = iter->second;
-    return {thread_list.cbegin(), thread_list.cend()};
+    return result;
 }
 } // namespace Kernel

src/core/hle/kernel/address_arbiter.h

@@ -86,7 +86,7 @@ private:
     void RemoveThread(std::shared_ptr<Thread> thread);
 
     // Gets the threads waiting on an address.
-    std::vector<std::shared_ptr<Thread>> GetThreadsWaitingOnAddress(VAddr address) const;
+    std::vector<std::shared_ptr<Thread>> GetThreadsWaitingOnAddress(VAddr address);
 
     /// List of threads waiting for a address arbiter
     std::unordered_map<VAddr, std::list<std::shared_ptr<Thread>>> arb_threads;

src/video_core/CMakeLists.txt

@@ -37,7 +37,6 @@ add_library(video_core STATIC
     memory_manager.h
     morton.cpp
     morton.h
-    query_cache.h
     rasterizer_accelerated.cpp
     rasterizer_accelerated.h
     rasterizer_cache.cpp
@@ -75,8 +74,6 @@ add_library(video_core STATIC
     renderer_opengl/gl_stream_buffer.h
     renderer_opengl/gl_texture_cache.cpp
     renderer_opengl/gl_texture_cache.h
-    renderer_opengl/gl_query_cache.cpp
-    renderer_opengl/gl_query_cache.h
     renderer_opengl/maxwell_to_gl.h
     renderer_opengl/renderer_opengl.cpp
     renderer_opengl/renderer_opengl.h
@@ -180,8 +177,6 @@ if (ENABLE_VULKAN)
         renderer_vulkan/vk_memory_manager.h
         renderer_vulkan/vk_pipeline_cache.cpp
         renderer_vulkan/vk_pipeline_cache.h
-        renderer_vulkan/vk_query_cache.cpp
-        renderer_vulkan/vk_query_cache.h
         renderer_vulkan/vk_rasterizer.cpp
         renderer_vulkan/vk_rasterizer.h
         renderer_vulkan/vk_renderpass_cache.cpp

src/video_core/engines/maxwell_3d.cpp

@@ -4,21 +4,17 @@
 
 #include <cinttypes>
 #include <cstring>
-#include <optional>
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/shader_type.h"
-#include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/textures/texture.h"
 
 namespace Tegra::Engines {
 
-using VideoCore::QueryType;
-
 /// First register id that is actually a Macro call.
 constexpr u32 MacroRegistersStart = 0xE00;
 
@@ -403,10 +399,6 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
         ProcessQueryCondition();
         break;
     }
-    case MAXWELL3D_REG_INDEX(counter_reset): {
-        ProcessCounterReset();
-        break;
-    }
     case MAXWELL3D_REG_INDEX(sync_info): {
         ProcessSyncPoint();
         break;
@@ -527,51 +519,61 @@ void Maxwell3D::ProcessFirmwareCall4() {
     regs.reg_array[0xd00] = 1;
 }
 
-void Maxwell3D::StampQueryResult(u64 payload, bool long_query) {
+void Maxwell3D::ProcessQueryGet() {
+    const GPUVAddr sequence_address{regs.query.QueryAddress()};
+    // Since the sequence address is given as a GPU VAddr, we have to convert it to an application
+    // VAddr before writing.
+
+    // TODO(Subv): Support the other query units.
+    ASSERT_MSG(regs.query.query_get.unit == Regs::QueryUnit::Crop,
+               "Units other than CROP are unimplemented");
+
+    u64 result = 0;
+
+    // TODO(Subv): Support the other query variables
+    switch (regs.query.query_get.select) {
+    case Regs::QuerySelect::Zero:
+        // This seems to actually write the query sequence to the query address.
+        result = regs.query.query_sequence;
+        break;
+    default:
+        result = 1;
+        UNIMPLEMENTED_MSG("Unimplemented query select type {}",
+                          static_cast<u32>(regs.query.query_get.select.Value()));
+    }
+
+    // TODO(Subv): Research and implement how query sync conditions work.
+
     struct LongQueryResult {
         u64_le value;
         u64_le timestamp;
     };
     static_assert(sizeof(LongQueryResult) == 16, "LongQueryResult has wrong size");
-    const GPUVAddr sequence_address{regs.query.QueryAddress()};
-    if (long_query) {
-        // Write the 128-bit result structure in long mode. Note: We emulate an infinitely fast
-        // GPU, this command may actually take a while to complete in real hardware due to GPU
-        // wait queues.
-        LongQueryResult query_result{payload, system.GPU().GetTicks()};
-        memory_manager.WriteBlock(sequence_address, &query_result, sizeof(query_result));
-    } else {
-        memory_manager.Write<u32>(sequence_address, static_cast<u32>(payload));
-    }
-}
 
-void Maxwell3D::ProcessQueryGet() {
-    // TODO(Subv): Support the other query units.
-    ASSERT_MSG(regs.query.query_get.unit == Regs::QueryUnit::Crop,
-               "Units other than CROP are unimplemented");
-
-    switch (regs.query.query_get.operation) {
-    case Regs::QueryOperation::Release:
-        StampQueryResult(regs.query.query_sequence, regs.query.query_get.short_query == 0);
-        break;
-    case Regs::QueryOperation::Acquire:
-        // TODO(Blinkhawk): Under this operation, the GPU waits for the CPU to write a value that
-        // matches the current payload.
-        UNIMPLEMENTED_MSG("Unimplemented query operation ACQUIRE");
-        break;
-    case Regs::QueryOperation::Counter:
-        if (const std::optional<u64> result = GetQueryResult()) {
-            // If the query returns an empty optional it means it's cached and deferred.
-            // In this case we have a non-empty result, so we stamp it immediately.
-            StampQueryResult(*result, regs.query.query_get.short_query == 0);
+    switch (regs.query.query_get.mode) {
+    case Regs::QueryMode::Write:
+    case Regs::QueryMode::Write2: {
+        u32 sequence = regs.query.query_sequence;
+        if (regs.query.query_get.short_query) {
+            // Write the current query sequence to the sequence address.
+            // TODO(Subv): Find out what happens if you use a long query type but mark it as a short
+            // query.
+            memory_manager.Write<u32>(sequence_address, sequence);
+        } else {
+            // Write the 128-bit result structure in long mode. Note: We emulate an infinitely fast
+            // GPU, this command may actually take a while to complete in real hardware due to GPU
+            // wait queues.
+            LongQueryResult query_result{};
+            query_result.value = result;
+            // TODO(Subv): Generate a real GPU timestamp and write it here instead of CoreTiming
+            query_result.timestamp = system.CoreTiming().GetTicks();
+            memory_manager.WriteBlock(sequence_address, &query_result, sizeof(query_result));
         }
         break;
-    case Regs::QueryOperation::Trap:
-        UNIMPLEMENTED_MSG("Unimplemented query operation TRAP");
-        break;
+    }
     default:
-        UNIMPLEMENTED_MSG("Unknown query operation");
-        break;
+        UNIMPLEMENTED_MSG("Query mode {} not implemented",
+                          static_cast<u32>(regs.query.query_get.mode.Value()));
     }
 }
 
@@ -588,20 +590,20 @@ void Maxwell3D::ProcessQueryCondition() {
     }
     case Regs::ConditionMode::ResNonZero: {
         Regs::QueryCompare cmp;
-        memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
+        memory_manager.ReadBlockUnsafe(condition_address, &cmp, sizeof(cmp));
         execute_on = cmp.initial_sequence != 0U && cmp.initial_mode != 0U;
         break;
     }
     case Regs::ConditionMode::Equal: {
         Regs::QueryCompare cmp;
-        memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
+        memory_manager.ReadBlockUnsafe(condition_address, &cmp, sizeof(cmp));
         execute_on =
             cmp.initial_sequence == cmp.current_sequence && cmp.initial_mode == cmp.current_mode;
         break;
     }
     case Regs::ConditionMode::NotEqual: {
         Regs::QueryCompare cmp;
-        memory_manager.ReadBlock(condition_address, &cmp, sizeof(cmp));
+        memory_manager.ReadBlockUnsafe(condition_address, &cmp, sizeof(cmp));
         execute_on =
             cmp.initial_sequence != cmp.current_sequence || cmp.initial_mode != cmp.current_mode;
         break;
@@ -614,18 +616,6 @@ void Maxwell3D::ProcessQueryCondition() {
     }
 }
 
-void Maxwell3D::ProcessCounterReset() {
-    switch (regs.counter_reset) {
-    case Regs::CounterReset::SampleCnt:
-        rasterizer.ResetCounter(QueryType::SamplesPassed);
-        break;
-    default:
-        LOG_WARNING(Render_OpenGL, "Unimplemented counter reset={}",
-                    static_cast<int>(regs.counter_reset));
-        break;
-    }
-}
-
 void Maxwell3D::ProcessSyncPoint() {
     const u32 sync_point = regs.sync_info.sync_point.Value();
     const u32 increment = regs.sync_info.increment.Value();
@@ -668,22 +658,6 @@ void Maxwell3D::DrawArrays() {
     }
 }
 
-std::optional<u64> Maxwell3D::GetQueryResult() {
-    switch (regs.query.query_get.select) {
-    case Regs::QuerySelect::Zero:
-        return 0;
-    case Regs::QuerySelect::SamplesPassed:
-        // Deferred.
-        rasterizer.Query(regs.query.QueryAddress(), VideoCore::QueryType::SamplesPassed,
-                         system.GPU().GetTicks());
-        return {};
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented query select type {}",
-                          static_cast<u32>(regs.query.query_get.select.Value()));
-        return 1;
-    }
-}
-
 void Maxwell3D::ProcessCBBind(std::size_t stage_index) {
     // Bind the buffer currently in CB_ADDRESS to the specified index in the desired shader stage.
     auto& shader = state.shader_stages[stage_index];

src/video_core/engines/maxwell_3d.h

@@ -6,7 +6,6 @@
 
 #include <array>
 #include <bitset>
-#include <optional>
 #include <type_traits>
 #include <unordered_map>
 #include <vector>
@@ -72,11 +71,12 @@ public:
         static constexpr std::size_t MaxConstBuffers = 18;
         static constexpr std::size_t MaxConstBufferSize = 0x10000;
 
-        enum class QueryOperation : u32 {
-            Release = 0,
-            Acquire = 1,
-            Counter = 2,
-            Trap = 3,
+        enum class QueryMode : u32 {
+            Write = 0,
+            Sync = 1,
+            // TODO(Subv): It is currently unknown what the difference between method 2 and method 0
+            // is.
+            Write2 = 2,
         };
 
         enum class QueryUnit : u32 {
@@ -410,27 +410,6 @@ public:
             Linear = 1,
         };
 
-        enum class CounterReset : u32 {
-            SampleCnt = 0x01,
-            Unk02 = 0x02,
-            Unk03 = 0x03,
-            Unk04 = 0x04,
-            EmittedPrimitives = 0x10, // Not tested
-            Unk11 = 0x11,
-            Unk12 = 0x12,
-            Unk13 = 0x13,
-            Unk15 = 0x15,
-            Unk16 = 0x16,
-            Unk17 = 0x17,
-            Unk18 = 0x18,
-            Unk1A = 0x1A,
-            Unk1B = 0x1B,
-            Unk1C = 0x1C,
-            Unk1D = 0x1D,
-            Unk1E = 0x1E,
-            GeneratedPrimitives = 0x1F,
-        };
-
         struct Cull {
             enum class FrontFace : u32 {
                 ClockWise = 0x0900,
@@ -879,7 +858,7 @@ public:
                     BitField<7, 1, u32> c7;
                 } clip_distance_enabled;
 
-                u32 samplecnt_enable;
+                INSERT_UNION_PADDING_WORDS(0x1);
 
                 float point_size;
 
@@ -887,11 +866,7 @@ public:
 
                 u32 point_sprite_enable;
 
-                INSERT_UNION_PADDING_WORDS(0x3);
-
-                CounterReset counter_reset;
-
-                INSERT_UNION_PADDING_WORDS(0x1);
+                INSERT_UNION_PADDING_WORDS(0x5);
 
                 u32 zeta_enable;
 
@@ -1106,7 +1081,7 @@ public:
                     u32 query_sequence;
                     union {
                         u32 raw;
-                        BitField<0, 2, QueryOperation> operation;
+                        BitField<0, 2, QueryMode> mode;
                         BitField<4, 1, u32> fence;
                         BitField<12, 4, QueryUnit> unit;
                         BitField<16, 1, QuerySyncCondition> sync_cond;
@@ -1438,15 +1413,9 @@ private:
     /// Handles a write to the QUERY_GET register.
     void ProcessQueryGet();
 
-    /// Writes the query result accordingly.
-    void StampQueryResult(u64 payload, bool long_query);
-
-    /// Handles conditional rendering.
+    // Handles Conditional Rendering
     void ProcessQueryCondition();
 
-    /// Handles counter resets.
-    void ProcessCounterReset();
-
     /// Handles writes to syncing register.
     void ProcessSyncPoint();
 
@@ -1463,9 +1432,6 @@ private:
 
     // Handles a instance drawcall from MME
     void StepInstance(MMEDrawMode expected_mode, u32 count);
-
-    /// Returns a query's value or an empty object if the value will be deferred through a cache.
-    std::optional<u64> GetQueryResult();
 };
 
 #define ASSERT_REG_POSITION(field_name, position)                                                  \
@@ -1531,10 +1497,8 @@ ASSERT_REG_POSITION(screen_y_control, 0x4EB);
 ASSERT_REG_POSITION(vb_element_base, 0x50D);
 ASSERT_REG_POSITION(vb_base_instance, 0x50E);
 ASSERT_REG_POSITION(clip_distance_enabled, 0x544);
-ASSERT_REG_POSITION(samplecnt_enable, 0x545);
 ASSERT_REG_POSITION(point_size, 0x546);
 ASSERT_REG_POSITION(point_sprite_enable, 0x548);
-ASSERT_REG_POSITION(counter_reset, 0x54C);
 ASSERT_REG_POSITION(zeta_enable, 0x54E);
 ASSERT_REG_POSITION(multisample_control, 0x54F);
 ASSERT_REG_POSITION(condition, 0x554);

src/video_core/gpu.cpp

@@ -6,7 +6,6 @@
 #include "common/microprofile.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/core_timing_util.h"
 #include "core/memory.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/kepler_compute.h"
@@ -123,19 +122,6 @@ bool GPU::CancelSyncptInterrupt(const u32 syncpoint_id, const u32 value) {
     return true;
 }
 
-u64 GPU::GetTicks() const {
-    // This values were reversed engineered by fincs from NVN
-    // The gpu clock is reported in units of 385/625 nanoseconds
-    constexpr u64 gpu_ticks_num = 384;
-    constexpr u64 gpu_ticks_den = 625;
-
-    const u64 cpu_ticks = system.CoreTiming().GetTicks();
-    const u64 nanoseconds = Core::Timing::CyclesToNs(cpu_ticks).count();
-    const u64 nanoseconds_num = nanoseconds / gpu_ticks_den;
-    const u64 nanoseconds_rem = nanoseconds % gpu_ticks_den;
-    return nanoseconds_num * gpu_ticks_num + (nanoseconds_rem * gpu_ticks_num) / gpu_ticks_den;
-}
-
 void GPU::FlushCommands() {
     renderer.Rasterizer().FlushCommands();
 }
@@ -354,7 +340,7 @@ void GPU::ProcessSemaphoreTriggerMethod() {
         block.sequence = regs.semaphore_sequence;
         // TODO(Kmather73): Generate a real GPU timestamp and write it here instead of
         // CoreTiming
-        block.timestamp = GetTicks();
+        block.timestamp = system.CoreTiming().GetTicks();
         memory_manager->WriteBlock(regs.semaphore_address.SemaphoreAddress(), &block,
                                    sizeof(block));
     } else {

src/video_core/gpu.h

@@ -192,8 +192,6 @@ public:
 
     bool CancelSyncptInterrupt(u32 syncpoint_id, u32 value);
 
-    u64 GetTicks() const;
-
     std::unique_lock<std::mutex> LockSync() {
         return std::unique_lock{sync_mutex};
     }

src/video_core/query_cache.h

@@ -1,359 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <algorithm>
-#include <array>
-#include <cstring>
-#include <iterator>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <unordered_map>
-#include <vector>
-
-#include "common/assert.h"
-#include "core/core.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/gpu.h"
-#include "video_core/memory_manager.h"
-#include "video_core/rasterizer_interface.h"
-
-namespace VideoCommon {
-
-template <class QueryCache, class HostCounter>
-class CounterStreamBase {
-public:
-    explicit CounterStreamBase(QueryCache& cache, VideoCore::QueryType type)
-        : cache{cache}, type{type} {}
-
-    /// Updates the state of the stream, enabling or disabling as needed.
-    void Update(bool enabled) {
-        if (enabled) {
-            Enable();
-        } else {
-            Disable();
-        }
-    }
-
-    /// Resets the stream to zero. It doesn't disable the query after resetting.
-    void Reset() {
-        if (current) {
-            current->EndQuery();
-
-            // Immediately start a new query to avoid disabling its state.
-            current = cache.Counter(nullptr, type);
-        }
-        last = nullptr;
-    }
-
-    /// Returns the current counter slicing as needed.
-    std::shared_ptr<HostCounter> Current() {
-        if (!current) {
-            return nullptr;
-        }
-        current->EndQuery();
-        last = std::move(current);
-        current = cache.Counter(last, type);
-        return last;
-    }
-
-    /// Returns true when the counter stream is enabled.
-    bool IsEnabled() const {
-        return current != nullptr;
-    }
-
-private:
-    /// Enables the stream.
-    void Enable() {
-        if (current) {
-            return;
-        }
-        current = cache.Counter(last, type);
-    }
-
-    // Disables the stream.
-    void Disable() {
-        if (current) {
-            current->EndQuery();
-        }
-        last = std::exchange(current, nullptr);
-    }
-
-    QueryCache& cache;
-    const VideoCore::QueryType type;
-
-    std::shared_ptr<HostCounter> current;
-    std::shared_ptr<HostCounter> last;
-};
-
-template <class QueryCache, class CachedQuery, class CounterStream, class HostCounter,
-          class QueryPool>
-class QueryCacheBase {
-public:
-    explicit QueryCacheBase(Core::System& system, VideoCore::RasterizerInterface& rasterizer)
-        : system{system}, rasterizer{rasterizer}, streams{{CounterStream{
-                                                      static_cast<QueryCache&>(*this),
-                                                      VideoCore::QueryType::SamplesPassed}}} {}
-
-    void InvalidateRegion(CacheAddr addr, std::size_t size) {
-        std::unique_lock lock{mutex};
-        FlushAndRemoveRegion(addr, size);
-    }
-
-    void FlushRegion(CacheAddr addr, std::size_t size) {
-        std::unique_lock lock{mutex};
-        FlushAndRemoveRegion(addr, size);
-    }
-
-    /**
-     * Records a query in GPU mapped memory, potentially marked with a timestamp.
-     * @param gpu_addr  GPU address to flush to when the mapped memory is read.
-     * @param type      Query type, e.g. SamplesPassed.
-     * @param timestamp Timestamp, when empty the flushed query is assumed to be short.
-     */
-    void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional<u64> timestamp) {
-        std::unique_lock lock{mutex};
-        auto& memory_manager = system.GPU().MemoryManager();
-        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
-
-        CachedQuery* query = TryGet(ToCacheAddr(host_ptr));
-        if (!query) {
-            const auto cpu_addr = memory_manager.GpuToCpuAddress(gpu_addr);
-            ASSERT_OR_EXECUTE(cpu_addr, return;);
-
-            query = Register(type, *cpu_addr, host_ptr, timestamp.has_value());
-        }
-
-        query->BindCounter(Stream(type).Current(), timestamp);
-    }
-
-    /// Updates counters from GPU state. Expected to be called once per draw, clear or dispatch.
-    void UpdateCounters() {
-        std::unique_lock lock{mutex};
-        const auto& regs = system.GPU().Maxwell3D().regs;
-        Stream(VideoCore::QueryType::SamplesPassed).Update(regs.samplecnt_enable);
-    }
-
-    /// Resets a counter to zero. It doesn't disable the query after resetting.
-    void ResetCounter(VideoCore::QueryType type) {
-        std::unique_lock lock{mutex};
-        Stream(type).Reset();
-    }
-
-    /// Disable all active streams. Expected to be called at the end of a command buffer.
-    void DisableStreams() {
-        std::unique_lock lock{mutex};
-        for (auto& stream : streams) {
-            stream.Update(false);
-        }
-    }
-
-    /// Returns a new host counter.
-    std::shared_ptr<HostCounter> Counter(std::shared_ptr<HostCounter> dependency,
-                                         VideoCore::QueryType type) {
-        return std::make_shared<HostCounter>(static_cast<QueryCache&>(*this), std::move(dependency),
-                                             type);
-    }
-
-    /// Returns the counter stream of the specified type.
-    CounterStream& Stream(VideoCore::QueryType type) {
-        return streams[static_cast<std::size_t>(type)];
-    }
-
-    /// Returns the counter stream of the specified type.
-    const CounterStream& Stream(VideoCore::QueryType type) const {
-        return streams[static_cast<std::size_t>(type)];
-    }
-
-protected:
-    std::array<QueryPool, VideoCore::NumQueryTypes> query_pools;
-
-private:
-    /// Flushes a memory range to guest memory and removes it from the cache.
-    void FlushAndRemoveRegion(CacheAddr addr, std::size_t size) {
-        const u64 addr_begin = static_cast<u64>(addr);
-        const u64 addr_end = addr_begin + static_cast<u64>(size);
-        const auto in_range = [addr_begin, addr_end](CachedQuery& query) {
-            const u64 cache_begin = query.GetCacheAddr();
-            const u64 cache_end = cache_begin + query.SizeInBytes();
-            return cache_begin < addr_end && addr_begin < cache_end;
-        };
-
-        const u64 page_end = addr_end >> PAGE_SHIFT;
-        for (u64 page = addr_begin >> PAGE_SHIFT; page <= page_end; ++page) {
-            const auto& it = cached_queries.find(page);
-            if (it == std::end(cached_queries)) {
-                continue;
-            }
-            auto& contents = it->second;
-            for (auto& query : contents) {
-                if (!in_range(query)) {
-                    continue;
-                }
-                rasterizer.UpdatePagesCachedCount(query.CpuAddr(), query.SizeInBytes(), -1);
-                query.Flush();
-            }
-            contents.erase(std::remove_if(std::begin(contents), std::end(contents), in_range),
-                           std::end(contents));
-        }
-    }
-
-    /// Registers the passed parameters as cached and returns a pointer to the stored cached query.
-    CachedQuery* Register(VideoCore::QueryType type, VAddr cpu_addr, u8* host_ptr, bool timestamp) {
-        rasterizer.UpdatePagesCachedCount(cpu_addr, CachedQuery::SizeInBytes(timestamp), 1);
-        const u64 page = static_cast<u64>(ToCacheAddr(host_ptr)) >> PAGE_SHIFT;
-        return &cached_queries[page].emplace_back(static_cast<QueryCache&>(*this), type, cpu_addr,
-                                                  host_ptr);
-    }
-
-    /// Tries to a get a cached query. Returns nullptr on failure.
-    CachedQuery* TryGet(CacheAddr addr) {
-        const u64 page = static_cast<u64>(addr) >> PAGE_SHIFT;
-        const auto it = cached_queries.find(page);
-        if (it == std::end(cached_queries)) {
-            return nullptr;
-        }
-        auto& contents = it->second;
-        const auto found =
-            std::find_if(std::begin(contents), std::end(contents),
-                         [addr](auto& query) { return query.GetCacheAddr() == addr; });
-        return found != std::end(contents) ? &*found : nullptr;
-    }
-
-    static constexpr std::uintptr_t PAGE_SIZE = 4096;
-    static constexpr unsigned PAGE_SHIFT = 12;
-
-    Core::System& system;
-    VideoCore::RasterizerInterface& rasterizer;
-
-    std::recursive_mutex mutex;
-
-    std::unordered_map<u64, std::vector<CachedQuery>> cached_queries;
-
-    std::array<CounterStream, VideoCore::NumQueryTypes> streams;
-};
-
-template <class QueryCache, class HostCounter>
-class HostCounterBase {
-public:
-    explicit HostCounterBase(std::shared_ptr<HostCounter> dependency_)
-        : dependency{std::move(dependency_)}, depth{dependency ? (dependency->Depth() + 1) : 0} {
-        // Avoid nesting too many dependencies to avoid a stack overflow when these are deleted.
-        constexpr u64 depth_threshold = 96;
-        if (depth > depth_threshold) {
-            depth = 0;
-            base_result = dependency->Query();
-            dependency = nullptr;
-        }
-    }
-    virtual ~HostCounterBase() = default;
-
-    /// Returns the current value of the query.
-    u64 Query() {
-        if (result) {
-            return *result;
-        }
-
-        u64 value = BlockingQuery() + base_result;
-        if (dependency) {
-            value += dependency->Query();
-            dependency = nullptr;
-        }
-
-        result = value;
-        return *result;
-    }
-
-    /// Returns true when flushing this query will potentially wait.
-    bool WaitPending() const noexcept {
-        return result.has_value();
-    }
-
-    u64 Depth() const noexcept {
-        return depth;
-    }
-
-protected:
-    /// Returns the value of query from the backend API blocking as needed.
-    virtual u64 BlockingQuery() const = 0;
-
-private:
-    std::shared_ptr<HostCounter> dependency; ///< Counter to add to this value.
-    std::optional<u64> result;               ///< Filled with the already returned value.
-    u64 depth;                               ///< Number of nested dependencies.
-    u64 base_result = 0;                     ///< Equivalent to nested dependencies value.
-};
-
-template <class HostCounter>
-class CachedQueryBase {
-public:
-    explicit CachedQueryBase(VAddr cpu_addr, u8* host_ptr)
-        : cpu_addr{cpu_addr}, host_ptr{host_ptr} {}
-    virtual ~CachedQueryBase() = default;
-
-    CachedQueryBase(CachedQueryBase&&) noexcept = default;
-    CachedQueryBase(const CachedQueryBase&) = delete;
-
-    CachedQueryBase& operator=(CachedQueryBase&&) noexcept = default;
-    CachedQueryBase& operator=(const CachedQueryBase&) = delete;
-
-    /// Flushes the query to guest memory.
-    virtual void Flush() {
-        // When counter is nullptr it means that it's just been reseted. We are supposed to write a
-        // zero in these cases.
-        const u64 value = counter ? counter->Query() : 0;
-        std::memcpy(host_ptr, &value, sizeof(u64));
-
-        if (timestamp) {
-            std::memcpy(host_ptr + TIMESTAMP_OFFSET, &*timestamp, sizeof(u64));
-        }
-    }
-
-    /// Binds a counter to this query.
-    void BindCounter(std::shared_ptr<HostCounter> counter_, std::optional<u64> timestamp_) {
-        if (counter) {
-            // If there's an old counter set it means the query is being rewritten by the game.
-            // To avoid losing the data forever, flush here.
-            Flush();
-        }
-        counter = std::move(counter_);
-        timestamp = timestamp_;
-    }
-
-    VAddr CpuAddr() const noexcept {
-        return cpu_addr;
-    }
-
-    CacheAddr GetCacheAddr() const noexcept {
-        return ToCacheAddr(host_ptr);
-    }
-
-    u64 SizeInBytes() const noexcept {
-        return SizeInBytes(timestamp.has_value());
-    }
-
-    static constexpr u64 SizeInBytes(bool with_timestamp) noexcept {
-        return with_timestamp ? LARGE_QUERY_SIZE : SMALL_QUERY_SIZE;
-    }
-
-protected:
-    /// Returns true when querying the counter may potentially block.
-    bool WaitPending() const noexcept {
-        return counter && counter->WaitPending();
-    }
-
-private:
-    static constexpr std::size_t SMALL_QUERY_SIZE = 8;   // Query size without timestamp.
-    static constexpr std::size_t LARGE_QUERY_SIZE = 16;  // Query size with timestamp.
-    static constexpr std::intptr_t TIMESTAMP_OFFSET = 8; // Timestamp offset in a large query.
-
-    VAddr cpu_addr;                       ///< Guest CPU address.
-    u8* host_ptr;                         ///< Writable host pointer.
-    std::shared_ptr<HostCounter> counter; ///< Host counter to query, owns the dependency tree.
-    std::optional<u64> timestamp;         ///< Timestamp to flush to guest memory.
-};
-
-} // namespace VideoCommon

src/video_core/rasterizer_interface.h

@@ -6,7 +6,6 @@
 
 #include <atomic>
 #include <functional>
-#include <optional>
 #include "common/common_types.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/gpu.h"
@@ -18,11 +17,6 @@ class MemoryManager;
 
 namespace VideoCore {
 
-enum class QueryType {
-    SamplesPassed,
-};
-constexpr std::size_t NumQueryTypes = 1;
-
 enum class LoadCallbackStage {
     Prepare,
     Decompile,
@@ -47,12 +41,6 @@ public:
     /// Dispatches a compute shader invocation
     virtual void DispatchCompute(GPUVAddr code_addr) = 0;
 
-    /// Resets the counter of a query
-    virtual void ResetCounter(QueryType type) = 0;
-
-    /// Records a GPU query and caches it
-    virtual void Query(GPUVAddr gpu_addr, QueryType type, std::optional<u64> timestamp) = 0;
-
     /// Notify rasterizer that all caches should be flushed to Switch memory
     virtual void FlushAll() = 0;
 

src/video_core/renderer_opengl/gl_query_cache.cpp

@@ -1,120 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstring>
-#include <memory>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include <glad/glad.h>
-
-#include "common/assert.h"
-#include "core/core.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/memory_manager.h"
-#include "video_core/renderer_opengl/gl_query_cache.h"
-#include "video_core/renderer_opengl/gl_rasterizer.h"
-
-namespace OpenGL {
-
-namespace {
-
-constexpr std::array<GLenum, VideoCore::NumQueryTypes> QueryTargets = {GL_SAMPLES_PASSED};
-
-constexpr GLenum GetTarget(VideoCore::QueryType type) {
-    return QueryTargets[static_cast<std::size_t>(type)];
-}
-
-} // Anonymous namespace
-
-QueryCache::QueryCache(Core::System& system, RasterizerOpenGL& gl_rasterizer)
-    : VideoCommon::QueryCacheBase<
-          QueryCache, CachedQuery, CounterStream, HostCounter,
-          std::vector<OGLQuery>>{system,
-                                 static_cast<VideoCore::RasterizerInterface&>(gl_rasterizer)},
-      gl_rasterizer{gl_rasterizer} {}
-
-QueryCache::~QueryCache() = default;
-
-OGLQuery QueryCache::AllocateQuery(VideoCore::QueryType type) {
-    auto& reserve = query_pools[static_cast<std::size_t>(type)];
-    OGLQuery query;
-    if (reserve.empty()) {
-        query.Create(GetTarget(type));
-        return query;
-    }
-
-    query = std::move(reserve.back());
-    reserve.pop_back();
-    return query;
-}
-
-void QueryCache::Reserve(VideoCore::QueryType type, OGLQuery&& query) {
-    query_pools[static_cast<std::size_t>(type)].push_back(std::move(query));
-}
-
-bool QueryCache::AnyCommandQueued() const noexcept {
-    return gl_rasterizer.AnyCommandQueued();
-}
-
-HostCounter::HostCounter(QueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type)
-    : VideoCommon::HostCounterBase<QueryCache, HostCounter>{std::move(dependency)}, cache{cache},
-      type{type}, query{cache.AllocateQuery(type)} {
-    glBeginQuery(GetTarget(type), query.handle);
-}
-
-HostCounter::~HostCounter() {
-    cache.Reserve(type, std::move(query));
-}
-
-void HostCounter::EndQuery() {
-    if (!cache.AnyCommandQueued()) {
-        // There are chances a query waited on without commands (glDraw, glClear, glDispatch). Not
-        // having any of these causes a lock. glFlush is considered a command, so we can safely wait
-        // for this. Insert to the OpenGL command stream a flush.
-        glFlush();
-    }
-    glEndQuery(GetTarget(type));
-}
-
-u64 HostCounter::BlockingQuery() const {
-    GLint64 value;
-    glGetQueryObjecti64v(query.handle, GL_QUERY_RESULT, &value);
-    return static_cast<u64>(value);
-}
-
-CachedQuery::CachedQuery(QueryCache& cache, VideoCore::QueryType type, VAddr cpu_addr, u8* host_ptr)
-    : VideoCommon::CachedQueryBase<HostCounter>{cpu_addr, host_ptr}, cache{&cache}, type{type} {}
-
-CachedQuery::CachedQuery(CachedQuery&& rhs) noexcept
-    : VideoCommon::CachedQueryBase<HostCounter>(std::move(rhs)), cache{rhs.cache}, type{rhs.type} {}
-
-CachedQuery& CachedQuery::operator=(CachedQuery&& rhs) noexcept {
-    VideoCommon::CachedQueryBase<HostCounter>::operator=(std::move(rhs));
-    cache = rhs.cache;
-    type = rhs.type;
-    return *this;
-}
-
-void CachedQuery::Flush() {
-    // Waiting for a query while another query of the same target is enabled locks Nvidia's driver.
-    // To avoid this disable and re-enable keeping the dependency stream.
-    // But we only have to do this if we have pending waits to be done.
-    auto& stream = cache->Stream(type);
-    const bool slice_counter = WaitPending() && stream.IsEnabled();
-    if (slice_counter) {
-        stream.Update(false);
-    }
-
-    VideoCommon::CachedQueryBase<HostCounter>::Flush();
-
-    if (slice_counter) {
-        stream.Update(true);
-    }
-}
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_query_cache.h

@@ -1,78 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <vector>
-
-#include "common/common_types.h"
-#include "video_core/query_cache.h"
-#include "video_core/rasterizer_interface.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
-
-namespace Core {
-class System;
-}
-
-namespace OpenGL {
-
-class CachedQuery;
-class HostCounter;
-class QueryCache;
-class RasterizerOpenGL;
-
-using CounterStream = VideoCommon::CounterStreamBase<QueryCache, HostCounter>;
-
-class QueryCache final : public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream,
-                                                            HostCounter, std::vector<OGLQuery>> {
-public:
-    explicit QueryCache(Core::System& system, RasterizerOpenGL& rasterizer);
-    ~QueryCache();
-
-    OGLQuery AllocateQuery(VideoCore::QueryType type);
-
-    void Reserve(VideoCore::QueryType type, OGLQuery&& query);
-
-    bool AnyCommandQueued() const noexcept;
-
-private:
-    RasterizerOpenGL& gl_rasterizer;
-};
-
-class HostCounter final : public VideoCommon::HostCounterBase<QueryCache, HostCounter> {
-public:
-    explicit HostCounter(QueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type);
-    ~HostCounter();
-
-    void EndQuery();
-
-private:
-    u64 BlockingQuery() const override;
-
-    QueryCache& cache;
-    const VideoCore::QueryType type;
-    OGLQuery query;
-};
-
-class CachedQuery final : public VideoCommon::CachedQueryBase<HostCounter> {
-public:
-    explicit CachedQuery(QueryCache& cache, VideoCore::QueryType type, VAddr cpu_addr,
-                         u8* host_ptr);
-    CachedQuery(CachedQuery&& rhs) noexcept;
-    CachedQuery(const CachedQuery&) = delete;
-
-    CachedQuery& operator=(CachedQuery&& rhs) noexcept;
-    CachedQuery& operator=(const CachedQuery&) = delete;
-
-    void Flush() override;
-
-private:
-    QueryCache* cache;
-    VideoCore::QueryType type;
-};
-
-} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -25,7 +25,6 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/memory_manager.h"
-#include "video_core/renderer_opengl/gl_query_cache.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_cache.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
@@ -93,8 +92,8 @@ std::size_t GetConstBufferSize(const Tegra::Engines::ConstBufferInfo& buffer,
 RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWindow& emu_window,
                                    ScreenInfo& info)
     : RasterizerAccelerated{system.Memory()}, texture_cache{system, *this, device},
-      shader_cache{*this, system, emu_window, device}, query_cache{system, *this}, system{system},
-      screen_info{info}, buffer_cache{*this, system, device, STREAM_BUFFER_SIZE} {
+      shader_cache{*this, system, emu_window, device}, system{system}, screen_info{info},
+      buffer_cache{*this, system, device, STREAM_BUFFER_SIZE} {
     shader_program_manager = std::make_unique<GLShader::ProgramManager>();
     state.draw.shader_program = 0;
     state.Apply();
@@ -542,16 +541,11 @@ void RasterizerOpenGL::Clear() {
     } else if (use_stencil) {
         glClearBufferiv(GL_STENCIL, 0, &regs.clear_stencil);
     }
-
-    ++num_queued_commands;
 }
 
 void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
     MICROPROFILE_SCOPE(OpenGL_Drawing);
     auto& gpu = system.GPU().Maxwell3D();
-    const auto& regs = gpu.regs;
-
-    query_cache.UpdateCounters();
 
     SyncRasterizeEnable(state);
     SyncColorMask();
@@ -644,8 +638,6 @@ void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
         glTextureBarrier();
     }
 
-    ++num_queued_commands;
-
     const GLuint base_instance = static_cast<GLuint>(gpu.regs.vb_base_instance);
     const GLsizei num_instances =
         static_cast<GLsizei>(is_instanced ? gpu.mme_draw.instance_count : 1);
@@ -715,16 +707,6 @@ void RasterizerOpenGL::DispatchCompute(GPUVAddr code_addr) {
     state.ApplyProgramPipeline();
 
     glDispatchCompute(launch_desc.grid_dim_x, launch_desc.grid_dim_y, launch_desc.grid_dim_z);
-    ++num_queued_commands;
-}
-
-void RasterizerOpenGL::ResetCounter(VideoCore::QueryType type) {
-    query_cache.ResetCounter(type);
-}
-
-void RasterizerOpenGL::Query(GPUVAddr gpu_addr, VideoCore::QueryType type,
-                             std::optional<u64> timestamp) {
-    query_cache.Query(gpu_addr, type, timestamp);
 }
 
 void RasterizerOpenGL::FlushAll() {}
@@ -736,7 +718,6 @@ void RasterizerOpenGL::FlushRegion(CacheAddr addr, u64 size) {
     }
     texture_cache.FlushRegion(addr, size);
     buffer_cache.FlushRegion(addr, size);
-    query_cache.FlushRegion(addr, size);
 }
 
 void RasterizerOpenGL::InvalidateRegion(CacheAddr addr, u64 size) {
@@ -747,7 +728,6 @@ void RasterizerOpenGL::InvalidateRegion(CacheAddr addr, u64 size) {
     texture_cache.InvalidateRegion(addr, size);
     shader_cache.InvalidateRegion(addr, size);
     buffer_cache.InvalidateRegion(addr, size);
-    query_cache.InvalidateRegion(addr, size);
 }
 
 void RasterizerOpenGL::FlushAndInvalidateRegion(CacheAddr addr, u64 size) {
@@ -758,18 +738,10 @@ void RasterizerOpenGL::FlushAndInvalidateRegion(CacheAddr addr, u64 size) {
 }
 
 void RasterizerOpenGL::FlushCommands() {
-    // Only flush when we have commands queued to OpenGL.
-    if (num_queued_commands == 0) {
-        return;
-    }
-    num_queued_commands = 0;
     glFlush();
 }
 
 void RasterizerOpenGL::TickFrame() {
-    // Ticking a frame means that buffers will be swapped, calling glFlush implicitly.
-    num_queued_commands = 0;
-
     buffer_cache.TickFrame();
 }
 

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -24,7 +24,6 @@
 #include "video_core/renderer_opengl/gl_buffer_cache.h"
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_framebuffer_cache.h"
-#include "video_core/renderer_opengl/gl_query_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_sampler_cache.h"
 #include "video_core/renderer_opengl/gl_shader_cache.h"
@@ -62,8 +61,6 @@ public:
     bool DrawMultiBatch(bool is_indexed) override;
     void Clear() override;
     void DispatchCompute(GPUVAddr code_addr) override;
-    void ResetCounter(VideoCore::QueryType type) override;
-    void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional<u64> timestamp) override;
     void FlushAll() override;
     void FlushRegion(CacheAddr addr, u64 size) override;
     void InvalidateRegion(CacheAddr addr, u64 size) override;
@@ -78,11 +75,6 @@ public:
     void LoadDiskResources(const std::atomic_bool& stop_loading,
                            const VideoCore::DiskResourceLoadCallback& callback) override;
 
-    /// Returns true when there are commands queued to the OpenGL server.
-    bool AnyCommandQueued() const {
-        return num_queued_commands > 0;
-    }
-
 private:
     /// Configures the color and depth framebuffer states.
     void ConfigureFramebuffers();
@@ -188,23 +180,10 @@ private:
     /// Syncs the alpha test state to match the guest state
     void SyncAlphaTest();
 
-    /// Check for extension that are not strictly required but are needed for correct emulation
+    /// Check for extension that are not strictly required
+    /// but are needed for correct emulation
     void CheckExtensions();
 
-    std::size_t CalculateVertexArraysSize() const;
-
-    std::size_t CalculateIndexBufferSize() const;
-
-    /// Updates and returns a vertex array object representing current vertex format
-    GLuint SetupVertexFormat();
-
-    void SetupVertexBuffer(GLuint vao);
-    void SetupVertexInstances(GLuint vao);
-
-    GLintptr SetupIndexBuffer();
-
-    void SetupShaders(GLenum primitive_mode);
-
     const Device device;
     OpenGLState state;
 
@@ -212,7 +191,6 @@ private:
     ShaderCacheOpenGL shader_cache;
     SamplerCacheOpenGL sampler_cache;
     FramebufferCacheOpenGL framebuffer_cache;
-    QueryCache query_cache;
 
     Core::System& system;
     ScreenInfo& screen_info;
@@ -230,8 +208,19 @@ private:
     BindBuffersRangePushBuffer bind_ubo_pushbuffer{GL_UNIFORM_BUFFER};
     BindBuffersRangePushBuffer bind_ssbo_pushbuffer{GL_SHADER_STORAGE_BUFFER};
 
-    /// Number of commands queued to the OpenGL driver. Reseted on flush.
-    std::size_t num_queued_commands = 0;
+    std::size_t CalculateVertexArraysSize() const;
+
+    std::size_t CalculateIndexBufferSize() const;
+
+    /// Updates and returns a vertex array object representing current vertex format
+    GLuint SetupVertexFormat();
+
+    void SetupVertexBuffer(GLuint vao);
+    void SetupVertexInstances(GLuint vao);
+
+    GLintptr SetupIndexBuffer();
+
+    void SetupShaders(GLenum primitive_mode);
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_resource_manager.cpp

@@ -207,21 +207,4 @@ void OGLFramebuffer::Release() {
     handle = 0;
 }
 
-void OGLQuery::Create(GLenum target) {
-    if (handle != 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
-    glCreateQueries(target, 1, &handle);
-}
-
-void OGLQuery::Release() {
-    if (handle == 0)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
-    glDeleteQueries(1, &handle);
-    handle = 0;
-}
-
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_resource_manager.h

@@ -266,29 +266,4 @@ public:
     GLuint handle = 0;
 };
 
-class OGLQuery : private NonCopyable {
-public:
-    OGLQuery() = default;
-
-    OGLQuery(OGLQuery&& o) noexcept : handle(std::exchange(o.handle, 0)) {}
-
-    ~OGLQuery() {
-        Release();
-    }
-
-    OGLQuery& operator=(OGLQuery&& o) noexcept {
-        Release();
-        handle = std::exchange(o.handle, 0);
-        return *this;
-    }
-
-    /// Creates a new internal OpenGL resource and stores the handle
-    void Create(GLenum target);
-
-    /// Deletes the internal OpenGL resource
-    void Release();
-
-    GLuint handle = 0;
-};
-
 } // namespace OpenGL

src/video_core/renderer_vulkan/vk_device.cpp

@@ -104,7 +104,6 @@ bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instan
     features.depthBiasClamp = true;
     features.geometryShader = true;
     features.tessellationShader = true;
-    features.occlusionQueryPrecise = true;
     features.fragmentStoresAndAtomics = true;
     features.shaderImageGatherExtended = true;
     features.shaderStorageImageWriteWithoutFormat = true;
@@ -118,10 +117,6 @@ bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instan
     bit8_storage.uniformAndStorageBuffer8BitAccess = true;
     SetNext(next, bit8_storage);
 
-    vk::PhysicalDeviceHostQueryResetFeaturesEXT host_query_reset;
-    host_query_reset.hostQueryReset = true;
-    SetNext(next, host_query_reset);
-
     vk::PhysicalDeviceFloat16Int8FeaturesKHR float16_int8;
     if (is_float16_supported) {
         float16_int8.shaderFloat16 = true;
@@ -278,7 +273,6 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
         VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,
         VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME,
         VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME,
-        VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME,
     };
     std::bitset<required_extensions.size()> available_extensions{};
 
@@ -346,7 +340,6 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
         std::make_pair(features.depthBiasClamp, "depthBiasClamp"),
         std::make_pair(features.geometryShader, "geometryShader"),
         std::make_pair(features.tessellationShader, "tessellationShader"),
-        std::make_pair(features.occlusionQueryPrecise, "occlusionQueryPrecise"),
         std::make_pair(features.fragmentStoresAndAtomics, "fragmentStoresAndAtomics"),
         std::make_pair(features.shaderImageGatherExtended, "shaderImageGatherExtended"),
         std::make_pair(features.shaderStorageImageWriteWithoutFormat,
@@ -383,7 +376,7 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
         }
     };
 
-    extensions.reserve(14);
+    extensions.reserve(13);
     extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     extensions.push_back(VK_KHR_16BIT_STORAGE_EXTENSION_NAME);
     extensions.push_back(VK_KHR_8BIT_STORAGE_EXTENSION_NAME);
@@ -391,7 +384,6 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
     extensions.push_back(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME);
     extensions.push_back(VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME);
     extensions.push_back(VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME);
-    extensions.push_back(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME);
 
     [[maybe_unused]] const bool nsight =
         std::getenv("NVTX_INJECTION64_PATH") || std::getenv("NSIGHT_LAUNCHED");

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1,122 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <utility>
-#include <vector>
-
-#include "video_core/renderer_vulkan/declarations.h"
-#include "video_core/renderer_vulkan/vk_device.h"
-#include "video_core/renderer_vulkan/vk_query_cache.h"
-#include "video_core/renderer_vulkan/vk_resource_manager.h"
-#include "video_core/renderer_vulkan/vk_scheduler.h"
-
-namespace Vulkan {
-
-namespace {
-
-constexpr std::array QUERY_TARGETS = {vk::QueryType::eOcclusion};
-
-constexpr vk::QueryType GetTarget(VideoCore::QueryType type) {
-    return QUERY_TARGETS[static_cast<std::size_t>(type)];
-}
-
-} // Anonymous namespace
-
-QueryPool::QueryPool() : VKFencedPool{GROW_STEP} {}
-
-QueryPool::~QueryPool() = default;
-
-void QueryPool::Initialize(const VKDevice& device_, VideoCore::QueryType type_) {
-    device = &device_;
-    type = type_;
-}
-
-std::pair<vk::QueryPool, std::uint32_t> QueryPool::Commit(VKFence& fence) {
-    std::size_t index;
-    do {
-        index = CommitResource(fence);
-    } while (usage[index]);
-    usage[index] = true;
-
-    return {*pools[index / GROW_STEP], static_cast<std::uint32_t>(index % GROW_STEP)};
-}
-
-void QueryPool::Allocate(std::size_t begin, std::size_t end) {
-    usage.resize(end);
-
-    const auto dev = device->GetLogical();
-    const u32 size = static_cast<u32>(end - begin);
-    const vk::QueryPoolCreateInfo query_pool_ci({}, GetTarget(type), size, {});
-    pools.push_back(dev.createQueryPoolUnique(query_pool_ci, nullptr, device->GetDispatchLoader()));
-}
-
-void QueryPool::Reserve(std::pair<vk::QueryPool, std::uint32_t> query) {
-    const auto it =
-        std::find_if(std::begin(pools), std::end(pools),
-                     [query_pool = query.first](auto& pool) { return query_pool == *pool; });
-    ASSERT(it != std::end(pools));
-
-    const std::ptrdiff_t pool_index = std::distance(std::begin(pools), it);
-    usage[pool_index * GROW_STEP + static_cast<std::ptrdiff_t>(query.second)] = false;
-}
-
-VKQueryCache::VKQueryCache(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
-                           const VKDevice& device, VKScheduler& scheduler)
-    : VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter,
-                                  QueryPool>{system, rasterizer},
-      device{device}, scheduler{scheduler} {
-    for (std::size_t i = 0; i < static_cast<std::size_t>(VideoCore::NumQueryTypes); ++i) {
-        query_pools[i].Initialize(device, static_cast<VideoCore::QueryType>(i));
-    }
-}
-
-VKQueryCache::~VKQueryCache() = default;
-
-std::pair<vk::QueryPool, std::uint32_t> VKQueryCache::AllocateQuery(VideoCore::QueryType type) {
-    return query_pools[static_cast<std::size_t>(type)].Commit(scheduler.GetFence());
-}
-
-void VKQueryCache::Reserve(VideoCore::QueryType type,
-                           std::pair<vk::QueryPool, std::uint32_t> query) {
-    query_pools[static_cast<std::size_t>(type)].Reserve(query);
-}
-
-HostCounter::HostCounter(VKQueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type)
-    : VideoCommon::HostCounterBase<VKQueryCache, HostCounter>{std::move(dependency)}, cache{cache},
-      type{type}, query{cache.AllocateQuery(type)}, ticks{cache.Scheduler().Ticks()} {
-    const auto dev = cache.Device().GetLogical();
-    cache.Scheduler().Record([dev, query = query](vk::CommandBuffer cmdbuf, auto& dld) {
-        dev.resetQueryPoolEXT(query.first, query.second, 1, dld);
-        cmdbuf.beginQuery(query.first, query.second, vk::QueryControlFlagBits::ePrecise, dld);
-    });
-}
-
-HostCounter::~HostCounter() {
-    cache.Reserve(type, query);
-}
-
-void HostCounter::EndQuery() {
-    cache.Scheduler().Record([query = query](auto cmdbuf, auto& dld) {
-        cmdbuf.endQuery(query.first, query.second, dld);
-    });
-}
-
-u64 HostCounter::BlockingQuery() const {
-    if (ticks >= cache.Scheduler().Ticks()) {
-        cache.Scheduler().Flush();
-    }
-
-    const auto dev = cache.Device().GetLogical();
-    const auto& dld = cache.Device().GetDispatchLoader();
-    u64 value;
-    dev.getQueryPoolResults(query.first, query.second, 1, sizeof(value), &value, sizeof(value),
-                            vk::QueryResultFlagBits::e64 | vk::QueryResultFlagBits::eWait, dld);
-    return value;
-}
-
-} // namespace Vulkan

src/video_core/renderer_vulkan/vk_query_cache.h

@@ -1,104 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "common/common_types.h"
-#include "video_core/query_cache.h"
-#include "video_core/renderer_vulkan/declarations.h"
-#include "video_core/renderer_vulkan/vk_resource_manager.h"
-
-namespace VideoCore {
-class RasterizerInterface;
-}
-
-namespace Vulkan {
-
-class CachedQuery;
-class HostCounter;
-class VKDevice;
-class VKQueryCache;
-class VKScheduler;
-
-using CounterStream = VideoCommon::CounterStreamBase<VKQueryCache, HostCounter>;
-
-class QueryPool final : public VKFencedPool {
-public:
-    explicit QueryPool();
-    ~QueryPool() override;
-
-    void Initialize(const VKDevice& device, VideoCore::QueryType type);
-
-    std::pair<vk::QueryPool, std::uint32_t> Commit(VKFence& fence);
-
-    void Reserve(std::pair<vk::QueryPool, std::uint32_t> query);
-
-protected:
-    void Allocate(std::size_t begin, std::size_t end) override;
-
-private:
-    static constexpr std::size_t GROW_STEP = 512;
-
-    const VKDevice* device = nullptr;
-    VideoCore::QueryType type = {};
-
-    std::vector<UniqueQueryPool> pools;
-    std::vector<bool> usage;
-};
-
-class VKQueryCache final
-    : public VideoCommon::QueryCacheBase<VKQueryCache, CachedQuery, CounterStream, HostCounter,
-                                         QueryPool> {
-public:
-    explicit VKQueryCache(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
-                          const VKDevice& device, VKScheduler& scheduler);
-    ~VKQueryCache();
-
-    std::pair<vk::QueryPool, std::uint32_t> AllocateQuery(VideoCore::QueryType type);
-
-    void Reserve(VideoCore::QueryType type, std::pair<vk::QueryPool, std::uint32_t> query);
-
-    const VKDevice& Device() const noexcept {
-        return device;
-    }
-
-    VKScheduler& Scheduler() const noexcept {
-        return scheduler;
-    }
-
-private:
-    const VKDevice& device;
-    VKScheduler& scheduler;
-};
-
-class HostCounter final : public VideoCommon::HostCounterBase<VKQueryCache, HostCounter> {
-public:
-    explicit HostCounter(VKQueryCache& cache, std::shared_ptr<HostCounter> dependency,
-                         VideoCore::QueryType type);
-    ~HostCounter();
-
-    void EndQuery();
-
-private:
-    u64 BlockingQuery() const override;
-
-    VKQueryCache& cache;
-    const VideoCore::QueryType type;
-    const std::pair<vk::QueryPool, std::uint32_t> query;
-    const u64 ticks;
-};
-
-class CachedQuery : public VideoCommon::CachedQueryBase<HostCounter> {
-public:
-    explicit CachedQuery(VKQueryCache&, VideoCore::QueryType, VAddr cpu_addr, u8* host_ptr)
-        : VideoCommon::CachedQueryBase<HostCounter>{cpu_addr, host_ptr} {}
-};
-
-} // namespace Vulkan

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -289,9 +289,7 @@ RasterizerVulkan::RasterizerVulkan(Core::System& system, Core::Frontend::EmuWind
                     staging_pool),
       pipeline_cache(system, *this, device, scheduler, descriptor_pool, update_descriptor_queue),
       buffer_cache(*this, system, device, memory_manager, scheduler, staging_pool),
-      sampler_cache(device), query_cache(system, *this, device, scheduler) {
-    scheduler.SetQueryCache(query_cache);
-}
+      sampler_cache(device) {}
 
 RasterizerVulkan::~RasterizerVulkan() = default;
 
@@ -310,8 +308,6 @@ void RasterizerVulkan::Draw(bool is_indexed, bool is_instanced) {
 
     FlushWork();
 
-    query_cache.UpdateCounters();
-
     const auto& gpu = system.GPU().Maxwell3D();
     GraphicsPipelineCacheKey key{GetFixedPipelineState(gpu.regs)};
 
@@ -366,8 +362,6 @@ void RasterizerVulkan::Draw(bool is_indexed, bool is_instanced) {
 void RasterizerVulkan::Clear() {
     MICROPROFILE_SCOPE(Vulkan_Clearing);
 
-    query_cache.UpdateCounters();
-
     const auto& gpu = system.GPU().Maxwell3D();
     if (!system.GPU().Maxwell3D().ShouldExecute()) {
         return;
@@ -435,8 +429,6 @@ void RasterizerVulkan::DispatchCompute(GPUVAddr code_addr) {
     sampled_views.clear();
     image_views.clear();
 
-    query_cache.UpdateCounters();
-
     const auto& launch_desc = system.GPU().KeplerCompute().launch_description;
     const ComputePipelineCacheKey key{
         code_addr,
@@ -479,28 +471,17 @@ void RasterizerVulkan::DispatchCompute(GPUVAddr code_addr) {
     });
 }
 
-void RasterizerVulkan::ResetCounter(VideoCore::QueryType type) {
-    query_cache.ResetCounter(type);
-}
-
-void RasterizerVulkan::Query(GPUVAddr gpu_addr, VideoCore::QueryType type,
-                             std::optional<u64> timestamp) {
-    query_cache.Query(gpu_addr, type, timestamp);
-}
-
 void RasterizerVulkan::FlushAll() {}
 
 void RasterizerVulkan::FlushRegion(CacheAddr addr, u64 size) {
     texture_cache.FlushRegion(addr, size);
     buffer_cache.FlushRegion(addr, size);
-    query_cache.FlushRegion(addr, size);
 }
 
 void RasterizerVulkan::InvalidateRegion(CacheAddr addr, u64 size) {
     texture_cache.InvalidateRegion(addr, size);
     pipeline_cache.InvalidateRegion(addr, size);
     buffer_cache.InvalidateRegion(addr, size);
-    query_cache.InvalidateRegion(addr, size);
 }
 
 void RasterizerVulkan::FlushAndInvalidateRegion(CacheAddr addr, u64 size) {

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -24,7 +24,6 @@
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_memory_manager.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
-#include "video_core/renderer_vulkan/vk_query_cache.h"
 #include "video_core/renderer_vulkan/vk_renderpass_cache.h"
 #include "video_core/renderer_vulkan/vk_resource_manager.h"
 #include "video_core/renderer_vulkan/vk_sampler_cache.h"
@@ -97,7 +96,7 @@ struct ImageView {
     vk::ImageLayout* layout = nullptr;
 };
 
-class RasterizerVulkan final : public VideoCore::RasterizerAccelerated {
+class RasterizerVulkan : public VideoCore::RasterizerAccelerated {
 public:
     explicit RasterizerVulkan(Core::System& system, Core::Frontend::EmuWindow& render_window,
                               VKScreenInfo& screen_info, const VKDevice& device,
@@ -109,8 +108,6 @@ public:
     bool DrawMultiBatch(bool is_indexed) override;
     void Clear() override;
     void DispatchCompute(GPUVAddr code_addr) override;
-    void ResetCounter(VideoCore::QueryType type) override;
-    void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional<u64> timestamp) override;
     void FlushAll() override;
     void FlushRegion(CacheAddr addr, u64 size) override;
     void InvalidateRegion(CacheAddr addr, u64 size) override;
@@ -250,7 +247,6 @@ private:
     VKPipelineCache pipeline_cache;
     VKBufferCache buffer_cache;
     VKSamplerCache sampler_cache;
-    VKQueryCache query_cache;
 
     std::array<View, Maxwell::NumRenderTargets> color_attachments;
     View zeta_attachment;

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -6,7 +6,6 @@
 #include "common/microprofile.h"
 #include "video_core/renderer_vulkan/declarations.h"
 #include "video_core/renderer_vulkan/vk_device.h"
-#include "video_core/renderer_vulkan/vk_query_cache.h"
 #include "video_core/renderer_vulkan/vk_resource_manager.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 
@@ -140,8 +139,6 @@ void VKScheduler::SubmitExecution(vk::Semaphore semaphore) {
 }
 
 void VKScheduler::AllocateNewContext() {
-    ++ticks;
-
     std::unique_lock lock{mutex};
     current_fence = next_fence;
     next_fence = &resource_manager.CommitFence();
@@ -149,10 +146,6 @@ void VKScheduler::AllocateNewContext() {
     current_cmdbuf = resource_manager.CommitCommandBuffer(*current_fence);
     current_cmdbuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit},
                          device.GetDispatchLoader());
-    // Enable counters once again. These are disabled when a command buffer is finished.
-    if (query_cache) {
-        query_cache->UpdateCounters();
-    }
 }
 
 void VKScheduler::InvalidateState() {
@@ -166,7 +159,6 @@ void VKScheduler::InvalidateState() {
 }
 
 void VKScheduler::EndPendingOperations() {
-    query_cache->DisableStreams();
     EndRenderPass();
 }
 

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <atomic>
 #include <condition_variable>
 #include <memory>
 #include <optional>
@@ -19,7 +18,6 @@ namespace Vulkan {
 
 class VKDevice;
 class VKFence;
-class VKQueryCache;
 class VKResourceManager;
 
 class VKFenceView {
@@ -69,11 +67,6 @@ public:
     /// Binds a pipeline to the current execution context.
     void BindGraphicsPipeline(vk::Pipeline pipeline);
 
-    /// Assigns the query cache.
-    void SetQueryCache(VKQueryCache& query_cache_) {
-        query_cache = &query_cache_;
-    }
-
     /// Returns true when viewports have been set in the current command buffer.
     bool TouchViewports() {
         return std::exchange(state.viewports, true);
@@ -119,11 +112,6 @@ public:
         return current_fence;
     }
 
-    /// Returns the current command buffer tick.
-    u64 Ticks() const {
-        return ticks;
-    }
-
 private:
     class Command {
     public:
@@ -217,8 +205,6 @@ private:
 
     const VKDevice& device;
     VKResourceManager& resource_manager;
-    VKQueryCache* query_cache = nullptr;
-
     vk::CommandBuffer current_cmdbuf;
     VKFence* current_fence = nullptr;
     VKFence* next_fence = nullptr;
@@ -241,7 +227,6 @@ private:
     Common::SPSCQueue<std::unique_ptr<CommandChunk>> chunk_reserve;
     std::mutex mutex;
     std::condition_variable cv;
-    std::atomic<u64> ticks = 0;
     bool quit = false;
 };