| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| 457 | 93.27% | 1 | 20.00% | |
| 21 | 4.29% | 1 | 20.00% | |
| 7 | 1.43% | 1 | 20.00% | |
| 4 | 0.82% | 1 | 20.00% | |
| 1 | 0.20% | 1 | 20.00% | |
| Total | 490 | 5 |
| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Marcelo Tosatti | 457 | 93.27% | 1 | 20.00% |
| Eiichi Tsukata | 21 | 4.29% | 1 | 20.00% |
| Parshuram Sangle | 7 | 1.43% | 1 | 20.00% |
| Rafael J. Wysocki | 4 | 0.82% | 1 | 20.00% |
| Joao Martins | 1 | 0.20% | 1 | 20.00% |
| Total | 490 | 5 |
// SPDX-License-Identifier: GPL-2.0 /* * haltpoll.c - haltpoll idle governor * * Copyright 2019 Red Hat, Inc. and/or its affiliates. * * This work is licensed under the terms of the GNU GPL, version 2. See * the COPYING file in the top-level directory. * * Authors: Marcelo Tosatti <mtosatti@redhat.com> */ #include <linux/kernel.h> #include <linux/cpuidle.h> #include <linux/time.h> #include <linux/ktime.h> #include <linux/hrtimer.h> #include <linux/tick.h> #include <linux/sched.h> #include <linux/module.h> #include <linux/kvm_para.h> #include <trace/events/power.h> static unsigned int guest_halt_poll_ns __read_mostly = 200000; module_param(guest_halt_poll_ns, uint, 0644); /* division factor to shrink halt_poll_ns */ static unsigned int guest_halt_poll_shrink __read_mostly = 2; module_param(guest_halt_poll_shrink, uint, 0644); /* multiplication factor to grow per-cpu poll_limit_ns */ static unsigned int guest_halt_poll_grow __read_mostly = 2; module_param(guest_halt_poll_grow, uint, 0644); /* value in us to start growing per-cpu halt_poll_ns */ static unsigned int guest_halt_poll_grow_start __read_mostly = 50000; module_param(guest_halt_poll_grow_start, uint, 0644); /* allow shrinking guest halt poll */ static bool guest_halt_poll_allow_shrink __read_mostly = true; module_param(guest_halt_poll_allow_shrink, bool, 0644); /** * haltpoll_select - selects the next idle state to enter * @drv: cpuidle driver containing state data * @dev: the CPU * @stop_tick: indication on whether or not to stop the tick */ static int haltpoll_select(struct cpuidle_driver *drv, struct cpuidle_device *dev, bool *stop_tick) { s64 latency_req = cpuidle_governor_latency_req(dev->cpu); if (!drv->state_count || latency_req == 0) { *stop_tick = false; return 0; } if (dev->poll_limit_ns == 0) return 1; /* Last state was poll? */ if (dev->last_state_idx == 0) { /* Halt if no event occurred on poll window */ if (dev->poll_time_limit == true) return 1; *stop_tick = false; /* Otherwise, poll again */ return 0; } *stop_tick = false; /* Last state was halt: poll */ return 0; } static void adjust_poll_limit(struct cpuidle_device *dev, u64 block_ns) { unsigned int val; /* Grow cpu_halt_poll_us if * cpu_halt_poll_us < block_ns < guest_halt_poll_us */ if (block_ns > dev->poll_limit_ns && block_ns <= guest_halt_poll_ns) { val = dev->poll_limit_ns * guest_halt_poll_grow; if (val < guest_halt_poll_grow_start) val = guest_halt_poll_grow_start; if (val > guest_halt_poll_ns) val = guest_halt_poll_ns; trace_guest_halt_poll_ns_grow(val, dev->poll_limit_ns); dev->poll_limit_ns = val; } else if (block_ns > guest_halt_poll_ns && guest_halt_poll_allow_shrink) { unsigned int shrink = guest_halt_poll_shrink; val = dev->poll_limit_ns; if (shrink == 0) { val = 0; } else { val /= shrink; /* Reset value to 0 if shrunk below grow_start */ if (val < guest_halt_poll_grow_start) val = 0; } trace_guest_halt_poll_ns_shrink(val, dev->poll_limit_ns); dev->poll_limit_ns = val; } } /** * haltpoll_reflect - update variables and update poll time * @dev: the CPU * @index: the index of actual entered state */ static void haltpoll_reflect(struct cpuidle_device *dev, int index) { dev->last_state_idx = index; if (index != 0) adjust_poll_limit(dev, dev->last_residency_ns); } /** * haltpoll_enable_device - scans a CPU's states and does setup * @drv: cpuidle driver * @dev: the CPU */ static int haltpoll_enable_device(struct cpuidle_driver *drv, struct cpuidle_device *dev) { dev->poll_limit_ns = 0; return 0; } static struct cpuidle_governor haltpoll_governor = { .name = "haltpoll", .rating = 9, .enable = haltpoll_enable_device, .select = haltpoll_select, .reflect = haltpoll_reflect, }; static int __init init_haltpoll(void) { if (kvm_para_available()) return cpuidle_register_governor(&haltpoll_governor); return 0; } postcore_initcall(init_haltpoll);