class Scheduler

Notifies the scheduler that a command buffer has been scheduled on the given context.

Notifies the scheduler that a command buffer has been completed on the given context.

///////////////////////////////////////////////////////////////////////////////////////////////

Returns the number of the CPU this scheduler instance is associated with.

Returns the index of the logical cluster of the CPU this scheduler instance

is associated with.

Returns the lock-free value of the estimated queue time for the CPU this

scheduler is associated with.

Returns the lock-free value of the estimated deadline utilization for the

CPU this scheduler is associated with.

Returns the reciprocal processing rate of the CPU this scheduler instance

is associated with.

Returns true if new scheduler wakeup accounting is enabled either by boot

option or gn arg.

Reschedules the given CPU mask, applying any updated bookkeeping that may

affect the currently running threads on those CPUs.

Returns the lock-free value of the estimated deadline utilization for the

CPU, clamped to the current rate limits, for the CPU this scheduler is

associated with.

Returns the lock-free value of the processing rate for the CPU this

scheduler is associated with.

Returns the processing rate of the CPU this scheduler instance is

associated with.

Returns a pointer to the currently running thread, if any.

TODO(johngro); This is not particularly safe. As soon as we returned this

thread's pointer, it could (in theory) exit. We probably need to require

that the scheduler's queue lock be held in order to peek at the active

thread member.

Dumps the state of the run queue to the specified output target. Note that

interrupts must be disabled in order to call this method.

Accessors for total weight and number of runnable tasks.

Dumps info about the currently active thread (if any). Note that

interrupts must be disabled in order to call this method.

Run the passed callable while holding the specified thread's scheduler's

lock, if any. Used by SetMigrateFn in thread.cc.

Peek at the current active mask for all schedulers.

Note that this is just a lockless atomic load. Baring special

circumstances, the set of active schedulers can change at any time.

Peek at the current active mask state for a given CPU's scheduler.

Note that this is just a lockless atomic load. Baring special

circumstances, the set of active schedulers can change at any time.

Accessors for the "idle" state mask; similar to the active state mask.

Sets the power domain set for this scheduler instance, returning the previous domain set.

Called by kernel tests and sys_system_set_processor_power_domain.

Updates the current power level for this CPU with the value reported by the power level

controller. Called by kernel tests and sys_system_set_processor_power_state.

Returns the current active power level, if any.

Returns the current power domain for this scheduler instance.

Returns the current active power coefficient.

Returns the max idle power coefficient.

Selects the context whose command buffer will be executed next.

Set/clears the current cpu's bit in the global mp_active_mask. Holds the

scheduler's queue lock while the bit is changed, enforcing the invariant

that a scheduler's active bit can only ever change while holding that

scheduler's lock.

Const accessor for static analysis.

See the comment in Thread::CreateEtc for why InitializeThread does not take

a stance on whether or not we should be in an active chain-lock

transaction. On the surface, demanding that we hold a threads lock without

also demanding that we also be involved in an active chain-lock transaction

is an apparent contradiction of some fundamental invariants (how can a

chain lock be held without being in a transaction?), but when used

exclusively from Thread::CreateEtc, it should be OK.

Initialize the first thread to run on the current CPU. Called from

thread_construct_first, this method will initialize the thread's scheduler

state, then mark the thread as being "active" in its cpu's scheduler.

Remove the impact of a CPUs first thread from the scheduler's bookkeeping.

During initial startup, threads are not _really_ being scheduled, yet they

can still do things like obtain locks and block, resulting in profile

inheritance. In order to hold the scheduler's bookkeeping invariants, we

assign these threads a fair weight, and include it in the total fair weight

tracked by the scheduler instance. When the thread either becomes the idle

thread (as the boot CPU first thread does), or exits (as secondary CPU first

threads do), it is important that we remove this weight from the total

bookkeeping. However, this is not as simple as just changing the thread's

weight via ChangeWeight, as idle threads are special cases who contribute no

weight to the total.

So, this small method simply fixes up the bookkeeping before allowing the

