1 files changed, 43 insertions, 10 deletions

diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index b24086fce..fe13cac93 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -49,8 +49,8 @@ TextureCache<P>::TextureCache(Runtime& runtime_, VideoCore::RasterizerInterface&
 
     if constexpr (HAS_DEVICE_MEMORY_INFO) {
         const s64 device_memory = static_cast<s64>(runtime.GetDeviceLocalMemory());
-        const s64 min_spacing_expected = device_memory - 1_GiB - 512_MiB;
-        const s64 min_spacing_critical = device_memory - 1_GiB;
+        const s64 min_spacing_expected = device_memory - 1_GiB;
+        const s64 min_spacing_critical = device_memory - 512_MiB;
         const s64 mem_threshold = std::min(device_memory, TARGET_THRESHOLD);
         const s64 min_vacancy_expected = (6 * mem_threshold) / 10;
         const s64 min_vacancy_critical = (3 * mem_threshold) / 10;
@@ -86,10 +86,12 @@ void TextureCache<P>::RunGarbageCollector() {
             // used by the async decoder thread.
             return false;
         }
+        if (!aggressive_mode && True(image.flags & ImageFlagBits::CostlyLoad)) {
+            return false;
+        }
         const bool must_download =
             image.IsSafeDownload() && False(image.flags & ImageFlagBits::BadOverlap);
-        if (!high_priority_mode &&
-            (must_download || True(image.flags & ImageFlagBits::CostlyLoad))) {
+        if (!high_priority_mode && must_download) {
             return false;
         }
         if (must_download) {
@@ -137,7 +139,6 @@ void TextureCache<P>::TickFrame() {
     TickAsyncDecode();
 
     runtime.TickFrame();
-    critical_gc = 0;
     ++frame_tick;
 
     if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) {
@@ -184,6 +185,42 @@ void TextureCache<P>::FillComputeImageViews(std::span<ImageViewInOut> views) {
 }
 
 template <class P>
+void TextureCache<P>::CheckFeedbackLoop(std::span<const ImageViewInOut> views) {
+    const bool requires_barrier = [&] {
+        for (const auto& view : views) {
+            if (!view.id) {
+                continue;
+            }
+            auto& image_view = slot_image_views[view.id];
+
+            // Check color targets
+            for (const auto& ct_view_id : render_targets.color_buffer_ids) {
+                if (ct_view_id) {
+                    auto& ct_view = slot_image_views[ct_view_id];
+                    if (image_view.image_id == ct_view.image_id) {
+                        return true;
+                    }
+                }
+            }
+
+            // Check zeta target
+            if (render_targets.depth_buffer_id) {
+                auto& zt_view = slot_image_views[render_targets.depth_buffer_id];
+                if (image_view.image_id == zt_view.image_id) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }();
+
+    if (requires_barrier) {
+        runtime.BarrierFeedbackLoop();
+    }
+}
+
+template <class P>
 typename P::Sampler* TextureCache<P>::GetGraphicsSampler(u32 index) {
     if (index > channel_state->graphics_sampler_table.Limit()) {
         LOG_DEBUG(HW_GPU, "Invalid sampler index={}", index);
@@ -1469,7 +1506,7 @@ std::optional<typename TextureCache<P>::BlitImages> TextureCache<P>::GetBlitImag
         if (!copy.must_accelerate) {
             do {
                 if (!src_id && !dst_id) {
-                    break;
+                    return std::nullopt;
                 }
                 if (src_id && True(slot_images[src_id].flags & ImageFlagBits::GpuModified)) {
                     break;
@@ -1847,10 +1884,6 @@ void TextureCache<P>::RegisterImage(ImageId image_id) {
         tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
     }
     total_used_memory += Common::AlignUp(tentative_size, 1024);
-    if (total_used_memory > critical_memory && critical_gc < GC_EMERGENCY_COUNTS) {
-        RunGarbageCollector();
-        critical_gc++;
-    }
     image.lru_index = lru_cache.Insert(image_id, frame_tick);
 
     ForEachGPUPage(image.gpu_addr, image.guest_size_bytes, [this, image_id](u64 page) {