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