Changes in / [b5ec090:63b3279e]

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 (deleted)
• 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-tokio
+        rdq-transfer-cfa
 
 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};
@@ -29 +27 @@
 
 impl BenchData {
-        pub fn new(options: ArgMatches, nthreads: usize, default_it: option::Option<u64>) -> BenchData {
+        pub fn new(options: ArgMatches, nthreads: usize) -> 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 {
@@ -54 +48 @@
         }
 
-        #[allow(dead_code)]
         pub async fn wait(&self, start: &Instant) -> Duration{
                 loop {
@@ -76 +69 @@
 }
 
-// ==================================================
-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, None));
+        let exp = Arc::new(bench::BenchData::new(options, tthreads));
 
         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, None));
+        let exp = Arc::new(bench::BenchData::new(options, nprocs));
         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, None));
+        let exp = Arc::new(bench::BenchData::new(options, nthreads));
 
         let s = (1000000 as u64).to_formatted_string(&Locale::en);
@@ -50 +50 @@
 
         let thddata : Arc<Vec<Arc<Yielder>>> = Arc::new(
-                (0..nthreads).map(|_i| {
+                (0..nthreads).map(|i| {
+                        let pi = (i + nthreads) % nthreads;
                         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);
 
-                                {
-                                        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 ) );
-                                                }
-                                        }
-                                }
+                                __disable_interrupts_hard();
+                                eventfd_t val;
+                                eventfd_read( this->idle, &val );
+                                __enable_interrupts_hard();
 
                                 #if !defined(__CFA_NO_STATISTICS__)