git.samba.org / jlayton / linux.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
tools/power turbostat: initial Gemini Lake SOC support
[jlayton/linux.git] / tools / power / x86 / turbostat / turbostat.c
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 6867557596afcc5f408498faa86e770a6540d712..819d67fbb6ca7571eef62b4d03d8541814734723 100644 (file)
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -55,11 +55,6 @@ unsigned int summary_only;
 unsigned int dump_only;
 unsigned int do_snb_cstates;
 unsigned int do_knl_cstates;
-unsigned int do_pc2;
-unsigned int do_pc3;
-unsigned int do_pc6;
-unsigned int do_pc7;
-unsigned int do_c8_c9_c10;
 unsigned int do_skl_residency;
 unsigned int do_slm_cstates;
 unsigned int use_c1_residency_msr;
@@ -365,6 +360,9 @@ struct msr_counter bic[] = {
        { 0x0, "Pkg%pc3" },
        { 0x0, "Pkg%pc6" },
        { 0x0, "Pkg%pc7" },
+       { 0x0, "Pkg%pc8" },
+       { 0x0, "Pkg%pc9" },
+       { 0x0, "Pkg%pc10" },
        { 0x0, "PkgWatt" },
        { 0x0, "CorWatt" },
        { 0x0, "GFXWatt" },
@@ -403,26 +401,30 @@ struct msr_counter bic[] = {
 #define        BIC_Pkgpc3      (1ULL << 18)
 #define        BIC_Pkgpc6      (1ULL << 19)
 #define        BIC_Pkgpc7      (1ULL << 20)
-#define        BIC_PkgWatt     (1ULL << 21)
-#define        BIC_CorWatt     (1ULL << 22)
-#define        BIC_GFXWatt     (1ULL << 23)
-#define        BIC_PkgCnt      (1ULL << 24)
-#define        BIC_RAMWatt     (1ULL << 27)
-#define        BIC_PKG__       (1ULL << 28)
-#define        BIC_RAM__       (1ULL << 29)
-#define        BIC_Pkg_J       (1ULL << 30)
-#define        BIC_Cor_J       (1ULL << 31)
-#define        BIC_GFX_J       (1ULL << 30)
-#define        BIC_RAM_J       (1ULL << 31)
-#define        BIC_Core        (1ULL << 32)
-#define        BIC_CPU         (1ULL << 33)
-#define        BIC_Mod_c6      (1ULL << 34)
+#define        BIC_Pkgpc8      (1ULL << 21)
+#define        BIC_Pkgpc9      (1ULL << 22)
+#define        BIC_Pkgpc10     (1ULL << 23)
+#define        BIC_PkgWatt     (1ULL << 24)
+#define        BIC_CorWatt     (1ULL << 25)
+#define        BIC_GFXWatt     (1ULL << 26)
+#define        BIC_PkgCnt      (1ULL << 27)
+#define        BIC_RAMWatt     (1ULL << 28)
+#define        BIC_PKG__       (1ULL << 29)
+#define        BIC_RAM__       (1ULL << 30)
+#define        BIC_Pkg_J       (1ULL << 31)
+#define        BIC_Cor_J       (1ULL << 32)
+#define        BIC_GFX_J       (1ULL << 33)
+#define        BIC_RAM_J       (1ULL << 34)
+#define        BIC_Core        (1ULL << 35)
+#define        BIC_CPU         (1ULL << 36)
+#define        BIC_Mod_c6      (1ULL << 37)
 
 unsigned long long bic_enabled = 0xFFFFFFFFFFFFFFFFULL;
 unsigned long long bic_present;
 
 #define DO_BIC(COUNTER_NAME) (bic_enabled & bic_present & COUNTER_NAME)
 #define BIC_PRESENT(COUNTER_BIT) (bic_present |= COUNTER_BIT)
+#define BIC_NOT_PRESENT(COUNTER_BIT) (bic_present &= ~COUNTER_BIT)
 
 /*
  * bic_lookup
@@ -539,19 +541,20 @@ void print_header(void)
                outp += sprintf(outp, "\tCPUGFX%%");
        }
 
-       if (do_pc2)
+       if (DO_BIC(BIC_Pkgpc2))
                outp += sprintf(outp, "\tPkg%%pc2");
-       if (do_pc3)
+       if (DO_BIC(BIC_Pkgpc3))
                outp += sprintf(outp, "\tPkg%%pc3");
-       if (do_pc6)
+       if (DO_BIC(BIC_Pkgpc6))
                outp += sprintf(outp, "\tPkg%%pc6");
-       if (do_pc7)
+       if (DO_BIC(BIC_Pkgpc7))
                outp += sprintf(outp, "\tPkg%%pc7");
-       if (do_c8_c9_c10) {
+       if (DO_BIC(BIC_Pkgpc8))
                outp += sprintf(outp, "\tPkg%%pc8");
+       if (DO_BIC(BIC_Pkgpc9))
                outp += sprintf(outp, "\tPkg%%pc9");
+       if (DO_BIC(BIC_Pkgpc10))
                outp += sprintf(outp, "\tPk%%pc10");
-       }
 
        if (do_rapl && !rapl_joules) {
                if (DO_BIC(BIC_PkgWatt))
@@ -644,11 +647,11 @@ int dump_counters(struct thread_data *t, struct core_data *c,
                outp += sprintf(outp, "CPU + GFX: %016llX\n", p->pkg_both_core_gfxe_c0);
 
                outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
-               if (do_pc3)
+               if (DO_BIC(BIC_Pkgpc3))
                        outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
-               if (do_pc6)
+               if (DO_BIC(BIC_Pkgpc6))
                        outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
-               if (do_pc7)
+               if (DO_BIC(BIC_Pkgpc7))
                        outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
                outp += sprintf(outp, "pc8: %016llX\n", p->pc8);
                outp += sprintf(outp, "pc9: %016llX\n", p->pc9);
@@ -680,7 +683,7 @@ int dump_counters(struct thread_data *t, struct core_data *c,
 int format_counters(struct thread_data *t, struct core_data *c,
        struct pkg_data *p)
 {
-       double interval_float;
+       double interval_float, tsc;
        char *fmt8;
        int i;
        struct msr_counter *mp;
@@ -695,6 +698,8 @@ int format_counters(struct thread_data *t, struct core_data *c,
 
        interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0;
 
+       tsc = t->tsc * tsc_tweak;
+
        /* topo columns, print blanks on 1st (average) line */
        if (t == &average.threads) {
                if (DO_BIC(BIC_Package))
@@ -725,14 +730,14 @@ int format_counters(struct thread_data *t, struct core_data *c,
                        1.0 / units * t->aperf / interval_float);
 
        if (DO_BIC(BIC_Busy))
-               outp += sprintf(outp, "\t%.2f", 100.0 * t->mperf/t->tsc/tsc_tweak);
+               outp += sprintf(outp, "\t%.2f", 100.0 * t->mperf/tsc);
 
        if (DO_BIC(BIC_Bzy_MHz)) {
                if (has_base_hz)
                        outp += sprintf(outp, "\t%.0f", base_hz / units * t->aperf / t->mperf);
                else
                        outp += sprintf(outp, "\t%.0f",
-                               1.0 * t->tsc / units * t->aperf / t->mperf / interval_float);
+                               tsc / units * t->aperf / t->mperf / interval_float);
        }
 
        if (DO_BIC(BIC_TSC_MHz))
@@ -748,7 +753,7 @@ int format_counters(struct thread_data *t, struct core_data *c,
 
        /* C1 */
        if (DO_BIC(BIC_CPU_c1))
-               outp += sprintf(outp, "\t%.2f", 100.0 * t->c1/t->tsc);
+               outp += sprintf(outp, "\t%.2f", 100.0 * t->c1/tsc);
 
        /* Added counters */
        for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
@@ -760,7 +765,7 @@ int format_counters(struct thread_data *t, struct core_data *c,
                } else if (mp->format == FORMAT_DELTA) {
                        outp += sprintf(outp, "\t%lld", t->counter[i]);
                } else if (mp->format == FORMAT_PERCENT) {
-                       outp += sprintf(outp, "\t%.2f", 100.0 * t->counter[i]/t->tsc);
+                       outp += sprintf(outp, "\t%.2f", 100.0 * t->counter[i]/tsc);
                }
        }
 
@@ -769,15 +774,15 @@ int format_counters(struct thread_data *t, struct core_data *c,
                goto done;
 
        if (DO_BIC(BIC_CPU_c3) && !do_slm_cstates && !do_knl_cstates)
-               outp += sprintf(outp, "\t%.2f", 100.0 * c->c3/t->tsc);
+               outp += sprintf(outp, "\t%.2f", 100.0 * c->c3/tsc);
        if (DO_BIC(BIC_CPU_c6))
-               outp += sprintf(outp, "\t%.2f", 100.0 * c->c6/t->tsc);
+               outp += sprintf(outp, "\t%.2f", 100.0 * c->c6/tsc);
        if (DO_BIC(BIC_CPU_c7))
-               outp += sprintf(outp, "\t%.2f", 100.0 * c->c7/t->tsc);
+               outp += sprintf(outp, "\t%.2f", 100.0 * c->c7/tsc);
 
        /* Mod%c6 */
        if (DO_BIC(BIC_Mod_c6))
-               outp += sprintf(outp, "\t%.2f", 100.0 * c->mc6_us / t->tsc);
+               outp += sprintf(outp, "\t%.2f", 100.0 * c->mc6_us / tsc);
 
        if (DO_BIC(BIC_CoreTmp))
                outp += sprintf(outp, "\t%d", c->core_temp_c);
@@ -791,7 +796,7 @@ int format_counters(struct thread_data *t, struct core_data *c,
                } else if (mp->format == FORMAT_DELTA) {
                        outp += sprintf(outp, "\t%lld", c->counter[i]);
                } else if (mp->format == FORMAT_PERCENT) {
-                       outp += sprintf(outp, "\t%.2f", 100.0 * c->counter[i]/t->tsc);
+                       outp += sprintf(outp, "\t%.2f", 100.0 * c->counter[i]/tsc);
                }
        }
 
@@ -819,25 +824,26 @@ int format_counters(struct thread_data *t, struct core_data *c,
 
        /* Totl%C0, Any%C0 GFX%C0 CPUGFX% */
        if (do_skl_residency) {
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_wtd_core_c0/t->tsc);
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_core_c0/t->tsc);
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_gfxe_c0/t->tsc);
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_both_core_gfxe_c0/t->tsc);
-       }
-
-       if (do_pc2)
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc2/t->tsc);
-       if (do_pc3)
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc3/t->tsc);
-       if (do_pc6)
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc6/t->tsc);
-       if (do_pc7)
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc7/t->tsc);
-       if (do_c8_c9_c10) {
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc8/t->tsc);
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc9/t->tsc);
-               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc10/t->tsc);
-       }
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_wtd_core_c0/tsc);
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_core_c0/tsc);
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_any_gfxe_c0/tsc);
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pkg_both_core_gfxe_c0/tsc);
+       }
+
+       if (DO_BIC(BIC_Pkgpc2))
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc2/tsc);
+       if (DO_BIC(BIC_Pkgpc3))
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc3/tsc);
+       if (DO_BIC(BIC_Pkgpc6))
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc6/tsc);
+       if (DO_BIC(BIC_Pkgpc7))
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc7/tsc);
+       if (DO_BIC(BIC_Pkgpc8))
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc8/tsc);
+       if (DO_BIC(BIC_Pkgpc9))
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc9/tsc);
+       if (DO_BIC(BIC_Pkgpc10))
+               outp += sprintf(outp, "\t%.2f", 100.0 * p->pc10/tsc);
 
        /*
         * If measurement interval exceeds minimum RAPL Joule Counter range,
@@ -878,7 +884,7 @@ int format_counters(struct thread_data *t, struct core_data *c,
                } else if (mp->format == FORMAT_DELTA) {
                        outp += sprintf(outp, "\t%lld", p->counter[i]);
                } else if (mp->format == FORMAT_PERCENT) {
-                       outp += sprintf(outp, "\t%.2f", 100.0 * p->counter[i]/t->tsc);
+                       outp += sprintf(outp, "\t%.2f", 100.0 * p->counter[i]/tsc);
                }
        }
 
@@ -947,11 +953,11 @@ delta_package(struct pkg_data *new, struct pkg_data *old)
                old->pkg_both_core_gfxe_c0 = new->pkg_both_core_gfxe_c0 - old->pkg_both_core_gfxe_c0;
        }
        old->pc2 = new->pc2 - old->pc2;
-       if (do_pc3)
+       if (DO_BIC(BIC_Pkgpc3))
                old->pc3 = new->pc3 - old->pc3;
-       if (do_pc6)
+       if (DO_BIC(BIC_Pkgpc6))
                old->pc6 = new->pc6 - old->pc6;
-       if (do_pc7)
+       if (DO_BIC(BIC_Pkgpc7))
                old->pc7 = new->pc7 - old->pc7;
        old->pc8 = new->pc8 - old->pc8;
        old->pc9 = new->pc9 - old->pc9;
@@ -1048,7 +1054,7 @@ delta_thread(struct thread_data *new, struct thread_data *old,
                        old->c1 = 0;
                else {
                        /* normal case, derive c1 */
