optimize cache bucket state writing (#382)

* optimize cache bucket snapshot and sidecar writing

1 files changed, 59 insertions, 42 deletions

diff --git a/src/zenstore/cache/cachedisklayer.cpp b/src/zenstore/cache/cachedisklayer.cpp
index da5038984..fbe559e58 100644
--- a/src/zenstore/cache/cachedisklayer.cpp
+++ b/src/zenstore/cache/cachedisklayer.cpp
@@ -318,10 +318,10 @@ private:
 #pragma pack(4)
 	struct ManifestData
 	{
-		uint32_t   RawSize;	   // 4
-		AccessTime Timestamp;  // 4
-		IoHash	   RawHash;	   // 20
-		IoHash	   Key;		   // 20
+		uint32_t RawSize;			 // 4
+		uint32_t SecondsSinceEpoch;	 // 4
+		IoHash	 RawHash;			 // 20
+		IoHash	 Key;				 // 20
 	};
 #pragma pack(pop)
 
@@ -603,7 +603,7 @@ BucketManifestSerializer::ReadSidecarFile(RwLock::ExclusiveLockScope&								  B
 
 			ZenCacheDiskLayer::CacheBucket::BucketPayload& PayloadEntry = Payloads[PlIndex];
 
-			AccessTimes[PlIndex] = Entry->Timestamp;
+			AccessTimes[PlIndex].SetSecondsSinceEpoch(Entry->SecondsSinceEpoch);
 
 			if (Entry->RawSize && Entry->RawHash != IoHash::Zero)
 			{
@@ -630,6 +630,16 @@ BucketManifestSerializer::WriteSidecarFile(RwLock::SharedLockScope&,
 {
 	ZEN_TRACE_CPU("Z$::WriteSidecarFile");
 
+	ZEN_DEBUG("writing store sidecar for '{}'", SidecarPath);
+	const uint64_t EntryCount = Index.size();
+	Stopwatch	   Timer;
+	const auto	   _ = MakeGuard([&] {
+		ZEN_INFO("wrote store sidecar for '{}' containing {} entries in {}",
+				 SidecarPath,
+				 EntryCount,
+				 NiceTimeSpanMs(Timer.GetElapsedTimeMs()));
+	});
+
 	BucketMetaHeader Header;
 	Header.EntryCount  = m_ManifestEntryCount;
 	Header.LogPosition = SnapshotLogPosition;
@@ -647,43 +657,44 @@ BucketManifestSerializer::WriteSidecarFile(RwLock::SharedLockScope&,
 
 	SidecarFile.Write(&Header, sizeof Header, 0);
 
-	// TODO: make this batching for better performance
 	{
 		uint64_t WriteOffset = sizeof Header;
 
-		//		BasicFileWriter SidecarWriter(SidecarFile, 128 * 1024);
+		const size_t MaxManifestDataBufferCount = (512u * 1024u) / sizeof(ManifestData);
 
-		std::vector<ManifestData> ManifestDataBuffer;
-		const size_t			  MaxManifestDataBufferCount = Min(Index.size(), 8192u);  // 512 Kb
-		ManifestDataBuffer.reserve(MaxManifestDataBufferCount);
+		std::vector<ManifestData> ManifestDataBuffer(Min(m_ManifestEntryCount, MaxManifestDataBufferCount));
+		auto					  WriteIt = ManifestDataBuffer.begin();
 		for (auto& Kv : Index)
 		{
-			const IoHash&	   Key	   = Kv.first;
-			const PayloadIndex PlIndex = Kv.second;
+			ManifestData& Data = *WriteIt++;
 
-			IoHash	 RawHash = IoHash::Zero;
-			uint32_t RawSize = 0;
+			const PayloadIndex PlIndex = Kv.second;
+			Data.Key				   = Kv.first;
+			Data.SecondsSinceEpoch	   = AccessTimes[PlIndex].GetSecondsSinceEpoch();
 
 			if (const MetaDataIndex MetaIndex = Payloads[PlIndex].MetaData)
 			{
-				RawHash = MetaDatas[MetaIndex].RawHash;
-				RawSize = MetaDatas[MetaIndex].RawSize;
+				Data.RawHash = MetaDatas[MetaIndex].RawHash;
+				Data.RawSize = MetaDatas[MetaIndex].RawSize;
+			}
+			else
+			{
+				Data.RawHash = IoHash::Zero;
+				Data.RawSize = 0;
 			}
 
-			ManifestDataBuffer.emplace_back(
-				ManifestData{.RawSize = RawSize, .Timestamp = AccessTimes[PlIndex], .RawHash = RawHash, .Key = Key});
-			if (ManifestDataBuffer.size() == MaxManifestDataBufferCount)
+			if (WriteIt == ManifestDataBuffer.end())
 			{
-				const uint64_t WriteSize = sizeof(ManifestData) * ManifestDataBuffer.size();
+				uint64_t WriteSize = std::distance(ManifestDataBuffer.begin(), WriteIt) * sizeof(ManifestData);
 				SidecarFile.Write(ManifestDataBuffer.data(), WriteSize, WriteOffset);
 				WriteOffset += WriteSize;
-				ManifestDataBuffer.clear();
-				ManifestDataBuffer.reserve(MaxManifestDataBufferCount);
+				WriteIt = ManifestDataBuffer.begin();
 			}
 		}
-		if (ManifestDataBuffer.size() > 0)
+		if (WriteIt != ManifestDataBuffer.begin())
 		{
-			SidecarFile.Write(ManifestDataBuffer.data(), sizeof(ManifestData) * ManifestDataBuffer.size(), WriteOffset);
+			uint64_t WriteSize = std::distance(ManifestDataBuffer.begin(), WriteIt) * sizeof(ManifestData);
+			SidecarFile.Write(ManifestDataBuffer.data(), WriteSize, WriteOffset);
 		}
 	}
 
@@ -867,32 +878,38 @@ ZenCacheDiskLayer::CacheBucket::WriteIndexSnapshotLocked(bool FlushLockPosition,
 			throw std::system_error(Ec, fmt::format("failed to create new snapshot file in '{}'", m_BucketDir));
 		}
 
-		{
-			// This is in a separate scope just to ensure IndexWriter goes out
-			// of scope before the file is flushed/closed, in order to ensure
-			// all data is written to the file
-			BasicFileWriter IndexWriter(ObjectIndexFile, 128 * 1024);
-
-			cache::impl::CacheBucketIndexHeader Header = {.EntryCount		= EntryCount,
-														  .LogPosition		= LogCount,
-														  .PayloadAlignment = gsl::narrow<uint32_t>(m_Configuration.PayloadAlignment)};
+		cache::impl::CacheBucketIndexHeader Header = {.EntryCount		= EntryCount,
+													  .LogPosition		= LogCount,
+													  .PayloadAlignment = gsl::narrow<uint32_t>(m_Configuration.PayloadAlignment)};
 
-			Header.Checksum = cache::impl::CacheBucketIndexHeader::ComputeChecksum(Header);
-			IndexWriter.Write(&Header, sizeof(cache::impl::CacheBucketIndexHeader), 0);
+		Header.Checksum = cache::impl::CacheBucketIndexHeader::ComputeChecksum(Header);
+		ObjectIndexFile.Write(&Header, sizeof(cache::impl::CacheBucketIndexHeader), 0);
 
+		if (EntryCount > 0)
+		{
 			uint64_t IndexWriteOffset = sizeof(cache::impl::CacheBucketIndexHeader);
 
+			size_t						MaxWriteEntryCount = (512u * 1024u) / sizeof(DiskIndexEntry);
+			std::vector<DiskIndexEntry> DiskEntryBuffer(Min(m_Index.size(), MaxWriteEntryCount));
+
+			auto WriteIt = DiskEntryBuffer.begin();
 			for (auto& Entry : m_Index)
 			{
-				DiskIndexEntry IndexEntry;
-				IndexEntry.Key		= Entry.first;
-				IndexEntry.Location = m_Payloads[Entry.second].Location;
-				IndexWriter.Write(&IndexEntry, sizeof(DiskIndexEntry), IndexWriteOffset);
-
-				IndexWriteOffset += sizeof(DiskIndexEntry);
+				*WriteIt++ = {.Key = Entry.first, .Location = m_Payloads[Entry.second].Location};
+				if (WriteIt == DiskEntryBuffer.end())
+				{
+					uint64_t WriteSize = std::distance(DiskEntryBuffer.begin(), WriteIt) * sizeof(DiskIndexEntry);
+					ObjectIndexFile.Write(DiskEntryBuffer.data(), WriteSize, IndexWriteOffset);
+					IndexWriteOffset += WriteSize;
+					WriteIt = DiskEntryBuffer.begin();
+				}
 			}
 
-			IndexWriter.Flush();
+			if (WriteIt != DiskEntryBuffer.begin())
+			{
+				uint64_t WriteSize = std::distance(DiskEntryBuffer.begin(), WriteIt) * sizeof(DiskIndexEntry);
+				ObjectIndexFile.Write(DiskEntryBuffer.data(), WriteSize, IndexWriteOffset);
+			}
 		}
 
 		ObjectIndexFile.Flush();