refactor blobstore (#458)

- Improvement: Refactored build store cache to use existing CidStore implementation instead of implementation specific blob storage
  - **CAUTION** This will clear any existing cache when updating as the manifest version and storage strategy has changed
- Bugfix: BuildStorage cache return "true" for metadata existance for all blobs that had payloads regardless of actual existance for metadata

1 files changed, 46 insertions, 41 deletions

diff --git a/src/zenstore/include/zenstore/buildstore/buildstore.h b/src/zenstore/include/zenstore/buildstore/buildstore.h
index adf48dc26..87b7dd812 100644
--- a/src/zenstore/include/zenstore/buildstore/buildstore.h
+++ b/src/zenstore/include/zenstore/buildstore/buildstore.h
@@ -6,9 +6,8 @@
 #include <zencore/iohash.h>
 #include <zenstore/accesstime.h>
 #include <zenstore/caslog.h>
+#include <zenstore/cidstore.h>
 #include <zenstore/gc.h>
-#include "../compactcas.h"
-#include "../filecas.h"
 
 ZEN_THIRD_PARTY_INCLUDES_START
 #include <tsl/robin_map.h>
@@ -19,18 +18,13 @@ namespace zen {
 struct BuildStoreConfig
 {
 	std::filesystem::path RootDirectory;
-	uint32_t			  SmallBlobBlockStoreMaxBlockSize	   = 256 * 1024 * 1024;
-	uint64_t			  SmallBlobBlockStoreMaxBlockEmbedSize = 1 * 1024 * 1024;
-	uint32_t			  SmallBlobBlockStoreAlignement		   = 16;
-	uint32_t			  MetadataBlockStoreMaxBlockSize	   = 64 * 1024 * 1024;
-	uint32_t			  MetadataBlockStoreAlignement		   = 8;
-	uint64_t			  MaxDiskSpaceLimit					   = 1u * 1024u * 1024u * 1024u * 1024u;  // 1TB
+	uint64_t			  MaxDiskSpaceLimit = 1u * 1024u * 1024u * 1024u * 1024u;  // 1TB
 };
 
-class BuildStore : public GcReferencer, public GcReferenceLocker, public GcStorage
+class BuildStore : public GcReferencer, public GcReferenceLocker
 {
 public:
-	explicit BuildStore(const BuildStoreConfig& Config, GcManager& Gc);
+	explicit BuildStore(const BuildStoreConfig& Config, GcManager& Gc, CidStore& BlobStore);
 	virtual ~BuildStore();
 
 	void	 PutBlob(const IoHash& BlobHashes, const IoBuffer& Payload);
@@ -44,7 +38,7 @@ public:
 
 	std::vector<BlobExistsResult> BlobsExists(std::span<const IoHash> BlobHashes);
 
-	void				  PutMetadatas(std::span<const IoHash> BlobHashes, std::span<const IoBuffer> MetaDatas);
+	void PutMetadatas(std::span<const IoHash> BlobHashes, std::span<const IoBuffer> MetaDatas, WorkerThreadPool* OptionalWorkerPool);
 	std::vector<IoBuffer> GetMetadatas(std::span<const IoHash> BlobHashes, WorkerThreadPool* OptionalWorkerPool);
 
 	void Flush();
@@ -52,10 +46,8 @@ public:
 	struct StorageStats
 	{
 		uint64_t EntryCount		   = 0;
-		uint64_t LargeBlobCount	   = 0;
-		uint64_t LargeBlobBytes	   = 0;
-		uint64_t SmallBlobCount	   = 0;
-		uint64_t SmallBlobBytes	   = 0;
+		uint64_t BlobCount		   = 0;
+		uint64_t BlobBytes		   = 0;
 		uint64_t MetadataCount	   = 0;
 		uint64_t MetadataByteCount = 0;
 	};
@@ -86,23 +78,18 @@ private:
 	//////// GcReferenceLocker
 	virtual std::vector<RwLock::SharedLockScope> LockState(GcCtx& Ctx) override;
 
-	//////// GcStorage
-	virtual void		  ScrubStorage(ScrubContext& ScrubCtx) override;
-	virtual GcStorageSize StorageSize() const override;
-
 #pragma pack(push)
 #pragma pack(1)
 	struct PayloadEntry
 	{
 		PayloadEntry() {}
-		PayloadEntry(uint64_t Flags, uint64_t Size)
+		PayloadEntry(uint8_t Flags, uint64_t Size)
 		{
 			ZEN_ASSERT((Size & 0x00ffffffffffffffu) == Size);
-			ZEN_ASSERT((Flags & (kTombStone | kStandalone)) == Flags);
+			ZEN_ASSERT((Flags & (kTombStone)) == Flags);
 			FlagsAndSize = (Size << 8) | Flags;
 		}
-		static const uint8_t kTombStone	 = 0x10u;  // Represents a deleted key/value
-		static const uint8_t kStandalone = 0x20u;  // This payload is stored as a standalone value
+		static const uint8_t kTombStone = 0x10u;  // Represents a deleted key/value
 
 		uint64_t FlagsAndSize = 0;
 		uint64_t GetSize() const { return FlagsAndSize >> 8; }
@@ -126,27 +113,47 @@ private:
 
 	struct MetadataEntry
 	{
-		BlockStoreLocation Location;  // 12 bytes
+		IoHash MetadataHash;  // 20 bytes
+
+		MetadataEntry() {}
 
-		ZenContentType		 ContentType = ZenContentType::kCOUNT;	// 1 byte
-		static const uint8_t kTombStone	 = 0x10u;					// Represents a deleted key/value
-		uint8_t				 Flags		 = 0;						// 1 byte
+		MetadataEntry(const IoHash& Hash, uint64_t Size, ZenContentType ContentType, uint8_t Flags)
+		{
+			ZEN_ASSERT((Size & 0x0000ffffffffffffu) == Size);
+			ZEN_ASSERT((Flags & kTombStone) == Flags);
+			FlagsContentTypeAndSize = (Size << 16) | ((uint64_t)ContentType << 8) | Flags;
+			MetadataHash			= Hash;
+		}
+
+		static const uint8_t kTombStone = 0x10u;  // Represents a deleted key/value
+
+		uint64_t GetSize() const { return FlagsContentTypeAndSize >> 16; }
+		void	 SetSize(uint64_t Size)
+		{
+			ZEN_ASSERT((Size & 0x0000ffffffffffffu) == Size);
+			FlagsContentTypeAndSize = (Size << 16) | (FlagsContentTypeAndSize & 0xffff);
+		}
+
+		uint8_t GetFlags() const { return uint8_t(FlagsContentTypeAndSize & 0xff); }
+		void	AddFlag(uint8_t Flag) { FlagsContentTypeAndSize |= Flag; }
+		void	SetFlags(uint8_t Flags) { FlagsContentTypeAndSize = (FlagsContentTypeAndSize & 0xffffffffffffff00u) | Flags; }
+
+		ZenContentType GetContentType() const { return ZenContentType((FlagsContentTypeAndSize >> 8) & 0xff); }
+		void		   SetContentType(ZenContentType ContentType)
+		{
+			FlagsContentTypeAndSize = (FlagsContentTypeAndSize & 0xffffffffffff00ffu) | (uint16_t(ContentType) << 8);
+		}
 
-		uint8_t Reserved1 = 0;
-		uint8_t Reserved2 = 0;
+		uint64_t FlagsContentTypeAndSize = ((uint64_t)ZenContentType::kCOUNT << 8);
 	};
-	static_assert(sizeof(MetadataEntry) == 16);
+	static_assert(sizeof(MetadataEntry) == 28);
 
 	struct MetadataDiskEntry
 	{
-		MetadataEntry Entry;	 // 16 bytes
+		MetadataEntry Entry;	 // 28 bytes
 		IoHash		  BlobHash;	 // 20 bytes
-		uint8_t		  Reserved1 = 0;
-		uint8_t		  Reserved2 = 0;
-		uint8_t		  Reserved3 = 0;
-		uint8_t		  Reserved4 = 0;
 	};
-	static_assert(sizeof(MetadataDiskEntry) == 40);
+	static_assert(sizeof(MetadataDiskEntry) == 48);
 
 #pragma pack(pop)
 
@@ -206,17 +213,15 @@ private:
 	std::vector<BlobEntry>							  m_BlobEntries;
 	tsl::robin_map<IoHash, BlobIndex, IoHash::Hasher> m_BlobLookup;
 
-	FileCasStrategy		 m_LargeBlobStore;
-	CasContainerStrategy m_SmallBlobStore;
-	BlockStore			 m_MetadataBlockStore;
+	CidStore& m_BlobStore;
 
 	TCasLogFile<PayloadDiskEntry>  m_PayloadlogFile;
 	TCasLogFile<MetadataDiskEntry> m_MetadatalogFile;
 	uint64_t					   m_BlobLogFlushPosition = 0;
 	uint64_t					   m_MetaLogFlushPosition = 0;
 
-	std::unique_ptr<HashSet> m_TrackedCacheKeys;
-	std::atomic<uint64_t>	 m_LastAccessTimeUpdateCount;
+	std::unique_ptr<std::vector<IoHash>> m_TrackedBlobKeys;
+	std::atomic<uint64_t>				 m_LastAccessTimeUpdateCount;
 
 	friend class BuildStoreGcReferenceChecker;
 	friend class BuildStoreGcReferencePruner;