-                       old->c1 = old->tsc - old->mperf - core_delta->c3
+                       old->c1 = (old->tsc * tsc_tweak) - old->mperf - core_delta->c3
                                - core_delta->c6 - core_delta->c7;
                }
        }
@@ -1124,11 +1130,11 @@ void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data
        p->pkg_both_core_gfxe_c0 = 0;
 
        p->pc2 = 0;
-       if (do_pc3)
+       if (DO_BIC(BIC_Pkgpc3))
                p->pc3 = 0;
-       if (do_pc6)
+       if (DO_BIC(BIC_Pkgpc6))
                p->pc6 = 0;
-       if (do_pc7)
+       if (DO_BIC(BIC_Pkgpc7))
                p->pc7 = 0;
        p->pc8 = 0;
        p->pc9 = 0;
@@ -1202,11 +1208,11 @@ int sum_counters(struct thread_data *t, struct core_data *c,
        }
 
        average.packages.pc2 += p->pc2;
-       if (do_pc3)
+       if (DO_BIC(BIC_Pkgpc3))
                average.packages.pc3 += p->pc3;
-       if (do_pc6)
+       if (DO_BIC(BIC_Pkgpc6))
                average.packages.pc6 += p->pc6;
-       if (do_pc7)
+       if (DO_BIC(BIC_Pkgpc7))
                average.packages.pc7 += p->pc7;
        average.packages.pc8 += p->pc8;
        average.packages.pc9 += p->pc9;
