GPU: Pre-emptively flush textures that are flushed often (to imported memory when available) (#4711)

* WIP texture pre-flush

Improve performance of TextureView GetData to buffer

Fix copy/sync ordering

Fix minor bug

Make this actually work

WIP host mapping stuff

* Fix usage flags

* message

* Cleanup 1

* Fix rebase

* Fix

* Improve pre-flush rules

* Fix pre-flush

* A lot of cleanup

* Use the host memory bits

* Select the correct memory type

* Cleanup TextureGroupHandle

* Missing comment

* Remove debugging logs

* Revert BufferHandle _value access modifier

* One interrupt action at a time.

* Support D32S8 to D24S8 conversion, safeguards

* Interrupt cannot happen in sync handle's lock

Waitable needs to be checked twice now, but this should stop it from deadlocking.

* Remove unused using

* Address some feedback

* Address feedback

* Address more feedback

* Address more feedback

* Improve sync rules

Should allow for faster sync in some cases.

1 files changed, 18 insertions, 13 deletions

diff --git a/src/Ryujinx.Graphics.Vulkan/SyncManager.cs b/src/Ryujinx.Graphics.Vulkan/SyncManager.cs
index 432d224f..b3f6e8e5 100644
--- a/src/Ryujinx.Graphics.Vulkan/SyncManager.cs
+++ b/src/Ryujinx.Graphics.Vulkan/SyncManager.cs
@@ -125,24 +125,29 @@ namespace Ryujinx.Graphics.Vulkan
 
             if (result != null)
             {
-                lock (result)
+                if (result.Waitable == null)
                 {
-                    if (result.Waitable == null)
-                    {
-                        return;
-                    }
+                    return;
+                }
 
-                    long beforeTicks = Stopwatch.GetTimestamp();
+                long beforeTicks = Stopwatch.GetTimestamp();
 
-                    if (result.NeedsFlush(FlushId))
+                if (result.NeedsFlush(FlushId))
+                {
+                    _gd.InterruptAction(() =>
                     {
-                        _gd.InterruptAction(() =>
+                        if (result.NeedsFlush(FlushId))
                         {
-                            if (result.NeedsFlush(FlushId))
-                            {
-                                _gd.FlushAllCommands();
-                            }
-                        });
+                            _gd.FlushAllCommands();
+                        }
+                    });
+                }
+
+                lock (result)
+                {
+                    if (result.Waitable == null)
+                    {
+                        return;
                     }
 
                     bool signaled = result.Signalled || result.Waitable.WaitForFences(_gd.Api, _device, 1000000000);