source: benchmark/readyQ/cycle.go @ 7a2a3af

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 7a2a3af was 7a2a3af, checked in by Thierry Delisle <tdelisle@…>, 13 months ago

Added more information to cycle output

  • Property mode set to 100644
File size: 3.5 KB
Line 
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("Duration (ms)       : %f\n", delta.Seconds());
129        p.Printf("Number of processors: %d\n", nprocs);
130        p.Printf("Number of threads   : %d\n", tthreads);
131        p.Printf("Cycle size (# thrds): %d\n", ring_size);
132        p.Printf("Yields per second   : %18.2f\n", float64(global_counter) / delta.Seconds())
133        p.Printf("ns per yields       : %18.2f\n", float64(delta.Nanoseconds()) / float64(global_counter))
134        p.Printf("Total yields        : %15d\n", global_counter)
135        p.Printf("Yields per threads  : %15d\n", global_counter / uint64(tthreads))
136        p.Printf("Yields per procs    : %15d\n", global_counter / uint64(nprocs))
137        p.Printf("Yields/sec/procs    : %18.2f\n", (float64(global_counter) / float64(nprocs)) / delta.Seconds())
138        p.Printf("ns per yields/procs : %18.2f\n", float64(delta.Nanoseconds()) / (float64(global_counter) / float64(nprocs)))
139
140}
Note: See TracBrowser for help on using the repository browser.