perfmonger 0.11.1 → 0.13.1

data/core/cmd/perfmonger-viewer/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/go.mod

@@ -0,0 +1,10 @@
+module github.com/hayamiz/perfmonger/core
+
+go 1.15
+
+require (
+	github.com/hayamiz/go-projson v0.0.0-20210510072849-3503bd24ae61
+	github.com/jroimartin/gocui v0.4.0
+	github.com/nsf/termbox-go v1.1.1
+	golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a
+)

data/core/go.sum

@@ -0,0 +1,17 @@
+github.com/hayamiz/go-projson v0.0.0-20210510072849-3503bd24ae61 h1:elFR/pEri9bFREP6YvJQDcFjncPBDhG+SwWJjYSvY8s=
+github.com/hayamiz/go-projson v0.0.0-20210510072849-3503bd24ae61/go.mod h1:Zkuug8uJZoQ8V34UfDAFVmKLVHPhe+TJUAazUzh6s1k=
+github.com/jroimartin/gocui v0.4.0 h1:52jnalstgmc25FmtGcWqa0tcbMEWS6RpFLsOIO+I+E8=
+github.com/jroimartin/gocui v0.4.0/go.mod h1:7i7bbj99OgFHzo7kB2zPb8pXLqMBSQegY7azfqXMkyY=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/nsf/termbox-go v1.1.1 h1:nksUPLCb73Q++DwbYUBEglYBRPZyoXJdrj5L+TkjyZY=
+github.com/nsf/termbox-go v1.1.1/go.mod h1:T0cTdVuOwf7pHQNtfhnEbzHbcNyCEcVU4YPpouCbVxo=
+golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a h1:kr2P4QFmQr29mSLA43kwrOcgcReGTfbE9N577tCTuBc=
+golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

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
+}

data/core/subsystem/perfmonger_linux_test.go

@@ -1,6 +1,7 @@
 package subsystem
 
 import (
+	"log"
 	"os"
 	"testing"
 )
@@ -71,3 +72,42 @@ func TestReadNetStat(t *testing.T) {
 		t.Error("Device 'lo' not found.")
 	}
 }
+
+func TestReadMemStat(t *testing.T) {
+	var err error
+	var stat_record *StatRecord = nil
+
+	err = ReadMemStat(stat_record)
+	if err == nil {
+		t.Errorf("Error should not be returned with non-nil *StatRecord.")
+	}
+
+	_, err = os.Stat("/proc/meminfo")
+	if err != nil {
+		t.Skip("/proc/meminfo is not present.")
+	}
+
+	stat_record = NewStatRecord()
+	err = ReadMemStat(stat_record)
+	if err != nil {
+		log.Print(err)
+		t.Error("Error should not be returned with valid *StatRecord.")
+		return
+	}
+	if stat_record.Mem == nil {
+		t.Error("stat_record.Mem should not be nil")
+		return
+	}
+
+	if stat_record.Mem.MemTotal == 0 {
+		t.Error("Cannot read MemTotal correctly")
+		return
+	}
+
+	mem := stat_record.Mem
+
+	if (mem.MemFree + mem.Cached + mem.Buffers) > mem.MemTotal {
+		t.Error("Inconsistent meminfo values")
+		return
+	}
+}

data/core/subsystem/stat.go

@@ -102,6 +102,38 @@ type NetStat struct {
 	Entries []*NetStatEntry
 }
 
+// all values are recorded in KB
+type MemStat struct {
+	MemTotal        int64
+	MemFree         int64
+	Buffers         int64
+	Cached          int64
+	SwapCached      int64
+	Active          int64
+	Inactive        int64
+	SwapTotal       int64
+	SwapFree        int64
+	Dirty           int64
+	Writeback       int64
+	AnonPages       int64
+	Mapped          int64
+	Shmem           int64
+	Slab            int64
+	SReclaimable    int64
+	SUnreclaim      int64
+	KernelStack     int64
+	PageTables      int64
+	NFS_Unstable    int64
+	Bounce          int64
+	CommitLimit     int64
+	Committed_AS    int64
+	AnonHugePages   int64
+	HugePages_Total int64
+	HugePages_Free  int64
+	HugePages_Rsvd  int64
+	HugePages_Surp  int64
+}
+
 type StatRecord struct {
 	Time      time.Time
 	Cpu       *CpuStat
@@ -110,6 +142,7 @@ type StatRecord struct {
 	Disk      *DiskStat
 	Softirq   *SoftIrqStat
 	Net       *NetStat
+	Mem       *MemStat
 }
 
 func (core_stat *CpuCoreStat) Clear() {
@@ -219,6 +252,42 @@ func NewNetStat() *NetStat {
 	return new(NetStat)
 }
 
+func NewMemStat() *MemStat {
+	return new(MemStat)
+}
+
+func (entry *MemStat) Clear() {
+	entry.MemTotal = 0
+	entry.MemFree = 0
+	entry.Buffers = 0
+	entry.Cached = 0
+	entry.SwapCached = 0
+	entry.Active = 0
+	entry.Inactive = 0
+	entry.SwapTotal = 0
+	entry.SwapFree = 0
+	entry.Dirty = 0
+	entry.Writeback = 0
+	entry.AnonPages = 0
+	entry.Mapped = 0
+	entry.Shmem = 0
+	entry.Slab = 0
+	entry.SReclaimable = 0
+	entry.NFS_Unstable = 0
+	entry.SUnreclaim = 0
+	entry.KernelStack = 0
+	entry.PageTables = 0
+	entry.NFS_Unstable = 0
+	entry.Bounce = 0
+	entry.CommitLimit = 0
+	entry.Committed_AS = 0
+	entry.AnonHugePages = 0
+	entry.HugePages_Total = 0
+	entry.HugePages_Free = 0
+	entry.HugePages_Rsvd = 0
+	entry.HugePages_Surp = 0
+}
+
 func NewStatRecord() *StatRecord {
 	return &StatRecord{
 		time.Now(),
@@ -228,6 +297,7 @@ func NewStatRecord() *StatRecord {
 		nil,
 		nil,
 		nil,
+		nil,
 	}
 }