feat(server): add perfenc example/test

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Author: elmarco

Cargo.lock

@@ -14,14 +14,18 @@ categories.workspace = true
 [lib]
 doctest = true
 
+[[example]]
+name = "perfenc"
+required-features = ["__bench"]
+
 [features]
 default = ["rayon"]
 helper = ["dep:x509-cert", "dep:rustls-pemfile"]
 rayon = ["dep:rayon"]
 
 # Internal (PRIVATE!) features used to aid testing.
 # Don't rely on these whatsoever. They may disappear at any time.
-__bench = []
+__bench = ["dep:visibility"]
 
 [dependencies]
 anyhow = "1.0"
@@ -45,9 +49,13 @@ x509-cert = { version = "0.2.5", optional = true }
 rustls-pemfile = { version = "2.2.0", optional = true }
 rayon = { version = "1.10.0", optional = true }
 bytes = "1"
+visibility = { version = "0.1", optional = true }
 
 [dev-dependencies]
-tokio = { version = "1", features = ["sync"] }
+tokio = { version = "1", features = ["sync", "fs"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+pico-args = "0.5"
+bytesize = "1.3"
 
 [lints]
 workspace = true

crates/ironrdp-server/Cargo.toml

@@ -0,0 +1,170 @@
+#![allow(unused_crate_dependencies)] // False positives because there are both a library and a binary.
+#![allow(clippy::print_stderr)]
+#![allow(clippy::print_stdout)]
+
+use std::io::Write;
+
+use anyhow::Context;
+use ironrdp_pdu::rdp::capability_sets::{CmdFlags, EntropyBits};
+use ironrdp_server::{
+    bench::encoder::UpdateEncoder, BitmapUpdate, DesktopSize, DisplayUpdate, PixelFormat, RdpServerDisplayUpdates,
+};
+use tokio::{fs::File, io::AsyncReadExt};
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> Result<(), anyhow::Error> {
+    setup_logging()?;
+    let mut args = pico_args::Arguments::from_env();
+
+    if args.contains(["-h", "--help"]) {
+        println!("Usage: perfenc [OPTIONS] <RGBX_INPUT_FILENAME>");
+        println!();
+        println!("Measure the performance of the IronRDP server encoder, given a raw RGBX video input file.");
+        println!();
+        println!("Options:");
+        println!("  --width <WIDTH>      Width of the display (default: 3840)");
+        println!("  --height <HEIGHT>    Height of the display (default: 2400)");
+        println!("  --codec <CODEC>      Codec to use (default: RemoteFX)");
+        println!("                        Valid values: RemoteFX, Bitmap, None");
+        std::process::exit(0);
+    }
+
+    let width = args.opt_value_from_str("--width")?.unwrap_or(3840);
+    let height = args.opt_value_from_str("--height")?.unwrap_or(2400);
+    let codec = args.opt_value_from_str("--codec")?.unwrap_or_else(OptCodec::default);
+
+    let filename: String = args.free_from_str().context("missing RGBX input filename")?;
+    let file = File::open(&filename)
+        .await
+        .with_context(|| format!("Failed to open file: {}", filename))?;
+
+    let mut flags = CmdFlags::all();
+
+    #[allow(unused)]
+    let (remotefx, qoicodec) = match codec {
+        OptCodec::RemoteFX => (Some((EntropyBits::Rlgr3, 0)), None::<u8>),
+        OptCodec::Bitmap => {
+            flags -= CmdFlags::SET_SURFACE_BITS;
+            (None, None)
+        }
+        OptCodec::None => (None, None),
+    };
+    let mut encoder = UpdateEncoder::new(DesktopSize { width, height }, flags, remotefx);
+
+    let mut total_raw = 0u64;
+    let mut total_enc = 0u64;
+    let mut n_updates = 0u64;
+    let mut updates = DisplayUpdates::new(file, DesktopSize { width, height });
+    while let Some(up) = updates.next_update().await {
+        if let DisplayUpdate::Bitmap(ref up) = up {
+            total_raw += up.data.len() as u64;
+        } else {
+            eprintln!("Invalid update");
+            break;
+        }
+        let mut iter = encoder.update(up);
+        loop {
+            let Some(frag) = iter.next().await else {
+                break;
+            };
+            let len = frag?.data.len() as u64;
+            total_enc += len;
+        }
+        n_updates += 1;
+        print!(".");
+        std::io::stdout().flush().unwrap();
+    }
+    println!();
+
+    let ratio = total_enc as f64 / total_raw as f64;
+    let percent = 100.0 - ratio * 100.0;
+    println!("Encoder: {:?}", encoder);
+    println!("Nb updates: {:?}", n_updates);
+    println!(
+        "Sum of bytes: {}/{} ({:.2}%)",
+        bytesize::ByteSize(total_enc),
+        bytesize::ByteSize(total_raw),
+        percent,
+    );
+    Ok(())
+}
+
+struct DisplayUpdates {
+    file: File,
+    desktop_size: DesktopSize,
+}
+
+impl DisplayUpdates {
+    fn new(file: File, desktop_size: DesktopSize) -> Self {
+        Self { file, desktop_size }
+    }
+}
+
+#[async_trait::async_trait]
+impl RdpServerDisplayUpdates for DisplayUpdates {
+    async fn next_update(&mut self) -> Option<DisplayUpdate> {
+        let stride = self.desktop_size.width as usize * 4;
+        let frame_size = stride * self.desktop_size.height as usize;
+        let mut buf = vec![0u8; frame_size];
+        if self.file.read_exact(&mut buf).await.is_err() {
+            return None;
+        }
+
+        let up = DisplayUpdate::Bitmap(BitmapUpdate {
+            x: 0,
+            y: 0,
+            width: self.desktop_size.width.try_into().unwrap(),
+            height: self.desktop_size.height.try_into().unwrap(),
+            format: PixelFormat::RgbX32,
+            data: buf.into(),
+            stride,
+        });
+        Some(up)
+    }
+}
+
+fn setup_logging() -> anyhow::Result<()> {
+    use tracing::metadata::LevelFilter;
+    use tracing_subscriber::prelude::*;
+    use tracing_subscriber::EnvFilter;
+
+    let fmt_layer = tracing_subscriber::fmt::layer().compact();
+
+    let env_filter = EnvFilter::builder()
+        .with_default_directive(LevelFilter::WARN.into())
+        .with_env_var("IRONRDP_LOG")
+        .from_env_lossy();
+
+    tracing_subscriber::registry()
+        .with(fmt_layer)
+        .with(env_filter)
+        .try_init()
+        .context("failed to set tracing global subscriber")?;
+
+    Ok(())
+}
+
+enum OptCodec {
+    RemoteFX,
+    Bitmap,
+    None,
+}
+
+impl Default for OptCodec {
+    fn default() -> Self {
+        Self::RemoteFX
+    }
+}
+
+impl core::str::FromStr for OptCodec {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "remotefx" => Ok(Self::RemoteFX),
+            "bitmap" => Ok(Self::Bitmap),
+            "none" => Ok(Self::None),
+            _ => Err(anyhow::anyhow!("unknown codec: {}", s)),
+        }
+    }
+}