thread to move on to become the idle thread (boot CPU), or simply exiting

(secondary CPU).

No chainlocks should be held when calling preempt. The thread's lock will

be obtained unconditionally in the process.

If holding a spinlock, the preemption will be deferred via self-IPI until

all spinlock are released and interrupts are re-enabled.

Finish unblocking a thread. This function expects the thread to be locked

when called. It will:

1) Select a scheduler compatible with the thread.

2) Place the thread into that scheduler's run queue.

3) Drop the thread's lock.

4) Reschedule if needed/permitted.

Unblock list expects to receive a list of threads, all of whose

locks are currently held. It will drop each thread's lock after

successfully assigning it to a scheduler.

Unblock a thread, but do not reschedule for the thread. A reschedule may

still be issued for power level changes.

UnblockIdle is used in the process of creation of the idle thread. It

simply asserts that the thread is (in fact) flagged as the idle thread, and

that it has hard affinity for exactly one CPU (its CPU). It then sets the

thread to be ready, and ensures that its curr_cpu_ state is correct.

Migrates any threads that can run on other CPUs off of the current CPU.

TimerTick is called when the preemption timer for a CPU has fired.

This function is logically private and should only be called by timer.cc.

Releases the lock held by the previous and current threads after a context

switch. This must be called by trampoline routines at some point before

jumping to the current thread's entry point.

Called when the base profile of |thread| has been changed by a program. The

thread must be either running or runnable when this method is called. If

the thread had been blocked instead, the change of the base profile would

have been managed at the WaitQueue level, perhaps eventually propagating to

the scheduler via UpstreamThreadBaseProfileChanged.

Called when the base profile of a thread (|upstream|) which exists upstream

of |target| has changed its base profile. It is possible for the rules

regarding scheduling penalties base profile changes to be slightly

different for when a thread's effective profile changes as a result of its

own base profile changing, vs the base profile of a thread which exists

upstream of it in a PI graph. Because of this, the two scenarios are

handled separately using two different methods.

Called when a thread (|upstream|) blocks in an OwnedWaitQueue, and the

target of that OWQ (|target|) is running or runnable. At the point that

this method is called, propagation of the static profile pressure

parameters (weight, deadline utilization, and minimum deadline) should have

already been propagated to |target|, and its EffectiveProfile should be

dirty. This method is called in order to update the dynamic scheduling

parameters (start time, finish time, time slice remaining) of |target| as

needed because of the join operation.

Called when a thread (|upstream|) unblocks from an OwnedWaitQueue and

leaves the PI graph whose running or runnable target is |target|.

At the point that this method is called, propagation of the static profile

pressure parameters (weight, deadline utilization, and minimum deadline)

should have already been propagated to |target|, and its EffectiveProfile

should be dirty. This method is called in order to update the dynamic

scheduling parameters (start time, finish time, time slice remaining) in

both |target| and |upstream| as needed because of the split operation.

Updates the performance scales of the requested CPUs and returns the

effective values in place, which may be different than the requested values

if they are below the minimum safe values for the respective CPUs.

Requires info.size()

<

= num CPUs.

Gets the performance scales of up to info.size() CPUs. Returns the last

values requested by userspace, even if they have not yet taken effect.

Requires info.size()

<

= num CPUs.

Gets the default performance scales of up to info.size() CPUs. Returns the

initial values determined by the system topology, or 1.0 when no topology

is available.

Requires info.size()

<

= num CPUs.

Updates the performance limits of the requested CPUs.

Requires limits.size()

<

= num CPUs.

Gets the processing limits of up to limits.size() CPUs.

Requires limits.size()

<

= num CPUs.

Get the mask of valid CPUs that thread may run on. If a new mask

is set, the thread will be migrated to satisfy the new constraint.

Sends a power level request through this scheduler's power level controller for testing. This

method is called from thread and IRQ context to ensure that the underlying machinery can be

safely called within Block, Unblock, and other scheduling operations.

Returns true if the request was sent, false otherwise.