Skip to content

Commit

Permalink
cpuidle: add a repeating pattern detector to the menu governor
Browse files Browse the repository at this point in the history
Currently, the menu governor uses the (corrected) next timer as key item
for predicting the idle duration.

It turns out that there are specific cases where this breaks down: There
are cases where we have a very repetitive pattern of idle durations, where
the idle period is pretty much the same, for reasons completely unrelated
to the next timer event.  Examples of such repeating patterns are network
loads with irq mitigation, the mouse moving but in theory also the wifi
beacons.

This patch adds a relatively simple detector for such repeating patterns,
where the standard deviation of the last 8 idle periods is compared to a
threshold.

With this extra predictor in place, measurements show that the DECAY
factor can now be increased (the decaying average will now decay slower)
to get an even more stable result.

[[email protected]: fix bug identified by Frank]
Signed-off-by: Arjan van de Ven <[email protected]>
Cc: Corrado Zoccolo <[email protected]>
Cc: Frank Rowand <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
Signed-off-by: Linus Torvalds <[email protected]>
  • Loading branch information
fenrus75 authored and torvalds committed May 25, 2010
1 parent 6cdafaa commit 1f85f87
Showing 1 changed file with 59 additions and 1 deletion.
60 changes: 59 additions & 1 deletion drivers/cpuidle/governors/menu.c
Original file line number Diff line number Diff line change
Expand Up @@ -21,9 +21,12 @@
#include <linux/math64.h>

#define BUCKETS 12
#define INTERVALS 8
#define RESOLUTION 1024
#define DECAY 4
#define DECAY 8
#define MAX_INTERESTING 50000
#define STDDEV_THRESH 400


/*
* Concepts and ideas behind the menu governor
Expand Down Expand Up @@ -64,6 +67,16 @@
* indexed based on the magnitude of the expected duration as well as the
* "is IO outstanding" property.
*
* Repeatable-interval-detector
* ----------------------------
* There are some cases where "next timer" is a completely unusable predictor:
* Those cases where the interval is fixed, for example due to hardware
* interrupt mitigation, but also due to fixed transfer rate devices such as
* mice.
* For this, we use a different predictor: We track the duration of the last 8
* intervals and if the stand deviation of these 8 intervals is below a
* threshold value, we use the average of these intervals as prediction.
*
* Limiting Performance Impact
* ---------------------------
* C states, especially those with large exit latencies, can have a real
Expand Down Expand Up @@ -104,6 +117,8 @@ struct menu_device {
unsigned int exit_us;
unsigned int bucket;
u64 correction_factor[BUCKETS];
u32 intervals[INTERVALS];
int interval_ptr;
};


Expand Down Expand Up @@ -175,6 +190,42 @@ static u64 div_round64(u64 dividend, u32 divisor)
return div_u64(dividend + (divisor / 2), divisor);
}

/*
* Try detecting repeating patterns by keeping track of the last 8
* intervals, and checking if the standard deviation of that set
* of points is below a threshold. If it is... then use the
* average of these 8 points as the estimated value.
*/
static void detect_repeating_patterns(struct menu_device *data)
{
int i;
uint64_t avg = 0;
uint64_t stddev = 0; /* contains the square of the std deviation */

/* first calculate average and standard deviation of the past */
for (i = 0; i < INTERVALS; i++)
avg += data->intervals[i];
avg = avg / INTERVALS;

/* if the avg is beyond the known next tick, it's worthless */
if (avg > data->expected_us)
return;

for (i = 0; i < INTERVALS; i++)
stddev += (data->intervals[i] - avg) *
(data->intervals[i] - avg);

stddev = stddev / INTERVALS;

/*
* now.. if stddev is small.. then assume we have a
* repeating pattern and predict we keep doing this.
*/

if (avg && stddev < STDDEV_THRESH)
data->predicted_us = avg;
}

/**
* menu_select - selects the next idle state to enter
* @dev: the CPU
Expand Down Expand Up @@ -218,6 +269,8 @@ static int menu_select(struct cpuidle_device *dev)
data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket],
RESOLUTION * DECAY);

detect_repeating_patterns(data);

/*
* We want to default to C1 (hlt), not to busy polling
* unless the timer is happening really really soon.
Expand Down Expand Up @@ -310,6 +363,11 @@ static void menu_update(struct cpuidle_device *dev)
new_factor = 1;

data->correction_factor[data->bucket] = new_factor;

/* update the repeating-pattern data */
data->intervals[data->interval_ptr++] = last_idle_us;
if (data->interval_ptr >= INTERVALS)
data->interval_ptr = 0;
}

/**
Expand Down

0 comments on commit 1f85f87

Please sign in to comment.