CAS: exposed some scrubbing stats

2 files changed, 41 insertions, 22 deletions

diff --git a/zenstore/CAS.cpp b/zenstore/CAS.cpp
index 808fc8fb3..a4bbfa340 100644
--- a/zenstore/CAS.cpp
+++ b/zenstore/CAS.cpp
@@ -96,9 +96,16 @@ GcContext::ContributeCas(std::span<const IoHash> Cas)
 //////////////////////////////////////////////////////////////////////////
 
 void
-ScrubContext::ReportBadChunks(std::span<IoHash> BadChunks)
+ScrubContext::ReportBadCasChunks(std::span<IoHash> BadCasChunks)
 {
-	ZEN_UNUSED(BadChunks);
+	m_BadCas.AddChunksToSet(BadCasChunks);
+}
+
+void
+ScrubContext::ReportScrubbed(uint64_t ChunkCount, uint64_t ChunkBytes)
+{
+	m_ChunkCount.fetch_add(ChunkCount);
+	m_ByteCount.fetch_add(ChunkBytes);
 }
 
 /**
diff --git a/zenstore/include/zenstore/CAS.h b/zenstore/include/zenstore/CAS.h
index 1425845a0..d0698df7f 100644
--- a/zenstore/include/zenstore/CAS.h
+++ b/zenstore/include/zenstore/CAS.h
@@ -31,6 +31,25 @@ struct CasStoreConfiguration
 	uint64_t HugeValueThreshold = 1024 * 1024;
 };
 
+/** Manage a set of IoHash values
+ */
+
+class CasChunkSet
+{
+public:
+	void						AddChunkToSet(const IoHash& HashToAdd);
+	void						AddChunksToSet(std::span<const IoHash> HashesToAdd);
+	void						RemoveChunksIf(std::function<bool(const IoHash& CandidateHash)>&& Predicate);
+	void						IterateChunks(std::function<void(const IoHash& ChunkHash)>&& Callback);
+	inline [[nodiscard]] bool	ContainsChunk(const IoHash& Hash) const { return m_ChunkSet.find(Hash) != m_ChunkSet.end(); }
+	inline [[nodiscard]] bool	IsEmpty() const { return m_ChunkSet.empty(); }
+	inline [[nodiscard]] size_t GetSize() const { return m_ChunkSet.size(); }
+
+private:
+	// Q: should we protect this with a lock, or is that a higher level concern?
+	std::unordered_set<IoHash> m_ChunkSet;
+};
+
 /** Garbage Collection context object
  */
 
@@ -58,33 +77,26 @@ private:
 class ScrubContext
 {
 public:
-	virtual void	ReportBadChunks(std::span<IoHash> BadChunks);
+	virtual void	ReportBadCasChunks(std::span<IoHash> BadCasChunks);
 	inline uint64_t ScrubTimestamp() const { return m_ScrubTime; }
 	inline bool		RunRecovery() const { return m_Recover; }
+	void			ReportScrubbed(uint64_t ChunkCount, uint64_t ChunkBytes);
+
+	inline uint64_t ScrubbedChunks() const { return m_ChunkCount; }
+	inline uint64_t ScrubbedBytes() const { return m_ByteCount; }
 
 private:
-	uint64_t m_ScrubTime = GetHifreqTimerValue();
-	bool	 m_Recover	 = true;
+	uint64_t			  m_ScrubTime = GetHifreqTimerValue();
+	bool				  m_Recover	  = true;
+	std::atomic<uint64_t> m_ChunkCount{0};
+	std::atomic<uint64_t> m_ByteCount{0};
+	CasChunkSet			  m_BadCas;
+	CasChunkSet			  m_BadCid;
 };
 
-/** Manage a set of IoHash values
- */
-
-class CasChunkSet
-{
-public:
-	void						AddChunkToSet(const IoHash& HashToAdd);
-	void						AddChunksToSet(std::span<const IoHash> HashesToAdd);
-	void						RemoveChunksIf(std::function<bool(const IoHash& CandidateHash)>&& Predicate);
-	void						IterateChunks(std::function<void(const IoHash& ChunkHash)>&& Callback);
-	inline [[nodiscard]] bool	ContainsChunk(const IoHash& Hash) const { return m_ChunkSet.find(Hash) != m_ChunkSet.end(); }
-	inline [[nodiscard]] bool	IsEmpty() const { return m_ChunkSet.empty(); }
-	inline [[nodiscard]] size_t GetSize() const { return m_ChunkSet.size(); }
+/** Content Addressable Storage interface
 
-private:
-	// Q: should we protect this with a lock, or is that a higher level concern?
-	std::unordered_set<IoHash> m_ChunkSet;
-};
+  */
 
 class CasStore
 {