1 /* 2 * (C) 2010,2011 Thomas Renninger <trenn@suse.de>, Novell Inc. 3 * 4 * Licensed under the terms of the GNU GPL License version 2. 5 * 6 * Based on Len Brown's <lenb@kernel.org> turbostat tool. 7 */ 8 9 #if defined(__i386__) || defined(__x86_64__) 10 11 #include <stdio.h> 12 #include <stdint.h> 13 #include <stdlib.h> 14 #include <string.h> 15 16 #include "helpers/helpers.h" 17 #include "idle_monitor/cpupower-monitor.h" 18 19 #define MSR_PKG_C3_RESIDENCY 0x3F8 20 #define MSR_PKG_C6_RESIDENCY 0x3F9 21 #define MSR_CORE_C3_RESIDENCY 0x3FC 22 #define MSR_CORE_C6_RESIDENCY 0x3FD 23 24 #define MSR_TSC 0x10 25 26 #define NHM_CSTATE_COUNT 4 27 28 enum intel_nhm_id { C3 = 0, C6, PC3, PC6, TSC = 0xFFFF }; 29 30 static int nhm_get_count_percent(unsigned int self_id, double *percent, 31 unsigned int cpu); 32 33 static cstate_t nhm_cstates[NHM_CSTATE_COUNT] = { 34 { 35 .name = "C3", 36 .desc = N_("Processor Core C3"), 37 .id = C3, 38 .range = RANGE_CORE, 39 .get_count_percent = nhm_get_count_percent, 40 }, 41 { 42 .name = "C6", 43 .desc = N_("Processor Core C6"), 44 .id = C6, 45 .range = RANGE_CORE, 46 .get_count_percent = nhm_get_count_percent, 47 }, 48 49 { 50 .name = "PC3", 51 .desc = N_("Processor Package C3"), 52 .id = PC3, 53 .range = RANGE_PACKAGE, 54 .get_count_percent = nhm_get_count_percent, 55 }, 56 { 57 .name = "PC6", 58 .desc = N_("Processor Package C6"), 59 .id = PC6, 60 .range = RANGE_PACKAGE, 61 .get_count_percent = nhm_get_count_percent, 62 }, 63 }; 64 65 static unsigned long long tsc_at_measure_start; 66 static unsigned long long tsc_at_measure_end; 67 static unsigned long long *previous_count[NHM_CSTATE_COUNT]; 68 static unsigned long long *current_count[NHM_CSTATE_COUNT]; 69 /* valid flag for all CPUs. If a MSR read failed it will be zero */ 70 static int *is_valid; 71 72 static int nhm_get_count(enum intel_nhm_id id, unsigned long long *val, 73 unsigned int cpu) 74 { 75 int msr; 76 77 switch (id) { 78 case C3: 79 msr = MSR_CORE_C3_RESIDENCY; 80 break; 81 case C6: 82 msr = MSR_CORE_C6_RESIDENCY; 83 break; 84 case PC3: 85 msr = MSR_PKG_C3_RESIDENCY; 86 break; 87 case PC6: 88 msr = MSR_PKG_C6_RESIDENCY; 89 break; 90 case TSC: 91 msr = MSR_TSC; 92 break; 93 default: 94 return -1; 95 }; 96 if (read_msr(cpu, msr, val)) 97 return -1; 98 99 return 0; 100 } 101 102 static int nhm_get_count_percent(unsigned int id, double *percent, 103 unsigned int cpu) 104 { 105 *percent = 0.0; 106 107 if (!is_valid[cpu]) 108 return -1; 109 110 *percent = (100.0 * 111 (current_count[id][cpu] - previous_count[id][cpu])) / 112 (tsc_at_measure_end - tsc_at_measure_start); 113 114 dprint("%s: previous: %llu - current: %llu - (%u)\n", 115 nhm_cstates[id].name, previous_count[id][cpu], 116 current_count[id][cpu], cpu); 117 118 dprint("%s: tsc_diff: %llu - count_diff: %llu - percent: %2.f (%u)\n", 119 nhm_cstates[id].name, 120 (unsigned long long) tsc_at_measure_end - tsc_at_measure_start, 121 current_count[id][cpu] - previous_count[id][cpu], 122 *percent, cpu); 123 124 return 0; 125 } 126 127 static int nhm_start(void) 128 { 129 int num, cpu; 130 unsigned long long dbg, val; 131 132 nhm_get_count(TSC, &tsc_at_measure_start, base_cpu); 133 134 for (num = 0; num < NHM_CSTATE_COUNT; num++) { 135 for (cpu = 0; cpu < cpu_count; cpu++) { 136 is_valid[cpu] = !nhm_get_count(num, &val, cpu); 137 previous_count[num][cpu] = val; 138 } 139 } 140 nhm_get_count(TSC, &dbg, base_cpu); 141 dprint("TSC diff: %llu\n", dbg - tsc_at_measure_start); 142 return 0; 143 } 144 145 static int nhm_stop(void) 146 { 147 unsigned long long val; 148 unsigned long long dbg; 149 int num, cpu; 150 151 nhm_get_count(TSC, &tsc_at_measure_end, base_cpu); 152 153 for (num = 0; num < NHM_CSTATE_COUNT; num++) { 154 for (cpu = 0; cpu < cpu_count; cpu++) { 155 is_valid[cpu] = !nhm_get_count(num, &val, cpu); 156 current_count[num][cpu] = val; 157 } 158 } 159 nhm_get_count(TSC, &dbg, base_cpu); 160 dprint("TSC diff: %llu\n", dbg - tsc_at_measure_end); 161 162 return 0; 163 } 164 165 struct cpuidle_monitor intel_nhm_monitor; 166 167 struct cpuidle_monitor *intel_nhm_register(void) 168 { 169 int num; 170 171 if (cpupower_cpu_info.vendor != X86_VENDOR_INTEL) 172 return NULL; 173 174 if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_INV_TSC)) 175 return NULL; 176 177 if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_APERF)) 178 return NULL; 179 180 /* Free this at program termination */ 181 is_valid = calloc(cpu_count, sizeof(int)); 182 for (num = 0; num < NHM_CSTATE_COUNT; num++) { 183 previous_count[num] = calloc(cpu_count, 184 sizeof(unsigned long long)); 185 current_count[num] = calloc(cpu_count, 186 sizeof(unsigned long long)); 187 } 188 189 intel_nhm_monitor.name_len = strlen(intel_nhm_monitor.name); 190 return &intel_nhm_monitor; 191 } 192 193 void intel_nhm_unregister(void) 194 { 195 int num; 196 197 for (num = 0; num < NHM_CSTATE_COUNT; num++) { 198 free(previous_count[num]); 199 free(current_count[num]); 200 } 201 free(is_valid); 202 } 203 204 struct cpuidle_monitor intel_nhm_monitor = { 205 .name = "Nehalem", 206 .hw_states_num = NHM_CSTATE_COUNT, 207 .hw_states = nhm_cstates, 208 .start = nhm_start, 209 .stop = nhm_stop, 210 .do_register = intel_nhm_register, 211 .unregister = intel_nhm_unregister, 212 .needs_root = 1, 213 .overflow_s = 922000000 /* 922337203 seconds TSC overflow 214 at 20GHz */ 215 }; 216 #endif 217