diff --git a/crates/skippy-topology/src/artifact_diagnostics.rs b/crates/skippy-topology/src/artifact_diagnostics.rs new file mode 100644 index 0000000000..04bfab5f7a --- /dev/null +++ b/crates/skippy-topology/src/artifact_diagnostics.rs @@ -0,0 +1,62 @@ +use crate::{DiagnosticSeverity, NodePlacementSignal, PlanDiagnostic, PlanReasonCode, StagePlan}; + +pub(crate) fn append_artifact_diagnostics( + diagnostics: &mut Vec, + stages: &[StagePlan], + placement_signals: &[NodePlacementSignal], +) { + let cached_bytes = stages + .iter() + .map(cached_artifact_bytes_for_stage) + .sum::(); + let missing_bytes = stages + .iter() + .map(missing_artifact_bytes_for_stage) + .sum::(); + + if cached_bytes == 0 && missing_bytes == 0 { + return; + } + + let peer_transfer_bytes = missing_bytes_by_transfer_support(stages, placement_signals, true); + let remote_download_bytes = missing_bytes.saturating_sub(peer_transfer_bytes); + let code = if missing_bytes > 0 { + PlanReasonCode::ArtifactTransferPenalty + } else { + PlanReasonCode::CacheLocalityPreferred + }; + + diagnostics.push(PlanDiagnostic { + severity: DiagnosticSeverity::Info, + code, + message: format!( + "artifact cold-start plan: cached={} bytes, missing={} bytes, peer-transfer-eligible={} bytes, remote-download-fallback={} bytes", + cached_bytes, missing_bytes, peer_transfer_bytes, remote_download_bytes + ), + }); +} + +fn missing_bytes_by_transfer_support( + stages: &[StagePlan], + placement_signals: &[NodePlacementSignal], + transfer_supported: bool, +) -> u64 { + stages + .iter() + .filter(|stage| { + placement_signals + .iter() + .find(|signal| signal.node_id == stage.node_id) + .is_some_and(|signal| signal.artifact_transfer_supported == transfer_supported) + }) + .map(missing_artifact_bytes_for_stage) + .sum() +} + +fn cached_artifact_bytes_for_stage(stage: &StagePlan) -> u64 { + stage.cached_slice_bytes.min(stage.parameter_bytes) +} + +fn missing_artifact_bytes_for_stage(stage: &StagePlan) -> u64 { + stage.missing_artifact_bytes.min(stage.parameter_bytes) +} diff --git a/crates/skippy-topology/src/lib.rs b/crates/skippy-topology/src/lib.rs index 7c5e6632fb..50d9facf6d 100644 --- a/crates/skippy-topology/src/lib.rs +++ b/crates/skippy-topology/src/lib.rs @@ -1,5 +1,7 @@ use serde::{Deserialize, Serialize}; +mod artifact_diagnostics; + #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)] pub struct TopologyPlanRequest { pub topology_id: String, @@ -1087,6 +1089,7 @@ fn plan_ranges_with_signals( let diagnostics = diagnostics_for( &stages, &boundaries, + placement_signals, request.family.as_ref(), request.policy, ); @@ -1375,10 +1378,12 @@ pub fn wire_payload_bytes_per_token(activation_width: u32, dtype: WireDType) -> fn diagnostics_for( stages: &[StagePlan], boundaries: &[BoundaryPlan], + placement_signals: &[NodePlacementSignal], family: Option<&FamilyCapabilityRecord>, policy: PlannerPolicy, ) -> Vec { let mut diagnostics = Vec::new(); + artifact_diagnostics::append_artifact_diagnostics(&mut diagnostics, stages, placement_signals); for stage in stages { if matches!( stage.migration_policy, diff --git a/crates/skippy-topology/src/tests.rs b/crates/skippy-topology/src/tests.rs index d0804c007c..509ba3126b 100644 --- a/crates/skippy-topology/src/tests.rs +++ b/crates/skippy-topology/src/tests.rs @@ -169,6 +169,70 @@ fn package_aware_plan_prefers_cached_peer_for_equal_capacity() { ); } +#[test] +fn package_aware_plan_reports_cold_start_artifact_totals() { + let mut transfer_ready = placement_signal("transfer-ready"); + transfer_ready.missing_artifact_bytes = 32; + transfer_ready.artifact_transfer_supported = true; + let mut remote_fallback = placement_signal("remote-fallback"); + remote_fallback.missing_artifact_bytes = 16; + remote_fallback.artifact_transfer_supported = false; + let mut warm = placement_signal("warm"); + warm.cached_slice_bytes = 64; + let request = TopologyPlanRequest { + topology_id: "topology-a".into(), + model_id: "model-a".into(), + layers: dense_attention_layers(9, 10), + nodes: vec![ + weighted_node("transfer-ready", 30), + weighted_node("remote-fallback", 30), + weighted_node("warm", 30), + ], + family: None, + policy: PlannerPolicy::default(), + }; + + let plan = plan_package_aware_contiguous_with_signals( + &request, + &[transfer_ready, remote_fallback, warm], + ) + .expect("plan"); + + let diagnostic = plan + .diagnostics + .iter() + .find(|diagnostic| diagnostic.code == PlanReasonCode::ArtifactTransferPenalty) + .expect("artifact diagnostic"); + assert!(diagnostic.message.contains("cached=30 bytes")); + assert!(diagnostic.message.contains("missing=46 bytes")); + assert!( + diagnostic + .message + .contains("peer-transfer-eligible=30 bytes") + ); + assert!( + diagnostic + .message + .contains("remote-download-fallback=16 bytes") + ); +} + +#[test] +fn weighted_plan_without_artifact_signals_stays_diagnostic_quiet() { + let request = TopologyPlanRequest { + topology_id: "topology-a".into(), + model_id: "model-a".into(), + layers: dense_attention_layers(6, 10), + nodes: vec![weighted_node("node-a", 30), weighted_node("node-b", 30)], + family: None, + policy: PlannerPolicy::default(), + }; + + let plan = plan_weighted_contiguous(&request).expect("plan"); + + assert!(plan.diagnostics.is_empty()); +} + #[test] fn package_aware_plan_penalizes_missing_untransferable_artifacts() { let mut cold = placement_signal("cold-high-vram");