Add benchmark for preparing SQE in place

Add benchmark for preparing SQE in place.

Signed-off-by: Liu Jiang <[email protected]>

Author: jiangliu

io-uring-bench/src/nop.rs

@@ -68,5 +68,39 @@ fn bench_prepare(c: &mut Criterion) {
         });
     });
 }
-criterion_group!(squeue, bench_normal, bench_prepare);
+
+fn bench_prepare_sqe(c: &mut Criterion) {
+    let mut io_uring = IoUring::new(16).unwrap();
+
+    c.bench_function("prepare_sqe", |b| {
+        b.iter(|| {
+            let mut queue = TaskQueue(128);
+
+            while queue.want() {
+                {
+                    let mut sq = io_uring.submission();
+                    while queue.want() {
+                        unsafe {
+                            match sq.get_available_sqe(0) {
+                                Ok(sqe) => {
+                                    let nop_sqe: &mut opcode::NopSqe = black_box(sqe.into());
+                                    nop_sqe.prepare();
+                                    sq.move_forward(1);
+                                    queue.pop();
+                                }
+                                Err(_) => break,
+                            };
+                        }
+                    }
+                }
+
+                io_uring.submit_and_wait(16).unwrap();
+
+                io_uring.completion().map(black_box).for_each(drop);
+            }
+        });
+    });
+}
+
+criterion_group!(squeue, bench_normal, bench_prepare, bench_prepare_sqe);
 criterion_main!(squeue);

io-uring-test/src/main.rs

@@ -30,6 +30,8 @@ fn main() -> anyhow::Result<()> {
     tests::queue::test_queue_split(&mut ring, &test)?;
     #[cfg(feature = "unstable")]
     tests::queue::test_nop_prepare(&mut ring, &test)?;
+    #[cfg(feature = "unstable")]
+    tests::queue::test_nop_prepare_sqe(&mut ring, &test)?;
 
     #[cfg(feature = "unstable")]
     tests::queue::test_batch(&mut ring, &test)?;

io-uring-test/src/tests/queue.rs

@@ -54,6 +54,36 @@ pub fn test_nop_prepare(ring: &mut IoUring, test: &Test) -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "unstable")]
+pub fn test_nop_prepare_sqe(ring: &mut IoUring, test: &Test) -> anyhow::Result<()> {
+    require! {
+        test;
+    }
+
+    println!("test nop_prepare_sqe");
+
+    let opt = SqeCommonOptions::default().user_data(0x42);
+
+    unsafe {
+        let mut queue = ring.submission();
+        let sqe = queue.get_available_sqe(0).unwrap();
+        let nop_sqe: &mut opcode::NopSqe = sqe.into();
+        nop_sqe.prepare();
+        opt.set(nop_sqe.get_mut_sqe());
+        queue.move_forward(1);
+    }
+
+    ring.submit_and_wait(1)?;
+
+    let cqes = ring.completion().collect::<Vec<_>>();
+
+    assert_eq!(cqes.len(), 1);
+    assert_eq!(cqes[0].user_data(), 0x42);
+    assert_eq!(cqes[0].result(), 0);
+
+    Ok(())
+}
+
 #[cfg(feature = "unstable")]
 pub fn test_batch(ring: &mut IoUring, test: &Test) -> anyhow::Result<()> {
     use std::mem::MaybeUninit;