Add baseline_rw benchmark (#177)

* baseline: Add Reader/Writer variant

This variant is meant to demonstrate and generate a baseline for
serializers that can marshal/unmarshal to/from standard io Reader and
Writer intefaces.

While the decision on reusing auxiliary buffers is arbitrary, it is
assumed that writing native types (uint64, etc) can be easily done by
any Reader/Writer implementation itself (or their callers).

The ultimate goal for this baseline test is as a benchmark against other
implementations that offer this method of serialization, strictly
measuring only the overhead of going through the io interfaces.

Both safe and unsafe+reuse implementations are provided.

* report: Update with baseline_rw results

Author: matheusd

benchmarks.go

@@ -502,6 +502,28 @@ var benchmarkCases = []BenchmarkCase{
 		Notes: []string{
 			"This is a manually written encoding, designed to be the fastest possible for this benchmark.",
 		},
+	}, {
+		Name: "baseline_rw",
+		URL:  "",
+		New:  baseline.NewBaselineReaderWriter,
+
+		TimeSupport: TSNoSupport,
+		APIKind:     AKManual,
+		Notes: []string{
+			"This is a manually written encoding, designed to be the fastest possible for this benchmark, using an io.Reader/io.Writer as the API.",
+		},
+	}, {
+		Name: "baseline_rw/unsafe_reuse",
+		URL:  "",
+		New:  baseline.NewBaselineReaderWriterUnsafeReuse,
+
+		UnsafeStringUnmarshal: true,
+		BufferReuseMarshal:    true,
+		TimeSupport:           TSNoSupport,
+		APIKind:               AKManual,
+		Notes: []string{
+			"This is a manually written encoding, designed to be the fastest possible for this benchmark, using an io.Reader/io.Writer as the API.",
+		},
 	}, {
 		Name: "fastape",
 		URL:  "github.com/nazarifard/fastape",

internal/serializers/baseline/baseline.go

@@ -4,7 +4,6 @@ import (
 	"encoding/binary"
 	"math"
 	"time"
-	"unsafe"
 
 	"github.com/alecthomas/go_serialization_benchmarks/goserbench"
 )
@@ -17,28 +16,6 @@ import (
 // marshalling/unmarshalling operations.
 type BaselineSerializer struct{}
 
-// maxSmallStructSerializeSize is the max size of a small struct serialized
-// with the baseline serializer.
-const maxSmallStructSerializeSize = 8 + 8 + 4 + 1 + goserbench.MaxSmallStructPhoneSize + goserbench.MaxSmallStructNameSize
-
-// appendBool appends a bool to b.
-func appendBool(b []byte, v bool) []byte {
-	if v {
-		return append(b, 1)
-	} else {
-		return append(b, 0)
-	}
-}
-
-// getBool reads the next bool from b.
-func getBool(b []byte) bool {
-	if b[0] == 0 {
-		return false
-	} else {
-		return true
-	}
-}
-
 func (b *BaselineSerializer) Marshal(o interface{}) ([]byte, error) {
 	a := o.(*goserbench.SmallStruct)
 	buf := make([]byte, 0, maxSmallStructSerializeSize)
@@ -89,9 +66,8 @@ func (b *BaselineUnsafeSerializer) Unmarshal(d []byte, o interface{}) error {
 	a.BirthDay = time.Unix(0, int64(binary.LittleEndian.Uint64(d[:8])))
 	a.Money = math.Float64frombits(binary.LittleEndian.Uint64(d[8:16]))
 	a.Siblings = int(binary.LittleEndian.Uint32(d[16:20]))
-	nameSlice, phoneSlice := d[20:36], d[36:46]
-	a.Name = *(*string)(unsafe.Pointer(&nameSlice))
-	a.Phone = *(*string)(unsafe.Pointer(&phoneSlice))
+	a.Name = unsafeSliceToString(d[20:36])
+	a.Phone = unsafeSliceToString(d[36:46])
 	a.Spouse = getBool(d[46:])
 	return nil
 }

internal/serializers/baseline/baseline_rw.go

@@ -0,0 +1,256 @@
+package baseline
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+	"math"
+	"time"
+
+	"github.com/alecthomas/go_serialization_benchmarks/goserbench"
+)
+
+// bytesMarshable is an interface for an io.Writer that can also generate a byte
+// slice and reset its size (i.e. a subset of *bytes.Buffer).
+type bytesMarshable interface {
+	io.Writer
+	Bytes() []byte
+	Reset()
+}
+
+// alwaysNilWriter is always nil. It is used to ensure the compiler does not
+// devirtualize calls to bytes.Buffer.Write().
+var alwaysNilWriter bytesMarshable
+
+// awlaysNilReader is always nil. It is used to ensure the compiler does not
+// devirtualize calls to bytes.Reader.Read().
+var awlaysNilReader io.Reader
+
+// BaselineReaderWriter is a hand-written baseline serializer that reads/writes
+// using standard io.Reader and io.Writer interfaces.
+//
+// While goserbench utlimately generates a []byte as a result of Marshal (and
+// reads from a []byte as well), this verifies the performance of using the
+// generic io interface, which could be used to write to other streams directly
+// (e.g. file or socket).
+type BaselineReaderWriter struct {
+	// Store r to avoid this allocation. This is meant to simulate the fact
+	// that Unmarshal() receives a Reader directly (instead of a []byte).
+	r *bytes.Reader
+
+	// Store w to avoid this allocation. This is meant to simulate the fact
+	// that Marshal() receives a Writer directly (instead of a []byte).
+	w *simpleBufferWriter
+
+	// aux buffer to read native values (int64, etc). Assume that the caller
+	// can amortize this allocation somehow.
+	auxBuf []byte
+
+	// aux buffer to read strings.
+	strBuf []byte
+}
+
+func (b *BaselineReaderWriter) Marshal(o interface{}) ([]byte, error) {
+	// Create a new bytes buffer. We do it like this (referencing
+	// alwaysNilWriter first) to avoid the compiler de-virtualizing and
+	// inlining the calls to w.Write() directly into bytes.Buffer.Write()
+	// calls, which simulates the worst case scenario of the overhead in
+	// using Write() calls.
+	w := alwaysNilWriter
+	if w == nil {
+		// Create with the pre-sized buffer. We assume the caller will
+		// be able to hint to the writer either the final size or at
+		// least an upper bound of what will be written, and that the
+		// writer will be able to use that hint (e.g. in case of a file,
+		// it could grow the file to allow adding that many bytes,
+		// create a kernel buffer, memory map the file, etc).
+		b.w.b = make([]byte, 0, maxSmallStructSerializeSize)
+		w = b.w
+	}
+
+	a := o.(*goserbench.SmallStruct)
+	extra := b.auxBuf[:0]
+	if _, err := w.Write(binary.LittleEndian.AppendUint64(extra, uint64(a.BirthDay.UnixNano()))); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write(binary.LittleEndian.AppendUint64(extra, math.Float64bits(a.Money))); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write(binary.LittleEndian.AppendUint32(extra, uint32(a.Siblings))); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write([]byte(a.Name)); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write([]byte(a.Phone)); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write(boolToByteSlice(a.Spouse)); err != nil {
+		return nil, err
+	}
+
+	return w.Bytes(), nil
+}
+
+func (b *BaselineReaderWriter) Unmarshal(d []byte, o interface{}) error {
+	// Create reader with passed buffer. We do it like this (referencing
+	// alwaysNilReader first) to ensure the compiler does not devirtualize
+	// and inline the Read() calls direcly to the *bytes.Buffer.
+	r := awlaysNilReader
+	if r == nil {
+		b.r.Reset(d)
+		r = b.r
+	}
+
+	a := o.(*goserbench.SmallStruct)
+	aux := b.auxBuf
+	strs := b.strBuf
+
+	if _, err := io.ReadFull(r, aux[:8]); err != nil {
+		return err
+	}
+	a.BirthDay = time.Unix(0, int64(binary.LittleEndian.Uint64(aux)))
+
+	if _, err := io.ReadFull(r, aux[:8]); err != nil {
+		return err
+	}
+	a.Money = math.Float64frombits(binary.LittleEndian.Uint64(aux))
+
+	if _, err := io.ReadFull(r, aux[:4]); err != nil {
+		return err
+	}
+	a.Siblings = int(binary.LittleEndian.Uint32(aux))
+
+	if _, err := io.ReadFull(r, strs[:goserbench.MaxSmallStructNameSize]); err != nil {
+		return err
+	}
+	a.Name = string(strs[:goserbench.MaxSmallStructNameSize])
+
+	if _, err := io.ReadFull(r, strs[:goserbench.MaxSmallStructPhoneSize]); err != nil {
+		return err
+	}
+	a.Phone = string(strs[:goserbench.MaxSmallStructPhoneSize])
+
+	if _, err := io.ReadFull(r, aux[:1]); err != nil {
+		return err
+	}
+	a.Spouse = aux[0] != 0
+	return nil
+}
+
+func NewBaselineReaderWriter() goserbench.Serializer {
+	return &BaselineReaderWriter{
+		r:      bytes.NewReader(nil),
+		w:      &simpleBufferWriter{},
+		auxBuf: make([]byte, 8),
+		strBuf: make([]byte, max(goserbench.MaxSmallStructNameSize, goserbench.MaxSmallStructPhoneSize)),
+	}
+}
+
+// BaselineReaderWriterUnsafeReuse is a hand-written baseline serializer that
+// reads/writes using standard io.Reader and io.Writer interfaces. It reuses
+// buffers and unsafe strings.
+type BaselineReaderWriterUnsafeReuse struct {
+	// w saves the buffer for writing.
+	w bytesMarshable
+
+	// r avoids having to allocate a *bytes.Reader reference.
+	r *bytes.Reader
+
+	// aux buffer to read native values (int64, etc).
+	auxBuf []byte
+
+	// aux buffer to read strings.
+	strBuf []byte
+}
+
+func (b *BaselineReaderWriterUnsafeReuse) Marshal(o interface{}) ([]byte, error) {
+	// Get a reference to the writer and reset its buffer. We do it like
+	// this (referencing alwaysNilWriter first) to ensure the compiler does
+	// not devirtualize and inline the Write() calls direcly to the
+	// *bytes.Buffer.
+	w := alwaysNilWriter
+	if w == nil {
+		w = b.w
+		w.Reset()
+	}
+
+	a := o.(*goserbench.SmallStruct)
+	extra := b.auxBuf[:0]
+	if _, err := w.Write(binary.LittleEndian.AppendUint64(extra, uint64(a.BirthDay.UnixNano()))); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write(binary.LittleEndian.AppendUint64(extra, math.Float64bits(a.Money))); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write(binary.LittleEndian.AppendUint32(extra, uint32(a.Siblings))); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write(unsafeStringToSlice(a.Name)); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write(unsafeStringToSlice(a.Phone)); err != nil {
+		return nil, err
+	}
+	if _, err := w.Write(boolToByteSlice(a.Spouse)); err != nil {
+		return nil, err
+	}
+
+	return w.Bytes(), nil
+}
+
+func (b *BaselineReaderWriterUnsafeReuse) Unmarshal(d []byte, o interface{}) error {
+	// Reset reader to passed buffer. We do it like this (referencing
+	// alwaysNilReader first) to ensure the compiler does not devirtualize
+	// and inline the Read() calls direcly to the *bytes.Buffer.
+	r := awlaysNilReader
+	if r == nil {
+		b.r.Reset(d)
+		r = b.r
+	}
+
+	a := o.(*goserbench.SmallStruct)
+	aux := b.auxBuf
+	strs := b.strBuf
+
+	if _, err := io.ReadFull(r, aux[:8]); err != nil {
+		return err
+	}
+	a.BirthDay = time.Unix(0, int64(binary.LittleEndian.Uint64(aux)))
+
+	if _, err := io.ReadFull(r, aux[:8]); err != nil {
+		return err
+	}
+	a.Money = math.Float64frombits(binary.LittleEndian.Uint64(aux))
+
+	if _, err := io.ReadFull(r, aux[:4]); err != nil {
+		return err
+	}
+	a.Siblings = int(binary.LittleEndian.Uint32(aux))
+
+	if _, err := io.ReadFull(r, strs[:goserbench.MaxSmallStructNameSize]); err != nil {
+		return err
+	}
+	a.Name = unsafeSliceToString(strs[:goserbench.MaxSmallStructNameSize])
+	strs = strs[goserbench.MaxSmallStructNameSize:]
+
+	if _, err := io.ReadFull(r, strs[:goserbench.MaxSmallStructPhoneSize]); err != nil {
+		return err
+	}
+	a.Phone = unsafeSliceToString(strs[:goserbench.MaxSmallStructPhoneSize])
+
+	if _, err := io.ReadFull(r, aux[:1]); err != nil {
+		return err
+	}
+	a.Spouse = aux[0] != 0
+	return nil
+}
+
+func NewBaselineReaderWriterUnsafeReuse() goserbench.Serializer {
+	return &BaselineReaderWriterUnsafeReuse{
+		w:      bytes.NewBuffer(make([]byte, 0, maxSmallStructSerializeSize)),
+		r:      bytes.NewReader(nil),
+		auxBuf: make([]byte, 8),
+		strBuf: make([]byte, goserbench.MaxSmallStructNameSize+goserbench.MaxSmallStructPhoneSize),
+	}
+}