Several robots send model requests to the same worker. One robot sends a burst. Step through what first-in-first-out, earliest-deadline-first and deficit round robin do with the same arrivals, then see two inputs the simulator refuses. This follows the serving-queue simulator in experiments/model-serving-fairness. The capability filter shown in the walkthrough further down is a separate step that simulator does not model.
- Status: simulated
- Storyboard: illustrative, hand-authored
- Measured results: N/A (not run)
- Registry status: planned, nothing measured
- plain codeConfig check
- plain codeAdmission
- plain codeQueue policy
- plain codeWorker
- plain codeReport
FIFO baseline
With first-in-first-out, the quiet robot waits behind the whole burst and misses its deadline.
-
The config is valid passed
fifo is one of the three schedulers: fifo, edf, drr.
scheduler: fifo
-
Every request is admitted passed
No queue_capacity is set, so nothing is rejected on arrival.
-
FIFO orders by arrival info
Robot-a arrived at 0.01 s, after the six burst requests, so it goes last.
order: noisy-f x6, then robot-a
-
Robot-a misses its deadline deadline missed
The worker takes 0.1 s per request, so robot-a finishes at 0.7 s. Its deadline was 0.61 s (0.01 s plus 0.6 s).
robot-a: finish 0.7 s > deadline 0.61 s
-
Fairness and miss-rate: N/A N/A (not run)
This toy is arithmetic on declared inputs. Real metrics come from running the simulator on a full scenario, and are SIMULATED.
Outcome: baseline FIFO lets a burst delay a quiet robot past its deadline. That is the problem the other policies are tested against.
EDF: tight deadline first
Earliest-deadline-first lets the request with the nearest deadline overtake the burst.
-
The config is valid passed
edf is an allowed scheduler.
scheduler: edf
-
Every request is admitted passed
No queue_capacity is set.
-
EDF orders by absolute deadline info
The first burst request starts at 0 s, before robot-a arrives. At 0.1 s robot-a's deadline is the earliest, so it is next.
next: robot-a (earliest deadline)
-
Robot-a finishes on time passed
It runs from 0.1 s to 0.2 s, well before its 0.6 s deadline. The burst follows and still finishes inside its 0.8 s deadline.
robot-a: finish 0.2 s
-
Fairness and miss-rate: N/A N/A (not run)
A question for the experiment: could a flood of tight-deadline requests push others back the same way? Not measured.
Outcome: accepted EDF helped robot-a in this toy because its deadline was tighter. Whether it is fair in general is a question, not a finding.
DRR: take turns
Deficit round robin gives each backlogged robot a turn, so the burst cannot hold the worker for long.
-
The config is valid passed
drr is an allowed scheduler and drr_quantum is 0.1 s.
scheduler: drr
drr_quantum: 0.1
-
Every request is admitted passed
No queue_capacity is set.
-
DRR serves each backlogged robot in turn info
Each turn adds the quantum, 0.1 s, to a robot's deficit. A request costs its service time, 0.1 s, so each turn serves one request.
ring: noisy-f, robot-a
-
Robot-a is served after one burst request passed
At 0.1 s noisy-f takes one turn. At 0.2 s it is robot-a's turn, so robot-a runs 0.2 s to 0.3 s and meets its deadline.
robot-a: finish 0.3 s
-
Fairness and miss-rate: N/A N/A (not run)
Jain fairness is computed over each robot's on-time ratio. When DRR delays the noisy robot, the index can go down even though the quiet robot now meets its deadline, so a higher index is not simply fairer. Read it next to the quiet-robot miss rate. Both would be SIMULATED values from a full run, and none are shown.
Outcome: accepted DRR bounded the quiet robot's wait without looking at deadlines. Its cost, such as longer delays and tail latency for the noisy robot, is exactly what a full run would have to measure.
Misspelled config
A config with an unknown scheduler name or an unknown key is refused as a whole. No partial run happens.
-
Unknown scheduler and unknown key rejected
round_robin is not one of fifo, edf, drr, and drr_quantun is not a known key. Typos fail loudly instead of falling back to a default.
ConfigError: scheduler must be one of ('fifo', 'edf', 'drr')
-
No report is produced N/A (not run)
Admission, queueing and the worker never start, so there is nothing to report.
Outcome: config rejected Rejected before anything ran. The runner documents a distinct exit status for invalid input.
Queue full: shared limit
A single shared queue limit rejects arrivals when it is full, and the quiet robot can be rejected because of someone else's burst.
-
The config is valid passed
queue_capacity of 4 is a valid whole number of at least 1.
queue_capacity: 4
-
The sixth burst request and robot-a are rejected rejected
The first burst request starts at once. The next four fill the queue to 4. The sixth burst request is rejected, and so is robot-a's request at 0.01 s, because the limit is shared by all robots.
rejected: noisy-f #6, robot-a #1
-
Four queued requests remain info
FIFO serves the first burst requests that were admitted.
-
Rejected requests never run info
A rejected request has no queue wait and no completion.
-
Goodput: N/A N/A (not run)
The metrics definitions count rejected requests against goodput. No value is computed here.
Outcome: rejected Admission control protected the queue but not the quiet robot. Per-robot limits are not part of this simulator.
What gets rejected, and why
Each row is a negative case in the storyboard above. Reason names are proposals for this study, not an implemented interface, unless the simulator source below defines them.
Rejections in the storyboard| Case | Stopped at | Reason | What it guards against |
|---|
| FIFO baseline | Worker (deadline) | Not a rejection: robot-a finished late. | Nothing is rejected, which is part of the point. |
|---|
| Misspelled config | Config check | ConfigError: unknown scheduler and unknown key | Typos that would silently change the experiment. |
|---|
| Queue full: shared limit | Admission | Queue at queue_capacity | Arrivals while the shared queue is full, including a quiet robot's. |
|---|
Experimental protocol
- Write the scenario as a config: robots as clients, their arrival patterns, deadlines and the models they use. Every number is an assumption, not a measurement.
- Run fifo, edf and drr on the same seeds, with first_idle and cache_aware worker placement. Use the default fleet for queue disciplines and the cache-pressure scenario for placement.
- Read deadline-miss rate, nearest-rank latency percentiles, starved requests, cache hit rate and Jain fairness together, never one alone.
- Inject a worker-down window to test recovery, and report only what a recorded run produced.
Everything the simulator prints is labelled SIMULATED, from assumed parameters. Jain fairness is computed over per-robot on-time ratios, so it can fall when a fair scheduler pushes the noisy robot late. Read it together with the quiet-robot miss rate and the goodput rate. Worker placement (first_idle or cache_aware) only matters when models compete for cache space, which is what the cache-pressure scenario is for. See also the experiment blueprint on this page.
Measured values
Every value is N/A until a reviewed run exists| Metric | Value | Why |
|---|
| Simulated task completion and fairness (registry primary metric) | N/A | No published run. |
|---|
| Quiet-robot deadline-miss rate | N/A | Not run. |
|---|
| Overall deadline-miss rate | N/A | Not run. |
|---|
| Jain fairness index | N/A | Not run. Not a simple higher-is-better score. |
|---|
| Starved requests | N/A | Not run. |
|---|
See the evidence registry. Nothing on this page is a benchmark.
Where the real code and tests live
Paths are relative to the repository root and the links open the main branch on GitHub. A link resolves once the change that adds the path has been merged.
Illustration only. The steps are fixed text written by hand. This page runs no model, sends no network request, publishes no ROS 2 message and moves no robot. Use the Pause decorative motion button near the top of the page to stop all motion; the player never starts by itself.
ROS 2