Plumb through to avoid static hack so that the regular tests should pass

timothycoleman · timothycoleman · commit fe7aa6495378 · 2025-05-03T08:54:22.000+01:00
diff --git a/src/EventStore.Core.Tests/ClusterVNodeOptionsExtensions.cs b/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,
 			}
diff --git a/src/EventStore.Core.Tests/Helpers/MiniClusterNode.cs b/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
diff --git a/src/EventStore.Core.Tests/Helpers/MiniNode.cs b/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,
diff --git a/src/EventStore.Core.Tests/Services/RedactionService/SwitchChunkFailureTests.cs b/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);
diff --git a/src/EventStore.Core.Tests/Services/Replication/LogReplication/LogReplicationWithExistingDbFixture.cs b/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),
diff --git a/src/EventStore.Core.Tests/TransactionLog/Optimization/tfchunkreader_existsat_optimizer_should.cs b/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,
diff --git a/src/EventStore.Core.Tests/TransactionLog/Scavenging/scavenged_chunk.cs b/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,
diff --git a/src/EventStore.Core.Tests/TransactionLog/TFChunkHelper.cs b/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());
 		}
diff --git a/src/EventStore.Core.Tests/TransactionLog/Validation/when_validating_tfchunk_db.cs b/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;
diff --git a/src/EventStore.Core.Tests/TransactionLog/when_opening_existing_tfchunk.cs b/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());
diff --git a/src/EventStore.Core.Tests/TransactionLog/when_opening_tfchunk_from_non_existing_file.cs b/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()));
 		}
 	}
diff --git a/src/EventStore.Core.Tests/TransactionLog/when_reading_from_a_cached_tfchunk.cs b/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();
 		}
diff --git a/src/EventStore.Core.Tests/TransactionLog/when_uncaching_a_tfchunk.cs b/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();
diff --git a/src/EventStore.Core.Tests/options.cs b/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),
 			};
