vendor/crossbeam-utils-0.7.2/benches/atomic_cell.rs

   1 #![feature(test)]
   2
   3 extern crate crossbeam_utils;
   4 extern crate test;
   5
   6 use std::sync::Barrier;
   7
   8 use crossbeam_utils::atomic::AtomicCell;
   9 use crossbeam_utils::thread;
  10
  11 #[bench]
  12 fn load_u8(b: &mut test::Bencher) {
  13     let a = AtomicCell::new(0u8);
  14     let mut sum = 0;
  15     b.iter(|| sum += a.load());
  16     test::black_box(sum);
  17 }
  18
  19 #[bench]
  20 fn store_u8(b: &mut test::Bencher) {
  21     let a = AtomicCell::new(0u8);
  22     b.iter(|| a.store(1));
  23 }
  24
  25 #[bench]
  26 fn fetch_add_u8(b: &mut test::Bencher) {
  27     let a = AtomicCell::new(0u8);
  28     b.iter(|| a.fetch_add(1));
  29 }
  30
  31 #[bench]
  32 fn compare_and_swap_u8(b: &mut test::Bencher) {
  33     let a = AtomicCell::new(0u8);
  34     let mut i = 0;
  35     b.iter(|| {
  36         a.compare_and_swap(i, i.wrapping_add(1));
  37         i = i.wrapping_add(1);
  38     });
  39 }
  40
  41 #[bench]
  42 fn concurrent_load_u8(b: &mut test::Bencher) {
  43     const THREADS: usize = 2;
  44     const STEPS: usize = 1_000_000;
  45
  46     let start = Barrier::new(THREADS + 1);
  47     let end = Barrier::new(THREADS + 1);
  48     let exit = AtomicCell::new(false);
  49
  50     let a = AtomicCell::new(0u8);
  51
  52     thread::scope(|scope| {
  53         for _ in 0..THREADS {
  54             scope.spawn(|_| loop {
  55                 start.wait();
  56
  57                 let mut sum = 0;
  58                 for _ in 0..STEPS {
  59                     sum += a.load();
  60                 }
  61                 test::black_box(sum);
  62
  63                 end.wait();
  64                 if exit.load() {
  65                     break;
  66                 }
  67             });
  68         }
  69
  70         start.wait();
  71         end.wait();
  72
  73         b.iter(|| {
  74             start.wait();
  75             end.wait();
  76         });
  77
  78         start.wait();
  79         exit.store(true);
  80         end.wait();
  81     })
  82     .unwrap();
  83 }
  84
  85 #[bench]
  86 fn load_usize(b: &mut test::Bencher) {
  87     let a = AtomicCell::new(0usize);
  88     let mut sum = 0;
  89     b.iter(|| sum += a.load());
  90     test::black_box(sum);
  91 }
  92
  93 #[bench]
  94 fn store_usize(b: &mut test::Bencher) {
  95     let a = AtomicCell::new(0usize);
  96     b.iter(|| a.store(1));
  97 }
  98
  99 #[bench]
 100 fn fetch_add_usize(b: &mut test::Bencher) {
 101     let a = AtomicCell::new(0usize);
 102     b.iter(|| a.fetch_add(1));
 103 }
 104
 105 #[bench]
 106 fn compare_and_swap_usize(b: &mut test::Bencher) {
 107     let a = AtomicCell::new(0usize);
 108     let mut i = 0;
 109     b.iter(|| {
 110         a.compare_and_swap(i, i.wrapping_add(1));
 111         i = i.wrapping_add(1);
 112     });
 113 }
 114
 115 #[bench]
 116 fn concurrent_load_usize(b: &mut test::Bencher) {
 117     const THREADS: usize = 2;
 118     const STEPS: usize = 1_000_000;
 119
 120     let start = Barrier::new(THREADS + 1);
 121     let end = Barrier::new(THREADS + 1);
 122     let exit = AtomicCell::new(false);
 123
 124     let a = AtomicCell::new(0usize);
 125
 126     thread::scope(|scope| {
 127         for _ in 0..THREADS {
 128             scope.spawn(|_| loop {
 129                 start.wait();
 130
 131                 let mut sum = 0;
 132                 for _ in 0..STEPS {
 133                     sum += a.load();
 134                 }
 135                 test::black_box(sum);
 136
 137                 end.wait();
 138                 if exit.load() {
 139                     break;
 140                 }
 141             });
 142         }
 143
 144         start.wait();
 145         end.wait();
 146
 147         b.iter(|| {
 148             start.wait();
 149             end.wait();
 150         });
 151
 152         start.wait();
 153         exit.store(true);
 154         end.wait();
 155     })
 156     .unwrap();
 157 }