Skip to content

Fix streaming slice decoding and optimize binary codec paths#35

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
kelindar merged 3 commits into from
Aug 10, 2026
Merged

Fix streaming slice decoding and optimize binary codec paths #35

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
670fe80
Optimize binary decoding paths and add benchmarks
kelindar Aug 10, 2026
b2dd2f0
Shorten benchmark case and path names
kelindar Aug 10, 2026
e51c248
Refactor pointer decode branching and expand codec path tests
kelindar Aug 10, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
89 changes: 89 additions & 0 deletions bench/main.go
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -6,6 +6,7 @@ package main
import (
"bytes"
"fmt"
"runtime"
"time"

"github.com/kelindar/bench"
Expand DownExpand Up@@ -55,6 +56,94 @@ func runBinary(b *bench.B) {
runBinaryReuse(b)
runBinaryTrace(b)
runBinaryUnion(b)
runBinaryPaths(b)
}

type binaryPathCase struct {
name string
value any
newOutput func() any
}

func binaryPathCases() []binaryPathCase {
items := make([]benchmarkItem, 32)
for i := range items {
items[i] = benchmarkItem{ID: int64(i), Name: "item"}
}
pointers := make([]*benchmarkItem, 16)
for i := range pointers {
if i%4 != 0 {
pointers[i] = &items[i]
}
}
strings := make([]string, 16)
for i := range strings {
strings[i] = "value"
}
signed := make([]int64, 32)
unsigned := make([]uint64, 32)
for i := range signed {
signed[i] = int64(i) - 16
unsigned[i] = uint64(i)
}
return []binaryPathCase{
{"flat", benchmarkFlat{ID: -42, Count: 99, Name: "flat"}, func() any { return new(benchmarkFlat) }},
{"typ", items, func() any { return new([]benchmarkItem) }},
{"str", strings, func() any { return new([]string) }},
{"i64", signed, func() any { return new([]int64) }},
{"u64", unsigned, func() any { return new([]uint64) }},
{"ptr", pointers, func() any { return new([]*benchmarkItem) }},
}
}

type benchmarkItem struct {
ID int64
Name string
}

type benchmarkFlat struct {
ID int64
Count uint64
Name string
}

type benchmarkStreamWriter struct{ bytes.Buffer }

func runBinaryPaths(b *bench.B) {
for _, tc := range binaryPathCases() {
data, err := binary.Marshal(tc.value)
if err != nil {
panic(err)
}

var writer benchmarkStreamWriter
encoder := binary.NewEncoder(&writer)
if err := encoder.Encode(tc.value); err != nil {
panic(err)
}

b.Run("path/"+tc.name+"-enc", func(int) {
out, _ := binary.Marshal(tc.value)
runtime.KeepAlive(out)
runtime.KeepAlive(tc.value)
})
b.Run("path/"+tc.name+"-enc-to", func(int) {
writer.Reset()
encoder.Reset(&writer)
_ = encoder.Encode(tc.value)
runtime.KeepAlive(tc.value)
})
b.Run("path/"+tc.name+"-dec", func(int) {
out := tc.newOutput()
_ = binary.Unmarshal(data, out)
runtime.KeepAlive(out)
})
b.Run("path/"+tc.name+"-stream-dec", func(int) {
out := tc.newOutput()
_ = binary.NewDecoder(bytes.NewReader(data)).Decode(out)
runtime.KeepAlive(out)
})
}
}

func runBinaryMsg(b *bench.B) {
Expand Down
135 changes: 63 additions & 72 deletions codecs.go
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -105,30 +105,36 @@ func (c *reflectCollectionCodec) DecodeTo(d *Decoder, rv reflect.Value) (err err
if n, err = decodeLength(l); err != nil {
return
}
minBytes := wireMinBytes(c.elemCodec)
if wireless {
return resizeSliceChecked(rv, n)
}
if d.Available() < 0 || minBytes == 0 {
rv.SetLen(0)
for i := 0; i < n; i++ {
appendSliceElement(rv)
if isStruct {
err = codec.DecodeTo(d, rv.Index(i))
} else {
err = c.elemCodec.DecodeTo(d, rv.Index(i))
}
if err != nil {
return
if d.Available() < 0 {
if err = resizeSliceChecked(rv, n); err != nil {
return
}
} else {
minBytes := wireMinBytes(c.elemCodec)
if minBytes == 0 {
rv.SetLen(0)
for i := 0; i < n; i++ {
appendSliceElement(rv)
if isStruct {
err = codec.DecodeTo(d, rv.Index(i))
} else {
err = c.elemCodec.DecodeTo(d, rv.Index(i))
}
if err != nil {
return
}
}
return nil
}
if err = d.ensureElements(n, minBytes); err != nil {
return
}
if err = resizeSliceChecked(rv, n); err != nil {
return
}
return nil
}
if err = d.ensureElements(n, minBytes); err != nil {
return
}
if err = resizeSliceChecked(rv, n); err != nil {
return
}
}
if isStruct {
Expand DownExpand Up@@ -183,21 +189,13 @@ func (c *reflectSliceOfPtrCodec) DecodeTo(d *Decoder, rv reflect.Value) (err err
if err != nil {
return err
}
stream := d.Available() < 0
if stream {
rv.SetLen(0)
} else {
if err = d.ensureAvailable(n); err != nil {
return err
}
if err = resizeSliceChecked(rv, n); err != nil {
return err
}
if err = d.ensureAvailable(n); err != nil {
return err
}
if err = resizeSliceChecked(rv, n); err != nil {
return err
}
for i := 0; i < n; i++ {
if stream {
appendSliceElement(rv)
}
ptr := rv.Index(i)
isNil, err = d.ReadBool()
switch {
Expand DownExpand Up@@ -319,25 +317,23 @@ func (c *stringSliceCodec) DecodeTo(d *Decoder, rv reflect.Value) (err error) {
if n, err = decodeLength(l); err != nil {
return
}
if d.Available() < 0 {
rv.SetLen(0)
for i := 0; i < n; i++ {
appendSliceElement(rv)
value, readErr := d.readString("")
if readErr != nil {
return readErr
}
rv.Index(i).SetString(value)
}
return nil
}
if err = d.ensureAvailable(n); err != nil {
return
}
if err = resizeSliceChecked(rv, n); err != nil {
return
}
}
if d.Available() < 0 {
for i := 0; i < n; i++ {
var value string
if value, err = d.ReadString(); err != nil {
return
}
rv.Index(i).SetString(value)
}
return nil
}
if c.array {
if err = d.ensureAvailable(n); err != nil {
return
Expand DownExpand Up@@ -625,27 +621,6 @@ func (c *varSliceCodec) DecodeTo(d *Decoder, rv reflect.Value) (err error) {
if n, err = decodeLength(l); err != nil {
return
}
if d.Available() < 0 {
rv.SetLen(0)
for i := 0; i < n; i++ {
appendSliceElement(rv)
if c.signed {
var value int64
if value, err = d.ReadVarint(); err == nil {
rv.Index(i).SetInt(value)
}
} else {
var value uint64
if value, err = d.ReadUvarint(); err == nil {
rv.Index(i).SetUint(value)
}
}
if err != nil {
return
}
}
return nil
}
if err = d.ensureAvailable(n); err != nil {
return
}
Expand DownExpand Up@@ -908,10 +883,26 @@ func (c reflectStructCodec) EncodeTo(e *Encoder, rv reflect.Value) (err error) {
e.WriteString(*(*string)(pointer))
case reflect.Bool:
e.writeBool(*(*bool)(pointer))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
e.WriteVarint(rv.Field(i).Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
e.WriteUvarint(rv.Field(i).Uint())
case reflect.Int:
e.WriteVarint(int64(*(*int)(pointer)))
case reflect.Int8:
e.WriteVarint(int64(*(*int8)(pointer)))
case reflect.Int16:
e.WriteVarint(int64(*(*int16)(pointer)))
case reflect.Int32:
e.WriteVarint(int64(*(*int32)(pointer)))
case reflect.Int64:
e.WriteVarint(*(*int64)(pointer))
case reflect.Uint:
e.WriteUvarint(uint64(*(*uint)(pointer)))
case reflect.Uint8:
e.WriteUvarint(uint64(*(*uint8)(pointer)))
case reflect.Uint16:
e.WriteUvarint(uint64(*(*uint16)(pointer)))
case reflect.Uint32:
e.WriteUvarint(uint64(*(*uint32)(pointer)))
case reflect.Uint64:
e.WriteUvarint(*(*uint64)(pointer))
case reflect.Complex64:
e.writeComplex64(*(*complex64)(pointer))
case reflect.Complex128:
Expand DownExpand Up@@ -1153,10 +1144,10 @@ func (c *customCodec) EncodeTo(e *Encoder, rv reflect.Value) (err error) {
func (c *customCodec) DecodeTo(d *Decoder, rv reflect.Value) (err error) {
if rv.Kind() == reflect.Ptr {
isNil, err := d.ReadBool()
if err != nil {
switch {
case err != nil:
return err
}
if isNil {
case isNil:
rv.SetZero()
return nil
}
Expand Down
43 changes: 43 additions & 0 deletions codecs_test.go
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -90,6 +90,16 @@ type malformedCodec struct{}

func (*malformedCodec) GetBinaryCodec(int) Codec { return nil }

type zeroCodec struct{}

func (zeroCodec) EncodeTo(*Encoder, reflect.Value) error { return nil }
func (zeroCodec) DecodeTo(*Decoder, reflect.Value) error { return nil }

type errorCodec struct{}

func (errorCodec) EncodeTo(*Encoder, reflect.Value) error { return nil }
func (errorCodec) DecodeTo(*Decoder, reflect.Value) error { return errors.New("decode failed") }

type nilCodecType struct{}

func (*nilCodecType) GetBinaryCodec() Codec { return nil }
Expand DownExpand Up@@ -675,6 +685,39 @@ func TestCollectionErrors(t *testing.T) {
assert.Error(t, Unmarshal(huge, &generic))
}

func TestCodecPaths(t *testing.T) {
got := []int{9}
codec := &reflectCollectionCodec{elemCodec: zeroCodec{}}
err := codec.DecodeTo(NewDecoder(bytes.NewBuffer([]byte{2})), reflect.ValueOf(&got).Elem())
assert.NoError(t, err)
assert.Equal(t, []int{0, 0}, got)

type item struct{ Value int }
var items []item
codec = &reflectCollectionCodec{elemCodec: &reflectStructCodec{{Field: fieldIncluded, Codec: zeroCodec{}}}}
err = codec.DecodeTo(NewDecoder(bytes.NewBuffer([]byte{2})), reflect.ValueOf(&items).Elem())
assert.NoError(t, err)
assert.Equal(t, []item{{}, {}}, items)

data := stdbinary.AppendUvarint(nil, uint64(^uint(0)>>1))
var streamed []int
codec = &reflectCollectionCodec{elemCodec: &primitiveCodec{}}
err = codec.DecodeTo(NewDecoder(bytes.NewReader(data)), reflect.ValueOf(&streamed).Elem())
assert.Equal(t, io.ErrUnexpectedEOF, err)

var unaddressable []int
err = codec.DecodeTo(NewDecoder(bytes.NewBuffer([]byte{1, 0})), reflect.ValueOf(unaddressable))
assert.Equal(t, io.ErrUnexpectedEOF, err)

codec = &reflectCollectionCodec{elemCodec: errorCodec{}}
assert.Error(t, codec.DecodeTo(NewDecoder(bytes.NewBuffer([]byte{1})), reflect.ValueOf(&got).Elem()))

var pointers []*int
ptrCodec := &reflectSliceOfPtrCodec{elemCodec: &primitiveCodec{}, elemType: reflect.TypeFor[int]()}
err = ptrCodec.DecodeTo(NewDecoder(bytes.NewBuffer([]byte{1, 0})), reflect.ValueOf(pointers))
assert.Equal(t, io.ErrUnexpectedEOF, err)
}

func TestFixedWidthSlices(t *testing.T) {
tests := []struct {
name string
Expand Down
19 changes: 5 additions & 14 deletions decoder.go
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -62,23 +62,14 @@ func (d *Decoder) Decode(v any) (err error) {
}

func (d *Decoder) Read(b []byte) (int, error) {
if d.slice != nil {
return d.slice.Read(b)
}
return d.reader.Read(b)
}

func (d *Decoder) ReadUvarint() (uint64, error) {
if d.slice != nil {
return d.slice.ReadUvarint()
}
return d.reader.ReadUvarint()
}

func (d *Decoder) ReadVarint() (int64, error) {
if d.slice != nil {
return d.slice.ReadVarint()
}
return d.reader.ReadVarint()
}

Expand DownExpand Up@@ -123,16 +114,16 @@ func (d *Decoder) ReadFloat64() (out float64, err error) {
}

func (d *Decoder) ReadBool() (bool, error) {
if d.slice != nil {
b, err := d.slice.ReadByte()
return b == 1, err
}
b, err := d.reader.ReadByte()
return b == 1, err
}

func (d *Decoder) ReadString() (out string, err error) {
return d.readString("")
var b []byte
if b, err = d.ReadSlice(); err == nil {
out = string(b)
}
return
}

func (d *Decoder) readString(old string) (string, error) {
Expand Down
Loading
Loading