@@ -1264,11 +1270,11 @@ void compute_average(struct thread_data *t, struct core_data *c,
        }
 
        average.packages.pc2 /= topo.num_packages;
-       if (do_pc3)
+       if (DO_BIC(BIC_Pkgpc3))
                average.packages.pc3 /= topo.num_packages;
-       if (do_pc6)
+       if (DO_BIC(BIC_Pkgpc6))
                average.packages.pc6 /= topo.num_packages;
-       if (do_pc7)
+       if (DO_BIC(BIC_Pkgpc7))
                average.packages.pc7 /= topo.num_packages;
 
        average.packages.pc8 /= topo.num_packages;
@@ -1446,10 +1452,10 @@ retry:
                if (get_msr(cpu, MSR_PKG_BOTH_CORE_GFXE_C0_RES, &p->pkg_both_core_gfxe_c0))
                        return -13;
        }
-       if (do_pc3)
+       if (DO_BIC(BIC_Pkgpc3))
                if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
                        return -9;
-       if (do_pc6) {
+       if (DO_BIC(BIC_Pkgpc6)) {
                if (do_slm_cstates) {
                        if (get_msr(cpu, MSR_ATOM_PKG_C6_RESIDENCY, &p->pc6))
                                return -10;
@@ -1459,20 +1465,22 @@ retry:
                }
        }
 
-       if (do_pc2)
+       if (DO_BIC(BIC_Pkgpc2))
                if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
                        return -11;
-       if (do_pc7)
+       if (DO_BIC(BIC_Pkgpc7))
                if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
                        return -12;
-       if (do_c8_c9_c10) {
+       if (DO_BIC(BIC_Pkgpc8))
                if (get_msr(cpu, MSR_PKG_C8_RESIDENCY, &p->pc8))
                        return -13;
+       if (DO_BIC(BIC_Pkgpc9))
                if (get_msr(cpu, MSR_PKG_C9_RESIDENCY, &p->pc9))
                        return -13;
+       if (DO_BIC(BIC_Pkgpc10))
                if (get_msr(cpu, MSR_PKG_C10_RESIDENCY, &p->pc10))
                        return -13;
-       }
+
        if (do_rapl & RAPL_PKG) {
                if (get_msr(cpu, MSR_PKG_ENERGY_STATUS, &msr))
                        return -13;
@@ -2527,6 +2535,7 @@ int probe_nhm_msrs(unsigned int family, unsigned int model)
                pkg_cstate_limits = phi_pkg_cstate_limits;
                break;
        case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
+       case INTEL_FAM6_ATOM_GEMINI_LAKE:
        case INTEL_FAM6_ATOM_DENVERTON: /* DNV */
                pkg_cstate_limits = bxt_pkg_cstate_limits;
                break;
@@ -3010,6 +3019,7 @@ void rapl_probe(unsigned int family, unsigned int model)
                }
                break;
        case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
+       case INTEL_FAM6_ATOM_GEMINI_LAKE:
                do_rapl = RAPL_PKG | RAPL_PKG_POWER_INFO;
                if (rapl_joules)
                        BIC_PRESENT(BIC_Pkg_J);
@@ -3353,6 +3363,7 @@ int has_snb_msrs(unsigned int family, unsigned int model)
        case INTEL_FAM6_KABYLAKE_DESKTOP:       /* KBL */
        case INTEL_FAM6_SKYLAKE_X:      /* SKX */
        case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
+       case INTEL_FAM6_ATOM_GEMINI_LAKE:
        case INTEL_FAM6_ATOM_DENVERTON: /* DNV */
                return 1;
        }
