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 ID(TOPDOWN_TOTAL_SLOTS, topdown-total-slots), 83 ID(TOPDOWN_SLOTS_ISSUED, topdown-slots-issued), 84 ID(TOPDOWN_SLOTS_RETIRED, topdown-slots-retired), 85 ID(TOPDOWN_FETCH_BUBBLES, topdown-fetch-bubbles), 86 ID(TOPDOWN_RECOVERY_BUBBLES, topdown-recovery-bubbles), 87 }; 88 #undef ID 89 90 void perf_stat_evsel_id_init(struct perf_evsel *evsel) 91 { 92 struct perf_stat_evsel *ps = evsel->priv; 93 int i; 94 95 /* ps->id is 0 hence PERF_STAT_EVSEL_ID__NONE by default */ 96 97 for (i = 0; i < PERF_STAT_EVSEL_ID__MAX; i++) { 98 if (!strcmp(perf_evsel__name(evsel), id_str[i])) { 99 ps->id = i; 100 break; 101 } 102 } 103 } 104 105 static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel) 106 { 107 int i; 108 struct perf_stat_evsel *ps = evsel->priv; 109 110 for (i = 0; i < 3; i++) 111 init_stats(&ps->res_stats[i]); 112 113 perf_stat_evsel_id_init(evsel); 114 } 115 116 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel) 117 { 118 evsel->priv = zalloc(sizeof(struct perf_stat_evsel)); 119 if (evsel->priv == NULL) 120 return -ENOMEM; 121 perf_evsel__reset_stat_priv(evsel); 122 return 0; 123 } 124 125 static void perf_evsel__free_stat_priv(struct perf_evsel *evsel) 126 { 127 zfree(&evsel->priv); 128 } 129 130 static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel, 131 int ncpus, int nthreads) 132 { 133 struct perf_counts *counts; 134 135 counts = perf_counts__new(ncpus, nthreads); 136 if (counts) 137 evsel->prev_raw_counts = counts; 138 139 return counts ? 0 : -ENOMEM; 140 } 141 142 static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel) 143 { 144 perf_counts__delete(evsel->prev_raw_counts); 145 evsel->prev_raw_counts = NULL; 146 } 147 148 static int perf_evsel__alloc_stats(struct perf_evsel *evsel, bool alloc_raw) 149 { 150 int ncpus = perf_evsel__nr_cpus(evsel); 151 int nthreads = thread_map__nr(evsel->threads); 152 153 if (perf_evsel__alloc_stat_priv(evsel) < 0 || 154 perf_evsel__alloc_counts(evsel, ncpus, nthreads) < 0 || 155 (alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel, ncpus, nthreads) < 0)) 156 return -ENOMEM; 157 158 return 0; 159 } 160 161 int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw) 162 { 163 struct perf_evsel *evsel; 164 165 evlist__for_each_entry(evlist, evsel) { 166 if (perf_evsel__alloc_stats(evsel, alloc_raw)) 167 goto out_free; 168 } 169 170 return 0; 171 172 out_free: 173 perf_evlist__free_stats(evlist); 174 return -1; 175 } 176 177 void perf_evlist__free_stats(struct perf_evlist *evlist) 178 { 179 struct perf_evsel *evsel; 180 181 evlist__for_each_entry(evlist, evsel) { 182 perf_evsel__free_stat_priv(evsel); 183 perf_evsel__free_counts(evsel); 184 perf_evsel__free_prev_raw_counts(evsel); 185 } 186 } 187 188 void perf_evlist__reset_stats(struct perf_evlist *evlist) 189 { 190 struct perf_evsel *evsel; 191 192 evlist__for_each_entry(evlist, evsel) { 193 perf_evsel__reset_stat_priv(evsel); 194 perf_evsel__reset_counts(evsel); 195 } 196 } 197 198 static void zero_per_pkg(struct perf_evsel *counter) 199 { 200 if (counter->per_pkg_mask) 201 memset(counter->per_pkg_mask, 0, MAX_NR_CPUS); 202 } 203 204 static int check_per_pkg(struct perf_evsel *counter, 205 struct perf_counts_values *vals, int cpu, bool *skip) 206 { 207 unsigned long *mask = counter->per_pkg_mask; 208 struct cpu_map *cpus = perf_evsel__cpus(counter); 209 int s; 210 211 *skip = false; 212 213 if (!counter->per_pkg) 214 return 0; 215 216 if (cpu_map__empty(cpus)) 217 return 0; 218 219 if (!mask) { 220 mask = zalloc(MAX_NR_CPUS); 221 if (!mask) 222 return -ENOMEM; 223 224 counter->per_pkg_mask = mask; 225 } 226 227 /* 228 * we do not consider an event that has not run as a good 229 * instance to mark a package as used (skip=1). Otherwise 230 * we may run into a situation where the first CPU in a package 231 * is not running anything, yet the second is, and this function 232 * would mark the package as used after the first CPU and would 233 * not read the values from the second CPU. 234 */ 235 if (!(vals->run && vals->ena)) 236 return 0; 237 238 s = cpu_map__get_socket(cpus, cpu, NULL); 239 if (s < 0) 240 return -1; 241 242 *skip = test_and_set_bit(s, mask) == 1; 243 return 0; 244 } 245 246 static int 247 process_counter_values(struct perf_stat_config *config, struct perf_evsel *evsel, 248 int cpu, int thread, 249 struct perf_counts_values *count) 250 { 251 struct perf_counts_values *aggr = &evsel->counts->aggr; 252 static struct perf_counts_values zero; 253 bool skip = false; 254 255 if (check_per_pkg(evsel, count, cpu, &skip)) { 256 pr_err("failed to read per-pkg counter\n"); 257 return -1; 258 } 259 260 if (skip) 261 count = &zero; 262 263 switch (config->aggr_mode) { 264 case AGGR_THREAD: 265 case AGGR_CORE: 266 case AGGR_SOCKET: 267 case AGGR_NONE: 268 if (!evsel->snapshot) 269 perf_evsel__compute_deltas(evsel, cpu, thread, count); 270 perf_counts_values__scale(count, config->scale, NULL); 271 if (config->aggr_mode == AGGR_NONE) 272 perf_stat__update_shadow_stats(evsel, count->values, cpu); 273 break; 274 case AGGR_GLOBAL: 275 aggr->val += count->val; 276 if (config->scale) { 277 aggr->ena += count->ena; 278 aggr->run += count->run; 279 } 280 case AGGR_UNSET: 281 default: 282 break; 283 } 284 285 return 0; 286 } 287 288 static int process_counter_maps(struct perf_stat_config *config, 289 struct perf_evsel *counter) 290 { 291 int nthreads = thread_map__nr(counter->threads); 292 int ncpus = perf_evsel__nr_cpus(counter); 293 int cpu, thread; 294 295 if (counter->system_wide) 296 nthreads = 1; 297 298 for (thread = 0; thread < nthreads; thread++) { 299 for (cpu = 0; cpu < ncpus; cpu++) { 300 if (process_counter_values(config, counter, cpu, thread, 301 perf_counts(counter->counts, cpu, thread))) 302 return -1; 303 } 304 } 305 306 return 0; 307 } 308 309 int perf_stat_process_counter(struct perf_stat_config *config, 310 struct perf_evsel *counter) 311 { 312 struct perf_counts_values *aggr = &counter->counts->aggr; 313 struct perf_stat_evsel *ps = counter->priv; 314 u64 *count = counter->counts->aggr.values; 315 u64 val; 316 int i, ret; 317 318 aggr->val = aggr->ena = aggr->run = 0; 319 320 /* 321 * We calculate counter's data every interval, 322 * and the display code shows ps->res_stats 323 * avg value. We need to zero the stats for 324 * interval mode, otherwise overall avg running 325 * averages will be shown for each interval. 326 */ 327 if (config->interval) 328 init_stats(ps->res_stats); 329 330 if (counter->per_pkg) 331 zero_per_pkg(counter); 332 333 ret = process_counter_maps(config, counter); 334 if (ret) 335 return ret; 336 337 if (config->aggr_mode != AGGR_GLOBAL) 338 return 0; 339 340 if (!counter->snapshot) 341 perf_evsel__compute_deltas(counter, -1, -1, aggr); 342 perf_counts_values__scale(aggr, config->scale, &counter->counts->scaled); 343 344 for (i = 0; i < 3; i++) 345 update_stats(&ps->res_stats[i], count[i]); 346 347 if (verbose) { 348 fprintf(config->output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 349 perf_evsel__name(counter), count[0], count[1], count[2]); 350 } 351 352 /* 353 * Save the full runtime - to allow normalization during printout: 354 */ 355 val = counter->scale * *count; 356 perf_stat__update_shadow_stats(counter, &val, 0); 357 358 return 0; 359 } 360 361 int perf_event__process_stat_event(struct perf_tool *tool __maybe_unused, 362 union perf_event *event, 363 struct perf_session *session) 364 { 365 struct perf_counts_values count; 366 struct stat_event *st = &event->stat; 367 struct perf_evsel *counter; 368 369 count.val = st->val; 370 count.ena = st->ena; 371 count.run = st->run; 372 373 counter = perf_evlist__id2evsel(session->evlist, st->id); 374 if (!counter) { 375 pr_err("Failed to resolve counter for stat event.\n"); 376 return -EINVAL; 377 } 378 379 *perf_counts(counter->counts, st->cpu, st->thread) = count; 380 counter->supported = true; 381 return 0; 382 } 383 384 size_t perf_event__fprintf_stat(union perf_event *event, FILE *fp) 385 { 386 struct stat_event *st = (struct stat_event *) event; 387 size_t ret; 388 389 ret = fprintf(fp, "\n... id %" PRIu64 ", cpu %d, thread %d\n", 390 st->id, st->cpu, st->thread); 391 ret += fprintf(fp, "... value %" PRIu64 ", enabled %" PRIu64 ", running %" PRIu64 "\n", 392 st->val, st->ena, st->run); 393 394 return ret; 395 } 396 397 size_t perf_event__fprintf_stat_round(union perf_event *event, FILE *fp) 398 { 399 struct stat_round_event *rd = (struct stat_round_event *)event; 400 size_t ret; 401 402 ret = fprintf(fp, "\n... time %" PRIu64 ", type %s\n", rd->time, 403 rd->type == PERF_STAT_ROUND_TYPE__FINAL ? "FINAL" : "INTERVAL"); 404 405 return ret; 406 } 407 408 size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp) 409 { 410 struct perf_stat_config sc; 411 size_t ret; 412 413 perf_event__read_stat_config(&sc, &event->stat_config); 414 415 ret = fprintf(fp, "\n"); 416 ret += fprintf(fp, "... aggr_mode %d\n", sc.aggr_mode); 417 ret += fprintf(fp, "... scale %d\n", sc.scale); 418 ret += fprintf(fp, "... interval %u\n", sc.interval); 419 420 return ret; 421 } 422