mirror of
https://github.com/buger/goreplay.git
synced 2024-04-21 12:32:02 +00:00
Urban IshimweandGitHub
9519b9a9f5
The focus here was to **reduce allocation in TCP parser** but speed may have hopeful improved too! pool no longer use map's key of **string** it uses **uint64** **Benchmarks** was revamped to be more clear if you want to compare these results copy the benchmark in tcp/bench_test.go@reduce-allocation to tcp/bench_test.go@master: **before(master)**: ``` BenchmarkPacketParseAndSort-4 1000000 1006 ns/op 64 B/op 2 allocs/op BenchmarkMessageParserWithoutHint-4 625 1772309 ns/op 1000 packets/op 419096 B/op 10045 allocs/op BenchmarkMessageParserWithHint-4 74 14969926 ns/op 1000 chunks/op 1002 packets/op 450992 B/op 10126 allocs/op ``` **After(this branch)**: ``` BenchmarkPacketParseAndSort-4 1267662 941 ns/op 64 B/op 2 allocs/op BenchmarkMessageParserWithoutHint-4 2256 523474 ns/op 1000 packets/op 243530 B/op 1037 allocs/op BenchmarkMessageParserWithHint-4 80 13990955 ns/op 1000 chunks/op 1002 packets/op 268609 B/op 1099 allocs/op ```
53 lines
1.1 KiB
Go
53 lines
1.1 KiB
Go
// Package byteutils provides helpers for working with byte slices
|
|
package byteutils
|
|
|
|
import (
|
|
"unsafe"
|
|
)
|
|
|
|
// Cut elements from slice for a given range
|
|
func Cut(a []byte, from, to int) []byte {
|
|
copy(a[from:], a[to:])
|
|
a = a[:len(a)-to+from]
|
|
|
|
return a
|
|
}
|
|
|
|
// Insert new slice at specified position
|
|
func Insert(a []byte, i int, b []byte) []byte {
|
|
a = append(a, make([]byte, len(b))...)
|
|
copy(a[i+len(b):], a[i:])
|
|
copy(a[i:i+len(b)], b)
|
|
|
|
return a
|
|
}
|
|
|
|
// Replace function unlike bytes.Replace allows you to specify range
|
|
func Replace(a []byte, from, to int, new []byte) []byte {
|
|
lenDiff := len(new) - (to - from)
|
|
|
|
if lenDiff > 0 {
|
|
// Extend if new segment bigger
|
|
a = append(a, make([]byte, lenDiff)...)
|
|
copy(a[to+lenDiff:], a[to:])
|
|
copy(a[from:from+len(new)], new)
|
|
|
|
return a
|
|
}
|
|
|
|
if lenDiff < 0 {
|
|
copy(a[from:], new)
|
|
copy(a[from+len(new):], a[to:])
|
|
return a[:len(a)+lenDiff]
|
|
}
|
|
|
|
// same size
|
|
copy(a[from:], new)
|
|
return a
|
|
}
|
|
|
|
// SliceToString preferred for large body payload (zero allocation and faster)
|
|
func SliceToString(buf []byte) string {
|
|
return *(*string)(unsafe.Pointer(&buf))
|
|
}
|