Official Inference Code of EAGLE-4
# Copyright 2026 Eagle AI Corp.
# SPDX-License-Identifier: LicenseRef-Eagle-4-Source-Available
"""DynamicDrafter wiring checks that run on CPU (the round itself needs CUDA graphs)."""
import collections
from types import SimpleNamespace
import pytest
import torch
from eagle_harness.core.cost_model import CostModel, CostModelParams, FixedShapePolicy
from eagle_harness.core.draft_tree import DraftTree, TreeShape
from eagle_harness.core.limits import ComputeIntensity
pytest.importorskip("sglang")
from eagle_harness.sglang.drafter import DynamicDrafter # noqa: E402
K, DEPTH, H, WIDTH = 4, 12, 8, 16
def _drafter(tree: DraftTree, cost: CostModel) -> DynamicDrafter:
return DynamicDrafter(
SimpleNamespace(tree=tree),
cost,
fixed=FixedShapePolicy(ComputeIntensity.HIGH, K, DEPTH, WIDTH),
build_trivial_input=lambda batch: None,
target_worker=SimpleNamespace(
model_runner=SimpleNamespace(
model_config=SimpleNamespace(model_is_mrope=False),
kv_index_translator=SimpleNamespace(reads_are_translated=True),
)
),
algorithm=SimpleNamespace(target_verify_graphs=None),
widths=lambda bs: [WIDTH, 8, 1],
tree_mask_mode=None,
device=torch.device("cpu"),
)
def _cost() -> CostModel:
return CostModel(
tables={},
params=CostModelParams(),
intensity=ComputeIntensity.HIGH,
node_top_k=K,
tree_depth=DEPTH,
verify_num=WIDTH,
)
def test_drafter_refuses_deltas_sized_by_the_verify_width():
"""The configuration of that regression (deltas for budgets 1..16, history budget 32) fails at startup."""
cost = _cost()
tree = DraftTree(TreeShape(K, DEPTH), 1, H, torch.float32, torch.device("cpu"), max_verify=WIDTH)
with pytest.raises(ValueError, match="budgets up to 32"):
_drafter(tree, cost)
def test_drafter_refuses_missing_launch_depths():
cost = _cost()
tree = DraftTree(TreeShape(K, DEPTH), 1, H, torch.float32, torch.device("cpu"), max_verify=32, delta_slots=(0, 2))
with pytest.raises(ValueError, match="at depths"):
_drafter(tree, cost)
class _Event:
def __init__(self):
self.records = 0
def record(self):
self.records += 1
def synchronize(self):
pass
def query(self):
return True
class _Steps(SimpleNamespace):
def run(self, bs, step):
self.ran.append(step)
class _StopAt:
"""The real cost model's step kinds; DECIDE stops at ``stop``."""
def __init__(self, cost: CostModel, stop: int):
self.cost, self.stop = cost, stop
def __getattr__(self, name):
return getattr(self.cost, name)
def tree_width(self, depth, bs, past, row, deltas):
return SimpleNamespace(stop=depth >= self.stop)
def _sequenced(tiny: bool, stop: int, policy=None):
cost = _cost()
cost.tier.tiny = tiny
tree = DraftTree(
TreeShape(K, DEPTH), 1, H, torch.float32, torch.device("cpu"), max_verify=32, delta_slots=cost.launch_depths
)
steps = _Steps(tree=tree, ran=[], max_step=DEPTH - 1, host_deltas=torch.zeros(DEPTH, 32, K + 1))
drafter = DynamicDrafter.__new__(DynamicDrafter)
drafter.steps, drafter.tree, drafter.cost = steps, tree, _StopAt(cost, stop)
drafter.fixed = FixedShapePolicy(ComputeIntensity.HIGH, K, DEPTH, WIDTH)
drafter.live, drafter.timer, drafter._seeding = None, None, None
drafter._interpolated, drafter._visits = False, collections.Counter()
drafter._deltas_ready, drafter._deltas_slot = _Event(), 0
drafter._policy = drafter.fixed if policy == "fixed" else drafter.cost
drafter.policy = lambda bs: drafter._policy
return drafter, steps
@pytest.mark.parametrize("tiny,first", [(True, 3), (False, 1)])
def test_queue_runs_the_steps_before_the_first_decision(tiny, first):
"""Batch size 1 (tiny): depths 0-1 keep, depth 2 launches, depth 3 decides; otherwise depth 1 decides."""
drafter, steps = _sequenced(tiny, stop=99)
assert drafter._queue_until_decision(1, drafter.cost) == first
assert steps.ran == list(range(1, first + 1))
assert drafter._deltas_slot == first - 1 and drafter._deltas_ready.records == 1
@pytest.mark.parametrize("stop", [3, 5, 7])
def test_prelaunched_and_direct_rounds_run_the_same_steps(stop):
direct, steps = _sequenced(True, stop)
policy = direct.cost
depth = direct._grow(1, direct._queue_until_decision(1, policy), None, 32, policy)
resumed, resumed_steps = _sequenced(True, stop)
policy = resumed.cost
first = resumed._queue_until_decision(1, policy) # at the end of the previous round
assert resumed._grow(1, first, None, 32, policy) == depth == stop + 1
assert steps.ran == resumed_steps.ran == list(range(1, stop + 1))
@pytest.mark.parametrize("stop", [3, 5, 99])
def test_sampled_depth_uses_the_previous_round_plan(stop):
drafter, steps = _sequenced(True, stop)
steps.sampled = SimpleNamespace(active=True)
drafter._sampled_depth = 6
first = drafter._queue_until_decision(1, drafter.cost)
depth = drafter._grow(1, first, None, 32, drafter.cost)
assert depth == 6
assert steps.ran == list(range(1, 6))
assert drafter._sampled_depth == (stop + 1 if stop <= 5 else 8)
def test_grow_stops_at_the_deepest_level():
drafter, steps = _sequenced(True, stop=99)
assert drafter._grow(1, drafter._queue_until_decision(1, drafter.cost), None, 32, drafter.cost) == DEPTH
assert steps.ran == list(range(1, DEPTH))
def test_fixed_shape_runs_every_step_without_host_decisions():
"""mode static / the live seed sweep: the whole tree is queued ahead, no work deltas are copied or waited on."""
drafter, steps = _sequenced(True, stop=0, policy="fixed")
fixed = drafter.fixed
first = drafter._queue_until_decision(1, fixed)
assert first == DEPTH - 1 and steps.ran == list(range(1, DEPTH))
assert drafter._deltas_ready.records == 0
assert drafter._grow(1, first, None, WIDTH, fixed) == DEPTH
assert steps.ran == list(range(1, DEPTH))
assert fixed.verify_num_paged([], 40, 1, 100, lagged=True) == (WIDTH, False)
fixed.force_width = 8
assert fixed.verify_num_paged([], 40, 1, 100, lagged=True) == (8, False)
assert fixed.verify_count(1, 5) == 5 and fixed.history_verify_num(1) == WIDTH
CHAIN_DEPTH, CHAIN_WIDTH = 15, 16
class _ChainStopAt:
"""A chain cost model whose chain rule stops at depth ``stop``; records the deltas each decision reads."""
def __init__(self, stop: int):
self.cost = CostModel(
tables={},
params=CostModelParams(),
intensity=ComputeIntensity.CHAIN,
node_top_k=1,
tree_depth=CHAIN_DEPTH,
verify_num=CHAIN_WIDTH,
)
self.stop, self.read = stop, []
self.cost.chain_stop = self._chain_stop
def _chain_stop(self, depth, bs, deltas):
self.read.append((depth, deltas))
return depth >= self.stop
def _chain_sequenced(stop: int):
policy = _ChainStopAt(stop)
cost = policy.cost
slots = cost.launch_depths
tree = DraftTree(
TreeShape(1, CHAIN_DEPTH), 1, H, torch.float32, torch.device("cpu"), max_verify=CHAIN_WIDTH, delta_slots=slots
)
# Host deltas: slot d, budget row v - 1 holds (d, v) so a test can tell which row a decision read.
host = torch.tensor([[[float(d), float(v + 1)] for v in range(CHAIN_WIDTH)] for d in range(CHAIN_DEPTH)])
steps = _Steps(tree=tree, ran=[], max_step=CHAIN_DEPTH - 1, host_deltas=host)
drafter = DynamicDrafter.__new__(DynamicDrafter)
drafter.steps, drafter.tree, drafter.cost = steps, tree, cost
drafter.live, drafter.timer, drafter._seeding = None, None, None
drafter._interpolated, drafter._visits = False, collections.Counter()
drafter._deltas_ready, drafter._deltas_slot = _Event(), 0
drafter.policy = lambda bs: cost
return drafter, steps, policy
@pytest.mark.parametrize("stop", [2, 6, 12])
def test_chain_rounds_stop_with_the_chain_rule(stop):
"""A top-1 chain at chain intensity asks the chain rule (CostModel.chain_stop), not the tree rule:
depth 0 keeps, odd depths launch their deltas, even depths decide from the whole-chain budget's deltas."""
drafter, steps, policy = _chain_sequenced(stop)
cost = policy.cost
assert cost.launch_depths == (1, 3, 5, 7, 9, 11, 13)
first = drafter._queue_until_decision(1, cost)
assert first == 2 and steps.ran == [1, 2] and drafter._deltas_slot == 1
for _ in range(16): # a history of narrow verifies: the tree rule's budget would read another deltas row
cost.record_verify_num(1, 4)
past = cost.history_verify_num(1)
assert past < CHAIN_WIDTH
assert drafter._grow(1, first, None, past, cost) == stop + 1
assert steps.ran == list(range(1, stop + 1))
assert policy.read == [(d, [float(d - 1), float(CHAIN_WIDTH)]) for d in range(2, stop + 1, 2)]
def test_chain_rounds_draft_the_whole_chain_when_the_rule_never_stops():
drafter, steps, policy = _chain_sequenced(stop=99)
cost = policy.cost
first = drafter._queue_until_decision(1, cost)
assert drafter._grow(1, first, None, cost.history_verify_num(1), cost) == CHAIN_DEPTH
assert steps.ran == list(range(1, CHAIN_DEPTH))
assert [d for d, _ in policy.read] == list(range(2, CHAIN_DEPTH - 1, 2))
def test_chain_rounds_verify_every_drafted_token():
"""A chain verifies every drafted token: the paged verify budget is not asked; the history is not touched."""
drafter, _, policy = _chain_sequenced(stop=4)
cost = policy.cost
def refuse(*args, **kwargs):
raise AssertionError("a chain round asked for the paged verify budget")
cost.verify_num_paged = refuse
history = [list(h) for h in cost._history]
assert cost.verify_count(1, 6) == 6
assert drafter._verify_width(cost, [0.0] * 6, 6, 1, 100) == 6
assert cost._history == history
def test_narrow_chains_keep_the_tree_rule():
"""The chain rule needs the 16-token chain's cost index; a width-8 chain (live costs index 0, 1, 3, 5, 7) keeps the
tree rule instead of failing its first round."""
cost = CostModel(
tables={}, params=CostModelParams(), intensity=ComputeIntensity.CHAIN, node_top_k=1, tree_depth=7, verify_num=8
)
assert not cost.chain_rounds and not cost.verifies_whole_draft
assert cost.launch_depths == (0, 2, 4)
assert _ChainStopAt(stop=2).cost.chain_rounds
def test_tree_rounds_keep_the_tree_rule():
cost = _cost()
cost.tier.tiny = True
assert not cost.verifies_whole_draft and cost.deltas_budget(32) == 32
assert [cost.width_step(d).value for d in range(4)] == ["keep", "keep", "launch", "decide"]
assert cost.launch_depths == tuple(range(0, DEPTH - 1, 2))
def test_batch_key_is_the_block_table_rows():
from eagle_harness.sglang.drafter import batch_key
batch = SimpleNamespace(reqs=[SimpleNamespace(kv=SimpleNamespace(req_pool_idx=i)) for i in (3, 1)])
assert batch_key(batch) == (3, 1)
class _ChainSteps(SimpleNamespace):
max_step = 6 # --speculative-num-steps 7: the widest chain verifies 8 tokens
def run(self, bs, step):
assert 1 <= step <= self.max_step # DraftTree.step's range
self.ran.append(step)
def load_batch(self, bs, seq_lens, req_pool_indices):
self.loaded.append(bs)
def begin(self, bs, probs, tokens, hidden):
self.begun.append(bs)
class _Tail:
def __init__(self):
self.built = []
def ranked_verify_input(self, bs, depth, count, width, on_rank):
self.built.append((bs, depth, count, width))
return SimpleNamespace(prepared_mrope_positions=None)
def _chain_drafter(widths):
"""A drafter with a fixed width per round (``widths`` handed out in order) and recording fakes."""
drafter = DynamicDrafter.__new__(DynamicDrafter)
plan = iter(widths)
drafter._chain_width = lambda bs: next(plan)
drafter.steps = _ChainSteps(ran=[], loaded=[], begun=[])
drafter.tail = _Tail()
drafter._trivial = lambda batch: "trivial"
drafter._bonus = torch.zeros(4, dtype=torch.int64)
drafter._device = torch.device("cpu")
drafter._pending = None
return drafter
def _chain_batch(bs):
return SimpleNamespace(
seq_lens=torch.full((bs,), 100),
req_pool_indices=torch.arange(bs),
reqs=[SimpleNamespace(kv=SimpleNamespace(req_pool_idx=i)) for i in range(bs)],
spec_info=SimpleNamespace(topk_p=None, topk_index=None, hidden_states=None, bonus_tokens=torch.ones(bs)),
multimodal_inputs=[None] * bs,
)
def test_fixed_width_chain_drafts_width_minus_one_tokens_and_verifies_them():
"""The begin drafts depth 1, so width 4 (3 drafted tokens) runs steps 1 and 2."""
drafter = _chain_drafter([4])
drafter.draft(_chain_batch(2))
assert drafter.steps.ran == [1, 2] and drafter.steps.begun == [2]
assert drafter.tail.built == [(2, 3, 3, 4)]
assert (drafter.last_depth, drafter.last_width) == (3, 4)
def test_the_widest_chain_ends_at_the_last_draft_step():
"""Width 8 with --speculative-num-steps 7: 7 drafted tokens, steps 1..6 (a step 7 was out of the tree's range)."""
drafter = _chain_drafter([8, 2])
drafter.draft(_chain_batch(4))
assert drafter.steps.ran == [1, 2, 3, 4, 5, 6]
assert drafter.tail.built == [(4, 7, 7, 8)]
drafter.draft(_chain_batch(4)) # width 2: the begin's token only
assert drafter.steps.ran == [1, 2, 3, 4, 5, 6] and drafter.steps.begun == [4, 4]
assert drafter.tail.built[-1] == (4, 1, 1, 2)
def test_fixed_width_one_is_plain_decoding():
"""Width 1 drafts nothing but still stages the batch: the draft extend after the verify reads it from the steps
(a stale batch there wrote the draft KV of other requests and broke acceptance)."""
drafter = _chain_drafter([1])
assert drafter.draft(_chain_batch(2)) == "trivial"
assert drafter.steps.loaded == [2]
assert drafter.steps.ran == [] and drafter.steps.begun == [] and drafter.tail.built == []
assert drafter.last_width == 1
def test_prelaunched_chain_keeps_the_width_it_was_queued_with():
"""The plan is asked once per round: by the prelaunch, which queues the whole chain, not again by the draft."""
drafter = _chain_drafter([6, 2])
batch = _chain_batch(1)
drafter._prelaunch_stream = None
drafter._take_pending = lambda: drafter.__dict__.pop("_pending_round", None)
width = drafter._chain_width(1)
from eagle_harness.sglang.drafter import Prelaunch, batch_key
drafter._pending_round = Prelaunch(batch_key(batch), drafter._queue_chain(1, width), width, stream=None)
drafter.draft(batch)
assert drafter.steps.ran == [1, 2, 3, 4] and drafter.steps.begun == []
assert drafter.tail.built == [(1, 5, 5, 6)]
drafter.draft(_chain_batch(3)) # no prelaunch for this batch: the plan's next width
assert drafter.tail.built[-1] == (3, 1, 1, 2)
class _KeptTree:
def __init__(self):
self.kept = []
def keep_rows(self, rows):
self.kept.append(rows.tolist())
def _prelaunched_chain(width, drafted, plan):
"""A chain drafter whose last round drafted the requests ``drafted`` (block-table rows) at ``width``."""
from eagle_harness.sglang.drafter import Prelaunch
drafter = _chain_drafter(plan)
drafter.tree, drafter._drafted_row = _KeptTree(), None
drafter.steps.req_to_token = torch.zeros(8, 4)
drafter.steps.req_pool_indices = torch.zeros(8, dtype=torch.int64)
drafter.steps.req_pool_indices[: len(drafted)] = torch.tensor(drafted)
pending = Prelaunch(tuple(drafted), drafter._queue_chain(len(drafted), width), width, stream=None)
drafter._take_pending = lambda: pending
return drafter
def _requests(rows):
batch = _chain_batch(len(rows))
batch.req_pool_indices = torch.tensor(rows)
batch.reqs = [SimpleNamespace(kv=SimpleNamespace(req_pool_idx=r)) for r in rows]
return batch
def test_a_batch_that_lost_requests_keeps_their_prelaunched_chain():
"""Requests 1 and 4 finished after the prelaunch drafted [5, 1, 7, 4]: the round verifies the kept rows' draft
(batch positions 0 and 2) instead of drafting the chain again."""
drafter = _prelaunched_chain(4, [5, 1, 7, 4], plan=[4])
drafter.draft(_requests([5, 7]))
assert drafter.steps.ran == [1, 2] and drafter.steps.begun == [] # the prelaunch's steps only
assert drafter.tree.kept == [[0, 2]] and drafter.steps.loaded == [2]
assert drafter.tail.built == [(2, 3, 3, 4)]
@pytest.mark.parametrize("rows, plan", [([5, 9], [4]), ([5, 7], [2])])
def test_a_new_request_or_width_drafts_the_chain_again(rows, plan):
"""A request the prelaunch did not draft (9), or a new width for the smaller batch, drafts from the begin."""
drafter = _prelaunched_chain(4, [5, 1, 7, 4], plan=plan)
drafter.draft(_requests(rows))
assert drafter.tree.kept == [] and drafter.steps.begun == [2]
@pytest.mark.parametrize("cycles, offset, sampled", [(1, -1, False), (1, 0, True), (1, 1, False), (2, 0, True)])
def test_live_draft_costs_continue_sampling_after_seeding(cycles, offset, sampled):
from eagle_harness.core.live_costs import LiveCosts
from eagle_harness.sglang.drafter import LIVE_REFRESH_ROUNDS
drafter, _ = _sequenced(True, stop=0)
drafter.live = LiveCosts(widths=lambda bs: [1, 8])
drafter._rounds = LIVE_REFRESH_ROUNDS * cycles + offset
drafter._bucket = lambda bs: bs
events = []
drafter.timer = SimpleNamespace(start=lambda: "start", stop=lambda *args: events.append(args))
assert drafter._timed_steps(4, lambda: 3) == 3
assert events == ([("start", 4, 0, 0, 3)] if sampled else [])
def test_prelaunched_draft_timing_uses_the_incoming_batch_and_context():
from eagle_harness.core.live_costs import LiveCosts
drafter, _ = _sequenced(True, stop=0)
drafter.live = LiveCosts(widths=lambda bs: [1, 8])
drafter._seeding = (4, 100) # The previous batch is shrinking before its next prelaunch.
drafter._bucket = lambda bs: bs
events = []
drafter.timer = SimpleNamespace(start=lambda: "start", stop=lambda *args: events.append(args))
assert drafter._timed_steps(2, lambda: 3, context=2048) == 3
assert events == [("start", 2, 0, 2048, 3)]
def test_cached_or_refreshed_unusable_live_costs_keep_fixed_shape():
from eagle_harness.core.live_costs import DRAFT_WIDTH, LiveCosts
from eagle_harness.sglang.drafter import LIVE_REFRESH_ROUNDS
drafter, _ = _sequenced(True, stop=0)
del drafter.policy # Exercise the production policy, not the step-order fixture's override.
drafter.cost = _cost()
drafter.live = LiveCosts(widths=lambda bs: [1, 8, 16], seed_samples=1)
for width in (1, 8, 16):
drafter.live.record(1, width, 100, 4000.0)
drafter.live.record(1, DRAFT_WIDTH, 100, 2000.0) # target/draft ratio 2: not priced by this model
drafter.cost.set_tables(drafter.live.tables())
drafter._bucket = lambda bs: bs
drafter.timer = SimpleNamespace(drain=lambda **kw: None)
drafter._sync_cells = drafter._save_cells = None
drafter._unpriced = set()
batch = SimpleNamespace(reqs=[None], seq_lens_cpu=torch.tensor([100]))
for previous_rounds in (0, LIVE_REFRESH_ROUNDS - 1):
drafter._rounds = previous_rounds
drafter._unpriced.clear()
drafter._begin_round(batch)
assert drafter.policy(1) is drafter.fixed
# A new measurement can recover the bucket on a later refresh.
drafter.live.cells[(1, DRAFT_WIDTH, 0)].us = 170.0
drafter._rounds = LIVE_REFRESH_ROUNDS - 1
drafter._begin_round(batch)
assert drafter.policy(1) is drafter.cost
def test_a_bucket_the_cost_model_refuses_keeps_the_fixed_shape(caplog):
"""Live costs outside the cost model's ratio checks must not raise mid-serving."""
drafter, _ = _sequenced(True, stop=0)
drafter._unpriced = set()
with caplog.at_level("WARNING"):
drafter._check_priced(1) # the model has no table for bucket 1
assert drafter._unpriced == {1} and "keeps the fixed draft shape" in caplog.text
def test_average_context_reads_request_lengths_when_the_overlap_scheduler_drops_host_mirrors():
"""Under the overlap scheduler a decode batch has neither seq_lens_cpu nor seq_lens_sum (first live-cost round)."""
reqs = [SimpleNamespace(seqlen=10), SimpleNamespace(seqlen=21)]
overlap = SimpleNamespace(reqs=reqs, seq_lens=torch.tensor([10, 21]), seq_lens_cpu=None, seq_lens_sum=None)
assert DynamicDrafter.average_context(overlap) == 15
synchronous = SimpleNamespace(reqs=reqs, seq_lens=torch.tensor([10, 21]), seq_lens_cpu=torch.tensor([12, 22]))
assert DynamicDrafter.average_context(synchronous) == 17
def _live_drafter(seeded):
"""A drafter on the production policy with live costs whose ``seeded`` buckets are ready."""
from eagle_harness.core.live_costs import DRAFT_WIDTH, LiveCosts
drafter, _ = _sequenced(True, stop=0)
del drafter.policy
drafter.cost = _cost()
drafter.live = LiveCosts(widths=lambda bs: [1, 8, 16], seed_samples=1)
for bucket in seeded:
for width, us in ((1, 4000.0 + 50 * bucket), (8, 4300.0 + 80 * bucket), (16, 4600.0 + 100 * bucket)):
drafter.live.record(bucket, width, 100, us)
drafter.live.record(bucket, DRAFT_WIDTH, 100, 170.0)
drafter.cost.set_tables(drafter.live.tables())
drafter._bucket = lambda bs: bs
drafter.timer = SimpleNamespace(drain=lambda **kw: None)
drafter._sync_cells = drafter._save_cells = None
drafter._unpriced = set()
drafter._rounds = 1
return drafter
def test_a_bucket_between_seeded_buckets_serves_the_cost_model_without_a_seed_sweep():
"""A draining batch passes through sizes the load never dwells in: they are priced from the buckets around
them, their rounds are not timed (so readiness changes only on seed rounds, alike on every TP rank), and only a
bucket the load stays in for LIVE_SEED_AFTER_ROUNDS rounds is seeded itself."""
from eagle_harness.sglang.drafter import LIVE_SEED_AFTER_ROUNDS
drafter = _live_drafter(seeded=(1, 8))
batch = SimpleNamespace(reqs=[None] * 4, seq_lens_cpu=torch.tensor([100] * 4))
drafter._begin_round(batch)
assert 4 in drafter.cost.tables and drafter.policy(4) is drafter.cost
assert drafter._seeding is None and drafter.round_timer is None
tables = drafter.cost.tables
drafter._begin_round(SimpleNamespace(reqs=[None] * 6, seq_lens_cpu=torch.tensor([100] * 6)))
assert drafter.cost.tables is not tables and {4, 6} <= set(drafter.cost.tables) # 6 joins, 4 stays
tables = drafter.cost.tables
drafter._begin_round(batch)
assert drafter.cost.tables is tables # bucket 4 is still tabled: no refresh (and no TP broadcast)
for _ in range(LIVE_SEED_AFTER_ROUNDS):
drafter._begin_round(batch)
assert drafter.policy(4) is drafter.fixed and drafter.fixed.force_width == 1
assert drafter._seeding == (4, 100) and drafter.round_timer is drafter.timer
def test_a_bucket_outside_the_seeded_ones_is_seeded_on_its_first_round():
drafter = _live_drafter(seeded=(1, 8))
drafter._begin_round(SimpleNamespace(reqs=[None] * 12, seq_lens_cpu=torch.tensor([100] * 12)))
assert 12 not in drafter.cost.tables and drafter.policy(12) is drafter.fixed
assert drafter._seeding == (12, 100) and drafter.round_timer is drafter.timer
def test_the_round_timer_waits_for_spans_of_unready_buckets():
"""Seed samples land on the same round on every TP rank: readiness decides which buckets are interpolated."""
from eagle_harness.core.live_costs import DRAFT_WIDTH, LiveCosts
from eagle_harness.sglang.drafter import RoundTimer
class Pending:
waited = False
def query(self):
return False
def synchronize(self):
self.waited = True
def elapsed_time(self, end):
return 4.0
live = LiveCosts(widths=lambda bs: [1], seed_samples=1)
live.record(1, 1, 100, 4000.0)
live.record(1, DRAFT_WIDTH, 100, 170.0)
timer = RoundTimer(live)
ready_end, unready_end = Pending(), Pending()
timer._pending = [(Pending(), ready_end, 1, 1, 100, 1), (Pending(), unready_end, 2, 1, 100, 1)]
timer.drain(wait=False)
assert not ready_end.waited and unready_end.waited
assert live.cells[(2, 1, 0)].samples == 1 and len(timer._pending) == 1
def test_warm_up_runs_the_tail_kernels_at_every_depth_and_verify_width():
"""Every ranking (one per depth) and selection (one per verify width) shape compiles before serving."""
drafter, _ = _sequenced(True, stop=0)
calls = []
shape = TreeShape(K, DEPTH)
drafter.tree = SimpleNamespace(
scores=SimpleNamespace(is_cuda=True),
shape=shape,
rank=lambda bs, depth, count: (calls.append(("rank", depth, count)) or "ranked", None),
select=lambda bs, depth, ranked, width: calls.append(("select", depth, width)),
)
drafter._widths = lambda bs: [16, 8, 1] if bs <= 8 else [16, 8, 4, 1]
drafter._algorithm = SimpleNamespace(target_verify_graphs=None)
drafter.warm_up([1, 8, 32])
ranks = [c for c in calls if c[0] == "rank"]
assert [c[1] for c in ranks] == list(range(1, DEPTH + 1))
assert all(count == min(shape.num_nodes(depth), 15) for _, depth, count in ranks)
assert {c[2] for c in calls if c[0] == "select"} == {4, 8, 16}
assert ("select", 1, 4) in calls and ("select", 3, 4) in calls # a depth-1 tree verifies at most K + 1 tokens
assert not any(c[0] == "select" and c[2] > shape.num_nodes(c[1]) + 1 for c in calls)