cpufreq.c revision b47b5b34b42fa8056577c43496cdb99a4c99f8d7
/*
* Copyright 2009, Intel Corporation
* Copyright 2009, Sun Microsystems, Inc
*
* This file is part of PowerTOP
*
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; version 2 of the License.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program in a file named COPYING; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*
* Authors:
* Arjan van de Ven <arjan@linux.intel.com>
* Eric C Saxe <eric.saxe@sun.com>
* Aubrey Li <aubrey.li@intel.com>
*/
/*
* GPL Disclaimer
*
* For the avoidance of doubt, except that if any license choice other
* than GPL or LGPL is available it will apply instead, Sun elects to
* use only the General Public License version 2 (GPLv2) at this time
* for any software where a choice of GPL license versions is made
* available with the language indicating that GPLv2 or any later
* version may be used, or where a choice of which version of the GPL
* is applied is otherwise unspecified.
*/
#include <stdlib.h>
#include <string.h>
#include <dtrace.h>
#include <kstat.h>
#include <errno.h>
#include "powertop.h"
#define DTP_ARG_COUNT 2
#define DTP_ARG_LENGTH 5
static uint64_t max_cpufreq = 0;
static dtrace_hdl_t *dtp;
static char **dtp_argv;
/*
* Enabling PM through /etc/power.conf
* See suggest_p_state()
*/
static char default_conf[] = "/etc/power.conf";
static char default_pmconf[] = "/usr/sbin/pmconfig";
static char cpupm_enable[] = " echo cpupm enable >> /etc/power.conf";
static char cpupm_treshold[] = " echo cpu-threshold 1s >> /etc/power.conf";
/*
* Buffer containing DTrace program to track CPU frequency transitions
*/
static const char *dtp_cpufreq =
"hrtime_t last[$0];"
""
"BEGIN"
"{"
" begin = timestamp;"
"}"
""
":::cpu-change-speed"
"/last[(processorid_t)arg0] != 0/"
"{"
" this->cpu = (processorid_t)arg0;"
" this->oldspeed = (uint32_t)(arg1/1000000);"
" @times[this->cpu, this->oldspeed] = sum(timestamp - last[this->cpu]);"
" last[this->cpu] = timestamp;"
"}"
":::cpu-change-speed"
"/last[(processorid_t)arg0] == 0/"
"{"
" this->cpu = (processorid_t)arg0;"
" this->oldspeed = (uint32_t)(arg1/1000000);"
" @times[this->cpu, this->oldspeed] = sum(timestamp - begin);"
" last[this->cpu] = timestamp;"
"}";
/*
* Same as above, but only for a specific CPU
*/
static const char *dtp_cpufreq_c =
"hrtime_t last;"
""
"BEGIN"
"{"
" begin = timestamp;"
"}"
""
":::cpu-change-speed"
"/(processorid_t)arg0 == $1 &&"
" last != 0/"
"{"
" this->cpu = (processorid_t)arg0;"
" this->oldspeed = (uint32_t)(arg1/1000000);"
" @times[this->cpu, this->oldspeed] = sum(timestamp - last);"
" last = timestamp;"
"}"
":::cpu-change-speed"
"/(processorid_t)arg0 == $1 &&"
" last == 0/"
"{"
" this->cpu = (processorid_t)arg0;"
" this->oldspeed = (uint32_t)(arg1/1000000);"
" @times[this->cpu, this->oldspeed] = sum(timestamp - begin);"
" last = timestamp;"
"}";
static int pt_cpufreq_setup(void);
static int pt_cpufreq_snapshot(void);
static int pt_cpufreq_dtrace_walk(const dtrace_aggdata_t *, void *);
static void pt_cpufreq_stat_account(double, uint_t);
static int pt_cpufreq_snapshot_cpu(kstat_ctl_t *,
uint_t);
static int
pt_cpufreq_setup(void)
{
return (EXIT_FAILURE);
return (EXIT_FAILURE);
}
if (PTOP_ON_CPU) {
== NULL) {
return (EXIT_FAILURE);
}
}
return (0);
}
/*
* Perform setup necessary to enumerate and track CPU speed changes
*/
int
pt_cpufreq_stat_prepare(void)
{
int err;
if ((err = pt_cpufreq_setup()) != 0) {
return (errno);
}
sizeof (cpu_power_info_t))) == NULL)
return (-1);
/*
* Enumerate the CPU frequencies
*/
return (errno);
(void) kstat_close(kc);
return (err);
}
g_npstates = 0;
g_npstates++;
state++;
}
(void) kstat_close(kc);
/*
* Return if speed transition is not supported
*/
if (g_npstates < 2)
return (-1);
/*
* Setup DTrace to look for CPU frequency changes
*/
return (-2);
}
/*
* Execute different scripts (defined above) depending on
* user specified options. Default mode uses dtp_cpufreq.
*/
if (PTOP_ON_CPU)
prog_ptr = (char *)dtp_cpufreq_c;
else
prog_ptr = (char *)dtp_cpufreq;
return (dtrace_errno(dtp));
}
return (dtrace_errno(dtp));
}
}
}
}
return (dtrace_errno(dtp));
}
return (dtrace_errno(dtp));
}
return (0);
}
/*
* The DTrace probes have already been enabled, and are tracking
* CPU speed transitions. Take a snapshot of the aggregations, and
* look for any CPUs that have made a speed transition over the last
* sampling interval. Note that the aggregations may be empty if no
* speed transitions took place over the last interval. In that case,
* notate that we have already accounted for the time, so that when
* we do encounter a speed transition in a future sampling interval
* we can subtract that time back out.
*/
int
pt_cpufreq_stat_collect(double interval)
{
int i, ret;
/*
* Zero out the interval time reported by DTrace for
* this interval
*/
for (i = 0; i < g_npstates; i++)
g_pstate_info[i].total_time = 0;
for (i = 0; i < g_ncpus; i++)
g_cpu_power_states[i].dtrace_time = 0;
return (-1);
if (dtrace_aggregate_snap(dtp) != 0)
NULL) != 0)
if ((ret = pt_cpufreq_snapshot()) != 0) {
return (ret);
}
switch (g_op_mode) {
case PTOP_MODE_CPU:
break;
case PTOP_MODE_DEFAULT:
default:
for (i = 0; i < g_ncpus_observed; i++)
break;
}
return (0);
}
static void
{
int i;
for (i = 0; i < g_npstates; i++) {
}
}
}
/*
* Take a snapshot of each CPU's speed by looking through the cpu_info kstats.
*/
static int
pt_cpufreq_snapshot(void)
{
int ret;
uint_t i;
return (errno);
switch (g_op_mode) {
case PTOP_MODE_CPU:
break;
case PTOP_MODE_DEFAULT:
default:
for (i = 0; i < g_ncpus_observed; i++)
break;
break;
}
if (kstat_close(kc) != 0)
return (ret);
}
static int
{
pt_error("%s : couldn't find cpu_info kstat for CPU "
return (1);
}
pt_error("%s : couldn't read cpu_info kstat for "
return (2);
}
pt_error("%s : couldn't find current_clock_Hz "
return (3);
}
return (0);
}
/*
* DTrace aggregation walker that sorts through a snapshot of the
* aggregation data collected during firings of the cpu-change-speed
* probe.
*/
/*ARGSUSED*/
static int
{
hrtime_t dt_state_time = 0;
int i;
for (i = 0; i < g_ncpus; i++) {
/* LINTED - alignment */
}
/* LINTED - alignment */
/* LINTED - alignment */
if (speed == 0) {
speed = max_cpufreq;
}
/*
* We have an aggregation record for "cpu" being at "speed"
* for an interval of "n" nanoseconds. The reported interval
* may exceed the powertop sampling interval, since we only
* notice during potentially infrequent firings of the
* "speed change" DTrace probe. In this case powertop would
* have already accounted for the portions of the interval
* that happened during prior powertop samplings, so subtract
* out time already accounted.
*/
for (i = 0; i < g_npstates; i++) {
if (cpu_pow->time_accounted > 0) {
if (dt_state_time == 0)
continue;
if (dt_state_time >
cpu_pow->time_accounted = 0;
}
}
}
}
}
return (DTRACE_AGGWALK_NEXT);
}
/*
* Used as a suggestion, sets PM in /etc/power.conf and
*/
void
enable_p_state(void)
{
(void) system(cpupm_enable);
(void) system(cpupm_treshold);
(void) system(default_pmconf);
}
/*
* Checks if PM is enabled in /etc/power.conf, enabling if not
*/
void
suggest_p_state(void)
{
char line[1024];
/*
* Return if speed transition is not supported
*/
if (g_npstates < 2)
return;
if (!file)
return;
return;
}
}
}
add_suggestion("Suggestion: enable CPU power management by "
"pressing the P key", 40, 'P', "P - Enable p-state",
}