Implemented returning buffer to the pool.

kekyo · kekyo · commit 2ebf73f828d0 · 2024-04-08T15:03:47.000+09:00
diff --git a/FlashCap.Core/BufferPool.cs b/FlashCap.Core/BufferPool.cs
@@ -32,7 +32,7 @@ public sealed class DefaultBufferPool :
     // Tried and tested, but simple strategies were the fastest.
     // Probably because each buffer table and lookup fragments on the CPU cache.
 
-    private const int BufferHolderLength = 13;
+    private const int bufferHolderLength = 13;
 
     [DebuggerStepThrough]
     private sealed class BufferHolder
@@ -42,66 +42,91 @@ private sealed class BufferHolder
         public BufferHolder(int maxReservedBufferElements) =>
             this.buffers = new byte[maxReservedBufferElements][];
 
-        public byte[] Rent(int size, bool exactSize)
+        public byte[]? Rent(int size, bool exactSize)
         {
             for (var index = 0; index < this.buffers.Length; index++)
             {
                 var buffer = this.buffers[index];
-                if (buffer != null && (exactSize ? (buffer.Length == size) : (buffer.Length <= size)))
+                if (buffer != null && (exactSize ? (buffer.Length == size) : (buffer.Length >= size)))
                 {
                     if (Interlocked.CompareExchange(ref this.buffers[index], null, buffer) == buffer)
                     {
-                        return buffer!;
+                        return buffer;
                     }
                 }
             }
 
-            return new byte[size];
+            return null;
         }
 
-        public void Return(byte[] buffer)
+        public bool Return(byte[] buffer)
         {
             for (var index = 0; index < this.buffers.Length; index++)
             {
                 if (this.buffers[index] == null)
                 {
                     if (Interlocked.CompareExchange(ref this.buffers[index], buffer, null) == null)
                     {
-                        break;
+                        return true;
                     }
                 }
             }
 
             // It was better to simply discard a buffer instance than the cost of extending the table.
+            return false;
         }
     }
 
     private readonly BufferHolder[] bufferHolders;
+    private int saved;
 
-    public DefaultBufferPool() : this(32)
+    public DefaultBufferPool() : this(16)
     {
     }
 
     public DefaultBufferPool(int maxReservedBufferElements) =>
-        this.bufferHolders = Enumerable.Range(0, BufferHolderLength).
+        this.bufferHolders = Enumerable.Range(0, bufferHolderLength).
         Select(_ => new BufferHolder(maxReservedBufferElements)).
         ToArray();
 
     public override byte[] Rent(int size, bool exactSize)
     {
-        // NOTE: Size is determined on a "less than" basis,
+        // NOTE: Size is determined on a "less than" basis when not exact size,
         // which may result in placement in different buckets and missed opportunities for reuse.
-        // This implementation is ignored it.
+        // This implementation is ignored penalties.
+        int saved;
         var bufferHolder = this.bufferHolders[size % this.bufferHolders.Length];
-        return bufferHolder.Rent(size, exactSize);
+        if (bufferHolder.Rent(size, exactSize) is { } b)
+        {
+            saved = Interlocked.Decrement(ref this.saved);
+        }
+        else
+        {
+            b = new byte[size];
+            saved = this.saved;
+        }
+
+#if DEBUG
+        Debug.WriteLine($"DefaultBufferPool: Rend: Size={b.Length}/{size}, ExactSize={exactSize}, Saved={saved}");
+#endif
+        return b;
     }
 
     public override void Return(byte[] buffer)
     {
-        if (Interlocked.Exchange(ref buffer, null!) is { } b)
+        int saved;
+        var bufferHolder = this.bufferHolders[buffer.Length % this.bufferHolders.Length];
+        if (bufferHolder.Return(buffer))
+        {
+            saved = Interlocked.Increment(ref this.saved);
+        }
+        else
         {
-            var bufferHolder = this.bufferHolders[b.Length % this.bufferHolders.Length];
-            bufferHolder.Return(b);
+            saved = this.saved;
         }
+
+#if DEBUG
+        Debug.WriteLine($"DefaultBufferPool: Returned: Size={buffer.Length}, Saved={saved}");
+#endif
     }
 }
diff --git a/FlashCap.Core/PixelBuffer.cs b/FlashCap.Core/PixelBuffer.cs
@@ -19,7 +19,7 @@ public sealed class PixelBuffer
 
     private byte[]? imageContainer;
     private int imageContainerSize;
