use hearth_core::budget::{gib, plan, Budget, Declared, GIB};
use hearth_core::fleet::{Fleet, Route};
use hearth_core::residency::{LostReason, Observation, Residency};
fn main() {
residency_is_a_named_state();
the_card_is_arithmetic();
routers_get_an_answer();
}
fn residency_is_a_named_state() {
println!("== residency ==");
let s = Residency::Unknown
.observe(&Observation::LoadStarted, 1_000)
.observe(
&Observation::ProbeOk {
vram_bytes: 21 * GIB,
},
41_000,
);
assert!(s.is_ready());
println!(" {}", s.explain(60_000));
let lost = s.observe(
&Observation::ProbeFailed {
gpu_present: false,
detail: "no CUDA device".into(),
},
3_600_000,
);
match lost {
Residency::Lost { reason, .. } => {
assert_eq!(reason, LostReason::GpuDetached);
assert!(!reason.is_operator_fault());
println!(
" lost: {reason:?}, operator at fault: {}",
reason.is_operator_fault()
);
}
other => unreachable!("expected a loss, got {other:?}"),
}
}
fn the_card_is_arithmetic() {
println!("== budget ==");
let budget = Budget::with_reserve_pct(48 * GIB, 8);
let roster = vec![
Declared {
model: "muse-local:latest".into(),
weights_bytes: 20 * GIB,
kv_bytes: GIB,
},
Declared {
model: "deepseek-r1:32b".into(),
weights_bytes: 20 * GIB,
kv_bytes: GIB,
},
Declared {
model: "gemma4:26b".into(),
weights_bytes: 16 * GIB,
kv_bytes: GIB,
},
];
let p = plan(budget, &roster);
println!(" {}", p.explain());
for r in &p.rejected {
println!(
" {} will never fit here — short by {:.1} GiB",
r.model,
gib(r.short_bytes())
);
}
assert_eq!(p.admitted.len(), 2);
assert_eq!(p.rejected.len(), 1);
}
fn routers_get_an_answer() {
println!("== routing ==");
let budget = Budget::with_reserve_pct(48 * GIB, 8);
let roster = vec![Declared {
model: "muse-local:latest".into(),
weights_bytes: 20 * GIB,
kv_bytes: GIB,
}];
let now = 1_000;
let mut fleet = Fleet::declare(budget, roster);
fleet.set_endpoint("muse-local:latest", "127.0.0.1:8090");
fleet.observe("muse-local:latest", &Observation::LoadStarted, now);
match fleet.route("muse-local:latest", now + 5_000) {
Route::Ready { endpoint, .. } => println!(" ready — send it to {endpoint}"),
Route::Warming { for_ms, .. } => {
println!(" warming for {for_ms}ms — wait or try elsewhere, but do NOT fault this node")
}
Route::Lost {
operator_fault,
reason,
..
} => {
println!(" lost ({reason:?}) — try elsewhere; score only if {operator_fault}")
}
Route::NotAdmitted { short_bytes, .. } => {
println!(
" never going to fit — short {:.1} GiB, stop asking",
gib(short_bytes)
)
}
Route::Failed { reason, .. } => println!(" failed: {reason}"),
Route::NotDeclared { .. } => println!(" not declared here"),
Route::Unknown { .. } => println!(" declared, never observed — we say so"),
}
println!(" {}", fleet.report(now + 5_000).trim_end());
}