Skip to content

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

sessions: a shard's gob definitions are compiled once, not once a shard (#3493)

yetone432393217a07
diff --git a/internal/sessions/call_cache.go b/internal/sessions/call_cache.go
index 5ab10cac5..71f6f44eb 100644
--- a/internal/sessions/call_cache.go
+++ b/internal/sessions/call_cache.go
@@ -539,7 +539,7 @@ func loadCalls(f file) *callFile {
return nil
}
var frame callFrame
- if gob.NewDecoder(bytes.NewReader(data)).Decode(&frame) != nil || frame.State.Path != f.path || frame.State.Agent != f.agent {
+ if decodeFrame(data, &frame) != nil || frame.State.Path != f.path || frame.State.Agent != f.agent {
return nil
}
if st != nil && frame.State.Off < st.Off {
diff --git a/internal/sessions/call_frame.go b/internal/sessions/call_frame.go
new file mode 100644
index 000000000..6b86a5115
--- /dev/null
+++ b/internal/sessions/call_frame.go
@@ -0,0 +1,116 @@
+package sessions
+
+import (
+ "bytes"
+ "encoding/gob"
+ "errors"
+ "io"
+ "sync"
+)
+
+// A shard's frame is one gob stream: the definitions of callFrame's types,
+// then the frame. Every frame is written by an Encoder of its own, so every
+// frame sends the same definitions, and a Decoder of its own compiled them
+// again for each: over ~15.6k shards at a start, ~400 MB of a cold Requests
+// build's ~1 GB of reading them, and the collections that came with it
+// (#3493). A shardDecoder keeps one Decoder and the definitions it has
+// read, and hands it only the frame when a frame's definitions are those.
+
+type shardDecoder struct {
+ types []byte // the definitions dec has read, as they were sent
+ in frameInput
+ dec *gob.Decoder
+}
+
+// frameInput is a Decoder's input, swapped from frame to frame. It is an
+// io.ByteReader, so the Decoder reads no further than each message.
+type frameInput struct{ b []byte }
+
+func (r *frameInput) Read(p []byte) (int, error) {
+ if len(r.b) == 0 {
+ return 0, io.EOF
+ }
+ n := copy(p, r.b)
+ r.b = r.b[n:]
+ return n, nil
+}
+
+func (r *frameInput) ReadByte() (byte, error) {
+ if len(r.b) == 0 {
+ return 0, io.EOF
+ }
+ c := r.b[0]
+ r.b = r.b[1:]
+ return c, nil
+}
+
+var shardDecoders sync.Pool
+
+var errShardFrame = errors.New("bad call frame")
+
+// decodeFrame decodes the gob stream data into frame.
+func decodeFrame(data []byte, frame *callFrame) error {
+ types, ok := gobTypes(data)
+ if !ok {
+ return errShardFrame
+ }
+ fd, _ := shardDecoders.Get().(*shardDecoder)
+ if fd != nil && bytes.Equal(fd.types, types) {
+ fd.in.b = data[len(types):]
+ } else {
+ fd = &shardDecoder{types: bytes.Clone(types)}
+ fd.in.b = data
+ fd.dec = gob.NewDecoder(&fd.in)
+ }
+ // a Decoder that failed is let go: what it read is unknown
+ if err := fd.dec.Decode(frame); err != nil {
+ return err
+ }
+ if len(fd.in.b) != 0 {
+ return errShardFrame
+ }
+ shardDecoders.Put(fd)
+ return nil
+}
+
+// gobTypes is the start of the gob stream data that defines types: the
+// messages before the first one of a value. Each message is its length,
+// then its type id, negative for a definition.
+func gobTypes(data []byte) ([]byte, bool) {
+ at := 0
+ for at < len(data) {
+ n, k := gobUint(data[at:])
+ if k == 0 || n > uint64(len(data)-at-k) {
+ return nil, false
+ }
+ id, j := gobUint(data[at+k:])
+ if j == 0 {
+ return nil, false
+ }
+ if id&1 == 0 { // a positive id: a value
+ return data[:at], true
+ }
+ at += k + int(n)
+ }
+ return nil, false
+}
+
+// gobUint reads one of gob's unsigned integers: a byte below 0x80 is the
+// value, any other is the negated count of big-endian bytes that follow.
+// k is how many bytes it took, 0 for a bad one.
+func gobUint(b []byte) (v uint64, k int) {
+ if len(b) == 0 {
+ return 0, 0
+ }
+ if b[0] < 0x80 {
+ return uint64(b[0]), 1
+ }
+ n := -int(int8(b[0]))
+ if n > 8 || n >= len(b) {
+ return 0, 0
+ }
+ for _, c := range b[1 : 1+n] {
+ v = v<<8 | uint64(c)
+ }
+ return v, 1 + n
+}
diff --git a/internal/sessions/call_frame_test.go b/internal/sessions/call_frame_test.go
new file mode 100644
index 000000000..3658d48fb
--- /dev/null
+++ b/internal/sessions/call_frame_test.go
@@ -0,0 +1,97 @@
+package sessions
+
+import (
+ "bytes"
+ "encoding/gob"
+ "reflect"
+ "testing"
+ "time"
+)
+
+func encodedFrame(t *testing.T, v any) []byte {
+ t.Helper()
+ var b bytes.Buffer
+ if err := gob.NewEncoder(&b).Encode(v); err != nil {
+ t.Fatal(err)
+ }
+ return b.Bytes()
+}
+
+func freshFrame(t *testing.T, data []byte) callFrame {
+ t.Helper()
+ var f callFrame
+ if err := gob.NewDecoder(bytes.NewReader(data)).Decode(&f); err != nil {
+ t.Fatal(err)
+ }
+ return f
+}
+
+// Frames decoded through one kept Decoder are the frames a Decoder of their
+// own reads, frame after frame, a frame of other definitions among them; a
+// cut or padded frame is an error, and the next frame still reads (#3493).
+func TestDecodeFrameAsAFreshDecoder(t *testing.T) {
+ var frames [][]byte
+ for i := range 5 {
+ f := callFrame{State: callDiskState{Path: "p", Size: int64(i), Mod: int64(i * 7)}, Strings: []string{"", "m", string(rune('a' + i))}}
+ for j := range i {
+ f.Patches = append(f.Patches, callPatch{Index: j, Text: [13]uint32{uint32(j)}, Began: time.Unix(int64(j), 0).UTC()})
+ }
+ frames = append(frames, encodedFrame(t, f))
+ }
+ // another writer's frame: other definitions, fields that land in callFrame
+ type otherFrame struct{ Strings []string }
+ frames = append(frames[:2], append([][]byte{encodedFrame(t, otherFrame{Strings: []string{"x"}})}, frames[2:]...)...)
+ for round := range 2 {
+ for i, data := range frames {
+ var got callFrame
+ if err := decodeFrame(data, &got); err != nil {
+ t.Fatalf("round %d frame %d: %v", round, i, err)
+ }
+ if want := freshFrame(t, data); !reflect.DeepEqual(got, want) {
+ t.Fatalf("round %d frame %d:\n got %+v\nwant %+v", round, i, got, want)
+ }
+ }
+ }
+ bad := map[string][]byte{
+ "cut": frames[3][:len(frames[3])-2],
+ "padded": append(bytes.Clone(frames[3]), 1, 2),
+ "empty": nil,
+ "types": frames[3][:len(frames[3])/3],
+ }
+ for name, data := range bad {
+ var f callFrame
+ if decodeFrame(data, &f) == nil {
+ t.Fatalf("a %s frame decoded", name)
+ }
+ var got callFrame
+ if err := decodeFrame(frames[4], &got); err != nil || !reflect.DeepEqual(got, freshFrame(t, frames[4])) {
+ t.Fatalf("after a %s frame: %v %+v", name, err, got)
+ }
+ }
+}
+
+// A frame of the definitions the last one had isn't compiled again: that
+// was most of the reading of a start's ~15.6k shards (#3493).
+func TestDecodeFrameKeepsDefinitions(t *testing.T) {
+ data := encodedFrame(t, callFrame{Strings: []string{"", "m"}, Patches: []callPatch{{Index: 1}}})
+ var f callFrame
+ if err := decodeFrame(data, &f); err != nil {
+ t.Fatal(err)
+ }
+ kept := testing.AllocsPerRun(50, func() {
+ var f callFrame
+ if err := decodeFrame(data, &f); err != nil {
+ t.Fatal(err)
+ }
+ })
+ fresh := testing.AllocsPerRun(50, func() {
+ var f callFrame
+ if err := gob.NewDecoder(bytes.NewReader(data)).Decode(&f); err != nil {
+ t.Fatal(err)
+ }
+ })
+ if kept*4 > fresh {
+ t.Fatalf("a kept Decoder made %v allocations a frame, a fresh one %v", kept, fresh)
+ }
+ t.Logf("allocations a frame: kept %v, fresh %v", kept, fresh)
+}