Changeset 0b84b15


Ignore:
Timestamp:
Oct 29, 2020, 3:33:45 PM (12 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
93068e53
Parents:
b35ab2d
Message:

Fixed the cycle benchmark, and implemented go equivalent

Location:
benchmark/readyQ
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • benchmark/readyQ/cycle.cfa

    rb35ab2d r0b84b15  
    44        Partner * partner;
    55        unsigned long long count;
    6         bool first;
    76};
    87
     
    1211
    1312void main( Partner & this ) {
    14         thread_loop {
     13        this.count = 0;
     14        for() {
    1515                park();
    1616                unpark( *this.partner );
     17                this.count ++;
     18                if( clock_mode && stop) break;
     19                if(!clock_mode && this.count >= stop_count) break;
    1720        }
    1821
    1922        __atomic_fetch_add(&threads_left, -1, __ATOMIC_SEQ_CST);
    20 
    21         if(this.first) park();
    2223}
    2324
     
    4142                                unsigned pi = (i + nthreads) % tthreads;
    4243                                threads[i].partner = &threads[pi];
    43                                 threads[i].first = i < nthreads;
    4444                        }
    4545                        printf("Starting\n");
     
    5151                                unpark( threads[i] );
    5252                        }
    53                         wait(start, end, is_tty);
     53                        wait(start, is_tty);
    5454
    5555                        stop = true;
  • benchmark/readyQ/cycle.go

    rb35ab2d r0b84b15  
     1package main
     2
     3import (
     4        "bufio"
     5        "flag"
     6        "fmt"
     7        "os"
     8        "runtime"
     9        "sync/atomic"
     10        "time"
     11        "golang.org/x/text/language"
     12        "golang.org/x/text/message"
     13)
     14
     15var clock_mode bool
     16var threads_left int64
     17var stop int32
     18var duration float64
     19var stop_count uint64
     20
     21func fflush(f *bufio.Writer) {
     22        defer f.Flush()
     23        f.Write([]byte("\r"))
     24}
     25
     26func wait(start time.Time, is_tty bool) {
     27        f := bufio.NewWriter(os.Stdout)
     28        tdur := time.Duration(duration)
     29        for true {
     30                time.Sleep(100 * time.Millisecond)
     31                end := time.Now()
     32                delta := end.Sub(start)
     33                if is_tty {
     34                        fmt.Printf(" %.1f",delta.Seconds())
     35                        fflush(f)
     36                }
     37                if clock_mode && delta >= (tdur * time.Second) {
     38                        break
     39                } else if !clock_mode && atomic.LoadInt64(&threads_left) == 0 {
     40                        break
     41                }
     42        }
     43}
     44
     45func partner(result chan uint64, mine chan int, next chan int) {
     46        count := uint64(0)
     47        for true {
     48                <- mine
     49                next <- 0
     50                count += 1
     51                if  clock_mode && atomic.LoadInt32(&stop) == 1 { break }
     52                if !clock_mode && count >= stop_count { break }
     53        }
     54
     55        atomic.AddInt64(&threads_left, -1);
     56        result <- count
     57}
     58
     59func main() {
     60        var nprocs int
     61        var nthreads int
     62        var ring_size int
     63
     64        nprocsOpt := flag.Int("p", 1, "The number of processors")
     65        nthreadsOpt := flag.Int("t", 1, "The number of threads")
     66        ring_sizeOpt := flag.Int("r", 2, "The number of threads per cycles")
     67        durationOpt := flag.Float64("d", 0, "Duration of the experiment in seconds")
     68        stopOpt := flag.Uint64("i", 0, "Duration of the experiment in iterations")
     69
     70        flag.Parse()
     71
     72        nprocs = *nprocsOpt
     73        nthreads = *nthreadsOpt
     74        ring_size = *ring_sizeOpt
     75        duration = *durationOpt
     76        stop_count = *stopOpt
     77
     78        if duration > 0 && stop_count > 0 {
     79                panic(fmt.Sprintf("--duration and --iterations cannot be used together\n"))
     80        } else if duration > 0 {
     81                clock_mode = true
     82                stop_count = 0xFFFFFFFFFFFFFFFF
     83                fmt.Printf("Running for %f seconds\n", duration)
     84        } else if stop_count > 0 {
     85                clock_mode = false
     86                fmt.Printf("Running for %d iterations\n", stop_count)
     87        } else {
     88                duration = 5
     89                clock_mode = true
     90                fmt.Printf("Running for %f seconds\n", duration)
     91        }
     92
     93        runtime.GOMAXPROCS(nprocs)
     94        tthreads := nthreads * ring_size
     95        threads_left = int64(tthreads)
     96
     97        result := make(chan uint64)
     98        channels := make([]chan int, tthreads)
     99        for i := range channels {
     100                channels[i] = make(chan int, 1)
     101        }
     102
     103        for i := 0; i < tthreads; i++ {
     104                pi := (i + nthreads) % tthreads
     105                go partner(result, channels[i], channels[pi])
     106        }
     107        fmt.Printf("Starting\n");
     108
     109        atomic.StoreInt32(&stop, 0)
     110        start := time.Now()
     111        for i := 0; i < nthreads; i++ {
     112                channels[i] <- 0
     113        }
     114        wait(start, true);
     115
     116        atomic.StoreInt32(&stop, 1)
     117        end := time.Now()
     118        delta := end.Sub(start)
     119
     120        fmt.Printf("\nDone\n")
     121
     122        global_counter := uint64(0)
     123        for i := 0; i < tthreads; i++ {
     124                global_counter += <- result
     125        }
     126
     127        p := message.NewPrinter(language.English)
     128        p.Printf("Took %f ms\n", delta.Seconds())
     129        p.Printf("Yields per second   : %18.2f\n", float64(global_counter) / delta.Seconds())
     130        p.Printf("ns per yields       : %18.2f\n", float64(delta.Nanoseconds()) / float64(global_counter))
     131        p.Printf("Total yields        : %15d\n", global_counter)
     132        p.Printf("Yields per threads  : %15d\n", global_counter / uint64(tthreads))
     133        p.Printf("Yields per procs    : %15d\n", global_counter / uint64(nprocs))
     134        p.Printf("Yields/sec/procs    : %18.2f\n", (float64(global_counter) / float64(nprocs)) / delta.Seconds())
     135        p.Printf("ns per yields/procs : %18.2f\n", float64(delta.Nanoseconds()) / (float64(global_counter) / float64(nprocs)))
     136
     137}
  • benchmark/readyQ/rq_bench.hfa

    rb35ab2d r0b84b15  
    1717volatile unsigned long long threads_left;
    1818
    19 #define thread_loop for(this.count = 0; this.count < stop_count && !stop; this.count++)
     19#define thread_loop for(this.count = 0;; this.count++)
    2020
    2121#define BENCH_OPT \
     
    3636                        clock_mode = true; \
    3737                        stop_count = 0xFFFFFFFFFFFFFFFF; \
     38                        printf("Running for %lf seconds\n", duration); \
    3839                } else if(stop_count > 0) { \
    3940                        clock_mode = false; \
     41                        printf("Running for %lu iterations\n", stop_count); \
    4042                } else { \
    4143                        duration = 5; clock_mode = true;\
     44                        printf("Running for %lf seconds\n", duration); \
    4245                } \
    4346        }
     
    6770}
    6871
    69 void wait(Time & start, Time & end, bool is_tty) {
     72void wait(const Time & start, bool is_tty) {
    7073        for() {
    7174                sleep(100`ms);
    72                 end = getTimeNsec();
     75                Time end = getTimeNsec();
    7376                Duration delta = end - start;
    7477                if(is_tty) {
Note: See TracChangeset for help on using the changeset viewer.