[net-next-2.6.git] / drivers / cpuidle / governors / menu.c

/*
 * menu.c - the menu idle governor
 *
 * Copyright (C) 2006-2007 Adam Belay <abelay@novell.com>
 *
 * This code is licenced under the GPL.
 */

#include <linux/kernel.h>
#include <linux/cpuidle.h>
#include <linux/latency.h>
#include <linux/time.h>
#include <linux/ktime.h>
#include <linux/hrtimer.h>
#include <linux/tick.h>

#define BREAK_FUZZ	4	/* 4 us */

struct menu_device {
	int		last_state_idx;

	unsigned int	expected_us;
	unsigned int	predicted_us;
	unsigned int	last_measured_us;
	unsigned int	elapsed_us;
};

static DEFINE_PER_CPU(struct menu_device, menu_devices);

/**
 * menu_select - selects the next idle state to enter
 * @dev: the CPU
 */
static int menu_select(struct cpuidle_device *dev)
{
	struct menu_device *data = &__get_cpu_var(menu_devices);
	int i;

	/* determine the expected residency time */
	data->expected_us =
		(u32) ktime_to_ns(tick_nohz_get_sleep_length()) / 1000;

	/* find the deepest idle state that satisfies our constraints */
	for (i = 1; i < dev->state_count; i++) {
		struct cpuidle_state *s = &dev->states[i];

		if (s->target_residency > data->expected_us)
			break;
		if (s->target_residency > data->predicted_us)
			break;
		if (s->exit_latency > system_latency_constraint())
			break;
	}

	data->last_state_idx = i - 1;
	return i - 1;
}

/**
 * menu_reflect - attempts to guess what happened after entry
 * @dev: the CPU
 *
 * NOTE: it's important to be fast here because this operation will add to
 *       the overall exit latency.
 */
static void menu_reflect(struct cpuidle_device *dev)
{
	struct menu_device *data = &__get_cpu_var(menu_devices);
	int last_idx = data->last_state_idx;
	unsigned int measured_us =
		cpuidle_get_last_residency(dev) + data->elapsed_us;
	struct cpuidle_state *target = &dev->states[last_idx];

	/*
	 * Ugh, this idle state doesn't support residency measurements, so we
	 * are basically lost in the dark.  As a compromise, assume we slept
	 * for one full standard timer tick.  However, be aware that this
	 * could potentially result in a suboptimal state transition.
	 */
	if (!(target->flags & CPUIDLE_FLAG_TIME_VALID))
		measured_us = USEC_PER_SEC / HZ;

	/* Predict time remaining until next break event */
	if (measured_us + BREAK_FUZZ < data->expected_us - target->exit_latency) {
		data->predicted_us = max(measured_us, data->last_measured_us);
		data->last_measured_us = measured_us;
		data->elapsed_us = 0;
	} else {
		if (data->elapsed_us < data->elapsed_us + measured_us)
			data->elapsed_us = measured_us;
		else
			data->elapsed_us = -1;
		data->predicted_us = max(measured_us, data->last_measured_us);
	}
}

/**
 * menu_enable_device - scans a CPU's states and does setup
 * @dev: the CPU
 */
static int menu_enable_device(struct cpuidle_device *dev)
{
	struct menu_device *data = &per_cpu(menu_devices, dev->cpu);

	memset(data, 0, sizeof(struct menu_device));

	return 0;
}

static struct cpuidle_governor menu_governor = {
	.name =		"menu",
	.rating =	20,
	.enable =	menu_enable_device,
	.select =	menu_select,
	.reflect =	menu_reflect,
	.owner =	THIS_MODULE,
};

/**
 * init_menu - initializes the governor
 */
static int __init init_menu(void)
{
	return cpuidle_register_governor(&menu_governor);
}

/**
 * exit_menu - exits the governor
 */
static void __exit exit_menu(void)
{
	cpuidle_unregister_governor(&menu_governor);
}

