Executor compiles

runtime/executor/benches/blocking.rs

@@ -0,0 +1,67 @@
+#![feature(test)]
+
+extern crate test;
+
+use bastion_executor::blocking;
+use lightproc::proc_stack::ProcStack;
+use std::thread;
+use std::time::Duration;
+use test::Bencher;
+
+#[cfg(feature = "tokio-runtime")]
+mod tokio_benchs {
+    use super::*;
+    #[bench]
+    fn blocking(b: &mut Bencher) {
+        tokio_test::block_on(async { _blocking(b) });
+    }
+    #[bench]
+    fn blocking_single(b: &mut Bencher) {
+        tokio_test::block_on(async {
+            _blocking_single(b);
+        });
+    }
+}
+
+#[cfg(not(feature = "tokio-runtime"))]
+mod no_tokio_benchs {
+    use super::*;
+    #[bench]
+    fn blocking(b: &mut Bencher) {
+        _blocking(b);
+    }
+    #[bench]
+    fn blocking_single(b: &mut Bencher) {
+        _blocking_single(b);
+    }
+}
+
+// Benchmark for a 10K burst task spawn
+fn _blocking(b: &mut Bencher) {
+    b.iter(|| {
+        (0..10_000)
+            .map(|_| {
+                blocking::spawn_blocking(
+                    async {
+                        let duration = Duration::from_millis(1);
+                        thread::sleep(duration);
+                    },
+                    ProcStack::default(),
+                )
+            })
+            .collect::<Vec<_>>()
+    });
+}
+
+// Benchmark for a single blocking task spawn
+fn _blocking_single(b: &mut Bencher) {
+    b.iter(|| {
+        blocking::spawn_blocking(
+            async {
+                let duration = Duration::from_millis(1);
+                thread::sleep(duration);
+            },
+            ProcStack::default(),
+        )
+    });
+}

runtime/executor/benches/perf.rs

@@ -0,0 +1,25 @@
+#![feature(test)]
+
+extern crate test;
+
+use bastion_executor::prelude::*;
+use lightproc::proc_stack::ProcStack;
+use test::{black_box, Bencher};
+
+#[bench]
+fn increment(b: &mut Bencher) {
+    let mut sum = 0;
+
+    b.iter(|| {
+        run(
+            async {
+                (0..10_000_000).for_each(|_| {
+                    sum += 1;
+                });
+            },
+            ProcStack::default(),
+        );
+    });
+
+    black_box(sum);
+}

runtime/executor/benches/run_blocking.rs

@@ -0,0 +1,69 @@
+#![feature(test)]
+
+extern crate test;
+
+use bastion_executor::blocking;
+use bastion_executor::run::run;
+use futures::future::join_all;
+use lightproc::proc_stack::ProcStack;
+use std::thread;
+use std::time::Duration;
+use test::Bencher;
+
+#[cfg(feature = "tokio-runtime")]
+mod tokio_benchs {
+    use super::*;
+    #[bench]
+    fn blocking(b: &mut Bencher) {
+        tokio_test::block_on(async { _blocking(b) });
+    }
+    #[bench]
+    fn blocking_single(b: &mut Bencher) {
+        tokio_test::block_on(async {
+            _blocking_single(b);
+        });
+    }
+}
+
+#[cfg(not(feature = "tokio-runtime"))]
+mod no_tokio_benchs {
+    use super::*;
+    #[bench]
+    fn blocking(b: &mut Bencher) {
+        _blocking(b);
+    }
+    #[bench]
+    fn blocking_single(b: &mut Bencher) {
+        _blocking_single(b);
+    }
+}
+
+// Benchmark for a 10K burst task spawn
+fn _blocking(b: &mut Bencher) {
+    b.iter(|| {
+        (0..10_000)
+            .map(|_| {
+                blocking::spawn_blocking(
+                    async {
+                        let duration = Duration::from_millis(1);
+                        thread::sleep(duration);
+                    },
+                    ProcStack::default(),
+                )
+            })
+            .collect::<Vec<_>>()
+    });
+}
+
+// Benchmark for a single blocking task spawn
+fn _blocking_single(b: &mut Bencher) {
+    b.iter(|| {
+        blocking::spawn_blocking(
+            async {
+                let duration = Duration::from_millis(1);
+                thread::sleep(duration);
+            },
+            ProcStack::default(),
+        )
+    });
+}

