cmake: support the standard cmake testing option

CMakeLists.txt

@@ -3,12 +3,14 @@
 
 cmake_minimum_required(VERSION 3.22)
 
+project(yuzu)
+
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
+
 include(DownloadExternals)
 include(CMakeDependentOption)
-
-project(yuzu)
+include(CTest)
 
 # Set bundled sdl2/qt as dependent options.
 # OFF by default, but if ENABLE_SDL2 and MSVC are true then ON
@@ -42,7 +44,7 @@ option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
-option(YUZU_TESTS "Compile tests" ON)
+option(YUZU_TESTS "Compile tests" "${BUILD_TESTING}")
 
 option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)
 
@@ -242,7 +244,7 @@ if (ENABLE_WEB_SERVICE)
 endif()
 
 if (YUZU_TESTS)
-    find_package(Catch2 2.13.7 REQUIRED)
+    find_package(Catch2 3.0.1 REQUIRED)
 endif()
 
 find_package(Boost 1.73.0 COMPONENTS context)
@@ -606,7 +608,6 @@ if (YUZU_USE_FASTER_LD AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     endif()
 endif()
 
-enable_testing()
 add_subdirectory(externals)
 add_subdirectory(src)
 

externals/CMakeLists.txt

@@ -5,6 +5,9 @@
 # some of its variables, which is only possible in 3.13+
 set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
 
+# Disable tests in all externals supporting the standard option name
+set(BUILD_TESTING OFF)
+
 # xbyak
 if ((ARCHITECTURE_x86 OR ARCHITECTURE_x86_64) AND NOT TARGET xbyak::xbyak)
     add_subdirectory(xbyak EXCLUDE_FROM_ALL)

src/common/input.h

@@ -292,6 +292,9 @@ class InputDevice {
 public:
     virtual ~InputDevice() = default;
 
+    // Request input device to update if necessary
+    virtual void SoftUpdate() {}
+
     // Force input device to update data regardless of the current state
     virtual void ForceUpdate() {}
 

src/common/settings.cpp

@@ -185,7 +185,6 @@ void RestoreGlobalState(bool is_powered_on) {
     // Renderer
     values.fsr_sharpening_slider.SetGlobal(true);
     values.renderer_backend.SetGlobal(true);
-    values.renderer_force_max_clock.SetGlobal(true);
     values.vulkan_device.SetGlobal(true);
     values.aspect_ratio.SetGlobal(true);
     values.max_anisotropy.SetGlobal(true);
@@ -201,7 +200,6 @@ void RestoreGlobalState(bool is_powered_on) {
     values.use_asynchronous_shaders.SetGlobal(true);
     values.use_fast_gpu_time.SetGlobal(true);
     values.use_pessimistic_flushes.SetGlobal(true);
-    values.use_vulkan_driver_pipeline_cache.SetGlobal(true);
     values.bg_red.SetGlobal(true);
     values.bg_green.SetGlobal(true);
     values.bg_blue.SetGlobal(true);

src/common/settings.h

@@ -415,7 +415,6 @@ struct Values {
     // Renderer
     SwitchableSetting<RendererBackend, true> renderer_backend{
         RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"};
-    SwitchableSetting<bool> renderer_force_max_clock{false, "force_max_clock"};
     Setting<bool> renderer_debug{false, "debug"};
     Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
     Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
@@ -452,8 +451,6 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
     SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
     SwitchableSetting<bool> use_pessimistic_flushes{false, "use_pessimistic_flushes"};
-    SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true,
-                                                             "use_vulkan_driver_pipeline_cache"};
 
     SwitchableSetting<u8> bg_red{0, "bg_red"};
     SwitchableSetting<u8> bg_green{0, "bg_green"};

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -229,11 +229,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     config.enable_cycle_counting = true;
 
     // Code cache size
-#ifdef ARCHITECTURE_arm64
-    config.code_cache_size = 128_MiB;
-#else
     config.code_cache_size = 512_MiB;
-#endif
 
     // Allow memory fault handling to work
     if (system.DebuggerEnabled()) {

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -288,11 +288,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
     config.enable_cycle_counting = true;
 
     // Code cache size
-#ifdef ARCHITECTURE_arm64
-    config.code_cache_size = 128_MiB;
-#else
     config.code_cache_size = 512_MiB;
-#endif
 
     // Allow memory fault handling to work
     if (system.DebuggerEnabled()) {

src/core/hid/emulated_controller.cpp

@@ -1434,6 +1434,16 @@ AnalogSticks EmulatedController::GetSticks() const {
         return {};
     }
 
+    // Some drivers like stick from buttons need constant refreshing
+    for (auto& device : stick_devices) {
+        if (!device) {
+            continue;
+        }
+        lock.unlock();
+        device->SoftUpdate();
+        lock.lock();
+    }
+
     return controller.analog_stick_state;
 }
 

src/core/internal_network/network.cpp

@@ -117,8 +117,6 @@ Errno TranslateNativeError(int e) {
         return Errno::NETUNREACH;
     case WSAEMSGSIZE:
         return Errno::MSGSIZE;
-    case WSAETIMEDOUT:
-        return Errno::TIMEDOUT;
     default:
         UNIMPLEMENTED_MSG("Unimplemented errno={}", e);
         return Errno::OTHER;
@@ -213,8 +211,6 @@ Errno TranslateNativeError(int e) {
         return Errno::NETUNREACH;
     case EMSGSIZE:
         return Errno::MSGSIZE;
-    case ETIMEDOUT:
-        return Errno::TIMEDOUT;
     default:
         UNIMPLEMENTED_MSG("Unimplemented errno={}", e);
         return Errno::OTHER;
@@ -230,7 +226,7 @@ Errno GetAndLogLastError() {
     int e = errno;
 #endif
     const Errno err = TranslateNativeError(e);
-    if (err == Errno::AGAIN || err == Errno::TIMEDOUT) {
+    if (err == Errno::AGAIN) {
         return err;
     }
     LOG_ERROR(Network, "Socket operation error: {}", Common::NativeErrorToString(e));

src/core/memory.cpp

@@ -436,7 +436,7 @@ struct Memory::Impl {
         }
 
         if (Settings::IsFastmemEnabled()) {
-            const bool is_read_enable = !Settings::IsGPULevelExtreme() || !cached;
+            const bool is_read_enable = Settings::IsGPULevelHigh() || !cached;
             system.DeviceMemory().buffer.Protect(vaddr, size, is_read_enable, !cached);
         }
 

src/input_common/helpers/stick_from_buttons.cpp

@@ -13,11 +13,11 @@ class Stick final : public Common::Input::InputDevice {
 public:
     using Button = std::unique_ptr<Common::Input::InputDevice>;
 
-    Stick(Button up_, Button down_, Button left_, Button right_, Button modifier_, Button updater_,
+    Stick(Button up_, Button down_, Button left_, Button right_, Button modifier_,
           float modifier_scale_, float modifier_angle_)
         : up(std::move(up_)), down(std::move(down_)), left(std::move(left_)),
-          right(std::move(right_)), modifier(std::move(modifier_)), updater(std::move(updater_)),
-          modifier_scale(modifier_scale_), modifier_angle(modifier_angle_) {
+          right(std::move(right_)), modifier(std::move(modifier_)), modifier_scale(modifier_scale_),
+          modifier_angle(modifier_angle_) {
         up->SetCallback({
             .on_change =
                 [this](const Common::Input::CallbackStatus& callback_) {
@@ -48,9 +48,6 @@ public:
                     UpdateModButtonStatus(callback_);
                 },
         });
-        updater->SetCallback({
-            .on_change = [this](const Common::Input::CallbackStatus& callback_) { SoftUpdate(); },
-        });
         last_x_axis_value = 0.0f;
         last_y_axis_value = 0.0f;
     }
@@ -251,7 +248,7 @@ public:
         modifier->ForceUpdate();
     }
 
-    void SoftUpdate() {
+    void SoftUpdate() override {
         Common::Input::CallbackStatus status{
             .type = Common::Input::InputType::Stick,
             .stick_status = GetStatus(),
@@ -311,7 +308,6 @@ private:
     Button left;
     Button right;
     Button modifier;
-    Button updater;
     float modifier_scale{};
     float modifier_angle{};
     float angle{};
@@ -335,12 +331,11 @@ std::unique_ptr<Common::Input::InputDevice> StickFromButton::Create(
     auto left = Common::Input::CreateInputDeviceFromString(params.Get("left", null_engine));
     auto right = Common::Input::CreateInputDeviceFromString(params.Get("right", null_engine));
     auto modifier = Common::Input::CreateInputDeviceFromString(params.Get("modifier", null_engine));
-    auto updater = Common::Input::CreateInputDeviceFromString("engine:updater,button:0");
     auto modifier_scale = params.Get("modifier_scale", 0.5f);
     auto modifier_angle = params.Get("modifier_angle", 5.5f);
     return std::make_unique<Stick>(std::move(up), std::move(down), std::move(left),
-                                   std::move(right), std::move(modifier), std::move(updater),
-                                   modifier_scale, modifier_angle);
+                                   std::move(right), std::move(modifier), modifier_scale,
+                                   modifier_angle);
 }
 
 } // namespace InputCommon

src/input_common/main.cpp

@@ -28,28 +28,6 @@
 
 namespace InputCommon {
 
-/// Dummy engine to get periodic updates
-class UpdateEngine final : public InputEngine {
-public:
-    explicit UpdateEngine(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
-        PreSetController(identifier);
-    }
-
-    void PumpEvents() {
-        SetButton(identifier, 0, last_state);
-        last_state = !last_state;
-    }
-
-private:
-    static constexpr PadIdentifier identifier = {
-        .guid = Common::UUID{},
-        .port = 0,
-        .pad = 0,
-    };
-
-    bool last_state{};
-};
-
 struct InputSubsystem::Impl {
     template <typename Engine>
     void RegisterEngine(std::string name, std::shared_ptr<Engine>& engine) {
@@ -67,7 +45,6 @@ struct InputSubsystem::Impl {
     void Initialize() {
         mapping_factory = std::make_shared<MappingFactory>();
 
-        RegisterEngine("updater", update_engine);
         RegisterEngine("keyboard", keyboard);
         RegisterEngine("mouse", mouse);
         RegisterEngine("touch", touch_screen);
@@ -97,7 +74,6 @@ struct InputSubsystem::Impl {
     }
 
     void Shutdown() {
-        UnregisterEngine(update_engine);
         UnregisterEngine(keyboard);
         UnregisterEngine(mouse);
         UnregisterEngine(touch_screen);
@@ -276,7 +252,6 @@ struct InputSubsystem::Impl {
     }
 
     void PumpEvents() const {
-        update_engine->PumpEvents();
 #ifdef HAVE_SDL2
         sdl->PumpEvents();
 #endif
@@ -288,7 +263,6 @@ struct InputSubsystem::Impl {
 
     std::shared_ptr<MappingFactory> mapping_factory;
 
-    std::shared_ptr<UpdateEngine> update_engine;
     std::shared_ptr<Keyboard> keyboard;
     std::shared_ptr<Mouse> mouse;
     std::shared_ptr<TouchScreen> touch_screen;

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -321,12 +321,8 @@ Id EmitGetAttribute(EmitContext& ctx, IR::Attribute attr, Id vertex) {
     case IR::Attribute::PositionY:
     case IR::Attribute::PositionZ:
     case IR::Attribute::PositionW:
-        return ctx.OpLoad(
-            ctx.F32[1],
-            ctx.need_input_position_indirect
-                ? AttrPointer(ctx, ctx.input_f32, vertex, ctx.input_position, ctx.u32_zero_value,
-                              ctx.Const(element))
-                : AttrPointer(ctx, ctx.input_f32, vertex, ctx.input_position, ctx.Const(element)));
+        return ctx.OpLoad(ctx.F32[1], AttrPointer(ctx, ctx.input_f32, vertex, ctx.input_position,
+                                                  ctx.Const(element)));
     case IR::Attribute::InstanceId:
         if (ctx.profile.support_vertex_instance_id) {
             return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.instance_id));

src/shader_recompiler/backend/spirv/emit_spirv_warp.cpp

@@ -58,10 +58,11 @@ Id SelectValue(EmitContext& ctx, Id in_range, Id value, Id src_thread_id) {
         ctx.OpGroupNonUniformShuffle(ctx.U32[1], SubgroupScope(ctx), value, src_thread_id), value);
 }
 
-Id AddPartitionBase(EmitContext& ctx, Id thread_id) {
-    const Id partition_idx{ctx.OpShiftRightLogical(ctx.U32[1], GetThreadId(ctx), ctx.Const(5u))};
-    const Id partition_base{ctx.OpShiftLeftLogical(ctx.U32[1], partition_idx, ctx.Const(5u))};
-    return ctx.OpIAdd(ctx.U32[1], thread_id, partition_base);
+Id GetUpperClamp(EmitContext& ctx, Id invocation_id, Id clamp) {
+    const Id thirty_two{ctx.Const(32u)};
+    const Id is_upper_partition{ctx.OpSGreaterThanEqual(ctx.U1, invocation_id, thirty_two)};
+    const Id upper_clamp{ctx.OpIAdd(ctx.U32[1], thirty_two, clamp)};
+    return ctx.OpSelect(ctx.U32[1], is_upper_partition, upper_clamp, clamp);
 }
 } // Anonymous namespace
 
@@ -144,32 +145,35 @@ Id EmitSubgroupGeMask(EmitContext& ctx) {
 Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                     Id segmentation_mask) {
     const Id not_seg_mask{ctx.OpNot(ctx.U32[1], segmentation_mask)};
-    const Id thread_id{EmitLaneId(ctx)};
+    const Id thread_id{GetThreadId(ctx)};
+    if (ctx.profile.warp_size_potentially_larger_than_guest) {
+        const Id thirty_two{ctx.Const(32u)};
+        const Id is_upper_partition{ctx.OpSGreaterThanEqual(ctx.U1, thread_id, thirty_two)};
+        const Id upper_index{ctx.OpIAdd(ctx.U32[1], thirty_two, index)};
+        const Id upper_clamp{ctx.OpIAdd(ctx.U32[1], thirty_two, clamp)};
+        index = ctx.OpSelect(ctx.U32[1], is_upper_partition, upper_index, index);
+        clamp = ctx.OpSelect(ctx.U32[1], is_upper_partition, upper_clamp, clamp);
+    }
     const Id min_thread_id{ComputeMinThreadId(ctx, thread_id, segmentation_mask)};
     const Id max_thread_id{ComputeMaxThreadId(ctx, min_thread_id, clamp, not_seg_mask)};
 
     const Id lhs{ctx.OpBitwiseAnd(ctx.U32[1], index, not_seg_mask)};
-    Id src_thread_id{ctx.OpBitwiseOr(ctx.U32[1], lhs, min_thread_id)};
+    const Id src_thread_id{ctx.OpBitwiseOr(ctx.U32[1], lhs, min_thread_id)};
     const Id in_range{ctx.OpSLessThanEqual(ctx.U1, src_thread_id, max_thread_id)};
 
-    if (ctx.profile.warp_size_potentially_larger_than_guest) {
-        src_thread_id = AddPartitionBase(ctx, src_thread_id);
-    }
-
     SetInBoundsFlag(inst, in_range);
     return SelectValue(ctx, in_range, value, src_thread_id);
 }
 
 Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                  Id segmentation_mask) {
-    const Id thread_id{EmitLaneId(ctx)};
-    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
-    Id src_thread_id{ctx.OpISub(ctx.U32[1], thread_id, index)};
-    const Id in_range{ctx.OpSGreaterThanEqual(ctx.U1, src_thread_id, max_thread_id)};
-
+    const Id thread_id{GetThreadId(ctx)};
     if (ctx.profile.warp_size_potentially_larger_than_guest) {
-        src_thread_id = AddPartitionBase(ctx, src_thread_id);
+        clamp = GetUpperClamp(ctx, thread_id, clamp);
     }
+    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
+    const Id src_thread_id{ctx.OpISub(ctx.U32[1], thread_id, index)};
+    const Id in_range{ctx.OpSGreaterThanEqual(ctx.U1, src_thread_id, max_thread_id)};
 
     SetInBoundsFlag(inst, in_range);
     return SelectValue(ctx, in_range, value, src_thread_id);
@@ -177,14 +181,13 @@ Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
 
 Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                    Id segmentation_mask) {
-    const Id thread_id{EmitLaneId(ctx)};
-    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
-    Id src_thread_id{ctx.OpIAdd(ctx.U32[1], thread_id, index)};
-    const Id in_range{ctx.OpSLessThanEqual(ctx.U1, src_thread_id, max_thread_id)};
-
+    const Id thread_id{GetThreadId(ctx)};
     if (ctx.profile.warp_size_potentially_larger_than_guest) {
-        src_thread_id = AddPartitionBase(ctx, src_thread_id);
+        clamp = GetUpperClamp(ctx, thread_id, clamp);
     }
+    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
+    const Id src_thread_id{ctx.OpIAdd(ctx.U32[1], thread_id, index)};
+    const Id in_range{ctx.OpSLessThanEqual(ctx.U1, src_thread_id, max_thread_id)};
 
     SetInBoundsFlag(inst, in_range);
     return SelectValue(ctx, in_range, value, src_thread_id);
@@ -192,14 +195,13 @@ Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clam
 
 Id EmitShuffleButterfly(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                         Id segmentation_mask) {
-    const Id thread_id{EmitLaneId(ctx)};
-    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
-    Id src_thread_id{ctx.OpBitwiseXor(ctx.U32[1], thread_id, index)};
-    const Id in_range{ctx.OpSLessThanEqual(ctx.U1, src_thread_id, max_thread_id)};
-
+    const Id thread_id{GetThreadId(ctx)};
     if (ctx.profile.warp_size_potentially_larger_than_guest) {
-        src_thread_id = AddPartitionBase(ctx, src_thread_id);
+        clamp = GetUpperClamp(ctx, thread_id, clamp);
     }
+    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
+    const Id src_thread_id{ctx.OpBitwiseXor(ctx.U32[1], thread_id, index)};
+    const Id in_range{ctx.OpSLessThanEqual(ctx.U1, src_thread_id, max_thread_id)};
 
     SetInBoundsFlag(inst, in_range);
     return SelectValue(ctx, in_range, value, src_thread_id);

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -544,7 +544,7 @@ void EmitContext::DefineCommonTypes(const Info& info) {
         U16 = Name(TypeInt(16, false), "u16");
         S16 = Name(TypeInt(16, true), "s16");
     }
-    if (info.uses_int64 && profile.support_int64) {
+    if (info.uses_int64) {
         AddCapability(spv::Capability::Int64);
         U64 = Name(TypeInt(64, false), "u64");
     }
@@ -721,21 +721,9 @@ void EmitContext::DefineAttributeMemAccess(const Info& info) {
         size_t label_index{0};
         if (info.loads.AnyComponent(IR::Attribute::PositionX)) {
             AddLabel(labels[label_index]);
-            const Id pointer{[&]() {
-                if (need_input_position_indirect) {
-                    if (is_array)
-                        return OpAccessChain(input_f32, input_position, vertex, u32_zero_value,
-                                             masked_index);
-                    else
-                        return OpAccessChain(input_f32, input_position, u32_zero_value,
-                                             masked_index);
-                } else {
-                    if (is_array)
-                        return OpAccessChain(input_f32, input_position, vertex, masked_index);
-                    else
-                        return OpAccessChain(input_f32, input_position, masked_index);
-                }
-            }()};
+            const Id pointer{is_array
+                                 ? OpAccessChain(input_f32, input_position, vertex, masked_index)
+                                 : OpAccessChain(input_f32, input_position, masked_index)};
             const Id result{OpLoad(F32[1], pointer)};
             OpReturnValue(result);
             ++label_index;
@@ -1379,25 +1367,12 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         Decorate(layer, spv::Decoration::Flat);
     }
     if (loads.AnyComponent(IR::Attribute::PositionX)) {
-        const bool is_fragment{stage == Stage::Fragment};
-        if (!is_fragment && profile.has_broken_spirv_position_input) {
-            need_input_position_indirect = true;
-
-            const Id input_position_struct = TypeStruct(F32[4]);
-            input_position = DefineInput(*this, input_position_struct, true);
-
-            MemberDecorate(input_position_struct, 0, spv::Decoration::BuiltIn,
-                           static_cast<unsigned>(spv::BuiltIn::Position));
-            Decorate(input_position_struct, spv::Decoration::Block);
-        } else {
-            const spv::BuiltIn built_in{is_fragment ? spv::BuiltIn::FragCoord
-                                                    : spv::BuiltIn::Position};
-            input_position = DefineInput(*this, F32[4], true, built_in);
-
-            if (profile.support_geometry_shader_passthrough) {
-                if (info.passthrough.AnyComponent(IR::Attribute::PositionX)) {
-                    Decorate(input_position, spv::Decoration::PassthroughNV);
-                }
+        const bool is_fragment{stage != Stage::Fragment};
+        const spv::BuiltIn built_in{is_fragment ? spv::BuiltIn::Position : spv::BuiltIn::FragCoord};
+        input_position = DefineInput(*this, F32[4], true, built_in);
+        if (profile.support_geometry_shader_passthrough) {
+            if (info.passthrough.AnyComponent(IR::Attribute::PositionX)) {
+                Decorate(input_position, spv::Decoration::PassthroughNV);
             }
         }
     }

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -280,7 +280,6 @@ public:
     Id write_global_func_u32x2{};
     Id write_global_func_u32x4{};
 
-    bool need_input_position_indirect{};
     Id input_position{};
     std::array<Id, 32> input_generics{};
 

src/shader_recompiler/frontend/maxwell/translate_program.cpp

@@ -171,70 +171,6 @@ std::map<IR::Attribute, IR::Attribute> GenerateLegacyToGenericMappings(
     }
     return mapping;
 }
-
-void EmitGeometryPassthrough(IR::IREmitter& ir, const IR::Program& program,
-                             const Shader::VaryingState& passthrough_mask,
-                             bool passthrough_position,
-                             std::optional<IR::Attribute> passthrough_layer_attr) {
-    for (u32 i = 0; i < program.output_vertices; i++) {
-        // Assign generics from input
-        for (u32 j = 0; j < 32; j++) {
-            if (!passthrough_mask.Generic(j)) {
-                continue;
-            }
-
-            const IR::Attribute attr = IR::Attribute::Generic0X + (j * 4);
-            ir.SetAttribute(attr + 0, ir.GetAttribute(attr + 0, ir.Imm32(i)), ir.Imm32(0));
-            ir.SetAttribute(attr + 1, ir.GetAttribute(attr + 1, ir.Imm32(i)), ir.Imm32(0));
-            ir.SetAttribute(attr + 2, ir.GetAttribute(attr + 2, ir.Imm32(i)), ir.Imm32(0));
-            ir.SetAttribute(attr + 3, ir.GetAttribute(attr + 3, ir.Imm32(i)), ir.Imm32(0));
-        }
-
-        if (passthrough_position) {
-            // Assign position from input
-            const IR::Attribute attr = IR::Attribute::PositionX;
-            ir.SetAttribute(attr + 0, ir.GetAttribute(attr + 0, ir.Imm32(i)), ir.Imm32(0));
-            ir.SetAttribute(attr + 1, ir.GetAttribute(attr + 1, ir.Imm32(i)), ir.Imm32(0));
-            ir.SetAttribute(attr + 2, ir.GetAttribute(attr + 2, ir.Imm32(i)), ir.Imm32(0));
-            ir.SetAttribute(attr + 3, ir.GetAttribute(attr + 3, ir.Imm32(i)), ir.Imm32(0));
-        }
-
-        if (passthrough_layer_attr) {
-            // Assign layer
-            ir.SetAttribute(IR::Attribute::Layer, ir.GetAttribute(*passthrough_layer_attr),
-                            ir.Imm32(0));
-        }
-
-        // Emit vertex
-        ir.EmitVertex(ir.Imm32(0));
-    }
-    ir.EndPrimitive(ir.Imm32(0));
-}
-
-u32 GetOutputTopologyVertices(OutputTopology output_topology) {
-    switch (output_topology) {
-    case OutputTopology::PointList:
-        return 1;
-    case OutputTopology::LineStrip:
-        return 2;
-    default:
-        return 3;
-    }
-}
-
-void LowerGeometryPassthrough(const IR::Program& program, const HostTranslateInfo& host_info) {
-    for (IR::Block* const block : program.blocks) {
-        for (IR::Inst& inst : block->Instructions()) {
-            if (inst.GetOpcode() == IR::Opcode::Epilogue) {
-                IR::IREmitter ir{*block, IR::Block::InstructionList::s_iterator_to(inst)};
-                EmitGeometryPassthrough(
-                    ir, program, program.info.passthrough,
-                    program.info.passthrough.AnyComponent(IR::Attribute::PositionX), {});
-            }
-        }
-    }
-}
-
 } // Anonymous namespace
 
 IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Block>& block_pool,
@@ -259,14 +195,9 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
         program.is_geometry_passthrough = sph.common0.geometry_passthrough != 0;
         if (program.is_geometry_passthrough) {
             const auto& mask{env.GpPassthroughMask()};
-            for (size_t i = 0; i < mask.size() * 32; ++i) {
+            for (size_t i = 0; i < program.info.passthrough.mask.size(); ++i) {
                 program.info.passthrough.mask[i] = ((mask[i / 32] >> (i % 32)) & 1) == 0;
             }
-
-            if (!host_info.support_geometry_shader_passthrough) {
-                program.output_vertices = GetOutputTopologyVertices(program.output_topology);
-                LowerGeometryPassthrough(program, host_info);
-            }
         }
         break;
     }
@@ -292,7 +223,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
 
     Optimization::PositionPass(env, program);
 
-    Optimization::GlobalMemoryToStorageBufferPass(program, host_info);
+    Optimization::GlobalMemoryToStorageBufferPass(program);
     Optimization::TexturePass(env, program, host_info);
 
     if (Settings::values.resolution_info.active) {
@@ -411,7 +342,17 @@ IR::Program GenerateGeometryPassthrough(ObjectPool<IR::Inst>& inst_pool,
     IR::Program program;
     program.stage = Stage::Geometry;
     program.output_topology = output_topology;
-    program.output_vertices = GetOutputTopologyVertices(output_topology);
+    switch (output_topology) {
+    case OutputTopology::PointList:
+        program.output_vertices = 1;
+        break;
+    case OutputTopology::LineStrip:
+        program.output_vertices = 2;
+        break;
+    default:
+        program.output_vertices = 3;
+        break;
+    }
 
     program.is_geometry_passthrough = false;
     program.info.loads.mask = source_program.info.stores.mask;
@@ -425,8 +366,35 @@ IR::Program GenerateGeometryPassthrough(ObjectPool<IR::Inst>& inst_pool,
     node.data.block = current_block;
 
     IR::IREmitter ir{*current_block};
-    EmitGeometryPassthrough(ir, program, program.info.stores, true,
-                            source_program.info.emulated_layer);
+    for (u32 i = 0; i < program.output_vertices; i++) {
+        // Assign generics from input
+        for (u32 j = 0; j < 32; j++) {
+            if (!program.info.stores.Generic(j)) {
+                continue;
+            }
+
+            const IR::Attribute attr = IR::Attribute::Generic0X + (j * 4);
+            ir.SetAttribute(attr + 0, ir.GetAttribute(attr + 0, ir.Imm32(i)), ir.Imm32(0));
+            ir.SetAttribute(attr + 1, ir.GetAttribute(attr + 1, ir.Imm32(i)), ir.Imm32(0));
+            ir.SetAttribute(attr + 2, ir.GetAttribute(attr + 2, ir.Imm32(i)), ir.Imm32(0));
+            ir.SetAttribute(attr + 3, ir.GetAttribute(attr + 3, ir.Imm32(i)), ir.Imm32(0));
+        }
+
+        // Assign position from input
+        const IR::Attribute attr = IR::Attribute::PositionX;
+        ir.SetAttribute(attr + 0, ir.GetAttribute(attr + 0, ir.Imm32(i)), ir.Imm32(0));
+        ir.SetAttribute(attr + 1, ir.GetAttribute(attr + 1, ir.Imm32(i)), ir.Imm32(0));
+        ir.SetAttribute(attr + 2, ir.GetAttribute(attr + 2, ir.Imm32(i)), ir.Imm32(0));
+        ir.SetAttribute(attr + 3, ir.GetAttribute(attr + 3, ir.Imm32(i)), ir.Imm32(0));
+
+        // Assign layer
+        ir.SetAttribute(IR::Attribute::Layer, ir.GetAttribute(source_program.info.emulated_layer),
+                        ir.Imm32(0));
+
+        // Emit vertex
+        ir.EmitVertex(ir.Imm32(0));
+    }
+    ir.EndPrimitive(ir.Imm32(0));
 
     IR::Block* return_block{block_pool.Create(inst_pool)};
     IR::IREmitter{*return_block}.Epilogue();

src/shader_recompiler/host_translate_info.h

@@ -15,9 +15,6 @@ struct HostTranslateInfo {
     bool needs_demote_reorder{}; ///< True when the device needs DemoteToHelperInvocation reordered
     bool support_snorm_render_buffer{};  ///< True when the device supports SNORM render buffers
     bool support_viewport_index_layer{}; ///< True when the device supports gl_Layer in VS
-    u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
-    bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
-                                                ///< passthrough shaders
 };
 
 } // namespace Shader

src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp

@@ -11,7 +11,6 @@
 #include "shader_recompiler/frontend/ir/breadth_first_search.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
 #include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/host_translate_info.h"
 #include "shader_recompiler/ir_opt/passes.h"
 
 namespace Shader::Optimization {
@@ -403,7 +402,7 @@ void CollectStorageBuffers(IR::Block& block, IR::Inst& inst, StorageInfo& info)
 }
 
 /// Returns the offset in indices (not bytes) for an equivalent storage instruction
-IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer, u32 alignment) {
+IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer) {
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
     IR::U32 offset;
     if (const std::optional<LowAddrInfo> low_addr{TrackLowAddress(&inst)}) {
@@ -416,10 +415,7 @@ IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer
     }
     // Subtract the least significant 32 bits from the guest offset. The result is the storage
     // buffer offset in bytes.
-    IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
-
-    // Align the offset base to match the host alignment requirements
-    low_cbuf = ir.BitwiseAnd(low_cbuf, ir.Imm32(~(alignment - 1U)));
+    const IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
     return ir.ISub(offset, low_cbuf);
 }
 
@@ -514,7 +510,7 @@ void Replace(IR::Block& block, IR::Inst& inst, const IR::U32& storage_index,
 }
 } // Anonymous namespace
 
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info) {
+void GlobalMemoryToStorageBufferPass(IR::Program& program) {
     StorageInfo info;
     for (IR::Block* const block : program.post_order_blocks) {
         for (IR::Inst& inst : block->Instructions()) {
@@ -538,8 +534,7 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn
         const IR::U32 index{IR::Value{static_cast<u32>(info.set.index_of(it))}};
         IR::Block* const block{storage_inst.block};
         IR::Inst* const inst{storage_inst.inst};
-        const IR::U32 offset{
-            StorageOffset(*block, *inst, storage_buffer, host_info.min_ssbo_alignment)};
+        const IR::U32 offset{StorageOffset(*block, *inst, storage_buffer)};
         Replace(*block, *inst, index, offset);
     }
 }

src/shader_recompiler/ir_opt/passes.h

@@ -15,7 +15,7 @@ namespace Shader::Optimization {
 void CollectShaderInfoPass(Environment& env, IR::Program& program);
 void ConstantPropagationPass(Environment& env, IR::Program& program);
 void DeadCodeEliminationPass(IR::Program& program);
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info);
+void GlobalMemoryToStorageBufferPass(IR::Program& program);
 void IdentityRemovalPass(IR::Program& program);
 void LowerFp16ToFp32(IR::Program& program);
 void LowerInt64ToInt32(IR::Program& program);

src/shader_recompiler/profile.h

@@ -55,8 +55,6 @@ struct Profile {
 
     /// OpFClamp is broken and OpFMax + OpFMin should be used instead
     bool has_broken_spirv_clamp{};
-    /// The Position builtin needs to be wrapped in a struct when used as an input
-    bool has_broken_spirv_position_input{};
     /// Offset image operands with an unsigned type do not work
     bool has_broken_unsigned_image_offsets{};
     /// Signed instructions with unsigned data types are misinterpreted

src/shader_recompiler/shader_info.h

@@ -65,8 +65,6 @@ enum class Interpolation {
 struct ConstantBufferDescriptor {
     u32 index;
     u32 count;
-
-    auto operator<=>(const ConstantBufferDescriptor&) const = default;
 };
 
 struct StorageBufferDescriptor {
@@ -74,8 +72,6 @@ struct StorageBufferDescriptor {
     u32 cbuf_offset;
     u32 count;
     bool is_written;
-
-    auto operator<=>(const StorageBufferDescriptor&) const = default;
 };
 
 struct TextureBufferDescriptor {
@@ -88,8 +84,6 @@ struct TextureBufferDescriptor {
     u32 secondary_shift_left;
     u32 count;
     u32 size_shift;
-
-    auto operator<=>(const TextureBufferDescriptor&) const = default;
 };
 using TextureBufferDescriptors = boost::container::small_vector<TextureBufferDescriptor, 6>;
 
@@ -101,8 +95,6 @@ struct ImageBufferDescriptor {
     u32 cbuf_offset;
     u32 count;
     u32 size_shift;
-
-    auto operator<=>(const ImageBufferDescriptor&) const = default;
 };
 using ImageBufferDescriptors = boost::container::small_vector<ImageBufferDescriptor, 2>;
 
@@ -118,8 +110,6 @@ struct TextureDescriptor {
     u32 secondary_shift_left;
     u32 count;
     u32 size_shift;
-
-    auto operator<=>(const TextureDescriptor&) const = default;
 };
 using TextureDescriptors = boost::container::small_vector<TextureDescriptor, 12>;
 
@@ -132,8 +122,6 @@ struct ImageDescriptor {
     u32 cbuf_offset;
     u32 count;
     u32 size_shift;
-
-    auto operator<=>(const ImageDescriptor&) const = default;
 };
 using ImageDescriptors = boost::container::small_vector<ImageDescriptor, 4>;
 

src/tests/CMakeLists.txt

@@ -14,7 +14,6 @@ add_executable(tests
     core/core_timing.cpp
     core/internal_network/network.cpp
     precompiled_headers.h
-    tests.cpp
     video_core/buffer_base.cpp
     input_common/calibration_configuration_job.cpp
 )
@@ -22,7 +21,7 @@ add_executable(tests
 create_target_directory_groups(tests)
 
 target_link_libraries(tests PRIVATE common core input_common)
-target_link_libraries(tests PRIVATE ${PLATFORM_LIBRARIES} Catch2::Catch2 Threads::Threads)
+target_link_libraries(tests PRIVATE ${PLATFORM_LIBRARIES} Catch2::Catch2WithMain Threads::Threads)
 
 add_test(NAME tests COMMAND tests)
 

src/tests/common/bit_field.cpp

@@ -4,7 +4,7 @@
 #include <array>
 #include <cstring>
 #include <type_traits>
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 #include "common/bit_field.h"
 
 TEST_CASE("BitField", "[common]") {

src/tests/common/cityhash.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "common/cityhash.h"
 

src/tests/common/fibers.cpp

@@ -11,7 +11,7 @@
 #include <unordered_map>
 #include <vector>
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "common/common_types.h"
 #include "common/fiber.h"

src/tests/common/host_memory.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "common/host_memory.h"
 #include "common/literals.h"

src/tests/common/param_package.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 #include <math.h>
 #include "common/logging/backend.h"
 #include "common/param_package.h"

src/tests/common/range_map.cpp

@@ -3,7 +3,7 @@
 
 #include <stdexcept>
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "common/range_map.h"
 

src/tests/common/ring_buffer.cpp

@@ -7,7 +7,7 @@
 #include <numeric>
 #include <thread>
 #include <vector>
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 #include "common/ring_buffer.h"
 
 namespace Common {

src/tests/common/scratch_buffer.cpp

@@ -5,7 +5,7 @@
 #include <array>
 #include <cstring>
 #include <span>
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 #include "common/common_types.h"
 #include "common/scratch_buffer.h"
 

src/tests/common/unique_function.cpp

@@ -3,7 +3,7 @@
 
 #include <string>
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "common/unique_function.h"
 

src/tests/core/core_timing.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2016 Dolphin Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include <array>
 #include <bitset>

src/tests/core/internal_network/network.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "core/internal_network/network.h"
 #include "core/internal_network/sockets.h"

src/tests/input_common/calibration_configuration_job.cpp

@@ -6,7 +6,7 @@
 #include <thread>
 #include <boost/asio.hpp>
 #include <boost/crc.hpp>
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "input_common/drivers/udp_client.h"
 #include "input_common/helpers/udp_protocol.h"

src/tests/tests.cpp

@@ -1,8 +0,0 @@
-// SPDX-FileCopyrightText: 2016 Citra Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#define CATCH_CONFIG_MAIN
-#include <catch2/catch.hpp>
-
-// Catch provides the main function since we've given it the
-// CATCH_CONFIG_MAIN preprocessor directive.

src/tests/video_core/buffer_base.cpp

@@ -4,7 +4,7 @@
 #include <stdexcept>
 #include <unordered_map>
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include "common/alignment.h"
 #include "common/common_types.h"
@@ -538,7 +538,7 @@ TEST_CASE("BufferBase: Cached write downloads") {
     int num = 0;
     buffer.ForEachDownloadRangeAndClear(c, WORD, [&](u64 offset, u64 size) { ++num; });
     buffer.ForEachUploadRange(c, WORD, [&](u64 offset, u64 size) { ++num; });
-    REQUIRE(num == 1);
+    REQUIRE(num == 0);
     REQUIRE(!buffer.IsRegionCpuModified(c + PAGE, PAGE));
     REQUIRE(!buffer.IsRegionGpuModified(c + PAGE, PAGE));
     buffer.FlushCachedWrites();

src/video_core/CMakeLists.txt

@@ -85,7 +85,6 @@ add_library(video_core STATIC
     gpu.h
     gpu_thread.cpp
     gpu_thread.h
-    invalidation_accumulator.h
     memory_manager.cpp
     memory_manager.h
     precompiled_headers.h
@@ -191,8 +190,6 @@ add_library(video_core STATIC
     renderer_vulkan/vk_texture_cache.cpp
     renderer_vulkan/vk_texture_cache.h
     renderer_vulkan/vk_texture_cache_base.cpp
-    renderer_vulkan/vk_turbo_mode.cpp
-    renderer_vulkan/vk_turbo_mode.h
     renderer_vulkan/vk_update_descriptor.cpp
     renderer_vulkan/vk_update_descriptor.h
     shader_cache.cpp

src/video_core/buffer_cache/buffer_base.h

@@ -430,7 +430,7 @@ private:
         if (query_begin >= SizeBytes() || size < 0) {
             return;
         }
-        [[maybe_unused]] u64* const untracked_words = Array<Type::Untracked>();
+        u64* const untracked_words = Array<Type::Untracked>();
         u64* const state_words = Array<type>();
         const u64 query_end = query_begin + std::min(static_cast<u64>(size), SizeBytes());
         u64* const words_begin = state_words + query_begin / BYTES_PER_WORD;
@@ -483,7 +483,7 @@ private:
                 NotifyRasterizer<true>(word_index, current_bits, ~u64{0});
             }
             // Exclude CPU modified pages when visiting GPU pages
-            const u64 word = current_word;
+            const u64 word = current_word & ~(type == Type::GPU ? untracked_words[word_index] : 0);
             u64 page = page_begin;
             page_begin = 0;
 
@@ -531,7 +531,7 @@ private:
     [[nodiscard]] bool IsRegionModified(u64 offset, u64 size) const noexcept {
         static_assert(type != Type::Untracked);
 
-        [[maybe_unused]] const u64* const untracked_words = Array<Type::Untracked>();
+        const u64* const untracked_words = Array<Type::Untracked>();
         const u64* const state_words = Array<type>();
         const u64 num_query_words = size / BYTES_PER_WORD + 1;
         const u64 word_begin = offset / BYTES_PER_WORD;
@@ -539,7 +539,8 @@ private:
         const u64 page_limit = Common::DivCeil(offset + size, BYTES_PER_PAGE);
         u64 page_index = (offset / BYTES_PER_PAGE) % PAGES_PER_WORD;
         for (u64 word_index = word_begin; word_index < word_end; ++word_index, page_index = 0) {
-            const u64 word = state_words[word_index];
+            const u64 off_word = type == Type::GPU ? untracked_words[word_index] : 0;
+            const u64 word = state_words[word_index] & ~off_word;
             if (word == 0) {
                 continue;
             }
@@ -563,7 +564,7 @@ private:
     [[nodiscard]] std::pair<u64, u64> ModifiedRegion(u64 offset, u64 size) const noexcept {
         static_assert(type != Type::Untracked);
 
-        [[maybe_unused]] const u64* const untracked_words = Array<Type::Untracked>();
+        const u64* const untracked_words = Array<Type::Untracked>();
         const u64* const state_words = Array<type>();
         const u64 num_query_words = size / BYTES_PER_WORD + 1;
         const u64 word_begin = offset / BYTES_PER_WORD;
@@ -573,7 +574,8 @@ private:
         u64 begin = std::numeric_limits<u64>::max();
         u64 end = 0;
         for (u64 word_index = word_begin; word_index < word_end; ++word_index) {
-            const u64 word = state_words[word_index];
+            const u64 off_word = type == Type::GPU ? untracked_words[word_index] : 0;
+            const u64 word = state_words[word_index] & ~off_word;
             if (word == 0) {
                 continue;
             }

src/video_core/buffer_cache/buffer_cache.h

@@ -1938,21 +1938,14 @@ typename BufferCache<P>::Binding BufferCache<P>::StorageBufferBinding(GPUVAddr s
                                                                       bool is_written) const {
     const GPUVAddr gpu_addr = gpu_memory->Read<u64>(ssbo_addr);
     const u32 size = gpu_memory->Read<u32>(ssbo_addr + 8);
-    const u32 alignment = runtime.GetStorageBufferAlignment();
-
-    const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);
-    const u32 aligned_size =
-        Common::AlignUp(static_cast<u32>(gpu_addr - aligned_gpu_addr) + size, alignment);
-
-    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(aligned_gpu_addr);
+    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
     if (!cpu_addr || size == 0) {
         return NULL_BINDING;
     }
-
-    const VAddr cpu_end = Common::AlignUp(*cpu_addr + aligned_size, Core::Memory::YUZU_PAGESIZE);
+    const VAddr cpu_end = Common::AlignUp(*cpu_addr + size, Core::Memory::YUZU_PAGESIZE);
     const Binding binding{
         .cpu_addr = *cpu_addr,
-        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *cpu_addr),
+        .size = is_written ? size : static_cast<u32>(cpu_end - *cpu_addr),
         .buffer_id = BufferId{},
     };
     return binding;

src/video_core/engines/engine_upload.cpp

@@ -76,7 +76,7 @@ void State::ProcessData(std::span<const u8> read_buffer) {
                                        regs.dest.height, regs.dest.depth, x_offset, regs.dest.y,
                                        x_elements, regs.line_count, regs.dest.BlockHeight(),
                                        regs.dest.BlockDepth(), regs.line_length_in);
-        memory_manager.WriteBlockCached(address, tmp_buffer.data(), dst_size);
+        memory_manager.WriteBlock(address, tmp_buffer.data(), dst_size);
     }
 }
 

src/video_core/engines/fermi_2d.cpp

@@ -6,7 +6,6 @@
 #include "common/microprofile.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/sw_blitter/blitter.h"
-#include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/surface.h"
 #include "video_core/textures/decoders.h"
@@ -21,8 +20,8 @@ namespace Tegra::Engines {
 
 using namespace Texture;
 
-Fermi2D::Fermi2D(MemoryManager& memory_manager_) : memory_manager{memory_manager_} {
-    sw_blitter = std::make_unique<Blitter::SoftwareBlitEngine>(memory_manager);
+Fermi2D::Fermi2D(MemoryManager& memory_manager_) {
+    sw_blitter = std::make_unique<Blitter::SoftwareBlitEngine>(memory_manager_);
     // Nvidia's OpenGL driver seems to assume these values
     regs.src.depth = 1;
     regs.dst.depth = 1;
@@ -105,7 +104,6 @@ void Fermi2D::Blit() {
         config.src_x0 = 0;
     }
 
-    memory_manager.FlushCaching();
     if (!rasterizer->AccelerateSurfaceCopy(src, regs.dst, config)) {
         sw_blitter->Blit(src, regs.dst, config);
     }

src/video_core/engines/fermi_2d.h

@@ -305,7 +305,6 @@ public:
 private:
     VideoCore::RasterizerInterface* rasterizer = nullptr;
     std::unique_ptr<Blitter::SoftwareBlitEngine> sw_blitter;
-    MemoryManager& memory_manager;
 
     /// Performs the copy from the source surface to the destination surface as configured in the
     /// registers.

src/video_core/engines/maxwell_3d.cpp

@@ -485,6 +485,11 @@ void Maxwell3D::StampQueryResult(u64 payload, bool long_query) {
 }
 
 void Maxwell3D::ProcessQueryGet() {
+    // TODO(Subv): Support the other query units.
+    if (regs.report_semaphore.query.location != Regs::ReportSemaphore::Location::All) {
+        LOG_DEBUG(HW_GPU, "Locations other than ALL are unimplemented");
+    }
+
     switch (regs.report_semaphore.query.operation) {
     case Regs::ReportSemaphore::Operation::Release:
         if (regs.report_semaphore.query.short_query != 0) {
@@ -644,7 +649,7 @@ void Maxwell3D::ProcessCBMultiData(const u32* start_base, u32 amount) {
 
     const GPUVAddr address{buffer_address + regs.const_buffer.offset};
     const size_t copy_size = amount * sizeof(u32);
-    memory_manager.WriteBlockCached(address, start_base, copy_size);
+    memory_manager.WriteBlock(address, start_base, copy_size);
 
     // Increment the current buffer position.
     regs.const_buffer.offset += static_cast<u32>(copy_size);

src/video_core/engines/maxwell_dma.cpp

@@ -69,7 +69,7 @@ void MaxwellDMA::Launch() {
     if (launch.multi_line_enable) {
         const bool is_src_pitch = launch.src_memory_layout == LaunchDMA::MemoryLayout::PITCH;
         const bool is_dst_pitch = launch.dst_memory_layout == LaunchDMA::MemoryLayout::PITCH;
-        memory_manager.FlushCaching();
+
         if (!is_src_pitch && !is_dst_pitch) {
             // If both the source and the destination are in block layout, assert.
             CopyBlockLinearToBlockLinear();
@@ -104,7 +104,6 @@ void MaxwellDMA::Launch() {
                                             reinterpret_cast<u8*>(tmp_buffer.data()),
                                             regs.line_length_in * sizeof(u32));
         } else {
-            memory_manager.FlushCaching();
             const auto convert_linear_2_blocklinear_addr = [](u64 address) {
                 return (address & ~0x1f0ULL) | ((address & 0x40) >> 2) | ((address & 0x10) << 1) |
                        ((address & 0x180) >> 1) | ((address & 0x20) << 3);
@@ -122,8 +121,8 @@ void MaxwellDMA::Launch() {
                     memory_manager.ReadBlockUnsafe(
                         convert_linear_2_blocklinear_addr(regs.offset_in + offset),
                         tmp_buffer.data(), tmp_buffer.size());
-                    memory_manager.WriteBlockCached(regs.offset_out + offset, tmp_buffer.data(),
-                                                    tmp_buffer.size());
+                    memory_manager.WriteBlock(regs.offset_out + offset, tmp_buffer.data(),
+                                              tmp_buffer.size());
                 }
             } else if (is_src_pitch && !is_dst_pitch) {
                 UNIMPLEMENTED_IF(regs.line_length_in % 16 != 0);
@@ -133,7 +132,7 @@ void MaxwellDMA::Launch() {
                 for (u32 offset = 0; offset < regs.line_length_in; offset += 16) {
                     memory_manager.ReadBlockUnsafe(regs.offset_in + offset, tmp_buffer.data(),
                                                    tmp_buffer.size());
-                    memory_manager.WriteBlockCached(
+                    memory_manager.WriteBlock(
                         convert_linear_2_blocklinear_addr(regs.offset_out + offset),
                         tmp_buffer.data(), tmp_buffer.size());
                 }
@@ -142,8 +141,8 @@ void MaxwellDMA::Launch() {
                     std::vector<u8> tmp_buffer(regs.line_length_in);
                     memory_manager.ReadBlockUnsafe(regs.offset_in, tmp_buffer.data(),
                                                    regs.line_length_in);
-                    memory_manager.WriteBlockCached(regs.offset_out, tmp_buffer.data(),
-                                                    regs.line_length_in);
+                    memory_manager.WriteBlock(regs.offset_out, tmp_buffer.data(),
+                                              regs.line_length_in);
                 }
             }
         }
@@ -205,7 +204,7 @@ void MaxwellDMA::CopyBlockLinearToPitch() {
                      src_params.origin.y, x_elements, regs.line_count, block_height, block_depth,
                      regs.pitch_out);
 
-    memory_manager.WriteBlockCached(regs.offset_out, write_buffer.data(), dst_size);
+    memory_manager.WriteBlock(regs.offset_out, write_buffer.data(), dst_size);
 }
 
 void MaxwellDMA::CopyPitchToBlockLinear() {
@@ -257,7 +256,7 @@ void MaxwellDMA::CopyPitchToBlockLinear() {
                    dst_params.origin.y, x_elements, regs.line_count, block_height, block_depth,
                    regs.pitch_in);
 
-    memory_manager.WriteBlockCached(regs.offset_out, write_buffer.data(), dst_size);
+    memory_manager.WriteBlock(regs.offset_out, write_buffer.data(), dst_size);
 }
 
 void MaxwellDMA::FastCopyBlockLinearToPitch() {
@@ -288,7 +287,7 @@ void MaxwellDMA::FastCopyBlockLinearToPitch() {
                      regs.src_params.block_size.height, regs.src_params.block_size.depth,
                      regs.pitch_out);
 
-    memory_manager.WriteBlockCached(regs.offset_out, write_buffer.data(), dst_size);
+    memory_manager.WriteBlock(regs.offset_out, write_buffer.data(), dst_size);
 }
 
 void MaxwellDMA::CopyBlockLinearToBlockLinear() {
@@ -348,7 +347,7 @@ void MaxwellDMA::CopyBlockLinearToBlockLinear() {
                    dst.depth, dst_x_offset, dst.origin.y, x_elements, regs.line_count,
                    dst.block_size.height, dst.block_size.depth, pitch);
 
-    memory_manager.WriteBlockCached(regs.offset_out, write_buffer.data(), dst_size);
+    memory_manager.WriteBlock(regs.offset_out, write_buffer.data(), dst_size);
 }
 
 void MaxwellDMA::ReleaseSemaphore() {

src/video_core/host_shaders/CMakeLists.txt

@@ -47,7 +47,6 @@ set(SHADER_FILES
     vulkan_present_scaleforce_fp16.frag
     vulkan_present_scaleforce_fp32.frag
     vulkan_quad_indexed.comp
-    vulkan_turbo_mode.comp
     vulkan_uint8.comp
 )
 

src/video_core/host_shaders/vulkan_turbo_mode.comp

@@ -1,29 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#version 460 core
-
-layout (local_size_x = 16, local_size_y = 8, local_size_z = 1) in;
-
-layout (binding = 0) buffer ThreadData {
-    uint data[];
-};
-
-uint xorshift32(uint x) {
-    x ^= x << 13;
-    x ^= x >> 17;
-    x ^= x << 5;
-    return x;
-}
-
-uint getGlobalIndex() {
-    return gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * gl_WorkGroupSize.y * gl_NumWorkGroups.y;
-}
-
-void main() {
-    uint myIndex = xorshift32(getGlobalIndex());
-    uint otherIndex = xorshift32(myIndex);
-
-    uint otherValue = atomicAdd(data[otherIndex % data.length()], 0) + 1;
-    atomicAdd(data[myIndex % data.length()], otherValue);
-}

src/video_core/invalidation_accumulator.h

@@ -1,79 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <utility>
-#include <vector>
-
-#include "common/common_types.h"
-
-namespace VideoCommon {
-
-class InvalidationAccumulator {
-public:
-    InvalidationAccumulator() = default;
-    ~InvalidationAccumulator() = default;
-
-    void Add(GPUVAddr address, size_t size) {
-        const auto reset_values = [&]() {
-            if (has_collected) {
-                buffer.emplace_back(start_address, accumulated_size);
-            }
-            start_address = address;
-            accumulated_size = size;
-            last_collection = start_address + size;
-        };
-        if (address >= start_address && address + size <= last_collection) [[likely]] {
-            return;
-        }
-        size = ((address + size + atomicity_size_mask) & atomicity_mask) - address;
-        address = address & atomicity_mask;
-        if (!has_collected) [[unlikely]] {
-            reset_values();
-            has_collected = true;
-            return;
-        }
-        if (address != last_collection) [[unlikely]] {
-            reset_values();
-            return;
-        }
-        accumulated_size += size;
-        last_collection += size;
-    }
-
-    void Clear() {
-        buffer.clear();
-        start_address = 0;
-        last_collection = 0;
-        has_collected = false;
-    }
-
-    bool AnyAccumulated() const {
-        return has_collected;
-    }
-
-    template <typename Func>
-    void Callback(Func&& func) {
-        if (!has_collected) {
-            return;
-        }
-        buffer.emplace_back(start_address, accumulated_size);
-        for (auto& [address, size] : buffer) {
-            func(address, size);
-        }
-    }
-
-private:
-    static constexpr size_t atomicity_bits = 5;
-    static constexpr size_t atomicity_size = 1ULL << atomicity_bits;
-    static constexpr size_t atomicity_size_mask = atomicity_size - 1;
-    static constexpr size_t atomicity_mask = ~atomicity_size_mask;
-    GPUVAddr start_address{};
-    GPUVAddr last_collection{};
-    size_t accumulated_size{};
-    bool has_collected{};
-    std::vector<std::pair<VAddr, size_t>> buffer;
-};
-
-} // namespace VideoCommon

src/video_core/macro/macro_hle.cpp

@@ -50,6 +50,38 @@ protected:
     Maxwell3D& maxwell3d;
 };
 
+class HLE_DrawArrays final : public HLEMacroImpl {
+public:
+    explicit HLE_DrawArrays(Maxwell3D& maxwell3d_) : HLEMacroImpl(maxwell3d_) {}
+
+    void Execute(const std::vector<u32>& parameters, [[maybe_unused]] u32 method) override {
+        maxwell3d.RefreshParameters();
+
+        auto topology = static_cast<Maxwell3D::Regs::PrimitiveTopology>(parameters[0]);
+        maxwell3d.draw_manager->DrawArray(topology, parameters[1], parameters[2],
+                                          maxwell3d.regs.global_base_instance_index, 1);
+    }
+};
+
+class HLE_DrawIndexed final : public HLEMacroImpl {
+public:
+    explicit HLE_DrawIndexed(Maxwell3D& maxwell3d_) : HLEMacroImpl(maxwell3d_) {}
+
+    void Execute(const std::vector<u32>& parameters, [[maybe_unused]] u32 method) override {
+        maxwell3d.RefreshParameters();
+        maxwell3d.regs.index_buffer.start_addr_high = parameters[1];
+        maxwell3d.regs.index_buffer.start_addr_low = parameters[2];
+        maxwell3d.regs.index_buffer.format =
+            static_cast<Engines::Maxwell3D::Regs::IndexFormat>(parameters[3]);
+        maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+
+        auto topology = static_cast<Maxwell3D::Regs::PrimitiveTopology>(parameters[0]);
+        maxwell3d.draw_manager->DrawIndex(topology, 0, parameters[4],
+                                          maxwell3d.regs.global_base_vertex_index,
+                                          maxwell3d.regs.global_base_instance_index, 1);
+    }
+};
+
 /*
  * @note: these macros have two versions, a normal and extended version, with the extended version
  * also assigning the base vertex/instance.
@@ -465,6 +497,11 @@ public:
 } // Anonymous namespace
 
 HLEMacro::HLEMacro(Maxwell3D& maxwell3d_) : maxwell3d{maxwell3d_} {
+    builders.emplace(0xDD6A7FA92A7D2674ULL,
+                     std::function<std::unique_ptr<CachedMacro>(Maxwell3D&)>(
+                         [](Maxwell3D& maxwell3d__) -> std::unique_ptr<CachedMacro> {
+                             return std::make_unique<HLE_DrawArrays>(maxwell3d__);
+                         }));
     builders.emplace(0x0D61FC9FAAC9FCADULL,
                      std::function<std::unique_ptr<CachedMacro>(Maxwell3D&)>(
                          [](Maxwell3D& maxwell3d__) -> std::unique_ptr<CachedMacro> {
@@ -475,6 +512,11 @@ HLEMacro::HLEMacro(Maxwell3D& maxwell3d_) : maxwell3d{maxwell3d_} {
                          [](Maxwell3D& maxwell3d__) -> std::unique_ptr<CachedMacro> {
                              return std::make_unique<HLE_DrawArraysIndirect<true>>(maxwell3d__);
                          }));
+    builders.emplace(0x2DB33AADB741839CULL,
+                     std::function<std::unique_ptr<CachedMacro>(Maxwell3D&)>(
+                         [](Maxwell3D& maxwell3d__) -> std::unique_ptr<CachedMacro> {
+                             return std::make_unique<HLE_DrawIndexed>(maxwell3d__);
+                         }));
     builders.emplace(0x771BB18C62444DA0ULL,
                      std::function<std::unique_ptr<CachedMacro>(Maxwell3D&)>(
                          [](Maxwell3D& maxwell3d__) -> std::unique_ptr<CachedMacro> {

src/video_core/memory_manager.cpp

@@ -6,13 +6,11 @@
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "common/settings.h"
 #include "core/core.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/memory.h"
-#include "video_core/invalidation_accumulator.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
@@ -28,8 +26,7 @@ MemoryManager::MemoryManager(Core::System& system_, u64 address_space_bits_, u64
       entries{}, big_entries{}, page_table{address_space_bits, address_space_bits + page_bits - 38,
                                            page_bits != big_page_bits ? page_bits : 0},
       kind_map{PTEKind::INVALID}, unique_identifier{unique_identifier_generator.fetch_add(
-                                      1, std::memory_order_acq_rel)},
-      accumulator{std::make_unique<VideoCommon::InvalidationAccumulator>()} {
+                                      1, std::memory_order_acq_rel)} {
     address_space_size = 1ULL << address_space_bits;
     page_size = 1ULL << page_bits;
     page_mask = page_size - 1ULL;
@@ -46,11 +43,6 @@ MemoryManager::MemoryManager(Core::System& system_, u64 address_space_bits_, u64
     big_page_table_cpu.resize(big_page_table_size);
     big_page_continous.resize(big_page_table_size / continous_bits, 0);
     entries.resize(page_table_size / 32, 0);
-    if (!Settings::IsGPULevelExtreme() && Settings::IsFastmemEnabled()) {
-        fastmem_arena = system.DeviceMemory().buffer.VirtualBasePointer();
-    } else {
-        fastmem_arena = nullptr;
-    }
 }
 
 MemoryManager::~MemoryManager() = default;
@@ -193,12 +185,15 @@ void MemoryManager::Unmap(GPUVAddr gpu_addr, std::size_t size) {
     if (size == 0) {
         return;
     }
-    GetSubmappedRangeImpl<false>(gpu_addr, size, page_stash);
+    const auto submapped_ranges = GetSubmappedRange(gpu_addr, size);
 
-    for (const auto& [map_addr, map_size] : page_stash) {
-        rasterizer->UnmapMemory(map_addr, map_size);
+    for (const auto& [map_addr, map_size] : submapped_ranges) {
+        // Flush and invalidate through the GPU interface, to be asynchronous if possible.
+        const std::optional<VAddr> cpu_addr = GpuToCpuAddress(map_addr);
+        ASSERT(cpu_addr);
+
+        rasterizer->UnmapMemory(*cpu_addr, map_size);
     }
-    page_stash.clear();
 
     BigPageTableOp<EntryType::Free>(gpu_addr, 0, size, PTEKind::INVALID);
     PageTableOp<EntryType::Free>(gpu_addr, 0, size, PTEKind::INVALID);
@@ -360,7 +355,7 @@ inline void MemoryManager::MemoryOperation(GPUVAddr gpu_src_addr, std::size_t si
     }
 }
 
-template <bool is_safe, bool use_fastmem>
+template <bool is_safe>
 void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size,
                                   [[maybe_unused]] VideoCommon::CacheType which) const {
     auto set_to_zero = [&]([[maybe_unused]] std::size_t page_index,
@@ -374,12 +369,8 @@ void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std:
         if constexpr (is_safe) {
             rasterizer->FlushRegion(cpu_addr_base, copy_amount, which);
         }
-        if constexpr (use_fastmem) {
-            std::memcpy(dest_buffer, &fastmem_arena[cpu_addr_base], copy_amount);
-        } else {
-            u8* physical = memory.GetPointer(cpu_addr_base);
-            std::memcpy(dest_buffer, physical, copy_amount);
-        }
+        u8* physical = memory.GetPointer(cpu_addr_base);
+        std::memcpy(dest_buffer, physical, copy_amount);
         dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
     };
     auto mapped_big = [&](std::size_t page_index, std::size_t offset, std::size_t copy_amount) {
@@ -388,15 +379,11 @@ void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std:
         if constexpr (is_safe) {
             rasterizer->FlushRegion(cpu_addr_base, copy_amount, which);
         }
-        if constexpr (use_fastmem) {
-            std::memcpy(dest_buffer, &fastmem_arena[cpu_addr_base], copy_amount);
+        if (!IsBigPageContinous(page_index)) [[unlikely]] {
+            memory.ReadBlockUnsafe(cpu_addr_base, dest_buffer, copy_amount);
         } else {
-            if (!IsBigPageContinous(page_index)) [[unlikely]] {
-                memory.ReadBlockUnsafe(cpu_addr_base, dest_buffer, copy_amount);
-            } else {
-                u8* physical = memory.GetPointer(cpu_addr_base);
-                std::memcpy(dest_buffer, physical, copy_amount);
-            }
+            u8* physical = memory.GetPointer(cpu_addr_base);
+            std::memcpy(dest_buffer, physical, copy_amount);
         }
         dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
     };
@@ -410,20 +397,12 @@ void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std:
 
 void MemoryManager::ReadBlock(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size,
                               VideoCommon::CacheType which) const {
-    if (fastmem_arena) [[likely]] {
-        ReadBlockImpl<true, true>(gpu_src_addr, dest_buffer, size, which);
-        return;
-    }
-    ReadBlockImpl<true, false>(gpu_src_addr, dest_buffer, size, which);
+    ReadBlockImpl<true>(gpu_src_addr, dest_buffer, size, which);
 }
 
 void MemoryManager::ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer,
                                     const std::size_t size) const {
-    if (fastmem_arena) [[likely]] {
-        ReadBlockImpl<false, true>(gpu_src_addr, dest_buffer, size, VideoCommon::CacheType::None);
-        return;
-    }
-    ReadBlockImpl<false, false>(gpu_src_addr, dest_buffer, size, VideoCommon::CacheType::None);
+    ReadBlockImpl<false>(gpu_src_addr, dest_buffer, size, VideoCommon::CacheType::None);
 }
 
 template <bool is_safe>
@@ -475,12 +454,6 @@ void MemoryManager::WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buf
     WriteBlockImpl<false>(gpu_dest_addr, src_buffer, size, VideoCommon::CacheType::None);
 }
 
-void MemoryManager::WriteBlockCached(GPUVAddr gpu_dest_addr, const void* src_buffer,
-                                     std::size_t size) {
-    WriteBlockImpl<false>(gpu_dest_addr, src_buffer, size, VideoCommon::CacheType::None);
-    accumulator->Add(gpu_dest_addr, size);
-}
-
 void MemoryManager::FlushRegion(GPUVAddr gpu_addr, size_t size,
                                 VideoCommon::CacheType which) const {
     auto do_nothing = [&]([[maybe_unused]] std::size_t page_index,
@@ -690,17 +663,7 @@ bool MemoryManager::IsFullyMappedRange(GPUVAddr gpu_addr, std::size_t size) cons
 std::vector<std::pair<GPUVAddr, std::size_t>> MemoryManager::GetSubmappedRange(
     GPUVAddr gpu_addr, std::size_t size) const {
     std::vector<std::pair<GPUVAddr, std::size_t>> result{};
-    GetSubmappedRangeImpl<true>(gpu_addr, size, result);
-    return result;
-}
-
-template <bool is_gpu_address>
-void MemoryManager::GetSubmappedRangeImpl(
-    GPUVAddr gpu_addr, std::size_t size,
-    std::vector<std::pair<std::conditional_t<is_gpu_address, GPUVAddr, VAddr>, std::size_t>>&
-        result) const {
-    std::optional<std::pair<std::conditional_t<is_gpu_address, GPUVAddr, VAddr>, std::size_t>>
-        last_segment{};
+    std::optional<std::pair<GPUVAddr, std::size_t>> last_segment{};
     std::optional<VAddr> old_page_addr{};
     const auto split = [&last_segment, &result]([[maybe_unused]] std::size_t page_index,
                                                 [[maybe_unused]] std::size_t offset,
@@ -722,12 +685,8 @@ void MemoryManager::GetSubmappedRangeImpl(
         }
         old_page_addr = {cpu_addr_base + copy_amount};
         if (!last_segment) {
-            if constexpr (is_gpu_address) {
-                const GPUVAddr new_base_addr = (page_index << big_page_bits) + offset;
-                last_segment = {new_base_addr, copy_amount};
-            } else {
-                last_segment = {cpu_addr_base, copy_amount};
-            }
+            const GPUVAddr new_base_addr = (page_index << big_page_bits) + offset;
+            last_segment = {new_base_addr, copy_amount};
         } else {
             last_segment->second += copy_amount;
         }
@@ -744,12 +703,8 @@ void MemoryManager::GetSubmappedRangeImpl(
         }
         old_page_addr = {cpu_addr_base + copy_amount};
         if (!last_segment) {
-            if constexpr (is_gpu_address) {
-                const GPUVAddr new_base_addr = (page_index << page_bits) + offset;
-                last_segment = {new_base_addr, copy_amount};
-            } else {
-                last_segment = {cpu_addr_base, copy_amount};
-            }
+            const GPUVAddr new_base_addr = (page_index << page_bits) + offset;
+            last_segment = {new_base_addr, copy_amount};
         } else {
             last_segment->second += copy_amount;
         }
@@ -760,18 +715,7 @@ void MemoryManager::GetSubmappedRangeImpl(
     };
     MemoryOperation<true>(gpu_addr, size, extend_size_big, split, do_short_pages);
     split(0, 0, 0);
-}
-
-void MemoryManager::FlushCaching() {
-    if (!accumulator->AnyAccumulated()) {
-        return;
-    }
-    accumulator->Callback([this](GPUVAddr addr, size_t size) {
-        GetSubmappedRangeImpl<false>(addr, size, page_stash);
-    });
-    rasterizer->InnerInvalidation(page_stash);
-    page_stash.clear();
-    accumulator->Clear();
+    return result;
 }
 
 } // namespace Tegra

src/video_core/memory_manager.h

@@ -19,10 +19,6 @@ namespace VideoCore {
 class RasterizerInterface;
 }
 
-namespace VideoCommon {
-class InvalidationAccumulator;
-}
-
 namespace Core {
 class DeviceMemory;
 namespace Memory {
@@ -84,7 +80,6 @@ public:
      */
     void ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size) const;
     void WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size);
-    void WriteBlockCached(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size);
 
     /**
      * Checks if a gpu region can be simply read with a pointer.
@@ -134,14 +129,12 @@ public:
     size_t GetMemoryLayoutSize(GPUVAddr gpu_addr,
                                size_t max_size = std::numeric_limits<size_t>::max()) const;
 
-    void FlushCaching();
-
 private:
     template <bool is_big_pages, typename FuncMapped, typename FuncReserved, typename FuncUnmapped>
     inline void MemoryOperation(GPUVAddr gpu_src_addr, std::size_t size, FuncMapped&& func_mapped,
                                 FuncReserved&& func_reserved, FuncUnmapped&& func_unmapped) const;
 
-    template <bool is_safe, bool use_fastmem>
+    template <bool is_safe>
     void ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size,
                        VideoCommon::CacheType which) const;
 
@@ -161,12 +154,6 @@ private:
     inline bool IsBigPageContinous(size_t big_page_index) const;
     inline void SetBigPageContinous(size_t big_page_index, bool value);
 
-    template <bool is_gpu_address>
-    void GetSubmappedRangeImpl(
-        GPUVAddr gpu_addr, std::size_t size,
-        std::vector<std::pair<std::conditional_t<is_gpu_address, GPUVAddr, VAddr>, std::size_t>>&
-            result) const;
-
     Core::System& system;
     Core::Memory::Memory& memory;
     Core::DeviceMemory& device_memory;
@@ -214,13 +201,10 @@ private:
     Common::VirtualBuffer<u32> big_page_table_cpu;
 
     std::vector<u64> big_page_continous;
-    std::vector<std::pair<VAddr, std::size_t>> page_stash{};
-    u8* fastmem_arena{};
 
     constexpr static size_t continous_bits = 64;
 
     const size_t unique_identifier;
-    std::unique_ptr<VideoCommon::InvalidationAccumulator> accumulator;
 
     static std::atomic<size_t> unique_identifier_generator;
 };

src/video_core/rasterizer_interface.h

@@ -6,7 +6,6 @@
 #include <functional>
 #include <optional>
 #include <span>
-#include <utility>
 #include "common/common_types.h"
 #include "common/polyfill_thread.h"
 #include "video_core/cache_types.h"
@@ -96,12 +95,6 @@ public:
     virtual void InvalidateRegion(VAddr addr, u64 size,
                                   VideoCommon::CacheType which = VideoCommon::CacheType::All) = 0;
 
-    virtual void InnerInvalidation(std::span<const std::pair<VAddr, std::size_t>> sequences) {
-        for (const auto& [cpu_addr, size] : sequences) {
-            InvalidateRegion(cpu_addr, size);
-        }
-    }
-
     /// Notify rasterizer that any caches of the specified region are desync with guest
     virtual void OnCPUWrite(VAddr addr, u64 size) = 0;
 

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -160,10 +160,6 @@ public:
         return device.CanReportMemoryUsage();
     }
 
-    u32 GetStorageBufferAlignment() const {
-        return static_cast<u32>(device.GetShaderStorageBufferAlignment());
-    }
-
 private:
     static constexpr std::array PABO_LUT{
         GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV,          GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV,

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -139,7 +139,6 @@ void RasterizerOpenGL::LoadDiskResources(u64 title_id, std::stop_token stop_load
 void RasterizerOpenGL::Clear(u32 layer_count) {
     MICROPROFILE_SCOPE(OpenGL_Clears);
 
-    gpu_memory->FlushCaching();
     const auto& regs = maxwell3d->regs;
     bool use_color{};
     bool use_depth{};
@@ -208,7 +207,6 @@ void RasterizerOpenGL::PrepareDraw(bool is_indexed, Func&& draw_func) {
     MICROPROFILE_SCOPE(OpenGL_Drawing);
 
     SCOPE_EXIT({ gpu.TickWork(); });
-    gpu_memory->FlushCaching();
     query_cache.UpdateCounters();
 
     GraphicsPipeline* const pipeline{shader_cache.CurrentGraphicsPipeline()};
@@ -321,7 +319,6 @@ void RasterizerOpenGL::DrawIndirect() {
 }
 
 void RasterizerOpenGL::DispatchCompute() {
-    gpu_memory->FlushCaching();
     ComputePipeline* const pipeline{shader_cache.CurrentComputePipeline()};
     if (!pipeline) {
         return;
@@ -529,7 +526,6 @@ void RasterizerOpenGL::TickFrame() {
 }
 
 bool RasterizerOpenGL::AccelerateConditionalRendering() {
-    gpu_memory->FlushCaching();
     if (Settings::IsGPULevelHigh()) {
         // Reimplement Host conditional rendering.
         return false;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -236,8 +236,6 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .needs_demote_reorder = device.IsAmd(),
           .support_snorm_render_buffer = false,
           .support_viewport_index_layer = device.HasVertexViewportLayer(),
-          .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
-          .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
       } {
     if (use_asynchronous_shaders) {
         workers = CreateWorkers();

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -442,13 +442,7 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
 
     glBindTextureUnit(0, screen_info.display_texture);
 
-    auto anti_aliasing = Settings::values.anti_aliasing.GetValue();
-    if (anti_aliasing > Settings::AntiAliasing::LastAA) {
-        LOG_ERROR(Render_OpenGL, "Invalid antialiasing option selected {}", anti_aliasing);
-        anti_aliasing = Settings::AntiAliasing::None;
-        Settings::values.anti_aliasing.SetValue(anti_aliasing);
-    }
-
+    const auto anti_aliasing = Settings::values.anti_aliasing.GetValue();
     if (anti_aliasing != Settings::AntiAliasing::None) {
         glEnablei(GL_SCISSOR_TEST, 0);
         auto viewport_width = screen_info.texture.width;

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -148,7 +148,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
         });
     }
     if (!extended_dynamic_state_2_extra) {
-        dynamic_state.Refresh2(regs, topology_, extended_dynamic_state_2);
+        dynamic_state.Refresh2(regs, topology, extended_dynamic_state_2);
     }
     if (!extended_dynamic_state_3_blend) {
         if (maxwell3d.dirty.flags[Dirty::Blending]) {

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -60,12 +60,23 @@ std::string GetDriverVersion(const Device& device) {
     return GetReadableVersion(version);
 }
 
-std::string BuildCommaSeparatedExtensions(
-    const std::set<std::string, std::less<>>& available_extensions) {
-    return fmt::format("{}", fmt::join(available_extensions, ","));
-}
+std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_extensions) {
+    std::sort(std::begin(available_extensions), std::end(available_extensions));
 
-} // Anonymous namespace
+    static constexpr std::size_t AverageExtensionSize = 64;
+    std::string separated_extensions;
+    separated_extensions.reserve(available_extensions.size() * AverageExtensionSize);
+
+    const auto end = std::end(available_extensions);
+    for (auto extension = std::begin(available_extensions); extension != end; ++extension) {
+        if (const bool is_last = extension + 1 == end; is_last) {
+            separated_extensions += *extension;
+        } else {
+            separated_extensions += fmt::format("{},", *extension);
+        }
+    }
+    return separated_extensions;
+}
 
 Device CreateDevice(const vk::Instance& instance, const vk::InstanceDispatch& dld,
                     VkSurfaceKHR surface) {
@@ -78,6 +89,7 @@ Device CreateDevice(const vk::Instance& instance, const vk::InstanceDispatch& dl
     const vk::PhysicalDevice physical_device(devices[device_index], dld);
     return Device(*instance, physical_device, surface, dld);
 }
+} // Anonymous namespace
 
 RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                                Core::Frontend::EmuWindow& emu_window,
@@ -86,7 +98,7 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
     : RendererBase(emu_window, std::move(context_)), telemetry_session(telemetry_session_),
       cpu_memory(cpu_memory_), gpu(gpu_), library(OpenLibrary()),
       instance(CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
-                              Settings::values.renderer_debug.GetValue())),
+                              true, Settings::values.renderer_debug.GetValue())),
       debug_callback(Settings::values.renderer_debug ? CreateDebugCallback(instance) : nullptr),
       surface(CreateSurface(instance, render_window)),
       device(CreateDevice(instance, dld, *surface)), memory_allocator(device, false),
@@ -97,10 +109,6 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
                   screen_info),
       rasterizer(render_window, gpu, cpu_memory, screen_info, device, memory_allocator,
                  state_tracker, scheduler) {
-    if (Settings::values.renderer_force_max_clock.GetValue() && device.ShouldBoostClocks()) {
-        turbo_mode.emplace(instance, dld);
-        scheduler.RegisterOnSubmit([this] { turbo_mode->QueueSubmitted(); });
-    }
     Report();
 } catch (const vk::Exception& exception) {
     LOG_ERROR(Render_Vulkan, "Vulkan initialization failed with error: {}", exception.what());
@@ -108,7 +116,6 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
 }
 
 RendererVulkan::~RendererVulkan() {
-    scheduler.RegisterOnSubmit([] {});
     void(device.GetLogical().WaitIdle());
 }
 

src/video_core/renderer_vulkan/renderer_vulkan.h

@@ -13,7 +13,6 @@
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 #include "video_core/renderer_vulkan/vk_swapchain.h"
-#include "video_core/renderer_vulkan/vk_turbo_mode.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
@@ -32,9 +31,6 @@ class GPU;
 
 namespace Vulkan {
 
-Device CreateDevice(const vk::Instance& instance, const vk::InstanceDispatch& dld,
-                    VkSurfaceKHR surface);
-
 class RendererVulkan final : public VideoCore::RendererBase {
 public:
     explicit RendererVulkan(Core::TelemetrySession& telemtry_session,
@@ -78,7 +74,6 @@ private:
     Swapchain swapchain;
     BlitScreen blit_screen;
     RasterizerVulkan rasterizer;
-    std::optional<TurboMode> turbo_mode;
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -330,19 +330,12 @@ bool BufferCacheRuntime::CanReportMemoryUsage() const {
     return device.CanReportMemoryUsage();
 }
 
-u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
-    return static_cast<u32>(device.GetStorageBufferAlignment());
-}
-
 void BufferCacheRuntime::Finish() {
     scheduler.Finish();
 }
 
 void BufferCacheRuntime::CopyBuffer(VkBuffer dst_buffer, VkBuffer src_buffer,
                                     std::span<const VideoCommon::BufferCopy> copies, bool barrier) {
-    if (dst_buffer == VK_NULL_HANDLE || src_buffer == VK_NULL_HANDLE) {
-        return;
-    }
     static constexpr VkMemoryBarrier READ_BARRIER{
         .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
         .pNext = nullptr,
@@ -401,9 +394,6 @@ void BufferCacheRuntime::PostCopyBarrier() {
 }
 
 void BufferCacheRuntime::ClearBuffer(VkBuffer dest_buffer, u32 offset, size_t size, u32 value) {
-    if (dest_buffer == VK_NULL_HANDLE) {
-        return;
-    }
     static constexpr VkMemoryBarrier READ_BARRIER{
         .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
         .pNext = nullptr,
@@ -483,11 +473,6 @@ void BufferCacheRuntime::BindVertexBuffer(u32 index, VkBuffer buffer, u32 offset
             cmdbuf.BindVertexBuffers2EXT(index, 1, &buffer, &vk_offset, &vk_size, &vk_stride);
         });
     } else {
-        if (!device.HasNullDescriptor() && buffer == VK_NULL_HANDLE) {
-            ReserveNullBuffer();
-            buffer = *null_buffer;
-            offset = 0;
-        }
         scheduler.Record([index, buffer, offset](vk::CommandBuffer cmdbuf) {
             cmdbuf.BindVertexBuffer(index, buffer, offset);
         });

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -73,8 +73,6 @@ public:
 
     bool CanReportMemoryUsage() const;
 
-    u32 GetStorageBufferAlignment() const;
-
     [[nodiscard]] StagingBufferRef UploadStagingBuffer(size_t size);
 
     [[nodiscard]] StagingBufferRef DownloadStagingBuffer(size_t size);

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -24,15 +24,13 @@ using Shader::ImageBufferDescriptor;
 using Shader::Backend::SPIRV::RESCALING_LAYOUT_WORDS_OFFSET;
 using Tegra::Texture::TexturePair;
 
-ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipeline_cache_,
-                                 DescriptorPool& descriptor_pool,
+ComputePipeline::ComputePipeline(const Device& device_, DescriptorPool& descriptor_pool,
                                  UpdateDescriptorQueue& update_descriptor_queue_,
                                  Common::ThreadWorker* thread_worker,
                                  PipelineStatistics* pipeline_statistics,
                                  VideoCore::ShaderNotify* shader_notify, const Shader::Info& info_,
                                  vk::ShaderModule spv_module_)
-    : device{device_}, pipeline_cache(pipeline_cache_),
-      update_descriptor_queue{update_descriptor_queue_}, info{info_},
+    : device{device_}, update_descriptor_queue{update_descriptor_queue_}, info{info_},
       spv_module(std::move(spv_module_)) {
     if (shader_notify) {
         shader_notify->MarkShaderBuilding();
@@ -58,27 +56,23 @@ ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipel
         if (device.IsKhrPipelineExecutablePropertiesEnabled()) {
             flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
         }
-        pipeline = device.GetLogical().CreateComputePipeline(
-            {
-                .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-                .pNext = nullptr,
-                .flags = flags,
-                .stage{
-                    .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-                    .pNext =
-                        device.IsExtSubgroupSizeControlSupported() ? &subgroup_size_ci : nullptr,
-                    .flags = 0,
-                    .stage = VK_SHADER_STAGE_COMPUTE_BIT,
-                    .module = *spv_module,
-                    .pName = "main",
-                    .pSpecializationInfo = nullptr,
-                },
-                .layout = *pipeline_layout,
-                .basePipelineHandle = 0,
-                .basePipelineIndex = 0,
+        pipeline = device.GetLogical().CreateComputePipeline({
+            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = flags,
+            .stage{
+                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+                .pNext = device.IsExtSubgroupSizeControlSupported() ? &subgroup_size_ci : nullptr,
+                .flags = 0,
+                .stage = VK_SHADER_STAGE_COMPUTE_BIT,
+                .module = *spv_module,
+                .pName = "main",
+                .pSpecializationInfo = nullptr,
             },
-            *pipeline_cache);
-
+            .layout = *pipeline_layout,
+            .basePipelineHandle = 0,
+            .basePipelineIndex = 0,
+        });
         if (pipeline_statistics) {
             pipeline_statistics->Collect(*pipeline);
         }

src/video_core/renderer_vulkan/vk_compute_pipeline.h

@@ -28,8 +28,7 @@ class Scheduler;
 
 class ComputePipeline {
 public:
-    explicit ComputePipeline(const Device& device, vk::PipelineCache& pipeline_cache,
-                             DescriptorPool& descriptor_pool,
+    explicit ComputePipeline(const Device& device, DescriptorPool& descriptor_pool,
                              UpdateDescriptorQueue& update_descriptor_queue,
                              Common::ThreadWorker* thread_worker,
                              PipelineStatistics* pipeline_statistics,
@@ -47,7 +46,6 @@ public:
 
 private:
     const Device& device;
-    vk::PipelineCache& pipeline_cache;
     UpdateDescriptorQueue& update_descriptor_queue;
     Shader::Info info;
 

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -234,14 +234,13 @@ ConfigureFuncPtr ConfigureFunc(const std::array<vk::ShaderModule, NUM_STAGES>& m
 
 GraphicsPipeline::GraphicsPipeline(
     Scheduler& scheduler_, BufferCache& buffer_cache_, TextureCache& texture_cache_,
-    vk::PipelineCache& pipeline_cache_, VideoCore::ShaderNotify* shader_notify,
-    const Device& device_, DescriptorPool& descriptor_pool,
+    VideoCore::ShaderNotify* shader_notify, const Device& device_, DescriptorPool& descriptor_pool,
     UpdateDescriptorQueue& update_descriptor_queue_, Common::ThreadWorker* worker_thread,
     PipelineStatistics* pipeline_statistics, RenderPassCache& render_pass_cache,
     const GraphicsPipelineCacheKey& key_, std::array<vk::ShaderModule, NUM_STAGES> stages,
     const std::array<const Shader::Info*, NUM_STAGES>& infos)
-    : key{key_}, device{device_}, texture_cache{texture_cache_}, buffer_cache{buffer_cache_},
-      pipeline_cache(pipeline_cache_), scheduler{scheduler_},
+    : key{key_}, device{device_}, texture_cache{texture_cache_},
+      buffer_cache{buffer_cache_}, scheduler{scheduler_},
       update_descriptor_queue{update_descriptor_queue_}, spv_modules{std::move(stages)} {
     if (shader_notify) {
         shader_notify->MarkShaderBuilding();
@@ -645,15 +644,12 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .pNext = nullptr,
         .flags = 0,
         .topology = input_assembly_topology,
-        .primitiveRestartEnable =
-            dynamic.primitive_restart_enable != 0 &&
-                    ((input_assembly_topology != VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
-                      device.IsTopologyListPrimitiveRestartSupported()) ||
-                     SupportsPrimitiveRestart(input_assembly_topology) ||
-                     (input_assembly_topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
-                      device.IsPatchListPrimitiveRestartSupported()))
-                ? VK_TRUE
-                : VK_FALSE,
+        .primitiveRestartEnable = dynamic.primitive_restart_enable != 0 &&
+                                  ((input_assembly_topology != VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
+                                    device.IsTopologyListPrimitiveRestartSupported()) ||
+                                   SupportsPrimitiveRestart(input_assembly_topology) ||
+                                   (input_assembly_topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
+                                    device.IsPatchListPrimitiveRestartSupported())),
     };
     const VkPipelineTessellationStateCreateInfo tessellation_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
@@ -703,7 +699,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         .cullMode = static_cast<VkCullModeFlags>(
             dynamic.cull_enable ? MaxwellToVK::CullFace(dynamic.CullFace()) : VK_CULL_MODE_NONE),
         .frontFace = MaxwellToVK::FrontFace(dynamic.FrontFace()),
-        .depthBiasEnable = (dynamic.depth_bias_enable != 0 ? VK_TRUE : VK_FALSE),
+        .depthBiasEnable = (dynamic.depth_bias_enable == 0 ? VK_TRUE : VK_FALSE),
         .depthBiasConstantFactor = 0.0f,
         .depthBiasClamp = 0.0f,
         .depthBiasSlopeFactor = 0.0f,
@@ -898,29 +894,27 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
     if (device.IsKhrPipelineExecutablePropertiesEnabled()) {
         flags |= VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR;
     }
-    pipeline = device.GetLogical().CreateGraphicsPipeline(
-        {
-            .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = flags,
-            .stageCount = static_cast<u32>(shader_stages.size()),
-            .pStages = shader_stages.data(),
-            .pVertexInputState = &vertex_input_ci,
-            .pInputAssemblyState = &input_assembly_ci,
-            .pTessellationState = &tessellation_ci,
-            .pViewportState = &viewport_ci,
-            .pRasterizationState = &rasterization_ci,
-            .pMultisampleState = &multisample_ci,
-            .pDepthStencilState = &depth_stencil_ci,
-            .pColorBlendState = &color_blend_ci,
-            .pDynamicState = &dynamic_state_ci,
-            .layout = *pipeline_layout,
-            .renderPass = render_pass,
-            .subpass = 0,
-            .basePipelineHandle = nullptr,
-            .basePipelineIndex = 0,
-        },
-        *pipeline_cache);
+    pipeline = device.GetLogical().CreateGraphicsPipeline({
+        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = flags,
+        .stageCount = static_cast<u32>(shader_stages.size()),
+        .pStages = shader_stages.data(),
+        .pVertexInputState = &vertex_input_ci,
+        .pInputAssemblyState = &input_assembly_ci,
+        .pTessellationState = &tessellation_ci,
+        .pViewportState = &viewport_ci,
+        .pRasterizationState = &rasterization_ci,
+        .pMultisampleState = &multisample_ci,
+        .pDepthStencilState = &depth_stencil_ci,
+        .pColorBlendState = &color_blend_ci,
+        .pDynamicState = &dynamic_state_ci,
+        .layout = *pipeline_layout,
+        .renderPass = render_pass,
+        .subpass = 0,
+        .basePipelineHandle = nullptr,
+        .basePipelineIndex = 0,
+    });
 }
 
 void GraphicsPipeline::Validate() {

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -70,14 +70,16 @@ class GraphicsPipeline {
     static constexpr size_t NUM_STAGES = Tegra::Engines::Maxwell3D::Regs::MaxShaderStage;
 
 public:
-    explicit GraphicsPipeline(
-        Scheduler& scheduler, BufferCache& buffer_cache, TextureCache& texture_cache,
-        vk::PipelineCache& pipeline_cache, VideoCore::ShaderNotify* shader_notify,
-        const Device& device, DescriptorPool& descriptor_pool,
-        UpdateDescriptorQueue& update_descriptor_queue, Common::ThreadWorker* worker_thread,
-        PipelineStatistics* pipeline_statistics, RenderPassCache& render_pass_cache,
-        const GraphicsPipelineCacheKey& key, std::array<vk::ShaderModule, NUM_STAGES> stages,
-        const std::array<const Shader::Info*, NUM_STAGES>& infos);
+    explicit GraphicsPipeline(Scheduler& scheduler, BufferCache& buffer_cache,
+                              TextureCache& texture_cache, VideoCore::ShaderNotify* shader_notify,
+                              const Device& device, DescriptorPool& descriptor_pool,
+                              UpdateDescriptorQueue& update_descriptor_queue,
+                              Common::ThreadWorker* worker_thread,
+                              PipelineStatistics* pipeline_statistics,
+                              RenderPassCache& render_pass_cache,
+                              const GraphicsPipelineCacheKey& key,
+                              std::array<vk::ShaderModule, NUM_STAGES> stages,
+                              const std::array<const Shader::Info*, NUM_STAGES>& infos);
 
     GraphicsPipeline& operator=(GraphicsPipeline&&) noexcept = delete;
     GraphicsPipeline(GraphicsPipeline&&) noexcept = delete;
@@ -131,7 +133,6 @@ private:
     const Device& device;
     TextureCache& texture_cache;
     BufferCache& buffer_cache;
-    vk::PipelineCache& pipeline_cache;
     Scheduler& scheduler;
     UpdateDescriptorQueue& update_descriptor_queue;
 

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -55,7 +55,6 @@ using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
 constexpr u32 CACHE_VERSION = 10;
-constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
 
 template <typename Container>
 auto MakeSpan(Container& container) {
@@ -285,7 +284,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
       render_pass_cache{render_pass_cache_}, buffer_cache{buffer_cache_},
       texture_cache{texture_cache_}, shader_notify{shader_notify_},
       use_asynchronous_shaders{Settings::values.use_asynchronous_shaders.GetValue()},
-      use_vulkan_pipeline_cache{Settings::values.use_vulkan_driver_pipeline_cache.GetValue()},
       workers(std::max(std::thread::hardware_concurrency(), 2U) - 1, "VkPipelineBuilder"),
       serialization_thread(1, "VkPipelineSerialization") {
     const auto& float_control{device.FloatControlProperties()};
@@ -331,7 +329,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
         .need_declared_frag_colors = false,
 
         .has_broken_spirv_clamp = driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS,
-        .has_broken_spirv_position_input = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
         .has_broken_unsigned_image_offsets = false,
         .has_broken_signed_operations = false,
         .has_broken_fp16_float_controls = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY,
@@ -344,8 +341,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
             driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE,
         .support_snorm_render_buffer = true,
         .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
-        .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
-        .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
     };
 
     if (device.GetMaxVertexInputAttributes() < Maxwell::NumVertexAttributes) {
@@ -367,12 +362,7 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
     };
 }
 
-PipelineCache::~PipelineCache() {
-    if (use_vulkan_pipeline_cache && !vulkan_pipeline_cache_filename.empty()) {
-        SerializeVulkanPipelineCache(vulkan_pipeline_cache_filename, vulkan_pipeline_cache,
-                                     CACHE_VERSION);
-    }
-}
+PipelineCache::~PipelineCache() = default;
 
 GraphicsPipeline* PipelineCache::CurrentGraphicsPipeline() {
     MICROPROFILE_SCOPE(Vulkan_PipelineCache);
@@ -428,12 +418,6 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
     }
     pipeline_cache_filename = base_dir / "vulkan.bin";
 
-    if (use_vulkan_pipeline_cache) {
-        vulkan_pipeline_cache_filename = base_dir / "vulkan_pipelines.bin";
-        vulkan_pipeline_cache =
-            LoadVulkanPipelineCache(vulkan_pipeline_cache_filename, CACHE_VERSION);
-    }
-
     struct {
         std::mutex mutex;
         size_t total{};
@@ -512,11 +496,6 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
 
     workers.WaitForRequests(stop_loading);
 
-    if (use_vulkan_pipeline_cache) {
-        SerializeVulkanPipelineCache(vulkan_pipeline_cache_filename, vulkan_pipeline_cache,
-                                     CACHE_VERSION);
-    }
-
     if (state.statistics) {
         state.statistics->Report();
     }
@@ -637,10 +616,10 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
         previous_stage = &program;
     }
     Common::ThreadWorker* const thread_worker{build_in_parallel ? &workers : nullptr};
-    return std::make_unique<GraphicsPipeline>(
-        scheduler, buffer_cache, texture_cache, vulkan_pipeline_cache, &shader_notify, device,
-        descriptor_pool, update_descriptor_queue, thread_worker, statistics, render_pass_cache, key,
-        std::move(modules), infos);
+    return std::make_unique<GraphicsPipeline>(scheduler, buffer_cache, texture_cache,
+                                              &shader_notify, device, descriptor_pool,
+                                              update_descriptor_queue, thread_worker, statistics,
+                                              render_pass_cache, key, std::move(modules), infos);
 
 } catch (const Shader::Exception& exception) {
     LOG_ERROR(Render_Vulkan, "{}", exception.what());
@@ -710,108 +689,13 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
         spv_module.SetObjectNameEXT(name.c_str());
     }
     Common::ThreadWorker* const thread_worker{build_in_parallel ? &workers : nullptr};
-    return std::make_unique<ComputePipeline>(device, vulkan_pipeline_cache, descriptor_pool,
-                                             update_descriptor_queue, thread_worker, statistics,
-                                             &shader_notify, program.info, std::move(spv_module));
+    return std::make_unique<ComputePipeline>(device, descriptor_pool, update_descriptor_queue,
+                                             thread_worker, statistics, &shader_notify,
+                                             program.info, std::move(spv_module));
 
 } catch (const Shader::Exception& exception) {
     LOG_ERROR(Render_Vulkan, "{}", exception.what());
     return nullptr;
 }
 
-void PipelineCache::SerializeVulkanPipelineCache(const std::filesystem::path& filename,
-                                                 const vk::PipelineCache& pipeline_cache,
-                                                 u32 cache_version) try {
-    std::ofstream file(filename, std::ios::binary);
-    file.exceptions(std::ifstream::failbit);
-    if (!file.is_open()) {
-        LOG_ERROR(Common_Filesystem, "Failed to open Vulkan driver pipeline cache file {}",
-                  Common::FS::PathToUTF8String(filename));
-        return;
-    }
-    file.write(VULKAN_CACHE_MAGIC_NUMBER.data(), VULKAN_CACHE_MAGIC_NUMBER.size())
-        .write(reinterpret_cast<const char*>(&cache_version), sizeof(cache_version));
-
-    size_t cache_size = 0;
-    std::vector<char> cache_data;
-    if (pipeline_cache) {
-        pipeline_cache.Read(&cache_size, nullptr);
-        cache_data.resize(cache_size);
-        pipeline_cache.Read(&cache_size, cache_data.data());
-    }
-    file.write(cache_data.data(), cache_size);
-
-    LOG_INFO(Render_Vulkan, "Vulkan driver pipelines cached at: {}",
-             Common::FS::PathToUTF8String(filename));
-
-} catch (const std::ios_base::failure& e) {
-    LOG_ERROR(Common_Filesystem, "{}", e.what());
-    if (!Common::FS::RemoveFile(filename)) {
-        LOG_ERROR(Common_Filesystem, "Failed to delete Vulkan driver pipeline cache file {}",
-                  Common::FS::PathToUTF8String(filename));
-    }
-}
-
-vk::PipelineCache PipelineCache::LoadVulkanPipelineCache(const std::filesystem::path& filename,
-                                                         u32 expected_cache_version) {
-    const auto create_pipeline_cache = [this](size_t data_size, const void* data) {
-        VkPipelineCacheCreateInfo pipeline_cache_ci = {
-            .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .initialDataSize = data_size,
-            .pInitialData = data};
-        return device.GetLogical().CreatePipelineCache(pipeline_cache_ci);
-    };
-    try {
-        std::ifstream file(filename, std::ios::binary | std::ios::ate);
-        if (!file.is_open()) {
-            return create_pipeline_cache(0, nullptr);
-        }
-        file.exceptions(std::ifstream::failbit);
-        const auto end{file.tellg()};
-        file.seekg(0, std::ios::beg);
-
-        std::array<char, 8> magic_number;
-        u32 cache_version;
-        file.read(magic_number.data(), magic_number.size())
-            .read(reinterpret_cast<char*>(&cache_version), sizeof(cache_version));
-        if (magic_number != VULKAN_CACHE_MAGIC_NUMBER || cache_version != expected_cache_version) {
-            file.close();
-            if (Common::FS::RemoveFile(filename)) {
-                if (magic_number != VULKAN_CACHE_MAGIC_NUMBER) {
-                    LOG_ERROR(Common_Filesystem, "Invalid Vulkan driver pipeline cache file");
-                }
-                if (cache_version != expected_cache_version) {
-                    LOG_INFO(Common_Filesystem, "Deleting old Vulkan driver pipeline cache");
-                }
-            } else {
-                LOG_ERROR(Common_Filesystem,
-                          "Invalid Vulkan pipeline cache file and failed to delete it in \"{}\"",
-                          Common::FS::PathToUTF8String(filename));
-            }
-            return create_pipeline_cache(0, nullptr);
-        }
-
-        static constexpr size_t header_size = magic_number.size() + sizeof(cache_version);
-        const size_t cache_size = static_cast<size_t>(end) - header_size;
-        std::vector<char> cache_data(cache_size);
-        file.read(cache_data.data(), cache_size);
-
-        LOG_INFO(Render_Vulkan,
-                 "Loaded Vulkan driver pipeline cache: ", Common::FS::PathToUTF8String(filename));
-
-        return create_pipeline_cache(cache_size, cache_data.data());
-
-    } catch (const std::ios_base::failure& e) {
-        LOG_ERROR(Common_Filesystem, "{}", e.what());
-        if (!Common::FS::RemoveFile(filename)) {
-            LOG_ERROR(Common_Filesystem, "Failed to delete Vulkan driver pipeline cache file {}",
-                      Common::FS::PathToUTF8String(filename));
-        }
-
-        return create_pipeline_cache(0, nullptr);
-    }
-}
-
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -135,12 +135,6 @@ private:
                                                            PipelineStatistics* statistics,
                                                            bool build_in_parallel);
 
-    void SerializeVulkanPipelineCache(const std::filesystem::path& filename,
-                                      const vk::PipelineCache& pipeline_cache, u32 cache_version);
-
-    vk::PipelineCache LoadVulkanPipelineCache(const std::filesystem::path& filename,
-                                              u32 expected_cache_version);
-
     const Device& device;
     Scheduler& scheduler;
     DescriptorPool& descriptor_pool;
@@ -150,7 +144,6 @@ private:
     TextureCache& texture_cache;
     VideoCore::ShaderNotify& shader_notify;
     bool use_asynchronous_shaders{};
-    bool use_vulkan_pipeline_cache{};
 
     GraphicsPipelineCacheKey graphics_key{};
     GraphicsPipeline* current_pipeline{};
@@ -165,9 +158,6 @@ private:
 
     std::filesystem::path pipeline_cache_filename;
 
-    std::filesystem::path vulkan_pipeline_cache_filename;
-    vk::PipelineCache vulkan_pipeline_cache;
-
     Common::ThreadWorker workers;
     Common::ThreadWorker serialization_thread;
     DynamicFeatures dynamic_features;

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -186,7 +186,6 @@ void RasterizerVulkan::PrepareDraw(bool is_indexed, Func&& draw_func) {
 
     SCOPE_EXIT({ gpu.TickWork(); });
     FlushWork();
-    gpu_memory->FlushCaching();
 
     query_cache.UpdateCounters();
 
@@ -270,7 +269,6 @@ void RasterizerVulkan::Clear(u32 layer_count) {
     MICROPROFILE_SCOPE(Vulkan_Clearing);
 
     FlushWork();
-    gpu_memory->FlushCaching();
 
     query_cache.UpdateCounters();
 
@@ -395,7 +393,6 @@ void RasterizerVulkan::Clear(u32 layer_count) {
 
 void RasterizerVulkan::DispatchCompute() {
     FlushWork();
-    gpu_memory->FlushCaching();
 
     ComputePipeline* const pipeline{pipeline_cache.CurrentComputePipeline()};
     if (!pipeline) {
@@ -484,27 +481,6 @@ void RasterizerVulkan::InvalidateRegion(VAddr addr, u64 size, VideoCommon::Cache
     }
 }
 
-void RasterizerVulkan::InnerInvalidation(std::span<const std::pair<VAddr, std::size_t>> sequences) {
-    {
-        std::scoped_lock lock{texture_cache.mutex};
-        for (const auto& [addr, size] : sequences) {
-            texture_cache.WriteMemory(addr, size);
-        }
-    }
-    {
-        std::scoped_lock lock{buffer_cache.mutex};
-        for (const auto& [addr, size] : sequences) {
-            buffer_cache.WriteMemory(addr, size);
-        }
-    }
-    {
-        for (const auto& [addr, size] : sequences) {
-            query_cache.InvalidateRegion(addr, size);
-            pipeline_cache.InvalidateRegion(addr, size);
-        }
-    }
-}
-
 void RasterizerVulkan::OnCPUWrite(VAddr addr, u64 size) {
     if (addr == 0 || size == 0) {
         return;
@@ -629,7 +605,6 @@ void RasterizerVulkan::TickFrame() {
 }
 
 bool RasterizerVulkan::AccelerateConditionalRendering() {
-    gpu_memory->FlushCaching();
     if (Settings::IsGPULevelHigh()) {
         // TODO(Blinkhawk): Reimplement Host conditional rendering.
         return false;

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -79,7 +79,6 @@ public:
                          VideoCommon::CacheType which = VideoCommon::CacheType::All) override;
     void InvalidateRegion(VAddr addr, u64 size,
                           VideoCommon::CacheType which = VideoCommon::CacheType::All) override;
-    void InnerInvalidation(std::span<const std::pair<VAddr, std::size_t>> sequences) override;
     void OnCPUWrite(VAddr addr, u64 size) override;
     void InvalidateGPUCache() override;
     void UnmapMemory(VAddr addr, u64 size) override;

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -213,11 +213,6 @@ void Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_s
             .signalSemaphoreCount = num_signal_semaphores,
             .pSignalSemaphores = signal_semaphores.data(),
         };
-
-        if (on_submit) {
-            on_submit();
-        }
-
         switch (const VkResult result = device.GetGraphicsQueue().Submit(submit_info)) {
         case VK_SUCCESS:
             break;

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -5,7 +5,6 @@
 
 #include <condition_variable>
 #include <cstddef>
-#include <functional>
 #include <memory>
 #include <thread>
 #include <utility>
@@ -67,11 +66,6 @@ public:
         query_cache = &query_cache_;
     }
 
-    // Registers a callback to perform on queue submission.
-    void RegisterOnSubmit(std::function<void()>&& func) {
-        on_submit = std::move(func);
-    }
-
     /// Send work to a separate thread.
     template <typename T>
     void Record(T&& command) {
@@ -222,7 +216,6 @@ private:
     vk::CommandBuffer current_cmdbuf;
 
     std::unique_ptr<CommandChunk> chunk;
-    std::function<void()> on_submit;
 
     State state;
 

src/video_core/renderer_vulkan/vk_turbo_mode.cpp

@@ -1,222 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/literals.h"
-#include "video_core/host_shaders/vulkan_turbo_mode_comp_spv.h"
-#include "video_core/renderer_vulkan/renderer_vulkan.h"
-#include "video_core/renderer_vulkan/vk_shader_util.h"
-#include "video_core/renderer_vulkan/vk_turbo_mode.h"
-#include "video_core/vulkan_common/vulkan_device.h"
-
-namespace Vulkan {
-
-using namespace Common::Literals;
-
-TurboMode::TurboMode(const vk::Instance& instance, const vk::InstanceDispatch& dld)
-    : m_device{CreateDevice(instance, dld, VK_NULL_HANDLE)}, m_allocator{m_device, false} {
-    {
-        std::scoped_lock lk{m_submission_lock};
-        m_submission_time = std::chrono::steady_clock::now();
-    }
-    m_thread = std::jthread([&](auto stop_token) { Run(stop_token); });
-}
-
-TurboMode::~TurboMode() = default;
-
-void TurboMode::QueueSubmitted() {
-    std::scoped_lock lk{m_submission_lock};
-    m_submission_time = std::chrono::steady_clock::now();
-    m_submission_cv.notify_one();
-}
-
-void TurboMode::Run(std::stop_token stop_token) {
-    auto& dld = m_device.GetLogical();
-
-    // Allocate buffer. 2MiB should be sufficient.
-    auto buffer = dld.CreateBuffer(VkBufferCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .size = 2_MiB,
-        .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = nullptr,
-    });
-
-    // Commit some device local memory for the buffer.
-    auto commit = m_allocator.Commit(buffer, MemoryUsage::DeviceLocal);
-
-    // Create the descriptor pool to contain our descriptor.
-    constexpr VkDescriptorPoolSize pool_size{
-        .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-    };
-
-    auto descriptor_pool = dld.CreateDescriptorPool(VkDescriptorPoolCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
-        .maxSets = 1,
-        .poolSizeCount = 1,
-        .pPoolSizes = &pool_size,
-    });
-
-    // Create the descriptor set layout from the pool.
-    constexpr VkDescriptorSetLayoutBinding layout_binding{
-        .binding = 0,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    };
-
-    auto descriptor_set_layout = dld.CreateDescriptorSetLayout(VkDescriptorSetLayoutCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .bindingCount = 1,
-        .pBindings = &layout_binding,
-    });
-
-    // Actually create the descriptor set.
-    auto descriptor_set = descriptor_pool.Allocate(VkDescriptorSetAllocateInfo{
-        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
-        .pNext = nullptr,
-        .descriptorPool = *descriptor_pool,
-        .descriptorSetCount = 1,
-        .pSetLayouts = descriptor_set_layout.address(),
-    });
-
-    // Create the shader.
-    auto shader = BuildShader(m_device, VULKAN_TURBO_MODE_COMP_SPV);
-
-    // Create the pipeline layout.
-    auto pipeline_layout = dld.CreatePipelineLayout(VkPipelineLayoutCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .setLayoutCount = 1,
-        .pSetLayouts = descriptor_set_layout.address(),
-        .pushConstantRangeCount = 0,
-        .pPushConstantRanges = nullptr,
-    });
-
-    // Actually create the pipeline.
-    const VkPipelineShaderStageCreateInfo shader_stage{
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .stage = VK_SHADER_STAGE_COMPUTE_BIT,
-        .module = *shader,
-        .pName = "main",
-        .pSpecializationInfo = nullptr,
-    };
-
-    auto pipeline = dld.CreateComputePipeline(VkComputePipelineCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .stage = shader_stage,
-        .layout = *pipeline_layout,
-        .basePipelineHandle = VK_NULL_HANDLE,
-        .basePipelineIndex = 0,
-    });
-
-    // Create a fence to wait on.
-    auto fence = dld.CreateFence(VkFenceCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-    });
-
-    // Create a command pool to allocate a command buffer from.
-    auto command_pool = dld.CreateCommandPool(VkCommandPoolCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
-        .pNext = nullptr,
-        .flags =
-            VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
-        .queueFamilyIndex = m_device.GetGraphicsFamily(),
-    });
-
-    // Create a single command buffer.
-    auto cmdbufs = command_pool.Allocate(1, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
-    auto cmdbuf = vk::CommandBuffer{cmdbufs[0], m_device.GetDispatchLoader()};
-
-    while (!stop_token.stop_requested()) {
-        // Reset the fence.
-        fence.Reset();
-
-        // Update descriptor set.
-        const VkDescriptorBufferInfo buffer_info{
-            .buffer = *buffer,
-            .offset = 0,
-            .range = VK_WHOLE_SIZE,
-        };
-
-        const VkWriteDescriptorSet buffer_write{
-            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-            .pNext = nullptr,
-            .dstSet = descriptor_set[0],
-            .dstBinding = 0,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .pImageInfo = nullptr,
-            .pBufferInfo = &buffer_info,
-            .pTexelBufferView = nullptr,
-        };
-
-        dld.UpdateDescriptorSets(std::array{buffer_write}, {});
-
-        // Set up the command buffer.
-        cmdbuf.Begin(VkCommandBufferBeginInfo{
-            .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-            .pNext = nullptr,
-            .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
-            .pInheritanceInfo = nullptr,
-        });
-
-        // Clear the buffer.
-        cmdbuf.FillBuffer(*buffer, 0, VK_WHOLE_SIZE, 0);
-
-        // Bind descriptor set.
-        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline_layout, 0,
-                                  descriptor_set, {});
-
-        // Bind the pipeline.
-        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
-
-        // Dispatch.
-        cmdbuf.Dispatch(64, 64, 1);
-
-        // Finish.
-        cmdbuf.End();
-
-        const VkSubmitInfo submit_info{
-            .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
-            .pNext = nullptr,
-            .waitSemaphoreCount = 0,
-            .pWaitSemaphores = nullptr,
-            .pWaitDstStageMask = nullptr,
-            .commandBufferCount = 1,
-            .pCommandBuffers = cmdbuf.address(),
-            .signalSemaphoreCount = 0,
-            .pSignalSemaphores = nullptr,
-        };
-
-        m_device.GetGraphicsQueue().Submit(std::array{submit_info}, *fence);
-
-        // Wait for completion.
-        fence.Wait();
-
-        // Wait for the next graphics queue submission if necessary.
-        std::unique_lock lk{m_submission_lock};
-        Common::CondvarWait(m_submission_cv, lk, stop_token, [this] {
-            return (std::chrono::steady_clock::now() - m_submission_time) <=
-                   std::chrono::milliseconds{100};
-        });
-    }
-}
-
-} // namespace Vulkan

src/video_core/renderer_vulkan/vk_turbo_mode.h

@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <chrono>
-#include <mutex>
-
-#include "common/polyfill_thread.h"
-#include "video_core/vulkan_common/vulkan_device.h"
-#include "video_core/vulkan_common/vulkan_memory_allocator.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
-namespace Vulkan {
-
-class TurboMode {
-public:
-    explicit TurboMode(const vk::Instance& instance, const vk::InstanceDispatch& dld);
-    ~TurboMode();
-
-    void QueueSubmitted();
-
-private:
-    void Run(std::stop_token stop_token);
-
-    Device m_device;
-    MemoryAllocator m_allocator;
-    std::mutex m_submission_lock;
-    std::condition_variable_any m_submission_cv;
-    std::chrono::time_point<std::chrono::steady_clock> m_submission_time{};
-
-    std::jthread m_thread;
-};
-
-} // namespace Vulkan

src/video_core/vulkan_common/vulkan_device.h

@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include <set>
 #include <span>
 #include <string>
 #include <unordered_map>
@@ -12,155 +11,6 @@
 #include "common/common_types.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
-// Define all features which may be used by the implementation here.
-// Vulkan version in the macro describes the minimum version required for feature availability.
-// If the Vulkan version is lower than the required version, the named extension is required.
-#define FOR_EACH_VK_FEATURE_1_1(FEATURE)                                                           \
-    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
-    FEATURE(KHR, 16BitStorage, 16BIT_STORAGE, bit16_storage)                                       \
-    FEATURE(KHR, ShaderAtomicInt64, SHADER_ATOMIC_INT64, shader_atomic_int64)                      \
-    FEATURE(KHR, ShaderDrawParameters, SHADER_DRAW_PARAMETERS, shader_draw_parameters)             \
-    FEATURE(KHR, ShaderFloat16Int8, SHADER_FLOAT16_INT8, shader_float16_int8)                      \
-    FEATURE(KHR, UniformBufferStandardLayout, UNIFORM_BUFFER_STANDARD_LAYOUT,                      \
-            uniform_buffer_standard_layout)                                                        \
-    FEATURE(KHR, VariablePointer, VARIABLE_POINTERS, variable_pointer)
-
-#define FOR_EACH_VK_FEATURE_1_2(FEATURE)                                                           \
-    FEATURE(EXT, HostQueryReset, HOST_QUERY_RESET, host_query_reset)                               \
-    FEATURE(KHR, 8BitStorage, 8BIT_STORAGE, bit8_storage)                                          \
-    FEATURE(KHR, TimelineSemaphore, TIMELINE_SEMAPHORE, timeline_semaphore)
-
-#define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
-    FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
-            shader_demote_to_helper_invocation)
-
-// Define all features which may be used by the implementation and require an extension here.
-#define FOR_EACH_VK_FEATURE_EXT(FEATURE)                                                           \
-    FEATURE(EXT, CustomBorderColor, CUSTOM_BORDER_COLOR, custom_border_color)                      \
-    FEATURE(EXT, DepthClipControl, DEPTH_CLIP_CONTROL, depth_clip_control)                         \
-    FEATURE(EXT, ExtendedDynamicState, EXTENDED_DYNAMIC_STATE, extended_dynamic_state)             \
-    FEATURE(EXT, ExtendedDynamicState2, EXTENDED_DYNAMIC_STATE_2, extended_dynamic_state2)         \
-    FEATURE(EXT, ExtendedDynamicState3, EXTENDED_DYNAMIC_STATE_3, extended_dynamic_state3)         \
-    FEATURE(EXT, IndexTypeUint8, INDEX_TYPE_UINT8, index_type_uint8)                               \
-    FEATURE(EXT, LineRasterization, LINE_RASTERIZATION, line_rasterization)                        \
-    FEATURE(EXT, PrimitiveTopologyListRestart, PRIMITIVE_TOPOLOGY_LIST_RESTART,                    \
-            primitive_topology_list_restart)                                                       \
-    FEATURE(EXT, ProvokingVertex, PROVOKING_VERTEX, provoking_vertex)                              \
-    FEATURE(EXT, Robustness2, ROBUSTNESS_2, robustness2)                                           \
-    FEATURE(EXT, TransformFeedback, TRANSFORM_FEEDBACK, transform_feedback)                        \
-    FEATURE(EXT, VertexInputDynamicState, VERTEX_INPUT_DYNAMIC_STATE, vertex_input_dynamic_state)  \
-    FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
-            pipeline_executable_properties)                                                        \
-    FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
-            workgroup_memory_explicit_layout)
-
-// Define miscellaneous extensions which may be used by the implementation here.
-#define FOR_EACH_VK_EXTENSION(EXTENSION)                                                           \
-    EXTENSION(EXT, CONSERVATIVE_RASTERIZATION, conservative_rasterization)                         \
-    EXTENSION(EXT, DEPTH_RANGE_UNRESTRICTED, depth_range_unrestricted)                             \
-    EXTENSION(EXT, MEMORY_BUDGET, memory_budget)                                                   \
-    EXTENSION(EXT, ROBUSTNESS_2, robustness_2)                                                     \
-    EXTENSION(EXT, SAMPLER_FILTER_MINMAX, sampler_filter_minmax)                                   \
-    EXTENSION(EXT, SHADER_STENCIL_EXPORT, shader_stencil_export)                                   \
-    EXTENSION(EXT, SHADER_VIEWPORT_INDEX_LAYER, shader_viewport_index_layer)                       \
-    EXTENSION(EXT, TOOLING_INFO, tooling_info)                                                     \
-    EXTENSION(EXT, VERTEX_ATTRIBUTE_DIVISOR, vertex_attribute_divisor)                             \
-    EXTENSION(KHR, DRIVER_PROPERTIES, driver_properties)                                           \
-    EXTENSION(KHR, EXTERNAL_MEMORY_FD, external_memory_fd)                                         \
-    EXTENSION(KHR, PUSH_DESCRIPTOR, push_descriptor)                                               \
-    EXTENSION(KHR, SAMPLER_MIRROR_CLAMP_TO_EDGE, sampler_mirror_clamp_to_edge)                     \
-    EXTENSION(KHR, SHADER_FLOAT_CONTROLS, shader_float_controls)                                   \
-    EXTENSION(KHR, SPIRV_1_4, spirv_1_4)                                                           \
-    EXTENSION(KHR, SWAPCHAIN, swapchain)                                                           \
-    EXTENSION(KHR, SWAPCHAIN_MUTABLE_FORMAT, swapchain_mutable_format)                             \
-    EXTENSION(NV, DEVICE_DIAGNOSTICS_CONFIG, device_diagnostics_config)                            \
-    EXTENSION(NV, GEOMETRY_SHADER_PASSTHROUGH, geometry_shader_passthrough)                        \
-    EXTENSION(NV, VIEWPORT_ARRAY2, viewport_array2)                                                \
-    EXTENSION(NV, VIEWPORT_SWIZZLE, viewport_swizzle)
-
-#define FOR_EACH_VK_EXTENSION_WIN32(EXTENSION)                                                     \
-    EXTENSION(KHR, EXTERNAL_MEMORY_WIN32, external_memory_win32)
-
-// Define extensions which must be supported.
-#define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
-    EXTENSION_NAME(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)                                             \
-    EXTENSION_NAME(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)                                 \
-    EXTENSION_NAME(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)                                        \
-    EXTENSION_NAME(VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME)                             \
-    EXTENSION_NAME(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)
-
-#define FOR_EACH_VK_MANDATORY_EXTENSION_GENERIC(EXTENSION_NAME)                                    \
-    EXTENSION_NAME(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME)
-
-#define FOR_EACH_VK_MANDATORY_EXTENSION_WIN32(EXTENSION_NAME)                                      \
-    EXTENSION_NAME(VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME)
-
-// Define extensions where the absence of the extension may result in a degraded experience.
-#define FOR_EACH_VK_RECOMMENDED_EXTENSION(EXTENSION_NAME)                                          \
-    EXTENSION_NAME(VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME)                               \
-    EXTENSION_NAME(VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME)                                 \
-    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME)                                   \
-    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME)                                 \
-    EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME)                                 \
-    EXTENSION_NAME(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)                                       \
-    EXTENSION_NAME(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME)                               \
-    EXTENSION_NAME(VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME)                               \
-    EXTENSION_NAME(VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME)                                           \
-    EXTENSION_NAME(VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME)
-
-// Define features which must be supported.
-#define FOR_EACH_VK_MANDATORY_FEATURE(FEATURE_NAME)                                                \
-    FEATURE_NAME(bit16_storage, storageBuffer16BitAccess)                                          \
-    FEATURE_NAME(bit16_storage, uniformAndStorageBuffer16BitAccess)                                \
-    FEATURE_NAME(bit8_storage, storageBuffer8BitAccess)                                            \
-    FEATURE_NAME(bit8_storage, uniformAndStorageBuffer8BitAccess)                                  \
-    FEATURE_NAME(features, depthBiasClamp)                                                         \
-    FEATURE_NAME(features, depthClamp)                                                             \
-    FEATURE_NAME(features, drawIndirectFirstInstance)                                              \
-    FEATURE_NAME(features, dualSrcBlend)                                                           \
-    FEATURE_NAME(features, fillModeNonSolid)                                                       \
-    FEATURE_NAME(features, fragmentStoresAndAtomics)                                               \
-    FEATURE_NAME(features, geometryShader)                                                         \
-    FEATURE_NAME(features, imageCubeArray)                                                         \
-    FEATURE_NAME(features, independentBlend)                                                       \
-    FEATURE_NAME(features, largePoints)                                                            \
-    FEATURE_NAME(features, logicOp)                                                                \
-    FEATURE_NAME(features, multiDrawIndirect)                                                      \
-    FEATURE_NAME(features, multiViewport)                                                          \
-    FEATURE_NAME(features, occlusionQueryPrecise)                                                  \
-    FEATURE_NAME(features, robustBufferAccess)                                                     \
-    FEATURE_NAME(features, samplerAnisotropy)                                                      \
-    FEATURE_NAME(features, sampleRateShading)                                                      \
-    FEATURE_NAME(features, shaderClipDistance)                                                     \
-    FEATURE_NAME(features, shaderCullDistance)                                                     \
-    FEATURE_NAME(features, shaderImageGatherExtended)                                              \
-    FEATURE_NAME(features, shaderStorageImageWriteWithoutFormat)                                   \
-    FEATURE_NAME(features, tessellationShader)                                                     \
-    FEATURE_NAME(features, vertexPipelineStoresAndAtomics)                                         \
-    FEATURE_NAME(features, wideLines)                                                              \
-    FEATURE_NAME(host_query_reset, hostQueryReset)                                                 \
-    FEATURE_NAME(robustness2, nullDescriptor)                                                      \
-    FEATURE_NAME(robustness2, robustBufferAccess2)                                                 \
-    FEATURE_NAME(robustness2, robustImageAccess2)                                                  \
-    FEATURE_NAME(shader_demote_to_helper_invocation, shaderDemoteToHelperInvocation)               \
-    FEATURE_NAME(shader_draw_parameters, shaderDrawParameters)                                     \
-    FEATURE_NAME(timeline_semaphore, timelineSemaphore)                                            \
-    FEATURE_NAME(variable_pointer, variablePointers)                                               \
-    FEATURE_NAME(variable_pointer, variablePointersStorageBuffer)
-
-// Define features where the absence of the feature may result in a degraded experience.
-#define FOR_EACH_VK_RECOMMENDED_FEATURE(FEATURE_NAME)                                              \
-    FEATURE_NAME(custom_border_color, customBorderColors)                                          \
-    FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
-    FEATURE_NAME(index_type_uint8, indexTypeUint8)                                                 \
-    FEATURE_NAME(primitive_topology_list_restart, primitiveTopologyListRestart)                    \
-    FEATURE_NAME(provoking_vertex, provokingVertexLast)                                            \
-    FEATURE_NAME(shader_float16_int8, shaderFloat16)                                               \
-    FEATURE_NAME(shader_float16_int8, shaderInt8)                                                  \
-    FEATURE_NAME(transform_feedback, transformFeedback)                                            \
-    FEATURE_NAME(uniform_buffer_standard_layout, uniformBufferStandardLayout)                      \
-    FEATURE_NAME(vertex_input_dynamic_state, vertexInputDynamicState)
-
 namespace Vulkan {
 
 class NsightAftermathTracker;
@@ -238,69 +88,67 @@ public:
 
     /// Returns the current Vulkan API version provided in Vulkan-formatted version numbers.
     u32 ApiVersion() const {
-        return properties.properties.apiVersion;
+        return properties.apiVersion;
     }
 
     /// Returns the current driver version provided in Vulkan-formatted version numbers.
     u32 GetDriverVersion() const {
-        return properties.properties.driverVersion;
+        return properties.driverVersion;
     }
 
     /// Returns the device name.
     std::string_view GetModelName() const {
-        return properties.properties.deviceName;
+        return properties.deviceName;
     }
 
     /// Returns the driver ID.
     VkDriverIdKHR GetDriverID() const {
-        return properties.driver.driverID;
+        return driver_id;
     }
 
-    bool ShouldBoostClocks() const;
-
     /// Returns uniform buffer alignment requeriment.
     VkDeviceSize GetUniformBufferAlignment() const {
-        return properties.properties.limits.minUniformBufferOffsetAlignment;
+        return properties.limits.minUniformBufferOffsetAlignment;
     }
 
     /// Returns storage alignment requeriment.
     VkDeviceSize GetStorageBufferAlignment() const {
-        return properties.properties.limits.minStorageBufferOffsetAlignment;
+        return properties.limits.minStorageBufferOffsetAlignment;
     }
 
     /// Returns the maximum range for storage buffers.
     VkDeviceSize GetMaxStorageBufferRange() const {
-        return properties.properties.limits.maxStorageBufferRange;
+        return properties.limits.maxStorageBufferRange;
     }
 
     /// Returns the maximum size for push constants.
     VkDeviceSize GetMaxPushConstantsSize() const {
-        return properties.properties.limits.maxPushConstantsSize;
+        return properties.limits.maxPushConstantsSize;
     }
 
     /// Returns the maximum size for shared memory.
     u32 GetMaxComputeSharedMemorySize() const {
-        return properties.properties.limits.maxComputeSharedMemorySize;
+        return properties.limits.maxComputeSharedMemorySize;
     }
 
     /// Returns float control properties of the device.
     const VkPhysicalDeviceFloatControlsPropertiesKHR& FloatControlProperties() const {
-        return properties.float_controls;
+        return float_controls;
     }
 
     /// Returns true if ASTC is natively supported.
     bool IsOptimalAstcSupported() const {
-        return features.features.textureCompressionASTC_LDR;
+        return is_optimal_astc_supported;
     }
 
     /// Returns true if the device supports float16 natively.
     bool IsFloat16Supported() const {
-        return features.shader_float16_int8.shaderFloat16;
+        return is_float16_supported;
     }
 
     /// Returns true if the device supports int8 natively.
     bool IsInt8Supported() const {
-        return features.shader_float16_int8.shaderInt8;
+        return is_int8_supported;
     }
 
     /// Returns true if the device warp size can potentially be bigger than guest's warp size.
@@ -310,32 +158,32 @@ public:
 
     /// Returns true if the device can be forced to use the guest warp size.
     bool IsGuestWarpSizeSupported(VkShaderStageFlagBits stage) const {
-        return properties.subgroup_size_control.requiredSubgroupSizeStages & stage;
+        return guest_warp_stages & stage;
     }
 
     /// Returns the maximum number of push descriptors.
     u32 MaxPushDescriptors() const {
-        return properties.push_descriptor.maxPushDescriptors;
+        return max_push_descriptors;
     }
 
     /// Returns true if formatless image load is supported.
     bool IsFormatlessImageLoadSupported() const {
-        return features.features.shaderStorageImageReadWithoutFormat;
+        return is_formatless_image_load_supported;
     }
 
     /// Returns true if shader int64 is supported.
     bool IsShaderInt64Supported() const {
-        return features.features.shaderInt64;
+        return is_shader_int64_supported;
     }
 
     /// Returns true if shader int16 is supported.
     bool IsShaderInt16Supported() const {
-        return features.features.shaderInt16;
+        return is_shader_int16_supported;
     }
 
     // Returns true if depth bounds is supported.
     bool IsDepthBoundsSupported() const {
-        return features.features.depthBounds;
+        return is_depth_bounds_supported;
     }
 
     /// Returns true when blitting from and to depth stencil images is supported.
@@ -345,151 +193,151 @@ public:
 
     /// Returns true if the device supports VK_NV_viewport_swizzle.
     bool IsNvViewportSwizzleSupported() const {
-        return extensions.viewport_swizzle;
+        return nv_viewport_swizzle;
     }
 
     /// Returns true if the device supports VK_NV_viewport_array2.
     bool IsNvViewportArray2Supported() const {
-        return extensions.viewport_array2;
+        return nv_viewport_array2;
     }
 
     /// Returns true if the device supports VK_NV_geometry_shader_passthrough.
     bool IsNvGeometryShaderPassthroughSupported() const {
-        return extensions.geometry_shader_passthrough;
+        return nv_geometry_shader_passthrough;
     }
 
     /// Returns true if the device supports VK_KHR_uniform_buffer_standard_layout.
     bool IsKhrUniformBufferStandardLayoutSupported() const {
-        return extensions.uniform_buffer_standard_layout;
+        return khr_uniform_buffer_standard_layout;
     }
 
     /// Returns true if the device supports VK_KHR_push_descriptor.
     bool IsKhrPushDescriptorSupported() const {
-        return extensions.push_descriptor;
+        return khr_push_descriptor;
     }
 
     /// Returns true if VK_KHR_pipeline_executable_properties is enabled.
     bool IsKhrPipelineExecutablePropertiesEnabled() const {
-        return extensions.pipeline_executable_properties;
+        return khr_pipeline_executable_properties;
     }
 
     /// Returns true if VK_KHR_swapchain_mutable_format is enabled.
     bool IsKhrSwapchainMutableFormatEnabled() const {
-        return extensions.swapchain_mutable_format;
+        return khr_swapchain_mutable_format;
     }
 
     /// Returns true if the device supports VK_KHR_workgroup_memory_explicit_layout.
     bool IsKhrWorkgroupMemoryExplicitLayoutSupported() const {
-        return extensions.workgroup_memory_explicit_layout;
+        return khr_workgroup_memory_explicit_layout;
     }
 
     /// Returns true if the device supports VK_EXT_primitive_topology_list_restart.
     bool IsTopologyListPrimitiveRestartSupported() const {
-        return features.primitive_topology_list_restart.primitiveTopologyListRestart;
+        return is_topology_list_restart_supported;
     }
 
     /// Returns true if the device supports VK_EXT_primitive_topology_list_restart.
     bool IsPatchListPrimitiveRestartSupported() const {
-        return features.primitive_topology_list_restart.primitiveTopologyPatchListRestart;
+        return is_patch_list_restart_supported;
     }
 
     /// Returns true if the device supports VK_EXT_index_type_uint8.
     bool IsExtIndexTypeUint8Supported() const {
-        return extensions.index_type_uint8;
+        return ext_index_type_uint8;
     }
 
     /// Returns true if the device supports VK_EXT_sampler_filter_minmax.
     bool IsExtSamplerFilterMinmaxSupported() const {
-        return extensions.sampler_filter_minmax;
+        return ext_sampler_filter_minmax;
     }
 
     /// Returns true if the device supports VK_EXT_depth_range_unrestricted.
     bool IsExtDepthRangeUnrestrictedSupported() const {
-        return extensions.depth_range_unrestricted;
+        return ext_depth_range_unrestricted;
     }
 
     /// Returns true if the device supports VK_EXT_depth_clip_control.
     bool IsExtDepthClipControlSupported() const {
-        return extensions.depth_clip_control;
+        return ext_depth_clip_control;
     }
 
     /// Returns true if the device supports VK_EXT_shader_viewport_index_layer.
     bool IsExtShaderViewportIndexLayerSupported() const {
-        return extensions.shader_viewport_index_layer;
+        return ext_shader_viewport_index_layer;
     }
 
     /// Returns true if the device supports VK_EXT_subgroup_size_control.
     bool IsExtSubgroupSizeControlSupported() const {
-        return extensions.subgroup_size_control;
+        return ext_subgroup_size_control;
     }
 
     /// Returns true if the device supports VK_EXT_transform_feedback.
     bool IsExtTransformFeedbackSupported() const {
-        return extensions.transform_feedback;
+        return ext_transform_feedback;
     }
 
     /// Returns true if the device supports VK_EXT_custom_border_color.
     bool IsExtCustomBorderColorSupported() const {
-        return extensions.custom_border_color;
+        return ext_custom_border_color;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state.
     bool IsExtExtendedDynamicStateSupported() const {
-        return extensions.extended_dynamic_state;
+        return ext_extended_dynamic_state;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state2.
     bool IsExtExtendedDynamicState2Supported() const {
-        return extensions.extended_dynamic_state2;
+        return ext_extended_dynamic_state_2;
     }
 
     bool IsExtExtendedDynamicState2ExtrasSupported() const {
-        return features.extended_dynamic_state2.extendedDynamicState2LogicOp;
+        return ext_extended_dynamic_state_2_extra;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3Supported() const {
-        return extensions.extended_dynamic_state3;
+        return ext_extended_dynamic_state_3;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3BlendingSupported() const {
-        return dynamic_state3_blending;
+        return ext_extended_dynamic_state_3_blend;
     }
 
     /// Returns true if the device supports VK_EXT_extended_dynamic_state3.
     bool IsExtExtendedDynamicState3EnablesSupported() const {
-        return dynamic_state3_enables;
+        return ext_extended_dynamic_state_3_enables;
     }
 
     /// Returns true if the device supports VK_EXT_line_rasterization.
     bool IsExtLineRasterizationSupported() const {
-        return extensions.line_rasterization;
+        return ext_line_rasterization;
     }
 
     /// Returns true if the device supports VK_EXT_vertex_input_dynamic_state.
     bool IsExtVertexInputDynamicStateSupported() const {
-        return extensions.vertex_input_dynamic_state;
+        return ext_vertex_input_dynamic_state;
     }
 
     /// Returns true if the device supports VK_EXT_shader_stencil_export.
     bool IsExtShaderStencilExportSupported() const {
-        return extensions.shader_stencil_export;
+        return ext_shader_stencil_export;
     }
 
     /// Returns true if the device supports VK_EXT_conservative_rasterization.
     bool IsExtConservativeRasterizationSupported() const {
-        return extensions.conservative_rasterization;
+        return ext_conservative_rasterization;
     }
 
     /// Returns true if the device supports VK_EXT_provoking_vertex.
     bool IsExtProvokingVertexSupported() const {
-        return extensions.provoking_vertex;
+        return ext_provoking_vertex;
     }
 
     /// Returns true if the device supports VK_KHR_shader_atomic_int64.
     bool IsExtShaderAtomicInt64Supported() const {
-        return extensions.shader_atomic_int64;
+        return ext_shader_atomic_int64;
     }
 
     /// Returns the minimum supported version of SPIR-V.
@@ -497,7 +345,7 @@ public:
         if (instance_version >= VK_API_VERSION_1_3) {
             return 0x00010600U;
         }
-        if (extensions.spirv_1_4) {
+        if (khr_spirv_1_4) {
             return 0x00010400U;
         }
         return 0x00010000U;
@@ -515,11 +363,11 @@ public:
 
     /// Returns the vendor name reported from Vulkan.
     std::string_view GetVendorName() const {
-        return properties.driver.driverName;
+        return vendor_name;
     }
 
     /// Returns the list of available extensions.
-    const std::set<std::string, std::less<>>& GetAvailableExtensions() const {
+    const std::vector<std::string>& GetAvailableExtensions() const {
         return supported_extensions;
     }
 
@@ -528,7 +376,7 @@ public:
     }
 
     bool CanReportMemoryUsage() const {
-        return extensions.memory_budget;
+        return ext_memory_budget;
     }
 
     u64 GetDeviceMemoryUsage() const;
@@ -549,30 +397,33 @@ public:
         return must_emulate_bgr565;
     }
 
-    bool HasNullDescriptor() const {
-        return features.robustness2.nullDescriptor;
-    }
-
     u32 GetMaxVertexInputAttributes() const {
-        return properties.properties.limits.maxVertexInputAttributes;
+        return max_vertex_input_attributes;
     }
 
     u32 GetMaxVertexInputBindings() const {
-        return properties.properties.limits.maxVertexInputBindings;
+        return max_vertex_input_bindings;
     }
 
 private:
-    /// Checks if the physical device is suitable and configures the object state
-    /// with all necessary info about its properties.
-    bool GetSuitability(bool requires_swapchain);
+    /// Checks if the physical device is suitable.
+    void CheckSuitability(bool requires_swapchain) const;
 
-    // Remove extensions which have incomplete feature support.
-    void RemoveUnsuitableExtensions();
-    void RemoveExtensionIfUnsuitable(bool is_suitable, const std::string& extension_name);
+    /// Loads extensions into a vector and stores available ones in this object.
+    std::vector<const char*> LoadExtensions(bool requires_surface);
 
     /// Sets up queue families.
     void SetupFamilies(VkSurfaceKHR surface);
 
+    /// Sets up device features.
+    void SetupFeatures();
+
+    /// Sets up device properties.
+    void SetupProperties();
+
+    /// Collects telemetry information from the device.
+    void CollectTelemetryParameters();
+
     /// Collects information about attached tools.
     void CollectToolingInfo();
 
@@ -583,93 +434,90 @@ private:
     std::vector<VkDeviceQueueCreateInfo> GetDeviceQueueCreateInfos() const;
 
     /// Returns true if ASTC textures are natively supported.
-    bool ComputeIsOptimalAstcSupported() const;
+    bool IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) const;
 
     /// Returns true if the device natively supports blitting depth stencil images.
     bool TestDepthStencilBlits() const;
 
-private:
-    VkInstance instance;         ///< Vulkan instance.
-    vk::DeviceDispatch dld;      ///< Device function pointers.
-    vk::PhysicalDevice physical; ///< Physical device.
-    vk::Device logical;          ///< Logical device.
-    vk::Queue graphics_queue;    ///< Main graphics queue.
-    vk::Queue present_queue;     ///< Main present queue.
-    u32 instance_version{};      ///< Vulkan instance version.
-    u32 graphics_family{};       ///< Main graphics queue family index.
-    u32 present_family{};        ///< Main present queue family index.
-
-    struct Extensions {
-#define EXTENSION(prefix, macro_name, var_name) bool var_name{};
-#define FEATURE(prefix, struct_name, macro_name, var_name) bool var_name{};
-
-        FOR_EACH_VK_FEATURE_1_1(FEATURE);
-        FOR_EACH_VK_FEATURE_1_2(FEATURE);
-        FOR_EACH_VK_FEATURE_1_3(FEATURE);
-        FOR_EACH_VK_FEATURE_EXT(FEATURE);
-        FOR_EACH_VK_EXTENSION(EXTENSION);
-        FOR_EACH_VK_EXTENSION_WIN32(EXTENSION);
-
-#undef EXTENSION
-#undef FEATURE
-    };
-
-    struct Features {
-#define FEATURE_CORE(prefix, struct_name, macro_name, var_name)                                    \
-    VkPhysicalDevice##struct_name##Features var_name{};
-#define FEATURE_EXT(prefix, struct_name, macro_name, var_name)                                     \
-    VkPhysicalDevice##struct_name##Features##prefix var_name{};
-
-        FOR_EACH_VK_FEATURE_1_1(FEATURE_CORE);
-        FOR_EACH_VK_FEATURE_1_2(FEATURE_CORE);
-        FOR_EACH_VK_FEATURE_1_3(FEATURE_CORE);
-        FOR_EACH_VK_FEATURE_EXT(FEATURE_EXT);
-
-#undef FEATURE_CORE
-#undef FEATURE_EXT
-
-        VkPhysicalDeviceFeatures features{};
-    };
-
-    struct Properties {
-        VkPhysicalDeviceDriverProperties driver{};
-        VkPhysicalDeviceFloatControlsProperties float_controls{};
-        VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor{};
-        VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
-        VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
-
-        VkPhysicalDeviceProperties properties{};
-    };
-
-    Extensions extensions{};
-    Features features{};
-    Properties properties{};
-
-    VkPhysicalDeviceFeatures2 features2{};
-    VkPhysicalDeviceProperties2 properties2{};
-
-    // Misc features
-    bool is_optimal_astc_supported{};       ///< Support for all guest ASTC formats.
-    bool is_blit_depth_stencil_supported{}; ///< Support for blitting from and to depth stencil.
-    bool is_warp_potentially_bigger{};      ///< Host warp size can be bigger than guest.
-    bool is_integrated{};                   ///< Is GPU an iGPU.
-    bool is_virtual{};                      ///< Is GPU a virtual GPU.
-    bool is_non_gpu{};                      ///< Is SoftwareRasterizer, FPGA, non-GPU device.
-    bool has_broken_cube_compatibility{};   ///< Has broken cube compatiblity bit
-    bool has_renderdoc{};                   ///< Has RenderDoc attached
-    bool has_nsight_graphics{};             ///< Has Nsight Graphics attached
-    bool supports_d24_depth{};              ///< Supports D24 depth buffers.
-    bool cant_blit_msaa{};                  ///< Does not support MSAA<->MSAA blitting.
-    bool must_emulate_bgr565{};             ///< Emulates BGR565 by swizzling RGB565 format.
-    bool dynamic_state3_blending{};         ///< Has all blending features of dynamic_state3.
-    bool dynamic_state3_enables{};          ///< Has all enables features of dynamic_state3.
-    u64 device_access_memory{};             ///< Total size of device local memory in bytes.
-    u32 sets_per_pool{};                    ///< Sets per Description Pool
+    VkInstance instance;                                         ///< Vulkan instance.
+    vk::DeviceDispatch dld;                                      ///< Device function pointers.
+    vk::PhysicalDevice physical;                                 ///< Physical device.
+    VkPhysicalDeviceProperties properties;                       ///< Device properties.
+    VkPhysicalDeviceFloatControlsPropertiesKHR float_controls{}; ///< Float control properties.
+    vk::Device logical;                                          ///< Logical device.
+    vk::Queue graphics_queue;                                    ///< Main graphics queue.
+    vk::Queue present_queue;                                     ///< Main present queue.
+    u32 instance_version{};                                      ///< Vulkan onstance version.
+    u32 graphics_family{};                      ///< Main graphics queue family index.
+    u32 present_family{};                       ///< Main present queue family index.
+    VkDriverIdKHR driver_id{};                  ///< Driver ID.
+    VkShaderStageFlags guest_warp_stages{};     ///< Stages where the guest warp size can be forced.
+    u64 device_access_memory{};                 ///< Total size of device local memory in bytes.
+    u32 max_push_descriptors{};                 ///< Maximum number of push descriptors
+    u32 sets_per_pool{};                        ///< Sets per Description Pool
+    bool is_optimal_astc_supported{};           ///< Support for native ASTC.
+    bool is_float16_supported{};                ///< Support for float16 arithmetic.
+    bool is_int8_supported{};                   ///< Support for int8 arithmetic.
+    bool is_warp_potentially_bigger{};          ///< Host warp size can be bigger than guest.
+    bool is_formatless_image_load_supported{};  ///< Support for shader image read without format.
+    bool is_depth_bounds_supported{};           ///< Support for depth bounds.
+    bool is_shader_float64_supported{};         ///< Support for float64.
+    bool is_shader_int64_supported{};           ///< Support for int64.
+    bool is_shader_int16_supported{};           ///< Support for int16.
+    bool is_shader_storage_image_multisample{}; ///< Support for image operations on MSAA images.
+    bool is_blit_depth_stencil_supported{};     ///< Support for blitting from and to depth stencil.
+    bool is_topology_list_restart_supported{};  ///< Support for primitive restart with list
+                                                ///< topologies.
+    bool is_patch_list_restart_supported{};     ///< Support for primitive restart with list patch.
+    bool is_integrated{};                       ///< Is GPU an iGPU.
+    bool is_virtual{};                          ///< Is GPU a virtual GPU.
+    bool is_non_gpu{};                          ///< Is SoftwareRasterizer, FPGA, non-GPU device.
+    bool nv_viewport_swizzle{};                 ///< Support for VK_NV_viewport_swizzle.
+    bool nv_viewport_array2{};                  ///< Support for VK_NV_viewport_array2.
+    bool nv_geometry_shader_passthrough{};      ///< Support for VK_NV_geometry_shader_passthrough.
+    bool khr_draw_indirect_count{};             ///< Support for VK_KHR_draw_indirect_count.
+    bool khr_uniform_buffer_standard_layout{};  ///< Support for scalar uniform buffer layouts.
+    bool khr_spirv_1_4{};                       ///< Support for VK_KHR_spirv_1_4.
+    bool khr_workgroup_memory_explicit_layout{}; ///< Support for explicit workgroup layouts.
+    bool khr_push_descriptor{};                  ///< Support for VK_KHR_push_descritor.
+    bool khr_pipeline_executable_properties{};   ///< Support for executable properties.
+    bool khr_swapchain_mutable_format{};         ///< Support for VK_KHR_swapchain_mutable_format.
+    bool ext_index_type_uint8{};                 ///< Support for VK_EXT_index_type_uint8.
+    bool ext_sampler_filter_minmax{};            ///< Support for VK_EXT_sampler_filter_minmax.
+    bool ext_depth_clip_control{};               ///< Support for VK_EXT_depth_clip_control
+    bool ext_depth_range_unrestricted{};         ///< Support for VK_EXT_depth_range_unrestricted.
+    bool ext_shader_viewport_index_layer{};    ///< Support for VK_EXT_shader_viewport_index_layer.
+    bool ext_tooling_info{};                   ///< Support for VK_EXT_tooling_info.
+    bool ext_subgroup_size_control{};          ///< Support for VK_EXT_subgroup_size_control.
+    bool ext_transform_feedback{};             ///< Support for VK_EXT_transform_feedback.
+    bool ext_custom_border_color{};            ///< Support for VK_EXT_custom_border_color.
+    bool ext_extended_dynamic_state{};         ///< Support for VK_EXT_extended_dynamic_state.
+    bool ext_extended_dynamic_state_2{};       ///< Support for VK_EXT_extended_dynamic_state2.
+    bool ext_extended_dynamic_state_2_extra{}; ///< Support for VK_EXT_extended_dynamic_state2.
+    bool ext_extended_dynamic_state_3{};       ///< Support for VK_EXT_extended_dynamic_state3.
+    bool ext_extended_dynamic_state_3_blend{}; ///< Support for VK_EXT_extended_dynamic_state3.
+    bool ext_extended_dynamic_state_3_enables{}; ///< Support for VK_EXT_extended_dynamic_state3.
+    bool ext_line_rasterization{};               ///< Support for VK_EXT_line_rasterization.
+    bool ext_vertex_input_dynamic_state{};       ///< Support for VK_EXT_vertex_input_dynamic_state.
+    bool ext_shader_stencil_export{};            ///< Support for VK_EXT_shader_stencil_export.
+    bool ext_shader_atomic_int64{};              ///< Support for VK_KHR_shader_atomic_int64.
+    bool ext_conservative_rasterization{};       ///< Support for VK_EXT_conservative_rasterization.
+    bool ext_provoking_vertex{};                 ///< Support for VK_EXT_provoking_vertex.
+    bool ext_memory_budget{};                    ///< Support for VK_EXT_memory_budget.
+    bool nv_device_diagnostics_config{};         ///< Support for VK_NV_device_diagnostics_config.
+    bool has_broken_cube_compatibility{};        ///< Has broken cube compatiblity bit
+    bool has_renderdoc{};                        ///< Has RenderDoc attached
+    bool has_nsight_graphics{};                  ///< Has Nsight Graphics attached
+    bool supports_d24_depth{};                   ///< Supports D24 depth buffers.
+    bool cant_blit_msaa{};                       ///< Does not support MSAA<->MSAA blitting.
+    bool must_emulate_bgr565{};                  ///< Emulates BGR565 by swizzling RGB565 format.
+    u32 max_vertex_input_attributes{};           ///< Max vertex input attributes in pipeline
+    u32 max_vertex_input_bindings{};             ///< Max vertex input buffers in pipeline
 
     // Telemetry parameters
-    std::set<std::string, std::less<>> supported_extensions; ///< Reported Vulkan extensions.
-    std::set<std::string, std::less<>> loaded_extensions;    ///< Loaded Vulkan extensions.
-    std::vector<size_t> valid_heap_memory;                   ///< Heaps used.
+    std::string vendor_name;                       ///< Device's driver name.
+    std::vector<std::string> supported_extensions; ///< Reported Vulkan extensions.
+    std::vector<size_t> valid_heap_memory;         ///< Heaps used.
 
     /// Format properties dictionary.
     std::unordered_map<VkFormat, VkFormatProperties> format_properties;

src/video_core/vulkan_common/vulkan_instance.cpp

@@ -32,7 +32,7 @@
 namespace Vulkan {
 namespace {
 [[nodiscard]] std::vector<const char*> RequiredExtensions(
-    Core::Frontend::WindowSystemType window_type, bool enable_validation) {
+    Core::Frontend::WindowSystemType window_type, bool enable_debug_utils) {
     std::vector<const char*> extensions;
     extensions.reserve(6);
     switch (window_type) {
@@ -65,7 +65,7 @@ namespace {
     if (window_type != Core::Frontend::WindowSystemType::Headless) {
         extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
     }
-    if (enable_validation) {
+    if (enable_debug_utils) {
         extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
     }
     extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
@@ -95,9 +95,9 @@ namespace {
     return true;
 }
 
-[[nodiscard]] std::vector<const char*> Layers(bool enable_validation) {
+[[nodiscard]] std::vector<const char*> Layers(bool enable_layers) {
     std::vector<const char*> layers;
-    if (enable_validation) {
+    if (enable_layers) {
         layers.push_back("VK_LAYER_KHRONOS_validation");
     }
     return layers;
@@ -125,7 +125,7 @@ void RemoveUnavailableLayers(const vk::InstanceDispatch& dld, std::vector<const
 
 vk::Instance CreateInstance(const Common::DynamicLibrary& library, vk::InstanceDispatch& dld,
                             u32 required_version, Core::Frontend::WindowSystemType window_type,
-                            bool enable_validation) {
+                            bool enable_debug_utils, bool enable_layers) {
     if (!library.IsOpen()) {
         LOG_ERROR(Render_Vulkan, "Vulkan library not available");
         throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
@@ -138,11 +138,11 @@ vk::Instance CreateInstance(const Common::DynamicLibrary& library, vk::InstanceD
         LOG_ERROR(Render_Vulkan, "Failed to load Vulkan function pointers");
         throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
     }
-    const std::vector<const char*> extensions = RequiredExtensions(window_type, enable_validation);
+    const std::vector<const char*> extensions = RequiredExtensions(window_type, enable_debug_utils);
     if (!AreExtensionsSupported(dld, extensions)) {
         throw vk::Exception(VK_ERROR_EXTENSION_NOT_PRESENT);
     }
-    std::vector<const char*> layers = Layers(enable_validation);
+    std::vector<const char*> layers = Layers(enable_layers);
     RemoveUnavailableLayers(dld, layers);
 
     const u32 available_version = vk::AvailableVersion(dld);

src/video_core/vulkan_common/vulkan_instance.h

@@ -17,7 +17,8 @@ namespace Vulkan {
  * @param dld                Dispatch table to load function pointers into
  * @param required_version   Required Vulkan version (for example, VK_API_VERSION_1_1)
  * @param window_type        Window system type's enabled extension
- * @param enable_validation  Whether to enable Vulkan validation layers or not
+ * @param enable_debug_utils Whether to enable VK_EXT_debug_utils_extension_name or not
+ * @param enable_layers      Whether to enable Vulkan validation layers or not
  *
  * @return A new Vulkan instance
  * @throw vk::Exception on failure
@@ -25,6 +26,6 @@ namespace Vulkan {
 [[nodiscard]] vk::Instance CreateInstance(
     const Common::DynamicLibrary& library, vk::InstanceDispatch& dld, u32 required_version,
     Core::Frontend::WindowSystemType window_type = Core::Frontend::WindowSystemType::Headless,
-    bool enable_validation = false);
+    bool enable_debug_utils = false, bool enable_layers = false);
 
 } // namespace Vulkan

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -152,7 +152,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCreateGraphicsPipelines);
     X(vkCreateImage);
     X(vkCreateImageView);
-    X(vkCreatePipelineCache);
     X(vkCreatePipelineLayout);
     X(vkCreateQueryPool);
     X(vkCreateRenderPass);
@@ -172,7 +171,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkDestroyImage);
     X(vkDestroyImageView);
     X(vkDestroyPipeline);
-    X(vkDestroyPipelineCache);
     X(vkDestroyPipelineLayout);
     X(vkDestroyQueryPool);
     X(vkDestroyRenderPass);
@@ -190,7 +188,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkGetEventStatus);
     X(vkGetFenceStatus);
     X(vkGetImageMemoryRequirements);
-    X(vkGetPipelineCacheData);
     X(vkGetMemoryFdKHR);
 #ifdef _WIN32
     X(vkGetMemoryWin32HandleKHR);
@@ -434,10 +431,6 @@ void Destroy(VkDevice device, VkPipeline handle, const DeviceDispatch& dld) noex
     dld.vkDestroyPipeline(device, handle, nullptr);
 }
 
-void Destroy(VkDevice device, VkPipelineCache handle, const DeviceDispatch& dld) noexcept {
-    dld.vkDestroyPipelineCache(device, handle, nullptr);
-}
-
 void Destroy(VkDevice device, VkPipelineLayout handle, const DeviceDispatch& dld) noexcept {
     dld.vkDestroyPipelineLayout(device, handle, nullptr);
 }
@@ -658,10 +651,6 @@ void ShaderModule::SetObjectNameEXT(const char* name) const {
     SetObjectName(dld, owner, handle, VK_OBJECT_TYPE_SHADER_MODULE, name);
 }
 
-void PipelineCache::SetObjectNameEXT(const char* name) const {
-    SetObjectName(dld, owner, handle, VK_OBJECT_TYPE_PIPELINE_CACHE, name);
-}
-
 void Semaphore::SetObjectNameEXT(const char* name) const {
     SetObjectName(dld, owner, handle, VK_OBJECT_TYPE_SEMAPHORE, name);
 }
@@ -757,29 +746,21 @@ DescriptorSetLayout Device::CreateDescriptorSetLayout(
     return DescriptorSetLayout(object, handle, *dld);
 }
 
-PipelineCache Device::CreatePipelineCache(const VkPipelineCacheCreateInfo& ci) const {
-    VkPipelineCache cache;
-    Check(dld->vkCreatePipelineCache(handle, &ci, nullptr, &cache));
-    return PipelineCache(cache, handle, *dld);
-}
-
 PipelineLayout Device::CreatePipelineLayout(const VkPipelineLayoutCreateInfo& ci) const {
     VkPipelineLayout object;
     Check(dld->vkCreatePipelineLayout(handle, &ci, nullptr, &object));
     return PipelineLayout(object, handle, *dld);
 }
 
-Pipeline Device::CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci,
-                                        VkPipelineCache cache) const {
+Pipeline Device::CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci) const {
     VkPipeline object;
-    Check(dld->vkCreateGraphicsPipelines(handle, cache, 1, &ci, nullptr, &object));
+    Check(dld->vkCreateGraphicsPipelines(handle, nullptr, 1, &ci, nullptr, &object));
     return Pipeline(object, handle, *dld);
 }
 
-Pipeline Device::CreateComputePipeline(const VkComputePipelineCreateInfo& ci,
-                                       VkPipelineCache cache) const {
+Pipeline Device::CreateComputePipeline(const VkComputePipelineCreateInfo& ci) const {
     VkPipeline object;
-    Check(dld->vkCreateComputePipelines(handle, cache, 1, &ci, nullptr, &object));
+    Check(dld->vkCreateComputePipelines(handle, nullptr, 1, &ci, nullptr, &object));
     return Pipeline(object, handle, *dld);
 }
 

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -270,7 +270,6 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines{};
     PFN_vkCreateImage vkCreateImage{};
     PFN_vkCreateImageView vkCreateImageView{};
-    PFN_vkCreatePipelineCache vkCreatePipelineCache{};
     PFN_vkCreatePipelineLayout vkCreatePipelineLayout{};
     PFN_vkCreateQueryPool vkCreateQueryPool{};
     PFN_vkCreateRenderPass vkCreateRenderPass{};
@@ -290,7 +289,6 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkDestroyImage vkDestroyImage{};
     PFN_vkDestroyImageView vkDestroyImageView{};
     PFN_vkDestroyPipeline vkDestroyPipeline{};
-    PFN_vkDestroyPipelineCache vkDestroyPipelineCache{};
     PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout{};
     PFN_vkDestroyQueryPool vkDestroyQueryPool{};
     PFN_vkDestroyRenderPass vkDestroyRenderPass{};
@@ -308,7 +306,6 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkGetEventStatus vkGetEventStatus{};
     PFN_vkGetFenceStatus vkGetFenceStatus{};
     PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements{};
-    PFN_vkGetPipelineCacheData vkGetPipelineCacheData{};
     PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR{};
 #ifdef _WIN32
     PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR{};
@@ -354,7 +351,6 @@ void Destroy(VkDevice, VkFramebuffer, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkImage, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkImageView, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkPipeline, const DeviceDispatch&) noexcept;
-void Destroy(VkDevice, VkPipelineCache, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkPipelineLayout, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkQueryPool, const DeviceDispatch&) noexcept;
 void Destroy(VkDevice, VkRenderPass, const DeviceDispatch&) noexcept;
@@ -777,18 +773,6 @@ public:
     void SetObjectNameEXT(const char* name) const;
 };
 
-class PipelineCache : public Handle<VkPipelineCache, VkDevice, DeviceDispatch> {
-    using Handle<VkPipelineCache, VkDevice, DeviceDispatch>::Handle;
-
-public:
-    /// Set object name.
-    void SetObjectNameEXT(const char* name) const;
-
-    VkResult Read(size_t* size, void* data) const noexcept {
-        return dld->vkGetPipelineCacheData(owner, handle, size, data);
-    }
-};
-
 class Semaphore : public Handle<VkSemaphore, VkDevice, DeviceDispatch> {
     using Handle<VkSemaphore, VkDevice, DeviceDispatch>::Handle;
 
@@ -860,15 +844,11 @@ public:
 
     DescriptorSetLayout CreateDescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo& ci) const;
 
-    PipelineCache CreatePipelineCache(const VkPipelineCacheCreateInfo& ci) const;
-
     PipelineLayout CreatePipelineLayout(const VkPipelineLayoutCreateInfo& ci) const;
 
-    Pipeline CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci,
-                                    VkPipelineCache cache = nullptr) const;
+    Pipeline CreateGraphicsPipeline(const VkGraphicsPipelineCreateInfo& ci) const;
 
-    Pipeline CreateComputePipeline(const VkComputePipelineCreateInfo& ci,
-                                   VkPipelineCache cache = nullptr) const;
+    Pipeline CreateComputePipeline(const VkComputePipelineCreateInfo& ci) const;
 
     Sampler CreateSampler(const VkSamplerCreateInfo& ci) const;
 

src/yuzu/Info.plist

@@ -34,8 +34,6 @@ SPDX-License-Identifier: GPL-2.0-or-later
     <string></string>
     <key>CSResourcesFileMapped</key>
     <true/>
-    <key>LSApplicationCategoryType</key>
-    <string>public.app-category.games</string>
     <key>LSRequiresCarbon</key>
     <true/>
     <key>NSHumanReadableCopyright</key>

src/yuzu/configuration/config.cpp

@@ -690,7 +690,6 @@ void Config::ReadRendererValues() {
     qt_config->beginGroup(QStringLiteral("Renderer"));
 
     ReadGlobalSetting(Settings::values.renderer_backend);
-    ReadGlobalSetting(Settings::values.renderer_force_max_clock);
     ReadGlobalSetting(Settings::values.vulkan_device);
     ReadGlobalSetting(Settings::values.fullscreen_mode);
     ReadGlobalSetting(Settings::values.aspect_ratio);
@@ -710,7 +709,6 @@ void Config::ReadRendererValues() {
     ReadGlobalSetting(Settings::values.use_asynchronous_shaders);
     ReadGlobalSetting(Settings::values.use_fast_gpu_time);
     ReadGlobalSetting(Settings::values.use_pessimistic_flushes);
-    ReadGlobalSetting(Settings::values.use_vulkan_driver_pipeline_cache);
     ReadGlobalSetting(Settings::values.bg_red);
     ReadGlobalSetting(Settings::values.bg_green);
     ReadGlobalSetting(Settings::values.bg_blue);
@@ -1307,9 +1305,6 @@ void Config::SaveRendererValues() {
                  static_cast<u32>(Settings::values.renderer_backend.GetValue(global)),
                  static_cast<u32>(Settings::values.renderer_backend.GetDefault()),
                  Settings::values.renderer_backend.UsingGlobal());
-    WriteSetting(QString::fromStdString(Settings::values.renderer_force_max_clock.GetLabel()),
-                 static_cast<u32>(Settings::values.renderer_force_max_clock.GetValue(global)),
-                 static_cast<u32>(Settings::values.renderer_force_max_clock.GetDefault()));
     WriteGlobalSetting(Settings::values.vulkan_device);
     WriteSetting(QString::fromStdString(Settings::values.fullscreen_mode.GetLabel()),
                  static_cast<u32>(Settings::values.fullscreen_mode.GetValue(global)),
@@ -1353,7 +1348,6 @@ void Config::SaveRendererValues() {
     WriteGlobalSetting(Settings::values.use_asynchronous_shaders);
     WriteGlobalSetting(Settings::values.use_fast_gpu_time);
     WriteGlobalSetting(Settings::values.use_pessimistic_flushes);
-    WriteGlobalSetting(Settings::values.use_vulkan_driver_pipeline_cache);
     WriteGlobalSetting(Settings::values.bg_red);
     WriteGlobalSetting(Settings::values.bg_green);
     WriteGlobalSetting(Settings::values.bg_blue);

src/yuzu/configuration/configure_graphics_advanced.cpp

@@ -25,13 +25,10 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
     ui->use_asynchronous_shaders->setEnabled(runtime_lock);
     ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
 
-    ui->renderer_force_max_clock->setChecked(Settings::values.renderer_force_max_clock.GetValue());
     ui->use_vsync->setChecked(Settings::values.use_vsync.GetValue());
     ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());
     ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
     ui->use_pessimistic_flushes->setChecked(Settings::values.use_pessimistic_flushes.GetValue());
-    ui->use_vulkan_driver_pipeline_cache->setChecked(
-        Settings::values.use_vulkan_driver_pipeline_cache.GetValue());
 
     if (Settings::IsConfiguringGlobal()) {
         ui->gpu_accuracy->setCurrentIndex(
@@ -40,8 +37,6 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
             Settings::values.max_anisotropy.GetValue());
     } else {
         ConfigurationShared::SetPerGameSetting(ui->gpu_accuracy, &Settings::values.gpu_accuracy);
-        ConfigurationShared::SetPerGameSetting(ui->renderer_force_max_clock,
-                                               &Settings::values.renderer_force_max_clock);
         ConfigurationShared::SetPerGameSetting(ui->anisotropic_filtering_combobox,
                                                &Settings::values.max_anisotropy);
         ConfigurationShared::SetHighlight(ui->label_gpu_accuracy,
@@ -53,9 +48,6 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
 
 void ConfigureGraphicsAdvanced::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.gpu_accuracy, ui->gpu_accuracy);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.renderer_force_max_clock,
-                                             ui->renderer_force_max_clock,
-                                             renderer_force_max_clock);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
                                              ui->anisotropic_filtering_combobox);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync, use_vsync);
@@ -66,9 +58,6 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
                                              ui->use_fast_gpu_time, use_fast_gpu_time);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_pessimistic_flushes,
                                              ui->use_pessimistic_flushes, use_pessimistic_flushes);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vulkan_driver_pipeline_cache,
-                                             ui->use_vulkan_driver_pipeline_cache,
-                                             use_vulkan_driver_pipeline_cache);
 }
 
 void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {
@@ -87,25 +76,18 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
     // Disable if not global (only happens during game)
     if (Settings::IsConfiguringGlobal()) {
         ui->gpu_accuracy->setEnabled(Settings::values.gpu_accuracy.UsingGlobal());
-        ui->renderer_force_max_clock->setEnabled(
-            Settings::values.renderer_force_max_clock.UsingGlobal());
         ui->use_vsync->setEnabled(Settings::values.use_vsync.UsingGlobal());
         ui->use_asynchronous_shaders->setEnabled(
             Settings::values.use_asynchronous_shaders.UsingGlobal());
         ui->use_fast_gpu_time->setEnabled(Settings::values.use_fast_gpu_time.UsingGlobal());
         ui->use_pessimistic_flushes->setEnabled(
             Settings::values.use_pessimistic_flushes.UsingGlobal());
-        ui->use_vulkan_driver_pipeline_cache->setEnabled(
-            Settings::values.use_vulkan_driver_pipeline_cache.UsingGlobal());
         ui->anisotropic_filtering_combobox->setEnabled(
             Settings::values.max_anisotropy.UsingGlobal());
 
         return;
     }
 
-    ConfigurationShared::SetColoredTristate(ui->renderer_force_max_clock,
-                                            Settings::values.renderer_force_max_clock,
-                                            renderer_force_max_clock);
     ConfigurationShared::SetColoredTristate(ui->use_vsync, Settings::values.use_vsync, use_vsync);
     ConfigurationShared::SetColoredTristate(ui->use_asynchronous_shaders,
                                             Settings::values.use_asynchronous_shaders,
@@ -115,9 +97,6 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
     ConfigurationShared::SetColoredTristate(ui->use_pessimistic_flushes,
                                             Settings::values.use_pessimistic_flushes,
                                             use_pessimistic_flushes);
-    ConfigurationShared::SetColoredTristate(ui->use_vulkan_driver_pipeline_cache,
-                                            Settings::values.use_vulkan_driver_pipeline_cache,
-                                            use_vulkan_driver_pipeline_cache);
     ConfigurationShared::SetColoredComboBox(
         ui->gpu_accuracy, ui->label_gpu_accuracy,
         static_cast<int>(Settings::values.gpu_accuracy.GetValue(true)));

src/yuzu/configuration/configure_graphics_advanced.h

@@ -36,12 +36,10 @@ private:
 
     std::unique_ptr<Ui::ConfigureGraphicsAdvanced> ui;
 
-    ConfigurationShared::CheckState renderer_force_max_clock;
     ConfigurationShared::CheckState use_vsync;
     ConfigurationShared::CheckState use_asynchronous_shaders;
     ConfigurationShared::CheckState use_fast_gpu_time;
     ConfigurationShared::CheckState use_pessimistic_flushes;
-    ConfigurationShared::CheckState use_vulkan_driver_pipeline_cache;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_graphics_advanced.ui

@@ -69,16 +69,6 @@
           </layout>
          </widget>
         </item>
-        <item>
-         <widget class="QCheckBox" name="renderer_force_max_clock">
-          <property name="toolTip">
-           <string>Runs work in the background while waiting for graphics commands to keep the GPU from lowering its clock speed.</string>
-          </property>
-          <property name="text">
-           <string>Force maximum clocks (Vulkan only)</string>
-          </property>
-         </widget>
-        </item>
         <item>
          <widget class="QCheckBox" name="use_vsync">
           <property name="toolTip">
@@ -119,16 +109,6 @@
           </property>
          </widget>
         </item>
-        <item>
-         <widget class="QCheckBox" name="use_vulkan_driver_pipeline_cache">
-          <property name="toolTip">
-            <string>Enables GPU vendor-specific pipeline cache. This option can improve shader loading time significantly in cases where the Vulkan driver does not store pipeline cache files internally.</string>
-          </property>
-          <property name="text">
-           <string>Use Vulkan pipeline cache</string>
-          </property>
-         </widget>
-        </item>
         <item>
          <widget class="QWidget" name="af_layout" native="true">
           <layout class="QHBoxLayout" name="horizontalLayout_1">

src/yuzu/main.cpp

@@ -1839,11 +1839,9 @@ void GMainWindow::OnEmulationStopTimeExpired() {
 
 void GMainWindow::OnEmulationStopped() {
     shutdown_timer.stop();
-    if (emu_thread) {
-        emu_thread->disconnect();
-        emu_thread->wait();
-        emu_thread.reset();
-    }
+    emu_thread->disconnect();
+    emu_thread->wait();
+    emu_thread = nullptr;
 
     if (shutdown_dialog) {
         shutdown_dialog->deleteLater();
@@ -2231,10 +2229,8 @@ void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget targ
     }
 
     switch (target) {
-    case GameListRemoveTarget::VkShaderCache:
-        RemoveVulkanDriverPipelineCache(program_id);
-        [[fallthrough]];
     case GameListRemoveTarget::GlShaderCache:
+    case GameListRemoveTarget::VkShaderCache:
         RemoveTransferableShaderCache(program_id, target);
         break;
     case GameListRemoveTarget::AllShaderCache:
@@ -2275,22 +2271,6 @@ void GMainWindow::RemoveTransferableShaderCache(u64 program_id, GameListRemoveTa
     }
 }
 
-void GMainWindow::RemoveVulkanDriverPipelineCache(u64 program_id) {
-    static constexpr std::string_view target_file_name = "vulkan_pipelines.bin";
-
-    const auto shader_cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir);
-    const auto shader_cache_folder_path = shader_cache_dir / fmt::format("{:016x}", program_id);
-    const auto target_file = shader_cache_folder_path / target_file_name;
-
-    if (!Common::FS::Exists(target_file)) {
-        return;
-    }
-    if (!Common::FS::RemoveFile(target_file)) {
-        QMessageBox::warning(this, tr("Error Removing Vulkan Driver Pipeline Cache"),
-                             tr("Failed to remove the driver pipeline cache."));
-    }
-}
-
 void GMainWindow::RemoveAllTransferableShaderCaches(u64 program_id) {
     const auto shader_cache_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir);
     const auto program_shader_cache_dir = shader_cache_dir / fmt::format("{:016x}", program_id);
@@ -3031,8 +3011,6 @@ void GMainWindow::OnStopGame() {
 
     if (OnShutdownBegin()) {
         OnShutdownBeginDialog();
-    } else {
-        OnEmulationStopped();
     }
 }
 

src/yuzu/main.h

@@ -347,7 +347,6 @@ private:
     void RemoveUpdateContent(u64 program_id, InstalledEntryType type);
     void RemoveAddOnContent(u64 program_id, InstalledEntryType type);
     void RemoveTransferableShaderCache(u64 program_id, GameListRemoveTarget target);
-    void RemoveVulkanDriverPipelineCache(u64 program_id);
     void RemoveAllTransferableShaderCaches(u64 program_id);
     void RemoveCustomConfiguration(u64 program_id, const std::string& game_path);
     std::optional<u64> SelectRomFSDumpTarget(const FileSys::ContentProvider&, u64 program_id);

src/yuzu_cmd/config.cpp

@@ -296,7 +296,6 @@ void Config::ReadValues() {
 
     // Renderer
     ReadSetting("Renderer", Settings::values.renderer_backend);
-    ReadSetting("Renderer", Settings::values.renderer_force_max_clock);
     ReadSetting("Renderer", Settings::values.renderer_debug);
     ReadSetting("Renderer", Settings::values.renderer_shader_feedback);
     ReadSetting("Renderer", Settings::values.enable_nsight_aftermath);
@@ -322,7 +321,6 @@ void Config::ReadValues() {
     ReadSetting("Renderer", Settings::values.accelerate_astc);
     ReadSetting("Renderer", Settings::values.use_fast_gpu_time);
     ReadSetting("Renderer", Settings::values.use_pessimistic_flushes);
-    ReadSetting("Renderer", Settings::values.use_vulkan_driver_pipeline_cache);
 
     ReadSetting("Renderer", Settings::values.bg_red);
     ReadSetting("Renderer", Settings::values.bg_green);

vcpkg.json

@@ -40,7 +40,7 @@
     "overrides": [
         {
             "name": "catch2",
-            "version": "2.13.9"
+            "version": "3.0.1"
         },
         {
             "name": "fmt",