menu.c 3.96 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 * 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>
11
#include <linux/pm_qos_params.h>
12 13 14 15 16 17
#include <linux/time.h>
#include <linux/ktime.h>
#include <linux/hrtimer.h>
#include <linux/tick.h>

#define BREAK_FUZZ	4	/* 4 us */
18
#define PRED_HISTORY_PCT	50
19 20 21 22 23 24

struct menu_device {
	int		last_state_idx;

	unsigned int	expected_us;
	unsigned int	predicted_us;
25
	unsigned int    current_predicted_us;
26 27 28 29 30 31 32 33 34 35 36 37 38
	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);
39
	int latency_req = pm_qos_requirement(PM_QOS_CPU_DMA_LATENCY);
40 41
	int i;

42 43 44 45 46 47
	/* Special case when user has set very strict latency requirement */
	if (unlikely(latency_req == 0)) {
		data->last_state_idx = 0;
		return 0;
	}

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

52 53 54 55 56 57
	/* Recalculate predicted_us based on prediction_history_pct */
	data->predicted_us *= PRED_HISTORY_PCT;
	data->predicted_us += (100 - PRED_HISTORY_PCT) *
				data->current_predicted_us;
	data->predicted_us /= 100;

58
	/* find the deepest idle state that satisfies our constraints */
59
	for (i = CPUIDLE_DRIVER_STATE_START + 1; i < dev->state_count; i++) {
60 61 62 63 64 65
		struct cpuidle_state *s = &dev->states[i];

		if (s->target_residency > data->expected_us)
			break;
		if (s->target_residency > data->predicted_us)
			break;
66
		if (s->exit_latency > latency_req)
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
			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;
85
	unsigned int last_idle_us = cpuidle_get_last_residency(dev);
86
	struct cpuidle_state *target = &dev->states[last_idx];
87
	unsigned int measured_us;
88 89 90 91 92 93 94

	/*
	 * 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.
	 */
95 96
	if (unlikely(!(target->flags & CPUIDLE_FLAG_TIME_VALID)))
		last_idle_us = USEC_PER_SEC / HZ;
97

98 99 100 101 102 103 104 105 106 107
	/*
	 * measured_us and elapsed_us are the cumulative idle time, since the
	 * last time we were woken out of idle by an interrupt.
	 */
	if (data->elapsed_us <= data->elapsed_us + last_idle_us)
		measured_us = data->elapsed_us + last_idle_us;
	else
		measured_us = -1;

	/* Predict time until next break event */
108
	data->current_predicted_us = max(measured_us, data->last_measured_us);
109 110 111

	if (last_idle_us + BREAK_FUZZ <
	    data->expected_us - target->exit_latency) {
112 113 114
		data->last_measured_us = measured_us;
		data->elapsed_us = 0;
	} else {
115
		data->elapsed_us = measured_us;
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
	}
}

/**
 * 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);