perfmonger 0.10.1 → 0.12.0

data/core/perfmonger-plot-formatter.go

@@ -11,23 +11,30 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
+	"regexp"
 	"sort"
 
 	ss "github.com/hayamiz/perfmonger/core/subsystem"
 )
 
 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 +43,11 @@ func parseArgs() *CmdOption {
 		os.Exit(1)
 	}
 
+	opt.disk_only_regex, err = regexp.Compile(opt.disk_only)
+	if err != nil {
+		panic(err)
+	}
+
 	return opt
 }
 
@@ -192,7 +204,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

@@ -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

@@ -3,7 +3,6 @@
 package main
 
 import (
-	"bytes"
 	"encoding/gob"
 	"flag"
 	"fmt"
@@ -12,6 +11,7 @@ import (
 	"regexp"
 	"sort"
 
+	projson "github.com/hayamiz/go-projson"
 	ss "github.com/hayamiz/perfmonger/core/subsystem"
 )
 
@@ -128,7 +128,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 +137,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 ==")

data/core/perfmonger-viewer.go

@@ -0,0 +1,164 @@
+//usr/bin/env go run $0 $@ ; exit
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"math"
+	"math/rand"
+	"time"
+
+	gocui "github.com/jroimartin/gocui"
+	termbox "github.com/nsf/termbox-go"
+)
+
+func main() {
+	g, err := gocui.NewGui(gocui.OutputNormal)
+	if err != nil {
+		log.Panicln(err)
+	}
+	defer g.Close()
+
+	g.SetManagerFunc(layout)
+
+	setupKeybind(g)
+
+	go func() {
+		for {
+			time.Sleep(1 * time.Second)
+			g.Update(layout)
+		}
+	}()
+
+	if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
+		log.Panicln(err)
+	}
+}
+
+func setupKeybind(g *gocui.Gui) {
+	if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
+		log.Panicln(err)
+	}
+
+	if err := g.SetKeybinding("", 'c', gocui.ModNone, changeColor); err != nil {
+		log.Panicln(err)
+	}
+
+	if err := g.SetKeybinding("", 'q', gocui.ModNone, quit); err != nil {
+		log.Panicln(err)
+	}
+}
+
+var colmode bool = false
+
+func changeColor(g *gocui.Gui, v *gocui.View) error {
+	if colmode {
+		colmode = false
+	} else {
+		colmode = true
+	}
+	return nil
+}
+
+// Vertical bar characters
+// ' ': \u0020
+// '▁': \u2581
+// '▂': \u2582
+// '▃': \u2583
+// '▄': \u2584
+// '▅': \u2585
+// '▆': \u2586
+// '▇': \u2587
+// '█': \u2588
+var vbar_runes []rune = []rune(" ▁▂▃▄▅▆▇█")
+
+func drawPercent(g *gocui.Gui, x int, y int, height int, pct float64, fg, bg termbox.Attribute) {
+	pct = math.Max(0.0, math.Min(100.0, pct))
+	pct_ndiv := 9
+	if height > 1 {
+		pct_ndiv += 8 * (height - 1)
+	}
+	pct_class := int(pct / (100.0 / float64(pct_ndiv)))
+
+	col := termbox.ColorBlue
+	if 25 <= pct && pct < 50 {
+		col = termbox.ColorGreen
+	} else if 50 <= pct && pct < 75 {
+		col = termbox.ColorYellow
+	} else if 75 <= pct {
+		col = termbox.ColorRed
+	}
+
+	if !colmode {
+		col = termbox.ColorWhite
+	}
+
+	for cell_pos := height - 1; cell_pos >= 0; cell_pos-- {
+		vbar_idx := intMin(pct_class, len(vbar_runes)-1)
+		termbox.SetCell(x, y+cell_pos, vbar_runes[vbar_idx], col, bg)
+		pct_class -= vbar_idx
+	}
+
+	// termbox.SetCell(x, y, vbar_runes[pct_class], fg, bg)
+}
+
+func drawRunes(g *gocui.Gui, x int, y int, runes []rune) {
+	for _, r := range runes {
+		termbox.SetCell(x, y, r, termbox.ColorDefault, termbox.ColorDefault)
+		x += 1
+	}
+}
+
+func intMin(x, y int) int {
+	if x > y {
+		return y
+	} else {
+		return x
+	}
+}
+
+var start_time int64 = time.Now().Unix()
+
+func layout(g *gocui.Gui) error {
+	// maxX, maxY := g.Size()
+	// if v, err := g.SetView("hello", maxX/2-7, maxY/2, maxX/2+7, maxY/2+2); err != nil {
+	// 	if err != gocui.ErrUnknownView {
+	// 		return err
+	// 	}
+	// 	fmt.Fprintln(v, "Hello world!")
+	// }
+
+	for coreid := 0; coreid < 8; coreid++ {
+		s := int64(coreid + 1)
+		rand.Seed(s)
+
+		inc := int(time.Now().Unix() - start_time)
+		for i := 0; i < inc; i++ {
+			rand.Float64()
+		}
+
+		for i := 0; i < 100; i++ {
+			// drawPercent(g, i+5, 1+coreid*5, 4, float64(i)/2.0, termbox.ColorDefault, termbox.ColorDefault)
+			drawPercent(g, i+6, 1+coreid*5, 4, rand.Float64()*100, termbox.ColorDefault, termbox.ColorDefault)
+
+			ch := '-'
+			if (i+inc)%10 == 0 {
+				ch = '+'
+			}
+			termbox.SetCell(i+6, 1+coreid*5+4, ch, termbox.ColorDefault, termbox.ColorDefault)
+		}
+		drawRunes(g, 0, 1+coreid*5, []rune(fmt.Sprintf("core%d", coreid)))
+
+		drawRunes(g, 100+6+1, 1+coreid*5, []rune(fmt.Sprintf("%%usr: % 2.1f", rand.Float64()*30)))
+		drawRunes(g, 100+6+1, 1+coreid*5+1, []rune(fmt.Sprintf("%%sys: % 2.1f", rand.Float64()*30)))
+		drawRunes(g, 100+6+1, 1+coreid*5+2, []rune(fmt.Sprintf("%%iow: % 2.1f", rand.Float64()*30)))
+		drawRunes(g, 100+6+1, 1+coreid*5+3, []rune(fmt.Sprintf("%%oth: % 2.1f", rand.Float64()*30)))
+	}
+
+	return nil
+}
+
+func quit(g *gocui.Gui, v *gocui.View) error {
+	return gocui.ErrQuit
+}