crates/ironrdp-server/examples/perfenc.rs

@@ -10,10 +10,12 @@ const MAX_FASTPATH_UPDATE_SIZE: usize = 16_374;
 
 const FASTPATH_HEADER_SIZE: usize = 6;
 
+#[cfg_attr(feature = "__bench", visibility::make(pub))]
 pub(crate) struct UpdateFragmenter {
     code: UpdateCode,
     index: usize,
-    data: Vec<u8>,
+    #[doc(hidden)] // not part of the public API, used by benchmarks
+    pub data: Vec<u8>,
     position: usize,
 }
 

crates/ironrdp-server/src/encoder/fast_path.rs

@@ -26,6 +26,7 @@ enum CodecId {
     None = 0x0,
 }
 
+#[cfg_attr(feature = "__bench", visibility::make(pub))]
 pub(crate) struct UpdateEncoder {
     desktop_size: DesktopSize,
     // FIXME: draw updates on the framebuffer
@@ -42,6 +43,7 @@ impl fmt::Debug for UpdateEncoder {
 }
 
 impl UpdateEncoder {
+    #[cfg_attr(feature = "__bench", visibility::make(pub))]
     pub(crate) fn new(desktop_size: DesktopSize, surface_flags: CmdFlags, remotefx: Option<(EntropyBits, u8)>) -> Self {
         let bitmap_updater = if !surface_flags.contains(CmdFlags::SET_SURFACE_BITS) {
             BitmapUpdater::Bitmap(BitmapHandler::new())
@@ -59,6 +61,7 @@ impl UpdateEncoder {
         }
     }
 
+    #[cfg_attr(feature = "__bench", visibility::make(pub))]
     pub(crate) fn update(&mut self, update: DisplayUpdate) -> EncoderIter<'_> {
         EncoderIter {
             encoder: self,
@@ -148,12 +151,14 @@ impl UpdateEncoder {
     }
 }
 
+#[cfg_attr(feature = "__bench", visibility::make(pub))]
 pub(crate) struct EncoderIter<'a> {
     encoder: &'a mut UpdateEncoder,
     update: Option<DisplayUpdate>,
 }
 
 impl EncoderIter<'_> {
+    #[cfg_attr(feature = "__bench", visibility::make(pub))]
     pub(crate) async fn next(&mut self) -> Option<Result<UpdateFragmenter>> {
         let update = self.update.take()?;
         let encoder = &mut self.encoder;

crates/ironrdp-server/src/encoder/mod.rs

@@ -32,6 +32,8 @@ pub mod bench {
         pub mod rfx {
             pub use crate::encoder::rfx::bench::{rfx_enc, rfx_enc_tile};
         }
+
+        pub use crate::encoder::UpdateEncoder;
     }
 }
 
@@ -40,7 +42,7 @@ macro_rules! time_warn {
     ($context:expr, $threshold_ms:expr, $op:expr) => {{
         #[cold]
         fn warn_log(context: &str, duration: u128) {
-            use ::core::sync::atomic::AtomicUsize;
+            use core::sync::atomic::AtomicUsize;
 
             static COUNT: AtomicUsize = AtomicUsize::new(0);
             let current_count = COUNT.fetch_add(1, ::core::sync::atomic::Ordering::Relaxed);
@@ -58,3 +60,10 @@ macro_rules! time_warn {
         result
     }};
 }
+
+#[cfg(test)]
+mod tests {
+    use bytesize as _;
+    use pico_args as _;
+    use tracing_subscriber as _;
+}