tools/perf/util/stat.c

   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 *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 *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 void perf_evsel__reset_stat_priv(struct perf_evsel *evsel)
 101 {
 102         int i;
 103         struct perf_stat *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 int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
 112 {
 113         evsel->priv = zalloc(sizeof(struct perf_stat));
 114         if (evsel->priv == NULL)
 115                 return -ENOMEM;
 116         perf_evsel__reset_stat_priv(evsel);
 117         return 0;
 118 }
 119
 120 void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
 121 {
 122         zfree(&evsel->priv);
 123 }
 124
 125 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 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 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, int cpu, bool *skip)
 200 {
 201         unsigned long *mask = counter->per_pkg_mask;
 202         struct cpu_map *cpus = perf_evsel__cpus(counter);
 203         int s;
 204
 205         *skip = false;
 206
 207         if (!counter->per_pkg)
 208                 return 0;
 209
 210         if (cpu_map__empty(cpus))
 211                 return 0;
 212
 213         if (!mask) {
 214                 mask = zalloc(MAX_NR_CPUS);
 215                 if (!mask)
 216                         return -ENOMEM;
 217
 218                 counter->per_pkg_mask = mask;
 219         }
 220
 221         s = cpu_map__get_socket(cpus, cpu);
 222         if (s < 0)
 223                 return -1;
 224
 225         *skip = test_and_set_bit(s, mask) == 1;
 226         return 0;
 227 }
 228
 229 static int
 230 process_counter_values(struct perf_stat_config *config, struct perf_evsel *evsel,
 231                        int cpu, int thread,
 232                        struct perf_counts_values *count)
 233 {
 234         struct perf_counts_values *aggr = &evsel->counts->aggr;
 235         static struct perf_counts_values zero;
 236         bool skip = false;
 237
 238         if (check_per_pkg(evsel, cpu, &skip)) {
 239                 pr_err("failed to read per-pkg counter\n");
 240                 return -1;
 241         }
 242
 243         if (skip)
 244                 count = &zero;
 245
 246         switch (config->aggr_mode) {
 247         case AGGR_THREAD:
 248         case AGGR_CORE:
 249         case AGGR_SOCKET:
 250         case AGGR_NONE:
 251                 if (!evsel->snapshot)
 252                         perf_evsel__compute_deltas(evsel, cpu, thread, count);
 253                 perf_counts_values__scale(count, config->scale, NULL);
 254                 if (config->aggr_mode == AGGR_NONE)
 255                         perf_stat__update_shadow_stats(evsel, count->values, cpu);
 256                 break;
 257         case AGGR_GLOBAL:
 258                 aggr->val += count->val;
 259                 if (config->scale) {
 260                         aggr->ena += count->ena;
 261                         aggr->run += count->run;
 262                 }
 263         default:
 264                 break;
 265         }
 266
 267         return 0;
 268 }
 269
 270 static int process_counter_maps(struct perf_stat_config *config,
 271                                 struct perf_evsel *counter)
 272 {
 273         int nthreads = thread_map__nr(counter->threads);
 274         int ncpus = perf_evsel__nr_cpus(counter);
 275         int cpu, thread;
 276
 277         if (counter->system_wide)
 278                 nthreads = 1;
 279
 280         for (thread = 0; thread < nthreads; thread++) {
 281                 for (cpu = 0; cpu < ncpus; cpu++) {
 282                         if (process_counter_values(config, counter, cpu, thread,
 283                                                    perf_counts(counter->counts, cpu, thread)))
 284                                 return -1;
 285                 }
 286         }
 287
 288         return 0;
 289 }
 290
 291 int perf_stat_process_counter(struct perf_stat_config *config,
 292                               struct perf_evsel *counter)
 293 {
 294         struct perf_counts_values *aggr = &counter->counts->aggr;
 295         struct perf_stat *ps = counter->priv;
 296         u64 *count = counter->counts->aggr.values;
 297         int i, ret;
 298
 299         aggr->val = aggr->ena = aggr->run = 0;
 300         init_stats(ps->res_stats);
 301
 302         if (counter->per_pkg)
 303                 zero_per_pkg(counter);
 304
 305         ret = process_counter_maps(config, counter);
 306         if (ret)
 307                 return ret;
 308
 309         if (config->aggr_mode != AGGR_GLOBAL)
 310                 return 0;
 311
 312         if (!counter->snapshot)
 313                 perf_evsel__compute_deltas(counter, -1, -1, aggr);
 314         perf_counts_values__scale(aggr, config->scale, &counter->counts->scaled);
 315
 316         for (i = 0; i < 3; i++)
 317                 update_stats(&ps->res_stats[i], count[i]);
 318
 319         if (verbose) {
 320                 fprintf(config->output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
 321                         perf_evsel__name(counter), count[0], count[1], count[2]);
 322         }
 323
 324         /*
 325          * Save the full runtime - to allow normalization during printout:
 326          */
 327         perf_stat__update_shadow_stats(counter, count, 0);
 328
 329         return 0;
 330 }