From: Venky Shankar Date: Mon, 21 Jan 2019 06:03:19 +0000 (-0500) Subject: mds: new intra-mds message type for forwarding aggregated metrics X-Git-Tag: v16.1.0~2176^2~6 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=80bac27a33945839b68c7596819c7a91073536e1;p=ceph.git mds: new intra-mds message type for forwarding aggregated metrics Signed-off-by: Venky Shankar --- diff --git a/src/mds/MDSPerfMetricTypes.h b/src/mds/MDSPerfMetricTypes.h new file mode 100644 index 000000000000..8ae2f5506571 --- /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 + +#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(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 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 index 000000000000..020cfabfb468 --- /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 + friend boost::intrusive_ptr ceph::make_message(Args&&... args); +}; + +#endif // CEPH_MDS_METRICS_H diff --git a/src/msg/Message.cc b/src/msg/Message.cc index 6ca3cd492aff..134d8ceab67d 100644 --- 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(); break; + case MSG_MDS_METRICS: + m = make_message(); + break; + case MSG_MGR_BEACON: m = make_message(); break; diff --git a/src/msg/Message.h b/src/msg/Message.h index b223aa6ebe71..60b0eac02d59 100644 --- 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