TL1/TL2/Protobuf speed benchmarks

go.mod

@@ -8,6 +8,7 @@ require (
 	github.com/charmbracelet/bubbletea v1.3.4
 	github.com/dchest/siphash v1.2.3
 	github.com/dgryski/go-maglev v0.0.0-20200611225407-8961b9b1b8e6
+	github.com/golang/protobuf v1.5.0
 	github.com/google/btree v1.1.3
 	github.com/google/flatbuffers v24.12.23+incompatible
 	github.com/google/go-cmp v0.7.0

go.sum

@@ -26,11 +26,14 @@ github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
 github.com/go-faster/xor v0.3.0 h1:tc0bdVe31Wj999e5rEj7K3DhHyQNp2VydYyLFj3YSN8=
 github.com/go-faster/xor v0.3.0/go.mod h1:x5CaDY9UKErKzqfRfFZdfu+OSTfoZny3w5Ak7UxcipQ=
+github.com/golang/protobuf v1.5.0 h1:LUVKkCeviFUMKqHa4tXIIij/lbhnMbP7Fn5wKdKkRh4=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg=
 github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
 github.com/google/flatbuffers v24.12.23+incompatible h1:ubBKR94NR4pXUCY/MUsRVzd9umNW7ht7EG9hHfS9FX8=
 github.com/google/flatbuffers v24.12.23+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/gotd/ige v0.2.2 h1:XQ9dJZwBfDnOGSTxKXBGP4gMud3Qku2ekScRjDWWfEk=
@@ -97,6 +100,8 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
 google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=

internal/speed/Makefile

@@ -2,3 +2,90 @@
 .PHONY: proto
 proto:
 	protoc --go_out=../../../../../../.. speed.proto
+
+
+.PHONY: gen_methods
+gen_methods:
+	bash scripts/create_proto.sh
+	bash scripts/create_tl.sh
+
+COUNT ?= 3
+
+.PHONY: all_benchmarks
+all_benchmarks:
+	go test -bench=. -count=$(COUNT)
+
+.PHONY: all_new_benchmarks
+all_new_benchmarks:
+	go test -bench='^BenchmarkNew' -count=$(COUNT)
+
+
+# ----------- POINT ---------------
+.PHONY: point_write_gen
+point_write_gen:
+	go test -bench='^BenchmarkPointWrite.*Gen' -count=$(COUNT)
+
+.PHONY: point_write
+point_write:
+	go test -bench='^BenchmarkPointWrite' -count=$(COUNT)
+
+.PHONY: point_read_gen
+point_read_gen:
+	go test -bench='^BenchmarkPointRead.*Gen' -count=$(COUNT)
+
+.PHONY: point_read
+point_read:
+	go test -bench='^BenchmarkPointRead' -count=$(COUNT)
+
+# ----------- POINTS ---------------
+.PHONY: points_read_gen
+points_read_gen:
+	go test -bench='^BenchmarkPointsRead.*Gen' -count=$(COUNT)
+
+.PHONY: points_write_gen
+points_write_gen:
+	go test -bench='^BenchmarkPointsWrite.*Gen' -count=$(COUNT)
+
+.PHONY: points_new_write_gen
+points_new_write_gen:
+	go test -bench='^BenchmarkNewPoints/Write' -count=$(COUNT)
+
+.PHONY: points_new_read_gen
+points_new_read_gen:
+	go test -bench='^BenchmarkNewPoints/Read' -count=$(COUNT)
+
+
+# ----------- memcache.value ---------------
+.PHONY: memcache_value_read_gen
+memcache_value_read_gen:
+	go test -bench='^BenchmarkMemcacheValueRead.*Gen' -count=$(COUNT)
+
+.PHONY: memcache_value_write_gen
+memcache_value_write_gen:
+	go test -bench='^BenchmarkMemcacheValueWrite.*Gen' -count=$(COUNT)
+
+.PHONY: memcache_value_new_read_gen
+memcache_value_new_read_gen:
+	go test -bench='^BenchmarkNewMemcacheValue/Read' -count=$(COUNT)
+
+.PHONY: memcache_value_new_write_gen
+memcache_value_new_write_gen:
+	go test -bench='^BenchmarkNewMemcacheValue/Write' -count=$(COUNT)
+
+
+# ----------- memcache.values ---------------
+.PHONY: memcache_values_read_gen
+memcache_values_read_gen:
+	go test -bench='^BenchmarkMemcacheValuesRead.*Gen' -count=$(COUNT)
+
+.PHONY: memcache_values_write_gen
+memcache_values_write_gen:
+	go test -bench='^BenchmarkMemcacheValuesWrite.*Gen' -count=$(COUNT)
+
+.PHONY: memcache_values_new_read_gen
+memcache_values_new_read_gen:
+	go test -bench='^BenchmarkNewMemcacheValues/Read' -count=$(COUNT)
+
+.PHONY: memcache_values_new_write_gen
+memcache_values_new_write_gen:
+	go test -bench='^BenchmarkNewMemcacheValues/Write' -count=$(COUNT)

internal/speed/bench_base.go

@@ -0,0 +1,270 @@
+package speed
+
+import (
+	"testing"
+
+	"github.com/VKCOM/tl/internal/speed/speed_tl/basictl"
+	"google.golang.org/protobuf/encoding/protowire"
+)
+
+type TLData[T any] struct {
+	WriteTL1Boxed func(x *T, buf []byte) []byte
+	ReadTL1Boxed  func(x *T, buf []byte) ([]byte, error)
+
+	WriteTL2 func(x *T, w []byte, tctx *basictl.TL2WriteContext) []byte
+	ReadTL2  func(x *T, r []byte, tctx *basictl.TL2ReadContext) (_ []byte, err error)
+}
+
+type ProtoData[P any] struct {
+	Size func(x *P) int
+
+	MarshalToSizedBuffer func(x *P, dAtA []byte) (int, error)
+	Marshal              func(x *P) (dAtA []byte, err error)
+
+	Unmarshal func(x *P, dAtA []byte) error
+}
+
+type benchDataGenerator[T, P any] struct {
+	TLProvider    TLData[T]
+	ProtoProvider ProtoData[P]
+
+	GenerateSamples func() []T
+	GenerateBuffer  func() []byte
+	MapSample       func(T) P
+
+	CompareTLResult    func(*T, *T) bool
+	CompareProtoResult func(*P, *P) bool
+}
+
+func benchBase[T, P any](b *testing.B, gen benchDataGenerator[T, P]) {
+	values := gen.GenerateSamples()
+	protoValues := make([]P, len(values))
+	for i := range protoValues {
+		protoValues[i] = gen.MapSample(values[i])
+	}
+
+	b.Run("Read", func(b *testing.B) {
+		b.Run("TL1", func(b *testing.B) {
+			buf := gen.GenerateBuffer()
+			for i := range values {
+				buf = gen.TLProvider.WriteTL1Boxed(&values[i], buf)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			finish := b.N / len(values)
+
+			var p T
+
+			for i := 0; i < finish; i++ {
+				buf2 := buf
+				for range values {
+					var err error
+
+					buf2, err = gen.TLProvider.ReadTL1Boxed(&p, buf2)
+					if err != nil {
+						b.Fatalf("bad")
+					}
+					//if gen.CompareTLResult != nil && !gen.CompareTLResult(&p, &v) {
+					//	b.Fatalf("bad")
+					//}
+				}
+				if len(buf2) != 0 {
+					b.Fatalf("bad")
+				}
+			}
+			printSizes(b, int64(len(buf))*int64(finish))
+		})
+
+		b.Run("TL2", func(b *testing.B) {
+			buf := gen.GenerateBuffer()
+			ctx := basictl.TL2WriteContext{SizeBuffer: make([]int, 10000)}
+
+			for i := range values {
+				buf = gen.TLProvider.WriteTL2(&values[i], buf, &ctx)
+			}
+
+			b.ReportAllocs()
+			b.ResetTimer()
+			finish := b.N / len(values)
+
+			var p T
+
+			for i := 0; i < finish; i++ {
+				buf2 := buf
+				for range values {
+					var err error
+
+					buf2, err = gen.TLProvider.ReadTL2(&p, buf2, nil)
+					if err != nil {
+						b.Fatalf("bad")
+					}
+					//if gen.CompareTLResult != nil && !gen.CompareTLResult(p, v) {
+					//	b.Fatalf("bad")
+					//}
+				}
+				if len(buf2) != 0 {
+					b.Fatalf("bad")
+				}
+			}
+			printSizes(b, int64(len(buf))*int64(finish))
+		})
+
+		//b.Run("Proto", func(b *testing.B) {
+		//	b.Run("New_Object", func(b *testing.B) {
+		b.Run("Proto_New_Object", func(b *testing.B) {
+			buf := gen.GenerateBuffer()
+			for j := range protoValues {
+				tmpBuf, err := gen.ProtoProvider.Marshal(&protoValues[j])
+				if err != nil {
+					b.Fatalf("bad")
+				}
+				buf = protowire.AppendBytes(buf, tmpBuf)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			finish := b.N / len(protoValues)
+
+			for i := 0; i < finish; i++ {
+				buf2 := buf
+				for j := 0; j < len(protoValues); j++ {
+					var err error
+					var p P
+
+					str, n := protowire.ConsumeBytes(buf2)
+					if n < 0 {
+						b.Fatalf("bad")
+					}
+					buf2 = buf2[n:]
+					err = gen.ProtoProvider.Unmarshal(&p, str)
+					if err != nil {
+						b.Fatalf("bad")
+					}
+
+					//if gen.CompareProtoResult != nil {
+					//	if !gen.CompareProtoResult(p, protoValues[j]) {
+					//		b.Fatalf("bad")
+					//	}
+					//}
+				}
+				if len(buf2) != 0 {
+					b.Fatalf("bad")
+				}
+			}
+			printSizes(b, int64(len(buf))*int64(finish))
+		})
+
+		b.Run("Proto_Same_Object", func(b *testing.B) {
+			//b.Run("Same_Object", func(b *testing.B) {
+			buf := gen.GenerateBuffer()
+			for j := range protoValues {
+				tmpBuf, err := gen.ProtoProvider.Marshal(&protoValues[j])
+				if err != nil {
+					b.Fatalf("bad")
+				}
+				buf = protowire.AppendBytes(buf, tmpBuf)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			finish := b.N / len(protoValues)
+
+			var p P
+
+			for i := 0; i < finish; i++ {
+				buf2 := buf
+				for j := 0; j < len(protoValues); j++ {
+					var err error
+
+					str, n := protowire.ConsumeBytes(buf2)
+					if n < 0 {
+						b.Fatalf("bad")
+					}
+					buf2 = buf2[n:]
+					err = gen.ProtoProvider.Unmarshal(&p, str)
+					if err != nil {
+						b.Fatalf("bad")
+					}
+
+					//if gen.CompareProtoResult != nil {
+					//	if !gen.CompareProtoResult(p, protoValues[j]) {
+					//		b.Fatalf("bad")
+					//	}
+					//}
+				}
+				if len(buf2) != 0 {
+					b.Fatalf("bad")
+				}
+			}
+			printSizes(b, int64(len(buf))*int64(finish))
+		})
+		//})
+	})
+
+	b.Run("Write", func(b *testing.B) {
+		b.Run("TL1", func(b *testing.B) {
+			buf := gen.GenerateBuffer()
+
+			b.ReportAllocs()
+			b.ResetTimer()
+			var total int64
+			finish := b.N / len(values)
+			for i := 0; i < finish; i++ {
+				for j := range values {
+					buf = gen.TLProvider.WriteTL1Boxed(&values[j], buf)
+				}
+				if len(buf) > bufferSize/2 {
+					total += int64(len(buf))
+					buf = buf[:0]
+				}
+			}
+
+			printSizes(b, total+int64(len(buf)))
+		})
+
+		b.Run("TL2", func(b *testing.B) {
+			buf := gen.GenerateBuffer()
+			ctx := basictl.TL2WriteContext{SizeBuffer: make([]int, 1000)}
+
+			b.ReportAllocs()
+			b.ResetTimer()
+			var total int64
+			finish := b.N / len(values)
+			for i := 0; i < finish; i++ {
+				for j := range values {
+					buf = gen.TLProvider.WriteTL2(&values[j], buf, &ctx)
+				}
+				if len(buf) > bufferSize/2 {
+					total += int64(len(buf))
+					buf = buf[:0]
+				}
+			}
+
+			printSizes(b, total+int64(len(buf)))
+		})
+
+		b.Run("Proto", func(b *testing.B) {
+			buf := gen.GenerateBuffer()
+
+			b.ReportAllocs()
+			b.ResetTimer()
+			var total int64
+			finish := b.N / len(protoValues)
+			for i := 0; i < finish; i++ {
+				for vIndex := range protoValues {
+					s := gen.ProtoProvider.Size(&protoValues[vIndex])
+					pointer := len(buf)
+					buf = append(buf, make([]byte, s)...)
+
+					_, err := gen.ProtoProvider.MarshalToSizedBuffer(&protoValues[vIndex], buf[pointer:])
+					if err != nil {
+						b.Fatal(err)
+					}
+				}
+				if len(buf) > bufferSize/2 {
+					total += int64(len(buf))
+					buf = buf[:0]
+				}
+			}
+			printSizes(b, total+int64(len(buf)))
+		})
+	})
+}