perfmonger 0.6.1 → 0.7.0

data/core/subsystem/perfmonger_linux.go

@@ -0,0 +1,292 @@
+// +build linux
+
+package subsystem
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+)
+
+type PlatformHeader LinuxHeader
+
+func NewPlatformHeader() *LinuxHeader {
+	header := new(LinuxHeader)
+	header.Devices = make(map[string]LinuxDevice)
+
+	header.getDevsParts()
+
+	return header
+}
+
+func (header *LinuxHeader) getDevsParts() {
+	f, err := os.Open("/proc/diskstats")
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	scan := bufio.NewScanner(f)
+	for scan.Scan() {
+		var major, minor int
+		var name string
+		c, err := fmt.Sscanf(scan.Text(), "%d %d %s", &major, &minor, &name)
+		if err != nil {
+			panic(err)
+		}
+		if c != 3 {
+			continue
+		}
+
+		header.DevsParts = append(header.DevsParts, name)
+
+		if isDevice(name) {
+			header.Devices[name] = LinuxDevice{
+				name, getPartitions(name),
+			}
+		}
+	}
+}
+
+func isDevice(name string) bool {
+	stat, err := os.Stat(fmt.Sprintf("/sys/block/%s", name))
+	if err == nil && stat.IsDir() {
+		return true
+	}
+
+	return false
+}
+
+func getPartitions(name string) []string {
+	var dir *os.File
+	var fis []os.FileInfo
+	var err error
+	var parts = []string{}
+
+	dir, err = os.Open(fmt.Sprintf("/sys/block/%s", name))
+	if err != nil {
+		panic(err)
+	}
+	fis, err = dir.Readdir(0)
+	if err != nil {
+		panic(err)
+	}
+	for _, fi := range fis {
+		_, err := os.Stat(fmt.Sprintf("/sys/block/%s/%s/stat", name, fi.Name()))
+		if err == nil {
+			// partition exists
+			parts = append(parts, fi.Name())
+		}
+	}
+
+	return parts
+}
+
+func ReadCpuStat(record *StatRecord) error {
+	f, ferr := os.Open("/proc/stat")
+	if ferr != nil {
+		return ferr
+	}
+	defer f.Close()
+
+	if record.Cpu == nil {
+		record.Cpu = NewCpuStat(runtime.NumCPU())
+	} else {
+		record.Cpu.Clear()
+	}
+
+	if record.Proc == nil {
+		record.Proc = NewProcStat()
+	} else {
+		record.Proc.Clear()
+	}
+
+	scan := bufio.NewScanner(f)
+	for scan.Scan() {
+		var err error
+		var cpu string
+		line := scan.Text()
+		if line[0:4] == "cpu " {
+			_, err = fmt.Sscanf(line,
+				"%s %d %d %d %d %d %d %d %d %d %d",
+				&cpu,
+				&record.Cpu.All.User,
+				&record.Cpu.All.Nice,
+				&record.Cpu.All.Sys,
+				&record.Cpu.All.Idle,
+				&record.Cpu.All.Iowait,
+				&record.Cpu.All.Hardirq,
+				&record.Cpu.All.Softirq,
+				&record.Cpu.All.Steal,
+				&record.Cpu.All.Guest,
+				&record.Cpu.All.GuestNice)
+			if err != nil {
+				return err
+			}
+		} else if line[0:3] == "cpu" {
+			var n_core int
+			var core_stat *CpuCoreStat
+			// assume n_core < 10000
+			_, err = fmt.Sscanf(line[3:7], "%d", &n_core)
+			if err != nil {
+				return err
+			}
+
+			core_stat = &record.Cpu.CoreStats[n_core]
+			_, err = fmt.Sscanf(line,
+				"%s %d %d %d %d %d %d %d %d %d %d",
+				&cpu,
+				&core_stat.User,
+				&core_stat.Nice,
+				&core_stat.Sys,
+				&core_stat.Idle,
+				&core_stat.Iowait,
+				&core_stat.Hardirq,
+				&core_stat.Softirq,
+				&core_stat.Steal,
+				&core_stat.Guest,
+				&core_stat.GuestNice)
+			if err != nil {
+				return err
+			}
+		} else if line[0:5] == "ctxt " {
+			_, err = fmt.Sscanf(line[4:], "%d", &record.Proc.ContextSwitch)
+			if err != nil {
+				return err
+			}
+		} else if line[0:10] == "processes " {
+			_, err = fmt.Sscanf(line[10:], "%d", &record.Proc.Fork)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func ReadDiskStats(record *StatRecord, targets *map[string]bool) error {
+	if record == nil {
+		return errors.New("Valid *StatRecord is required.")
+	}
+
+	f, ferr := os.Open("/proc/diskstats")
+	if ferr != nil {
+		panic(ferr)
+	}
+	defer f.Close()
+
+	if record.Disk == nil {
+		record.Disk = NewDiskStat()
+	} else {
+		record.Disk.Clear()
+	}
+
+	scan := bufio.NewScanner(f)
+
+	var num_items int
+	var err error
+	for scan.Scan() {
+		var rdmerge_or_rdsec int64
+		var rdsec_or_wrios int64
+		var rdticks_or_wrsec int64
+
+		line := scan.Text()
+		entry := NewDiskStatEntry()
+
+		num_items, err = fmt.Sscanf(line,
+			"%d %d %s %d %d %d %d %d %d %d %d %d %d %d",
+			&entry.Major, &entry.Minor, &entry.Name,
+			&entry.RdIos, &rdmerge_or_rdsec, &rdsec_or_wrios, &rdticks_or_wrsec,
+			&entry.WrIos, &entry.WrMerges, &entry.WrSectors, &entry.WrTicks,
+			&entry.IosPgr, &entry.TotalTicks, &entry.ReqTicks)
+		if err != nil {
+			return err
+		}
+
+		if num_items == 14 {
+			entry.RdMerges = rdmerge_or_rdsec
+			entry.RdSectors = rdsec_or_wrios
+			entry.RdTicks = rdticks_or_wrsec
+		} else if num_items == 7 {
+			entry.RdSectors = rdmerge_or_rdsec
+			entry.WrIos = rdsec_or_wrios
+			entry.WrSectors = rdticks_or_wrsec
+		} else {
+			continue
+		}
+
+		if entry.RdIos == 0 && entry.WrIos == 0 {
+			continue
+		}
+
+		if targets != nil {
+			if _, ok := (*targets)[entry.Name]; !ok {
+				// device not in targets
+				continue
+			}
+		} else {
+			if !isDevice(entry.Name) {
+				continue
+			}
+		}
+
+		record.Disk.Entries = append(record.Disk.Entries, entry)
+	}
+
+	return nil
+}
+
+func ReadNetStat(record *StatRecord) error {
+	if record == nil {
+		return errors.New("Valid *StatRecord is required.")
+	}
+
+	net_stat := NewNetStat()
+
+	f, err := os.Open("/proc/net/dev")
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	scanner := bufio.NewScanner(f)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		switch {
+		case line[0:7] == "Inter-|":
+			continue
+		case line[0:7] == " face |":
+			continue
+		}
+
+		e := NewNetStatEntry()
+
+		var devname string
+		n, err := fmt.Sscanf(line,
+			"%s %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d", &devname,
+			&e.RxBytes, &e.RxPackets, &e.RxErrors, &e.RxDrops,
+			&e.RxFifo, &e.RxFrame, &e.RxCompressed, &e.RxMulticast,
+			&e.TxBytes, &e.TxPackets, &e.TxErrors, &e.TxDrops,
+			&e.TxFifo, &e.TxFrame, &e.TxCompressed, &e.TxMulticast)
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+		if n != 17 {
+			continue
+		}
+
+		// trim trailing ":" from devname
+		e.Name = devname[0 : len(devname)-1]
+
+		net_stat.Entries = append(net_stat.Entries, e)
+	}
+
+	record.Net = net_stat
+
+	return nil
+}

data/core/subsystem/perfmonger_linux_test.go

@@ -0,0 +1,73 @@
+package subsystem
+
+import (
+	"os"
+	"testing"
+)
+
+func TestReadDiskStat(t *testing.T) {
+	var err error
+	var stat_record *StatRecord = nil
+
+	err = ReadDiskStats(stat_record, nil)
+	if err == nil {
+		t.Errorf("Error should be returned with nil *StatRecord.")
+	}
+
+	_, err = os.Stat("/proc/diskstats")
+	if err != nil {
+		t.Skip("/proc/diskstats is not present.")
+	}
+
+	stat_record = NewStatRecord()
+	err = ReadDiskStats(stat_record, nil)
+	if err != nil {
+		t.Error("Error should not be returned with valid *StatRecord")
+	}
+	if stat_record.Disk == nil {
+		t.Error("stat_record.Disk should not be nil")
+		return
+	}
+	if len(stat_record.Disk.Entries) == 0 {
+		t.Error("No device found.")
+	}
+}
+
+func TestReadNetStat(t *testing.T) {
+	var err error
+	var stat_record *StatRecord = nil
+
+	err = ReadNetStat(stat_record)
+	if err == nil {
+		t.Errorf("Error should be returned with nil *StatRecord.")
+	}
+
+	_, err = os.Stat("/proc/net/dev")
+	if err != nil {
+		t.Skip("/proc/net/dev is not present.")
+	}
+
+	stat_record = NewStatRecord()
+	err = ReadNetStat(stat_record)
+	if err != nil {
+		t.Error("Error should not be returned with valid *StatRecord.")
+	}
+	if stat_record.Net == nil {
+		t.Error("stat_record.Net should not be nil")
+		return
+	}
+	if len(stat_record.Net.Entries) == 0 {
+		t.Error("No net device found, though every linux host should have 'lo'.")
+	}
+	// search 'lo'
+	lo_found := false
+	for _, entry := range stat_record.Net.Entries {
+		if entry.Name == "lo" {
+			lo_found = true
+			break
+		}
+	}
+	if !lo_found {
+		t.Error("Device 'lo' not found.")
+	}
+}

data/core/subsystem/stat.go

@@ -0,0 +1,214 @@
+package subsystem
+
+import "time"
+
+//
+// Record
+//
+
+type CpuCoreStat struct {
+	User      int64
+	Nice      int64
+	Sys       int64
+	Idle      int64
+	Iowait    int64
+	Hardirq   int64
+	Softirq   int64
+	Steal     int64
+	Guest     int64
+	GuestNice int64
+}
+
+type CpuStat struct {
+	All       CpuCoreStat
+	NumCore   int
+	CoreStats []CpuCoreStat
+}
+
+type ProcStat struct {
+	ContextSwitch int64
+	Fork          int64
+}
+
+type SoftIrqStat struct {
+	Hi          int64
+	Timer       int64
+	NetTx       int64
+	NetRx       int64
+	Block       int64
+	BlockIopoll int64
+	Tasklet     int64
+	Sched       int64
+	Hrtimer     int64
+	Rcu         int64
+}
+
+type DiskStatEntry struct {
+	Major      uint
+	Minor      uint
+	Name       string
+	RdIos      int64
+	RdMerges   int64
+	RdSectors  int64
+	RdTicks    int64
+	WrIos      int64
+	WrMerges   int64
+	WrSectors  int64
+	WrTicks    int64
+	IosPgr     int64
+	TotalTicks int64
+	ReqTicks   int64
+}
+
+type DiskStat struct {
+	Entries []*DiskStatEntry
+}
+
+type NetStatEntry struct {
+	Name         string
+	RxBytes      int64
+	RxPackets    int64
+	RxErrors     int64
+	RxDrops      int64
+	RxFifo       int64
+	RxFrame      int64
+	RxCompressed int64
+	RxMulticast  int64
+	TxBytes      int64
+	TxPackets    int64
+	TxErrors     int64
+	TxDrops      int64
+	TxFifo       int64
+	TxFrame      int64
+	TxCompressed int64
+	TxMulticast  int64
+}
+
+type NetStat struct {
+	Entries []*NetStatEntry
+}
+
+type StatRecord struct {
+	Time    time.Time
+	Cpu     *CpuStat
+	Proc    *ProcStat
+	Disk    *DiskStat
+	Softirq *SoftIrqStat
+	Net     *NetStat
+}
+
+func (core_stat *CpuCoreStat) Clear() {
+	core_stat.User = 0
+	core_stat.Nice = 0
+	core_stat.Sys = 0
+	core_stat.Iowait = 0
+	core_stat.Steal = 0
+	core_stat.Hardirq = 0
+	core_stat.Softirq = 0
+	core_stat.Guest = 0
+	core_stat.GuestNice = 0
+	core_stat.Idle = 0
+}
+
+func (core_stat *CpuCoreStat) Uptime() int64 {
+	// Don't take Guest because User include Guest
+	return core_stat.User +
+		core_stat.Nice +
+		core_stat.Sys +
+		core_stat.Iowait +
+		core_stat.Steal +
+		core_stat.Hardirq +
+		core_stat.Softirq +
+		core_stat.Idle
+}
+
+func NewCpuStat(num_core int) *CpuStat {
+	if num_core < 1 {
+		return nil
+	}
+
+	cpu_stat := new(CpuStat)
+
+	cpu_stat.NumCore = num_core
+	cpu_stat.CoreStats = make([]CpuCoreStat, num_core)
+
+	return cpu_stat
+}
+
+func (cpu_stat *CpuStat) Clear() {
+	cpu_stat.All.Clear()
+	for idx, _ := range cpu_stat.CoreStats {
+		cpu_stat.CoreStats[idx].Clear()
+	}
+}
+
+func NewProcStat() *ProcStat {
+	return &ProcStat{0, 0}
+}
+
+func (proc_stat *ProcStat) Clear() {
+	proc_stat.ContextSwitch = 0
+	proc_stat.Fork = 0
+}
+
+func NewDiskStatEntry() *DiskStatEntry {
+	return new(DiskStatEntry)
+}
+
+func NewDiskStat() *DiskStat {
+	return &DiskStat{[]*DiskStatEntry{}}
+}
+
+func (disk_stat *DiskStat) Clear() {
+	disk_stat.Entries = []*DiskStatEntry{}
+}
+
+func (sirq_stat *SoftIrqStat) Clear() {
+	sirq_stat.Hi = 0
+	sirq_stat.Timer = 0
+	sirq_stat.NetTx = 0
+	sirq_stat.NetRx = 0
+	sirq_stat.Block = 0
+	sirq_stat.BlockIopoll = 0
+	sirq_stat.Tasklet = 0
+	sirq_stat.Sched = 0
+	sirq_stat.Hrtimer = 0
+	sirq_stat.Rcu = 0
+}
+
+func NewNetStatEntry() *NetStatEntry {
+	return new(NetStatEntry)
+}
+
+func (entry *NetStatEntry) Clear() {
+	entry.Name = ""
+	entry.RxBytes = 0
+	entry.RxPackets = 0
+	entry.RxErrors = 0
+	entry.RxDrops = 0
+	entry.TxBytes = 0
+	entry.TxPackets = 0
+	entry.TxErrors = 0
+	entry.TxDrops = 0
+}
+
+func NewNetStat() *NetStat {
+	return new(NetStat)
+}
+
+func NewStatRecord() *StatRecord {
+	return &StatRecord{
+		time.Now(),
+		nil,
+		nil,
+		nil,
+		nil,
+		nil,
+	}
+}
+
+func (rec *StatRecord) Clear() {
+	rec.Cpu.Clear()
+	rec.Proc.Clear()
+	rec.Disk.Clear()
+}