notParsec / 문서전체 문서

데이터·검증 자료

evidence/network-latency/relay_latency_diagnostic.rs

design/evidence/network-latency/relay_latency_diagnostic.rs

출처: 현재 작업 폴더 · 원문 다운로드

//! Disposable diagnosis: actual authenticated TLS/WS relay, controlled consumer delay; no GPU.
use anyhow::Result;
use notparsec_device_client::{initialize, remote::RemoteApi, request_registration};
use notparsec_session::remote::{self, DesktopSource};
use notparsec_wire::{remote::Input, video::{Codec, Event, Format, Packet}};
use std::{sync::{Arc,atomic::{AtomicUsize,Ordering}},time::{Duration,Instant}};
use tokio::sync::mpsc;
use zeroize::Zeroizing;
use axum::serve::ListenerExt;
struct Source { format:Format, next:Instant, sequence:u64, payload:usize, idle:bool, input:Arc<AtomicUsize> }
impl DesktopSource for Source {
 fn format(&self)->Format { self.format.clone() }
 fn frame(&mut self)->Result<Option<Packet>> {
  if (self.idle && self.sequence>0) || Instant::now()<self.next { return Ok(None) }
  self.next=Instant::now()+Duration::from_micros(16_667);
  let sequence=self.sequence;self.sequence+=1;
  Ok(Some(Packet{timing:None,sequence,time_100ns:(sequence*166667) as i64,keyframe:sequence==0,data:vec![0x65;self.payload]}))
 }
 fn input(&mut self,input:Input)->Result<()> { if matches!(input,Input::ReleaseAll){self.input.fetch_add(1,Ordering::SeqCst);} Ok(()) }
 fn request_keyframe(&mut self)->Result<()> {Ok(())}
 fn set_bitrate(&mut self,bitrate:u32)->Result<()> {self.format.bitrate=bitrate;Ok(())}
}
async fn scenario(label:&str,idle:bool,consumer_delay_ms:u64)->Result<()> {
 let work=tempfile::tempdir()?;
 let db=notparsec_control_server::open_database(&work.path().join("control.db"))?;
 let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await?;
 let origin=format!("http://{}",listener.local_addr()?);
 let router=notparsec_control_server::router(db.clone());
 let server=tokio::spawn(async move { axum::serve(listener.tap_io(|s|{s.set_nodelay(true).unwrap();}),router).await.unwrap() });
 let host=work.path().join("host");let client=work.path().join("client");let mut ids=Vec::new();
 for (path,name) in [(&host,"diagnostic host"),(&client,"diagnostic viewer")] {
  initialize(path,&origin)?;let registration=request_registration(path,name).await?;
  notparsec_control_server::approve_enrollment(&db,&registration.device_id)?;ids.push(registration.device_id);
 }
 let password="disposable-diagnostic-password";notparsec_session::host::initialize(&host,password)?;
 let input=Arc::new(AtomicUsize::new(0));let host_input=input.clone();
 let factory:remote::DesktopFactory=Arc::new(move |_|Ok(Box::new(Source{format:Format{codec:Codec::H264,width:1920,height:1080,fps:60,bitrate:10_000_000},next:Instant::now(),sequence:0,payload:16*1024,idle,input:host_input.clone()})));
 let (stop,stopped)=tokio::sync::oneshot::channel();let(status,_)=std::sync::mpsc::channel();
 let host_task=tokio::spawn(async move{remote::host(&host,factory,stopped,status).await});
 let mut api=RemoteApi::connect(&client).await?;
 for _ in 0..80 {if !api.hosts().await?.is_empty(){break}tokio::time::sleep(Duration::from_millis(25)).await;}
 let connection=remote::connect(&mut api,&ids[0],Zeroizing::new(password.into())).await?;
 let session=connection.session;
 let (tx,rx)=mpsc::channel(128);let(frames,mut frame_rx)=mpsc::channel(2);
 let (metrics,mut metric_rx)=tokio::sync::watch::channel(remote::ClientMetrics::default());
 let viewer=tokio::spawn(remote::receive_desktop_monitored(connection.stream,rx,frames,metrics));
 let consumed=Arc::new(AtomicUsize::new(0));let c=consumed.clone();
 let drain=tokio::spawn(async move{while let Some(event)=frame_rx.recv().await{if matches!(event,Event::Frame(_)){c.fetch_add(1,Ordering::SeqCst);if consumer_delay_ms>0{tokio::time::sleep(Duration::from_millis(consumer_delay_ms)).await;}}}});
 let mut samples=Vec::new();let mut queues=Vec::new();let mut last=None;let end=tokio::time::sleep(Duration::from_secs(6));tokio::pin!(end);
 loop {tokio::select!{_=&mut end=>break,r=metric_rx.changed()=>{if r.is_err(){break}let s=metric_rx.borrow_and_update().clone();if let Some((rtt,at))=s.rtt{if Some(at)!=last{last=Some(at);samples.push(rtt.as_secs_f64()*1000.);}}if let Some((wait,_))=s.decoder_queue_wait{queues.push(wait.as_secs_f64()*1000.);}}}}
 let started=Instant::now();let before=input.load(Ordering::SeqCst);tx.send(Input::ReleaseAll).await?;
 let deadline=Instant::now()+Duration::from_secs(2);while input.load(Ordering::SeqCst)==before && Instant::now()<deadline{tokio::time::sleep(Duration::from_millis(1)).await;}
 let input_seen=input.load(Ordering::SeqCst)>before;
 println!("DIAGNOSTIC {{\"case\":\"{label}\",\"consumer_delay_ms\":{consumer_delay_ms},\"rtt_ms\":{samples:?},\"max_decoder_queue_ms\":{},\"consumed\":{},\"release_all_delivery_ms\":{},\"release_all_seen\":{input_seen}}}",queues.iter().copied().fold(0f64,f64::max),consumed.load(Ordering::SeqCst),started.elapsed().as_secs_f64()*1000.);
 assert!(!samples.is_empty(),"No RTT samples");
 api.close(&session).await?;let _=stop.send(());viewer.abort();drain.abort();let _=tokio::time::timeout(Duration::from_secs(3),host_task).await;server.abort();Ok(())
}
#[tokio::test(flavor="multi_thread",worker_threads=4)]
async fn measure_actual_relay_with_controlled_decoder_backpressure()->Result<()> {
 scenario("idle",true,0).await?;
 scenario("60fps_16k_frames_fast_consumer",false,0).await?;
 scenario("60fps_16k_frames_50ms_consumer",false,50).await?;Ok(())
}