use std::time::Duration;
use matier_transport::h2::LoadSnapshot;
pub const BUSY_SATURATED_PERMILLE: u32 = 500;
pub const DISPATCH_SATURATED: Duration = Duration::from_micros(100);
pub const INBOX_SATURATED: usize = 256;
pub const SCALE_MIN_IN_FLIGHT: usize = 4;
pub const SCALE_DEEP_IN_FLIGHT: usize = 16;
pub const SCALE_DEEP_BUSY_PERMILLE: u32 = 250;
pub const SCALE_UP_COOLDOWN: Duration = Duration::from_millis(50);
pub const BUSY_LOW_PERMILLE: u32 = 200;
pub const DRAIN_PROJECTED_MAX_PERMILLE: u32 = 300;
pub const DRAIN_AFTER_LOW: Duration = Duration::from_secs(1);
pub const DRAIN_HOLDOFF_AFTER_SCALE_UP: Duration = Duration::from_secs(5);
pub const REAP_TICK_MIN: Duration = Duration::from_millis(5);
pub const REAP_TICK_MAX: Duration = Duration::from_millis(250);
#[must_use]
pub fn default_h2_max_conns() -> usize {
std::thread::available_parallelism().map_or(4, std::num::NonZero::get)
}
#[must_use]
pub fn h2_ceiling(min_conns: usize, max_conns: usize) -> usize {
let workers =
tokio::runtime::Handle::try_current().map_or(usize::MAX, |h| h.metrics().num_workers());
max_conns.min(workers).max(min_conns).max(1)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ScaleThresholds {
pub busy_permille: u32,
pub dispatch_delay: Duration,
pub inbox: usize,
pub cooldown: Duration,
}
impl Default for ScaleThresholds {
fn default() -> Self {
Self {
busy_permille: BUSY_SATURATED_PERMILLE,
dispatch_delay: DISPATCH_SATURATED,
inbox: INBOX_SATURATED,
cooldown: SCALE_UP_COOLDOWN,
}
}
}
impl ScaleThresholds {
#[must_use]
pub fn is_saturated(&self, load: LoadSnapshot, in_flight: usize, limit: usize) -> bool {
in_flight >= limit
|| (in_flight >= SCALE_DEEP_IN_FLIGHT && load.busy_permille > SCALE_DEEP_BUSY_PERMILLE)
|| (in_flight >= SCALE_MIN_IN_FLIGHT
&& (load.busy_permille > self.busy_permille
|| load.dispatch_delay > self.dispatch_delay
|| load.inbox > self.inbox))
}
}
#[must_use]
pub fn is_saturated(load: LoadSnapshot, in_flight: usize, limit: usize) -> bool {
ScaleThresholds::default().is_saturated(load, in_flight, limit)
}
#[must_use]
pub fn can_drain(busy_permille: &[u32]) -> bool {
let n = busy_permille.len();
if n < 2 {
return false;
}
let sum: u32 = busy_permille.iter().sum();
busy_permille.iter().all(|&b| b < BUSY_LOW_PERMILLE)
&& sum / (n as u32 - 1) < DRAIN_PROJECTED_MAX_PERMILLE
}
#[must_use]
pub fn reap_tick(idle_timeout: Duration) -> Duration {
(idle_timeout / 4).clamp(REAP_TICK_MIN, REAP_TICK_MAX)
}
#[cfg(test)]
mod tests {
use super::*;
fn load(busy: u32, disp_us: u64, inbox: usize) -> LoadSnapshot {
LoadSnapshot {
busy_permille: busy,
dispatch_delay: Duration::from_micros(disp_us),
inbox,
}
}
#[test]
fn saturation_signals() {
assert!(!is_saturated(load(0, 0, 0), 3, 128));
assert!(!is_saturated(load(250, 100, 256), 39, 128)); assert!(!is_saturated(
load(500, 100, 256),
SCALE_DEEP_IN_FLIGHT - 1,
128
));
assert!(is_saturated(load(501, 0, 0), 8, 128));
assert!(is_saturated(load(10, 101, 0), 8, 128));
assert!(is_saturated(load(10, 0, 257), 8, 128));
assert!(!is_saturated(load(1000, 5000, 1000), 1, 128));
assert!(!is_saturated(
load(1000, 5000, 1000),
SCALE_MIN_IN_FLIGHT - 1,
128
));
assert!(is_saturated(load(1000, 0, 0), SCALE_MIN_IN_FLIGHT, 128));
assert!(is_saturated(load(0, 0, 0), 128, 128));
assert!(is_saturated(load(0, 0, 0), 5, 4));
}
#[test]
fn deep_connections_saturate_at_a_lower_busy_fraction() {
assert!(is_saturated(load(470, 20, 6), 64, 128));
assert!(is_saturated(load(251, 0, 0), SCALE_DEEP_IN_FLIGHT, 128));
assert!(!is_saturated(load(250, 0, 0), 64, 128));
assert!(!is_saturated(
load(470, 20, 6),
SCALE_DEEP_IN_FLIGHT - 1,
128
));
assert!(!is_saturated(load(470, 20, 6), 1, 128));
assert!(is_saturated(load(430, 20, 6), 32, 128));
}
#[test]
fn drain_needs_everyone_low_and_projection_ok() {
assert!(!can_drain(&[]));
assert!(!can_drain(&[10]));
assert!(can_drain(&[10, 10]));
assert!(can_drain(&[140, 140, 140])); assert!(!can_drain(&[190, 190])); assert!(!can_drain(&[10, 200])); assert!(can_drain(&[199, 199, 199, 199, 199, 199, 199, 199, 100])); for n in 2..=64u32 {
let busy = vec![BUSY_LOW_PERMILLE - 1; n as usize];
if can_drain(&busy) {
let projected = (BUSY_LOW_PERMILLE - 1) * n / (n - 1);
assert!(projected < BUSY_SATURATED_PERMILLE);
}
}
}
#[test]
fn ceiling_follows_runtime_workers_but_honours_a_pin() {
assert_eq!(h2_ceiling(1, 8), 8); let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(3)
.build()
.unwrap();
rt.block_on(async {
assert_eq!(h2_ceiling(1, 8), 3);
assert_eq!(h2_ceiling(1, 2), 2);
assert_eq!(h2_ceiling(6, 6), 6);
});
}
#[test]
fn tick_is_bounded() {
assert_eq!(reap_tick(Duration::from_millis(1)), REAP_TICK_MIN);
assert_eq!(reap_tick(Duration::from_secs(90)), REAP_TICK_MAX);
assert_eq!(
reap_tick(Duration::from_millis(200)),
Duration::from_millis(50)
);
}
#[test]
fn default_max_is_positive() {
assert!(default_h2_max_conns() >= 1);
}
}