MB-46907 Move Couchstore file system histograms to CouchKVStore

Couchstore specific file system histograms are kept in KVStore. These
are not used by any other KVStore implementation, hence can be moved
inside CouchKVStore itself. Stats dependent on these histograms are also
moved inside CouchKVStore.

Change-Id: Ib80b2cfa8878de22b8d342443e42466a976f1b19
Reviewed-on: http://review.couchbase.org/c/kv_engine/+/156145
Reviewed-by: Dave Rigby <[email protected]>
Tested-by: Build Bot <[email protected]>

Author: rohansuri

engines/ep/src/couch-kvstore/couch-kvstore.cc

@@ -22,6 +22,7 @@
 #include "kvstore_config.h"
 #include "persistence_callback.h"
 #include "rollback_result.h"
+#include "statistics/cbstat_collector.h"
 #include "vb_commit.h"
 #include "vbucket.h"
 #include "vbucket_bgfetch_item.h"
@@ -353,9 +354,9 @@ CouchKVStore::CouchKVStore(const CouchKVStoreConfig& config,
             std::vector<std::atomic_bool>(configuration.getMaxVBuckets());
     vbAbortCompaction =
             std::vector<std::atomic_bool>(configuration.getMaxVBuckets());
-    statCollectingFileOps = getCouchstoreStatsOps(st.fsStats, base_ops);
-    statCollectingFileOpsCompaction = getCouchstoreStatsOps(
-        st.fsStatsCompaction, base_ops);
+    statCollectingFileOps = getCouchstoreStatsOps(fsStats, base_ops);
+    statCollectingFileOpsCompaction =
+            getCouchstoreStatsOps(fsStatsCompaction, base_ops);
 
     // init db file map with default revision number, 1
     auto numDbFiles = configuration.getMaxVBuckets();
@@ -398,6 +399,84 @@ CouchKVStore::CouchKVStore(const CouchKVStoreConfig& config,
     initialize(map);
 }
 
+size_t CouchKVStore::getMemFootPrint() const {
+    return KVStore::getMemFootPrint() + fsStats.getMemFootPrint() +
+           fsStatsCompaction.getMemFootPrint();
+}
+
+void CouchKVStore::resetStats() {
+    KVStore::resetStats();
+    fsStats.reset();
+    fsStatsCompaction.reset();
+}
+
+void CouchKVStore::addStats(const AddStatFn& add_stat,
+                            const void* c,
+                            const std::string& args) const {
+    KVStore::addStats(add_stat, c, args);
+    const auto prefix = getStatsPrefix();
+
+    const size_t read = fsStats.totalBytesRead.load() +
+                        fsStatsCompaction.totalBytesRead.load();
+    add_prefixed_stat(prefix, "io_total_read_bytes", read, add_stat, c);
+
+    const size_t written = fsStats.totalBytesWritten.load() +
+                           fsStatsCompaction.totalBytesWritten.load();
+    add_prefixed_stat(prefix, "io_total_write_bytes", written, add_stat, c);
+
+    // Flusher Write Amplification - ratio of bytes written to disk by
+    // flusher to "useful" user data written - i.e. doesn't include bytes
+    // written later by compaction (after initial flush). Used to measure
+    // the impact of KVstore on persistTo times.
+    const double flusherWriteAmp = double(fsStats.totalBytesWritten.load()) /
+                                   st.io_document_write_bytes;
+    add_prefixed_stat(prefix,
+                      "io_flusher_write_amplification",
+                      flusherWriteAmp,
+                      add_stat,
+                      c);
+
+    // Total Write Amplification - ratio of total bytes written to disk
+    // to "useful" user data written over entire disk lifecycle. Includes
+    // bytes during initial item flush to disk  and compaction.
+    // Used to measure the overall write amplification.
+    const double totalWriteAmp = double(written) / st.io_document_write_bytes;
+    add_prefixed_stat(
+            prefix, "io_total_write_amplification", totalWriteAmp, add_stat, c);
+
+    add_prefixed_stat(prefix,
+                      "io_compaction_read_bytes",
+                      fsStatsCompaction.totalBytesRead,
+                      add_stat,
+                      c);
+    add_prefixed_stat(prefix,
+                      "io_compaction_write_bytes",
+                      fsStatsCompaction.totalBytesWritten,
+                      add_stat,
+                      c);
+}
+
+void CouchKVStore::addTimingStats(const AddStatFn& add_stat,
+                                  const CookieIface* c) const {
+    KVStore::addTimingStats(add_stat, c);
+
+    const auto prefix = getStatsPrefix();
+
+    // file ops stats.
+    add_prefixed_stat(prefix, "fsReadTime", fsStats.readTimeHisto, add_stat, c);
+    add_prefixed_stat(
+            prefix, "fsWriteTime", fsStats.writeTimeHisto, add_stat, c);
+    add_prefixed_stat(prefix, "fsSyncTime", fsStats.syncTimeHisto, add_stat, c);
+    add_prefixed_stat(prefix, "fsReadSize", fsStats.readSizeHisto, add_stat, c);
+    add_prefixed_stat(
+            prefix, "fsWriteSize", fsStats.writeSizeHisto, add_stat, c);
+    add_prefixed_stat(prefix, "fsReadSeek", fsStats.readSeekHisto, add_stat, c);
+    add_prefixed_stat(
+            prefix, "fsReadCount", fsStats.readCountHisto, add_stat, c);
+    add_prefixed_stat(
+            prefix, "fsWriteCount", fsStats.writeCountHisto, add_stat, c);
+}
+
 void CouchKVStore::initialize(
         const std::unordered_map<Vbid, std::unordered_set<uint64_t>>& map) {
     for (const auto& [vbid, revisions] : map) {
@@ -1973,21 +2052,21 @@ bool CouchKVStore::getStat(std::string_view name, size_t& value) const {
         value = st.io_document_write_bytes;
         return true;
     } else if (name == "io_flusher_write_bytes") {
-        value = st.fsStats.totalBytesWritten;
+        value = fsStats.totalBytesWritten;
         return true;
     } else if (name == "io_total_read_bytes") {
-        value = st.fsStats.totalBytesRead.load() +
-                st.fsStatsCompaction.totalBytesRead.load();
+        value = fsStats.totalBytesRead.load() +
+                fsStatsCompaction.totalBytesRead.load();
         return true;
     } else if (name == "io_total_write_bytes") {
-        value = st.fsStats.totalBytesWritten.load() +
-                st.fsStatsCompaction.totalBytesWritten.load();
+        value = fsStats.totalBytesWritten.load() +
+                fsStatsCompaction.totalBytesWritten.load();
         return true;
     } else if (name == "io_compaction_read_bytes") {
-        value = st.fsStatsCompaction.totalBytesRead;
+        value = fsStatsCompaction.totalBytesRead;
         return true;
     } else if (name == "io_compaction_write_bytes") {
-        value = st.fsStatsCompaction.totalBytesWritten;
+        value = fsStatsCompaction.totalBytesWritten;
         return true;
     } else if (name == "io_bg_fetch_read_count") {
         value = st.getMultiFsReadCount;

engines/ep/src/couch-kvstore/couch-kvstore.h

@@ -196,6 +196,17 @@ class CouchKVStore : public KVStore
 
     using KVStore::get;
 
+    void addTimingStats(const AddStatFn& add_stat,
+                        const CookieIface* c) const override;
+
+    size_t getMemFootPrint() const override;
+
+    void resetStats() override;
+
+    void addStats(const AddStatFn& add_stat,
+                  const void* c,
+                  const std::string& args) const override;
+
     GetValue getWithHeader(const KVFileHandle& kvFileHandle,
                            const DiskDocKey& key,
                            Vbid vb,
@@ -945,15 +956,15 @@ class CouchKVStore : public KVStore
      * FileOpsInterface implementation for couchstore which tracks
      * all bytes read/written by couchstore *except* compaction.
      *
-     * Backed by this->st.fsStats
+     * Backed by this->fsStats
      */
     std::unique_ptr<FileOpsInterface> statCollectingFileOps;
 
     /**
      * FileOpsInterface implementation for couchstore which tracks
      * all bytes read/written by couchstore just for compaction
      *
-     * Backed by this->st.fsStatsCompaction
+     * Backed by this->fsStatsCompaction
      */
     std::unique_ptr<FileOpsInterface> statCollectingFileOpsCompaction;
 
@@ -1030,4 +1041,11 @@ class CouchKVStore : public KVStore
     /// re-acquired. This allows the actual flusher to run in the hook rather
     /// poking the kvstore manually
     TestingHook<const std::string&> concurrentCompactionPreLockHook;
+
+private:
+    // Stats from the underlying OS file operations
+    FileStats fsStats;
+
+    // Underlying stats for OS file operations during compaction
+    FileStats fsStatsCompaction;
 };

engines/ep/src/kvstore.cc

@@ -174,9 +174,6 @@ void KVStoreStats::reset() {
     getMultiFsReadHisto.reset();
     getMultiFsReadPerDocHisto.reset();
     flusherWriteAmplificationHisto.reset();
-
-    fsStats.reset();
-    fsStatsCompaction.reset();
 }
 
 std::unique_ptr<KVStore> KVStoreFactory::create(KVStoreConfig& config) {
@@ -406,45 +403,6 @@ void KVStore::addStats(const AddStatFn& add_stat,
                       st.io_document_write_bytes,
                       add_stat,
                       c);
-
-    const size_t read = st.fsStats.totalBytesRead.load() +
-                        st.fsStatsCompaction.totalBytesRead.load();
-    add_prefixed_stat(prefix, "io_total_read_bytes", read, add_stat, c);
-
-    const size_t written = st.fsStats.totalBytesWritten.load() +
-                           st.fsStatsCompaction.totalBytesWritten.load();
-    add_prefixed_stat(prefix, "io_total_write_bytes", written, add_stat, c);
-
-    // Flusher Write Amplification - ratio of bytes written to disk by
-    // flusher to "useful" user data written - i.e. doesn't include bytes
-    // written later by compaction (after initial flush). Used to measure
-    // the impact of KVstore on persistTo times.
-    const double flusherWriteAmp = double(st.fsStats.totalBytesWritten.load()) /
-                                   st.io_document_write_bytes;
-    add_prefixed_stat(prefix,
-                      "io_flusher_write_amplification",
-                      flusherWriteAmp,
-                      add_stat,
-                      c);
-
-    // Total Write Amplification - ratio of total bytes written to disk
-    // to "useful" user data written over entire disk lifecycle. Includes
-    // bytes during initial item flush to disk  and compaction.
-    // Used to measure the overall write amplification.
-    const double totalWriteAmp = double(written) / st.io_document_write_bytes;
-    add_prefixed_stat(
-            prefix, "io_total_write_amplification", totalWriteAmp, add_stat, c);
-
-    add_prefixed_stat(prefix,
-                      "io_compaction_read_bytes",
-                      st.fsStatsCompaction.totalBytesRead,
-                      add_stat,
-                      c);
-    add_prefixed_stat(prefix,
-                      "io_compaction_write_bytes",
-                      st.fsStatsCompaction.totalBytesWritten,
-                      add_stat,
-                      c);
 }
 
 void KVStore::addTimingStats(const AddStatFn& add_stat,
@@ -474,24 +432,6 @@ void KVStore::addTimingStats(const AddStatFn& add_stat,
                       st.flusherWriteAmplificationHisto,
                       add_stat,
                       c);
-
-    //file ops stats
-    add_prefixed_stat(
-            prefix, "fsReadTime", st.fsStats.readTimeHisto, add_stat, c);
-    add_prefixed_stat(
-            prefix, "fsWriteTime", st.fsStats.writeTimeHisto, add_stat, c);
-    add_prefixed_stat(
-            prefix, "fsSyncTime", st.fsStats.syncTimeHisto, add_stat, c);
-    add_prefixed_stat(
-            prefix, "fsReadSize", st.fsStats.readSizeHisto, add_stat, c);
-    add_prefixed_stat(
-            prefix, "fsWriteSize", st.fsStats.writeSizeHisto, add_stat, c);
-    add_prefixed_stat(
-            prefix, "fsReadSeek", st.fsStats.readSeekHisto, add_stat, c);
-    add_prefixed_stat(
-            prefix, "fsReadCount", st.fsStats.readCountHisto, add_stat, c);
-    add_prefixed_stat(
-            prefix, "fsWriteCount", st.fsStats.writeCountHisto, add_stat, c);
 }
 
 void KVStore::optimizeWrites(std::vector<queued_item>& items) {

engines/ep/src/kvstore.h

@@ -515,12 +515,6 @@ class KVStoreStats {
     HdrHistogram flusherWriteAmplificationHisto{
             1, 1000, 2, HdrHistogram::Iterator::IterMode::Percentiles};
 
-    // Stats from the underlying OS file operations
-    FileStats fsStats;
-
-    // Underlying stats for OS file operations during compaction
-    FileStats fsStatsCompaction;
-
     size_t getMemFootPrint() const {
         return readTimeHisto.getMemFootPrint() +
                readSizeHisto.getMemFootPrint() +
@@ -531,7 +525,6 @@ class KVStoreStats {
                saveDocsHisto.getMemFootPrint() + batchSize.getMemFootPrint() +
                getMultiFsReadHisto.getMemFootPrint() +
                getMultiFsReadPerDocHisto.getMemFootPrint() +
-               fsStats.getMemFootPrint() + fsStatsCompaction.getMemFootPrint() +
                flusherWriteAmplificationHisto.getMemFootPrint();
     }
 };
@@ -681,11 +674,11 @@ class KVStore {
     /**
      * Resets kvstore specific stats
      */
-    void resetStats() {
+    virtual void resetStats() {
         st.reset();
     }
 
-    size_t getMemFootPrint() const {
+    virtual size_t getMemFootPrint() const {
         return st.getMemFootPrint();
     }