perfmonger 0.10.2 → 0.12.1

data/core/cmd/perfmonger-player/perfmonger-player.go

@@ -0,0 +1,247 @@
+//usr/bin/env go run $0 $@ ; exit
+
+package main
+
+import (
+	"bufio"
+	"encoding/gob"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+
+	projson "github.com/hayamiz/go-projson"
+	ss "github.com/hayamiz/perfmonger/core/subsystem"
+    core "github.com/hayamiz/perfmonger/core"
+)
+
+type PlayerOption struct {
+	logfile string
+	color   bool
+	pretty  bool
+}
+
+var option PlayerOption
+var init_rec ss.StatRecord
+
+func showCpuStat(printer *projson.JsonPrinter, prev_rec *ss.StatRecord, cur_rec *ss.StatRecord) error {
+	cusage, err := ss.GetCpuUsage(prev_rec.Cpu, cur_rec.Cpu)
+	if err != nil {
+		return err
+	}
+
+	printer.PutKey("cpu")
+	cusage.WriteJsonTo(printer)
+
+	return nil
+}
+
+func showInterruptStat(printer *projson.JsonPrinter, prev_rec *ss.StatRecord, cur_rec *ss.StatRecord) error {
+	intr_usage, err := ss.GetInterruptUsage(
+		prev_rec.Time, prev_rec.Interrupt,
+		cur_rec.Time, cur_rec.Interrupt)
+	if err != nil {
+		return err
+	}
+
+	printer.PutKey("intr")
+	intr_usage.WriteJsonTo(printer)
+
+	return nil
+}
+
+func showDiskStat(printer *projson.JsonPrinter, prev_rec *ss.StatRecord, cur_rec *ss.StatRecord) error {
+	dusage, err := ss.GetDiskUsage(
+		prev_rec.Time, prev_rec.Disk,
+		cur_rec.Time, cur_rec.Disk)
+	if err != nil {
+		return err
+	}
+
+	printer.PutKey("disk")
+
+	dusage.WriteJsonTo(printer)
+
+	return nil
+}
+
+func showNetStat(printer *projson.JsonPrinter, prev_rec *ss.StatRecord, cur_rec *ss.StatRecord) error {
+	dusage, err := ss.GetNetUsage(
+		prev_rec.Time, prev_rec.Net,
+		cur_rec.Time, cur_rec.Net,
+	)
+	if err != nil {
+		return err
+	}
+
+	printer.PutKey("net")
+
+	dusage.WriteJsonTo(printer)
+
+	return nil
+}
+
+func showMemStat(printer *projson.JsonPrinter, cur_rec *ss.StatRecord) error {
+	musage, err := ss.GetMemUsage(cur_rec.Mem)
+	if err != nil {
+		return err
+	}
+
+	printer.PutKey("mem")
+
+	musage.WriteJsonTo(printer)
+
+	return nil
+}
+
+func showStat(printer *projson.JsonPrinter, prev_rec *ss.StatRecord, cur_rec *ss.StatRecord) error {
+	printer.Reset()
+	if option.pretty {
+		printer.SetStyle(projson.SmartStyle)
+	}
+	if option.color {
+		printer.SetColor(true)
+	}
+	printer.BeginObject()
+	printer.PutKey("time")
+	printer.PutFloatFmt(float64(cur_rec.Time.UnixNano())/1e9, "%.3f")
+	printer.PutKey("elapsed_time")
+	printer.PutFloatFmt((float64(cur_rec.Time.UnixNano())-float64(init_rec.Time.UnixNano()))/1e9,
+		"%.3f")
+
+	if cur_rec.Cpu != nil {
+		err := showCpuStat(printer, prev_rec, cur_rec)
+		if err != nil {
+			return err
+		}
+	}
+	if cur_rec.Interrupt != nil {
+		err := showInterruptStat(printer, prev_rec, cur_rec)
+		if err != nil {
+			return err
+		}
+	}
+	if cur_rec.Disk != nil {
+		err := showDiskStat(printer, prev_rec, cur_rec)
+		if err != nil {
+			return err
+		}
+	}
+	if cur_rec.Net != nil {
+		err := showNetStat(printer, prev_rec, cur_rec)
+		if err != nil {
+			return err
+		}
+	}
+	if cur_rec.Mem != nil {
+		err := showMemStat(printer, cur_rec)
+		if err != nil {
+			return err
+		}
+	}
+
+	printer.FinishObject()
+
+	return nil
+}
+
+func parseArgs() {
+	flag.BoolVar(&option.color, "color", false, "Use colored JSON output")
+	flag.BoolVar(&option.pretty, "pretty", false, "Use human readable JSON output")
+
+	flag.Parse()
+
+	option.logfile = flag.Arg(0)
+}
+
+func main() {
+	var in *os.File
+	var out *bufio.Writer
+
+	parseArgs()
+
+	if option.logfile == "" {
+		in = os.Stdin
+	} else {
+		f, err := os.Open(option.logfile)
+		if err != nil {
+			panic(err)
+		}
+		in = f
+		defer f.Close()
+	}
+	input_reader := core.NewPerfmongerLogReader(in)
+	dec := gob.NewDecoder(input_reader)
+
+	out = bufio.NewWriter(os.Stdout)
+
+	var cheader ss.CommonHeader
+	var pheader ss.PlatformHeader
+	var records = make([]ss.StatRecord, 2)
+	curr := 0
+
+	var err error
+
+	err = dec.Decode(&cheader)
+	if err == io.EOF {
+		return
+	}
+	if err != nil {
+		panic(err)
+	}
+	err = dec.Decode(&pheader)
+	if err == io.EOF {
+		return
+	}
+	if err != nil {
+		panic(err)
+	}
+
+	// read first record
+	err = dec.Decode(&records[curr])
+	if err == io.EOF {
+		return
+	} else if err != nil {
+		panic(err)
+	}
+	init_rec = records[curr]
+	curr ^= 1
+
+	printer := projson.NewPrinter()
+	for {
+		prev_rec := &records[curr^1]
+		cur_rec := &records[curr]
+
+		err = dec.Decode(cur_rec)
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			panic(err)
+		}
+
+		err = showStat(printer, prev_rec, cur_rec)
+		if err != nil {
+			printer.Reset()
+			fmt.Fprintln(os.Stderr, "skip by err")
+			continue
+		}
+
+		if str, err := printer.String(); err != nil {
+			fmt.Println("error", err)
+			fmt.Println(str)
+		} else {
+			_, err = out.WriteString(str + "\n")
+		}
+		err = out.Flush()
+		if err != nil {
+			// stdout is closed
+			break
+		}
+
+		printer.Reset()
+
+		curr ^= 1
+	}
+
+	return
+}

