Changes in / [a3769cc:347925c]


Ignore:
Files:
1 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • benchmark/Cargo.toml.in

    ra3769cc r347925c  
    1212name = "rdq-locality-tokio"
    1313path = "@abs_srcdir@/readyQ/locality.rs"
    14 
    15 [[bin]]
    16 name = "rdq-transfer-tokio"
    17 path = "@abs_srcdir@/readyQ/transfer.rs"
    1814
    1915[[bin]]

  • benchmark/Makefile.am

    ra3769cc r347925c  
    600600        rdq-locality-go \
    601601        rdq-locality-fibre \
    602         rdq-transfer-cfa \
    603         rdq-transfer-tokio
     602        rdq-transfer-cfa
    604603
    605604rdq-benches:
    … …  
    607606
    608607clean-rdq-benches:
    609         rm -rf $(RDQBENCHES) $(builddir)/target go.mod
    610 
    611 rdq-%-tokio$(EXEEXT): $(builddir)/target/release/rdq-%-tokio$(EXEEXT)
    612         $(BENCH_V_RUSTC)cp $(builddir)/target/release/$(basename $@) $@
    613 
    614 $(builddir)/target/release/rdq-%-tokio$(EXEEXT): $(srcdir)/readyQ/%.rs $(srcdir)/bench.rs
    615         $(BENCH_V_RUSTC)cd $(builddir) && cargo build --release
     608        rm -rf $(RDQBENCHES)
     609
     610rdq-%-tokio$(EXEEXT): $(srcdir)/readyQ/%.rs $(srcdir)/bench.rs
     611        cd $(builddir) && cargo build --release
     612        cp $(builddir)/target/release/$(basename $@) $@
    616613
    617614rdq-%-cfa$(EXEEXT): $(srcdir)/readyQ/%.cfa $(srcdir)/readyQ/rq_bench.hfa
    … …  
    620617go.mod:
    621618        touch $@
    622         go mod edit -module=rdq.bench
     619        go mod edit -module=rdqbench
    623620        go get golang.org/x/sync/semaphore
    624621        go get golang.org/x/text/language

  • benchmark/bench.rs

    ra3769cc r347925c  
    11use std::io::{self, Write};
    2 use std::option;
    32use std::sync::atomic::{AtomicU64, AtomicBool, Ordering};
    43use std::time::{Instant,Duration};
    5 use std::u128;
    64
    75use clap::{Arg, ArgMatches};
    … …  
    2927
    3028impl BenchData {
    31         pub fn new(options: ArgMatches, nthreads: usize, default_it: option::Option<u64>) -> BenchData {
     29        pub fn new(options: ArgMatches, nthreads: usize) -> BenchData {
    3230                let (clock_mode, stop_count, duration) = if options.is_present("iterations") {
    3331                        (false,
    3432                        options.value_of("iterations").unwrap().parse::<u64>().unwrap(),
    35                         -1.0)
    36                 } else if !default_it.is_none() {
    37                         (false,
    38                         default_it.unwrap(),
    3933                        -1.0)
    4034                } else {
    … …  
    5448        }
    5549
    56         #[allow(dead_code)]
    5750        pub async fn wait(&self, start: &Instant) -> Duration{
    5851                loop {
    … …  
    7669}
    7770
    78 // ==================================================
    79 pub fn _lehmer64( state: &mut u128 ) -> u64 {
    80         *state = state.wrapping_mul(0xda942042e4dd58b5);
    81         return (*state >> 64) as u64;
    82 }

  • benchmark/readyQ/cycle.cpp

    ra3769cc r347925c  
    4141                        Fibre * threads[tthreads];
    4242                        Partner thddata[tthreads];
    43                         for(unsigned i = 0; i < tthreads; i++) {
     43                        for(int i = 0; i < tthreads; i++) {
    4444                                unsigned pi = (i + nthreads) % tthreads;
    4545                                thddata[i].next = &thddata[pi].self;
    4646                        }
    47                         for(unsigned i = 0; i < tthreads; i++) {
     47                        for(int i = 0; i < tthreads; i++) {
    4848                                threads[i] = new Fibre( reinterpret_cast<void (*)(void *)>(partner_main), &thddata[i] );
    4949                        }
    … …  
    5353                        start = timeHiRes();
    5454
    55                         for(unsigned i = 0; i < nthreads; i++) {
     55                        for(int i = 0; i < nthreads; i++) {
    5656                                thddata[i].self.post();
    5757                        }
    … …  
    6262                        printf("\nDone\n");
    6363
    64                         for(unsigned i = 0; i < tthreads; i++) {
     64                        for(int i = 0; i < tthreads; i++) {
    6565                                thddata[i].self.post();
    6666                                fibre_join( threads[i], nullptr );

  • benchmark/readyQ/cycle.rs

    ra3769cc r347925c  
    4646
    4747        let tthreads = nthreads * ring_size;
    48         let exp = Arc::new(bench::BenchData::new(options, tthreads, None));
     48        let exp = Arc::new(bench::BenchData::new(options, tthreads));
    4949
    5050        let s = (1000000 as u64).to_formatted_string(&Locale::en);

  • benchmark/readyQ/locality.rs

    ra3769cc r347925c  
    124124                                                return (r as *mut MyData, true);
    125125                                        }
    126                                         let got = self.ptr.compare_exchange_weak(expected, ctx as *mut MyCtx as u64, Ordering::SeqCst, Ordering::SeqCst);
    127                                         if got == Ok(expected) {
     126                                        let got = self.ptr.compare_and_swap(expected, ctx as *mut MyCtx as u64, Ordering::SeqCst);
     127                                        if got == expected {
    128128                                                break expected;// We got the seat
    129129                                        }
    … …  
    285285        assert_eq!(&s, "1,000,000");
    286286
    287         let exp = Arc::new(bench::BenchData::new(options, nprocs, None));
     287        let exp = Arc::new(bench::BenchData::new(options, nprocs));
    288288        let mut results = Result::new();
    289289

  • benchmark/readyQ/transfer.cfa

    ra3769cc r347925c  
    3939                        Pause();
    4040                        if( (timeHiRes() - start) > 5`s ) {
    41                                 print_stats_now( bench_cluster, CFA_STATS_READY_Q | CFA_STATS_IO );
    4241                                serr | "Programs has been blocked for more than 5 secs";
    4342                                exit(1);
    … …  
    111110        cfa_option opt[] = {
    112111                BENCH_OPT,
    113                 { 'e', "exhaust", "Whether or not threads that have seen the new epoch should park instead of yielding.", exhaust, parse_yesno}
     112                { 'e', "exhaust", "Whether or not threads that have seen the new epoch should yield or park.", exhaust, parse_yesno}
    114113        };
    115114        BENCH_OPT_PARSE("cforall transition benchmark");

  • benchmark/readyQ/yield.rs

    ra3769cc r347925c  
    4444        let nprocs    = options.value_of("nprocs").unwrap().parse::<usize>().unwrap();
    4545
    46         let exp = Arc::new(bench::BenchData::new(options, nthreads, None));
     46        let exp = Arc::new(bench::BenchData::new(options, nthreads));
    4747
    4848        let s = (1000000 as u64).to_formatted_string(&Locale::en);
    … …  
    5050
    5151        let thddata : Arc<Vec<Arc<Yielder>>> = Arc::new(
    52                 (0..nthreads).map(|_i| {
     52                (0..nthreads).map(|i| {
     53                        let pi = (i + nthreads) % nthreads;
    5354                        Arc::new(Yielder{
    5455                                sem: sync::Semaphore::new(0),

  • libcfa/src/concurrency/kernel.cfa

    ra3769cc r347925c  
    2222#include <errno.h>
    2323#include <stdio.h>
    24 #include <string.h>
    2524#include <signal.h>
    2625#include <unistd.h>
    … …  
    3231#include "kernel_private.hfa"
    3332#include "preemption.hfa"
    34 #include "strstream.hfa"
    35 #include "device/cpu.hfa"
    3633
    3734//Private includes
    … …  
    234231                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
    235232
    236                                 {
    237                                         eventfd_t val;
    238                                         ssize_t ret = read( this->idle, &val, sizeof(val) );
    239                                         if(ret < 0) {
    240                                                 switch((int)errno) {
    241                                                 case EAGAIN:
    242                                                 #if EAGAIN != EWOULDBLOCK
    243                                                         case EWOULDBLOCK:
    244                                                 #endif
    245                                                 case EINTR:
    246                                                         // No need to do anything special here, just assume it's a legitimate wake-up
    247                                                         break;
    248                                                 default:
    249                                                         abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
    250                                                 }
    251                                         }
    252                                 }
     233                                __disable_interrupts_hard();
     234                                eventfd_t val;
     235                                eventfd_read( this->idle, &val );
     236                                __enable_interrupts_hard();
    253237
    254238                                #if !defined(__CFA_NO_STATISTICS__)

  • libcfa/src/device/cpu.cfa

    ra3769cc r347925c  
    422422        }
    423423}
    424 
    425 cpu_info_t cpu_info;

  • libcfa/src/device/cpu.hfa

    ra3769cc r347925c  
    3030};
    3131
    32 extern cpu_info_t cpu_info;
     32cpu_info_t cpu_info;
Note: See TracChangeset for help on using the changeset viewer.