[linux-2.6-block.git] / drivers / md / bcache / stats.c

// SPDX-License-Identifier: GPL-2.0
/*
 * bcache stats code
 *
 * Copyright 2012 Google, Inc.
 */

#include "bcache.h"
#include "stats.h"
#include "btree.h"
#include "sysfs.h"

/*
 * We keep absolute totals of various statistics, and addionally a set of three
 * rolling averages.
 *
 * Every so often, a timer goes off and rescales the rolling averages.
 * accounting_rescale[] is how many times the timer has to go off before we
 * rescale each set of numbers; that gets us half lives of 5 minutes, one hour,
 * and one day.
 *
 * accounting_delay is how often the timer goes off - 22 times in 5 minutes,
 * and accounting_weight is what we use to rescale:
 *
 * pow(31 / 32, 22) ~= 1/2
 *
 * So that we don't have to increment each set of numbers every time we (say)
 * get a cache hit, we increment a single atomic_t in acc->collector, and when
 * the rescale function runs it resets the atomic counter to 0 and adds its
 * old value to each of the exported numbers.
 *
 * To reduce rounding error, the numbers in struct cache_stats are all
 * stored left shifted by 16, and scaled back in the sysfs show() function.
 */

static const unsigned int DAY_RESCALE		= 288;
static const unsigned int HOUR_RESCALE		= 12;
static const unsigned int FIVE_MINUTE_RESCALE	= 1;
static const unsigned int accounting_delay	= (HZ * 300) / 22;
static const unsigned int accounting_weight	= 32;

/* sysfs reading/writing */

read_attribute(cache_hits);
read_attribute(cache_misses);
read_attribute(cache_bypass_hits);
read_attribute(cache_bypass_misses);
read_attribute(cache_hit_ratio);
read_attribute(cache_miss_collisions);
read_attribute(bypassed);

SHOW(bch_stats)
{
	struct cache_stats *s =
		container_of(kobj, struct cache_stats, kobj);
#define var(stat)		(s->stat >> 16)
	var_print(cache_hits);
	var_print(cache_misses);
	var_print(cache_bypass_hits);
	var_print(cache_bypass_misses);

	sysfs_print(cache_hit_ratio,
		    DIV_SAFE(var(cache_hits) * 100,
			     var(cache_hits) + var(cache_misses)));

	var_print(cache_miss_collisions);
	sysfs_hprint(bypassed,	var(sectors_bypassed) << 9);
#undef var
	return 0;
}

STORE(bch_stats)
{
	return size;
}

static void bch_stats_release(struct kobject *k)
{
}

static struct attribute *bch_stats_attrs[] = {
	&sysfs_cache_hits,
	&sysfs_cache_misses,
	&sysfs_cache_bypass_hits,
	&sysfs_cache_bypass_misses,
	&sysfs_cache_hit_ratio,
	&sysfs_cache_miss_collisions,
	&sysfs_bypassed,
	NULL
};
ATTRIBUTE_GROUPS(bch_stats);
static KTYPE(bch_stats);

int bch_cache_accounting_add_kobjs(struct cache_accounting *acc,
				   struct kobject *parent)
{
	int ret = kobject_add(&acc->total.kobj, parent,
			      "stats_total");
	ret = ret ?: kobject_add(&acc->five_minute.kobj, parent,
				 "stats_five_minute");
	ret = ret ?: kobject_add(&acc->hour.kobj, parent,
				 "stats_hour");
	ret = ret ?: kobject_add(&acc->day.kobj, parent,
				 "stats_day");
	return ret;
}

void bch_cache_accounting_clear(struct cache_accounting *acc)
{
	acc->total.cache_hits = 0;
	acc->total.cache_misses = 0;
	acc->total.cache_bypass_hits = 0;
	acc->total.cache_bypass_misses = 0;
	acc->total.cache_miss_collisions = 0;
	acc->total.sectors_bypassed = 0;
}

void bch_cache_accounting_destroy(struct cache_accounting *acc)
{
	kobject_put(&acc->total.kobj);
	kobject_put(&acc->five_minute.kobj);
	kobject_put(&acc->hour.kobj);
	kobject_put(&acc->day.kobj);

	atomic_set(&acc->closing, 1);
	if (del_timer_sync(&acc->timer))
		closure_return(&acc->cl);
}

/* EWMA scaling */

static void scale_stat(unsigned long *stat)
{
	*stat =  ewma_add(*stat, 0, accounting_weight, 0);
}

