Lines Matching +full:gpu +full:- +full:top +full:- +full:thermal
1 // SPDX-License-Identifier: GPL-2.0-only
3 * turbostat -- show CPU frequency and C-state residency
19 #define VFM_MODEL_MASK GENMASK(VFM_FAMILY_BIT - 1, VFM_MODEL_BIT)
20 #define VFM_FAMILY_MASK GENMASK(VFM_VENDOR_BIT - 1, VFM_FAMILY_BIT)
21 #define VFM_VENDOR_MASK GENMASK(VFM_RSVD_BIT - 1, VFM_VENDOR_BIT)
76 * 1. built-in only, the sysfs counters are not here -- we learn of those at run-time
78 * matching on them for --show and --hide.
83 * Usually truncated to 7 characters, but also handles 18 columns for raw 64-bit counters
99 #define ROUND_UP_TO_PAGE_SIZE(n) (((n) + 0x1000UL-1UL) & ~(0x1000UL-1UL))
582 bool has_per_core_rapl; /* Indicates cores energy collection is per-core, not per-package. AMD specific for now */
1002 .has_msr_module_c6_res_ms = 1, /* DMR has Dual-Core-Module and MC6 MSR */
1285 /* MSRs that are not yet in the kernel-provided header. */
1366 .perf_name = "energy-pkg",
1379 .perf_name = "energy-pkg",
1392 .perf_name = "energy-pkg",
1405 .perf_name = "energy-pkg",
1418 .perf_name = "energy-cores",
1431 .perf_name = "energy-cores",
1444 .perf_name = "energy-ram",
1457 .perf_name = "energy-ram",
1470 .perf_name = "energy-gpu",
1483 .perf_name = "energy-gpu",
1548 .perf_name = "energy-psys",
1561 .perf_name = "energy-psys",
1625 .perf_name = "c1-residency",
1635 .perf_name = "c3-residency",
1645 .perf_name = "c6-residency",
1655 .perf_name = "c7-residency",
1665 .perf_name = "c2-residency",
1675 .perf_name = "c3-residency",
1685 .perf_name = "c6-residency",
1695 .perf_name = "c7-residency",
1705 .perf_name = "c8-residency",
1715 .perf_name = "c9-residency",
1725 .perf_name = "c10-residency",
1861 /* BIC-like metadata */
1883 return sscanf(e->d_name, "telem%u", &dummy);
1890 sscanf((*a)->d_name, "telem%u", &aidx);
1891 sscanf((*b)->d_name, "telem%u", &bidx);
1893 return (aidx > bidx) ? 1 : (aidx < bidx) ? -1 : 0;
1900 if (!iter->dir)
1903 if (iter->current_name_idx >= iter->num_names)
1906 ret = iter->namelist[iter->current_name_idx];
1907 ++iter->current_name_idx;
1914 int num_names = iter->num_names;
1916 if (!iter->dir) {
1917 iter->dir = opendir(pmt_root_path);
1918 if (iter->dir == NULL)
1921 num_names = scandir(pmt_root_path, &iter->namelist, pmt_telemdir_filter, pmt_telemdir_sort);
1922 if (num_names == -1)
1926 iter->current_name_idx = 0;
1927 iter->num_names = num_names;
1939 if (iter->namelist) {
1940 for (unsigned int i = 0; i < iter->num_names; i++) {
1941 free(iter->namelist[i]);
1942 iter->namelist[i] = NULL;
1946 free(iter->namelist);
1947 iter->namelist = NULL;
1948 iter->num_names = 0;
1949 iter->current_name_idx = 0;
1951 closedir(iter->dir);
1952 iter->dir = NULL;
1957 return (p->msb - p->lsb) + 1;
1964 new_mem = (struct pmt_domain_info *)reallocarray(pcounter->domains, new_size, sizeof(*pcounter->domains));
1971 const size_t num_new_domains = new_size - pcounter->num_domains;
1973 memset(&new_mem[pcounter->num_domains], 0, num_new_domains * sizeof(*pcounter->domains));
1975 pcounter->num_domains = new_size;
1976 pcounter->domains = new_mem;
1989 new_size = MAX(new_size, pcounter->num_domains * 2);
2021 unsigned long long mc6_us; /* duplicate as per-core for now, even though per module */
2103 /* get_msr_sum() = sum + (get_msr() - last) */
2121 if (platform->rapl_msrs & RAPL_AMD_F17H)
2145 offset = -1;
2178 idx = -1;
2187 return platform->rapl_msrs & (RAPL_PKG | RAPL_AMD_F17H);
2189 return platform->rapl_msrs & RAPL_DRAM;
2191 return platform->rapl_msrs & RAPL_CORE_ENERGY_STATUS;
2193 return platform->rapl_msrs & RAPL_GFX;
2195 return platform->rapl_msrs & RAPL_PKG_PERF_STATUS;
2197 return platform->rapl_msrs & RAPL_DRAM_PERF_STATUS;
2199 return platform->rapl_msrs & RAPL_PSYS;
2235 if (p->msr_num != 0) {
2236 *pp = p->next;
2244 pp = &p->next;
2256 sys.added_thread_counters -= free_msr_counters_(&sys.tp);
2259 sys.added_core_counters -= free_msr_counters_(&sys.cp);
2262 sys.added_package_counters -= free_msr_counters_(&sys.pp);
2281 int logical_node_id; /* 0-based count within the package */
2331 * skip non-present cpus
2352 if (cpu_is_not_allowed(t->cpu_id))
2369 return ((int)t->cpu_id == c->base_cpu || c->base_cpu < 0);
2376 return ((int)t->cpu_id == p->base_cpu || p->base_cpu < 0);
2388 if (sched_setaffinity(0, cpu_affinity_setsize, cpu_affinity_set) == -1)
2389 return -1;
2411 err(-1, "%s open failed, try chown or chmod +r /dev/msr*, "
2412 "or run with --no-msr, or run as root", pathname);
2414 err(-1, "%s open failed, try chown or chmod +r /dev/cpu/*/msr, "
2415 "or run with --no-msr, or run as root", pathname);
2445 const pid_t pid = -1;
2469 fd_instr_count_percpu[cpu] = open_perf_counter(cpu, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS, -1, 0);
2483 err(-1, "cpu%d: msr offset 0x%llx read failed", cpu, (unsigned long long)offset);
2494 return -1;
2497 return -1;
2503 return -1;
2515 if (!(platform->rapl_msrs & cai->feature_mask))
2516 return -1;
2518 ret = add_msr_counter(cpu, cai->msr);
2520 return -1;
2522 switch (cai->rci_index) {
2539 switch (pc->scope) {
2562 * HIDE_LIST - hide this list of counters, show the rest [default]
2563 * SHOW_LIST - show this list of counters, hide the rest
2570 "Usage: turbostat [OPTIONS][(--interval seconds) | COMMAND ...]\n"
2574 "If no COMMAND is specified, turbostat wakes every 5-seconds\n"
2576 " -a, --add counter\n"
2578 " eg. --add msr0x10,u64,cpu,delta,MY_TSC\n"
2579 " eg. --add perf/cstate_pkg/c2-residency,package,delta,percent,perfPC2\n"
2580 " eg. --add pmt,name=XTAL,type=raw,domain=package0,offset=0,lsb=0,msb=63,guid=0x1a067102\n"
2581 " -c, --cpu cpu-set\n"
2582 " limit output to summary plus cpu-set:\n"
2583 " {core | package | j,k,l..m,n-p }\n"
2584 " -d, --debug\n"
2587 " -D, --Dump\n"
2589 " -e, --enable [all | column]\n"
2591 " -f, --force\n"
2593 " -H, --hide [column | column,column,...]\n"
2595 " -i, --interval sec.subsec\n"
2596 " override default 5-second measurement interval\n"
2597 " -J, --Joules\n"
2599 " -l, --list\n"
2601 " -M, --no-msr\n"
2603 " -P, --no-perf\n"
2605 " -n, --num_iterations num\n"
2607 " -N, --header_iterations num\n"
2609 " -o, --out file\n"
2611 " -q, --quiet\n"
2613 " -s, --show [column | column,column,...]\n"
2615 " -S, --Summary\n"
2616 " limits output to 1-line system summary per interval\n"
2617 " -T, --TCC temperature\n"
2618 " sets the Thermal Control Circuit temperature in\n"
2620 " -h, --help\n"
2622 " -v, --version\n\t\tprint version information\n\nFor more help, run \"man turbostat\"\n");
2680 fprintf(stderr, "More than max %d un-recognized --add options '%s'\n",
2690 fprintf(stderr, "More than max %d un-recognized --skip options '%s'\n",
2760 for (mp = sys.tp; mp; mp = mp->next) {
2762 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE) {
2763 if (mp->width == 64)
2764 outp += sprintf(outp, "%s%18.18s", (printed++ ? delim : ""), mp->name);
2766 outp += sprintf(outp, "%s%10.10s", (printed++ ? delim : ""), mp->name);
2768 if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
2769 outp += sprintf(outp, "%s%8s", (printed++ ? delim : ""), mp->name);
2771 outp += sprintf(outp, "%s%s", (printed++ ? delim : ""), mp->name);
2775 for (pp = sys.perf_tp; pp; pp = pp->next) {
2777 if (pp->format == FORMAT_RAW) {
2778 if (pp->width == 64)
2779 outp += sprintf(outp, "%s%18.18s", (printed++ ? delim : ""), pp->name);
2781 outp += sprintf(outp, "%s%10.10s", (printed++ ? delim : ""), pp->name);
2783 if ((pp->type == COUNTER_ITEMS) && sums_need_wide_columns)
2784 outp += sprintf(outp, "%s%8s", (printed++ ? delim : ""), pp->name);
2786 outp += sprintf(outp, "%s%s", (printed++ ? delim : ""), pp->name);
2792 switch (ppmt->type) {
2795 outp += sprintf(outp, "%s%10.10s", (printed++ ? delim : ""), ppmt->name);
2797 outp += sprintf(outp, "%s%18.18s", (printed++ ? delim : ""), ppmt->name);
2803 outp += sprintf(outp, "%s%s", (printed++ ? delim : ""), ppmt->name);
2807 ppmt = ppmt->next;
2828 if (platform->rapl_msrs && !rapl_joules) {
2829 if (DO_BIC(BIC_CorWatt) && platform->has_per_core_rapl)
2831 } else if (platform->rapl_msrs && rapl_joules) {
2832 if (DO_BIC(BIC_Cor_J) && platform->has_per_core_rapl)
2836 for (mp = sys.cp; mp; mp = mp->next) {
2837 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE) {
2838 if (mp->width == 64)
2839 outp += sprintf(outp, "%s%18.18s", delim, mp->name);
2841 outp += sprintf(outp, "%s%10.10s", delim, mp->name);
2843 if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
2844 outp += sprintf(outp, "%s%8s", delim, mp->name);
2846 outp += sprintf(outp, "%s%s", delim, mp->name);
2850 for (pp = sys.perf_cp; pp; pp = pp->next) {
2852 if (pp->format == FORMAT_RAW) {
2853 if (pp->width == 64)
2854 outp += sprintf(outp, "%s%18.18s", (printed++ ? delim : ""), pp->name);
2856 outp += sprintf(outp, "%s%10.10s", (printed++ ? delim : ""), pp->name);
2858 if ((pp->type == COUNTER_ITEMS) && sums_need_wide_columns)
2859 outp += sprintf(outp, "%s%8s", (printed++ ? delim : ""), pp->name);
2861 outp += sprintf(outp, "%s%s", (printed++ ? delim : ""), pp->name);
2867 switch (ppmt->type) {
2870 outp += sprintf(outp, "%s%10.10s", (printed++ ? delim : ""), ppmt->name);
2872 outp += sprintf(outp, "%s%18.18s", (printed++ ? delim : ""), ppmt->name);
2878 outp += sprintf(outp, "%s%s", (printed++ ? delim : ""), ppmt->name);
2882 ppmt = ppmt->next;
2939 if (DO_BIC(BIC_CorWatt) && !platform->has_per_core_rapl)
2952 if (DO_BIC(BIC_Cor_J) && !platform->has_per_core_rapl)
2966 for (mp = sys.pp; mp; mp = mp->next) {
2967 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE) {
2968 if (mp->width == 64)
2969 outp += sprintf(outp, "%s%18.18s", delim, mp->name);
2970 else if (mp->width == 32)
2971 outp += sprintf(outp, "%s%10.10s", delim, mp->name);
2973 outp += sprintf(outp, "%s%7.7s", delim, mp->name);
2975 if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
2976 outp += sprintf(outp, "%s%8s", delim, mp->name);
2978 outp += sprintf(outp, "%s%7.7s", delim, mp->name);
2982 for (pp = sys.perf_pp; pp; pp = pp->next) {
2984 if (pp->format == FORMAT_RAW) {
2985 if (pp->width == 64)
2986 outp += sprintf(outp, "%s%18.18s", (printed++ ? delim : ""), pp->name);
2988 outp += sprintf(outp, "%s%10.10s", (printed++ ? delim : ""), pp->name);
2990 if ((pp->type == COUNTER_ITEMS) && sums_need_wide_columns)
2991 outp += sprintf(outp, "%s%8s", (printed++ ? delim : ""), pp->name);
2993 outp += sprintf(outp, "%s%s", (printed++ ? delim : ""), pp->name);
2999 switch (ppmt->type) {
3002 outp += sprintf(outp, "%s%10.10s", (printed++ ? delim : ""), ppmt->name);
3004 outp += sprintf(outp, "%s%18.18s", (printed++ ? delim : ""), ppmt->name);
3010 outp += sprintf(outp, "%s%s", (printed++ ? delim : ""), ppmt->name);
3014 ppmt = ppmt->next;
3034 outp += sprintf(outp, "CPU: %d flags 0x%x\n", t->cpu_id, t->flags);
3035 outp += sprintf(outp, "TSC: %016llX\n", t->tsc);
3036 outp += sprintf(outp, "aperf: %016llX\n", t->aperf);
3037 outp += sprintf(outp, "mperf: %016llX\n", t->mperf);
3038 outp += sprintf(outp, "c1: %016llX\n", t->c1);
3041 outp += sprintf(outp, "IPC: %lld\n", t->instr_count);
3044 outp += sprintf(outp, "IRQ: %lld\n", t->irq_count);
3046 outp += sprintf(outp, "IRQ: %lld\n", t->nmi_count);
3048 outp += sprintf(outp, "SMI: %d\n", t->smi_count);
3050 for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
3052 sprintf(outp, "tADDED [%d] %8s msr0x%x: %08llX %s\n", i, mp->name, mp->msr_num,
3053 t->counter[i], mp->sp->path);
3058 outp += sprintf(outp, "core: %d\n", c->core_id);
3059 outp += sprintf(outp, "c3: %016llX\n", c->c3);
3060 outp += sprintf(outp, "c6: %016llX\n", c->c6);
3061 outp += sprintf(outp, "c7: %016llX\n", c->c7);
3062 outp += sprintf(outp, "DTS: %dC\n", c->core_temp_c);
3063 outp += sprintf(outp, "cpu_throt_count: %016llX\n", c->core_throt_cnt);
3065 const unsigned long long energy_value = c->core_energy.raw_value * c->core_energy.scale;
3066 const double energy_scale = c->core_energy.scale;
3068 if (c->core_energy.unit == RAPL_UNIT_JOULES)
3071 for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
3073 sprintf(outp, "cADDED [%d] %8s msr0x%x: %08llX %s\n", i, mp->name, mp->msr_num,
3074 c->counter[i], mp->sp->path);
3076 outp += sprintf(outp, "mc6_us: %016llX\n", c->mc6_us);
3080 outp += sprintf(outp, "package: %d\n", p->package_id);
3082 outp += sprintf(outp, "Weighted cores: %016llX\n", p->pkg_wtd_core_c0);
3083 outp += sprintf(outp, "Any cores: %016llX\n", p->pkg_any_core_c0);
3084 outp += sprintf(outp, "Any GFX: %016llX\n", p->pkg_any_gfxe_c0);
3085 outp += sprintf(outp, "CPU + GFX: %016llX\n", p->pkg_both_core_gfxe_c0);
3087 outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
3089 outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
3091 outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
3093 outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
3094 outp += sprintf(outp, "pc8: %016llX\n", p->pc8);
3095 outp += sprintf(outp, "pc9: %016llX\n", p->pc9);
3096 outp += sprintf(outp, "pc10: %016llX\n", p->pc10);
3097 outp += sprintf(outp, "cpu_lpi: %016llX\n", p->cpu_lpi);
3098 outp += sprintf(outp, "sys_lpi: %016llX\n", p->sys_lpi);
3099 outp += sprintf(outp, "Joules PKG: %0llX\n", p->energy_pkg.raw_value);
3100 outp += sprintf(outp, "Joules COR: %0llX\n", p->energy_cores.raw_value);
3101 outp += sprintf(outp, "Joules GFX: %0llX\n", p->energy_gfx.raw_value);
3102 outp += sprintf(outp, "Joules RAM: %0llX\n", p->energy_dram.raw_value);
3103 outp += sprintf(outp, "Joules PSYS: %0llX\n", pplat_cnt->energy_psys.raw_value);
3104 outp += sprintf(outp, "Throttle PKG: %0llX\n", p->rapl_pkg_perf_status.raw_value);
3105 outp += sprintf(outp, "Throttle RAM: %0llX\n", p->rapl_dram_perf_status.raw_value);
3106 outp += sprintf(outp, "PTM: %dC\n", p->pkg_temp_c);
3108 for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
3110 sprintf(outp, "pADDED [%d] %8s msr0x%x: %08llX %s\n", i, mp->name, mp->msr_num,
3111 p->counter[i], mp->sp->path);
3128 assert(c->unit == RAPL_UNIT_JOULES);
3130 const double scaled = c->raw_value * c->scale;
3167 /*if not summary line and --cpu is used */
3168 if ((t != &average.threads) && (cpu_subset && !CPU_ISSET_S(t->cpu_id, cpu_subset_size, cpu_subset)))
3175 timersub(&t->tv_end, &t->tv_begin, &tv);
3181 outp += sprintf(outp, "%10ld.%06ld\t", t->tv_end.tv_sec, t->tv_end.tv_usec);
3183 interval_float = t->tv_delta.tv_sec + t->tv_delta.tv_usec / 1000000.0;
3185 tsc = t->tsc * tsc_tweak;
3190 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3192 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3194 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3196 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3198 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3200 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3202 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3204 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3208 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->package_id);
3210 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3214 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), cpus[t->cpu_id].die_id);
3216 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3220 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), cpus[t->cpu_id].l3_id);
3222 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3227 (printed++ ? delim : ""), cpus[t->cpu_id].physical_node_id);
3229 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3233 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), c->core_id);
3235 outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
3238 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), t->cpu_id);
3240 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), t->apic_id);
3242 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), t->x2apic_id);
3246 outp += sprintf(outp, "%s%.0f", (printed++ ? delim : ""), 1.0 / units * t->aperf / interval_float);
3249 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * t->mperf / tsc);
3254 sprintf(outp, "%s%.0f", (printed++ ? delim : ""), base_hz / units * t->aperf / t->mperf);
3257 tsc / units * t->aperf / t->mperf / interval_float);
3261 outp += sprintf(outp, "%s%.0f", (printed++ ? delim : ""), 1.0 * t->tsc / units / interval_float);
3264 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 1.0 * t->instr_count / t->aperf);
3269 outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), t->irq_count);
3271 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), t->irq_count);
3277 outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), t->nmi_count);
3279 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), t->nmi_count);
3284 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), t->smi_count);
3287 for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
3288 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE) {
3289 if (mp->width == 32)
3291 sprintf(outp, "%s0x%08x", (printed++ ? delim : ""), (unsigned int)t->counter[i]);
3293 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), t->counter[i]);
3294 } else if (mp->format == FORMAT_DELTA) {
3295 if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
3296 outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), t->counter[i]);
3298 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), t->counter[i]);
3299 } else if (mp->format == FORMAT_PERCENT) {
3300 if (mp->type == COUNTER_USEC)
3303 t->counter[i] / interval_float / 10000);
3305 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * t->counter[i] / tsc);
3310 for (i = 0, pp = sys.perf_tp; pp; ++i, pp = pp->next) {
3311 if (pp->format == FORMAT_RAW) {
3312 if (pp->width == 32)
3315 (unsigned int)t->perf_counter[i]);
3317 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), t->perf_counter[i]);
3318 } else if (pp->format == FORMAT_DELTA) {
3319 if ((pp->type == COUNTER_ITEMS) && sums_need_wide_columns)
3320 outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), t->perf_counter[i]);
3322 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), t->perf_counter[i]);
3323 } else if (pp->format == FORMAT_PERCENT) {
3324 if (pp->type == COUNTER_USEC)
3327 t->perf_counter[i] / interval_float / 10000);
3330 sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * t->perf_counter[i] / tsc);
3334 for (i = 0, ppmt = sys.pmt_tp; ppmt; i++, ppmt = ppmt->next) {
3335 const unsigned long value_raw = t->pmt_counter[i];
3337 switch (ppmt->type) {
3341 (unsigned int)t->pmt_counter[i]);
3343 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), t->pmt_counter[i]);
3360 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * t->c1 / tsc);
3362 /* print per-core data only for 1st thread in core */
3367 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->c3 / tsc);
3369 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->c6 / tsc);
3371 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->c7 / tsc);
3375 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->mc6_us / tsc);
3378 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), c->core_temp_c);
3382 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), c->core_throt_cnt);
3384 for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
3385 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE) {
3386 if (mp->width == 32)
3388 sprintf(outp, "%s0x%08x", (printed++ ? delim : ""), (unsigned int)c->counter[i]);
3390 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), c->counter[i]);
3391 } else if (mp->format == FORMAT_DELTA) {
3392 if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
3393 outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), c->counter[i]);
3395 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), c->counter[i]);
3396 } else if (mp->format == FORMAT_PERCENT) {
3397 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->counter[i] / tsc);
3401 for (i = 0, pp = sys.perf_cp; pp; i++, pp = pp->next) {
3402 if (pp->format == FORMAT_RAW) {
3403 if (pp->width == 32)
3406 (unsigned int)c->perf_counter[i]);
3408 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), c->perf_counter[i]);
3409 } else if (pp->format == FORMAT_DELTA) {
3410 if ((pp->type == COUNTER_ITEMS) && sums_need_wide_columns)
3411 outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), c->perf_counter[i]);
3413 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), c->perf_counter[i]);
3414 } else if (pp->format == FORMAT_PERCENT) {
3415 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->perf_counter[i] / tsc);
3419 for (i = 0, ppmt = sys.pmt_cp; ppmt; i++, ppmt = ppmt->next) {
3420 const unsigned long value_raw = c->pmt_counter[i];
3422 switch (ppmt->type) {
3426 (unsigned int)c->pmt_counter[i]);
3428 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), c->pmt_counter[i]);
3445 if (DO_BIC(BIC_CorWatt) && platform->has_per_core_rapl)
3448 rapl_counter_get_value(&c->core_energy, RAPL_UNIT_WATTS, interval_float));
3449 if (DO_BIC(BIC_Cor_J) && platform->has_per_core_rapl)
3451 rapl_counter_get_value(&c->core_energy, RAPL_UNIT_JOULES, interval_float));
3453 /* print per-package data only for 1st core in package */
3459 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->pkg_temp_c);
3463 if (p->gfx_rc6_ms == -1) { /* detect GFX counter reset */
3467 p->gfx_rc6_ms / 10.0 / interval_float);
3473 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->gfx_mhz);
3477 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->gfx_act_mhz);
3481 if (p->sam_mc6_ms == -1) { /* detect GFX counter reset */
3485 p->sam_mc6_ms / 10.0 / interval_float);
3491 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->sam_mhz);
3495 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->sam_act_mhz);
3499 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pkg_wtd_core_c0 / tsc);
3501 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pkg_any_core_c0 / tsc);
3503 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pkg_any_gfxe_c0 / tsc);
3505 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pkg_both_core_gfxe_c0 / tsc);
3508 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc2 / tsc);
3510 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc3 / tsc);
3512 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc6 / tsc);
3514 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc7 / tsc);
3516 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc8 / tsc);
3518 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc9 / tsc);
3520 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc10 / tsc);
3524 sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->die_c6 / crystal_hz / interval_float);
3527 if (p->cpu_lpi >= 0)
3530 100.0 * p->cpu_lpi / 1000000.0 / interval_float);
3535 if (p->sys_lpi >= 0)
3538 100.0 * p->sys_lpi / 1000000.0 / interval_float);
3546 rapl_counter_get_value(&p->energy_pkg, RAPL_UNIT_WATTS, interval_float));
3547 if (DO_BIC(BIC_CorWatt) && !platform->has_per_core_rapl)
3550 rapl_counter_get_value(&p->energy_cores, RAPL_UNIT_WATTS, interval_float));
3554 rapl_counter_get_value(&p->energy_gfx, RAPL_UNIT_WATTS, interval_float));
3558 rapl_counter_get_value(&p->energy_dram, RAPL_UNIT_WATTS, interval_float));
3561 rapl_counter_get_value(&p->energy_pkg, RAPL_UNIT_JOULES, interval_float));
3562 if (DO_BIC(BIC_Cor_J) && !platform->has_per_core_rapl)
3564 rapl_counter_get_value(&p->energy_cores, RAPL_UNIT_JOULES, interval_float));
3567 rapl_counter_get_value(&p->energy_gfx, RAPL_UNIT_JOULES, interval_float));
3570 rapl_counter_get_value(&p->energy_dram, RAPL_UNIT_JOULES, interval_float));
3574 rapl_counter_get_value(&p->rapl_pkg_perf_status, RAPL_UNIT_WATTS, interval_float));
3578 rapl_counter_get_value(&p->rapl_dram_perf_status, RAPL_UNIT_WATTS, interval_float));
3581 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->uncore_mhz);
3583 for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
3584 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE) {
3585 if (mp->width == 32)
3587 sprintf(outp, "%s0x%08x", (printed++ ? delim : ""), (unsigned int)p->counter[i]);
3589 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), p->counter[i]);
3590 } else if (mp->format == FORMAT_DELTA) {
3591 if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
3592 outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), p->counter[i]);
3594 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), p->counter[i]);
3595 } else if (mp->format == FORMAT_PERCENT) {
3596 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->counter[i] / tsc);
3597 } else if (mp->type == COUNTER_K2M)
3598 outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), (unsigned int)p->counter[i] / 1000);
3601 for (i = 0, pp = sys.perf_pp; pp; i++, pp = pp->next) {
3602 if (pp->format == FORMAT_RAW) {
3603 if (pp->width == 32)
3606 (unsigned int)p->perf_counter[i]);
3608 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), p->perf_counter[i]);
3609 } else if (pp->format == FORMAT_DELTA) {
3610 if ((pp->type == COUNTER_ITEMS) && sums_need_wide_columns)
3611 outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), p->perf_counter[i]);
3613 outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), p->perf_counter[i]);
3614 } else if (pp->format == FORMAT_PERCENT) {
3615 outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->perf_counter[i] / tsc);
3616 } else if (pp->type == COUNTER_K2M) {
3618 sprintf(outp, "%s%d", (printed++ ? delim : ""), (unsigned int)p->perf_counter[i] / 1000);
3622 for (i = 0, ppmt = sys.pmt_pp; ppmt; i++, ppmt = ppmt->next) {
3623 const unsigned long value_raw = p->pmt_counter[i];
3625 switch (ppmt->type) {
3629 (unsigned int)p->pmt_counter[i]);
3631 outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), p->pmt_counter[i]);
3648 rapl_counter_get_value(&pplat_cnt->energy_psys, RAPL_UNIT_WATTS, interval_float));
3651 rapl_counter_get_value(&pplat_cnt->energy_psys, RAPL_UNIT_JOULES, interval_float));
3654 if (*(outp - 1) != '\n')
3700 old = ((((unsigned long long)new << 32) - ((unsigned long long)old << 32)) >> 32);
3710 old->pkg_wtd_core_c0 = new->pkg_wtd_core_c0 - old->pkg_wtd_core_c0;
3712 old->pkg_any_core_c0 = new->pkg_any_core_c0 - old->pkg_any_core_c0;
3714 old->pkg_any_gfxe_c0 = new->pkg_any_gfxe_c0 - old->pkg_any_gfxe_c0;
3716 old->pkg_both_core_gfxe_c0 = new->pkg_both_core_gfxe_c0 - old->pkg_both_core_gfxe_c0;
3718 old->pc2 = new->pc2 - old->pc2;
3720 old->pc3 = new->pc3 - old->pc3;
3722 old->pc6 = new->pc6 - old->pc6;
3724 old->pc7 = new->pc7 - old->pc7;
3725 old->pc8 = new->pc8 - old->pc8;
3726 old->pc9 = new->pc9 - old->pc9;
3727 old->pc10 = new->pc10 - old->pc10;
3728 old->die_c6 = new->die_c6 - old->die_c6;
3729 old->cpu_lpi = new->cpu_lpi - old->cpu_lpi;
3730 old->sys_lpi = new->sys_lpi - old->sys_lpi;
3731 old->pkg_temp_c = new->pkg_temp_c;
3734 if (old->gfx_rc6_ms > new->gfx_rc6_ms)
3735 old->gfx_rc6_ms = -1;
3737 old->gfx_rc6_ms = new->gfx_rc6_ms - old->gfx_rc6_ms;
3739 old->uncore_mhz = new->uncore_mhz;
3740 old->gfx_mhz = new->gfx_mhz;
3741 old->gfx_act_mhz = new->gfx_act_mhz;
3744 if (old->sam_mc6_ms > new->sam_mc6_ms)
3745 old->sam_mc6_ms = -1;
3747 old->sam_mc6_ms = new->sam_mc6_ms - old->sam_mc6_ms;
3749 old->sam_mhz = new->sam_mhz;
3750 old->sam_act_mhz = new->sam_act_mhz;
3752 old->energy_pkg.raw_value = new->energy_pkg.raw_value - old->energy_pkg.raw_value;
3753 old->energy_cores.raw_value = new->energy_cores.raw_value - old->energy_cores.raw_value;
3754 old->energy_gfx.raw_value = new->energy_gfx.raw_value - old->energy_gfx.raw_value;
3755 old->energy_dram.raw_value = new->energy_dram.raw_value - old->energy_dram.raw_value;
3756 old->rapl_pkg_perf_status.raw_value = new->rapl_pkg_perf_status.raw_value - old->rapl_pkg_perf_status.raw_value;
3757 old->rapl_dram_perf_status.raw_value =
3758 new->rapl_dram_perf_status.raw_value - old->rapl_dram_perf_status.raw_value;
3760 for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
3761 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE)
3762 old->counter[i] = new->counter[i];
3763 else if (mp->format == FORMAT_AVERAGE)
3764 old->counter[i] = new->counter[i];
3766 old->counter[i] = new->counter[i] - old->counter[i];
3769 for (i = 0, pp = sys.perf_pp; pp; i++, pp = pp->next) {
3770 if (pp->format == FORMAT_RAW)
3771 old->perf_counter[i] = new->perf_counter[i];
3772 else if (pp->format == FORMAT_AVERAGE)
3773 old->perf_counter[i] = new->perf_counter[i];
3775 old->perf_counter[i] = new->perf_counter[i] - old->perf_counter[i];
3778 for (i = 0, ppmt = sys.pmt_pp; ppmt; i++, ppmt = ppmt->next) {
3779 if (ppmt->format == FORMAT_RAW)
3780 old->pmt_counter[i] = new->pmt_counter[i];
3782 old->pmt_counter[i] = new->pmt_counter[i] - old->pmt_counter[i];
3795 old->c3 = new->c3 - old->c3;
3796 old->c6 = new->c6 - old->c6;
3797 old->c7 = new->c7 - old->c7;
3798 old->core_temp_c = new->core_temp_c;
3799 old->core_throt_cnt = new->core_throt_cnt - old->core_throt_cnt;
3800 old->mc6_us = new->mc6_us - old->mc6_us;
3802 DELTA_WRAP32(new->core_energy.raw_value, old->core_energy.raw_value);
3804 for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
3805 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE)
3806 old->counter[i] = new->counter[i];
3808 old->counter[i] = new->counter[i] - old->counter[i];
3811 for (i = 0, pp = sys.perf_cp; pp; i++, pp = pp->next) {
3812 if (pp->format == FORMAT_RAW)
3813 old->perf_counter[i] = new->perf_counter[i];
3815 old->perf_counter[i] = new->perf_counter[i] - old->perf_counter[i];
3818 for (i = 0, ppmt = sys.pmt_cp; ppmt; i++, ppmt = ppmt->next) {
3819 if (ppmt->format == FORMAT_RAW)
3820 old->pmt_counter[i] = new->pmt_counter[i];
3822 old->pmt_counter[i] = new->pmt_counter[i] - old->pmt_counter[i];
3828 if (!DO_BIC(BIC_CPU_c1) || platform->has_msr_core_c1_res)
3835 * old = new - old
3846 new->apic_id = old->apic_id;
3848 new->x2apic_id = old->x2apic_id;
3853 * over-write old w/ new so we can print end of interval values
3856 timersub(&new->tv_begin, &old->tv_begin, &old->tv_delta);
3857 old->tv_begin = new->tv_begin;
3858 old->tv_end = new->tv_end;
3860 old->tsc = new->tsc - old->tsc;
3863 if (old->tsc < (1000 * 1000))
3864 errx(-3, "Insanely slow TSC rate, TSC stops in idle?\n"
3865 "You can disable all c-states by booting with \"idle=poll\"\n"
3868 old->c1 = new->c1 - old->c1;
3872 if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
3873 old->aperf = new->aperf - old->aperf;
3874 old->mperf = new->mperf - old->mperf;
3876 return -1;
3880 if (platform->has_msr_core_c1_res) {
3888 * it is possible for mperf's non-halted cycles + idle states
3891 if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > (old->tsc * tsc_tweak))
3892 old->c1 = 0;
3895 old->c1 = (old->tsc * tsc_tweak) - old->mperf - core_delta->c3
3896 - core_delta->c6 - core_delta->c7;
3900 if (old->mperf == 0) {
3902 fprintf(outf, "cpu%d MPERF 0!\n", old->cpu_id);
3903 old->mperf = 1; /* divide by 0 protection */
3907 old->instr_count = new->instr_count - old->instr_count;
3910 old->irq_count = new->irq_count - old->irq_count;
3913 old->nmi_count = new->nmi_count - old->nmi_count;
3916 old->smi_count = new->smi_count - old->smi_count;
3918 for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
3919 if (mp->format == FORMAT_RAW || mp->format == FORMAT_AVERAGE)
3920 old->counter[i] = new->counter[i];
3922 old->counter[i] = new->counter[i] - old->counter[i];
3925 for (i = 0, pp = sys.perf_tp; pp; i++, pp = pp->next) {
3926 if (pp->format == FORMAT_RAW)
3927 old->perf_counter[i] = new->perf_counter[i];
3929 old->perf_counter[i] = new->perf_counter[i] - old->perf_counter[i];
3932 for (i = 0, ppmt = sys.pmt_tp; ppmt; i++, ppmt = ppmt->next) {
3933 if (ppmt->format == FORMAT_RAW)
3934 old->pmt_counter[i] = new->pmt_counter[i];
3936 old->pmt_counter[i] = new->pmt_counter[i] - old->pmt_counter[i];
3963 old->energy_psys.raw_value = new->energy_psys.raw_value - old->energy_psys.raw_value;
3968 c->raw_value = 0;
3969 c->scale = 0.0;
3970 c->unit = RAPL_UNIT_INVALID;
3978 t->tv_begin.tv_sec = 0;
3979 t->tv_begin.tv_usec = 0;
3980 t->tv_end.tv_sec = 0;
3981 t->tv_end.tv_usec = 0;
3982 t->tv_delta.tv_sec = 0;
3983 t->tv_delta.tv_usec = 0;
3985 t->tsc = 0;
3986 t->aperf = 0;
3987 t->mperf = 0;
3988 t->c1 = 0;
3990 t->instr_count = 0;
3992 t->irq_count = 0;
3993 t->nmi_count = 0;
3994 t->smi_count = 0;
3996 c->c3 = 0;
3997 c->c6 = 0;
3998 c->c7 = 0;
3999 c->mc6_us = 0;
4000 c->core_temp_c = 0;
4001 rapl_counter_clear(&c->core_energy);
4002 c->core_throt_cnt = 0;
4004 p->pkg_wtd_core_c0 = 0;
4005 p->pkg_any_core_c0 = 0;
4006 p->pkg_any_gfxe_c0 = 0;
4007 p->pkg_both_core_gfxe_c0 = 0;
4009 p->pc2 = 0;
4011 p->pc3 = 0;
4013 p->pc6 = 0;
4015 p->pc7 = 0;
4016 p->pc8 = 0;
4017 p->pc9 = 0;
4018 p->pc10 = 0;
4019 p->die_c6 = 0;
4020 p->cpu_lpi = 0;
4021 p->sys_lpi = 0;
4023 rapl_counter_clear(&p->energy_pkg);
4024 rapl_counter_clear(&p->energy_dram);
4025 rapl_counter_clear(&p->energy_cores);
4026 rapl_counter_clear(&p->energy_gfx);
4027 rapl_counter_clear(&p->rapl_pkg_perf_status);
4028 rapl_counter_clear(&p->rapl_dram_perf_status);
4029 p->pkg_temp_c = 0;
4031 p->gfx_rc6_ms = 0;
4032 p->uncore_mhz = 0;
4033 p->gfx_mhz = 0;
4034 p->gfx_act_mhz = 0;
4035 p->sam_mc6_ms = 0;
4036 p->sam_mhz = 0;
4037 p->sam_act_mhz = 0;
4038 for (i = 0, mp = sys.tp; mp; i++, mp = mp->next)
4039 t->counter[i] = 0;
4041 for (i = 0, mp = sys.cp; mp; i++, mp = mp->next)
4042 c->counter[i] = 0;
4044 for (i = 0, mp = sys.pp; mp; i++, mp = mp->next)
4045 p->counter[i] = 0;
4047 memset(&t->perf_counter[0], 0, sizeof(t->perf_counter));
4048 memset(&c->perf_counter[0], 0, sizeof(c->perf_counter));
4049 memset(&p->perf_counter[0], 0, sizeof(p->perf_counter));
4051 memset(&t->pmt_counter[0], 0, ARRAY_SIZE(t->pmt_counter));
4052 memset(&c->pmt_counter[0], 0, ARRAY_SIZE(c->pmt_counter));
4053 memset(&p->pmt_counter[0], 0, ARRAY_SIZE(p->pmt_counter));
4059 if (dst->unit == RAPL_UNIT_INVALID) {
4060 dst->unit = src->unit;
4061 dst->scale = src->scale;
4064 assert(dst->unit == src->unit);
4065 assert(dst->scale == src->scale);
4067 dst->raw_value += src->raw_value;
4077 /* copy un-changing apic_id's */
4079 average.threads.apic_id = t->apic_id;
4081 average.threads.x2apic_id = t->x2apic_id;
4088 average.threads.tv_end = t->tv_end;
4090 average.threads.tsc += t->tsc;
4091 average.threads.aperf += t->aperf;
4092 average.threads.mperf += t->mperf;
4093 average.threads.c1 += t->c1;
4095 average.threads.instr_count += t->instr_count;
4097 average.threads.irq_count += t->irq_count;
4098 average.threads.nmi_count += t->nmi_count;
4099 average.threads.smi_count += t->smi_count;
4101 for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
4102 if (mp->format == FORMAT_RAW)
4104 average.threads.counter[i] += t->counter[i];
4107 for (i = 0, pp = sys.perf_tp; pp; i++, pp = pp->next) {
4108 if (pp->format == FORMAT_RAW)
4110 average.threads.perf_counter[i] += t->perf_counter[i];
4113 for (i = 0, ppmt = sys.pmt_tp; ppmt; i++, ppmt = ppmt->next) {
4114 average.threads.pmt_counter[i] += t->pmt_counter[i];
4117 /* sum per-core values only for 1st thread in core */
4121 average.cores.c3 += c->c3;
4122 average.cores.c6 += c->c6;
4123 average.cores.c7 += c->c7;
4124 average.cores.mc6_us += c->mc6_us;
4126 average.cores.core_temp_c = MAX(average.cores.core_temp_c, c->core_temp_c);
4127 average.cores.core_throt_cnt = MAX(average.cores.core_throt_cnt, c->core_throt_cnt);
4129 rapl_counter_accumulate(&average.cores.core_energy, &c->core_energy);
4131 for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
4132 if (mp->format == FORMAT_RAW)
4134 average.cores.counter[i] += c->counter[i];
4137 for (i = 0, pp = sys.perf_cp; pp; i++, pp = pp->next) {
4138 if (pp->format == FORMAT_RAW)
4140 average.cores.perf_counter[i] += c->perf_counter[i];
4143 for (i = 0, ppmt = sys.pmt_cp; ppmt; i++, ppmt = ppmt->next) {
4144 average.cores.pmt_counter[i] += c->pmt_counter[i];
4147 /* sum per-pkg values only for 1st core in pkg */
4152 average.packages.pkg_wtd_core_c0 += p->pkg_wtd_core_c0;
4154 average.packages.pkg_any_core_c0 += p->pkg_any_core_c0;
4156 average.packages.pkg_any_gfxe_c0 += p->pkg_any_gfxe_c0;
4158 average.packages.pkg_both_core_gfxe_c0 += p->pkg_both_core_gfxe_c0;
4160 average.packages.pc2 += p->pc2;
4162 average.packages.pc3 += p->pc3;
4164 average.packages.pc6 += p->pc6;
4166 average.packages.pc7 += p->pc7;
4167 average.packages.pc8 += p->pc8;
4168 average.packages.pc9 += p->pc9;
4169 average.packages.pc10 += p->pc10;
4170 average.packages.die_c6 += p->die_c6;
4172 average.packages.cpu_lpi = p->cpu_lpi;
4173 average.packages.sys_lpi = p->sys_lpi;
4175 rapl_counter_accumulate(&average.packages.energy_pkg, &p->energy_pkg);
4176 rapl_counter_accumulate(&average.packages.energy_dram, &p->energy_dram);
4177 rapl_counter_accumulate(&average.packages.energy_cores, &p->energy_cores);
4178 rapl_counter_accumulate(&average.packages.energy_gfx, &p->energy_gfx);
4180 average.packages.gfx_rc6_ms = p->gfx_rc6_ms;
4181 average.packages.uncore_mhz = p->uncore_mhz;
4182 average.packages.gfx_mhz = p->gfx_mhz;
4183 average.packages.gfx_act_mhz = p->gfx_act_mhz;
4184 average.packages.sam_mc6_ms = p->sam_mc6_ms;
4185 average.packages.sam_mhz = p->sam_mhz;
4186 average.packages.sam_act_mhz = p->sam_act_mhz;
4188 average.packages.pkg_temp_c = MAX(average.packages.pkg_temp_c, p->pkg_temp_c);
4190 rapl_counter_accumulate(&average.packages.rapl_pkg_perf_status, &p->rapl_pkg_perf_status);
4191 rapl_counter_accumulate(&average.packages.rapl_dram_perf_status, &p->rapl_dram_perf_status);
4193 for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
4194 if ((mp->format == FORMAT_RAW) && (topo.num_packages == 0))
4195 average.packages.counter[i] = p->counter[i];
4197 average.packages.counter[i] += p->counter[i];
4200 for (i = 0, pp = sys.perf_pp; pp; i++, pp = pp->next) {
4201 if ((pp->format == FORMAT_RAW) && (topo.num_packages == 0))
4202 average.packages.perf_counter[i] = p->perf_counter[i];
4204 average.packages.perf_counter[i] += p->perf_counter[i];
4207 for (i = 0, ppmt = sys.pmt_pp; ppmt; i++, ppmt = ppmt->next) {
4208 average.packages.pmt_counter[i] += p->pmt_counter[i];
4270 for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
4271 if (mp->format == FORMAT_RAW)
4273 if (mp->type == COUNTER_ITEMS) {
4280 for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
4281 if (mp->format == FORMAT_RAW)
4283 if (mp->type == COUNTER_ITEMS) {
4289 for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
4290 if (mp->format == FORMAT_RAW)
4292 if (mp->type == COUNTER_ITEMS) {
4299 for (i = 0, pp = sys.perf_tp; pp; i++, pp = pp->next) {
4300 if (pp->format == FORMAT_RAW)
4302 if (pp->type == COUNTER_ITEMS) {
4309 for (i = 0, pp = sys.perf_cp; pp; i++, pp = pp->next) {
4310 if (pp->format == FORMAT_RAW)
4312 if (pp->type == COUNTER_ITEMS) {
4318 for (i = 0, pp = sys.perf_pp; pp; i++, pp = pp->next) {
4319 if (pp->format == FORMAT_RAW)
4321 if (pp->type == COUNTER_ITEMS) {
4328 for (i = 0, ppmt = sys.pmt_tp; ppmt; i++, ppmt = ppmt->next) {
4331 for (i = 0, ppmt = sys.pmt_cp; ppmt; i++, ppmt = ppmt->next) {
4334 for (i = 0, ppmt = sys.pmt_pp; ppmt; i++, ppmt = ppmt->next) {
4384 if (mp->msr_num != 0) {
4386 if (get_msr(cpu, mp->msr_num, counterp))
4387 return -1;
4391 if (mp->flags & SYSFS_PERCPU) {
4392 sprintf(path, "/sys/devices/system/cpu/cpu%d/%s", cpu, mp->sp->path);
4432 int ret, epb = -1;
4451 return -1;
4466 t->apic_id = (ebx >> 24) & 0xff;
4488 t->x2apic_id = eax;
4500 t->x2apic_id = edx;
4502 if (debug && (t->apic_id != (t->x2apic_id & 0xff)))
4503 fprintf(outf, "cpu%d: BIOS BUG: apic 0x%x x2apic 0x%x\n", t->cpu_id, t->apic_id, t->x2apic_id);
4516 return -1;
4520 return -1;
4536 int ret = -1;
4539 if (fdmt == -1) {
4542 ret = -1;
4546 bytes_read = read(fdmt, buf, sizeof(buf) - 1);
4550 ret = -1;
4559 ret = -1;
4577 v = -1;
4603 unsigned int ret = -1;
4609 return -1;
4680 if (rci->source[i] == COUNTER_SOURCE_PERF)
4691 if (cci->source[i] == COUNTER_SOURCE_PERF)
4699 if (rci->source[idx] == COUNTER_SOURCE_NONE)
4702 rc->raw_value = rci->data[idx];
4703 rc->unit = rci->unit[idx];
4704 rc->scale = rci->scale[idx];
4724 if (rci->fd_perf != -1) {
4727 const ssize_t actual_read_size = read(rci->fd_perf, &perf_data[0], sizeof(perf_data));
4730 err(-1, "%s: failed to read perf_data (%zu %zu)", __func__, expected_read_size,
4735 switch (rci->source[i]) {
4737 rci->data[i] = 0;
4742 assert(rci->fd_perf != -1);
4746 i, perf_data[pi], rci->scale[i], perf_data[pi] * rci->scale[i]);
4748 rci->data[i] = perf_data[pi];
4758 if (rci->flags[i] & RAPL_COUNTER_FLAG_USE_MSR_SUM) {
4759 if (get_msr_sum(cpu, rci->msr[i], &rci->data[i]))
4760 return -13 - i;
4762 if (get_msr(cpu, rci->msr[i], &rci->data[i]))
4763 return -13 - i;
4766 rci->data[i] &= rci->msr_mask[i];
4767 if (rci->msr_shift[i] >= 0)
4768 rci->data[i] >>= abs(rci->msr_shift[i]);
4770 rci->data[i] <<= abs(rci->msr_shift[i]);
4777 write_rapl_counter(&p->energy_pkg, rci, RAPL_RCI_INDEX_ENERGY_PKG);
4778 write_rapl_counter(&p->energy_cores, rci, RAPL_RCI_INDEX_ENERGY_CORES);
4779 write_rapl_counter(&p->energy_dram, rci, RAPL_RCI_INDEX_DRAM);
4780 write_rapl_counter(&p->energy_gfx, rci, RAPL_RCI_INDEX_GFX);
4781 write_rapl_counter(&p->rapl_pkg_perf_status, rci, RAPL_RCI_INDEX_PKG_PERF_STATUS);
4782 write_rapl_counter(&p->rapl_dram_perf_status, rci, RAPL_RCI_INDEX_DRAM_PERF_STATUS);
4783 write_rapl_counter(&c->core_energy, rci, RAPL_RCI_INDEX_CORE_ENERGY);
4784 write_rapl_counter(&pplat_cnt->energy_psys, rci, RAPL_RCI_INDEX_ENERGY_PLATFORM);
4792 if (sp->id == id)
4793 return (sp->path);
4794 sp = sp->next;
4832 if (cci->fd_perf_core != -1) {
4836 actual_read_size_core = read(cci->fd_perf_core, &perf_data_core[0], sizeof(perf_data_core));
4839 err(-1, "%s: read perf %s: %ld", __func__, "core", actual_read_size_core);
4842 if (cci->fd_perf_pkg != -1) {
4846 actual_read_size_pkg = read(cci->fd_perf_pkg, &perf_data_pkg[0], sizeof(perf_data_pkg));
4849 err(-1, "%s: read perf %s: %ld", __func__, "pkg", actual_read_size_pkg);
4855 err(-1, "%s: failed to read perf_data (%zu %zu)", __func__, expected_read_size, actual_read_size_total);
4875 switch (cci->source[i]) {
4881 assert(cci->fd_perf_core != -1 || cci->fd_perf_pkg != -1);
4886 cci->data[i] = perf_data[pi];
4893 if (get_msr(cpu, cci->msr[i], &cci->data[i]))
4894 return -13 - i;
4897 fprintf(stderr, "cstate via %s0x%llx %u: %llu\n", "msr", cci->msr[i], i, cci->data[i]);
4911 if (cci->source[index] != COUNTER_SOURCE_NONE) \
4912 out_counter = cci->data[index]; \
4917 PERF_COUNTER_WRITE_DATA(t->c1, CCSTATE_RCI_INDEX_C1_RESIDENCY);
4918 PERF_COUNTER_WRITE_DATA(c->c3, CCSTATE_RCI_INDEX_C3_RESIDENCY);
4919 PERF_COUNTER_WRITE_DATA(c->c6, CCSTATE_RCI_INDEX_C6_RESIDENCY);
4920 PERF_COUNTER_WRITE_DATA(c->c7, CCSTATE_RCI_INDEX_C7_RESIDENCY);
4922 PERF_COUNTER_WRITE_DATA(p->pc2, PCSTATE_RCI_INDEX_C2_RESIDENCY);
4923 PERF_COUNTER_WRITE_DATA(p->pc3, PCSTATE_RCI_INDEX_C3_RESIDENCY);
4924 PERF_COUNTER_WRITE_DATA(p->pc6, PCSTATE_RCI_INDEX_C6_RESIDENCY);
4925 PERF_COUNTER_WRITE_DATA(p->pc7, PCSTATE_RCI_INDEX_C7_RESIDENCY);
4926 PERF_COUNTER_WRITE_DATA(p->pc8, PCSTATE_RCI_INDEX_C8_RESIDENCY);
4927 PERF_COUNTER_WRITE_DATA(p->pc9, PCSTATE_RCI_INDEX_C9_RESIDENCY);
4928 PERF_COUNTER_WRITE_DATA(p->pc10, PCSTATE_RCI_INDEX_C10_RESIDENCY);
4940 if (mci->source[i] == COUNTER_SOURCE_PERF)
4961 ZERO_ARRAY(mci->data);
4963 if (mci->fd_perf != -1) {
4966 const ssize_t actual_read_size = read(mci->fd_perf, &perf_data[0], sizeof(perf_data));
4969 err(-1, "%s: failed to read perf_data (%zu %zu)", __func__, expected_read_size,
4974 switch (mci->source[i]) {
4980 assert(mci->fd_perf != -1);
4985 mci->data[i] = perf_data[pi];
4993 if (get_msr(cpu, mci->msr[i], &mci->data[i]))
4994 return -2 - i;
4996 mci->data[i] &= mci->msr_mask[i];
4999 fprintf(stderr, "Reading msr counter via msr at %u: %llu\n", i, mci->data[i]);
5006 t->aperf = mci->data[MSR_RCI_INDEX_APERF];
5007 t->mperf = mci->data[MSR_RCI_INDEX_MPERF];
5008 t->smi_count = mci->data[MSR_RCI_INDEX_SMI];
5019 for (size_t i = 0; pp; ++i, pp = pp->next) {
5021 assert(domain < pp->num_domains);
5023 fd_counter = pp->fd_perf_per_domain[domain];
5025 if (fd_counter == -1)
5032 out[i] = value * pp->scale;
5045 mask = ((1 << (msb + 1)) - 1);
5047 mask -= (1 << lsb) - 1;
5054 if (domain_id >= ppmt->num_domains)
5057 const unsigned long *pmmio = ppmt->domains[domain_id].pcounter;
5059 const unsigned long value_mask = pmt_gen_value_mask(ppmt->lsb, ppmt->msb);
5060 const unsigned long value_shift = ppmt->lsb;
5072 if (!platform->has_per_core_rapl)
5086 if (!platform->has_per_core_rapl)
5089 /* Compute the system-wide unique core-id for @cpu */
5103 int cpu = t->cpu_id;
5112 return -1;
5115 gettimeofday(&t->tv_begin, (struct timezone *)NULL);
5120 t->tsc = rdtsc(); /* we are running on local CPU of interest */
5125 if (read(get_instr_count_fd(cpu), &t->instr_count, sizeof(long long)) != sizeof(long long))
5126 return -4;
5129 t->irq_count = irqs_per_cpu[cpu];
5131 t->nmi_count = nmi_per_cpu[cpu];
5135 for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
5136 if (get_mp(cpu, mp, &t->counter[i], mp->sp->path))
5137 return -10;
5140 if (perf_counter_info_read_values(sys.perf_tp, cpu, t->perf_counter, MAX_ADDED_THREAD_COUNTERS))
5141 return -10;
5143 for (i = 0, pp = sys.pmt_tp; pp; i++, pp = pp->next)
5144 t->pmt_counter[i] = pmt_read_counter(pp, t->cpu_id);
5150 if (platform->has_per_core_rapl) {
5156 if (DO_BIC(BIC_CPU_c7) && t->is_atom) {
5163 c->c6 -= c->c7;
5167 if (get_msr(cpu, MSR_MODULE_C6_RES_MS, &c->mc6_us))
5168 return -8;
5172 return -9;
5173 c->core_temp_c = tj_max - ((msr >> 16) & 0x7F);
5177 get_core_throt_cnt(cpu, &c->core_throt_cnt);
5179 for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
5180 if (get_mp(cpu, mp, &c->counter[i], mp->sp->path))
5181 return -10;
5184 if (perf_counter_info_read_values(sys.perf_cp, cpu, c->perf_counter, MAX_ADDED_CORE_COUNTERS))
5185 return -10;
5187 for (i = 0, pp = sys.pmt_cp; pp; i++, pp = pp->next)
5188 c->pmt_counter[i] = pmt_read_counter(pp, c->core_id);
5195 if (get_msr(cpu, MSR_PKG_WEIGHTED_CORE_C0_RES, &p->pkg_wtd_core_c0))
5196 return -10;
5199 if (get_msr(cpu, MSR_PKG_ANY_CORE_C0_RES, &p->pkg_any_core_c0))
5200 return -11;
5203 if (get_msr(cpu, MSR_PKG_ANY_GFXE_C0_RES, &p->pkg_any_gfxe_c0))
5204 return -12;
5207 if (get_msr(cpu, MSR_PKG_BOTH_CORE_GFXE_C0_RES, &p->pkg_both_core_gfxe_c0))
5208 return -13;
5212 p->cpu_lpi = cpuidle_cur_cpu_lpi_us;
5214 p->sys_lpi = cpuidle_cur_sys_lpi_us;
5216 if (!platform->has_per_core_rapl) {
5224 return -17;
5225 p->pkg_temp_c = tj_max - ((msr >> 16) & 0x7F);
5229 p->uncore_mhz = get_legacy_uncore_mhz(p->package_id);
5232 p->gfx_rc6_ms = gfx_info[GFX_rc6].val_ull;
5235 p->gfx_mhz = gfx_info[GFX_MHz].val;
5238 p->gfx_act_mhz = gfx_info[GFX_ACTMHz].val;
5241 p->sam_mc6_ms = gfx_info[SAM_mc6].val_ull;
5244 p->sam_mhz = gfx_info[SAM_MHz].val;
5247 p->sam_act_mhz = gfx_info[SAM_ACTMHz].val;
5249 for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
5252 if (mp->msr_num == 0) {
5253 path = find_sysfs_path_by_id(mp->sp, p->package_id);
5255 warnx("%s: package_id %d not found", __func__, p->package_id);
5256 return -10;
5259 if (get_mp(cpu, mp, &p->counter[i], path))
5260 return -10;
5263 if (perf_counter_info_read_values(sys.perf_pp, cpu, p->perf_counter, MAX_ADDED_PACKAGE_COUNTERS))
5264 return -10;
5266 for (i = 0, pp = sys.pmt_pp; pp; i++, pp = pp->next)
5267 p->pmt_counter[i] = pmt_read_counter(pp, p->package_id);
5270 gettimeofday(&t->tv_end, (struct timezone *)NULL);
5330 if (!platform->has_nhm_msrs || no_msr)
5333 switch (platform->cst_limit) {
5374 if (!platform->has_nhm_msrs || no_msr)
5392 if (!platform->has_nhm_msrs || no_msr)
5396 fprintf(outf, "cpu%d: MSR_IA32_POWER_CTL: 0x%08llx (C1E auto-promotion: %sabled)\n",
5399 /* C-state Pre-wake Disable (CSTATE_PREWAKE_DISABLE) */
5400 if (platform->has_cst_prewake_bit)
5401 fprintf(outf, "C-state Pre-wake: %sabled\n", msr & 0x40000000 ? "DIS" : "EN");
5477 if (platform->trl_msrs & TRL_CORECOUNT) {
5484 for (shift = 56; shift >= 0; shift -= 8) {
5553 * [0] -- Reserved
5554 * [7:1] -- Base value of number of active cores of bucket 1.
5555 * [15:8] -- Base value of freq ratio of bucket 1.
5556 * [20:16] -- +ve delta of number of active cores of bucket 2.
5559 * [23:21] -- Negative delta of freq ratio of bucket 2.
5561 * freq ratio of bucket 1 - delta
5562 * [28:24]-- +ve delta of number of active cores of bucket 3.
5563 * [31:29]-- -ve delta of freq ratio of bucket 3.
5564 * [36:32]-- +ve delta of number of active cores of bucket 4.
5565 * [39:37]-- -ve delta of freq ratio of bucket 4.
5566 * [44:40]-- +ve delta of number of active cores of bucket 5.
5567 * [47:45]-- -ve delta of freq ratio of bucket 5.
5568 * [52:48]-- +ve delta of number of active cores of bucket 6.
5569 * [55:53]-- -ve delta of freq ratio of bucket 6.
5570 * [60:56]-- +ve delta of number of active cores of bucket 7.
5571 * [63:61]-- -ve delta of freq ratio of bucket 7.
5583 ratio[b_nr + 1] = ratio[b_nr] - delta_ratio;
5587 for (i = buckets_no - 1; i >= 0; i--)
5588 if (i > 0 ? ratio[i] != ratio[i - 1] : 1)
5598 if (!platform->has_nhm_msrs || no_msr)
5605 fprintf(outf, " (%s%s%s%s%slocked, pkg-cstate-limit=%d (%s)",
5606 (msr & SNB_C3_AUTO_UNDEMOTE) ? "UNdemote-C3, " : "",
5607 (msr & SNB_C1_AUTO_UNDEMOTE) ? "UNdemote-C1, " : "",
5608 (msr & NHM_C3_AUTO_DEMOTE) ? "demote-C3, " : "",
5609 (msr & NHM_C1_AUTO_DEMOTE) ? "demote-C1, " : "",
5613 if (platform->has_cst_auto_convension) {
5614 fprintf(outf, ", automatic c-state conversion=%s", (msr & AUTOMATIC_CSTATE_CONVERSION) ? "on" : "off");
5670 if (!platform->has_irtl_msrs || no_msr)
5673 if (platform->supported_cstates & PC3) {
5680 if (platform->supported_cstates & PC6) {
5687 if (platform->supported_cstates & PC7) {
5694 if (platform->supported_cstates & PC8) {
5701 if (platform->supported_cstates & PC9) {
5708 if (platform->supported_cstates & PC10) {
5754 if (ccstate_counter_info[counter_id].fd_perf_core != -1)
5757 if (ccstate_counter_info[counter_id].fd_perf_pkg != -1)
5772 if (msr_counter_info[cpu].fd_perf != -1)
5789 if (rapl_counter_info_perdomain[domain_id].fd_perf != -1)
5803 if (!pp->fd_perf_per_domain)
5807 for (size_t domain = 0; domain < pp->num_domains; ++domain) {
5808 if (pp->fd_perf_per_domain[domain] != -1) {
5809 close(pp->fd_perf_per_domain[domain]);
5810 pp->fd_perf_per_domain[domain] = -1;
5814 free(pp->fd_perf_per_domain);
5815 pp->fd_perf_per_domain = NULL;
5817 pp = pp->next;
5946 cpus[cpu].logical_node_id = -1;
5955 if (cpus[cpu].logical_node_id != -1)
5984 int cpu = thiscpu->logical_cpu_id;
5994 return -1;
6004 if (*next == '-') /* no negative cpu numbers */
6024 if (*next == '-') {
6059 int cpu = thiscpu->logical_cpu_id;
6064 thiscpu->put_ids = CPU_ALLOC((topo.max_cpu_num + 1));
6065 if (thiscpu->thread_id < 0)
6066 thiscpu->thread_id = thread_id++;
6067 if (!thiscpu->put_ids)
6068 return -1;
6071 CPU_ZERO_S(size, thiscpu->put_ids);
6078 return -1;
6081 offset -= BITMASK_SIZE;
6088 if (sib_core == thiscpu->physical_core_id) {
6089 CPU_SET_S(so, size, thiscpu->put_ids);
6098 return CPU_COUNT_S(size, thiscpu->put_ids);
6103 * skip non-present cpus
6125 if (cpu_is_not_allowed(t->cpu_id))
6229 fprintf(outf, "turbostat: re-initialized with num_cpus %d, allowed_cpus %d\n", topo.num_cpus,
6250 topo.max_cpu_num--; /* 0 based */
6273 cpus[cpu].thread_id = -1;
6295 return -1;
6402 return -EINVAL;
6424 return -1;
6449 return -1;
6577 /* get_msr_sum() = sum + (get_msr() - last) */
6594 int cpu = t->cpu_id;
6650 if (timer_create(CLOCK_REALTIME, &sev, &timerid) == -1) {
6666 if (timer_settime(timerid, 0, &its, NULL) == -1) {
6681 * return value < -20 on failure
6690 if (errno && (original_priority == -1))
6691 return -21;
6695 return -21;
6700 return -21;
6716 * ignore on error - we probably don't have permission to set it, but
6719 set_my_sched_priority(-20);
6727 if (retval < -1) {
6729 } else if (retval == -1) {
6753 if (retval < -1) {
6755 } else if (retval == -1) {
6777 if (retval < -1) {
6779 } else if (retval == -1) {
6851 if (cap_free(caps) == -1)
6852 err(-6, "cap_free\n");
6880 "\tRun as root to enable them or use %s to disable the access explicitly", pathname, "--no-msr");
6890 if (!platform->has_nhm_msrs || no_msr)
6893 if (platform->bclk_freq == BCLK_100MHZ)
6895 else if (platform->bclk_freq == BCLK_133MHZ)
6897 else if (platform->bclk_freq == BCLK_SLV)
6908 if (platform->enable_tsc_tweak)
6930 if (!platform->has_nhm_msrs || no_msr)
6933 if (platform->trl_msrs & TRL_LIMIT2)
6936 if (platform->trl_msrs & TRL_LIMIT1)
6939 if (platform->trl_msrs & TRL_BASE) {
6946 if (platform->trl_msrs & TRL_ATOM)
6949 if (platform->trl_msrs & TRL_KNL)
6952 if (platform->has_config_tdp)
6959 int retval = -1;
6965 return (-1);
7018 fprintf(outf, "Uncore Frequency package%d die%d: %d - %d MHz ", i, j, k / 1000, l / 1000);
7024 fprintf(outf, "(%d - %d MHz)", k / 1000, l / 1000);
7048 uncore_max_id -= 1;
7052 for (i = uncore_max_id; i >= 0; --i) {
7076 * and reported -- So it is effectively (enabled & present).
7081 * This allows "--show/--hide UncMHz" to be effective for
7096 fprintf(outf, "Uncore Frequency package%d domain%d cluster%d: %d - %d MHz ", package_id, domain_id,
7103 fprintf(outf, "(%d - %d MHz)", k / 1000, l / 1000);
7152 if (!strncmp(buf, "gt0-rc", strlen("gt0-rc")))
7154 else if (!strncmp(buf, "gt0-mc", strlen("gt0-mc")))
7263 /* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */
7264 sp = strchr(name_buf, '-');
7349 cpu = t->cpu_id;
7351 /* EPB is per-package */
7357 return -1;
7401 cpu = t->cpu_id;
7403 /* MSR_HWP_CAPABILITIES is per-package */
7409 return -1;
7415 fprintf(outf, "cpu%d: MSR_PM_ENABLE: 0x%08llx (%sHWP)\n", cpu, msr, (msr & (1 << 0)) ? "" : "No-");
7468 cpu, msr, ((msr) & 0x1) ? "" : "No-", ((msr) & 0x4) ? "" : "No-");
7487 cpu = t->cpu_id;
7489 /* per-package */
7495 return -1;
7498 if (platform->plr_msrs & PLR_CORE) {
7510 (msr & 1 << 6) ? "VR-Therm, " : "",
7511 (msr & 1 << 5) ? "Auto-HWP, " : "",
7524 (msr & 1 << 22) ? "VR-Therm, " : "",
7525 (msr & 1 << 21) ? "Auto-HWP, " : "",
7531 if (platform->plr_msrs & PLR_GFX) {
7538 (msr & 1 << 6) ? "VR-Therm, " : "",
7546 (msr & 1 << 22) ? "VR-Therm, " : "",
7551 if (platform->plr_msrs & PLR_RING) {
7557 (msr & 1 << 6) ? "VR-Therm, " : "",
7563 (msr & 1 << 22) ? "VR-Therm, " : "",
7575 if (platform->rapl_quirk_tdp)
7576 return platform->rapl_quirk_tdp;
7585 if (platform->rapl_msrs & RAPL_PKG_POWER_INFO)
7616 if (!platform->rapl_msrs || no_msr)
7619 if (!(platform->rapl_msrs & RAPL_PKG_PERF_STATUS))
7621 if (!(platform->rapl_msrs & RAPL_DRAM_PERF_STATUS))
7629 if (platform->has_rapl_divisor)
7634 if (platform->has_fixed_rapl_unit)
7639 if (platform->has_fixed_rapl_psys_unit)
7670 if (!platform->rapl_msrs || no_msr)
7676 rapl_time_units = ldexp(1.0, -(msr >> 16 & 0xf));
7677 rapl_energy_units = ldexp(1.0, -(msr >> 8 & 0x1f));
7678 rapl_power_units = ldexp(1.0, -(msr & 0xf));
7706 return -1;
7720 return -1;
7735 return -1;
7762 return -1;
7769 return -1;
7817 if (strlen(entry->d_name) > 100)
7820 if (strncmp(entry->d_name, "intel-rapl", strlen("intel-rapl")))
7823 snprintf(path, PATH_MAX, "%s/%s/name", PATH_RAPL_SYSFS, entry->d_name);
7825 /* Parse top level domains first, including package and psys */
7830 snprintf(path, PATH_MAX, "%s/%s", PATH_RAPL_SYSFS, entry->d_name);
7839 if (strncmp(centry->d_name, "intel-rapl", strlen("intel-rapl")))
7841 snprintf(path, PATH_MAX, "%s/%s/%s", PATH_RAPL_SYSFS, entry->d_name, centry->d_name);
7860 if (!platform->rapl_msrs)
7867 cpu = t->cpu_id;
7870 return -1;
7873 if (platform->rapl_msrs & RAPL_AMD_F17H) {
7876 return -1;
7880 return -1;
7886 if (platform->rapl_msrs & RAPL_PKG_POWER_INFO) {
7889 return -5;
7891 fprintf(outf, "cpu%d: MSR_PKG_POWER_INFO: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
7899 if (platform->rapl_msrs & RAPL_PKG) {
7902 return -9;
7916 return -9;
7923 if (platform->rapl_msrs & RAPL_DRAM_POWER_INFO) {
7925 return -6;
7927 fprintf(outf, "cpu%d: MSR_DRAM_POWER_INFO,: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
7934 if (platform->rapl_msrs & RAPL_DRAM) {
7936 return -9;
7942 if (platform->rapl_msrs & RAPL_CORE_POLICY) {
7944 return -7;
7948 if (platform->rapl_msrs & RAPL_CORE_POWER_LIMIT) {
7950 return -9;
7955 if (platform->rapl_msrs & RAPL_GFX) {
7957 return -8;
7962 return -9;
7987 if (!platform->rapl_msrs || no_msr)
7995 * the Thermal Control Circuit (TCC) activates.
7999 * but also allow cmdline over-ride with -T.
8001 * Several MSR temperature values are in units of degrees-C
8002 * below this value, including the Digital Thermal Sensor (DTS),
8003 * Package Thermal Management Sensor (PTM), and thermal event thresholds.
8018 /* this is a per-package concept */
8022 cpu = t->cpu_id;
8025 return -1;
8035 if (!platform->has_nhm_msrs || no_msr)
8044 int bits = platform->tcc_offset_bits;
8051 tcc_offset = (msr >> 24) & GENMASK(bits - 1, 0);
8052 fprintf(outf, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C) (%d default - %d offset)\n",
8053 cpu, msr, tcc_default - tcc_offset, tcc_default, tcc_offset);
8068 fprintf(outf, "cpu%d: Guessing tjMax %d C, Please use -T to specify\n", cpu, tj_max);
8088 cpu = t->cpu_id;
8090 /* DTS is per-core, no need to print for each thread */
8096 return -1;
8104 fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_STATUS: 0x%08llx (%d C)\n", cpu, msr, tj_max - dts);
8112 cpu, msr, tj_max - dts, tj_max - dts2);
8123 fprintf(outf, "cpu%d: MSR_IA32_THERM_STATUS: 0x%08llx (%d C +/- %d)\n",
8124 cpu, msr, tj_max - dts, resolution);
8132 cpu, msr, tj_max - dts, tj_max - dts2);
8163 if (cpu_migrate(t->cpu_id)) {
8164 fprintf(outf, "Could not migrate to CPU %d\n", t->cpu_id);
8165 return -1;
8174 t->is_atom = true;
8187 base_cpu, msr, msr & FEAT_CTL_LOCKED ? "" : "UN-", msr & (1 << 18) ? "SGX" : "");
8203 msr & MSR_IA32_MISC_ENABLE_TM1 ? "" : "No-",
8204 msr & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP ? "" : "No-",
8205 msr & MSR_IA32_MISC_ENABLE_MWAIT ? "" : "No-",
8206 msr & MSR_IA32_MISC_ENABLE_PREFETCH_DISABLE ? "No-" : "",
8207 msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE ? "No-" : "");
8217 if (!platform->has_msr_misc_feature_control)
8222 "cpu%d: MSR_MISC_FEATURE_CONTROL: 0x%08llx (%sL2-Prefetch %sL2-Prefetch-pair %sL1-Prefetch %sL1-IP-Prefetch)\n",
8223 base_cpu, msr, msr & (0 << 0) ? "No-" : "", msr & (1 << 0) ? "No-" : "",
8224 msr & (2 << 0) ? "No-" : "", msr & (3 << 0) ? "No-" : "");
8241 if (!platform->has_msr_misc_pwr_mgmt)
8245 fprintf(outf, "cpu%d: MSR_MISC_PWR_MGMT: 0x%08llx (%sable-EIST_Coordination %sable-EPB %sable-OOB)\n",
8263 if (!platform->has_msr_c6_demotion_policy_config)
8267 fprintf(outf, "cpu%d: MSR_CC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-CC6-Demotion)\n",
8271 fprintf(outf, "cpu%d: MSR_MC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-MC6-Demotion)\n",
8308 fd = open_perf_counter(base_cpu, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS, -1, 0);
8309 has_access = fd != -1;
8311 if (fd != -1)
8317 "instructions retired perf counter", "--no-perf");
8325 int ret = -1;
8328 return -1;
8330 if (!cai->perf_name)
8331 return -1;
8333 const double scale = read_perf_scale(cai->perf_subsys, cai->perf_name);
8338 const enum rapl_unit unit = read_perf_rapl_unit(cai->perf_subsys, cai->perf_name);
8343 const unsigned int rapl_type = read_perf_type(cai->perf_subsys);
8344 const unsigned int rapl_energy_pkg_config = read_perf_config(cai->perf_subsys, cai->perf_name);
8346 ret = open_perf_counter(cpu, rapl_type, rapl_energy_pkg_config, rci->fd_perf, PERF_FORMAT_GROUP);
8347 if (ret == -1)
8351 if (rci->fd_perf == -1)
8352 rci->fd_perf = ret;
8365 * Linux-perf manages the HW instructions-retired counter
8376 err(-1, "calloc fd_instr_count_percpu");
8387 err(-1, "calloc rapl_counter_info_percpu");
8396 rci->fd_perf = -1;
8398 rci->data[i] = 0;
8399 rci->source[i] = COUNTER_SOURCE_NONE;
8415 if (!BIC_IS_ENABLED(cai->bic_number))
8435 if ((cai->flags & RAPL_COUNTER_FLAG_PLATFORM_COUNTER) && (cpu != base_cpu))
8450 * Thus need a check to avoid re-probe the same counters.
8452 if (rci->source[cai->rci_index] != COUNTER_SOURCE_NONE)
8456 if (add_rapl_perf_counter(cpu, rci, cai, &scale, &unit) != -1) {
8457 rci->source[cai->rci_index] = COUNTER_SOURCE_PERF;
8458 rci->scale[cai->rci_index] = scale * cai->compat_scale;
8459 rci->unit[cai->rci_index] = unit;
8460 rci->flags[cai->rci_index] = cai->flags;
8464 rci->source[cai->rci_index] = COUNTER_SOURCE_MSR;
8465 rci->msr[cai->rci_index] = cai->msr;
8466 rci->msr_mask[cai->rci_index] = cai->msr_mask;
8467 rci->msr_shift[cai->rci_index] = cai->msr_shift;
8468 rci->unit[cai->rci_index] = RAPL_UNIT_JOULES;
8469 rci->scale[cai->rci_index] = *cai->platform_rapl_msr_scale * cai->compat_scale;
8470 rci->flags[cai->rci_index] = cai->flags;
8473 if (rci->source[cai->rci_index] != COUNTER_SOURCE_NONE)
8479 BIC_PRESENT(cai->bic_number);
8495 return &cci->fd_perf_core;
8498 return &cci->fd_perf_pkg;
8505 int ret = -1;
8508 return -1;
8510 if (!cai->perf_name)
8511 return -1;
8513 int *pfd_group = get_cstate_perf_group_fd(cci, cai->perf_subsys);
8518 const unsigned int type = read_perf_type(cai->perf_subsys);
8519 const unsigned int config = read_perf_config(cai->perf_subsys, cai->perf_name);
8523 if (ret == -1)
8527 if (*pfd_group == -1)
8539 int ret = -1;
8542 return -1;
8544 if (!cai->perf_name)
8545 return -1;
8547 const unsigned int type = read_perf_type(cai->perf_subsys);
8548 const unsigned int config = read_perf_config(cai->perf_subsys, cai->perf_name);
8550 ret = open_perf_counter(cpu, type, config, cci->fd_perf, PERF_FORMAT_GROUP);
8552 if (ret == -1)
8556 if (cci->fd_perf == -1)
8557 cci->fd_perf = ret;
8561 fprintf(stderr, "%s: %s/%s: %d (cpu: %d)\n", __func__, cai->perf_subsys, cai->perf_name, ret, cpu);
8576 msr_counter_info[cpu].fd_perf = -1;
8582 cai->present = false;
8591 if (cai->needed) {
8593 if (add_msr_perf_counter(cpu, cci, cai) != -1) {
8594 cci->source[cai->rci_index] = COUNTER_SOURCE_PERF;
8595 cai->present = true;
8598 } else if (add_msr_counter(cpu, cai->msr) >= 0) {
8599 cci->source[cai->rci_index] = COUNTER_SOURCE_MSR;
8600 cci->msr[cai->rci_index] = cai->msr;
8601 cci->msr_mask[cai->rci_index] = cai->msr_mask;
8602 cai->present = true;
8613 const bool need_soft_c1 = (!platform->has_msr_core_c1_res) && (platform->supported_cstates & CC1);
8667 ccstate_counter_info[cpu].fd_perf_core = -1;
8668 ccstate_counter_info[cpu].fd_perf_pkg = -1;
8691 const bool per_thread = cai->flags & CSTATE_COUNTER_FLAG_COLLECT_PER_THREAD;
8692 const bool per_core = cai->flags & CSTATE_COUNTER_FLAG_COLLECT_PER_CORE;
8700 const bool counter_needed = BIC_IS_ENABLED(cai->bic_number) ||
8701 (soft_c1 && (cai->flags & CSTATE_COUNTER_FLAG_SOFT_C1_DEPENDENCY));
8702 const bool counter_supported = (platform->supported_cstates & cai->feature_mask);
8706 if (add_cstate_perf_counter(cpu, cci, cai) != -1) {
8708 cci->source[cai->rci_index] = COUNTER_SOURCE_PERF;
8711 } else if (pkg_cstate_limit >= cai->pkg_cstate_limit
8712 && add_msr_counter(cpu, cai->msr) >= 0) {
8713 cci->source[cai->rci_index] = COUNTER_SOURCE_MSR;
8714 cci->msr[cai->rci_index] = cai->msr;
8718 if (cci->source[cai->rci_index] != COUNTER_SOURCE_NONE) {
8727 BIC_PRESENT(cai->bic_number);
8740 const bool soft_c1 = !platform->has_msr_core_c1_res && has_amperf_access()
8741 && platform->supported_cstates & CC1;
8753 if (platform->has_msr_module_c6_res_ms)
8756 if (platform->has_ext_cst_msrs && !no_msr) {
8868 ecx_flags & (1 << 0) ? "SSE3" : "-",
8869 ecx_flags & (1 << 3) ? "MONITOR" : "-",
8870 ecx_flags & (1 << 6) ? "SMX" : "-",
8871 ecx_flags & (1 << 7) ? "EIST" : "-",
8872 ecx_flags & (1 << 8) ? "TM2" : "-",
8873 edx_flags & (1 << 4) ? "TSC" : "-",
8874 edx_flags & (1 << 5) ? "MSR" : "-",
8875 edx_flags & (1 << 22) ? "ACPI-TM" : "-",
8876 edx_flags & (1 << 28) ? "HT" : "-", edx_flags & (1 << 29) ? "TM" : "-");
8887 * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
8918 has_aperf ? "" : "No-",
8919 has_turbo ? "" : "No-",
8920 do_dts ? "" : "No-",
8921 do_ptm ? "" : "No-",
8922 has_hwp ? "" : "No-",
8923 has_hwp_notify ? "" : "No-",
8924 has_hwp_activity_window ? "" : "No-",
8925 has_hwp_epp ? "" : "No-", has_hwp_pkg ? "" : "No-", has_epb ? "" : "No-");
8941 fprintf(outf, "CPUID(7): %sSGX %sHybrid\n", has_sgx ? "" : "No-", is_hybrid ? "" : "No-");
8963 crystal_hz = platform->crystal_freq;
8988 if (platform->enable_tsc_tweak)
8997 aperf_mperf_multiplier = platform->need_perf_multiplier ? 1024 : 1;
9009 if (platform->has_msr_knl_core_c6_residency && cai->msr == MSR_CORE_C6_RESIDENCY)
9010 cai->msr = MSR_KNL_CORE_C6_RESIDENCY;
9012 if (!platform->has_msr_core_c1_res && cai->msr == MSR_CORE_C1_RES)
9013 cai->msr = 0;
9015 if (platform->has_msr_atom_pkg_c6_residency && cai->msr == MSR_PKG_C6_RESIDENCY)
9016 cai->msr = MSR_ATOM_PKG_C6_RESIDENCY;
9041 if (platform->has_nhm_msrs && !no_msr)
9054 if (isdigit(dirp->d_name[0]))
9070 return -1;
9084 return -1;
9182 err(-ENODEV, "No valid cpus found");
9304 (*t)[i].cpu_id = -1;
9311 (*c)[i].core_id = -1;
9312 (*c)[i].base_cpu = -1;
9321 (*p)[i].base_cpu = -1;
9343 /* Workaround for systems where physical_node_id==-1
9344 * and logical_node_id==(-1 - topo.num_cpus)
9352 t->cpu_id = cpu_id;
9354 if (c->base_cpu < 0)
9355 c->base_cpu = t->cpu_id;
9357 pkg_base[pkg_id].base_cpu = t->cpu_id;
9360 c->core_id = core_id;
9376 err(-1, "calloc output buffer");
9383 err(-1, "calloc fd_percpu");
9390 err(-1, "calloc %d", topo.num_cpus);
9394 err(-1, "calloc %d IRQ", topo.max_cpu_num + 1);
9398 err(-1, "calloc %d NMI", topo.max_cpu_num + 1);
9404 if ((int)t->cpu_id == c->base_cpu)
9406 if ((int)t->cpu_id == p->base_cpu)
9444 err(-ENODEV, "No valid cpus found");
9477 * -1: doesn't have separate perf device for p and e core
9488 cached = -1;
9493 cached = -1;
9518 switch (pinfo->scope) {
9533 pinfo->fd_perf_per_domain = calloc(num_domains, sizeof(*pinfo->fd_perf_per_domain));
9534 if (!pinfo->fd_perf_per_domain)
9538 pinfo->fd_perf_per_domain[i] = -1;
9540 pinfo->num_domains = num_domains;
9541 pinfo->scale = 1.0;
9567 const char *perf_device = pinfo->device;
9585 if (perf_type == (unsigned int)-1) {
9586 warnx("%s: perf/%s/%s: failed to read %s", __func__, perf_device, pinfo->event, "type");
9590 perf_config = read_perf_config(perf_device, pinfo->event);
9591 if (perf_config == (unsigned int)-1) {
9593 __func__, perf_device, pinfo->event, "config");
9598 perf_scale = read_perf_scale(perf_device, pinfo->event);
9602 fd_perf = open_perf_counter(cpu, perf_type, perf_config, -1, 0);
9603 if (fd_perf == -1) {
9605 __func__, perf_device, pinfo->event, cpu);
9610 pinfo->fd_perf_per_domain[next_domain] = fd_perf;
9611 pinfo->scale = perf_scale;
9615 perf_device, pinfo->event, cpu, pinfo->fd_perf_per_domain[next_domain]);
9618 pinfo = pinfo->next;
9645 if (fd_telem_info == -1)
9646 return -1;
9651 return -1;
9656 return -1;
9678 if (stat(SYSFS_TELEM_PATH, &st) == -1)
9689 if (fstatat(dirfd(pmt_iter.dir), entry->d_name, &st, 0) == -1)
9695 fd_telem_dir = openat(dirfd(pmt_iter.dir), entry->d_name, O_RDONLY);
9696 if (fd_telem_dir == -1)
9722 if (fd_pmt == -1)
9744 new_pmt->guid = guid;
9745 new_pmt->mmio_base = mmio;
9746 new_pmt->pmt_offset = offset;
9747 new_pmt->size = size;
9748 new_pmt->next = pmt_mmios;
9751 last->next = new_pmt;
9780 if (pmmio->guid == guid)
9783 pmmio = pmmio->next;
9794 ret = (char *)pmmio->mmio_base;
9799 * - we might have to apply the offset first.
9801 ret += pmmio->pmt_offset;
9818 ret = ret->next;
9819 --seq;
9833 if (strcmp(pcounter->name, name) == 0)
9836 pcounter = pcounter->next;
9859 if (domain_id >= pcounter->num_domains)
9862 assert(pcounter->domains);
9863 assert(domain_id < pcounter->num_domains);
9865 pcounter->domains[domain_id].pcounter = pmmio;
9898 if (offset >= mmio->size) {
9900 fprintf(stderr, "%s: offset %u outside of PMT MMIO size %u\n", __func__, offset, mmio->size);
9914 strncpy(pcounter->name, name, ARRAY_SIZE(pcounter->name) - 1);
9915 pcounter->type = type;
9916 pcounter->scope = scope;
9917 pcounter->lsb = lsb;
9918 pcounter->msb = msb;
9919 pcounter->format = format;
9921 conflict += pcounter->type != type;
9922 conflict += pcounter->scope != scope;
9923 conflict += pcounter->lsb != lsb;
9924 conflict += pcounter->msb != msb;
9925 conflict += pcounter->format != format;
9937 pcounter->next = *pmt_root;
10030 if (BIC_IS_ENABLED(BIC_IPC) && has_aperf_access && get_instr_count_fd(base_cpu) != -1)
10037 if (platform->enable_tsc_tweak && !has_base_hz) {
10076 if (child_pid == -1)
10081 if (waitpid(child_pid, &status, 0) == -1)
10089 * because re-starting is problematic when forking
10129 fprintf(outf, "turbostat version 2025.09.09 - Len Brown <lenb@kernel.org>\n");
10145 ret = fread(bootcmd, sizeof(char), COMMAND_LINE_SIZE - 1, fp);
10159 for (mp = head; mp; mp = mp->next) {
10161 fprintf(stderr, "%s: %s %s\n", __func__, name, mp->name);
10162 if (!strcmp(name, mp->name))
10175 errx(1, "Requested MSR counter 0x%x, but in --no-msr mode", msr_num);
10192 return -1;
10204 return -1;
10216 return -1;
10221 return -1;
10227 err(-1, "calloc msr_counter");
10229 msrp->msr_num = msr_num;
10230 strncpy(msrp->name, name, NAME_BYTES - 1);
10231 msrp->width = width;
10232 msrp->type = type;
10233 msrp->format = format;
10234 msrp->flags = flags;
10238 msrp->next = sys.tp;
10242 msrp->next = sys.cp;
10246 msrp->next = sys.pp;
10260 strncpy(sp->path, path, PATH_BYTES - 1);
10261 sp->id = id;
10262 sp->next = msrp->sp;
10263 msrp->sp = sp;
10289 strncpy(pinfo->device, perf_device, ARRAY_SIZE(pinfo->device) - 1);
10290 strncpy(pinfo->event, perf_event, ARRAY_SIZE(pinfo->event) - 1);
10292 strncpy(pinfo->name, name, ARRAY_SIZE(pinfo->name) - 1);
10293 pinfo->width = width;
10294 pinfo->scope = scope;
10295 pinfo->type = type;
10296 pinfo->format = format;
10310 return -1;
10317 return -1;
10324 return -1;
10332 return -1;
10336 pinfo->next = sys.perf_tp;
10342 pinfo->next = sys.perf_cp;
10348 pinfo->next = sys.perf_pp;
10357 __func__, pinfo->device, pinfo->event, pinfo->name, pinfo->scope);
10458 fprintf(stderr, "--add: (msrDDD | msr0xXXX | /path_to_counter | perf/device/event) required\n");
10462 /* Test for non-empty perf_device and perf_event */
10501 int fd_telem_dir = -1;
10505 int ret = -1;
10508 if (fd_target_dir == -1) {
10509 return -1;
10512 if (fstat(fd_target_dir, &target_stat) == -1) {
10529 fd_telem_dir = openat(dirfd(pmt_iter.dir), dirname->d_name, O_RDONLY | O_DIRECTORY);
10530 if (fd_telem_dir == -1)
10538 if (fstat(fd_telem_dir, &stat) == -1) {
10540 dirname->d_name, strerror(errno));
10562 fd_telem_dir = -1;
10567 if (fd_telem_dir != -1)
10841 exit(-EINVAL);
10853 for (state = 10; state >= 0; --state) {
10862 /* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */
10863 sp = strchr(name_buf, '-');
10902 for (state = 10; state >= 0; --state) {
10920 /* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */
10921 sp = strchr(name_buf, '-');
10950 *sp = '-';
10960 * 1,2,4..6,8-10 and set bits in cpu_subset
10992 fprintf(stderr, "\"--cpu %s\" malformed\n", optarg);
10994 exit(-1);
11013 { "hide", required_argument, 0, 'H' }, // meh, -h taken by --help
11018 { "no-msr", no_argument, 0, 'M' },
11019 { "no-perf", no_argument, 0, 'P' },
11031 * like adding the MSR counter with --add and at the same time using --no-msr.
11033 while ((opt = getopt_long_only(argc, argv, "+MPn:", long_options, &option_index)) != -1) {
11047 while ((opt = getopt_long_only(argc, argv, "+C:c:Dde:hi:Jn:o:qMST:v", long_options, &option_index)) != -1) {
11065 /* --enable specified counter, without clearning existing list */
11077 * --hide: do not show those specified
11103 interval_tv.tv_usec = (interval - interval_tv.tv_sec) * 1000000;
11104 interval_ts.tv_nsec = (interval - interval_ts.tv_sec) * 1000000000;
11143 * --show: show only those specified
11193 if (ret == -1)
11234 if (argc - optind)