Levarage payload alignment when storing offset

1 files changed, 28 insertions, 23 deletions

diff --git a/zenstore/compactcas.cpp b/zenstore/compactcas.cpp
index f7dd36517..63f56c943 100644
--- a/zenstore/compactcas.cpp
+++ b/zenstore/compactcas.cpp
@@ -266,10 +266,10 @@ CasContainerStrategy::InsertChunk(const void* ChunkData, size_t ChunkSize, const
 	m_CurrentInsertOffset = AlignPositon(InsertOffset + ChunkSize, m_PayloadAlignment);
 
 	const CasLocation Location(m_CurrentBlockIndex, InsertOffset, ChunkSize);
-	CasDiskIndexEntry IndexEntry{.Key = ChunkHash, .Location = CasDiskLocation(Location)};
+	CasDiskIndexEntry IndexEntry{.Key = ChunkHash, .Location = CasDiskLocation(Location, m_PayloadAlignment)};
 
 	RwLock::ExclusiveLockScope __(m_LocationMapLock);
-	m_LocationMap[ChunkHash] = CasDiskLocation(Location);
+	m_LocationMap[ChunkHash] = CasDiskLocation(Location, m_PayloadAlignment);
 	m_TotalSize.fetch_add(static_cast<uint64_t>(ChunkSize));
 	m_CasLog.Append(IndexEntry);
 
@@ -289,7 +289,7 @@ CasContainerStrategy::FindChunk(const IoHash& ChunkHash)
 
 	if (auto KeyIt = m_LocationMap.find(ChunkHash); KeyIt != m_LocationMap.end())
 	{
-		CasLocation Location = *KeyIt->second;
+		CasLocation Location = KeyIt->second.Get(m_PayloadAlignment);
 
 		if (auto BlockIt = m_OpenBlocks.find(Location.BlockIndex); BlockIt != m_OpenBlocks.end())
 		{
@@ -365,7 +365,7 @@ CasContainerStrategy::Scrub(ScrubContext& Ctx)
 
 				for (auto& Entry : m_LocationMap)
 				{
-					const CasLocation Location	  = *Entry.second;
+					const CasLocation Location	  = Entry.second.Get(m_PayloadAlignment);
 					const uint64_t	  EntryOffset = Location.Offset;
 
 					if ((EntryOffset >= WindowStart) && (EntryOffset < WindowEnd))
@@ -401,7 +401,7 @@ CasContainerStrategy::Scrub(ScrubContext& Ctx)
 		for (const CasDiskIndexEntry& Entry : BigChunks)
 		{
 			IoHashStream	  Hasher;
-			const CasLocation Location		  = *Entry.Location;
+			const CasLocation Location		  = Entry.Location.Get(m_PayloadAlignment);
 			auto&			  SmallObjectFile = *m_OpenBlocks[Location.BlockIndex];
 			SmallObjectFile.StreamByteRange(Location.Offset, Location.Size, [&](const void* Data, uint64_t Size) {
 				Hasher.Append(Data, Size);
@@ -503,7 +503,7 @@ CasContainerStrategy::CollectGarbage(GcContext& GcCtx)
 		for (const auto& Entry : m_LocationMap)
 		{
 			TotalChunkHashes.push_back(Entry.first);
-			const CasLocation Location = *Entry.second;
+			const CasLocation Location = Entry.second.Get(m_PayloadAlignment);
 			if (BlockIndexToKeepChunksMap.contains(Location.BlockIndex))
 			{
 				continue;
@@ -519,7 +519,7 @@ CasContainerStrategy::CollectGarbage(GcContext& GcCtx)
 			if (Keep)
 			{
 				auto			  KeyIt			= m_LocationMap.find(ChunkHash);
-				const CasLocation ChunkLocation = *KeyIt->second;
+				const CasLocation ChunkLocation = KeyIt->second.Get(m_PayloadAlignment);
 				auto&			  ChunkMap		= KeepChunks[BlockIndexToKeepChunksMap[ChunkLocation.BlockIndex]];
 				ChunkMap[ChunkHash]				= KeyIt->second;
 				NewTotalSize += ChunkLocation.Size;
@@ -544,7 +544,7 @@ CasContainerStrategy::CollectGarbage(GcContext& GcCtx)
 		for (const auto& ChunkHash : DeletedChunks)
 		{
 			auto			   KeyIt		 = m_LocationMap.find(ChunkHash);
-			const CasLocation& ChunkLocation = *KeyIt->second;
+			const CasLocation& ChunkLocation = KeyIt->second.Get(m_PayloadAlignment);
 			BlocksToReWrite.insert(ChunkLocation.BlockIndex);
 			m_CasLog.Append({.Key = ChunkHash, .Location = KeyIt->second, .Flags = CasDiskIndexEntry::kTombstone});
 			m_LocationMap.erase(ChunkHash);
@@ -616,7 +616,7 @@ CasContainerStrategy::CollectGarbage(GcContext& GcCtx)
 			std::vector<uint8_t> Chunk;
 			for (auto& Entry : ChunkMap)
 			{
-				const CasLocation ChunkLocation = *Entry.second;
+				const CasLocation ChunkLocation = Entry.second.Get(m_PayloadAlignment);
 				Chunk.resize(ChunkLocation.Size);
 				BlockFile->Read(Chunk.data(), Chunk.size(), ChunkLocation.Offset);
 
@@ -678,7 +678,7 @@ CasContainerStrategy::CollectGarbage(GcContext& GcCtx)
 
 				NewBlockFile->Write(Chunk.data(), Chunk.size(), WriteOffset);
 				CasLocation NewChunkLocation(NewBlockIndex, WriteOffset, Chunk.size());
-				Entry.second			 = CasDiskLocation(NewChunkLocation);
+				Entry.second			 = CasDiskLocation(NewChunkLocation, m_PayloadAlignment);
 				MovedBlocks[Entry.first] = Entry.second;
 				WriteOffset				 = AlignPositon(WriteOffset + Chunk.size(), m_PayloadAlignment);
 			}
@@ -991,7 +991,7 @@ CasContainerStrategy::OpenContainer(bool IsNewStore)
 				}
 				NewBlockFile->Write(Chunk.data(), Chunk.size(), WriteOffset);
 				CasLocation NewChunkLocation(NewBlockIndex, WriteOffset, Chunk.size());
-				m_CasLog.Append({.Key = ChunkHash, .Location = CasDiskLocation(NewChunkLocation)});
+				m_CasLog.Append({.Key = ChunkHash, .Location = CasDiskLocation(NewChunkLocation, m_PayloadAlignment)});
 				WriteOffset = AlignPositon(WriteOffset + Chunk.size(), m_PayloadAlignment);
 			}
 			m_CasLog.Close();
@@ -1043,7 +1043,7 @@ CasContainerStrategy::OpenContainer(bool IsNewStore)
 	std::unordered_map<uint32_t, uint64_t> BlockUsage;
 	for (const auto& Entry : m_LocationMap)
 	{
-		const CasLocation Location = *Entry.second;
+		const CasLocation Location = Entry.second.Get(m_PayloadAlignment);
 		m_TotalSize.fetch_add(Location.Size);
 		uint64_t NextBlockStart = Location.Offset + Location.Size;
 		auto	 It				= BlockUsage.find(Location.BlockIndex);
@@ -1161,30 +1161,35 @@ operator==(const CasLocation& Lhs, const CasLocation& Rhs)
 TEST_CASE("cas.casdisklocation")
 {
 	CasLocation Zero = CasLocation{.BlockIndex = 0, .Offset = 0, .Size = 0};
-	CHECK(Zero == *CasDiskLocation(Zero));
+	CHECK(Zero == CasDiskLocation(Zero, 4).Get(4));
 
 	CasLocation MaxBlockIndex = CasLocation{.BlockIndex = CasDiskLocation::MaxBlockIndex, .Offset = 0, .Size = 0};
-	CHECK(MaxBlockIndex == *CasDiskLocation(MaxBlockIndex));
+	CHECK(MaxBlockIndex == CasDiskLocation(MaxBlockIndex, 4).Get(4));
 
-	CasLocation MaxOffset = CasLocation{.BlockIndex = 0, .Offset = CasDiskLocation::MaxOffset, .Size = 0};
-	CHECK(MaxOffset == *CasDiskLocation(MaxOffset));
+	CasLocation MaxOffset = CasLocation{.BlockIndex = 0, .Offset = CasDiskLocation::MaxOffset * 4, .Size = 0};
+	CHECK(MaxOffset == CasDiskLocation(MaxOffset, 4).Get(4));
 
 	CasLocation MaxSize = CasLocation{.BlockIndex = 0, .Offset = 0, .Size = std::numeric_limits<uint32_t>::max()};
-	CHECK(MaxSize == *CasDiskLocation(MaxSize));
+	CHECK(MaxSize == CasDiskLocation(MaxSize, 4).Get(4));
 
 	CasLocation MaxBlockIndexAndOffset =
-		CasLocation{.BlockIndex = CasDiskLocation::MaxBlockIndex, .Offset = CasDiskLocation::MaxOffset, .Size = 0};
-	CHECK(MaxBlockIndexAndOffset == *CasDiskLocation(MaxBlockIndexAndOffset));
+		CasLocation{.BlockIndex = CasDiskLocation::MaxBlockIndex, .Offset = CasDiskLocation::MaxOffset * 4, .Size = 0};
+	CHECK(MaxBlockIndexAndOffset == CasDiskLocation(MaxBlockIndexAndOffset, 4).Get(4));
 
 	CasLocation MaxAll = CasLocation{.BlockIndex = CasDiskLocation::MaxBlockIndex,
-									 .Offset	 = CasDiskLocation::MaxOffset,
+									 .Offset	 = CasDiskLocation::MaxOffset * 4,
 									 .Size		 = std::numeric_limits<uint32_t>::max()};
-	CHECK(MaxAll == *CasDiskLocation(MaxAll));
+	CHECK(MaxAll == CasDiskLocation(MaxAll, 4).Get(4));
+
+	CasLocation MaxAll4096 = CasLocation{.BlockIndex = CasDiskLocation::MaxBlockIndex,
+										 .Offset	 = CasDiskLocation::MaxOffset * 4096,
+										 .Size		 = std::numeric_limits<uint32_t>::max()};
+	CHECK(MaxAll4096 == CasDiskLocation(MaxAll4096, 4096).Get(4096));
 
 	CasLocation Middle = CasLocation{.BlockIndex = (CasDiskLocation::MaxBlockIndex) / 2,
-									 .Offset	 = (CasDiskLocation::MaxOffset) / 2,
+									 .Offset	 = ((CasDiskLocation::MaxOffset) / 2) * 4,
 									 .Size		 = std::numeric_limits<uint32_t>::max() / 2};
-	CHECK(Middle == *CasDiskLocation(Middle));
+	CHECK(Middle == CasDiskLocation(Middle, 4).Get(4));
 }
 
 TEST_CASE("cas.compact.gc")