LogBufferPool

Author: BRUNER Patrick

src/LogExpert.Core/Classes/Log/LogBuffer.cs

@@ -1,3 +1,5 @@
+using System.Buffers;
+
 using ColumnizerLib;
 
 using NLog;
@@ -15,7 +17,10 @@ public class LogBuffer
     private readonly List<long> _filePositions; // file position for every line
 #endif
 
-    private readonly List<LogLine> _lineList;
+    private LogLine[] _lineArray;
+    private int _lineArrayLength; // capacity of the rented array
+
+    //private readonly List<LogLine> _lineList;
 
     private int MAX_LINES = 500;
 
@@ -31,7 +36,10 @@ public LogBuffer (ILogFileInfo fileInfo, int maxLines)
     {
         FileInfo = fileInfo;
         MAX_LINES = maxLines;
-        _lineList = new(MAX_LINES);
+        //_lineList = new(MAX_LINES);
+
+        _lineArray = ArrayPool<LogLine>.Shared.Rent(maxLines);
+        _lineArrayLength = _lineArray.Length;
 #if DEBUG
         _filePositions = new(MAX_LINES);
 #endif
@@ -81,23 +89,67 @@ public long Size
 
     public void AddLine (LogLine lineMemory, long filePos)
     {
-        _lineList.Add(lineMemory);
+        //_lineList.Add(lineMemory);
+
+        if (LineCount < _lineArrayLength)
+        {
+            _lineArray[LineCount] = lineMemory;
+            LineCount++;
+        }
+#if DEBUG
+        else
+        {
+            _logger.Error("AddLine overflow: LineCount={0} >= _lineArrayLength={1}", LineCount, _lineArrayLength);
+        }
+#endif
+
 #if DEBUG
         _filePositions.Add(filePos);
 #endif
-        LineCount++;
         IsDisposed = false;
     }
 
     public void ClearLines ()
     {
-        _lineList.Clear();
+        Array.Clear(_lineArray, 0, LineCount);
+        //_lineList.Clear();
+        LineCount = 0;
+    }
+
+    /// <summary>
+    /// Prepares the buffer for reuse from the pool.
+    /// </summary>
+    public void Reinitialise (ILogFileInfo fileInfo, int maxLines)
+    {
+        FileInfo = fileInfo;
+        MAX_LINES = maxLines;
+        StartLine = 0;
+        StartPos = 0;
+        Size = 0;
         LineCount = 0;
+        DroppedLinesCount = 0;
+        PrevBuffersDroppedLinesSum = 0;
+        IsDisposed = false;
+        _lineArray = ArrayPool<LogLine>.Shared.Rent(maxLines);
+        _lineArrayLength = _lineArray.Length;
+#if DEBUG
+        _filePositions.Clear();
+        DisposeCount = 0;
+#endif
     }
 
     public void DisposeContent ()
     {
-        _lineList.Clear();
+        //_lineList.Clear();
+
+        if (_lineArray != null)
+        {
+            Array.Clear(_lineArray, 0, LineCount);
+            ArrayPool<LogLine>.Shared.Return(_lineArray);
+            _lineArray = null;
+            LineCount = 0;
+        }
+
         IsDisposed = true;
 #if DEBUG
         DisposeCount++;
@@ -106,9 +158,12 @@ public void DisposeContent ()
 
     public LogLine? GetLineMemoryOfBlock (int num)
     {
-        return num < _lineList.Count && num >= 0
-            ? _lineList[num]
-            : null;
+        return num < LineCount && num >= 0
+        ? _lineArray[num]
+        : null;
+        //return num < _lineList.Count && num >= 0
+        //    ? _lineList[num]
+        //    : null;
     }
 
     /// <summary>

src/LogExpert.Core/Classes/Log/LogBufferPool.cs

@@ -0,0 +1,33 @@
+using System.Collections.Concurrent;
+
+using ColumnizerLib;
+
+namespace LogExpert.Core.Classes.Log;
+
+public sealed class LogBufferPool (int maxSize)
+{
+    private readonly ConcurrentBag<LogBuffer> _pool = [];
+    private readonly int _maxSize = maxSize;
+
+    public LogBuffer Rent (ILogFileInfo fileInfo, int maxLines)
+    {
+        if (_pool.TryTake(out var buffer))
+        {
+            buffer.Reinitialise(fileInfo, maxLines);
+            return buffer;
+        }
+
+        return new LogBuffer(fileInfo, maxLines);
+    }
+
+    public void Return (LogBuffer buffer)
+    {
+        ArgumentNullException.ThrowIfNull(buffer);
+
+        buffer.DisposeContent();
+        if (_pool.Count < _maxSize)
+        {
+            _pool.Add(buffer);
+        }
+    }
+}

src/LogExpert.Core/Classes/Log/LogfileReader.cs

@@ -30,6 +30,7 @@ public partial class LogfileReader : IAutoLogLineMemoryColumnizerCallback, IDisp
     private readonly ReaderType _readerType;
     private readonly int _maximumLineLength;
 
+    private readonly LogBufferPool _bufferPool;
     private readonly Lock _logBufferLock = new();
     private readonly ReaderWriterLockSlim _bufferListLock = new(LockRecursionPolicy.SupportsRecursion);
 
@@ -101,6 +102,8 @@ private LogfileReader (string[] fileNames, EncodingOptions encodingOptions, bool
         _pluginRegistry = pluginRegistry;
         _disposed = false;
 
+        _bufferPool = new LogBufferPool(_max_buffers * 2);
+
         InitLruBuffers();
 
         ILogFileInfo fileInfo = null;
@@ -1300,11 +1303,15 @@ private void ReadToBufferList (ILogFileInfo logFileInfo, long filePos, int start
             {
                 if (_bufferList.Count == 0)
                 {
-                    logBuffer = new LogBuffer(logFileInfo, _maxLinesPerBuffer)
-                    {
-                        StartLine = startLine,
-                        StartPos = filePos
-                    };
+                    logBuffer = _bufferPool.Rent(logFileInfo, _maxLinesPerBuffer);
+                    logBuffer.StartLine = startLine;
+                    logBuffer.StartPos = filePos;
+                    // logBuffer.PrevBuffersDroppedLinesSum = droppedLines;
+                    // logBuffer = new LogBuffer(logFileInfo, _maxLinesPerBuffer)
+                    // {
+                    //     StartLine = startLine,
+                    //     StartPos = filePos
+                    // };
 
                     UpgradeBufferlistLockToWriterLock();
 
@@ -1323,11 +1330,15 @@ private void ReadToBufferList (ILogFileInfo logFileInfo, long filePos, int start
 
                     if (!logBuffer.FileInfo.FullName.Equals(logFileInfo.FullName, StringComparison.Ordinal))
                     {
-                        logBuffer = new LogBuffer(logFileInfo, _maxLinesPerBuffer)
-                        {
-                            StartLine = startLine,
-                            StartPos = filePos
-                        };
+                        logBuffer = _bufferPool.Rent(logFileInfo, _maxLinesPerBuffer);
+                        logBuffer.StartLine = startLine;
+                        logBuffer.StartPos = filePos;
+                        // logBuffer.PrevBuffersDroppedLinesSum = droppedLines;
+                        // logBuffer = new LogBuffer(logFileInfo, _maxLinesPerBuffer)
+                        // {
+                        //     StartLine = startLine,
+                        //     StartPos = filePos
+                        // };
 
                         UpgradeBufferlistLockToWriterLock();
 
@@ -1408,12 +1419,17 @@ private void ReadToBufferList (ILogFileInfo logFileInfo, long filePos, int start
                         Monitor.Exit(logBuffer);
                         try
                         {
-                            var newBuffer = new LogBuffer(logFileInfo, _maxLinesPerBuffer)
-                            {
-                                StartLine = lineNum,
-                                StartPos = filePos,
-                                PrevBuffersDroppedLinesSum = droppedLines
-                            };
+                            var newBuffer = _bufferPool.Rent(logFileInfo, _maxLinesPerBuffer);
+                            newBuffer.StartLine = lineNum;
+                            newBuffer.StartPos = filePos;
+                            newBuffer.PrevBuffersDroppedLinesSum = droppedLines;
+
+                            //var newBuffer = new LogBuffer(logFileInfo, _maxLinesPerBuffer)
+                            //{
+                            //    StartLine = lineNum,
+                            //    StartPos = filePos,
+                            //    PrevBuffersDroppedLinesSum = droppedLines
+                            //};
 
                             AcquireBufferListWriterLock();
 
@@ -1564,7 +1580,8 @@ private void GarbageCollectLruCache ()
                     try
                     {
                         removed.LogBuffer.AcquireContentLock(ref lockTaken);
-                        removed.LogBuffer.DisposeContent();
+                        //removed.LogBuffer.DisposeContent();
+                        _bufferPool.Return(removed.LogBuffer);
                     }
                     finally
                     {