using glide

vendor/github.com/templexxx/cpufeat/cpu_test.go

@@ -0,0 +1,26 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cpufeat
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestAMD64minimalFeatures(t *testing.T) {
+	if runtime.GOARCH == "amd64" {
+		if !X86.HasSSE2 {
+			t.Fatalf("HasSSE2 expected true, got false")
+		}
+	}
+}
+
+func TestAVX2hasAVX(t *testing.T) {
+	if runtime.GOARCH == "amd64" {
+		if X86.HasAVX2 && !X86.HasAVX {
+			t.Fatalf("HasAVX expected true, got false")
+		}
+	}
+}

vendor/github.com/templexxx/reedsolomon/mathtool/cntinverse.go

@@ -0,0 +1,193 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+)
+
+var vects = flag.Uint64("vects", 20, "number of vects (data+parity)")
+var data = flag.Uint64("data", 0, "number of data vects; keep it empty if you want to "+
+	"get the max num of inverse matrix")
+
+func init() {
+	flag.Usage = func() {
+		fmt.Printf("Usage of %s:\n", os.Args[0])
+		fmt.Println("  cntinverse [-flags]")
+		fmt.Println("  Valid flags:")
+		flag.PrintDefaults()
+	}
+}
+
+func main() {
+	flag.Parse()
+	if *vects > 256 {
+		fmt.Println("Error: vects must <= 256")
+		os.Exit(1)
+	}
+	if *data == 0 {
+		n := getMAXCCombination(*vects)
+		fmt.Println("max num of inverse matrix :", n)
+		os.Exit(0)
+	}
+	n := getCCombination(*vects, *data)
+	fmt.Println("num of inverse matrix:", n)
+	os.Exit(0)
+}
+
+func getMAXCCombination(a uint64) uint64 {
+	b := a / 2 // proved in mathtool/combination.jpg
+	return getCCombination(a, b)
+}
+
+func getCCombination(a, b uint64) uint64 {
+	top := make([]uint64, a-b)
+	bottom := make([]uint64, a-b-1)
+	for i := b + 1; i <= a; i++ {
+		top[i-b-1] = i
+	}
+	var i uint64
+	for i = 2; i <= a-b; i++ {
+		bottom[i-2] = i
+	}
+	for j := 0; j <= 5; j++ {
+		cleanEven(top, bottom)
+		clean3(top, bottom)
+		clean5(top, bottom)
+	}
+	cleanCoffeRound1(top, bottom)
+	if maxBottomBigger5more1(bottom) {
+		top = shuffTop(top)
+		cleanCoffeRound1(top, bottom)
+		cleanCoffeRound1(bottom, top)
+		cleanCoffeRound1(top, bottom)
+		cleanCoffeRound1(bottom, top)
+		cleanCoffeRound1(top, bottom)
+		cleanCoffeRound1(bottom, top)
+	}
+	var topV, bottomV uint64 = 1, 1
+	for _, t := range top {
+		topV = topV * t
+	}
+	for _, b := range bottom {
+		bottomV = bottomV * b
+	}
+	return topV / bottomV
+}
+
+func cleanEven(top, bottom []uint64) {
+	for i, b := range bottom {
+		if even(b) {
+			for j, t := range top {
+				if even(t) {
+					top[j] = t / 2
+					bottom[i] = b / 2
+					break
+				}
+			}
+		}
+	}
+}
+
+func even(a uint64) bool {
+	return a&1 == 0
+}
+
+func clean3(top, bottom []uint64) {
+	for i, b := range bottom {
+		if mod3(b) {
+			for j, t := range top {
+				if mod3(t) {
+					top[j] = t / 3
+					bottom[i] = b / 3
+					break
+				}
+			}
+		}
+	}
+}
+
+func mod3(a uint64) bool {
+	c := a / 3
+	if 3*c == a {
+		return true
+	}
+	return false
+}
+
+func clean5(top, bottom []uint64) {
+	for i, b := range bottom {
+		if mod5(b) {
+			for j, t := range top {
+				if mod5(t) {
+					top[j] = t / 5
+					bottom[i] = b / 5
+					break
+				}
+			}
+		}
+	}
+}
+
+func mod5(a uint64) bool {
+	c := a / 5
+	if 5*c == a {
+		return true
+	}
+	return false
+}
+
+func maxBottomBigger5more1(bottom []uint64) bool {
+	cnt := 0
+	for _, b := range bottom {
+		if b >= 5 {
+			cnt++
+		}
+	}
+	if cnt >= 2 {
+		return true
+	}
+	return false
+}
+
+func cleanCoffeRound1(top, bottom []uint64) {
+	for i, b := range bottom {
+		for j, t := range top {
+			if isCoffe(b, t) {
+				top[j] = t / b
+				bottom[i] = 1
+				break
+			}
+		}
+	}
+}
+
+func isCoffe(b, t uint64) bool {
+	c := t / b
+	if c*b == t {
+		return true
+	}
+	return false
+}
+
+func shuffTop(top []uint64) []uint64 {
+	var tmp uint64 = 1
+	newLen := len(top) + 1
+	for i, t := range top {
+		if t <= 5 {
+			tmp = tmp * t
+			newLen--
+			top[i] = 1
+		}
+	}
+	topNew := make([]uint64, newLen)
+	topNew[0] = tmp
+	cnt := 1
+	for _, t := range top {
+		if t != 1 {
+			topNew[cnt] = t
+			cnt++
+		}
+	}
+	return topNew
+}

