Lines Matching full:tick

32 #include "tick-internal.h"
167 * Ensure that the tick is aligned to a multiple of in tick_init_jiffy_update()
236 * When we are idle and the tick is stopped, we have to touch in tick_sched_handle()
248 * In case the current tick fired too early past its expected in tick_sched_handle()
328 /* Empty, the tick restart happens on tick_nohz_irq_exit() */ in nohz_full_kick_func()
336 * re-evaluate its dependency on the tick and restart it if necessary.
350 * re-evaluate its dependency on the tick and restart it if necessary.
381 * we guarantee it sees the new tick dependency upon in tick_nohz_kick_task()
402 * their dependency on the tick and restart it if necessary.
428 * Set a global tick dependency. Used by perf events that rely on freq and
442 * Set per-CPU tick dependency. Used by scheduler and perf events in order to
477 * Set a per-task tick dependency. RCU needs this. Also posix CPU timers
494 * Set a per-taskgroup tick dependency. Posix CPU timers need this in order to elapse
519 * Re-evaluate the need for the tick as we switch the current task.
520 * It might need the tick due to per task/process properties:
572 * Full dynticks uses IRQ work to drive the tick rescheduling on safe in tick_nohz_init()
574 * interrupts to avoid circular dependency on the tick. in tick_nohz_init()
607 * NOHZ - aka dynamic tick functionality
791 * Reset to make sure the next tick stop doesn't get fooled by past in tick_nohz_restart()
818 * Keep the periodic tick, when RCU, architecture or irq_work in tick_nohz_next_event()
847 * If the tick is due in the next period, keep it ticking or in tick_nohz_next_event()
858 * We've not stopped the tick yet, and there's a timer in the in tick_nohz_next_event()
901 * the tick timer next, which might be this CPU as well. If we in tick_nohz_stop_tick()
929 * call we save the current tick time, so we can restart the in tick_nohz_stop_tick()
930 * scheduler tick in tick_nohz_restart_sched_tick(). in tick_nohz_stop_tick()
945 * the tick timer. in tick_nohz_stop_tick()
993 /* Cancel the scheduled timer and restore the tick: */ in tick_nohz_restart_sched_tick()
1054 pr_warn("NOHZ tick-stop error: local softirq work is pending, handler #%02x!!!\n", in report_idle_softirq()
1066 * the CPU which runs the tick timer next. If we don't drop in can_stop_idle_tick()
1074 * Make sure the CPU doesn't get fooled by obsolete tick in can_stop_idle_tick()
1092 * Keep the tick alive to guarantee timekeeping progression in can_stop_idle_tick()
1107 * tick_nohz_idle_stop_tick - stop the idle tick from the idle task
1109 * When the next event is more than a tick into the future, stop the idle tick
1119 * tick timer expiration time is known already. in tick_nohz_idle_stop_tick()
1181 * tick_nohz_irq_exit - Notify the tick about IRQ exit
1186 * re-evaluation of the next tick. Depending on the context:
1189 * time accounting. The next tick will be re-evaluated on the next idle
1194 * 2.1) If there is any tick dependency, restart the tick if stopped.
1196 * 2.2) If there is no tick dependency, (re-)evaluate the next tick and
1210 * tick_nohz_idle_got_tick - Check whether or not the tick handler has run
1225 * or the tick, whichever expires first. Note that, if the tick has been
1237 * @delta_next: duration until the next event if the tick cannot be stopped
1313 * We stopped the tick in idle. update_process_times() would miss the in tick_nohz_account_idle_time()
1314 * time we slept, as it does only a 1 tick accounting. in tick_nohz_account_idle_time()
1347 * tick_nohz_idle_exit - Update the tick upon idle task exit
1349 * When the idle task exits, update the tick depending on the
1353 * restart the tick.
1356 * 2.1) If the tick can be kept stopped (no tick dependencies)
1357 * then re-evaluate the next tick and try to keep it stopped
1359 * 2.2) If the tick has dependencies, restart the tick.
1390 * In low-resolution mode, the tick handler must be implemented directly
1392 * infrastructure actually relies on the tick itself as a backend in
1410 * In dynticks mode, tick reprogram is deferred: in tick_nohz_lowres_handler()
1524 * In dynticks mode, tick reprogram is deferred: in tick_nohz_highres_handler()
1547 * tick_setup_sched_timer - setup the tick emulation timer
1554 /* Emulate tick processing via per-CPU hrtimers: */ in tick_setup_sched_timer()
1561 /* Offset the tick to avert 'jiffies_lock' contention. */ in tick_setup_sched_timer()