From 3d98e1361b2f1c3993aa7f1e9b1ac49fc5b6e512 Mon Sep 17 00:00:00 2001
From: riperiperi <rhy3756547@hotmail.com>
Date: Sat, 29 Oct 2022 23:07:37 +0100
Subject: GPU: Use a bitmap to track buffer modified flags. (#3775)
* Initial implementation
* Some improvements.
* Fix incorrect cast
* Performance improvement and improved correctness
* Add very fast path when all handles are checked.
* Slightly faster
* Add comment
* De-virtualize region handle
All region handles are now bitmap backed.
* Remove non-bitmap tracking
* Remove unused methods
* Add docs, remove unused methods
* Address Feedback
* Rename file
---
Ryujinx.Memory/Tracking/ConcurrentBitmap.cs | 161 ++++++++++++++++++++++++++++
1 file changed, 161 insertions(+)
create mode 100644 Ryujinx.Memory/Tracking/ConcurrentBitmap.cs
(limited to 'Ryujinx.Memory/Tracking/ConcurrentBitmap.cs')
diff --git a/Ryujinx.Memory/Tracking/ConcurrentBitmap.cs b/Ryujinx.Memory/Tracking/ConcurrentBitmap.cs
new file mode 100644
index 00000000..2e007bb5
--- /dev/null
+++ b/Ryujinx.Memory/Tracking/ConcurrentBitmap.cs
@@ -0,0 +1,161 @@
+using System;
+using System.Threading;
+
+namespace Ryujinx.Memory.Tracking
+{
+ /// <summary>
+ /// A bitmap that can be safely modified from multiple threads.
+ /// </summary>
+ internal class ConcurrentBitmap
+ {
+ public const int IntSize = 64;
+
+ public const int IntShift = 6;
+ public const int IntMask = IntSize - 1;
+
+ /// <summary>
+ /// Masks representing the bitmap. Least significant bit first, 64-bits per mask.
+ /// </summary>
+ public readonly long[] Masks;
+
+ /// <summary>
+ /// Create a new multithreaded bitmap.
+ /// </summary>
+ /// <param name="count">The number of bits to reserve</param>
+ /// <param name="set">Whether the bits should be initially set or not</param>
+ public ConcurrentBitmap(int count, bool set)
+ {
+ Masks = new long[(count + IntMask) / IntSize];
+
+ if (set)
+ {
+ Array.Fill(Masks, -1L);
+ }
+ }
+
+ /// <summary>
+ /// Check if any bit in the bitmap is set.
+ /// </summary>
+ /// <returns>True if any bits are set, false otherwise</returns>
+ public bool AnySet()
+ {
+ for (int i = 0; i < Masks.Length; i++)
+ {
+ if (Volatile.Read(ref Masks[i]) != 0)
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /// <summary>
+ /// Check if a bit in the bitmap is set.
+ /// </summary>
+ /// <param name="bit">The bit index to check</param>
+ /// <returns>True if the bit is set, false otherwise</returns>
+ public bool IsSet(int bit)
+ {
+ int wordIndex = bit >> IntShift;
+ int wordBit = bit & IntMask;
+
+ long wordMask = 1L << wordBit;
+
+ return (Volatile.Read(ref Masks[wordIndex]) & wordMask) != 0;
+ }
+
+ /// <summary>
+ /// Check if any bit in a range of bits in the bitmap are set. (inclusive)
+ /// </summary>
+ /// <param name="start">The first bit index to check</param>
+ /// <param name="end">The last bit index to check</param>
+ /// <returns>True if a bit is set, false otherwise</returns>
+ public bool IsSet(int start, int end)
+ {
+ if (start == end)
+ {
+ return IsSet(start);
+ }
+
+ int startIndex = start >> IntShift;
+ int startBit = start & IntMask;
+ long startMask = -1L << startBit;
+
+ int endIndex = end >> IntShift;
+ int endBit = end & IntMask;
+ long endMask = (long)(ulong.MaxValue >> (IntMask - endBit));
+
+ long startValue = Volatile.Read(ref Masks[startIndex]);
+
+ if (startIndex == endIndex)
+ {
+ return (startValue & startMask & endMask) != 0;
+ }
+
+ if ((startValue & startMask) != 0)
+ {
+ return true;
+ }
+
+ for (int i = startIndex + 1; i < endIndex; i++)
+ {
+ if (Volatile.Read(ref Masks[i]) != 0)
+ {
+ return true;
+ }
+ }
+
+ long endValue = Volatile.Read(ref Masks[endIndex]);
+
+ if ((endValue & endMask) != 0)
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+ /// <summary>
+ /// Set a bit at a specific index to either true or false.
+ /// </summary>
+ /// <param name="bit">The bit index to set</param>
+ /// <param name="value">Whether the bit should be set or not</param>
+ public void Set(int bit, bool value)
+ {
+ int wordIndex = bit >> IntShift;
+ int wordBit = bit & IntMask;
+
+ long wordMask = 1L << wordBit;
+
+ long existing;
+ long newValue;
+
+ do
+ {
+ existing = Volatile.Read(ref Masks[wordIndex]);
+
+ if (value)
+ {
+ newValue = existing | wordMask;
+ }
+ else
+ {
+ newValue = existing & ~wordMask;
+ }
+ }
+ while (Interlocked.CompareExchange(ref Masks[wordIndex], newValue, existing) != existing);
+ }
+
+ /// <summary>
+ /// Clear the bitmap entirely, setting all bits to 0.
+ /// </summary>
+ public void Clear()
+ {
+ for (int i = 0; i < Masks.Length; i++)
+ {
+ Volatile.Write(ref Masks[i], 0);
+ }
+ }
+ }
+}
--
cgit v1.2.3-70-g09d2