mds: new intra-mds message type for forwarding aggregated metrics

Signed-off-by: Venky Shankar <vshankar@redhat.com>

diff --git a/src/mds/MDSPerfMetricTypes.h b/src/mds/MDSPerfMetricTypes.h
new file mode 100644 (file)
index 0000000..8ae2f55
--- /dev/null
+++ b/src/mds/MDSPerfMetricTypes.h
@@ -0,0 +1,190 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef CEPH_MDS_PERF_METRIC_TYPES_H
+#define CEPH_MDS_PERF_METRIC_TYPES_H
+
+#include <ostream>
+
+#include "include/denc.h"
+#include "include/utime.h"
+#include "mdstypes.h"
+
+enum UpdateType : uint32_t {
+  UPDATE_TYPE_REFRESH = 0,
+  UPDATE_TYPE_REMOVE,
+};
+
+struct CapHitMetric {
+  uint64_t hits = 0;
+  uint64_t misses = 0;
+
+  DENC(CapHitMetric, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.hits, p);
+    denc(v.misses, p);
+    DENC_FINISH(p);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_unsigned("hits", hits);
+    f->dump_unsigned("misses", misses);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const CapHitMetric &metric) {
+    os << "{hits=" << metric.hits << ", misses=" << metric.misses << "}";
+    return os;
+  }
+};
+
+struct ReadLatencyMetric {
+  utime_t lat;
+
+  DENC(ReadLatencyMetric, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.lat, p);
+    DENC_FINISH(p);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_object("read_latency", lat);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const ReadLatencyMetric &metric) {
+    os << "{latency=" << metric.lat << "}";
+    return os;
+  }
+};
+
+struct WriteLatencyMetric {
+  utime_t lat;
+
+  DENC(WriteLatencyMetric, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.lat, p);
+    DENC_FINISH(p);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_object("write_latency", lat);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const WriteLatencyMetric &metric) {
+    os << "{latency=" << metric.lat << "}";
+    return os;
+  }
+};
+
+struct MetadataLatencyMetric {
+  utime_t lat;
+
+  DENC(MetadataLatencyMetric, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.lat, p);
+    DENC_FINISH(p);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_object("metadata_latency", lat);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const MetadataLatencyMetric &metric) {
+    os << "{latency=" << metric.lat << "}";
+    return os;
+  }
+};
+
+WRITE_CLASS_DENC(CapHitMetric)
+WRITE_CLASS_DENC(ReadLatencyMetric)
+WRITE_CLASS_DENC(WriteLatencyMetric)
+WRITE_CLASS_DENC(MetadataLatencyMetric)
+
+// metrics that are forwarded to the MDS by client(s).
+struct Metrics {
+  // metrics
+  CapHitMetric cap_hit_metric;
+  ReadLatencyMetric read_latency_metric;
+  WriteLatencyMetric write_latency_metric;
+  MetadataLatencyMetric metadata_latency_metric;
+
+  // metric update type
+  uint32_t update_type = UpdateType::UPDATE_TYPE_REFRESH;
+
+  DENC(Metrics, v, p) {
+    DENC_START(1, 1, p);
+    denc(v.update_type, p);
+    denc(v.cap_hit_metric, p);
+    denc(v.read_latency_metric, p);
+    denc(v.write_latency_metric, p);
+    denc(v.metadata_latency_metric, p);
+    DENC_FINISH(p);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_int("update_type", static_cast<uint32_t>(update_type));
+    f->dump_object("cap_hit_metric", cap_hit_metric);
+    f->dump_object("read_latency_metric", read_latency_metric);
+    f->dump_object("write_latency_metric", write_latency_metric);
+    f->dump_object("metadata_latency_metric", metadata_latency_metric);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const Metrics& metrics) {
+    os << "[update_type=" << metrics.update_type << ", metrics={"
+       << "cap_hit_metric=" << metrics.cap_hit_metric
+       << ", read_latency=" << metrics.read_latency_metric
+       << ", write_latency=" << metrics.write_latency_metric
+       << ", metadata_latency=" << metrics.metadata_latency_metric
+       << "}]";
+    return os;
+  }
+};
+WRITE_CLASS_DENC(Metrics)
+
+struct metrics_message_t {
+  version_t seq = 0;
+  mds_rank_t rank = MDS_RANK_NONE;
+  std::map<entity_inst_t, Metrics> client_metrics_map;
+
+  metrics_message_t() {
+  }
+  metrics_message_t(version_t seq, mds_rank_t rank)
+    : seq(seq), rank(rank) {
+  }
+
+  void encode(bufferlist &bl, uint64_t features) const {
+    using ceph::encode;
+    ENCODE_START(1, 1, bl);
+    encode(seq, bl);
+    encode(rank, bl);
+    encode(client_metrics_map, bl, features);
+    ENCODE_FINISH(bl);
+  }
+
+  void decode(bufferlist::const_iterator &iter) {
+    using ceph::decode;
+    DECODE_START(1, iter);
+    decode(seq, iter);
+    decode(rank, iter);
+    decode(client_metrics_map, iter);
+    DECODE_FINISH(iter);
+  }
+
+  void dump(Formatter *f) const {
+    f->dump_unsigned("seq", seq);
+    f->dump_int("rank", rank);
+    for (auto &[client, metrics] : client_metrics_map) {
+      f->dump_object("client", client);
+      f->dump_object("metrics", metrics);
+    }
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const metrics_message_t &metrics_message) {
+    os << "[sequence=" << metrics_message.seq << ", rank=" << metrics_message.rank
+       << ", metrics=" << metrics_message.client_metrics_map << "]";
+    return os;
+  }
+};
+
+WRITE_CLASS_ENCODER_FEATURES(metrics_message_t)
+
+#endif // CEPH_MDS_PERF_METRIC_TYPES_H

