tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c

   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  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <stdint.h>
  11 #include <string.h>
  12 #include <limits.h>
  13
  14 #include "helpers/sysfs.h"
  15 #include "helpers/helpers.h"
  16 #include "idle_monitor/cpupower-monitor.h"
  17
  18 #define CPUIDLE_STATES_MAX 10
  19 static cstate_t cpuidle_cstates[CPUIDLE_STATES_MAX];
  20 struct cpuidle_monitor cpuidle_sysfs_monitor;
  21
  22 static unsigned long long **previous_count;
  23 static unsigned long long **current_count;
  24 struct timespec start_time;
  25 static unsigned long long timediff;
  26
  27 static int cpuidle_get_count_percent(unsigned int id, double *percent,
  28                                      unsigned int cpu)
  29 {
  30         unsigned long long statediff = current_count[cpu][id]
  31                 - previous_count[cpu][id];
  32         dprint("%s: - diff: %llu - percent: %f (%u)\n",
  33                cpuidle_cstates[id].name, timediff, *percent, cpu);
  34
  35         if (timediff == 0)
  36                 *percent = 0.0;
  37         else
  38                 *percent = ((100.0 * statediff) / timediff);
  39
  40         dprint("%s: - timediff: %llu - statediff: %llu - percent: %f (%u)\n",
  41                cpuidle_cstates[id].name, timediff, statediff, *percent, cpu);
  42
  43         return 0;
  44 }
  45
  46 static int cpuidle_start(void)
  47 {
  48         int cpu, state;
  49         clock_gettime(CLOCK_REALTIME, &start_time);
  50         for (cpu = 0; cpu < cpu_count; cpu++) {
  51                 for (state = 0; state < cpuidle_sysfs_monitor.hw_states_num;
  52                      state++) {
  53                         previous_count[cpu][state] =
  54                                 sysfs_get_idlestate_time(cpu, state);
  55                         dprint("CPU %d - State: %d - Val: %llu\n",
  56                                cpu, state, previous_count[cpu][state]);
  57                 }
  58         };
  59         return 0;
  60 }
  61
  62 static int cpuidle_stop(void)
  63 {
  64         int cpu, state;
  65         struct timespec end_time;
  66         clock_gettime(CLOCK_REALTIME, &end_time);
  67         timediff = timespec_diff_us(start_time, end_time);
  68
  69         for (cpu = 0; cpu < cpu_count; cpu++) {
  70                 for (state = 0; state < cpuidle_sysfs_monitor.hw_states_num;
  71                      state++) {
  72                         current_count[cpu][state] =
  73                                 sysfs_get_idlestate_time(cpu, state);
  74                         dprint("CPU %d - State: %d - Val: %llu\n",
  75                                cpu, state, previous_count[cpu][state]);
  76                 }
  77         };
  78         return 0;
  79 }
  80
  81 void fix_up_intel_idle_driver_name(char *tmp, int num)
  82 {
  83         /* fix up cpuidle name for intel idle driver */
  84         if (!strncmp(tmp, "NHM-", 4)) {
  85                 switch (num) {
  86                 case 1:
  87                         strcpy(tmp, "C1");
  88                         break;
  89                 case 2:
  90                         strcpy(tmp, "C3");
  91                         break;
  92                 case 3:
  93                         strcpy(tmp, "C6");
  94                         break;
  95                 }
  96         } else if (!strncmp(tmp, "SNB-", 4)) {
  97                 switch (num) {
  98                 case 1:
  99                         strcpy(tmp, "C1");
 100                         break;
 101                 case 2:
 102                         strcpy(tmp, "C3");
 103                         break;
 104                 case 3:
 105                         strcpy(tmp, "C6");
 106                         break;
 107                 case 4:
 108                         strcpy(tmp, "C7");
 109                         break;
 110                 }
 111         } else if (!strncmp(tmp, "ATM-", 4)) {
 112                 switch (num) {
 113                 case 1:
 114                         strcpy(tmp, "C1");
 115                         break;
 116                 case 2:
 117                         strcpy(tmp, "C2");
 118                         break;
 119                 case 3:
 120                         strcpy(tmp, "C4");
 121                         break;
 122                 case 4:
 123                         strcpy(tmp, "C6");
 124                         break;
 125                 }
 126         }
 127 }
 128
 129 static struct cpuidle_monitor *cpuidle_register(void)
 130 {
 131         int num;
 132         char *tmp;
 133
 134         /* Assume idle state count is the same for all CPUs */
 135         cpuidle_sysfs_monitor.hw_states_num = sysfs_get_idlestate_count(0);
 136
 137         if (cpuidle_sysfs_monitor.hw_states_num <= 0)
 138                 return NULL;
 139
 140         for (num = 0; num < cpuidle_sysfs_monitor.hw_states_num; num++) {
 141                 tmp = sysfs_get_idlestate_name(0, num);
 142                 if (tmp == NULL)
 143                         continue;
 144
 145                 fix_up_intel_idle_driver_name(tmp, num);
 146                 strncpy(cpuidle_cstates[num].name, tmp, CSTATE_NAME_LEN - 1);
 147                 free(tmp);
 148
 149                 tmp = sysfs_get_idlestate_desc(0, num);
 150                 if (tmp == NULL)
 151                         continue;
 152                 strncpy(cpuidle_cstates[num].desc, tmp, CSTATE_DESC_LEN - 1);
 153                 free(tmp);
 154
 155                 cpuidle_cstates[num].range = RANGE_THREAD;
 156                 cpuidle_cstates[num].id = num;
 157                 cpuidle_cstates[num].get_count_percent =
 158                         cpuidle_get_count_percent;
 159         };
 160
 161         /* Free this at program termination */
 162         previous_count = malloc(sizeof(long long *) * cpu_count);
 163         current_count = malloc(sizeof(long long *) * cpu_count);
 164         for (num = 0; num < cpu_count; num++) {
 165                 previous_count[num] = malloc(sizeof(long long) *
 166                                         cpuidle_sysfs_monitor.hw_states_num);
 167                 current_count[num] = malloc(sizeof(long long) *
 168                                         cpuidle_sysfs_monitor.hw_states_num);
 169         }
 170
 171         cpuidle_sysfs_monitor.name_len = strlen(cpuidle_sysfs_monitor.name);
 172         return &cpuidle_sysfs_monitor;
 173 }
 174
 175 void cpuidle_unregister(void)
 176 {
 177         int num;
 178
 179         for (num = 0; num < cpu_count; num++) {
 180                 free(previous_count[num]);
 181                 free(current_count[num]);
 182         }
 183         free(previous_count);
 184         free(current_count);
 185 }
 186
 187 struct cpuidle_monitor cpuidle_sysfs_monitor = {
 188         .name                   = "Idle_Stats",
 189         .hw_states              = cpuidle_cstates,
 190         .start                  = cpuidle_start,
 191         .stop                   = cpuidle_stop,
 192         .do_register            = cpuidle_register,
 193         .unregister             = cpuidle_unregister,
 194         .needs_root             = 0,
 195         .overflow_s             = UINT_MAX,
 196 };