[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-devel] [PATCH RFC 15/59] controller: Move "running" code to a separate file



From: George Dunlap <george.dunlap@xxxxxxxxxx>

Signed-off-by: George Dunlap <george.dunlap@xxxxxxxxxx>
---
 Makefile     |   2 +-
 benchmark.go | 153 --------------------------------------------------
 run.go       | 178 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 179 insertions(+), 154 deletions(-)
 create mode 100644 run.go

diff --git a/Makefile b/Makefile
index 7a33cfb..2e06f87 100644
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,7 @@ BINALL = $(BIN)
 .PHONY: all
 all: $(BIN)
 
-schedbench: main.go processworker.go xenworker.go benchmark.go
+schedbench: main.go processworker.go xenworker.go benchmark.go run.go
        go build -o $@ $^
 
 .PHONY: clean
diff --git a/benchmark.go b/benchmark.go
index 4354a47..2e03fe5 100644
--- a/benchmark.go
+++ b/benchmark.go
@@ -21,8 +21,6 @@ package main
 import (
        "fmt"
        "os"
-       "os/signal"
-       "time"
        "io/ioutil"
        "encoding/json"
 )
@@ -71,11 +69,6 @@ const (
        SEC = MSEC * 1000
 )
 
-type WorkerState struct {
-       w Worker
-       LastReport WorkerReport
-}
-
 func Throughput(lt int, lm int, t int, m int) (tput float64) {
        time := float64(t - lt) / SEC
        mops := m - lm
@@ -84,80 +77,6 @@ func Throughput(lt int, lm int, t int, m int) (tput float64) 
{
        return
 }
 
-func Report(ws *WorkerState, r WorkerReport) {
-       //fmt.Println(r)
-
-       lr := ws.LastReport
-
-       if (lr.Now > 0) {
-               time := float64(r.Now - lr.Now) / SEC
-               mops := r.Mops - lr.Mops
-
-               tput := Throughput(lr.Now, lr.Mops, r.Now, r.Mops)
-               
-               fmt.Printf("%v Time: %2.3f Mops: %d Tput: %4.2f\n", r.Id, time, 
mops, tput);
-       }
-
-       ws.LastReport = r
-}
-
-type WorkerList map[WorkerId]*WorkerState
-
-func (ws *WorkerList) Start(report chan WorkerReport, done chan bool) (i int) {
-       i = 0
-       for j := range *ws {
-               go (*ws)[j].w.Process(report, done)
-               i++
-       }
-       return
-}
-
-func (ws *WorkerList) Stop() {
-       for i := range *ws {
-               (*ws)[i].w.Shutdown()
-       }
-}
-
-const (
-       WorkerProcess = iota
-       WorkerXen = iota
-)
-
-func NewWorkerList(workers []WorkerSet, workerType int) (wl WorkerList, err 
error) {
-       wl = WorkerList(make(map[WorkerId]*WorkerState))
-
-       for wsi := range workers {
-               for i := 0; i < workers[wsi].Count; i = i+1 {
-                       Id := WorkerId{Set:wsi,Id:i}
-
-                       ws := wl[Id]
-
-                       if ws != nil {
-                               panic("Duplicate worker for id!")
-                       }
-                       
-                       ws = &WorkerState{}
-                       
-                       switch workerType {
-                       case WorkerProcess:
-                               ws.w = &ProcessWorker{}
-                       case WorkerXen:
-                               ws.w = &XenWorker{}
-                       default:
-                               err = fmt.Errorf("Unknown type: %d", workerType)
-                               return
-                       }
-                       
-                       ws.w.SetId(Id)
-               
-                       ws.w.Init(workers[wsi].Params)
-
-                       wl[Id] = ws
-               }
-       }
-       return
-}
-
 type BenchmarkRunData struct {
        Raw []WorkerReport       `json:",omitempty"`
        Summary map[WorkerId]*WorkerSummary  `json:",omitempty"`
@@ -171,59 +90,6 @@ type BenchmarkRun struct {
        Results BenchmarkRunData 
 }
 
-func (run *BenchmarkRun) Run() (err error) {
-       Workers, err := NewWorkerList(run.Workers, WorkerXen)
-       if err != nil {
-               fmt.Println("Error creating workers: %v", err)
-               return
-       }
-       
-       report := make(chan WorkerReport)
-       done := make(chan bool)
-       signals := make(chan os.Signal, 1)
-
-       signal.Notify(signals, os.Interrupt)
-       
-       i := Workers.Start(report, done)
-
-       // FIXME:
-       // 1. Make a zero timeout mean "never"
-       // 2. Make the signals / timeout thing a bit more rational; signal then 
timeout shouldn't hard kill
-       timeout := time.After(time.Duration(run.RuntimeSeconds) * time.Second);
-       stopped := false
-       for i > 0 {
-               select {
-               case r := <-report:
-                       run.Results.Raw = append(run.Results.Raw, r)
-                       Report(Workers[r.Id], r)
-               case <-done:
-                       i--;
-                       fmt.Println(i, "workers left");
-               case <-timeout:
-                       if ! stopped {
-                               Workers.Stop()
-                               stopped = true
-                               run.Completed = true
-                       }
-               case <-signals:
-                       if ! stopped {
-                               fmt.Println("SIGINT receieved, shutting down 
workers")
-                               Workers.Stop()
-                               stopped = true
-                               if run.RuntimeSeconds == 0 {
-                                       run.Completed = true
-                               }
-                               err = fmt.Errorf("Interrupted")
-                       } else {
-                               err = fmt.Errorf("Interrupted")
-                               fmt.Println("SIGINT received after stop, 
exiting without cleaning up")
-                               return
-                       }
-               }
-       }
-       return
-}
-
 func (run *BenchmarkRun) checkSummary() (done bool, err error) {
        if run.Results.Summary != nil {
                done = true
@@ -328,25 +194,6 @@ type BenchmarkPlan struct {
        Runs []BenchmarkRun
 }
 
-func (plan *BenchmarkPlan) Run() (err error) {
-       for i := range plan.Runs {
-               if ! plan.Runs[i].Completed {
-                       fmt.Printf("Running test [%d] %s\n", i, 
plan.Runs[i].Label)
-                       err = plan.Runs[i].Run()
-                       if err != nil {
-                               return
-                       }
-               }
-               fmt.Printf("Test [%d] %s completed\n", i, plan.Runs[i].Label)
-               err = plan.Save()
-               if err != nil {
-                       fmt.Println("Error saving: ", err)
-                       return
-               }
-       }
-       return
-}
-
 func LoadBenchmark(filename string) (plan BenchmarkPlan, err error) {
        plan.filename = filename
        
diff --git a/run.go b/run.go
new file mode 100644
index 0000000..7b5ef0a
--- /dev/null
+++ b/run.go
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2016 George W. Dunlap, Citrix Systems UK Ltd
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License only.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+package main
+
+import (
+       "fmt"
+       "os"
+       "os/signal"
+       "time"
+)
+
+type WorkerState struct {
+       w Worker
+       LastReport WorkerReport
+}
+
+func Report(ws *WorkerState, r WorkerReport) {
+       //fmt.Println(r)
+
+       lr := ws.LastReport
+
+       if (lr.Now > 0) {
+               time := float64(r.Now - lr.Now) / SEC
+               mops := r.Mops - lr.Mops
+
+               tput := Throughput(lr.Now, lr.Mops, r.Now, r.Mops)
+               
+               fmt.Printf("%v Time: %2.3f Mops: %d Tput: %4.2f\n", r.Id, time, 
mops, tput);
+       }
+
+       ws.LastReport = r
+}
+
+type WorkerList map[WorkerId]*WorkerState
+
+func (ws *WorkerList) Start(report chan WorkerReport, done chan bool) (i int) {
+       i = 0
+       for j := range *ws {
+               go (*ws)[j].w.Process(report, done)
+               i++
+       }
+       return
+}
+
+func (ws *WorkerList) Stop() {
+       for i := range *ws {
+               (*ws)[i].w.Shutdown()
+       }
+}
+
+const (
+       WorkerProcess = iota
+       WorkerXen = iota
+)
+
+func NewWorkerList(WorkerSets []WorkerSet, workerType int) (wl WorkerList, err 
error) {
+       wl = WorkerList(make(map[WorkerId]*WorkerState))
+
+       for wsi := range WorkerSets {
+               for i := 0; i < WorkerSets[wsi].Count; i = i+1 {
+                       Id := WorkerId{Set:wsi,Id:i}
+
+                       ws := wl[Id]
+
+                       if ws != nil {
+                               panic("Duplicate worker for id!")
+                       }
+                       
+                       ws = &WorkerState{}
+                       
+                       switch workerType {
+                       case WorkerProcess:
+                               ws.w = &ProcessWorker{}
+                       case WorkerXen:
+                               ws.w = &XenWorker{}
+                       default:
+                               err = fmt.Errorf("Unknown type: %d", workerType)
+                               return
+                       }
+                       
+                       ws.w.SetId(Id)
+               
+                       ws.w.Init(WorkerSets[wsi].Params)
+
+                       wl[Id] = ws
+               }
+       }
+       return
+}
+
+func (run *BenchmarkRun) Run() (err error) {
+       Workers, err := NewWorkerList(run.Workers, WorkerXen)
+       if err != nil {
+               fmt.Println("Error creating workers: %v", err)
+               return
+       }
+       
+       report := make(chan WorkerReport)
+       done := make(chan bool)
+       signals := make(chan os.Signal, 1)
+
+       signal.Notify(signals, os.Interrupt)
+       
+       i := Workers.Start(report, done)
+
+       // FIXME:
+       // 1. Make a zero timeout mean "never"
+       // 2. Make the signals / timeout thing a bit more rational; signal then 
timeout shouldn't hard kill
+       timeout := time.After(time.Duration(run.RuntimeSeconds) * time.Second);
+       stopped := false
+       for i > 0 {
+               select {
+               case r := <-report:
+                       run.Results.Raw = append(run.Results.Raw, r)
+                       Report(Workers[r.Id], r)
+               case <-done:
+                       i--;
+                       fmt.Println(i, "workers left");
+               case <-timeout:
+                       if ! stopped {
+                               Workers.Stop()
+                               stopped = true
+                               run.Completed = true
+                       }
+               case <-signals:
+                       if ! stopped {
+                               fmt.Println("SIGINT receieved, shutting down 
workers")
+                               Workers.Stop()
+                               stopped = true
+                               if run.RuntimeSeconds == 0 {
+                                       run.Completed = true
+                               }
+                               err = fmt.Errorf("Interrupted")
+                       } else {
+                               err = fmt.Errorf("Interrupted")
+                               fmt.Println("SIGINT received after stop, 
exiting without cleaning up")
+                               return
+                       }
+               }
+       }
+       return
+}
+
+func (plan *BenchmarkPlan) Run() (err error) {
+       for i := range plan.Runs {
+               if ! plan.Runs[i].Completed {
+                       fmt.Printf("Running test [%d] %s\n", i, 
plan.Runs[i].Label)
+                       err = plan.Runs[i].Run()
+                       if err != nil {
+                               return
+                       }
+               }
+               fmt.Printf("Test [%d] %s completed\n", i, plan.Runs[i].Label)
+               err = plan.Save()
+               if err != nil {
+                       fmt.Println("Error saving: ", err)
+                       return
+               }
+       }
+       return
+}
+
-- 
2.7.4


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
https://lists.xen.org/xen-devel

 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.