static void scale_stats(struct cache_stats *stats, unsigned long rescale_at)
{
	if (++stats->rescale == rescale_at) {
		stats->rescale = 0;
		scale_stat(&stats->cache_hits);
		scale_stat(&stats->cache_misses);
		scale_stat(&stats->cache_bypass_hits);
		scale_stat(&stats->cache_bypass_misses);
		scale_stat(&stats->cache_miss_collisions);
		scale_stat(&stats->sectors_bypassed);
	}
}

static void scale_accounting(struct timer_list *t)
{
	struct cache_accounting *acc = from_timer(acc, t, timer);

#define move_stat(name) do {						\
	unsigned int t = atomic_xchg(&acc->collector.name, 0);		\
	t <<= 16;							\
	acc->five_minute.name += t;					\
	acc->hour.name += t;						\
	acc->day.name += t;						\
	acc->total.name += t;						\
} while (0)

	move_stat(cache_hits);
	move_stat(cache_misses);
	move_stat(cache_bypass_hits);
	move_stat(cache_bypass_misses);
	move_stat(cache_miss_collisions);
	move_stat(sectors_bypassed);

	scale_stats(&acc->total, 0);
	scale_stats(&acc->day, DAY_RESCALE);
	scale_stats(&acc->hour, HOUR_RESCALE);
	scale_stats(&acc->five_minute, FIVE_MINUTE_RESCALE);

	acc->timer.expires += accounting_delay;

	if (!atomic_read(&acc->closing))
		add_timer(&acc->timer);
	else
		closure_return(&acc->cl);
}

static void mark_cache_stats(struct cache_stat_collector *stats,
			     bool hit, bool bypass)
{
	if (!bypass)
		if (hit)
			atomic_inc(&stats->cache_hits);
		else
			atomic_inc(&stats->cache_misses);
	else
		if (hit)
			atomic_inc(&stats->cache_bypass_hits);
		else
			atomic_inc(&stats->cache_bypass_misses);
}

void bch_mark_cache_accounting(struct cache_set *c, struct bcache_device *d,
			       bool hit, bool bypass)
{
	struct cached_dev *dc = container_of(d, struct cached_dev, disk);

	mark_cache_stats(&dc->accounting.collector, hit, bypass);
	mark_cache_stats(&c->accounting.collector, hit, bypass);
}

void bch_mark_cache_miss_collision(struct cache_set *c, struct bcache_device *d)
{
	struct cached_dev *dc = container_of(d, struct cached_dev, disk);

	atomic_inc(&dc->accounting.collector.cache_miss_collisions);
	atomic_inc(&c->accounting.collector.cache_miss_collisions);
}

void bch_mark_sectors_bypassed(struct cache_set *c, struct cached_dev *dc,
			       int sectors)
{
	atomic_add(sectors, &dc->accounting.collector.sectors_bypassed);
	atomic_add(sectors, &c->accounting.collector.sectors_bypassed);
}

void bch_cache_accounting_init(struct cache_accounting *acc,
			       struct closure *parent)
{
	kobject_init(&acc->total.kobj,		&bch_stats_ktype);
	kobject_init(&acc->five_minute.kobj,	&bch_stats_ktype);
	kobject_init(&acc->hour.kobj,		&bch_stats_ktype);
	kobject_init(&acc->day.kobj,		&bch_stats_ktype);

