jschoubben
02f50bd9d6
Since the build CPU cap (issue 1806) shanks' mesh-build-go kept capacity 3 inside a 12-core slice: three full checks got about 4 cores each and ran past the 30-minute step bound (issue 1890). The puller now judges by min(configured, floor(slice quota cores / cores-per-step)), the quota read live from its cgroup, says it on change and writes capacity.<node> to the pauses state. A run's phases (fetch and merge, digest, tests) are logged with the ask id and written to its running step key; Asker.Wait hands every step value to a WithStepSeen hook.
88 lines
3.5 KiB
Go
88 lines
3.5 KiB
Go
package buildstep
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
// 1887/A7: the node's build capacity is the build module's setting, read at every pull: the control-node at 0 pulls
|
|
// nothing, a change takes effect at the next read, and a setting that cannot be read pulls nothing.
|
|
func TestNodeCapacity(t *testing.T) {
|
|
if got := NodeCapacity("", DefaultCapacities, "novox", nil)(); got != 0 {
|
|
t.Errorf("novox = %d by default, want 0", got)
|
|
}
|
|
if got := NodeCapacity("", DefaultCapacities, "shanks", nil)(); got != 3 {
|
|
t.Errorf("shanks = %d by default, want 3", got)
|
|
}
|
|
file := filepath.Join(t.TempDir(), "settings.json")
|
|
os.WriteFile(file, []byte(`{"capacity":"shanks=1,ace=2"}`), 0o600)
|
|
capacity := NodeCapacity(file, DefaultCapacities, "shanks", nil)
|
|
if got := capacity(); got != 1 {
|
|
t.Errorf("shanks = %d from the file, want 1", got)
|
|
}
|
|
os.WriteFile(file, []byte(`{"capacity":"shanks=4"}`), 0o600)
|
|
if got := capacity(); got != 4 {
|
|
t.Errorf("shanks = %d after the change, want 4", got)
|
|
}
|
|
if got := NodeCapacity(file, "", "pi", nil)(); got != 1 {
|
|
t.Errorf("a node not named = %d, want 1", got)
|
|
}
|
|
os.WriteFile(file, []byte(`{"capacity":"shanks=lots"}`), 0o600)
|
|
if got := capacity(); got != 0 {
|
|
t.Errorf("an unreadable setting = %d, want 0", got)
|
|
}
|
|
if got := NodeCapacity(filepath.Join(t.TempDir(), "none"), DefaultCapacities, "shanks", nil)(); got != 0 {
|
|
t.Errorf("a missing file = %d, want 0", got)
|
|
}
|
|
}
|
|
|
|
// ADR 0553 §4: a step's threads are the composer's share over the module's own capacity; without the word, none. And
|
|
// issue 1806's follow-up: the capacity judged by is the configured one bounded by the build slice's cores over the cores
|
|
// a step needs (the three build nodes as they stand on 2026-10-26), and cores-per-step is read from the settings file.
|
|
func TestNodeLimitsAndTheCPUBound(t *testing.T) {
|
|
t.Setenv("MESH_BUILD_CPU_SHARE", "")
|
|
if l := NodeLimits(3); l.Threads != 0 || l.Slots != 3 {
|
|
t.Errorf("without the word: %+v", l)
|
|
}
|
|
t.Setenv("MESH_BUILD_CPU_SHARE", "75")
|
|
if l := NodeLimits(3); l.Percent != 75 || l.Slots != 3 || l.Threads < 1 {
|
|
t.Errorf("from the word: %+v", l)
|
|
}
|
|
for _, c := range []struct {
|
|
name string
|
|
configured, quota int
|
|
cores float64
|
|
effective, byCPU int
|
|
}{
|
|
{"shanks: 12 cores, configured 3", 3, 1200, 6, 2, 2},
|
|
{"ace: 18 cores, configured 2", 2, 1800, 6, 2, 3},
|
|
{"g14: 8 cores, configured 2", 2, 800, 6, 1, 1},
|
|
{"node on shanks: 12 cores at 2", 3, 1200, 2, 3, 6},
|
|
{"no quota: the configured one", 3, 0, 6, 3, 0},
|
|
{"configured 0 pulls nothing", 0, 1200, 6, 0, 0},
|
|
{"a quota under one step still builds one", 2, 100, 6, 1, 1},
|
|
{"no cores a step is one", 2, 150, 0, 1, 1},
|
|
} {
|
|
got := EffectiveCapacity(c.configured, c.quota, "test", c.cores)
|
|
if got.Effective != c.effective || got.ByCPU != c.byCPU || got.Why == "" {
|
|
t.Errorf("%s: %+v, want effective %d, by CPU %d", c.name, got, c.effective, c.byCPU)
|
|
}
|
|
}
|
|
file := filepath.Join(t.TempDir(), "settings.json")
|
|
var said []string
|
|
cores := NodeCoresPerStep(file, 6, func(f string, a ...any) { said = append(said, f) })
|
|
for _, c := range []struct {
|
|
file string
|
|
want float64
|
|
}{{`{"capacity":"shanks=2"}`, 6}, {`{"cores-per-step":4}`, 4}, {`{"cores-per-step":"3.5"}`, 3.5}, {`{"cores-per-step":0}`, 6}, {`{"cores-per-step":0}`, 6}} {
|
|
os.WriteFile(file, []byte(c.file), 0o600)
|
|
if got := cores(); got != c.want {
|
|
t.Errorf("cores-per-step from %s = %g, want %g", c.file, got, c.want)
|
|
}
|
|
}
|
|
if len(said) != 1 {
|
|
t.Errorf("a value not above zero is said once, said %d times", len(said))
|
|
}
|
|
}
|