diff --git a/src/EventStore.Core.XUnit.Tests/Scavenge/Infrastructure/Scenario.cs b/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,
diff --git a/src/EventStore.Core/ClusterVNode.cs b/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,
diff --git a/src/EventStore.Core/ClusterVNodeOptions.cs b/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)),
diff --git a/src/EventStore.Core/Services/RedactionService.cs b/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,
diff --git a/src/EventStore.Core/TransactionLog/Chunks/ChunkCacheManager.cs b/src/EventStore.Core/TransactionLog/Chunks/ChunkCacheManager.cs
@@ -16,6 +16,8 @@ public class UnmanagedChunkCacheManager : IChunkCacheManager {
 	// the actual lengths of all the buffers
 	private readonly Dictionary<nint, int> _bufferLengths = [];
 
+//qq	public static UnmanagedChunkCacheManager Instance { get; } = new UnmanagedChunkCacheManager();
+
 	public nint AllocateAtLeast(int numBytes) {
 		lock (_lock) {
 			var pointer = Marshal.AllocHGlobal(numBytes);
diff --git a/src/EventStore.Core/TransactionLog/Chunks/TFChunk/TFChunk.cs b/src/EventStore.Core/TransactionLog/Chunks/TFChunk/TFChunk.cs
@@ -135,10 +135,9 @@ private enum CacheStatus {
 
 		private IChunkReadSide _readSide;
 
-		//qq temporary to save some plumbing
-		public static IChunkCacheManager DefaultCacheManager { get; set; } = new UnmanagedChunkCacheManager();
-
-		private TFChunk(string filename,
+		private TFChunk(
+			IChunkCacheManager cacheManager,
+			string filename,
 			int initialReaderCount,
 			int maxReaderCount,
 			int midpointsDepth,
@@ -154,6 +153,7 @@ private TFChunk(string filename,
 					"initialReaderCount is greater than maxReaderCount.");
 			Ensure.Nonnegative(midpointsDepth, "midpointsDepth");
 
+			_cacheManager = cacheManager;
 			_filename = filename;
 			_internalStreamsCount = initialReaderCount;
 			_maxReaderCount = maxReaderCount;
@@ -162,17 +162,15 @@ private TFChunk(string filename,
 			_unbuffered = unbuffered;
 			_writeThrough = writethrough;
 			_reduceFileCachePressure = reduceFileCachePressure;
-
-			_cacheManager = DefaultCacheManager;
 		}
 
 		~TFChunk() {
 			FreeCachedData();
 		}
 
-		public static TFChunk FromCompletedFile(string filename, bool verifyHash, bool unbufferedRead,
+		public static TFChunk FromCompletedFile(IChunkCacheManager cacheManager, string filename, bool verifyHash, bool unbufferedRead,
 			int initialReaderCount, int maxReaderCount, ITransactionFileTracker tracker, bool optimizeReadSideCache = false, bool reduceFileCachePressure = false) {
-			var chunk = new TFChunk(filename, initialReaderCount, maxReaderCount,
+			var chunk = new TFChunk(cacheManager, filename, initialReaderCount, maxReaderCount,
 				TFConsts.MidpointsDepth, false, unbufferedRead, false, reduceFileCachePressure);
 			try {
 				chunk.InitCompleted(verifyHash, optimizeReadSideCache, tracker);
@@ -184,9 +182,9 @@ public static TFChunk FromCompletedFile(string filename, bool verifyHash, bool u
 			return chunk;
 		}
 
-		public static TFChunk FromOngoingFile(string filename, int writePosition, bool checkSize, bool unbuffered,
+		public static TFChunk FromOngoingFile(IChunkCacheManager cacheManager, string filename, int writePosition, bool checkSize, bool unbuffered,
 			bool writethrough, int initialReaderCount, int maxReaderCount, bool reduceFileCachePressure, ITransactionFileTracker tracker) {
-			var chunk = new TFChunk(filename,
+			var chunk = new TFChunk(cacheManager, filename,
 				initialReaderCount,
 				maxReaderCount,
 				TFConsts.MidpointsDepth,
@@ -203,7 +201,9 @@ public static TFChunk FromOngoingFile(string filename, int writePosition, bool c
 			return chunk;
 		}
 
-		public static TFChunk CreateNew(string filename,
+		public static TFChunk CreateNew(
+			IChunkCacheManager cacheManager,
+			string filename,
 			int chunkSize,
 			int chunkStartNumber,
 			int chunkEndNumber,
@@ -218,11 +218,13 @@ public static TFChunk CreateNew(string filename,
 			var size = GetAlignedSize(chunkSize + ChunkHeader.Size + ChunkFooter.Size);
 			var chunkHeader = new ChunkHeader(CurrentChunkVersion, chunkSize, chunkStartNumber, chunkEndNumber,
 				isScavenged, Guid.NewGuid());
-			return CreateWithHeader(filename, chunkHeader, size, inMem, unbuffered, writethrough, initialReaderCount, maxReaderCount,
+			return CreateWithHeader(cacheManager, filename, chunkHeader, size, inMem, unbuffered, writethrough, initialReaderCount, maxReaderCount,
 				reduceFileCachePressure, tracker);
 		}
 
-		public static TFChunk CreateWithHeader(string filename,
+		public static TFChunk CreateWithHeader(
+			IChunkCacheManager cacheManager,
+			string filename,
 			ChunkHeader header,
 			int fileSize,
 			bool inMem,
@@ -232,7 +234,7 @@ public static TFChunk CreateWithHeader(string filename,
 			int maxReaderCount,
 			bool reduceFileCachePressure,
 			ITransactionFileTracker tracker) {
-			var chunk = new TFChunk(filename,
+			var chunk = new TFChunk(cacheManager, filename,
 				initialReaderCount,
 				maxReaderCount,
 				TFConsts.MidpointsDepth,
@@ -421,7 +423,9 @@ private void CreateInMemChunk(ChunkHeader chunkHeader, int fileSize) {
 			// ALLOCATE MEM
 			_cacheStatus = CacheStatus.Cached;
 			_cachedLength = fileSize;
-			_cachedData = _cacheManager.AllocateAtLeast(_cachedLength);
+			//qq no point in pooling for inmemdb, it just makes it harder for the tests to free the memory
+			_cachedData = Marshal.AllocHGlobal(_cachedLength);
+			GC.AddMemoryPressure(_cachedLength);
 
 			// WRITER STREAM
 			var memStream =
diff --git a/src/EventStore.Core/TransactionLog/Chunks/TFChunkDb.cs b/src/EventStore.Core/TransactionLog/Chunks/TFChunkDb.cs
@@ -16,12 +16,13 @@ public class TFChunkDb : IDisposable {
 		private readonly ITransactionFileTracker _tracker;
 		private int _closed;
 
-		public TFChunkDb(TFChunkDbConfig config, ITransactionFileTracker tracker = null, ILogger log = null) {
+		public TFChunkDb(TFChunkDbConfig config, IChunkCacheManager cacheManager = null, ITransactionFileTracker tracker = null, ILogger log = null) {
 			Ensure.NotNull(config, "config");
 
 			Config = config;
 			_tracker = tracker ?? new TFChunkTracker.NoOp();
-			Manager = new TFChunkManager(Config, _tracker);
+			cacheManager ??= new UnmanagedChunkCacheManager();
+			Manager = new TFChunkManager(Config, cacheManager, _tracker);
 			_log = log ?? Serilog.Log.ForContext<TFChunkDb>();
 		}
 
@@ -72,15 +73,19 @@ public void Open(bool verifyHash = true, bool readOnly = false, int threads = 1)
 							// but the actual last chunk is (lastChunkNum-1) one and it could be not completed yet -- perfectly valid situation.
 							var footer = ReadChunkFooter(chunkInfo.ChunkFileName);
 							if (footer.IsCompleted)
-								chunk = TFChunk.TFChunk.FromCompletedFile(chunkInfo.ChunkFileName, verifyHash: false,
+								chunk = TFChunk.TFChunk.FromCompletedFile(
+									Manager.ChunkCacheManager,
+									chunkInfo.ChunkFileName, verifyHash: false,
 									unbufferedRead: Config.Unbuffered,
 									initialReaderCount: Config.InitialReaderCount,
 									maxReaderCount: Config.MaxReaderCount,
 									tracker: _tracker,
 									optimizeReadSideCache: Config.OptimizeReadSideCache,
 									reduceFileCachePressure: Config.ReduceFileCachePressure);
 							else {
-								chunk = TFChunk.TFChunk.FromOngoingFile(chunkInfo.ChunkFileName, Config.ChunkSize,
+								chunk = TFChunk.TFChunk.FromOngoingFile(
+									Manager.ChunkCacheManager,
+									chunkInfo.ChunkFileName, Config.ChunkSize,
 									checkSize: false,
 									unbuffered: Config.Unbuffered,
 									writethrough: Config.WriteThrough, initialReaderCount: Config.InitialReaderCount,
@@ -92,7 +97,9 @@ public void Open(bool verifyHash = true, bool readOnly = false, int threads = 1)
 									chunk.Complete();
 							}
 						} else {
-							chunk = TFChunk.TFChunk.FromCompletedFile(chunkInfo.ChunkFileName, verifyHash: false,
+							chunk = TFChunk.TFChunk.FromCompletedFile(
+								Manager.ChunkCacheManager,
+								chunkInfo.ChunkFileName, verifyHash: false,
 								unbufferedRead: Config.Unbuffered,
 								initialReaderCount: Config.InitialReaderCount,
 								maxReaderCount: Config.MaxReaderCount,
@@ -121,7 +128,9 @@ public void Open(bool verifyHash = true, bool readOnly = false, int threads = 1)
 				var chunkHeader = ReadChunkHeader(chunkFileName);
 				var chunkLocalPos = chunkHeader.GetLocalLogPosition(checkpoint);
 				if (chunkHeader.IsScavenged) {
-					var lastChunk = TFChunk.TFChunk.FromCompletedFile(chunkFileName, verifyHash: false,
+					var lastChunk = TFChunk.TFChunk.FromCompletedFile(
+						Manager.ChunkCacheManager,
+						chunkFileName, verifyHash: false,
 						unbufferedRead: Config.Unbuffered,
 						initialReaderCount: Config.InitialReaderCount,
 						maxReaderCount: Config.MaxReaderCount,
@@ -148,7 +157,9 @@ public void Open(bool verifyHash = true, bool readOnly = false, int threads = 1)
 						Manager.AddNewChunk();
 					}
 				} else {
-					var lastChunk = TFChunk.TFChunk.FromOngoingFile(chunkFileName, (int)chunkLocalPos, checkSize: false,
+					var lastChunk = TFChunk.TFChunk.FromOngoingFile(
+						Manager.ChunkCacheManager,
+						chunkFileName, (int)chunkLocalPos, checkSize: false,
 						unbuffered: Config.Unbuffered,
 						writethrough: Config.WriteThrough, initialReaderCount: Config.InitialReaderCount,
 						maxReaderCount: Config.MaxReaderCount,
diff --git a/src/EventStore.Core/TransactionLog/Chunks/TFChunkManager.cs b/src/EventStore.Core/TransactionLog/Chunks/TFChunkManager.cs
diff --git a/src/EventStore.Core/TransactionLog/Chunks/TFChunkScavenger.cs b/src/EventStore.Core/TransactionLog/Chunks/TFChunkScavenger.cs
diff --git a/src/EventStore.Core/TransactionLog/Scavenging/DbAccess/ChunkManagerForExecutor.cs b/src/EventStore.Core/TransactionLog/Scavenging/DbAccess/ChunkManagerForExecutor.cs
diff --git a/src/EventStore.Core/TransactionLog/Scavenging/DbAccess/ChunkWriterForExecutor.cs b/src/EventStore.Core/TransactionLog/Scavenging/DbAccess/ChunkWriterForExecutor.cs

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ public static ClusterVNodeOptions ReduceMemoryUsageForTests(this ClusterVNodeOpt`
`12`	`12`	`Database = options.Database with {`
`13`	`13`	`ChunkSize = MiniNode.ChunkSize,`
`14`	`14`	`ChunksCacheSize = MiniNode.CachedChunkSize,`
	`15`	`+ ChunkCachePooling = false,`
`15`	`16`	`StreamExistenceFilterSize = 10_000,`
`16`	`17`	`ScavengeBackendCacheSize = 64 * 1024,`
`17`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,9 @@ public static TFChunkDbConfig CreateDbConfig(`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`public static TFChunk CreateNewChunk(string fileName, int chunkSize = 4096, bool isScavenged = false) {`
`73`		`- return TFChunk.CreateNew(fileName, chunkSize, 0, 0,`
	`73`	`+ return TFChunk.CreateNew(`
	`74`	`+ new UnmanagedChunkCacheManager(),`
	`75`	`+ fileName, chunkSize, 0, 0,`
`74`	`76`	`isScavenged: isScavenged, inMem: false, unbuffered: false,`
`75`	`77`	`writethrough: false, initialReaderCount: Constants.TFChunkInitialReaderCountDefault, maxReaderCount: Constants.TFChunkMaxReaderCountDefault, reduceFileCachePressure: false, tracker: new TFChunkTracker.NoOp());`
`76`	`78`	`}`