Merge branch 'main' into 273-integrated-memory-tracking273-integrated-memory-tracking

1 files changed, 36 insertions, 16 deletions

diff --git a/src/zenserver/cache/cachedisklayer.h b/src/zenserver/cache/cachedisklayer.h
index 277371f2c..6997a12e4 100644
--- a/src/zenserver/cache/cachedisklayer.h
+++ b/src/zenserver/cache/cachedisklayer.h
@@ -197,15 +197,15 @@ public:
 		CacheBucket(GcManager& Gc, std::atomic_uint64_t& OuterCacheMemoryUsage, std::string BucketName, const BucketConfiguration& Config);
 		~CacheBucket();
 
-		bool OpenOrCreate(std::filesystem::path BucketDir, bool AllowCreate = true);
-		bool Get(const IoHash& HashKey, ZenCacheValue& OutValue);
-		void Put(const IoHash& HashKey, const ZenCacheValue& Value, std::span<IoHash> References);
-		void MemCacheTrim(GcClock::TimePoint ExpireTime);
-		bool Drop();
-		void Flush();
-		void ScrubStorage(ScrubContext& Ctx);
-		void GatherReferences(GcContext& GcCtx);
-		void CollectGarbage(GcContext& GcCtx);
+		bool	 OpenOrCreate(std::filesystem::path BucketDir, bool AllowCreate = true);
+		bool	 Get(const IoHash& HashKey, ZenCacheValue& OutValue);
+		void	 Put(const IoHash& HashKey, const ZenCacheValue& Value, std::span<IoHash> References);
+		uint64_t MemCacheTrim(GcClock::TimePoint ExpireTime);
+		bool	 Drop();
+		void	 Flush();
+		void	 ScrubStorage(ScrubContext& Ctx);
+		void	 GatherReferences(GcContext& GcCtx);
+		void	 CollectGarbage(GcContext& GcCtx);
 
 		inline GcStorageSize StorageSize() const
 		{
@@ -218,7 +218,7 @@ public:
 		CacheValueDetails::BucketDetails GetValueDetails(RwLock::SharedLockScope& IndexLock, const std::string_view ValueFilter) const;
 		void EnumerateBucketContents(std::function<void(const IoHash& Key, const CacheValueDetails::ValueDetails& Details)>& Fn) const;
 
-		void GetUsageByAccess(GcClock::TimePoint TickStart, GcClock::Duration SectionLength, std::vector<uint64_t>& InOutUsageSlots);
+		void GetUsageByAccess(GcClock::TimePoint Now, GcClock::Duration MaxAge, std::vector<uint64_t>& InOutUsageSlots);
 #if ZEN_WITH_TESTS
 		void SetAccessTime(const IoHash& HashKey, GcClock::TimePoint Time);
 #endif	// ZEN_WITH_TESTS
@@ -286,6 +286,11 @@ public:
 
 			operator bool() const { return RawSize != 0 || RawHash != IoHash::Zero; };
 		};
+		struct MemCacheData
+		{
+			IoBuffer	 Payload;
+			PayloadIndex OwnerIndex;
+		};
 #pragma pack(pop)
 		static_assert(sizeof(BucketPayload) == 20u);
 		static_assert(sizeof(BucketMetaData) == 28u);
@@ -323,7 +328,7 @@ public:
 		std::vector<BucketPayload>	m_Payloads;
 		std::vector<BucketMetaData> m_MetaDatas;
 		std::vector<MetaDataIndex>	m_FreeMetaDatas;
-		std::vector<IoBuffer>		m_MemCachedPayloads;
+		std::vector<MemCacheData>	m_MemCachedPayloads;
 		std::vector<MemCachedIndex> m_FreeMemCachedPayloads;
 		std::vector<ReferenceIndex> m_FirstReferenceIndex;
 		std::vector<IoHash>			m_ReferenceHashes;
@@ -364,7 +369,7 @@ public:
 								   const ZenCacheDiskLayer::CacheBucket::BucketMetaData& MetaData);
 		void		   RemoveMetaData(RwLock::ExclusiveLockScope&, BucketPayload& Payload);
 		BucketMetaData GetMetaData(RwLock::SharedLockScope&, const BucketPayload& Payload) const;
-		void		   SetMemCachedData(RwLock::ExclusiveLockScope&, BucketPayload& Payload, IoBuffer& MemCachedData);
+		void		   SetMemCachedData(RwLock::ExclusiveLockScope&, PayloadIndex PayloadIndex, IoBuffer& MemCachedData);
 		size_t		   RemoveMemCachedData(RwLock::ExclusiveLockScope&, BucketPayload& Payload);
 
 		void	 InitializeIndexFromDisk(RwLock::ExclusiveLockScope&, bool IsNew);
@@ -390,7 +395,7 @@ public:
 						  std::vector<BucketPayload>&  Payloads,
 						  std::vector<AccessTime>&	   AccessTimes,
 						  std::vector<BucketMetaData>& MetaDatas,
-						  std::vector<IoBuffer>&	   MemCachedPayloads,
+						  std::vector<MemCacheData>&   MemCachedPayloads,
 						  std::vector<ReferenceIndex>& FirstReferenceIndex,
 						  IndexMap&					   Index,
 						  RwLock::ExclusiveLockScope&  IndexLock);
@@ -405,6 +410,10 @@ public:
 			m_MemCachedSize.fetch_sub(ValueSize, std::memory_order::relaxed);
 			m_OuterCacheMemoryUsage.fetch_sub(ValueSize, std::memory_order::relaxed);
 		}
+		static inline uint64_t EstimateMemCachePayloadMemory(uint64_t PayloadSize)
+		{
+			return sizeof(MemCacheData) + sizeof(IoBufferCore) + RoundUp(PayloadSize, 8u);
+		}
 
 		// These locks are here to avoid contention on file creation, therefore it's sufficient
 		// that we take the same lock for the same hash
@@ -436,10 +445,21 @@ private:
 		{
 			return;
 		}
+		if (m_IsMemCacheTrimming)
+		{
+			return;
+		}
+
+		const GcClock::Tick NowTick = GcClock::TickCount();
+		if (NowTick < m_NextAllowedTrimTick)
+		{
+			return;
+		}
+
 		MemCacheTrim();
 	}
-	void MemCacheTrim();
-	void MemCacheTrim(std::vector<CacheBucket*>& Buckets, GcClock::TimePoint ExpireTime);
+	void	 MemCacheTrim();
+	uint64_t MemCacheTrim(std::vector<CacheBucket*>& Buckets, GcClock::TimePoint ExpireTime);
 
 	GcManager&													  m_Gc;
 	JobQueue&													  m_JobQueue;
@@ -447,7 +467,7 @@ private:
 	Configuration												  m_Configuration;
 	std::atomic_uint64_t										  m_TotalMemCachedSize{};
 	std::atomic_bool											  m_IsMemCacheTrimming = false;
-	std::atomic<GcClock::Tick>									  m_LastTickMemCacheTrim;
+	std::atomic<GcClock::Tick>									  m_NextAllowedTrimTick;
 	mutable RwLock												  m_Lock;
 	std::unordered_map<std::string, std::unique_ptr<CacheBucket>> m_Buckets;
 	std::vector<std::unique_ptr<CacheBucket>>					  m_DroppedBuckets;