linux/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c
<<
>>
Prefs
   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 *  Output format inspired by Len Brown's <lenb@kernel.org> turbostat tool.
   7 *
   8 */
   9
  10
  11#include <stdio.h>
  12#include <unistd.h>
  13#include <stdlib.h>
  14#include <string.h>
  15#include <time.h>
  16#include <signal.h>
  17#include <sys/types.h>
  18#include <sys/wait.h>
  19#include <libgen.h>
  20
  21#include "idle_monitor/cpupower-monitor.h"
  22#include "idle_monitor/idle_monitors.h"
  23#include "helpers/helpers.h"
  24
  25/* Define pointers to all monitors.  */
  26#define DEF(x) & x ## _monitor ,
  27struct cpuidle_monitor *all_monitors[] = {
  28#include "idle_monitors.def"
  290
  30};
  31
  32static struct cpuidle_monitor *monitors[MONITORS_MAX];
  33static unsigned int avail_monitors;
  34
  35static char *progname;
  36
  37enum operation_mode_e { list = 1, show, show_all };
  38static int mode;
  39static int interval = 1;
  40static char *show_monitors_param;
  41static struct cpupower_topology cpu_top;
  42static unsigned int wake_cpus;
  43
  44/* ToDo: Document this in the manpage */
  45static char range_abbr[RANGE_MAX] = { 'T', 'C', 'P', 'M', };
  46
  47static void print_wrong_arg_exit(void)
  48{
  49        printf(_("invalid or unknown argument\n"));
  50        exit(EXIT_FAILURE);
  51}
  52
  53long long timespec_diff_us(struct timespec start, struct timespec end)
  54{
  55        struct timespec temp;
  56        if ((end.tv_nsec - start.tv_nsec) < 0) {
  57                temp.tv_sec = end.tv_sec - start.tv_sec - 1;
  58                temp.tv_nsec = 1000000000 + end.tv_nsec - start.tv_nsec;
  59        } else {
  60                temp.tv_sec = end.tv_sec - start.tv_sec;
  61                temp.tv_nsec = end.tv_nsec - start.tv_nsec;
  62        }
  63        return (temp.tv_sec * 1000000) + (temp.tv_nsec / 1000);
  64}
  65
  66void print_n_spaces(int n)
  67{
  68        int x;
  69        for (x = 0; x < n; x++)
  70                printf(" ");
  71}
  72
  73/* size of s must be at least n + 1 */
  74int fill_string_with_spaces(char *s, int n)
  75{
  76        int len = strlen(s);
  77        if (len > n)
  78                return -1;
  79        for (; len < n; len++)
  80                s[len] = ' ';
  81        s[len] = '\0';
  82        return 0;
  83}
  84
  85void print_header(int topology_depth)
  86{
  87        int unsigned mon;
  88        int state, need_len;
  89        cstate_t s;
  90        char buf[128] = "";
  91        int percent_width = 4;
  92
  93        fill_string_with_spaces(buf, topology_depth * 5 - 1);
  94        printf("%s|", buf);
  95
  96        for (mon = 0; mon < avail_monitors; mon++) {
  97                need_len = monitors[mon]->hw_states_num * (percent_width + 3)
  98                        - 1;
  99                if (mon != 0) {
 100                        printf("|| ");
 101                        need_len--;
 102                }
 103                sprintf(buf, "%s", monitors[mon]->name);
 104                fill_string_with_spaces(buf, need_len);
 105                printf("%s", buf);
 106        }
 107        printf("\n");
 108
 109        if (topology_depth > 2)
 110                printf("PKG |");
 111        if (topology_depth > 1)
 112                printf("CORE|");
 113        if (topology_depth > 0)
 114                printf("CPU |");
 115
 116        for (mon = 0; mon < avail_monitors; mon++) {
 117                if (mon != 0)
 118                        printf("|| ");
 119                else
 120                        printf(" ");
 121                for (state = 0; state < monitors[mon]->hw_states_num; state++) {
 122                        if (state != 0)
 123                                printf(" | ");
 124                        s = monitors[mon]->hw_states[state];
 125                        sprintf(buf, "%s", s.name);
 126                        fill_string_with_spaces(buf, percent_width);
 127                        printf("%s", buf);
 128                }
 129                printf(" ");
 130        }
 131        printf("\n");
 132}
 133
 134
 135void print_results(int topology_depth, int cpu)
 136{
 137        unsigned int mon;
 138        int state, ret;
 139        double percent;
 140        unsigned long long result;
 141        cstate_t s;
 142
 143        /* Be careful CPUs may got resorted for pkg value do not just use cpu */
 144        if (!bitmask_isbitset(cpus_chosen, cpu_top.core_info[cpu].cpu))
 145                return;
 146        if (!cpu_top.core_info[cpu].is_online &&
 147            cpu_top.core_info[cpu].pkg == -1)
 148                return;
 149
 150        if (topology_depth > 2)
 151                printf("%4d|", cpu_top.core_info[cpu].pkg);
 152        if (topology_depth > 1)
 153                printf("%4d|", cpu_top.core_info[cpu].core);
 154        if (topology_depth > 0)
 155                printf("%4d|", cpu_top.core_info[cpu].cpu);
 156
 157        for (mon = 0; mon < avail_monitors; mon++) {
 158                if (mon != 0)
 159                        printf("||");
 160
 161                for (state = 0; state < monitors[mon]->hw_states_num; state++) {
 162                        if (state != 0)
 163                                printf("|");
 164
 165                        s = monitors[mon]->hw_states[state];
 166
 167                        if (s.get_count_percent) {
 168                                ret = s.get_count_percent(s.id, &percent,
 169                                                  cpu_top.core_info[cpu].cpu);
 170                                if (ret)
 171                                        printf("******");
 172                                else if (percent >= 100.0)
 173                                        printf("%6.1f", percent);
 174                                else
 175                                        printf("%6.2f", percent);
 176                        } else if (s.get_count) {
 177                                ret = s.get_count(s.id, &result,
 178                                                  cpu_top.core_info[cpu].cpu);
 179                                if (ret)
 180                                        printf("******");
 181                                else
 182                                        printf("%6llu", result);
 183                        } else {
 184                                printf(_("Monitor %s, Counter %s has no count "
 185                                         "function. Implementation error\n"),
 186                                       monitors[mon]->name, s.name);
 187                                exit(EXIT_FAILURE);
 188                        }
 189                }
 190        }
 191        /*
 192         * The monitor could still provide useful data, for example
 193         * AMD HW counters partly sit in PCI config space.
 194         * It's up to the monitor plug-in to check .is_online, this one
 195         * is just for additional info.
 196         */
 197        if (!cpu_top.core_info[cpu].is_online &&
 198            cpu_top.core_info[cpu].pkg != -1) {
 199                printf(_(" *is offline\n"));
 200                return;
 201        } else
 202                printf("\n");
 203}
 204
 205
 206/* param: string passed by -m param (The list of monitors to show)
 207 *
 208 * Monitors must have been registered already, matching monitors
 209 * are picked out and available monitors array is overridden
 210 * with matching ones
 211 *
 212 * Monitors get sorted in the same order the user passes them
 213*/
 214
 215static void parse_monitor_param(char *param)
 216{
 217        unsigned int num;
 218        int mon, hits = 0;
 219        char *tmp = param, *token;
 220        struct cpuidle_monitor *tmp_mons[MONITORS_MAX];
 221
 222
 223        for (mon = 0; mon < MONITORS_MAX; mon++, tmp = NULL) {
 224                token = strtok(tmp, ",");
 225                if (token == NULL)
 226                        break;
 227                if (strlen(token) >= MONITOR_NAME_LEN) {
 228                        printf(_("%s: max monitor name length"
 229                                 " (%d) exceeded\n"), token, MONITOR_NAME_LEN);
 230                        continue;
 231                }
 232
 233                for (num = 0; num < avail_monitors; num++) {
 234                        if (!strcmp(monitors[num]->name, token)) {
 235                                dprint("Found requested monitor: %s\n", token);
 236                                tmp_mons[hits] = monitors[num];
 237                                hits++;
 238                        }
 239                }
 240        }
 241        if (hits == 0) {
 242                printf(_("No matching monitor found in %s, "
 243                         "try -l option\n"), param);
 244                exit(EXIT_FAILURE);
 245        }
 246        /* Override detected/registerd monitors array with requested one */
 247        memcpy(monitors, tmp_mons,
 248                sizeof(struct cpuidle_monitor *) * MONITORS_MAX);
 249        avail_monitors = hits;
 250}
 251
 252void list_monitors(void)
 253{
 254        unsigned int mon;
 255        int state;
 256        cstate_t s;
 257
 258        for (mon = 0; mon < avail_monitors; mon++) {
 259                printf(_("Monitor \"%s\" (%d states) - Might overflow after %u "
 260                         "s\n"),
 261                        monitors[mon]->name, monitors[mon]->hw_states_num,
 262                        monitors[mon]->overflow_s);
 263
 264                for (state = 0; state < monitors[mon]->hw_states_num; state++) {
 265                        s = monitors[mon]->hw_states[state];
 266                        /*
 267                         * ToDo show more state capabilities:
 268                         * percent, time (granlarity)
 269                         */
 270                        printf("%s\t[%c] -> %s\n", s.name, range_abbr[s.range],
 271                               gettext(s.desc));
 272                }
 273        }
 274}
 275
 276int fork_it(char **argv)
 277{
 278        int status;
 279        unsigned int num;
 280        unsigned long long timediff;
 281        pid_t child_pid;
 282        struct timespec start, end;
 283
 284        child_pid = fork();
 285        clock_gettime(CLOCK_REALTIME, &start);
 286
 287        for (num = 0; num < avail_monitors; num++)
 288                monitors[num]->start();
 289
 290        if (!child_pid) {
 291                /* child */
 292                execvp(argv[0], argv);
 293        } else {
 294                /* parent */
 295                if (child_pid == -1) {
 296                        perror("fork");
 297                        exit(1);
 298                }
 299
 300                signal(SIGINT, SIG_IGN);
 301                signal(SIGQUIT, SIG_IGN);
 302                if (waitpid(child_pid, &status, 0) == -1) {
 303                        perror("wait");
 304                        exit(1);
 305                }
 306        }
 307        clock_gettime(CLOCK_REALTIME, &end);
 308        for (num = 0; num < avail_monitors; num++)
 309                monitors[num]->stop();
 310
 311        timediff = timespec_diff_us(start, end);
 312        if (WIFEXITED(status))
 313                printf(_("%s took %.5f seconds and exited with status %d\n"),
 314                        argv[0], timediff / (1000.0 * 1000),
 315                        WEXITSTATUS(status));
 316        return 0;
 317}
 318
 319int do_interval_measure(int i)
 320{
 321        unsigned int num;
 322        int cpu;
 323
 324        if (wake_cpus)
 325                for (cpu = 0; cpu < cpu_count; cpu++)
 326                        bind_cpu(cpu);
 327
 328        for (num = 0; num < avail_monitors; num++) {
 329                dprint("HW C-state residency monitor: %s - States: %d\n",
 330                       monitors[num]->name, monitors[num]->hw_states_num);
 331                monitors[num]->start();
 332        }
 333
 334        sleep(i);
 335
 336        if (wake_cpus)
 337                for (cpu = 0; cpu < cpu_count; cpu++)
 338                        bind_cpu(cpu);
 339
 340        for (num = 0; num < avail_monitors; num++)
 341                monitors[num]->stop();
 342
 343
 344        return 0;
 345}
 346
 347static void cmdline(int argc, char *argv[])
 348{
 349        int opt;
 350        progname = basename(argv[0]);
 351
 352        while ((opt = getopt(argc, argv, "+lci:m:")) != -1) {
 353                switch (opt) {
 354                case 'l':
 355                        if (mode)
 356                                print_wrong_arg_exit();
 357                        mode = list;
 358                        break;
 359                case 'i':
 360                        /* only allow -i with -m or no option */
 361                        if (mode && mode != show)
 362                                print_wrong_arg_exit();
 363                        interval = atoi(optarg);
 364                        break;
 365                case 'm':
 366                        if (mode)
 367                                print_wrong_arg_exit();
 368                        mode = show;
 369                        show_monitors_param = optarg;
 370                        break;
 371                case 'c':
 372                        wake_cpus = 1;
 373                        break;
 374                default:
 375                        print_wrong_arg_exit();
 376                }
 377        }
 378        if (!mode)
 379                mode = show_all;
 380}
 381
 382int cmd_monitor(int argc, char **argv)
 383{
 384        unsigned int num;
 385        struct cpuidle_monitor *test_mon;
 386        int cpu;
 387
 388        cmdline(argc, argv);
 389        cpu_count = get_cpu_topology(&cpu_top);
 390        if (cpu_count < 0) {
 391                printf(_("Cannot read number of available processors\n"));
 392                return EXIT_FAILURE;
 393        }
 394
 395        if (!cpu_top.core_info[0].is_online)
 396                printf("WARNING: at least one cpu is offline\n");
 397
 398        /* Default is: monitor all CPUs */
 399        if (bitmask_isallclear(cpus_chosen))
 400                bitmask_setall(cpus_chosen);
 401
 402        dprint("System has up to %d CPU cores\n", cpu_count);
 403
 404        for (num = 0; all_monitors[num]; num++) {
 405                dprint("Try to register: %s\n", all_monitors[num]->name);
 406                test_mon = all_monitors[num]->do_register();
 407                if (test_mon) {
 408                        if (test_mon->needs_root && !run_as_root) {
 409                                fprintf(stderr, _("Available monitor %s needs "
 410                                          "root access\n"), test_mon->name);
 411                                continue;
 412                        }
 413                        monitors[avail_monitors] = test_mon;
 414                        dprint("%s registered\n", all_monitors[num]->name);
 415                        avail_monitors++;
 416                }
 417        }
 418
 419        if (avail_monitors == 0) {
 420                printf(_("No HW Cstate monitors found\n"));
 421                return 1;
 422        }
 423
 424        if (mode == list) {
 425                list_monitors();
 426                exit(EXIT_SUCCESS);
 427        }
 428
 429        if (mode == show)
 430                parse_monitor_param(show_monitors_param);
 431
 432        dprint("Packages: %d - Cores: %d - CPUs: %d\n",
 433               cpu_top.pkgs, cpu_top.cores, cpu_count);
 434
 435        /*
 436         * if any params left, it must be a command to fork
 437         */
 438        if (argc - optind)
 439                fork_it(argv + optind);
 440        else
 441                do_interval_measure(interval);
 442
 443        /* ToDo: Topology parsing needs fixing first to do
 444           this more generically */
 445        if (cpu_top.pkgs > 1)
 446                print_header(3);
 447        else
 448                print_header(1);
 449
 450        for (cpu = 0; cpu < cpu_count; cpu++) {
 451                if (cpu_top.pkgs > 1)
 452                        print_results(3, cpu);
 453                else
 454                        print_results(1, cpu);
 455        }
 456
 457        for (num = 0; num < avail_monitors; num++)
 458                monitors[num]->unregister();
 459
 460        cpu_topology_release(cpu_top);
 461        return 0;
 462}
 463