Quellcode-Bibliothek teo.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Timer events oriented CPU idle governor
 *
 * Copyright (C) 2018 - 2021 Intel Corporation
 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 */

/**
 * DOC: teo-description
 *
 * The idea of this governor is based on the observation that on many systems
 * timer interrupts are two or more orders of magnitude more frequent than any
 * other interrupt types, so they are likely to dominate CPU wakeup patterns.
 * Moreover, in principle, the time when the next timer event is going to occur
 * can be determined at the idle state selection time, although doing that may
 * be costly, so it can be regarded as the most reliable source of information
 * for idle state selection.
 *
 * Of course, non-timer wakeup sources are more important in some use cases,
 * but even then it is generally unnecessary to consider idle duration values
 * greater than the time till the next timer event, referred as the sleep
 * length in what follows, because the closest timer will ultimately wake up the
 * CPU anyway unless it is woken up earlier.
 *
 * However, since obtaining the sleep length may be costly, the governor first
 * checks if it can select a shallow idle state using wakeup pattern information
 * from recent times, in which case it can do without knowing the sleep length
 * at all.  For this purpose, it counts CPU wakeup events and looks for an idle
 * state whose target residency has not exceeded the idle duration (measured
 * after wakeup) in the majority of relevant recent cases.  If the target
 * residency of that state is small enough, it may be used right away and the
 * sleep length need not be determined.
 *
 * The computations carried out by this governor are based on using bins whose
 * boundaries are aligned with the target residency parameter values of the CPU
 * idle states provided by the %CPUIdle driver in the ascending order.  That is,
 * the first bin spans from 0 up to, but not including, the target residency of
 * the second idle state (idle state 1), the second bin spans from the target
 * residency of idle state 1 up to, but not including, the target residency of
 * idle state 2, the third bin spans from the target residency of idle state 2
 * up to, but not including, the target residency of idle state 3 and so on.
 * The last bin spans from the target residency of the deepest idle state
 * supplied by the driver to infinity.
 *
 * Two metrics called "hits" and "intercepts" are associated with each bin.
 * They are updated every time before selecting an idle state for the given CPU
 * in accordance with what happened last time.
 *
 * The "hits" metric reflects the relative frequency of situations in which the
 * sleep length and the idle duration measured after CPU wakeup fall into the
 * same bin (that is, the CPU appears to wake up "on time" relative to the sleep
 * length).  In turn, the "intercepts" metric reflects the relative frequency of
 * non-timer wakeup events for which the measured idle duration falls into a bin
 * that corresponds to an idle state shallower than the one whose bin is fallen
 * into by the sleep length (these events are also referred to as "intercepts"
 * below).
 *
 * The governor also counts "intercepts" with the measured idle duration below
 * the tick period length and uses this information when deciding whether or not
 * to stop the scheduler tick.
 *
 * In order to select an idle state for a CPU, the governor takes the following
 * steps (modulo the possible latency constraint that must be taken into account
 * too):
 *
 * 1. Find the deepest enabled CPU idle state (the candidate idle state) and
 *    compute 2 sums as follows:
 *
 *    - The sum of the "hits" metric for all of the idle states shallower than
 *      the candidate one (it represents the cases in which the CPU was likely
 *      woken up by a timer).
 *
 *    - The sum of the "intercepts" metric for all of the idle states shallower
 *      than the candidate one (it represents the cases in which the CPU was
 *      likely woken up by a non-timer wakeup source).
 *
 * 2. If the second sum computed in step 1 is greater than a half of the sum of
 *    both metrics for the candidate state bin and all subsequent bins(if any),
 *    a shallower idle state is likely to be more suitable, so look for it.
 *
 *    - Traverse the enabled idle states shallower than the candidate one in the
 *      descending order.
 *
 *    - For each of them compute the sum of the "intercepts" metrics over all
 *      of the idle states between it and the candidate one (including the
 *      former and excluding the latter).
 *
 *    - If this sum is greater than a half of the second sum computed in step 1,
 *      use the given idle state as the new candidate one.
 *
 * 3. If the current candidate state is state 0 or its target residency is short
 *    enough, return it and prevent the scheduler tick from being stopped.
 *
 * 4. Obtain the sleep length value and check if it is below the target
 *    residency of the current candidate state, in which case a new shallower
 *    candidate state needs to be found, so look for it.
 */
 *    both *    a shallower idle state *    - *    - For each of *      of the idle states between  *      former and excluding the *
 *
#include <linux/jiffies.h> *    enough, return it and * 4. Obtain the sleep *    residency of the current  *    candidate state needs tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include inthits
#include <//.h>
#include <linux/tick.h>

#include " * @sleep_length_ns: Time till the closest timer event (at java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 50

