Initial commit

vendor/github.com/shirou/gopsutil/cpu/BUILD.bazel

@@ -0,0 +1,52 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cpu.go",
+        "cpu_darwin.go",
+        "cpu_darwin_cgo.go",
+        "cpu_darwin_nocgo.go",
+        "cpu_fallback.go",
+        "cpu_freebsd.go",
+        "cpu_freebsd_386.go",
+        "cpu_freebsd_amd64.go",
+        "cpu_linux.go",
+        "cpu_openbsd.go",
+        "cpu_solaris.go",
+        "cpu_windows.go",
+    ],
+    cgo = True,
+    importmap = "go-common/vendor/github.com/shirou/gopsutil/cpu",
+    importpath = "github.com/shirou/gopsutil/cpu",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/shirou/gopsutil/internal/common:go_default_library",
+    ] + select({
+        "@io_bazel_rules_go//go/platform:freebsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:openbsd": [
+            "//vendor/golang.org/x/sys/unix:go_default_library",
+        ],
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/github.com/StackExchange/wmi:go_default_library",
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/shirou/gopsutil/cpu/cpu.go

@@ -0,0 +1,189 @@
+package cpu
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+// TimesStat contains the amounts of time the CPU has spent performing different
+// kinds of work. Time units are in USER_HZ or Jiffies (typically hundredths of
+// a second). It is based on linux /proc/stat file.
+type TimesStat struct {
+	CPU       string  `json:"cpu"`
+	User      float64 `json:"user"`
+	System    float64 `json:"system"`
+	Idle      float64 `json:"idle"`
+	Nice      float64 `json:"nice"`
+	Iowait    float64 `json:"iowait"`
+	Irq       float64 `json:"irq"`
+	Softirq   float64 `json:"softirq"`
+	Steal     float64 `json:"steal"`
+	Guest     float64 `json:"guest"`
+	GuestNice float64 `json:"guestNice"`
+	Stolen    float64 `json:"stolen"`
+}
+
+type InfoStat struct {
+	CPU        int32    `json:"cpu"`
+	VendorID   string   `json:"vendorId"`
+	Family     string   `json:"family"`
+	Model      string   `json:"model"`
+	Stepping   int32    `json:"stepping"`
+	PhysicalID string   `json:"physicalId"`
+	CoreID     string   `json:"coreId"`
+	Cores      int32    `json:"cores"`
+	ModelName  string   `json:"modelName"`
+	Mhz        float64  `json:"mhz"`
+	CacheSize  int32    `json:"cacheSize"`
+	Flags      []string `json:"flags"`
+	Microcode  string   `json:"microcode"`
+}
+
+type lastPercent struct {
+	sync.Mutex
+	lastCPUTimes    []TimesStat
+	lastPerCPUTimes []TimesStat
+}
+
+var lastCPUPercent lastPercent
+var invoke common.Invoker = common.Invoke{}
+
+func init() {
+	lastCPUPercent.Lock()
+	lastCPUPercent.lastCPUTimes, _ = Times(false)
+	lastCPUPercent.lastPerCPUTimes, _ = Times(true)
+	lastCPUPercent.Unlock()
+}
+
+func Counts(logical bool) (int, error) {
+	return CountsWithContext(context.Background(), logical)
+}
+
+func CountsWithContext(ctx context.Context, logical bool) (int, error) {
+	return runtime.NumCPU(), nil
+}
+
+func (c TimesStat) String() string {
+	v := []string{
+		`"cpu":"` + c.CPU + `"`,
+		`"user":` + strconv.FormatFloat(c.User, 'f', 1, 64),
+		`"system":` + strconv.FormatFloat(c.System, 'f', 1, 64),
+		`"idle":` + strconv.FormatFloat(c.Idle, 'f', 1, 64),
+		`"nice":` + strconv.FormatFloat(c.Nice, 'f', 1, 64),
+		`"iowait":` + strconv.FormatFloat(c.Iowait, 'f', 1, 64),
+		`"irq":` + strconv.FormatFloat(c.Irq, 'f', 1, 64),
+		`"softirq":` + strconv.FormatFloat(c.Softirq, 'f', 1, 64),
+		`"steal":` + strconv.FormatFloat(c.Steal, 'f', 1, 64),
+		`"guest":` + strconv.FormatFloat(c.Guest, 'f', 1, 64),
+		`"guestNice":` + strconv.FormatFloat(c.GuestNice, 'f', 1, 64),
+		`"stolen":` + strconv.FormatFloat(c.Stolen, 'f', 1, 64),
+	}
+
+	return `{` + strings.Join(v, ",") + `}`
+}
+
+// Total returns the total number of seconds in a CPUTimesStat
+func (c TimesStat) Total() float64 {
+	total := c.User + c.System + c.Nice + c.Iowait + c.Irq + c.Softirq + c.Steal +
+		c.Guest + c.GuestNice + c.Idle + c.Stolen
+	return total
+}
+
+func (c InfoStat) String() string {
+	s, _ := json.Marshal(c)
+	return string(s)
+}
+
+func getAllBusy(t TimesStat) (float64, float64) {
+	busy := t.User + t.System + t.Nice + t.Iowait + t.Irq +
+		t.Softirq + t.Steal + t.Guest + t.GuestNice + t.Stolen
+	return busy + t.Idle, busy
+}
+
+func calculateBusy(t1, t2 TimesStat) float64 {
+	t1All, t1Busy := getAllBusy(t1)
+	t2All, t2Busy := getAllBusy(t2)
+
+	if t2Busy <= t1Busy {
+		return 0
+	}
+	if t2All <= t1All {
+		return 1
+	}
+	return (t2Busy - t1Busy) / (t2All - t1All) * 100
+}
+
+func calculateAllBusy(t1, t2 []TimesStat) ([]float64, error) {
+	// Make sure the CPU measurements have the same length.
+	if len(t1) != len(t2) {
+		return nil, fmt.Errorf(
+			"received two CPU counts: %d != %d",
+			len(t1), len(t2),
+		)
+	}
+
+	ret := make([]float64, len(t1))
+	for i, t := range t2 {
+		ret[i] = calculateBusy(t1[i], t)
+	}
+	return ret, nil
+}
+
+// Percent calculates the percentage of cpu used either per CPU or combined.
+// If an interval of 0 is given it will compare the current cpu times against the last call.
+// Returns one value per cpu, or a single value if percpu is set to false.
+func Percent(interval time.Duration, percpu bool) ([]float64, error) {
+	return PercentWithContext(context.Background(), interval, percpu)
+}
+
+func PercentWithContext(ctx context.Context, interval time.Duration, percpu bool) ([]float64, error) {
+	if interval <= 0 {
+		return percentUsedFromLastCall(percpu)
+	}
+
+	// Get CPU usage at the start of the interval.
+	cpuTimes1, err := Times(percpu)
+	if err != nil {
+		return nil, err
+	}
+
+	time.Sleep(interval)
+
+	// And at the end of the interval.
+	cpuTimes2, err := Times(percpu)
+	if err != nil {
+		return nil, err
+	}
+
+	return calculateAllBusy(cpuTimes1, cpuTimes2)
+}
+
+func percentUsedFromLastCall(percpu bool) ([]float64, error) {
+	cpuTimes, err := Times(percpu)
+	if err != nil {
+		return nil, err
+	}
+	lastCPUPercent.Lock()
+	defer lastCPUPercent.Unlock()
+	var lastTimes []TimesStat
+	if percpu {
+		lastTimes = lastCPUPercent.lastPerCPUTimes
+		lastCPUPercent.lastPerCPUTimes = cpuTimes
+	} else {
+		lastTimes = lastCPUPercent.lastCPUTimes
+		lastCPUPercent.lastCPUTimes = cpuTimes
+	}
+
+	if lastTimes == nil {
+		return nil, fmt.Errorf("error getting times for cpu percent. lastTimes was nil")
+	}
+	return calculateAllBusy(lastTimes, cpuTimes)
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_darwin.go

@@ -0,0 +1,115 @@
+// +build darwin
+
+package cpu
+
+import (
+	"context"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+// sys/resource.h
+const (
+	CPUser    = 0
+	CPNice    = 1
+	CPSys     = 2
+	CPIntr    = 3
+	CPIdle    = 4
+	CPUStates = 5
+)
+
+// default value. from time.h
+var ClocksPerSec = float64(128)
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	if percpu {
+		return perCPUTimes()
+	}
+
+	return allCPUTimes()
+}
+
+// Returns only one CPUInfoStat on FreeBSD
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	var ret []InfoStat
+	sysctl, err := exec.LookPath("/usr/sbin/sysctl")
+	if err != nil {
+		return ret, err
+	}
+	out, err := invoke.CommandWithContext(ctx, sysctl, "machdep.cpu")
+	if err != nil {
+		return ret, err
+	}
+
+	c := InfoStat{}
+	for _, line := range strings.Split(string(out), "\n") {
+		values := strings.Fields(line)
+		if len(values) < 1 {
+			continue
+		}
+
+		t, err := strconv.ParseInt(values[1], 10, 64)
+		// err is not checked here because some value is string.
+		if strings.HasPrefix(line, "machdep.cpu.brand_string") {
+			c.ModelName = strings.Join(values[1:], " ")
+		} else if strings.HasPrefix(line, "machdep.cpu.family") {
+			c.Family = values[1]
+		} else if strings.HasPrefix(line, "machdep.cpu.model") {
+			c.Model = values[1]
+		} else if strings.HasPrefix(line, "machdep.cpu.stepping") {
+			if err != nil {
+				return ret, err
+			}
+			c.Stepping = int32(t)
+		} else if strings.HasPrefix(line, "machdep.cpu.features") {
+			for _, v := range values[1:] {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if strings.HasPrefix(line, "machdep.cpu.leaf7_features") {
+			for _, v := range values[1:] {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if strings.HasPrefix(line, "machdep.cpu.extfeatures") {
+			for _, v := range values[1:] {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if strings.HasPrefix(line, "machdep.cpu.core_count") {
+			if err != nil {
+				return ret, err
+			}
+			c.Cores = int32(t)
+		} else if strings.HasPrefix(line, "machdep.cpu.cache.size") {
+			if err != nil {
+				return ret, err
+			}
+			c.CacheSize = int32(t)
+		} else if strings.HasPrefix(line, "machdep.cpu.vendor") {
+			c.VendorID = values[1]
+		}
+	}
+
+	// Use the rated frequency of the CPU. This is a static value and does not
+	// account for low power or Turbo Boost modes.
+	out, err = invoke.CommandWithContext(ctx, sysctl, "hw.cpufrequency")
+	if err != nil {
+		return ret, err
+	}
+
+	values := strings.Fields(string(out))
+	hz, err := strconv.ParseFloat(values[1], 64)
+	if err != nil {
+		return ret, err
+	}
+	c.Mhz = hz / 1000000.0
+
+	return append(ret, c), nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_darwin_cgo.go

@@ -0,0 +1,111 @@
+// +build darwin
+// +build cgo
+
+package cpu
+
+/*
+#include <stdlib.h>
+#include <sys/sysctl.h>
+#include <sys/mount.h>
+#include <mach/mach_init.h>
+#include <mach/mach_host.h>
+#include <mach/host_info.h>
+#if TARGET_OS_MAC
+#include <libproc.h>
+#endif
+#include <mach/processor_info.h>
+#include <mach/vm_map.h>
+*/
+import "C"
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"unsafe"
+)
+
+// these CPU times for darwin is borrowed from influxdb/telegraf.
+
+func perCPUTimes() ([]TimesStat, error) {
+	var (
+		count   C.mach_msg_type_number_t
+		cpuload *C.processor_cpu_load_info_data_t
+		ncpu    C.natural_t
+	)
+
+	status := C.host_processor_info(C.host_t(C.mach_host_self()),
+		C.PROCESSOR_CPU_LOAD_INFO,
+		&ncpu,
+		(*C.processor_info_array_t)(unsafe.Pointer(&cpuload)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return nil, fmt.Errorf("host_processor_info error=%d", status)
+	}
+
+	// jump through some cgo casting hoops and ensure we properly free
+	// the memory that cpuload points to
+	target := C.vm_map_t(C.mach_task_self_)
+	address := C.vm_address_t(uintptr(unsafe.Pointer(cpuload)))
+	defer C.vm_deallocate(target, address, C.vm_size_t(ncpu))
+
+	// the body of struct processor_cpu_load_info
+	// aka processor_cpu_load_info_data_t
+	var cpu_ticks [C.CPU_STATE_MAX]uint32
+
+	// copy the cpuload array to a []byte buffer
+	// where we can binary.Read the data
+	size := int(ncpu) * binary.Size(cpu_ticks)
+	buf := (*[1 << 30]byte)(unsafe.Pointer(cpuload))[:size:size]
+
+	bbuf := bytes.NewBuffer(buf)
+
+	var ret []TimesStat
+
+	for i := 0; i < int(ncpu); i++ {
+		err := binary.Read(bbuf, binary.LittleEndian, &cpu_ticks)
+		if err != nil {
+			return nil, err
+		}
+
+		c := TimesStat{
+			CPU:    fmt.Sprintf("cpu%d", i),
+			User:   float64(cpu_ticks[C.CPU_STATE_USER]) / ClocksPerSec,
+			System: float64(cpu_ticks[C.CPU_STATE_SYSTEM]) / ClocksPerSec,
+			Nice:   float64(cpu_ticks[C.CPU_STATE_NICE]) / ClocksPerSec,
+			Idle:   float64(cpu_ticks[C.CPU_STATE_IDLE]) / ClocksPerSec,
+		}
+
+		ret = append(ret, c)
+	}
+
+	return ret, nil
+}
+
+func allCPUTimes() ([]TimesStat, error) {
+	var count C.mach_msg_type_number_t
+	var cpuload C.host_cpu_load_info_data_t
+
+	count = C.HOST_CPU_LOAD_INFO_COUNT
+
+	status := C.host_statistics(C.host_t(C.mach_host_self()),
+		C.HOST_CPU_LOAD_INFO,
+		C.host_info_t(unsafe.Pointer(&cpuload)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return nil, fmt.Errorf("host_statistics error=%d", status)
+	}
+
+	c := TimesStat{
+		CPU:    "cpu-total",
+		User:   float64(cpuload.cpu_ticks[C.CPU_STATE_USER]) / ClocksPerSec,
+		System: float64(cpuload.cpu_ticks[C.CPU_STATE_SYSTEM]) / ClocksPerSec,
+		Nice:   float64(cpuload.cpu_ticks[C.CPU_STATE_NICE]) / ClocksPerSec,
+		Idle:   float64(cpuload.cpu_ticks[C.CPU_STATE_IDLE]) / ClocksPerSec,
+	}
+
+	return []TimesStat{c}, nil
+
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_darwin_nocgo.go

@@ -0,0 +1,14 @@
+// +build darwin
+// +build !cgo
+
+package cpu
+
+import "github.com/shirou/gopsutil/internal/common"
+
+func perCPUTimes() ([]TimesStat, error) {
+	return []TimesStat{}, common.ErrNotImplementedError
+}
+
+func allCPUTimes() ([]TimesStat, error) {
+	return []TimesStat{}, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_fallback.go

@@ -0,0 +1,25 @@
+// +build !darwin,!linux,!freebsd,!openbsd,!solaris,!windows
+
+package cpu
+
+import (
+	"context"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	return []TimesStat{}, common.ErrNotImplementedError
+}
+
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	return []InfoStat{}, common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd.go

@@ -0,0 +1,168 @@
+package cpu
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+var ClocksPerSec = float64(128)
+var cpuMatch = regexp.MustCompile(`^CPU:`)
+var originMatch = regexp.MustCompile(`Origin\s*=\s*"(.+)"\s+Id\s*=\s*(.+)\s+Family\s*=\s*(.+)\s+Model\s*=\s*(.+)\s+Stepping\s*=\s*(.+)`)
+var featuresMatch = regexp.MustCompile(`Features=.+<(.+)>`)
+var featuresMatch2 = regexp.MustCompile(`Features2=[a-f\dx]+<(.+)>`)
+var cpuEnd = regexp.MustCompile(`^Trying to mount root`)
+var cpuCores = regexp.MustCompile(`FreeBSD/SMP: (\d*) package\(s\) x (\d*) core\(s\)`)
+var cpuTimesSize int
+var emptyTimes cpuTimes
+
+func init() {
+	getconf, err := exec.LookPath("/usr/bin/getconf")
+	if err != nil {
+		return
+	}
+	out, err := invoke.Command(getconf, "CLK_TCK")
+	// ignore errors
+	if err == nil {
+		i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
+		if err == nil {
+			ClocksPerSec = float64(i)
+		}
+	}
+}
+
+func timeStat(name string, t *cpuTimes) *TimesStat {
+	return &TimesStat{
+		User:   float64(t.User) / ClocksPerSec,
+		Nice:   float64(t.Nice) / ClocksPerSec,
+		System: float64(t.Sys) / ClocksPerSec,
+		Idle:   float64(t.Idle) / ClocksPerSec,
+		Irq:    float64(t.Intr) / ClocksPerSec,
+		CPU:    name,
+	}
+}
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	if percpu {
+		buf, err := unix.SysctlRaw("kern.cp_times")
+		if err != nil {
+			return nil, err
+		}
+
+		// We can't do this in init due to the conflict with cpu.init()
+		if cpuTimesSize == 0 {
+			cpuTimesSize = int(reflect.TypeOf(cpuTimes{}).Size())
+		}
+
+		ncpus := len(buf) / cpuTimesSize
+		ret := make([]TimesStat, 0, ncpus)
+		for i := 0; i < ncpus; i++ {
+			times := (*cpuTimes)(unsafe.Pointer(&buf[i*cpuTimesSize]))
+			if *times == emptyTimes {
+				// CPU not present
+				continue
+			}
+			ret = append(ret, *timeStat(fmt.Sprintf("cpu%d", len(ret)), times))
+		}
+		return ret, nil
+	}
+
+	buf, err := unix.SysctlRaw("kern.cp_time")
+	if err != nil {
+		return nil, err
+	}
+
+	times := (*cpuTimes)(unsafe.Pointer(&buf[0]))
+	return []TimesStat{*timeStat("cpu-total", times)}, nil
+}
+
+// Returns only one InfoStat on FreeBSD.  The information regarding core
+// count, however is accurate and it is assumed that all InfoStat attributes
+// are the same across CPUs.
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	const dmesgBoot = "/var/run/dmesg.boot"
+
+	c, num, err := parseDmesgBoot(dmesgBoot)
+	if err != nil {
+		return nil, err
+	}
+
+	var u32 uint32
+	if u32, err = unix.SysctlUint32("hw.clockrate"); err != nil {
+		return nil, err
+	}
+	c.Mhz = float64(u32)
+
+	if u32, err = unix.SysctlUint32("hw.ncpu"); err != nil {
+		return nil, err
+	}
+	c.Cores = int32(u32)
+
+	if c.ModelName, err = unix.Sysctl("hw.model"); err != nil {
+		return nil, err
+	}
+
+	ret := make([]InfoStat, num)
+	for i := 0; i < num; i++ {
+		ret[i] = c
+	}
+
+	return ret, nil
+}
+
+func parseDmesgBoot(fileName string) (InfoStat, int, error) {
+	c := InfoStat{}
+	lines, _ := common.ReadLines(fileName)
+	cpuNum := 1 // default cpu num is 1
+	for _, line := range lines {
+		if matches := cpuEnd.FindStringSubmatch(line); matches != nil {
+			break
+		} else if matches := originMatch.FindStringSubmatch(line); matches != nil {
+			c.VendorID = matches[1]
+			c.Family = matches[3]
+			c.Model = matches[4]
+			t, err := strconv.ParseInt(matches[5], 10, 32)
+			if err != nil {
+				return c, 0, fmt.Errorf("unable to parse FreeBSD CPU stepping information from %q: %v", line, err)
+			}
+			c.Stepping = int32(t)
+		} else if matches := featuresMatch.FindStringSubmatch(line); matches != nil {
+			for _, v := range strings.Split(matches[1], ",") {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if matches := featuresMatch2.FindStringSubmatch(line); matches != nil {
+			for _, v := range strings.Split(matches[1], ",") {
+				c.Flags = append(c.Flags, strings.ToLower(v))
+			}
+		} else if matches := cpuCores.FindStringSubmatch(line); matches != nil {
+			t, err := strconv.ParseInt(matches[1], 10, 32)
+			if err != nil {
+				return c, 0, fmt.Errorf("unable to parse FreeBSD CPU Nums from %q: %v", line, err)
+			}
+			cpuNum = int(t)
+			t2, err := strconv.ParseInt(matches[2], 10, 32)
+			if err != nil {
+				return c, 0, fmt.Errorf("unable to parse FreeBSD CPU cores from %q: %v", line, err)
+			}
+			c.Cores = int32(t2)
+		}
+	}
+
+	return c, cpuNum, nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_386.go

@@ -0,0 +1,9 @@
+package cpu
+
+type cpuTimes struct {
+	User uint32
+	Nice uint32
+	Sys  uint32
+	Intr uint32
+	Idle uint32
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_amd64.go

@@ -0,0 +1,9 @@
+package cpu
+
+type cpuTimes struct {
+	User uint64
+	Nice uint64
+	Sys  uint64
+	Intr uint64
+	Idle uint64
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_linux.go

@@ -0,0 +1,285 @@
+// +build linux
+
+package cpu
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var cpu_tick = float64(100)
+
+func init() {
+	getconf, err := exec.LookPath("/usr/bin/getconf")
+	if err != nil {
+		return
+	}
+	out, err := invoke.CommandWithContext(context.Background(), getconf, "CLK_TCK")
+	// ignore errors
+	if err == nil {
+		i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
+		if err == nil {
+			cpu_tick = float64(i)
+		}
+	}
+}
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	filename := common.HostProc("stat")
+	var lines = []string{}
+	if percpu {
+		statlines, err := common.ReadLines(filename)
+		if err != nil || len(statlines) < 2 {
+			return []TimesStat{}, nil
+		}
+		for _, line := range statlines[1:] {
+			if !strings.HasPrefix(line, "cpu") {
+				break
+			}
+			lines = append(lines, line)
+		}
+	} else {
+		lines, _ = common.ReadLinesOffsetN(filename, 0, 1)
+	}
+
+	ret := make([]TimesStat, 0, len(lines))
+
+	for _, line := range lines {
+		ct, err := parseStatLine(line)
+		if err != nil {
+			continue
+		}
+		ret = append(ret, *ct)
+
+	}
+	return ret, nil
+}
+
+func sysCPUPath(cpu int32, relPath string) string {
+	return common.HostSys(fmt.Sprintf("devices/system/cpu/cpu%d", cpu), relPath)
+}
+
+func finishCPUInfo(c *InfoStat) error {
+	var lines []string
+	var err error
+	var value float64
+
+	if len(c.CoreID) == 0 {
+		lines, err = common.ReadLines(sysCPUPath(c.CPU, "topology/core_id"))
+		if err == nil {
+			c.CoreID = lines[0]
+		}
+	}
+
+	// override the value of c.Mhz with cpufreq/cpuinfo_max_freq regardless
+	// of the value from /proc/cpuinfo because we want to report the maximum
+	// clock-speed of the CPU for c.Mhz, matching the behaviour of Windows
+	lines, err = common.ReadLines(sysCPUPath(c.CPU, "cpufreq/cpuinfo_max_freq"))
+	// if we encounter errors below such as there are no cpuinfo_max_freq file,
+	// we just ignore. so let Mhz is 0.
+	if err != nil {
+		return nil
+	}
+	value, err = strconv.ParseFloat(lines[0], 64)
+	if err != nil {
+		return nil
+	}
+	c.Mhz = value / 1000.0 // value is in kHz
+	if c.Mhz > 9999 {
+		c.Mhz = c.Mhz / 1000.0 // value in Hz
+	}
+	return nil
+}
+
+// CPUInfo on linux will return 1 item per physical thread.
+//
+// CPUs have three levels of counting: sockets, cores, threads.
+// Cores with HyperThreading count as having 2 threads per core.
+// Sockets often come with many physical CPU cores.
+// For example a single socket board with two cores each with HT will
+// return 4 CPUInfoStat structs on Linux and the "Cores" field set to 1.
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	filename := common.HostProc("cpuinfo")
+	lines, _ := common.ReadLines(filename)
+
+	var ret []InfoStat
+	var processorName string
+
+	c := InfoStat{CPU: -1, Cores: 1}
+	for _, line := range lines {
+		fields := strings.Split(line, ":")
+		if len(fields) < 2 {
+			continue
+		}
+		key := strings.TrimSpace(fields[0])
+		value := strings.TrimSpace(fields[1])
+
+		switch key {
+		case "Processor":
+			processorName = value
+		case "processor":
+			if c.CPU >= 0 {
+				err := finishCPUInfo(&c)
+				if err != nil {
+					return ret, err
+				}
+				ret = append(ret, c)
+			}
+			c = InfoStat{Cores: 1, ModelName: processorName}
+			t, err := strconv.ParseInt(value, 10, 64)
+			if err != nil {
+				return ret, err
+			}
+			c.CPU = int32(t)
+		case "vendorId", "vendor_id":
+			c.VendorID = value
+		case "cpu family":
+			c.Family = value
+		case "model":
+			c.Model = value
+		case "model name", "cpu":
+			c.ModelName = value
+			if strings.Contains(value, "POWER8") ||
+				strings.Contains(value, "POWER7") {
+				c.Model = strings.Split(value, " ")[0]
+				c.Family = "POWER"
+				c.VendorID = "IBM"
+			}
+		case "stepping", "revision":
+			val := value
+
+			if key == "revision" {
+				val = strings.Split(value, ".")[0]
+			}
+
+			t, err := strconv.ParseInt(val, 10, 64)
+			if err != nil {
+				return ret, err
+			}
+			c.Stepping = int32(t)
+		case "cpu MHz", "clock":
+			// treat this as the fallback value, thus we ignore error
+			if t, err := strconv.ParseFloat(strings.Replace(value, "MHz", "", 1), 64); err == nil {
+				c.Mhz = t
+			}
+		case "cache size":
+			t, err := strconv.ParseInt(strings.Replace(value, " KB", "", 1), 10, 64)
+			if err != nil {
+				return ret, err
+			}
+			c.CacheSize = int32(t)
+		case "physical id":
+			c.PhysicalID = value
+		case "core id":
+			c.CoreID = value
+		case "flags", "Features":
+			c.Flags = strings.FieldsFunc(value, func(r rune) bool {
+				return r == ',' || r == ' '
+			})
+		case "microcode":
+			c.Microcode = value
+		}
+	}
+	if c.CPU >= 0 {
+		err := finishCPUInfo(&c)
+		if err != nil {
+			return ret, err
+		}
+		ret = append(ret, c)
+	}
+	return ret, nil
+}
+
+func parseStatLine(line string) (*TimesStat, error) {
+	fields := strings.Fields(line)
+
+	if len(fields) == 0 {
+		return nil, errors.New("stat does not contain cpu info")
+	}
+
+	if strings.HasPrefix(fields[0], "cpu") == false {
+		//		return CPUTimesStat{}, e
+		return nil, errors.New("not contain cpu")
+	}
+
+	cpu := fields[0]
+	if cpu == "cpu" {
+		cpu = "cpu-total"
+	}
+	user, err := strconv.ParseFloat(fields[1], 64)
+	if err != nil {
+		return nil, err
+	}
+	nice, err := strconv.ParseFloat(fields[2], 64)
+	if err != nil {
+		return nil, err
+	}
+	system, err := strconv.ParseFloat(fields[3], 64)
+	if err != nil {
+		return nil, err
+	}
+	idle, err := strconv.ParseFloat(fields[4], 64)
+	if err != nil {
+		return nil, err
+	}
+	iowait, err := strconv.ParseFloat(fields[5], 64)
+	if err != nil {
+		return nil, err
+	}
+	irq, err := strconv.ParseFloat(fields[6], 64)
+	if err != nil {
+		return nil, err
+	}
+	softirq, err := strconv.ParseFloat(fields[7], 64)
+	if err != nil {
+		return nil, err
+	}
+
+	ct := &TimesStat{
+		CPU:     cpu,
+		User:    float64(user) / cpu_tick,
+		Nice:    float64(nice) / cpu_tick,
+		System:  float64(system) / cpu_tick,
+		Idle:    float64(idle) / cpu_tick,
+		Iowait:  float64(iowait) / cpu_tick,
+		Irq:     float64(irq) / cpu_tick,
+		Softirq: float64(softirq) / cpu_tick,
+	}
+	if len(fields) > 8 { // Linux >= 2.6.11
+		steal, err := strconv.ParseFloat(fields[8], 64)
+		if err != nil {
+			return nil, err
+		}
+		ct.Steal = float64(steal) / cpu_tick
+	}
+	if len(fields) > 9 { // Linux >= 2.6.24
+		guest, err := strconv.ParseFloat(fields[9], 64)
+		if err != nil {
+			return nil, err
+		}
+		ct.Guest = float64(guest) / cpu_tick
+	}
+	if len(fields) > 10 { // Linux >= 3.2.0
+		guestNice, err := strconv.ParseFloat(fields[10], 64)
+		if err != nil {
+			return nil, err
+		}
+		ct.GuestNice = float64(guestNice) / cpu_tick
+	}
+
+	return ct, nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_openbsd.go

@@ -0,0 +1,119 @@
+// +build openbsd
+
+package cpu
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/unix"
+)
+
+// sys/sched.h
+const (
+	CPUser    = 0
+	CPNice    = 1
+	CPSys     = 2
+	CPIntr    = 3
+	CPIdle    = 4
+	CPUStates = 5
+)
+
+// sys/sysctl.h
+const (
+	CTLKern     = 1  // "high kernel": proc, limits
+	KernCptime  = 40 // KERN_CPTIME
+	KernCptime2 = 71 // KERN_CPTIME2
+)
+
+var ClocksPerSec = float64(128)
+
+func init() {
+	getconf, err := exec.LookPath("/usr/bin/getconf")
+	if err != nil {
+		return
+	}
+	out, err := invoke.Command(getconf, "CLK_TCK")
+	// ignore errors
+	if err == nil {
+		i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
+		if err == nil {
+			ClocksPerSec = float64(i)
+		}
+	}
+}
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	var ret []TimesStat
+
+	var ncpu int
+	if percpu {
+		ncpu, _ = Counts(true)
+	} else {
+		ncpu = 1
+	}
+
+	for i := 0; i < ncpu; i++ {
+		var cpuTimes [CPUStates]int64
+		var mib []int32
+		if percpu {
+			mib = []int32{CTLKern, KernCptime}
+		} else {
+			mib = []int32{CTLKern, KernCptime2, int32(i)}
+		}
+		buf, _, err := common.CallSyscall(mib)
+		if err != nil {
+			return ret, err
+		}
+
+		br := bytes.NewReader(buf)
+		err = binary.Read(br, binary.LittleEndian, &cpuTimes)
+		if err != nil {
+			return ret, err
+		}
+		c := TimesStat{
+			User:   float64(cpuTimes[CPUser]) / ClocksPerSec,
+			Nice:   float64(cpuTimes[CPNice]) / ClocksPerSec,
+			System: float64(cpuTimes[CPSys]) / ClocksPerSec,
+			Idle:   float64(cpuTimes[CPIdle]) / ClocksPerSec,
+			Irq:    float64(cpuTimes[CPIntr]) / ClocksPerSec,
+		}
+		if !percpu {
+			c.CPU = "cpu-total"
+		} else {
+			c.CPU = fmt.Sprintf("cpu%d", i)
+		}
+		ret = append(ret, c)
+	}
+
+	return ret, nil
+}
+
+// Returns only one (minimal) CPUInfoStat on OpenBSD
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	var ret []InfoStat
+
+	c := InfoStat{}
+
+	v, err := unix.Sysctl("hw.model")
+	if err != nil {
+		return nil, err
+	}
+	c.ModelName = v
+
+	return append(ret, c), nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_solaris.go

@@ -0,0 +1,198 @@
+package cpu
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+var ClocksPerSec = float64(128)
+
+func init() {
+	getconf, err := exec.LookPath("/usr/bin/getconf")
+	if err != nil {
+		return
+	}
+	out, err := invoke.Command(getconf, "CLK_TCK")
+	// ignore errors
+	if err == nil {
+		i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64)
+		if err == nil {
+			ClocksPerSec = float64(i)
+		}
+	}
+}
+
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	return []TimesStat{}, common.ErrNotImplementedError
+}
+
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	psrInfo, err := exec.LookPath("/usr/sbin/psrinfo")
+	if err != nil {
+		return nil, fmt.Errorf("cannot find psrinfo: %s", err)
+	}
+	psrInfoOut, err := invoke.CommandWithContext(ctx, psrInfo, "-p", "-v")
+	if err != nil {
+		return nil, fmt.Errorf("cannot execute psrinfo: %s", err)
+	}
+
+	isaInfo, err := exec.LookPath("/usr/bin/isainfo")
+	if err != nil {
+		return nil, fmt.Errorf("cannot find isainfo: %s", err)
+	}
+	isaInfoOut, err := invoke.CommandWithContext(ctx, isaInfo, "-b", "-v")
+	if err != nil {
+		return nil, fmt.Errorf("cannot execute isainfo: %s", err)
+	}
+
+	procs, err := parseProcessorInfo(string(psrInfoOut))
+	if err != nil {
+		return nil, fmt.Errorf("error parsing psrinfo output: %s", err)
+	}
+
+	flags, err := parseISAInfo(string(isaInfoOut))
+	if err != nil {
+		return nil, fmt.Errorf("error parsing isainfo output: %s", err)
+	}
+
+	result := make([]InfoStat, 0, len(flags))
+	for _, proc := range procs {
+		procWithFlags := proc
+		procWithFlags.Flags = flags
+		result = append(result, procWithFlags)
+	}
+
+	return result, nil
+}
+
+var flagsMatch = regexp.MustCompile(`[\w\.]+`)
+
+func parseISAInfo(cmdOutput string) ([]string, error) {
+	words := flagsMatch.FindAllString(cmdOutput, -1)
+
+	// Sanity check the output
+	if len(words) < 4 || words[1] != "bit" || words[3] != "applications" {
+		return nil, errors.New("attempted to parse invalid isainfo output")
+	}
+
+	flags := make([]string, len(words)-4)
+	for i, val := range words[4:] {
+		flags[i] = val
+	}
+	sort.Strings(flags)
+
+	return flags, nil
+}
+
+var psrInfoMatch = regexp.MustCompile(`The physical processor has (?:([\d]+) virtual processor \(([\d]+)\)|([\d]+) cores and ([\d]+) virtual processors[^\n]+)\n(?:\s+ The core has.+\n)*\s+.+ \((\w+) ([\S]+) family (.+) model (.+) step (.+) clock (.+) MHz\)\n[\s]*(.*)`)
+
+const (
+	psrNumCoresOffset   = 1
+	psrNumCoresHTOffset = 3
+	psrNumHTOffset      = 4
+	psrVendorIDOffset   = 5
+	psrFamilyOffset     = 7
+	psrModelOffset      = 8
+	psrStepOffset       = 9
+	psrClockOffset      = 10
+	psrModelNameOffset  = 11
+)
+
+func parseProcessorInfo(cmdOutput string) ([]InfoStat, error) {
+	matches := psrInfoMatch.FindAllStringSubmatch(cmdOutput, -1)
+
+	var infoStatCount int32
+	result := make([]InfoStat, 0, len(matches))
+	for physicalIndex, physicalCPU := range matches {
+		var step int32
+		var clock float64
+
+		if physicalCPU[psrStepOffset] != "" {
+			stepParsed, err := strconv.ParseInt(physicalCPU[psrStepOffset], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for step as 32-bit integer: %s", physicalCPU[9], err)
+			}
+			step = int32(stepParsed)
+		}
+
+		if physicalCPU[psrClockOffset] != "" {
+			clockParsed, err := strconv.ParseInt(physicalCPU[psrClockOffset], 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for clock as 32-bit integer: %s", physicalCPU[10], err)
+			}
+			clock = float64(clockParsed)
+		}
+
+		var err error
+		var numCores int64
+		var numHT int64
+		switch {
+		case physicalCPU[psrNumCoresOffset] != "":
+			numCores, err = strconv.ParseInt(physicalCPU[psrNumCoresOffset], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for core count as 32-bit integer: %s", physicalCPU[1], err)
+			}
+
+			for i := 0; i < int(numCores); i++ {
+				result = append(result, InfoStat{
+					CPU:        infoStatCount,
+					PhysicalID: strconv.Itoa(physicalIndex),
+					CoreID:     strconv.Itoa(i),
+					Cores:      1,
+					VendorID:   physicalCPU[psrVendorIDOffset],
+					ModelName:  physicalCPU[psrModelNameOffset],
+					Family:     physicalCPU[psrFamilyOffset],
+					Model:      physicalCPU[psrModelOffset],
+					Stepping:   step,
+					Mhz:        clock,
+				})
+				infoStatCount++
+			}
+		case physicalCPU[psrNumCoresHTOffset] != "":
+			numCores, err = strconv.ParseInt(physicalCPU[psrNumCoresHTOffset], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for core count as 32-bit integer: %s", physicalCPU[3], err)
+			}
+
+			numHT, err = strconv.ParseInt(physicalCPU[psrNumHTOffset], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("cannot parse value %q for hyperthread count as 32-bit integer: %s", physicalCPU[4], err)
+			}
+
+			for i := 0; i < int(numCores); i++ {
+				result = append(result, InfoStat{
+					CPU:        infoStatCount,
+					PhysicalID: strconv.Itoa(physicalIndex),
+					CoreID:     strconv.Itoa(i),
+					Cores:      int32(numHT) / int32(numCores),
+					VendorID:   physicalCPU[psrVendorIDOffset],
+					ModelName:  physicalCPU[psrModelNameOffset],
+					Family:     physicalCPU[psrFamilyOffset],
+					Model:      physicalCPU[psrModelOffset],
+					Stepping:   step,
+					Mhz:        clock,
+				})
+				infoStatCount++
+			}
+		default:
+			return nil, errors.New("values for cores with and without hyperthreading are both set")
+		}
+	}
+	return result, nil
+}

vendor/github.com/shirou/gopsutil/cpu/cpu_windows.go

@@ -0,0 +1,172 @@
+// +build windows
+
+package cpu
+
+import (
+	"context"
+	"fmt"
+	"unsafe"
+
+	"github.com/StackExchange/wmi"
+	"github.com/shirou/gopsutil/internal/common"
+	"golang.org/x/sys/windows"
+)
+
+type Win32_Processor struct {
+	LoadPercentage            *uint16
+	Family                    uint16
+	Manufacturer              string
+	Name                      string
+	NumberOfLogicalProcessors uint32
+	ProcessorID               *string
+	Stepping                  *string
+	MaxClockSpeed             uint32
+}
+
+// Win32_PerfFormattedData_Counters_ProcessorInformation stores instance value of the perf counters
+type Win32_PerfFormattedData_Counters_ProcessorInformation struct {
+	Name                  string
+	PercentDPCTime        uint64
+	PercentIdleTime       uint64
+	PercentUserTime       uint64
+	PercentProcessorTime  uint64
+	PercentInterruptTime  uint64
+	PercentPriorityTime   uint64
+	PercentPrivilegedTime uint64
+	InterruptsPerSec      uint32
+	ProcessorFrequency    uint32
+	DPCRate               uint32
+}
+
+// Win32_PerfFormattedData_PerfOS_System struct to have count of processes and processor queue length
+type Win32_PerfFormattedData_PerfOS_System struct {
+	Processes            uint32
+	ProcessorQueueLength uint32
+}
+
+// Times returns times stat per cpu and combined for all CPUs
+func Times(percpu bool) ([]TimesStat, error) {
+	return TimesWithContext(context.Background(), percpu)
+}
+
+func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
+	if percpu {
+		return perCPUTimes()
+	}
+
+	var ret []TimesStat
+	var lpIdleTime common.FILETIME
+	var lpKernelTime common.FILETIME
+	var lpUserTime common.FILETIME
+	r, _, _ := common.ProcGetSystemTimes.Call(
+		uintptr(unsafe.Pointer(&lpIdleTime)),
+		uintptr(unsafe.Pointer(&lpKernelTime)),
+		uintptr(unsafe.Pointer(&lpUserTime)))
+	if r == 0 {
+		return ret, windows.GetLastError()
+	}
+
+	LOT := float64(0.0000001)
+	HIT := (LOT * 4294967296.0)
+	idle := ((HIT * float64(lpIdleTime.DwHighDateTime)) + (LOT * float64(lpIdleTime.DwLowDateTime)))
+	user := ((HIT * float64(lpUserTime.DwHighDateTime)) + (LOT * float64(lpUserTime.DwLowDateTime)))
+	kernel := ((HIT * float64(lpKernelTime.DwHighDateTime)) + (LOT * float64(lpKernelTime.DwLowDateTime)))
+	system := (kernel - idle)
+
+	ret = append(ret, TimesStat{
+		CPU:    "cpu-total",
+		Idle:   float64(idle),
+		User:   float64(user),
+		System: float64(system),
+	})
+	return ret, nil
+}
+
+func Info() ([]InfoStat, error) {
+	return InfoWithContext(context.Background())
+}
+
+func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
+	var ret []InfoStat
+	var dst []Win32_Processor
+	q := wmi.CreateQuery(&dst, "")
+	if err := common.WMIQueryWithContext(ctx, q, &dst); err != nil {
+		return ret, err
+	}
+
+	var procID string
+	for i, l := range dst {
+		procID = ""
+		if l.ProcessorID != nil {
+			procID = *l.ProcessorID
+		}
+
+		cpu := InfoStat{
+			CPU:        int32(i),
+			Family:     fmt.Sprintf("%d", l.Family),
+			VendorID:   l.Manufacturer,
+			ModelName:  l.Name,
+			Cores:      int32(l.NumberOfLogicalProcessors),
+			PhysicalID: procID,
+			Mhz:        float64(l.MaxClockSpeed),
+			Flags:      []string{},
+		}
+		ret = append(ret, cpu)
+	}
+
+	return ret, nil
+}
+
+// PerfInfo returns the performance counter's instance value for ProcessorInformation.
+// Name property is the key by which overall, per cpu and per core metric is known.
+func PerfInfo() ([]Win32_PerfFormattedData_Counters_ProcessorInformation, error) {
+	return PerfInfoWithContext(context.Background())
+}
+
+func PerfInfoWithContext(ctx context.Context) ([]Win32_PerfFormattedData_Counters_ProcessorInformation, error) {
+	var ret []Win32_PerfFormattedData_Counters_ProcessorInformation
+
+	q := wmi.CreateQuery(&ret, "")
+	err := common.WMIQueryWithContext(ctx, q, &ret)
+	if err != nil {
+		return []Win32_PerfFormattedData_Counters_ProcessorInformation{}, err
+	}
+
+	return ret, err
+}
+
+// ProcInfo returns processes count and processor queue length in the system.
+// There is a single queue for processor even on multiprocessors systems.
+func ProcInfo() ([]Win32_PerfFormattedData_PerfOS_System, error) {
+	return ProcInfoWithContext(context.Background())
+}
+
+func ProcInfoWithContext(ctx context.Context) ([]Win32_PerfFormattedData_PerfOS_System, error) {
+	var ret []Win32_PerfFormattedData_PerfOS_System
+	q := wmi.CreateQuery(&ret, "")
+	err := common.WMIQueryWithContext(ctx, q, &ret)
+	if err != nil {
+		return []Win32_PerfFormattedData_PerfOS_System{}, err
+	}
+	return ret, err
+}
+
+// perCPUTimes returns times stat per cpu, per core and overall for all CPUs
+func perCPUTimes() ([]TimesStat, error) {
+	var ret []TimesStat
+	stats, err := PerfInfo()
+	if err != nil {
+		return nil, err
+	}
+	for _, v := range stats {
+		c := TimesStat{
+			CPU:    v.Name,
+			User:   float64(v.PercentUserTime),
+			System: float64(v.PercentPrivilegedTime),
+			Idle:   float64(v.PercentIdleTime),
+			Irq:    float64(v.PercentInterruptTime),
+		}
+		ret = append(ret, c)
+	}
+	return ret, nil
+}