An stage is schedulable if it is ready (see `_is_stage_ready()`), it hasn't been selected in the current scheduling round, and its job

When an executor becomes idle, it may need to be moved somewhere. If it's idle at a stage, it might need to be moved to the job pool.

raises an exception if `executor_key` is not found in the durations from `wave`

searches for a schedulable stage in a given job, prioritizing frontier stages

trains the model on different job arrival sequences. For each job sequence: - multiple rollouts are collected in parallel, asynchronou

There may be executors at the current source pool that weren't committed anywhere, e.g. because there were no more stages to schedule,

starts work on another one of `stage`'s tasks, assuming there are still tasks remaining and the executor is local to the stage

a stage's executor demand is the number of executors that it can accept in addition to the executors currently working on, committed to,

a stage is saturated if it doesn't need any more executors.

should be called whenever this executor is released from a job

truncates the numer of executor assigned to `stage` to the stage's demand, if it's larger

searches to see if all the dependencies of stage with id `stage_id` are satisfied.

CLIP loss

if ` stage` is completed, returns all of its successors whose other dependencies are also completed, if any exist.

forward pass without any message passing. Needed whenever all the active jobs are almost complete and only have a single layer of node

called upon a task completion. if the executor has been commited to a next stage, then try assigning it there. Otherwise, if `stage` became

returns a set containing all the stages which are source nodes in the dag, i.e. which have no dependencies

a stage is ready if - it is unsaturated, and - all of its parent stages are saturated

performs some bookkeeping when a job completes

performs some bookkeeping when a stage completes

resumes the simulation until either there are new scheduling decisions to be made, or it's done.

sends a `executor` to `stage`, assuming that the executor is currently at a different job

If a executor arrives to a stage that no longer needs any executors, then greedily try to find a backup stage.

called upon a task completion. If any new stages were unlocked within this job upon the task completion, then start a new commitment r