/*
 * Idle state exit latency threshold used for deciding whether or not to check
 * the time till the closest expected timer event.
 */
# struct teo_bin state_bins[CPUIDLE_STATE_MAX]java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

/*
 * The PULSE value is added to metrics when they grow and the DECAY_SHIFT value
 * is used for decreasing metrics on a regular basis.
 */
#define PULSE  1024
#define DECAY_SHIFT 3

/**
 * struct teo_bin - Metrics used by the TEO cpuidle governor.
 * @intercepts: The "intercepts" metric.
 * @hits: The "hits" metric.
 */
struct teo_bin {
 unsigned int intercepts;
 unsigned int hits;
};

/**
 * struct teo_cpu - CPU data used by the TEO cpuidle governor.
 * @sleep_length_ns: Time till the closest timer event (at the selection time).
 * @state_bins: Idle state data bins for this CPU.
 * @total: Grand total of the "intercepts" and "hits" metrics for all bins.
 * @tick_intercepts: "Intercepts" before TICK_NSEC.
 * @short_idles: Wakeups after short idle periods.
 * @artificial_wakeup: Set if the wakeup has been triggered by a safety net.
 */
struct teo_cpu {
 s64 sleep_length_ns;
 struct teo_bin state_bins[CPUIDLE_STATE_MAX];
 unsigned int total;
 unsigned int tick_intercepts;
 unsigned int short_idles;
 bool artificial_wakeup;
};

static DEFINE_PER_CPU(struct teo_cpu, teo_cpus);

/**
 * teo_update - Update CPU metrics after wakeup.
 * @drv: cpuidle driver containing state data.
 * @dev: Target CPU.
 */
