| /linux/Documentation/admin-guide/hw-vuln/ |
| H A D | core-scheduling.rst | 6 Core scheduling support allows userspace to define groups of tasks that can
8 group of tasks don't trust another), or for performance usecases (some
20 attacks. It allows HT to be turned on safely by ensuring that only tasks in a
35 Using this feature, userspace defines groups of tasks that can be co-scheduled
37 tasks that are not in the same group never run simultaneously on a core, while
42 well as admission and removal of tasks from created groups::
67 will be performed for all tasks in the task group of ``pid``.
77 Building hierarchies of tasks
87 Transferring a cookie between the current and other tasks is possible using
91 scheduling group and share it with already running tasks.
[all …]
|
| /linux/Documentation/power/ |
| H A D | freezing-of-tasks.rst | 2 Freezing of tasks
7 I. What is the freezing of tasks?
10 The freezing of tasks is a mechanism by which user space processes and some
19 The tasks that have PF_NOFREEZE unset (all user space tasks and some kernel
31 wakes up all the kernel threads. All freezable tasks must react to that by
38 tasks are generally frozen before kernel threads.
72 has initiated a freezing operation, the freezing of tasks will fail and the
79 order to wake up each frozen task. Then, the tasks that have been frozen leave
83 Rationale behind the functions dealing with freezing and thawing of tasks
87 - freezes only userspace tasks
[all …]
|
| /linux/Documentation/admin-guide/cgroup-v1/ |
| H A D | cpuacct.rst | 5 The CPU accounting controller is used to group tasks using cgroups and
6 account the CPU usage of these groups of tasks.
9 group accumulates the CPU usage of all of its child groups and the tasks
17 visible at /sys/fs/cgroup. At bootup, this group includes all the tasks in
18 the system. /sys/fs/cgroup/tasks lists the tasks in this cgroup.
20 by this group which is essentially the CPU time obtained by all the tasks
27 # echo $$ > g1/tasks
38 user: Time spent by tasks of the cgroup in user mode.
39 system: Time spent by tasks of the cgroup in kernel mode.
|
| /linux/Documentation/scheduler/ |
| H A D | sched-util-clamp.rst | 12 of tasks. It was introduced in v5.3 release. The CGroup support was merged in
16 performance requirements and restrictions of the tasks, thus it helps the
35 One can tell the system (scheduler) that some tasks require a minimum
37 can tell the system that some tasks should be restricted from consuming too
45 dropped. It can also dynamically 'prime' up these tasks if it knows in the
56 Another example is in Android where tasks are classified as background,
58 resources background tasks are consuming by capping the performance point they
59 can run at. This constraint helps reserve resources for important tasks, like
63 background tasks to stay on the little cores which will ensure that:
65 1. The big cores are free to run top-app tasks immediately. top-app
[all …]
|
| H A D | sched-rt-group.rst | 14 2.3 Basis for grouping tasks
44 multiple groups of real-time tasks, each group must be assigned a fixed portion
57 tasks (SCHED_OTHER). Any allocated run time not used will also be picked up by
72 The remaining CPU time will be used for user input and other tasks. Because
73 real-time tasks have explicitly allocated the CPU time they need to perform
74 their tasks, buffer underruns in the graphics or audio can be eliminated.
95 period_us for the real-time tasks. Without CONFIG_RT_GROUP_SCHED enabled,
96 this only serves for admission control of deadline tasks. With
115 SCHED_OTHER (non-RT tasks). These defaults were chosen so that a run-away
116 real-time tasks will not lock up the machine but leave a little time to recover
[all …]
|
| H A D | sched-eevdf.rst | 14 runnable tasks with the same priority. To do so, it assigns a virtual run
18 has exceeded its portion. EEVDF picks tasks with lag greater or equal to
21 allows latency-sensitive tasks with shorter time slices to be prioritized,
25 tasks; but at the time of writing EEVDF uses a "decaying" mechanism based
26 on virtual run time (VRT). This prevents tasks from exploiting the system
29 lag to decay over VRT. Hence, long-sleeping tasks eventually have their lag
30 reset. Finally, tasks can preempt others if their VD is earlier, and tasks
|
| H A D | sched-ext.rst | 14 together, as tasks aren't tied to specific CPUs at the time of wakeup.
55 ``SCHED_EXT`` tasks are scheduled by sched_ext.
58 set in ``ops->flags``, only tasks with the ``SCHED_EXT`` policy are scheduled
59 by sched_ext, while tasks with ``SCHED_NORMAL``, ``SCHED_BATCH`` and
64 detection of any internal error including stalled runnable tasks aborts the
65 BPF scheduler and reverts all tasks back to the fair-class scheduler.
138 * ``SCX_EV_BYPASS_DISPATCH``: number of tasks dispatched while in bypass mode.
142 * ``SCX_EV_SUB_BYPASS_DISPATCH``: tasks dispatched from sub-scheduler bypass
226 * SCHED_BATCH tasks should use sched_ext.
249 ``cpu.max``, ``cpu.weight`` and ``cpu.idle``. For sched_ext tasks, the
[all …]
|
| /linux/tools/sched_ext/ |
| H A D | scx_userland.c | 12 * program only schedules tasks which may run on any CPU.
43 " -b BATCH The number of tasks to batch when dispatching (default: 8)\n"
50 /* Number of tasks to batch when dispatching to user space. */
65 /* Number of tasks currently enqueued. */
68 /* The data structure containing tasks that are enqueued in user space. */
76 * Use a vruntime-sorted list to store tasks. This could easily be extended to
84 * A vruntime-sorted list of tasks. The head of the list contains the task with
91 * The main array of tasks. The array is allocated all at once during
95 * for newly enabled tasks that are passed to the scheduler from the
98 struct enqueued_task *tasks; variable
[all …]
|
| H A D | scx_pair.bpf.c | 13 * that they will only ever schedule tasks that belong to the same CPU cgroup.
23 * decisions. Paired CPUs always schedule tasks from the same
39 * Tasks and cgroups
45 * always schedule tasks from the same cgroup within a given CPU pair. When a
52 * FIFO queue that we enqueue tasks in. For example, there is a cgrp_q_idx_hash
55 * store the FIFO queue of tasks, and the length of that map, per cgroup. This
58 * tasks are added to their cgroup's FIFO queue.
60 * Dispatching tasks
63 * This section will describe how enqueued tasks are dispatched and scheduled.
64 * Tasks are dispatched in pair_dispatch(), and at a high level the workflow is
[all …]
|
| /linux/Documentation/livepatch/ |
| H A D | livepatch.rst | 85 transition state where tasks are converging to the patched state.
87 sequence occurs when a patch is disabled, except the tasks converge from
91 interrupts. The same is true for forked tasks: the child inherits the
95 safe to patch tasks:
98 tasks. If no affected functions are on the stack of a given task,
100 the tasks on the first try. Otherwise it'll keep trying
108 a) Patching I/O-bound user tasks which are sleeping on an affected
111 b) Patching CPU-bound user tasks. If the task is highly CPU-bound
115 3. For idle "swapper" tasks, since they don't ever exit the kernel, they
122 the second approach. It's highly likely that some tasks may still be
[all …]
|
| /linux/include/linux/ |
| H A D | rcupdate_trace.h | 41 * task is guaranteed to block until all other tasks exit their read-side
43 * task while other tasks are within RCU read-side critical sections,
45 * the all the other tasks exit their critical sections.
88 * task is guaranteed to block until all other tasks exit their read-side
90 * task while other tasks are within RCU read-side critical sections,
92 * the all the other tasks exit their critical sections.
105 // In case we interrupted a Tasks Trace RCU reader. in rcu_read_lock_trace()
148 * The callback function will be invoked some time after a trace rcu-tasks
150 * trace rcu-tasks read-side critical sections have completed. These
163 * synchronize_rcu_tasks_trace - wait for a trace rcu-tasks grace period
[all …]
|
| H A D | psi_types.h | 19 * For IO and CPU stalls the presence of running/oncpu tasks
54 * SOME: Stalled tasks & working tasks
55 * FULL: Stalled tasks & no working tasks
87 /* States of the tasks belonging to this group */
88 unsigned int tasks[NR_PSI_TASK_COUNTS] member
91 /* Aggregate pressure state derived from the tasks */
|
| /linux/kernel/rcu/ |
| H A D | tasks.h | 24 * struct rcu_tasks_percpu - Per-CPU component of definition for a Tasks-RCU-like mechanism.
34 * @rtp_blkd_tasks: List of tasks blocked as readers.
35 * @rtp_exit_list: List of tasks in the latter portion of do_exit().
58 * struct rcu_tasks - Definition for a Tasks-RCU-like mechanism.
186 /* RCU tasks grace-period state for debugging. */
243 // Tasks RCU. Do not enqueue callbacks before this function is invoked.
339 // Enqueue a callback for the specified flavor of Tasks RCU.
420 // Wait for all in-flight callbacks for the specified RCU Tasks flavor.
631 // RCU-tasks kthread that detects grace periods and invokes callbacks.
651 * one RCU-tasks grace period and then invokes the callbacks. in rcu_tasks_kthread()
[all …]
|
| /linux/lib/ |
| H A D | test_workqueue.c | 140 struct task_struct **tasks; in run_bench() local
156 tasks = kzalloc_objs(*tasks, n_threads); in run_bench()
157 if (!tasks) { in run_bench()
165 kfree(tasks); in run_bench()
178 kfree(tasks); in run_bench()
198 tasks[i] = kthread_create(bench_kthread_fn, &ctxs[i], in run_bench()
200 if (IS_ERR(tasks[i])) { in run_bench()
201 ret = PTR_ERR(tasks[i]); in run_bench()
207 kthread_stop(tasks[i]); in run_bench()
211 kthread_bind(tasks[i], cpu); in run_bench()
[all …]
|
| /linux/kernel/livepatch/ |
| H A D | transition.c | 42 * "straggler" tasks which failed to transition in the first attempt.
58 * tasks even in userspace and idle. in klp_transition_work_fn()
99 * All tasks have transitioned to KLP_TRANSITION_UNPATCHED so we can now in klp_complete_transition()
316 * on other methods (e.g., switching tasks at kernel exit). in klp_try_switch_task()
384 * Sends a fake signal to all non-kthread tasks with TIF_PATCH_PENDING set. in __klp_sched_try_switch()
392 pr_notice("signaling remaining tasks\n"); in __klp_sched_try_switch()
413 * Send fake signal to all non-kthread tasks which are in klp_send_signals()
423 * Try to switch all remaining tasks to the target patch state by walking the in klp_send_signals()
424 * stacks of sleeping tasks and looking for any to-be-patched or in klp_send_signals()
428 * If any tasks ar in klp_send_signals()
[all...] |
| /linux/kernel/sched/ext/ |
| H A D | inlines.h | 19 SCX_DSP_LOCAL, /* local DSQ has tasks */
54 * tasks that aren't bypassing and the bypassing descendants' in scx_dispatch_sched()
55 * tasks. The following implements a simple built-in behavior - in scx_dispatch_sched()
61 * bypassed tasks. in scx_dispatch_sched()
76 * rq_offline_scx() moves this CPU's tasks to the local DSQ only after in scx_dispatch_sched()
77 * the wait. The grace period can depend on those tasks running. in scx_dispatch_sched()
88 * produced some tasks, retry. The BPF scheduler may depend on this in scx_dispatch_sched()
119 * dispatching ineligible tasks. Break out once in a while to in scx_dispatch_sched()
133 * Prevent the CPU from going idle while bypassed descendants have tasks in scx_dispatch_sched()
134 * queued. Without this fallback, bypassed tasks coul in scx_dispatch_sched()
[all...] |
| /linux/tools/perf/scripts/python/ |
| H A D | sched-migration.py | 100 def __init__(self, tasks = [0], event = RunqueueEventUnknown()): argument
101 self.tasks = tuple(tasks)
107 if taskState(prev_state) == "R" and next in self.tasks \
108 and prev in self.tasks:
114 next_tasks = list(self.tasks[:])
115 if prev in self.tasks:
127 if old not in self.tasks:
129 next_tasks = [task for task in self.tasks if task != old]
134 if new in self.tasks:
137 next_tasks = self.tasks[:] + tuple([new])
[all …]
|
| /linux/include/linux/sched/ |
| H A D | deadline.h | 6 * SCHED_DEADLINE tasks has negative priorities, reflecting
8 * NORMAL/BATCH tasks.
20 * tasks will return true. Use dl_policy() to ignore PI-boosted tasks.
65 * We support constrained deadline tasks. However, there are some restrictions
66 * applied only for tasks which do not have an implicit deadline. See
|
| H A D | rt.h | 21 * tasks will return true. Use rt_policy() to ignore PI-boosted tasks.
30 * PI-boosted tasks will return true. Use rt_or_dl_task_policy() to ignore
31 * PI-boosted tasks.
40 * PI-boosted tasks will return false.
81 * default timeslice is 100 msecs (used only for SCHED_RR tasks).
|
| /linux/kernel/sched/ |
| H A D | psi.c | 11 * When CPU, memory and IO are contended, tasks experience delays that
30 * In the SOME state of a given resource, one or more tasks are
32 * perform work, but the CPU may still be executing other tasks.
34 * In the FULL state of a given resource, all non-idle tasks are
48 * FULL means all non-idle tasks in the cgroup are delayed on the CPU
62 * The more tasks and available CPUs there are, the more work can be
65 * tasks and CPUs.
67 * Consider a scenario where 257 number crunching tasks are trying to
75 * Conversely, consider a scenario of 4 tasks and 4 CPUs where at any
76 * given time *one* of the tasks is delayed due to a lack of memory.
[all …]
|
| /linux/tools/testing/selftests/futex/include/ |
| H A D | futextest.h | 112 * futex_wake() - wake one or more tasks blocked on uaddr in futex_wake()
113 * @nr_wake: wake up to this many tasks in futex_wake()
134 * futex_wake_bitset() - wake one or more tasks blocked on uaddr with bitset in futex_wake_bitset()
177 * @nr_wake: wake up to this many tasks
178 * @nr_requeue: requeue up to this many tasks in futex_requeue()
192 * futex_cmp_requeue() - requeue tasks from uaddr to uaddr2 in futex_cmp_requeue()
193 * @nr_wake: wake up to this many tasks in futex_cmp_requeue()
194 * @nr_requeue: requeue up to this many tasks in futex_cmp_requeue()
221 * futex_cmp_requeue_pi() - requeue tasks from uaddr to uaddr2 (PI aware)
224 * @nr_wake: wake up to this many tasks in futex_cmp_requeue_pi()
[all...] |
| /linux/Documentation/locking/ |
| H A D | futex-requeue-pi.rst | 5 Requeueing of tasks from a non-PI futex to a PI futex requires
17 pthread_cond_broadcast() must resort to waking all the tasks waiting
47 Once pthread_cond_broadcast() requeues the tasks, the cond->mutex
54 be able to requeue tasks to PI futexes. This support implies that
113 possibly wake the waiting tasks. Internally, this system call is
118 nr_wake+nr_requeue tasks to the PI futex, calling
126 requeue up to nr_wake + nr_requeue tasks. It will wake only as many
127 tasks as it can acquire the lock for, which in the majority of cases
|
| /linux/tools/perf/Documentation/ |
| H A D | perf-timechart.txt | 48 --tasks-only::
63 Print task info for at least given number of tasks.
68 Highlight tasks (using different color) that run more than given
69 duration or tasks with given name. If number is given it's interpreted
92 --tasks-only::
93 Record only tasks-related events
120 then generate timechart and highlight 'gcc' tasks:
|
| /linux/kernel/power/ |
| H A D | process.c | 31 "remaining freezable tasks"; in try_to_freeze_tasks()
75 * We need to retry, but first give the freezing tasks some in try_to_freeze_tasks()
90 "(%d tasks refusing to freeze, wq_busy=%d):\n", what, in try_to_freeze_tasks()
146 * killable tasks. There is no guarantee oom victims will in freeze_processes()
162 * (if any) before thawing the userspace tasks. So, it is the responsibility
163 * of the caller to thaw the userspace tasks, when the time is right.
192 pr_info("Restarting tasks: Starting\n"); in thaw_processes()
211 pr_info("Restarting tasks: Done\n"); in thaw_processes()
|
| /linux/Documentation/admin-guide/kdump/ |
| H A D | gdbmacros.txt | 17 set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
20 set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
51 set $next_t=(char *)($next_t->tasks.next) - $tasks_off
83 set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
86 set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
97 set $next_t=(char *)($next_t->tasks.next) - $tasks_off
106 set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
109 set $next_t=(((char *)($init_t->tasks).next) - $tasks_off)
127 set $next_t=(char *)($next_t->tasks.next) - $tasks_off
139 set $tasks_off=((size_t)&((struct task_struct *)0)->tasks)
[all …]
|