1 /* 2 * Copyright 2009, Intel Corporation 3 * Copyright 2009, Sun Microsystems, Inc 4 * 5 * This file is part of PowerTOP 6 * 7 * This program file is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the 9 * Free Software Foundation; version 2 of the License. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program in a file named COPYING; if not, write to the 18 * Free Software Foundation, Inc., 19 * 51 Franklin Street, Fifth Floor, 20 * Boston, MA 02110-1301 USA 21 * 22 * Authors: 23 * Arjan van de Ven <arjan@linux.intel.com> 24 * Eric C Saxe <eric.saxe@sun.com> 25 * Aubrey Li <aubrey.li@intel.com> 26 */ 27 28 /* 29 * GPL Disclaimer 30 * 31 * For the avoidance of doubt, except that if any license choice other 32 * than GPL or LGPL is available it will apply instead, Sun elects to 33 * use only the General Public License version 2 (GPLv2) at this time 34 * for any software where a choice of GPL license versions is made 35 * available with the language indicating that GPLv2 or any later 36 * version may be used, or where a choice of which version of the GPL 37 * is applied is otherwise unspecified. 38 */ 39 40 #include <getopt.h> 41 #include <unistd.h> 42 #include <stdio.h> 43 #include <stdlib.h> 44 #include <signal.h> 45 #include <string.h> 46 #include <ctype.h> 47 #include <poll.h> 48 #include "powertop.h" 49 50 /* 51 * Global variables, see powertop.h for comments and extern declarations. 52 * These are ordered by type, grouped by usage. 53 */ 54 int g_bit_depth; 55 int g_total_events, g_top_events; 56 int g_npstates, g_max_cstate, g_longest_cstate; 57 uint_t g_features; 58 uint_t g_ncpus; 59 uint_t g_ncpus_observed; 60 61 processorid_t *g_cpu_table; 62 63 double g_interval_length; 64 hrtime_t g_total_c_time; 65 66 uchar_t g_op_mode; 67 boolean_t g_gui; 68 uint_t g_observed_cpu; 69 70 event_info_t g_event_info[EVENT_NUM_MAX]; 71 state_info_t g_cstate_info[NSTATES]; 72 freq_state_info_t g_pstate_info[NSTATES]; 73 cpu_power_info_t *g_cpu_power_states; 74 75 boolean_t g_turbo_supported; 76 boolean_t g_sig_resize; 77 78 uint_t g_argc; 79 char **g_argv; 80 81 static const int true = 1; 82 83 void 84 pt_sig_handler(int sig) 85 { 86 switch (sig) { 87 case SIGWINCH: 88 g_sig_resize = B_TRUE; 89 break; 90 } 91 } 92 93 int 94 main(int argc, char **argv) 95 { 96 double interval, interval_usr; 97 hrtime_t interval_start; 98 int index2 = 0, c, dump_count = 0; 99 char *endptr, key; 100 boolean_t root_user = B_FALSE; 101 struct pollfd pollset; 102 103 static struct option opts[] = { 104 { "dump", 1, NULL, 'd' }, 105 { "time", 1, NULL, 't' }, 106 { "help", 0, NULL, 'h' }, 107 { "cpu", 1, NULL, 'c' }, 108 { "verbose", 0, NULL, 'v' }, 109 { 0, 0, NULL, 0 } 110 }; 111 112 pt_set_progname(argv[0]); 113 114 /* 115 * Enumerate the system's CPUs, populate cpu_table, g_ncpus 116 */ 117 if ((g_ncpus = g_ncpus_observed = pt_enumerate_cpus()) == 0) 118 exit(EXIT_FAILURE); 119 120 if ((g_bit_depth = pt_get_bit_depth()) < 0) 121 exit(EXIT_FAILURE); 122 123 g_features = 0; 124 interval = interval_usr = INTERVAL_DEFAULT; 125 g_op_mode = PT_MODE_DEFAULT; 126 g_max_cstate = 0; 127 g_argv = NULL; 128 g_argc = 0; 129 g_observed_cpu = 0; 130 g_turbo_supported = B_FALSE; 131 g_sig_resize = B_FALSE; 132 g_curr_sugg = NULL; 133 134 while ((c = getopt_long(argc, argv, "d:t:hvc:", opts, &index2)) 135 != EOF) { 136 if (c == -1) 137 break; 138 139 switch (c) { 140 case 'd': 141 if (PT_ON_DUMP) { 142 pt_usage(); 143 exit(EXIT_USAGE); 144 } 145 146 g_op_mode |= PT_MODE_DUMP; 147 g_gui = B_FALSE; 148 dump_count = (int)strtod(optarg, &endptr); 149 150 if (dump_count <= 0 || *endptr != NULL) { 151 pt_usage(); 152 exit(EXIT_USAGE); 153 } 154 155 break; 156 case 't': 157 if (PT_ON_TIME) { 158 pt_usage(); 159 exit(EXIT_USAGE); 160 } 161 162 g_op_mode |= PT_MODE_TIME; 163 interval = interval_usr = (double)strtod(optarg, 164 &endptr); 165 166 if (*endptr != NULL || interval < 1 || 167 interval > INTERVAL_MAX) { 168 pt_usage(); 169 exit(EXIT_USAGE); 170 } 171 172 break; 173 case 'v': 174 if (PT_ON_CPU || PT_ON_VERBOSE) { 175 pt_usage(); 176 exit(EXIT_USAGE); 177 } 178 179 g_op_mode |= PT_MODE_VERBOSE; 180 break; 181 case 'c': 182 if (PT_ON_CPU || PT_ON_VERBOSE) { 183 pt_usage(); 184 exit(EXIT_USAGE); 185 } 186 187 g_op_mode |= PT_MODE_CPU; 188 g_observed_cpu = (uint_t)strtod(optarg, &endptr); 189 190 if (g_observed_cpu >= g_ncpus) { 191 pt_usage(); 192 exit(EXIT_USAGE); 193 } 194 195 g_argc = 1; 196 g_ncpus_observed = 1; 197 198 if ((g_argv = malloc(sizeof (char *))) == NULL) 199 return (EXIT_FAILURE); 200 201 if ((*g_argv = malloc(sizeof (char) * 5)) == NULL) 202 return (EXIT_FAILURE); 203 204 (void) snprintf(*g_argv, 5, "%d\0", g_observed_cpu); 205 break; 206 case 'h': 207 pt_usage(); 208 exit(EXIT_SUCCESS); 209 default: 210 pt_usage(); 211 exit(EXIT_USAGE); 212 } 213 } 214 215 if (optind < argc) { 216 pt_usage(); 217 exit(EXIT_USAGE); 218 } 219 220 (void) printf("%s %s\n\n", TITLE, COPYRIGHT_INTEL); 221 222 (void) printf("Collecting data for %.2f second(s) \n", 223 (float)interval); 224 225 /* Prepare P-state statistics */ 226 if (pt_cpufreq_stat_prepare() == 0) 227 g_features |= FEATURE_PSTATE; 228 229 /* Prepare C-state statistics */ 230 if (pt_cpuidle_stat_prepare() == 0) 231 g_features |= FEATURE_CSTATE; 232 else 233 /* 234 * PowerTop was unable to run a DTrace program, 235 * most likely for lack of permissions. 236 */ 237 exit(EXIT_FAILURE); 238 239 /* Prepare event statistics */ 240 if (pt_events_stat_prepare() != -1) 241 g_features |= FEATURE_EVENTS; 242 243 /* 244 * If the system is running on battery, find out what's 245 * the kstat module for it 246 */ 247 pt_battery_mod_lookup(); 248 249 /* Prepare turbo statistics */ 250 if (pt_turbo_stat_prepare() == 0) 251 g_features |= FEATURE_TURBO; 252 253 /* 254 * Initialize the display. 255 */ 256 if (!PT_ON_DUMP) { 257 pt_display_init_curses(); 258 pt_display_setup(B_FALSE); 259 (void) signal(SIGWINCH, pt_sig_handler); 260 261 pt_display_title_bar(); 262 pt_display_status_bar(); 263 264 g_gui = B_TRUE; 265 pollset.fd = STDIN_FILENO; 266 pollset.events = POLLIN; 267 } 268 269 /* 270 * Installs the initial suggestions, running as root and turning CPU 271 * power management ON. 272 */ 273 if (geteuid() != 0) { 274 pt_sugg_as_root(); 275 } else { 276 root_user = B_TRUE; 277 pt_cpufreq_suggest(); 278 } 279 280 while (true) { 281 key = 0; 282 283 if (g_sig_resize) 284 pt_display_resize(); 285 286 interval_start = gethrtime(); 287 288 if (!PT_ON_DUMP) { 289 if (poll(&pollset, (nfds_t)1, 290 (int)(interval * MILLISEC)) > 0) 291 (void) read(STDIN_FILENO, &key, 1); 292 } else { 293 (void) sleep((int)interval); 294 } 295 296 g_interval_length = (double)(gethrtime() - interval_start) 297 /NANOSEC; 298 299 g_top_events = 0; 300 g_total_events = 0; 301 302 (void) memset(g_event_info, 0, 303 EVENT_NUM_MAX * sizeof (event_info_t)); 304 (void) memset(g_cstate_info, 0, 305 NSTATES * sizeof (state_info_t)); 306 307 /* Collect idle state transition stats */ 308 if (g_features & FEATURE_CSTATE && 309 pt_cpuidle_stat_collect(g_interval_length) < 0) { 310 /* Reinitialize C-state statistics */ 311 if (pt_cpuidle_stat_prepare() != 0) 312 exit(EXIT_FAILURE); 313 314 continue; 315 } 316 317 /* Collect frequency change stats */ 318 if (g_features & FEATURE_PSTATE && 319 pt_cpufreq_stat_collect(g_interval_length) < 0) { 320 /* Reinitialize P-state statistics */ 321 if (pt_cpufreq_stat_prepare() != 0) 322 exit(EXIT_FAILURE); 323 324 continue; 325 } 326 327 /* Collect event statistics */ 328 if (g_features & FEATURE_EVENTS && 329 pt_events_stat_collect() < 0) { 330 /* Reinitialize event statistics */ 331 if (pt_events_stat_prepare() != 0) 332 exit(EXIT_FAILURE); 333 334 continue; 335 } 336 337 /* Collect turbo statistics */ 338 if (g_features & FEATURE_TURBO && 339 pt_turbo_stat_collect() < 0) 340 exit(EXIT_FAILURE); 341 342 /* Show CPU power states */ 343 pt_display_states(); 344 345 /* Show wakeups events affecting PM */ 346 if (g_features & FEATURE_EVENTS) { 347 pt_display_wakeups(g_interval_length); 348 pt_display_events(g_interval_length); 349 } 350 351 pt_battery_print(); 352 353 if (key && !PT_ON_DUMP) { 354 switch (toupper(key)) { 355 case 'Q': 356 exit(EXIT_SUCCESS); 357 break; 358 359 case 'R': 360 interval = 3; 361 break; 362 } 363 364 /* 365 * Check if the user has activated the current 366 * suggestion. 367 */ 368 if (g_curr_sugg != NULL && 369 toupper(key) == g_curr_sugg->key && 370 g_curr_sugg->func) 371 g_curr_sugg->func(); 372 } 373 374 if (dump_count) 375 dump_count--; 376 377 /* Exits if user requested a dump */ 378 if (PT_ON_DUMP && !dump_count) 379 exit(EXIT_SUCCESS); 380 381 /* No key pressed, will suggest something */ 382 if (!key && !dump_count) 383 pt_sugg_pick(); 384 385 /* Refresh display */ 386 if (!PT_ON_DUMP) 387 pt_display_update(); 388 389 if (root_user) 390 pt_cpufreq_suggest(); 391 392 /* 393 * Update the interval based on how long the CPU was in the 394 * longest c-state during the last snapshot. If the user 395 * specified an interval we skip this bit and keep it fixed. 396 */ 397 if (g_features & FEATURE_CSTATE && !PT_ON_TIME && 398 g_longest_cstate > 0 && 399 g_cstate_info[g_longest_cstate].events > 0) { 400 double deep_idle_res = (((double) 401 g_cstate_info[g_longest_cstate].total_time/MICROSEC 402 /g_ncpus)/g_cstate_info[g_longest_cstate].events); 403 404 if (deep_idle_res < INTERVAL_DEFAULT || 405 (g_total_events/interval) < 1) 406 interval = INTERVAL_DEFAULT; 407 else 408 interval = INTERVAL_UPDATE(deep_idle_res); 409 } else { 410 /* 411 * Restore interval after a refresh. 412 */ 413 if (key) 414 interval = interval_usr; 415 } 416 } 417 418 return (EXIT_SUCCESS); 419 } 420