perfmonger 0.11.2 → 0.14.0

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
@@ -76,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",
@@ -340,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}

@@ -12,6 +12,7 @@ import (
 	"sort"
 
 	projson "github.com/hayamiz/go-projson"
+	"github.com/hayamiz/perfmonger/core"
 	ss "github.com/hayamiz/perfmonger/core/subsystem"
 )
 
@@ -38,6 +39,7 @@ func parseArgs() {
 	flag.Parse()
 
 	if len(flag.Args()) < 1 {
+		fmt.Fprintln(os.Stderr, "Insufficient argument")
 		os.Exit(1)
 	}
 
@@ -61,7 +63,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 +130,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)

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,100 @@ 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 "Hugepagesize:":
+			mem_stat.Hugepagesize = 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,39 @@ 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
+	Hugepagesize    int64
+}
+
 type StatRecord struct {
 	Time      time.Time
 	Cpu       *CpuStat
@@ -110,6 +143,7 @@ type StatRecord struct {
 	Disk      *DiskStat
 	Softirq   *SoftIrqStat
 	Net       *NetStat
+	Mem       *MemStat
 }
 
 func (core_stat *CpuCoreStat) Clear() {
@@ -219,6 +253,43 @@ 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
+	entry.Hugepagesize = 0
+}
+
 func NewStatRecord() *StatRecord {
 	return &StatRecord{
 		time.Now(),
@@ -228,6 +299,7 @@ func NewStatRecord() *StatRecord {
 		nil,
 		nil,
 		nil,
+		nil,
 	}
 }
 

data/core/subsystem/stat_test.go

@@ -262,6 +262,14 @@ func TestNewNetStat(t *testing.T) {
 	}
 }
 
+func TestNewMemStat(t *testing.T) {
+	memstat := NewMemStat()
+
+	if memstat == nil {
+		t.Error("failed to create MemStat")
+	}
+}
+
 func TestNewStatRecord(t *testing.T) {
 	stat_record := NewStatRecord()
 
@@ -278,4 +286,5 @@ func TestNewStatRecord(t *testing.T) {
 	checkFieldIsNil("Disk")
 	checkFieldIsNil("Softirq")
 	checkFieldIsNil("Net")
+	checkFieldIsNil("Mem")
 }

data/core/subsystem/usage.go

@@ -85,6 +85,10 @@ type NetUsageEntry struct {
 
 type NetUsage map[string]*NetUsageEntry
 
+type MemUsage struct {
+	mem *MemStat
+}
+
 var UseColor = false
 
 func SetUseColor(use_color bool) {
@@ -562,6 +566,82 @@ func (nusage *NetUsage) WriteJsonTo(printer *projson.JsonPrinter) {
 	printer.FinishObject()
 }
 
+func GetMemUsage(mem *MemStat) (*MemUsage, error) {
+	if mem == nil {
+		return nil, errors.New("invalid memstat")
+	}
+
+	musage := new(MemUsage)
+	musage.mem = mem
+
+	return musage, nil
+}
+
+func (musage *MemUsage) WriteJsonTo(printer *projson.JsonPrinter) {
+	printer.BeginObject()
+
+	printer.PutKey("mem_total")
+	printer.PutInt64(musage.mem.MemTotal)
+	printer.PutKey("mem_used")
+	printer.PutInt64(musage.mem.MemTotal - musage.mem.MemFree - musage.mem.Buffers - musage.mem.Cached - musage.mem.SReclaimable)
+	printer.PutKey("mem_free")
+	printer.PutInt64(musage.mem.MemFree)
+	printer.PutKey("buffers")
+	printer.PutInt64(musage.mem.Buffers)
+	printer.PutKey("cached")
+	printer.PutInt64(musage.mem.Cached)
+	printer.PutKey("swap_cached")
+	printer.PutInt64(musage.mem.SwapCached)
+	printer.PutKey("active")
+	printer.PutInt64(musage.mem.Active)
+	printer.PutKey("inactive")
+	printer.PutInt64(musage.mem.Inactive)
+	printer.PutKey("swap_total")
+	printer.PutInt64(musage.mem.SwapTotal)
+	printer.PutKey("swap_free")
+	printer.PutInt64(musage.mem.SwapFree)
+	printer.PutKey("dirty")
+	printer.PutInt64(musage.mem.Dirty)
+	printer.PutKey("writeback")
+	printer.PutInt64(musage.mem.Writeback)
+	printer.PutKey("anon_pages")
+	printer.PutInt64(musage.mem.AnonPages)
+	printer.PutKey("mapped")
+	printer.PutInt64(musage.mem.Mapped)
+	printer.PutKey("shmem")
+	printer.PutInt64(musage.mem.Shmem)
+	printer.PutKey("slab")
+	printer.PutInt64(musage.mem.Slab)
+	printer.PutKey("s_reclaimable")
+	printer.PutInt64(musage.mem.SReclaimable)
+	printer.PutKey("s_unreclaim")
+	printer.PutInt64(musage.mem.SUnreclaim)
+	printer.PutKey("kernel_stack")
+	printer.PutInt64(musage.mem.KernelStack)
+	printer.PutKey("page_tables")
+	printer.PutInt64(musage.mem.PageTables)
+	printer.PutKey("nfs_unstable")
+	printer.PutInt64(musage.mem.NFS_Unstable)
+	printer.PutKey("bounce")
+	printer.PutInt64(musage.mem.Bounce)
+	printer.PutKey("commit_limit")
+	printer.PutInt64(musage.mem.CommitLimit)
+	printer.PutKey("committed_as")
+	printer.PutInt64(musage.mem.Committed_AS)
+	printer.PutKey("anon_huge_pages")
+	printer.PutInt64(musage.mem.AnonHugePages)
+	printer.PutKey("huge_pages_total")
+	printer.PutInt64(musage.mem.HugePages_Total)
+	printer.PutKey("huge_pages_free")
+	printer.PutInt64(musage.mem.HugePages_Free)
+	printer.PutKey("huge_pages_rsvd")
+	printer.PutInt64(musage.mem.HugePages_Rsvd)
+	printer.PutKey("huge_pages_surp")
+	printer.PutInt64(musage.mem.HugePages_Surp)
+
+	printer.FinishObject()
+}
+
 func (entry *NetUsageEntry) WriteJsonTo(printer *projson.JsonPrinter) {
 	printer.BeginObject()