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.goindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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)+}