Naive POC: recycle buffers used for chunk cache

src/EventStore.Core.Tests/ClusterVNodeOptionsExtensions.cs

@@ -12,6 +12,7 @@ public static ClusterVNodeOptions ReduceMemoryUsageForTests(this ClusterVNodeOpt
 			Database = options.Database with {
 				ChunkSize = MiniNode.ChunkSize,
 				ChunksCacheSize = MiniNode.CachedChunkSize,
+				ChunkCachePooling = false,
 				StreamExistenceFilterSize = 10_000,
 				ScavengeBackendCacheSize = 64 * 1024,
 			}

src/EventStore.Core.Tests/Helpers/MiniClusterNode.cs

@@ -136,6 +136,7 @@ public MiniClusterNode(string pathname, int debugIndex, IPEndPoint internalTcp,
 					MaxMemTableSize = memTableSize,
 					MemDb = inMemDb,
 					Db = _dbPath,
+					ChunkCachePooling = false,
 					ChunkSize = MiniNode.ChunkSize,
 					ChunksCacheSize = MiniNode.CachedChunkSize,
 					StreamExistenceFilterSize = 10_000

src/EventStore.Core.Tests/Helpers/MiniNode.cs

@@ -115,6 +115,7 @@ public MiniNode(string pathname,
 					Database = new() {
 						ChunkSize = chunkSize,
 						ChunksCacheSize = cachedChunkSize,
+						ChunkCachePooling = false,
 						SkipDbVerify = true,
 						StatsStorage = StatsStorage.None,
 						MaxMemTableSize = memTableSize,

src/EventStore.Core.Tests/Services/RedactionService/SwitchChunkFailureTests.cs

@@ -131,7 +131,9 @@ public async Task cannot_switch_with_chunk_having_mismatched_range() {
 
 			newChunk = $"{nameof(cannot_switch_with_chunk_having_mismatched_range)}-chunk-0-2.tmp";
 			var chunkHeader = new ChunkHeader(1, 1024, 0, 2, true, Guid.NewGuid());
-			var chunk = TFChunk.CreateWithHeader(Path.Combine(PathName, newChunk), chunkHeader, 1024, false, false, false, 1, 1, false,
+			var chunk = TFChunk.CreateWithHeader(
+				new UnmanagedChunkCacheManager(),
+				Path.Combine(PathName, newChunk), chunkHeader, 1024, false, false, false, 1, 1, false,
 				new TFChunkTracker.NoOp());
 			chunk.Dispose();
 			msg = await SwitchChunk(GetChunk(0, 0), newChunk);

src/EventStore.Core.Tests/Services/Replication/LogReplication/LogReplicationWithExistingDbFixture.cs

@@ -38,6 +38,7 @@ protected static Task CreateChunk(TFChunkDb db, bool raw, bool complete, int chu
 			chunkId: Guid.NewGuid());
 
 		var chunk = TFChunk.CreateWithHeader(
+			new UnmanagedChunkCacheManager(),
 			filename: filename,
 			header: header,
 			fileSize: TFChunk.GetAlignedSize(db.Config.ChunkSize + ChunkHeader.Size + ChunkFooter.Size),

src/EventStore.Core.Tests/TransactionLog/Optimization/tfchunkreader_existsat_optimizer_should.cs

@@ -87,7 +87,9 @@ private TFChunk CreateChunk(int chunkNumber, bool scavenged) {
 
 		private TFChunk CreateChunk(int chunkNumber, bool scavenged, out List<PosMap> posmap) {
 			var map = new List<PosMap>();
-			var chunk = TFChunk.CreateNew(GetFilePathFor("chunk-" + chunkNumber + "-" + Guid.NewGuid()), 1024 * 1024,
+			var chunk = TFChunk.CreateNew(
+				new UnmanagedChunkCacheManager(),
+				GetFilePathFor("chunk-" + chunkNumber + "-" + Guid.NewGuid()), 1024 * 1024,
 				chunkNumber, chunkNumber, scavenged, false, false, false,
 				Constants.TFChunkInitialReaderCountDefault,
 				Constants.TFChunkMaxReaderCountDefault,

src/EventStore.Core.Tests/TransactionLog/Scavenging/scavenged_chunk.cs

@@ -11,7 +11,9 @@ public class scavenged_chunk : SpecificationWithFile {
 		[Test]
 		public void is_fully_resident_in_memory_when_cached() {
 			var map = new List<PosMap>();
-			var chunk = TFChunk.CreateNew(Filename, 1024 * 1024, 0, 0, true, false, false, false,
+			var chunk = TFChunk.CreateNew(
+				new UnmanagedChunkCacheManager(),
+				Filename, 1024 * 1024, 0, 0, true, false, false, false,
 				Constants.TFChunkInitialReaderCountDefault,
 				Constants.TFChunkMaxReaderCountDefault,
 				false,

src/EventStore.Core.Tests/TransactionLog/TFChunkHelper.cs

@@ -70,7 +70,9 @@ public static TFChunkDbConfig CreateDbConfig(
 		}
 
 		public static TFChunk CreateNewChunk(string fileName, int chunkSize = 4096, bool isScavenged = false) {
-			return TFChunk.CreateNew(fileName, chunkSize, 0, 0,
+			return TFChunk.CreateNew(
+				new UnmanagedChunkCacheManager(),
+				fileName, chunkSize, 0, 0,
 				isScavenged: isScavenged, inMem: false, unbuffered: false,
 				writethrough: false, initialReaderCount: Constants.TFChunkInitialReaderCountDefault, maxReaderCount: Constants.TFChunkMaxReaderCountDefault, reduceFileCachePressure: false, tracker: new TFChunkTracker.NoOp());
 		}

src/EventStore.Core.Tests/TransactionLog/Validation/when_validating_tfchunk_db.cs

@@ -446,7 +446,7 @@ public void when_prelast_chunk_corrupted_throw_hash_validation_exception() {
 				.WriteTo.Sink(sink)
 				.MinimumLevel.Verbose()
 				.CreateLogger())
-			using (var db = new TFChunkDb(config, new TFChunkTracker.NoOp(), log)) {
+			using (var db = new TFChunkDb(config, new UnmanagedChunkCacheManager(), new TFChunkTracker.NoOp(), log)) {
 				byte[] contents = new byte[config.ChunkSize];
 				for (var i = 0; i < config.ChunkSize; i++) {
 					contents[i] = 0;

src/EventStore.Core.Tests/TransactionLog/when_opening_existing_tfchunk.cs

@@ -15,7 +15,9 @@ public override void TestFixtureSetUp() {
 			base.TestFixtureSetUp();
 			_chunk = TFChunkHelper.CreateNewChunk(Filename);
 			_chunk.Complete();
-			_testChunk = TFChunk.FromCompletedFile(Filename, true, false,
+			_testChunk = TFChunk.FromCompletedFile(
+				new UnmanagedChunkCacheManager(),
+				Filename, true, false,
 				Constants.TFChunkInitialReaderCountDefault,
 				Constants.TFChunkMaxReaderCountDefault,
 				reduceFileCachePressure: false, tracker: new TFChunkTracker.NoOp());

src/EventStore.Core.Tests/TransactionLog/when_opening_tfchunk_from_non_existing_file.cs

@@ -8,7 +8,9 @@ namespace EventStore.Core.Tests.TransactionLog {
 	public class when_opening_tfchunk_from_non_existing_file : SpecificationWithFile {
 		[Test]
 		public void it_should_throw_a_file_not_found_exception() {
-			Assert.Throws<CorruptDatabaseException>(() => TFChunk.FromCompletedFile(Filename, verifyHash: true,
+			Assert.Throws<CorruptDatabaseException>(() => TFChunk.FromCompletedFile(
+				new UnmanagedChunkCacheManager(),
+				Filename, verifyHash: true,
 				unbufferedRead: false, initialReaderCount: Constants.TFChunkInitialReaderCountDefault, maxReaderCount: Constants.TFChunkMaxReaderCountDefault, reduceFileCachePressure: false, tracker: new TFChunkTracker.NoOp()));
 		}
 	}

src/EventStore.Core.Tests/TransactionLog/when_reading_from_a_cached_tfchunk.cs

@@ -29,7 +29,9 @@ public override void TestFixtureSetUp() {
 			_result = _chunk.TryAppend(_record);
 			_chunk.Flush();
 			_chunk.Complete();
-			_cachedChunk = TFChunk.FromCompletedFile(Filename, verifyHash: true, unbufferedRead: false,
+			_cachedChunk = TFChunk.FromCompletedFile(
+				new UnmanagedChunkCacheManager(),
+				Filename, verifyHash: true, unbufferedRead: false,
 				initialReaderCount: Constants.TFChunkInitialReaderCountDefault, maxReaderCount: Constants.TFChunkMaxReaderCountDefault, reduceFileCachePressure: false, tracker: new TFChunkTracker.NoOp());
 			_cachedChunk.CacheInMemory();
 		}

src/EventStore.Core.Tests/TransactionLog/when_uncaching_a_tfchunk.cs

@@ -29,7 +29,9 @@ public override void TestFixtureSetUp() {
 			_result = _chunk.TryAppend(_record);
 			_chunk.Flush();
 			_chunk.Complete();
-			_uncachedChunk = TFChunk.FromCompletedFile(Filename, verifyHash: true, unbufferedRead: false,
+			_uncachedChunk = TFChunk.FromCompletedFile(
+				new UnmanagedChunkCacheManager(),
+				Filename, verifyHash: true, unbufferedRead: false,
 				initialReaderCount: Constants.TFChunkInitialReaderCountDefault, maxReaderCount: Constants.TFChunkMaxReaderCountDefault, reduceFileCachePressure: false, tracker: new TFChunkTracker.NoOp());
 			_uncachedChunk.CacheInMemory();
 			_uncachedChunk.UnCacheFromMemory();

src/EventStore.Core.Tests/options.cs

@@ -62,7 +62,7 @@ public void all_keys_are_read_from_configuration() {
 				nameof(ClusterVNodeOptions.TrustedRootCertificates), 
 				nameof(ClusterVNodeOptions.IndexBitnessVersion), 
 				nameof(ClusterVNodeOptions.Cluster.QuorumSize),
-				nameof(ClusterVNodeOptions.Database.ChunkSize),
+				nameof(ClusterVNodeOptions.Database.ChunkSize), //qq do we want to exclude this
 				nameof(ClusterVNodeOptions.Database.StatsStorage),
 				nameof(ClusterVNodeOptions.Unknown.Options),
 			};

src/EventStore.Core.XUnit.Tests/Scavenge/Infrastructure/Scenario.cs

@@ -705,6 +705,7 @@ private void EmptyRequestedChunks(TFChunkDb db) {
 					chunkId: Guid.NewGuid());
 
 				var newChunk = TFChunk.CreateWithHeader(
+					new UnmanagedChunkCacheManager(),
 					filename: $"{chunk.FileName}.tmp",
 					header: newChunkHeader,
 					fileSize: ChunkHeader.Size,

src/EventStore.Core.XUnit.Tests/TransactionLog/Chunks/PoolingChunkCacheManagerTests.cs

@@ -0,0 +1,97 @@
+using System.Collections.Generic;
+using EventStore.Core.TransactionLog.Chunks;
+using Xunit;
+
+namespace EventStore.Core.XUnit.Tests.TransactionLog.Chunks;
+
+public class PoolingChunkCacheManagerTests {
+	readonly FakeInnerManager _recorder = new();
+
+	private PoolingChunkCacheManager CreateSut(int initialBuffers) =>
+		new(_recorder, minBufferSize: 100, cleanBuffers: false, initialBuffers: initialBuffers);
+
+	[Fact]
+	public void can_allocate_multiple_buffers() {
+		var sut = CreateSut(initialBuffers: 0);
+		sut.AllocateAtLeast(99);
+		sut.AllocateAtLeast(100);
+		sut.AllocateAtLeast(101);
+		Assert.Equal<string>(
+			[
+				"Allocated buffer 0 with 100 bytes", // respects minimum
+				"Allocated buffer 1 with 100 bytes",
+				"Allocated buffer 2 with 101 bytes", // can allocate larger
+			],
+			_recorder.GetNewMessages());
+	}
+
+	[Fact]
+	public void can_reuse_buffers() {
+		var sut = CreateSut(initialBuffers: 0);
+		var p0 = sut.AllocateAtLeast(100);
+		sut.Free(p0);
+
+		sut.AllocateAtLeast(101);
+		sut.AllocateAtLeast(100); // reuse p1
+		sut.AllocateAtLeast(101);
+
+		Assert.Equal<string>(
+			[
+				"Allocated buffer 0 with 100 bytes",
+				"Allocated buffer 1 with 101 bytes",
+				"Allocated buffer 2 with 101 bytes",
+			],
+			_recorder.GetNewMessages());
+	}
+
+	[Fact]
+	public void can_reuse_smaller_buffers() {
+		var sut = CreateSut(initialBuffers: 0);
+		var p0 = sut.AllocateAtLeast(90);
+		sut.Free(p0);
+
+		sut.AllocateAtLeast(95);
+
+		Assert.Equal<string>(["Allocated buffer 0 with 100 bytes"], _recorder.GetNewMessages());
+	}
+
+	[Fact]
+	public void can_create_initial_buffers() {
+		var sut = CreateSut(initialBuffers: 3);
+
+		Assert.Equal<string>(
+			[
+				"Allocated buffer 0 with 100 bytes",
+				"Allocated buffer 1 with 100 bytes",
+				"Allocated buffer 2 with 100 bytes",
+			],
+			_recorder.GetNewMessages());
+
+		sut.AllocateAtLeast(100);
+		sut.AllocateAtLeast(100);
+		sut.AllocateAtLeast(100);
+
+		Assert.Equal<string>([], _recorder.GetNewMessages());
+	}
+
+	class FakeInnerManager : IChunkCacheManager {
+		readonly List<string> _messages = [];
+		nint _nextBuffer;
+
+		public string[] GetNewMessages() {
+			var newMessages = _messages.ToArray();
+			_messages.Clear();
+			return newMessages;
+		}
+
+		public nint AllocateAtLeast(int numBytes) {
+			var p = _nextBuffer++;
+			_messages.Add($"Allocated buffer {p} with {numBytes} bytes");
+			return p;
+		}
+
+		public void Free(nint pointer) {
+			_messages.Add($"Freed buffer {pointer}");
+		}
+	}
+}

src/EventStore.Core/ClusterVNode.cs

@@ -306,7 +306,36 @@ public ClusterVNode(ClusterVNodeOptions options,
 			metricsConfiguration ??= new();
 			MetricsBootstrapper.Bootstrap(metricsConfiguration, dbConfig, trackers);
 
-			Db = new TFChunkDb(dbConfig, tracker: trackers.TransactionFileTracker);
+
+
+			IChunkCacheManager cacheManager = new UnmanagedChunkCacheManager();
+
+			if (options.Database.ChunkCachePooling) {
+				var chunkTotalSize = dbConfig.ChunkSize + ChunkHeader.Size + ChunkFooter.Size;
+				var cacheSizeBytes = dbConfig.MaxChunksCacheSize.RoundUpToMultipleOf(chunkTotalSize);
+				var cacheSizePhysicalChunks = cacheSizeBytes / chunkTotalSize;
+				var initialBuffers = cacheSizePhysicalChunks + 2;
+
+				var allowanceForPosMap = 16 * 1024 * 1024; //qq hand wave. 6% increase in chunk cache memory usage acceptable
+
+				Log.Information($"#### Chunk cache pooling is enabled");
+				Log.Information($"#### Pre-allocating {initialBuffers} initialBuffers based on chunk cache size of {cacheSizePhysicalChunks} chunks.");
+
+				cacheManager = new PoolingChunkCacheManager(
+					inner: cacheManager,
+					minBufferSize: chunkTotalSize + allowanceForPosMap,
+					cleanBuffers: true,
+					initialBuffers: (int)initialBuffers);
+			} else {
+				Log.Information($"#### Chunk cache pooling is disabled");
+			}
+
+
+
+			Db = new TFChunkDb(
+				dbConfig,
+				cacheManager: cacheManager,
+				tracker: trackers.TransactionFileTracker);
 
 			TFChunkDbConfig CreateDbConfig(
 				out SystemStatsHelper statsHelper,

src/EventStore.Core/ClusterVNodeOptions.cs

@@ -415,6 +415,10 @@ public record ClusterOptions {
 
 		[Description("Database Options")]
 		public record DatabaseOptions {
+			//qq
+			[Description("Enabled Chunk Cache Buffer Pooling (experimental)")]
+			public bool ChunkCachePooling { get; init; } = true;
+
 			[Description("The minimum flush delay in milliseconds.")]
 			public double MinFlushDelayMs { get; init; } = TFConsts.MinFlushDelayMs.TotalMilliseconds;
 
@@ -579,6 +583,7 @@ public static int GetTFChunkMaxReaderCount(int readerThreadsCount, int chunkInit
 
 
 			internal static DatabaseOptions FromConfiguration(IConfigurationRoot configurationRoot) => new() {
+				ChunkCachePooling = configurationRoot.GetValue<bool>(nameof(ChunkCachePooling)),
 				MinFlushDelayMs = configurationRoot.GetValue<double>(nameof(MinFlushDelayMs)),
 				DisableScavengeMerging = configurationRoot.GetValue<bool>(nameof(DisableScavengeMerging)),
 				MemDb = configurationRoot.GetValue<bool>(nameof(MemDb)),

src/EventStore.Core/Services/RedactionService.cs

@@ -244,6 +244,7 @@ private bool IsValidSwitchChunkRequest(string targetChunkFile, string newChunkFi
 			try {
 				// temporarily open the chunk to verify its integrity
 				newChunk = TFChunk.FromCompletedFile(
+					_db.Manager.ChunkCacheManager,
 					filename: newChunkPath,
 					verifyHash: true,
 					unbufferedRead: _db.Config.Unbuffered,