feat(speculation): allocator contract and sticky impl - #450
Open
behinddwalls wants to merge 1 commit into
Open
Conversation
This was referenced Jul 28, 2026
behinddwalls
force-pushed
the
preetam/speculation-allocator
branch
from
July 28, 2026 19:32
86a9654 to
10e097e
Compare
behinddwalls
marked this pull request as ready for review
July 28, 2026 19:59
sbalabanov
requested changes
Jul 28, 2026
sbalabanov
left a comment
sbalabanov
left a comment
Contributor
There was a problem hiding this comment.
critical comment about failing fast
|
|
||
| Because cancellation is best-effort, an `Allocator` should not spend capacity it merely expects a cancel to release — a build cancelled to make room keeps charging the budget until its cancel reaches a terminal state, so the queue converges over successive runs rather than oversubscribing the hard cap on concurrent builds in a single pass. | ||
|
|
||
| ## `sticky` |
Contributor
There was a problem hiding this comment.
move that into sticky/README.md instead
|
|
||
| ## `sticky` | ||
|
|
||
| The `sticky` `Allocator` fills only free budget slots and leaves every in-flight build running. Against the budget it counts the paths that still hold a build slot — `pending`, `building`, and `cancelling` (a cancel is a request, and the build keeps its slot until it actually stops). It then proposes a build for each new candidate, in order, until the budget fills; it never proposes a cancel. |
Contributor
There was a problem hiding this comment.
add that 'sticky' operates the "builds" as a build unit budget (so, it is quite coarse).
More interesting implementations may operate with more granular units, understanding the size of the build needed to be done (i.e. based on number of targets, historical data etc).
| } | ||
|
|
||
| // New returns a sticky allocator.Allocator with the given concurrent-build | ||
| // budget. |
Contributor
There was a problem hiding this comment.
explain what unit of measure for the budget is
| // data defect. Skip it rather than counting it: a status that | ||
| // never turns terminal would pin a build slot forever. That leaves | ||
| // the path free to be proposed again, which is self-correcting, | ||
| // but the malformed entry is worth knowing about. |
Contributor
There was a problem hiding this comment.
SQ default on data inconsistencies is to fail fast and hard
behinddwalls
force-pushed
the
preetam/speculation-allocator
branch
2 times, most recently
from
July 29, 2026 18:24
bf09ae6 to
6977b91
Compare
behinddwalls
force-pushed
the
preetam/speculation-allocator
branch
2 times, most recently
from
July 29, 2026 22:41
d6f1dfe to
af1efe4
Compare
behinddwalls
force-pushed
the
preetam/speculation-allocator
branch
2 times, most recently
from
July 29, 2026 23:18
2b3a122 to
32e21b9
Compare
behinddwalls
force-pushed
the
preetam/speculation-allocator
branch
from
July 29, 2026 23:18
32e21b9 to
00ca258
Compare
Add submitqueue/extension/speculation/allocator, the budget-spending composition point (Allocator) the standard Speculator hands its candidate stream to, plus the sticky implementation and mocks. The Allocator owns terminal-path suppression: the generator enumerates the whole path space with no knowledge of the path sets, so paths whose builds already ran come back round as candidates. Allocate reconciles the stream against the path sets by path ID — an in-flight candidate stays funded rather than starting a new attempt, and a terminal one is skipped without spending a slot. The budget is measured in concurrent builds: one slot per path whose attempt is pending, building, or cancelling, whatever that build's size. That unit is deliberately coarse — an allocator that understands build size (target count, historical cost) could weight paths instead; the contract leaves the unit to the implementation. sticky fills only free budget slots and never preempts a running build, trading responsiveness for never discarding work already started; its policy counterpart is a preempting allocator. A stored path with no status is corrupt data and sticky fails fast — Allocate returns an error rather than guessing whether the record holds a slot — which also removes its only logging dependency, so New takes just the budget. Tests cover a terminal path arriving as the top-ranked candidate for each terminal status (passed, failed, cancelled): it is skipped and the slot goes to the next eligible candidate. Contract docs live in allocator/README.md; sticky's behavior is documented next to the code in sticky/README.md.
behinddwalls
force-pushed
the
preetam/speculation-allocator
branch
from
July 30, 2026 01:19
00ca258 to
80c246f
Compare
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Add submitqueue/extension/speculation/allocator, the budget-spending composition point (Allocator) the standard Speculator hands its candidate stream to, plus the sticky implementation and mocks.
The Allocator owns terminal-path suppression: the generator enumerates the whole path space with no knowledge of the path sets, so paths whose builds already ran come back round as candidates. Allocate reconciles the stream against the path sets by path ID — an in-flight candidate stays funded rather than starting a new attempt, and a terminal one is skipped without spending a slot.
sticky fills only free budget slots and never preempts a running build, trading responsiveness for never discarding work already started; its policy counterpart is a preempting allocator. Tests cover a terminal path arriving as the top-ranked candidate for each terminal status (passed, failed, cancelled): it is skipped and the slot goes to the next eligible candidate.
Stack