data/core/subsystem/Makefile

@@ -1,3 +1,7 @@
 
 all:
 	make -C ../
+
+check:
+	go test
+

data/core/subsystem/perfmonger_linux.go

@@ -429,3 +429,98 @@ func ReadNetStat(record *StatRecord) error {
 
 	return nil
 }
+
+func ReadMemStat(record *StatRecord) error {
+	if record == nil {
+		return errors.New("Valid *StatRecord is required.")
+	}
+
+	mem_stat := NewMemStat()
+
+	f, err := os.Open("/proc/meminfo")
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	scanner := bufio.NewScanner(f)
+
+	for scanner.Scan() {
+		var key string
+		var val int64
+		line := scanner.Text()
+
+		n, err := fmt.Sscanf(line, "%s %d", &key, &val)
+
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+		if n != 2 {
+			continue
+		}
+
+		switch key {
+		case "HugePages_Surp:":
+			mem_stat.HugePages_Surp = val
+		case "HugePages_Rsvd:":
+			mem_stat.HugePages_Rsvd = val
+		case "HugePages_Free:":
+			mem_stat.HugePages_Free = val
+		case "HugePages_Total:":
+			mem_stat.HugePages_Total = val
+		case "AnonHugePages:":
+			mem_stat.AnonHugePages = val
+		case "Committed_AS:":
+			mem_stat.Committed_AS = val
+		case "CommitLimit:":
+			mem_stat.CommitLimit = val
+		case "Bounce:":
+			mem_stat.Bounce = val
+		case "NFS_Unstable:":
+			mem_stat.NFS_Unstable = val
+		case "Shmem:":
+			mem_stat.Shmem = val
+		case "Slab:":
+			mem_stat.Slab = val
+		case "SReclaimable:":
+			mem_stat.SReclaimable = val
+		case "SUnreclaim:":
+			mem_stat.SUnreclaim = val
+		case "KernelStack:":
+			mem_stat.KernelStack = val
+		case "PageTables:":
+			mem_stat.PageTables = val
+		case "Mapped:":
+			mem_stat.Mapped = val
+		case "AnonPages:":
+			mem_stat.AnonPages = val
+		case "Writeback:":
+			mem_stat.Writeback = val
+		case "Dirty:":
+			mem_stat.Dirty = val
+		case "SwapFree:":
+			mem_stat.SwapFree = val
+		case "SwapTotal:":
+			mem_stat.SwapTotal = val
+		case "Inactive:":
+			mem_stat.Inactive = val
+		case "Active:":
+			mem_stat.Active = val
+		case "SwapCached:":
+			mem_stat.SwapCached = val
+		case "Cached:":
+			mem_stat.Cached = val
+		case "Buffers:":
+			mem_stat.Buffers = val
+		case "MemFree:":
+			mem_stat.MemFree = val
+		case "MemTotal:":
+			mem_stat.MemTotal = val
+		}
+	}
+
+	record.Mem = mem_stat
+
+	return nil
+}