From 10c5890547794703cdb0c49425f92cf8d5bef376 Mon Sep 17 00:00:00 2001 From: Yingxin Cheng Date: Mon, 23 Aug 2021 15:31:46 +0800 Subject: [PATCH] crimson/seastore: improve metrics about onode and lba trees Absolute value: * tree_depth By transaction source: * tree_inserts_committed * tree_inserts_invalidated * tree_erases_committed * tree_erase_invalidated Signed-off-by: Yingxin Cheng --- src/crimson/os/seastore/cache.cc | 176 ++++++++++++++------------ src/crimson/os/seastore/cache.h | 22 +++- src/crimson/os/seastore/transaction.h | 8 -- 3 files changed, 116 insertions(+), 90 deletions(-) diff --git a/src/crimson/os/seastore/cache.cc b/src/crimson/os/seastore/cache.cc index d30a73a1503ec..2a3e91cf6d686 100644 --- a/src/crimson/os/seastore/cache.cc +++ b/src/crimson/os/seastore/cache.cc @@ -435,82 +435,78 @@ void Cache::register_metrics() */ auto tree_label = sm::label("tree"); auto onode_label = tree_label("ONODE"); - stats.committed_onode_tree_stats = {}; - stats.invalidated_onode_tree_stats = {}; - metrics.add_group( - "cache", - { - sm::make_counter( - "tree_depth", - stats.committed_onode_tree_stats.depth, - sm::description("the depth of tree"), - {onode_label} - ), - sm::make_counter( - "tree_inserts_committed", - stats.committed_onode_tree_stats.num_inserts, - sm::description("total number of committed insert operations"), - {onode_label} - ), - sm::make_counter( - "tree_erases_committed", - stats.committed_onode_tree_stats.num_erases, - sm::description("total number of committed erase operations"), - {onode_label} - ), - sm::make_counter( - "tree_inserts_invalidated", - stats.invalidated_onode_tree_stats.num_inserts, - sm::description("total number of invalidated insert operations"), - {onode_label} - ), - sm::make_counter( - "tree_erases_invalidated", - stats.invalidated_onode_tree_stats.num_erases, - sm::description("total number of invalidated erase operations"), - {onode_label} - ), - } - ); - auto lba_label = tree_label("LBA"); - stats.committed_lba_tree_stats = {}; - stats.invalidated_lba_tree_stats = {}; - metrics.add_group( - "cache", - { - sm::make_counter( - "tree_depth", - stats.committed_lba_tree_stats.depth, - sm::description("the depth of tree"), - {lba_label} - ), - sm::make_counter( - "tree_inserts_committed", - stats.committed_lba_tree_stats.num_inserts, - sm::description("total number of committed insert operations"), - {lba_label} - ), - sm::make_counter( - "tree_erases_committed", - stats.committed_lba_tree_stats.num_erases, - sm::description("total number of committed erase operations"), - {lba_label} - ), - sm::make_counter( - "tree_inserts_invalidated", - stats.invalidated_lba_tree_stats.num_inserts, - sm::description("total number of invalidated insert operations"), - {lba_label} - ), - sm::make_counter( - "tree_erases_invalidated", - stats.invalidated_lba_tree_stats.num_erases, - sm::description("total number of invalidated erase operations"), - {lba_label} - ), + auto register_tree_metrics = [&labels_by_src, &onode_label, this]( + const sm::label_instance& tree_label, + uint64_t& tree_depth, + counter_by_src_t& committed_tree_efforts, + counter_by_src_t& invalidated_tree_efforts) { + tree_depth = 0; + metrics.add_group( + "cache", + { + sm::make_counter( + "tree_depth", + tree_depth, + sm::description("the depth of tree"), + {tree_label} + ), + } + ); + committed_tree_efforts.fill({}); + invalidated_tree_efforts.fill({}); + for (auto& [src, src_label] : labels_by_src) { + if (src == src_t::READ) { + // READ transaction won't contain any tree inserts and erases + continue; + } + if (src == src_t::CLEANER && tree_label == onode_label) { + // CLEANER transaction won't contain any onode tree operations + continue; + } + auto& committed_efforts = get_by_src(committed_tree_efforts, src); + auto& invalidated_efforts = get_by_src(invalidated_tree_efforts, src); + metrics.add_group( + "cache", + { + sm::make_counter( + "tree_inserts_committed", + committed_efforts.num_inserts, + sm::description("total number of committed insert operations"), + {tree_label, src_label} + ), + sm::make_counter( + "tree_erases_committed", + committed_efforts.num_erases, + sm::description("total number of committed erase operations"), + {tree_label, src_label} + ), + sm::make_counter( + "tree_inserts_invalidated", + invalidated_efforts.num_inserts, + sm::description("total number of invalidated insert operations"), + {tree_label, src_label} + ), + sm::make_counter( + "tree_erases_invalidated", + invalidated_efforts.num_erases, + sm::description("total number of invalidated erase operations"), + {tree_label, src_label} + ), + } + ); } - ); + }; + register_tree_metrics( + onode_label, + stats.onode_tree_depth, + stats.committed_onode_tree_efforts, + stats.invalidated_onode_tree_efforts); + register_tree_metrics( + lba_label, + stats.lba_tree_depth, + stats.committed_lba_tree_efforts, + stats.invalidated_lba_tree_efforts); } void Cache::add_extent(CachedExtentRef ref) @@ -664,8 +660,16 @@ void Cache::invalidate(Transaction& t, CachedExtent& conflicting_extent) efforts.mutate_delta_bytes += i->get_delta().length(); } - stats.invalidated_onode_tree_stats.increment(t.onode_tree_stats); - stats.invalidated_lba_tree_stats.increment(t.lba_tree_stats); + if (t.get_src() == Transaction::src_t::CLEANER) { + // CLEANER transaction won't contain any onode tree operations + assert(t.onode_tree_stats.is_clear()); + } else { + get_by_src(stats.invalidated_onode_tree_efforts, t.get_src() + ).increment(t.onode_tree_stats); + } + + get_by_src(stats.invalidated_lba_tree_efforts, t.get_src() + ).increment(t.lba_tree_stats); } else { // read transaction won't have non-read efforts assert(t.retired_set.empty()); @@ -769,8 +773,24 @@ record_t Cache::prepare_record(Transaction &t) assert(!t.is_weak()); assert(t.get_src() != Transaction::src_t::READ); - stats.committed_onode_tree_stats.increment(t.onode_tree_stats); - stats.committed_lba_tree_stats.increment(t.lba_tree_stats); + + if (t.get_src() == Transaction::src_t::CLEANER) { + // CLEANER transaction won't contain any onode tree operations + assert(t.onode_tree_stats.is_clear()); + } else { + if (t.onode_tree_stats.depth) { + stats.onode_tree_depth = t.onode_tree_stats.depth; + } + get_by_src(stats.committed_onode_tree_efforts, t.get_src() + ).increment(t.onode_tree_stats); + } + + if (t.lba_tree_stats.depth) { + stats.lba_tree_depth = t.lba_tree_stats.depth; + } + get_by_src(stats.committed_lba_tree_efforts, t.get_src() + ).increment(t.lba_tree_stats); + ++(get_by_src(stats.trans_committed_by_src, t.get_src())); auto& efforts = get_by_src(stats.committed_efforts_by_src, t.get_src()); diff --git a/src/crimson/os/seastore/cache.h b/src/crimson/os/seastore/cache.h index 0417dbff9f448..d111ab6251489 100644 --- a/src/crimson/os/seastore/cache.h +++ b/src/crimson/os/seastore/cache.h @@ -628,6 +628,16 @@ private: counter_by_extent_t fresh_by_ext; }; + struct tree_efforts_t { + uint64_t num_inserts = 0; + uint64_t num_erases = 0; + + void increment(const Transaction::tree_stats_t& incremental) { + num_inserts += incremental.num_inserts; + num_erases += incremental.num_erases; + } + }; + template using counter_by_src_t = std::array; @@ -641,10 +651,14 @@ private: uint64_t read_transactions_successful; effort_t read_effort_successful; uint64_t dirty_bytes; - Transaction::tree_stats_t committed_onode_tree_stats; - Transaction::tree_stats_t committed_lba_tree_stats; - Transaction::tree_stats_t invalidated_onode_tree_stats; - Transaction::tree_stats_t invalidated_lba_tree_stats; + + uint64_t onode_tree_depth; + counter_by_src_t committed_onode_tree_efforts; + counter_by_src_t invalidated_onode_tree_efforts; + + uint64_t lba_tree_depth; + counter_by_src_t committed_lba_tree_efforts; + counter_by_src_t invalidated_lba_tree_efforts; } stats; template diff --git a/src/crimson/os/seastore/transaction.h b/src/crimson/os/seastore/transaction.h index 2041d8cff015c..31197982756da 100644 --- a/src/crimson/os/seastore/transaction.h +++ b/src/crimson/os/seastore/transaction.h @@ -227,14 +227,6 @@ public: num_inserts == 0 && num_erases == 0); } - void increment(const tree_stats_t& incremental) { - if (incremental.depth != 0) { - // depth is an absolute value - depth = incremental.depth; - } - num_inserts += incremental.num_inserts; - num_erases += incremental.num_erases; - } }; tree_stats_t& get_onode_tree_stats() { return onode_tree_stats; -- 2.39.5