1103a8feaSLen Brown /* 2103a8feaSLen Brown * turbostat -- show CPU frequency and C-state residency 3103a8feaSLen Brown * on modern Intel turbo-capable processors. 4103a8feaSLen Brown * 5*e23da037SLen Brown * Copyright (c) 2012 Intel Corporation. 6103a8feaSLen Brown * Len Brown <len.brown@intel.com> 7103a8feaSLen Brown * 8103a8feaSLen Brown * This program is free software; you can redistribute it and/or modify it 9103a8feaSLen Brown * under the terms and conditions of the GNU General Public License, 10103a8feaSLen Brown * version 2, as published by the Free Software Foundation. 11103a8feaSLen Brown * 12103a8feaSLen Brown * This program is distributed in the hope it will be useful, but WITHOUT 13103a8feaSLen Brown * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14103a8feaSLen Brown * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 15103a8feaSLen Brown * more details. 16103a8feaSLen Brown * 17103a8feaSLen Brown * You should have received a copy of the GNU General Public License along with 18103a8feaSLen Brown * this program; if not, write to the Free Software Foundation, Inc., 19103a8feaSLen Brown * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 20103a8feaSLen Brown */ 21103a8feaSLen Brown 22103a8feaSLen Brown #include <stdio.h> 23103a8feaSLen Brown #include <unistd.h> 24103a8feaSLen Brown #include <sys/types.h> 25103a8feaSLen Brown #include <sys/wait.h> 26103a8feaSLen Brown #include <sys/stat.h> 27103a8feaSLen Brown #include <sys/resource.h> 28103a8feaSLen Brown #include <fcntl.h> 29103a8feaSLen Brown #include <signal.h> 30103a8feaSLen Brown #include <sys/time.h> 31103a8feaSLen Brown #include <stdlib.h> 32103a8feaSLen Brown #include <dirent.h> 33103a8feaSLen Brown #include <string.h> 34103a8feaSLen Brown #include <ctype.h> 35103a8feaSLen Brown 36103a8feaSLen Brown #define MSR_TSC 0x10 37103a8feaSLen Brown #define MSR_NEHALEM_PLATFORM_INFO 0xCE 38103a8feaSLen Brown #define MSR_NEHALEM_TURBO_RATIO_LIMIT 0x1AD 39103a8feaSLen Brown #define MSR_APERF 0xE8 40103a8feaSLen Brown #define MSR_MPERF 0xE7 41103a8feaSLen Brown #define MSR_PKG_C2_RESIDENCY 0x60D /* SNB only */ 42103a8feaSLen Brown #define MSR_PKG_C3_RESIDENCY 0x3F8 43103a8feaSLen Brown #define MSR_PKG_C6_RESIDENCY 0x3F9 44103a8feaSLen Brown #define MSR_PKG_C7_RESIDENCY 0x3FA /* SNB only */ 45103a8feaSLen Brown #define MSR_CORE_C3_RESIDENCY 0x3FC 46103a8feaSLen Brown #define MSR_CORE_C6_RESIDENCY 0x3FD 47103a8feaSLen Brown #define MSR_CORE_C7_RESIDENCY 0x3FE /* SNB only */ 48103a8feaSLen Brown 49103a8feaSLen Brown char *proc_stat = "/proc/stat"; 50103a8feaSLen Brown unsigned int interval_sec = 5; /* set with -i interval_sec */ 51103a8feaSLen Brown unsigned int verbose; /* set with -v */ 52*e23da037SLen Brown unsigned int summary_only; /* set with -s */ 53103a8feaSLen Brown unsigned int skip_c0; 54103a8feaSLen Brown unsigned int skip_c1; 55103a8feaSLen Brown unsigned int do_nhm_cstates; 56103a8feaSLen Brown unsigned int do_snb_cstates; 57103a8feaSLen Brown unsigned int has_aperf; 58103a8feaSLen Brown unsigned int units = 1000000000; /* Ghz etc */ 59103a8feaSLen Brown unsigned int genuine_intel; 60103a8feaSLen Brown unsigned int has_invariant_tsc; 61103a8feaSLen Brown unsigned int do_nehalem_platform_info; 62103a8feaSLen Brown unsigned int do_nehalem_turbo_ratio_limit; 63103a8feaSLen Brown unsigned int extra_msr_offset; 64103a8feaSLen Brown double bclk; 65103a8feaSLen Brown unsigned int show_pkg; 66103a8feaSLen Brown unsigned int show_core; 67103a8feaSLen Brown unsigned int show_cpu; 68103a8feaSLen Brown 69103a8feaSLen Brown int aperf_mperf_unstable; 70103a8feaSLen Brown int backwards_count; 71103a8feaSLen Brown char *progname; 72103a8feaSLen Brown int need_reinitialize; 73103a8feaSLen Brown 74103a8feaSLen Brown int num_cpus; 75103a8feaSLen Brown 76a829eb4dSLen Brown struct counters { 77103a8feaSLen Brown unsigned long long tsc; /* per thread */ 78103a8feaSLen Brown unsigned long long aperf; /* per thread */ 79103a8feaSLen Brown unsigned long long mperf; /* per thread */ 80103a8feaSLen Brown unsigned long long c1; /* per thread (calculated) */ 81103a8feaSLen Brown unsigned long long c3; /* per core */ 82103a8feaSLen Brown unsigned long long c6; /* per core */ 83103a8feaSLen Brown unsigned long long c7; /* per core */ 84103a8feaSLen Brown unsigned long long pc2; /* per package */ 85103a8feaSLen Brown unsigned long long pc3; /* per package */ 86103a8feaSLen Brown unsigned long long pc6; /* per package */ 87103a8feaSLen Brown unsigned long long pc7; /* per package */ 88103a8feaSLen Brown unsigned long long extra_msr; /* per thread */ 89103a8feaSLen Brown int pkg; 90103a8feaSLen Brown int core; 91103a8feaSLen Brown int cpu; 92a829eb4dSLen Brown struct counters *next; 93a829eb4dSLen Brown }; 94103a8feaSLen Brown 95a829eb4dSLen Brown struct counters *cnt_even; 96a829eb4dSLen Brown struct counters *cnt_odd; 97a829eb4dSLen Brown struct counters *cnt_delta; 98a829eb4dSLen Brown struct counters *cnt_average; 99103a8feaSLen Brown struct timeval tv_even; 100103a8feaSLen Brown struct timeval tv_odd; 101103a8feaSLen Brown struct timeval tv_delta; 102103a8feaSLen Brown 103103a8feaSLen Brown unsigned long long get_msr(int cpu, off_t offset) 104103a8feaSLen Brown { 105103a8feaSLen Brown ssize_t retval; 106103a8feaSLen Brown unsigned long long msr; 107103a8feaSLen Brown char pathname[32]; 108103a8feaSLen Brown int fd; 109103a8feaSLen Brown 110103a8feaSLen Brown sprintf(pathname, "/dev/cpu/%d/msr", cpu); 111103a8feaSLen Brown fd = open(pathname, O_RDONLY); 112103a8feaSLen Brown if (fd < 0) { 113103a8feaSLen Brown perror(pathname); 114103a8feaSLen Brown need_reinitialize = 1; 115103a8feaSLen Brown return 0; 116103a8feaSLen Brown } 117103a8feaSLen Brown 118103a8feaSLen Brown retval = pread(fd, &msr, sizeof msr, offset); 119103a8feaSLen Brown if (retval != sizeof msr) { 120103a8feaSLen Brown fprintf(stderr, "cpu%d pread(..., 0x%zx) = %jd\n", 121103a8feaSLen Brown cpu, offset, retval); 122103a8feaSLen Brown exit(-2); 123103a8feaSLen Brown } 124103a8feaSLen Brown 125103a8feaSLen Brown close(fd); 126103a8feaSLen Brown return msr; 127103a8feaSLen Brown } 128103a8feaSLen Brown 129a829eb4dSLen Brown void print_header(void) 130103a8feaSLen Brown { 131103a8feaSLen Brown if (show_pkg) 132d30c4b7aSLen Brown fprintf(stderr, "pk"); 133*e23da037SLen Brown if (show_pkg) 134*e23da037SLen Brown fprintf(stderr, " "); 135103a8feaSLen Brown if (show_core) 136*e23da037SLen Brown fprintf(stderr, "cor"); 137103a8feaSLen Brown if (show_cpu) 138103a8feaSLen Brown fprintf(stderr, " CPU"); 139*e23da037SLen Brown if (show_pkg || show_core || show_cpu) 140*e23da037SLen Brown fprintf(stderr, " "); 141103a8feaSLen Brown if (do_nhm_cstates) 142103a8feaSLen Brown fprintf(stderr, " %%c0"); 143103a8feaSLen Brown if (has_aperf) 144103a8feaSLen Brown fprintf(stderr, " GHz"); 145103a8feaSLen Brown fprintf(stderr, " TSC"); 146103a8feaSLen Brown if (do_nhm_cstates) 147103a8feaSLen Brown fprintf(stderr, " %%c1"); 148103a8feaSLen Brown if (do_nhm_cstates) 149103a8feaSLen Brown fprintf(stderr, " %%c3"); 150103a8feaSLen Brown if (do_nhm_cstates) 151103a8feaSLen Brown fprintf(stderr, " %%c6"); 152103a8feaSLen Brown if (do_snb_cstates) 153103a8feaSLen Brown fprintf(stderr, " %%c7"); 154103a8feaSLen Brown if (do_snb_cstates) 155103a8feaSLen Brown fprintf(stderr, " %%pc2"); 156103a8feaSLen Brown if (do_nhm_cstates) 157103a8feaSLen Brown fprintf(stderr, " %%pc3"); 158103a8feaSLen Brown if (do_nhm_cstates) 159103a8feaSLen Brown fprintf(stderr, " %%pc6"); 160103a8feaSLen Brown if (do_snb_cstates) 161103a8feaSLen Brown fprintf(stderr, " %%pc7"); 162103a8feaSLen Brown if (extra_msr_offset) 163103a8feaSLen Brown fprintf(stderr, " MSR 0x%x ", extra_msr_offset); 164103a8feaSLen Brown 165103a8feaSLen Brown putc('\n', stderr); 166103a8feaSLen Brown } 167103a8feaSLen Brown 168a829eb4dSLen Brown void dump_cnt(struct counters *cnt) 169103a8feaSLen Brown { 170aeae1e92SLen Brown if (!cnt) 171aeae1e92SLen Brown return; 172aeae1e92SLen Brown if (cnt->pkg) fprintf(stderr, "package: %d ", cnt->pkg); 173aeae1e92SLen Brown if (cnt->core) fprintf(stderr, "core:: %d ", cnt->core); 174aeae1e92SLen Brown if (cnt->cpu) fprintf(stderr, "CPU: %d ", cnt->cpu); 175aeae1e92SLen Brown if (cnt->tsc) fprintf(stderr, "TSC: %016llX\n", cnt->tsc); 176aeae1e92SLen Brown if (cnt->c3) fprintf(stderr, "c3: %016llX\n", cnt->c3); 177aeae1e92SLen Brown if (cnt->c6) fprintf(stderr, "c6: %016llX\n", cnt->c6); 178aeae1e92SLen Brown if (cnt->c7) fprintf(stderr, "c7: %016llX\n", cnt->c7); 179aeae1e92SLen Brown if (cnt->aperf) fprintf(stderr, "aperf: %016llX\n", cnt->aperf); 180aeae1e92SLen Brown if (cnt->pc2) fprintf(stderr, "pc2: %016llX\n", cnt->pc2); 181aeae1e92SLen Brown if (cnt->pc3) fprintf(stderr, "pc3: %016llX\n", cnt->pc3); 182aeae1e92SLen Brown if (cnt->pc6) fprintf(stderr, "pc6: %016llX\n", cnt->pc6); 183aeae1e92SLen Brown if (cnt->pc7) fprintf(stderr, "pc7: %016llX\n", cnt->pc7); 184aeae1e92SLen Brown if (cnt->extra_msr) fprintf(stderr, "msr0x%x: %016llX\n", extra_msr_offset, cnt->extra_msr); 185103a8feaSLen Brown } 186103a8feaSLen Brown 187a829eb4dSLen Brown void dump_list(struct counters *cnt) 188103a8feaSLen Brown { 189a829eb4dSLen Brown printf("dump_list 0x%p\n", cnt); 190103a8feaSLen Brown 191a829eb4dSLen Brown for (; cnt; cnt = cnt->next) 192a829eb4dSLen Brown dump_cnt(cnt); 193103a8feaSLen Brown } 194103a8feaSLen Brown 195*e23da037SLen Brown /* 196*e23da037SLen Brown * column formatting convention & formats 197*e23da037SLen Brown * package: "pk" 2 columns %2d 198*e23da037SLen Brown * core: "cor" 3 columns %3d 199*e23da037SLen Brown * CPU: "CPU" 3 columns %3d 200*e23da037SLen Brown * GHz: "GHz" 3 columns %3.2 201*e23da037SLen Brown * TSC: "TSC" 3 columns %3.2 202*e23da037SLen Brown * percentage " %pc3" %6.2 203*e23da037SLen Brown */ 204a829eb4dSLen Brown void print_cnt(struct counters *p) 205103a8feaSLen Brown { 206103a8feaSLen Brown double interval_float; 207103a8feaSLen Brown 208103a8feaSLen Brown interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0; 209103a8feaSLen Brown 210103a8feaSLen Brown /* topology columns, print blanks on 1st (average) line */ 211a829eb4dSLen Brown if (p == cnt_average) { 212103a8feaSLen Brown if (show_pkg) 213103a8feaSLen Brown fprintf(stderr, " "); 214*e23da037SLen Brown if (show_pkg && show_core) 215*e23da037SLen Brown fprintf(stderr, " "); 216103a8feaSLen Brown if (show_core) 217103a8feaSLen Brown fprintf(stderr, " "); 218103a8feaSLen Brown if (show_cpu) 219*e23da037SLen Brown fprintf(stderr, " " " "); 220103a8feaSLen Brown } else { 221103a8feaSLen Brown if (show_pkg) 222*e23da037SLen Brown fprintf(stderr, "%2d", p->pkg); 223*e23da037SLen Brown if (show_pkg && show_core) 224*e23da037SLen Brown fprintf(stderr, " "); 225103a8feaSLen Brown if (show_core) 226*e23da037SLen Brown fprintf(stderr, "%3d", p->core); 227103a8feaSLen Brown if (show_cpu) 228*e23da037SLen Brown fprintf(stderr, " %3d", p->cpu); 229103a8feaSLen Brown } 230103a8feaSLen Brown 231103a8feaSLen Brown /* %c0 */ 232103a8feaSLen Brown if (do_nhm_cstates) { 233*e23da037SLen Brown if (show_pkg || show_core || show_cpu) 234*e23da037SLen Brown fprintf(stderr, " "); 235103a8feaSLen Brown if (!skip_c0) 236*e23da037SLen Brown fprintf(stderr, "%6.2f", 100.0 * p->mperf/p->tsc); 237103a8feaSLen Brown else 238103a8feaSLen Brown fprintf(stderr, " ****"); 239103a8feaSLen Brown } 240103a8feaSLen Brown 241103a8feaSLen Brown /* GHz */ 242103a8feaSLen Brown if (has_aperf) { 243103a8feaSLen Brown if (!aperf_mperf_unstable) { 244*e23da037SLen Brown fprintf(stderr, " %3.2f", 245103a8feaSLen Brown 1.0 * p->tsc / units * p->aperf / 246103a8feaSLen Brown p->mperf / interval_float); 247103a8feaSLen Brown } else { 248103a8feaSLen Brown if (p->aperf > p->tsc || p->mperf > p->tsc) { 249*e23da037SLen Brown fprintf(stderr, " ***"); 250103a8feaSLen Brown } else { 251*e23da037SLen Brown fprintf(stderr, "%3.1f*", 252103a8feaSLen Brown 1.0 * p->tsc / 253103a8feaSLen Brown units * p->aperf / 254103a8feaSLen Brown p->mperf / interval_float); 255103a8feaSLen Brown } 256103a8feaSLen Brown } 257103a8feaSLen Brown } 258103a8feaSLen Brown 259103a8feaSLen Brown /* TSC */ 260103a8feaSLen Brown fprintf(stderr, "%5.2f", 1.0 * p->tsc/units/interval_float); 261103a8feaSLen Brown 262103a8feaSLen Brown if (do_nhm_cstates) { 263103a8feaSLen Brown if (!skip_c1) 264*e23da037SLen Brown fprintf(stderr, " %6.2f", 100.0 * p->c1/p->tsc); 265103a8feaSLen Brown else 266103a8feaSLen Brown fprintf(stderr, " ****"); 267103a8feaSLen Brown } 268103a8feaSLen Brown if (do_nhm_cstates) 269d30c4b7aSLen Brown fprintf(stderr, " %6.2f", 100.0 * p->c3/p->tsc); 270103a8feaSLen Brown if (do_nhm_cstates) 271d30c4b7aSLen Brown fprintf(stderr, " %6.2f", 100.0 * p->c6/p->tsc); 272103a8feaSLen Brown if (do_snb_cstates) 273d30c4b7aSLen Brown fprintf(stderr, " %6.2f", 100.0 * p->c7/p->tsc); 274103a8feaSLen Brown if (do_snb_cstates) 275*e23da037SLen Brown fprintf(stderr, " %6.2f", 100.0 * p->pc2/p->tsc); 276103a8feaSLen Brown if (do_nhm_cstates) 277*e23da037SLen Brown fprintf(stderr, " %6.2f", 100.0 * p->pc3/p->tsc); 278103a8feaSLen Brown if (do_nhm_cstates) 279*e23da037SLen Brown fprintf(stderr, " %6.2f", 100.0 * p->pc6/p->tsc); 280103a8feaSLen Brown if (do_snb_cstates) 281*e23da037SLen Brown fprintf(stderr, " %6.2f", 100.0 * p->pc7/p->tsc); 282103a8feaSLen Brown if (extra_msr_offset) 283103a8feaSLen Brown fprintf(stderr, " 0x%016llx", p->extra_msr); 284103a8feaSLen Brown putc('\n', stderr); 285103a8feaSLen Brown } 286103a8feaSLen Brown 287a829eb4dSLen Brown void print_counters(struct counters *counters) 288103a8feaSLen Brown { 289a829eb4dSLen Brown struct counters *cnt; 290*e23da037SLen Brown static int printed; 291103a8feaSLen Brown 292*e23da037SLen Brown 293*e23da037SLen Brown if (!printed || !summary_only) 294103a8feaSLen Brown print_header(); 295103a8feaSLen Brown 296103a8feaSLen Brown if (num_cpus > 1) 297a829eb4dSLen Brown print_cnt(cnt_average); 298103a8feaSLen Brown 299*e23da037SLen Brown printed = 1; 300*e23da037SLen Brown 301*e23da037SLen Brown if (summary_only) 302*e23da037SLen Brown return; 303*e23da037SLen Brown 304a829eb4dSLen Brown for (cnt = counters; cnt != NULL; cnt = cnt->next) 305a829eb4dSLen Brown print_cnt(cnt); 306103a8feaSLen Brown 307103a8feaSLen Brown } 308103a8feaSLen Brown 309103a8feaSLen Brown #define SUBTRACT_COUNTER(after, before, delta) (delta = (after - before), (before > after)) 310103a8feaSLen Brown 311a829eb4dSLen Brown int compute_delta(struct counters *after, 312a829eb4dSLen Brown struct counters *before, struct counters *delta) 313103a8feaSLen Brown { 314103a8feaSLen Brown int errors = 0; 315103a8feaSLen Brown int perf_err = 0; 316103a8feaSLen Brown 317103a8feaSLen Brown skip_c0 = skip_c1 = 0; 318103a8feaSLen Brown 319103a8feaSLen Brown for ( ; after && before && delta; 320103a8feaSLen Brown after = after->next, before = before->next, delta = delta->next) { 321103a8feaSLen Brown if (before->cpu != after->cpu) { 322103a8feaSLen Brown printf("cpu configuration changed: %d != %d\n", 323103a8feaSLen Brown before->cpu, after->cpu); 324103a8feaSLen Brown return -1; 325103a8feaSLen Brown } 326103a8feaSLen Brown 327103a8feaSLen Brown if (SUBTRACT_COUNTER(after->tsc, before->tsc, delta->tsc)) { 328103a8feaSLen Brown fprintf(stderr, "cpu%d TSC went backwards %llX to %llX\n", 329103a8feaSLen Brown before->cpu, before->tsc, after->tsc); 330103a8feaSLen Brown errors++; 331103a8feaSLen Brown } 332103a8feaSLen Brown /* check for TSC < 1 Mcycles over interval */ 333103a8feaSLen Brown if (delta->tsc < (1000 * 1000)) { 334103a8feaSLen Brown fprintf(stderr, "Insanely slow TSC rate," 335103a8feaSLen Brown " TSC stops in idle?\n"); 336103a8feaSLen Brown fprintf(stderr, "You can disable all c-states" 337103a8feaSLen Brown " by booting with \"idle=poll\"\n"); 338103a8feaSLen Brown fprintf(stderr, "or just the deep ones with" 339103a8feaSLen Brown " \"processor.max_cstate=1\"\n"); 340103a8feaSLen Brown exit(-3); 341103a8feaSLen Brown } 342103a8feaSLen Brown if (SUBTRACT_COUNTER(after->c3, before->c3, delta->c3)) { 343103a8feaSLen Brown fprintf(stderr, "cpu%d c3 counter went backwards %llX to %llX\n", 344103a8feaSLen Brown before->cpu, before->c3, after->c3); 345103a8feaSLen Brown errors++; 346103a8feaSLen Brown } 347103a8feaSLen Brown if (SUBTRACT_COUNTER(after->c6, before->c6, delta->c6)) { 348103a8feaSLen Brown fprintf(stderr, "cpu%d c6 counter went backwards %llX to %llX\n", 349103a8feaSLen Brown before->cpu, before->c6, after->c6); 350103a8feaSLen Brown errors++; 351103a8feaSLen Brown } 352103a8feaSLen Brown if (SUBTRACT_COUNTER(after->c7, before->c7, delta->c7)) { 353103a8feaSLen Brown fprintf(stderr, "cpu%d c7 counter went backwards %llX to %llX\n", 354103a8feaSLen Brown before->cpu, before->c7, after->c7); 355103a8feaSLen Brown errors++; 356103a8feaSLen Brown } 357103a8feaSLen Brown if (SUBTRACT_COUNTER(after->pc2, before->pc2, delta->pc2)) { 358103a8feaSLen Brown fprintf(stderr, "cpu%d pc2 counter went backwards %llX to %llX\n", 359103a8feaSLen Brown before->cpu, before->pc2, after->pc2); 360103a8feaSLen Brown errors++; 361103a8feaSLen Brown } 362103a8feaSLen Brown if (SUBTRACT_COUNTER(after->pc3, before->pc3, delta->pc3)) { 363103a8feaSLen Brown fprintf(stderr, "cpu%d pc3 counter went backwards %llX to %llX\n", 364103a8feaSLen Brown before->cpu, before->pc3, after->pc3); 365103a8feaSLen Brown errors++; 366103a8feaSLen Brown } 367103a8feaSLen Brown if (SUBTRACT_COUNTER(after->pc6, before->pc6, delta->pc6)) { 368103a8feaSLen Brown fprintf(stderr, "cpu%d pc6 counter went backwards %llX to %llX\n", 369103a8feaSLen Brown before->cpu, before->pc6, after->pc6); 370103a8feaSLen Brown errors++; 371103a8feaSLen Brown } 372103a8feaSLen Brown if (SUBTRACT_COUNTER(after->pc7, before->pc7, delta->pc7)) { 373103a8feaSLen Brown fprintf(stderr, "cpu%d pc7 counter went backwards %llX to %llX\n", 374103a8feaSLen Brown before->cpu, before->pc7, after->pc7); 375103a8feaSLen Brown errors++; 376103a8feaSLen Brown } 377103a8feaSLen Brown 378103a8feaSLen Brown perf_err = SUBTRACT_COUNTER(after->aperf, before->aperf, delta->aperf); 379103a8feaSLen Brown if (perf_err) { 380103a8feaSLen Brown fprintf(stderr, "cpu%d aperf counter went backwards %llX to %llX\n", 381103a8feaSLen Brown before->cpu, before->aperf, after->aperf); 382103a8feaSLen Brown } 383103a8feaSLen Brown perf_err |= SUBTRACT_COUNTER(after->mperf, before->mperf, delta->mperf); 384103a8feaSLen Brown if (perf_err) { 385103a8feaSLen Brown fprintf(stderr, "cpu%d mperf counter went backwards %llX to %llX\n", 386103a8feaSLen Brown before->cpu, before->mperf, after->mperf); 387103a8feaSLen Brown } 388103a8feaSLen Brown if (perf_err) { 389103a8feaSLen Brown if (!aperf_mperf_unstable) { 390103a8feaSLen Brown fprintf(stderr, "%s: APERF or MPERF went backwards *\n", progname); 391103a8feaSLen Brown fprintf(stderr, "* Frequency results do not cover entire interval *\n"); 392103a8feaSLen Brown fprintf(stderr, "* fix this by running Linux-2.6.30 or later *\n"); 393103a8feaSLen Brown 394103a8feaSLen Brown aperf_mperf_unstable = 1; 395103a8feaSLen Brown } 396103a8feaSLen Brown /* 397103a8feaSLen Brown * mperf delta is likely a huge "positive" number 398103a8feaSLen Brown * can not use it for calculating c0 time 399103a8feaSLen Brown */ 400103a8feaSLen Brown skip_c0 = 1; 401103a8feaSLen Brown skip_c1 = 1; 402103a8feaSLen Brown } 403103a8feaSLen Brown 404103a8feaSLen Brown /* 405103a8feaSLen Brown * As mperf and tsc collection are not atomic, 406103a8feaSLen Brown * it is possible for mperf's non-halted cycles 407103a8feaSLen Brown * to exceed TSC's all cycles: show c1 = 0% in that case. 408103a8feaSLen Brown */ 409103a8feaSLen Brown if (delta->mperf > delta->tsc) 410103a8feaSLen Brown delta->c1 = 0; 411103a8feaSLen Brown else /* normal case, derive c1 */ 412103a8feaSLen Brown delta->c1 = delta->tsc - delta->mperf 413103a8feaSLen Brown - delta->c3 - delta->c6 - delta->c7; 414103a8feaSLen Brown 415103a8feaSLen Brown if (delta->mperf == 0) 416103a8feaSLen Brown delta->mperf = 1; /* divide by 0 protection */ 417103a8feaSLen Brown 418103a8feaSLen Brown /* 419103a8feaSLen Brown * for "extra msr", just copy the latest w/o subtracting 420103a8feaSLen Brown */ 421103a8feaSLen Brown delta->extra_msr = after->extra_msr; 422103a8feaSLen Brown if (errors) { 423103a8feaSLen Brown fprintf(stderr, "ERROR cpu%d before:\n", before->cpu); 424a829eb4dSLen Brown dump_cnt(before); 425103a8feaSLen Brown fprintf(stderr, "ERROR cpu%d after:\n", before->cpu); 426a829eb4dSLen Brown dump_cnt(after); 427103a8feaSLen Brown errors = 0; 428103a8feaSLen Brown } 429103a8feaSLen Brown } 430103a8feaSLen Brown return 0; 431103a8feaSLen Brown } 432103a8feaSLen Brown 433a829eb4dSLen Brown void compute_average(struct counters *delta, struct counters *avg) 434103a8feaSLen Brown { 435a829eb4dSLen Brown struct counters *sum; 436103a8feaSLen Brown 437a829eb4dSLen Brown sum = calloc(1, sizeof(struct counters)); 438103a8feaSLen Brown if (sum == NULL) { 439103a8feaSLen Brown perror("calloc sum"); 440103a8feaSLen Brown exit(1); 441103a8feaSLen Brown } 442103a8feaSLen Brown 443103a8feaSLen Brown for (; delta; delta = delta->next) { 444103a8feaSLen Brown sum->tsc += delta->tsc; 445103a8feaSLen Brown sum->c1 += delta->c1; 446103a8feaSLen Brown sum->c3 += delta->c3; 447103a8feaSLen Brown sum->c6 += delta->c6; 448103a8feaSLen Brown sum->c7 += delta->c7; 449103a8feaSLen Brown sum->aperf += delta->aperf; 450103a8feaSLen Brown sum->mperf += delta->mperf; 451103a8feaSLen Brown sum->pc2 += delta->pc2; 452103a8feaSLen Brown sum->pc3 += delta->pc3; 453103a8feaSLen Brown sum->pc6 += delta->pc6; 454103a8feaSLen Brown sum->pc7 += delta->pc7; 455103a8feaSLen Brown } 456103a8feaSLen Brown avg->tsc = sum->tsc/num_cpus; 457103a8feaSLen Brown avg->c1 = sum->c1/num_cpus; 458103a8feaSLen Brown avg->c3 = sum->c3/num_cpus; 459103a8feaSLen Brown avg->c6 = sum->c6/num_cpus; 460103a8feaSLen Brown avg->c7 = sum->c7/num_cpus; 461103a8feaSLen Brown avg->aperf = sum->aperf/num_cpus; 462103a8feaSLen Brown avg->mperf = sum->mperf/num_cpus; 463103a8feaSLen Brown avg->pc2 = sum->pc2/num_cpus; 464103a8feaSLen Brown avg->pc3 = sum->pc3/num_cpus; 465103a8feaSLen Brown avg->pc6 = sum->pc6/num_cpus; 466103a8feaSLen Brown avg->pc7 = sum->pc7/num_cpus; 467103a8feaSLen Brown 468103a8feaSLen Brown free(sum); 469103a8feaSLen Brown } 470103a8feaSLen Brown 471a829eb4dSLen Brown void get_counters(struct counters *cnt) 472103a8feaSLen Brown { 473a829eb4dSLen Brown for ( ; cnt; cnt = cnt->next) { 474a829eb4dSLen Brown cnt->tsc = get_msr(cnt->cpu, MSR_TSC); 475103a8feaSLen Brown if (do_nhm_cstates) 476a829eb4dSLen Brown cnt->c3 = get_msr(cnt->cpu, MSR_CORE_C3_RESIDENCY); 477103a8feaSLen Brown if (do_nhm_cstates) 478a829eb4dSLen Brown cnt->c6 = get_msr(cnt->cpu, MSR_CORE_C6_RESIDENCY); 479103a8feaSLen Brown if (do_snb_cstates) 480a829eb4dSLen Brown cnt->c7 = get_msr(cnt->cpu, MSR_CORE_C7_RESIDENCY); 481103a8feaSLen Brown if (has_aperf) 482a829eb4dSLen Brown cnt->aperf = get_msr(cnt->cpu, MSR_APERF); 483103a8feaSLen Brown if (has_aperf) 484a829eb4dSLen Brown cnt->mperf = get_msr(cnt->cpu, MSR_MPERF); 485103a8feaSLen Brown if (do_snb_cstates) 486a829eb4dSLen Brown cnt->pc2 = get_msr(cnt->cpu, MSR_PKG_C2_RESIDENCY); 487103a8feaSLen Brown if (do_nhm_cstates) 488a829eb4dSLen Brown cnt->pc3 = get_msr(cnt->cpu, MSR_PKG_C3_RESIDENCY); 489103a8feaSLen Brown if (do_nhm_cstates) 490a829eb4dSLen Brown cnt->pc6 = get_msr(cnt->cpu, MSR_PKG_C6_RESIDENCY); 491103a8feaSLen Brown if (do_snb_cstates) 492a829eb4dSLen Brown cnt->pc7 = get_msr(cnt->cpu, MSR_PKG_C7_RESIDENCY); 493103a8feaSLen Brown if (extra_msr_offset) 494a829eb4dSLen Brown cnt->extra_msr = get_msr(cnt->cpu, extra_msr_offset); 495103a8feaSLen Brown } 496103a8feaSLen Brown } 497103a8feaSLen Brown 498a829eb4dSLen Brown void print_nehalem_info(void) 499103a8feaSLen Brown { 500103a8feaSLen Brown unsigned long long msr; 501103a8feaSLen Brown unsigned int ratio; 502103a8feaSLen Brown 503103a8feaSLen Brown if (!do_nehalem_platform_info) 504103a8feaSLen Brown return; 505103a8feaSLen Brown 506103a8feaSLen Brown msr = get_msr(0, MSR_NEHALEM_PLATFORM_INFO); 507103a8feaSLen Brown 508103a8feaSLen Brown ratio = (msr >> 40) & 0xFF; 509103a8feaSLen Brown fprintf(stderr, "%d * %.0f = %.0f MHz max efficiency\n", 510103a8feaSLen Brown ratio, bclk, ratio * bclk); 511103a8feaSLen Brown 512103a8feaSLen Brown ratio = (msr >> 8) & 0xFF; 513103a8feaSLen Brown fprintf(stderr, "%d * %.0f = %.0f MHz TSC frequency\n", 514103a8feaSLen Brown ratio, bclk, ratio * bclk); 515103a8feaSLen Brown 516103a8feaSLen Brown if (verbose > 1) 517103a8feaSLen Brown fprintf(stderr, "MSR_NEHALEM_PLATFORM_INFO: 0x%llx\n", msr); 518103a8feaSLen Brown 519103a8feaSLen Brown if (!do_nehalem_turbo_ratio_limit) 520103a8feaSLen Brown return; 521103a8feaSLen Brown 522103a8feaSLen Brown msr = get_msr(0, MSR_NEHALEM_TURBO_RATIO_LIMIT); 523103a8feaSLen Brown 524103a8feaSLen Brown ratio = (msr >> 24) & 0xFF; 525103a8feaSLen Brown if (ratio) 526103a8feaSLen Brown fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 4 active cores\n", 527103a8feaSLen Brown ratio, bclk, ratio * bclk); 528103a8feaSLen Brown 529103a8feaSLen Brown ratio = (msr >> 16) & 0xFF; 530103a8feaSLen Brown if (ratio) 531103a8feaSLen Brown fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 3 active cores\n", 532103a8feaSLen Brown ratio, bclk, ratio * bclk); 533103a8feaSLen Brown 534103a8feaSLen Brown ratio = (msr >> 8) & 0xFF; 535103a8feaSLen Brown if (ratio) 536103a8feaSLen Brown fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 2 active cores\n", 537103a8feaSLen Brown ratio, bclk, ratio * bclk); 538103a8feaSLen Brown 539103a8feaSLen Brown ratio = (msr >> 0) & 0xFF; 540103a8feaSLen Brown if (ratio) 541103a8feaSLen Brown fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 1 active cores\n", 542103a8feaSLen Brown ratio, bclk, ratio * bclk); 543103a8feaSLen Brown 544103a8feaSLen Brown } 545103a8feaSLen Brown 546a829eb4dSLen Brown void free_counter_list(struct counters *list) 547103a8feaSLen Brown { 548a829eb4dSLen Brown struct counters *p; 549103a8feaSLen Brown 550103a8feaSLen Brown for (p = list; p; ) { 551a829eb4dSLen Brown struct counters *free_me; 552103a8feaSLen Brown 553103a8feaSLen Brown free_me = p; 554103a8feaSLen Brown p = p->next; 555103a8feaSLen Brown free(free_me); 556103a8feaSLen Brown } 557103a8feaSLen Brown } 558103a8feaSLen Brown 559103a8feaSLen Brown void free_all_counters(void) 560103a8feaSLen Brown { 561a829eb4dSLen Brown free_counter_list(cnt_even); 562a829eb4dSLen Brown cnt_even = NULL; 563103a8feaSLen Brown 564a829eb4dSLen Brown free_counter_list(cnt_odd); 565a829eb4dSLen Brown cnt_odd = NULL; 566103a8feaSLen Brown 567a829eb4dSLen Brown free_counter_list(cnt_delta); 568a829eb4dSLen Brown cnt_delta = NULL; 569103a8feaSLen Brown 570a829eb4dSLen Brown free_counter_list(cnt_average); 571a829eb4dSLen Brown cnt_average = NULL; 572103a8feaSLen Brown } 573103a8feaSLen Brown 574a829eb4dSLen Brown void insert_counters(struct counters **list, 575a829eb4dSLen Brown struct counters *new) 576103a8feaSLen Brown { 577a829eb4dSLen Brown struct counters *prev; 578103a8feaSLen Brown 579103a8feaSLen Brown /* 580103a8feaSLen Brown * list was empty 581103a8feaSLen Brown */ 582103a8feaSLen Brown if (*list == NULL) { 583103a8feaSLen Brown new->next = *list; 584103a8feaSLen Brown *list = new; 585103a8feaSLen Brown return; 586103a8feaSLen Brown } 587103a8feaSLen Brown 588*e23da037SLen Brown if (!summary_only) 589103a8feaSLen Brown show_cpu = 1; /* there is more than one CPU */ 590103a8feaSLen Brown 591103a8feaSLen Brown /* 592103a8feaSLen Brown * insert on front of list. 593103a8feaSLen Brown * It is sorted by ascending package#, core#, cpu# 594103a8feaSLen Brown */ 595103a8feaSLen Brown if (((*list)->pkg > new->pkg) || 596103a8feaSLen Brown (((*list)->pkg == new->pkg) && ((*list)->core > new->core)) || 597103a8feaSLen Brown (((*list)->pkg == new->pkg) && ((*list)->core == new->core) && ((*list)->cpu > new->cpu))) { 598103a8feaSLen Brown new->next = *list; 599103a8feaSLen Brown *list = new; 600103a8feaSLen Brown return; 601103a8feaSLen Brown } 602103a8feaSLen Brown 603103a8feaSLen Brown prev = *list; 604103a8feaSLen Brown 605103a8feaSLen Brown while (prev->next && (prev->next->pkg < new->pkg)) { 606103a8feaSLen Brown prev = prev->next; 607*e23da037SLen Brown if (!summary_only) 608103a8feaSLen Brown show_pkg = 1; /* there is more than 1 package */ 609103a8feaSLen Brown } 610103a8feaSLen Brown 611103a8feaSLen Brown while (prev->next && (prev->next->pkg == new->pkg) 612103a8feaSLen Brown && (prev->next->core < new->core)) { 613103a8feaSLen Brown prev = prev->next; 614*e23da037SLen Brown if (!summary_only) 615103a8feaSLen Brown show_core = 1; /* there is more than 1 core */ 616103a8feaSLen Brown } 617103a8feaSLen Brown 618103a8feaSLen Brown while (prev->next && (prev->next->pkg == new->pkg) 619103a8feaSLen Brown && (prev->next->core == new->core) 620103a8feaSLen Brown && (prev->next->cpu < new->cpu)) { 621103a8feaSLen Brown prev = prev->next; 622103a8feaSLen Brown } 623103a8feaSLen Brown 624103a8feaSLen Brown /* 625103a8feaSLen Brown * insert after "prev" 626103a8feaSLen Brown */ 627103a8feaSLen Brown new->next = prev->next; 628103a8feaSLen Brown prev->next = new; 629103a8feaSLen Brown } 630103a8feaSLen Brown 631a829eb4dSLen Brown void alloc_new_counters(int pkg, int core, int cpu) 632103a8feaSLen Brown { 633a829eb4dSLen Brown struct counters *new; 634103a8feaSLen Brown 635103a8feaSLen Brown if (verbose > 1) 636103a8feaSLen Brown printf("pkg%d core%d, cpu%d\n", pkg, core, cpu); 637103a8feaSLen Brown 638a829eb4dSLen Brown new = (struct counters *)calloc(1, sizeof(struct counters)); 639103a8feaSLen Brown if (new == NULL) { 640103a8feaSLen Brown perror("calloc"); 641103a8feaSLen Brown exit(1); 642103a8feaSLen Brown } 643103a8feaSLen Brown new->pkg = pkg; 644103a8feaSLen Brown new->core = core; 645103a8feaSLen Brown new->cpu = cpu; 646a829eb4dSLen Brown insert_counters(&cnt_odd, new); 647103a8feaSLen Brown 648a829eb4dSLen Brown new = (struct counters *)calloc(1, 649a829eb4dSLen Brown sizeof(struct counters)); 650103a8feaSLen Brown if (new == NULL) { 651103a8feaSLen Brown perror("calloc"); 652103a8feaSLen Brown exit(1); 653103a8feaSLen Brown } 654103a8feaSLen Brown new->pkg = pkg; 655103a8feaSLen Brown new->core = core; 656103a8feaSLen Brown new->cpu = cpu; 657a829eb4dSLen Brown insert_counters(&cnt_even, new); 658103a8feaSLen Brown 659a829eb4dSLen Brown new = (struct counters *)calloc(1, sizeof(struct counters)); 660103a8feaSLen Brown if (new == NULL) { 661103a8feaSLen Brown perror("calloc"); 662103a8feaSLen Brown exit(1); 663103a8feaSLen Brown } 664103a8feaSLen Brown new->pkg = pkg; 665103a8feaSLen Brown new->core = core; 666103a8feaSLen Brown new->cpu = cpu; 667a829eb4dSLen Brown insert_counters(&cnt_delta, new); 668103a8feaSLen Brown 669a829eb4dSLen Brown new = (struct counters *)calloc(1, sizeof(struct counters)); 670103a8feaSLen Brown if (new == NULL) { 671103a8feaSLen Brown perror("calloc"); 672103a8feaSLen Brown exit(1); 673103a8feaSLen Brown } 674103a8feaSLen Brown new->pkg = pkg; 675103a8feaSLen Brown new->core = core; 676103a8feaSLen Brown new->cpu = cpu; 677a829eb4dSLen Brown cnt_average = new; 678103a8feaSLen Brown } 679103a8feaSLen Brown 680103a8feaSLen Brown int get_physical_package_id(int cpu) 681103a8feaSLen Brown { 682103a8feaSLen Brown char path[64]; 683103a8feaSLen Brown FILE *filep; 684103a8feaSLen Brown int pkg; 685103a8feaSLen Brown 686103a8feaSLen Brown sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu); 687103a8feaSLen Brown filep = fopen(path, "r"); 688103a8feaSLen Brown if (filep == NULL) { 689103a8feaSLen Brown perror(path); 690103a8feaSLen Brown exit(1); 691103a8feaSLen Brown } 692103a8feaSLen Brown fscanf(filep, "%d", &pkg); 693103a8feaSLen Brown fclose(filep); 694103a8feaSLen Brown return pkg; 695103a8feaSLen Brown } 696103a8feaSLen Brown 697103a8feaSLen Brown int get_core_id(int cpu) 698103a8feaSLen Brown { 699103a8feaSLen Brown char path[64]; 700103a8feaSLen Brown FILE *filep; 701103a8feaSLen Brown int core; 702103a8feaSLen Brown 703103a8feaSLen Brown sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/core_id", cpu); 704103a8feaSLen Brown filep = fopen(path, "r"); 705103a8feaSLen Brown if (filep == NULL) { 706103a8feaSLen Brown perror(path); 707103a8feaSLen Brown exit(1); 708103a8feaSLen Brown } 709103a8feaSLen Brown fscanf(filep, "%d", &core); 710103a8feaSLen Brown fclose(filep); 711103a8feaSLen Brown return core; 712103a8feaSLen Brown } 713103a8feaSLen Brown 714103a8feaSLen Brown /* 715103a8feaSLen Brown * run func(index, cpu) on every cpu in /proc/stat 716103a8feaSLen Brown */ 717103a8feaSLen Brown 718103a8feaSLen Brown int for_all_cpus(void (func)(int, int, int)) 719103a8feaSLen Brown { 720103a8feaSLen Brown FILE *fp; 721103a8feaSLen Brown int cpu_count; 722103a8feaSLen Brown int retval; 723103a8feaSLen Brown 724103a8feaSLen Brown fp = fopen(proc_stat, "r"); 725103a8feaSLen Brown if (fp == NULL) { 726103a8feaSLen Brown perror(proc_stat); 727103a8feaSLen Brown exit(1); 728103a8feaSLen Brown } 729103a8feaSLen Brown 730103a8feaSLen Brown retval = fscanf(fp, "cpu %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n"); 731103a8feaSLen Brown if (retval != 0) { 732103a8feaSLen Brown perror("/proc/stat format"); 733103a8feaSLen Brown exit(1); 734103a8feaSLen Brown } 735103a8feaSLen Brown 736103a8feaSLen Brown for (cpu_count = 0; ; cpu_count++) { 737103a8feaSLen Brown int cpu; 738103a8feaSLen Brown 739103a8feaSLen Brown retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu); 740103a8feaSLen Brown if (retval != 1) 741103a8feaSLen Brown break; 742103a8feaSLen Brown 743103a8feaSLen Brown func(get_physical_package_id(cpu), get_core_id(cpu), cpu); 744103a8feaSLen Brown } 745103a8feaSLen Brown fclose(fp); 746103a8feaSLen Brown return cpu_count; 747103a8feaSLen Brown } 748103a8feaSLen Brown 749103a8feaSLen Brown void re_initialize(void) 750103a8feaSLen Brown { 751103a8feaSLen Brown printf("turbostat: topology changed, re-initializing.\n"); 752103a8feaSLen Brown free_all_counters(); 753a829eb4dSLen Brown num_cpus = for_all_cpus(alloc_new_counters); 754103a8feaSLen Brown need_reinitialize = 0; 755103a8feaSLen Brown printf("num_cpus is now %d\n", num_cpus); 756103a8feaSLen Brown } 757103a8feaSLen Brown 758103a8feaSLen Brown void dummy(int pkg, int core, int cpu) { return; } 759103a8feaSLen Brown /* 760103a8feaSLen Brown * check to see if a cpu came on-line 761103a8feaSLen Brown */ 762a829eb4dSLen Brown void verify_num_cpus(void) 763103a8feaSLen Brown { 764103a8feaSLen Brown int new_num_cpus; 765103a8feaSLen Brown 766103a8feaSLen Brown new_num_cpus = for_all_cpus(dummy); 767103a8feaSLen Brown 768103a8feaSLen Brown if (new_num_cpus != num_cpus) { 769103a8feaSLen Brown if (verbose) 770103a8feaSLen Brown printf("num_cpus was %d, is now %d\n", 771103a8feaSLen Brown num_cpus, new_num_cpus); 772103a8feaSLen Brown need_reinitialize = 1; 773103a8feaSLen Brown } 774103a8feaSLen Brown } 775103a8feaSLen Brown 776103a8feaSLen Brown void turbostat_loop() 777103a8feaSLen Brown { 778103a8feaSLen Brown restart: 779a829eb4dSLen Brown get_counters(cnt_even); 780103a8feaSLen Brown gettimeofday(&tv_even, (struct timezone *)NULL); 781103a8feaSLen Brown 782103a8feaSLen Brown while (1) { 783103a8feaSLen Brown verify_num_cpus(); 784103a8feaSLen Brown if (need_reinitialize) { 785103a8feaSLen Brown re_initialize(); 786103a8feaSLen Brown goto restart; 787103a8feaSLen Brown } 788103a8feaSLen Brown sleep(interval_sec); 789a829eb4dSLen Brown get_counters(cnt_odd); 790103a8feaSLen Brown gettimeofday(&tv_odd, (struct timezone *)NULL); 791103a8feaSLen Brown 792a829eb4dSLen Brown compute_delta(cnt_odd, cnt_even, cnt_delta); 793103a8feaSLen Brown timersub(&tv_odd, &tv_even, &tv_delta); 794a829eb4dSLen Brown compute_average(cnt_delta, cnt_average); 795a829eb4dSLen Brown print_counters(cnt_delta); 796103a8feaSLen Brown if (need_reinitialize) { 797103a8feaSLen Brown re_initialize(); 798103a8feaSLen Brown goto restart; 799103a8feaSLen Brown } 800103a8feaSLen Brown sleep(interval_sec); 801a829eb4dSLen Brown get_counters(cnt_even); 802103a8feaSLen Brown gettimeofday(&tv_even, (struct timezone *)NULL); 803a829eb4dSLen Brown compute_delta(cnt_even, cnt_odd, cnt_delta); 804103a8feaSLen Brown timersub(&tv_even, &tv_odd, &tv_delta); 805a829eb4dSLen Brown compute_average(cnt_delta, cnt_average); 806a829eb4dSLen Brown print_counters(cnt_delta); 807103a8feaSLen Brown } 808103a8feaSLen Brown } 809103a8feaSLen Brown 810103a8feaSLen Brown void check_dev_msr() 811103a8feaSLen Brown { 812103a8feaSLen Brown struct stat sb; 813103a8feaSLen Brown 814103a8feaSLen Brown if (stat("/dev/cpu/0/msr", &sb)) { 815103a8feaSLen Brown fprintf(stderr, "no /dev/cpu/0/msr\n"); 816103a8feaSLen Brown fprintf(stderr, "Try \"# modprobe msr\"\n"); 817103a8feaSLen Brown exit(-5); 818103a8feaSLen Brown } 819103a8feaSLen Brown } 820103a8feaSLen Brown 821103a8feaSLen Brown void check_super_user() 822103a8feaSLen Brown { 823103a8feaSLen Brown if (getuid() != 0) { 824103a8feaSLen Brown fprintf(stderr, "must be root\n"); 825103a8feaSLen Brown exit(-6); 826103a8feaSLen Brown } 827103a8feaSLen Brown } 828103a8feaSLen Brown 829103a8feaSLen Brown int has_nehalem_turbo_ratio_limit(unsigned int family, unsigned int model) 830103a8feaSLen Brown { 831103a8feaSLen Brown if (!genuine_intel) 832103a8feaSLen Brown return 0; 833103a8feaSLen Brown 834103a8feaSLen Brown if (family != 6) 835103a8feaSLen Brown return 0; 836103a8feaSLen Brown 837103a8feaSLen Brown switch (model) { 838103a8feaSLen Brown case 0x1A: /* Core i7, Xeon 5500 series - Bloomfield, Gainstown NHM-EP */ 839103a8feaSLen Brown case 0x1E: /* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */ 840103a8feaSLen Brown case 0x1F: /* Core i7 and i5 Processor - Nehalem */ 841103a8feaSLen Brown case 0x25: /* Westmere Client - Clarkdale, Arrandale */ 842103a8feaSLen Brown case 0x2C: /* Westmere EP - Gulftown */ 843103a8feaSLen Brown case 0x2A: /* SNB */ 844103a8feaSLen Brown case 0x2D: /* SNB Xeon */ 845553575f1SLen Brown case 0x3A: /* IVB */ 846553575f1SLen Brown case 0x3D: /* IVB Xeon */ 847103a8feaSLen Brown return 1; 848103a8feaSLen Brown case 0x2E: /* Nehalem-EX Xeon - Beckton */ 849103a8feaSLen Brown case 0x2F: /* Westmere-EX Xeon - Eagleton */ 850103a8feaSLen Brown default: 851103a8feaSLen Brown return 0; 852103a8feaSLen Brown } 853103a8feaSLen Brown } 854103a8feaSLen Brown 855103a8feaSLen Brown int is_snb(unsigned int family, unsigned int model) 856103a8feaSLen Brown { 857103a8feaSLen Brown if (!genuine_intel) 858103a8feaSLen Brown return 0; 859103a8feaSLen Brown 860103a8feaSLen Brown switch (model) { 861103a8feaSLen Brown case 0x2A: 862103a8feaSLen Brown case 0x2D: 863103a8feaSLen Brown return 1; 864103a8feaSLen Brown } 865103a8feaSLen Brown return 0; 866103a8feaSLen Brown } 867103a8feaSLen Brown 868103a8feaSLen Brown double discover_bclk(unsigned int family, unsigned int model) 869103a8feaSLen Brown { 870103a8feaSLen Brown if (is_snb(family, model)) 871103a8feaSLen Brown return 100.00; 872103a8feaSLen Brown else 873103a8feaSLen Brown return 133.33; 874103a8feaSLen Brown } 875103a8feaSLen Brown 876103a8feaSLen Brown void check_cpuid() 877103a8feaSLen Brown { 878103a8feaSLen Brown unsigned int eax, ebx, ecx, edx, max_level; 879103a8feaSLen Brown unsigned int fms, family, model, stepping; 880103a8feaSLen Brown 881103a8feaSLen Brown eax = ebx = ecx = edx = 0; 882103a8feaSLen Brown 883103a8feaSLen Brown asm("cpuid" : "=a" (max_level), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0)); 884103a8feaSLen Brown 885103a8feaSLen Brown if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e) 886103a8feaSLen Brown genuine_intel = 1; 887103a8feaSLen Brown 888103a8feaSLen Brown if (verbose) 889103a8feaSLen Brown fprintf(stderr, "%.4s%.4s%.4s ", 890103a8feaSLen Brown (char *)&ebx, (char *)&edx, (char *)&ecx); 891103a8feaSLen Brown 892103a8feaSLen Brown asm("cpuid" : "=a" (fms), "=c" (ecx), "=d" (edx) : "a" (1) : "ebx"); 893103a8feaSLen Brown family = (fms >> 8) & 0xf; 894103a8feaSLen Brown model = (fms >> 4) & 0xf; 895103a8feaSLen Brown stepping = fms & 0xf; 896103a8feaSLen Brown if (family == 6 || family == 0xf) 897103a8feaSLen Brown model += ((fms >> 16) & 0xf) << 4; 898103a8feaSLen Brown 899103a8feaSLen Brown if (verbose) 900103a8feaSLen Brown fprintf(stderr, "%d CPUID levels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n", 901103a8feaSLen Brown max_level, family, model, stepping, family, model, stepping); 902103a8feaSLen Brown 903103a8feaSLen Brown if (!(edx & (1 << 5))) { 904103a8feaSLen Brown fprintf(stderr, "CPUID: no MSR\n"); 905103a8feaSLen Brown exit(1); 906103a8feaSLen Brown } 907103a8feaSLen Brown 908103a8feaSLen Brown /* 909103a8feaSLen Brown * check max extended function levels of CPUID. 910103a8feaSLen Brown * This is needed to check for invariant TSC. 911103a8feaSLen Brown * This check is valid for both Intel and AMD. 912103a8feaSLen Brown */ 913103a8feaSLen Brown ebx = ecx = edx = 0; 914103a8feaSLen Brown asm("cpuid" : "=a" (max_level), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0x80000000)); 915103a8feaSLen Brown 916103a8feaSLen Brown if (max_level < 0x80000007) { 917103a8feaSLen Brown fprintf(stderr, "CPUID: no invariant TSC (max_level 0x%x)\n", max_level); 918103a8feaSLen Brown exit(1); 919103a8feaSLen Brown } 920103a8feaSLen Brown 921103a8feaSLen Brown /* 922103a8feaSLen Brown * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8 923103a8feaSLen Brown * this check is valid for both Intel and AMD 924103a8feaSLen Brown */ 925103a8feaSLen Brown asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0x80000007)); 9268209e054SThomas Renninger has_invariant_tsc = edx & (1 << 8); 927103a8feaSLen Brown 928103a8feaSLen Brown if (!has_invariant_tsc) { 929103a8feaSLen Brown fprintf(stderr, "No invariant TSC\n"); 930103a8feaSLen Brown exit(1); 931103a8feaSLen Brown } 932103a8feaSLen Brown 933103a8feaSLen Brown /* 934103a8feaSLen Brown * APERF/MPERF is advertised by CPUID.EAX=0x6: ECX.bit0 935103a8feaSLen Brown * this check is valid for both Intel and AMD 936103a8feaSLen Brown */ 937103a8feaSLen Brown 938103a8feaSLen Brown asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0x6)); 9398209e054SThomas Renninger has_aperf = ecx & (1 << 0); 940103a8feaSLen Brown if (!has_aperf) { 941103a8feaSLen Brown fprintf(stderr, "No APERF MSR\n"); 942103a8feaSLen Brown exit(1); 943103a8feaSLen Brown } 944103a8feaSLen Brown 945103a8feaSLen Brown do_nehalem_platform_info = genuine_intel && has_invariant_tsc; 946103a8feaSLen Brown do_nhm_cstates = genuine_intel; /* all Intel w/ non-stop TSC have NHM counters */ 947103a8feaSLen Brown do_snb_cstates = is_snb(family, model); 948103a8feaSLen Brown bclk = discover_bclk(family, model); 949103a8feaSLen Brown 950103a8feaSLen Brown do_nehalem_turbo_ratio_limit = has_nehalem_turbo_ratio_limit(family, model); 951103a8feaSLen Brown } 952103a8feaSLen Brown 953103a8feaSLen Brown 954103a8feaSLen Brown void usage() 955103a8feaSLen Brown { 956103a8feaSLen Brown fprintf(stderr, "%s: [-v] [-M MSR#] [-i interval_sec | command ...]\n", 957103a8feaSLen Brown progname); 958103a8feaSLen Brown exit(1); 959103a8feaSLen Brown } 960103a8feaSLen Brown 961103a8feaSLen Brown 962103a8feaSLen Brown /* 963103a8feaSLen Brown * in /dev/cpu/ return success for names that are numbers 964103a8feaSLen Brown * ie. filter out ".", "..", "microcode". 965103a8feaSLen Brown */ 966103a8feaSLen Brown int dir_filter(const struct dirent *dirp) 967103a8feaSLen Brown { 968103a8feaSLen Brown if (isdigit(dirp->d_name[0])) 969103a8feaSLen Brown return 1; 970103a8feaSLen Brown else 971103a8feaSLen Brown return 0; 972103a8feaSLen Brown } 973103a8feaSLen Brown 974103a8feaSLen Brown int open_dev_cpu_msr(int dummy1) 975103a8feaSLen Brown { 976103a8feaSLen Brown return 0; 977103a8feaSLen Brown } 978103a8feaSLen Brown 979103a8feaSLen Brown void turbostat_init() 980103a8feaSLen Brown { 981103a8feaSLen Brown check_cpuid(); 982103a8feaSLen Brown 983103a8feaSLen Brown check_dev_msr(); 984103a8feaSLen Brown check_super_user(); 985103a8feaSLen Brown 986a829eb4dSLen Brown num_cpus = for_all_cpus(alloc_new_counters); 987103a8feaSLen Brown 988103a8feaSLen Brown if (verbose) 989103a8feaSLen Brown print_nehalem_info(); 990103a8feaSLen Brown } 991103a8feaSLen Brown 992103a8feaSLen Brown int fork_it(char **argv) 993103a8feaSLen Brown { 994103a8feaSLen Brown int retval; 995103a8feaSLen Brown pid_t child_pid; 996a829eb4dSLen Brown get_counters(cnt_even); 997103a8feaSLen Brown gettimeofday(&tv_even, (struct timezone *)NULL); 998103a8feaSLen Brown 999103a8feaSLen Brown child_pid = fork(); 1000103a8feaSLen Brown if (!child_pid) { 1001103a8feaSLen Brown /* child */ 1002103a8feaSLen Brown execvp(argv[0], argv); 1003103a8feaSLen Brown } else { 1004103a8feaSLen Brown int status; 1005103a8feaSLen Brown 1006103a8feaSLen Brown /* parent */ 1007103a8feaSLen Brown if (child_pid == -1) { 1008103a8feaSLen Brown perror("fork"); 1009103a8feaSLen Brown exit(1); 1010103a8feaSLen Brown } 1011103a8feaSLen Brown 1012103a8feaSLen Brown signal(SIGINT, SIG_IGN); 1013103a8feaSLen Brown signal(SIGQUIT, SIG_IGN); 1014103a8feaSLen Brown if (waitpid(child_pid, &status, 0) == -1) { 1015103a8feaSLen Brown perror("wait"); 1016103a8feaSLen Brown exit(1); 1017103a8feaSLen Brown } 1018103a8feaSLen Brown } 1019a829eb4dSLen Brown get_counters(cnt_odd); 1020103a8feaSLen Brown gettimeofday(&tv_odd, (struct timezone *)NULL); 1021a829eb4dSLen Brown retval = compute_delta(cnt_odd, cnt_even, cnt_delta); 1022103a8feaSLen Brown 1023103a8feaSLen Brown timersub(&tv_odd, &tv_even, &tv_delta); 1024a829eb4dSLen Brown compute_average(cnt_delta, cnt_average); 1025103a8feaSLen Brown if (!retval) 1026a829eb4dSLen Brown print_counters(cnt_delta); 1027103a8feaSLen Brown 10286eab04a8SJustin P. Mattock fprintf(stderr, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0); 1029103a8feaSLen Brown 1030103a8feaSLen Brown return 0; 1031103a8feaSLen Brown } 1032103a8feaSLen Brown 1033103a8feaSLen Brown void cmdline(int argc, char **argv) 1034103a8feaSLen Brown { 1035103a8feaSLen Brown int opt; 1036103a8feaSLen Brown 1037103a8feaSLen Brown progname = argv[0]; 1038103a8feaSLen Brown 1039*e23da037SLen Brown while ((opt = getopt(argc, argv, "+svi:M:")) != -1) { 1040103a8feaSLen Brown switch (opt) { 1041*e23da037SLen Brown case 's': 1042*e23da037SLen Brown summary_only++; 1043*e23da037SLen Brown break; 1044103a8feaSLen Brown case 'v': 1045103a8feaSLen Brown verbose++; 1046103a8feaSLen Brown break; 1047103a8feaSLen Brown case 'i': 1048103a8feaSLen Brown interval_sec = atoi(optarg); 1049103a8feaSLen Brown break; 1050103a8feaSLen Brown case 'M': 1051103a8feaSLen Brown sscanf(optarg, "%x", &extra_msr_offset); 1052103a8feaSLen Brown if (verbose > 1) 1053103a8feaSLen Brown fprintf(stderr, "MSR 0x%X\n", extra_msr_offset); 1054103a8feaSLen Brown break; 1055103a8feaSLen Brown default: 1056103a8feaSLen Brown usage(); 1057103a8feaSLen Brown } 1058103a8feaSLen Brown } 1059103a8feaSLen Brown } 1060103a8feaSLen Brown 1061103a8feaSLen Brown int main(int argc, char **argv) 1062103a8feaSLen Brown { 1063103a8feaSLen Brown cmdline(argc, argv); 1064103a8feaSLen Brown 1065103a8feaSLen Brown if (verbose > 1) 1066103a8feaSLen Brown fprintf(stderr, "turbostat Dec 6, 2010" 1067103a8feaSLen Brown " - Len Brown <lenb@kernel.org>\n"); 1068103a8feaSLen Brown if (verbose > 1) 1069103a8feaSLen Brown fprintf(stderr, "http://userweb.kernel.org/~lenb/acpi/utils/pmtools/turbostat/\n"); 1070103a8feaSLen Brown 1071103a8feaSLen Brown turbostat_init(); 1072103a8feaSLen Brown 1073103a8feaSLen Brown /* 1074103a8feaSLen Brown * if any params left, it must be a command to fork 1075103a8feaSLen Brown */ 1076103a8feaSLen Brown if (argc - optind) 1077103a8feaSLen Brown return fork_it(argv + optind); 1078103a8feaSLen Brown else 1079103a8feaSLen Brown turbostat_loop(); 1080103a8feaSLen Brown 1081103a8feaSLen Brown return 0; 1082103a8feaSLen Brown } 1083