Changes in benchmark/readyQ/cycle.go [2c7eee0:7a2a3af]

File:

• benchmark/readyQ/cycle.go (modified) (4 diffs)

benchmark/readyQ/cycle.go

@@ -2 +2 @@
 
 import (
+        "bufio"
         "flag"
         "fmt"
+        "os"
+        "runtime"
         "sync/atomic"
         "time"
@@ -9 +12 @@
         "golang.org/x/text/message"
 )
+
+var clock_mode bool
+var threads_left int64
+var stop int32
+var duration float64
+var stop_count uint64
+
+func fflush(f *bufio.Writer) {
+        defer f.Flush()
+        f.Write([]byte("\r"))
+}
+
+func wait(start time.Time, is_tty bool) {
+        f := bufio.NewWriter(os.Stdout)
+        tdur := time.Duration(duration)
+        for true {
+                time.Sleep(100 * time.Millisecond)
+                end := time.Now()
+                delta := end.Sub(start)
+                if is_tty {
+                        fmt.Printf(" %.1f",delta.Seconds())
+                        fflush(f)
+                }
+                if clock_mode && delta >= (tdur * time.Second) {
+                        break
+                } else if !clock_mode && atomic.LoadInt64(&threads_left) == 0 {
+                        break
+                }
+        }
+}
 
 func partner(result chan uint64, mine chan int, next chan int) {
@@ -25 +58 @@
 
 func main() {
+        var nprocs int
+        var nthreads int
         var ring_size int
 
+        nprocsOpt := flag.Int("p", 1, "The number of processors")
+        nthreadsOpt := flag.Int("t", 1, "The number of threads")
         ring_sizeOpt := flag.Int("r", 2, "The number of threads per cycles")
+        durationOpt := flag.Float64("d", 0, "Duration of the experiment in seconds")
+        stopOpt := flag.Uint64("i", 0, "Duration of the experiment in iterations")
 
-        bench_init()
+        flag.Parse()
 
+        nprocs = *nprocsOpt
+        nthreads = *nthreadsOpt
         ring_size = *ring_sizeOpt
+        duration = *durationOpt
+        stop_count = *stopOpt
 
+        if duration > 0 && stop_count > 0 {
+                panic(fmt.Sprintf("--duration and --iterations cannot be used together\n"))
+        } else if duration > 0 {
+                clock_mode = true
+                stop_count = 0xFFFFFFFFFFFFFFFF
+                fmt.Printf("Running for %f seconds\n", duration)
+        } else if stop_count > 0 {
+                clock_mode = false
+                fmt.Printf("Running for %d iterations\n", stop_count)
+        } else {
+                duration = 5
+                clock_mode = true
+                fmt.Printf("Running for %f seconds\n", duration)
+        }
+
+        runtime.GOMAXPROCS(nprocs)
         tthreads := nthreads * ring_size
         threads_left = int64(tthreads)
@@ -67 +126 @@
 
         p := message.NewPrinter(language.English)
-        p.Printf("Duration (ms)        : %f\n", delta.Seconds());
-        p.Printf("Number of processors : %d\n", nprocs);
-        p.Printf("Number of threads    : %d\n", tthreads);
-        p.Printf("Cycle size (# thrds) : %d\n", ring_size);
-        p.Printf("Total Operations(ops): %15d\n", global_counter)
-        p.Printf("Yields per second    : %18.2f\n", float64(global_counter) / delta.Seconds())
-        p.Printf("ns per ops           : %18.2f\n", float64(delta.Nanoseconds()) / float64(global_counter))
-        p.Printf("Ops per threads      : %15d\n", global_counter / uint64(tthreads))
-        p.Printf("Ops per procs        : %15d\n", global_counter / uint64(nprocs))
-        p.Printf("Ops/sec/procs        : %18.2f\n", (float64(global_counter) / float64(nprocs)) / delta.Seconds())
-        p.Printf("ns per ops/procs     : %18.2f\n", float64(delta.Nanoseconds()) / (float64(global_counter) / float64(nprocs)))
+        p.Printf("Duration (ms)       : %f\n", delta.Seconds());
+        p.Printf("Number of processors: %d\n", nprocs);
+        p.Printf("Number of threads   : %d\n", tthreads);
+        p.Printf("Cycle size (# thrds): %d\n", ring_size);
+        p.Printf("Yields per second   : %18.2f\n", float64(global_counter) / delta.Seconds())
+        p.Printf("ns per yields       : %18.2f\n", float64(delta.Nanoseconds()) / float64(global_counter))
+        p.Printf("Total yields        : %15d\n", global_counter)
+        p.Printf("Yields per threads  : %15d\n", global_counter / uint64(tthreads))
+        p.Printf("Yields per procs    : %15d\n", global_counter / uint64(nprocs))
+        p.Printf("Yields/sec/procs    : %18.2f\n", (float64(global_counter) / float64(nprocs)) / delta.Seconds())
+        p.Printf("ns per yields/procs : %18.2f\n", float64(delta.Nanoseconds()) / (float64(global_counter) / float64(nprocs)))
 
 }