-    private byte[]? transcodedImageContainer = null;
+    private byte[]? transcodedImageContainer;
     private bool isValidTranscodedImage;
     private long timestampMicroseconds;
     private TranscodeFormats transcodeFormat;
@@ -48,18 +48,25 @@ internal unsafe void CopyIn(
 
         lock (this)
         {
-            if (this.imageContainer == null ||
-                this.imageContainer.Length < totalSize)
+            var imageContainer = this.imageContainer;
+
+            if (imageContainer == null ||
+                imageContainer.Length < totalSize)
             {
-                Debug.WriteLine($"Allocated: CurrentSize={this.imageContainer?.Length ?? 0}, Size={totalSize}");
+                if (imageContainer != null)
+                {
+                    this.bufferPool.Return(imageContainer);
+                }
+                imageContainer = this.bufferPool.Rent(totalSize, false);
+                this.imageContainer = imageContainer;
 
-                this.imageContainer = this.bufferPool.Rent(totalSize, false);
+                Debug.WriteLine($"Allocated: Size={totalSize}");
             }
 
             this.imageContainerSize = totalSize;
             this.isValidTranscodedImage = false;
 
-            fixed (byte* pImageContainer = this.imageContainer!)
+            fixed (byte* pImageContainer = imageContainer)
             {
                 if (pBih->biCompression == NativeMethods.Compression.MJPG ||
                     pBih->biCompression == NativeMethods.Compression.BI_JPEG ||
@@ -117,24 +124,28 @@ internal unsafe ArraySegment<byte> InternalExtractImage(BufferStrategies strateg
     {
         lock (this)
         {
-            if (this.imageContainer == null)
+            var imageContainer = this.imageContainer;
+            if (imageContainer == null)
             {
                 throw new InvalidOperationException("Extracted before capture.");
             }
 
             if (this.transcodeFormat != TranscodeFormats.DoNotTranscode)
             {
-                if (this.isValidTranscodedImage && this.transcodedImageContainer != null)
+                var transcodedImageContainer = this.transcodedImageContainer;
+                if (this.isValidTranscodedImage && transcodedImageContainer != null)
                 {
                     if (strategy == BufferStrategies.ForceReuse)
                     {
-                        return new ArraySegment<byte>(this.transcodedImageContainer);
+                        return new ArraySegment<byte>(transcodedImageContainer);
                     }
                     else
                     {
-                        var copied1 = this.bufferPool.Rent(this.transcodedImageContainer.Length, true);
-                        Array.Copy(this.transcodedImageContainer, copied1, copied1.Length);
-                        return new ArraySegment<byte>(copied1);
+                        var copiedImageContainer = new byte[transcodedImageContainer.Length];
+                        Array.Copy(transcodedImageContainer,
+                            copiedImageContainer, copiedImageContainer.Length);
+
+                        return new ArraySegment<byte>(copiedImageContainer);
                     }
                 }
 
@@ -154,6 +165,10 @@ internal unsafe ArraySegment<byte> InternalExtractImage(BufferStrategies strateg
                         if (this.transcodedImageContainer == null ||
                             this.transcodedImageContainer.Length != totalSize)
                         {
+                            if (this.transcodedImageContainer != null)
+                            {
+                                this.bufferPool.Return(this.transcodedImageContainer);
+                            }
                             this.transcodedImageContainer = this.bufferPool.Rent(totalSize, true);
                         }
 
@@ -200,9 +215,7 @@ internal unsafe ArraySegment<byte> InternalExtractImage(BufferStrategies strateg
                         }
                         else
                         {
-                            var copied1 = this.transcodedImageContainer;
-                            this.transcodedImageContainer = null;
-                            return new ArraySegment<byte>(copied1);
+                            return new ArraySegment<byte>(this.transcodedImageContainer);
                         }
                     }
                 }
@@ -211,19 +224,19 @@ internal unsafe ArraySegment<byte> InternalExtractImage(BufferStrategies strateg
             switch (strategy)
             {
                 case BufferStrategies.ForceReuse:
-                    return new ArraySegment<byte>(this.imageContainer, 0, this.imageContainerSize);
+                    return new ArraySegment<byte>(imageContainer, 0, this.imageContainerSize);
                 case BufferStrategies.CopyWhenDifferentSizeOrReuse:
-                    if (this.imageContainer.Length == this.imageContainerSize)
+                    if (imageContainer.Length == this.imageContainerSize)
                     {
-                        return new ArraySegment<byte>(this.imageContainer);
+                        return new ArraySegment<byte>(imageContainer);
                     }
                     break;
             }
 
             var copied = this.bufferPool.Rent(this.imageContainerSize, true);
-            Array.Copy(this.imageContainer, copied, copied.Length);
+            Array.Copy(imageContainer, copied, copied.Length);
 
-            Debug.WriteLine($"Copied: CurrentSize={this.imageContainer.Length}, Size={this.imageContainerSize}");
+            Debug.WriteLine($"Copied: CurrentSize={imageContainer.Length}, Size={this.imageContainerSize}");
 
             return new ArraySegment<byte>(copied);
         }

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public sealed class DefaultBufferPool :`
`32`	`32`	`// Tried and tested, but simple strategies were the fastest.`
`33`	`33`	`// Probably because each buffer table and lookup fragments on the CPU cache.`
`34`	`34`
`35`		`- private const int BufferHolderLength = 13;`
	`35`	`+ private const int bufferHolderLength = 13;`
`36`	`36`
`37`	`37`	`[DebuggerStepThrough]`
`38`	`38`	`private sealed class BufferHolder`
`@@ -42,66 +42,91 @@ private sealed class BufferHolder`
`42`	`42`	`public BufferHolder(int maxReservedBufferElements) =>`
`43`	`43`	`this.buffers = new byte[maxReservedBufferElements][];`
`44`	`44`
`45`		`- public byte[] Rent(int size, bool exactSize)`
	`45`	`+ public byte[]? Rent(int size, bool exactSize)`
`46`	`46`	`{`
`47`	`47`	`for (var index = 0; index < this.buffers.Length; index++)`
`48`	`48`	`{`
`49`	`49`	`var buffer = this.buffers[index];`
`50`		`- if (buffer != null && (exactSize ? (buffer.Length == size) : (buffer.Length <= size)))`
	`50`	`+ if (buffer != null && (exactSize ? (buffer.Length == size) : (buffer.Length >= size)))`
`51`	`51`	`{`
`52`	`52`	`if (Interlocked.CompareExchange(ref this.buffers[index], null, buffer) == buffer)`
`53`	`53`	`{`
`54`		`- return buffer!;`
	`54`	`+ return buffer;`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`- return new byte[size];`
	`59`	`+ return null;`
`60`	`60`	`}`
`61`	`61`
`62`		`- public void Return(byte[] buffer)`
	`62`	`+ public bool Return(byte[] buffer)`
`63`	`63`	`{`
`64`	`64`	`for (var index = 0; index < this.buffers.Length; index++)`
`65`	`65`	`{`
`66`	`66`	`if (this.buffers[index] == null)`
`67`	`67`	`{`
`68`	`68`	`if (Interlocked.CompareExchange(ref this.buffers[index], buffer, null) == null)`
`69`	`69`	`{`
`70`		`- break;`
	`70`	`+ return true;`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`// It was better to simply discard a buffer instance than the cost of extending the table.`
	`76`	`+ return false;`
`76`	`77`	`}`
`77`	`78`	`}`
`78`	`79`
`79`	`80`	`private readonly BufferHolder[] bufferHolders;`
	`81`	`+ private int saved;`
`80`	`82`
`81`		`- public DefaultBufferPool() : this(32)`
	`83`	`+ public DefaultBufferPool() : this(16)`
`82`	`84`	`{`
`83`	`85`	`}`
`84`	`86`
`85`	`87`	`public DefaultBufferPool(int maxReservedBufferElements) =>`
`86`		`- this.bufferHolders = Enumerable.Range(0, BufferHolderLength).`
	`88`	`+ this.bufferHolders = Enumerable.Range(0, bufferHolderLength).`
`87`	`89`	`Select(_ => new BufferHolder(maxReservedBufferElements)).`
`88`	`90`	`ToArray();`
`89`	`91`
`90`	`92`	`public override byte[] Rent(int size, bool exactSize)`
`91`	`93`	`{`
`92`		`- // NOTE: Size is determined on a "less than" basis,`
	`94`	`+ // NOTE: Size is determined on a "less than" basis when not exact size,`
`93`	`95`	`// which may result in placement in different buckets and missed opportunities for reuse.`
`94`		`- // This implementation is ignored it.`
	`96`	`+ // This implementation is ignored penalties.`
	`97`	`+ int saved;`
`95`	`98`	`var bufferHolder = this.bufferHolders[size % this.bufferHolders.Length];`
`96`		`- return bufferHolder.Rent(size, exactSize);`
	`99`	`+ if (bufferHolder.Rent(size, exactSize) is { } b)`
	`100`	`+ {`
	`101`	`+ saved = Interlocked.Decrement(ref this.saved);`
	`102`	`+ }`
	`103`	`+ else`
	`104`	`+ {`
	`105`	`+ b = new byte[size];`
	`106`	`+ saved = this.saved;`
	`107`	`+ }`
	`108`	`+`
	`109`	`+#if DEBUG`
	`110`	`+ Debug.WriteLine($"DefaultBufferPool: Rend: Size={b.Length}/{size}, ExactSize={exactSize}, Saved={saved}");`
	`111`	`+#endif`
	`112`	`+ return b;`
`97`	`113`	`}`
`98`	`114`
`99`	`115`	`public override void Return(byte[] buffer)`
`100`	`116`	`{`
`101`		`- if (Interlocked.Exchange(ref buffer, null!) is { } b)`
	`117`	`+ int saved;`
	`118`	`+ var bufferHolder = this.bufferHolders[buffer.Length % this.bufferHolders.Length];`
	`119`	`+ if (bufferHolder.Return(buffer))`
	`120`	`+ {`
	`121`	`+ saved = Interlocked.Increment(ref this.saved);`
	`122`	`+ }`
	`123`	`+ else`
`102`	`124`	`{`
`103`		`- var bufferHolder = this.bufferHolders[b.Length % this.bufferHolders.Length];`
`104`		`- bufferHolder.Return(b);`
	`125`	`+ saved = this.saved;`
`105`	`126`	`}`
	`127`	`+`
	`128`	`+#if DEBUG`
	`129`	`+ Debug.WriteLine($"DefaultBufferPool: Returned: Size={buffer.Length}, Saved={saved}");`
	`130`	`+#endif`
`106`	`131`	`}`
`107`	`132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public sealed class PixelBuffer`
`19`	`19`
`20`	`20`	`private byte[]? imageContainer;`
`21`	`21`	`private int imageContainerSize;`
`22`		`- private byte[]? transcodedImageContainer = null;`
	`22`	`+ private byte[]? transcodedImageContainer;`
`23`	`23`	`private bool isValidTranscodedImage;`
`24`	`24`	`private long timestampMicroseconds;`
`25`	`25`	`private TranscodeFormats transcodeFormat;`
`@@ -48,18 +48,25 @@ internal unsafe void CopyIn(`
`48`	`48`
`49`	`49`	`lock (this)`
`50`	`50`	`{`
`51`		`- if (this.imageContainer == null \|\|`
`52`		`- this.imageContainer.Length < totalSize)`
	`51`	`+ var imageContainer = this.imageContainer;`
	`52`	`+`
	`53`	`+ if (imageContainer == null \|\|`
	`54`	`+ imageContainer.Length < totalSize)`
`53`	`55`	`{`
`54`		`- Debug.WriteLine($"Allocated: CurrentSize={this.imageContainer?.Length ?? 0}, Size={totalSize}");`
	`56`	`+ if (imageContainer != null)`
	`57`	`+ {`
	`58`	`+ this.bufferPool.Return(imageContainer);`
	`59`	`+ }`
	`60`	`+ imageContainer = this.bufferPool.Rent(totalSize, false);`
	`61`	`+ this.imageContainer = imageContainer;`
`55`	`62`
`56`		`- this.imageContainer = this.bufferPool.Rent(totalSize, false);`
	`63`	`+ Debug.WriteLine($"Allocated: Size={totalSize}");`
`57`	`64`	`}`
`58`	`65`
`59`	`66`	`this.imageContainerSize = totalSize;`
`60`	`67`	`this.isValidTranscodedImage = false;`
`61`	`68`
`62`		`- fixed (byte* pImageContainer = this.imageContainer!)`
	`69`	`+ fixed (byte* pImageContainer = imageContainer)`
`63`	`70`	`{`
`64`	`71`	`if (pBih->biCompression == NativeMethods.Compression.MJPG \|\|`
`65`	`72`	`pBih->biCompression == NativeMethods.Compression.BI_JPEG \|\|`
`@@ -117,24 +124,28 @@ internal unsafe ArraySegment<byte> InternalExtractImage(BufferStrategies strateg`
`117`	`124`	`{`
`118`	`125`	`lock (this)`
`119`	`126`	`{`
`120`		`- if (this.imageContainer == null)`
	`127`	`+ var imageContainer = this.imageContainer;`
	`128`	`+ if (imageContainer == null)`
`121`	`129`	`{`
`122`	`130`	`throw new InvalidOperationException("Extracted before capture.");`
`123`	`131`	`}`
`124`	`132`
`125`	`133`	`if (this.transcodeFormat != TranscodeFormats.DoNotTranscode)`
`126`	`134`	`{`
`127`		`- if (this.isValidTranscodedImage && this.transcodedImageContainer != null)`
	`135`	`+ var transcodedImageContainer = this.transcodedImageContainer;`
	`136`	`+ if (this.isValidTranscodedImage && transcodedImageContainer != null)`
`128`	`137`	`{`
`129`	`138`	`if (strategy == BufferStrategies.ForceReuse)`
`130`	`139`	`{`
`131`		`- return new ArraySegment<byte>(this.transcodedImageContainer);`
	`140`	`+ return new ArraySegment<byte>(transcodedImageContainer);`
`132`	`141`	`}`
`133`	`142`	`else`
`134`	`143`	`{`
`135`		`- var copied1 = this.bufferPool.Rent(this.transcodedImageContainer.Length, true);`
`136`		`- Array.Copy(this.transcodedImageContainer, copied1, copied1.Length);`
`137`		`- return new ArraySegment<byte>(copied1);`
	`144`	`+ var copiedImageContainer = new byte[transcodedImageContainer.Length];`
	`145`	`+ Array.Copy(transcodedImageContainer,`
	`146`	`+ copiedImageContainer, copiedImageContainer.Length);`
	`147`	`+`
	`148`	`+ return new ArraySegment<byte>(copiedImageContainer);`
`138`	`149`	`}`
`139`	`150`	`}`
`140`	`151`
`@@ -154,6 +165,10 @@ internal unsafe ArraySegment<byte> InternalExtractImage(BufferStrategies strateg`
`154`	`165`	`if (this.transcodedImageContainer == null \|\|`
`155`	`166`	`this.transcodedImageContainer.Length != totalSize)`
`156`	`167`	`{`
	`168`	`+ if (this.transcodedImageContainer != null)`
	`169`	`+ {`
	`170`	`+ this.bufferPool.Return(this.transcodedImageContainer);`
	`171`	`+ }`
`157`	`172`	`this.transcodedImageContainer = this.bufferPool.Rent(totalSize, true);`
`158`	`173`	`}`
`159`	`174`
`@@ -200,9 +215,7 @@ internal unsafe ArraySegment<byte> InternalExtractImage(BufferStrategies strateg`
`200`	`215`	`}`
`201`	`216`	`else`
`202`	`217`	`{`
`203`		`- var copied1 = this.transcodedImageContainer;`
`204`		`- this.transcodedImageContainer = null;`
`205`		`- return new ArraySegment<byte>(copied1);`
	`218`	`+ return new ArraySegment<byte>(this.transcodedImageContainer);`
`206`	`219`	`}`
`207`	`220`	`}`
`208`	`221`	`}`
`@@ -211,19 +224,19 @@ internal unsafe ArraySegment<byte> InternalExtractImage(BufferStrategies strateg`
`211`	`224`	`switch (strategy)`
`212`	`225`	`{`
`213`	`226`	`case BufferStrategies.ForceReuse:`
`214`		`- return new ArraySegment<byte>(this.imageContainer, 0, this.imageContainerSize);`
	`227`	`+ return new ArraySegment<byte>(imageContainer, 0, this.imageContainerSize);`
`215`	`228`	`case BufferStrategies.CopyWhenDifferentSizeOrReuse:`
`216`		`- if (this.imageContainer.Length == this.imageContainerSize)`
	`229`	`+ if (imageContainer.Length == this.imageContainerSize)`
`217`	`230`	`{`
`218`		`- return new ArraySegment<byte>(this.imageContainer);`
	`231`	`+ return new ArraySegment<byte>(imageContainer);`
`219`	`232`	`}`
`220`	`233`	`break;`
`221`	`234`	`}`
`222`	`235`
`223`	`236`	`var copied = this.bufferPool.Rent(this.imageContainerSize, true);`
`224`		`- Array.Copy(this.imageContainer, copied, copied.Length);`
	`237`	`+ Array.Copy(imageContainer, copied, copied.Length);`
`225`	`238`
`226`		`- Debug.WriteLine($"Copied: CurrentSize={this.imageContainer.Length}, Size={this.imageContainerSize}");`
	`239`	`+ Debug.WriteLine($"Copied: CurrentSize={imageContainer.Length}, Size={this.imageContainerSize}");`
`227`	`240`
`228`	`241`	`return new ArraySegment<byte>(copied);`
`229`	`242`	`}`