vendor/github.com/templexxx/reedsolomon/mathtool/gentbls.go

@@ -0,0 +1,270 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// set deg here
+const deg = 8 // <= 8
+
+type polynomial [deg + 1]byte
+
+func main() {
+	f, err := os.OpenFile("tables", os.O_WRONLY|os.O_CREATE, 0666)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	defer f.Close()
+	outputWriter := bufio.NewWriter(f)
+	ps := genPrimitivePolynomial()
+	title := strconv.FormatInt(int64(deg), 10) + " degree primitive polynomial：\n"
+	var pss string
+	for i, p := range ps {
+		pf := formatPolynomial(p)
+		pf = strconv.FormatInt(int64(i+1), 10) + ". " + pf + ";\n"
+		pss = pss + pf
+	}
+	body := fmt.Sprintf(title+"%v", pss)
+	outputWriter.WriteString(body)
+
+	//set primitive polynomial here to generator tables
+	//x^8+x^4+x^3+x^2+1
+	var primitivePolynomial polynomial
+	primitivePolynomial[0] = 1
+	primitivePolynomial[2] = 1
+	primitivePolynomial[3] = 1
+	primitivePolynomial[4] = 1
+	primitivePolynomial[8] = 1
+
+	lenExpTable := (1 << deg) - 1
+	expTable := genExpTable(primitivePolynomial, lenExpTable)
+	body = fmt.Sprintf("expTbl: %#v\n", expTable)
+	outputWriter.WriteString(body)
+
+	logTable := genLogTable(expTable)
+	body = fmt.Sprintf("logTbl: %#v\n", logTable)
+	outputWriter.WriteString(body)
+
+	mulTable := genMulTable(expTable, logTable)
+	body = fmt.Sprintf("mulTbl: %#v\n", mulTable)
+	outputWriter.WriteString(body)
+
+	lowTable, highTable := genMulTableHalf(mulTable)
+	body = fmt.Sprintf("lowTbl: %#v\n", lowTable)
+	outputWriter.WriteString(body)
+	body = fmt.Sprintf("highTbl: %#v\n", highTable)
+	outputWriter.WriteString(body)
+
+	var combTable [256][32]byte
+	for i := range combTable {
+		l := lowTable[i]
+		for j := 0; j < 16; j++ {
+			combTable[i][j] = l[j]
+		}
+		h := highTable[i][:]
+		for k := 16; k < 32; k++ {
+			combTable[i][k] = h[k-16]
+		}
+	}
+	body = fmt.Sprintf("lowhighTbl: %#v\n", combTable)
+	outputWriter.WriteString(body)
+
+	inverseTable := genInverseTable(mulTable)
+	body = fmt.Sprintf("inverseTbl: %#v\n", inverseTable)
+	outputWriter.WriteString(body)
+	outputWriter.Flush()
+}
+
+// generate primitive Polynomial
+func genPrimitivePolynomial() []polynomial {
+	// drop Polynomial x，so the constant term must be 1
+	// so there are 2^(deg-1) Polynomials
+	cnt := 1 << (deg - 1)
+	var polynomials []polynomial
+	var p polynomial
+	p[0] = 1
+	p[deg] = 1
+	// gen all Polynomials
+	for i := 0; i < cnt; i++ {
+		p = genPolynomial(p, 1)
+		polynomials = append(polynomials, p)
+	}
+	// drop Polynomial x+1, so the cnt of Polynomials is odd
+	var psRaw []polynomial
+	for _, p := range polynomials {
+		var n int
+		for _, v := range p {
+			if v == 1 {
+				n++
+			}
+		}
+		if n&1 != 0 {
+			psRaw = append(psRaw, p)
+		}
+	}
+	// order of primitive element == 2^deg -1 ?
+	var ps []polynomial
+	for _, p := range psRaw {
+		lenTable := (1 << deg) - 1
+		table := genExpTable(p, lenTable)
+		var numOf1 int
+		for _, v := range table {
+			// cnt 1 in ExpTable
+			if int(v) == 1 {
+				numOf1++
+			}
+		}
+		if numOf1 == 1 {
+			ps = append(ps, p)
+		}
+	}
+	return ps
+}
+
+func genPolynomial(p polynomial, i int) polynomial {
+	if p[i] == 0 {
+		p[i] = 1
+	} else {
+		p[i] = 0
+		i++
+		if i == deg {
+			return p
+		}
+		p = genPolynomial(p, i)
+	}
+	return p
+}
+
+func genExpTable(primitivePolynomial polynomial, exp int) []byte {
+	table := make([]byte, exp)
+	var rawPolynomial polynomial
+	rawPolynomial[1] = 1
+	table[0] = byte(1)
+	table[1] = byte(2)
+	for i := 2; i < exp; i++ {
+		rawPolynomial = expGrowPolynomial(rawPolynomial, primitivePolynomial)
+		table[i] = byte(getValueOfPolynomial(rawPolynomial))
+	}
+	return table
+}
+
+func expGrowPolynomial(raw, primitivePolynomial polynomial) polynomial {
+	var newP polynomial
+	for i, v := range raw[:deg] {
+		if v == 1 {
+			newP[i+1] = 1
+		}
+	}
+	if newP[deg] == 1 {
+		for i, v := range primitivePolynomial[:deg] {
+			if v == 1 {
+				if newP[i] == 1 {
+					newP[i] = 0
+				} else {
+					newP[i] = 1
+				}
+			}
+		}
+	}
+	newP[deg] = 0
+	return newP
+}
+
+func getValueOfPolynomial(p polynomial) uint8 {
+	var v uint8
+	for i, coefficient := range p[:deg] {
+		if coefficient != 0 {
+			add := 1 << uint8(i)
+			v += uint8(add)
+		}
+	}
+	return v
+}
+
+func genLogTable(expTable []byte) []byte {
+	table := make([]byte, (1 << deg))
+	//table[0] 无法由本原元的幂得到
+	table[0] = 0
+	for i, v := range expTable {
+		table[v] = byte(i)
+	}
+	return table
+}
+
+func genMulTable(expTable, logTable []byte) [256][256]byte {
+	var result [256][256]byte
+	for a := range result {
+		for b := range result[a] {
+			if a == 0 || b == 0 {
+				result[a][b] = 0
+				continue
+			}
+			logA := int(logTable[a])
+			logB := int(logTable[b])
+			logSum := logA + logB
+			for logSum >= 255 {
+				logSum -= 255
+			}
+			result[a][b] = expTable[logSum]
+		}
+	}
+	return result
+}
+
+func genMulTableHalf(mulTable [256][256]byte) (low [256][16]byte, high [256][16]byte) {
+	for a := range low {
+		for b := range low {
+			//result := 0
+			var result byte
+			if !(a == 0 || b == 0) {
+				//result = int(mulTable[a][b])
+				result = mulTable[a][b]
+
+			}
+			// b & 00001111, [0,15]
+			if (b & 0xf) == b {
+				low[a][b] = result
+			}
+			// b & 11110000, [240,255]
+			if (b & 0xf0) == b {
+				high[a][b>>4] = result
+			}
+		}
+	}
+	return
+}
+
+func genInverseTable(mulTable [256][256]byte) [256]byte {
+	var inVerseTable [256]byte
+	for i, t := range mulTable {
+		for j, v := range t {
+			if int(v) == 1 {
+				inVerseTable[i] = byte(j)
+			}
+		}
+	}
+	return inVerseTable
+}
+
+func formatPolynomial(p polynomial) string {
+	var ps string
+	for i := deg; i > 1; i-- {
+		if p[i] == 1 {
+			ps = ps + "x^" + strconv.FormatInt(int64(i), 10) + "+"
+		}
+	}
+	if p[1] == 1 {
+		ps = ps + "x+"
+	}
+	if p[0] == 1 {
+		ps = ps + "1"
+	} else {
+		strings.TrimSuffix(ps, "+")
+	}
+	return ps
+}

