Another take

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/IntSetting.kt

@@ -20,6 +20,7 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
     RENDERER_ACCURACY("gpu_accuracy"),
     RENDERER_RESOLUTION("resolution_setup"),
     RENDERER_FRAME_GEN_MULTIPLIER("frame_gen_multiplier"),
+    RENDERER_FRAME_GEN_TARGET_RATE("frame_gen_target_rate"),
     RENDERER_FRAME_GEN_QUEUE_TARGET("frame_gen_queue_target"),
     RENDERER_FRAME_GEN_FLOW_SCALE("frame_gen_flow_scale"),
     RENDERER_VSYNC("use_vsync"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -99,6 +99,7 @@ abstract class SettingsItem(
         private val frameGenKeys = setOf(
             BooleanSetting.RENDERER_FRAME_GEN.key,
             IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key,
+            IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key,
             IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET.key,
             BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.key,
             IntSetting.RENDERER_FRAME_GEN_FLOW_SCALE.key,
@@ -640,6 +641,15 @@ abstract class SettingsItem(
                     valuesId = R.array.frameGenMultiplierValues
                 )
             )
+            put(
+                SingleChoiceSetting(
+                    IntSetting.RENDERER_FRAME_GEN_TARGET_RATE,
+                    titleId = R.string.frame_gen_target_rate,
+                    descriptionId = R.string.frame_gen_target_rate_description,
+                    choicesId = R.array.frameGenTargetRateNames,
+                    valuesId = R.array.frameGenTargetRateValues
+                )
+            )
             put(
                 SingleChoiceSetting(
                     IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -125,7 +125,13 @@ class SettingsFragmentPresenter(
             add(HeaderSetting(R.string.frame_gen))
 
             add(BooleanSetting.RENDERER_FRAME_GEN.key)
-            add(IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key)
+            add(IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key)
+            if (IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.getInt(
+                    getNeedsGlobalForKey(IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key)
+                ) == 0
+            ) {
+                add(IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key)
+            }
             add(IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET.key)
             add(BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.key)
             if (!BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.getBoolean(

src/android/app/src/main/res/values/arrays.xml

@@ -174,6 +174,24 @@
         <item>4</item>
     </integer-array>
 
+    <string-array name="frameGenTargetRateNames">
+        <item>@string/frame_gen_target_rate_off</item>
+        <item>@string/frame_gen_target_rate_60</item>
+        <item>@string/frame_gen_target_rate_90</item>
+        <item>@string/frame_gen_target_rate_120</item>
+        <item>@string/frame_gen_target_rate_144</item>
+        <item>@string/frame_gen_target_rate_165</item>
+    </string-array>
+
+    <integer-array name="frameGenTargetRateValues">
+        <item>0</item>
+        <item>60</item>
+        <item>90</item>
+        <item>120</item>
+        <item>144</item>
+        <item>165</item>
+    </integer-array>
+
     <string-array name="frameGenQueueTargetNames">
         <item>@string/frame_gen_queue_target_0</item>
         <item>@string/frame_gen_queue_target_1</item>

src/android/app/src/main/res/values/strings.xml

@@ -306,6 +306,14 @@
     <string name="frame_gen_multiplier_2x">2x</string>
     <string name="frame_gen_multiplier_3x">3x</string>
     <string name="frame_gen_multiplier_4x">4x</string>
+    <string name="frame_gen_target_rate">Target frame rate</string>
+    <string name="frame_gen_target_rate_description">Pick the rate your display can actually show. The multiplier then rises or falls on its own to hold it, and rolls back any step that makes the game itself run slower.</string>
+    <string name="frame_gen_target_rate_off">Off (use a fixed multiplier)</string>
+    <string name="frame_gen_target_rate_60">60 FPS</string>
+    <string name="frame_gen_target_rate_90">90 FPS</string>
+    <string name="frame_gen_target_rate_120">120 FPS</string>
+    <string name="frame_gen_target_rate_144">144 FPS</string>
+    <string name="frame_gen_target_rate_165">165 FPS</string>
     <string name="frame_gen_queue_target">Frame queue target</string>
     <string name="frame_gen_queue_target_description">How many finished frames may wait ahead of the display. Larger queues absorb GPU spikes at the cost of input latency.</string>
     <string name="frame_gen_queue_target_0">Unbuffered (lowest latency)</string>

src/common/settings.cpp

@@ -392,6 +392,16 @@ size_t FrameGenGenerations() {
     return FrameGenMultiplier() - 1;
 }
 
+size_t FrameGenMaxGenerations() {
+    if (!values.frame_gen.GetValue()) {
+        return 0;
+    }
+    if (values.frame_gen_target_rate.GetValue() != 0) {
+        return MAX_FRAME_GEN_MULTIPLIER - 1;
+    }
+    return FrameGenMultiplier() - 1;
+}
+
 void RestoreGlobalState(bool is_powered_on) {
     // If a game is running, DO NOT restore the global settings state
     if (is_powered_on) {

src/common/settings.h

@@ -402,6 +402,17 @@ struct Values {
                                                       false,
                                                       &frame_gen};
 
+    SwitchableSetting<u32, true> frame_gen_target_rate{linkage,
+                                                       0,
+                                                       0,
+                                                       240,
+                                                       "frame_gen_target_rate",
+                                                       Category::Renderer,
+                                                       Specialization::Countable,
+                                                       true,
+                                                       true,
+                                                       &frame_gen};
+
     SwitchableSetting<bool> frame_gen_flow_scale_auto{linkage,
                                                       true,
                                                       "frame_gen_flow_scale_auto",
@@ -934,6 +945,8 @@ constexpr u32 MAX_FRAME_GEN_MULTIPLIER = 4;
 
 [[nodiscard]] size_t FrameGenGenerations();
 
+[[nodiscard]] size_t FrameGenMaxGenerations();
+
 bool getDebugKnobAt(u8 i);
 
 void UpdateGPUAccuracy();

src/video_core/CMakeLists.txt

@@ -127,6 +127,8 @@ add_library(video_core STATIC
     renderer_vulkan/present/filters.h
     renderer_vulkan/present/frame_gen.cpp
     renderer_vulkan/present/frame_gen.h
+    renderer_vulkan/present/frame_gen_pacer.cpp
+    renderer_vulkan/present/frame_gen_pacer.h
     renderer_vulkan/present/lsfg_alpha.cpp
     renderer_vulkan/present/lsfg_alpha.h
     renderer_vulkan/present/lsfg_beta.cpp

src/video_core/renderer_vulkan/present/frame_gen.cpp

@@ -21,6 +21,7 @@ namespace {
 
 constexpr size_t COLOR_CHANNELS = 4;
 constexpr u64 LSFG_REQUIRED_FRAMES = 2;
+constexpr u32 LSFG_RECURRENCE_FRAMES = 2;
 
 [[nodiscard]] f32 ManualFlowScale() {
     return static_cast<f32>(Settings::values.frame_gen_flow_scale.GetValue()) / 100.0f;
@@ -43,10 +44,6 @@ constexpr u64 LSFG_REQUIRED_FRAMES = 2;
     return std::clamp(stepped, 0.25f, 1.0f);
 }
 
-[[nodiscard]] size_t ConfiguredGenerations() {
-    return Settings::FrameGenGenerations();
-}
-
 bool IsBlueFirst(VkFormat format) {
     return format == VK_FORMAT_B8G8R8A8_UNORM || format == VK_FORMAT_B8G8R8A8_SRGB;
 }
@@ -197,15 +194,16 @@ FrameGen::FrameGen(MemoryAllocator& memory_allocator_, Scheduler& scheduler_)
 
 FrameGen::~FrameGen() = default;
 
-void FrameGen::Process(const Device& device, Frame* frame, VkFormat format, VkExtent2D guest_extent,
-                       bool generate) {
+void FrameGen::Process(const Device& device, Frame* frame, VkFormat format,
+                       VkExtent2D guest_extent) {
     generated = false;
 
-    if (unavailable || ConfiguredGenerations() == 0) {
+    if (unavailable || !Settings::values.frame_gen.GetValue()) {
         if (chain) {
             scheduler.Finish();
             chain.reset();
         }
+        warm_streak = 0;
         return;
     }
 
@@ -234,12 +232,15 @@ void FrameGen::Process(const Device& device, Frame* frame, VkFormat format, VkEx
 
     const u64 count = frame_count++;
     last_count = count;
-    last_generations = ConfiguredGenerations();
-    generated = generate && count + 1 >= LSFG_REQUIRED_FRAMES;
+    last_generations = plan.generations;
+
+    const bool warm = plan.warm && count + 1 >= LSFG_REQUIRED_FRAMES;
+    warm_streak = warm ? warm_streak + 1 : 0;
+    generated = warm && warm_streak >= LSFG_RECURRENCE_FRAMES && plan.generations > 0;
 
     scheduler.RequestOutsideRenderPassOperationContext();
     scheduler.Record([this, source = *frame->image, extent, count,
-                      dispatch = generated](vk::CommandBuffer cmdbuf) {
+                      dispatch = warm](vk::CommandBuffer cmdbuf) {
         CopyPresentedFrame(cmdbuf, source, chain->Input(count), extent);
         if (dispatch) {
             chain->DispatchShared(cmdbuf, count);
@@ -255,11 +256,13 @@ void FrameGen::Process(const Device& device, Frame* frame, VkFormat format, VkEx
     }
 }
 
-size_t FrameGen::WantedGenerations() const {
+size_t FrameGen::WantedGenerations(size_t capacity) {
     if (unavailable) {
+        plan = {};
         return 0;
     }
-    return ConfiguredGenerations();
+    plan = pacer.Plan(capacity);
+    return plan.generations;
 }
 
 size_t FrameGen::GeneratedFrameCount() const {
@@ -291,6 +294,7 @@ void FrameGen::Rebuild(const Device& device, VkExtent2D extent, VkFormat format,
     built_extent = extent;
     built_format = format;
     frame_count = 0;
+    warm_streak = 0;
     generated = false;
 }
 

src/video_core/renderer_vulkan/present/frame_gen.h

@@ -6,6 +6,7 @@
 #include <optional>
 
 #include "common/common_types.h"
+#include "video_core/renderer_vulkan/present/frame_gen_pacer.h"
 #include "video_core/renderer_vulkan/present/lsfg_chain.h"
 #include "video_core/renderer_vulkan/present/lsfg_shaders.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
@@ -21,10 +22,9 @@ public:
     explicit FrameGen(MemoryAllocator& memory_allocator, Scheduler& scheduler);
     ~FrameGen();
 
-    void Process(const Device& device, Frame* frame, VkFormat format, VkExtent2D guest_extent,
-                 bool generate);
+    void Process(const Device& device, Frame* frame, VkFormat format, VkExtent2D guest_extent);
 
-    [[nodiscard]] size_t WantedGenerations() const;
+    [[nodiscard]] size_t WantedGenerations(size_t capacity);
 
     [[nodiscard]] size_t GeneratedFrameCount() const;
 
@@ -39,6 +39,8 @@ private:
 
     std::optional<LsfgShaders> shaders;
     std::optional<LsfgChain> chain;
+    FrameGenPacer pacer;
+    FrameGenPlan plan{};
     VkExtent2D peak_guest_extent{};
     VkExtent2D built_extent{};
     VkFormat built_format{VK_FORMAT_UNDEFINED};
@@ -46,6 +48,7 @@ private:
     u64 frame_count{};
     u64 last_count{};
     size_t last_generations{};
+    u32 warm_streak{};
     bool generated{};
     bool unavailable{};
     bool dumped{};

src/video_core/renderer_vulkan/present/frame_gen_pacer.cpp

@@ -0,0 +1,240 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <algorithm>
+#include <cmath>
+#include <utility>
+
+#include "common/settings.h"
+#include "video_core/renderer_vulkan/present/frame_gen_pacer.h"
+
+namespace Vulkan {
+
+namespace {
+
+using Clock = std::chrono::steady_clock;
+
+constexpr f32 INTERVAL_SMOOTHING = 0.25f;
+constexpr f32 MINIMUM_BASE_RATE = 10.0f;
+constexpr f32 BURST_CADENCE_RATIO = 3.0f;
+constexpr f32 BURST_TARGET_RATIO = 2.0f;
+constexpr f32 PROBE_THROUGHPUT_TOLERANCE = 0.95f;
+constexpr f32 PROBE_BASE_COLLAPSE_RATIO = 0.70f;
+constexpr f32 PROBE_MARGINAL_GAIN = 1.15f;
+constexpr f32 TARGET_SATISFIED_RATIO = 0.95f;
+constexpr f32 UNLOADED_BASE_RETENTION = 0.75f;
+constexpr f32 CREDIT_EPSILON = 1.0e-4f;
+constexpr u32 MAX_PROBE_FAILURES = 4;
+
+constexpr auto STABILIZATION_DURATION = std::chrono::seconds(1);
+constexpr auto PROBE_DURATION = std::chrono::seconds(1);
+constexpr auto DEFICIT_DURATION = std::chrono::seconds(1);
+constexpr auto PROBE_STEP_DELAY = std::chrono::milliseconds(250);
+
+[[nodiscard]] Clock::duration ProbeBackoff(u32 failures) {
+    switch (failures) {
+    case 1:
+        return std::chrono::seconds(5);
+    case 2:
+        return std::chrono::seconds(15);
+    case 3:
+        return std::chrono::seconds(30);
+    default:
+        return std::chrono::seconds(60);
+    }
+}
+
+} // Anonymous namespace
+
+FrameGenPlan FrameGenPacer::Plan(size_t capacity) {
+    const size_t ceiling = std::min(capacity, Settings::FrameGenMaxGenerations());
+    if (ceiling == 0) {
+        Reset();
+        return {};
+    }
+
+    const Clock::time_point now = Clock::now();
+    const size_t previous_generations = std::exchange(issued_generations, 0);
+    if (!last_frame) {
+        last_frame = now;
+        return {};
+    }
+
+    const Clock::duration interval = now - *last_frame;
+    const f32 interval_seconds = std::chrono::duration<f32>(interval).count();
+    last_frame = now;
+
+    if (interval_seconds <= 0.0f) {
+        Stabilize(now);
+        return {};
+    }
+
+    const f32 target_rate = static_cast<f32>(Settings::values.frame_gen_target_rate.GetValue());
+
+    if (smoothed_interval > 0.0f) {
+        f32 burst_threshold = BURST_CADENCE_RATIO / smoothed_interval;
+        if (target_rate > 0.0f) {
+            burst_threshold = std::max(burst_threshold, target_rate * BURST_TARGET_RATIO);
+        }
+        if (1.0f / interval_seconds > burst_threshold) {
+            DeferEvaluations(interval);
+            output_credit = 0.0f;
+            return {};
+        }
+    }
+
+    if (interval_seconds > 1.0f / MINIMUM_BASE_RATE) {
+        Stabilize(now);
+        return {};
+    }
+
+    smoothed_interval = smoothed_interval > 0.0f
+                            ? smoothed_interval +
+                                  (interval_seconds - smoothed_interval) * INTERVAL_SMOOTHING
+                            : interval_seconds;
+
+    if (previous_generations == 0) {
+        const f32 measured = 1.0f / smoothed_interval;
+        unloaded_base_rate =
+            unloaded_base_rate > 0.0f
+                ? unloaded_base_rate + (measured - unloaded_base_rate) * INTERVAL_SMOOTHING
+                : measured;
+    }
+
+    if (stable_until) {
+        if (now < *stable_until) {
+            return {};
+        }
+        stable_until.reset();
+    }
+
+    if (target_rate == 0.0f) {
+        limit = std::min(Settings::FrameGenGenerations(), ceiling);
+        output_credit = 0.0f;
+        issued_generations = limit;
+        return {.generations = limit, .warm = limit > 0};
+    }
+
+    UpdateLimit(now, 1.0f / smoothed_interval, target_rate, ceiling);
+
+    const size_t allowed = std::min(limit, ceiling);
+    const f32 desired_outputs = smoothed_interval * target_rate;
+    if (allowed == 0 || desired_outputs <= 1.0f) {
+        output_credit = 0.0f;
+        return {};
+    }
+
+    output_credit += desired_outputs;
+    const size_t outputs =
+        std::max<size_t>(1, static_cast<size_t>(std::floor(output_credit + CREDIT_EPSILON)));
+    const size_t generations = std::min(outputs - 1, allowed);
+
+    output_credit -= static_cast<f32>(generations + 1);
+    if (output_credit < 0.0f) {
+        output_credit = 0.0f;
+    } else if (generations == allowed && output_credit >= 1.0f) {
+        output_credit = std::fmod(output_credit, 1.0f);
+    }
+
+    issued_generations = generations;
+    return {.generations = generations, .warm = true};
+}
+
+void FrameGenPacer::UpdateLimit(Clock::time_point now, f32 base_rate, f32 target_rate,
+                                size_t ceiling) {
+    limit = std::min(limit, ceiling);
+
+    if (probe_until) {
+        if (now < *probe_until) {
+            return;
+        }
+        probe_until.reset();
+        output_credit = 0.0f;
+
+        const f32 previous_output =
+            std::min(target_rate, probe_base_rate * static_cast<f32>(probe_previous_limit + 1));
+        const f32 current_output =
+            std::min(target_rate, base_rate * static_cast<f32>(limit + 1));
+
+        const bool throughput_regressed =
+            current_output < previous_output * PROBE_THROUGHPUT_TOLERANCE;
+        const bool collapsed_for_marginal_gain =
+            base_rate < probe_base_rate * PROBE_BASE_COLLAPSE_RATIO &&
+            current_output < previous_output * PROBE_MARGINAL_GAIN;
+        const bool emulation_slowed = unloaded_base_rate > 0.0f &&
+                                      base_rate < unloaded_base_rate * UNLOADED_BASE_RETENTION;
+
+        if (throughput_regressed || collapsed_for_marginal_gain || emulation_slowed) {
+            limit = probe_previous_limit;
+            probe_failures = std::min(probe_failures + 1, MAX_PROBE_FAILURES);
+            next_probe = now + ProbeBackoff(probe_failures);
+            deficit_since.reset();
+            return;
+        }
+
+        probe_failures = 0;
+        next_probe = now + PROBE_STEP_DELAY;
+    }
+
+    if (base_rate * static_cast<f32>(limit + 1) >= target_rate * TARGET_SATISFIED_RATIO ||
+        limit >= ceiling) {
+        deficit_since.reset();
+        return;
+    }
+
+    if (!deficit_since) {
+        deficit_since = now;
+        return;
+    }
+    if (now - *deficit_since < DEFICIT_DURATION) {
+        return;
+    }
+    if (next_probe && now < *next_probe) {
+        return;
+    }
+
+    probe_previous_limit = limit;
+    probe_base_rate = base_rate;
+    ++limit;
+    probe_until = now + PROBE_DURATION;
+    deficit_since.reset();
+    output_credit = 0.0f;
+}
+
+void FrameGenPacer::DeferEvaluations(Clock::duration amount) {
+    const auto defer = [amount](std::optional<Clock::time_point>& deadline) {
+        if (deadline) {
+            *deadline += amount;
+        }
+    };
+    defer(stable_until);
+    defer(probe_until);
+    defer(next_probe);
+    deficit_since.reset();
+}
+
+void FrameGenPacer::Stabilize(Clock::time_point now) {
+    stable_until = now + STABILIZATION_DURATION;
+    probe_until.reset();
+    deficit_since.reset();
+    smoothed_interval = 0.0f;
+    output_credit = 0.0f;
+}
+
+void FrameGenPacer::Reset() {
+    last_frame.reset();
+    stable_until.reset();
+    probe_until.reset();
+    next_probe.reset();
+    deficit_since.reset();
+    smoothed_interval = 0.0f;
+    output_credit = 0.0f;
+    probe_base_rate = 0.0f;
+    unloaded_base_rate = 0.0f;
+    issued_generations = 0;
+    probe_previous_limit = 0;
+    limit = 0;
+    probe_failures = 0;
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/frame_gen_pacer.h

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <chrono>
+#include <optional>
+
+#include "common/common_types.h"
+
+namespace Vulkan {
+
+struct FrameGenPlan {
+    size_t generations{};
+    bool warm{};
+};
+
+class FrameGenPacer {
+public:
+    [[nodiscard]] FrameGenPlan Plan(size_t capacity);
+
+    void Reset();
+
+private:
+    using Clock = std::chrono::steady_clock;
+
+    void Stabilize(Clock::time_point now);
+    void DeferEvaluations(Clock::duration amount);
+    void UpdateLimit(Clock::time_point now, f32 base_rate, f32 target_rate, size_t ceiling);
+
+    std::optional<Clock::time_point> last_frame;
+    std::optional<Clock::time_point> stable_until;
+    std::optional<Clock::time_point> probe_until;
+    std::optional<Clock::time_point> next_probe;
+    std::optional<Clock::time_point> deficit_since;
+    f32 smoothed_interval{};
+    f32 output_credit{};
+    f32 probe_base_rate{};
+    f32 unloaded_base_rate{};
+    size_t issued_generations{};
+    size_t probe_previous_limit{};
+    size_t limit{};
+    u32 probe_failures{};
+};
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -208,11 +208,9 @@ void RendererVulkan::Composite(std::span<const Tegra::FramebufferConfig> framebu
                                render_window.GetFramebufferLayout(), swapchain.GetImageCount(),
                                swapchain.GetImageViewFormat());
 
-    const size_t wanted = frame_gen.WantedGenerations();
-    const bool can_present_all = wanted > 0 && present_manager.AvailableExtraFrames() >= wanted;
+    void(frame_gen.WantedGenerations(present_manager.MaxExtraFrames()));
 
-    frame_gen.Process(device, frame, swapchain.GetImageFormat(), GuestExtent(framebuffers),
-                      can_present_all);
+    frame_gen.Process(device, frame, swapchain.GetImageFormat(), GuestExtent(framebuffers));
 
     const size_t generated_frames = frame_gen.GeneratedFrameCount();
     for (size_t generation = 0; generation < generated_frames; ++generation) {

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -193,9 +193,8 @@ void PresentManager::Present(Frame* frame) {
     }
 }
 
-size_t PresentManager::AvailableExtraFrames() {
-    std::scoped_lock lock{free_mutex};
-    return free_queue.size();
+size_t PresentManager::MaxExtraFrames() const {
+    return image_count - 1;
 }
 
 void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat image_view_format,
@@ -351,7 +350,7 @@ void PresentManager::SetImageCount() {
     // We cannot have more than 7 images in flight at any given time.
     // FRAMES_IN_FLIGHT is 8, and the cache TICKS_TO_DESTROY is 8.
     // Mali drivers will give us 6.
-    const size_t generations = Settings::FrameGenGenerations();
+    const size_t generations = Settings::FrameGenMaxGenerations();
     const size_t queued_composites = Settings::values.frame_gen_queue_target.GetValue() + 1;
     image_count =
         std::clamp<size_t>((generations + 1) * queued_composites, swapchain.GetImageCount(),

src/video_core/renderer_vulkan/vk_present_manager.h

@@ -63,7 +63,7 @@ public:
     void WaitPresent();
 
     /// How many additional frames can be queued without stalling the render thread
-    size_t AvailableExtraFrames();
+    [[nodiscard]] size_t MaxExtraFrames() const;
 
 private:
     void PresentThread(std::stop_token token);