reedsolomon-go/galoisAvx512_amd64_test.go

416 lines
12 KiB
Go

//go:build !noasm && !appengine && !gccgo
// +build !noasm,!appengine,!gccgo
// Copyright 2015, Klaus Post, see LICENSE for details.
// Copyright 2019, Minio, Inc.
package reedsolomon
import (
"bytes"
"math/rand"
"testing"
"time"
)
func testGaloisAvx512Parallelx1(t *testing.T, inputSize int) {
if !defaultOptions.useAVX512 {
t.Skip("AVX512 not detected")
}
rand.Seed(time.Now().UnixNano())
var size = 1024 * 1024
if testing.Short() {
size = 4096
}
in, out := make([][]byte, inputSize), make([][]byte, dimOut81)
for i := range in {
in[i] = make([]byte, size)
rand.Read(in[i])
}
for i := range out {
out[i] = make([]byte, size)
rand.Read(out[i])
}
opts := defaultOptions
opts.useSSSE3 = true
matrix := [(16 + 16) * dimIn * dimOut81]byte{}
coeffs := make([]byte, dimIn*len(out))
for i := 0; i < dimIn*len(out); i++ {
coeffs[i] = byte(rand.Int31n(256))
copy(matrix[i*32:], mulTableLow[coeffs[i]][:])
copy(matrix[i*32+16:], mulTableHigh[coeffs[i]][:])
}
// Do first run with clearing out any existing results
_galMulAVX512Parallel81(in, out, &matrix, false)
expect := make([][]byte, len(out))
for i := range expect {
expect[i] = make([]byte, size)
rand.Read(expect[i])
}
for i := range in {
if i == 0 {
galMulSlice(coeffs[i], in[i], expect[0], &options{})
} else {
galMulSliceXor(coeffs[i], in[i], expect[0], &options{})
}
}
for i := range out {
if 0 != bytes.Compare(out[i], expect[i]) {
t.Errorf("got [%d]%#v...,\n expected [%d]%#v...", i, out[i][:8], i, expect[i][:8])
}
}
inToAdd := make([][]byte, len(in))
for i := range inToAdd {
inToAdd[i] = make([]byte, size)
rand.Read(inToAdd[i])
}
for i := 0; i < dimIn*len(out); i++ {
coeffs[i] = byte(rand.Int31n(256))
copy(matrix[i*32:], mulTableLow[coeffs[i]][:])
copy(matrix[i*32+16:], mulTableHigh[coeffs[i]][:])
}
// Do second run by adding to original run
_galMulAVX512Parallel81(inToAdd, out, &matrix, true)
for i := range in {
galMulSliceXor(coeffs[i], inToAdd[i], expect[0], &options{})
}
for i := range out {
if 0 != bytes.Compare(out[i], expect[i]) {
t.Errorf("got [%d]%#v...,\n expected [%d]%#v...", i, out[i][:8], i, expect[i][:8])
}
}
}
func TestGaloisAvx512Parallel11(t *testing.T) { testGaloisAvx512Parallelx1(t, 1) }
func TestGaloisAvx512Parallel21(t *testing.T) { testGaloisAvx512Parallelx1(t, 2) }
func TestGaloisAvx512Parallel31(t *testing.T) { testGaloisAvx512Parallelx1(t, 3) }
func TestGaloisAvx512Parallel41(t *testing.T) { testGaloisAvx512Parallelx1(t, 4) }
func TestGaloisAvx512Parallel51(t *testing.T) { testGaloisAvx512Parallelx1(t, 5) }
func TestGaloisAvx512Parallel61(t *testing.T) { testGaloisAvx512Parallelx1(t, 6) }
func TestGaloisAvx512Parallel71(t *testing.T) { testGaloisAvx512Parallelx1(t, 7) }
func TestGaloisAvx512Parallel81(t *testing.T) { testGaloisAvx512Parallelx1(t, 8) }
func testGaloisAvx512Parallelx2(t *testing.T, inputSize int) {
if !defaultOptions.useAVX512 {
t.Skip("AVX512 not detected")
}
rand.Seed(time.Now().UnixNano())
var size = 1024 * 1024
if testing.Short() {
size = 4096
}
in, out := make([][]byte, inputSize), make([][]byte, dimOut82)
for i := range in {
in[i] = make([]byte, size)
rand.Read(in[i])
}
for i := range out {
out[i] = make([]byte, size)
rand.Read(out[i])
}
opts := defaultOptions
opts.useSSSE3 = true
matrix := [(16 + 16) * dimIn * dimOut82]byte{}
coeffs := make([]byte, dimIn*len(out))
for i := 0; i < dimIn*len(out); i++ {
coeffs[i] = byte(rand.Int31n(256))
copy(matrix[i*32:], mulTableLow[coeffs[i]][:])
copy(matrix[i*32+16:], mulTableHigh[coeffs[i]][:])
}
// Do first run with clearing out any existing results
_galMulAVX512Parallel82(in, out, &matrix, false)
expect := make([][]byte, len(out))
for i := range expect {
expect[i] = make([]byte, size)
rand.Read(expect[i])
}
for i := range in {
if i == 0 {
galMulSlice(coeffs[i], in[i], expect[0], &options{})
galMulSlice(coeffs[dimIn+i], in[i], expect[1], &options{})
} else {
galMulSliceXor(coeffs[i], in[i], expect[0], &options{})
galMulSliceXor(coeffs[dimIn+i], in[i], expect[1], &options{})
}
}
for i := range out {
if 0 != bytes.Compare(out[i], expect[i]) {
t.Errorf("got [%d]%#v...,\n expected [%d]%#v...", i, out[i][:8], i, expect[i][:8])
}
}
inToAdd := make([][]byte, len(in))
for i := range inToAdd {
inToAdd[i] = make([]byte, size)
rand.Read(inToAdd[i])
}
for i := 0; i < dimIn*len(out); i++ {
coeffs[i] = byte(rand.Int31n(256))
copy(matrix[i*32:], mulTableLow[coeffs[i]][:])
copy(matrix[i*32+16:], mulTableHigh[coeffs[i]][:])
}
// Do second run by adding to original run
_galMulAVX512Parallel82(inToAdd, out, &matrix, true)
for i := range in {
galMulSliceXor(coeffs[i], inToAdd[i], expect[0], &options{})
galMulSliceXor(coeffs[dimIn+i], inToAdd[i], expect[1], &options{})
}
for i := range out {
if 0 != bytes.Compare(out[i], expect[i]) {
t.Errorf("got [%d]%#v...,\n expected [%d]%#v...", i, out[i][:8], i, expect[i][:8])
}
}
}
func TestGaloisAvx512Parallel12(t *testing.T) { testGaloisAvx512Parallelx2(t, 1) }
func TestGaloisAvx512Parallel22(t *testing.T) { testGaloisAvx512Parallelx2(t, 2) }
func TestGaloisAvx512Parallel32(t *testing.T) { testGaloisAvx512Parallelx2(t, 3) }
func TestGaloisAvx512Parallel42(t *testing.T) { testGaloisAvx512Parallelx2(t, 4) }
func TestGaloisAvx512Parallel52(t *testing.T) { testGaloisAvx512Parallelx2(t, 5) }
func TestGaloisAvx512Parallel62(t *testing.T) { testGaloisAvx512Parallelx2(t, 6) }
func TestGaloisAvx512Parallel72(t *testing.T) { testGaloisAvx512Parallelx2(t, 7) }
func TestGaloisAvx512Parallel82(t *testing.T) { testGaloisAvx512Parallelx2(t, 8) }
func testGaloisAvx512Parallelx4(t *testing.T, inputSize int) {
if !defaultOptions.useAVX512 {
t.Skip("AVX512 not detected")
}
rand.Seed(time.Now().UnixNano())
var size = 1 << 20
if testing.Short() {
size = 4096
}
in, out := make([][]byte, inputSize), make([][]byte, dimOut84)
for i := range in {
in[i] = make([]byte, size)
rand.Read(in[i])
}
for i := range out {
out[i] = make([]byte, size)
rand.Read(out[i])
}
opts := defaultOptions
opts.useSSSE3 = true
matrix := [(16 + 16) * dimIn * dimOut84]byte{}
coeffs := make([]byte, dimIn*len(out))
for i := 0; i < dimIn*len(out); i++ {
coeffs[i] = byte(rand.Int31n(256))
copy(matrix[i*32:], mulTableLow[coeffs[i]][:])
copy(matrix[i*32+16:], mulTableHigh[coeffs[i]][:])
}
// Do first run with clearing out any existing results
_galMulAVX512Parallel84(in, out, &matrix, false)
expect := make([][]byte, 4)
for i := range expect {
expect[i] = make([]byte, size)
rand.Read(expect[i])
}
for i := range in {
if i == 0 {
galMulSlice(coeffs[i], in[i], expect[0], &options{})
galMulSlice(coeffs[dimIn+i], in[i], expect[1], &options{})
galMulSlice(coeffs[dimIn*2+i], in[i], expect[2], &options{})
galMulSlice(coeffs[dimIn*3+i], in[i], expect[3], &options{})
} else {
galMulSliceXor(coeffs[i], in[i], expect[0], &options{})
galMulSliceXor(coeffs[dimIn+i], in[i], expect[1], &options{})
galMulSliceXor(coeffs[dimIn*2+i], in[i], expect[2], &options{})
galMulSliceXor(coeffs[dimIn*3+i], in[i], expect[3], &options{})
}
}
for i := range out {
if 0 != bytes.Compare(out[i], expect[i]) {
t.Errorf("got [%d]%#v...,\n expected [%d]%#v...", i, out[i][:8], i, expect[i][:8])
}
}
inToAdd := make([][]byte, len(in))
for i := range inToAdd {
inToAdd[i] = make([]byte, size)
rand.Read(inToAdd[i])
}
for i := 0; i < dimIn*len(out); i++ {
coeffs[i] = byte(rand.Int31n(256))
copy(matrix[i*32:], mulTableLow[coeffs[i]][:])
copy(matrix[i*32+16:], mulTableHigh[coeffs[i]][:])
}
// Do second run by adding to original run
_galMulAVX512Parallel84(inToAdd, out, &matrix, true)
for i := range in {
galMulSliceXor(coeffs[i], inToAdd[i], expect[0], &options{})
galMulSliceXor(coeffs[dimIn+i], inToAdd[i], expect[1], &options{})
galMulSliceXor(coeffs[dimIn*2+i], inToAdd[i], expect[2], &options{})
galMulSliceXor(coeffs[dimIn*3+i], inToAdd[i], expect[3], &options{})
}
for i := range out {
if 0 != bytes.Compare(out[i], expect[i]) {
t.Errorf("got [%d]%#v...,\n expected [%d]%#v...", i, out[i][:8], i, expect[i][:8])
}
}
}
func TestGaloisAvx512Parallel14(t *testing.T) { testGaloisAvx512Parallelx4(t, 1) }
func TestGaloisAvx512Parallel24(t *testing.T) { testGaloisAvx512Parallelx4(t, 2) }
func TestGaloisAvx512Parallel34(t *testing.T) { testGaloisAvx512Parallelx4(t, 3) }
func TestGaloisAvx512Parallel44(t *testing.T) { testGaloisAvx512Parallelx4(t, 4) }
func TestGaloisAvx512Parallel54(t *testing.T) { testGaloisAvx512Parallelx4(t, 5) }
func TestGaloisAvx512Parallel64(t *testing.T) { testGaloisAvx512Parallelx4(t, 6) }
func TestGaloisAvx512Parallel74(t *testing.T) { testGaloisAvx512Parallelx4(t, 7) }
func TestGaloisAvx512Parallel84(t *testing.T) { testGaloisAvx512Parallelx4(t, 8) }
func testCodeSomeShardsAvx512WithLength(t *testing.T, ds, ps, l int, parallel bool) {
if !defaultOptions.useAVX512 {
t.Skip("AVX512 not detected")
}
var data = make([]byte, l)
fillRandom(data)
enc, _ := New(ds, ps)
r := enc.(*reedSolomon) // need to access private methods
shards, _ := enc.Split(data)
// Fill shards to encode with garbage
for i := r.DataShards; i < r.DataShards+r.ParityShards; i++ {
rand.Read(shards[i])
}
if parallel {
r.codeSomeShardsAvx512P(r.parity, shards[:r.DataShards], shards[r.DataShards:], len(shards[0]))
} else {
r.codeSomeShardsAvx512(r.parity, shards[:r.DataShards], shards[r.DataShards:r.DataShards+r.ParityShards], len(shards[0]))
}
correct, _ := r.Verify(shards)
if !correct {
t.Errorf("Verification of encoded shards failed")
}
}
func testCodeSomeShardsAvx512(t *testing.T, ds, ps int) {
if !defaultOptions.useAVX512 {
t.Skip("AVX512 not detected")
}
step := 1
if testing.Short() {
// A prime for variation
step += 29
}
for l := 1; l <= 8192; l += step {
testCodeSomeShardsAvx512WithLength(t, ds, ps, l, false)
testCodeSomeShardsAvx512WithLength(t, ds, ps, l, true)
}
}
func TestCodeSomeShardsAvx512_8x2(t *testing.T) { testCodeSomeShardsAvx512(t, 8, 2) }
func TestCodeSomeShardsAvx512_1x4(t *testing.T) { testCodeSomeShardsAvx512(t, 1, 4) }
func TestCodeSomeShardsAvx512_2x4(t *testing.T) { testCodeSomeShardsAvx512(t, 2, 4) }
func TestCodeSomeShardsAvx512_3x4(t *testing.T) { testCodeSomeShardsAvx512(t, 3, 4) }
func TestCodeSomeShardsAvx512_4x4(t *testing.T) { testCodeSomeShardsAvx512(t, 4, 4) }
func TestCodeSomeShardsAvx512_5x4(t *testing.T) { testCodeSomeShardsAvx512(t, 5, 4) }
func TestCodeSomeShardsAvx512_6x4(t *testing.T) { testCodeSomeShardsAvx512(t, 6, 4) }
func TestCodeSomeShardsAvx512_7x4(t *testing.T) { testCodeSomeShardsAvx512(t, 7, 4) }
func TestCodeSomeShardsAvx512_8x4(t *testing.T) { testCodeSomeShardsAvx512(t, 8, 4) }
func TestCodeSomeShardsAvx512_9x4(t *testing.T) { testCodeSomeShardsAvx512(t, 9, 4) }
func TestCodeSomeShardsAvx512_10x4(t *testing.T) { testCodeSomeShardsAvx512(t, 10, 4) }
func TestCodeSomeShardsAvx512_12x4(t *testing.T) { testCodeSomeShardsAvx512(t, 12, 4) }
func TestCodeSomeShardsAvx512_16x4(t *testing.T) { testCodeSomeShardsAvx512(t, 16, 4) }
func TestCodeSomeShardsAvx512_3x6(t *testing.T) { testCodeSomeShardsAvx512(t, 3, 6) }
func TestCodeSomeShardsAvx512_8x6(t *testing.T) { testCodeSomeShardsAvx512(t, 8, 6) }
func TestCodeSomeShardsAvx512_8x7(t *testing.T) { testCodeSomeShardsAvx512(t, 8, 7) }
func TestCodeSomeShardsAvx512_3x8(t *testing.T) { testCodeSomeShardsAvx512(t, 3, 8) }
func TestCodeSomeShardsAvx512_8x8(t *testing.T) { testCodeSomeShardsAvx512(t, 8, 8) }
func TestCodeSomeShardsAvx512_5x10(t *testing.T) { testCodeSomeShardsAvx512(t, 5, 10) }
func TestCodeSomeShardsAvx512_8x10(t *testing.T) { testCodeSomeShardsAvx512(t, 8, 10) }
func TestCodeSomeShardsAvx512_9x10(t *testing.T) { testCodeSomeShardsAvx512(t, 9, 10) }
func TestCodeSomeShardsAvx512_Manyx4(t *testing.T) {
if !defaultOptions.useAVX512 {
return
}
step := 1
if testing.Short() {
step += 7
}
for inputs := 1; inputs <= 200; inputs += step {
testCodeSomeShardsAvx512WithLength(t, inputs, 4, 1024+33, false)
testCodeSomeShardsAvx512WithLength(t, inputs, 4, 1024+33, true)
}
}
func TestCodeSomeShardsAvx512_ManyxMany(t *testing.T) {
if !defaultOptions.useAVX512 {
return
}
step := 1
if testing.Short() {
step += 5
}
for outputs := 1; outputs <= 32; outputs += step {
for inputs := 1; inputs <= 32; inputs += step {
testCodeSomeShardsAvx512WithLength(t, inputs, outputs, 1024+33, false)
testCodeSomeShardsAvx512WithLength(t, inputs, outputs, 1024+33, true)
}
}
}