enricobuehler
b8a33e21a2
ci / rust (push) Has been cancelled
First step of 1 Gbps+ readiness (the whole point of the GF(2^16) Leopard FEC): make 1 Gbps configurable and its dominant failure mode observable, before the real transport work (sendmmsg + paced encode|send split) lands. Investigation (6-way) verdict: we're ~halfway, and it's mostly clamps plus one real piece of work. The integer/type path, FEC (a 1 Gbps frame is only a few hundred shards in one GF(2^16) block, far under the 65535 ceiling), AES-GCM (AES-NI, ~10-25x headroom), and the M1 reassembler bounds (fully derived from the negotiated FecConfig) are ALL already 1 Gbps-ready and untouched. This commit (the configurable + observable foundation): - m3.rs: MAX_BITRATE_KBPS 500_000 -> 2_000_000 (2 Gbps headroom over the 1 Gbps+ target); MAX_PROBE_KBPS 1_000_000 -> 3_000_000 (probe can demonstrate headroom ABOVE the session cap so a client can confidently pick a 1 Gbps+ bitrate). - transport/udp.rs: TARGET_SOCKBUF 8 MB -> 32 MB (a multi-MB IDR keyframe burst no longer fills the buffer); scripts/99-punktfunk-net.conf bumped to match. - Observability: Transport::send now returns Ok(true|false) (false = WouldBlock send-buffer drop, previously a silent Ok(())). Session counts these as a new `packets_send_dropped` stat (distinct from recv-side packets_dropped) — in Stats, the C ABI PunktfunkStats (header regenerated), a PUNKTFUNK_PERF periodic wire-Mbps + drop dump in virtual_stream, and the speed-test probe completion log. This is the dominant 1 Gbps+ loss mode and was invisible. Loopback-verified: a probe now runs at 1.2 Gbps target (no longer truncated to 1 Gbps) with the drop counter live. NOT yet a sustained-1-Gbps proof — the single-send()-per-packet native path is the next, real piece of work (port the proven GameStream sendmmsg + paced send thread into the core Transport). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
63 lines
2.4 KiB
Rust
63 lines
2.4 KiB
Rust
//! Live counters for the frame-pacing / quality logic and the web UI.
|
|
|
|
use std::sync::atomic::{AtomicU64, Ordering};
|
|
|
|
/// Immutable snapshot, copied across the C ABI as `PunktfunkStats`.
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
|
pub struct Stats {
|
|
pub frames_submitted: u64,
|
|
pub frames_completed: u64,
|
|
pub frames_dropped: u64,
|
|
pub packets_sent: u64,
|
|
pub packets_received: u64,
|
|
pub packets_dropped: u64,
|
|
/// Packets the host could NOT hand to the kernel because the send buffer was full (WouldBlock)
|
|
/// — the dominant loss mode at very high bitrate. Distinct from `packets_dropped` (recv-side
|
|
/// reassembler rejects). A non-zero, growing value means the link/encoder is outrunning the
|
|
/// send path; raise `net.core.wmem_max` / lower the bitrate, or wait for paced batched sending.
|
|
pub packets_send_dropped: u64,
|
|
pub fec_recovered_shards: u64,
|
|
pub bytes_sent: u64,
|
|
pub bytes_received: u64,
|
|
}
|
|
|
|
/// Atomic accumulators owned by a [`Session`](crate::session::Session). Snapshot to
|
|
/// [`Stats`] for readers. `Relaxed` ordering is fine: these are monotonic counters
|
|
/// read for display, never used to synchronize other memory.
|
|
#[derive(Default)]
|
|
pub struct StatsCounters {
|
|
pub frames_submitted: AtomicU64,
|
|
pub frames_completed: AtomicU64,
|
|
pub frames_dropped: AtomicU64,
|
|
pub packets_sent: AtomicU64,
|
|
pub packets_received: AtomicU64,
|
|
pub packets_dropped: AtomicU64,
|
|
pub packets_send_dropped: AtomicU64,
|
|
pub fec_recovered_shards: AtomicU64,
|
|
pub bytes_sent: AtomicU64,
|
|
pub bytes_received: AtomicU64,
|
|
}
|
|
|
|
impl StatsCounters {
|
|
#[inline]
|
|
pub fn add(counter: &AtomicU64, n: u64) {
|
|
counter.fetch_add(n, Ordering::Relaxed);
|
|
}
|
|
|
|
pub fn snapshot(&self) -> Stats {
|
|
let l = Ordering::Relaxed;
|
|
Stats {
|
|
frames_submitted: self.frames_submitted.load(l),
|
|
frames_completed: self.frames_completed.load(l),
|
|
frames_dropped: self.frames_dropped.load(l),
|
|
packets_sent: self.packets_sent.load(l),
|
|
packets_received: self.packets_received.load(l),
|
|
packets_dropped: self.packets_dropped.load(l),
|
|
packets_send_dropped: self.packets_send_dropped.load(l),
|
|
fec_recovered_shards: self.fec_recovered_shards.load(l),
|
|
bytes_sent: self.bytes_sent.load(l),
|
|
bytes_received: self.bytes_received.load(l),
|
|
}
|
|
}
|
|
}
|