npnc 0.2.1

Lock-free queues.
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

// Copyright 2017 Kyle Mayes
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#![cfg_attr(feature="valgrind", feature(alloc_system))]

#[cfg(feature="valgrind")]
extern crate alloc_system;

#[macro_use]
extern crate queuecheck;
extern crate npnc;

use std::env;

#[cfg(feature="valgrind")]
const OPERATIONS: usize = 100_000;
#[cfg(not(feature="valgrind"))]
const OPERATIONS: usize = 1_000_000;

macro_rules! test {
    ([$($path:tt)*], $producers:expr, $consumers:expr) => ({
        queuecheck_test!(
            OPERATIONS,
            $producers,
            $consumers,
            |p: &npnc::$($path)*::Producer<String>, i: String| p.produce(i).unwrap(),
            |c: &npnc::$($path)*::Consumer<String>| c.consume().ok()
        );
    });
}

macro_rules! test_mpmc {
    ([$($path:tt)*]$(, $size:expr)*) => ({
        let (producer, consumer) = npnc::$($path)*::channel($($size)*);
        test!([$($path)*], vec![producer.clone(), producer], vec![consumer.clone(), consumer]);
    });
}

macro_rules! test_spsc {
    ([$($path:tt)*]$(, $size:expr)*) => ({
        let (producer, consumer) = npnc::$($path)*::channel($($size)*);
        test!([$($path)*], vec![producer], vec![consumer]);
    });
}

macro_rules! run {
    ($filter:expr, $name:expr, $test:expr) => ({
        if $filter.as_ref().map_or(true, |f| $name.contains(f)) {
            println!("test {} ...", $name);
            $test;
        }
    });
}

fn main() {
    let filter = env::args().nth(1);
    run!(filter, "bounded_spsc", test_spsc!([bounded::spsc], 2 << 24));
    run!(filter, "unbounded_spsc", test_spsc!([unbounded::spsc]));
    run!(filter, "bounded_mpmc", test_mpmc!([bounded::mpmc], 2 << 24));
    run!(filter, "unbounded_mpmc", test_mpmc!([unbounded::mpmc], 2));
}