quickring 0.1.0

A very fast, lock-free SPSC ring buffer.
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use quickring::RingBuffer;
use ringbuf::traits::{Consumer, Producer};
use ringbuf::{StaticRb, traits::Split};
use std::thread;
use std::time::Instant;

const OPS: usize = 1_000_000_000;

fn main() {
    // bench_ringbuffer::<{ 1 << 1 }>();
    // bench_ringbuffer::<{ 1 << 2 }>();
    // bench_ringbuffer::<{ 1 << 3 }>();
    // bench_ringbuffer::<{ 1 << 4 }>();
    // bench_ringbuffer::<{ 1 << 5 }>();
    // bench_ringbuffer::<{ 1 << 6 }>();
    // bench_ringbuffer::<{ 1 << 7 }>();
    // bench_ringbuffer::<{ 1 << 8 }>();
    // bench_ringbuffer::<{ 1 << 9 }>();
    // bench_ringbuffer::<{ 1 << 10 }>();
    // bench_ringbuffer::<{ 1 << 11 }>();
    bench_ringbuffer::<{ 1 << 12 }>();
    bench_ringbuffer::<{ 1 << 13 }>();
    // bench_ringbuffer::<{ 1 << 14 }>();
    // bench_ringbuffer::<{ 1 << 15 }>();
    // bench_ringbuffer::<{ 1 << 16 }>();
    // bench_ringbuffer::<{ 1 << 17 }>();
    // bench_ringbuffer::<{ 1 << 18 }>();
    // bench_ringbuffer::<{ 1 << 19 }>();
    // bench_ringbuffer::<{ 1 << 20 }>();
    // bench_ringbuffer::<{ 1 << 21 }>();
    // bench_ringbuffer::<{ 1 << 22 }>();
    // bench_ringbuffer::<{ 1 << 23 }>();
    // bench_ringbuffer::<{ 1 << 24 }>();
    // bench_ringbuffer::<{ 1 << 25 }>();

    // bench_ringbuf::<{ 1 << 1 }>();
    // bench_ringbuf::<{ 1 << 2 }>();
    // bench_ringbuf::<{ 1 << 3 }>();
    // bench_ringbuf::<{ 1 << 4 }>();
    // bench_ringbuf::<{ 1 << 5 }>();
    // bench_ringbuf::<{ 1 << 6 }>();
    // bench_ringbuf::<{ 1 << 7 }>();
    // bench_ringbuf::<{ 1 << 8 }>();
    // bench_ringbuf::<{ 1 << 9 }>();
    // bench_ringbuf::<{ 1 << 10 }>();
    // bench_ringbuf::<{ 1 << 11 }>();
    // bench_ringbuf::<{ 1 << 12 }>();
    // bench_ringbuf::<{ 1 << 13 }>();
    // bench_ringbuf::<{ 1 << 14 }>();
    // bench_ringbuf::<{ 1 << 15 }>();
    // bench_ringbuf::<{ 1 << 16 }>();
    // bench_ringbuf::<{ 1 << 17 }>();
    // bench_ringbuf::<{ 1 << 18 }>();
    // bench_ringbuf::<{ 1 << 19 }>();
    // bench_ringbuf::<{ 1 << 20 }>();
    // bench_ringbuf::<{ 1 << 21 }>();
    // bench_ringbuf::<{ 1 << 22 }>();
    // bench_ringbuf::<{ 1 << 23 }>();
    // bench_ringbuf::<{ 1 << 24 }>();
    // bench_ringbuf::<{ 1 << 25 }>();
}

fn bench_ringbuffer<const CAP: usize>() {
    let rb: RingBuffer<usize, CAP> = RingBuffer::new();
    let (mut tx, mut rx) = rb.split();

    let start = Instant::now();
    let mut sum = 0_usize;

    let producer = thread::spawn(move || {
        for i in 0..OPS {
            while !tx.push(i) {}
        }
    });

    let consumer = thread::spawn(move || {
        let mut sum = 0usize;
        for _ in 0..OPS {
            loop {
                if let Some(x) = rx.pop() {
                    sum = sum.wrapping_add(x);
                    break;
                }
            }
        }
        sum
    });

    producer.join().unwrap();
    let sum = consumer.join().unwrap();

    let duration = start.elapsed();
    println!("Sum: {}", sum);
    println!("RingBuffer CAP = {}: {:?}", CAP, duration);
}

fn bench_ringbuf<const CAP: usize>() {
    let rb = StaticRb::<usize, CAP>::default();
    let (mut tx, mut rx) = rb.split();

    let start = Instant::now();

    let producer = thread::spawn(move || {
        for i in 0..OPS {
            while tx.try_push(i).is_err() {}
        }
    });

    let consumer = thread::spawn(move || {
        for _ in 0..OPS {
            while rx.try_pop().is_none() {}
        }
    });

    producer.join().unwrap();
    consumer.join().unwrap();

    let duration = start.elapsed();
    println!("StaticRb CAP = {}: {:?}", CAP, duration);
}