Added Benchmark that tests serialization and deserialization of some enums.

Previous benchmarks were concerned about empty sending and empty
receiving or sending bytes directly. This will now test the
serialization.

Signed-off-by: Narfinger <[email protected]>

more enum stuff

Author: Narfinger

Cargo.toml

@@ -23,6 +23,10 @@ harness = false
 name = "ipc_shared_mem"
 harness = false
 
+[[bench]]
+name = "struct_ipc"
+harness = false
+
 [features]
 default = []
 force-inprocess = []
@@ -52,6 +56,7 @@ crossbeam-utils = "0.8"
 futures-test = "0.3"
 static_assertions = "1.1.0"
 criterion = { version = "0.5", features = ["html_reports"] }
+rand = "0.9.2"
 
 [target.'cfg(target_os = "windows")'.dependencies.windows]
 version = "0.61"

benches/ipc.rs

@@ -70,4 +70,5 @@ criterion_group!(
     transfer_receivers<8>,
     transfer_receivers<64>,
 );
+
 criterion_main!(benches);

benches/struct_ipc.rs

@@ -0,0 +1,191 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use ipc_channel::ipc;
+use rand::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Serialize, Deserialize)]
+enum TestSmall {
+    Msg0,
+    Msg1,
+    Msg2(u32, u32),
+    Msg3(u32, u32, u32),
+    Msg4(String),
+    Msg5,
+    Msg6,
+}
+
+trait NewFromRandom {
+    fn new(rng: &mut ThreadRng) -> Self;
+}
+
+impl NewFromRandom for TestSmall {
+    fn new(rng: &mut ThreadRng) -> Self {
+        match rng.random_range(0..=6) {
+            0 => Self::Msg0,
+            1 => Self::Msg1,
+            2 => Self::Msg2(23, 42),
+            3 => Self::Msg3(23, 42, 243),
+            4 => Self::Msg4(String::from("This is a test string of medium size")),
+            5 => Self::Msg5,
+            6 => Self::Msg6,
+            _ => Self::Msg6,
+        }
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+enum TestMedium {
+    Msg0(u32),
+    Msg1(u32),
+    Msg2(u32),
+    Msg3(u32),
+    Msg4(u32),
+    Msg5(u32),
+    Msg6(u32),
+    Msg7(u32),
+    Msg8(u32),
+    Msg9(u32),
+    Msg10(u32),
+    Msg11(u32),
+    Msg12(u32),
+    Msg13(u32),
+    Msg14(u32),
+    Msg15(u32),
+    Msg16(u32),
+    Msg17(u32),
+    Msg18(u32),
+    Msg19(u32),
+    Msg20(u32),
+    Msg21(u32),
+    Msg22(u32),
+    Msg23(u32),
+    Msg24(u32),
+    Msg25(u32),
+    Msg26(u32),
+}
+
+impl NewFromRandom for TestMedium {
+    fn new(rng: &mut ThreadRng) -> Self {
+        match rng.random_range(0..=26) {
+            0 => Self::Msg0(42),
+            1 => Self::Msg1(42),
+            2 => Self::Msg2(42),
+            3 => Self::Msg3(42),
+            4 => Self::Msg4(42),
+            5 => Self::Msg5(42),
+            6 => Self::Msg6(42),
+            7 => Self::Msg7(42),
+            8 => Self::Msg8(42),
+            9 => Self::Msg9(42),
+            10 => Self::Msg10(42),
+            11 => Self::Msg11(42),
+            12 => Self::Msg12(42),
+            13 => Self::Msg13(42),
+            14 => Self::Msg14(42),
+            15 => Self::Msg15(42),
+            16 => Self::Msg16(42),
+            17 => Self::Msg17(42),
+            18 => Self::Msg18(42),
+            19 => Self::Msg19(42),
+            20 => Self::Msg20(42),
+            21 => Self::Msg21(42),
+            22 => Self::Msg22(42),
+            23 => Self::Msg23(42),
+            24 => Self::Msg24(42),
+            25 => Self::Msg25(42),
+            26 => Self::Msg26(42),
+            _ => Self::Msg6(42),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+enum TestFractured {
+    Msg0,
+    Msg1(Vec<usize>),
+    Msg2(
+        usize,
+        usize,
+        usize,
+        usize,
+        usize,
+        usize,
+        usize,
+        usize,
+        usize,
+        usize,
+    ),
+    Msg3(usize),
+    Msg4(usize, usize, usize),
+}
+
+impl NewFromRandom for TestFractured {
+    fn new(rng: &mut ThreadRng) -> Self {
+        match rng.random_range(0..=4) {
+            0 => Self::Msg0,
+            1 => Self::Msg1(vec![1, 2, 3]),
+            2 => Self::Msg2(1, 2, 3, 4, 5, 6, 7, 8, 9, 10),
+            3 => Self::Msg3(1),
+            4 => Self::Msg4(1, 2, 3),
+            _ => Self::Msg3(1),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+enum TestNested {
+    Msg0,
+    Msg1(TestSmall),
+    Msg2(TestMedium),
+    Msg3(TestFractured),
+    Msg4(usize),
+}
+
+impl NewFromRandom for TestNested {
+    fn new(rng: &mut ThreadRng) -> Self {
+        match rng.random_range(0..=5) {
+            0 => Self::Msg0,
+            1 => Self::Msg1(TestSmall::Msg6),
+            2 => Self::Msg2(TestMedium::Msg20(2)),
+            3 => Self::Msg3(TestFractured::Msg3(0)),
+            4 => Self::Msg4(2),
+            _ => Self::Msg3(TestFractured::Msg0),
+        }
+    }
+}
+
+fn transfer_enum<T>(criterion: &mut Criterion)
+where
+    T: NewFromRandom,
+    T: for<'de> Deserialize<'de>,
+    T: Serialize,
+{
+    criterion.bench_function("transfer_simple_struct", |bencher| {
+        let (tx, rx) = ipc::channel().unwrap();
+        let mut rng = rand::rng();
+
+        bencher.iter_batched(
+            || T::new(&mut rng),
+            |s| {
+                tx.send(s).unwrap();
+                rx.recv().unwrap();
+            },
+            criterion::BatchSize::SmallInput,
+        );
+    });
+}
+
+// TestSmall is a small enum
+// TestMedium is a medium size enum
+// TestFractured is an enum with varying sizes of inners
+// TestNested nests the enums
+
+criterion_group!(
+    benches,
+    transfer_enum<TestSmall>,
+    transfer_enum<TestMedium>,
+    transfer_enum<TestFractured>,
+    transfer_enum<TestNested>,
+);
+
+criterion_main!(benches);