[zzylol]

Why

Part 2 of #1185 (part 1: #1188). The planner still ran on a wall-clock budget upstream of Stage 3. The facade gave planning 30 s, split into a seed round over a few tumbling-window widths and growing intermediate rounds, and kept the best round's plan. Pass 1, Pass 2 and Stage 2 checked deadlines too. So the widths searched, and with them the selected plan, depended on machine speed and load. That is what made the wall-clock-ignored tests (markers #1067/#1175/#1180) flaky.

What

• Planning has no time budget. Pass 2 builds every tumbling-window width of each reader's grid in one pass. Stage 2 and Stage 3 then run once over that full catalog.
• Removed:
  • the facade's rounds and their report fields
  • PlanSearchSettings::time_limit_ms
  • every deadline parameter and deadline error in Pass 1, Pass 2, Stage 2, types and executor
  • the reference pricer's EvaluationDeadlineExceeded
  • stage_pipeline --milp-time-limit-s
• Tests that were ignored for wall-clock reasons: 186 run again and pass, and the tests of behaviour that no longer exists are deleted.
  • 7 stay ignored with a new, non-wall-clock reason because they fail on main too: cost models 2/3 (Memo search solver: MILP over the memo for all cost models #888), forced heap / @ MILP gaps (Stage 3 review: plan selection, the MILP over the memo, cost and accuracy constraints #1015).
  • 3 stay ignored because they now plan for over 30 min in debug (Planning is about 20x slower since the full tumbling-window-width domain (#1185) #1197).
• Plans are unchanged: every corpus and sketch snapshot is byte-identical, and the compared workloads keep the same cost (table below).
• Planning is much slower on large workloads (see Limitations). Tracked in Planning is about 20x slower since the full tumbling-window-width domain (#1185) #1197.

How

• Facade (crates/planner/src/run.rs): run_planning runs Stage 0 and Pass 1, then Pass 2 → Stage 2 → Stage 3 once, then builds the selected plan with AssignmentRealizer::realize.
  • The round loop and its types are deleted: Round, RoundEnd, RoundOutcome and plan_round.
  • So are the round constants, calibration_is_frozen and has_splittable_window.
  • PlanningRoundReport is folded into PlanningReport.
• Pass 2:
  • Deleted: the round state (Pass2RoundState), the width domain and frontier (TumblingWindowWidthDomain, TumblingWindowWidthFrontier) and check_generation_deadline.
  • Local window composition now enumerates tumbling_window_width_domain(grids), the divisor set the old Complete round used. It still skips candidates whose signature already exists.
• Stage 2, types, executor: the deadline parameters are deleted. No caller ever set them.
  • This removes flatten_before, compile_before and the set_retention deadline, along with their *DeadlineExceeded errors.
  • It also removes CandidateGenerationTimeout, PerComputationLogicalMemoCandidatesError::Timeout and Pass2RuleError::DeadlineExceeded.

Key code interfaces added / modified

crates/planner/src/run.rs

/// Settings of one planning run (stays).
pub struct PlanSearchSettings {
    /// Keep Pass 1's output for inspection (stage_pipeline, the viewer). Default off.
    pub inspect: bool,            // unchanged
    // pub time_limit_ms: u64,    // removed: no planning budget
}

/// Why the facade selected no plan (stays).
pub enum SelectionError {
    /// Bad input: the deployment's capabilities contradict the data workload.
    InvalidDeploymentCapabilities(DeploymentCapabilitiesError), // unchanged
    /// Pass 1's memo candidates or Pass 2 failed.
    LogicalASAPCandidates(String),     // unchanged
    /// Stage 2 failed.
    PhysicalASAPCandidates(String),    // unchanged
    /// Stage 3 selected no plan.
    Selection(ErrorSelectingPlan),     // unchanged
    /// Stage 2 could not build the plan Stage 3 selected.
    Realization(PhysicalCandidateError), // unchanged
    // DeadlineReached,                // removed
}

/// One run's counts and stage times (stays; absorbs PlanningRoundReport, which is removed).
pub struct PlanningReport {
    /// Stage 0 and Pass 1, in milliseconds.
    pub pass1_ms: f64,                          // unchanged
    /// Pass 2's memo groups.
    pub memo_groups: usize,                     // was per round
    /// Pass 2's candidates.
    pub logical_candidates: usize,              // was per round
    /// Stage 2's operator nodes.
    pub operator_nodes: usize,                  // was per round
    /// Stage 2's physical candidates.
    pub physical_candidates: usize,             // was per round
    /// Stage 2's producer links over every candidate input.
    pub physical_producer_links: usize,         // was per round
    /// Stage 2's pruned candidates.
    pub stage2_pruned_candidates: usize,        // was per round
    /// Pass 2, Stage 2 and Stage 3 wall time, in milliseconds.
    pub pass2_ms: f64,                          // was per round
    pub stage2_ms: f64,                         // was per round
    pub stage3_ms: f64,                         // was per round
    /// Stage 3's search report, when it selected a plan.
    pub search_report: Option<SearchReport>,    // was per round
    // pub rounds: Vec<PlanningRoundReport>,          // removed
    // pub selected_round: Option<usize>,             // removed
    // pub tumbling_window_widths_pending: bool,      // removed
    // pub time_limit_ms: u64,                        // removed
}

pass2/logical_memo_candidates.rs, catalog/mod.rs

/// Pass 2: every tumbling-window width, in one pass.
pub fn generate_logical_asap_memo_candidates(
    pass1: PerComputationLogicalMemoCandidates,
    entries: &[QueryWorkloadEntry],
) -> Result<LogicalASAPMemoCandidates, Pass2RuleError>; // was (round state, domain, deadline) -> LogicalASAPMemoCandidatesError

/// Stage 2's catalog over Pass 2's memo.
pub fn generate_physical_asap_memo_candidates(
    logical: &LogicalASAPMemoCandidates,
    entries: &[QueryWorkloadEntry],
    data: &DataWorkload,
    query_time_results_retained: bool,
    raw_data_retained: bool,
    // deadline: Option<Instant>,   // removed
) -> Result<PhysicalASAPMemoCandidates, ErrorGeneratingPhysicalASAPMemoCandidates>;

Removed, with no replacement:

• executor::compile_before and Error::CompilationDeadlineExceeded
• flatten_before and FlattenDeadlineExceeded
• PhysicalASAPCompilationError
• TumblingWindowChainExpansionError
• InstallableDagError::DeadlineExceeded
• CandidateGenerationTimeout
• ErrorSelectingPlan::EvaluationDeadlineExceeded
• Selector::offer_before
• CLI: stage_pipeline --milp-time-limit-s

Usage:

# Plan the two-query sum_over_time fixture. There is no time flag any more.
# Pass 2 emits every width dividing the readers' grids;
# Stage 3's MILP runs to proven optimality.
stage_pipeline --workload <workload.json> --out run.json
# run.json: planning_report has one set of counts (no "rounds");
# the selected plan costs 5.94e-6 /s, the same as before this PR.

Major algorithm changes

Tumbling-window-width search

• Problem: the facade searched widths in rounds under a 30 s budget. On RangeHeavy T8+T5 it ended after 3 rounds with widths still unsearched, so the plan depended on how many rounds fit on the machine.
• Before:
  1. A seed round over the seed grids' widths.
  2. Intermediate rounds over a growing frontier, each running Pass 2 → Stage 2 → Stage 3 on the delta.
  3. Stop at the deadline or when the domain is complete; keep the cheapest round's plan.
• After: one Pass 2 over tumbling_window_width_domain(grids) (every divisor width), then Stage 2 and Stage 3 once.
• Correctness: the catalog is a superset of every round's, and Stage 3 is exact (fix(plan-selection): run the group selection MILP to proven optimality and cost exactly (#1185, part 1) #1188). So the selected cost is never higher than before, and it is the optimum over the full domain. Corpus and sketch snapshots are byte-identical, and the measured costs match.
• Complexity: catalog size grows with the number of divisor widths (for example, 48 for a 60 s grid) times the candidates per width. Measured (release):

Workload	Before	After	Cost/s before → after
RangeHeavy T8+T5 1h (stage_pipeline)	117 s, widths left unsearched	2257 s (Stage 3: warm start + build ≈1507 s, HiGHS ≈749 s, 114k vars)	6.4822e-6 → 6.4822e-6
runtime_install two-query fixture	< 60 s (debug)	155 s	5.94e-6 → 5.94e-6
planner-layering-1	2.1 s	0.2 s	unchanged

• Assumptions and limits: no time bound at all. A large workload now takes as long as the exact search takes (Planning is about 20x slower since the full tumbling-window-width domain (#1185) #1197).

Before this PR

Planning stopped after 30 s. On large workloads it returned the best plan over the widths it had reached, which varied with machine load. Tests that depended on the full domain were ignored as wall-clock flakes.

After this PR

Planning is deterministic: it returns the optimum over every tumbling-window width for any machine speed, and the time it takes is the cost of that search. The wall-clock markers #1067/#1175/#1180 are gone from the tests.

Verification

• Library tests:
  • logical 201
  • physical 31
  • plan-selection 142
  • types 143 + 103
  • executor 114 + 175
• Integration tests: 364 pass. The only failures fail on main too and are ignored with Stage 3 review: plan selection, the MILP over the memo, cost and accuracy constraints #1015 or Memo search solver: MILP over the memo for all cost models #888.
• devtools stage_pipeline: 44 pass, and planner_fuzz, memo_pricing and the manifest test are un-ignored.
• corpus_snapshots --release --include-ignored: 9 pass (q05 now searches the full domain; its snapshot is unchanged).
• DAG viewer: test_server 28, Node 45. The test_viewer header check is updated for the removed round text.
• cargo fmt --all --check and cargo clippy --workspace --tests --all-features: clean.
• Local debug cargo test --workspace (the CI command) was used to find the tests that now take over 30 min; they are ignored with Planning is about 20x slower since the full tumbling-window-width domain (#1185) #1197.

Limitations

• Planning time (Planning is about 20x slower since the full tumbling-window-width domain (#1185) #1197): the warm start is unbounded, HiGHS runs single-threaded, and the catalog spans every width. Possible fixes are listed in Planning is about 20x slower since the full tumbling-window-width domain (#1185) #1197; narrowing the width domain would change the search space and needs a decision.
• tools/benchmark_tumbling_window_search.py and the two evaluation docs are marked historical: their budget and round fields no longer exist.
• server.py's 300 s PLAN_TIMEOUT_SECONDS (HTTP subprocess guard) and planner_fuzz --time-budget-s (campaign length) are kept; neither is a planning parameter.

Closes #1185.

🤖 Generated with Claude Code