feat(benches): add perfenc

Make some internal APIs publicly visible thanks to "visibility" when
compiling with the "__bench" feature.

("testsuite-core" also learned "__bench", because fast_path.rs is a
shared file)

Signed-off-by: Marc-André Lureau <[email protected]>

Author: elmarco

Cargo.lock

@@ -1,6 +1,7 @@
 [workspace]
 members = [
   "crates/*",
+  "benches",
   "xtask",
   "ffi",
 ]

Cargo.toml

@@ -0,0 +1,193 @@
+#![allow(unused_crate_dependencies)] // False positives because there are both a library and a binary.
+#![allow(clippy::print_stderr)]
+#![allow(clippy::print_stdout)]
+
+use core::time::Duration;
+use std::{io::Write, time::Instant};
+
+use anyhow::Context;
+use ironrdp::pdu::rdp::capability_sets::{CmdFlags, EntropyBits};
+use ironrdp::server::{
+    bench::encoder::{UpdateEncoder, UpdateEncoderCodecs},
+    BitmapUpdate, DesktopSize, DisplayUpdate, PixelFormat, RdpServerDisplayUpdates,
+};
+use tokio::{fs::File, io::AsyncReadExt, time::sleep};
+
+#[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");
+        println!("  --fps <FPS>          Frames per second (default: 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 fps = args.opt_value_from_str("--fps")?.unwrap_or(0);
+
+    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();
+    let mut update_codecs = UpdateEncoderCodecs::new();
+
+    match codec {
+        OptCodec::RemoteFX => update_codecs.set_remotefx(Some((EntropyBits::Rlgr3, 0))),
+        OptCodec::Bitmap => {
+            flags -= CmdFlags::SET_SURFACE_BITS;
+        }
+        OptCodec::None => {}
+    };
+
+    let mut encoder = UpdateEncoder::new(DesktopSize { width, height }, flags, update_codecs);
+
+    let mut total_raw = 0u64;
+    let mut total_enc = 0u64;
+    let mut n_updates = 0u64;
+    let mut updates = DisplayUpdates::new(file, DesktopSize { width, height }, fps);
+    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,
+    fps: u64,
+    last_update_time: Option<Instant>,
+}
+
+impl DisplayUpdates {
+    fn new(file: File, desktop_size: DesktopSize, fps: u64) -> Self {
+        Self {
+            file,
+            desktop_size,
+            fps,
+            last_update_time: None,
+        }
+    }
+}
+
+#[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 now = Instant::now();
+        if let Some(last_update_time) = self.last_update_time {
+            let elapsed = now - last_update_time;
+            if self.fps > 0 && elapsed < Duration::from_millis(1000 / self.fps) {
+                sleep(Duration::from_millis(
+                    1000 / self.fps - u64::try_from(elapsed.as_millis()).unwrap(),
+                ))
+                .await;
+            }
+        }
+        self.last_update_time = Some(now);
+
+        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)),
+        }
+    }
+}

benches/src/perfenc.rs

@@ -22,7 +22,7 @@ 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"
@@ -46,6 +46,7 @@ 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"] }

crates/ironrdp-server/Cargo.toml

@@ -8,10 +8,13 @@ const MAX_FASTPATH_UPDATE_SIZE: usize = 16_374;
 
 const FASTPATH_HEADER_SIZE: usize = 6;
 
+#[allow(unreachable_pub)]
+#[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,16 +26,19 @@ enum CodecId {
     None = 0x0,
 }
 
+#[cfg_attr(feature = "__bench", visibility::make(pub))]
 #[derive(Debug)]
 pub(crate) struct UpdateEncoderCodecs {
     remotefx: Option<(EntropyBits, u8)>,
 }
 
 impl UpdateEncoderCodecs {
+    #[cfg_attr(feature = "__bench", visibility::make(pub))]
     pub(crate) fn new() -> Self {
         Self { remotefx: None }
     }
 
+    #[cfg_attr(feature = "__bench", visibility::make(pub))]
     pub(crate) fn set_remotefx(&mut self, remotefx: Option<(EntropyBits, u8)>) {
         self.remotefx = remotefx
     }
@@ -47,6 +50,7 @@ impl Default for UpdateEncoderCodecs {
     }
 }
 
+#[cfg_attr(feature = "__bench", visibility::make(pub))]
 pub(crate) struct UpdateEncoder {
     desktop_size: DesktopSize,
     // FIXME: draw updates on the framebuffer
@@ -63,6 +67,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, codecs: UpdateEncoderCodecs) -> Self {
         let bitmap_updater = if surface_flags.contains(CmdFlags::SET_SURFACE_BITS) {
             let mut bitmap = BitmapUpdater::None(NoneHandler);
@@ -83,6 +88,7 @@ impl UpdateEncoder {
         }
     }
 
+    #[cfg_attr(feature = "__bench", visibility::make(pub))]
     pub(crate) fn update(&mut self, update: DisplayUpdate) -> EncoderIter<'_> {
         EncoderIter {
             encoder: self,
@@ -167,12 +173,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, UpdateEncoderCodecs};
     }
 }
 
@@ -58,3 +60,10 @@ macro_rules! time_warn {
         result
     }};
 }
+
+#[cfg(test)]
+mod tests {
+    use bytesize as _;
+    use pico_args as _;
+    use tracing_subscriber as _;
+}