mirror of
https://github.com/hanzos3/crc64nvme.git
synced 2026-10-30 19:54:48 +00:00
`VMOVDQA` uses AVX encoding and will crash on non-avx machines. #### Bonus * Prefetch in avx512 - 50% faster on out-of-cache data. 36465.21 MB/s -> 71629.42 MB/s @64MiB blocks. * Skip calling asm if alignment caused size to be < 128. * Test with different alignments. * Extend benchmarks.
210 lines
4.5 KiB
Go
210 lines
4.5 KiB
Go
// Copyright (c) 2025 Minio Inc. All rights reserved.
|
|
// Use of this source code is governed by a license that can be
|
|
// found in the LICENSE file.
|
|
|
|
package crc64nvme
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"hash"
|
|
"hash/crc64"
|
|
"io"
|
|
"math/rand"
|
|
"runtime"
|
|
"sync/atomic"
|
|
"testing"
|
|
)
|
|
|
|
var crc64Table = crc64.MakeTable(NVME)
|
|
|
|
func TestChecksum(t *testing.T) {
|
|
if hasAsm {
|
|
if hasAsm512 {
|
|
testChecksum(t, "asm512-")
|
|
hasAsm512 = false
|
|
defer func() {
|
|
hasAsm512 = true
|
|
}()
|
|
}
|
|
testChecksum(t, "asm-")
|
|
hasAsm = false
|
|
testChecksum(t, "")
|
|
hasAsm = true
|
|
} else {
|
|
testChecksum(t, "")
|
|
}
|
|
}
|
|
|
|
func testChecksum(t *testing.T, asm string) {
|
|
sizes := []int{0, 1, 3, 7, 8, 9, 15, 17, 127, 128, 129, 255, 256, 257, 511, 512, 513, 1e3, 1e4, 1e5, 1e6}
|
|
for _, size := range sizes {
|
|
t.Run(fmt.Sprintf("%ssize=%d", asm, size), func(t *testing.T) {
|
|
rng := rand.New(rand.NewSource(int64(size)))
|
|
for align := range 16 {
|
|
t.Run(fmt.Sprintf("align=%d", align), func(t *testing.T) {
|
|
data := make([]byte, size+align)[align:]
|
|
rng.Read(data)
|
|
ref := crc64.Checksum(data, crc64Table)
|
|
got := Checksum(data)
|
|
if got != ref {
|
|
t.Errorf("got 0x%x, want 0x%x", got, ref)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHasher(t *testing.T) {
|
|
if hasAsm {
|
|
if hasAsm512 {
|
|
testChecksum(t, "asm512-")
|
|
hasAsm512 = false
|
|
defer func() {
|
|
hasAsm512 = true
|
|
}()
|
|
}
|
|
testHasher(t, "asm-")
|
|
hasAsm = false
|
|
testHasher(t, "")
|
|
hasAsm = true
|
|
} else {
|
|
testHasher(t, "")
|
|
}
|
|
}
|
|
|
|
func testHasher(t *testing.T, asm string) {
|
|
sizes := []int{0, 1, 3, 7, 8, 9, 15, 17, 127, 128, 129, 255, 256, 257, 383, 384, 385, 1e3, 1e4, 1e5, 1e6}
|
|
for _, size := range sizes {
|
|
t.Run(fmt.Sprintf("%ssize=%d", asm, size), func(t *testing.T) {
|
|
rng := rand.New(rand.NewSource(int64(size)))
|
|
data := make([]byte, size)
|
|
rng.Read(data)
|
|
ref := crc64.Checksum(data, crc64Table)
|
|
h := New()
|
|
io.CopyBuffer(h, bytes.NewReader(data), make([]byte, 17))
|
|
got := h.Sum64()
|
|
if got != ref {
|
|
t.Errorf("got 0x%x, want 0x%x", got, ref)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoopAlignment(t *testing.T) {
|
|
for l := 128; l <= 128*10; l++ {
|
|
dataBlock := make([]byte, l)
|
|
for i := range dataBlock {
|
|
dataBlock[i] = byte(i + 1)
|
|
}
|
|
|
|
// make sure we don't start on an aligned boundary
|
|
offset := rand.Intn(16)
|
|
data := dataBlock[offset:]
|
|
|
|
ref := crc64.Checksum(data, crc64Table)
|
|
got := update(0, data)
|
|
if got != ref {
|
|
t.Errorf("got 0x%x, want 0x%x", got, ref)
|
|
}
|
|
}
|
|
}
|
|
|
|
func setAsm(asm, asm512 bool) (reset func()) {
|
|
oldAsm := hasAsm
|
|
oldAsm512 := hasAsm512
|
|
hasAsm = asm
|
|
hasAsm512 = asm512
|
|
return func() {
|
|
hasAsm = oldAsm
|
|
hasAsm512 = oldAsm512
|
|
}
|
|
}
|
|
|
|
func BenchmarkCrc64(b *testing.B) {
|
|
for _, sz := range []int64{64 << 20, 4 << 20, 1 << 20, 64 << 10, 4 << 10, 1 << 10, 128, 10} {
|
|
if hasAsm512 {
|
|
b.Run(fmt.Sprint(sz, "-asm512"), func(b *testing.B) {
|
|
defer setAsm(true, true)()
|
|
bench(b, New(), sz)
|
|
})
|
|
}
|
|
if hasAsm {
|
|
b.Run(fmt.Sprint(sz, "-asm"), func(b *testing.B) {
|
|
defer setAsm(true, false)()
|
|
bench(b, New(), sz)
|
|
})
|
|
}
|
|
b.Run(fmt.Sprint(sz, "-go"), func(b *testing.B) {
|
|
defer setAsm(false, false)()
|
|
bench(b, New(), sz)
|
|
})
|
|
b.Run(fmt.Sprint(sz, "-stdlib"), func(b *testing.B) {
|
|
bench(b, crc64.New(crc64Table), sz)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func bench(b *testing.B, h hash.Hash64, size int64) {
|
|
b.SetBytes(size)
|
|
data := make([]byte, size)
|
|
for i := range data {
|
|
data[i] = byte(i)
|
|
}
|
|
in := make([]byte, 0, h.Size())
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
h.Reset()
|
|
h.Write(data)
|
|
h.Sum(in)
|
|
}
|
|
}
|
|
|
|
func benchmarkParallel(b *testing.B, size int) {
|
|
hashes := make([]hash.Hash64, runtime.GOMAXPROCS(0))
|
|
for i := range hashes {
|
|
hashes[i] = New()
|
|
}
|
|
|
|
rng := rand.New(rand.NewSource(0xabadc0cac01a))
|
|
data := make([][]byte, runtime.GOMAXPROCS(0))
|
|
for i := range data {
|
|
data[i] = make([]byte, size)
|
|
rng.Read(data[i])
|
|
}
|
|
|
|
b.SetBytes(int64(size))
|
|
b.ResetTimer()
|
|
|
|
counter := uint64(0)
|
|
b.RunParallel(func(pb *testing.PB) {
|
|
for pb.Next() {
|
|
index := atomic.AddUint64(&counter, 1)
|
|
index = index % uint64(len(data))
|
|
hashes[index].Reset()
|
|
hashes[index].Write(data[index])
|
|
in := make([]byte, 0, hashes[index].Size())
|
|
hashes[index].Sum(in)
|
|
}
|
|
})
|
|
}
|
|
|
|
func BenchmarkParallel(b *testing.B) {
|
|
// go test -cpu=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 -bench=Parallel
|
|
b.Run("1KB", func(b *testing.B) {
|
|
benchmarkParallel(b, 1*1024)
|
|
})
|
|
b.Run("10KB", func(b *testing.B) {
|
|
benchmarkParallel(b, 10*1024)
|
|
})
|
|
b.Run("1M", func(b *testing.B) {
|
|
benchmarkParallel(b, 1*1024*1024)
|
|
})
|
|
b.Run("50M", func(b *testing.B) {
|
|
benchmarkParallel(b, 50*1024*1024)
|
|
})
|
|
}
|