Changes in / [347925c:a3769cc]

Files:

• benchmark/Cargo.toml.in (modified) (1 diff)
• benchmark/Makefile.am (modified) (3 diffs)
• benchmark/bench.rs (modified) (4 diffs)
• benchmark/readyQ/cycle.cpp (modified) (3 diffs)
• benchmark/readyQ/cycle.rs (modified) (1 diff)
• benchmark/readyQ/locality.rs (modified) (2 diffs)
• benchmark/readyQ/transfer.cfa (modified) (2 diffs)
• benchmark/readyQ/transfer.rs (added)
• benchmark/readyQ/yield.rs (modified) (2 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (3 diffs)
• libcfa/src/device/cpu.cfa (modified) (1 diff)
• libcfa/src/device/cpu.hfa (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:
@@ -606 +607 @@
 
 clean-rdq-benches:
-        rm -rf $(RDQBENCHES)
-
-rdq-%-tokio$(EXEEXT): $(srcdir)/readyQ/%.rs $(srcdir)/bench.rs
-        cd $(builddir) && cargo build --release
-        cp $(builddir)/target/release/$(basename $@) $@
+        rm -rf $(RDQBENCHES) $(builddir)/target go.mod
+
+rdq-%-tokio$(EXEEXT): $(builddir)/target/release/rdq-%-tokio$(EXEEXT)
+        $(BENCH_V_RUSTC)cp $(builddir)/target/release/$(basename $@) $@
+
+$(builddir)/target/release/rdq-%-tokio$(EXEEXT): $(srcdir)/readyQ/%.rs $(srcdir)/bench.rs
+        $(BENCH_V_RUSTC)cd $(builddir) && cargo build --release
 
 rdq-%-cfa$(EXEEXT): $(srcdir)/readyQ/%.cfa $(srcdir)/readyQ/rq_bench.hfa
@@ -617 +620 @@
 go.mod:
         touch $@
-        go mod edit -module=rdqbench
+        go mod edit -module=rdq.bench
         go get golang.org/x/sync/semaphore
         go get golang.org/x/text/language

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.cpp

@@ -41 +41 @@
                         Fibre * threads[tthreads];
                         Partner thddata[tthreads];
-                        for(int i = 0; i < tthreads; i++) {
+                        for(unsigned i = 0; i < tthreads; i++) {
                                 unsigned pi = (i + nthreads) % tthreads;
                                 thddata[i].next = &thddata[pi].self;
                         }
-                        for(int i = 0; i < tthreads; i++) {
+                        for(unsigned i = 0; i < tthreads; i++) {
                                 threads[i] = new Fibre( reinterpret_cast<void (*)(void *)>(partner_main), &thddata[i] );
                         }
@@ -53 +53 @@
                         start = timeHiRes();
 
-                        for(int i = 0; i < nthreads; i++) {
+                        for(unsigned i = 0; i < nthreads; i++) {
                                 thddata[i].self.post();
                         }
@@ -62 +62 @@
                         printf("\nDone\n");
 
-                        for(int i = 0; i < tthreads; i++) {
+                        for(unsigned i = 0; i < tthreads; i++) {
                                 thddata[i].self.post();
                                 fibre_join( threads[i], nullptr );

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

@@ -124 +124 @@
                                                 return (r as *mut MyData, true);
                                         }
-                                        let got = self.ptr.compare_and_swap(expected, ctx as *mut MyCtx as u64, Ordering::SeqCst);
-                                        if got == expected {
+                                        let got = self.ptr.compare_exchange_weak(expected, ctx as *mut MyCtx as u64, Ordering::SeqCst, Ordering::SeqCst);
+                                        if got == Ok(expected) {
                                                 break expected;// We got the seat
                                         }
@@ -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/transfer.cfa

@@ -39 +39 @@
                         Pause();
                         if( (timeHiRes() - start) > 5`s ) {
+                                print_stats_now( bench_cluster, CFA_STATS_READY_Q | CFA_STATS_IO );
                                 serr | "Programs has been blocked for more than 5 secs";
                                 exit(1);
@@ -110 +111 @@
         cfa_option opt[] = {
                 BENCH_OPT,
-                { 'e', "exhaust", "Whether or not threads that have seen the new epoch should yield or park.", exhaust, parse_yesno}
+                { 'e', "exhaust", "Whether or not threads that have seen the new epoch should park instead of yielding.", exhaust, parse_yesno}
         };
         BENCH_OPT_PARSE("cforall transition benchmark");

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

@@ -22 +22 @@
 #include <errno.h>
 #include <stdio.h>
+#include <string.h>
 #include <signal.h>
 #include <unistd.h>
@@ -31 +32 @@
 #include "kernel_private.hfa"
 #include "preemption.hfa"
+#include "strstream.hfa"
+#include "device/cpu.hfa"
 
 //Private includes
@@ -231 +234 @@
                                 __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__)

libcfa/src/device/cpu.cfa

@@ -422 +422 @@
         }
 }
+
+cpu_info_t cpu_info;

libcfa/src/device/cpu.hfa

@@ -30 +30 @@
 };
 
-cpu_info_t cpu_info;
+extern cpu_info_t cpu_info;