	closure_init(&acc->cl, parent);
	timer_setup(&acc->timer, scale_accounting, 0);
	acc->timer.expires	= jiffies + accounting_delay;
	add_timer(&acc->timer);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
cafe5635 KO	2	/*
	3	* bcache stats code
	4	*
	5	* Copyright 2012 Google, Inc.
	6	*/
	7
	8	#include "bcache.h"
	9	#include "stats.h"
	10	#include "btree.h"
cafe5635 KO	11	#include "sysfs.h"
	12
	13	/*
	14	* We keep absolute totals of various statistics, and addionally a set of three
	15	* rolling averages.
	16	*
	17	* Every so often, a timer goes off and rescales the rolling averages.
	18	* accounting_rescale[] is how many times the timer has to go off before we
	19	* rescale each set of numbers; that gets us half lives of 5 minutes, one hour,
	20	* and one day.
	21	*
	22	* accounting_delay is how often the timer goes off - 22 times in 5 minutes,
	23	* and accounting_weight is what we use to rescale:
	24	*
	25	* pow(31 / 32, 22) ~= 1/2
	26	*
	27	* So that we don't have to increment each set of numbers every time we (say)
	28	* get a cache hit, we increment a single atomic_t in acc->collector, and when
	29	* the rescale function runs it resets the atomic counter to 0 and adds its
	30	* old value to each of the exported numbers.
	31	*
	32	* To reduce rounding error, the numbers in struct cache_stats are all
	33	* stored left shifted by 16, and scaled back in the sysfs show() function.
	34	*/
	35
6f10f7d1 CL	36	static const unsigned int DAY_RESCALE = 288;
	37	static const unsigned int HOUR_RESCALE = 12;
	38	static const unsigned int FIVE_MINUTE_RESCALE = 1;
	39	static const unsigned int accounting_delay = (HZ * 300) / 22;
	40	static const unsigned int accounting_weight = 32;
cafe5635 KO	41
	42	/* sysfs reading/writing */
	43
	44	read_attribute(cache_hits);
	45	read_attribute(cache_misses);
	46	read_attribute(cache_bypass_hits);
	47	read_attribute(cache_bypass_misses);
	48	read_attribute(cache_hit_ratio);
cafe5635 KO	49	read_attribute(cache_miss_collisions);
	50	read_attribute(bypassed);
	51
	52	SHOW(bch_stats)
	53	{
	54	struct cache_stats *s =
	55	container_of(kobj, struct cache_stats, kobj);
	56	#define var(stat) (s->stat >> 16)
	57	var_print(cache_hits);
	58	var_print(cache_misses);
	59	var_print(cache_bypass_hits);
	60	var_print(cache_bypass_misses);
	61
	62	sysfs_print(cache_hit_ratio,
	63	DIV_SAFE(var(cache_hits) * 100,
	64	var(cache_hits) + var(cache_misses)));
	65
cafe5635 KO	66	var_print(cache_miss_collisions);
	67	sysfs_hprint(bypassed, var(sectors_bypassed) << 9);
	68	#undef var
	69	return 0;
	70	}
	71
	72	STORE(bch_stats)
	73	{
	74	return size;
	75	}
	76
	77	static void bch_stats_release(struct kobject *k)
	78	{
	79	}
	80
fa97cb84	81	static struct attribute *bch_stats_attrs[] = {
cafe5635 KO	82	&sysfs_cache_hits,
	83	&sysfs_cache_misses,
	84	&sysfs_cache_bypass_hits,
	85	&sysfs_cache_bypass_misses,
	86	&sysfs_cache_hit_ratio,
cafe5635 KO	87	&sysfs_cache_miss_collisions,
	88	&sysfs_bypassed,
	89	NULL
	90	};
fa97cb84	91	ATTRIBUTE_GROUPS(bch_stats);
cafe5635 KO	92	static KTYPE(bch_stats);
cafe5635 KO	93
cafe5635 KO	94	int bch_cache_accounting_add_kobjs(struct cache_accounting *acc,
	95	struct kobject *parent)
	96	{
	97	int ret = kobject_add(&acc->total.kobj, parent,
	98	"stats_total");
	99	ret = ret ?: kobject_add(&acc->five_minute.kobj, parent,
	100	"stats_five_minute");
	101	ret = ret ?: kobject_add(&acc->hour.kobj, parent,
	102	"stats_hour");
	103	ret = ret ?: kobject_add(&acc->day.kobj, parent,
	104	"stats_day");
	105	return ret;
	106	}
	107
	108	void bch_cache_accounting_clear(struct cache_accounting *acc)
	109	{
5bebf748 CL	110	acc->total.cache_hits = 0;
	111	acc->total.cache_misses = 0;
	112	acc->total.cache_bypass_hits = 0;
	113	acc->total.cache_bypass_misses = 0;
5bebf748 CL	114	acc->total.cache_miss_collisions = 0;
5bebf748 CL	115	acc->total.sectors_bypassed = 0;
cafe5635 KO	116	}
	117
	118	void bch_cache_accounting_destroy(struct cache_accounting *acc)
	119	{
	120	kobject_put(&acc->total.kobj);
	121	kobject_put(&acc->five_minute.kobj);
	122	kobject_put(&acc->hour.kobj);
	123	kobject_put(&acc->day.kobj);
	124
	125	atomic_set(&acc->closing, 1);
	126	if (del_timer_sync(&acc->timer))
	127	closure_return(&acc->cl);
	128	}
	129
	130	/* EWMA scaling */
	131
	132	static void scale_stat(unsigned long *stat)
	133	{
	134	stat = ewma_add(stat, 0, accounting_weight, 0);
	135	}
	136
	137	static void scale_stats(struct cache_stats *stats, unsigned long rescale_at)
	138	{
	139	if (++stats->rescale == rescale_at) {
	140	stats->rescale = 0;
	141	scale_stat(&stats->cache_hits);
	142	scale_stat(&stats->cache_misses);
	143	scale_stat(&stats->cache_bypass_hits);
	144	scale_stat(&stats->cache_bypass_misses);
cafe5635 KO	145	scale_stat(&stats->cache_miss_collisions);
	146	scale_stat(&stats->sectors_bypassed);
	147	}
	148	}
	149
8376d3c1	150	static void scale_accounting(struct timer_list *t)
cafe5635	151	{
8376d3c1	152	struct cache_accounting *acc = from_timer(acc, t, timer);
cafe5635 KO	153
cafe5635 KO	154	#define move_stat(name) do { \
6f10f7d1	155	unsigned int t = atomic_xchg(&acc->collector.name, 0); \
cafe5635 KO	156	t <<= 16; \
	157	acc->five_minute.name += t; \
	158	acc->hour.name += t; \
	159	acc->day.name += t; \
	160	acc->total.name += t; \
	161	} while (0)
	162
	163	move_stat(cache_hits);
	164	move_stat(cache_misses);
	165	move_stat(cache_bypass_hits);
	166	move_stat(cache_bypass_misses);
cafe5635 KO	167	move_stat(cache_miss_collisions);
	168	move_stat(sectors_bypassed);
	169
	170	scale_stats(&acc->total, 0);
	171	scale_stats(&acc->day, DAY_RESCALE);
	172	scale_stats(&acc->hour, HOUR_RESCALE);
	173	scale_stats(&acc->five_minute, FIVE_MINUTE_RESCALE);
	174
	175	acc->timer.expires += accounting_delay;
	176
	177	if (!atomic_read(&acc->closing))
	178	add_timer(&acc->timer);
	179	else
	180	closure_return(&acc->cl);
	181	}
	182
	183	static void mark_cache_stats(struct cache_stat_collector *stats,
	184	bool hit, bool bypass)
	185	{
	186	if (!bypass)
	187	if (hit)
	188	atomic_inc(&stats->cache_hits);
	189	else
	190	atomic_inc(&stats->cache_misses);
	191	else
	192	if (hit)
	193	atomic_inc(&stats->cache_bypass_hits);
	194	else
	195	atomic_inc(&stats->cache_bypass_misses);
	196	}
	197
