cmd/syncthing: Enable KCP by default
Also, use upstream library, as my changes have been merged.
This commit is contained in:
Audrius Butkevicius
committed by
GitHub
GitHub
parent
889814a1af
commit
fb7264a663
193
vendor/github.com/templexxx/reedsolomon/mathtool/cntinverse.go
generated
vendored
Normal file
193
vendor/github.com/templexxx/reedsolomon/mathtool/cntinverse.go
generated
vendored
Normal file
@@ -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
|
||||
}
|
||||
270
vendor/github.com/templexxx/reedsolomon/mathtool/gentbls.go
generated
vendored
Normal file
270
vendor/github.com/templexxx/reedsolomon/mathtool/gentbls.go
generated
vendored
Normal file
@@ -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
|
||||
}
|
||||
Reference in New Issue
Block a user