183 lines
7.4 KiB
Go
183 lines
7.4 KiB
Go
package main
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// aCPUHog is a machine whose CPU is 75 % busy (1.5 of 2 CPUs) over a 2 s window: a unit, another unit,
|
|
// and a container, each with a known usage_usec delta, leaving part of the machine's busy time
|
|
// unaccounted — the shape of issue 739, where 750 % of 12 CPUs went to processes outside containers.
|
|
func aCPUHog(t *testing.T) *fake {
|
|
f := newFake(t)
|
|
f.file("/proc/stat", "cpu 0 0 0 0 0 0 0 0 0 0\ncpu0 0 0 0 0 0 0 0 0 0 0\ncpu1 0 0 0 0 0 0 0 0 0 0\nintr 1\n")
|
|
f.then("/proc/stat", "cpu 100 0 50 50 0 0 0 0 0 0\ncpu0 50 0 25 25 0 0 0 0 0 0\ncpu1 50 0 25 25 0 0 0 0 0 0\nintr 2\n")
|
|
|
|
zero := "usage_usec 0\nuser_usec 0\nsystem_usec 0\n"
|
|
cg := func(path string, usec int) {
|
|
f.file("/sys/fs/cgroup/"+path+"/cpu.stat", zero)
|
|
f.then("/sys/fs/cgroup/"+path+"/cpu.stat", "usage_usec "+itoa(usec)+"\nuser_usec "+itoa(usec)+"\nsystem_usec 0\n")
|
|
}
|
|
cg("system.slice/alpha.service", 1000000) // 50 % of one CPU over 2 s
|
|
cg("system.slice/beta.service", 400000) // 20 %
|
|
cg("system.slice/docker-"+store+".scope", 600000) // 30 %, named "cpu-hog" by the runtime
|
|
f.answers["docker ps --no-trunc --format {{.ID}}\t{{.Names}}"] = store + "\tcpu-hog\n"
|
|
return f
|
|
}
|
|
|
|
func TestCPUTopRanksUnitsAndContainersByCPUOverTheWindow(t *testing.T) {
|
|
f := aCPUHog(t)
|
|
out, err := tool(t, f.machine(), "cpu_top").Run(map[string]any{"seconds": 2.0})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m := out.(map[string]any)
|
|
if m["by"] != "unit" || f.waited != 2*time.Second {
|
|
t.Errorf("the default: %+v, waited %s", m, f.waited)
|
|
}
|
|
cpu := m["cpu"].(MachineCPU)
|
|
if cpu.CPUs != 2 || cpu.BusyPct != 75 || cpu.CPUsBusy != 1.5 {
|
|
t.Errorf("machine cpu %+v", cpu)
|
|
}
|
|
top := m["top"].([]CPUUsage)
|
|
if len(top) != 3 {
|
|
t.Fatalf("three units moved: %+v", top)
|
|
}
|
|
if top[0].Unit != "alpha.service" || top[0].CPUPct != 50 || top[0].SharePct != 33.3 {
|
|
t.Errorf("busiest first: %+v", top[0])
|
|
}
|
|
if top[1].Container != "cpu-hog" || top[1].CPUPct != 30 || top[1].SharePct != 20 {
|
|
t.Errorf("the container, named by the runtime: %+v", top[1])
|
|
}
|
|
if top[2].Unit != "beta.service" || top[2].CPUPct != 20 || top[2].SharePct != 13.3 {
|
|
t.Errorf("the least busy: %+v", top[2])
|
|
}
|
|
if m["unaccounted_pct"] != 33.3 {
|
|
t.Errorf("unaccounted: %+v (machine busy 150%% of one CPU, units sum to 100%%, 50%% of 150%% left over)", m["unaccounted_pct"])
|
|
}
|
|
}
|
|
|
|
func TestCPUTopByContainerNamesOnlyContainers(t *testing.T) {
|
|
out, err := tool(t, aCPUHog(t).machine(), "cpu_top").Run(map[string]any{"by": "container", "seconds": 2.0})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
top := out.(map[string]any)["top"].([]CPUUsage)
|
|
if len(top) != 1 || top[0].Container != "cpu-hog" || top[0].Unit != "" || top[0].CPUPct != 30 {
|
|
t.Errorf("by container: %+v", top)
|
|
}
|
|
if _, err := tool(t, aCPUHog(t).machine(), "cpu_top").Run(map[string]any{"by": "process"}); err == nil {
|
|
t.Error("by=process was accepted; cpu_top only ranks units and containers")
|
|
}
|
|
}
|
|
|
|
func TestCPUTopLimitsHowManyAreNamed(t *testing.T) {
|
|
out, err := tool(t, aCPUHog(t).machine(), "cpu_top").Run(map[string]any{"limit": 1.0, "seconds": 2.0})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m := out.(map[string]any)
|
|
top := m["top"].([]CPUUsage)
|
|
if len(top) != 1 || top[0].Unit != "alpha.service" {
|
|
t.Errorf("limit 1: %+v", top)
|
|
}
|
|
// The limit narrows the list, never the unaccounted share, which is taken over every unit.
|
|
if m["unaccounted_pct"] != 33.3 {
|
|
t.Errorf("unaccounted with limit 1: %+v", m["unaccounted_pct"])
|
|
}
|
|
}
|
|
|
|
func TestCPUTopLeavesOutACgroupThatAppearsOrVanishesWithinTheWindow(t *testing.T) {
|
|
f := aCPUHog(t)
|
|
f.then("/sys/fs/cgroup/system.slice/short-lived.service/cpu.stat", "usage_usec 500000\n")
|
|
out, err := tool(t, f.machine(), "cpu_top").Run(map[string]any{"seconds": 2.0})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
top := out.(map[string]any)["top"].([]CPUUsage)
|
|
for _, u := range top {
|
|
if u.Unit == "short-lived.service" {
|
|
t.Errorf("a unit only in the second reading was counted: %+v", top)
|
|
}
|
|
}
|
|
if !strings.Contains(strings.Join(f.calls, ","), "docker ps") {
|
|
t.Errorf("the container runtime was never asked: %v", f.calls)
|
|
}
|
|
}
|
|
|
|
// aTinyLoad is a machine with 12 CPUs, only 0.04 of them busy over a 2 s window (busy 1 of 300 total
|
|
// ticks): rounded to one decimal for display, CPUsBusy reads 0.0, but a unit using half of that busy
|
|
// time still has a non-zero share — review round 1's decision that share_pct and unaccounted_pct are
|
|
// computed from the unrounded busy time, never from the rounded CPUsBusy.
|
|
func aTinyLoad(t *testing.T) *fake {
|
|
f := newFake(t)
|
|
cpus := "cpu0 0 0 0 0 0 0 0 0 0 0\ncpu1 0 0 0 0 0 0 0 0 0 0\ncpu2 0 0 0 0 0 0 0 0 0 0\ncpu3 0 0 0 0 0 0 0 0 0 0\n" +
|
|
"cpu4 0 0 0 0 0 0 0 0 0 0\ncpu5 0 0 0 0 0 0 0 0 0 0\ncpu6 0 0 0 0 0 0 0 0 0 0\ncpu7 0 0 0 0 0 0 0 0 0 0\n" +
|
|
"cpu8 0 0 0 0 0 0 0 0 0 0\ncpu9 0 0 0 0 0 0 0 0 0 0\ncpu10 0 0 0 0 0 0 0 0 0 0\ncpu11 0 0 0 0 0 0 0 0 0 0\n"
|
|
f.file("/proc/stat", "cpu 0 0 0 0 0 0 0 0 0 0\n"+cpus)
|
|
f.then("/proc/stat", "cpu 1 0 0 299 0 0 0 0 0 0\n"+cpus)
|
|
|
|
f.file("/sys/fs/cgroup/system.slice/tiny.service/cpu.stat", "usage_usec 0\n")
|
|
f.then("/sys/fs/cgroup/system.slice/tiny.service/cpu.stat", "usage_usec 60000\n") // 3 % of one CPU over 2 s
|
|
return f
|
|
}
|
|
|
|
func TestCPUTopSharesAreNonZeroEvenWhenRoundedCPUsBusyIsZero(t *testing.T) {
|
|
out, err := tool(t, aTinyLoad(t).machine(), "cpu_top").Run(map[string]any{"seconds": 2.0})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m := out.(map[string]any)
|
|
cpu := m["cpu"].(MachineCPU)
|
|
if cpu.CPUs != 12 || cpu.CPUsBusy != 0 {
|
|
t.Fatalf("the machine 0.04 CPUs busy, rounded for display: %+v", cpu)
|
|
}
|
|
top := m["top"].([]CPUUsage)
|
|
if len(top) != 1 || top[0].Unit != "tiny.service" || top[0].CPUPct != 3 || top[0].SharePct != 75 {
|
|
t.Fatalf("a non-zero share from the unrounded busy time: %+v", top)
|
|
}
|
|
if m["unaccounted_pct"] != 25.0 {
|
|
t.Fatalf("unaccounted from the unrounded busy time: %+v (want 25, so shares plus unaccounted add to 100)",
|
|
m["unaccounted_pct"])
|
|
}
|
|
}
|
|
|
|
// TestCPUTopKeepsCgroupsWithTheSameUnitNameAsSeparateRows is review round 1's other decision: units are keyed
|
|
// by their cgroup path, never by filepath.Base, so two cgroups that both end in "init.scope" — one at the
|
|
// root, one under a user's session — are two rows, not one merged by their shared leaf name.
|
|
func TestCPUTopKeepsCgroupsWithTheSameUnitNameAsSeparateRows(t *testing.T) {
|
|
f := aCPUHog(t)
|
|
cg := func(path string, usec int) {
|
|
f.file("/sys/fs/cgroup/"+path+"/cpu.stat", "usage_usec 0\n")
|
|
f.then("/sys/fs/cgroup/"+path+"/cpu.stat", "usage_usec "+itoa(usec)+"\n")
|
|
}
|
|
cg("init.scope", 1000000) // the root init, 50 % of one CPU over 2 s
|
|
cg("user.slice/user@1000.service/init.scope", 400000) // a user session's init, 20 %
|
|
|
|
out, err := tool(t, f.machine(), "cpu_top").Run(map[string]any{"seconds": 2.0, "limit": 10.0})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
top := out.(map[string]any)["top"].([]CPUUsage)
|
|
var inits []CPUUsage
|
|
for _, u := range top {
|
|
if u.Unit == "init.scope" {
|
|
inits = append(inits, u)
|
|
}
|
|
}
|
|
if len(inits) != 2 {
|
|
t.Fatalf("two cgroups named init.scope, merged into %d row(s): %+v", len(inits), top)
|
|
}
|
|
byCgroup := map[string]CPUUsage{}
|
|
for _, u := range inits {
|
|
byCgroup[u.Cgroup] = u
|
|
}
|
|
if u, ok := byCgroup["init.scope"]; !ok || u.CPUPct != 50 {
|
|
t.Errorf("the root init.scope: %+v", byCgroup)
|
|
}
|
|
if u, ok := byCgroup["user.slice/user@1000.service/init.scope"]; !ok || u.CPUPct != 20 {
|
|
t.Errorf("the user session's init.scope: %+v", byCgroup)
|
|
}
|
|
}
|