vendor/github.com/templexxx/reedsolomon/matrix_test.go

@@ -0,0 +1,146 @@
+package reedsolomon
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestVerifyEncMatrixVand(t *testing.T) {
+	a, err := genEncMatrixVand(4, 4)
+	if err != nil {
+		t.Fatal(err)
+	}
+	e := []byte{1, 0, 0, 0,
+		0, 1, 0, 0,
+		0, 0, 1, 0,
+		0, 0, 0, 1,
+		27, 28, 18, 20,
+		28, 27, 20, 18,
+		18, 20, 27, 28,
+		20, 18, 28, 27}
+	if !bytes.Equal(a, e) {
+		t.Fatal("mismatch")
+	}
+}
+
+func TestVerifyEncMatrixCauchy(t *testing.T) {
+	a := genEncMatrixCauchy(4, 4)
+	e := []byte{1, 0, 0, 0,
+		0, 1, 0, 0,
+		0, 0, 1, 0,
+		0, 0, 0, 1,
+		71, 167, 122, 186,
+		167, 71, 186, 122,
+		122, 186, 71, 167,
+		186, 122, 167, 71}
+	if !bytes.Equal(a, e) {
+		t.Fatal("mismatch")
+	}
+}
+
+func TestMatrixInvert(t *testing.T) {
+	testCases := []struct {
+		matrixData  []byte
+		cols        int
+		expect      []byte
+		ok          bool
+		expectedErr error
+	}{
+		{
+			[]byte{56, 23, 98,
+				3, 100, 200,
+				45, 201, 123},
+			3,
+			[]byte{175, 133, 33,
+				130, 13, 245,
+				112, 35, 126},
+			true,
+			nil,
+		},
+		{
+			[]byte{0, 23, 98,
+				3, 100, 200,
+				45, 201, 123},
+			3,
+			[]byte{245, 128, 152,
+				188, 64, 135,
+				231, 81, 239},
+			true,
+			nil,
+		},
+		{
+			[]byte{1, 0, 0, 0, 0,
+				0, 1, 0, 0, 0,
+				0, 0, 0, 1, 0,
+				0, 0, 0, 0, 1,
+				7, 7, 6, 6, 1},
+			5,
+			[]byte{1, 0, 0, 0, 0,
+				0, 1, 0, 0, 0,
+				123, 123, 1, 122, 122,
+				0, 0, 1, 0, 0,
+				0, 0, 0, 1, 0},
+			true,
+			nil,
+		},
+		{
+			[]byte{4, 2,
+				12, 6},
+			2,
+			nil,
+			false,
+			errSingular,
+		},
+	}
+
+	for i, c := range testCases {
+		m := matrix(c.matrixData)
+		raw := make([]byte, 2*c.cols*c.cols)
+		actual := make([]byte, c.cols*c.cols)
+		actualErr := m.invert(raw, c.cols, actual)
+		if actualErr != nil && c.ok {
+			t.Errorf("case.%d, expected to pass, but failed with: <ERROR> %s", i+1, actualErr.Error())
+		}
+		if actualErr == nil && !c.ok {
+			t.Errorf("case.%d, expected to fail with <ERROR> \"%s\", but passed", i+1, c.expectedErr)
+		}
+		if actualErr != nil && !c.ok {
+			if c.expectedErr != actualErr {
+				t.Errorf("case.%d, expected to fail with error \"%s\", but instead failed with error \"%s\"", i+1, c.expectedErr, actualErr)
+			}
+		}
+		if actualErr == nil && c.ok {
+			if !bytes.Equal(c.expect, actual) {
+				t.Errorf("case.%d, mismatch", i+1)
+			}
+		}
+	}
+}
+
+func benchmarkInvert(b *testing.B, size int) {
+	m := genEncMatrixCauchy(size, 2)
+	m.swap(0, size, size)
+	m.swap(1, size+1, size)
+	b.ResetTimer()
+	buf := make([]byte, 3*size*size)
+	raw := buf[:2*size*size]
+	r := buf[2*size*size:]
+	for i := 0; i < b.N; i++ {
+		err := m.invert(raw, size, r)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkInvert5x5(b *testing.B) {
+	benchmarkInvert(b, 5)
+}
+
+func BenchmarkInvert10x10(b *testing.B) {
+	benchmarkInvert(b, 10)
+}
+
+func BenchmarkInvert20x20(b *testing.B) {
+	benchmarkInvert(b, 20)
+}

vendor/github.com/templexxx/reedsolomon/rs_test.go

@@ -0,0 +1,309 @@
+package reedsolomon
+
+import (
+	"bytes"
+	"fmt"
+	"math/rand"
+	"testing"
+)
+
+const (
+	kb         = 1024
+	mb         = 1024 * 1024
+	testNumIn  = 10
+	testNumOut = 4
+)
+
+const verifySize = 256 + 32 + 16 + 15
+
+func TestVerifyEncBase(t *testing.T) {
+	d := 5
+	p := 5
+	vects := [][]byte{
+		{0, 1},
+		{4, 5},
+		{2, 3},
+		{6, 7},
+		{8, 9},
+		{0, 0},
+		{0, 0},
+		{0, 0},
+		{0, 0},
+		{0, 0},
+	}
+	em, err := genEncMatrixVand(d, p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := em[d*d:]
+	e := &encBase{data: d, parity: p, gen: g}
+	err = e.Encode(vects)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if vects[5][0] != 12 || vects[5][1] != 13 {
+		t.Fatal("vect 5 mismatch")
+	}
+	if vects[6][0] != 10 || vects[6][1] != 11 {
+		t.Fatal("vect 6 mismatch")
+	}
+	if vects[7][0] != 14 || vects[7][1] != 15 {
+		t.Fatal("vect 7 mismatch")
+	}
+	if vects[8][0] != 90 || vects[8][1] != 91 {
+		t.Fatal("vect 8 mismatch")
+	}
+	if vects[9][0] != 94 || vects[9][1] != 95 {
+		t.Fatal("shard 9 mismatch")
+	}
+}
+
+func fillRandom(v []byte) {
+	for i := 0; i < len(v); i += 7 {
+		val := rand.Int63()
+		for j := 0; i+j < len(v) && j < 7; j++ {
+			v[i+j] = byte(val)
+			val >>= 8
+		}
+	}
+}
+
+func verifyEnc(t *testing.T, d, p int) {
+	for i := 1; i <= verifySize; i++ {
+		vects1 := make([][]byte, d+p)
+		vects2 := make([][]byte, d+p)
+		for j := 0; j < d+p; j++ {
+			vects1[j] = make([]byte, i)
+			vects2[j] = make([]byte, i)
+		}
+		for j := 0; j < d; j++ {
+			rand.Seed(int64(j))
+			fillRandom(vects1[j])
+			copy(vects2[j], vects1[j])
+		}
+		e, err := New(d, p)
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = e.Encode(vects1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		em, err := genEncMatrixVand(d, p)
+		if err != nil {
+			t.Fatal(err)
+		}
+		g := em[d*d:]
+		e2 := &encBase{data: d, parity: p, gen: g}
+		err = e2.Encode(vects2)
+		for k, v1 := range vects1 {
+			if !bytes.Equal(v1, vects2[k]) {
+				t.Fatalf("no match enc with encBase; vect: %d; size: %d", k, i)
+			}
+		}
+	}
+}
+
+func TestVerifyEnc(t *testing.T) {
+	verifyEnc(t, testNumIn, testNumOut)
+}
+
+func verifyReconst(t *testing.T, d, p int, lost []int) {
+	for i := 1; i <= verifySize; i++ {
+		vects1 := make([][]byte, d+p)
+		vects2 := make([][]byte, d+p)
+		for j := 0; j < d+p; j++ {
+			vects1[j] = make([]byte, i)
+			vects2[j] = make([]byte, i)
+		}
+		for j := 0; j < d; j++ {
+			rand.Seed(int64(j))
+			fillRandom(vects1[j])
+		}
+		e, err := New(d, p)
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = e.Encode(vects1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for j := 0; j < d+p; j++ {
+			copy(vects2[j], vects1[j])
+		}
+		for _, i := range lost {
+			vects2[i] = nil
+		}
+		err = e.Reconstruct(vects2)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for k, v1 := range vects1 {
+			if !bytes.Equal(v1, vects2[k]) {
+				t.Fatalf("no match reconst; vect: %d; size: %d", k, i)
+			}
+		}
+	}
+}
+
+func TestVerifyReconst(t *testing.T) {
+	lost := []int{0, 11, 3, 4}
+	verifyReconst(t, testNumIn, testNumOut, lost)
+}
+
+func benchEnc(b *testing.B, d, p, size int) {
+	vects := make([][]byte, d+p)
+	for j := 0; j < d+p; j++ {
+		vects[j] = make([]byte, size)
+	}
+	for j := 0; j < d; j++ {
+		rand.Seed(int64(j))
+		fillRandom(vects[j])
+	}
+	e, err := New(d, p)
+	if err != nil {
+		b.Fatal(err)
+	}
+	err = e.Encode(vects)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(d * size))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		err = e.Encode(vects)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func benchEncRun(f func(*testing.B, int, int, int), d, p int, size []int) func(*testing.B) {
+	return func(b *testing.B) {
+		for _, s := range size {
+			b.Run(fmt.Sprintf("%d+%d_%d", d, p, s), func(b *testing.B) {
+				f(b, d, p, s)
+			})
+		}
+	}
+}
+
+func BenchmarkEnc(b *testing.B) {
+	s1 := []int{1350}
+	b.Run("", benchEncRun(benchEnc, 10, 3, s1))
+	s2 := []int{1400, 4 * kb, 64 * kb, mb, 16 * mb}
+	b.Run("", benchEncRun(benchEnc, testNumIn, testNumOut, s2))
+}
+
+func benchReconst(b *testing.B, d, p, size int, lost []int) {
+	vects := make([][]byte, d+p)
+	for j := 0; j < d+p; j++ {
+		vects[j] = make([]byte, size)
+	}
+	for j := 0; j < d; j++ {
+		rand.Seed(int64(j))
+		fillRandom(vects[j])
+	}
+	e, err := New(d, p)
+	if err != nil {
+		b.Fatal(err)
+	}
+	err = e.Encode(vects)
+	if err != nil {
+		b.Fatal(err)
+	}
+	for _, i := range lost {
+		vects[i] = nil
+	}
+	err = e.Reconstruct(vects)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(d * size))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, i := range lost {
+			vects[i] = nil
+		}
+		err = e.Reconstruct(vects)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func benchReconstRun(f func(*testing.B, int, int, int, []int), d, p int, size, lost []int) func(*testing.B) {
+	return func(b *testing.B) {
+		for _, s := range size {
+			b.Run(fmt.Sprintf("%d+%d_%d", d, p, s), func(b *testing.B) {
+				f(b, d, p, s, lost)
+			})
+		}
+	}
+}
+
+// Reconstruct p vects
+func BenchmarkReconst(b *testing.B) {
+	l1 := []int{2, 4, 5}
+	s1 := []int{1350}
+	b.Run("", benchReconstRun(benchReconst, 10, 3, s1, l1))
+	l2 := []int{2, 4, 7, 9}
+	s2 := []int{1400, 4 * kb, 64 * kb, mb, 16 * mb}
+	b.Run("", benchReconstRun(benchReconst, testNumIn, testNumOut, s2, l2))
+}
+
+func benchReconstPos(b *testing.B, d, p, size int, has, dLost, pLost []int) {
+	vects := make([][]byte, d+p)
+	for j := 0; j < d+p; j++ {
+		vects[j] = make([]byte, size)
+	}
+	for j := 0; j < d; j++ {
+		rand.Seed(int64(j))
+		fillRandom(vects[j])
+	}
+	e, err := New(d, p)
+	if err != nil {
+		b.Fatal(err)
+	}
+	err = e.Encode(vects)
+	if err != nil {
+		b.Fatal(err)
+	}
+	err = e.ReconstWithPos(vects, has, dLost, pLost)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(d * size))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		err = e.ReconstWithPos(vects, has, dLost, pLost)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func benchReconstPosRun(f func(*testing.B, int, int, int, []int, []int, []int), d, p int, size,
+	has, dLost, pLost []int) func(*testing.B) {
+	return func(b *testing.B) {
+		for _, s := range size {
+			b.Run(fmt.Sprintf("%dx%d_%d", d, p, s), func(b *testing.B) {
+				f(b, d, p, s, has, dLost, pLost)
+			})
+		}
+	}
+}
+
+// Reconstruct p vects with position
+func BenchmarkReconstWithPos(b *testing.B) {
+	h1 := []int{0, 1, 3, 6, 7, 8, 9, 10, 11, 12}
+	d1 := []int{2, 4, 5}
+	p1 := []int{}
+	s1 := []int{1350}
+	b.Run("", benchReconstPosRun(benchReconstPos, 10, 3, s1, h1, d1, p1))
+	h2 := []int{0, 1, 3, 5, 6, 8, 10, 11, 12, 13}
+	d2 := []int{2, 4, 7, 9}
+	p2 := []int{}
+	s2 := []int{1400, 4 * kb, 64 * kb, mb, 16 * mb}
+	b.Run("", benchReconstPosRun(benchReconstPos, testNumIn, testNumOut, s2, h2, d2, p2))
+}

vendor/github.com/templexxx/xor/xor_test.go

@@ -0,0 +1,299 @@
+package xor
+
+import (
+	"bytes"
+	"math/rand"
+	"testing"
+)
+
+func TestVerifyBytesNoSIMD(t *testing.T) {
+	for i := 1; i <= unitSize+16+2; i++ {
+		if !verifyBytesNoSIMD(i) {
+			t.Fatal("xor fault ", "size:", i)
+		}
+	}
+}
+
+func verifyBytesNoSIMD(size int) bool {
+	dst := make([]byte, size)
+	src0 := make([]byte, size)
+	src1 := make([]byte, size)
+	expect := make([]byte, size)
+	rand.Seed(7)
+	fillRandom(src0)
+	rand.Seed(8)
+	fillRandom(src1)
+	for i := 0; i < size; i++ {
+		expect[i] = src0[i] ^ src1[i]
+	}
+	xorBytes(dst, src0, src1, size)
+	return bytes.Equal(expect, dst)
+}
+
+func TestVerifyBytes(t *testing.T) {
+	for i := 1; i <= unitSize+16+2; i++ {
+		if !verifyBytes(i) {
+			t.Fatal("xor fault ", "size:", i)
+		}
+	}
+}
+
+func verifyBytes(size int) bool {
+	dst := make([]byte, size)
+	src0 := make([]byte, size)
+	src1 := make([]byte, size)
+	expect := make([]byte, size)
+	rand.Seed(7)
+	fillRandom(src0)
+	rand.Seed(8)
+	fillRandom(src1)
+	for i := 0; i < size; i++ {
+		expect[i] = src0[i] ^ src1[i]
+	}
+	xorBytes(dst, src0, src1, size)
+	return bytes.Equal(expect, dst)
+}
+
+func TestVerifyBytesSrc1(t *testing.T) {
+	for i := 1; i <= unitSize+16+2; i++ {
+		if !verifyBytesSrc1(i) {
+			t.Fatal("xor fault ", "size:", i)
+		}
+	}
+}
+func verifyBytesSrc1(size int) bool {
+	dst := make([]byte, size)
+	src0 := make([]byte, size)
+	src1 := make([]byte, size)
+	expect := make([]byte, size)
+	rand.Seed(7)
+	fillRandom(src0)
+	rand.Seed(8)
+	fillRandom(src1)
+	for i := 0; i < size; i++ {
+		expect[i] = src0[i] ^ src1[i]
+	}
+	xorSrc0(dst, src0, src1)
+	return bytes.Equal(expect, dst)
+}
+
+func TestVerifyMatrixNoSIMD(t *testing.T) {
+	for i := 1; i <= unitSize+16+2; i++ {
+		if !verifyMatrixNoSIMD(i) {
+			t.Fatal("xor fault ", "size:", i)
+		}
+	}
+}
+
+func verifyMatrixNoSIMD(size int) bool {
+	numSRC := 3
+	dst := make([]byte, size)
+	expect := make([]byte, size)
+	src := make([][]byte, numSRC)
+	for i := 0; i < numSRC; i++ {
+		src[i] = make([]byte, size)
+		rand.Seed(int64(i))
+		fillRandom(src[i])
+	}
+	for i := 0; i < size; i++ {
+		expect[i] = src[0][i] ^ src[1][i]
+	}
+	for i := 2; i < numSRC; i++ {
+		for j := 0; j < size; j++ {
+			expect[j] ^= src[i][j]
+		}
+	}
+	matrixNoSIMD(dst, src)
+	return bytes.Equal(expect, dst)
+}
+
+func TestVerifyMatrix(t *testing.T) {
+	for i := 1; i <= unitSize+16+2; i++ {
+		if !verifyMatrix(i) {
+			t.Fatal("xor fault ", "size:", i)
+		}
+	}
+}
+
+func verifyMatrix(size int) bool {
+	numSRC := 3
+	dst := make([]byte, size)
+	expect := make([]byte, size)
+	src := make([][]byte, numSRC)
+	for i := 0; i < numSRC; i++ {
+		src[i] = make([]byte, size)
+		rand.Seed(int64(i))
+		fillRandom(src[i])
+	}
+	for i := 0; i < size; i++ {
+		expect[i] = src[0][i] ^ src[1][i]
+	}
+	for i := 2; i < numSRC; i++ {
+		for j := 0; j < size; j++ {
+			expect[j] ^= src[i][j]
+		}
+	}
+	xorMatrix(dst, src)
+	return bytes.Equal(expect, dst)
+}
+
+func BenchmarkBytesNoSIMDx12B(b *testing.B) {
+	benchmarkBytesNoSIMD(b, 12)
+}
+func BenchmarkBytes12B(b *testing.B) {
+	benchmarkBytesMini(b, 12)
+}
+func BenchmarkBytesNoSIMD16B(b *testing.B) {
+	benchmarkBytesNoSIMD(b, 16)
+}
+func BenchmarkBytes16B(b *testing.B) {
+	benchmarkBytesMini(b, 16)
+}
+func BenchmarkBytesNoSIMD24B(b *testing.B) {
+	benchmarkBytesNoSIMD(b, 24)
+}
+func BenchmarkBytes24B(b *testing.B) {
+	benchmarkBytesMini(b, 24)
+}
+func BenchmarkBytesNoSIMD32B(b *testing.B) {
+	benchmarkBytesNoSIMD(b, 32)
+}
+func BenchmarkBytes32B(b *testing.B) {
+	benchmarkBytesMini(b, 32)
+}
+func benchmarkBytesMini(b *testing.B, size int) {
+	src0 := make([]byte, size)
+	src1 := make([]byte, size)
+	dst := make([]byte, size)
+	rand.Seed(int64(0))
+	fillRandom(src0)
+	rand.Seed(int64(1))
+	fillRandom(src1)
+	BytesSrc1(dst, src0, src1)
+	b.SetBytes(int64(size) * 2)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		BytesSrc1(dst, src0, src1)
+	}
+}
+
+func BenchmarkBytesNoSIMD1K(b *testing.B) {
+	benchmarkBytesNoSIMD(b, 1024)
+}
+func BenchmarkBytesNoSIMD16K(b *testing.B) {
+	benchmarkBytesNoSIMD(b, 16*1024)
+}
+func BenchmarkBytesNoSIMD16M(b *testing.B) {
+	benchmarkBytesNoSIMD(b, 16*1024*1024)
+}
+func benchmarkBytesNoSIMD(b *testing.B, size int) {
+	src1 := make([]byte, size)
+	src2 := make([]byte, size)
+	dst := make([]byte, size)
+	rand.Seed(int64(0))
+	fillRandom(src1)
+	rand.Seed(int64(1))
+	fillRandom(src2)
+	bytesNoSIMD(dst, src1, src2, size)
+	b.SetBytes(int64(size) * 2)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		bytesNoSIMD(dst, src1, src2, size)
+	}
+}
+
+func BenchmarkBytes1K(b *testing.B) {
+	benchmarkBytes(b, 1024)
+}
+func BenchmarkBytes16K(b *testing.B) {
+	benchmarkBytes(b, 16*1024)
+}
+func BenchmarkBytes16M(b *testing.B) {
+	benchmarkBytes(b, 16*1024*1024)
+}
+
+// compare with bytes
+func BenchmarkMatrix2x1K(b *testing.B) {
+	benchmarkMatrix(b, 2, 1024)
+}
+func BenchmarkMatrix2x16K(b *testing.B) {
+	benchmarkMatrix(b, 2, 16*1024)
+}
+func BenchmarkMatrix2x16M(b *testing.B) {
+	benchmarkMatrix(b, 2, 16*1024*1024)
+}
+func benchmarkBytes(b *testing.B, size int) {
+	src1 := make([]byte, size)
+	src2 := make([]byte, size)
+	dst := make([]byte, size)
+	rand.Seed(int64(0))
+	fillRandom(src1)
+	rand.Seed(int64(1))
+	fillRandom(src2)
+	xorBytes(dst, src1, src2, size)
+	b.SetBytes(int64(size) * 2)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		xorBytes(dst, src1, src2, size)
+	}
+}
+
+func BenchmarkMatrixNoSIMD5x1K(b *testing.B) {
+	benchmarkMatrixNoSIMD(b, 5, 1024)
+}
+func BenchmarkMatrixNoSIMD5x16K(b *testing.B) {
+	benchmarkMatrixNoSIMD(b, 5, 16*1024)
+}
+func BenchmarkMatrixNoSIMD5x16M(b *testing.B) {
+	benchmarkMatrixNoSIMD(b, 5, 16*1024*1024)
+}
+func benchmarkMatrixNoSIMD(b *testing.B, numSRC, size int) {
+	src := make([][]byte, numSRC)
+	dst := make([]byte, size)
+	for i := 0; i < numSRC; i++ {
+		rand.Seed(int64(i))
+		src[i] = make([]byte, size)
+		fillRandom(src[i])
+	}
+	matrixNoSIMD(dst, src)
+	b.SetBytes(int64(size * numSRC))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		matrixNoSIMD(dst, src)
+	}
+}
+
+func BenchmarkMatrix5x1K(b *testing.B) {
+	benchmarkMatrix(b, 5, 1024)
+}
+func BenchmarkMatrix5x16K(b *testing.B) {
+	benchmarkMatrix(b, 5, 16*1024)
+}
+func BenchmarkMatrix5x16M(b *testing.B) {
+	benchmarkMatrix(b, 5, 16*1024*1024)
+}
+func benchmarkMatrix(b *testing.B, numSRC, size int) {
+	src := make([][]byte, numSRC)
+	dst := make([]byte, size)
+	for i := 0; i < numSRC; i++ {
+		rand.Seed(int64(i))
+		src[i] = make([]byte, size)
+		fillRandom(src[i])
+	}
+	xorMatrix(dst, src)
+	b.SetBytes(int64(size * numSRC))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		xorMatrix(dst, src)
+	}
+}
+
+func fillRandom(p []byte) {
+	for i := 0; i < len(p); i += 7 {
+		val := rand.Int63()
+		for j := 0; i+j < len(p) && j < 7; j++ {
+			p[i+j] = byte(val)
+			val >>= 8
+		}
+	}
+}