220bb38c KO	198	void bch_mark_cache_accounting(struct cache_set c, struct bcache_device d,
220bb38c KO	199	bool hit, bool bypass)
cafe5635	200	{
220bb38c	201	struct cached_dev *dc = container_of(d, struct cached_dev, disk);
1fae7cf0	202
cafe5635	203	mark_cache_stats(&dc->accounting.collector, hit, bypass);
220bb38c	204	mark_cache_stats(&c->accounting.collector, hit, bypass);
cafe5635 KO	205	}
cafe5635 KO	206
220bb38c	207	void bch_mark_cache_miss_collision(struct cache_set c, struct bcache_device d)
cafe5635	208	{
220bb38c	209	struct cached_dev *dc = container_of(d, struct cached_dev, disk);
1fae7cf0	210
cafe5635	211	atomic_inc(&dc->accounting.collector.cache_miss_collisions);
220bb38c	212	atomic_inc(&c->accounting.collector.cache_miss_collisions);
cafe5635 KO	213	}
cafe5635 KO	214
220bb38c KO	215	void bch_mark_sectors_bypassed(struct cache_set c, struct cached_dev dc,
220bb38c KO	216	int sectors)
cafe5635	217	{
cafe5635	218	atomic_add(sectors, &dc->accounting.collector.sectors_bypassed);
220bb38c	219	atomic_add(sectors, &c->accounting.collector.sectors_bypassed);
cafe5635	220	}
f59fce84 KO	221
	222	void bch_cache_accounting_init(struct cache_accounting *acc,
	223	struct closure *parent)
	224	{
	225	kobject_init(&acc->total.kobj, &bch_stats_ktype);
	226	kobject_init(&acc->five_minute.kobj, &bch_stats_ktype);
	227	kobject_init(&acc->hour.kobj, &bch_stats_ktype);
	228	kobject_init(&acc->day.kobj, &bch_stats_ktype);
	229
	230	closure_init(&acc->cl, parent);
8376d3c1	231	timer_setup(&acc->timer, scale_accounting, 0);
f59fce84	232	acc->timer.expires = jiffies + accounting_delay;
f59fce84 KO	233	add_timer(&acc->timer);
f59fce84 KO	234	}