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

[Ronald Rojas <ronladred@gmail.com>]

From: George Dunlap <george.dunlap@citrix.com>

Signed-off-by: George Dunlap <george.dunlap@citrix.com>
---
 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@lists.xen.org
https://lists.xen.org/xen-devel