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

[Xen-devel] [PATCH RFC 32/59] controller: Allow specification of an input file



From: George Dunlap <george.dunlap@xxxxxxxxxx>

So that we can analyze data later if we want.

Signed-off-by: George Dunlap <george.dunlap@xxxxxxxxxx>
---
 main.go | 194 +++++++++++++++++++++++++++++++++++-----------------------------
 1 file changed, 106 insertions(+), 88 deletions(-)

diff --git a/main.go b/main.go
index f8d77cf..ddb768c 100644
--- a/main.go
+++ b/main.go
@@ -26,101 +26,119 @@ import (
 )
 
 func main() {
-       filename := "test.bench"
-
-       switch(os.Args[1]) {
-       case "plan":
-               workerA := []string{"burnwait", "70", "200000"}
-               //workerB := []string{"burnwait", "10", "20000000"}
-               workerB := []string{"burnwait", "10", "300000",
-                       "burnwait", "20", "300000",
-                       "burnwait", "10", "300000",
-                       "burnwait", "10", "300000",
-                       "burnwait", "10", "300000",
-                       "burnwait", "10", "300000",
-                       "burnwait", "30", "300000",
-               }
+       Args := os.Args
 
+       Args = Args[1:]
+       filename := "test.bench"
 
-               plan :=  BenchmarkPlan{
-                       WorkerType:WorkerXen,
-                       WorkerConfig:WorkerConfig{Pool:"schedbench"},
-                       filename:filename,
-                       Runs:[]BenchmarkRun{
-                               {Label:"baseline-a",
+       for len(Args) > 0 {
+               switch(Args[0]) {
+               case "-f":
+                       if len(Args) < 2 {
+                               fmt.Println("Need arg for -f")
+                               os.Exit(1)
+                       }
+                       filename = Args[1]
+                       Args = Args[2:]
+               case "plan":
+                       workerA := []string{"burnwait", "70", "200000"}
+                       //workerB := []string{"burnwait", "10", "20000000"}
+                       workerB := []string{"burnwait", "10", "300000",
+                               "burnwait", "20", "300000",
+                               "burnwait", "10", "300000",
+                               "burnwait", "10", "300000",
+                               "burnwait", "10", "300000",
+                               "burnwait", "10", "300000",
+                               "burnwait", "30", "300000",
+                       }
+                       
+                       
+                       plan :=  BenchmarkPlan{
+                               WorkerType:WorkerXen,
+                               WorkerConfig:WorkerConfig{Pool:"schedbench"},
+                               filename:filename,
+                               Runs:[]BenchmarkRun{
+                                       {Label:"baseline-a",
+                                               WorkerSets:[]WorkerSet{
+                                                       
{Params:WorkerParams{workerA},
+                                                               Count:1}},
+                                               RuntimeSeconds:10,},
+                                       {Label:"baseline-b",
+                                               WorkerSets:[]WorkerSet{
+                                                       
{Params:WorkerParams{workerB},
+                                                               Count:1}},
+                                               RuntimeSeconds:10,},
+                               }}
+                       
+                       for i := 1; i <= 16 ; i *= 2 {
+                               label := fmt.Sprintf("%da+%db", i, i)
+                               run := BenchmarkRun{
+                                       Label:label,
                                        WorkerSets:[]WorkerSet{
                                                {Params:WorkerParams{workerA},
-                                                       Count:1}},
-                                       RuntimeSeconds:10,},
-                               {Label:"baseline-b",
-                                       WorkerSets:[]WorkerSet{
+                                                       Count:i},
                                                {Params:WorkerParams{workerB},
-                                                       Count:1}},
-                                       RuntimeSeconds:10,},
-                       }}
-
-               for i := 1; i <= 16 ; i *= 2 {
-                       label := fmt.Sprintf("%da+%db", i, i)
-                       run := BenchmarkRun{
-                               Label:label,
-                               WorkerSets:[]WorkerSet{
-                                       {Params:WorkerParams{workerA},
-                                               Count:i},
-                                       {Params:WorkerParams{workerB},
-                                               Count:i}},
-                               RuntimeSeconds:10}
-                       plan.Runs = append(plan.Runs, run)
-               }
-               
-               err := plan.Save()
-               if err != nil {
-                       fmt.Println("Saving plan ", filename, " ", err)
-                       os.Exit(1)
-               }
-               fmt.Println("Created plan in ", filename)
-       case "run":
-               plan, err := LoadBenchmark(filename)
-               if err != nil {
-                       fmt.Println("Loading benchmark ", filename, " ", err)
-                       os.Exit(1)
-               }
-       
-               err = plan.Run()
-               if err != nil {
-                       fmt.Println("Running benchmark run:", err)
-                       os.Exit(1)
-               }
-               
-       case "report":
-               verbosity := 0
-               if len(os.Args) > 2 {
-                       verbosity, _ = strconv.Atoi(os.Args[2])
-               }
-               plan, err := LoadBenchmark(filename)
-               if err != nil {
-                       fmt.Println("Loading benchmark ", filename, " ", err)
-                       os.Exit(1)
-               }
-       
-               err = plan.TextReport(verbosity)
-               if err != nil {
-                       fmt.Println("Running benchmark run:", err)
-                       os.Exit(1)
-               }
-       case "htmlreport":
-               plan, err := LoadBenchmark(filename)
-               if err != nil {
-                       fmt.Println("Loading benchmark ", filename, " ", err)
-                       os.Exit(1)
-               }
-       
-               err = plan.HTMLReport()
-               if err != nil {
-                       fmt.Println("Running benchmark run:", err)
+                                                       Count:i}},
+                                       RuntimeSeconds:10}
+                               plan.Runs = append(plan.Runs, run)
+                       }
+                       
+                       err := plan.Save()
+                       if err != nil {
+                               fmt.Println("Saving plan ", filename, " ", err)
+                               os.Exit(1)
+                       }
+                       fmt.Println("Created plan in ", filename)
+                       Args = Args[1:]
+               case "run":
+                       plan, err := LoadBenchmark(filename)
+                       if err != nil {
+                               fmt.Println("Loading benchmark ", filename, " 
", err)
+                               os.Exit(1)
+                       }
+                       
+                       err = plan.Run()
+                       if err != nil {
+                               fmt.Println("Running benchmark run:", err)
+                               os.Exit(1)
+                       }
+                       Args = Args[1:]
+                       
+               case "report":
+                       verbosity := 0
+                       Args = Args[1:]
+                       if len(Args) > 0 {
+                               verbosity, _ = strconv.Atoi(os.Args[0])
+                               Args = Args[1:]
+                       }
+                       plan, err := LoadBenchmark(filename)
+                       if err != nil {
+                               fmt.Println("Loading benchmark ", filename, " 
", err)
+                               os.Exit(1)
+                       }
+                       
+                       err = plan.TextReport(verbosity)
+                       if err != nil {
+                               fmt.Println("Running benchmark run:", err)
+                               os.Exit(1)
+                       }
+               case "htmlreport":
+                       plan, err := LoadBenchmark(filename)
+                       if err != nil {
+                               fmt.Println("Loading benchmark ", filename, " 
", err)
+                               os.Exit(1)
+                       }
+                       
+                       err = plan.HTMLReport()
+                       if err != nil {
+                               fmt.Println("Running benchmark run:", err)
+                               os.Exit(1)
+                       }
+                       Args = Args[1:]
+               default:
+                       fmt.Println("Unknown argument: ", Args[0])
                        os.Exit(1)
                }
-       default:
-               fmt.Println("Unknown argument: ", os.Args[1])
        }
 }
 
-- 
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®.