1 #![feature(test)]
2 
3 extern crate crossbeam_epoch as epoch;
4 extern crate crossbeam_utils as utils;
5 extern crate test;
6 
7 use epoch::Owned;
8 use test::Bencher;
9 use utils::thread::scope;
10 
11 #[bench]
single_alloc_defer_free(b: &mut Bencher)12 fn single_alloc_defer_free(b: &mut Bencher) {
13     b.iter(|| {
14         let guard = &epoch::pin();
15         let p = Owned::new(1).into_shared(guard);
16         unsafe {
17             guard.defer_destroy(p);
18         }
19     });
20 }
21 
22 #[bench]
single_defer(b: &mut Bencher)23 fn single_defer(b: &mut Bencher) {
24     b.iter(|| {
25         let guard = &epoch::pin();
26         guard.defer(move || ());
27     });
28 }
29 
30 #[bench]
multi_alloc_defer_free(b: &mut Bencher)31 fn multi_alloc_defer_free(b: &mut Bencher) {
32     const THREADS: usize = 16;
33     const STEPS: usize = 10_000;
34 
35     b.iter(|| {
36         scope(|s| {
37             for _ in 0..THREADS {
38                 s.spawn(|_| {
39                     for _ in 0..STEPS {
40                         let guard = &epoch::pin();
41                         let p = Owned::new(1).into_shared(guard);
42                         unsafe {
43                             guard.defer_destroy(p);
44                         }
45                     }
46                 });
47             }
48         })
49         .unwrap();
50     });
51 }
52 
53 #[bench]
multi_defer(b: &mut Bencher)54 fn multi_defer(b: &mut Bencher) {
55     const THREADS: usize = 16;
56     const STEPS: usize = 10_000;
57 
58     b.iter(|| {
59         scope(|s| {
60             for _ in 0..THREADS {
61                 s.spawn(|_| {
62                     for _ in 0..STEPS {
63                         let guard = &epoch::pin();
64                         guard.defer(move || ());
65                     }
66                 });
67             }
68         })
69         .unwrap();
70     });
71 }
72