From: xiubli@redhat.com
To: jlayton@kernel.org
Cc: sage@redhat.com, idryomov@gmail.com, gfarnum@redhat.com,
zyan@redhat.com, pdonnell@redhat.com, ceph-devel@vger.kernel.org,
Xiubo Li <xiubli@redhat.com>
Subject: [PATCH v4 4/4] ceph: add standard deviation support for read/write/metadata perf metric
Date: Wed, 18 Mar 2020 01:45:55 -0400 [thread overview]
Message-ID: <1584510355-6936-5-git-send-email-xiubli@redhat.com> (raw)
In-Reply-To: <1584510355-6936-1-git-send-email-xiubli@redhat.com>
From: Xiubo Li <xiubli@redhat.com>
Switch {read/write/metadata}_latency_sum to atomic type and remove
{read/write/metadata}_latency_sum showing in the debugfs, which makes
no sense.
URL: https://tracker.ceph.com/issues/44534
Signed-off-by: Xiubo Li <xiubli@redhat.com>
---
fs/ceph/debugfs.c | 88 +++++++++++++++++++++++++++++++++----------------
fs/ceph/metric.c | 99 ++++++++++++++++++++++++++++++++-----------------------
fs/ceph/metric.h | 18 ++++++----
3 files changed, 129 insertions(+), 76 deletions(-)
diff --git a/fs/ceph/debugfs.c b/fs/ceph/debugfs.c
index 01b95fe..21f5663 100644
--- a/fs/ceph/debugfs.c
+++ b/fs/ceph/debugfs.c
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-2.0
#include <linux/ceph/ceph_debug.h>
+#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/module.h>
@@ -124,48 +125,77 @@ static int mdsc_show(struct seq_file *s, void *p)
return 0;
}
+static s64 get_avg(atomic64_t *totalp, atomic64_t *sump, spinlock_t *lockp,
+ s64 *total)
+{
+ s64 n, sum, avg = 0;
+
+ spin_lock(lockp);
+ n = atomic64_read(totalp);
+ sum = atomic64_read(sump);
+ spin_unlock(lockp);
+
+ if (likely(n))
+ avg = DIV64_U64_ROUND_CLOSEST(sum, n);
+
+ *total = n;
+ return avg;
+}
+
+#define METRIC(name, total, avg, min, max, sq) { \
+ s64 _total, _avg, _min, _max, _sq, _st, _re = 0; \
+ _avg = jiffies_to_usecs(avg); \
+ _min = jiffies_to_usecs(min == S64_MAX ? 0 : min); \
+ _max = jiffies_to_usecs(max); \
+ _total = total - 1; \
+ _sq = _total > 0 ? DIV64_U64_ROUND_CLOSEST(sq, _total) : 0; \
+ _sq = jiffies_to_usecs(_sq); \
+ _st = int_sqrt64(_sq); \
+ if (_st > 0) { \
+ _re = 5 * (_sq - (_st * _st)); \
+ _re = _re > 0 ? _re - 1 : 0; \
+ _re = _st > 0 ? div64_s64(_re, _st) : 0; \
+ } \
+ seq_printf(s, "%-14s%-12lld%-16lld%-16lld%-16lld%lld.%lld\n", \
+ name, total, _avg, _min, _max, _st, _re); \
+}
+
static int metric_show(struct seq_file *s, void *p)
{
struct ceph_fs_client *fsc = s->private;
struct ceph_mds_client *mdsc = fsc->mdsc;
int i, nr_caps = 0;
- s64 total, sum, avg = 0, min, max;
+ s64 total, avg, min, max, sq;
- seq_printf(s, "item total sum_lat(us) avg_lat(us) min_lat(us) max_lat(us)\n");
- seq_printf(s, "-------------------------------------------------------------------------------------\n");
+ seq_printf(s, "item total avg_lat(us) min_lat(us) max_lat(us) stdev(us)\n");
+ seq_printf(s, "-----------------------------------------------------------------------------------\n");
- total = percpu_counter_sum(&mdsc->metric.total_reads);
- sum = percpu_counter_sum(&mdsc->metric.read_latency_sum);
- sum = jiffies_to_usecs(sum);
- avg = total ? DIV64_U64_ROUND_CLOSEST(sum, total) : 0;
+ avg = get_avg(&mdsc->metric.total_reads,
+ &mdsc->metric.read_latency_sum,
+ &mdsc->metric.read_latency_lock,
+ &total);
min = atomic64_read(&mdsc->metric.read_latency_min);
- min = jiffies_to_usecs(min == S64_MAX ? 0 : min);
max = atomic64_read(&mdsc->metric.read_latency_max);
- max = jiffies_to_usecs(max);
- seq_printf(s, "%-14s%-12lld%-16lld%-16lld%-16lld%lld\n", "read",
- total, sum, avg, min, max);
-
- total = percpu_counter_sum(&mdsc->metric.total_writes);
- sum = percpu_counter_sum(&mdsc->metric.write_latency_sum);
- sum = jiffies_to_usecs(sum);
- avg = total ? DIV64_U64_ROUND_CLOSEST(sum, total) : 0;
+ sq = percpu_counter_sum(&mdsc->metric.read_latency_sq_sum);
+ METRIC("read", total, avg, min, max, sq);
+
+ avg = get_avg(&mdsc->metric.total_writes,
+ &mdsc->metric.write_latency_sum,
+ &mdsc->metric.write_latency_lock,
+ &total);
min = atomic64_read(&mdsc->metric.write_latency_min);
- min = jiffies_to_usecs(min == S64_MAX ? 0 : min);
max = atomic64_read(&mdsc->metric.write_latency_max);
- max = jiffies_to_usecs(max);
- seq_printf(s, "%-14s%-12lld%-16lld%-16lld%-16lld%lld\n", "write",
- total, sum, avg, min, max);
-
- total = percpu_counter_sum(&mdsc->metric.total_metadatas);
- sum = percpu_counter_sum(&mdsc->metric.metadata_latency_sum);
- sum = jiffies_to_usecs(sum);
- avg = total ? DIV64_U64_ROUND_CLOSEST(sum, total) : 0;
+ sq = percpu_counter_sum(&mdsc->metric.write_latency_sq_sum);
+ METRIC("write", total, avg, min, max, sq);
+
+ avg = get_avg(&mdsc->metric.total_metadatas,
+ &mdsc->metric.metadata_latency_sum,
+ &mdsc->metric.metadata_latency_lock,
+ &total);
min = atomic64_read(&mdsc->metric.metadata_latency_min);
- min = jiffies_to_usecs(min == S64_MAX ? 0 : min);
max = atomic64_read(&mdsc->metric.metadata_latency_max);
- max = jiffies_to_usecs(max);
- seq_printf(s, "%-14s%-12lld%-16lld%-16lld%-16lld%lld\n", "metadata",
- total, sum, avg, min, max);
+ sq = percpu_counter_sum(&mdsc->metric.metadata_latency_sq_sum);
+ METRIC("metadata", total, avg, min, max, sq);
seq_printf(s, "\n");
seq_printf(s, "item total miss hit\n");
diff --git a/fs/ceph/metric.c b/fs/ceph/metric.c
index 1b764df..23bd80f 100644
--- a/fs/ceph/metric.c
+++ b/fs/ceph/metric.c
@@ -1,5 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
+#include <linux/kernel.h>
#include <linux/atomic.h>
#include <linux/percpu_counter.h>
@@ -29,52 +30,43 @@ int ceph_mdsc_metric_init(struct ceph_client_metric *m)
if (ret)
goto err_i_caps_mis;
- ret = percpu_counter_init(&m->total_reads, 0, GFP_KERNEL);
+ ret = percpu_counter_init(&m->read_latency_sq_sum, 0, GFP_KERNEL);
if (ret)
- goto err_total_reads;
-
- ret = percpu_counter_init(&m->read_latency_sum, 0, GFP_KERNEL);
- if (ret)
- goto err_read_latency_sum;
+ goto err_read_latency_sq_sum;
+ spin_lock_init(&m->read_latency_lock);
+ atomic64_set(&m->total_reads, 0);
+ atomic64_set(&m->read_latency_sum, 0);
atomic64_set(&m->read_latency_min, S64_MAX);
atomic64_set(&m->read_latency_max, 0);
- ret = percpu_counter_init(&m->total_writes, 0, GFP_KERNEL);
- if (ret)
- goto err_total_writes;
-
- ret = percpu_counter_init(&m->write_latency_sum, 0, GFP_KERNEL);
+ ret = percpu_counter_init(&m->write_latency_sq_sum, 0, GFP_KERNEL);
if (ret)
- goto err_write_latency_sum;
+ goto err_write_latency_sq_sum;
+ spin_lock_init(&m->write_latency_lock);
+ atomic64_set(&m->total_writes, 0);
+ atomic64_set(&m->write_latency_sum, 0);
atomic64_set(&m->write_latency_min, S64_MAX);
atomic64_set(&m->write_latency_max, 0);
- ret = percpu_counter_init(&m->total_metadatas, 0, GFP_KERNEL);
+ ret = percpu_counter_init(&m->metadata_latency_sq_sum, 0, GFP_KERNEL);
if (ret)
- goto err_total_metadatas;
-
- ret = percpu_counter_init(&m->metadata_latency_sum, 0, GFP_KERNEL);
- if (ret)
- goto err_metadata_latency_sum;
+ goto err_metadata_latency_sq_sum;
+ spin_lock_init(&m->metadata_latency_lock);
+ atomic64_set(&m->total_metadatas, 0);
+ atomic64_set(&m->metadata_latency_sum, 0);
atomic64_set(&m->metadata_latency_min, S64_MAX);
atomic64_set(&m->metadata_latency_max, 0);
return 0;
-err_metadata_latency_sum:
- percpu_counter_destroy(&m->total_metadatas);
-err_total_metadatas:
- percpu_counter_destroy(&m->write_latency_sum);
-err_write_latency_sum:
- percpu_counter_destroy(&m->total_writes);
-err_total_writes:
- percpu_counter_destroy(&m->read_latency_sum);
-err_read_latency_sum:
- percpu_counter_destroy(&m->total_reads);
-err_total_reads:
+err_metadata_latency_sq_sum:
+ percpu_counter_destroy(&m->write_latency_sq_sum);
+err_write_latency_sq_sum:
+ percpu_counter_destroy(&m->read_latency_sq_sum);
+err_read_latency_sq_sum:
percpu_counter_destroy(&m->i_caps_mis);
err_i_caps_mis:
percpu_counter_destroy(&m->i_caps_hit);
@@ -88,12 +80,9 @@ int ceph_mdsc_metric_init(struct ceph_client_metric *m)
void ceph_mdsc_metric_destroy(struct ceph_client_metric *m)
{
- percpu_counter_destroy(&m->metadata_latency_sum);
- percpu_counter_destroy(&m->total_metadatas);
- percpu_counter_destroy(&m->write_latency_sum);
- percpu_counter_destroy(&m->total_writes);
- percpu_counter_destroy(&m->read_latency_sum);
- percpu_counter_destroy(&m->total_reads);
+ percpu_counter_destroy(&m->metadata_latency_sq_sum);
+ percpu_counter_destroy(&m->write_latency_sq_sum);
+ percpu_counter_destroy(&m->read_latency_sq_sum);
percpu_counter_destroy(&m->i_caps_mis);
percpu_counter_destroy(&m->i_caps_hit);
percpu_counter_destroy(&m->d_lease_mis);
@@ -124,6 +113,28 @@ static inline void __update_max_latency(atomic64_t *max, unsigned long lat)
} while (unlikely((cur = atomic64_cmpxchg(max, old, lat)) != old));
}
+static inline void __update_avg_and_sq(atomic64_t *totalp, atomic64_t *lat_sump,
+ struct percpu_counter *sq_sump,
+ spinlock_t *lockp, unsigned long lat)
+{
+ s64 total, avg, sq, lsum;
+
+ spin_lock(lockp);
+ total = atomic64_inc_return(totalp);
+ lsum = atomic64_add_return(lat, lat_sump);
+ spin_unlock(lockp);
+
+ if (unlikely(total == 1))
+ return;
+
+ /* the sq is (lat - old_avg) * (lat - new_avg) */
+ avg = DIV64_U64_ROUND_CLOSEST((lsum - lat), (total - 1));
+ sq = lat - avg;
+ avg = DIV64_U64_ROUND_CLOSEST(lsum, total);
+ sq = sq * (lat - avg);
+ percpu_counter_add(sq_sump, sq);
+}
+
void ceph_update_read_latency(struct ceph_client_metric *m,
unsigned long r_start,
unsigned long r_end,
@@ -134,10 +145,12 @@ void ceph_update_read_latency(struct ceph_client_metric *m,
if (rc < 0 && rc != -ENOENT && rc != -ETIMEDOUT)
return;
- percpu_counter_inc(&m->total_reads);
- percpu_counter_add(&m->read_latency_sum, lat);
__update_min_latency(&m->read_latency_min, lat);
__update_max_latency(&m->read_latency_max, lat);
+ __update_avg_and_sq(&m->total_reads, &m->read_latency_sum,
+ &m->read_latency_sq_sum,
+ &m->read_latency_lock,
+ lat);
}
void ceph_update_write_latency(struct ceph_client_metric *m,
@@ -150,10 +163,12 @@ void ceph_update_write_latency(struct ceph_client_metric *m,
if (rc && rc != -ETIMEDOUT)
return;
- percpu_counter_inc(&m->total_writes);
- percpu_counter_add(&m->write_latency_sum, lat);
__update_min_latency(&m->write_latency_min, lat);
__update_max_latency(&m->write_latency_max, lat);
+ __update_avg_and_sq(&m->total_writes, &m->write_latency_sum,
+ &m->write_latency_sq_sum,
+ &m->write_latency_lock,
+ lat);
}
void ceph_update_metadata_latency(struct ceph_client_metric *m,
@@ -166,8 +181,10 @@ void ceph_update_metadata_latency(struct ceph_client_metric *m,
if (rc && rc != -ENOENT)
return;
- percpu_counter_inc(&m->total_metadatas);
- percpu_counter_add(&m->metadata_latency_sum, lat);
__update_min_latency(&m->metadata_latency_min, lat);
__update_max_latency(&m->metadata_latency_max, lat);
+ __update_avg_and_sq(&m->total_metadatas, &m->metadata_latency_sum,
+ &m->metadata_latency_sq_sum,
+ &m->metadata_latency_lock,
+ lat);
}
diff --git a/fs/ceph/metric.h b/fs/ceph/metric.h
index f139aff..d63b95e 100644
--- a/fs/ceph/metric.h
+++ b/fs/ceph/metric.h
@@ -14,18 +14,24 @@ struct ceph_client_metric {
struct percpu_counter i_caps_hit;
struct percpu_counter i_caps_mis;
- struct percpu_counter total_reads;
- struct percpu_counter read_latency_sum;
+ struct percpu_counter read_latency_sq_sum;
+ spinlock_t read_latency_lock;
+ atomic64_t total_reads;
+ atomic64_t read_latency_sum;
atomic64_t read_latency_min;
atomic64_t read_latency_max;
- struct percpu_counter total_writes;
- struct percpu_counter write_latency_sum;
+ struct percpu_counter write_latency_sq_sum;
+ spinlock_t write_latency_lock;
+ atomic64_t total_writes;
+ atomic64_t write_latency_sum;
atomic64_t write_latency_min;
atomic64_t write_latency_max;
- struct percpu_counter total_metadatas;
- struct percpu_counter metadata_latency_sum;
+ struct percpu_counter metadata_latency_sq_sum;
+ spinlock_t metadata_latency_lock;
+ atomic64_t total_metadatas;
+ atomic64_t metadata_latency_sum;
atomic64_t metadata_latency_min;
atomic64_t metadata_latency_max;
};
--
1.8.3.1
next prev parent reply other threads:[~2020-03-18 5:46 UTC|newest]
Thread overview: 9+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-03-18 5:45 [PATCH v4 0/4] ceph: add min/max/stdev latency support xiubli
2020-03-18 5:45 ` [PATCH v4 1/4] ceph: switch to DIV64_U64_ROUND_CLOSEST to support 32-bit arches xiubli
2020-03-18 5:45 ` [PATCH v4 2/4] ceph: add min/max latency support for read/write/metadata metrics xiubli
2020-03-18 5:45 ` [PATCH v4 3/4] ceph: move the metric helpers into one separate file xiubli
2020-03-18 5:45 ` xiubli [this message]
2020-03-18 9:11 ` [PATCH v4 0/4] ceph: add min/max/stdev latency support Ilya Dryomov
2020-03-18 10:36 ` Xiubo Li
2020-03-18 10:43 ` Jeff Layton
2020-03-18 10:50 ` Xiubo Li
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1584510355-6936-5-git-send-email-xiubli@redhat.com \
--to=xiubli@redhat.com \
--cc=ceph-devel@vger.kernel.org \
--cc=gfarnum@redhat.com \
--cc=idryomov@gmail.com \
--cc=jlayton@kernel.org \
--cc=pdonnell@redhat.com \
--cc=sage@redhat.com \
--cc=zyan@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.