MODULE_LICENSE("GPL");
module_init(init_menu);
module_exit(exit_menu);
Commit	Line	Data
4f86d3a8 LB	1	/*
	2	* menu.c - the menu idle governor
	3	*
	4	* Copyright (C) 2006-2007 Adam Belay <abelay@novell.com>
	5	*
	6	* This code is licenced under the GPL.
	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/cpuidle.h>
	11	#include <linux/latency.h>
	12	#include <linux/time.h>
	13	#include <linux/ktime.h>
	14	#include <linux/hrtimer.h>
	15	#include <linux/tick.h>
	16
	17	#define BREAK_FUZZ 4 /* 4 us */
	18
	19	struct menu_device {
	20	int last_state_idx;
	21
	22	unsigned int expected_us;
	23	unsigned int predicted_us;
	24	unsigned int last_measured_us;
	25	unsigned int elapsed_us;
	26	};
	27
	28	static DEFINE_PER_CPU(struct menu_device, menu_devices);
	29
	30	/**
	31	* menu_select - selects the next idle state to enter
	32	* @dev: the CPU
	33	*/
	34	static int menu_select(struct cpuidle_device *dev)
	35	{
	36	struct menu_device *data = &__get_cpu_var(menu_devices);
	37	int i;
	38
	39	/* determine the expected residency time */
	40	data->expected_us =
	41	(u32) ktime_to_ns(tick_nohz_get_sleep_length()) / 1000;
	42
	43	/* find the deepest idle state that satisfies our constraints */
	44	for (i = 1; i < dev->state_count; i++) {
	45	struct cpuidle_state *s = &dev->states[i];
	46
	47	if (s->target_residency > data->expected_us)
	48	break;
	49	if (s->target_residency > data->predicted_us)
	50	break;
	51	if (s->exit_latency > system_latency_constraint())
	52	break;
	53	}
	54
	55	data->last_state_idx = i - 1;
	56	return i - 1;
	57	}
	58
	59	/**
	60	* menu_reflect - attempts to guess what happened after entry
	61	* @dev: the CPU
	62	*
	63	* NOTE: it's important to be fast here because this operation will add to
	64	* the overall exit latency.
65	*/
66	static void menu_reflect(struct cpuidle_device *dev)
67	{
68	struct menu_device *data = &__get_cpu_var(menu_devices);
69	int last_idx = data->last_state_idx;
70	unsigned int measured_us =
71	cpuidle_get_last_residency(dev) + data->elapsed_us;
72	struct cpuidle_state *target = &dev->states[last_idx];
73
74	/*
75	* Ugh, this idle state doesn't support residency measurements, so we
76	* are basically lost in the dark. As a compromise, assume we slept
77	* for one full standard timer tick. However, be aware that this
78	* could potentially result in a suboptimal state transition.
79	*/
80	if (!(target->flags & CPUIDLE_FLAG_TIME_VALID))
81	measured_us = USEC_PER_SEC / HZ;
82
83	/* Predict time remaining until next break event */
84	if (measured_us + BREAK_FUZZ < data->expected_us - target->exit_latency) {
85	data->predicted_us = max(measured_us, data->last_measured_us);
86	data->last_measured_us = measured_us;
87	data->elapsed_us = 0;
88	} else {
89	if (data->elapsed_us < data->elapsed_us + measured_us)
90	data->elapsed_us = measured_us;
91	else
92	data->elapsed_us = -1;
93	data->predicted_us = max(measured_us, data->last_measured_us);
94	}
95	}
96
97	/**
98	* menu_enable_device - scans a CPU's states and does setup
99	* @dev: the CPU
100	*/
101	static int menu_enable_device(struct cpuidle_device *dev)
102	{
103	struct menu_device *data = &per_cpu(menu_devices, dev->cpu);
104
105	memset(data, 0, sizeof(struct menu_device));
106
107	return 0;
108	}
109
110	static struct cpuidle_governor menu_governor = {
111	.name = "menu",
112	.rating = 20,
113	.enable = menu_enable_device,
114	.select = menu_select,
115	.reflect = menu_reflect,
116	.owner = THIS_MODULE,
117	};
118
119	/**
120	* init_menu - initializes the governor
121	*/
122	static int __init init_menu(void)
123	{
124	return cpuidle_register_governor(&menu_governor);
125	}
126
127	/**
128	* exit_menu - exits the governor
129	*/
130	static void __exit exit_menu(void)
131	{
132	cpuidle_unregister_governor(&menu_governor);
133	}
134
135	MODULE_LICENSE("GPL");
136	module_init(init_menu);
137	module_exit(exit_menu);