Is there a more efficient function for finding []byte similarities? - performance

Question

I am looking for an efficient way to find the prefix similarity between two byte slices. I am currently using this but am looking for a more efficient way if possible.
Thank you.
s1 -> [0 15 136 96 88 76 0 0 0 1]
s2 -> [0 15 136 96 246 1 255 255 255 255]
output -> [0 15 136 96]
func bytesSimilar(s1 []byte, s2 []byte) []byte {
for !bytes.Equal(s1,s2) {
s1 = s1[:len(s1)-1]
s2 = s2[:len(s2)-1]
}
return s1
}
Benchmarking code:
func BenchmarkBytePrefix200(b *testing.B) {
s1 := []byte{0, 15, 136, 96, 88, 76, 0, 0, 0, 1}
s2 := []byte{0, 15, 136, 96, 246, 1, 255, 255, 255, 255}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
bytePrefix(s1, s2)
}
}
Results on an MBP:
BenchmarkBytePrefix200-8 48738078 29.5 ns/op 0 B/op 0 allocs/op

Answer 1

My opinion, from your code above, the following section is very expensive on I/O resource
s1 = s1[:len(s1)-1]
s2 = s2[:len(s2)-1]
We can actually just do a simple loop and exit early when different byte found. With this approach, we don't need much memory allocation process. It is more lines in code, but better performance.
Code is as below
func bytesSimilar2(s1 []byte, s2 []byte) []byte {
l1 := len(s1)
l2 := len(s2)
least := l1
if least > l2 {
least = l2
}
count := 0
for i := 0; i < least; i++ {
if s1[i] == s2[i] {
count++
continue
}
break
}
if count == 0 {
return []byte{}
}
return s1[:count]
}
func BenchmarkBytePrefix200v1(b *testing.B) {
s1 := []byte{0, 15, 136, 96, 88, 76, 0, 0, 0, 1}
s2 := []byte{0, 15, 136, 96, 246, 1, 255, 255, 255, 255}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
bytesSimilar1(s1, s2)
}
}
func BenchmarkBytePrefix200v2(b *testing.B) {
s1 := []byte{0, 15, 136, 96, 88, 76, 0, 0, 0, 1}
s2 := []byte{0, 15, 136, 96, 246, 1, 255, 255, 255, 255}
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
bytesSimilar2(s1, s2)
}
}
The comparison result is per below, 38.7ns/op vs 7.40ns/op
goos: darwin
goarch: amd64
pkg: git.kanosolution.net/kano/acl
BenchmarkBytePrefix200v1-8 27184414 38.7 ns/op 0 B/op 0 allocs/op
BenchmarkBytePrefix200v2-8 161031307 7.40 ns/op 0 B/op 0 allocs/op
PASS

Answer 2

In case bytePrefix is the same as bytesSimilar in your question:
func BytesSimilarNew(s1 []byte, s2 []byte) []byte {
for i := 0; i < len(s1); i++ {
if s1[i] ^ s2[i] > 0 {
return s1[:i]
}
}
return []byte{}
}
then the comparison:
BenchmarkBytePrefix200
BenchmarkBytePrefix200-8 28900861 36.5 ns/op 0 B/op 0 allocs/op
BenchmarkByteSimilarNew200
BenchmarkByteSimilarNew200-8 237646268 5.06 ns/op 0 B/op 0 allocs/op
PASS