@@ -3384,6 +3395,7 @@ int has_hsw_msrs(unsigned int family, unsigned int model)
        case INTEL_FAM6_KABYLAKE_MOBILE:        /* KBL */
        case INTEL_FAM6_KABYLAKE_DESKTOP:       /* KBL */
        case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
+       case INTEL_FAM6_ATOM_GEMINI_LAKE:
                return 1;
        }
        return 0;
@@ -3775,6 +3787,7 @@ void process_cpuid()
                                        crystal_hz = 25000000;  /* 25.0 MHz */
                                        break;
                                case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
+                               case INTEL_FAM6_ATOM_GEMINI_LAKE:
                                        crystal_hz = 19200000;  /* 19.2 MHz */
                                        break;
                                default:
@@ -3822,17 +3835,27 @@ void process_cpuid()
                BIC_PRESENT(BIC_CPU_c7);
 
        do_irtl_snb = has_snb_msrs(family, model);
-       do_pc2 = do_snb_cstates && (pkg_cstate_limit >= PCL__2);
-       do_pc3 = (pkg_cstate_limit >= PCL__3);
-       do_pc6 = (pkg_cstate_limit >= PCL__6);
-       do_pc7 = do_snb_cstates && (pkg_cstate_limit >= PCL__7);
+       if (do_snb_cstates && (pkg_cstate_limit >= PCL__2))
+               BIC_PRESENT(BIC_Pkgpc2);
+       if (pkg_cstate_limit >= PCL__3)
+               BIC_PRESENT(BIC_Pkgpc3);
+       if (pkg_cstate_limit >= PCL__6)
+               BIC_PRESENT(BIC_Pkgpc6);
+       if (do_snb_cstates && (pkg_cstate_limit >= PCL__7))
+               BIC_PRESENT(BIC_Pkgpc7);
        if (has_slv_msrs(family, model)) {
-               do_pc2 = do_pc3 = do_pc7 = 0;
-               do_pc6 = 1;
+               BIC_NOT_PRESENT(BIC_Pkgpc2);
+               BIC_NOT_PRESENT(BIC_Pkgpc3);
+               BIC_PRESENT(BIC_Pkgpc6);
+               BIC_NOT_PRESENT(BIC_Pkgpc7);
                BIC_PRESENT(BIC_Mod_c6);
                use_c1_residency_msr = 1;
        }
