Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

edit: the big-TOML shape test bounds the parse by two sizes' time ratio, not one second of wall clock (#2219)

Niko Wu36200091ad12
diff --git a/internal/edit/toml_shape_test.go b/internal/edit/toml_shape_test.go
index fdd8043fa..4db63ee84 100644
--- a/internal/edit/toml_shape_test.go
+++ b/internal/edit/toml_shape_test.go
@@ -43,29 +43,59 @@ func TestTOMLShaperMatchesParser(t *testing.T) {
}
}
-// A big config.toml is parsed in a time that grows with its size, not its
-// square: Codex's own reached 1.5 MB, and each key's line was counted from
-// the top of the file, a third of a second at every magpie start.
-func TestTOMLBigFileParsesInLinearTime(t *testing.T) {
+// tomlBigFile is a config.toml of about size bytes: the table shape a Codex
+// one reached, 1.5 MB of keys, each on its own header.
+func tomlBigFile(size int) []string {
var b strings.Builder
- for i := 0; b.Len() < 3<<20; i++ {
+ for i := 0; b.Len() < size; i++ {
fmt.Fprintf(&b, "[projects.\"/Users/me/p%d\"]\ntrust_level = \"trusted\" # note\n\n", i)
}
b.WriteString("model_provider = \"magpie\"\n")
- lines := splitLines("model_provider = \"x\"\n" + b.String())
- start := time.Now()
- f, err := parseTOMLFile(lines)
- if err != nil {
- t.Fatal(err)
- }
- if d := time.Since(start); d > time.Second {
- t.Errorf("a 3 MB file took %v to parse", d)
+ return splitLines("model_provider = \"x\"\n" + b.String())
+}
+
+// parseTOMLTimed parses lines three times and keeps the fastest, which a
+// loaded runner can still reach, and the file it read.
+func parseTOMLTimed(t *testing.T, lines []string) (tomlFile, time.Duration) {
+ t.Helper()
+ var f tomlFile
+ var best time.Duration
+ for rep := 0; rep < 3; rep++ {
+ start := time.Now()
+ got, err := parseTOMLFile(lines)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if d := time.Since(start); rep == 0 || d < best {
+ best = d
+ }
+ f = got
}
+ return f, best
+}
+
+// A big config.toml is parsed in a time that grows with its size, not its
+// square: Codex's own reached 1.5 MB, and each key's line was counted from
+// the top of the file, a third of a second at every magpie start.
+//
+// The check is the ratio between parsing a 2 MB and an 8 MB file, not a bound
+// in seconds: a runner at load ~190 took the still-linear 3 MB parse past the
+// old 1s bound and went red without anything quadratic (#2219). Load slows
+// both parses together, not their ratio. A parse that grows with size squared
+// needs 16× the time for the 4× bigger file, where the linear one needs 4×,
+// so the bound sits between the two, far from both.
+func TestTOMLBigFileParsesInLinearTime(t *testing.T) {
+ small, large := tomlBigFile(2<<20), tomlBigFile(8<<20)
+ f, dSmall := parseTOMLTimed(t, small)
if len(f.tables) < 30000 || f.root.keys[0].name != "model_provider" {
t.Fatalf("parsed %d tables, root %+v", len(f.tables), f.root.keys)
}
last := f.tables[len(f.tables)-1]
- if k := last.keys[len(last.keys)-1]; k.name != "model_provider" || k.from != len(lines)-2 && k.from != len(lines)-1 {
- t.Errorf("last key %+v of %d lines", k, len(lines))
+ if k := last.keys[len(last.keys)-1]; k.name != "model_provider" || k.from != len(small)-2 && k.from != len(small)-1 {
+ t.Errorf("last key %+v of %d lines", k, len(small))
+ }
+ _, dLarge := parseTOMLTimed(t, large)
+ if ratio := float64(dLarge) / float64(dSmall); ratio > 8 {
+ t.Errorf("an 8 MB file took %v to parse, %.1f× the 2 MB one's %v: near the 16× of size squared, not the 4× of size", dLarge, ratio, dSmall)
}
}