Changes in / [63b3279:b5ec090]

Files:

• benchmark/Cargo.toml.in (modified) (1 diff)
• benchmark/Makefile.am (modified) (1 diff)
• benchmark/bench.rs (modified) (4 diffs)
• benchmark/readyQ/cycle.rs (modified) (1 diff)
• benchmark/readyQ/locality.rs (modified) (1 diff)
• benchmark/readyQ/transfer.rs (added)
• benchmark/readyQ/yield.rs (modified) (2 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (1 diff)

benchmark/Cargo.toml.in

@@ -12 +12 @@
 name = "rdq-locality-tokio"
 path = "@abs_srcdir@/readyQ/locality.rs"
+
+[[bin]]
+name = "rdq-transfer-tokio"
+path = "@abs_srcdir@/readyQ/transfer.rs"
 
 [[bin]]

benchmark/Makefile.am

@@ -600 +600 @@
         rdq-locality-go \
         rdq-locality-fibre \
-        rdq-transfer-cfa
+        rdq-transfer-cfa \
+        rdq-transfer-tokio
 
 rdq-benches:

benchmark/bench.rs

@@ -1 +1 @@
 use std::io::{self, Write};
+use std::option;
 use std::sync::atomic::{AtomicU64, AtomicBool, Ordering};
 use std::time::{Instant,Duration};
+use std::u128;
 
 use clap::{Arg, ArgMatches};
@@ -27 +29 @@
 
 impl BenchData {
-        pub fn new(options: ArgMatches, nthreads: usize) -> BenchData {
+        pub fn new(options: ArgMatches, nthreads: usize, default_it: option::Option<u64>) -> BenchData {
                 let (clock_mode, stop_count, duration) = if options.is_present("iterations") {
                         (false,
                         options.value_of("iterations").unwrap().parse::<u64>().unwrap(),
+                        -1.0)
+                } else if !default_it.is_none() {
+                        (false,
+                        default_it.unwrap(),
                         -1.0)
                 } else {
@@ -48 +54 @@
         }
 
+        #[allow(dead_code)]
         pub async fn wait(&self, start: &Instant) -> Duration{
                 loop {
@@ -69 +76 @@
 }
 
+// ==================================================
+pub fn _lehmer64( state: &mut u128 ) -> u64 {
+        *state = state.wrapping_mul(0xda942042e4dd58b5);
+        return (*state >> 64) as u64;
+}

benchmark/readyQ/cycle.rs

@@ -46 +46 @@
 
         let tthreads = nthreads * ring_size;
-        let exp = Arc::new(bench::BenchData::new(options, tthreads));
+        let exp = Arc::new(bench::BenchData::new(options, tthreads, None));
 
         let s = (1000000 as u64).to_formatted_string(&Locale::en);

benchmark/readyQ/locality.rs

@@ -285 +285 @@
         assert_eq!(&s, "1,000,000");
 
-        let exp = Arc::new(bench::BenchData::new(options, nprocs));
+        let exp = Arc::new(bench::BenchData::new(options, nprocs, None));
         let mut results = Result::new();
 

benchmark/readyQ/yield.rs

@@ -44 +44 @@
         let nprocs    = options.value_of("nprocs").unwrap().parse::<usize>().unwrap();
 
-        let exp = Arc::new(bench::BenchData::new(options, nthreads));
+        let exp = Arc::new(bench::BenchData::new(options, nthreads, None));
 
         let s = (1000000 as u64).to_formatted_string(&Locale::en);
@@ -50 +50 @@
 
         let thddata : Arc<Vec<Arc<Yielder>>> = Arc::new(
-                (0..nthreads).map(|i| {
-                        let pi = (i + nthreads) % nthreads;
+                (0..nthreads).map(|_i| {
                         Arc::new(Yielder{
                                 sem: sync::Semaphore::new(0),

libcfa/src/concurrency/kernel.cfa

@@ -231 +231 @@
                                 __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
 
-                                __disable_interrupts_hard();
-                                eventfd_t val;
-                                eventfd_read( this->idle, &val );
-                                __enable_interrupts_hard();
+                                {
+                                        eventfd_t val;
+                                        ssize_t ret = read( this->idle, &val, sizeof(val) );
+                                        if(ret < 0) {
+                                                switch((int)errno) {
+                                                case EAGAIN:
+                                                #if EAGAIN != EWOULDBLOCK
+                                                        case EWOULDBLOCK:
+                                                #endif
+                                                case EINTR:
+                                                        // No need to do anything special here, just assume it's a legitimate wake-up
+                                                        break;
+                                                default:
+                                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
+                                                }
+                                        }
+                                }
 
                                 #if !defined(__CFA_NO_STATISTICS__)