tools/power/x86/turbostat/turbostat.c

   1 /*
   2  * turbostat -- show CPU frequency and C-state residency
   3  * on modern Intel turbo-capable processors.
   4  *
   5  * Copyright (c) 2012 Intel Corporation.
   6  * Len Brown <len.brown@intel.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms and conditions of the GNU General Public License,
  10  * version 2, as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #define _GNU_SOURCE
  23 #include <stdio.h>
  24 #include <unistd.h>
  25 #include <sys/types.h>
  26 #include <sys/wait.h>
  27 #include <sys/stat.h>
  28 #include <sys/resource.h>
  29 #include <fcntl.h>
  30 #include <signal.h>
  31 #include <sys/time.h>
  32 #include <stdlib.h>
  33 #include <dirent.h>
  34 #include <string.h>
  35 #include <ctype.h>
  36 #include <sched.h>
  37
  38 #define MSR_NEHALEM_PLATFORM_INFO       0xCE
  39 #define MSR_NEHALEM_TURBO_RATIO_LIMIT   0x1AD
  40 #define MSR_IVT_TURBO_RATIO_LIMIT       0x1AE
  41 #define MSR_APERF       0xE8
  42 #define MSR_MPERF       0xE7
  43 #define MSR_PKG_C2_RESIDENCY    0x60D   /* SNB only */
  44 #define MSR_PKG_C3_RESIDENCY    0x3F8
  45 #define MSR_PKG_C6_RESIDENCY    0x3F9
  46 #define MSR_PKG_C7_RESIDENCY    0x3FA   /* SNB only */
  47 #define MSR_CORE_C3_RESIDENCY   0x3FC
  48 #define MSR_CORE_C6_RESIDENCY   0x3FD
  49 #define MSR_CORE_C7_RESIDENCY   0x3FE   /* SNB only */
  50
  51 char *proc_stat = "/proc/stat";
  52 unsigned int interval_sec = 5;  /* set with -i interval_sec */
  53 unsigned int verbose;           /* set with -v */
  54 unsigned int summary_only;      /* set with -s */
  55 unsigned int skip_c0;
  56 unsigned int skip_c1;
  57 unsigned int do_nhm_cstates;
  58 unsigned int do_snb_cstates;
  59 unsigned int has_aperf;
  60 unsigned int units = 1000000000;        /* Ghz etc */
  61 unsigned int genuine_intel;
  62 unsigned int has_invariant_tsc;
  63 unsigned int do_nehalem_platform_info;
  64 unsigned int do_nehalem_turbo_ratio_limit;
  65 unsigned int do_ivt_turbo_ratio_limit;
  66 unsigned int extra_msr_offset32;
  67 unsigned int extra_msr_offset64;
  68 unsigned int extra_delta_offset32;
  69 unsigned int extra_delta_offset64;
  70 double bclk;
  71 unsigned int show_pkg;
  72 unsigned int show_core;
  73 unsigned int show_cpu;
  74 unsigned int show_pkg_only;
  75 unsigned int show_core_only;
  76 char *output_buffer, *outp;
  77
  78 int aperf_mperf_unstable;
  79 int backwards_count;
  80 char *progname;
  81
  82 cpu_set_t *cpu_present_set, *cpu_affinity_set;
  83 size_t cpu_present_setsize, cpu_affinity_setsize;
  84
  85 struct thread_data {
  86         unsigned long long tsc;
  87         unsigned long long aperf;
  88         unsigned long long mperf;
  89         unsigned long long c1;  /* derived */
  90         unsigned long long extra_msr64;
  91         unsigned long long extra_delta64;
  92         unsigned long long extra_msr32;
  93         unsigned long long extra_delta32;
  94         unsigned int cpu_id;
  95         unsigned int flags;
  96 #define CPU_IS_FIRST_THREAD_IN_CORE     0x2
  97 #define CPU_IS_FIRST_CORE_IN_PACKAGE    0x4
  98 } *thread_even, *thread_odd;
  99
 100 struct core_data {
 101         unsigned long long c3;
 102         unsigned long long c6;
 103         unsigned long long c7;
 104         unsigned int core_id;
 105 } *core_even, *core_odd;
 106
 107 struct pkg_data {
 108         unsigned long long pc2;
 109         unsigned long long pc3;
 110         unsigned long long pc6;
 111         unsigned long long pc7;
 112         unsigned int package_id;
 113 } *package_even, *package_odd;
 114
 115 #define ODD_COUNTERS thread_odd, core_odd, package_odd
 116 #define EVEN_COUNTERS thread_even, core_even, package_even
 117
 118 #define GET_THREAD(thread_base, thread_no, core_no, pkg_no) \
 119         (thread_base + (pkg_no) * topo.num_cores_per_pkg * \
 120                 topo.num_threads_per_core + \
 121                 (core_no) * topo.num_threads_per_core + (thread_no))
 122 #define GET_CORE(core_base, core_no, pkg_no) \
 123         (core_base + (pkg_no) * topo.num_cores_per_pkg + (core_no))
 124 #define GET_PKG(pkg_base, pkg_no) (pkg_base + pkg_no)
 125
 126 struct system_summary {
 127         struct thread_data threads;
 128         struct core_data cores;
 129         struct pkg_data packages;
 130 } sum, average;
 131
 132
 133 struct topo_params {
 134         int num_packages;
 135         int num_cpus;
 136         int num_cores;
 137         int max_cpu_num;
 138         int num_cores_per_pkg;
 139         int num_threads_per_core;
 140 } topo;
 141
 142 struct timeval tv_even, tv_odd, tv_delta;
 143
 144 void setup_all_buffers(void);
 145
 146 int cpu_is_not_present(int cpu)
 147 {
 148         return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
 149 }
 150 /*
 151  * run func(thread, core, package) in topology order
 152  * skip non-present cpus
 153  */
 154
 155 int for_all_cpus(int (func)(struct thread_data *, struct core_data *, struct pkg_data *),
 156         struct thread_data *thread_base, struct core_data *core_base, struct pkg_data *pkg_base)
 157 {
 158         int retval, pkg_no, core_no, thread_no;
 159
 160         for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
 161                 for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
 162                         for (thread_no = 0; thread_no <
 163                                 topo.num_threads_per_core; ++thread_no) {
 164                                 struct thread_data *t;
 165                                 struct core_data *c;
 166                                 struct pkg_data *p;
 167
 168                                 t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
 169
 170                                 if (cpu_is_not_present(t->cpu_id))
 171                                         continue;
 172
 173                                 c = GET_CORE(core_base, core_no, pkg_no);
 174                                 p = GET_PKG(pkg_base, pkg_no);
 175
 176                                 retval = func(t, c, p);
 177                                 if (retval)
 178                                         return retval;
 179                         }
 180                 }
 181         }
 182         return 0;
 183 }
 184
 185 int cpu_migrate(int cpu)
 186 {
 187         CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
 188         CPU_SET_S(cpu, cpu_affinity_setsize, cpu_affinity_set);
 189         if (sched_setaffinity(0, cpu_affinity_setsize, cpu_affinity_set) == -1)
 190                 return -1;
 191         else
 192                 return 0;
 193 }
 194
 195 int get_msr(int cpu, off_t offset, unsigned long long *msr)
 196 {
 197         ssize_t retval;
 198         char pathname[32];
 199         int fd;
 200
 201         sprintf(pathname, "/dev/cpu/%d/msr", cpu);
 202         fd = open(pathname, O_RDONLY);
 203         if (fd < 0)
 204                 return -1;
 205
 206         retval = pread(fd, msr, sizeof *msr, offset);
 207         close(fd);
 208
 209         if (retval != sizeof *msr)
 210                 return -1;
 211
 212         return 0;
 213 }
 214
 215 void print_header(void)
 216 {
 217         if (show_pkg)
 218                 outp += sprintf(outp, "pk");
 219         if (show_pkg)
 220                 outp += sprintf(outp, " ");
 221         if (show_core)
 222                 outp += sprintf(outp, "cor");
 223         if (show_cpu)
 224                 outp += sprintf(outp, " CPU");
 225         if (show_pkg || show_core || show_cpu)
 226                 outp += sprintf(outp, " ");
 227         if (do_nhm_cstates)
 228                 outp += sprintf(outp, "   %%c0");
 229         if (has_aperf)
 230                 outp += sprintf(outp, "  GHz");
 231         outp += sprintf(outp, "  TSC");
 232         if (extra_delta_offset32)
 233                 outp += sprintf(outp, "  count 0x%03X", extra_delta_offset32);
 234         if (extra_delta_offset64)
 235                 outp += sprintf(outp, "  COUNT 0x%03X", extra_delta_offset64);
 236         if (extra_msr_offset32)
 237                 outp += sprintf(outp, "   MSR 0x%03X", extra_msr_offset32);
 238         if (extra_msr_offset64)
 239                 outp += sprintf(outp, "           MSR 0x%03X", extra_msr_offset64);
 240         if (do_nhm_cstates)
 241                 outp += sprintf(outp, "    %%c1");
 242         if (do_nhm_cstates)
 243                 outp += sprintf(outp, "    %%c3");
 244         if (do_nhm_cstates)
 245                 outp += sprintf(outp, "    %%c6");
 246         if (do_snb_cstates)
 247                 outp += sprintf(outp, "    %%c7");
 248         if (do_snb_cstates)
 249                 outp += sprintf(outp, "   %%pc2");
 250         if (do_nhm_cstates)
 251                 outp += sprintf(outp, "   %%pc3");
 252         if (do_nhm_cstates)
 253                 outp += sprintf(outp, "   %%pc6");
 254         if (do_snb_cstates)
 255                 outp += sprintf(outp, "   %%pc7");
 256
 257         outp += sprintf(outp, "\n");
 258 }
 259
 260 int dump_counters(struct thread_data *t, struct core_data *c,
 261         struct pkg_data *p)
 262 {
 263         fprintf(stderr, "t %p, c %p, p %p\n", t, c, p);
 264
 265         if (t) {
 266                 fprintf(stderr, "CPU: %d flags 0x%x\n", t->cpu_id, t->flags);
 267                 fprintf(stderr, "TSC: %016llX\n", t->tsc);
 268                 fprintf(stderr, "aperf: %016llX\n", t->aperf);
 269                 fprintf(stderr, "mperf: %016llX\n", t->mperf);
 270                 fprintf(stderr, "c1: %016llX\n", t->c1);
 271                 fprintf(stderr, "msr0x%x: %08llX\n",
 272                         extra_delta_offset32, t->extra_delta32);
 273                 fprintf(stderr, "msr0x%x: %016llX\n",
 274                         extra_delta_offset64, t->extra_delta64);
 275                 fprintf(stderr, "msr0x%x: %08llX\n",
 276                         extra_msr_offset32, t->extra_msr32);
 277                 fprintf(stderr, "msr0x%x: %016llX\n",
 278                         extra_msr_offset64, t->extra_msr64);
 279         }
 280
 281         if (c) {
 282                 fprintf(stderr, "core: %d\n", c->core_id);
 283                 fprintf(stderr, "c3: %016llX\n", c->c3);
 284                 fprintf(stderr, "c6: %016llX\n", c->c6);
 285                 fprintf(stderr, "c7: %016llX\n", c->c7);
 286         }
 287
 288         if (p) {
 289                 fprintf(stderr, "package: %d\n", p->package_id);
 290                 fprintf(stderr, "pc2: %016llX\n", p->pc2);
 291                 fprintf(stderr, "pc3: %016llX\n", p->pc3);
 292                 fprintf(stderr, "pc6: %016llX\n", p->pc6);
 293                 fprintf(stderr, "pc7: %016llX\n", p->pc7);
 294         }
 295         return 0;
 296 }
 297
 298 /*
 299  * column formatting convention & formats
 300  * package: "pk" 2 columns %2d
 301  * core: "cor" 3 columns %3d
 302  * CPU: "CPU" 3 columns %3d
 303  * GHz: "GHz" 3 columns %3.2
 304  * TSC: "TSC" 3 columns %3.2
 305  * percentage " %pc3" %6.2
 306  */
 307 int format_counters(struct thread_data *t, struct core_data *c,
 308         struct pkg_data *p)
 309 {
 310         double interval_float;
 311
 312          /* if showing only 1st thread in core and this isn't one, bail out */
 313         if (show_core_only && !(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
 314                 return 0;
 315
 316          /* if showing only 1st thread in pkg and this isn't one, bail out */
 317         if (show_pkg_only && !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
 318                 return 0;
 319
 320         interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0;
 321
 322         /* topo columns, print blanks on 1st (average) line */
 323         if (t == &average.threads) {
 324                 if (show_pkg)
 325                         outp += sprintf(outp, "  ");
 326                 if (show_pkg && show_core)
 327                         outp += sprintf(outp, " ");
 328                 if (show_core)
 329                         outp += sprintf(outp, "   ");
 330                 if (show_cpu)
 331                         outp += sprintf(outp, " " "   ");
 332         } else {
 333                 if (show_pkg) {
 334                         if (p)
 335                                 outp += sprintf(outp, "%2d", p->package_id);
 336                         else
 337                                 outp += sprintf(outp, "  ");
 338                 }
 339                 if (show_pkg && show_core)
 340                         outp += sprintf(outp, " ");
 341                 if (show_core) {
 342                         if (c)
 343                                 outp += sprintf(outp, "%3d", c->core_id);
 344                         else
 345                                 outp += sprintf(outp, "   ");
 346                 }
 347                 if (show_cpu)
 348                         outp += sprintf(outp, " %3d", t->cpu_id);
 349         }
 350
 351         /* %c0 */
 352         if (do_nhm_cstates) {
 353                 if (show_pkg || show_core || show_cpu)
 354                         outp += sprintf(outp, " ");
 355                 if (!skip_c0)
 356                         outp += sprintf(outp, "%6.2f", 100.0 * t->mperf/t->tsc);
 357                 else
 358                         outp += sprintf(outp, "  ****");
 359         }
 360
 361         /* GHz */
 362         if (has_aperf) {
 363                 if (!aperf_mperf_unstable) {
 364                         outp += sprintf(outp, " %3.2f",
 365                                 1.0 * t->tsc / units * t->aperf /
 366                                 t->mperf / interval_float);
 367                 } else {
 368                         if (t->aperf > t->tsc || t->mperf > t->tsc) {
 369                                 outp += sprintf(outp, " ***");
 370                         } else {
 371                                 outp += sprintf(outp, "%3.1f*",
 372                                         1.0 * t->tsc /
 373                                         units * t->aperf /
 374                                         t->mperf / interval_float);
 375                         }
 376                 }
 377         }
 378
 379         /* TSC */
 380         outp += sprintf(outp, "%5.2f", 1.0 * t->tsc/units/interval_float);
 381
 382         /* delta */
 383         if (extra_delta_offset32)
 384                 outp += sprintf(outp, "  %11llu", t->extra_delta32);
 385
 386         /* DELTA */
 387         if (extra_delta_offset64)
 388                 outp += sprintf(outp, "  %11llu", t->extra_delta64);
 389         /* msr */
 390         if (extra_msr_offset32)
 391                 outp += sprintf(outp, "  0x%08llx", t->extra_msr32);
 392
 393         /* MSR */
 394         if (extra_msr_offset64)
 395                 outp += sprintf(outp, "  0x%016llx", t->extra_msr64);
 396
 397         if (do_nhm_cstates) {
 398                 if (!skip_c1)
 399                         outp += sprintf(outp, " %6.2f", 100.0 * t->c1/t->tsc);
 400                 else
 401                         outp += sprintf(outp, "  ****");
 402         }
 403
 404         /* print per-core data only for 1st thread in core */
 405         if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
 406                 goto done;
 407
 408         if (do_nhm_cstates)
 409                 outp += sprintf(outp, " %6.2f", 100.0 * c->c3/t->tsc);
 410         if (do_nhm_cstates)
 411                 outp += sprintf(outp, " %6.2f", 100.0 * c->c6/t->tsc);
 412         if (do_snb_cstates)
 413                 outp += sprintf(outp, " %6.2f", 100.0 * c->c7/t->tsc);
 414
 415         /* print per-package data only for 1st core in package */
 416         if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
 417                 goto done;
 418
 419         if (do_snb_cstates)
 420                 outp += sprintf(outp, " %6.2f", 100.0 * p->pc2/t->tsc);
 421         if (do_nhm_cstates)
 422                 outp += sprintf(outp, " %6.2f", 100.0 * p->pc3/t->tsc);
 423         if (do_nhm_cstates)
 424                 outp += sprintf(outp, " %6.2f", 100.0 * p->pc6/t->tsc);
 425         if (do_snb_cstates)
 426                 outp += sprintf(outp, " %6.2f", 100.0 * p->pc7/t->tsc);
 427 done:
 428         outp += sprintf(outp, "\n");
 429
 430         return 0;
 431 }
 432
 433 void flush_stdout()
 434 {
 435         fputs(output_buffer, stdout);
 436         outp = output_buffer;
 437 }
 438 void flush_stderr()
 439 {
 440         fputs(output_buffer, stderr);
 441         outp = output_buffer;
 442 }
 443 void format_all_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 444 {
 445         static int printed;
 446
 447         if (!printed || !summary_only)
 448                 print_header();
 449
 450         if (topo.num_cpus > 1)
 451                 format_counters(&average.threads, &average.cores,
 452                         &average.packages);
 453
 454         printed = 1;
 455
 456         if (summary_only)
 457                 return;
 458
 459         for_all_cpus(format_counters, t, c, p);
 460 }
 461
 462 void
 463 delta_package(struct pkg_data *new, struct pkg_data *old)
 464 {
 465         old->pc2 = new->pc2 - old->pc2;
 466         old->pc3 = new->pc3 - old->pc3;
 467         old->pc6 = new->pc6 - old->pc6;
 468         old->pc7 = new->pc7 - old->pc7;
 469 }
 470
 471 void
 472 delta_core(struct core_data *new, struct core_data *old)
 473 {
 474         old->c3 = new->c3 - old->c3;
 475         old->c6 = new->c6 - old->c6;
 476         old->c7 = new->c7 - old->c7;
 477 }
 478
 479 /*
 480  * old = new - old
 481  */
 482 void
 483 delta_thread(struct thread_data *new, struct thread_data *old,
 484         struct core_data *core_delta)
 485 {
 486         old->tsc = new->tsc - old->tsc;
 487
 488         /* check for TSC < 1 Mcycles over interval */
 489         if (old->tsc < (1000 * 1000)) {
 490                 fprintf(stderr, "Insanely slow TSC rate, TSC stops in idle?\n");
 491                 fprintf(stderr, "You can disable all c-states by booting with \"idle=poll\"\n");
 492                 fprintf(stderr, "or just the deep ones with \"processor.max_cstate=1\"\n");
 493                 exit(-3);
 494         }
 495
 496         old->c1 = new->c1 - old->c1;
 497
 498         if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
 499                 old->aperf = new->aperf - old->aperf;
 500                 old->mperf = new->mperf - old->mperf;
 501         } else {
 502
 503                 if (!aperf_mperf_unstable) {
 504                         fprintf(stderr, "%s: APERF or MPERF went backwards *\n", progname);
 505                         fprintf(stderr, "* Frequency results do not cover entire interval *\n");
 506                         fprintf(stderr, "* fix this by running Linux-2.6.30 or later *\n");
 507
 508                         aperf_mperf_unstable = 1;
 509                 }
 510                 /*
 511                  * mperf delta is likely a huge "positive" number
 512                  * can not use it for calculating c0 time
 513                  */
 514                 skip_c0 = 1;
 515                 skip_c1 = 1;
 516         }
 517
 518
 519         /*
 520          * As counter collection is not atomic,
 521          * it is possible for mperf's non-halted cycles + idle states
 522          * to exceed TSC's all cycles: show c1 = 0% in that case.
 523          */
 524         if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
 525                 old->c1 = 0;
 526         else {
 527                 /* normal case, derive c1 */
 528                 old->c1 = old->tsc - old->mperf - core_delta->c3
 529                                 - core_delta->c6 - core_delta->c7;
 530         }
 531
 532         if (old->mperf == 0) {
 533                 if (verbose > 1) fprintf(stderr, "cpu%d MPERF 0!\n", old->cpu_id);
 534                 old->mperf = 1; /* divide by 0 protection */
 535         }
 536
 537         old->extra_delta32 = new->extra_delta32 - old->extra_delta32;
 538         old->extra_delta32 &= 0xFFFFFFFF;
 539
 540         old->extra_delta64 = new->extra_delta64 - old->extra_delta64;
 541
 542         /*
 543          * Extra MSR is just a snapshot, simply copy latest w/o subtracting
 544          */
 545         old->extra_msr32 = new->extra_msr32;
 546         old->extra_msr64 = new->extra_msr64;
 547 }
 548
 549 int delta_cpu(struct thread_data *t, struct core_data *c,
 550         struct pkg_data *p, struct thread_data *t2,
 551         struct core_data *c2, struct pkg_data *p2)
 552 {
 553         /* calculate core delta only for 1st thread in core */
 554         if (t->flags & CPU_IS_FIRST_THREAD_IN_CORE)
 555                 delta_core(c, c2);
 556
 557         /* always calculate thread delta */
 558         delta_thread(t, t2, c2);        /* c2 is core delta */
 559
 560         /* calculate package delta only for 1st core in package */
 561         if (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)
 562                 delta_package(p, p2);
 563
 564         return 0;
 565 }
 566
 567 void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 568 {
 569         t->tsc = 0;
 570         t->aperf = 0;
 571         t->mperf = 0;
 572         t->c1 = 0;
 573
 574         t->extra_delta32 = 0;
 575         t->extra_delta64 = 0;
 576
 577         /* tells format_counters to dump all fields from this set */
 578         t->flags = CPU_IS_FIRST_THREAD_IN_CORE | CPU_IS_FIRST_CORE_IN_PACKAGE;
 579
 580         c->c3 = 0;
 581         c->c6 = 0;
 582         c->c7 = 0;
 583
 584         p->pc2 = 0;
 585         p->pc3 = 0;
 586         p->pc6 = 0;
 587         p->pc7 = 0;
 588 }
 589 int sum_counters(struct thread_data *t, struct core_data *c,
 590         struct pkg_data *p)
 591 {
 592         average.threads.tsc += t->tsc;
 593         average.threads.aperf += t->aperf;
 594         average.threads.mperf += t->mperf;
 595         average.threads.c1 += t->c1;
 596
 597         average.threads.extra_delta32 += t->extra_delta32;
 598         average.threads.extra_delta64 += t->extra_delta64;
 599
 600         /* sum per-core values only for 1st thread in core */
 601         if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
 602                 return 0;
 603
 604         average.cores.c3 += c->c3;
 605         average.cores.c6 += c->c6;
 606         average.cores.c7 += c->c7;
 607
 608         /* sum per-pkg values only for 1st core in pkg */
 609         if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
 610                 return 0;
 611
 612         average.packages.pc2 += p->pc2;
 613         average.packages.pc3 += p->pc3;
 614         average.packages.pc6 += p->pc6;
 615         average.packages.pc7 += p->pc7;
 616
 617         return 0;
 618 }
 619 /*
 620  * sum the counters for all cpus in the system
 621  * compute the weighted average
 622  */
 623 void compute_average(struct thread_data *t, struct core_data *c,
 624         struct pkg_data *p)
 625 {
 626         clear_counters(&average.threads, &average.cores, &average.packages);
 627
 628         for_all_cpus(sum_counters, t, c, p);
 629
 630         average.threads.tsc /= topo.num_cpus;
 631         average.threads.aperf /= topo.num_cpus;
 632         average.threads.mperf /= topo.num_cpus;
 633         average.threads.c1 /= topo.num_cpus;
 634
 635         average.threads.extra_delta32 /= topo.num_cpus;
 636         average.threads.extra_delta32 &= 0xFFFFFFFF;
 637
 638         average.threads.extra_delta64 /= topo.num_cpus;
 639
 640         average.cores.c3 /= topo.num_cores;
 641         average.cores.c6 /= topo.num_cores;
 642         average.cores.c7 /= topo.num_cores;
 643
 644         average.packages.pc2 /= topo.num_packages;
 645         average.packages.pc3 /= topo.num_packages;
 646         average.packages.pc6 /= topo.num_packages;
 647         average.packages.pc7 /= topo.num_packages;
 648 }
 649
 650 static unsigned long long rdtsc(void)
 651 {
 652         unsigned int low, high;
 653
 654         asm volatile("rdtsc" : "=a" (low), "=d" (high));
 655
 656         return low | ((unsigned long long)high) << 32;
 657 }
 658
 659
 660 /*
 661  * get_counters(...)
 662  * migrate to cpu
 663  * acquire and record local counters for that cpu
 664  */
 665 int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 666 {
 667         int cpu = t->cpu_id;
 668
 669         if (cpu_migrate(cpu))
 670                 return -1;
 671
 672         t->tsc = rdtsc();       /* we are running on local CPU of interest */
 673
 674         if (has_aperf) {
 675                 if (get_msr(cpu, MSR_APERF, &t->aperf))
 676                         return -3;
 677                 if (get_msr(cpu, MSR_MPERF, &t->mperf))
 678                         return -4;
 679         }
 680
 681         if (extra_delta_offset32) {
 682                 if (get_msr(cpu, extra_delta_offset32, &t->extra_delta32))
 683                         return -5;
 684                 t->extra_delta32 &= 0xFFFFFFFF;
 685         }
 686
 687         if (extra_delta_offset64)
 688                 if (get_msr(cpu, extra_delta_offset64, &t->extra_delta64))
 689                         return -5;
 690
 691         if (extra_msr_offset32) {
 692                 if (get_msr(cpu, extra_msr_offset32, &t->extra_msr32))
 693                         return -5;
 694                 t->extra_msr32 &= 0xFFFFFFFF;
 695         }
 696
 697         if (extra_msr_offset64)
 698                 if (get_msr(cpu, extra_msr_offset64, &t->extra_msr64))
 699                         return -5;
 700
 701         /* collect core counters only for 1st thread in core */
 702         if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
 703                 return 0;
 704
 705         if (do_nhm_cstates) {
 706                 if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3))
 707                         return -6;
 708                 if (get_msr(cpu, MSR_CORE_C6_RESIDENCY, &c->c6))
 709                         return -7;
 710         }
 711
 712         if (do_snb_cstates)
 713                 if (get_msr(cpu, MSR_CORE_C7_RESIDENCY, &c->c7))
 714                         return -8;
 715
 716         /* collect package counters only for 1st core in package */
 717         if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
 718                 return 0;
 719
 720         if (do_nhm_cstates) {
 721                 if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
 722                         return -9;
 723                 if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
 724                         return -10;
 725         }
 726         if (do_snb_cstates) {
 727                 if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
 728                         return -11;
 729                 if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
 730                         return -12;
 731         }
 732         return 0;
 733 }
 734
 735 void print_verbose_header(void)
 736 {
 737         unsigned long long msr;
 738         unsigned int ratio;
 739
 740         if (!do_nehalem_platform_info)
 741                 return;
 742
 743         get_msr(0, MSR_NEHALEM_PLATFORM_INFO, &msr);
 744
 745         if (verbose > 1)
 746                 fprintf(stderr, "MSR_NEHALEM_PLATFORM_INFO: 0x%llx\n", msr);
 747
 748         ratio = (msr >> 40) & 0xFF;
 749         fprintf(stderr, "%d * %.0f = %.0f MHz max efficiency\n",
 750                 ratio, bclk, ratio * bclk);
 751
 752         ratio = (msr >> 8) & 0xFF;
 753         fprintf(stderr, "%d * %.0f = %.0f MHz TSC frequency\n",
 754                 ratio, bclk, ratio * bclk);
 755
 756         if (!do_ivt_turbo_ratio_limit)
 757                 goto print_nhm_turbo_ratio_limits;
 758
 759         get_msr(0, MSR_IVT_TURBO_RATIO_LIMIT, &msr);
 760
 761         if (verbose > 1)
 762                 fprintf(stderr, "MSR_IVT_TURBO_RATIO_LIMIT: 0x%llx\n", msr);
 763
 764         ratio = (msr >> 56) & 0xFF;
 765         if (ratio)
 766                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 16 active cores\n",
 767                         ratio, bclk, ratio * bclk);
 768
 769         ratio = (msr >> 48) & 0xFF;
 770         if (ratio)
 771                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 15 active cores\n",
 772                         ratio, bclk, ratio * bclk);
 773
 774         ratio = (msr >> 40) & 0xFF;
 775         if (ratio)
 776                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 14 active cores\n",
 777                         ratio, bclk, ratio * bclk);
 778
 779         ratio = (msr >> 32) & 0xFF;
 780         if (ratio)
 781                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 13 active cores\n",
 782                         ratio, bclk, ratio * bclk);
 783
 784         ratio = (msr >> 24) & 0xFF;
 785         if (ratio)
 786                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 12 active cores\n",
 787                         ratio, bclk, ratio * bclk);
 788
 789         ratio = (msr >> 16) & 0xFF;
 790         if (ratio)
 791                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 11 active cores\n",
 792                         ratio, bclk, ratio * bclk);
 793
 794         ratio = (msr >> 8) & 0xFF;
 795         if (ratio)
 796                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 10 active cores\n",
 797                         ratio, bclk, ratio * bclk);
 798
 799         ratio = (msr >> 0) & 0xFF;
 800         if (ratio)
 801                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 9 active cores\n",
 802                         ratio, bclk, ratio * bclk);
 803
 804 print_nhm_turbo_ratio_limits:
 805
 806         if (!do_nehalem_turbo_ratio_limit)
 807                 return;
 808
 809         get_msr(0, MSR_NEHALEM_TURBO_RATIO_LIMIT, &msr);
 810
 811         if (verbose > 1)
 812                 fprintf(stderr, "MSR_NEHALEM_TURBO_RATIO_LIMIT: 0x%llx\n", msr);
 813
 814         ratio = (msr >> 56) & 0xFF;
 815         if (ratio)
 816                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 8 active cores\n",
 817                         ratio, bclk, ratio * bclk);
 818
 819         ratio = (msr >> 48) & 0xFF;
 820         if (ratio)
 821                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 7 active cores\n",
 822                         ratio, bclk, ratio * bclk);
 823
 824         ratio = (msr >> 40) & 0xFF;
 825         if (ratio)
 826                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 6 active cores\n",
 827                         ratio, bclk, ratio * bclk);
 828
 829         ratio = (msr >> 32) & 0xFF;
 830         if (ratio)
 831                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 5 active cores\n",
 832                         ratio, bclk, ratio * bclk);
 833
 834         ratio = (msr >> 24) & 0xFF;
 835         if (ratio)
 836                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 4 active cores\n",
 837                         ratio, bclk, ratio * bclk);
 838
 839         ratio = (msr >> 16) & 0xFF;
 840         if (ratio)
 841                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 3 active cores\n",
 842                         ratio, bclk, ratio * bclk);
 843
 844         ratio = (msr >> 8) & 0xFF;
 845         if (ratio)
 846                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 2 active cores\n",
 847                         ratio, bclk, ratio * bclk);
 848
 849         ratio = (msr >> 0) & 0xFF;
 850         if (ratio)
 851                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 1 active cores\n",
 852                         ratio, bclk, ratio * bclk);
 853 }
 854
 855 void free_all_buffers(void)
 856 {
 857         CPU_FREE(cpu_present_set);
 858         cpu_present_set = NULL;
 859         cpu_present_set = 0;
 860
 861         CPU_FREE(cpu_affinity_set);
 862         cpu_affinity_set = NULL;
 863         cpu_affinity_setsize = 0;
 864
 865         free(thread_even);
 866         free(core_even);
 867         free(package_even);
 868
 869         thread_even = NULL;
 870         core_even = NULL;
 871         package_even = NULL;
 872
 873         free(thread_odd);
 874         free(core_odd);
 875         free(package_odd);
 876
 877         thread_odd = NULL;
 878         core_odd = NULL;
 879         package_odd = NULL;
 880
 881         free(output_buffer);
 882         output_buffer = NULL;
 883         outp = NULL;
 884 }
 885
 886 /*
 887  * cpu_is_first_sibling_in_core(cpu)
 888  * return 1 if given CPU is 1st HT sibling in the core
 889  */
 890 int cpu_is_first_sibling_in_core(int cpu)
 891 {
 892         char path[64];
 893         FILE *filep;
 894         int first_cpu;
 895
 896         sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
 897         filep = fopen(path, "r");
 898         if (filep == NULL) {
 899                 perror(path);
 900                 exit(1);
 901         }
 902         fscanf(filep, "%d", &first_cpu);
 903         fclose(filep);
 904         return (cpu == first_cpu);
 905 }
 906
 907 /*
 908  * cpu_is_first_core_in_package(cpu)
 909  * return 1 if given CPU is 1st core in package
 910  */
 911 int cpu_is_first_core_in_package(int cpu)
 912 {
 913         char path[64];
 914         FILE *filep;
 915         int first_cpu;
 916
 917         sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list", cpu);
 918         filep = fopen(path, "r");
 919         if (filep == NULL) {
 920                 perror(path);
 921                 exit(1);
 922         }
 923         fscanf(filep, "%d", &first_cpu);
 924         fclose(filep);
 925         return (cpu == first_cpu);
 926 }
 927
 928 int get_physical_package_id(int cpu)
 929 {
 930         char path[80];
 931         FILE *filep;
 932         int pkg;
 933
 934         sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu);
 935         filep = fopen(path, "r");
 936         if (filep == NULL) {
 937                 perror(path);
 938                 exit(1);
 939         }
 940         fscanf(filep, "%d", &pkg);
 941         fclose(filep);
 942         return pkg;
 943 }
 944
 945 int get_core_id(int cpu)
 946 {
 947         char path[80];
 948         FILE *filep;
 949         int core;
 950
 951         sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/core_id", cpu);
 952         filep = fopen(path, "r");
 953         if (filep == NULL) {
 954                 perror(path);
 955                 exit(1);
 956         }
 957         fscanf(filep, "%d", &core);
 958         fclose(filep);
 959         return core;
 960 }
 961
 962 int get_num_ht_siblings(int cpu)
 963 {
 964         char path[80];
 965         FILE *filep;
 966         int sib1, sib2;
 967         int matches;
 968         char character;
 969
 970         sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
 971         filep = fopen(path, "r");
 972         if (filep == NULL) {
 973                 perror(path);
 974                 exit(1);
 975         }
 976         /*
 977          * file format:
 978          * if a pair of number with a character between: 2 siblings (eg. 1-2, or 1,4)
 979          * otherwinse 1 sibling (self).
 980          */
 981         matches = fscanf(filep, "%d%c%d\n", &sib1, &character, &sib2);
 982
 983         fclose(filep);
 984
 985         if (matches == 3)
 986                 return 2;
 987         else
 988                 return 1;
 989 }
 990
 991 /*
 992  * run func(thread, core, package) in topology order
 993  * skip non-present cpus
 994  */
 995
 996 int for_all_cpus_2(int (func)(struct thread_data *, struct core_data *,
 997         struct pkg_data *, struct thread_data *, struct core_data *,
 998         struct pkg_data *), struct thread_data *thread_base,
 999         struct core_data *core_base, struct pkg_data *pkg_base,
1000         struct thread_data *thread_base2, struct core_data *core_base2,
1001         struct pkg_data *pkg_base2)
1002 {
1003         int retval, pkg_no, core_no, thread_no;
1004
1005         for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
1006                 for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
1007                         for (thread_no = 0; thread_no <
1008                                 topo.num_threads_per_core; ++thread_no) {
1009                                 struct thread_data *t, *t2;
1010                                 struct core_data *c, *c2;
1011                                 struct pkg_data *p, *p2;
1012
1013                                 t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
1014
1015                                 if (cpu_is_not_present(t->cpu_id))
1016                                         continue;
1017
1018                                 t2 = GET_THREAD(thread_base2, thread_no, core_no, pkg_no);
1019
1020                                 c = GET_CORE(core_base, core_no, pkg_no);
1021                                 c2 = GET_CORE(core_base2, core_no, pkg_no);
1022
1023                                 p = GET_PKG(pkg_base, pkg_no);
1024                                 p2 = GET_PKG(pkg_base2, pkg_no);
1025
1026                                 retval = func(t, c, p, t2, c2, p2);
1027                                 if (retval)
1028                                         return retval;
1029                         }
1030                 }
1031         }
1032         return 0;
1033 }
1034
1035 /*
1036  * run func(cpu) on every cpu in /proc/stat
1037  * return max_cpu number
1038  */
1039 int for_all_proc_cpus(int (func)(int))
1040 {
1041         FILE *fp;
1042         int cpu_num;
1043         int retval;
1044
1045         fp = fopen(proc_stat, "r");
1046         if (fp == NULL) {
1047                 perror(proc_stat);
1048                 exit(1);
1049         }
1050
1051         retval = fscanf(fp, "cpu %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n");
1052         if (retval != 0) {
1053                 perror("/proc/stat format");
1054                 exit(1);
1055         }
1056
1057         while (1) {
1058                 retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu_num);
1059                 if (retval != 1)
1060                         break;
1061
1062                 retval = func(cpu_num);
1063                 if (retval) {
1064                         fclose(fp);
1065                         return(retval);
1066                 }
1067         }
1068         fclose(fp);
1069         return 0;
1070 }
1071
1072 void re_initialize(void)
1073 {
1074         free_all_buffers();
1075         setup_all_buffers();
1076         printf("turbostat: re-initialized with num_cpus %d\n", topo.num_cpus);
1077 }
1078
1079
1080 /*
1081  * count_cpus()
1082  * remember the last one seen, it will be the max
1083  */
1084 int count_cpus(int cpu)
1085 {
1086         if (topo.max_cpu_num < cpu)
1087                 topo.max_cpu_num = cpu;
1088
1089         topo.num_cpus += 1;
1090         return 0;
1091 }
1092 int mark_cpu_present(int cpu)
1093 {
1094         CPU_SET_S(cpu, cpu_present_setsize, cpu_present_set);
1095         return 0;
1096 }
1097
1098 void turbostat_loop()
1099 {
1100         int retval;
1101
1102 restart:
1103         retval = for_all_cpus(get_counters, EVEN_COUNTERS);
1104         if (retval) {
1105                 re_initialize();
1106                 goto restart;
1107         }
1108         gettimeofday(&tv_even, (struct timezone *)NULL);
1109
1110         while (1) {
1111                 if (for_all_proc_cpus(cpu_is_not_present)) {
1112                         re_initialize();
1113                         goto restart;
1114                 }
1115                 sleep(interval_sec);
1116                 retval = for_all_cpus(get_counters, ODD_COUNTERS);
1117                 if (retval) {
1118                         re_initialize();
1119                         goto restart;
1120                 }
1121                 gettimeofday(&tv_odd, (struct timezone *)NULL);
1122                 timersub(&tv_odd, &tv_even, &tv_delta);
1123                 for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS);
1124                 compute_average(EVEN_COUNTERS);
1125                 format_all_counters(EVEN_COUNTERS);
1126                 flush_stdout();
1127                 sleep(interval_sec);
1128                 retval = for_all_cpus(get_counters, EVEN_COUNTERS);
1129                 if (retval) {
1130                         re_initialize();
1131                         goto restart;
1132                 }
1133                 gettimeofday(&tv_even, (struct timezone *)NULL);
1134                 timersub(&tv_even, &tv_odd, &tv_delta);
1135                 for_all_cpus_2(delta_cpu, EVEN_COUNTERS, ODD_COUNTERS);
1136                 compute_average(ODD_COUNTERS);
1137                 format_all_counters(ODD_COUNTERS);
1138                 flush_stdout();
1139         }
1140 }
1141
1142 void check_dev_msr()
1143 {
1144         struct stat sb;
1145
1146         if (stat("/dev/cpu/0/msr", &sb)) {
1147                 fprintf(stderr, "no /dev/cpu/0/msr\n");
1148                 fprintf(stderr, "Try \"# modprobe msr\"\n");
1149                 exit(-5);
1150         }
1151 }
1152
1153 void check_super_user()
1154 {
1155         if (getuid() != 0) {
1156                 fprintf(stderr, "must be root\n");
1157                 exit(-6);
1158         }
1159 }
1160
1161 int has_nehalem_turbo_ratio_limit(unsigned int family, unsigned int model)
1162 {
1163         if (!genuine_intel)
1164                 return 0;
1165
1166         if (family != 6)
1167                 return 0;
1168
1169         switch (model) {
1170         case 0x1A:      /* Core i7, Xeon 5500 series - Bloomfield, Gainstown NHM-EP */
1171         case 0x1E:      /* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */
1172         case 0x1F:      /* Core i7 and i5 Processor - Nehalem */
1173         case 0x25:      /* Westmere Client - Clarkdale, Arrandale */
1174         case 0x2C:      /* Westmere EP - Gulftown */
1175         case 0x2A:      /* SNB */
1176         case 0x2D:      /* SNB Xeon */
1177         case 0x3A:      /* IVB */
1178         case 0x3E:      /* IVB Xeon */
1179                 return 1;
1180         case 0x2E:      /* Nehalem-EX Xeon - Beckton */
1181         case 0x2F:      /* Westmere-EX Xeon - Eagleton */
1182         default:
1183                 return 0;
1184         }
1185 }
1186 int has_ivt_turbo_ratio_limit(unsigned int family, unsigned int model)
1187 {
1188         if (!genuine_intel)
1189                 return 0;
1190
1191         if (family != 6)
1192                 return 0;
1193
1194         switch (model) {
1195         case 0x3E:      /* IVB Xeon */
1196                 return 1;
1197         default:
1198                 return 0;
1199         }
1200 }
1201
1202
1203 int is_snb(unsigned int family, unsigned int model)
1204 {
1205         if (!genuine_intel)
1206                 return 0;
1207
1208         switch (model) {
1209         case 0x2A:
1210         case 0x2D:
1211         case 0x3A:      /* IVB */
1212         case 0x3E:      /* IVB Xeon */
1213                 return 1;
1214         }
1215         return 0;
1216 }
1217
1218 double discover_bclk(unsigned int family, unsigned int model)
1219 {
1220         if (is_snb(family, model))
1221                 return 100.00;
1222         else
1223                 return 133.33;
1224 }
1225
1226 void check_cpuid()
1227 {
1228         unsigned int eax, ebx, ecx, edx, max_level;
1229         unsigned int fms, family, model, stepping;
1230
1231         eax = ebx = ecx = edx = 0;
1232
1233         asm("cpuid" : "=a" (max_level), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0));
1234
1235         if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e)
1236                 genuine_intel = 1;
1237
1238         if (verbose)
1239                 fprintf(stderr, "%.4s%.4s%.4s ",
1240                         (char *)&ebx, (char *)&edx, (char *)&ecx);
1241
1242         asm("cpuid" : "=a" (fms), "=c" (ecx), "=d" (edx) : "a" (1) : "ebx");
1243         family = (fms >> 8) & 0xf;
1244         model = (fms >> 4) & 0xf;
1245         stepping = fms & 0xf;
1246         if (family == 6 || family == 0xf)
1247                 model += ((fms >> 16) & 0xf) << 4;
1248
1249         if (verbose)
1250                 fprintf(stderr, "%d CPUID levels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n",
1251                         max_level, family, model, stepping, family, model, stepping);
1252
1253         if (!(edx & (1 << 5))) {
1254                 fprintf(stderr, "CPUID: no MSR\n");
1255                 exit(1);
1256         }
1257
1258         /*
1259          * check max extended function levels of CPUID.
1260          * This is needed to check for invariant TSC.
1261          * This check is valid for both Intel and AMD.
1262          */
1263         ebx = ecx = edx = 0;
1264         asm("cpuid" : "=a" (max_level), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0x80000000));
1265
1266         if (max_level < 0x80000007) {
1267                 fprintf(stderr, "CPUID: no invariant TSC (max_level 0x%x)\n", max_level);
1268                 exit(1);
1269         }
1270
1271         /*
1272          * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
1273          * this check is valid for both Intel and AMD
1274          */
1275         asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0x80000007));
1276         has_invariant_tsc = edx & (1 << 8);
1277
1278         if (!has_invariant_tsc) {
1279                 fprintf(stderr, "No invariant TSC\n");
1280                 exit(1);
1281         }
1282
1283         /*
1284          * APERF/MPERF is advertised by CPUID.EAX=0x6: ECX.bit0
1285          * this check is valid for both Intel and AMD
1286          */
1287
1288         asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0x6));
1289         has_aperf = ecx & (1 << 0);
1290         if (!has_aperf) {
1291                 fprintf(stderr, "No APERF MSR\n");
1292                 exit(1);
1293         }
1294
1295         do_nehalem_platform_info = genuine_intel && has_invariant_tsc;
1296         do_nhm_cstates = genuine_intel; /* all Intel w/ non-stop TSC have NHM counters */
1297         do_snb_cstates = is_snb(family, model);
1298         bclk = discover_bclk(family, model);
1299
1300         do_nehalem_turbo_ratio_limit = has_nehalem_turbo_ratio_limit(family, model);
1301         do_ivt_turbo_ratio_limit = has_ivt_turbo_ratio_limit(family, model);
1302 }
1303
1304
1305 void usage()
1306 {
1307         fprintf(stderr, "%s: [-v][-p|-P|-S][-c MSR# | -s]][-C MSR#][-m MSR#][-M MSR#][-i interval_sec | command ...]\n",
1308                 progname);
1309         exit(1);
1310 }
1311
1312
1313 /*
1314  * in /dev/cpu/ return success for names that are numbers
1315  * ie. filter out ".", "..", "microcode".
1316  */
1317 int dir_filter(const struct dirent *dirp)
1318 {
1319         if (isdigit(dirp->d_name[0]))
1320                 return 1;
1321         else
1322                 return 0;
1323 }
1324
1325 int open_dev_cpu_msr(int dummy1)
1326 {
1327         return 0;
1328 }
1329
1330 void topology_probe()
1331 {
1332         int i;
1333         int max_core_id = 0;
1334         int max_package_id = 0;
1335         int max_siblings = 0;
1336         struct cpu_topology {
1337                 int core_id;
1338                 int physical_package_id;
1339         } *cpus;
1340
1341         /* Initialize num_cpus, max_cpu_num */
1342         topo.num_cpus = 0;
1343         topo.max_cpu_num = 0;
1344         for_all_proc_cpus(count_cpus);
1345         if (!summary_only && topo.num_cpus > 1)
1346                 show_cpu = 1;
1347
1348         if (verbose > 1)
1349                 fprintf(stderr, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
1350
1351         cpus = calloc(1, (topo.max_cpu_num  + 1) * sizeof(struct cpu_topology));
1352         if (cpus == NULL) {
1353                 perror("calloc cpus");
1354                 exit(1);
1355         }
1356
1357         /*
1358          * Allocate and initialize cpu_present_set
1359          */
1360         cpu_present_set = CPU_ALLOC((topo.max_cpu_num + 1));
1361         if (cpu_present_set == NULL) {
1362                 perror("CPU_ALLOC");
1363                 exit(3);
1364         }
1365         cpu_present_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
1366         CPU_ZERO_S(cpu_present_setsize, cpu_present_set);
1367         for_all_proc_cpus(mark_cpu_present);
1368
1369         /*
1370          * Allocate and initialize cpu_affinity_set
1371          */
1372         cpu_affinity_set = CPU_ALLOC((topo.max_cpu_num + 1));
1373         if (cpu_affinity_set == NULL) {
1374                 perror("CPU_ALLOC");
1375                 exit(3);
1376         }
1377         cpu_affinity_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
1378         CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
1379
1380
1381         /*
1382          * For online cpus
1383          * find max_core_id, max_package_id
1384          */
1385         for (i = 0; i <= topo.max_cpu_num; ++i) {
1386                 int siblings;
1387
1388                 if (cpu_is_not_present(i)) {
1389                         if (verbose > 1)
1390                                 fprintf(stderr, "cpu%d NOT PRESENT\n", i);
1391                         continue;
1392                 }
1393                 cpus[i].core_id = get_core_id(i);
1394                 if (cpus[i].core_id > max_core_id)
1395                         max_core_id = cpus[i].core_id;
1396
1397                 cpus[i].physical_package_id = get_physical_package_id(i);
1398                 if (cpus[i].physical_package_id > max_package_id)
1399                         max_package_id = cpus[i].physical_package_id;
1400
1401                 siblings = get_num_ht_siblings(i);
1402                 if (siblings > max_siblings)
1403                         max_siblings = siblings;
1404                 if (verbose > 1)
1405                         fprintf(stderr, "cpu %d pkg %d core %d\n",
1406                                 i, cpus[i].physical_package_id, cpus[i].core_id);
1407         }
1408         topo.num_cores_per_pkg = max_core_id + 1;
1409         if (verbose > 1)
1410                 fprintf(stderr, "max_core_id %d, sizing for %d cores per package\n",
1411                         max_core_id, topo.num_cores_per_pkg);
1412         if (!summary_only && topo.num_cores_per_pkg > 1)
1413                 show_core = 1;
1414
1415         topo.num_packages = max_package_id + 1;
1416         if (verbose > 1)
1417                 fprintf(stderr, "max_package_id %d, sizing for %d packages\n",
1418                         max_package_id, topo.num_packages);
1419         if (!summary_only && topo.num_packages > 1)
1420                 show_pkg = 1;
1421
1422         topo.num_threads_per_core = max_siblings;
1423         if (verbose > 1)
1424                 fprintf(stderr, "max_siblings %d\n", max_siblings);
1425
1426         free(cpus);
1427 }
1428
1429 void
1430 allocate_counters(struct thread_data **t, struct core_data **c, struct pkg_data **p)
1431 {
1432         int i;
1433
1434         *t = calloc(topo.num_threads_per_core * topo.num_cores_per_pkg *
1435                 topo.num_packages, sizeof(struct thread_data));
1436         if (*t == NULL)
1437                 goto error;
1438
1439         for (i = 0; i < topo.num_threads_per_core *
1440                 topo.num_cores_per_pkg * topo.num_packages; i++)
1441                 (*t)[i].cpu_id = -1;
1442
1443         *c = calloc(topo.num_cores_per_pkg * topo.num_packages,
1444                 sizeof(struct core_data));
1445         if (*c == NULL)
1446                 goto error;
1447
1448         for (i = 0; i < topo.num_cores_per_pkg * topo.num_packages; i++)
1449                 (*c)[i].core_id = -1;
1450
1451         *p = calloc(topo.num_packages, sizeof(struct pkg_data));
1452         if (*p == NULL)
1453                 goto error;
1454
1455         for (i = 0; i < topo.num_packages; i++)
1456                 (*p)[i].package_id = i;
1457
1458         return;
1459 error:
1460         perror("calloc counters");
1461         exit(1);
1462 }
1463 /*
1464  * init_counter()
1465  *
1466  * set cpu_id, core_num, pkg_num
1467  * set FIRST_THREAD_IN_CORE and FIRST_CORE_IN_PACKAGE
1468  *
1469  * increment topo.num_cores when 1st core in pkg seen
1470  */
1471 void init_counter(struct thread_data *thread_base, struct core_data *core_base,
1472         struct pkg_data *pkg_base, int thread_num, int core_num,
1473         int pkg_num, int cpu_id)
1474 {
1475         struct thread_data *t;
1476         struct core_data *c;
1477         struct pkg_data *p;
1478
1479         t = GET_THREAD(thread_base, thread_num, core_num, pkg_num);
1480         c = GET_CORE(core_base, core_num, pkg_num);
1481         p = GET_PKG(pkg_base, pkg_num);
1482
1483         t->cpu_id = cpu_id;
1484         if (thread_num == 0) {
1485                 t->flags |= CPU_IS_FIRST_THREAD_IN_CORE;
1486                 if (cpu_is_first_core_in_package(cpu_id))
1487                         t->flags |= CPU_IS_FIRST_CORE_IN_PACKAGE;
1488         }
1489
1490         c->core_id = core_num;
1491         p->package_id = pkg_num;
1492 }
1493
1494
1495 int initialize_counters(int cpu_id)
1496 {
1497         int my_thread_id, my_core_id, my_package_id;
1498
1499         my_package_id = get_physical_package_id(cpu_id);
1500         my_core_id = get_core_id(cpu_id);
1501
1502         if (cpu_is_first_sibling_in_core(cpu_id)) {
1503                 my_thread_id = 0;
1504                 topo.num_cores++;
1505         } else {
1506                 my_thread_id = 1;
1507         }
1508
1509         init_counter(EVEN_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
1510         init_counter(ODD_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
1511         return 0;
1512 }
1513
1514 void allocate_output_buffer()
1515 {
1516         output_buffer = calloc(1, (1 + topo.num_cpus) * 128);
1517         outp = output_buffer;
1518         if (outp == NULL) {
1519                 perror("calloc");
1520                 exit(-1);
1521         }
1522 }
1523
1524 void setup_all_buffers(void)
1525 {
1526         topology_probe();
1527         allocate_counters(&thread_even, &core_even, &package_even);
1528         allocate_counters(&thread_odd, &core_odd, &package_odd);
1529         allocate_output_buffer();
1530         for_all_proc_cpus(initialize_counters);
1531 }
1532 void turbostat_init()
1533 {
1534         check_cpuid();
1535
1536         check_dev_msr();
1537         check_super_user();
1538
1539         setup_all_buffers();
1540
1541         if (verbose)
1542                 print_verbose_header();
1543 }
1544
1545 int fork_it(char **argv)
1546 {
1547         pid_t child_pid;
1548
1549         for_all_cpus(get_counters, EVEN_COUNTERS);
1550         /* clear affinity side-effect of get_counters() */
1551         sched_setaffinity(0, cpu_present_setsize, cpu_present_set);
1552         gettimeofday(&tv_even, (struct timezone *)NULL);
1553
1554         child_pid = fork();
1555         if (!child_pid) {
1556                 /* child */
1557                 execvp(argv[0], argv);
1558         } else {
1559                 int status;
1560
1561                 /* parent */
1562                 if (child_pid == -1) {
1563                         perror("fork");
1564                         exit(1);
1565                 }
1566
1567                 signal(SIGINT, SIG_IGN);
1568                 signal(SIGQUIT, SIG_IGN);
1569                 if (waitpid(child_pid, &status, 0) == -1) {
1570                         perror("wait");
1571                         exit(1);
1572                 }
1573         }
1574         /*
1575          * n.b. fork_it() does not check for errors from for_all_cpus()
1576          * because re-starting is problematic when forking
1577          */
1578         for_all_cpus(get_counters, ODD_COUNTERS);
1579         gettimeofday(&tv_odd, (struct timezone *)NULL);
1580         timersub(&tv_odd, &tv_even, &tv_delta);
1581         for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS);
1582         compute_average(EVEN_COUNTERS);
1583         format_all_counters(EVEN_COUNTERS);
1584         flush_stderr();
1585
1586         fprintf(stderr, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);
1587
1588         return 0;
1589 }
1590
1591 void cmdline(int argc, char **argv)
1592 {
1593         int opt;
1594
1595         progname = argv[0];
1596
1597         while ((opt = getopt(argc, argv, "+pPSvisc:sC:m:M:")) != -1) {
1598                 switch (opt) {
1599                 case 'p':
1600                         show_core_only++;
1601                         break;
1602                 case 'P':
1603                         show_pkg_only++;
1604                         break;
1605                 case 'S':
1606                         summary_only++;
1607                         break;
1608                 case 'v':
1609                         verbose++;
1610                         break;
1611                 case 'i':
1612                         interval_sec = atoi(optarg);
1613                         break;
1614                 case 'c':
1615                         sscanf(optarg, "%x", &extra_delta_offset32);
1616                         break;
1617                 case 's':
1618                         extra_delta_offset32 = 0x34;    /* SMI counter */
1619                         break;
1620                 case 'C':
1621                         sscanf(optarg, "%x", &extra_delta_offset64);
1622                         break;
1623                 case 'm':
1624                         sscanf(optarg, "%x", &extra_msr_offset32);
1625                         break;
1626                 case 'M':
1627                         sscanf(optarg, "%x", &extra_msr_offset64);
1628                         break;
1629                 default:
1630                         usage();
1631                 }
1632         }
1633 }
1634
1635 int main(int argc, char **argv)
1636 {
1637         cmdline(argc, argv);
1638
1639         if (verbose > 1)
1640                 fprintf(stderr, "turbostat v2.1 October 6, 2012"
1641                         " - Len Brown <lenb@kernel.org>\n");
1642
1643         turbostat_init();
1644
1645         /*
1646          * if any params left, it must be a command to fork
1647          */
1648         if (argc - optind)
1649                 return fork_it(argv + optind);
1650         else
1651                 turbostat_loop();
1652
1653         return 0;
1654 }