feat(server): benchmark the remotefx tile encoder

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

Author: elmarco

Cargo.lock

@@ -17,6 +17,7 @@ test = false
 
 [features]
 helper = ["dep:x509-cert", "dep:rustls-pemfile"]
+bench = []
 
 [dependencies]
 anyhow = "1.0"
@@ -41,6 +42,13 @@ rustls-pemfile = { version = "2.2.0", optional = true }
 
 [dev-dependencies]
 tokio = { version = "1", features = ["sync"] }
+criterion = "0.5"
+
+[[bench]]
+name = "bench"
+path = "benches/bench.rs"
+required-features = ["bench"]
+harness = false
 
 [lints]
 workspace = true

crates/ironrdp-server/Cargo.toml

@@ -0,0 +1,30 @@
+use std::num::NonZero;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use ironrdp_pdu::codecs::rfx::{EntropyAlgorithm, Quant};
+use ironrdp_server::{bench::encoder::*, BitmapUpdate};
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let quant = Quant::default();
+    let algo = EntropyAlgorithm::Rlgr3;
+    let bitmap = BitmapUpdate {
+        top: 0,
+        left: 0,
+        width: NonZero::new(64).unwrap(),
+        height: NonZero::new(64).unwrap(),
+        format: ironrdp_server::PixelFormat::ARgb32,
+        data: vec![0; 64 * 64 * 4],
+        order: ironrdp_server::PixelOrder::BottomToTop,
+        stride: 64 * 4,
+    };
+    let enc = rfx::UpdateEncoder::new(&bitmap, quant, algo);
+    let mut buf = vec![0; 64 * 64 * 3];
+    c.bench_function("rfxenc", |b| {
+        b.iter(|| {
+            let _ = enc.encode(0, 0, &mut buf);
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

crates/ironrdp-server/benches/bench.rs

@@ -1,5 +1,7 @@
-pub(crate) mod bitmap;
-pub(crate) mod rfx;
+#![allow(unreachable_pub)]
+
+pub mod bitmap;
+pub mod rfx;
 
 use std::{cmp, mem};
 

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

@@ -1,3 +1,5 @@
+#![allow(unreachable_pub)]
+
 use ironrdp_core::{cast_length, other_err, EncodeResult};
 use ironrdp_graphics::color_conversion::to_64x64_ycbcr_tile;
 use ironrdp_graphics::rfx_encode_component;
@@ -130,28 +132,28 @@ impl RfxEncoder {
     }
 }
 
-struct UpdateEncoder<'a> {
+pub struct UpdateEncoder<'a> {
     bitmap: &'a BitmapUpdate,
     quant: rfx::Quant,
     entropy_algorithm: rfx::EntropyAlgorithm,
 }
 
-struct EncodedTile<'a> {
+pub struct EncodedTile<'a> {
     y_data: &'a [u8],
     cb_data: &'a [u8],
     cr_data: &'a [u8],
 }
 
 impl<'a> UpdateEncoder<'a> {
-    fn new(bitmap: &'a BitmapUpdate, quant: rfx::Quant, entropy_algorithm: rfx::EntropyAlgorithm) -> Self {
+    pub fn new(bitmap: &'a BitmapUpdate, quant: rfx::Quant, entropy_algorithm: rfx::EntropyAlgorithm) -> Self {
         Self {
             bitmap,
             quant,
             entropy_algorithm,
         }
     }
 
-    fn encode<'b>(&self, tile_x: usize, tile_y: usize, buf: &'b mut [u8]) -> Result<EncodedTile<'b>, RlgrError> {
+    pub fn encode<'b>(&self, tile_x: usize, tile_y: usize, buf: &'b mut [u8]) -> Result<EncodedTile<'b>, RlgrError> {
         assert!(buf.len() >= 4096 * 3);
 
         let bpp: usize = self.bitmap.format.bytes_per_pixel().into();