runtime/executor/benches/spawn.rs

@@ -0,0 +1,70 @@
+#![feature(test)]
+
+extern crate test;
+
+use bastion_executor::load_balancer;
+use bastion_executor::prelude::spawn;
+use futures_timer::Delay;
+use lightproc::proc_stack::ProcStack;
+use std::time::Duration;
+use test::Bencher;
+
+#[cfg(feature = "tokio-runtime")]
+mod tokio_benchs {
+    use super::*;
+    #[bench]
+    fn spawn_lot(b: &mut Bencher) {
+        tokio_test::block_on(async { _spawn_lot(b) });
+    }
+    #[bench]
+    fn spawn_single(b: &mut Bencher) {
+        tokio_test::block_on(async {
+            _spawn_single(b);
+        });
+    }
+}
+
+#[cfg(not(feature = "tokio-runtime"))]
+mod no_tokio_benchs {
+    use super::*;
+    #[bench]
+    fn spawn_lot(b: &mut Bencher) {
+        _spawn_lot(b);
+    }
+    #[bench]
+    fn spawn_single(b: &mut Bencher) {
+        _spawn_single(b);
+    }
+}
+
+// Benchmark for a 10K burst task spawn
+fn _spawn_lot(b: &mut Bencher) {
+    let proc_stack = ProcStack::default();
+    b.iter(|| {
+        let _ = (0..10_000)
+            .map(|_| {
+                spawn(
+                    async {
+                        let duration = Duration::from_millis(1);
+                        Delay::new(duration).await;
+                    },
+                    proc_stack.clone(),
+                )
+            })
+            .collect::<Vec<_>>();
+    });
+}
+
+// Benchmark for a single task spawn
+fn _spawn_single(b: &mut Bencher) {
+    let proc_stack = ProcStack::default();
+    b.iter(|| {
+        spawn(
+            async {
+                let duration = Duration::from_millis(1);
+                Delay::new(duration).await;
+            },
+            proc_stack.clone(),
+        );
+    });
+}

runtime/executor/benches/stats.rs

@@ -0,0 +1,71 @@
+#![feature(test)]
+
+extern crate test;
+use bastion_executor::load_balancer::{core_count, get_cores, stats, SmpStats};
+use bastion_executor::placement;
+use std::thread;
+use test::Bencher;
+
+fn stress_stats<S: SmpStats + Sync + Send>(stats: &'static S) {
+    let mut handles = Vec::with_capacity(*core_count());
+    for core in get_cores() {
+        let handle = thread::spawn(move || {
+            placement::set_for_current(*core);
+            for i in 0..100 {
+                stats.store_load(core.id, 10);
+                if i % 3 == 0 {
+                    let _sorted_load = stats.get_sorted_load();
+                }
+            }
+        });
+        handles.push(handle);
+    }
+
+    for handle in handles {
+        handle.join().unwrap();
+    }
+}
+
+// previous lock based stats benchmark 1,352,791 ns/iter (+/- 2,682,013)
+
+// 158,278 ns/iter (+/- 117,103)
+#[bench]
+fn lockless_stats_bench(b: &mut Bencher) {
+    b.iter(|| {
+        stress_stats(stats());
+    });
+}
+
+#[bench]
+fn lockless_stats_bad_load(b: &mut Bencher) {
+    let stats = stats();
+    const MAX_CORE: usize = 256;
+    for i in 0..MAX_CORE {
+        // Generating the worst possible mergesort scenario
+        // [0,2,4,6,8,10,1,3,5,7,9]...
+        if i <= MAX_CORE / 2 {
+            stats.store_load(i, i * 2);
+        } else {
+            stats.store_load(i, i - 1 - MAX_CORE / 2);
+        }
+    }
+
+    b.iter(|| {
+        let _sorted_load = stats.get_sorted_load();
+    });
+}
+
+#[bench]
+fn lockless_stats_good_load(b: &mut Bencher) {
+    let stats = stats();
+    const MAX_CORE: usize = 256;
+    for i in 0..MAX_CORE {
+        // Generating the best possible mergesort scenario
+        // [0,1,2,3,4,5,6,7,8,9]...
+        stats.store_load(i, i);
+    }
+
+    b.iter(|| {
+        let _sorted_load = stats.get_sorted_load();
+    });
+}