add more trace scopes (#362)

* more trace scopes
* Make sure ReplayLogEntries uses the correct size for oplog buffer
* changelog

1 files changed, 89 insertions, 77 deletions

diff --git a/src/zenstore/blockstore.cpp b/src/zenstore/blockstore.cpp
index cdd7abae7..a16dd4539 100644
--- a/src/zenstore/blockstore.cpp
+++ b/src/zenstore/blockstore.cpp
@@ -66,6 +66,8 @@ BlockStoreFile::Open()
 void
 BlockStoreFile::Create(uint64_t InitialSize)
 {
+	ZEN_TRACE_CPU("BlockStoreFile::Create");
+
 	auto ParentPath = m_Path.parent_path();
 	if (!std::filesystem::is_directory(ParentPath))
 	{
@@ -118,12 +120,14 @@ BlockStoreFile::Read(void* Data, uint64_t Size, uint64_t FileOffset)
 void
 BlockStoreFile::Write(const void* Data, uint64_t Size, uint64_t FileOffset)
 {
+	ZEN_TRACE_CPU("BlockStoreFile::Write");
 	m_File.Write(Data, Size, FileOffset);
 }
 
 void
 BlockStoreFile::Flush()
 {
+	ZEN_TRACE_CPU("BlockStoreFile::Flush");
 	m_File.Flush();
 }
 
@@ -335,6 +339,7 @@ BlockStore::GetReclaimSnapshotState()
 IoBuffer
 BlockStore::TryGetChunk(const BlockStoreLocation& Location) const
 {
+	ZEN_TRACE_CPU("BlockStore::TryGetChunk");
 	RwLock::SharedLockScope InsertLock(m_InsertLock);
 	if (auto BlockIt = m_ChunkBlocks.find(Location.BlockIndex); BlockIt != m_ChunkBlocks.end())
 	{
@@ -499,6 +504,8 @@ BlockStore::ReclaimSpace(const ReclaimSnapshotState&			Snapshot,
 	Ref<BlockStoreFile> NewBlockFile;
 	try
 	{
+		ZEN_TRACE_CPU("BlockStore::ReclaimSpace::Compact");
+
 		uint64_t WriteOffset   = 0;
 		uint32_t NewBlockIndex = 0;
 		for (uint32_t BlockIndex : BlocksToReWrite)
@@ -523,6 +530,8 @@ BlockStore::ReclaimSpace(const ReclaimSnapshotState&			Snapshot,
 			ChunkIndexArray& KeepMap = BlockKeepChunks[ChunkMapIndex];
 			if (KeepMap.empty())
 			{
+				ZEN_TRACE_CPU("BlockStore::ReclaimSpace::DeleteBlock");
+
 				const ChunkIndexArray& DeleteMap = BlockDeleteChunks[ChunkMapIndex];
 				for (size_t DeleteIndex : DeleteMap)
 				{
@@ -561,99 +570,102 @@ BlockStore::ReclaimSpace(const ReclaimSnapshotState&			Snapshot,
 				KeepMap.clear();
 			}
 
-			MovedChunksArray	 MovedChunks;
-			std::vector<uint8_t> Chunk;
-			for (const size_t& ChunkIndex : KeepMap)
+			MovedChunksArray MovedChunks;
 			{
-				const BlockStoreLocation ChunkLocation = ChunkLocations[ChunkIndex];
-				Chunk.resize(ChunkLocation.Size);
-				OldBlockFile->Read(Chunk.data(), Chunk.size(), ChunkLocation.Offset);
-
-				if (!NewBlockFile || (WriteOffset + Chunk.size() > m_MaxBlockSize))
+				ZEN_TRACE_CPU("BlockStore::ReclaimSpace::MoveBlock");
+				std::vector<uint8_t> Chunk;
+				for (const size_t& ChunkIndex : KeepMap)
 				{
-					uint32_t NextBlockIndex = m_WriteBlockIndex.load(std::memory_order_relaxed);
+					const BlockStoreLocation ChunkLocation = ChunkLocations[ChunkIndex];
+					Chunk.resize(ChunkLocation.Size);
+					OldBlockFile->Read(Chunk.data(), Chunk.size(), ChunkLocation.Offset);
 
-					if (NewBlockFile)
+					if (!NewBlockFile || (WriteOffset + Chunk.size() > m_MaxBlockSize))
 					{
-						NewBlockFile->Flush();
-						NewBlockFile = nullptr;
-					}
-					{
-						ChangeCallback(MovedChunks, {});
-						MovedCount += KeepMap.size();
-						MovedChunks.clear();
-						RwLock::ExclusiveLockScope __(m_InsertLock);
-						Stopwatch				   Timer;
-						const auto				   ___ = MakeGuard([&] {
-							uint64_t ElapsedUs = Timer.GetElapsedTimeUs();
-							ReadBlockTimeUs += ElapsedUs;
-							ReadBlockLongestTimeUs = std::max(ElapsedUs, ReadBlockLongestTimeUs);
-						});
-						if (m_ChunkBlocks.size() == m_MaxBlockCount)
-						{
-							ZEN_ERROR("unable to allocate a new block in '{}', count limit {} exeeded",
-									  m_BlocksBasePath,
-									  static_cast<uint64_t>(std::numeric_limits<uint32_t>::max()) + 1);
-							return;
-						}
-						while (m_ChunkBlocks.contains(NextBlockIndex))
+						uint32_t NextBlockIndex = m_WriteBlockIndex.load(std::memory_order_relaxed);
+
+						if (NewBlockFile)
 						{
-							NextBlockIndex = (NextBlockIndex + 1) & (m_MaxBlockCount - 1);
+							NewBlockFile->Flush();
+							NewBlockFile = nullptr;
 						}
-						std::filesystem::path NewBlockPath = GetBlockPath(m_BlocksBasePath, NextBlockIndex);
-						NewBlockFile					   = new BlockStoreFile(NewBlockPath);
-						m_ChunkBlocks[NextBlockIndex]	   = NewBlockFile;
-					}
-
-					std::error_code Error;
-					DiskSpace		Space = DiskSpaceInfo(m_BlocksBasePath, Error);
-					if (Error)
-					{
-						ZEN_ERROR("get disk space in '{}' FAILED, reason: '{}'", m_BlocksBasePath, Error.message());
-						return;
-					}
-					if (Space.Free < m_MaxBlockSize)
-					{
-						uint64_t ReclaimedSpace = DiskReserveCallback();
-						if (Space.Free + ReclaimedSpace < m_MaxBlockSize)
 						{
-							ZEN_WARN("garbage collect for '{}' FAILED, required disk space {}, free {}",
-									 m_BlocksBasePath,
-									 m_MaxBlockSize,
-									 NiceBytes(Space.Free + ReclaimedSpace));
-							RwLock::ExclusiveLockScope _l(m_InsertLock);
+							ChangeCallback(MovedChunks, {});
+							MovedCount += KeepMap.size();
+							MovedChunks.clear();
+							RwLock::ExclusiveLockScope __(m_InsertLock);
 							Stopwatch				   Timer;
-							const auto				   __ = MakeGuard([&] {
+							const auto				   ___ = MakeGuard([&] {
 								uint64_t ElapsedUs = Timer.GetElapsedTimeUs();
 								ReadBlockTimeUs += ElapsedUs;
 								ReadBlockLongestTimeUs = std::max(ElapsedUs, ReadBlockLongestTimeUs);
 							});
-							ZEN_ASSERT(m_ChunkBlocks[NextBlockIndex] == NewBlockFile);
-							m_ChunkBlocks.erase(NextBlockIndex);
-							NewBlockFile->MarkAsDeleteOnClose();
-							return;
+							if (m_ChunkBlocks.size() == m_MaxBlockCount)
+							{
+								ZEN_ERROR("unable to allocate a new block in '{}', count limit {} exeeded",
+										  m_BlocksBasePath,
+										  static_cast<uint64_t>(std::numeric_limits<uint32_t>::max()) + 1);
+								return;
+							}
+							while (m_ChunkBlocks.contains(NextBlockIndex))
+							{
+								NextBlockIndex = (NextBlockIndex + 1) & (m_MaxBlockCount - 1);
+							}
+							std::filesystem::path NewBlockPath = GetBlockPath(m_BlocksBasePath, NextBlockIndex);
+							NewBlockFile					   = new BlockStoreFile(NewBlockPath);
+							m_ChunkBlocks[NextBlockIndex]	   = NewBlockFile;
 						}
 
-						ZEN_INFO("using gc reserve for '{}', reclaimed {}, disk free {}",
-								 m_BlocksBasePath,
-								 ReclaimedSpace,
-								 NiceBytes(Space.Free + ReclaimedSpace));
+						std::error_code Error;
+						DiskSpace		Space = DiskSpaceInfo(m_BlocksBasePath, Error);
+						if (Error)
+						{
+							ZEN_ERROR("get disk space in '{}' FAILED, reason: '{}'", m_BlocksBasePath, Error.message());
+							return;
+						}
+						if (Space.Free < m_MaxBlockSize)
+						{
+							uint64_t ReclaimedSpace = DiskReserveCallback();
+							if (Space.Free + ReclaimedSpace < m_MaxBlockSize)
+							{
+								ZEN_WARN("garbage collect for '{}' FAILED, required disk space {}, free {}",
+										 m_BlocksBasePath,
+										 m_MaxBlockSize,
+										 NiceBytes(Space.Free + ReclaimedSpace));
+								RwLock::ExclusiveLockScope _l(m_InsertLock);
+								Stopwatch				   Timer;
+								const auto				   __ = MakeGuard([&] {
+									uint64_t ElapsedUs = Timer.GetElapsedTimeUs();
+									ReadBlockTimeUs += ElapsedUs;
+									ReadBlockLongestTimeUs = std::max(ElapsedUs, ReadBlockLongestTimeUs);
+								});
+								ZEN_ASSERT(m_ChunkBlocks[NextBlockIndex] == NewBlockFile);
+								m_ChunkBlocks.erase(NextBlockIndex);
+								NewBlockFile->MarkAsDeleteOnClose();
+								return;
+							}
+
+							ZEN_INFO("using gc reserve for '{}', reclaimed {}, disk free {}",
+									 m_BlocksBasePath,
+									 ReclaimedSpace,
+									 NiceBytes(Space.Free + ReclaimedSpace));
+						}
+						NewBlockFile->Create(m_MaxBlockSize);
+						NewBlockIndex = NextBlockIndex;
+						WriteOffset	  = 0;
 					}
-					NewBlockFile->Create(m_MaxBlockSize);
-					NewBlockIndex = NextBlockIndex;
-					WriteOffset	  = 0;
-				}
 
-				NewBlockFile->Write(Chunk.data(), Chunk.size(), WriteOffset);
-				MovedChunks.push_back({ChunkIndex, {.BlockIndex = NewBlockIndex, .Offset = WriteOffset, .Size = Chunk.size()}});
-				uint64_t OldOffset = WriteOffset;
-				WriteOffset		   = RoundUp(WriteOffset + Chunk.size(), PayloadAlignment);
-				m_TotalSize.fetch_add(WriteOffset - OldOffset, std::memory_order::relaxed);
-			}
-			Chunk.clear();
-			if (NewBlockFile)
-			{
-				NewBlockFile->Flush();
+					NewBlockFile->Write(Chunk.data(), Chunk.size(), WriteOffset);
+					MovedChunks.push_back({ChunkIndex, {.BlockIndex = NewBlockIndex, .Offset = WriteOffset, .Size = Chunk.size()}});
+					uint64_t OldOffset = WriteOffset;
+					WriteOffset		   = RoundUp(WriteOffset + Chunk.size(), PayloadAlignment);
+					m_TotalSize.fetch_add(WriteOffset - OldOffset, std::memory_order::relaxed);
+				}
+				Chunk.clear();
+				if (NewBlockFile)
+				{
+					NewBlockFile->Flush();
+				}
 			}
 
 			const ChunkIndexArray& DeleteMap = BlockDeleteChunks[ChunkMapIndex];