Lines Matching full:task
125 * By default, if there are no other task to run on the CPU, ext core
126 * keeps running the current task even after its slice expires. If this
133 * An exiting task may schedule after PF_EXITING is set. In such cases,
134 * bpf_task_from_pid() may not be able to find the task and if the BPF
135 * scheduler depends on pid lookup for dispatching, the task will be
152 * A migration disabled task can only execute on its current CPU. By
157 * A migration disabled task never invokes ops.select_cpu() as it can
215 /* the cgroup the task is joining */
222 /* Whether the task exited before running on sched_ext. */
238 /* next task is being scheduled by &sched_class_rt */
240 /* next task is being scheduled by &sched_class_dl */
242 /* next task is being scheduled by &sched_class_stop */
259 /* the task that's going to be scheduled on the CPU */
260 struct task_struct *task; member
294 * @select_cpu: Pick the target CPU for a task which is being woken up
295 * @p: task being woken up
321 * @enqueue: Enqueue a task on the BPF scheduler
322 * @p: task being enqueued
328 * the task will stall.
336 * @dequeue: Remove a task from the BPF scheduler
337 * @p: task being dequeued
341 * the task while updating its scheduling properties (e.g. priority).
343 * The ext core keeps track of whether the BPF side owns a given task or
354 * @prev: previous task being switched out
366 * When not %NULL, @prev is an SCX task with its slice depleted. If
376 * @p: task running currently
379 * executing an SCX task. Setting @p->scx.slice to 0 will trigger an
385 * @runnable: A task is becoming runnable on its associated CPU
386 * @p: task becoming runnable
389 * This and the following three functions can be used to track a task's
390 * execution state transitions. A task becomes ->runnable() on a CPU,
406 * task may be ->enqueue()'d without being preceded by this operation
412 * @running: A task is starting to run on its associated CPU
413 * @p: task starting to run
416 * one the task is going to run on. This can happen when a task
419 * the task's assigned CPU.
422 * target CPU the task is going to use.
424 * See ->runnable() for explanation on the task state notifiers.
429 * @stopping: A task is stopping execution
430 * @p: task stopping to run
431 * @runnable: is task @p still runnable?
434 * one the task was running on. This can happen when a task
437 * the task's assigned CPU.
440 * the task was running on.
442 * See ->runnable() for explanation on the task state notifiers. If
449 * @quiescent: A task is becoming not runnable on its associated CPU
450 * @p: task becoming not runnable
453 * See ->runnable() for explanation on the task state notifiers.
470 * @from: yielding task
471 * @to: optional yield target task
475 * dispatched before the yielding task. Return value is ignored in this
484 * @core_sched_before: Task ordering for core-sched
485 * @a: task A
486 * @b: task B
502 * @set_weight: Set task weight
503 * @p: task to set weight for
512 * @p: task to set CPU affinity for
565 * @init_task: Initialize a task to run in a BPF scheduler
566 * @p: task to initialize for BPF scheduling
569 * Either we're loading a BPF scheduler or a new task is being forked.
571 * be used for allocations, and is called exactly once for a task.
580 * @exit_task: Exit a previously-running task from the system
581 * @p: task to exit
590 * @enable: Enable BPF scheduling for a task
591 * @p: task to enable BPF scheduling for
599 * @disable: Disable BPF scheduling for a task
600 * @p: task to disable BPF scheduling for
629 * @dump_task: Dump BPF scheduler state for a runnable task on error
631 * @p: runnable task to generate debug dump for
664 * @cgroup_prep_move: Prepare a task to be moved to a different cgroup
665 * @p: task being moved
680 * @p: task being moved
691 * @p: task whose cgroup move is being canceled
815 * runnable task should be able to wait before being scheduled. The
870 * If ops.select_cpu() returns a CPU which can't be used by the task,
877 * the meantime. In this case, the task is bounced to the global DSQ.
882 * If SCX_OPS_ENQ_LAST is not set, the number of times that a task
888 * If SCX_OPS_ENQ_EXITING is not set, the number of times that a task
895 * migration disabled task skips ops.enqueue() and is dispatched to its
901 * The number of times a task, enqueued on a local DSQ with
910 * priority class task even if the BPF scheduler always satisfies the
919 * Total number of times a task's time slice was refilled with the
940 * The number of times the scheduler attempted to insert a task that it
966 struct task_struct *task; member
1063 * The maximum amount of time in jiffies that a task may be runnable
1102 * current task is cleared to zero and the CPU is kicked into the
1108 * Only allowed on local DSQs. Guarantees that the task either gets
1115 * If the task can't stay on the CPU for any reason, it gets
1126 * The task being enqueued was previously enqueued on a DSQ, but was
1128 * out why a given task is being reenqueued.
1133 * The task being enqueued is the only task available for the cpu. By
1159 * The generic core-sched layer decided to execute the task even though
1165 * The task is being dequeued due to a property change (e.g.,
1202 * Preempt the current task and execute the dispatch path. If the
1203 * current task of the target CPU is an SCX task, its ->scx.slice is
1205 * task expires and the dispatch path is invoked.
1210 * The scx_bpf_kick_cpu() call will return after the current SCX task of
1212 * scheduling. This has no effect if the current task on the target CPU
1238 * Task Ownership State Machine (sched_ext_entity->ops_state)
1240 * The sched_ext core uses this state machine to track task ownership
1270 * Task is owned by the SCX core. It's either on a run queue, running,
1272 * claim on this task.
1275 * Transitional state while transferring a task from the SCX core to
1276 * the BPF scheduler. The task's rq lock is held during this state.
1279 * dispatch, if the task is still in %SCX_OPSS_QUEUEING the completion
1284 * Task is owned by the BPF scheduler. It's on a DSQ (dispatch queue)
1287 * dispatch/dequeue races: if a task is dequeued and re-enqueued, the
1292 * Transitional state while transferring a task from the BPF scheduler
1294 * selected the task for execution. When dequeue needs to take the task
1306 * Cross-CPU Task Migration
1308 * When moving a task in the %SCX_OPSS_DISPATCHING state, we can't simply
1314 * p->scx.holding_cpu. When moving a task to a different rq:
1316 * 1. Verify task can be moved (CPU affinity, migration_disabled, etc.)
1318 * 3. Set task state to %SCX_OPSS_NONE; dequeue waits while DISPATCHING
1322 * 5. Lock src_rq (where the task currently lives)
1324 * race (dequeue clears holding_cpu to -1 when it takes the task), in
1336 * This state tracking allows the BPF scheduler to try to dispatch any task
1350 * on the task being dispatched.
1386 * scx_task_sched - Find scx_sched scheduling a task
1387 * @p: task of interest
1400 * scx_task_sched_rcu - Find scx_sched scheduling a task
1401 * @p: task of interest
1411 * scx_task_on_sched - Is a task on the specified sched?
1413 * @p: task of interest