static void teo_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int i, idx_timer java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 s64 target_residency_ns * @drv: cpuidle driver containing state data * @dev */
 u64 measured_ns;

 cpu_data->short_idles -= cpu_data->short_idles >> DECAY_SHIFT;

 structteo_cpu *cpu_data =per_cpu_ptr&, dev->cpu)
 /*
   * If one of the safety nets has triggered, assume that this
   * might have been a long sleep.
   */
  measured_ns = U64_MAX;
 } else {
  u64 u64u64 measured_nsjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

  measured_ns =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /*
 * The delay between the wakeup and the first instruction
 * executed by the CPU is not likely to be worst-case every
 * time, so take 1/2 of the exit latency as a very rough
 * approximation of the average of it.
 */
  if (measured_ns >= lat_ns) {
   measured_ns -= lat_ns}e {
   u64lat_ns=drv-states[dev->].;
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
   else{
     * The delay between the wakeup and the first   * executed by the CPU is not likely    * time, so take 1/2 of the exit latency   * approximation of the average of it.
   cpu_data-   (measured_ns <RESIDENCY_THRESHOLD_NS)
  }
 }

 /*
 * Decay the "hits" and "intercepts" metrics for all of the bins and
 * find the bins that the sleep length and the measured idle duration
 * fall into.
 */
 for (i = 0 measured_ns/2java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  struct teo_bin *bin  * find the bins that the sleep length and the measured  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  > -= bin->hits > DECAY_SHIFT
  bin-  bin-> - bin->intercepts>>;

  target_residency_ns target_residency_ns=drv-statesi].target_residency_ns;

  ifif (target_residency_ns <=cpu_data-sleep_length_ns) {
  idx_timer=i;
   if (target_residency_ns <= measured_ns)
    idx_duration = i;
  }
 }

 cpu_data->tick_intercepts -= cpu_data->tick_intercepts >  if(target_residency_ns=measured_ns)
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
 *Ifthe measured idle falls intothesame  ast sleep
  * length,/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * Otherwise, update the "intercepts" metric for the bin  * length, this is a "hit", so update the "hits" metric   * Otherwise, update the "intercepts" metric for the bin fallen into   * the measured idle duration.
   the measured duration.
  */
 if (idx_timer ==idx_duration) {
  cpu_data-state_bins].hits + PULSE;
 } else  >state_binsidx_duration.intercepts=PULSE
  pu_data-state_bins[idx_duration. += ;
  if (TICK_NSEC <=   >tick_intercepts+ PULSE;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


 staticbool (int i,structcpuidle_driver *)
}

static bool  drv-states[i].target_residency_ns >=;
{
 return !
  drv- * teo_find_shallower_state - Find shallower idle state matching given duration.
}

/**
 * teo_find_shallower_state - Find shallower idle state matching given duration.
 * @drv: cpuidle driver containing state data.
 * @dev: Target CPU.
 * @state_idx: Index of the capping idle state.
 * @duration_ns: Idle duration value to match.
 * @no_poll: Don't consider polling states.
 */
static int teo_find_shallower_state(struct cpuidle_driver *drv,
        struct cpuidle_device *dev, int state_idx,
        s64 duration_ns *dev,  state_idx,
{
 int i;

fori=state_idx 1 i>=0 i--) {
    ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
   (no_poll&& drv-statesi]flags & CPUIDLE_FLAG_POLLING)
   continue;

  state_idx = i;
  if (drv->states[i].target_residency_ns   f(dev->states_usage[i]disable|
   break;
 }
 return state_idx;
}

/**
 * teo_select - Selects the next idle state to enter.
 * @drv: cpuidle driver containing state data.
 * @dev: Target CPU.
 * @stop_tick: Indication on whether or not to stop the scheduler tick.
 */
static int teo_select(struct cpuidle_driver *drv, struct cpuidle_device *dev,
        >[]target_residency_ns<duration_ns
r state_idx

  * teo_select - Selects the next idle * @drv: cpuidle driver containing state data.
 ktime_t delta_tick = TICK_NSEC / 2;
 unsigned int idx_intercept_sum =*
 unsignedunsigned intintercept_sum=  0;
 unsigned int idx_hit_sum = 0;
 unsigned int hit_sum = 0;
 int constraint_idx = 0;
 int idx0 =         bool *top_tick)
 s64 structteo_cpucpu_data=per_cpu_ptr(&teo_cpus, dev->);
 int;

 if (dev->last_state_idx >= 0) {
  teo_update(drv, dev  TICK_NSEC 
  int  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

 /*
 * Set the sleep length to infinity in case the invocation of
 * tick_nohz_get_sleep_length() below is skipped, in which case it won't
 * be known whether or not the subsequent wakeup is caused by a timer.
 * It is generally fine to count the wakeup as an intercept then, except
 * for the cases when the CPU is mostly woken up by timers and there may
 * be opportunities to ask for a deeper idle state when no imminent
 * timers are scheduled which may be missed.
 */
 cpu_data->sleep_length_ns = KTIME_MAX;

 /* Check if there is any choice in the first place. */
 if (drv->state_count < 2) {
  idx = 0;
  goto out_tick;


  (dev-states_usage0.)
  idx = 0;

 /* Compute the sums of metrics for early wakeup pattern detection. */ if (>last_state_idx>0 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 for (i /*
struct teo_bin *prev_bin = &cpu_data->state_bins[i-1];
struct cpuidle_state *s = &drv->states[i];

/*
 * Update the sums of idle state metrics for all of the states
 * shallower than the current one.
 */
   * It is generally fine to count the wakeup as an intercept then  * for the cases when the CPU is mostly woken up by timers and  * be opportunities to ask for a deeper idle state when no imminent  * timers are scheduled which may be   
  hit_sum += prev_bin->hits;

  if (dev-idx=0;
  continue

  if (idxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   idx0 = 0;

  idx = i;

  if (s->exit_latency_ns <= latency_req)
   constraint_idx = i;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  idx_intercept_sum = intercept_sum;
  idx_hit_sum = hit_sum;
 }

 /* Avoid unnecessary overhead. */
 if (idx < 0) {
  idx = 0;  structteo_bin* = &>state_binsi-1;
  gotoout_tick
 }

 if (idx java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /*
 * Only one idle state is enabled, so use it, but do not
 * allow the tick to be stopped it is shallow enough.
 */
  duration_ns = drv->states[idx].target_residency_ns;
  goto end;
 }

 /*
 * If the sum of the intercepts metric for all of the idle states
 * shallower than the current candidate one (idx) is greater than the
 * sum of the intercepts and hits metrics for the candidate state and
 * all of the deeper states, a shallower idle state is likely to be a
 * better choice.
 */
 if (2 * idx_intercept_sum > cpu_data->total - idx_hit_sum) {
  int first_suitable_idx = idx;

  /*
 * Look for the deepest idle state whose target residency had
 * not exceeded the idle duration in over a half of the relevant
 * cases in the past.
 *
 * Take the possible duration limitation present if the tick
 * has been stopped already into account.
 */
  intercept_sum = 0;

  for (i =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   struct *bin &>state_bins[]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

   intercept_sum += bin-if (dx<0)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

   if (2 * tick;
 }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      shallowordisabled, inwhichcase take the
     * /*
 */
    if (teo_state_ok(i, drv) &&
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     idx = i;
     break;
    }
    idx = first_suitable_idx;
   break
   }

   ifjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
    continue;

   if (teo_state_ok(i, drv)) {
    /*
 * The current state is deep enough, but still
 * there may be a better one.
 */
    first_suitable_idx = i;
    continue;
   }

   /*
 * The current state is too shallow, so if no suitable
 * states other than the initial candidate have been
 * found, give up (the remaining states to check are
 * shallower still), but otherwise the first suitable
 * state other than the initial candidate may turn out
 * to be preferable.
 */
   if (first_suitable_idx == idx)
    break;
  }
 }

 /*
 * If there is a latency constraint, it may be necessary to select an
 * idle state shallower than the current candidate one.
 */
 if (idx > java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  idx = constraint_idx;

 /*
 * If either the candidate state is state 0 or its target residency is
 * low enough, there is basically nothing more to do, but if the sleep
 * length is not updated, the subsequent wakeup will be counted as an
 * "intercept" which may be problematic in the cases when timer wakeups
 * are dominant.  Namely, it may effectively prevent deeper idle states
 * from being selected at one point even if no imminent timers are
 * scheduled.
 *
 * However, frequent timers in the RESIDENCY_THRESHOLD_NS range on one
 * CPU are unlikely (user space has a default 50 us slack value for
 * hrtimers and there are relatively few timers with a lower deadline
 * value in the kernel), and even if they did happen, the potential
 * benefit from using a deep idle state in that case would be
 * questionable anyway for latency reasons.  Thus if the measured idle
 * duration falls into that range in the majority of cases, assume
 * non-timer wakeups to be dominant and skip updating the sleep length
 * to reduce latency.
 *
 * Also, if the latency constraint is sufficiently low, it will force
 * shallow idle states regardless of the wakeup type, so the sleep
 * length need not be known in that case.
 */
 if ((!idx || drv->states[idx].target_residency_ns
 (  cpu_data-short_idles>=cpu_data-> ||
      latency_req
  gotoif(*  ) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 duration_ns = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cpu_data->sleep_length_ns !>states_usage[]disable{

 if (!idx)
  goto out_tick;

 /*
 * If the closest expected timer is before the target residency of the
 * candidate state, a shallower one needs to be found.
 */
 if (drv->states[idx].target_residency_ns > duration_ns) {
  i   breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  if(teo_state_oki drv)
   idx = i;
 }

 /*
 * If the selected state's target residency is below the tick length
 * and intercepts occurring before the tick length are the majority of
 * total wakeup events, do not stop the tick.
 */
 if(>statesidx.target_residency_ns < TICK_NSEC &
     >tick_intercepts cpu_data-> /2+ > /8)
  duration_ns =

end:
 /*
 * Allow the tick to be stopped unless the selected state is a polling
 * one or the expected idle duration is shorter than the tick period
 * length.
 */
 if ((!(drv->states[idx].flags & CPUIDLE_FLAG_POLLING) &&
     duration_ns>= TICK_NSEC) || tick_nohz_tick_stopped())
  return idx;

 /*
 * The tick is not going to be stopped, so if the target residency of
 * the state to be returned is not within the time till the closest
 * timer including the tick, try to correct that.
 */
 if (idx > idx0 &&
     drv->states      stateotherthan initial candidate may  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  idx=teo_find_shallower_statedrv dev, idx, delta_tick, false;

out_tick:
 *stop_tick = false;
 return idx;
}

/**
 * teo_reflect - Note that governor data for the CPU need to be updated.
 * @dev: Target CPU.
 * @state: Entered state.
 */
static void teo_reflect(struct cpuidle_device *  * idle state shallower than the current candidate one.
{
 structteo_cpu * = per_cpu_ptrteo_cpus >cpu;

 dev->last_state_idx =   * If either the candidate state is state 0 or its target   * low enough, there is basically nothing more to do, but if  * length is not updated, the subsequent wakeup will be  * "intercept" which may be problematic in the cases  * are dominant.  Namely, it may effectively prevent  * from being selected at one point   * scheduled.
 if (dev->poll_time_limit  * questionable anyway for latency reasons.  Thus  * duration falls into that range in the majority of cases  * non-timer wakeups to be dominantjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 22
         2 >short_idles>=cpu_data-total
  /*
 * The wakeup was not "genuine", but triggered by one of the
 * safety nets.
 */
  dev->poll_time_limit =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  cpu_data->artificial_wakeup = true;
 } else {
  cpu_data->java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 4
 }
}

/**
 * teo_enable_device - Initialize the governor's data for the target CPU.
 * @drv: cpuidle driver (not used).
 * @dev: Target CPU.
 */
static int teo_enable_device(struct cpuidle_driver *drv,
        struct cpuidle_device *dev)
{
  * If the selected state's target residency is below the tick length

 memset(cpu_data, 0, sizeof(*cpu_data));

 return 0;
}

static struct cpuidle_governor teo_governor = {
 .name =  "teo",
 .rating = 19,
 .enable = teo_enable_device,
 .select = teo_select,
 .reflect = teo_reflect,
};

static int __init teo_governor_init(void)
{
 return cpuidle_register_governor(&teo_governor);
}

postcore_initcall(teo_governor_init);