data/core/{perfmonger-plot-formatter.go → cmd/perfmonger-plot-formatter/perfmonger-plot-formatter.go}

@@ -11,23 +11,31 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
+	"regexp"
 	"sort"
 
 	ss "github.com/hayamiz/perfmonger/core/subsystem"
+	"github.com/hayamiz/perfmonger/core"
 )
 
 type CmdOption struct {
-	DiskFile       string
-	CpuFile        string
-	PerfmongerFile string
+	DiskFile        string
+	CpuFile         string
+	PerfmongerFile  string
+	disk_only       string
+	disk_only_regex *regexp.Regexp
 }
 
 func parseArgs() *CmdOption {
+	var err error
+
 	opt := new(CmdOption)
 
 	flag.StringVar(&opt.DiskFile, "diskfile", "./disk.dat", "Disk performance data file")
 	flag.StringVar(&opt.CpuFile, "cpufile", "./cpu.dat", "CPU performance data file")
 	flag.StringVar(&opt.PerfmongerFile, "perfmonger", "", "Perfmonger log file")
+	flag.StringVar(&opt.disk_only, "disk-only",
+		"", "Select disk devices by regex")
 
 	flag.Parse()
 
@@ -36,6 +44,11 @@ func parseArgs() *CmdOption {
 		os.Exit(1)
 	}
 
+	opt.disk_only_regex, err = regexp.Compile(opt.disk_only)
+	if err != nil {
+		panic(err)
+	}
+
 	return opt
 }
 
@@ -129,7 +142,7 @@ func main() {
 	}
 	defer f.Close()
 
-	input_reader := newPerfmongerLogReader(f)
+	input_reader := core.NewPerfmongerLogReader(f)
 	dec := gob.NewDecoder(input_reader)
 
 	var cheader ss.CommonHeader
@@ -192,7 +205,9 @@ func main() {
 		}
 
 		// Disk usage
-		dusage, err := ss.GetDiskUsage(prev_rec.Time, prev_rec.Disk, cur_rec.Time, cur_rec.Disk)
+		dusage, err := ss.GetDiskUsage1(prev_rec.Time, prev_rec.Disk,
+			cur_rec.Time, cur_rec.Disk,
+			opt.disk_only_regex)
 		if err != nil {
 			panic(err)
 		}

data/core/{perfmonger-recorder.go → cmd/perfmonger-recorder/perfmonger-recorder.go}

