1 #include <math.h> 2 #include "stat.h" 3 #include "evlist.h" 4 #include "evsel.h" 5 #include "thread_map.h" 6 7 void update_stats(struct stats *stats, u64 val) 8 { 9 double delta; 10 11 stats->n++; 12 delta = val - stats->mean; 13 stats->mean += delta / stats->n; 14 stats->M2 += delta*(val - stats->mean); 15 16 if (val > stats->max) 17 stats->max = val; 18 19 if (val < stats->min) 20 stats->min = val; 21 } 22 23 double avg_stats(struct stats *stats) 24 { 25 return stats->mean; 26 } 27 28 /* 29 * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance 30 * 31 * (\Sum n_i^2) - ((\Sum n_i)^2)/n 32 * s^2 = ------------------------------- 33 * n - 1 34 * 35 * http://en.wikipedia.org/wiki/Stddev 36 * 37 * The std dev of the mean is related to the std dev by: 38 * 39 * s 40 * s_mean = ------- 41 * sqrt(n) 42 * 43 */ 44 double stddev_stats(struct stats *stats) 45 { 46 double variance, variance_mean; 47 48 if (stats->n < 2) 49 return 0.0; 50 51 variance = stats->M2 / (stats->n - 1); 52 variance_mean = variance / stats->n; 53 54 return sqrt(variance_mean); 55 } 56 57 double rel_stddev_stats(double stddev, double avg) 58 { 59 double pct = 0.0; 60 61 if (avg) 62 pct = 100.0 * stddev/avg; 63 64 return pct; 65 } 66 67 bool __perf_evsel_stat__is(struct perf_evsel *evsel, 68 enum perf_stat_evsel_id id) 69 { 70 struct perf_stat_evsel *ps = evsel->priv; 71 72 return ps->id == id; 73 } 74 75 #define ID(id, name) [PERF_STAT_EVSEL_ID__##id] = #name 76 static const char *id_str[PERF_STAT_EVSEL_ID__MAX] = { 77 ID(NONE, x), 78 ID(CYCLES_IN_TX, cpu/cycles-t/), 79 ID(TRANSACTION_START, cpu/tx-start/), 80 ID(ELISION_START, cpu/el-start/), 81 ID(CYCLES_IN_TX_CP, cpu/cycles-ct/), 82 }; 83 #undef ID 84 85 void perf_stat_evsel_id_init(struct perf_evsel *evsel) 86 { 87 struct perf_stat_evsel *ps = evsel->priv; 88 int i; 89 90 /* ps->id is 0 hence PERF_STAT_EVSEL_ID__NONE by default */ 91 92 for (i = 0; i < PERF_STAT_EVSEL_ID__MAX; i++) { 93 if (!strcmp(perf_evsel__name(evsel), id_str[i])) { 94 ps->id = i; 95 break; 96 } 97 } 98 } 99 100 static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel) 101 { 102 int i; 103 struct perf_stat_evsel *ps = evsel->priv; 104 105 for (i = 0; i < 3; i++) 106 init_stats(&ps->res_stats[i]); 107 108 perf_stat_evsel_id_init(evsel); 109 } 110 111 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel) 112 { 113 evsel->priv = zalloc(sizeof(struct perf_stat_evsel)); 114 if (evsel->priv == NULL) 115 return -ENOMEM; 116 perf_evsel__reset_stat_priv(evsel); 117 return 0; 118 } 119 120 static void perf_evsel__free_stat_priv(struct perf_evsel *evsel) 121 { 122 zfree(&evsel->priv); 123 } 124 125 static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel, 126 int ncpus, int nthreads) 127 { 128 struct perf_counts *counts; 129 130 counts = perf_counts__new(ncpus, nthreads); 131 if (counts) 132 evsel->prev_raw_counts = counts; 133 134 return counts ? 0 : -ENOMEM; 135 } 136 137 static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel) 138 { 139 perf_counts__delete(evsel->prev_raw_counts); 140 evsel->prev_raw_counts = NULL; 141 } 142 143 static int perf_evsel__alloc_stats(struct perf_evsel *evsel, bool alloc_raw) 144 { 145 int ncpus = perf_evsel__nr_cpus(evsel); 146 int nthreads = thread_map__nr(evsel->threads); 147 148 if (perf_evsel__alloc_stat_priv(evsel) < 0 || 149 perf_evsel__alloc_counts(evsel, ncpus, nthreads) < 0 || 150 (alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel, ncpus, nthreads) < 0)) 151 return -ENOMEM; 152 153 return 0; 154 } 155 156 int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw) 157 { 158 struct perf_evsel *evsel; 159 160 evlist__for_each(evlist, evsel) { 161 if (perf_evsel__alloc_stats(evsel, alloc_raw)) 162 goto out_free; 163 } 164 165 return 0; 166 167 out_free: 168 perf_evlist__free_stats(evlist); 169 return -1; 170 } 171 172 void perf_evlist__free_stats(struct perf_evlist *evlist) 173 { 174 struct perf_evsel *evsel; 175 176 evlist__for_each(evlist, evsel) { 177 perf_evsel__free_stat_priv(evsel); 178 perf_evsel__free_counts(evsel); 179 perf_evsel__free_prev_raw_counts(evsel); 180 } 181 } 182 183 void perf_evlist__reset_stats(struct perf_evlist *evlist) 184 { 185 struct perf_evsel *evsel; 186 187 evlist__for_each(evlist, evsel) { 188 perf_evsel__reset_stat_priv(evsel); 189 perf_evsel__reset_counts(evsel); 190 } 191 } 192 193 static void zero_per_pkg(struct perf_evsel *counter) 194 { 195 if (counter->per_pkg_mask) 196 memset(counter->per_pkg_mask, 0, MAX_NR_CPUS); 197 } 198 199 static int check_per_pkg(struct perf_evsel *counter, 200 struct perf_counts_values *vals, int cpu, bool *skip) 201 { 202 unsigned long *mask = counter->per_pkg_mask; 203 struct cpu_map *cpus = perf_evsel__cpus(counter); 204 int s; 205 206 *skip = false; 207 208 if (!counter->per_pkg) 209 return 0; 210 211 if (cpu_map__empty(cpus)) 212 return 0; 213 214 if (!mask) { 215 mask = zalloc(MAX_NR_CPUS); 216 if (!mask) 217 return -ENOMEM; 218 219 counter->per_pkg_mask = mask; 220 } 221 222 /* 223 * we do not consider an event that has not run as a good 224 * instance to mark a package as used (skip=1). Otherwise 225 * we may run into a situation where the first CPU in a package 226 * is not running anything, yet the second is, and this function 227 * would mark the package as used after the first CPU and would 228 * not read the values from the second CPU. 229 */ 230 if (!(vals->run && vals->ena)) 231 return 0; 232 233 s = cpu_map__get_socket(cpus, cpu, NULL); 234 if (s < 0) 235 return -1; 236 237 *skip = test_and_set_bit(s, mask) == 1; 238 return 0; 239 } 240 241 static int 242 process_counter_values(struct perf_stat_config *config, struct perf_evsel *evsel, 243 int cpu, int thread, 244 struct perf_counts_values *count) 245 { 246 struct perf_counts_values *aggr = &evsel->counts->aggr; 247 static struct perf_counts_values zero; 248 bool skip = false; 249 250 if (check_per_pkg(evsel, count, cpu, &skip)) { 251 pr_err("failed to read per-pkg counter\n"); 252 return -1; 253 } 254 255 if (skip) 256 count = &zero; 257 258 switch (config->aggr_mode) { 259 case AGGR_THREAD: 260 case AGGR_CORE: 261 case AGGR_SOCKET: 262 case AGGR_NONE: 263 if (!evsel->snapshot) 264 perf_evsel__compute_deltas(evsel, cpu, thread, count); 265 perf_counts_values__scale(count, config->scale, NULL); 266 if (config->aggr_mode == AGGR_NONE) 267 perf_stat__update_shadow_stats(evsel, count->values, cpu); 268 break; 269 case AGGR_GLOBAL: 270 aggr->val += count->val; 271 if (config->scale) { 272 aggr->ena += count->ena; 273 aggr->run += count->run; 274 } 275 case AGGR_UNSET: 276 default: 277 break; 278 } 279 280 return 0; 281 } 282 283 static int process_counter_maps(struct perf_stat_config *config, 284 struct perf_evsel *counter) 285 { 286 int nthreads = thread_map__nr(counter->threads); 287 int ncpus = perf_evsel__nr_cpus(counter); 288 int cpu, thread; 289 290 if (counter->system_wide) 291 nthreads = 1; 292 293 for (thread = 0; thread < nthreads; thread++) { 294 for (cpu = 0; cpu < ncpus; cpu++) { 295 if (process_counter_values(config, counter, cpu, thread, 296 perf_counts(counter->counts, cpu, thread))) 297 return -1; 298 } 299 } 300 301 return 0; 302 } 303 304 int perf_stat_process_counter(struct perf_stat_config *config, 305 struct perf_evsel *counter) 306 { 307 struct perf_counts_values *aggr = &counter->counts->aggr; 308 struct perf_stat_evsel *ps = counter->priv; 309 u64 *count = counter->counts->aggr.values; 310 u64 val; 311 int i, ret; 312 313 aggr->val = aggr->ena = aggr->run = 0; 314 315 /* 316 * We calculate counter's data every interval, 317 * and the display code shows ps->res_stats 318 * avg value. We need to zero the stats for 319 * interval mode, otherwise overall avg running 320 * averages will be shown for each interval. 321 */ 322 if (config->interval) 323 init_stats(ps->res_stats); 324 325 if (counter->per_pkg) 326 zero_per_pkg(counter); 327 328 ret = process_counter_maps(config, counter); 329 if (ret) 330 return ret; 331 332 if (config->aggr_mode != AGGR_GLOBAL) 333 return 0; 334 335 if (!counter->snapshot) 336 perf_evsel__compute_deltas(counter, -1, -1, aggr); 337 perf_counts_values__scale(aggr, config->scale, &counter->counts->scaled); 338 339 for (i = 0; i < 3; i++) 340 update_stats(&ps->res_stats[i], count[i]); 341 342 if (verbose) { 343 fprintf(config->output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 344 perf_evsel__name(counter), count[0], count[1], count[2]); 345 } 346 347 /* 348 * Save the full runtime - to allow normalization during printout: 349 */ 350 val = counter->scale * *count; 351 perf_stat__update_shadow_stats(counter, &val, 0); 352 353 return 0; 354 } 355 356 int perf_event__process_stat_event(struct perf_tool *tool __maybe_unused, 357 union perf_event *event, 358 struct perf_session *session) 359 { 360 struct perf_counts_values count; 361 struct stat_event *st = &event->stat; 362 struct perf_evsel *counter; 363 364 count.val = st->val; 365 count.ena = st->ena; 366 count.run = st->run; 367 368 counter = perf_evlist__id2evsel(session->evlist, st->id); 369 if (!counter) { 370 pr_err("Failed to resolve counter for stat event.\n"); 371 return -EINVAL; 372 } 373 374 *perf_counts(counter->counts, st->cpu, st->thread) = count; 375 counter->supported = true; 376 return 0; 377 } 378 379 size_t perf_event__fprintf_stat(union perf_event *event, FILE *fp) 380 { 381 struct stat_event *st = (struct stat_event *) event; 382 size_t ret; 383 384 ret = fprintf(fp, "\n... id %" PRIu64 ", cpu %d, thread %d\n", 385 st->id, st->cpu, st->thread); 386 ret += fprintf(fp, "... value %" PRIu64 ", enabled %" PRIu64 ", running %" PRIu64 "\n", 387 st->val, st->ena, st->run); 388 389 return ret; 390 } 391 392 size_t perf_event__fprintf_stat_round(union perf_event *event, FILE *fp) 393 { 394 struct stat_round_event *rd = (struct stat_round_event *)event; 395 size_t ret; 396 397 ret = fprintf(fp, "\n... time %" PRIu64 ", type %s\n", rd->time, 398 rd->type == PERF_STAT_ROUND_TYPE__FINAL ? "FINAL" : "INTERVAL"); 399 400 return ret; 401 } 402 403 size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp) 404 { 405 struct perf_stat_config sc; 406 size_t ret; 407 408 perf_event__read_stat_config(&sc, &event->stat_config); 409 410 ret = fprintf(fp, "\n"); 411 ret += fprintf(fp, "... aggr_mode %d\n", sc.aggr_mode); 412 ret += fprintf(fp, "... scale %d\n", sc.scale); 413 ret += fprintf(fp, "... interval %u\n", sc.interval); 414 415 return ret; 416 } 417