-       do_c8_c9_c10 = has_hsw_msrs(family, model);
+       if (has_hsw_msrs(family, model)) {
+               BIC_PRESENT(BIC_Pkgpc8);
+               BIC_PRESENT(BIC_Pkgpc9);
+               BIC_PRESENT(BIC_Pkgpc10);
+       }
        do_irtl_hsw = has_hsw_msrs(family, model);
        do_skl_residency = has_skl_msrs(family, model);
        do_slm_cstates = is_slm(family, model);
@@ -3979,7 +4002,7 @@ void topology_probe()
        if (debug > 1)
                fprintf(outf, "max_core_id %d, sizing for %d cores per package\n",
                        max_core_id, topo.num_cores_per_pkg);
-       if (debug && !summary_only && topo.num_cores_per_pkg > 1)
+       if (!summary_only && topo.num_cores_per_pkg > 1)
                BIC_PRESENT(BIC_Core);
 
        topo.num_packages = max_package_id + 1;
@@ -4280,7 +4303,7 @@ int add_counter(unsigned int msr_num, char *name, unsigned int width,
 void parse_add_command(char *add_command)
 {
        int msr_num = 0;
-       char name_buffer[NAME_BYTES];
+       char name_buffer[NAME_BYTES] = "";
        int width = 64;
        int fail = 0;
        enum counter_scope scope = SCOPE_CPU;
Jeff Layton's Linux Kernel Tree