encoding: add simple benchmarks to compare V1 vs V2
name old time/op new time/op delta
TextEncode-4 7.70ms ± 2% 18.57ms ± 3% +141.06% (p=0.000 n=10+9)
TextDecode-4 9.62ms ± 6% 252.85ms ±10% +2529.10% (p=0.000 n=10+10)
JSONEncode-4 30.3ms ± 0% 10.7ms ± 7% -64.80% (p=0.000 n=9+9)
JSONDecode-4 54.1ms ± 0% 880.1ms ± 3% +1526.65% (p=0.000 n=9+10)
name old alloc/op new alloc/op delta
TextEncode-4 3.98MB ± 0% 28.90MB ± 0% +626.36% (p=0.000 n=10+10)
TextDecode-4 2.74MB ± 0% 1158.24MB ± 0% +42114.16% (p=0.000 n=10+8)
JSONEncode-4 10.3MB ± 0% 3.9MB ± 0% -61.74% (p=0.000 n=10+9)
JSONDecode-4 19.0MB ± 0% 3349.9MB ± 0% +17534.57% (p=0.000 n=10+10)
name old allocs/op new allocs/op delta
TextEncode-4 43.9k ± 0% 73.5k ± 0% +67.53% (p=0.000 n=10+10)
TextDecode-4 56.2k ± 0% 277.1k ± 0% +393.31% (p=0.000 n=8+8)
JSONEncode-4 465k ± 0% 64k ± 0% -86.30% (p=0.000 n=10+10)
JSONDecode-4 289k ± 0% 247k ± 0% -14.58% (p=0.000 n=10+10)
Change-Id: I593a52445b6356eec1488236d5f1f1a8c4b62cb3
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/172137
Reviewed-by: Damien Neil <dneil@google.com>
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
diff --git a/encoding/bench_test.go b/encoding/bench_test.go
new file mode 100644
index 0000000..ca866c0
--- /dev/null
+++ b/encoding/bench_test.go
@@ -0,0 +1,213 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package encoding_test
+
+import (
+ "flag"
+ "fmt"
+ "testing"
+
+ jsonpbV1 "github.com/golang/protobuf/jsonpb"
+ protoV1 "github.com/golang/protobuf/proto"
+ "github.com/golang/protobuf/v2/encoding/jsonpb"
+ "github.com/golang/protobuf/v2/encoding/textpb"
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+
+ tpb "github.com/golang/protobuf/v2/internal/testprotos/test"
+)
+
+// The results of these microbenchmarks are unlikely to correspond well
+// to real world peformance. They are mainly useful as a quick check to
+// detect unexpected regressions and for profiling specific cases.
+
+var benchV1 = flag.Bool("v1", false, "benchmark the v1 implementation")
+
+const (
+ boolValue = true
+ intValue = 1 << 30
+ floatValue = 3.14159265
+ strValue = "hello world"
+
+ maxRecurseLevel = 3
+)
+
+func makeProto() *tpb.TestAllTypes {
+ m := &tpb.TestAllTypes{}
+ fillMessage(m.ProtoReflect(), 0)
+ return m
+}
+
+func fillMessage(m pref.Message, level int) {
+ if level > maxRecurseLevel {
+ return
+ }
+
+ knownFields := m.KnownFields()
+ fieldDescs := m.Type().Fields()
+ for i := 0; i < fieldDescs.Len(); i++ {
+ fd := fieldDescs.Get(i)
+ num := fd.Number()
+ if cardinality := fd.Cardinality(); cardinality == pref.Repeated {
+ if !fd.IsMap() {
+ setList(knownFields.Get(num).List(), fd, level)
+ } else {
+ setMap(knownFields.Get(num).Map(), fd, level)
+ }
+ } else {
+ setScalarField(knownFields, fd, level)
+ }
+ }
+}
+
+func setScalarField(knownFields pref.KnownFields, fd pref.FieldDescriptor, level int) {
+ num := fd.Number()
+ switch fd.Kind() {
+ case pref.MessageKind, pref.GroupKind:
+ m := knownFields.NewMessage(num)
+ fillMessage(m, level+1)
+ knownFields.Set(num, pref.ValueOf(m))
+ default:
+ knownFields.Set(num, scalarField(fd.Kind()))
+ }
+}
+
+func scalarField(kind pref.Kind) pref.Value {
+ switch kind {
+ case pref.BoolKind:
+ return pref.ValueOf(boolValue)
+
+ case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+ return pref.ValueOf(int32(intValue))
+
+ case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+ return pref.ValueOf(int64(intValue))
+
+ case pref.Uint32Kind, pref.Fixed32Kind:
+ return pref.ValueOf(uint32(intValue))
+
+ case pref.Uint64Kind, pref.Fixed64Kind:
+ return pref.ValueOf(uint64(intValue))
+
+ case pref.FloatKind:
+ return pref.ValueOf(float32(floatValue))
+
+ case pref.DoubleKind:
+ return pref.ValueOf(float64(floatValue))
+
+ case pref.BytesKind:
+ return pref.ValueOf([]byte(strValue))
+
+ case pref.StringKind:
+ return pref.ValueOf(strValue)
+
+ case pref.EnumKind:
+ return pref.ValueOf(pref.EnumNumber(42))
+ }
+
+ panic(fmt.Sprintf("FieldDescriptor.Kind %v is not valid", kind))
+}
+
+func setList(list pref.List, fd pref.FieldDescriptor, level int) {
+ switch fd.Kind() {
+ case pref.MessageKind, pref.GroupKind:
+ for i := 0; i < 10; i++ {
+ m := list.NewMessage()
+ fillMessage(m, level+1)
+ list.Append(pref.ValueOf(m))
+ }
+ default:
+ for i := 0; i < 100; i++ {
+ list.Append(scalarField(fd.Kind()))
+ }
+ }
+}
+
+func setMap(mmap pref.Map, fd pref.FieldDescriptor, level int) {
+ fields := fd.MessageType().Fields()
+ keyDesc := fields.ByNumber(1)
+ valDesc := fields.ByNumber(2)
+
+ pkey := scalarField(keyDesc.Kind())
+ switch kind := valDesc.Kind(); kind {
+ case pref.MessageKind, pref.GroupKind:
+ m := mmap.NewMessage()
+ fillMessage(m, level+1)
+ mmap.Set(pkey.MapKey(), pref.ValueOf(m))
+ default:
+ mmap.Set(pkey.MapKey(), scalarField(kind))
+ }
+}
+
+func BenchmarkTextEncode(b *testing.B) {
+ m := makeProto()
+ for i := 0; i < b.N; i++ {
+ if *benchV1 {
+ protoV1.MarshalTextString(m)
+ } else {
+ _, err := textpb.MarshalOptions{Indent: " "}.Marshal(m)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+ }
+}
+
+func BenchmarkTextDecode(b *testing.B) {
+ m := makeProto()
+ in, err := textpb.MarshalOptions{Indent: " "}.Marshal(m)
+ if err != nil {
+ b.Fatal(err)
+ }
+
+ for i := 0; i < b.N; i++ {
+ m := &tpb.TestAllTypes{}
+ var err error
+ if *benchV1 {
+ err = protoV1.UnmarshalText(string(in), m)
+ } else {
+ err = textpb.Unmarshal(m, in)
+ }
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func BenchmarkJSONEncode(b *testing.B) {
+ m := makeProto()
+ for i := 0; i < b.N; i++ {
+ var err error
+ if *benchV1 {
+ jsm := &jsonpbV1.Marshaler{Indent: " "}
+ _, err = jsm.MarshalToString(m)
+ } else {
+ _, err = jsonpb.MarshalOptions{Indent: " "}.Marshal(m)
+ }
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func BenchmarkJSONDecode(b *testing.B) {
+ m := makeProto()
+ out, err := jsonpb.MarshalOptions{Indent: " "}.Marshal(m)
+ if err != nil {
+ b.Fatal(err)
+ }
+
+ for i := 0; i < b.N; i++ {
+ m := &tpb.TestAllTypes{}
+ var err error
+ if *benchV1 {
+ err = jsonpbV1.UnmarshalString(string(out), m)
+ } else {
+ err = jsonpb.Unmarshal(m, out)
+ }
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
