enhance SubmissionQueue to support generate SQE in place

io-uring-bench/src/nop.rs

@@ -41,5 +41,66 @@ fn bench_normal(c: &mut Criterion) {
     });
 }
 
-criterion_group!(squeue, bench_normal);
+fn bench_prepare(c: &mut Criterion) {
+    let mut io_uring = IoUring::new(16).unwrap();
+
+    c.bench_function("prepare", |b| {
+        b.iter(|| {
+            let mut queue = TaskQueue(128);
+
+            while queue.want() {
+                {
+                    let mut sq = io_uring.submission();
+                    while queue.want() {
+                        unsafe {
+                            match sq.push_command(&black_box(opcode::Nop::new()), None) {
+                                Ok(_) => queue.pop(),
+                                Err(_) => break,
+                            }
+                        }
+                    }
+                }
+
+                io_uring.submit_and_wait(16).unwrap();
+
+                io_uring.completion().map(black_box).for_each(drop);
+            }
+        });
+    });
+}
+
+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

@@ -29,6 +29,10 @@ fn main() -> anyhow::Result<()> {
     tests::queue::test_nop(&mut ring, &test)?;
     tests::queue::test_queue_split(&mut ring, &test)?;
     tests::queue::test_debug_print(&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

@@ -1,4 +1,5 @@
 use crate::Test;
+use io_uring::squeue::SqeCommonOptions;
 use io_uring::{opcode, IoUring};
 
 pub fn test_nop(ring: &mut IoUring, test: &Test) -> anyhow::Result<()> {
@@ -26,6 +27,63 @@ pub fn test_nop(ring: &mut IoUring, test: &Test) -> anyhow::Result<()> {
     Ok(())
 }
 
+#[cfg(feature = "unstable")]
+pub fn test_nop_prepare(ring: &mut IoUring, test: &Test) -> anyhow::Result<()> {
+    require! {
+        test;
+    }
+
+    println!("test nop_prepare");
+
+    let nop = opcode::Nop::new();
+    let opt = SqeCommonOptions::default().user_data(0x42);
+
+    unsafe {
+        let mut queue = ring.submission();
+        queue.push_command(&nop, Some(&opt)).expect("queue is full");
+    }
+
+    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_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;