wireshift-uring 0.1.1

Native Linux io_uring backend for wireshift
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#![allow(missing_docs)]

use std::sync::{Arc, Barrier};
use std::thread;
use std::time::Duration;
use wireshift_core::backend::{Backend, BackendSubmission};
use wireshift_core::config::RingConfig;
use wireshift_core::op::OpDescriptor;
use wireshift_uring::UringBackend;

#[test]
fn test_concurrent_100_threads() {
    let config = RingConfig::default().with_queue_depth(256);
    let (tx, rx) = std::sync::mpsc::channel();
    let backend = Arc::new(UringBackend::new(&config, tx).unwrap());

    let thread_count = 100;
    let ops_per_thread = 50;
    let barrier = Arc::new(Barrier::new(thread_count));

    let mut handles = vec![];

    for t_id in 0..thread_count {
        let backend_clone = Arc::clone(&backend);
        let barrier_clone = Arc::clone(&barrier);

        handles.push(thread::spawn(move || {
            barrier_clone.wait();
            for i in 0..ops_per_thread {
                let id = (t_id as u64 * 1000) + i as u64;
                let submission = BackendSubmission { timeout: None, 
                    id,
                    descriptor: OpDescriptor::Nop,
                };
                // It's acceptable to drop requests if queue is full, we are testing for panics/deadlocks
                let _ = backend_clone.submit(submission);
            }
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    // Test passes if we successfully spawn threads, submit ops, and join without crashing.
}