refactor: name ASAP family strategies and clarify IR modules

Author: zzylol

crates/asap-aware-mapping/src/accuracy/mod.rs

@@ -33,7 +33,7 @@ use crate::exact_composition::ExactOperation;
 /// [`DefaultAccuracyModel`]; a deployment with a proof for a composition the
 /// default rejects (a registered cross-metric conversion, say) implements
 /// this trait and passes it to
-/// [`crate::replacement::SketchAlgorithmStrategy::new_with_planning_inputs`].
+/// [`crate::replacement::ASAPStrategies::new_with_planning_inputs`].
 pub trait AccuracyModel {
     /// The definition-registered rule for applying `operation` to an
     /// approximate input. `None` means the function is exact only over exact

crates/asap-aware-mapping/src/accuracy/reconciliation.rs

@@ -31,7 +31,7 @@
 //! Two `NonASAPOp::Aggregate` nodes are accuracy-near-duplicates here iff,
 //! **in this order**:
 //!
-//! 1. Both are the same bindable shape [`crate::replacement::SketchAlgorithmStrategy`]
+//! 1. Both are the same bindable shape [`crate::replacement::ASAPStrategies`]
 //!    itself targets — a single measure, no `HAVING` (`bindable_intent`'s own
 //!    scope) — **and** that one measure is one of the four accuracy-bearing
 //!    [`AggIntent`] variants ([`crate::replacement::accuracy_target`]'s own
@@ -105,7 +105,7 @@
 //!
 //! Like every [`ReplacementStrategy`], this only ever *proposes* — the
 //! looser-accuracy consumer's own independently-sized candidate (from
-//! [`crate::replacement::SketchAlgorithmStrategy`]) stays in its
+//! [`crate::replacement::ASAPStrategies`]) stays in its
 //! [`crate::replacement::TargetSubDAGCandidates`] right alongside this strategy's
 //! "read the tighter sibling instead" [`Replacement::Rewrite`] candidate;
 //! [`crate::cost_model::CostModel`]-driven ranking picks between them;
@@ -176,7 +176,7 @@ type BindableAccuracyAggregate<'a> = (
 
 /// The `(reduction, intent, accuracy, output_names, child)` shape this
 /// module operates on: the same single-measure, no-`HAVING` bindable shape
-/// [`crate::replacement::SketchAlgorithmStrategy`] targets (see that
+/// [`crate::replacement::ASAPStrategies`] targets (see that
 /// module's private `bindable_intent`), further narrowed to a measure whose
 /// intent actually carries an [`AccuracyTarget`]
 /// ([`crate::replacement::accuracy_target`]'s own scope: `Count` /
@@ -838,7 +838,7 @@ mod tests {
             "global_selection must commit to some candidate for a single-consumer looser target"
         );
         // With no recompute term at all (it never rebuilds `target`), this
-        // candidate strictly undercuts every SketchAlgorithmStrategy
+        // candidate strictly undercuts every ASAPStrategies
         // candidate (which each pay a recompute term on top of their own
         // maintenance term) under DefaultCostModel's numbers — the sane
         // direction: reading an already-necessary sibling should be able to

crates/asap-aware-mapping/src/cost_model.rs

@@ -26,7 +26,7 @@
 //! than overloading these ones across incompatible `Kind`/`Params` types.
 //!
 //! Every entry point that doesn't take an explicit `&dyn CostModel`
-//! ([`SketchAlgorithmStrategy::default_cost_model`](crate::replacement::SketchAlgorithmStrategy::default_cost_model),
+//! ([`ASAPStrategies::default_cost_model`](crate::replacement::ASAPStrategies::default_cost_model),
 //! [`search_workload`](crate::replacement::search_workload)) runs against
 //! [`DefaultCostModel`], so a deployment that never plugs in its own cost
 //! model keeps today's static-preference-order behavior exactly, byte for
@@ -738,14 +738,14 @@ pub trait CostModel {
     /// on [`CandidateLogicalASAPDAGs::cost_sorted`](crate::replacement::CandidateLogicalASAPDAGs::cost_sorted)),
     /// not just order candidates against each other — that ordering job
     /// already belongs to [`rank_candidates`](Self::rank_candidates) (for a
-    /// [`SketchAlgorithmStrategy`](crate::replacement::SketchAlgorithmStrategy)
+    /// [`ASAPStrategies`](crate::replacement::ASAPStrategies)
     /// group) and [`cse_share_decision`](Self::cse_share_decision) (for a
     /// [`SharedSubDagStrategy`](crate::replacement::SharedSubDagStrategy)
     /// group).
     ///
     /// One method covers both candidate shapes this crate ships:
     /// `candidate.replacement`'s [`Replacement::SubDag`] from a summary
-    /// realization (a `SketchAlgorithmStrategy` candidate — the bound node is
+    /// realization (a `ASAPStrategies` candidate — the bound node is
     /// right there, nothing to reconstruct) and the same arm from a rewrite
     /// (a `SharedSubDagStrategy` share-vs-recompute candidate — no bound
     /// summary of its own, since sharing is a decision about a target
@@ -1030,7 +1030,7 @@ impl CostModel for DefaultCostModel {
     /// second formula:
     ///
     /// - A [`ReplacementProvenance::SummaryRealization`] candidate (a
-    ///   `SketchAlgorithmStrategy` binding): `cse_recompute_cost` (the one-time
+    ///   `ASAPStrategies` binding): `cse_recompute_cost` (the one-time
     ///   structural cost of building `target` at all) plus
     ///   `cse_shared_maintenance_cost` of the candidate's own bound family
     ///   (a pricier family — a sketch over an exact accumulator, say —

crates/asap-aware-mapping/src/explanation.rs

@@ -31,7 +31,7 @@
 //! collapses into a single question this module asks of *that* data instead:
 //! **for a given `TargetSubDAG`, does its candidate list contain anything
 //! other than the trivial, no-op realization?** A `TargetSubDAG` whose only
-//! candidate is "the one thing `SketchAlgorithmStrategy` would have committed
+//! candidate is "the one thing `ASAPStrategies` would have committed
 //! to anyway, with no alternative" has no optimization to report — that
 //! candidate isn't an *opportunity*, it's just the target's existing shape
 //! reflected back. A `TargetSubDAG` with more than one candidate (several
@@ -45,7 +45,7 @@
 //! - [`ExplanationKind::SketchApproximation`] — the `TargetSubDAG`'s
 //!   candidate list contains at least one summary-realization [`Replacement::SubDag`] that
 //!   actually realizes a sketch family (`FieldDataType::Sketch`), i.e.
-//!   [`SketchAlgorithmStrategy`] found something to offer beyond whatever
+//!   [`ASAPStrategies`] found something to offer beyond whatever
 //!   exact/pass-through candidate [`crate::replacement`]'s own
 //!   `realizations_for_intent` would have committed to on its own.
 //! - [`ExplanationKind::CommonSubexpressionReuse`] — the `TargetSubDAG`
@@ -103,7 +103,7 @@
 //! [`ReplacementStrategy`] already *is* that extension point, one layer
 //! down, and [`explain_replacements_with`]'s own `strategies`
 //! parameter is where a caller plugs in a custom one (or a custom
-//! `CostModel`, via [`crate::replacement::SketchAlgorithmStrategy::new`]) — the identical spot
+//! `CostModel`, via [`crate::replacement::ASAPStrategies::new`]) — the identical spot
 //! [`crate::replacement::search_workload_with`] itself exposes.
 //!
 //! ## Two guarantees the old traversal made, re-verified against the new one
@@ -176,7 +176,7 @@
 //! [`ReplacementSubDAG`]: crate::replacement::ReplacementSubDAG
 //! [`Replacement`]: crate::replacement::Replacement
 //! [`Replacement::SubDag`]: crate::replacement::Replacement::SubDag
-//! [`SketchAlgorithmStrategy`]: crate::replacement::SketchAlgorithmStrategy
+//! [`ASAPStrategies`]: crate::replacement::ASAPStrategies
 //! [`SharedSubDagStrategy`]: crate::replacement::SharedSubDagStrategy
 //! [`CandidateLogicalASAPDAGs`]: crate::replacement::CandidateLogicalASAPDAGs
 //! [`TargetSubDAGCandidates`]: crate::replacement::TargetSubDAGCandidates
@@ -206,7 +206,7 @@ use crate::replacement::{
 pub enum ExplanationKind {
     /// A `TargetSubDAG`'s candidate list contains at least one
     /// [`Replacement::SubDag`] that realizes a sketch family —
-    /// [`crate::replacement::SketchAlgorithmStrategy`] found a genuine sketch
+    /// [`crate::replacement::ASAPStrategies`] found a genuine sketch
     /// alternative for this `Aggregate`, beyond whatever exact/pass-through
     /// candidate `crate::replacement`'s own `realizations_for_intent` would
     /// have committed to on its own.
@@ -273,7 +273,7 @@ pub fn explain_replacements<Id: Display>(
 /// instead of [`crate::replacement::default_strategies`] — the extension
 /// point for a deployment-specific [`ReplacementStrategy`], or a custom
 /// `CostModel` plugged into
-/// [`crate::replacement::SketchAlgorithmStrategy::new`] (e.g. via
+/// [`crate::replacement::ASAPStrategies::new`] (e.g. via
 /// [`crate::replacement::default_strategies_with`]).
 ///
 /// [`ReplacementStrategy`]: crate::replacement::ReplacementStrategy
@@ -839,7 +839,7 @@ mod tests {
         let q = agg(vec![2], default_quantile(0.99), metric_scan(&["job"]));
         let custom_model = AlwaysDDSketch;
         let strategies: Vec<Box<dyn ReplacementStrategy + '_>> = vec![Box::new(
-            crate::replacement::SketchAlgorithmStrategy::new(&custom_model),
+            crate::replacement::ASAPStrategies::new(&custom_model),
         )];
         let findings = explain_replacements_with(vec![("q", q)], &strategies);
         assert_eq!(findings.len(), 1);

crates/asap-aware-mapping/src/grouping.rs

@@ -41,7 +41,7 @@
 //! An earlier draft of this module (written against the very first draft of
 //! #251) reused a `CostModel`-wrapping adapter that "steered" a
 //! whole-recursive-bind decision procedure toward a specific `SketchKind`,
-//! the same pattern [`crate::replacement::SketchAlgorithmStrategy`]'s own module
+//! the same pattern [`crate::replacement::ASAPStrategies`]'s own module
 //! docs explain was deliberately deleted from this crate as an anti-pattern:
 //! forcing a choice via a whole-tree `CostModel` adapter had a real bug where
 //! the forced choice could leak into a target's own nested aggregates. This
@@ -53,7 +53,7 @@
 //! passes that exact,
 //! already-decided `Realization` to
 //! [`crate::replacement::construct_summary`] — the same first-class,
-//! one-candidate-at-a-time primitive [`crate::replacement::SketchAlgorithmStrategy`]
+//! one-candidate-at-a-time primitive [`crate::replacement::ASAPStrategies`]
 //! itself calls once per candidate. No adapter, no steering, no risk of a
 //! forced choice leaking into nested aggregates.
 //!
@@ -111,15 +111,15 @@ pub fn has_subpopulations(reduction: &Reduction) -> bool {
 
 /// A single static instance so [`HydraGroupingStrategy::default_cost_model`]
 /// can hand out a `&'static dyn CostModel` without heap-allocating one — same
-/// pattern [`crate::replacement::SketchAlgorithmStrategy`] uses.
+/// pattern [`crate::replacement::ASAPStrategies`] uses.
 static DEFAULT_COST_MODEL: DefaultCostModel = DefaultCostModel;
 
 /// Wraps the `GroupingStrategy` axis (issue #256) as a
-/// [`ReplacementStrategy`]: for a target [`SketchAlgorithmStrategy`](crate::replacement::SketchAlgorithmStrategy)
+/// [`ReplacementStrategy`]: for a target [`ASAPStrategies`](crate::replacement::ASAPStrategies)
 /// already has an opinion on, offers an additional
 /// `GroupingStrategy::SharedMultiSubpopulation` candidate wherever the
 /// legality conditions in the module docs above hold — alongside, not
-/// instead of, the per-subpopulation candidates `SketchAlgorithmStrategy`
+/// instead of, the per-subpopulation candidates `ASAPStrategies`
 /// itself enumerates. The workload search composes both strategies over the
 /// same target, so it sees every summary-family alternative *and* the Hydra
 /// alternative; the built-in workload search registers both strategies, and
@@ -133,7 +133,7 @@ pub struct HydraGroupingStrategy<'a> {
 impl HydraGroupingStrategy<'static> {
     /// A strategy that ranks/binds via the built-in [`DefaultCostModel`] —
     /// what a deployment gets with no custom cost model plugged in, the same
-    /// default [`crate::replacement::SketchAlgorithmStrategy::default_cost_model`]
+    /// default [`crate::replacement::ASAPStrategies::default_cost_model`]
     /// offers.
     pub fn default_cost_model() -> Self {
         Self {
@@ -145,7 +145,7 @@ impl HydraGroupingStrategy<'static> {
 impl<'a> HydraGroupingStrategy<'a> {
     /// A strategy that ranks/binds via `cost_model` instead of the built-in
     /// static preference order — the same customization point
-    /// [`crate::replacement::SketchAlgorithmStrategy::new`] already offers.
+    /// [`crate::replacement::ASAPStrategies::new`] already offers.
     pub fn new(cost_model: &'a dyn CostModel) -> Self {
         Self {
             planning_inputs: CandidatePlanningInputs::with_default_accuracy(cost_model),
@@ -814,7 +814,7 @@ mod tests {
     /// A custom `CostModel` doesn't change *which* candidate is offered —
     /// only which sketch candidate `realizations_for_intent` itself would
     /// have ranked first, and how that candidate's own params are sized —
-    /// same guarantee `SketchAlgorithmStrategy` makes for its own candidates.
+    /// same guarantee `ASAPStrategies` makes for its own candidates.
     struct PreferDDSketch;
     impl CostModel for PreferDDSketch {
         fn rank_candidates(

crates/asap-aware-mapping/src/lib.rs

@@ -8,7 +8,7 @@
 //! **Common sub-expression elimination (CSE) is not this crate's job.**
 //! Detection is a primary pass over the pre-ASAP operator IR itself
 //! (`asap_types::ir::cse`, design tracked in issue #223), run before a
-//! tree ever reaches [`replacement::SketchAlgorithmStrategy`] — see issue #222
+//! tree ever reaches [`replacement::ASAPStrategies`] — see issue #222
 //! for why (batch query optimization needs to see shared work across a
 //! `QueryWorkload` before summary binding, not after). This crate may
 //! eventually run a second, narrower CSE pass of its own over an
@@ -92,7 +92,7 @@
 //!   #33) is an additional `ReplacementStrategy`: the orthogonal
 //!   `GroupingStrategy` axis (one summary instance per `by` subpopulation
 //!   versus one shared Hydra-family structure serving all of them), offered
-//!   alongside the candidates [`replacement::SketchAlgorithmStrategy`]
+//!   alongside the candidates [`replacement::ASAPStrategies`]
 //!   enumerates for the same target.
 //! - [`rewrite`] — the "semantic-equivalent rewriting (e.g. `avg` →
 //!   `sum`/`count`) to increase how often the [sharing/sketch] optimizations
@@ -117,7 +117,7 @@
 //! |---|---|---|
 //! | Schema resolution | Derive input schemas and resolve column names to positions | `asap_types::pre_asap::SchemaResolver::resolve_schema`, `resolve_root` |
 //! | Realization | Enumerate ranked physical forms for one aggregate intent | `replacement::realizations_for_intent` |
-//! | Replacement | Construct each candidate summary sub-DAG | [`replacement::SketchAlgorithmStrategy`] |
+//! | Replacement | Construct each candidate summary sub-DAG | [`replacement::ASAPStrategies`] |
 //! | Search | Enumerate and compare alternatives across a workload | [`replacement::search_workload`] |
 //! | Runtime placement | Choose deployment locations and concrete executors | Downstream physical plan providers |
 //!
@@ -208,12 +208,12 @@ pub use recurrence::{
 };
 pub use replacement::{
     default_strategies, default_strategies_with, is_logical_rewrite, search_workload,
-    search_workload_with, search_workload_with_targets, summary_candidates,
+    search_workload_with, search_workload_with_targets, summary_candidates, ASAPStrategies,
     CandidateLogicalASAPDAGs, CompositionDecision, GlobalSelection, Matcher, Proposals,
     RankedTargetSubDAGCandidates, Realization, RealizationError, RecurrenceProfileMap,
     RejectedCandidate, Replacement, ReplacementProvenance, ReplacementStrategy, ReplacementSubDAG,
-    SharedSubDagStrategy, SketchAlgorithmStrategy, TargetSubDAG, TargetSubDAGCandidates,
-    TargetSubDAGSelection, MAX_SEARCH_ITERATIONS,
+    SharedSubDagStrategy, TargetSubDAG, TargetSubDAGCandidates, TargetSubDAGSelection,
+    MAX_SEARCH_ITERATIONS,
 };
 pub use rewrite::{AvgToSumOverCountStrategy, SemanticEquivalentRewriteStrategy};
 pub use summary_maintenance_dag_export::{

crates/asap-aware-mapping/src/physical_plan_cost_model.rs

@@ -691,7 +691,7 @@ mod tests {
             version: "unused-base-v1".into(),
         };
         let candidates =
-            crate::replacement::SketchAlgorithmStrategy::default_cost_model().replacements(&target);
+            crate::replacement::ASAPStrategies::default_cost_model().replacements(&target);
         provider.storage_io = Some(profile.clone());
         let model = PhysicalPlanCostModel::new(&provider, base.clone()).unwrap();
         let estimate = model.estimate_candidate(&candidates[0], &target).unwrap();
@@ -722,7 +722,7 @@ mod tests {
         let root = query();
         let target = TargetSubDAG::new(&root);
         let candidates =
-            crate::replacement::SketchAlgorithmStrategy::default_cost_model().replacements(&target);
+            crate::replacement::ASAPStrategies::default_cost_model().replacements(&target);
         let provider = TestProvider::new(true, 800);
         let model = PhysicalPlanCostModel::new(&provider, calibration()).unwrap();
         let estimate = model.estimate_candidate(&candidates[0], &target).unwrap();
@@ -1019,7 +1019,7 @@ mod tests {
         }
 
         let root = query();
-        let candidates = crate::replacement::SketchAlgorithmStrategy::default_cost_model()
+        let candidates = crate::replacement::ASAPStrategies::default_cost_model()
             .replacements(&TargetSubDAG::new(&root));
         let provider = WrongScope(TestProvider::new(true, 800));
         let model = PhysicalPlanCostModel::new(&provider, calibration()).unwrap();
@@ -1065,7 +1065,7 @@ mod tests {
         }
 
         let root = query();
-        let candidates = crate::replacement::SketchAlgorithmStrategy::default_cost_model()
+        let candidates = crate::replacement::ASAPStrategies::default_cost_model()
             .replacements(&TargetSubDAG::new(&root));
         let model = PhysicalPlanCostModel::new(&BlankVersionProvider, calibration()).unwrap();
         assert_eq!(
@@ -1092,7 +1092,7 @@ mod tests {
     #[test]
     fn sibling_candidates_share_one_scope_and_raw_baseline() {
         let root = query();
-        let candidates = crate::replacement::SketchAlgorithmStrategy::default_cost_model()
+        let candidates = crate::replacement::ASAPStrategies::default_cost_model()
             .replacements(&TargetSubDAG::new(&root));
         assert!(candidates.len() >= 2);
         let provider = TestProvider::new(true, 800);