perf: bsr fast paths for readCode/PeekCode + pool OmitEmpty field slices

Three optimizations targeting decode throughput and encode GC pressure:

1. readCode() bsr fast path (#57): read directly from byte-slice data
   instead of going through interface dispatch on the hottest decode
   function. Handles d.rec recording mode inline.

2. PeekCode() bsr fast path (#59): peek directly at byte-slice data
   avoiding ReadByte+UnreadByte interface dispatch.

3. Pool OmitEmpty filtered field slices (#58): use sync.Pool for the
   []*field slice allocated when struct fields are omitted, returned
   via putFilteredFields after iteration in encodeStructValue.

Benchmark results (Apple M3 Max, 3 iterations):
  StructUnmarshal:          361 ns → 334 ns  (-7.5%)
  StructUnmarshalPartially: 247 ns → 232 ns  (-6.1%)
  MapIntInt:                328 ns → 314 ns  (-4.3%)
  StructManual:             569 ns → 544 ns  (-4.4%)

Closes #57, closes #59, closes #58

Author: xe-nvdk

decode.go

@@ -610,6 +610,14 @@ func (d *Decoder) DecodeRaw() (RawMessage, error) {
 // PeekCode returns the next MessagePack code without advancing the reader.
 // Subpackage msgpack/codes defines the list of available msgpcode.
 func (d *Decoder) PeekCode() (byte, error) {
+	// Fast path: when decoding from a byte slice, peek directly
+	// to avoid two interface method calls (ReadByte + UnreadByte).
+	if d.s == &d.bsr {
+		if d.bsr.pos >= len(d.bsr.data) {
+			return 0, io.EOF
+		}
+		return d.bsr.data[d.bsr.pos], nil
+	}
 	c, err := d.s.ReadByte()
 	if err != nil {
 		return 0, err
@@ -634,6 +642,19 @@ func (d *Decoder) hasNilCode() bool {
 }
 
 func (d *Decoder) readCode() (byte, error) {
+	// Fast path: when decoding from a byte slice, read directly
+	// to avoid interface method dispatch on the hottest decode function.
+	if d.s == &d.bsr {
+		if d.bsr.pos >= len(d.bsr.data) {
+			return 0, io.EOF
+		}
+		c := d.bsr.data[d.bsr.pos]
+		d.bsr.pos++
+		if d.rec != nil {
+			d.rec = append(d.rec, c)
+		}
+		return c, nil
+	}
 	c, err := d.s.ReadByte()
 	if err != nil {
 		return 0, err

encode_map.go

@@ -279,21 +279,40 @@ func encodeStructValue(e *Encoder, strct reflect.Value) error {
 	fields := structFields.OmitEmpty(e, strct)
 
 	if err := e.EncodeMapLen(len(fields)); err != nil {
+		putFilteredFields(structFields, fields)
 		return err
 	}
 
 	for _, f := range fields {
 		if err := e.EncodeString(f.name); err != nil {
+			putFilteredFields(structFields, fields)
 			return err
 		}
 		if err := f.EncodeValue(e, strct); err != nil {
+			putFilteredFields(structFields, fields)
 			return err
 		}
 	}
 
+	putFilteredFields(structFields, fields)
 	return nil
 }
 
+// putFilteredFields returns a pooled filtered field slice.
+// It is a no-op when the slice is the original fs.List (not pooled).
+func putFilteredFields(fs *fields, filtered []*field) {
+	if len(filtered) > 0 && len(fs.List) > 0 && &filtered[0] == &fs.List[0] {
+		return
+	}
+	for i := range filtered {
+		filtered[i] = nil
+	}
+	if cap(filtered) <= 64 {
+		s := filtered
+		filteredFieldsPool.Put(&s)
+	}
+}
+
 func encodeStructValueAsArray(e *Encoder, strct reflect.Value, fields []*field) error {
 	if err := e.EncodeArrayLen(len(fields)); err != nil {
 		return err

types.go

@@ -120,6 +120,13 @@ func (f *field) DecodeValue(d *Decoder, strct reflect.Value) error {
 	return f.decoder(d, v)
 }
 
+var filteredFieldsPool = sync.Pool{
+	New: func() interface{} {
+		s := make([]*field, 0, 16)
+		return &s
+	},
+}
+
 //------------------------------------------------------------------------------
 
 type fields struct {
@@ -172,14 +179,18 @@ func (fs *fields) OmitEmpty(e *Encoder, strct reflect.Value) []*field {
 		return fs.List
 	}
 
-	// Second pass: build the filtered slice only when necessary.
-	fields := make([]*field, 0, n)
+	// Second pass: build the filtered slice from pool.
+	sp := filteredFieldsPool.Get().(*[]*field)
+	fields := (*sp)[:0]
+	if cap(fields) < n {
+		fields = make([]*field, 0, n)
+	}
 	for _, f := range fs.List {
 		if !f.Omit(e, strct) {
 			fields = append(fields, f)
 		}
 	}
-
+	*sp = fields
 	return fields
 }