github-mirrors/VictoriaMetrics
1
0
Fork 0
mirror of https://github.com/VictoriaMetrics/VictoriaMetrics.git synced 2024-12-01 14:47:38 +00:00
Code Issues Projects Releases Packages Wiki Activity
VictoriaMetrics/lib/encoding/int_timing_test.go
Aliaksandr Valialkin cc2647d212
lib/encoding: optimize UnmarshalVarUint64, UnmarshalVarInt64 and UnmarshalBytes a bit 
Change the return values for these functions - now they return the unmarshaled result plus
the size of the unmarshaled result in bytes, so the caller could re-slice the src for further unmarshaling.

This improves performance of these functions in hot loops of VictoriaLogs a bit.
2024-05-14 01:23:54 +02:00

379 lines
8.4 KiB
Go
Raw Blame History

package encoding
import (
"fmt"
"testing"
)
func BenchmarkMarshalUint64(b *testing.B) {
b.ReportAllocs()
b.SetBytes(1)
b.RunParallel(func(pb *testing.PB) {
var dst []byte
var sink uint64
for pb.Next() {
dst = MarshalUint64(dst[:0], sink)
sink += uint64(len(dst))
}
Sink.Add(sink)
})
}
func BenchmarkUnmarshalUint64(b *testing.B) {
b.ReportAllocs()
b.SetBytes(1)
b.RunParallel(func(pb *testing.PB) {
var sink uint64
for pb.Next() {
v := UnmarshalUint64(testMarshaledUint64Data)
sink += v
}
Sink.Add(sink)
})
}
func BenchmarkMarshalInt64(b *testing.B) {
b.ReportAllocs()
b.SetBytes(1)
b.RunParallel(func(pb *testing.PB) {
var dst []byte
var sink uint64
for pb.Next() {
dst = MarshalInt64(dst[:0], int64(sink))
sink += uint64(len(dst))
}
Sink.Add(sink)
})
}
func BenchmarkUnmarshalInt64(b *testing.B) {
b.ReportAllocs()
b.SetBytes(1)
b.RunParallel(func(pb *testing.PB) {
var sink uint64
for pb.Next() {
v := UnmarshalInt64(testMarshaledInt64Data)
sink += uint64(v)
}
Sink.Add(sink)
})
}
func BenchmarkMarshalVarUint64s(b *testing.B) {
b.Run("up-to-(1<<7)-1", func(b *testing.B) {
benchmarkMarshalVarUint64s(b, (1<<7)-1)
})
b.Run("up-to-(1<<14)-1", func(b *testing.B) {
benchmarkMarshalVarUint64s(b, (1<<14)-1)
})
b.Run("up-to-(1<<28)-1", func(b *testing.B) {
benchmarkMarshalVarUint64s(b, (1<<28)-1)
})
b.Run("up-to-(1<<64)-1", func(b *testing.B) {
benchmarkMarshalVarUint64s(b, (1<<64)-1)
})
}
func benchmarkMarshalVarUint64s(b *testing.B, maxValue uint64) {
const numsCount = 8000
var data []uint64
n := maxValue
for i := 0; i < numsCount; i++ {
if n > maxValue {
n = maxValue
}
data = append(data, n)
n--
}
b.ResetTimer()
b.ReportAllocs()
b.SetBytes(numsCount)
b.RunParallel(func(pb *testing.PB) {
var sink uint64
var dst []byte
for pb.Next() {
dst = MarshalVarUint64s(dst[:0], data)
sink += uint64(len(dst))
}
Sink.Add(sink)
})
}
func BenchmarkMarshalVarInt64s(b *testing.B) {
b.Run("up-to-(1<<6)-1", func(b *testing.B) {
benchmarkMarshalVarInt64s(b, (1<<6)-1)
})
b.Run("up-to-(1<<13)-1", func(b *testing.B) {
benchmarkMarshalVarInt64s(b, (1<<13)-1)
})
b.Run("up-to-(1<<27)-1", func(b *testing.B) {
benchmarkMarshalVarInt64s(b, (1<<27)-1)
})
b.Run("up-to-(1<<63)-1", func(b *testing.B) {
benchmarkMarshalVarInt64s(b, (1<<63)-1)
})
}
func benchmarkMarshalVarInt64s(b *testing.B, maxValue int64) {
const numsCount = 8000
var data []int64
n := maxValue
for i := 0; i < numsCount; i++ {
if n < -maxValue {
n = maxValue
}
data = append(data, n)
n--
}
b.ResetTimer()
b.ReportAllocs()
b.SetBytes(numsCount)
b.RunParallel(func(pb *testing.PB) {
var sink uint64
var dst []byte
for pb.Next() {
dst = MarshalVarInt64s(dst[:0], data)
sink += uint64(len(dst))
}
Sink.Add(sink)
})
}
func BenchmarkUnmarshalVarUint64(b *testing.B) {
b.Run("up-to-(1<<7)-1", func(b *testing.B) {
benchmarkUnmarshalVarUint64(b, (1<<7)-1)
})
b.Run("up-to-(1<<14)-1", func(b *testing.B) {
benchmarkUnmarshalVarUint64(b, (1<<14)-1)
})
b.Run("up-to-(1<<28)-1", func(b *testing.B) {
benchmarkUnmarshalVarUint64(b, (1<<28)-1)
})
b.Run("up-to-(1<<64)-1", func(b *testing.B) {
benchmarkUnmarshalVarUint64(b, (1<<64)-1)
})
}
func benchmarkUnmarshalVarUint64(b *testing.B, maxValue uint64) {
const numsCount = 8000
var data []byte
n := maxValue
for i := 0; i < numsCount; i++ {
if n > maxValue {
n = maxValue
}
data = MarshalVarUint64(data, n)
n--
}
b.ResetTimer()
b.ReportAllocs()
b.SetBytes(numsCount)
b.RunParallel(func(pb *testing.PB) {
var sink uint64
for pb.Next() {
src := data
for len(src) > 0 {
n, nSize := UnmarshalVarUint64(src)
if nSize <= 0 {
panic(fmt.Errorf("unexpected error"))
}
src = src[nSize:]
sink += n
}
}
Sink.Add(sink)
})
}
func BenchmarkUnmarshalVarUint64s(b *testing.B) {
b.Run("up-to-(1<<7)-1", func(b *testing.B) {
benchmarkUnmarshalVarUint64s(b, (1<<7)-1)
})
b.Run("up-to-(1<<14)-1", func(b *testing.B) {
benchmarkUnmarshalVarUint64s(b, (1<<14)-1)
})
b.Run("up-to-(1<<28)-1", func(b *testing.B) {
benchmarkUnmarshalVarUint64s(b, (1<<28)-1)
})
b.Run("up-to-(1<<64)-1", func(b *testing.B) {
benchmarkUnmarshalVarUint64s(b, (1<<64)-1)
})
}
func benchmarkUnmarshalVarUint64s(b *testing.B, maxValue uint64) {
const numsCount = 8000
var data []byte
n := maxValue
for i := 0; i < numsCount; i++ {
if n > maxValue {
n = maxValue
}
data = MarshalVarUint64(data, n)
n--
}
b.ResetTimer()
b.ReportAllocs()
b.SetBytes(numsCount)
b.RunParallel(func(pb *testing.PB) {
var sink uint64
dst := make([]uint64, numsCount)
for pb.Next() {
tail, err := UnmarshalVarUint64s(dst, data)
if err != nil {
panic(fmt.Errorf("unexpected error: %w", err))
}
if len(tail) > 0 {
panic(fmt.Errorf("unexpected non-empty tail with len=%d: %X", len(tail), tail))
}
sink += uint64(len(dst))
}
Sink.Add(sink)
})
}
func BenchmarkUnmarshalVarInt64(b *testing.B) {
b.Run("up-to-(1<<6)-1", func(b *testing.B) {
benchmarkUnmarshalVarInt64(b, (1<<6)-1)
})
b.Run("up-to-(1<<13)-1", func(b *testing.B) {
benchmarkUnmarshalVarInt64(b, (1<<13)-1)
})
b.Run("up-to-(1<<27)-1", func(b *testing.B) {
benchmarkUnmarshalVarInt64(b, (1<<27)-1)
})
b.Run("up-to-(1<<63)-1", func(b *testing.B) {
benchmarkUnmarshalVarInt64(b, (1<<63)-1)
})
}
func benchmarkUnmarshalVarInt64(b *testing.B, maxValue int64) {
const numsCount = 8000
var data []byte
n := maxValue
for i := 0; i < numsCount; i++ {
if n < -maxValue {
n = maxValue
}
data = MarshalVarInt64(data, n)
n--
}
b.ResetTimer()
b.ReportAllocs()
b.SetBytes(numsCount)
b.RunParallel(func(pb *testing.PB) {
var sink uint64
for pb.Next() {
src := data
for len(src) > 0 {
n, nSize := UnmarshalVarInt64(src)
if nSize <= 0 {
panic(fmt.Errorf("unexpected error"))
}
src = src[nSize:]
sink += uint64(n)
}
}
Sink.Add(sink)
})
}
func BenchmarkUnmarshalVarInt64s(b *testing.B) {
b.Run("up-to-(1<<6)-1", func(b *testing.B) {
benchmarkUnmarshalVarInt64s(b, (1<<6)-1)
})
b.Run("up-to-(1<<13)-1", func(b *testing.B) {
benchmarkUnmarshalVarInt64s(b, (1<<13)-1)
})
b.Run("up-to-(1<<27)-1", func(b *testing.B) {
benchmarkUnmarshalVarInt64s(b, (1<<27)-1)
})
b.Run("up-to-(1<<63)-1", func(b *testing.B) {
benchmarkUnmarshalVarInt64s(b, (1<<63)-1)
})
}
func benchmarkUnmarshalVarInt64s(b *testing.B, maxValue int64) {
const numsCount = 8000
var data []byte
n := maxValue
for i := 0; i < numsCount; i++ {
if n < -maxValue {
n = maxValue
}
data = MarshalVarInt64(data, n)
n--
}
b.ResetTimer()
b.ReportAllocs()
b.SetBytes(numsCount)
b.RunParallel(func(pb *testing.PB) {
var sink uint64
dst := make([]int64, numsCount)
for pb.Next() {
tail, err := UnmarshalVarInt64s(dst, data)
if err != nil {
panic(fmt.Errorf("unexpected error: %w", err))
}
if len(tail) > 0 {
panic(fmt.Errorf("unexpected non-empty tail with len=%d: %X", len(tail), tail))
}
sink += uint64(len(dst))
}
Sink.Add(sink)
})
}
func BenchmarkMarshalVarUint64(b *testing.B) {
b.Run("small-ints", func(b *testing.B) {
benchmarkMarshalVarUint64(b, []uint64{1, 2, 3, 4, 5, 67, 127})
})
b.Run("big-ints", func(b *testing.B) {
benchmarkMarshalVarUint64(b, []uint64{12355, 89832432, 8989843, 8989989, 883443, 9891233, 8232434342})
})
}
func benchmarkMarshalVarUint64(b *testing.B, a []uint64) {
b.ReportAllocs()
b.SetBytes(int64(len(a)))
b.RunParallel(func(pb *testing.PB) {
var buf []byte
var sink uint64
for pb.Next() {
buf = buf[:0]
for _, n := range a {
buf = MarshalVarUint64(buf, n)
}
sink += uint64(len(buf))
}
Sink.Add(sink)
})
}
func BenchmarkMarshalVarInt64(b *testing.B) {
b.Run("small-ints", func(b *testing.B) {
benchmarkMarshalVarInt64(b, []int64{1, 2, 3, -4, 5, -60, 63})
})
b.Run("big-ints", func(b *testing.B) {
benchmarkMarshalVarInt64(b, []int64{12355, -89832432, 8989843, -8989989, 883443, -9891233, 8232434342})
})
}
func benchmarkMarshalVarInt64(b *testing.B, a []int64) {
b.ReportAllocs()
b.SetBytes(int64(len(a)))
b.RunParallel(func(pb *testing.PB) {
var buf []byte
var sink uint64
for pb.Next() {
buf = buf[:0]
for _, n := range a {
buf = MarshalVarInt64(buf, n)
}
sink += uint64(len(buf))
}
Sink.Add(sink)
})
}
var testMarshaledInt64Data = MarshalInt64(nil, 1234567890)
var testMarshaledUint64Data = MarshalUint64(nil, 1234567890)
Reference in a new issue View git blame Copy permalink