@@ -36,6 +36,7 @@ type RecorderOption struct {
 	no_intr             bool
 	no_disk             bool
 	no_net              bool
+	no_mem              bool
 	debug               bool
 	listDevices         bool
 	player_bin          string
@@ -43,6 +44,8 @@ type RecorderOption struct {
 	targetDisks         *map[string]bool
 	background          bool
 	gzip                bool
+	color               bool
+	pretty              bool
 }
 
 var option RecorderOption
@@ -74,6 +77,8 @@ func parseArgs() {
 		false, "Do not record disk usage")
 	flag.BoolVar(&option.no_net, "no-net",
 		false, "Do not record net usage")
+	flag.BoolVar(&option.no_mem, "no-mem",
+		false, "Do not record memory usage")
 	flag.BoolVar(&option.debug, "debug",
 		false, "Enable debug mode")
 	flag.BoolVar(&option.listDevices, "list-devices",
@@ -86,6 +91,10 @@ func parseArgs() {
 		"", "Run perfmonger-player to show JSON output")
 	flag.BoolVar(&option.gzip, "gzip",
 		false, "Save a logfile in gzipped format")
+	flag.BoolVar(&option.color, "color",
+		false, "Colored output (for live subcmd)")
+	flag.BoolVar(&option.pretty, "pretty",
+		false, "Pretty output (for live subcmd)")
 
 	flag.Parse()
 
@@ -190,7 +199,7 @@ func main() {
 	parseArgs()
 
 	hostname, _ := os.Hostname()
-	cheader := &ss.CommonHeader{ss.Linux, hostname, time.Now()}
+	cheader := &ss.CommonHeader{Platform: ss.Linux, Hostname: hostname, StartTime: time.Now()}
 
 	platform_header := ss.NewPlatformHeader()
 
@@ -206,7 +215,15 @@ func main() {
 	var player_stdout io.ReadCloser = nil
 
 	if option.player_bin != "" {
-		player_cmd = exec.Command(option.player_bin)
+		if option.color {
+			if option.pretty {
+				player_cmd = exec.Command(option.player_bin, "-color", "-pretty")
+			} else {
+				player_cmd = exec.Command(option.player_bin, "-color")
+			}
+		} else {
+			player_cmd = exec.Command(option.player_bin)
+		}
 		player_stdin, err = player_cmd.StdinPipe()
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Failed to get stdin of %s", option.player_bin)
@@ -326,6 +343,9 @@ func main() {
 		if !option.no_net {
 			ss.ReadNetStat(record)
 		}
+		if !option.no_mem {
+			ss.ReadMemStat(record)
+		}
 
 		err = enc.Encode(record)
 		if err != nil {

data/core/{perfmonger-summarizer.go → cmd/perfmonger-summarizer/perfmonger-summarizer.go}

@@ -3,7 +3,6 @@
 package main
 
 import (
-	"bytes"
 	"encoding/gob"
 	"flag"
 	"fmt"
@@ -12,7 +11,9 @@ import (
 	"regexp"
 	"sort"
 
+	projson "github.com/hayamiz/go-projson"
 	ss "github.com/hayamiz/perfmonger/core/subsystem"
+	"github.com/hayamiz/perfmonger/core"
 )
 
 type SummaryOption struct {
@@ -61,7 +62,7 @@ func main() {
 	}
 	defer f.Close()
 
-	input_reader := newPerfmongerLogReader(f)
+	input_reader := core.NewPerfmongerLogReader(f)
 	dec := gob.NewDecoder(input_reader)
 
 	err = dec.Decode(&cheader)
@@ -128,7 +129,7 @@ func main() {
 			option.disk_only_regex)
 	}
 
-	if fst_record.Disk != nil && lst_record.Disk != nil {
+	if fst_record.Net != nil && lst_record.Net != nil {
 		net_usage, err = ss.GetNetUsage(
 			fst_record.Time, fst_record.Net,
 			lst_record.Time, lst_record.Net)
@@ -137,32 +138,38 @@ func main() {
 	interval := lst_record.Time.Sub(fst_record.Time)
 
 	if option.json {
-		buf := bytes.NewBuffer([]byte{})
+		printer := projson.NewPrinter()
 
-		buf.WriteString(fmt.Sprintf(`{"exectime":%.3f`, interval.Seconds()))
+		printer.BeginObject()
+		printer.PutKey("exectime")
+		printer.PutFloatFmt(interval.Seconds(), "%.3f")
 		if cpu_usage != nil {
-			buf.WriteString(`,"cpu":`)
-			cpu_usage.WriteJsonTo(buf)
+			printer.PutKey("cpu")
+			cpu_usage.WriteJsonTo(printer)
 		}
 
 		if intr_usage != nil {
-			buf.WriteString(`,"intr":`)
-			intr_usage.WriteJsonTo(buf)
+			printer.PutKey("intr")
+			intr_usage.WriteJsonTo(printer)
 		}
 
 		if disk_usage != nil {
-			buf.WriteString(`,"disk":`)
-			disk_usage.WriteJsonTo(buf)
+			printer.PutKey("disk")
+			disk_usage.WriteJsonTo(printer)
 		}
 
 		if net_usage != nil {
-			buf.WriteString(`,"net":`)
-			net_usage.WriteJsonTo(buf)
+			printer.PutKey("net")
+			net_usage.WriteJsonTo(printer)
 		}
 
-		buf.WriteByte('}')
+		printer.FinishObject()
 
-		fmt.Println(buf.String())
+		if str, err := printer.String(); err != nil {
+			fmt.Println("skip by err")
+		} else {
+			fmt.Println(str)
+		}
 	} else {
 		if option.title == "" {
 			fmt.Println("== performance summary ==")