diff --git a/src/messages/MMDSMetrics.h b/src/messages/MMDSMetrics.h
new file mode 100644 (file)
index 0000000..020cfab
--- /dev/null
+++ b/src/messages/MMDSMetrics.h
@@ -0,0 +1,53 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef CEPH_MDS_METRICS_H
+#define CEPH_MDS_METRICS_H
+
+#include "msg/Message.h"
+#include "mds/MDSPerfMetricTypes.h"
+
+class MMDSMetrics : public SafeMessage {
+private:
+  static constexpr int HEAD_VERSION = 1;
+  static constexpr int COMPAT_VERSION = 1;
+public:
+  // metrics messsage (client -> metrics map, rank, etc..)
+  metrics_message_t metrics_message;
+
+protected:
+  MMDSMetrics() : SafeMessage(MSG_MDS_METRICS, HEAD_VERSION, COMPAT_VERSION) {
+  }
+  MMDSMetrics(metrics_message_t metrics_message)
+    : SafeMessage(MSG_MDS_METRICS, HEAD_VERSION, COMPAT_VERSION),
+      metrics_message(metrics_message) {
+  }
+  ~MMDSMetrics() { }
+
+public:
+  std::string_view get_type_name() const override {
+    return "mds_metrics";
+  }
+
+  void print(ostream &out) const override {
+    out << "mds_metrics from rank=" << metrics_message.rank << " carrying "
+        << metrics_message.client_metrics_map.size() << " metric updates";
+  }
+
+  void encode_payload(uint64_t features) override {
+    using ceph::encode;
+    encode(metrics_message, payload, features);
+  }
+
+  void decode_payload() override {
+    using ceph::decode;
+    auto iter = payload.cbegin();
+    decode(metrics_message, iter);
+  }
+
+private:
+  template<class T, typename... Args>
+  friend boost::intrusive_ptr<T> ceph::make_message(Args&&... args);
+};
+
+#endif // CEPH_MDS_METRICS_H

diff --git a/src/msg/Message.cc b/src/msg/Message.cc
index 6ca3cd492affb07eecbe4b22903f50d1eaa27f5d..134d8ceab67db1ef7e9c56ec005b67eb8435b8ef 100644 (file)
--- a/src/msg/Message.cc
+++ b/src/msg/Message.cc
@@ -175,6 +175,7 @@
 #include "messages/MHeartbeat.h"
 
 #include "messages/MMDSTableRequest.h"
+#include "messages/MMDSMetrics.h"
 
 //#include "messages/MInodeUpdate.h"
 #include "messages/MCacheExpire.h"
@@ -833,6 +834,10 @@ Message *decode_message(CephContext *cct,
     m = make_message<MLock>();
     break;
 
+  case MSG_MDS_METRICS:
+    m = make_message<MMDSMetrics>();
+    break;
+
   case MSG_MGR_BEACON:
     m = make_message<MMgrBeacon>();
     break;

diff --git a/src/msg/Message.h b/src/msg/Message.h
index b223aa6ebe718f57e20c0a7f941ed1927b126d88..60b0eac02d59c446e9c41679639afe904856772f 100644 (file)
--- a/src/msg/Message.h
+++ b/src/msg/Message.h
@@ -171,6 +171,7 @@
 #define MSG_MDS_FRAGMENTNOTIFYACK  0x212
 #define MSG_MDS_LOCK               0x300
 #define MSG_MDS_INODEFILECAPS      0x301
+#define MSG_MDS_METRICS            0x302
 
 #define MSG_MDS_EXPORTDIRDISCOVER     0x449
 #define MSG_MDS_EXPORTDIRDISCOVERACK  0x450