package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"os"
"strconv"
"strings"
"time"
)
type SchedStat struct {
Pid int `json:"pid"`
RunTicks int `json:"run_ticks"`
WaitTicks int `json:"wait_ticks"`
SlicesRan int `json:"ran_slices"`
AverageRun float64 `json:"avg_run"`
AverageWait float64 `json:"avg_wait"`
}
func usage() {
fmt.Fprintf(os.Stderr, "usage: %s <pid>\n", os.Args[0])
}
func main() {
if len(os.Args) == 1 {
usage()
os.Exit(1)
}
input := os.Args[1]
pid, err := strconv.Atoi(input)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to convert %s to a PID: %v", input, err)
os.Exit(1)
}
p := Proc{
PID: pid,
}
oran := 0
owait_ticks := 0
orun_ticks := 0
for {
stat, err := p.SchedStat()
if err != nil {
fmt.Fprintf(os.Stderr, "failed to get schedstat for %d: %v\n", p.PID, err)
os.Exit(1)
}
diff := stat.SlicesRan - oran
var avgrun, avgwait float64
if diff > 0 {
avgrun = float64((stat.RunTicks - orun_ticks) / diff)
avgwait = float64((stat.WaitTicks - owait_ticks) / diff)
} else {
avgrun = 0
avgwait = 0
}
stat.AverageRun = avgrun
stat.AverageWait = avgwait
out, err := json.Marshal(stat)
if err != nil {
fmt.Fprintln(err)
os.Exit(1)
}
fmt.Println(string(out))
oran = stat.SlicesRan
orun_ticks = stat.RunTicks
owait_ticks = stat.WaitTicks
time.Sleep(5 * time.Second)
}
}
// This the the path that contains the scheduler statistics.
// Note that they are not populated unless the value for
// /proc/sys/kernel/sched_schedstats is 1
const procSchedStat = "/proc/schedstat"
var idleness = []string{"idle", "busy", "newlyIdle"}
type ProcSchedStat struct {
RunTicks int `json:"run_ticks"`
WaitTicks int `json:"wait_ticks"`
SlicesRan int `json:"ran_slices"`
AverageRun float64 `json:"avg_run"`
AverageWait float64 `json:"avg_wait"`
}
// SchedCPUStat contains the load balancer statistics for a CPU.
type SchedCPUStat struct {
YieldCount uint64 `json:"yield_count"`
SchedulerCount uint64 `json:"sched_count"`
SchedulerGoIdle uint64 `json:"sched_go_idle"`
TryToWakeUp uint64 `json:"try_to_wake"`
TryToWakeUpLocal uint64 `json:"try_to_wake_local"`
Running uint64 `json:"running"`
Waiting uint64 `json:"waiting"`
Slices uint64 `json:"slices"`
Domains map[string]SchedDomain `json:"domains"`
}
// SchedLoadBalance contains the load balancer statistics for a domain
// in a given domain.
type SchedLoadBalance struct {
LBCount uint64 `json:"lb_count"`
LBBalanced uint64 `json:"lb_balanced"`
LBFailed uint64 `json:"lb_failed"`
LBImbalanced uint64 `json:"lb_imbalanced"`
LBGained uint64 `json:"lb_gained"`
LBHotGain uint64 `json:"lb_hot_gain"`
LBNoBusyQueue uint64 `json:"lb_no_busy_queue"`
LBNoBusyGroup uint64 `json:"lb_no_busy_group"`
}
// SchedDomain contains the statistics for a domain.
type SchedDomain struct {
LoadBalancers map[string]SchedLoadBalance `json:"lbs"`
ActiveLoadBalanceCount uint64 `json:"active_lb_count"`
ActiveLoadBalanceFailed uint64 `json:"active_lb_failed"`
ActiveLoadBalancePushed uint64 `json:"active_lb_pushed"`
TryToWakeUpRemote uint64 `json:"try_to_wake_up_remote"`
TryToWakeUpMoveAffine uint64 `json:"try_to_wake_up_move_affine"`
TryToWakeUpMoveBalance uint64 `json:"try_to_wake_up_move_balance"`
}
// Proc provides information about a running process.
type Proc struct {
// The process ID.
PID int
}
// SchedStat returns scheduler statistics for the process.
// The information available are:
// 1. time spent on the cpu
// 2. time spent waiting on a runqueue
// 3. # of timeslices run on this cpu
//
func (p Proc) SchedStat() (ProcSchedStat, error) {
path := fmt.Sprintf("/proc/%d/schedstat", p.PID)
b, err := ioutil.ReadFile(path)
if err != nil {
return ProcSchedStat{}, err
}
content := string(b)
stats := strings.Fields(content)
run_ticks, err := strconv.Atoi(stats[0])
if err != nil {
return ProcSchedStat{}, err
}
wait_ticks, err := strconv.Atoi(stats[1])
if err != nil {
return ProcSchedStat{}, err
}
nran, err := strconv.Atoi(stats[2])
if err != nil {
return ProcSchedStat{}, err
}
stat := ProcSchedStat{
RunTicks: run_ticks,
WaitTicks: wait_ticks,
SlicesRan: nran,
}
return stat, nil
}
// ReadSchedstat returns statistics from the scheduler.
// Information about the statistics can be found at
// https://www.kernel.org/doc/html/latest/scheduler/sched-stats.html.
func ReadSchedStat() (map[string]SchedCPUStat, error) {
b, err := ioutil.ReadFile(procSchedStat)
if err != nil {
return nil, fmt.Errorf("procfs: failed to open %s: %v", procSchedStat, err)
}
content := string(b)
cpus := map[string]SchedCPUStat{}
lines := strings.Split(content, "\n")
var currentCpu string
// The first line is the version of the stats
// TODO(fcuny): we should check which version is used, because the
// format changes.
for _, line := range lines[2:] {
// The format is as follow:
// cpu<N> 1 2 3 4 5 6 7 8 9
// domain<N> <cpumask> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
if strings.HasPrefix(line, "cpu") {
// meaning of the fields: https://www.kernel.org/doc/html/latest/scheduler/sched-stats.html#cpu-statistics
fields := strings.Fields(line)
cpuStat := SchedCPUStat{
YieldCount: convertField(fields[1]),
SchedulerCount: convertField(fields[3]),
SchedulerGoIdle: convertField(fields[4]),
TryToWakeUp: convertField(fields[5]),
TryToWakeUpLocal: convertField(fields[6]),
Running: convertField(fields[7]),
Waiting: convertField(fields[8]),
Slices: convertField(fields[9]),
Domains: map[string]SchedDomain{},
}
currentCpu = fields[0]
cpus[currentCpu] = cpuStat
} else if strings.HasPrefix(line, "domain") {
// meaning of the fields: https://www.kernel.org/doc/html/latest/scheduler/sched-stats.html#domain-statistics
fields := strings.Fields(line)
i := 2
lbs := map[string]SchedLoadBalance{}
for _, idle := range idleness {
lb := SchedLoadBalance{
LBCount: convertField(fields[i]),
LBBalanced: convertField(fields[i+1]),
LBFailed: convertField(fields[i+2]),
LBImbalanced: convertField(fields[i+3]),
LBGained: convertField(fields[i+4]),
LBHotGain: convertField(fields[i+5]),
LBNoBusyQueue: convertField(fields[i+6]),
LBNoBusyGroup: convertField(fields[i+7]),
}
i = i + 8
lbs[idle] = lb
}
domain := SchedDomain{
LoadBalancers: lbs,
ActiveLoadBalanceCount: convertField(fields[26]),
ActiveLoadBalanceFailed: convertField(fields[27]),
ActiveLoadBalancePushed: convertField(fields[28]),
TryToWakeUpRemote: convertField(fields[35]),
TryToWakeUpMoveAffine: convertField(fields[36]),
TryToWakeUpMoveBalance: convertField(fields[37]),
}
c := cpus[currentCpu]
c.Domains[fields[0]] = domain
cpus[currentCpu] = c
}
}
return cpus, nil
}
func convertField(field string) uint64 {
val, err := strconv.ParseUint(field, 10, 64)
if err != nil {
return 0
}
return val
}
