perfmonger 0.9.0 → 0.10.1

data/core/perfmonger-summarizer.go

@@ -59,7 +59,10 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	dec := gob.NewDecoder(f)
+	defer f.Close()
+
+	input_reader := newPerfmongerLogReader(f)
+	dec := gob.NewDecoder(input_reader)
 
 	err = dec.Decode(&cheader)
 	if err == io.EOF {
@@ -103,6 +106,7 @@ func main() {
 	lst_record := lst_records[idx]
 
 	var cpu_usage *ss.CpuUsage = nil
+	var intr_usage *ss.InterruptUsage = nil
 	var disk_usage *ss.DiskUsage = nil
 	var net_usage *ss.NetUsage = nil
 
@@ -110,6 +114,13 @@ func main() {
 		cpu_usage, err = ss.GetCpuUsage(fst_record.Cpu, lst_record.Cpu)
 	}
 
+	if fst_record.Interrupt != nil && lst_record.Interrupt != nil {
+		intr_usage, err = ss.GetInterruptUsage(
+			fst_record.Time, fst_record.Interrupt,
+			lst_record.Time, lst_record.Interrupt,
+		)
+	}
+
 	if fst_record.Disk != nil && lst_record.Disk != nil {
 		disk_usage, err = ss.GetDiskUsage1(
 			fst_record.Time, fst_record.Disk,
@@ -134,6 +145,11 @@ func main() {
 			cpu_usage.WriteJsonTo(buf)
 		}
 
+		if intr_usage != nil {
+			buf.WriteString(`,"intr":`)
+			intr_usage.WriteJsonTo(buf)
+		}
+
 		if disk_usage != nil {
 			buf.WriteString(`,"disk":`)
 			disk_usage.WriteJsonTo(buf)

data/core/subsystem/perfmonger_linux.go

@@ -8,7 +8,10 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"runtime"
+	"strconv"
+	"strings"
 )
 
 type PlatformHeader LinuxHeader
@@ -92,7 +95,23 @@ func ReadCpuStat(record *StatRecord) error {
 	defer f.Close()
 
 	if record.Cpu == nil {
-		record.Cpu = NewCpuStat(runtime.NumCPU())
+		num_core := 0
+		out, err := exec.Command("nproc", "--all").Output()
+		out_str := strings.TrimSpace(string(out))
+
+		if err == nil {
+			num_core, err = strconv.Atoi(out_str)
+
+			if err != nil {
+				num_core = 0
+			}
+		}
+
+		if num_core == 0 {
+			num_core = runtime.NumCPU()
+		}
+
+		record.Cpu = NewCpuStat(num_core)
 	} else {
 		record.Cpu.Clear()
 	}
@@ -200,6 +219,89 @@ func ReadCpuStat(record *StatRecord) error {
 	return nil
 }
 
+func parseInterruptStatEntry(line string, num_core int) (*InterruptStatEntry, error) {
+	entry := new(InterruptStatEntry)
+
+	entry.NumCore = num_core
+	entry.IntrCounts = make([]int, num_core)
+
+	tokens := strings.Fields(line)
+
+	idx := 0
+
+	tok := tokens[0]
+	tok = strings.TrimRight(tok, ":")
+	if irqno, err := strconv.Atoi(tok); err == nil {
+		entry.IrqNo = irqno
+		entry.IrqType = ""
+	} else {
+		entry.IrqNo = -1
+		entry.IrqType = tok
+	}
+
+	for idx := 1; idx < num_core+1; idx += 1 {
+		var c int
+		var err error
+
+		if idx >= len(tokens) {
+			break
+		}
+
+		tok = tokens[idx]
+		if c, err = strconv.Atoi(tok); err != nil {
+			return nil, errors.New("Invalid string for IntrCounts element: " + tok)
+		}
+
+		entry.IntrCounts[idx-1] = c
+	}
+
+	idx = num_core + 1
+	if idx < len(tokens) {
+		entry.Descr = strings.Join(tokens[idx:], " ")
+	} else {
+		entry.Descr = ""
+	}
+
+	return entry, nil
+}
+
+func ReadInterruptStat(record *StatRecord) error {
+	intr_stat := NewInterruptStat()
+
+	if record == nil {
+		return errors.New("Valid *StatRecord is required.")
+	}
+
+	f, err := os.Open("/proc/interrupts")
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	scan := bufio.NewScanner(f)
+
+	if !scan.Scan() {
+		return errors.New("/proc/interrupts seems to be empty")
+	}
+
+	cores := strings.Fields(scan.Text())
+	num_core := len(cores)
+
+	for scan.Scan() {
+		entry, err := parseInterruptStatEntry(scan.Text(), num_core)
+
+		if err != nil {
+			return err
+		}
+
+		intr_stat.Entries = append(intr_stat.Entries, entry)
+		intr_stat.NumEntries += 1
+	}
+
+	record.Interrupt = intr_stat
+
+	return nil
+}
+
 func ReadDiskStats(record *StatRecord, targets *map[string]bool) error {
 	if record == nil {
 		return errors.New("Valid *StatRecord is required.")
@@ -294,6 +396,7 @@ func ReadNetStat(record *StatRecord) error {
 		case line[0:7] == " face |":
 			continue
 		}
+		line = strings.Replace(line, ":", " ", -1)
 
 		e := NewNetStatEntry()
 
@@ -314,7 +417,10 @@ func ReadNetStat(record *StatRecord) error {
 		}
 
 		// trim trailing ":" from devname
-		e.Name = devname[0 : len(devname)-1]
+		if devname[len(devname)-1] == ':' {
+			devname = devname[0 : len(devname)-1]
+		}
+		e.Name = devname
 
 		net_stat.Entries = append(net_stat.Entries, e)
 	}

data/core/subsystem/stat.go

@@ -43,6 +43,20 @@ type SoftIrqStat struct {
 	Rcu         int64
 }
 
+type InterruptStatEntry struct {
+	IrqNo   int    // >0 if associated with devices, -1 if not
+	IrqType string // set intr name if IrqNo == -1
+
+	NumCore    int
+	IntrCounts []int
+	Descr      string
+}
+
+type InterruptStat struct {
+	NumEntries uint
+	Entries    []*InterruptStatEntry
+}
+
 type DiskStatEntry struct {
 	Major      uint
 	Minor      uint
@@ -89,12 +103,13 @@ type NetStat struct {
 }
 
 type StatRecord struct {
-	Time    time.Time
-	Cpu     *CpuStat
-	Proc    *ProcStat
-	Disk    *DiskStat
-	Softirq *SoftIrqStat
-	Net     *NetStat
+	Time      time.Time
+	Cpu       *CpuStat
+	Interrupt *InterruptStat
+	Proc      *ProcStat
+	Disk      *DiskStat
+	Softirq   *SoftIrqStat
+	Net       *NetStat
 }
 
 func (core_stat *CpuCoreStat) Clear() {
@@ -142,6 +157,14 @@ func (cpu_stat *CpuStat) Clear() {
 	}
 }
 
+func NewInterruptStat() *InterruptStat {
+	intr_stat := new(InterruptStat)
+	intr_stat.NumEntries = 0
+	intr_stat.Entries = make([]*InterruptStatEntry, 0)
+
+	return intr_stat
+}
+
 func NewProcStat() *ProcStat {
 	return &ProcStat{0, 0}
 }
@@ -204,6 +227,7 @@ func NewStatRecord() *StatRecord {
 		nil,
 		nil,
 		nil,
+		nil,
 	}
 }
 

data/core/subsystem/usage.go

@@ -29,6 +29,20 @@ type CpuUsage struct {
 	CoreUsages []*CpuCoreUsage
 }
 
+type CpuCoreIntrUsage struct {
+	Device float64 // intr/sec for devices
+	System float64 // intr/sec for system internal interrupts (timers, TLB miss, ...)
+}
+
+type InterruptUsage struct {
+	Interval time.Duration
+
+	NumEntries uint
+	NumCore    int
+
+	CoreIntrUsages []*CpuCoreIntrUsage
+}
+
 type DiskUsageEntry struct {
 	Interval time.Duration
 
@@ -169,6 +183,68 @@ func GetCpuUsage(c1 *CpuStat, c2 *CpuStat) (*CpuUsage, error) {
 	return usage, nil
 }
 
+func GetInterruptUsage(t1 time.Time, i1 *InterruptStat, t2 time.Time, i2 *InterruptStat) (*InterruptUsage, error) {
+	num_core := i1.Entries[0].NumCore
+
+	usage := new(InterruptUsage)
+	usage.Interval = t2.Sub(t1)
+	usage.NumEntries = i1.NumEntries
+	usage.NumCore = num_core
+	usage.CoreIntrUsages = make([]*CpuCoreIntrUsage, num_core)
+
+	for coreid := 0; coreid < usage.NumCore; coreid += 1 {
+		core_usage := new(CpuCoreIntrUsage)
+		core_usage.Device = 0
+		core_usage.System = 0
+
+		core_dev_count := 0
+		core_sys_count := 0
+
+		for idx, istat_entry1 := range i1.Entries {
+			istat_entry2 := i2.Entries[idx]
+
+			if istat_entry1.IrqNo != istat_entry2.IrqNo ||
+				istat_entry1.IrqType != istat_entry2.IrqType {
+				return nil, errors.New("Intr stat format changed")
+			}
+
+			countup := istat_entry2.IntrCounts[coreid] - istat_entry1.IntrCounts[coreid]
+			if istat_entry1.IrqNo != -1 {
+				core_dev_count += countup
+			} else {
+				core_sys_count += countup
+			}
+		}
+
+		core_usage.Device = float64(core_dev_count) / usage.Interval.Seconds()
+		core_usage.System = float64(core_sys_count) / usage.Interval.Seconds()
+
+		usage.CoreIntrUsages[coreid] = core_usage
+	}
+
+	return usage, nil
+}
+
+func (intr_usage *InterruptUsage) WriteJsonTo(buf *bytes.Buffer) {
+	buf.WriteString("{")
+	buf.WriteString(`"core_dev_intr":[`)
+	for idx, core_usage := range intr_usage.CoreIntrUsages {
+		if idx > 0 {
+			buf.WriteString(",")
+		}
+		fmt.Fprintf(buf, "%.2f", core_usage.Device)
+	}
+	buf.WriteString(`],"core_sys_intr":[`)
+	for idx, core_usage := range intr_usage.CoreIntrUsages {
+		if idx > 0 {
+			buf.WriteString(",")
+		}
+		fmt.Fprintf(buf, "%.2f", core_usage.System)
+	}
+	buf.WriteString("]")
+	buf.WriteString("}")
+}
+
 func (duentry *DiskUsageEntry) WriteJsonTo(buf *bytes.Buffer) {
 	fmt.Fprintf(buf,
 		`{"riops":%.2f,"wiops":%.2f,"rkbyteps":%.2f,"wkbyteps":%.2f,"rlatency":%.3f,"wlatency":%.3f,"rsize":%.2f,"wsize":%.2f,"qlen":%.2f}`,

data/core/subsystem/usage_test.go

@@ -65,6 +65,7 @@ func floatEqWithin(val1, val2, epsilon float64) bool {
 
 func TestGetCoreUsage(t *testing.T) {
 	var err error
+	var usage *CpuCoreUsage
 
 	c1 := new(CpuCoreStat)
 	c2 := new(CpuCoreStat)
@@ -73,10 +74,22 @@ func TestGetCoreUsage(t *testing.T) {
 	c2.User = 5
 	c2.Sys = 5
 
-	// should return error if uptime is the same
-	_, err = GetCpuCoreUsage(c1, c2)
-	if err == nil {
-		t.Error("err == nil, want non-nil")
+	// should return usage 0% with no error if uptime is the same
+	usage, err = GetCpuCoreUsage(c1, c2)
+	if err != nil {
+		t.Error("err != nil, want nil")
+	}
+	if !(usage.User == 0 &&
+		usage.Nice == 0 &&
+		usage.Sys == 0 &&
+		usage.Idle == 0 &&
+		usage.Iowait == 0 &&
+		usage.Hardirq == 0 &&
+		usage.Softirq == 0 &&
+		usage.Steal == 0 &&
+		usage.Guest == 0 &&
+		usage.GuestNice == 0) {
+		t.Error("usage is not 0%, want 0%")
 	}
 
 	// should return error if c1.Uptime() is larger than c2.Uptime()
@@ -87,7 +100,6 @@ func TestGetCoreUsage(t *testing.T) {
 	}
 
 	// should return 75% usr and 25% sys usage
-	var usage *CpuCoreUsage
 	c1.Clear()
 	c2.Clear()
 	c1.User = 100
@@ -124,11 +136,11 @@ func TestGetCpuUsage(t *testing.T) {
 	c2 := NewCpuStat(num_core)
 
 	usage, err = GetCpuUsage(c1, c2)
-	if err == nil {
-		t.Error("Error should be returned because no difference between c1 and c2")
+	if err != nil {
+		t.Error("Error should not be returned")
 	}
-	if usage != nil {
-		t.Error("Nil should be returned as usage")
+	if usage == nil {
+		t.Error("Nil should not be returned as usage")
 	}
 
 	c1.CoreStats[0].User = 100
@@ -141,13 +153,13 @@ func TestGetCpuUsage(t *testing.T) {
 	c2.CoreStats[1].User = c1.CoreStats[0].User + 300
 	c2.CoreStats[1].Sys = c1.CoreStats[0].Sys + 100
 
-	usage, err = GetCpuUsage(c1, c2)
-	if err == nil {
-		t.Error("Error should be returned because no progress in .All uptime")
-	}
-	if usage != nil {
-		t.Error("Nil should be returned as usage")
-	}
+	// usage, err = GetCpuUsage(c1, c2)
+	// if err == nil {
+	// 	t.Error("Error should be returned because no progress in .All uptime")
+	// }
+	// if usage != nil {
+	// 	t.Error("Nil should be returned as usage")
+	// }
 
 	c1.All.User = 200
 	c1.All.Sys = 100
@@ -158,12 +170,12 @@ func TestGetCpuUsage(t *testing.T) {
 	c2.CoreStats[0].Clear()
 
 	usage, err = GetCpuUsage(c1, c2)
-	if err == nil {
-		t.Error("Error should be returned because no progress in .CoreStats[9] uptime")
-	}
-	if usage != nil {
-		t.Error("Nil should be returned as usage")
-	}
+	// if err == nil {
+	// 	t.Error("Error should be returned because no progress in .CoreStats[9] uptime")
+	// }
+	// if usage != nil {
+	// 	t.Error("Nil should be returned as usage")
+	// }
 
 	c1.CoreStats[0].User = 100
 	c1.CoreStats[0].Sys = 50

data/core/utils.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"bufio"
+	"compress/gzip"
+	"io"
+)
+
+func newPerfmongerLogReader(source io.Reader) io.Reader {
+	var ret io.Reader
+	reader := bufio.NewReader(source)
+
+	magic_numbers, e := reader.Peek(2)
+	if e != nil {
+		panic(e)
+	}
+
+	// check magic number
+	if magic_numbers[0] == 0x1f && magic_numbers[1] == 0x8b {
+		// gzipped gob input
+		ret, e = gzip.NewReader(reader)
+		if e != nil {
+			panic(e)
+		}
+	} else {
+		// plain gob input
+		ret = reader
+	}
+
+	return ret
+}