mirror of https://github.com/go-gitea/gitea
Move modules/gzip to gitea.com/macaron/gzip (#9058)
* Move modules/gzip to gitea.com/macaron/gzip * Fix vendorpull/9009/head^2
Lunny Xiao
5 years ago
committed by
GitHub
parent
ba4e8f221b
commit
9ff6312627
@ -1,131 +0,0 @@ |
|||||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
|
||||||
// Use of this source code is governed by a MIT-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package gzip |
|
||||||
|
|
||||||
import ( |
|
||||||
"archive/zip" |
|
||||||
"bytes" |
|
||||||
"io/ioutil" |
|
||||||
"net/http" |
|
||||||
"net/http/httptest" |
|
||||||
"testing" |
|
||||||
|
|
||||||
"gitea.com/macaron/macaron" |
|
||||||
gzipp "github.com/klauspost/compress/gzip" |
|
||||||
"github.com/stretchr/testify/assert" |
|
||||||
) |
|
||||||
|
|
||||||
func setup(sampleResponse []byte) (*macaron.Macaron, *[]byte) { |
|
||||||
m := macaron.New() |
|
||||||
m.Use(Middleware()) |
|
||||||
m.Get("/", func() *[]byte { return &sampleResponse }) |
|
||||||
return m, &sampleResponse |
|
||||||
} |
|
||||||
|
|
||||||
func reqNoAcceptGzip(t *testing.T, m *macaron.Macaron, sampleResponse *[]byte) { |
|
||||||
// Request without accept gzip: Should not gzip
|
|
||||||
resp := httptest.NewRecorder() |
|
||||||
req, err := http.NewRequest("GET", "/", nil) |
|
||||||
assert.NoError(t, err) |
|
||||||
m.ServeHTTP(resp, req) |
|
||||||
|
|
||||||
_, ok := resp.HeaderMap[contentEncodingHeader] |
|
||||||
assert.False(t, ok) |
|
||||||
|
|
||||||
contentEncoding := resp.Header().Get(contentEncodingHeader) |
|
||||||
assert.NotContains(t, contentEncoding, "gzip") |
|
||||||
|
|
||||||
result := resp.Body.Bytes() |
|
||||||
assert.Equal(t, *sampleResponse, result) |
|
||||||
} |
|
||||||
|
|
||||||
func reqAcceptGzip(t *testing.T, m *macaron.Macaron, sampleResponse *[]byte, expectGzip bool) { |
|
||||||
// Request without accept gzip: Should not gzip
|
|
||||||
resp := httptest.NewRecorder() |
|
||||||
req, err := http.NewRequest("GET", "/", nil) |
|
||||||
assert.NoError(t, err) |
|
||||||
req.Header.Set(acceptEncodingHeader, "gzip") |
|
||||||
m.ServeHTTP(resp, req) |
|
||||||
|
|
||||||
_, ok := resp.HeaderMap[contentEncodingHeader] |
|
||||||
assert.Equal(t, ok, expectGzip) |
|
||||||
|
|
||||||
contentEncoding := resp.Header().Get(contentEncodingHeader) |
|
||||||
if expectGzip { |
|
||||||
assert.Contains(t, contentEncoding, "gzip") |
|
||||||
gzippReader, err := gzipp.NewReader(resp.Body) |
|
||||||
assert.NoError(t, err) |
|
||||||
result, err := ioutil.ReadAll(gzippReader) |
|
||||||
assert.NoError(t, err) |
|
||||||
assert.Equal(t, *sampleResponse, result) |
|
||||||
} else { |
|
||||||
assert.NotContains(t, contentEncoding, "gzip") |
|
||||||
result := resp.Body.Bytes() |
|
||||||
assert.Equal(t, *sampleResponse, result) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func TestMiddlewareSmall(t *testing.T) { |
|
||||||
m, sampleResponse := setup([]byte("Small response")) |
|
||||||
|
|
||||||
reqNoAcceptGzip(t, m, sampleResponse) |
|
||||||
|
|
||||||
reqAcceptGzip(t, m, sampleResponse, false) |
|
||||||
} |
|
||||||
|
|
||||||
func TestMiddlewareLarge(t *testing.T) { |
|
||||||
b := make([]byte, MinSize+1) |
|
||||||
for i := range b { |
|
||||||
b[i] = byte(i % 256) |
|
||||||
} |
|
||||||
m, sampleResponse := setup(b) |
|
||||||
|
|
||||||
reqNoAcceptGzip(t, m, sampleResponse) |
|
||||||
|
|
||||||
// This should be gzipped as we accept gzip
|
|
||||||
reqAcceptGzip(t, m, sampleResponse, true) |
|
||||||
} |
|
||||||
|
|
||||||
func TestMiddlewareGzip(t *testing.T) { |
|
||||||
b := make([]byte, MinSize*10) |
|
||||||
for i := range b { |
|
||||||
b[i] = byte(i % 256) |
|
||||||
} |
|
||||||
outputBuffer := bytes.NewBuffer([]byte{}) |
|
||||||
gzippWriter := gzipp.NewWriter(outputBuffer) |
|
||||||
gzippWriter.Write(b) |
|
||||||
gzippWriter.Flush() |
|
||||||
gzippWriter.Close() |
|
||||||
output := outputBuffer.Bytes() |
|
||||||
|
|
||||||
m, sampleResponse := setup(output) |
|
||||||
|
|
||||||
reqNoAcceptGzip(t, m, sampleResponse) |
|
||||||
|
|
||||||
// This should not be gzipped even though we accept gzip
|
|
||||||
reqAcceptGzip(t, m, sampleResponse, false) |
|
||||||
} |
|
||||||
|
|
||||||
func TestMiddlewareZip(t *testing.T) { |
|
||||||
b := make([]byte, MinSize*10) |
|
||||||
for i := range b { |
|
||||||
b[i] = byte(i % 256) |
|
||||||
} |
|
||||||
outputBuffer := bytes.NewBuffer([]byte{}) |
|
||||||
zipWriter := zip.NewWriter(outputBuffer) |
|
||||||
fileWriter, err := zipWriter.Create("default") |
|
||||||
assert.NoError(t, err) |
|
||||||
fileWriter.Write(b) |
|
||||||
//fileWriter.Close()
|
|
||||||
zipWriter.Close() |
|
||||||
output := outputBuffer.Bytes() |
|
||||||
|
|
||||||
m, sampleResponse := setup(output) |
|
||||||
|
|
||||||
reqNoAcceptGzip(t, m, sampleResponse) |
|
||||||
|
|
||||||
// This should not be gzipped even though we accept gzip
|
|
||||||
reqAcceptGzip(t, m, sampleResponse, false) |
|
||||||
} |
|
||||||
@ -0,0 +1,9 @@ |
|||||||
|
module gitea.com/macaron/gzip |
||||||
|
|
||||||
|
go 1.12 |
||||||
|
|
||||||
|
require ( |
||||||
|
gitea.com/macaron/macaron v1.3.3-0.20190821202302-9646c0587edb |
||||||
|
github.com/klauspost/compress v1.9.2 |
||||||
|
github.com/stretchr/testify v1.4.0 |
||||||
|
) |
||||||
@ -0,0 +1,42 @@ |
|||||||
|
gitea.com/macaron/inject v0.0.0-20190803172902-8375ba841591 h1:UbCTjPcLrNxR9LzKDjQBMT2zoxZuEnca1pZCpgeMuhQ= |
||||||
|
gitea.com/macaron/inject v0.0.0-20190803172902-8375ba841591/go.mod h1:h6E4kLao1Yko6DOU6QDnQPcuoNzvbZqzj2mtPcEn1aM= |
||||||
|
gitea.com/macaron/macaron v1.3.3-0.20190821202302-9646c0587edb h1:amL0md6orTj1tXY16ANzVU9FmzQB+W7aJwp8pVDbrmA= |
||||||
|
gitea.com/macaron/macaron v1.3.3-0.20190821202302-9646c0587edb/go.mod h1:0coI+mSPSwbsyAbOuFllVS38awuk9mevhLD52l50Gjs= |
||||||
|
github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= |
||||||
|
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= |
||||||
|
github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= |
||||||
|
github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e h1:JKmoR8x90Iww1ks85zJ1lfDGgIiMDuIptTOhJq+zKyg= |
||||||
|
github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= |
||||||
|
github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= |
||||||
|
github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= |
||||||
|
github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= |
||||||
|
github.com/klauspost/compress v1.9.2 h1:LfVyl+ZlLlLDeQ/d2AqfGIIH4qEDu0Ed2S5GyhCWIWY= |
||||||
|
github.com/klauspost/compress v1.9.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= |
||||||
|
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= |
||||||
|
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= |
||||||
|
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= |
||||||
|
github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304 h1:Jpy1PXuP99tXNrhbq2BaPz9B+jNAvH1JPQQpG/9GCXY= |
||||||
|
github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= |
||||||
|
github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s= |
||||||
|
github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 h1:WN9BUFbdyOsSH/XohnWpXOlq9NBD5sGAB2FciQMUEe8= |
||||||
|
github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= |
||||||
|
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= |
||||||
|
github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= |
||||||
|
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= |
||||||
|
github.com/unknwon/com v0.0.0-20190804042917-757f69c95f3e h1:GSGeB9EAKY2spCABz6xOX5DbxZEXolK+nBSvmsQwRjM= |
||||||
|
github.com/unknwon/com v0.0.0-20190804042917-757f69c95f3e/go.mod h1:tOOxU81rwgoCLoOVVPHb6T/wt8HZygqH5id+GNnlCXM= |
||||||
|
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= |
||||||
|
golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4 h1:HuIa8hRrWRSrqYzx1qI49NNxhdi2PrY7gxVSq1JjLDc= |
||||||
|
golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= |
||||||
|
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= |
||||||
|
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= |
||||||
|
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= |
||||||
|
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= |
||||||
|
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= |
||||||
|
golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= |
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= |
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= |
||||||
|
gopkg.in/ini.v1 v1.44.0 h1:YRJzTUp0kSYWUVFF5XAbDFfyiqwsl0Vb9R8TVP5eRi0= |
||||||
|
gopkg.in/ini.v1 v1.44.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= |
||||||
|
gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= |
||||||
|
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= |
||||||
@ -1,32 +0,0 @@ |
|||||||
// Copyright 2012 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 flate |
|
||||||
|
|
||||||
// forwardCopy is like the built-in copy function except that it always goes
|
|
||||||
// forward from the start, even if the dst and src overlap.
|
|
||||||
// It is equivalent to:
|
|
||||||
// for i := 0; i < n; i++ {
|
|
||||||
// mem[dst+i] = mem[src+i]
|
|
||||||
// }
|
|
||||||
func forwardCopy(mem []byte, dst, src, n int) { |
|
||||||
if dst <= src { |
|
||||||
copy(mem[dst:dst+n], mem[src:src+n]) |
|
||||||
return |
|
||||||
} |
|
||||||
for { |
|
||||||
if dst >= src+n { |
|
||||||
copy(mem[dst:dst+n], mem[src:src+n]) |
|
||||||
return |
|
||||||
} |
|
||||||
// There is some forward overlap. The destination
|
|
||||||
// will be filled with a repeated pattern of mem[src:src+k].
|
|
||||||
// We copy one instance of the pattern here, then repeat.
|
|
||||||
// Each time around this loop k will double.
|
|
||||||
k := dst - src |
|
||||||
copy(mem[dst:dst+k], mem[src:src+k]) |
|
||||||
n -= k |
|
||||||
dst += k |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,41 +0,0 @@ |
|||||||
//+build !noasm
|
|
||||||
//+build !appengine
|
|
||||||
|
|
||||||
// Copyright 2015, Klaus Post, see LICENSE for details.
|
|
||||||
|
|
||||||
package flate |
|
||||||
|
|
||||||
import ( |
|
||||||
"github.com/klauspost/cpuid" |
|
||||||
) |
|
||||||
|
|
||||||
// crc32sse returns a hash for the first 4 bytes of the slice
|
|
||||||
// len(a) must be >= 4.
|
|
||||||
//go:noescape
|
|
||||||
func crc32sse(a []byte) uint32 |
|
||||||
|
|
||||||
// crc32sseAll calculates hashes for each 4-byte set in a.
|
|
||||||
// dst must be east len(a) - 4 in size.
|
|
||||||
// The size is not checked by the assembly.
|
|
||||||
//go:noescape
|
|
||||||
func crc32sseAll(a []byte, dst []uint32) |
|
||||||
|
|
||||||
// matchLenSSE4 returns the number of matching bytes in a and b
|
|
||||||
// up to length 'max'. Both slices must be at least 'max'
|
|
||||||
// bytes in size.
|
|
||||||
//
|
|
||||||
// TODO: drop the "SSE4" name, since it doesn't use any SSE instructions.
|
|
||||||
//
|
|
||||||
//go:noescape
|
|
||||||
func matchLenSSE4(a, b []byte, max int) int |
|
||||||
|
|
||||||
// histogram accumulates a histogram of b in h.
|
|
||||||
// h must be at least 256 entries in length,
|
|
||||||
// and must be cleared before calling this function.
|
|
||||||
//go:noescape
|
|
||||||
func histogram(b []byte, h []int32) |
|
||||||
|
|
||||||
// Detect SSE 4.2 feature.
|
|
||||||
func init() { |
|
||||||
useSSE42 = cpuid.CPU.SSE42() |
|
||||||
} |
|
||||||
@ -1,213 +0,0 @@ |
|||||||
//+build !noasm |
|
||||||
//+build !appengine |
|
||||||
|
|
||||||
// Copyright 2015, Klaus Post, see LICENSE for details. |
|
||||||
|
|
||||||
// func crc32sse(a []byte) uint32 |
|
||||||
TEXT ·crc32sse(SB), 4, $0 |
|
||||||
MOVQ a+0(FP), R10 |
|
||||||
XORQ BX, BX |
|
||||||
|
|
||||||
// CRC32 dword (R10), EBX |
|
||||||
BYTE $0xF2; BYTE $0x41; BYTE $0x0f
|
|
||||||
BYTE $0x38; BYTE $0xf1; BYTE $0x1a
|
|
||||||
|
|
||||||
MOVL BX, ret+24(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func crc32sseAll(a []byte, dst []uint32) |
|
||||||
TEXT ·crc32sseAll(SB), 4, $0 |
|
||||||
MOVQ a+0(FP), R8 // R8: src |
|
||||||
MOVQ a_len+8(FP), R10 // input length |
|
||||||
MOVQ dst+24(FP), R9 // R9: dst |
|
||||||
SUBQ $4, R10 |
|
||||||
JS end |
|
||||||
JZ one_crc |
|
||||||
MOVQ R10, R13 |
|
||||||
SHRQ $2, R10 // len/4 |
|
||||||
ANDQ $3, R13 // len&3 |
|
||||||
XORQ BX, BX |
|
||||||
ADDQ $1, R13 |
|
||||||
TESTQ R10, R10 |
|
||||||
JZ rem_loop |
|
||||||
|
|
||||||
crc_loop: |
|
||||||
MOVQ (R8), R11 |
|
||||||
XORQ BX, BX |
|
||||||
XORQ DX, DX |
|
||||||
XORQ DI, DI |
|
||||||
MOVQ R11, R12 |
|
||||||
SHRQ $8, R11 |
|
||||||
MOVQ R12, AX |
|
||||||
MOVQ R11, CX |
|
||||||
SHRQ $16, R12 |
|
||||||
SHRQ $16, R11 |
|
||||||
MOVQ R12, SI |
|
||||||
|
|
||||||
// CRC32 EAX, EBX |
|
||||||
BYTE $0xF2; BYTE $0x0f
|
|
||||||
BYTE $0x38; BYTE $0xf1; BYTE $0xd8
|
|
||||||
|
|
||||||
// CRC32 ECX, EDX |
|
||||||
BYTE $0xF2; BYTE $0x0f
|
|
||||||
BYTE $0x38; BYTE $0xf1; BYTE $0xd1
|
|
||||||
|
|
||||||
// CRC32 ESI, EDI |
|
||||||
BYTE $0xF2; BYTE $0x0f
|
|
||||||
BYTE $0x38; BYTE $0xf1; BYTE $0xfe
|
|
||||||
MOVL BX, (R9) |
|
||||||
MOVL DX, 4(R9) |
|
||||||
MOVL DI, 8(R9) |
|
||||||
|
|
||||||
XORQ BX, BX |
|
||||||
MOVL R11, AX |
|
||||||
|
|
||||||
// CRC32 EAX, EBX |
|
||||||
BYTE $0xF2; BYTE $0x0f
|
|
||||||
BYTE $0x38; BYTE $0xf1; BYTE $0xd8
|
|
||||||
MOVL BX, 12(R9) |
|
||||||
|
|
||||||
ADDQ $16, R9 |
|
||||||
ADDQ $4, R8 |
|
||||||
XORQ BX, BX |
|
||||||
SUBQ $1, R10 |
|
||||||
JNZ crc_loop |
|
||||||
|
|
||||||
rem_loop: |
|
||||||
MOVL (R8), AX |
|
||||||
|
|
||||||
// CRC32 EAX, EBX |
|
||||||
BYTE $0xF2; BYTE $0x0f
|
|
||||||
BYTE $0x38; BYTE $0xf1; BYTE $0xd8
|
|
||||||
|
|
||||||
MOVL BX, (R9) |
|
||||||
ADDQ $4, R9 |
|
||||||
ADDQ $1, R8 |
|
||||||
XORQ BX, BX |
|
||||||
SUBQ $1, R13 |
|
||||||
JNZ rem_loop |
|
||||||
|
|
||||||
end: |
|
||||||
RET |
|
||||||
|
|
||||||
one_crc: |
|
||||||
MOVQ $1, R13 |
|
||||||
XORQ BX, BX |
|
||||||
JMP rem_loop |
|
||||||
|
|
||||||
// func matchLenSSE4(a, b []byte, max int) int |
|
||||||
TEXT ·matchLenSSE4(SB), 4, $0 |
|
||||||
MOVQ a_base+0(FP), SI |
|
||||||
MOVQ b_base+24(FP), DI |
|
||||||
MOVQ DI, DX |
|
||||||
MOVQ max+48(FP), CX |
|
||||||
|
|
||||||
cmp8: |
|
||||||
// As long as we are 8 or more bytes before the end of max, we can load and |
|
||||||
// compare 8 bytes at a time. If those 8 bytes are equal, repeat. |
|
||||||
CMPQ CX, $8 |
|
||||||
JLT cmp1 |
|
||||||
MOVQ (SI), AX |
|
||||||
MOVQ (DI), BX |
|
||||||
CMPQ AX, BX |
|
||||||
JNE bsf |
|
||||||
ADDQ $8, SI |
|
||||||
ADDQ $8, DI |
|
||||||
SUBQ $8, CX |
|
||||||
JMP cmp8 |
|
||||||
|
|
||||||
bsf: |
|
||||||
// If those 8 bytes were not equal, XOR the two 8 byte values, and return |
|
||||||
// the index of the first byte that differs. The BSF instruction finds the |
|
||||||
// least significant 1 bit, the amd64 architecture is little-endian, and |
|
||||||
// the shift by 3 converts a bit index to a byte index. |
|
||||||
XORQ AX, BX |
|
||||||
BSFQ BX, BX |
|
||||||
SHRQ $3, BX |
|
||||||
ADDQ BX, DI |
|
||||||
|
|
||||||
// Subtract off &b[0] to convert from &b[ret] to ret, and return. |
|
||||||
SUBQ DX, DI |
|
||||||
MOVQ DI, ret+56(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
cmp1: |
|
||||||
// In the slices' tail, compare 1 byte at a time. |
|
||||||
CMPQ CX, $0 |
|
||||||
JEQ matchLenEnd |
|
||||||
MOVB (SI), AX |
|
||||||
MOVB (DI), BX |
|
||||||
CMPB AX, BX |
|
||||||
JNE matchLenEnd |
|
||||||
ADDQ $1, SI |
|
||||||
ADDQ $1, DI |
|
||||||
SUBQ $1, CX |
|
||||||
JMP cmp1 |
|
||||||
|
|
||||||
matchLenEnd: |
|
||||||
// Subtract off &b[0] to convert from &b[ret] to ret, and return. |
|
||||||
SUBQ DX, DI |
|
||||||
MOVQ DI, ret+56(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func histogram(b []byte, h []int32) |
|
||||||
TEXT ·histogram(SB), 4, $0 |
|
||||||
MOVQ b+0(FP), SI // SI: &b |
|
||||||
MOVQ b_len+8(FP), R9 // R9: len(b) |
|
||||||
MOVQ h+24(FP), DI // DI: Histogram |
|
||||||
MOVQ R9, R8 |
|
||||||
SHRQ $3, R8 |
|
||||||
JZ hist1 |
|
||||||
XORQ R11, R11 |
|
||||||
|
|
||||||
loop_hist8: |
|
||||||
MOVQ (SI), R10 |
|
||||||
|
|
||||||
MOVB R10, R11 |
|
||||||
INCL (DI)(R11*4) |
|
||||||
SHRQ $8, R10 |
|
||||||
|
|
||||||
MOVB R10, R11 |
|
||||||
INCL (DI)(R11*4) |
|
||||||
SHRQ $8, R10 |
|
||||||
|
|
||||||
MOVB R10, R11 |
|
||||||
INCL (DI)(R11*4) |
|
||||||
SHRQ $8, R10 |
|
||||||
|
|
||||||
MOVB R10, R11 |
|
||||||
INCL (DI)(R11*4) |
|
||||||
SHRQ $8, R10 |
|
||||||
|
|
||||||
MOVB R10, R11 |
|
||||||
INCL (DI)(R11*4) |
|
||||||
SHRQ $8, R10 |
|
||||||
|
|
||||||
MOVB R10, R11 |
|
||||||
INCL (DI)(R11*4) |
|
||||||
SHRQ $8, R10 |
|
||||||
|
|
||||||
MOVB R10, R11 |
|
||||||
INCL (DI)(R11*4) |
|
||||||
SHRQ $8, R10 |
|
||||||
|
|
||||||
INCL (DI)(R10*4) |
|
||||||
|
|
||||||
ADDQ $8, SI |
|
||||||
DECQ R8 |
|
||||||
JNZ loop_hist8 |
|
||||||
|
|
||||||
hist1: |
|
||||||
ANDQ $7, R9 |
|
||||||
JZ end_hist |
|
||||||
XORQ R10, R10 |
|
||||||
|
|
||||||
loop_hist1: |
|
||||||
MOVB (SI), R10 |
|
||||||
INCL (DI)(R10*4) |
|
||||||
INCQ SI |
|
||||||
DECQ R9 |
|
||||||
JNZ loop_hist1 |
|
||||||
|
|
||||||
end_hist: |
|
||||||
RET |
|
||||||
@ -1,35 +0,0 @@ |
|||||||
//+build !amd64 noasm appengine
|
|
||||||
|
|
||||||
// Copyright 2015, Klaus Post, see LICENSE for details.
|
|
||||||
|
|
||||||
package flate |
|
||||||
|
|
||||||
func init() { |
|
||||||
useSSE42 = false |
|
||||||
} |
|
||||||
|
|
||||||
// crc32sse should never be called.
|
|
||||||
func crc32sse(a []byte) uint32 { |
|
||||||
panic("no assembler") |
|
||||||
} |
|
||||||
|
|
||||||
// crc32sseAll should never be called.
|
|
||||||
func crc32sseAll(a []byte, dst []uint32) { |
|
||||||
panic("no assembler") |
|
||||||
} |
|
||||||
|
|
||||||
// matchLenSSE4 should never be called.
|
|
||||||
func matchLenSSE4(a, b []byte, max int) int { |
|
||||||
panic("no assembler") |
|
||||||
return 0 |
|
||||||
} |
|
||||||
|
|
||||||
// histogram accumulates a histogram of b in h.
|
|
||||||
//
|
|
||||||
// len(h) must be >= 256, and h's elements must be all zeroes.
|
|
||||||
func histogram(b []byte, h []int32) { |
|
||||||
h = h[:256] |
|
||||||
for _, t := range b { |
|
||||||
h[t]++ |
|
||||||
} |
|
||||||
} |
|
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,257 @@ |
|||||||
|
// Copyright 2011 The Snappy-Go Authors. All rights reserved.
|
||||||
|
// Modified for deflate by Klaus Post (c) 2015.
|
||||||
|
// Use of this source code is governed by a BSD-style
|
||||||
|
// license that can be found in the LICENSE file.
|
||||||
|
|
||||||
|
package flate |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"math/bits" |
||||||
|
) |
||||||
|
|
||||||
|
type fastEnc interface { |
||||||
|
Encode(dst *tokens, src []byte) |
||||||
|
Reset() |
||||||
|
} |
||||||
|
|
||||||
|
func newFastEnc(level int) fastEnc { |
||||||
|
switch level { |
||||||
|
case 1: |
||||||
|
return &fastEncL1{fastGen: fastGen{cur: maxStoreBlockSize}} |
||||||
|
case 2: |
||||||
|
return &fastEncL2{fastGen: fastGen{cur: maxStoreBlockSize}} |
||||||
|
case 3: |
||||||
|
return &fastEncL3{fastGen: fastGen{cur: maxStoreBlockSize}} |
||||||
|
case 4: |
||||||
|
return &fastEncL4{fastGen: fastGen{cur: maxStoreBlockSize}} |
||||||
|
case 5: |
||||||
|
return &fastEncL5{fastGen: fastGen{cur: maxStoreBlockSize}} |
||||||
|
case 6: |
||||||
|
return &fastEncL6{fastGen: fastGen{cur: maxStoreBlockSize}} |
||||||
|
default: |
||||||
|
panic("invalid level specified") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
const ( |
||||||
|
tableBits = 16 // Bits used in the table
|
||||||
|
tableSize = 1 << tableBits // Size of the table
|
||||||
|
tableShift = 32 - tableBits // Right-shift to get the tableBits most significant bits of a uint32.
|
||||||
|
baseMatchOffset = 1 // The smallest match offset
|
||||||
|
baseMatchLength = 3 // The smallest match length per the RFC section 3.2.5
|
||||||
|
maxMatchOffset = 1 << 15 // The largest match offset
|
||||||
|
|
||||||
|
bTableBits = 18 // Bits used in the big tables
|
||||||
|
bTableSize = 1 << bTableBits // Size of the table
|
||||||
|
allocHistory = maxMatchOffset * 10 // Size to preallocate for history.
|
||||||
|
bufferReset = (1 << 31) - allocHistory - maxStoreBlockSize // Reset the buffer offset when reaching this.
|
||||||
|
) |
||||||
|
|
||||||
|
const ( |
||||||
|
prime3bytes = 506832829 |
||||||
|
prime4bytes = 2654435761 |
||||||
|
prime5bytes = 889523592379 |
||||||
|
prime6bytes = 227718039650203 |
||||||
|
prime7bytes = 58295818150454627 |
||||||
|
prime8bytes = 0xcf1bbcdcb7a56463 |
||||||
|
) |
||||||
|
|
||||||
|
func load32(b []byte, i int) uint32 { |
||||||
|
// Help the compiler eliminate bounds checks on the read so it can be done in a single read.
|
||||||
|
b = b[i:] |
||||||
|
b = b[:4] |
||||||
|
return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 |
||||||
|
} |
||||||
|
|
||||||
|
func load64(b []byte, i int) uint64 { |
||||||
|
// Help the compiler eliminate bounds checks on the read so it can be done in a single read.
|
||||||
|
b = b[i:] |
||||||
|
b = b[:8] |
||||||
|
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | |
||||||
|
uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 |
||||||
|
} |
||||||
|
|
||||||
|
func load3232(b []byte, i int32) uint32 { |
||||||
|
// Help the compiler eliminate bounds checks on the read so it can be done in a single read.
|
||||||
|
b = b[i:] |
||||||
|
b = b[:4] |
||||||
|
return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 |
||||||
|
} |
||||||
|
|
||||||
|
func load6432(b []byte, i int32) uint64 { |
||||||
|
// Help the compiler eliminate bounds checks on the read so it can be done in a single read.
|
||||||
|
b = b[i:] |
||||||
|
b = b[:8] |
||||||
|
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | |
||||||
|
uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 |
||||||
|
} |
||||||
|
|
||||||
|
func hash(u uint32) uint32 { |
||||||
|
return (u * 0x1e35a7bd) >> tableShift |
||||||
|
} |
||||||
|
|
||||||
|
type tableEntry struct { |
||||||
|
val uint32 |
||||||
|
offset int32 |
||||||
|
} |
||||||
|
|
||||||
|
// fastGen maintains the table for matches,
|
||||||
|
// and the previous byte block for level 2.
|
||||||
|
// This is the generic implementation.
|
||||||
|
type fastGen struct { |
||||||
|
hist []byte |
||||||
|
cur int32 |
||||||
|
} |
||||||
|
|
||||||
|
func (e *fastGen) addBlock(src []byte) int32 { |
||||||
|
// check if we have space already
|
||||||
|
if len(e.hist)+len(src) > cap(e.hist) { |
||||||
|
if cap(e.hist) == 0 { |
||||||
|
e.hist = make([]byte, 0, allocHistory) |
||||||
|
} else { |
||||||
|
if cap(e.hist) < maxMatchOffset*2 { |
||||||
|
panic("unexpected buffer size") |
||||||
|
} |
||||||
|
// Move down
|
||||||
|
offset := int32(len(e.hist)) - maxMatchOffset |
||||||
|
copy(e.hist[0:maxMatchOffset], e.hist[offset:]) |
||||||
|
e.cur += offset |
||||||
|
e.hist = e.hist[:maxMatchOffset] |
||||||
|
} |
||||||
|
} |
||||||
|
s := int32(len(e.hist)) |
||||||
|
e.hist = append(e.hist, src...) |
||||||
|
return s |
||||||
|
} |
||||||
|
|
||||||
|
// hash4 returns the hash of u to fit in a hash table with h bits.
|
||||||
|
// Preferably h should be a constant and should always be <32.
|
||||||
|
func hash4u(u uint32, h uint8) uint32 { |
||||||
|
return (u * prime4bytes) >> ((32 - h) & 31) |
||||||
|
} |
||||||
|
|
||||||
|
type tableEntryPrev struct { |
||||||
|
Cur tableEntry |
||||||
|
Prev tableEntry |
||||||
|
} |
||||||
|
|
||||||
|
// hash4x64 returns the hash of the lowest 4 bytes of u to fit in a hash table with h bits.
|
||||||
|
// Preferably h should be a constant and should always be <32.
|
||||||
|
func hash4x64(u uint64, h uint8) uint32 { |
||||||
|
return (uint32(u) * prime4bytes) >> ((32 - h) & 31) |
||||||
|
} |
||||||
|
|
||||||
|
// hash7 returns the hash of the lowest 7 bytes of u to fit in a hash table with h bits.
|
||||||
|
// Preferably h should be a constant and should always be <64.
|
||||||
|
func hash7(u uint64, h uint8) uint32 { |
||||||
|
return uint32(((u << (64 - 56)) * prime7bytes) >> ((64 - h) & 63)) |
||||||
|
} |
||||||
|
|
||||||
|
// hash8 returns the hash of u to fit in a hash table with h bits.
|
||||||
|
// Preferably h should be a constant and should always be <64.
|
||||||
|
func hash8(u uint64, h uint8) uint32 { |
||||||
|
return uint32((u * prime8bytes) >> ((64 - h) & 63)) |
||||||
|
} |
||||||
|
|
||||||
|
// hash6 returns the hash of the lowest 6 bytes of u to fit in a hash table with h bits.
|
||||||
|
// Preferably h should be a constant and should always be <64.
|
||||||
|
func hash6(u uint64, h uint8) uint32 { |
||||||
|
return uint32(((u << (64 - 48)) * prime6bytes) >> ((64 - h) & 63)) |
||||||
|
} |
||||||
|
|
||||||
|
// matchlen will return the match length between offsets and t in src.
|
||||||
|
// The maximum length returned is maxMatchLength - 4.
|
||||||
|
// It is assumed that s > t, that t >=0 and s < len(src).
|
||||||
|
func (e *fastGen) matchlen(s, t int32, src []byte) int32 { |
||||||
|
if debugDecode { |
||||||
|
if t >= s { |
||||||
|
panic(fmt.Sprint("t >=s:", t, s)) |
||||||
|
} |
||||||
|
if int(s) >= len(src) { |
||||||
|
panic(fmt.Sprint("s >= len(src):", s, len(src))) |
||||||
|
} |
||||||
|
if t < 0 { |
||||||
|
panic(fmt.Sprint("t < 0:", t)) |
||||||
|
} |
||||||
|
if s-t > maxMatchOffset { |
||||||
|
panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")")) |
||||||
|
} |
||||||
|
} |
||||||
|
s1 := int(s) + maxMatchLength - 4 |
||||||
|
if s1 > len(src) { |
||||||
|
s1 = len(src) |
||||||
|
} |
||||||
|
|
||||||
|
// Extend the match to be as long as possible.
|
||||||
|
return int32(matchLen(src[s:s1], src[t:])) |
||||||
|
} |
||||||
|
|
||||||
|
// matchlenLong will return the match length between offsets and t in src.
|
||||||
|
// It is assumed that s > t, that t >=0 and s < len(src).
|
||||||
|
func (e *fastGen) matchlenLong(s, t int32, src []byte) int32 { |
||||||
|
if debugDecode { |
||||||
|
if t >= s { |
||||||
|
panic(fmt.Sprint("t >=s:", t, s)) |
||||||
|
} |
||||||
|
if int(s) >= len(src) { |
||||||
|
panic(fmt.Sprint("s >= len(src):", s, len(src))) |
||||||
|
} |
||||||
|
if t < 0 { |
||||||
|
panic(fmt.Sprint("t < 0:", t)) |
||||||
|
} |
||||||
|
if s-t > maxMatchOffset { |
||||||
|
panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")")) |
||||||
|
} |
||||||
|
} |
||||||
|
// Extend the match to be as long as possible.
|
||||||
|
return int32(matchLen(src[s:], src[t:])) |
||||||
|
} |
||||||
|
|
||||||
|
// Reset the encoding table.
|
||||||
|
func (e *fastGen) Reset() { |
||||||
|
if cap(e.hist) < int(maxMatchOffset*8) { |
||||||
|
l := maxMatchOffset * 8 |
||||||
|
// Make it at least 1MB.
|
||||||
|
if l < 1<<20 { |
||||||
|
l = 1 << 20 |
||||||
|
} |
||||||
|
e.hist = make([]byte, 0, l) |
||||||
|
} |
||||||
|
// We offset current position so everything will be out of reach
|
||||||
|
e.cur += maxMatchOffset + int32(len(e.hist)) |
||||||
|
e.hist = e.hist[:0] |
||||||
|
} |
||||||
|
|
||||||
|
// matchLen returns the maximum length.
|
||||||
|
// 'a' must be the shortest of the two.
|
||||||
|
func matchLen(a, b []byte) int { |
||||||
|
b = b[:len(a)] |
||||||
|
var checked int |
||||||
|
if len(a) > 4 { |
||||||
|
// Try 4 bytes first
|
||||||
|
if diff := load32(a, 0) ^ load32(b, 0); diff != 0 { |
||||||
|
return bits.TrailingZeros32(diff) >> 3 |
||||||
|
} |
||||||
|
// Switch to 8 byte matching.
|
||||||
|
checked = 4 |
||||||
|
a = a[4:] |
||||||
|
b = b[4:] |
||||||
|
for len(a) >= 8 { |
||||||
|
b = b[:len(a)] |
||||||
|
if diff := load64(a, 0) ^ load64(b, 0); diff != 0 { |
||||||
|
return checked + (bits.TrailingZeros64(diff) >> 3) |
||||||
|
} |
||||||
|
checked += 8 |
||||||
|
a = a[8:] |
||||||
|
b = b[8:] |
||||||
|
} |
||||||
|
} |
||||||
|
b = b[:len(a)] |
||||||
|
for i := range a { |
||||||
|
if a[i] != b[i] { |
||||||
|
return int(i) + checked |
||||||
|
} |
||||||
|
} |
||||||
|
return len(a) + checked |
||||||
|
} |
||||||
@ -0,0 +1,174 @@ |
|||||||
|
package flate |
||||||
|
|
||||||
|
// fastGen maintains the table for matches,
|
||||||
|
// and the previous byte block for level 2.
|
||||||
|
// This is the generic implementation.
|
||||||
|
type fastEncL1 struct { |
||||||
|
fastGen |
||||||
|
table [tableSize]tableEntry |
||||||
|
} |
||||||
|
|
||||||
|
// EncodeL1 uses a similar algorithm to level 1
|
||||||
|
func (e *fastEncL1) Encode(dst *tokens, src []byte) { |
||||||
|
const ( |
||||||
|
inputMargin = 12 - 1 |
||||||
|
minNonLiteralBlockSize = 1 + 1 + inputMargin |
||||||
|
) |
||||||
|
|
||||||
|
// Protect against e.cur wraparound.
|
||||||
|
for e.cur >= bufferReset { |
||||||
|
if len(e.hist) == 0 { |
||||||
|
for i := range e.table[:] { |
||||||
|
e.table[i] = tableEntry{} |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
break |
||||||
|
} |
||||||
|
// Shift down everything in the table that isn't already too far away.
|
||||||
|
minOff := e.cur + int32(len(e.hist)) - maxMatchOffset |
||||||
|
for i := range e.table[:] { |
||||||
|
v := e.table[i].offset |
||||||
|
if v <= minOff { |
||||||
|
v = 0 |
||||||
|
} else { |
||||||
|
v = v - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
e.table[i].offset = v |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
} |
||||||
|
|
||||||
|
s := e.addBlock(src) |
||||||
|
|
||||||
|
// This check isn't in the Snappy implementation, but there, the caller
|
||||||
|
// instead of the callee handles this case.
|
||||||
|
if len(src) < minNonLiteralBlockSize { |
||||||
|
// We do not fill the token table.
|
||||||
|
// This will be picked up by caller.
|
||||||
|
dst.n = uint16(len(src)) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Override src
|
||||||
|
src = e.hist |
||||||
|
nextEmit := s |
||||||
|
|
||||||
|
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
||||||
|
// lets us use a fast path for emitLiteral in the main loop, while we are
|
||||||
|
// looking for copies.
|
||||||
|
sLimit := int32(len(src) - inputMargin) |
||||||
|
|
||||||
|
// nextEmit is where in src the next emitLiteral should start from.
|
||||||
|
cv := load3232(src, s) |
||||||
|
|
||||||
|
for { |
||||||
|
const skipLog = 5 |
||||||
|
const doEvery = 2 |
||||||
|
|
||||||
|
nextS := s |
||||||
|
var candidate tableEntry |
||||||
|
for { |
||||||
|
nextHash := hash(cv) |
||||||
|
candidate = e.table[nextHash] |
||||||
|
nextS = s + doEvery + (s-nextEmit)>>skipLog |
||||||
|
if nextS > sLimit { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
now := load6432(src, nextS) |
||||||
|
e.table[nextHash] = tableEntry{offset: s + e.cur, val: cv} |
||||||
|
nextHash = hash(uint32(now)) |
||||||
|
|
||||||
|
offset := s - (candidate.offset - e.cur) |
||||||
|
if offset < maxMatchOffset && cv == candidate.val { |
||||||
|
e.table[nextHash] = tableEntry{offset: nextS + e.cur, val: uint32(now)} |
||||||
|
break |
||||||
|
} |
||||||
|
|
||||||
|
// Do one right away...
|
||||||
|
cv = uint32(now) |
||||||
|
s = nextS |
||||||
|
nextS++ |
||||||
|
candidate = e.table[nextHash] |
||||||
|
now >>= 8 |
||||||
|
e.table[nextHash] = tableEntry{offset: s + e.cur, val: cv} |
||||||
|
|
||||||
|
offset = s - (candidate.offset - e.cur) |
||||||
|
if offset < maxMatchOffset && cv == candidate.val { |
||||||
|
e.table[nextHash] = tableEntry{offset: nextS + e.cur, val: uint32(now)} |
||||||
|
break |
||||||
|
} |
||||||
|
cv = uint32(now) |
||||||
|
s = nextS |
||||||
|
} |
||||||
|
|
||||||
|
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
||||||
|
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
||||||
|
// them as literal bytes.
|
||||||
|
for { |
||||||
|
// Invariant: we have a 4-byte match at s, and no need to emit any
|
||||||
|
// literal bytes prior to s.
|
||||||
|
|
||||||
|
// Extend the 4-byte match as long as possible.
|
||||||
|
t := candidate.offset - e.cur |
||||||
|
l := e.matchlenLong(s+4, t+4, src) + 4 |
||||||
|
|
||||||
|
// Extend backwards
|
||||||
|
for t > 0 && s > nextEmit && src[t-1] == src[s-1] { |
||||||
|
s-- |
||||||
|
t-- |
||||||
|
l++ |
||||||
|
} |
||||||
|
if nextEmit < s { |
||||||
|
emitLiteral(dst, src[nextEmit:s]) |
||||||
|
} |
||||||
|
|
||||||
|
// Save the match found
|
||||||
|
dst.AddMatchLong(l, uint32(s-t-baseMatchOffset)) |
||||||
|
s += l |
||||||
|
nextEmit = s |
||||||
|
if nextS >= s { |
||||||
|
s = nextS + 1 |
||||||
|
} |
||||||
|
if s >= sLimit { |
||||||
|
// Index first pair after match end.
|
||||||
|
if int(s+l+4) < len(src) { |
||||||
|
cv := load3232(src, s) |
||||||
|
e.table[hash(cv)] = tableEntry{offset: s + e.cur, val: cv} |
||||||
|
} |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
// We could immediately start working at s now, but to improve
|
||||||
|
// compression we first update the hash table at s-2 and at s. If
|
||||||
|
// another emitCopy is not our next move, also calculate nextHash
|
||||||
|
// at s+1. At least on GOARCH=amd64, these three hash calculations
|
||||||
|
// are faster as one load64 call (with some shifts) instead of
|
||||||
|
// three load32 calls.
|
||||||
|
x := load6432(src, s-2) |
||||||
|
o := e.cur + s - 2 |
||||||
|
prevHash := hash(uint32(x)) |
||||||
|
e.table[prevHash] = tableEntry{offset: o, val: uint32(x)} |
||||||
|
x >>= 16 |
||||||
|
currHash := hash(uint32(x)) |
||||||
|
candidate = e.table[currHash] |
||||||
|
e.table[currHash] = tableEntry{offset: o + 2, val: uint32(x)} |
||||||
|
|
||||||
|
offset := s - (candidate.offset - e.cur) |
||||||
|
if offset > maxMatchOffset || uint32(x) != candidate.val { |
||||||
|
cv = uint32(x >> 8) |
||||||
|
s++ |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
emitRemainder: |
||||||
|
if int(nextEmit) < len(src) { |
||||||
|
// If nothing was added, don't encode literals.
|
||||||
|
if dst.n == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
emitLiteral(dst, src[nextEmit:]) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,199 @@ |
|||||||
|
package flate |
||||||
|
|
||||||
|
// fastGen maintains the table for matches,
|
||||||
|
// and the previous byte block for level 2.
|
||||||
|
// This is the generic implementation.
|
||||||
|
type fastEncL2 struct { |
||||||
|
fastGen |
||||||
|
table [bTableSize]tableEntry |
||||||
|
} |
||||||
|
|
||||||
|
// EncodeL2 uses a similar algorithm to level 1, but is capable
|
||||||
|
// of matching across blocks giving better compression at a small slowdown.
|
||||||
|
func (e *fastEncL2) Encode(dst *tokens, src []byte) { |
||||||
|
const ( |
||||||
|
inputMargin = 12 - 1 |
||||||
|
minNonLiteralBlockSize = 1 + 1 + inputMargin |
||||||
|
) |
||||||
|
|
||||||
|
// Protect against e.cur wraparound.
|
||||||
|
for e.cur >= bufferReset { |
||||||
|
if len(e.hist) == 0 { |
||||||
|
for i := range e.table[:] { |
||||||
|
e.table[i] = tableEntry{} |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
break |
||||||
|
} |
||||||
|
// Shift down everything in the table that isn't already too far away.
|
||||||
|
minOff := e.cur + int32(len(e.hist)) - maxMatchOffset |
||||||
|
for i := range e.table[:] { |
||||||
|
v := e.table[i].offset |
||||||
|
if v <= minOff { |
||||||
|
v = 0 |
||||||
|
} else { |
||||||
|
v = v - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
e.table[i].offset = v |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
} |
||||||
|
|
||||||
|
s := e.addBlock(src) |
||||||
|
|
||||||
|
// This check isn't in the Snappy implementation, but there, the caller
|
||||||
|
// instead of the callee handles this case.
|
||||||
|
if len(src) < minNonLiteralBlockSize { |
||||||
|
// We do not fill the token table.
|
||||||
|
// This will be picked up by caller.
|
||||||
|
dst.n = uint16(len(src)) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Override src
|
||||||
|
src = e.hist |
||||||
|
nextEmit := s |
||||||
|
|
||||||
|
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
||||||
|
// lets us use a fast path for emitLiteral in the main loop, while we are
|
||||||
|
// looking for copies.
|
||||||
|
sLimit := int32(len(src) - inputMargin) |
||||||
|
|
||||||
|
// nextEmit is where in src the next emitLiteral should start from.
|
||||||
|
cv := load3232(src, s) |
||||||
|
for { |
||||||
|
// When should we start skipping if we haven't found matches in a long while.
|
||||||
|
const skipLog = 5 |
||||||
|
const doEvery = 2 |
||||||
|
|
||||||
|
nextS := s |
||||||
|
var candidate tableEntry |
||||||
|
for { |
||||||
|
nextHash := hash4u(cv, bTableBits) |
||||||
|
s = nextS |
||||||
|
nextS = s + doEvery + (s-nextEmit)>>skipLog |
||||||
|
if nextS > sLimit { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
candidate = e.table[nextHash] |
||||||
|
now := load6432(src, nextS) |
||||||
|
e.table[nextHash] = tableEntry{offset: s + e.cur, val: cv} |
||||||
|
nextHash = hash4u(uint32(now), bTableBits) |
||||||
|
|
||||||
|
offset := s - (candidate.offset - e.cur) |
||||||
|
if offset < maxMatchOffset && cv == candidate.val { |
||||||
|
e.table[nextHash] = tableEntry{offset: nextS + e.cur, val: uint32(now)} |
||||||
|
break |
||||||
|
} |
||||||
|
|
||||||
|
// Do one right away...
|
||||||
|
cv = uint32(now) |
||||||
|
s = nextS |
||||||
|
nextS++ |
||||||
|
candidate = e.table[nextHash] |
||||||
|
now >>= 8 |
||||||
|
e.table[nextHash] = tableEntry{offset: s + e.cur, val: cv} |
||||||
|
|
||||||
|
offset = s - (candidate.offset - e.cur) |
||||||
|
if offset < maxMatchOffset && cv == candidate.val { |
||||||
|
break |
||||||
|
} |
||||||
|
cv = uint32(now) |
||||||
|
} |
||||||
|
|
||||||
|
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
||||||
|
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
||||||
|
// them as literal bytes.
|
||||||
|
|
||||||
|
// Call emitCopy, and then see if another emitCopy could be our next
|
||||||
|
// move. Repeat until we find no match for the input immediately after
|
||||||
|
// what was consumed by the last emitCopy call.
|
||||||
|
//
|
||||||
|
// If we exit this loop normally then we need to call emitLiteral next,
|
||||||
|
// though we don't yet know how big the literal will be. We handle that
|
||||||
|
// by proceeding to the next iteration of the main loop. We also can
|
||||||
|
// exit this loop via goto if we get close to exhausting the input.
|
||||||
|
for { |
||||||
|
// Invariant: we have a 4-byte match at s, and no need to emit any
|
||||||
|
// literal bytes prior to s.
|
||||||
|
|
||||||
|
// Extend the 4-byte match as long as possible.
|
||||||
|
t := candidate.offset - e.cur |
||||||
|
l := e.matchlenLong(s+4, t+4, src) + 4 |
||||||
|
|
||||||
|
// Extend backwards
|
||||||
|
for t > 0 && s > nextEmit && src[t-1] == src[s-1] { |
||||||
|
s-- |
||||||
|
t-- |
||||||
|
l++ |
||||||
|
} |
||||||
|
if nextEmit < s { |
||||||
|
emitLiteral(dst, src[nextEmit:s]) |
||||||
|
} |
||||||
|
|
||||||
|
dst.AddMatchLong(l, uint32(s-t-baseMatchOffset)) |
||||||
|
s += l |
||||||
|
nextEmit = s |
||||||
|
if nextS >= s { |
||||||
|
s = nextS + 1 |
||||||
|
} |
||||||
|
|
||||||
|
if s >= sLimit { |
||||||
|
// Index first pair after match end.
|
||||||
|
if int(s+l+4) < len(src) { |
||||||
|
cv := load3232(src, s) |
||||||
|
e.table[hash4u(cv, bTableBits)] = tableEntry{offset: s + e.cur, val: cv} |
||||||
|
} |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
// Store every second hash in-between, but offset by 1.
|
||||||
|
for i := s - l + 2; i < s-5; i += 7 { |
||||||
|
x := load6432(src, int32(i)) |
||||||
|
nextHash := hash4u(uint32(x), bTableBits) |
||||||
|
e.table[nextHash] = tableEntry{offset: e.cur + i, val: uint32(x)} |
||||||
|
// Skip one
|
||||||
|
x >>= 16 |
||||||
|
nextHash = hash4u(uint32(x), bTableBits) |
||||||
|
e.table[nextHash] = tableEntry{offset: e.cur + i + 2, val: uint32(x)} |
||||||
|
// Skip one
|
||||||
|
x >>= 16 |
||||||
|
nextHash = hash4u(uint32(x), bTableBits) |
||||||
|
e.table[nextHash] = tableEntry{offset: e.cur + i + 4, val: uint32(x)} |
||||||
|
} |
||||||
|
|
||||||
|
// We could immediately start working at s now, but to improve
|
||||||
|
// compression we first update the hash table at s-2 to s. If
|
||||||
|
// another emitCopy is not our next move, also calculate nextHash
|
||||||
|
// at s+1. At least on GOARCH=amd64, these three hash calculations
|
||||||
|
// are faster as one load64 call (with some shifts) instead of
|
||||||
|
// three load32 calls.
|
||||||
|
x := load6432(src, s-2) |
||||||
|
o := e.cur + s - 2 |
||||||
|
prevHash := hash4u(uint32(x), bTableBits) |
||||||
|
prevHash2 := hash4u(uint32(x>>8), bTableBits) |
||||||
|
e.table[prevHash] = tableEntry{offset: o, val: uint32(x)} |
||||||
|
e.table[prevHash2] = tableEntry{offset: o + 1, val: uint32(x >> 8)} |
||||||
|
currHash := hash4u(uint32(x>>16), bTableBits) |
||||||
|
candidate = e.table[currHash] |
||||||
|
e.table[currHash] = tableEntry{offset: o + 2, val: uint32(x >> 16)} |
||||||
|
|
||||||
|
offset := s - (candidate.offset - e.cur) |
||||||
|
if offset > maxMatchOffset || uint32(x>>16) != candidate.val { |
||||||
|
cv = uint32(x >> 24) |
||||||
|
s++ |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
emitRemainder: |
||||||
|
if int(nextEmit) < len(src) { |
||||||
|
// If nothing was added, don't encode literals.
|
||||||
|
if dst.n == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
emitLiteral(dst, src[nextEmit:]) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,225 @@ |
|||||||
|
package flate |
||||||
|
|
||||||
|
// fastEncL3
|
||||||
|
type fastEncL3 struct { |
||||||
|
fastGen |
||||||
|
table [tableSize]tableEntryPrev |
||||||
|
} |
||||||
|
|
||||||
|
// Encode uses a similar algorithm to level 2, will check up to two candidates.
|
||||||
|
func (e *fastEncL3) Encode(dst *tokens, src []byte) { |
||||||
|
const ( |
||||||
|
inputMargin = 8 - 1 |
||||||
|
minNonLiteralBlockSize = 1 + 1 + inputMargin |
||||||
|
) |
||||||
|
|
||||||
|
// Protect against e.cur wraparound.
|
||||||
|
for e.cur >= bufferReset { |
||||||
|
if len(e.hist) == 0 { |
||||||
|
for i := range e.table[:] { |
||||||
|
e.table[i] = tableEntryPrev{} |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
break |
||||||
|
} |
||||||
|
// Shift down everything in the table that isn't already too far away.
|
||||||
|
minOff := e.cur + int32(len(e.hist)) - maxMatchOffset |
||||||
|
for i := range e.table[:] { |
||||||
|
v := e.table[i] |
||||||
|
if v.Cur.offset <= minOff { |
||||||
|
v.Cur.offset = 0 |
||||||
|
} else { |
||||||
|
v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
if v.Prev.offset <= minOff { |
||||||
|
v.Prev.offset = 0 |
||||||
|
} else { |
||||||
|
v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
e.table[i] = v |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
} |
||||||
|
|
||||||
|
s := e.addBlock(src) |
||||||
|
|
||||||
|
// Skip if too small.
|
||||||
|
if len(src) < minNonLiteralBlockSize { |
||||||
|
// We do not fill the token table.
|
||||||
|
// This will be picked up by caller.
|
||||||
|
dst.n = uint16(len(src)) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Override src
|
||||||
|
src = e.hist |
||||||
|
nextEmit := s |
||||||
|
|
||||||
|
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
||||||
|
// lets us use a fast path for emitLiteral in the main loop, while we are
|
||||||
|
// looking for copies.
|
||||||
|
sLimit := int32(len(src) - inputMargin) |
||||||
|
|
||||||
|
// nextEmit is where in src the next emitLiteral should start from.
|
||||||
|
cv := load3232(src, s) |
||||||
|
for { |
||||||
|
const skipLog = 6 |
||||||
|
nextS := s |
||||||
|
var candidate tableEntry |
||||||
|
for { |
||||||
|
nextHash := hash(cv) |
||||||
|
s = nextS |
||||||
|
nextS = s + 1 + (s-nextEmit)>>skipLog |
||||||
|
if nextS > sLimit { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
candidates := e.table[nextHash] |
||||||
|
now := load3232(src, nextS) |
||||||
|
e.table[nextHash] = tableEntryPrev{Prev: candidates.Cur, Cur: tableEntry{offset: s + e.cur, val: cv}} |
||||||
|
|
||||||
|
// Check both candidates
|
||||||
|
candidate = candidates.Cur |
||||||
|
offset := s - (candidate.offset - e.cur) |
||||||
|
if cv == candidate.val { |
||||||
|
if offset > maxMatchOffset { |
||||||
|
cv = now |
||||||
|
// Previous will also be invalid, we have nothing.
|
||||||
|
continue |
||||||
|
} |
||||||
|
o2 := s - (candidates.Prev.offset - e.cur) |
||||||
|
if cv != candidates.Prev.val || o2 > maxMatchOffset { |
||||||
|
break |
||||||
|
} |
||||||
|
// Both match and are valid, pick longest.
|
||||||
|
l1, l2 := matchLen(src[s+4:], src[s-offset+4:]), matchLen(src[s+4:], src[s-o2+4:]) |
||||||
|
if l2 > l1 { |
||||||
|
candidate = candidates.Prev |
||||||
|
} |
||||||
|
break |
||||||
|
} else { |
||||||
|
// We only check if value mismatches.
|
||||||
|
// Offset will always be invalid in other cases.
|
||||||
|
candidate = candidates.Prev |
||||||
|
if cv == candidate.val { |
||||||
|
offset := s - (candidate.offset - e.cur) |
||||||
|
if offset <= maxMatchOffset { |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
cv = now |
||||||
|
} |
||||||
|
|
||||||
|
// Call emitCopy, and then see if another emitCopy could be our next
|
||||||
|
// move. Repeat until we find no match for the input immediately after
|
||||||
|
// what was consumed by the last emitCopy call.
|
||||||
|
//
|
||||||
|
// If we exit this loop normally then we need to call emitLiteral next,
|
||||||
|
// though we don't yet know how big the literal will be. We handle that
|
||||||
|
// by proceeding to the next iteration of the main loop. We also can
|
||||||
|
// exit this loop via goto if we get close to exhausting the input.
|
||||||
|
for { |
||||||
|
// Invariant: we have a 4-byte match at s, and no need to emit any
|
||||||
|
// literal bytes prior to s.
|
||||||
|
|
||||||
|
// Extend the 4-byte match as long as possible.
|
||||||
|
//
|
||||||
|
t := candidate.offset - e.cur |
||||||
|
l := e.matchlenLong(s+4, t+4, src) + 4 |
||||||
|
|
||||||
|
// Extend backwards
|
||||||
|
for t > 0 && s > nextEmit && src[t-1] == src[s-1] { |
||||||
|
s-- |
||||||
|
t-- |
||||||
|
l++ |
||||||
|
} |
||||||
|
if nextEmit < s { |
||||||
|
emitLiteral(dst, src[nextEmit:s]) |
||||||
|
} |
||||||
|
|
||||||
|
dst.AddMatchLong(l, uint32(s-t-baseMatchOffset)) |
||||||
|
s += l |
||||||
|
nextEmit = s |
||||||
|
if nextS >= s { |
||||||
|
s = nextS + 1 |
||||||
|
} |
||||||
|
|
||||||
|
if s >= sLimit { |
||||||
|
t += l |
||||||
|
// Index first pair after match end.
|
||||||
|
if int(t+4) < len(src) && t > 0 { |
||||||
|
cv := load3232(src, t) |
||||||
|
nextHash := hash(cv) |
||||||
|
e.table[nextHash] = tableEntryPrev{ |
||||||
|
Prev: e.table[nextHash].Cur, |
||||||
|
Cur: tableEntry{offset: e.cur + t, val: cv}, |
||||||
|
} |
||||||
|
} |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
// We could immediately start working at s now, but to improve
|
||||||
|
// compression we first update the hash table at s-3 to s.
|
||||||
|
x := load6432(src, s-3) |
||||||
|
prevHash := hash(uint32(x)) |
||||||
|
e.table[prevHash] = tableEntryPrev{ |
||||||
|
Prev: e.table[prevHash].Cur, |
||||||
|
Cur: tableEntry{offset: e.cur + s - 3, val: uint32(x)}, |
||||||
|
} |
||||||
|
x >>= 8 |
||||||
|
prevHash = hash(uint32(x)) |
||||||
|
|
||||||
|
e.table[prevHash] = tableEntryPrev{ |
||||||
|
Prev: e.table[prevHash].Cur, |
||||||
|
Cur: tableEntry{offset: e.cur + s - 2, val: uint32(x)}, |
||||||
|
} |
||||||
|
x >>= 8 |
||||||
|
prevHash = hash(uint32(x)) |
||||||
|
|
||||||
|
e.table[prevHash] = tableEntryPrev{ |
||||||
|
Prev: e.table[prevHash].Cur, |
||||||
|
Cur: tableEntry{offset: e.cur + s - 1, val: uint32(x)}, |
||||||
|
} |
||||||
|
x >>= 8 |
||||||
|
currHash := hash(uint32(x)) |
||||||
|
candidates := e.table[currHash] |
||||||
|
cv = uint32(x) |
||||||
|
e.table[currHash] = tableEntryPrev{ |
||||||
|
Prev: candidates.Cur, |
||||||
|
Cur: tableEntry{offset: s + e.cur, val: cv}, |
||||||
|
} |
||||||
|
|
||||||
|
// Check both candidates
|
||||||
|
candidate = candidates.Cur |
||||||
|
if cv == candidate.val { |
||||||
|
offset := s - (candidate.offset - e.cur) |
||||||
|
if offset <= maxMatchOffset { |
||||||
|
continue |
||||||
|
} |
||||||
|
} else { |
||||||
|
// We only check if value mismatches.
|
||||||
|
// Offset will always be invalid in other cases.
|
||||||
|
candidate = candidates.Prev |
||||||
|
if cv == candidate.val { |
||||||
|
offset := s - (candidate.offset - e.cur) |
||||||
|
if offset <= maxMatchOffset { |
||||||
|
continue |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
cv = uint32(x >> 8) |
||||||
|
s++ |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
emitRemainder: |
||||||
|
if int(nextEmit) < len(src) { |
||||||
|
// If nothing was added, don't encode literals.
|
||||||
|
if dst.n == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
emitLiteral(dst, src[nextEmit:]) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,210 @@ |
|||||||
|
package flate |
||||||
|
|
||||||
|
import "fmt" |
||||||
|
|
||||||
|
type fastEncL4 struct { |
||||||
|
fastGen |
||||||
|
table [tableSize]tableEntry |
||||||
|
bTable [tableSize]tableEntry |
||||||
|
} |
||||||
|
|
||||||
|
func (e *fastEncL4) Encode(dst *tokens, src []byte) { |
||||||
|
const ( |
||||||
|
inputMargin = 12 - 1 |
||||||
|
minNonLiteralBlockSize = 1 + 1 + inputMargin |
||||||
|
) |
||||||
|
|
||||||
|
// Protect against e.cur wraparound.
|
||||||
|
for e.cur >= bufferReset { |
||||||
|
if len(e.hist) == 0 { |
||||||
|
for i := range e.table[:] { |
||||||
|
e.table[i] = tableEntry{} |
||||||
|
} |
||||||
|
for i := range e.bTable[:] { |
||||||
|
e.bTable[i] = tableEntry{} |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
break |
||||||
|
} |
||||||
|
// Shift down everything in the table that isn't already too far away.
|
||||||
|
minOff := e.cur + int32(len(e.hist)) - maxMatchOffset |
||||||
|
for i := range e.table[:] { |
||||||
|
v := e.table[i].offset |
||||||
|
if v <= minOff { |
||||||
|
v = 0 |
||||||
|
} else { |
||||||
|
v = v - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
e.table[i].offset = v |
||||||
|
} |
||||||
|
for i := range e.bTable[:] { |
||||||
|
v := e.bTable[i].offset |
||||||
|
if v <= minOff { |
||||||
|
v = 0 |
||||||
|
} else { |
||||||
|
v = v - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
e.bTable[i].offset = v |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
} |
||||||
|
|
||||||
|
s := e.addBlock(src) |
||||||
|
|
||||||
|
// This check isn't in the Snappy implementation, but there, the caller
|
||||||
|
// instead of the callee handles this case.
|
||||||
|
if len(src) < minNonLiteralBlockSize { |
||||||
|
// We do not fill the token table.
|
||||||
|
// This will be picked up by caller.
|
||||||
|
dst.n = uint16(len(src)) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Override src
|
||||||
|
src = e.hist |
||||||
|
nextEmit := s |
||||||
|
|
||||||
|
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
||||||
|
// lets us use a fast path for emitLiteral in the main loop, while we are
|
||||||
|
// looking for copies.
|
||||||
|
sLimit := int32(len(src) - inputMargin) |
||||||
|
|
||||||
|
// nextEmit is where in src the next emitLiteral should start from.
|
||||||
|
cv := load6432(src, s) |
||||||
|
for { |
||||||
|
const skipLog = 6 |
||||||
|
const doEvery = 1 |
||||||
|
|
||||||
|
nextS := s |
||||||
|
var t int32 |
||||||
|
for { |
||||||
|
nextHashS := hash4x64(cv, tableBits) |
||||||
|
nextHashL := hash7(cv, tableBits) |
||||||
|
|
||||||
|
s = nextS |
||||||
|
nextS = s + doEvery + (s-nextEmit)>>skipLog |
||||||
|
if nextS > sLimit { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
// Fetch a short+long candidate
|
||||||
|
sCandidate := e.table[nextHashS] |
||||||
|
lCandidate := e.bTable[nextHashL] |
||||||
|
next := load6432(src, nextS) |
||||||
|
entry := tableEntry{offset: s + e.cur, val: uint32(cv)} |
||||||
|
e.table[nextHashS] = entry |
||||||
|
e.bTable[nextHashL] = entry |
||||||
|
|
||||||
|
t = lCandidate.offset - e.cur |
||||||
|
if s-t < maxMatchOffset && uint32(cv) == lCandidate.val { |
||||||
|
// We got a long match. Use that.
|
||||||
|
break |
||||||
|
} |
||||||
|
|
||||||
|
t = sCandidate.offset - e.cur |
||||||
|
if s-t < maxMatchOffset && uint32(cv) == sCandidate.val { |
||||||
|
// Found a 4 match...
|
||||||
|
lCandidate = e.bTable[hash7(next, tableBits)] |
||||||
|
|
||||||
|
// If the next long is a candidate, check if we should use that instead...
|
||||||
|
lOff := nextS - (lCandidate.offset - e.cur) |
||||||
|
if lOff < maxMatchOffset && lCandidate.val == uint32(next) { |
||||||
|
l1, l2 := matchLen(src[s+4:], src[t+4:]), matchLen(src[nextS+4:], src[nextS-lOff+4:]) |
||||||
|
if l2 > l1 { |
||||||
|
s = nextS |
||||||
|
t = lCandidate.offset - e.cur |
||||||
|
} |
||||||
|
} |
||||||
|
break |
||||||
|
} |
||||||
|
cv = next |
||||||
|
} |
||||||
|
|
||||||
|
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
||||||
|
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
||||||
|
// them as literal bytes.
|
||||||
|
|
||||||
|
// Extend the 4-byte match as long as possible.
|
||||||
|
l := e.matchlenLong(s+4, t+4, src) + 4 |
||||||
|
|
||||||
|
// Extend backwards
|
||||||
|
for t > 0 && s > nextEmit && src[t-1] == src[s-1] { |
||||||
|
s-- |
||||||
|
t-- |
||||||
|
l++ |
||||||
|
} |
||||||
|
if nextEmit < s { |
||||||
|
emitLiteral(dst, src[nextEmit:s]) |
||||||
|
} |
||||||
|
if false { |
||||||
|
if t >= s { |
||||||
|
panic("s-t") |
||||||
|
} |
||||||
|
if (s - t) > maxMatchOffset { |
||||||
|
panic(fmt.Sprintln("mmo", t)) |
||||||
|
} |
||||||
|
if l < baseMatchLength { |
||||||
|
panic("bml") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
dst.AddMatchLong(l, uint32(s-t-baseMatchOffset)) |
||||||
|
s += l |
||||||
|
nextEmit = s |
||||||
|
if nextS >= s { |
||||||
|
s = nextS + 1 |
||||||
|
} |
||||||
|
|
||||||
|
if s >= sLimit { |
||||||
|
// Index first pair after match end.
|
||||||
|
if int(s+8) < len(src) { |
||||||
|
cv := load6432(src, s) |
||||||
|
e.table[hash4x64(cv, tableBits)] = tableEntry{offset: s + e.cur, val: uint32(cv)} |
||||||
|
e.bTable[hash7(cv, tableBits)] = tableEntry{offset: s + e.cur, val: uint32(cv)} |
||||||
|
} |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
// Store every 3rd hash in-between
|
||||||
|
if true { |
||||||
|
i := nextS |
||||||
|
if i < s-1 { |
||||||
|
cv := load6432(src, i) |
||||||
|
t := tableEntry{offset: i + e.cur, val: uint32(cv)} |
||||||
|
t2 := tableEntry{val: uint32(cv >> 8), offset: t.offset + 1} |
||||||
|
e.bTable[hash7(cv, tableBits)] = t |
||||||
|
e.bTable[hash7(cv>>8, tableBits)] = t2 |
||||||
|
e.table[hash4u(t2.val, tableBits)] = t2 |
||||||
|
|
||||||
|
i += 3 |
||||||
|
for ; i < s-1; i += 3 { |
||||||
|
cv := load6432(src, i) |
||||||
|
t := tableEntry{offset: i + e.cur, val: uint32(cv)} |
||||||
|
t2 := tableEntry{val: uint32(cv >> 8), offset: t.offset + 1} |
||||||
|
e.bTable[hash7(cv, tableBits)] = t |
||||||
|
e.bTable[hash7(cv>>8, tableBits)] = t2 |
||||||
|
e.table[hash4u(t2.val, tableBits)] = t2 |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// We could immediately start working at s now, but to improve
|
||||||
|
// compression we first update the hash table at s-1 and at s.
|
||||||
|
x := load6432(src, s-1) |
||||||
|
o := e.cur + s - 1 |
||||||
|
prevHashS := hash4x64(x, tableBits) |
||||||
|
prevHashL := hash7(x, tableBits) |
||||||
|
e.table[prevHashS] = tableEntry{offset: o, val: uint32(x)} |
||||||
|
e.bTable[prevHashL] = tableEntry{offset: o, val: uint32(x)} |
||||||
|
cv = x >> 8 |
||||||
|
} |
||||||
|
|
||||||
|
emitRemainder: |
||||||
|
if int(nextEmit) < len(src) { |
||||||
|
// If nothing was added, don't encode literals.
|
||||||
|
if dst.n == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
emitLiteral(dst, src[nextEmit:]) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,276 @@ |
|||||||
|
package flate |
||||||
|
|
||||||
|
import "fmt" |
||||||
|
|
||||||
|
type fastEncL5 struct { |
||||||
|
fastGen |
||||||
|
table [tableSize]tableEntry |
||||||
|
bTable [tableSize]tableEntryPrev |
||||||
|
} |
||||||
|
|
||||||
|
func (e *fastEncL5) Encode(dst *tokens, src []byte) { |
||||||
|
const ( |
||||||
|
inputMargin = 12 - 1 |
||||||
|
minNonLiteralBlockSize = 1 + 1 + inputMargin |
||||||
|
) |
||||||
|
|
||||||
|
// Protect against e.cur wraparound.
|
||||||
|
for e.cur >= bufferReset { |
||||||
|
if len(e.hist) == 0 { |
||||||
|
for i := range e.table[:] { |
||||||
|
e.table[i] = tableEntry{} |
||||||
|
} |
||||||
|
for i := range e.bTable[:] { |
||||||
|
e.bTable[i] = tableEntryPrev{} |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
break |
||||||
|
} |
||||||
|
// Shift down everything in the table that isn't already too far away.
|
||||||
|
minOff := e.cur + int32(len(e.hist)) - maxMatchOffset |
||||||
|
for i := range e.table[:] { |
||||||
|
v := e.table[i].offset |
||||||
|
if v <= minOff { |
||||||
|
v = 0 |
||||||
|
} else { |
||||||
|
v = v - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
e.table[i].offset = v |
||||||
|
} |
||||||
|
for i := range e.bTable[:] { |
||||||
|
v := e.bTable[i] |
||||||
|
if v.Cur.offset <= minOff { |
||||||
|
v.Cur.offset = 0 |
||||||
|
v.Prev.offset = 0 |
||||||
|
} else { |
||||||
|
v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset |
||||||
|
if v.Prev.offset <= minOff { |
||||||
|
v.Prev.offset = 0 |
||||||
|
} else { |
||||||
|
v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
} |
||||||
|
e.bTable[i] = v |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
} |
||||||
|
|
||||||
|
s := e.addBlock(src) |
||||||
|
|
||||||
|
// This check isn't in the Snappy implementation, but there, the caller
|
||||||
|
// instead of the callee handles this case.
|
||||||
|
if len(src) < minNonLiteralBlockSize { |
||||||
|
// We do not fill the token table.
|
||||||
|
// This will be picked up by caller.
|
||||||
|
dst.n = uint16(len(src)) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Override src
|
||||||
|
src = e.hist |
||||||
|
nextEmit := s |
||||||
|
|
||||||
|
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
||||||
|
// lets us use a fast path for emitLiteral in the main loop, while we are
|
||||||
|
// looking for copies.
|
||||||
|
sLimit := int32(len(src) - inputMargin) |
||||||
|
|
||||||
|
// nextEmit is where in src the next emitLiteral should start from.
|
||||||
|
cv := load6432(src, s) |
||||||
|
for { |
||||||
|
const skipLog = 6 |
||||||
|
const doEvery = 1 |
||||||
|
|
||||||
|
nextS := s |
||||||
|
var l int32 |
||||||
|
var t int32 |
||||||
|
for { |
||||||
|
nextHashS := hash4x64(cv, tableBits) |
||||||
|
nextHashL := hash7(cv, tableBits) |
||||||
|
|
||||||
|
s = nextS |
||||||
|
nextS = s + doEvery + (s-nextEmit)>>skipLog |
||||||
|
if nextS > sLimit { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
// Fetch a short+long candidate
|
||||||
|
sCandidate := e.table[nextHashS] |
||||||
|
lCandidate := e.bTable[nextHashL] |
||||||
|
next := load6432(src, nextS) |
||||||
|
entry := tableEntry{offset: s + e.cur, val: uint32(cv)} |
||||||
|
e.table[nextHashS] = entry |
||||||
|
eLong := &e.bTable[nextHashL] |
||||||
|
eLong.Cur, eLong.Prev = entry, eLong.Cur |
||||||
|
|
||||||
|
nextHashS = hash4x64(next, tableBits) |
||||||
|
nextHashL = hash7(next, tableBits) |
||||||
|
|
||||||
|
t = lCandidate.Cur.offset - e.cur |
||||||
|
if s-t < maxMatchOffset { |
||||||
|
if uint32(cv) == lCandidate.Cur.val { |
||||||
|
// Store the next match
|
||||||
|
e.table[nextHashS] = tableEntry{offset: nextS + e.cur, val: uint32(next)} |
||||||
|
eLong := &e.bTable[nextHashL] |
||||||
|
eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur, val: uint32(next)}, eLong.Cur |
||||||
|
|
||||||
|
t2 := lCandidate.Prev.offset - e.cur |
||||||
|
if s-t2 < maxMatchOffset && uint32(cv) == lCandidate.Prev.val { |
||||||
|
l = e.matchlen(s+4, t+4, src) + 4 |
||||||
|
ml1 := e.matchlen(s+4, t2+4, src) + 4 |
||||||
|
if ml1 > l { |
||||||
|
t = t2 |
||||||
|
l = ml1 |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
break |
||||||
|
} |
||||||
|
t = lCandidate.Prev.offset - e.cur |
||||||
|
if s-t < maxMatchOffset && uint32(cv) == lCandidate.Prev.val { |
||||||
|
// Store the next match
|
||||||
|
e.table[nextHashS] = tableEntry{offset: nextS + e.cur, val: uint32(next)} |
||||||
|
eLong := &e.bTable[nextHashL] |
||||||
|
eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur, val: uint32(next)}, eLong.Cur |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
t = sCandidate.offset - e.cur |
||||||
|
if s-t < maxMatchOffset && uint32(cv) == sCandidate.val { |
||||||
|
// Found a 4 match...
|
||||||
|
l = e.matchlen(s+4, t+4, src) + 4 |
||||||
|
lCandidate = e.bTable[nextHashL] |
||||||
|
// Store the next match
|
||||||
|
|
||||||
|
e.table[nextHashS] = tableEntry{offset: nextS + e.cur, val: uint32(next)} |
||||||
|
eLong := &e.bTable[nextHashL] |
||||||
|
eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur, val: uint32(next)}, eLong.Cur |
||||||
|
|
||||||
|
// If the next long is a candidate, use that...
|
||||||
|
t2 := lCandidate.Cur.offset - e.cur |
||||||
|
if nextS-t2 < maxMatchOffset { |
||||||
|
if lCandidate.Cur.val == uint32(next) { |
||||||
|
ml := e.matchlen(nextS+4, t2+4, src) + 4 |
||||||
|
if ml > l { |
||||||
|
t = t2 |
||||||
|
s = nextS |
||||||
|
l = ml |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
// If the previous long is a candidate, use that...
|
||||||
|
t2 = lCandidate.Prev.offset - e.cur |
||||||
|
if nextS-t2 < maxMatchOffset && lCandidate.Prev.val == uint32(next) { |
||||||
|
ml := e.matchlen(nextS+4, t2+4, src) + 4 |
||||||
|
if ml > l { |
||||||
|
t = t2 |
||||||
|
s = nextS |
||||||
|
l = ml |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
break |
||||||
|
} |
||||||
|
cv = next |
||||||
|
} |
||||||
|
|
||||||
|
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
||||||
|
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
||||||
|
// them as literal bytes.
|
||||||
|
|
||||||
|
// Extend the 4-byte match as long as possible.
|
||||||
|
if l == 0 { |
||||||
|
l = e.matchlenLong(s+4, t+4, src) + 4 |
||||||
|
} else if l == maxMatchLength { |
||||||
|
l += e.matchlenLong(s+l, t+l, src) |
||||||
|
} |
||||||
|
// Extend backwards
|
||||||
|
for t > 0 && s > nextEmit && src[t-1] == src[s-1] { |
||||||
|
s-- |
||||||
|
t-- |
||||||
|
l++ |
||||||
|
} |
||||||
|
if nextEmit < s { |
||||||
|
emitLiteral(dst, src[nextEmit:s]) |
||||||
|
} |
||||||
|
if false { |
||||||
|
if t >= s { |
||||||
|
panic(fmt.Sprintln("s-t", s, t)) |
||||||
|
} |
||||||
|
if (s - t) > maxMatchOffset { |
||||||
|
panic(fmt.Sprintln("mmo", s-t)) |
||||||
|
} |
||||||
|
if l < baseMatchLength { |
||||||
|
panic("bml") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
dst.AddMatchLong(l, uint32(s-t-baseMatchOffset)) |
||||||
|
s += l |
||||||
|
nextEmit = s |
||||||
|
if nextS >= s { |
||||||
|
s = nextS + 1 |
||||||
|
} |
||||||
|
|
||||||
|
if s >= sLimit { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
// Store every 3rd hash in-between.
|
||||||
|
if true { |
||||||
|
const hashEvery = 3 |
||||||
|
i := s - l + 1 |
||||||
|
if i < s-1 { |
||||||
|
cv := load6432(src, i) |
||||||
|
t := tableEntry{offset: i + e.cur, val: uint32(cv)} |
||||||
|
e.table[hash4x64(cv, tableBits)] = t |
||||||
|
eLong := &e.bTable[hash7(cv, tableBits)] |
||||||
|
eLong.Cur, eLong.Prev = t, eLong.Cur |
||||||
|
|
||||||
|
// Do an long at i+1
|
||||||
|
cv >>= 8 |
||||||
|
t = tableEntry{offset: t.offset + 1, val: uint32(cv)} |
||||||
|
eLong = &e.bTable[hash7(cv, tableBits)] |
||||||
|
eLong.Cur, eLong.Prev = t, eLong.Cur |
||||||
|
|
||||||
|
// We only have enough bits for a short entry at i+2
|
||||||
|
cv >>= 8 |
||||||
|
t = tableEntry{offset: t.offset + 1, val: uint32(cv)} |
||||||
|
e.table[hash4x64(cv, tableBits)] = t |
||||||
|
|
||||||
|
// Skip one - otherwise we risk hitting 's'
|
||||||
|
i += 4 |
||||||
|
for ; i < s-1; i += hashEvery { |
||||||
|
cv := load6432(src, i) |
||||||
|
t := tableEntry{offset: i + e.cur, val: uint32(cv)} |
||||||
|
t2 := tableEntry{offset: t.offset + 1, val: uint32(cv >> 8)} |
||||||
|
eLong := &e.bTable[hash7(cv, tableBits)] |
||||||
|
eLong.Cur, eLong.Prev = t, eLong.Cur |
||||||
|
e.table[hash4u(t2.val, tableBits)] = t2 |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// We could immediately start working at s now, but to improve
|
||||||
|
// compression we first update the hash table at s-1 and at s.
|
||||||
|
x := load6432(src, s-1) |
||||||
|
o := e.cur + s - 1 |
||||||
|
prevHashS := hash4x64(x, tableBits) |
||||||
|
prevHashL := hash7(x, tableBits) |
||||||
|
e.table[prevHashS] = tableEntry{offset: o, val: uint32(x)} |
||||||
|
eLong := &e.bTable[prevHashL] |
||||||
|
eLong.Cur, eLong.Prev = tableEntry{offset: o, val: uint32(x)}, eLong.Cur |
||||||
|
cv = x >> 8 |
||||||
|
} |
||||||
|
|
||||||
|
emitRemainder: |
||||||
|
if int(nextEmit) < len(src) { |
||||||
|
// If nothing was added, don't encode literals.
|
||||||
|
if dst.n == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
emitLiteral(dst, src[nextEmit:]) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,279 @@ |
|||||||
|
package flate |
||||||
|
|
||||||
|
import "fmt" |
||||||
|
|
||||||
|
type fastEncL6 struct { |
||||||
|
fastGen |
||||||
|
table [tableSize]tableEntry |
||||||
|
bTable [tableSize]tableEntryPrev |
||||||
|
} |
||||||
|
|
||||||
|
func (e *fastEncL6) Encode(dst *tokens, src []byte) { |
||||||
|
const ( |
||||||
|
inputMargin = 12 - 1 |
||||||
|
minNonLiteralBlockSize = 1 + 1 + inputMargin |
||||||
|
) |
||||||
|
|
||||||
|
// Protect against e.cur wraparound.
|
||||||
|
for e.cur >= bufferReset { |
||||||
|
if len(e.hist) == 0 { |
||||||
|
for i := range e.table[:] { |
||||||
|
e.table[i] = tableEntry{} |
||||||
|
} |
||||||
|
for i := range e.bTable[:] { |
||||||
|
e.bTable[i] = tableEntryPrev{} |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
break |
||||||
|
} |
||||||
|
// Shift down everything in the table that isn't already too far away.
|
||||||
|
minOff := e.cur + int32(len(e.hist)) - maxMatchOffset |
||||||
|
for i := range e.table[:] { |
||||||
|
v := e.table[i].offset |
||||||
|
if v <= minOff { |
||||||
|
v = 0 |
||||||
|
} else { |
||||||
|
v = v - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
e.table[i].offset = v |
||||||
|
} |
||||||
|
for i := range e.bTable[:] { |
||||||
|
v := e.bTable[i] |
||||||
|
if v.Cur.offset <= minOff { |
||||||
|
v.Cur.offset = 0 |
||||||
|
v.Prev.offset = 0 |
||||||
|
} else { |
||||||
|
v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset |
||||||
|
if v.Prev.offset <= minOff { |
||||||
|
v.Prev.offset = 0 |
||||||
|
} else { |
||||||
|
v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset |
||||||
|
} |
||||||
|
} |
||||||
|
e.bTable[i] = v |
||||||
|
} |
||||||
|
e.cur = maxMatchOffset |
||||||
|
} |
||||||
|
|
||||||
|
s := e.addBlock(src) |
||||||
|
|
||||||
|
// This check isn't in the Snappy implementation, but there, the caller
|
||||||
|
// instead of the callee handles this case.
|
||||||
|
if len(src) < minNonLiteralBlockSize { |
||||||
|
// We do not fill the token table.
|
||||||
|
// This will be picked up by caller.
|
||||||
|
dst.n = uint16(len(src)) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Override src
|
||||||
|
src = e.hist |
||||||
|
nextEmit := s |
||||||
|
|
||||||
|
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
||||||
|
// lets us use a fast path for emitLiteral in the main loop, while we are
|
||||||
|
// looking for copies.
|
||||||
|
sLimit := int32(len(src) - inputMargin) |
||||||
|
|
||||||
|
// nextEmit is where in src the next emitLiteral should start from.
|
||||||
|
cv := load6432(src, s) |
||||||
|
// Repeat MUST be > 1 and within range
|
||||||
|
repeat := int32(1) |
||||||
|
for { |
||||||
|
const skipLog = 7 |
||||||
|
const doEvery = 1 |
||||||
|
|
||||||
|
nextS := s |
||||||
|
var l int32 |
||||||
|
var t int32 |
||||||
|
for { |
||||||
|
nextHashS := hash4x64(cv, tableBits) |
||||||
|
nextHashL := hash7(cv, tableBits) |
||||||
|
s = nextS |
||||||
|
nextS = s + doEvery + (s-nextEmit)>>skipLog |
||||||
|
if nextS > sLimit { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
// Fetch a short+long candidate
|
||||||
|
sCandidate := e.table[nextHashS] |
||||||
|
lCandidate := e.bTable[nextHashL] |
||||||
|
next := load6432(src, nextS) |
||||||
|
entry := tableEntry{offset: s + e.cur, val: uint32(cv)} |
||||||
|
e.table[nextHashS] = entry |
||||||
|
eLong := &e.bTable[nextHashL] |
||||||
|
eLong.Cur, eLong.Prev = entry, eLong.Cur |
||||||
|
|
||||||
|
// Calculate hashes of 'next'
|
||||||
|
nextHashS = hash4x64(next, tableBits) |
||||||
|
nextHashL = hash7(next, tableBits) |
||||||
|
|
||||||
|
t = lCandidate.Cur.offset - e.cur |
||||||
|
if s-t < maxMatchOffset { |
||||||
|
if uint32(cv) == lCandidate.Cur.val { |
||||||
|
// Long candidate matches at least 4 bytes.
|
||||||
|
|
||||||
|
// Store the next match
|
||||||
|
e.table[nextHashS] = tableEntry{offset: nextS + e.cur, val: uint32(next)} |
||||||
|
eLong := &e.bTable[nextHashL] |
||||||
|
eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur, val: uint32(next)}, eLong.Cur |
||||||
|
|
||||||
|
// Check the previous long candidate as well.
|
||||||
|
t2 := lCandidate.Prev.offset - e.cur |
||||||
|
if s-t2 < maxMatchOffset && uint32(cv) == lCandidate.Prev.val { |
||||||
|
l = e.matchlen(s+4, t+4, src) + 4 |
||||||
|
ml1 := e.matchlen(s+4, t2+4, src) + 4 |
||||||
|
if ml1 > l { |
||||||
|
t = t2 |
||||||
|
l = ml1 |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
break |
||||||
|
} |
||||||
|
// Current value did not match, but check if previous long value does.
|
||||||
|
t = lCandidate.Prev.offset - e.cur |
||||||
|
if s-t < maxMatchOffset && uint32(cv) == lCandidate.Prev.val { |
||||||
|
// Store the next match
|
||||||
|
e.table[nextHashS] = tableEntry{offset: nextS + e.cur, val: uint32(next)} |
||||||
|
eLong := &e.bTable[nextHashL] |
||||||
|
eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur, val: uint32(next)}, eLong.Cur |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
t = sCandidate.offset - e.cur |
||||||
|
if s-t < maxMatchOffset && uint32(cv) == sCandidate.val { |
||||||
|
// Found a 4 match...
|
||||||
|
l = e.matchlen(s+4, t+4, src) + 4 |
||||||
|
|
||||||
|
// Look up next long candidate (at nextS)
|
||||||
|
lCandidate = e.bTable[nextHashL] |
||||||
|
|
||||||
|
// Store the next match
|
||||||
|
e.table[nextHashS] = tableEntry{offset: nextS + e.cur, val: uint32(next)} |
||||||
|
eLong := &e.bTable[nextHashL] |
||||||
|
eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur, val: uint32(next)}, eLong.Cur |
||||||
|
|
||||||
|
// Check repeat at s + repOff
|
||||||
|
const repOff = 1 |
||||||
|
t2 := s - repeat + repOff |
||||||
|
if load3232(src, t2) == uint32(cv>>(8*repOff)) { |
||||||
|
ml := e.matchlen(s+4+repOff, t2+4, src) + 4 |
||||||
|
if ml > l { |
||||||
|
t = t2 |
||||||
|
l = ml |
||||||
|
s += repOff |
||||||
|
// Not worth checking more.
|
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// If the next long is a candidate, use that...
|
||||||
|
t2 = lCandidate.Cur.offset - e.cur |
||||||
|
if nextS-t2 < maxMatchOffset { |
||||||
|
if lCandidate.Cur.val == uint32(next) { |
||||||
|
ml := e.matchlen(nextS+4, t2+4, src) + 4 |
||||||
|
if ml > l { |
||||||
|
t = t2 |
||||||
|
s = nextS |
||||||
|
l = ml |
||||||
|
// This is ok, but check previous as well.
|
||||||
|
} |
||||||
|
} |
||||||
|
// If the previous long is a candidate, use that...
|
||||||
|
t2 = lCandidate.Prev.offset - e.cur |
||||||
|
if nextS-t2 < maxMatchOffset && lCandidate.Prev.val == uint32(next) { |
||||||
|
ml := e.matchlen(nextS+4, t2+4, src) + 4 |
||||||
|
if ml > l { |
||||||
|
t = t2 |
||||||
|
s = nextS |
||||||
|
l = ml |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
break |
||||||
|
} |
||||||
|
cv = next |
||||||
|
} |
||||||
|
|
||||||
|
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
||||||
|
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
||||||
|
// them as literal bytes.
|
||||||
|
|
||||||
|
// Extend the 4-byte match as long as possible.
|
||||||
|
if l == 0 { |
||||||
|
l = e.matchlenLong(s+4, t+4, src) + 4 |
||||||
|
} else if l == maxMatchLength { |
||||||
|
l += e.matchlenLong(s+l, t+l, src) |
||||||
|
} |
||||||
|
|
||||||
|
// Extend backwards
|
||||||
|
for t > 0 && s > nextEmit && src[t-1] == src[s-1] { |
||||||
|
s-- |
||||||
|
t-- |
||||||
|
l++ |
||||||
|
} |
||||||
|
if nextEmit < s { |
||||||
|
emitLiteral(dst, src[nextEmit:s]) |
||||||
|
} |
||||||
|
if false { |
||||||
|
if t >= s { |
||||||
|
panic(fmt.Sprintln("s-t", s, t)) |
||||||
|
} |
||||||
|
if (s - t) > maxMatchOffset { |
||||||
|
panic(fmt.Sprintln("mmo", s-t)) |
||||||
|
} |
||||||
|
if l < baseMatchLength { |
||||||
|
panic("bml") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
dst.AddMatchLong(l, uint32(s-t-baseMatchOffset)) |
||||||
|
repeat = s - t |
||||||
|
s += l |
||||||
|
nextEmit = s |
||||||
|
if nextS >= s { |
||||||
|
s = nextS + 1 |
||||||
|
} |
||||||
|
|
||||||
|
if s >= sLimit { |
||||||
|
// Index after match end.
|
||||||
|
for i := nextS + 1; i < int32(len(src))-8; i += 2 { |
||||||
|
cv := load6432(src, i) |
||||||
|
e.table[hash4x64(cv, tableBits)] = tableEntry{offset: i + e.cur, val: uint32(cv)} |
||||||
|
eLong := &e.bTable[hash7(cv, tableBits)] |
||||||
|
eLong.Cur, eLong.Prev = tableEntry{offset: i + e.cur, val: uint32(cv)}, eLong.Cur |
||||||
|
} |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
// Store every long hash in-between and every second short.
|
||||||
|
if true { |
||||||
|
for i := nextS + 1; i < s-1; i += 2 { |
||||||
|
cv := load6432(src, i) |
||||||
|
t := tableEntry{offset: i + e.cur, val: uint32(cv)} |
||||||
|
t2 := tableEntry{offset: t.offset + 1, val: uint32(cv >> 8)} |
||||||
|
eLong := &e.bTable[hash7(cv, tableBits)] |
||||||
|
eLong2 := &e.bTable[hash7(cv>>8, tableBits)] |
||||||
|
e.table[hash4x64(cv, tableBits)] = t |
||||||
|
eLong.Cur, eLong.Prev = t, eLong.Cur |
||||||
|
eLong2.Cur, eLong2.Prev = t2, eLong2.Cur |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// We could immediately start working at s now, but to improve
|
||||||
|
// compression we first update the hash table at s-1 and at s.
|
||||||
|
cv = load6432(src, s) |
||||||
|
} |
||||||
|
|
||||||
|
emitRemainder: |
||||||
|
if int(nextEmit) < len(src) { |
||||||
|
// If nothing was added, don't encode literals.
|
||||||
|
if dst.n == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
emitLiteral(dst, src[nextEmit:]) |
||||||
|
} |
||||||
|
} |
||||||
@ -1,48 +0,0 @@ |
|||||||
// Copyright 2009 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 flate |
|
||||||
|
|
||||||
var reverseByte = [256]byte{ |
|
||||||
0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, |
|
||||||
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, |
|
||||||
0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, |
|
||||||
0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, |
|
||||||
0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, |
|
||||||
0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, |
|
||||||
0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, |
|
||||||
0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, |
|
||||||
0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, |
|
||||||
0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, |
|
||||||
0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, |
|
||||||
0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, |
|
||||||
0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, |
|
||||||
0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, |
|
||||||
0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, |
|
||||||
0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, |
|
||||||
0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, |
|
||||||
0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, |
|
||||||
0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, |
|
||||||
0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, |
|
||||||
0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, |
|
||||||
0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, |
|
||||||
0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, |
|
||||||
0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, |
|
||||||
0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, |
|
||||||
0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, |
|
||||||
0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, |
|
||||||
0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, |
|
||||||
0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, |
|
||||||
0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, |
|
||||||
0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, |
|
||||||
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff, |
|
||||||
} |
|
||||||
|
|
||||||
func reverseUint16(v uint16) uint16 { |
|
||||||
return uint16(reverseByte[v>>8]) | uint16(reverseByte[v&0xFF])<<8 |
|
||||||
} |
|
||||||
|
|
||||||
func reverseBits(number uint16, bitLength byte) uint16 { |
|
||||||
return reverseUint16(number << uint8(16-bitLength)) |
|
||||||
} |
|
||||||
@ -1,856 +0,0 @@ |
|||||||
// Copyright 2011 The Snappy-Go Authors. All rights reserved.
|
|
||||||
// Modified for deflate by Klaus Post (c) 2015.
|
|
||||||
// Use of this source code is governed by a BSD-style
|
|
||||||
// license that can be found in the LICENSE file.
|
|
||||||
|
|
||||||
package flate |
|
||||||
|
|
||||||
// emitLiteral writes a literal chunk and returns the number of bytes written.
|
|
||||||
func emitLiteral(dst *tokens, lit []byte) { |
|
||||||
ol := int(dst.n) |
|
||||||
for i, v := range lit { |
|
||||||
dst.tokens[(i+ol)&maxStoreBlockSize] = token(v) |
|
||||||
} |
|
||||||
dst.n += uint16(len(lit)) |
|
||||||
} |
|
||||||
|
|
||||||
// emitCopy writes a copy chunk and returns the number of bytes written.
|
|
||||||
func emitCopy(dst *tokens, offset, length int) { |
|
||||||
dst.tokens[dst.n] = matchToken(uint32(length-3), uint32(offset-minOffsetSize)) |
|
||||||
dst.n++ |
|
||||||
} |
|
||||||
|
|
||||||
type snappyEnc interface { |
|
||||||
Encode(dst *tokens, src []byte) |
|
||||||
Reset() |
|
||||||
} |
|
||||||
|
|
||||||
func newSnappy(level int) snappyEnc { |
|
||||||
switch level { |
|
||||||
case 1: |
|
||||||
return &snappyL1{} |
|
||||||
case 2: |
|
||||||
return &snappyL2{snappyGen: snappyGen{cur: maxStoreBlockSize, prev: make([]byte, 0, maxStoreBlockSize)}} |
|
||||||
case 3: |
|
||||||
return &snappyL3{snappyGen: snappyGen{cur: maxStoreBlockSize, prev: make([]byte, 0, maxStoreBlockSize)}} |
|
||||||
case 4: |
|
||||||
return &snappyL4{snappyL3{snappyGen: snappyGen{cur: maxStoreBlockSize, prev: make([]byte, 0, maxStoreBlockSize)}}} |
|
||||||
default: |
|
||||||
panic("invalid level specified") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
const ( |
|
||||||
tableBits = 14 // Bits used in the table
|
|
||||||
tableSize = 1 << tableBits // Size of the table
|
|
||||||
tableMask = tableSize - 1 // Mask for table indices. Redundant, but can eliminate bounds checks.
|
|
||||||
tableShift = 32 - tableBits // Right-shift to get the tableBits most significant bits of a uint32.
|
|
||||||
baseMatchOffset = 1 // The smallest match offset
|
|
||||||
baseMatchLength = 3 // The smallest match length per the RFC section 3.2.5
|
|
||||||
maxMatchOffset = 1 << 15 // The largest match offset
|
|
||||||
) |
|
||||||
|
|
||||||
func load32(b []byte, i int) uint32 { |
|
||||||
b = b[i : i+4 : len(b)] // Help the compiler eliminate bounds checks on the next line.
|
|
||||||
return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 |
|
||||||
} |
|
||||||
|
|
||||||
func load64(b []byte, i int) uint64 { |
|
||||||
b = b[i : i+8 : len(b)] // Help the compiler eliminate bounds checks on the next line.
|
|
||||||
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | |
|
||||||
uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 |
|
||||||
} |
|
||||||
|
|
||||||
func hash(u uint32) uint32 { |
|
||||||
return (u * 0x1e35a7bd) >> tableShift |
|
||||||
} |
|
||||||
|
|
||||||
// snappyL1 encapsulates level 1 compression
|
|
||||||
type snappyL1 struct{} |
|
||||||
|
|
||||||
func (e *snappyL1) Reset() {} |
|
||||||
|
|
||||||
func (e *snappyL1) Encode(dst *tokens, src []byte) { |
|
||||||
const ( |
|
||||||
inputMargin = 16 - 1 |
|
||||||
minNonLiteralBlockSize = 1 + 1 + inputMargin |
|
||||||
) |
|
||||||
|
|
||||||
// This check isn't in the Snappy implementation, but there, the caller
|
|
||||||
// instead of the callee handles this case.
|
|
||||||
if len(src) < minNonLiteralBlockSize { |
|
||||||
// We do not fill the token table.
|
|
||||||
// This will be picked up by caller.
|
|
||||||
dst.n = uint16(len(src)) |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
// Initialize the hash table.
|
|
||||||
//
|
|
||||||
// The table element type is uint16, as s < sLimit and sLimit < len(src)
|
|
||||||
// and len(src) <= maxStoreBlockSize and maxStoreBlockSize == 65535.
|
|
||||||
var table [tableSize]uint16 |
|
||||||
|
|
||||||
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
|
||||||
// lets us use a fast path for emitLiteral in the main loop, while we are
|
|
||||||
// looking for copies.
|
|
||||||
sLimit := len(src) - inputMargin |
|
||||||
|
|
||||||
// nextEmit is where in src the next emitLiteral should start from.
|
|
||||||
nextEmit := 0 |
|
||||||
|
|
||||||
// The encoded form must start with a literal, as there are no previous
|
|
||||||
// bytes to copy, so we start looking for hash matches at s == 1.
|
|
||||||
s := 1 |
|
||||||
nextHash := hash(load32(src, s)) |
|
||||||
|
|
||||||
for { |
|
||||||
// Copied from the C++ snappy implementation:
|
|
||||||
//
|
|
||||||
// Heuristic match skipping: If 32 bytes are scanned with no matches
|
|
||||||
// found, start looking only at every other byte. If 32 more bytes are
|
|
||||||
// scanned (or skipped), look at every third byte, etc.. When a match
|
|
||||||
// is found, immediately go back to looking at every byte. This is a
|
|
||||||
// small loss (~5% performance, ~0.1% density) for compressible data
|
|
||||||
// due to more bookkeeping, but for non-compressible data (such as
|
|
||||||
// JPEG) it's a huge win since the compressor quickly "realizes" the
|
|
||||||
// data is incompressible and doesn't bother looking for matches
|
|
||||||
// everywhere.
|
|
||||||
//
|
|
||||||
// The "skip" variable keeps track of how many bytes there are since
|
|
||||||
// the last match; dividing it by 32 (ie. right-shifting by five) gives
|
|
||||||
// the number of bytes to move ahead for each iteration.
|
|
||||||
skip := 32 |
|
||||||
|
|
||||||
nextS := s |
|
||||||
candidate := 0 |
|
||||||
for { |
|
||||||
s = nextS |
|
||||||
bytesBetweenHashLookups := skip >> 5 |
|
||||||
nextS = s + bytesBetweenHashLookups |
|
||||||
skip += bytesBetweenHashLookups |
|
||||||
if nextS > sLimit { |
|
||||||
goto emitRemainder |
|
||||||
} |
|
||||||
candidate = int(table[nextHash&tableMask]) |
|
||||||
table[nextHash&tableMask] = uint16(s) |
|
||||||
nextHash = hash(load32(src, nextS)) |
|
||||||
// TODO: < should be <=, and add a test for that.
|
|
||||||
if s-candidate < maxMatchOffset && load32(src, s) == load32(src, candidate) { |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
|
||||||
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
|
||||||
// them as literal bytes.
|
|
||||||
emitLiteral(dst, src[nextEmit:s]) |
|
||||||
|
|
||||||
// Call emitCopy, and then see if another emitCopy could be our next
|
|
||||||
// move. Repeat until we find no match for the input immediately after
|
|
||||||
// what was consumed by the last emitCopy call.
|
|
||||||
//
|
|
||||||
// If we exit this loop normally then we need to call emitLiteral next,
|
|
||||||
// though we don't yet know how big the literal will be. We handle that
|
|
||||||
// by proceeding to the next iteration of the main loop. We also can
|
|
||||||
// exit this loop via goto if we get close to exhausting the input.
|
|
||||||
for { |
|
||||||
// Invariant: we have a 4-byte match at s, and no need to emit any
|
|
||||||
// literal bytes prior to s.
|
|
||||||
base := s |
|
||||||
|
|
||||||
// Extend the 4-byte match as long as possible.
|
|
||||||
//
|
|
||||||
// This is an inlined version of Snappy's:
|
|
||||||
// s = extendMatch(src, candidate+4, s+4)
|
|
||||||
s += 4 |
|
||||||
s1 := base + maxMatchLength |
|
||||||
if s1 > len(src) { |
|
||||||
s1 = len(src) |
|
||||||
} |
|
||||||
a := src[s:s1] |
|
||||||
b := src[candidate+4:] |
|
||||||
b = b[:len(a)] |
|
||||||
l := len(a) |
|
||||||
for i := range a { |
|
||||||
if a[i] != b[i] { |
|
||||||
l = i |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
s += l |
|
||||||
|
|
||||||
// matchToken is flate's equivalent of Snappy's emitCopy.
|
|
||||||
dst.tokens[dst.n] = matchToken(uint32(s-base-baseMatchLength), uint32(base-candidate-baseMatchOffset)) |
|
||||||
dst.n++ |
|
||||||
nextEmit = s |
|
||||||
if s >= sLimit { |
|
||||||
goto emitRemainder |
|
||||||
} |
|
||||||
|
|
||||||
// We could immediately start working at s now, but to improve
|
|
||||||
// compression we first update the hash table at s-1 and at s. If
|
|
||||||
// another emitCopy is not our next move, also calculate nextHash
|
|
||||||
// at s+1. At least on GOARCH=amd64, these three hash calculations
|
|
||||||
// are faster as one load64 call (with some shifts) instead of
|
|
||||||
// three load32 calls.
|
|
||||||
x := load64(src, s-1) |
|
||||||
prevHash := hash(uint32(x >> 0)) |
|
||||||
table[prevHash&tableMask] = uint16(s - 1) |
|
||||||
currHash := hash(uint32(x >> 8)) |
|
||||||
candidate = int(table[currHash&tableMask]) |
|
||||||
table[currHash&tableMask] = uint16(s) |
|
||||||
// TODO: >= should be >, and add a test for that.
|
|
||||||
if s-candidate >= maxMatchOffset || uint32(x>>8) != load32(src, candidate) { |
|
||||||
nextHash = hash(uint32(x >> 16)) |
|
||||||
s++ |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
emitRemainder: |
|
||||||
if nextEmit < len(src) { |
|
||||||
emitLiteral(dst, src[nextEmit:]) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
type tableEntry struct { |
|
||||||
val uint32 |
|
||||||
offset int32 |
|
||||||
} |
|
||||||
|
|
||||||
func load3232(b []byte, i int32) uint32 { |
|
||||||
b = b[i : i+4 : len(b)] // Help the compiler eliminate bounds checks on the next line.
|
|
||||||
return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 |
|
||||||
} |
|
||||||
|
|
||||||
func load6432(b []byte, i int32) uint64 { |
|
||||||
b = b[i : i+8 : len(b)] // Help the compiler eliminate bounds checks on the next line.
|
|
||||||
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | |
|
||||||
uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 |
|
||||||
} |
|
||||||
|
|
||||||
// snappyGen maintains the table for matches,
|
|
||||||
// and the previous byte block for level 2.
|
|
||||||
// This is the generic implementation.
|
|
||||||
type snappyGen struct { |
|
||||||
prev []byte |
|
||||||
cur int32 |
|
||||||
} |
|
||||||
|
|
||||||
// snappyGen maintains the table for matches,
|
|
||||||
// and the previous byte block for level 2.
|
|
||||||
// This is the generic implementation.
|
|
||||||
type snappyL2 struct { |
|
||||||
snappyGen |
|
||||||
table [tableSize]tableEntry |
|
||||||
} |
|
||||||
|
|
||||||
// EncodeL2 uses a similar algorithm to level 1, but is capable
|
|
||||||
// of matching across blocks giving better compression at a small slowdown.
|
|
||||||
func (e *snappyL2) Encode(dst *tokens, src []byte) { |
|
||||||
const ( |
|
||||||
inputMargin = 16 - 1 |
|
||||||
minNonLiteralBlockSize = 1 + 1 + inputMargin |
|
||||||
) |
|
||||||
|
|
||||||
// Ensure that e.cur doesn't wrap, mainly an issue on 32 bits.
|
|
||||||
if e.cur > 1<<30 { |
|
||||||
for i := range e.table { |
|
||||||
e.table[i] = tableEntry{} |
|
||||||
} |
|
||||||
e.cur = maxStoreBlockSize |
|
||||||
} |
|
||||||
|
|
||||||
// This check isn't in the Snappy implementation, but there, the caller
|
|
||||||
// instead of the callee handles this case.
|
|
||||||
if len(src) < minNonLiteralBlockSize { |
|
||||||
// We do not fill the token table.
|
|
||||||
// This will be picked up by caller.
|
|
||||||
dst.n = uint16(len(src)) |
|
||||||
e.cur += maxStoreBlockSize |
|
||||||
e.prev = e.prev[:0] |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
|
||||||
// lets us use a fast path for emitLiteral in the main loop, while we are
|
|
||||||
// looking for copies.
|
|
||||||
sLimit := int32(len(src) - inputMargin) |
|
||||||
|
|
||||||
// nextEmit is where in src the next emitLiteral should start from.
|
|
||||||
nextEmit := int32(0) |
|
||||||
s := int32(0) |
|
||||||
cv := load3232(src, s) |
|
||||||
nextHash := hash(cv) |
|
||||||
|
|
||||||
for { |
|
||||||
// Copied from the C++ snappy implementation:
|
|
||||||
//
|
|
||||||
// Heuristic match skipping: If 32 bytes are scanned with no matches
|
|
||||||
// found, start looking only at every other byte. If 32 more bytes are
|
|
||||||
// scanned (or skipped), look at every third byte, etc.. When a match
|
|
||||||
// is found, immediately go back to looking at every byte. This is a
|
|
||||||
// small loss (~5% performance, ~0.1% density) for compressible data
|
|
||||||
// due to more bookkeeping, but for non-compressible data (such as
|
|
||||||
// JPEG) it's a huge win since the compressor quickly "realizes" the
|
|
||||||
// data is incompressible and doesn't bother looking for matches
|
|
||||||
// everywhere.
|
|
||||||
//
|
|
||||||
// The "skip" variable keeps track of how many bytes there are since
|
|
||||||
// the last match; dividing it by 32 (ie. right-shifting by five) gives
|
|
||||||
// the number of bytes to move ahead for each iteration.
|
|
||||||
skip := int32(32) |
|
||||||
|
|
||||||
nextS := s |
|
||||||
var candidate tableEntry |
|
||||||
for { |
|
||||||
s = nextS |
|
||||||
bytesBetweenHashLookups := skip >> 5 |
|
||||||
nextS = s + bytesBetweenHashLookups |
|
||||||
skip += bytesBetweenHashLookups |
|
||||||
if nextS > sLimit { |
|
||||||
goto emitRemainder |
|
||||||
} |
|
||||||
candidate = e.table[nextHash&tableMask] |
|
||||||
now := load3232(src, nextS) |
|
||||||
e.table[nextHash&tableMask] = tableEntry{offset: s + e.cur, val: cv} |
|
||||||
nextHash = hash(now) |
|
||||||
|
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset >= maxMatchOffset || cv != candidate.val { |
|
||||||
// Out of range or not matched.
|
|
||||||
cv = now |
|
||||||
continue |
|
||||||
} |
|
||||||
break |
|
||||||
} |
|
||||||
|
|
||||||
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
|
||||||
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
|
||||||
// them as literal bytes.
|
|
||||||
emitLiteral(dst, src[nextEmit:s]) |
|
||||||
|
|
||||||
// Call emitCopy, and then see if another emitCopy could be our next
|
|
||||||
// move. Repeat until we find no match for the input immediately after
|
|
||||||
// what was consumed by the last emitCopy call.
|
|
||||||
//
|
|
||||||
// If we exit this loop normally then we need to call emitLiteral next,
|
|
||||||
// though we don't yet know how big the literal will be. We handle that
|
|
||||||
// by proceeding to the next iteration of the main loop. We also can
|
|
||||||
// exit this loop via goto if we get close to exhausting the input.
|
|
||||||
for { |
|
||||||
// Invariant: we have a 4-byte match at s, and no need to emit any
|
|
||||||
// literal bytes prior to s.
|
|
||||||
|
|
||||||
// Extend the 4-byte match as long as possible.
|
|
||||||
//
|
|
||||||
s += 4 |
|
||||||
t := candidate.offset - e.cur + 4 |
|
||||||
l := e.matchlen(s, t, src) |
|
||||||
|
|
||||||
// matchToken is flate's equivalent of Snappy's emitCopy. (length,offset)
|
|
||||||
dst.tokens[dst.n] = matchToken(uint32(l+4-baseMatchLength), uint32(s-t-baseMatchOffset)) |
|
||||||
dst.n++ |
|
||||||
s += l |
|
||||||
nextEmit = s |
|
||||||
if s >= sLimit { |
|
||||||
goto emitRemainder |
|
||||||
} |
|
||||||
|
|
||||||
// We could immediately start working at s now, but to improve
|
|
||||||
// compression we first update the hash table at s-1 and at s. If
|
|
||||||
// another emitCopy is not our next move, also calculate nextHash
|
|
||||||
// at s+1. At least on GOARCH=amd64, these three hash calculations
|
|
||||||
// are faster as one load64 call (with some shifts) instead of
|
|
||||||
// three load32 calls.
|
|
||||||
x := load6432(src, s-1) |
|
||||||
prevHash := hash(uint32(x)) |
|
||||||
e.table[prevHash&tableMask] = tableEntry{offset: e.cur + s - 1, val: uint32(x)} |
|
||||||
x >>= 8 |
|
||||||
currHash := hash(uint32(x)) |
|
||||||
candidate = e.table[currHash&tableMask] |
|
||||||
e.table[currHash&tableMask] = tableEntry{offset: e.cur + s, val: uint32(x)} |
|
||||||
|
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset >= maxMatchOffset || uint32(x) != candidate.val { |
|
||||||
cv = uint32(x >> 8) |
|
||||||
nextHash = hash(cv) |
|
||||||
s++ |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
emitRemainder: |
|
||||||
if int(nextEmit) < len(src) { |
|
||||||
emitLiteral(dst, src[nextEmit:]) |
|
||||||
} |
|
||||||
e.cur += int32(len(src)) |
|
||||||
e.prev = e.prev[:len(src)] |
|
||||||
copy(e.prev, src) |
|
||||||
} |
|
||||||
|
|
||||||
type tableEntryPrev struct { |
|
||||||
Cur tableEntry |
|
||||||
Prev tableEntry |
|
||||||
} |
|
||||||
|
|
||||||
// snappyL3
|
|
||||||
type snappyL3 struct { |
|
||||||
snappyGen |
|
||||||
table [tableSize]tableEntryPrev |
|
||||||
} |
|
||||||
|
|
||||||
// Encode uses a similar algorithm to level 2, will check up to two candidates.
|
|
||||||
func (e *snappyL3) Encode(dst *tokens, src []byte) { |
|
||||||
const ( |
|
||||||
inputMargin = 16 - 1 |
|
||||||
minNonLiteralBlockSize = 1 + 1 + inputMargin |
|
||||||
) |
|
||||||
|
|
||||||
// Ensure that e.cur doesn't wrap, mainly an issue on 32 bits.
|
|
||||||
if e.cur > 1<<30 { |
|
||||||
for i := range e.table { |
|
||||||
e.table[i] = tableEntryPrev{} |
|
||||||
} |
|
||||||
e.cur = maxStoreBlockSize |
|
||||||
} |
|
||||||
|
|
||||||
// This check isn't in the Snappy implementation, but there, the caller
|
|
||||||
// instead of the callee handles this case.
|
|
||||||
if len(src) < minNonLiteralBlockSize { |
|
||||||
// We do not fill the token table.
|
|
||||||
// This will be picked up by caller.
|
|
||||||
dst.n = uint16(len(src)) |
|
||||||
e.cur += maxStoreBlockSize |
|
||||||
e.prev = e.prev[:0] |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
|
||||||
// lets us use a fast path for emitLiteral in the main loop, while we are
|
|
||||||
// looking for copies.
|
|
||||||
sLimit := int32(len(src) - inputMargin) |
|
||||||
|
|
||||||
// nextEmit is where in src the next emitLiteral should start from.
|
|
||||||
nextEmit := int32(0) |
|
||||||
s := int32(0) |
|
||||||
cv := load3232(src, s) |
|
||||||
nextHash := hash(cv) |
|
||||||
|
|
||||||
for { |
|
||||||
// Copied from the C++ snappy implementation:
|
|
||||||
//
|
|
||||||
// Heuristic match skipping: If 32 bytes are scanned with no matches
|
|
||||||
// found, start looking only at every other byte. If 32 more bytes are
|
|
||||||
// scanned (or skipped), look at every third byte, etc.. When a match
|
|
||||||
// is found, immediately go back to looking at every byte. This is a
|
|
||||||
// small loss (~5% performance, ~0.1% density) for compressible data
|
|
||||||
// due to more bookkeeping, but for non-compressible data (such as
|
|
||||||
// JPEG) it's a huge win since the compressor quickly "realizes" the
|
|
||||||
// data is incompressible and doesn't bother looking for matches
|
|
||||||
// everywhere.
|
|
||||||
//
|
|
||||||
// The "skip" variable keeps track of how many bytes there are since
|
|
||||||
// the last match; dividing it by 32 (ie. right-shifting by five) gives
|
|
||||||
// the number of bytes to move ahead for each iteration.
|
|
||||||
skip := int32(32) |
|
||||||
|
|
||||||
nextS := s |
|
||||||
var candidate tableEntry |
|
||||||
for { |
|
||||||
s = nextS |
|
||||||
bytesBetweenHashLookups := skip >> 5 |
|
||||||
nextS = s + bytesBetweenHashLookups |
|
||||||
skip += bytesBetweenHashLookups |
|
||||||
if nextS > sLimit { |
|
||||||
goto emitRemainder |
|
||||||
} |
|
||||||
candidates := e.table[nextHash&tableMask] |
|
||||||
now := load3232(src, nextS) |
|
||||||
e.table[nextHash&tableMask] = tableEntryPrev{Prev: candidates.Cur, Cur: tableEntry{offset: s + e.cur, val: cv}} |
|
||||||
nextHash = hash(now) |
|
||||||
|
|
||||||
// Check both candidates
|
|
||||||
candidate = candidates.Cur |
|
||||||
if cv == candidate.val { |
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset < maxMatchOffset { |
|
||||||
break |
|
||||||
} |
|
||||||
} else { |
|
||||||
// We only check if value mismatches.
|
|
||||||
// Offset will always be invalid in other cases.
|
|
||||||
candidate = candidates.Prev |
|
||||||
if cv == candidate.val { |
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset < maxMatchOffset { |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
cv = now |
|
||||||
} |
|
||||||
|
|
||||||
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
|
||||||
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
|
||||||
// them as literal bytes.
|
|
||||||
emitLiteral(dst, src[nextEmit:s]) |
|
||||||
|
|
||||||
// Call emitCopy, and then see if another emitCopy could be our next
|
|
||||||
// move. Repeat until we find no match for the input immediately after
|
|
||||||
// what was consumed by the last emitCopy call.
|
|
||||||
//
|
|
||||||
// If we exit this loop normally then we need to call emitLiteral next,
|
|
||||||
// though we don't yet know how big the literal will be. We handle that
|
|
||||||
// by proceeding to the next iteration of the main loop. We also can
|
|
||||||
// exit this loop via goto if we get close to exhausting the input.
|
|
||||||
for { |
|
||||||
// Invariant: we have a 4-byte match at s, and no need to emit any
|
|
||||||
// literal bytes prior to s.
|
|
||||||
|
|
||||||
// Extend the 4-byte match as long as possible.
|
|
||||||
//
|
|
||||||
s += 4 |
|
||||||
t := candidate.offset - e.cur + 4 |
|
||||||
l := e.matchlen(s, t, src) |
|
||||||
|
|
||||||
// matchToken is flate's equivalent of Snappy's emitCopy. (length,offset)
|
|
||||||
dst.tokens[dst.n] = matchToken(uint32(l+4-baseMatchLength), uint32(s-t-baseMatchOffset)) |
|
||||||
dst.n++ |
|
||||||
s += l |
|
||||||
nextEmit = s |
|
||||||
if s >= sLimit { |
|
||||||
goto emitRemainder |
|
||||||
} |
|
||||||
|
|
||||||
// We could immediately start working at s now, but to improve
|
|
||||||
// compression we first update the hash table at s-2, s-1 and at s. If
|
|
||||||
// another emitCopy is not our next move, also calculate nextHash
|
|
||||||
// at s+1. At least on GOARCH=amd64, these three hash calculations
|
|
||||||
// are faster as one load64 call (with some shifts) instead of
|
|
||||||
// three load32 calls.
|
|
||||||
x := load6432(src, s-2) |
|
||||||
prevHash := hash(uint32(x)) |
|
||||||
|
|
||||||
e.table[prevHash&tableMask] = tableEntryPrev{ |
|
||||||
Prev: e.table[prevHash&tableMask].Cur, |
|
||||||
Cur: tableEntry{offset: e.cur + s - 2, val: uint32(x)}, |
|
||||||
} |
|
||||||
x >>= 8 |
|
||||||
prevHash = hash(uint32(x)) |
|
||||||
|
|
||||||
e.table[prevHash&tableMask] = tableEntryPrev{ |
|
||||||
Prev: e.table[prevHash&tableMask].Cur, |
|
||||||
Cur: tableEntry{offset: e.cur + s - 1, val: uint32(x)}, |
|
||||||
} |
|
||||||
x >>= 8 |
|
||||||
currHash := hash(uint32(x)) |
|
||||||
candidates := e.table[currHash&tableMask] |
|
||||||
cv = uint32(x) |
|
||||||
e.table[currHash&tableMask] = tableEntryPrev{ |
|
||||||
Prev: candidates.Cur, |
|
||||||
Cur: tableEntry{offset: s + e.cur, val: cv}, |
|
||||||
} |
|
||||||
|
|
||||||
// Check both candidates
|
|
||||||
candidate = candidates.Cur |
|
||||||
if cv == candidate.val { |
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset < maxMatchOffset { |
|
||||||
continue |
|
||||||
} |
|
||||||
} else { |
|
||||||
// We only check if value mismatches.
|
|
||||||
// Offset will always be invalid in other cases.
|
|
||||||
candidate = candidates.Prev |
|
||||||
if cv == candidate.val { |
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset < maxMatchOffset { |
|
||||||
continue |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
cv = uint32(x >> 8) |
|
||||||
nextHash = hash(cv) |
|
||||||
s++ |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
emitRemainder: |
|
||||||
if int(nextEmit) < len(src) { |
|
||||||
emitLiteral(dst, src[nextEmit:]) |
|
||||||
} |
|
||||||
e.cur += int32(len(src)) |
|
||||||
e.prev = e.prev[:len(src)] |
|
||||||
copy(e.prev, src) |
|
||||||
} |
|
||||||
|
|
||||||
// snappyL4
|
|
||||||
type snappyL4 struct { |
|
||||||
snappyL3 |
|
||||||
} |
|
||||||
|
|
||||||
// Encode uses a similar algorithm to level 3,
|
|
||||||
// but will check up to two candidates if first isn't long enough.
|
|
||||||
func (e *snappyL4) Encode(dst *tokens, src []byte) { |
|
||||||
const ( |
|
||||||
inputMargin = 16 - 1 |
|
||||||
minNonLiteralBlockSize = 1 + 1 + inputMargin |
|
||||||
matchLenGood = 12 |
|
||||||
) |
|
||||||
|
|
||||||
// Ensure that e.cur doesn't wrap, mainly an issue on 32 bits.
|
|
||||||
if e.cur > 1<<30 { |
|
||||||
for i := range e.table { |
|
||||||
e.table[i] = tableEntryPrev{} |
|
||||||
} |
|
||||||
e.cur = maxStoreBlockSize |
|
||||||
} |
|
||||||
|
|
||||||
// This check isn't in the Snappy implementation, but there, the caller
|
|
||||||
// instead of the callee handles this case.
|
|
||||||
if len(src) < minNonLiteralBlockSize { |
|
||||||
// We do not fill the token table.
|
|
||||||
// This will be picked up by caller.
|
|
||||||
dst.n = uint16(len(src)) |
|
||||||
e.cur += maxStoreBlockSize |
|
||||||
e.prev = e.prev[:0] |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
|
||||||
// lets us use a fast path for emitLiteral in the main loop, while we are
|
|
||||||
// looking for copies.
|
|
||||||
sLimit := int32(len(src) - inputMargin) |
|
||||||
|
|
||||||
// nextEmit is where in src the next emitLiteral should start from.
|
|
||||||
nextEmit := int32(0) |
|
||||||
s := int32(0) |
|
||||||
cv := load3232(src, s) |
|
||||||
nextHash := hash(cv) |
|
||||||
|
|
||||||
for { |
|
||||||
// Copied from the C++ snappy implementation:
|
|
||||||
//
|
|
||||||
// Heuristic match skipping: If 32 bytes are scanned with no matches
|
|
||||||
// found, start looking only at every other byte. If 32 more bytes are
|
|
||||||
// scanned (or skipped), look at every third byte, etc.. When a match
|
|
||||||
// is found, immediately go back to looking at every byte. This is a
|
|
||||||
// small loss (~5% performance, ~0.1% density) for compressible data
|
|
||||||
// due to more bookkeeping, but for non-compressible data (such as
|
|
||||||
// JPEG) it's a huge win since the compressor quickly "realizes" the
|
|
||||||
// data is incompressible and doesn't bother looking for matches
|
|
||||||
// everywhere.
|
|
||||||
//
|
|
||||||
// The "skip" variable keeps track of how many bytes there are since
|
|
||||||
// the last match; dividing it by 32 (ie. right-shifting by five) gives
|
|
||||||
// the number of bytes to move ahead for each iteration.
|
|
||||||
skip := int32(32) |
|
||||||
|
|
||||||
nextS := s |
|
||||||
var candidate tableEntry |
|
||||||
var candidateAlt tableEntry |
|
||||||
for { |
|
||||||
s = nextS |
|
||||||
bytesBetweenHashLookups := skip >> 5 |
|
||||||
nextS = s + bytesBetweenHashLookups |
|
||||||
skip += bytesBetweenHashLookups |
|
||||||
if nextS > sLimit { |
|
||||||
goto emitRemainder |
|
||||||
} |
|
||||||
candidates := e.table[nextHash&tableMask] |
|
||||||
now := load3232(src, nextS) |
|
||||||
e.table[nextHash&tableMask] = tableEntryPrev{Prev: candidates.Cur, Cur: tableEntry{offset: s + e.cur, val: cv}} |
|
||||||
nextHash = hash(now) |
|
||||||
|
|
||||||
// Check both candidates
|
|
||||||
candidate = candidates.Cur |
|
||||||
if cv == candidate.val { |
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset < maxMatchOffset { |
|
||||||
offset = s - (candidates.Prev.offset - e.cur) |
|
||||||
if cv == candidates.Prev.val && offset < maxMatchOffset { |
|
||||||
candidateAlt = candidates.Prev |
|
||||||
} |
|
||||||
break |
|
||||||
} |
|
||||||
} else { |
|
||||||
// We only check if value mismatches.
|
|
||||||
// Offset will always be invalid in other cases.
|
|
||||||
candidate = candidates.Prev |
|
||||||
if cv == candidate.val { |
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset < maxMatchOffset { |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
cv = now |
|
||||||
} |
|
||||||
|
|
||||||
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
|
||||||
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
|
||||||
// them as literal bytes.
|
|
||||||
emitLiteral(dst, src[nextEmit:s]) |
|
||||||
|
|
||||||
// Call emitCopy, and then see if another emitCopy could be our next
|
|
||||||
// move. Repeat until we find no match for the input immediately after
|
|
||||||
// what was consumed by the last emitCopy call.
|
|
||||||
//
|
|
||||||
// If we exit this loop normally then we need to call emitLiteral next,
|
|
||||||
// though we don't yet know how big the literal will be. We handle that
|
|
||||||
// by proceeding to the next iteration of the main loop. We also can
|
|
||||||
// exit this loop via goto if we get close to exhausting the input.
|
|
||||||
for { |
|
||||||
// Invariant: we have a 4-byte match at s, and no need to emit any
|
|
||||||
// literal bytes prior to s.
|
|
||||||
|
|
||||||
// Extend the 4-byte match as long as possible.
|
|
||||||
//
|
|
||||||
s += 4 |
|
||||||
t := candidate.offset - e.cur + 4 |
|
||||||
l := e.matchlen(s, t, src) |
|
||||||
// Try alternative candidate if match length < matchLenGood.
|
|
||||||
if l < matchLenGood-4 && candidateAlt.offset != 0 { |
|
||||||
t2 := candidateAlt.offset - e.cur + 4 |
|
||||||
l2 := e.matchlen(s, t2, src) |
|
||||||
if l2 > l { |
|
||||||
l = l2 |
|
||||||
t = t2 |
|
||||||
} |
|
||||||
} |
|
||||||
// matchToken is flate's equivalent of Snappy's emitCopy. (length,offset)
|
|
||||||
dst.tokens[dst.n] = matchToken(uint32(l+4-baseMatchLength), uint32(s-t-baseMatchOffset)) |
|
||||||
dst.n++ |
|
||||||
s += l |
|
||||||
nextEmit = s |
|
||||||
if s >= sLimit { |
|
||||||
goto emitRemainder |
|
||||||
} |
|
||||||
|
|
||||||
// We could immediately start working at s now, but to improve
|
|
||||||
// compression we first update the hash table at s-2, s-1 and at s. If
|
|
||||||
// another emitCopy is not our next move, also calculate nextHash
|
|
||||||
// at s+1. At least on GOARCH=amd64, these three hash calculations
|
|
||||||
// are faster as one load64 call (with some shifts) instead of
|
|
||||||
// three load32 calls.
|
|
||||||
x := load6432(src, s-2) |
|
||||||
prevHash := hash(uint32(x)) |
|
||||||
|
|
||||||
e.table[prevHash&tableMask] = tableEntryPrev{ |
|
||||||
Prev: e.table[prevHash&tableMask].Cur, |
|
||||||
Cur: tableEntry{offset: e.cur + s - 2, val: uint32(x)}, |
|
||||||
} |
|
||||||
x >>= 8 |
|
||||||
prevHash = hash(uint32(x)) |
|
||||||
|
|
||||||
e.table[prevHash&tableMask] = tableEntryPrev{ |
|
||||||
Prev: e.table[prevHash&tableMask].Cur, |
|
||||||
Cur: tableEntry{offset: e.cur + s - 1, val: uint32(x)}, |
|
||||||
} |
|
||||||
x >>= 8 |
|
||||||
currHash := hash(uint32(x)) |
|
||||||
candidates := e.table[currHash&tableMask] |
|
||||||
cv = uint32(x) |
|
||||||
e.table[currHash&tableMask] = tableEntryPrev{ |
|
||||||
Prev: candidates.Cur, |
|
||||||
Cur: tableEntry{offset: s + e.cur, val: cv}, |
|
||||||
} |
|
||||||
|
|
||||||
// Check both candidates
|
|
||||||
candidate = candidates.Cur |
|
||||||
candidateAlt = tableEntry{} |
|
||||||
if cv == candidate.val { |
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset < maxMatchOffset { |
|
||||||
offset = s - (candidates.Prev.offset - e.cur) |
|
||||||
if cv == candidates.Prev.val && offset < maxMatchOffset { |
|
||||||
candidateAlt = candidates.Prev |
|
||||||
} |
|
||||||
continue |
|
||||||
} |
|
||||||
} else { |
|
||||||
// We only check if value mismatches.
|
|
||||||
// Offset will always be invalid in other cases.
|
|
||||||
candidate = candidates.Prev |
|
||||||
if cv == candidate.val { |
|
||||||
offset := s - (candidate.offset - e.cur) |
|
||||||
if offset < maxMatchOffset { |
|
||||||
continue |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
cv = uint32(x >> 8) |
|
||||||
nextHash = hash(cv) |
|
||||||
s++ |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
emitRemainder: |
|
||||||
if int(nextEmit) < len(src) { |
|
||||||
emitLiteral(dst, src[nextEmit:]) |
|
||||||
} |
|
||||||
e.cur += int32(len(src)) |
|
||||||
e.prev = e.prev[:len(src)] |
|
||||||
copy(e.prev, src) |
|
||||||
} |
|
||||||
|
|
||||||
func (e *snappyGen) matchlen(s, t int32, src []byte) int32 { |
|
||||||
s1 := int(s) + maxMatchLength - 4 |
|
||||||
if s1 > len(src) { |
|
||||||
s1 = len(src) |
|
||||||
} |
|
||||||
|
|
||||||
// If we are inside the current block
|
|
||||||
if t >= 0 { |
|
||||||
b := src[t:] |
|
||||||
a := src[s:s1] |
|
||||||
b = b[:len(a)] |
|
||||||
// Extend the match to be as long as possible.
|
|
||||||
for i := range a { |
|
||||||
if a[i] != b[i] { |
|
||||||
return int32(i) |
|
||||||
} |
|
||||||
} |
|
||||||
return int32(len(a)) |
|
||||||
} |
|
||||||
|
|
||||||
// We found a match in the previous block.
|
|
||||||
tp := int32(len(e.prev)) + t |
|
||||||
if tp < 0 { |
|
||||||
return 0 |
|
||||||
} |
|
||||||
|
|
||||||
// Extend the match to be as long as possible.
|
|
||||||
a := src[s:s1] |
|
||||||
b := e.prev[tp:] |
|
||||||
if len(b) > len(a) { |
|
||||||
b = b[:len(a)] |
|
||||||
} |
|
||||||
a = a[:len(b)] |
|
||||||
for i := range b { |
|
||||||
if a[i] != b[i] { |
|
||||||
return int32(i) |
|
||||||
} |
|
||||||
} |
|
||||||
n := int32(len(b)) |
|
||||||
a = src[s+n : s1] |
|
||||||
b = src[:len(a)] |
|
||||||
for i := range a { |
|
||||||
if a[i] != b[i] { |
|
||||||
return int32(i) + n |
|
||||||
} |
|
||||||
} |
|
||||||
return int32(len(a)) + n |
|
||||||
} |
|
||||||
|
|
||||||
// Reset the encoding table.
|
|
||||||
func (e *snappyGen) Reset() { |
|
||||||
e.prev = e.prev[:0] |
|
||||||
e.cur += maxMatchOffset + 1 |
|
||||||
} |
|
||||||
@ -0,0 +1,252 @@ |
|||||||
|
package flate |
||||||
|
|
||||||
|
import ( |
||||||
|
"io" |
||||||
|
"math" |
||||||
|
) |
||||||
|
|
||||||
|
const ( |
||||||
|
maxStatelessBlock = math.MaxInt16 |
||||||
|
|
||||||
|
slTableBits = 13 |
||||||
|
slTableSize = 1 << slTableBits |
||||||
|
slTableShift = 32 - slTableBits |
||||||
|
) |
||||||
|
|
||||||
|
type statelessWriter struct { |
||||||
|
dst io.Writer |
||||||
|
closed bool |
||||||
|
} |
||||||
|
|
||||||
|
func (s *statelessWriter) Close() error { |
||||||
|
if s.closed { |
||||||
|
return nil |
||||||
|
} |
||||||
|
s.closed = true |
||||||
|
// Emit EOF block
|
||||||
|
return StatelessDeflate(s.dst, nil, true) |
||||||
|
} |
||||||
|
|
||||||
|
func (s *statelessWriter) Write(p []byte) (n int, err error) { |
||||||
|
err = StatelessDeflate(s.dst, p, false) |
||||||
|
if err != nil { |
||||||
|
return 0, err |
||||||
|
} |
||||||
|
return len(p), nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *statelessWriter) Reset(w io.Writer) { |
||||||
|
s.dst = w |
||||||
|
s.closed = false |
||||||
|
} |
||||||
|
|
||||||
|
// NewStatelessWriter will do compression but without maintaining any state
|
||||||
|
// between Write calls.
|
||||||
|
// There will be no memory kept between Write calls,
|
||||||
|
// but compression and speed will be suboptimal.
|
||||||
|
// Because of this, the size of actual Write calls will affect output size.
|
||||||
|
func NewStatelessWriter(dst io.Writer) io.WriteCloser { |
||||||
|
return &statelessWriter{dst: dst} |
||||||
|
} |
||||||
|
|
||||||
|
// StatelessDeflate allows to compress directly to a Writer without retaining state.
|
||||||
|
// When returning everything will be flushed.
|
||||||
|
func StatelessDeflate(out io.Writer, in []byte, eof bool) error { |
||||||
|
var dst tokens |
||||||
|
bw := newHuffmanBitWriter(out) |
||||||
|
if eof && len(in) == 0 { |
||||||
|
// Just write an EOF block.
|
||||||
|
// Could be faster...
|
||||||
|
bw.writeStoredHeader(0, true) |
||||||
|
bw.flush() |
||||||
|
return bw.err |
||||||
|
} |
||||||
|
|
||||||
|
for len(in) > 0 { |
||||||
|
todo := in |
||||||
|
if len(todo) > maxStatelessBlock { |
||||||
|
todo = todo[:maxStatelessBlock] |
||||||
|
} |
||||||
|
in = in[len(todo):] |
||||||
|
// Compress
|
||||||
|
statelessEnc(&dst, todo) |
||||||
|
isEof := eof && len(in) == 0 |
||||||
|
|
||||||
|
if dst.n == 0 { |
||||||
|
bw.writeStoredHeader(len(todo), isEof) |
||||||
|
if bw.err != nil { |
||||||
|
return bw.err |
||||||
|
} |
||||||
|
bw.writeBytes(todo) |
||||||
|
} else if int(dst.n) > len(todo)-len(todo)>>4 { |
||||||
|
// If we removed less than 1/16th, huffman compress the block.
|
||||||
|
bw.writeBlockHuff(isEof, todo, false) |
||||||
|
} else { |
||||||
|
bw.writeBlockDynamic(&dst, isEof, todo, false) |
||||||
|
} |
||||||
|
if bw.err != nil { |
||||||
|
return bw.err |
||||||
|
} |
||||||
|
dst.Reset() |
||||||
|
} |
||||||
|
if !eof { |
||||||
|
// Align.
|
||||||
|
bw.writeStoredHeader(0, false) |
||||||
|
} |
||||||
|
bw.flush() |
||||||
|
return bw.err |
||||||
|
} |
||||||
|
|
||||||
|
func hashSL(u uint32) uint32 { |
||||||
|
return (u * 0x1e35a7bd) >> slTableShift |
||||||
|
} |
||||||
|
|
||||||
|
func load3216(b []byte, i int16) uint32 { |
||||||
|
// Help the compiler eliminate bounds checks on the read so it can be done in a single read.
|
||||||
|
b = b[i:] |
||||||
|
b = b[:4] |
||||||
|
return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 |
||||||
|
} |
||||||
|
|
||||||
|
func load6416(b []byte, i int16) uint64 { |
||||||
|
// Help the compiler eliminate bounds checks on the read so it can be done in a single read.
|
||||||
|
b = b[i:] |
||||||
|
b = b[:8] |
||||||
|
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | |
||||||
|
uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 |
||||||
|
} |
||||||
|
|
||||||
|
func statelessEnc(dst *tokens, src []byte) { |
||||||
|
const ( |
||||||
|
inputMargin = 12 - 1 |
||||||
|
minNonLiteralBlockSize = 1 + 1 + inputMargin |
||||||
|
) |
||||||
|
|
||||||
|
type tableEntry struct { |
||||||
|
offset int16 |
||||||
|
} |
||||||
|
|
||||||
|
var table [slTableSize]tableEntry |
||||||
|
|
||||||
|
// This check isn't in the Snappy implementation, but there, the caller
|
||||||
|
// instead of the callee handles this case.
|
||||||
|
if len(src) < minNonLiteralBlockSize { |
||||||
|
// We do not fill the token table.
|
||||||
|
// This will be picked up by caller.
|
||||||
|
dst.n = uint16(len(src)) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
s := int16(1) |
||||||
|
nextEmit := int16(0) |
||||||
|
// sLimit is when to stop looking for offset/length copies. The inputMargin
|
||||||
|
// lets us use a fast path for emitLiteral in the main loop, while we are
|
||||||
|
// looking for copies.
|
||||||
|
sLimit := int16(len(src) - inputMargin) |
||||||
|
|
||||||
|
// nextEmit is where in src the next emitLiteral should start from.
|
||||||
|
cv := load3216(src, s) |
||||||
|
|
||||||
|
for { |
||||||
|
const skipLog = 5 |
||||||
|
const doEvery = 2 |
||||||
|
|
||||||
|
nextS := s |
||||||
|
var candidate tableEntry |
||||||
|
for { |
||||||
|
nextHash := hashSL(cv) |
||||||
|
candidate = table[nextHash] |
||||||
|
nextS = s + doEvery + (s-nextEmit)>>skipLog |
||||||
|
if nextS > sLimit || nextS <= 0 { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
now := load6416(src, nextS) |
||||||
|
table[nextHash] = tableEntry{offset: s} |
||||||
|
nextHash = hashSL(uint32(now)) |
||||||
|
|
||||||
|
if cv == load3216(src, candidate.offset) { |
||||||
|
table[nextHash] = tableEntry{offset: nextS} |
||||||
|
break |
||||||
|
} |
||||||
|
|
||||||
|
// Do one right away...
|
||||||
|
cv = uint32(now) |
||||||
|
s = nextS |
||||||
|
nextS++ |
||||||
|
candidate = table[nextHash] |
||||||
|
now >>= 8 |
||||||
|
table[nextHash] = tableEntry{offset: s} |
||||||
|
|
||||||
|
if cv == load3216(src, candidate.offset) { |
||||||
|
table[nextHash] = tableEntry{offset: nextS} |
||||||
|
break |
||||||
|
} |
||||||
|
cv = uint32(now) |
||||||
|
s = nextS |
||||||
|
} |
||||||
|
|
||||||
|
// A 4-byte match has been found. We'll later see if more than 4 bytes
|
||||||
|
// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
|
||||||
|
// them as literal bytes.
|
||||||
|
for { |
||||||
|
// Invariant: we have a 4-byte match at s, and no need to emit any
|
||||||
|
// literal bytes prior to s.
|
||||||
|
|
||||||
|
// Extend the 4-byte match as long as possible.
|
||||||
|
t := candidate.offset |
||||||
|
l := int16(matchLen(src[s+4:], src[t+4:]) + 4) |
||||||
|
|
||||||
|
// Extend backwards
|
||||||
|
for t > 0 && s > nextEmit && src[t-1] == src[s-1] { |
||||||
|
s-- |
||||||
|
t-- |
||||||
|
l++ |
||||||
|
} |
||||||
|
if nextEmit < s { |
||||||
|
emitLiteral(dst, src[nextEmit:s]) |
||||||
|
} |
||||||
|
|
||||||
|
// Save the match found
|
||||||
|
dst.AddMatchLong(int32(l), uint32(s-t-baseMatchOffset)) |
||||||
|
s += l |
||||||
|
nextEmit = s |
||||||
|
if nextS >= s { |
||||||
|
s = nextS + 1 |
||||||
|
} |
||||||
|
if s >= sLimit { |
||||||
|
goto emitRemainder |
||||||
|
} |
||||||
|
|
||||||
|
// We could immediately start working at s now, but to improve
|
||||||
|
// compression we first update the hash table at s-2 and at s. If
|
||||||
|
// another emitCopy is not our next move, also calculate nextHash
|
||||||
|
// at s+1. At least on GOARCH=amd64, these three hash calculations
|
||||||
|
// are faster as one load64 call (with some shifts) instead of
|
||||||
|
// three load32 calls.
|
||||||
|
x := load6416(src, s-2) |
||||||
|
o := s - 2 |
||||||
|
prevHash := hashSL(uint32(x)) |
||||||
|
table[prevHash] = tableEntry{offset: o} |
||||||
|
x >>= 16 |
||||||
|
currHash := hashSL(uint32(x)) |
||||||
|
candidate = table[currHash] |
||||||
|
table[currHash] = tableEntry{offset: o + 2} |
||||||
|
|
||||||
|
if uint32(x) != load3216(src, candidate.offset) { |
||||||
|
cv = uint32(x >> 8) |
||||||
|
s++ |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
emitRemainder: |
||||||
|
if int(nextEmit) < len(src) { |
||||||
|
// If nothing was added, don't encode literals.
|
||||||
|
if dst.n == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
emitLiteral(dst, src[nextEmit:]) |
||||||
|
} |
||||||
|
} |
||||||
@ -1,24 +0,0 @@ |
|||||||
# Compiled Object files, Static and Dynamic libs (Shared Objects) |
|
||||||
*.o |
|
||||||
*.a |
|
||||||
*.so |
|
||||||
|
|
||||||
# Folders |
|
||||||
_obj |
|
||||||
_test |
|
||||||
|
|
||||||
# Architecture specific extensions/prefixes |
|
||||||
*.[568vq] |
|
||||||
[568vq].out |
|
||||||
|
|
||||||
*.cgo1.go |
|
||||||
*.cgo2.c |
|
||||||
_cgo_defun.c |
|
||||||
_cgo_gotypes.go |
|
||||||
_cgo_export.* |
|
||||||
|
|
||||||
_testmain.go |
|
||||||
|
|
||||||
*.exe |
|
||||||
*.test |
|
||||||
*.prof |
|
||||||
@ -1,8 +0,0 @@ |
|||||||
language: go |
|
||||||
|
|
||||||
go: |
|
||||||
- 1.3 |
|
||||||
- 1.4 |
|
||||||
- 1.5 |
|
||||||
- 1.6 |
|
||||||
- tip |
|
||||||
@ -1,22 +0,0 @@ |
|||||||
The MIT License (MIT) |
|
||||||
|
|
||||||
Copyright (c) 2015 Klaus Post |
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|
||||||
of this software and associated documentation files (the "Software"), to deal |
|
||||||
in the Software without restriction, including without limitation the rights |
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
||||||
copies of the Software, and to permit persons to whom the Software is |
|
||||||
furnished to do so, subject to the following conditions: |
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in all |
|
||||||
copies or substantial portions of the Software. |
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
||||||
SOFTWARE. |
|
||||||
|
|
||||||
@ -1,145 +0,0 @@ |
|||||||
# cpuid |
|
||||||
Package cpuid provides information about the CPU running the current program. |
|
||||||
|
|
||||||
CPU features are detected on startup, and kept for fast access through the life of the application. |
|
||||||
Currently x86 / x64 (AMD64) is supported, and no external C (cgo) code is used, which should make the library very easy to use. |
|
||||||
|
|
||||||
You can access the CPU information by accessing the shared CPU variable of the cpuid library. |
|
||||||
|
|
||||||
Package home: https://github.com/klauspost/cpuid |
|
||||||
|
|
||||||
[![GoDoc][1]][2] [![Build Status][3]][4] |
|
||||||
|
|
||||||
[1]: https://godoc.org/github.com/klauspost/cpuid?status.svg |
|
||||||
[2]: https://godoc.org/github.com/klauspost/cpuid |
|
||||||
[3]: https://travis-ci.org/klauspost/cpuid.svg |
|
||||||
[4]: https://travis-ci.org/klauspost/cpuid |
|
||||||
|
|
||||||
# features |
|
||||||
## CPU Instructions |
|
||||||
* **CMOV** (i686 CMOV) |
|
||||||
* **NX** (NX (No-Execute) bit) |
|
||||||
* **AMD3DNOW** (AMD 3DNOW) |
|
||||||
* **AMD3DNOWEXT** (AMD 3DNowExt) |
|
||||||
* **MMX** (standard MMX) |
|
||||||
* **MMXEXT** (SSE integer functions or AMD MMX ext) |
|
||||||
* **SSE** (SSE functions) |
|
||||||
* **SSE2** (P4 SSE functions) |
|
||||||
* **SSE3** (Prescott SSE3 functions) |
|
||||||
* **SSSE3** (Conroe SSSE3 functions) |
|
||||||
* **SSE4** (Penryn SSE4.1 functions) |
|
||||||
* **SSE4A** (AMD Barcelona microarchitecture SSE4a instructions) |
|
||||||
* **SSE42** (Nehalem SSE4.2 functions) |
|
||||||
* **AVX** (AVX functions) |
|
||||||
* **AVX2** (AVX2 functions) |
|
||||||
* **FMA3** (Intel FMA 3) |
|
||||||
* **FMA4** (Bulldozer FMA4 functions) |
|
||||||
* **XOP** (Bulldozer XOP functions) |
|
||||||
* **F16C** (Half-precision floating-point conversion) |
|
||||||
* **BMI1** (Bit Manipulation Instruction Set 1) |
|
||||||
* **BMI2** (Bit Manipulation Instruction Set 2) |
|
||||||
* **TBM** (AMD Trailing Bit Manipulation) |
|
||||||
* **LZCNT** (LZCNT instruction) |
|
||||||
* **POPCNT** (POPCNT instruction) |
|
||||||
* **AESNI** (Advanced Encryption Standard New Instructions) |
|
||||||
* **CLMUL** (Carry-less Multiplication) |
|
||||||
* **HTT** (Hyperthreading (enabled)) |
|
||||||
* **HLE** (Hardware Lock Elision) |
|
||||||
* **RTM** (Restricted Transactional Memory) |
|
||||||
* **RDRAND** (RDRAND instruction is available) |
|
||||||
* **RDSEED** (RDSEED instruction is available) |
|
||||||
* **ADX** (Intel ADX (Multi-Precision Add-Carry Instruction Extensions)) |
|
||||||
* **SHA** (Intel SHA Extensions) |
|
||||||
* **AVX512F** (AVX-512 Foundation) |
|
||||||
* **AVX512DQ** (AVX-512 Doubleword and Quadword Instructions) |
|
||||||
* **AVX512IFMA** (AVX-512 Integer Fused Multiply-Add Instructions) |
|
||||||
* **AVX512PF** (AVX-512 Prefetch Instructions) |
|
||||||
* **AVX512ER** (AVX-512 Exponential and Reciprocal Instructions) |
|
||||||
* **AVX512CD** (AVX-512 Conflict Detection Instructions) |
|
||||||
* **AVX512BW** (AVX-512 Byte and Word Instructions) |
|
||||||
* **AVX512VL** (AVX-512 Vector Length Extensions) |
|
||||||
* **AVX512VBMI** (AVX-512 Vector Bit Manipulation Instructions) |
|
||||||
* **MPX** (Intel MPX (Memory Protection Extensions)) |
|
||||||
* **ERMS** (Enhanced REP MOVSB/STOSB) |
|
||||||
* **RDTSCP** (RDTSCP Instruction) |
|
||||||
* **CX16** (CMPXCHG16B Instruction) |
|
||||||
* **SGX** (Software Guard Extensions, with activation details) |
|
||||||
|
|
||||||
## Performance |
|
||||||
* **RDTSCP()** Returns current cycle count. Can be used for benchmarking. |
|
||||||
* **SSE2SLOW** (SSE2 is supported, but usually not faster) |
|
||||||
* **SSE3SLOW** (SSE3 is supported, but usually not faster) |
|
||||||
* **ATOM** (Atom processor, some SSSE3 instructions are slower) |
|
||||||
* **Cache line** (Probable size of a cache line). |
|
||||||
* **L1, L2, L3 Cache size** on newer Intel/AMD CPUs. |
|
||||||
|
|
||||||
## Cpu Vendor/VM |
|
||||||
* **Intel** |
|
||||||
* **AMD** |
|
||||||
* **VIA** |
|
||||||
* **Transmeta** |
|
||||||
* **NSC** |
|
||||||
* **KVM** (Kernel-based Virtual Machine) |
|
||||||
* **MSVM** (Microsoft Hyper-V or Windows Virtual PC) |
|
||||||
* **VMware** |
|
||||||
* **XenHVM** |
|
||||||
|
|
||||||
# installing |
|
||||||
|
|
||||||
```go get github.com/klauspost/cpuid``` |
|
||||||
|
|
||||||
# example |
|
||||||
|
|
||||||
```Go |
|
||||||
package main |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"github.com/klauspost/cpuid" |
|
||||||
) |
|
||||||
|
|
||||||
func main() { |
|
||||||
// Print basic CPU information: |
|
||||||
fmt.Println("Name:", cpuid.CPU.BrandName) |
|
||||||
fmt.Println("PhysicalCores:", cpuid.CPU.PhysicalCores) |
|
||||||
fmt.Println("ThreadsPerCore:", cpuid.CPU.ThreadsPerCore) |
|
||||||
fmt.Println("LogicalCores:", cpuid.CPU.LogicalCores) |
|
||||||
fmt.Println("Family", cpuid.CPU.Family, "Model:", cpuid.CPU.Model) |
|
||||||
fmt.Println("Features:", cpuid.CPU.Features) |
|
||||||
fmt.Println("Cacheline bytes:", cpuid.CPU.CacheLine) |
|
||||||
fmt.Println("L1 Data Cache:", cpuid.CPU.Cache.L1D, "bytes") |
|
||||||
fmt.Println("L1 Instruction Cache:", cpuid.CPU.Cache.L1D, "bytes") |
|
||||||
fmt.Println("L2 Cache:", cpuid.CPU.Cache.L2, "bytes") |
|
||||||
fmt.Println("L3 Cache:", cpuid.CPU.Cache.L3, "bytes") |
|
||||||
|
|
||||||
// Test if we have a specific feature: |
|
||||||
if cpuid.CPU.SSE() { |
|
||||||
fmt.Println("We have Streaming SIMD Extensions") |
|
||||||
} |
|
||||||
} |
|
||||||
``` |
|
||||||
|
|
||||||
Sample output: |
|
||||||
``` |
|
||||||
>go run main.go |
|
||||||
Name: Intel(R) Core(TM) i5-2540M CPU @ 2.60GHz |
|
||||||
PhysicalCores: 2 |
|
||||||
ThreadsPerCore: 2 |
|
||||||
LogicalCores: 4 |
|
||||||
Family 6 Model: 42 |
|
||||||
Features: CMOV,MMX,MMXEXT,SSE,SSE2,SSE3,SSSE3,SSE4.1,SSE4.2,AVX,AESNI,CLMUL |
|
||||||
Cacheline bytes: 64 |
|
||||||
We have Streaming SIMD Extensions |
|
||||||
``` |
|
||||||
|
|
||||||
# private package |
|
||||||
|
|
||||||
In the "private" folder you can find an autogenerated version of the library you can include in your own packages. |
|
||||||
|
|
||||||
For this purpose all exports are removed, and functions and constants are lowercased. |
|
||||||
|
|
||||||
This is not a recommended way of using the library, but provided for convenience, if it is difficult for you to use external packages. |
|
||||||
|
|
||||||
# license |
|
||||||
|
|
||||||
This code is published under an MIT license. See LICENSE file for more information. |
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,42 +0,0 @@ |
|||||||
// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file. |
|
||||||
|
|
||||||
// +build 386,!gccgo |
|
||||||
|
|
||||||
// func asmCpuid(op uint32) (eax, ebx, ecx, edx uint32) |
|
||||||
TEXT ·asmCpuid(SB), 7, $0 |
|
||||||
XORL CX, CX |
|
||||||
MOVL op+0(FP), AX |
|
||||||
CPUID |
|
||||||
MOVL AX, eax+4(FP) |
|
||||||
MOVL BX, ebx+8(FP) |
|
||||||
MOVL CX, ecx+12(FP) |
|
||||||
MOVL DX, edx+16(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func asmCpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) |
|
||||||
TEXT ·asmCpuidex(SB), 7, $0 |
|
||||||
MOVL op+0(FP), AX |
|
||||||
MOVL op2+4(FP), CX |
|
||||||
CPUID |
|
||||||
MOVL AX, eax+8(FP) |
|
||||||
MOVL BX, ebx+12(FP) |
|
||||||
MOVL CX, ecx+16(FP) |
|
||||||
MOVL DX, edx+20(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func xgetbv(index uint32) (eax, edx uint32) |
|
||||||
TEXT ·asmXgetbv(SB), 7, $0 |
|
||||||
MOVL index+0(FP), CX |
|
||||||
BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
|
|
||||||
MOVL AX, eax+4(FP) |
|
||||||
MOVL DX, edx+8(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func asmRdtscpAsm() (eax, ebx, ecx, edx uint32) |
|
||||||
TEXT ·asmRdtscpAsm(SB), 7, $0 |
|
||||||
BYTE $0x0F; BYTE $0x01; BYTE $0xF9 // RDTSCP
|
|
||||||
MOVL AX, eax+0(FP) |
|
||||||
MOVL BX, ebx+4(FP) |
|
||||||
MOVL CX, ecx+8(FP) |
|
||||||
MOVL DX, edx+12(FP) |
|
||||||
RET |
|
||||||
@ -1,42 +0,0 @@ |
|||||||
// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file. |
|
||||||
|
|
||||||
//+build amd64,!gccgo |
|
||||||
|
|
||||||
// func asmCpuid(op uint32) (eax, ebx, ecx, edx uint32) |
|
||||||
TEXT ·asmCpuid(SB), 7, $0 |
|
||||||
XORQ CX, CX |
|
||||||
MOVL op+0(FP), AX |
|
||||||
CPUID |
|
||||||
MOVL AX, eax+8(FP) |
|
||||||
MOVL BX, ebx+12(FP) |
|
||||||
MOVL CX, ecx+16(FP) |
|
||||||
MOVL DX, edx+20(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func asmCpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) |
|
||||||
TEXT ·asmCpuidex(SB), 7, $0 |
|
||||||
MOVL op+0(FP), AX |
|
||||||
MOVL op2+4(FP), CX |
|
||||||
CPUID |
|
||||||
MOVL AX, eax+8(FP) |
|
||||||
MOVL BX, ebx+12(FP) |
|
||||||
MOVL CX, ecx+16(FP) |
|
||||||
MOVL DX, edx+20(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func asmXgetbv(index uint32) (eax, edx uint32) |
|
||||||
TEXT ·asmXgetbv(SB), 7, $0 |
|
||||||
MOVL index+0(FP), CX |
|
||||||
BYTE $0x0f; BYTE $0x01; BYTE $0xd0 // XGETBV
|
|
||||||
MOVL AX, eax+8(FP) |
|
||||||
MOVL DX, edx+12(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func asmRdtscpAsm() (eax, ebx, ecx, edx uint32) |
|
||||||
TEXT ·asmRdtscpAsm(SB), 7, $0 |
|
||||||
BYTE $0x0F; BYTE $0x01; BYTE $0xF9 // RDTSCP
|
|
||||||
MOVL AX, eax+0(FP) |
|
||||||
MOVL BX, ebx+4(FP) |
|
||||||
MOVL CX, ecx+8(FP) |
|
||||||
MOVL DX, edx+12(FP) |
|
||||||
RET |
|
||||||
@ -1,17 +0,0 @@ |
|||||||
// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
|
|
||||||
|
|
||||||
// +build 386,!gccgo amd64,!gccgo
|
|
||||||
|
|
||||||
package cpuid |
|
||||||
|
|
||||||
func asmCpuid(op uint32) (eax, ebx, ecx, edx uint32) |
|
||||||
func asmCpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32) |
|
||||||
func asmXgetbv(index uint32) (eax, edx uint32) |
|
||||||
func asmRdtscpAsm() (eax, ebx, ecx, edx uint32) |
|
||||||
|
|
||||||
func initCPU() { |
|
||||||
cpuid = asmCpuid |
|
||||||
cpuidex = asmCpuidex |
|
||||||
xgetbv = asmXgetbv |
|
||||||
rdtscpAsm = asmRdtscpAsm |
|
||||||
} |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
|
|
||||||
|
|
||||||
// +build !amd64,!386 gccgo
|
|
||||||
|
|
||||||
package cpuid |
|
||||||
|
|
||||||
func initCPU() { |
|
||||||
cpuid = func(op uint32) (eax, ebx, ecx, edx uint32) { |
|
||||||
return 0, 0, 0, 0 |
|
||||||
} |
|
||||||
|
|
||||||
cpuidex = func(op, op2 uint32) (eax, ebx, ecx, edx uint32) { |
|
||||||
return 0, 0, 0, 0 |
|
||||||
} |
|
||||||
|
|
||||||
xgetbv = func(index uint32) (eax, edx uint32) { |
|
||||||
return 0, 0 |
|
||||||
} |
|
||||||
|
|
||||||
rdtscpAsm = func() (eax, ebx, ecx, edx uint32) { |
|
||||||
return 0, 0, 0, 0 |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,3 +0,0 @@ |
|||||||
package cpuid |
|
||||||
|
|
||||||
//go:generate go run private-gen.go
|
|
||||||
@ -1,24 +0,0 @@ |
|||||||
# Compiled Object files, Static and Dynamic libs (Shared Objects) |
|
||||||
*.o |
|
||||||
*.a |
|
||||||
*.so |
|
||||||
|
|
||||||
# Folders |
|
||||||
_obj |
|
||||||
_test |
|
||||||
|
|
||||||
# Architecture specific extensions/prefixes |
|
||||||
*.[568vq] |
|
||||||
[568vq].out |
|
||||||
|
|
||||||
*.cgo1.go |
|
||||||
*.cgo2.c |
|
||||||
_cgo_defun.c |
|
||||||
_cgo_gotypes.go |
|
||||||
_cgo_export.* |
|
||||||
|
|
||||||
_testmain.go |
|
||||||
|
|
||||||
*.exe |
|
||||||
*.test |
|
||||||
*.prof |
|
||||||
@ -1,13 +0,0 @@ |
|||||||
language: go |
|
||||||
|
|
||||||
go: |
|
||||||
- 1.3 |
|
||||||
- 1.4 |
|
||||||
- 1.5 |
|
||||||
- 1.6 |
|
||||||
- 1.7 |
|
||||||
- tip |
|
||||||
|
|
||||||
script: |
|
||||||
- go test -v . |
|
||||||
- go test -v -race . |
|
||||||
@ -1,28 +0,0 @@ |
|||||||
Copyright (c) 2012 The Go Authors. All rights reserved. |
|
||||||
Copyright (c) 2015 Klaus Post |
|
||||||
|
|
||||||
Redistribution and use in source and binary forms, with or without |
|
||||||
modification, are permitted provided that the following conditions are |
|
||||||
met: |
|
||||||
|
|
||||||
* Redistributions of source code must retain the above copyright |
|
||||||
notice, this list of conditions and the following disclaimer. |
|
||||||
* Redistributions in binary form must reproduce the above |
|
||||||
copyright notice, this list of conditions and the following disclaimer |
|
||||||
in the documentation and/or other materials provided with the |
|
||||||
distribution. |
|
||||||
* Neither the name of Google Inc. nor the names of its |
|
||||||
contributors may be used to endorse or promote products derived from |
|
||||||
this software without specific prior written permission. |
|
||||||
|
|
||||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
@ -1,87 +0,0 @@ |
|||||||
# crc32 |
|
||||||
CRC32 hash with x64 optimizations |
|
||||||
|
|
||||||
This package is a drop-in replacement for the standard library `hash/crc32` package, that features SSE 4.2 optimizations on x64 platforms, for a 10x speedup. |
|
||||||
|
|
||||||
[](https://travis-ci.org/klauspost/crc32) |
|
||||||
|
|
||||||
# usage |
|
||||||
|
|
||||||
Install using `go get github.com/klauspost/crc32`. This library is based on Go 1.5 code and requires Go 1.3 or newer. |
|
||||||
|
|
||||||
Replace `import "hash/crc32"` with `import "github.com/klauspost/crc32"` and you are good to go. |
|
||||||
|
|
||||||
# changes |
|
||||||
* Oct 20, 2016: Changes have been merged to upstream Go. Package updated to match. |
|
||||||
* Dec 4, 2015: Uses the "slice-by-8" trick more extensively, which gives a 1.5 to 2.5x speedup if assembler is unavailable. |
|
||||||
|
|
||||||
|
|
||||||
# performance |
|
||||||
|
|
||||||
For *Go 1.7* performance is equivalent to the standard library. So if you use this package for Go 1.7 you can switch back. |
|
||||||
|
|
||||||
|
|
||||||
For IEEE tables (the most common), there is approximately a factor 10 speedup with "CLMUL" (Carryless multiplication) instruction: |
|
||||||
``` |
|
||||||
benchmark old ns/op new ns/op delta |
|
||||||
BenchmarkCrc32KB 99955 10258 -89.74% |
|
||||||
|
|
||||||
benchmark old MB/s new MB/s speedup |
|
||||||
BenchmarkCrc32KB 327.83 3194.20 9.74x |
|
||||||
``` |
|
||||||
|
|
||||||
For other tables and "CLMUL" capable machines the performance is the same as the standard library. |
|
||||||
|
|
||||||
Here are some detailed benchmarks, comparing to go 1.5 standard library with and without assembler enabled. |
|
||||||
|
|
||||||
``` |
|
||||||
Std: Standard Go 1.5 library |
|
||||||
Crc: Indicates IEEE type CRC. |
|
||||||
40B: Size of each slice encoded. |
|
||||||
NoAsm: Assembler was disabled (ie. not an AMD64 or SSE 4.2+ capable machine). |
|
||||||
Castagnoli: Castagnoli CRC type. |
|
||||||
|
|
||||||
BenchmarkStdCrc40B-4 10000000 158 ns/op 252.88 MB/s |
|
||||||
BenchmarkCrc40BNoAsm-4 20000000 105 ns/op 377.38 MB/s (slice8) |
|
||||||
BenchmarkCrc40B-4 20000000 105 ns/op 378.77 MB/s (slice8) |
|
||||||
|
|
||||||
BenchmarkStdCrc1KB-4 500000 3604 ns/op 284.10 MB/s |
|
||||||
BenchmarkCrc1KBNoAsm-4 1000000 1463 ns/op 699.79 MB/s (slice8) |
|
||||||
BenchmarkCrc1KB-4 3000000 396 ns/op 2583.69 MB/s (asm) |
|
||||||
|
|
||||||
BenchmarkStdCrc8KB-4 200000 11417 ns/op 717.48 MB/s (slice8) |
|
||||||
BenchmarkCrc8KBNoAsm-4 200000 11317 ns/op 723.85 MB/s (slice8) |
|
||||||
BenchmarkCrc8KB-4 500000 2919 ns/op 2805.73 MB/s (asm) |
|
||||||
|
|
||||||
BenchmarkStdCrc32KB-4 30000 45749 ns/op 716.24 MB/s (slice8) |
|
||||||
BenchmarkCrc32KBNoAsm-4 30000 45109 ns/op 726.42 MB/s (slice8) |
|
||||||
BenchmarkCrc32KB-4 100000 11497 ns/op 2850.09 MB/s (asm) |
|
||||||
|
|
||||||
BenchmarkStdNoAsmCastagnol40B-4 10000000 161 ns/op 246.94 MB/s |
|
||||||
BenchmarkStdCastagnoli40B-4 50000000 28.4 ns/op 1410.69 MB/s (asm) |
|
||||||
BenchmarkCastagnoli40BNoAsm-4 20000000 100 ns/op 398.01 MB/s (slice8) |
|
||||||
BenchmarkCastagnoli40B-4 50000000 28.2 ns/op 1419.54 MB/s (asm) |
|
||||||
|
|
||||||
BenchmarkStdNoAsmCastagnoli1KB-4 500000 3622 ns/op 282.67 MB/s |
|
||||||
BenchmarkStdCastagnoli1KB-4 10000000 144 ns/op 7099.78 MB/s (asm) |
|
||||||
BenchmarkCastagnoli1KBNoAsm-4 1000000 1475 ns/op 694.14 MB/s (slice8) |
|
||||||
BenchmarkCastagnoli1KB-4 10000000 146 ns/op 6993.35 MB/s (asm) |
|
||||||
|
|
||||||
BenchmarkStdNoAsmCastagnoli8KB-4 50000 28781 ns/op 284.63 MB/s |
|
||||||
BenchmarkStdCastagnoli8KB-4 1000000 1029 ns/op 7957.89 MB/s (asm) |
|
||||||
BenchmarkCastagnoli8KBNoAsm-4 200000 11410 ns/op 717.94 MB/s (slice8) |
|
||||||
BenchmarkCastagnoli8KB-4 1000000 1000 ns/op 8188.71 MB/s (asm) |
|
||||||
|
|
||||||
BenchmarkStdNoAsmCastagnoli32KB-4 10000 115426 ns/op 283.89 MB/s |
|
||||||
BenchmarkStdCastagnoli32KB-4 300000 4065 ns/op 8059.13 MB/s (asm) |
|
||||||
BenchmarkCastagnoli32KBNoAsm-4 30000 45171 ns/op 725.41 MB/s (slice8) |
|
||||||
BenchmarkCastagnoli32KB-4 500000 4077 ns/op 8035.89 MB/s (asm) |
|
||||||
``` |
|
||||||
|
|
||||||
The IEEE assembler optimizations has been submitted and will be part of the Go 1.6 standard library. |
|
||||||
|
|
||||||
However, the improved use of slice-by-8 has not, but will probably be submitted for Go 1.7. |
|
||||||
|
|
||||||
# license |
|
||||||
|
|
||||||
Standard Go license. Changes are Copyright (c) 2015 Klaus Post under same conditions. |
|
||||||
@ -1,207 +0,0 @@ |
|||||||
// Copyright 2009 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 crc32 implements the 32-bit cyclic redundancy check, or CRC-32,
|
|
||||||
// checksum. See http://en.wikipedia.org/wiki/Cyclic_redundancy_check for
|
|
||||||
// information.
|
|
||||||
//
|
|
||||||
// Polynomials are represented in LSB-first form also known as reversed representation.
|
|
||||||
//
|
|
||||||
// See http://en.wikipedia.org/wiki/Mathematics_of_cyclic_redundancy_checks#Reversed_representations_and_reciprocal_polynomials
|
|
||||||
// for information.
|
|
||||||
package crc32 |
|
||||||
|
|
||||||
import ( |
|
||||||
"hash" |
|
||||||
"sync" |
|
||||||
) |
|
||||||
|
|
||||||
// The size of a CRC-32 checksum in bytes.
|
|
||||||
const Size = 4 |
|
||||||
|
|
||||||
// Predefined polynomials.
|
|
||||||
const ( |
|
||||||
// IEEE is by far and away the most common CRC-32 polynomial.
|
|
||||||
// Used by ethernet (IEEE 802.3), v.42, fddi, gzip, zip, png, ...
|
|
||||||
IEEE = 0xedb88320 |
|
||||||
|
|
||||||
// Castagnoli's polynomial, used in iSCSI.
|
|
||||||
// Has better error detection characteristics than IEEE.
|
|
||||||
// http://dx.doi.org/10.1109/26.231911
|
|
||||||
Castagnoli = 0x82f63b78 |
|
||||||
|
|
||||||
// Koopman's polynomial.
|
|
||||||
// Also has better error detection characteristics than IEEE.
|
|
||||||
// http://dx.doi.org/10.1109/DSN.2002.1028931
|
|
||||||
Koopman = 0xeb31d82e |
|
||||||
) |
|
||||||
|
|
||||||
// Table is a 256-word table representing the polynomial for efficient processing.
|
|
||||||
type Table [256]uint32 |
|
||||||
|
|
||||||
// This file makes use of functions implemented in architecture-specific files.
|
|
||||||
// The interface that they implement is as follows:
|
|
||||||
//
|
|
||||||
// // archAvailableIEEE reports whether an architecture-specific CRC32-IEEE
|
|
||||||
// // algorithm is available.
|
|
||||||
// archAvailableIEEE() bool
|
|
||||||
//
|
|
||||||
// // archInitIEEE initializes the architecture-specific CRC3-IEEE algorithm.
|
|
||||||
// // It can only be called if archAvailableIEEE() returns true.
|
|
||||||
// archInitIEEE()
|
|
||||||
//
|
|
||||||
// // archUpdateIEEE updates the given CRC32-IEEE. It can only be called if
|
|
||||||
// // archInitIEEE() was previously called.
|
|
||||||
// archUpdateIEEE(crc uint32, p []byte) uint32
|
|
||||||
//
|
|
||||||
// // archAvailableCastagnoli reports whether an architecture-specific
|
|
||||||
// // CRC32-C algorithm is available.
|
|
||||||
// archAvailableCastagnoli() bool
|
|
||||||
//
|
|
||||||
// // archInitCastagnoli initializes the architecture-specific CRC32-C
|
|
||||||
// // algorithm. It can only be called if archAvailableCastagnoli() returns
|
|
||||||
// // true.
|
|
||||||
// archInitCastagnoli()
|
|
||||||
//
|
|
||||||
// // archUpdateCastagnoli updates the given CRC32-C. It can only be called
|
|
||||||
// // if archInitCastagnoli() was previously called.
|
|
||||||
// archUpdateCastagnoli(crc uint32, p []byte) uint32
|
|
||||||
|
|
||||||
// castagnoliTable points to a lazily initialized Table for the Castagnoli
|
|
||||||
// polynomial. MakeTable will always return this value when asked to make a
|
|
||||||
// Castagnoli table so we can compare against it to find when the caller is
|
|
||||||
// using this polynomial.
|
|
||||||
var castagnoliTable *Table |
|
||||||
var castagnoliTable8 *slicing8Table |
|
||||||
var castagnoliArchImpl bool |
|
||||||
var updateCastagnoli func(crc uint32, p []byte) uint32 |
|
||||||
var castagnoliOnce sync.Once |
|
||||||
|
|
||||||
func castagnoliInit() { |
|
||||||
castagnoliTable = simpleMakeTable(Castagnoli) |
|
||||||
castagnoliArchImpl = archAvailableCastagnoli() |
|
||||||
|
|
||||||
if castagnoliArchImpl { |
|
||||||
archInitCastagnoli() |
|
||||||
updateCastagnoli = archUpdateCastagnoli |
|
||||||
} else { |
|
||||||
// Initialize the slicing-by-8 table.
|
|
||||||
castagnoliTable8 = slicingMakeTable(Castagnoli) |
|
||||||
updateCastagnoli = func(crc uint32, p []byte) uint32 { |
|
||||||
return slicingUpdate(crc, castagnoliTable8, p) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// IEEETable is the table for the IEEE polynomial.
|
|
||||||
var IEEETable = simpleMakeTable(IEEE) |
|
||||||
|
|
||||||
// ieeeTable8 is the slicing8Table for IEEE
|
|
||||||
var ieeeTable8 *slicing8Table |
|
||||||
var ieeeArchImpl bool |
|
||||||
var updateIEEE func(crc uint32, p []byte) uint32 |
|
||||||
var ieeeOnce sync.Once |
|
||||||
|
|
||||||
func ieeeInit() { |
|
||||||
ieeeArchImpl = archAvailableIEEE() |
|
||||||
|
|
||||||
if ieeeArchImpl { |
|
||||||
archInitIEEE() |
|
||||||
updateIEEE = archUpdateIEEE |
|
||||||
} else { |
|
||||||
// Initialize the slicing-by-8 table.
|
|
||||||
ieeeTable8 = slicingMakeTable(IEEE) |
|
||||||
updateIEEE = func(crc uint32, p []byte) uint32 { |
|
||||||
return slicingUpdate(crc, ieeeTable8, p) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// MakeTable returns a Table constructed from the specified polynomial.
|
|
||||||
// The contents of this Table must not be modified.
|
|
||||||
func MakeTable(poly uint32) *Table { |
|
||||||
switch poly { |
|
||||||
case IEEE: |
|
||||||
ieeeOnce.Do(ieeeInit) |
|
||||||
return IEEETable |
|
||||||
case Castagnoli: |
|
||||||
castagnoliOnce.Do(castagnoliInit) |
|
||||||
return castagnoliTable |
|
||||||
} |
|
||||||
return simpleMakeTable(poly) |
|
||||||
} |
|
||||||
|
|
||||||
// digest represents the partial evaluation of a checksum.
|
|
||||||
type digest struct { |
|
||||||
crc uint32 |
|
||||||
tab *Table |
|
||||||
} |
|
||||||
|
|
||||||
// New creates a new hash.Hash32 computing the CRC-32 checksum
|
|
||||||
// using the polynomial represented by the Table.
|
|
||||||
// Its Sum method will lay the value out in big-endian byte order.
|
|
||||||
func New(tab *Table) hash.Hash32 { |
|
||||||
if tab == IEEETable { |
|
||||||
ieeeOnce.Do(ieeeInit) |
|
||||||
} |
|
||||||
return &digest{0, tab} |
|
||||||
} |
|
||||||
|
|
||||||
// NewIEEE creates a new hash.Hash32 computing the CRC-32 checksum
|
|
||||||
// using the IEEE polynomial.
|
|
||||||
// Its Sum method will lay the value out in big-endian byte order.
|
|
||||||
func NewIEEE() hash.Hash32 { return New(IEEETable) } |
|
||||||
|
|
||||||
func (d *digest) Size() int { return Size } |
|
||||||
|
|
||||||
func (d *digest) BlockSize() int { return 1 } |
|
||||||
|
|
||||||
func (d *digest) Reset() { d.crc = 0 } |
|
||||||
|
|
||||||
// Update returns the result of adding the bytes in p to the crc.
|
|
||||||
func Update(crc uint32, tab *Table, p []byte) uint32 { |
|
||||||
switch tab { |
|
||||||
case castagnoliTable: |
|
||||||
return updateCastagnoli(crc, p) |
|
||||||
case IEEETable: |
|
||||||
// Unfortunately, because IEEETable is exported, IEEE may be used without a
|
|
||||||
// call to MakeTable. We have to make sure it gets initialized in that case.
|
|
||||||
ieeeOnce.Do(ieeeInit) |
|
||||||
return updateIEEE(crc, p) |
|
||||||
default: |
|
||||||
return simpleUpdate(crc, tab, p) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (d *digest) Write(p []byte) (n int, err error) { |
|
||||||
switch d.tab { |
|
||||||
case castagnoliTable: |
|
||||||
d.crc = updateCastagnoli(d.crc, p) |
|
||||||
case IEEETable: |
|
||||||
// We only create digest objects through New() which takes care of
|
|
||||||
// initialization in this case.
|
|
||||||
d.crc = updateIEEE(d.crc, p) |
|
||||||
default: |
|
||||||
d.crc = simpleUpdate(d.crc, d.tab, p) |
|
||||||
} |
|
||||||
return len(p), nil |
|
||||||
} |
|
||||||
|
|
||||||
func (d *digest) Sum32() uint32 { return d.crc } |
|
||||||
|
|
||||||
func (d *digest) Sum(in []byte) []byte { |
|
||||||
s := d.Sum32() |
|
||||||
return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s)) |
|
||||||
} |
|
||||||
|
|
||||||
// Checksum returns the CRC-32 checksum of data
|
|
||||||
// using the polynomial represented by the Table.
|
|
||||||
func Checksum(data []byte, tab *Table) uint32 { return Update(0, tab, data) } |
|
||||||
|
|
||||||
// ChecksumIEEE returns the CRC-32 checksum of data
|
|
||||||
// using the IEEE polynomial.
|
|
||||||
func ChecksumIEEE(data []byte) uint32 { |
|
||||||
ieeeOnce.Do(ieeeInit) |
|
||||||
return updateIEEE(0, data) |
|
||||||
} |
|
||||||
@ -1,230 +0,0 @@ |
|||||||
// Copyright 2011 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.
|
|
||||||
|
|
||||||
// +build !appengine,!gccgo
|
|
||||||
|
|
||||||
// AMD64-specific hardware-assisted CRC32 algorithms. See crc32.go for a
|
|
||||||
// description of the interface that each architecture-specific file
|
|
||||||
// implements.
|
|
||||||
|
|
||||||
package crc32 |
|
||||||
|
|
||||||
import "unsafe" |
|
||||||
|
|
||||||
// This file contains the code to call the SSE 4.2 version of the Castagnoli
|
|
||||||
// and IEEE CRC.
|
|
||||||
|
|
||||||
// haveSSE41/haveSSE42/haveCLMUL are defined in crc_amd64.s and use
|
|
||||||
// CPUID to test for SSE 4.1, 4.2 and CLMUL support.
|
|
||||||
func haveSSE41() bool |
|
||||||
func haveSSE42() bool |
|
||||||
func haveCLMUL() bool |
|
||||||
|
|
||||||
// castagnoliSSE42 is defined in crc32_amd64.s and uses the SSE4.2 CRC32
|
|
||||||
// instruction.
|
|
||||||
//go:noescape
|
|
||||||
func castagnoliSSE42(crc uint32, p []byte) uint32 |
|
||||||
|
|
||||||
// castagnoliSSE42Triple is defined in crc32_amd64.s and uses the SSE4.2 CRC32
|
|
||||||
// instruction.
|
|
||||||
//go:noescape
|
|
||||||
func castagnoliSSE42Triple( |
|
||||||
crcA, crcB, crcC uint32, |
|
||||||
a, b, c []byte, |
|
||||||
rounds uint32, |
|
||||||
) (retA uint32, retB uint32, retC uint32) |
|
||||||
|
|
||||||
// ieeeCLMUL is defined in crc_amd64.s and uses the PCLMULQDQ
|
|
||||||
// instruction as well as SSE 4.1.
|
|
||||||
//go:noescape
|
|
||||||
func ieeeCLMUL(crc uint32, p []byte) uint32 |
|
||||||
|
|
||||||
var sse42 = haveSSE42() |
|
||||||
var useFastIEEE = haveCLMUL() && haveSSE41() |
|
||||||
|
|
||||||
const castagnoliK1 = 168 |
|
||||||
const castagnoliK2 = 1344 |
|
||||||
|
|
||||||
type sse42Table [4]Table |
|
||||||
|
|
||||||
var castagnoliSSE42TableK1 *sse42Table |
|
||||||
var castagnoliSSE42TableK2 *sse42Table |
|
||||||
|
|
||||||
func archAvailableCastagnoli() bool { |
|
||||||
return sse42 |
|
||||||
} |
|
||||||
|
|
||||||
func archInitCastagnoli() { |
|
||||||
if !sse42 { |
|
||||||
panic("arch-specific Castagnoli not available") |
|
||||||
} |
|
||||||
castagnoliSSE42TableK1 = new(sse42Table) |
|
||||||
castagnoliSSE42TableK2 = new(sse42Table) |
|
||||||
// See description in updateCastagnoli.
|
|
||||||
// t[0][i] = CRC(i000, O)
|
|
||||||
// t[1][i] = CRC(0i00, O)
|
|
||||||
// t[2][i] = CRC(00i0, O)
|
|
||||||
// t[3][i] = CRC(000i, O)
|
|
||||||
// where O is a sequence of K zeros.
|
|
||||||
var tmp [castagnoliK2]byte |
|
||||||
for b := 0; b < 4; b++ { |
|
||||||
for i := 0; i < 256; i++ { |
|
||||||
val := uint32(i) << uint32(b*8) |
|
||||||
castagnoliSSE42TableK1[b][i] = castagnoliSSE42(val, tmp[:castagnoliK1]) |
|
||||||
castagnoliSSE42TableK2[b][i] = castagnoliSSE42(val, tmp[:]) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// castagnoliShift computes the CRC32-C of K1 or K2 zeroes (depending on the
|
|
||||||
// table given) with the given initial crc value. This corresponds to
|
|
||||||
// CRC(crc, O) in the description in updateCastagnoli.
|
|
||||||
func castagnoliShift(table *sse42Table, crc uint32) uint32 { |
|
||||||
return table[3][crc>>24] ^ |
|
||||||
table[2][(crc>>16)&0xFF] ^ |
|
||||||
table[1][(crc>>8)&0xFF] ^ |
|
||||||
table[0][crc&0xFF] |
|
||||||
} |
|
||||||
|
|
||||||
func archUpdateCastagnoli(crc uint32, p []byte) uint32 { |
|
||||||
if !sse42 { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
|
|
||||||
// This method is inspired from the algorithm in Intel's white paper:
|
|
||||||
// "Fast CRC Computation for iSCSI Polynomial Using CRC32 Instruction"
|
|
||||||
// The same strategy of splitting the buffer in three is used but the
|
|
||||||
// combining calculation is different; the complete derivation is explained
|
|
||||||
// below.
|
|
||||||
//
|
|
||||||
// -- The basic idea --
|
|
||||||
//
|
|
||||||
// The CRC32 instruction (available in SSE4.2) can process 8 bytes at a
|
|
||||||
// time. In recent Intel architectures the instruction takes 3 cycles;
|
|
||||||
// however the processor can pipeline up to three instructions if they
|
|
||||||
// don't depend on each other.
|
|
||||||
//
|
|
||||||
// Roughly this means that we can process three buffers in about the same
|
|
||||||
// time we can process one buffer.
|
|
||||||
//
|
|
||||||
// The idea is then to split the buffer in three, CRC the three pieces
|
|
||||||
// separately and then combine the results.
|
|
||||||
//
|
|
||||||
// Combining the results requires precomputed tables, so we must choose a
|
|
||||||
// fixed buffer length to optimize. The longer the length, the faster; but
|
|
||||||
// only buffers longer than this length will use the optimization. We choose
|
|
||||||
// two cutoffs and compute tables for both:
|
|
||||||
// - one around 512: 168*3=504
|
|
||||||
// - one around 4KB: 1344*3=4032
|
|
||||||
//
|
|
||||||
// -- The nitty gritty --
|
|
||||||
//
|
|
||||||
// Let CRC(I, X) be the non-inverted CRC32-C of the sequence X (with
|
|
||||||
// initial non-inverted CRC I). This function has the following properties:
|
|
||||||
// (a) CRC(I, AB) = CRC(CRC(I, A), B)
|
|
||||||
// (b) CRC(I, A xor B) = CRC(I, A) xor CRC(0, B)
|
|
||||||
//
|
|
||||||
// Say we want to compute CRC(I, ABC) where A, B, C are three sequences of
|
|
||||||
// K bytes each, where K is a fixed constant. Let O be the sequence of K zero
|
|
||||||
// bytes.
|
|
||||||
//
|
|
||||||
// CRC(I, ABC) = CRC(I, ABO xor C)
|
|
||||||
// = CRC(I, ABO) xor CRC(0, C)
|
|
||||||
// = CRC(CRC(I, AB), O) xor CRC(0, C)
|
|
||||||
// = CRC(CRC(I, AO xor B), O) xor CRC(0, C)
|
|
||||||
// = CRC(CRC(I, AO) xor CRC(0, B), O) xor CRC(0, C)
|
|
||||||
// = CRC(CRC(CRC(I, A), O) xor CRC(0, B), O) xor CRC(0, C)
|
|
||||||
//
|
|
||||||
// The castagnoliSSE42Triple function can compute CRC(I, A), CRC(0, B),
|
|
||||||
// and CRC(0, C) efficiently. We just need to find a way to quickly compute
|
|
||||||
// CRC(uvwx, O) given a 4-byte initial value uvwx. We can precompute these
|
|
||||||
// values; since we can't have a 32-bit table, we break it up into four
|
|
||||||
// 8-bit tables:
|
|
||||||
//
|
|
||||||
// CRC(uvwx, O) = CRC(u000, O) xor
|
|
||||||
// CRC(0v00, O) xor
|
|
||||||
// CRC(00w0, O) xor
|
|
||||||
// CRC(000x, O)
|
|
||||||
//
|
|
||||||
// We can compute tables corresponding to the four terms for all 8-bit
|
|
||||||
// values.
|
|
||||||
|
|
||||||
crc = ^crc |
|
||||||
|
|
||||||
// If a buffer is long enough to use the optimization, process the first few
|
|
||||||
// bytes to align the buffer to an 8 byte boundary (if necessary).
|
|
||||||
if len(p) >= castagnoliK1*3 { |
|
||||||
delta := int(uintptr(unsafe.Pointer(&p[0])) & 7) |
|
||||||
if delta != 0 { |
|
||||||
delta = 8 - delta |
|
||||||
crc = castagnoliSSE42(crc, p[:delta]) |
|
||||||
p = p[delta:] |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Process 3*K2 at a time.
|
|
||||||
for len(p) >= castagnoliK2*3 { |
|
||||||
// Compute CRC(I, A), CRC(0, B), and CRC(0, C).
|
|
||||||
crcA, crcB, crcC := castagnoliSSE42Triple( |
|
||||||
crc, 0, 0, |
|
||||||
p, p[castagnoliK2:], p[castagnoliK2*2:], |
|
||||||
castagnoliK2/24) |
|
||||||
|
|
||||||
// CRC(I, AB) = CRC(CRC(I, A), O) xor CRC(0, B)
|
|
||||||
crcAB := castagnoliShift(castagnoliSSE42TableK2, crcA) ^ crcB |
|
||||||
// CRC(I, ABC) = CRC(CRC(I, AB), O) xor CRC(0, C)
|
|
||||||
crc = castagnoliShift(castagnoliSSE42TableK2, crcAB) ^ crcC |
|
||||||
p = p[castagnoliK2*3:] |
|
||||||
} |
|
||||||
|
|
||||||
// Process 3*K1 at a time.
|
|
||||||
for len(p) >= castagnoliK1*3 { |
|
||||||
// Compute CRC(I, A), CRC(0, B), and CRC(0, C).
|
|
||||||
crcA, crcB, crcC := castagnoliSSE42Triple( |
|
||||||
crc, 0, 0, |
|
||||||
p, p[castagnoliK1:], p[castagnoliK1*2:], |
|
||||||
castagnoliK1/24) |
|
||||||
|
|
||||||
// CRC(I, AB) = CRC(CRC(I, A), O) xor CRC(0, B)
|
|
||||||
crcAB := castagnoliShift(castagnoliSSE42TableK1, crcA) ^ crcB |
|
||||||
// CRC(I, ABC) = CRC(CRC(I, AB), O) xor CRC(0, C)
|
|
||||||
crc = castagnoliShift(castagnoliSSE42TableK1, crcAB) ^ crcC |
|
||||||
p = p[castagnoliK1*3:] |
|
||||||
} |
|
||||||
|
|
||||||
// Use the simple implementation for what's left.
|
|
||||||
crc = castagnoliSSE42(crc, p) |
|
||||||
return ^crc |
|
||||||
} |
|
||||||
|
|
||||||
func archAvailableIEEE() bool { |
|
||||||
return useFastIEEE |
|
||||||
} |
|
||||||
|
|
||||||
var archIeeeTable8 *slicing8Table |
|
||||||
|
|
||||||
func archInitIEEE() { |
|
||||||
if !useFastIEEE { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
// We still use slicing-by-8 for small buffers.
|
|
||||||
archIeeeTable8 = slicingMakeTable(IEEE) |
|
||||||
} |
|
||||||
|
|
||||||
func archUpdateIEEE(crc uint32, p []byte) uint32 { |
|
||||||
if !useFastIEEE { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
|
|
||||||
if len(p) >= 64 { |
|
||||||
left := len(p) & 15 |
|
||||||
do := len(p) - left |
|
||||||
crc = ^ieeeCLMUL(^crc, p[:do]) |
|
||||||
p = p[do:] |
|
||||||
} |
|
||||||
if len(p) == 0 { |
|
||||||
return crc |
|
||||||
} |
|
||||||
return slicingUpdate(crc, archIeeeTable8, p) |
|
||||||
} |
|
||||||
@ -1,319 +0,0 @@ |
|||||||
// Copyright 2011 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. |
|
||||||
|
|
||||||
// +build gc |
|
||||||
|
|
||||||
#define NOSPLIT 4 |
|
||||||
#define RODATA 8 |
|
||||||
|
|
||||||
// castagnoliSSE42 updates the (non-inverted) crc with the given buffer. |
|
||||||
// |
|
||||||
// func castagnoliSSE42(crc uint32, p []byte) uint32 |
|
||||||
TEXT ·castagnoliSSE42(SB), NOSPLIT, $0 |
|
||||||
MOVL crc+0(FP), AX // CRC value |
|
||||||
MOVQ p+8(FP), SI // data pointer |
|
||||||
MOVQ p_len+16(FP), CX // len(p) |
|
||||||
|
|
||||||
// If there are fewer than 8 bytes to process, skip alignment. |
|
||||||
CMPQ CX, $8 |
|
||||||
JL less_than_8 |
|
||||||
|
|
||||||
MOVQ SI, BX |
|
||||||
ANDQ $7, BX |
|
||||||
JZ aligned |
|
||||||
|
|
||||||
// Process the first few bytes to 8-byte align the input. |
|
||||||
|
|
||||||
// BX = 8 - BX. We need to process this many bytes to align. |
|
||||||
SUBQ $1, BX |
|
||||||
XORQ $7, BX |
|
||||||
|
|
||||||
BTQ $0, BX |
|
||||||
JNC align_2 |
|
||||||
|
|
||||||
CRC32B (SI), AX |
|
||||||
DECQ CX |
|
||||||
INCQ SI |
|
||||||
|
|
||||||
align_2: |
|
||||||
BTQ $1, BX |
|
||||||
JNC align_4 |
|
||||||
|
|
||||||
// CRC32W (SI), AX |
|
||||||
BYTE $0x66; BYTE $0xf2; BYTE $0x0f; BYTE $0x38; BYTE $0xf1; BYTE $0x06
|
|
||||||
|
|
||||||
SUBQ $2, CX |
|
||||||
ADDQ $2, SI |
|
||||||
|
|
||||||
align_4: |
|
||||||
BTQ $2, BX |
|
||||||
JNC aligned |
|
||||||
|
|
||||||
// CRC32L (SI), AX |
|
||||||
BYTE $0xf2; BYTE $0x0f; BYTE $0x38; BYTE $0xf1; BYTE $0x06
|
|
||||||
|
|
||||||
SUBQ $4, CX |
|
||||||
ADDQ $4, SI |
|
||||||
|
|
||||||
aligned: |
|
||||||
// The input is now 8-byte aligned and we can process 8-byte chunks. |
|
||||||
CMPQ CX, $8 |
|
||||||
JL less_than_8 |
|
||||||
|
|
||||||
CRC32Q (SI), AX |
|
||||||
ADDQ $8, SI |
|
||||||
SUBQ $8, CX |
|
||||||
JMP aligned |
|
||||||
|
|
||||||
less_than_8: |
|
||||||
// We may have some bytes left over; process 4 bytes, then 2, then 1.
|
|
||||||
BTQ $2, CX |
|
||||||
JNC less_than_4 |
|
||||||
|
|
||||||
// CRC32L (SI), AX |
|
||||||
BYTE $0xf2; BYTE $0x0f; BYTE $0x38; BYTE $0xf1; BYTE $0x06
|
|
||||||
ADDQ $4, SI |
|
||||||
|
|
||||||
less_than_4: |
|
||||||
BTQ $1, CX |
|
||||||
JNC less_than_2 |
|
||||||
|
|
||||||
// CRC32W (SI), AX |
|
||||||
BYTE $0x66; BYTE $0xf2; BYTE $0x0f; BYTE $0x38; BYTE $0xf1; BYTE $0x06
|
|
||||||
ADDQ $2, SI |
|
||||||
|
|
||||||
less_than_2: |
|
||||||
BTQ $0, CX |
|
||||||
JNC done |
|
||||||
|
|
||||||
CRC32B (SI), AX |
|
||||||
|
|
||||||
done: |
|
||||||
MOVL AX, ret+32(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// castagnoliSSE42Triple updates three (non-inverted) crcs with (24*rounds) |
|
||||||
// bytes from each buffer. |
|
||||||
// |
|
||||||
// func castagnoliSSE42Triple( |
|
||||||
// crc1, crc2, crc3 uint32, |
|
||||||
// a, b, c []byte, |
|
||||||
// rounds uint32, |
|
||||||
// ) (retA uint32, retB uint32, retC uint32) |
|
||||||
TEXT ·castagnoliSSE42Triple(SB), NOSPLIT, $0 |
|
||||||
MOVL crcA+0(FP), AX |
|
||||||
MOVL crcB+4(FP), CX |
|
||||||
MOVL crcC+8(FP), DX |
|
||||||
|
|
||||||
MOVQ a+16(FP), R8 // data pointer |
|
||||||
MOVQ b+40(FP), R9 // data pointer |
|
||||||
MOVQ c+64(FP), R10 // data pointer |
|
||||||
|
|
||||||
MOVL rounds+88(FP), R11 |
|
||||||
|
|
||||||
loop: |
|
||||||
CRC32Q (R8), AX |
|
||||||
CRC32Q (R9), CX |
|
||||||
CRC32Q (R10), DX |
|
||||||
|
|
||||||
CRC32Q 8(R8), AX |
|
||||||
CRC32Q 8(R9), CX |
|
||||||
CRC32Q 8(R10), DX |
|
||||||
|
|
||||||
CRC32Q 16(R8), AX |
|
||||||
CRC32Q 16(R9), CX |
|
||||||
CRC32Q 16(R10), DX |
|
||||||
|
|
||||||
ADDQ $24, R8 |
|
||||||
ADDQ $24, R9 |
|
||||||
ADDQ $24, R10 |
|
||||||
|
|
||||||
DECQ R11 |
|
||||||
JNZ loop |
|
||||||
|
|
||||||
MOVL AX, retA+96(FP) |
|
||||||
MOVL CX, retB+100(FP) |
|
||||||
MOVL DX, retC+104(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func haveSSE42() bool |
|
||||||
TEXT ·haveSSE42(SB), NOSPLIT, $0 |
|
||||||
XORQ AX, AX |
|
||||||
INCL AX |
|
||||||
CPUID |
|
||||||
SHRQ $20, CX |
|
||||||
ANDQ $1, CX |
|
||||||
MOVB CX, ret+0(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func haveCLMUL() bool |
|
||||||
TEXT ·haveCLMUL(SB), NOSPLIT, $0 |
|
||||||
XORQ AX, AX |
|
||||||
INCL AX |
|
||||||
CPUID |
|
||||||
SHRQ $1, CX |
|
||||||
ANDQ $1, CX |
|
||||||
MOVB CX, ret+0(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func haveSSE41() bool |
|
||||||
TEXT ·haveSSE41(SB), NOSPLIT, $0 |
|
||||||
XORQ AX, AX |
|
||||||
INCL AX |
|
||||||
CPUID |
|
||||||
SHRQ $19, CX |
|
||||||
ANDQ $1, CX |
|
||||||
MOVB CX, ret+0(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// CRC32 polynomial data |
|
||||||
// |
|
||||||
// These constants are lifted from the |
|
||||||
// Linux kernel, since they avoid the costly |
|
||||||
// PSHUFB 16 byte reversal proposed in the |
|
||||||
// original Intel paper. |
|
||||||
DATA r2r1kp<>+0(SB)/8, $0x154442bd4 |
|
||||||
DATA r2r1kp<>+8(SB)/8, $0x1c6e41596 |
|
||||||
DATA r4r3kp<>+0(SB)/8, $0x1751997d0 |
|
||||||
DATA r4r3kp<>+8(SB)/8, $0x0ccaa009e |
|
||||||
DATA rupolykp<>+0(SB)/8, $0x1db710641 |
|
||||||
DATA rupolykp<>+8(SB)/8, $0x1f7011641 |
|
||||||
DATA r5kp<>+0(SB)/8, $0x163cd6124 |
|
||||||
|
|
||||||
GLOBL r2r1kp<>(SB), RODATA, $16 |
|
||||||
GLOBL r4r3kp<>(SB), RODATA, $16 |
|
||||||
GLOBL rupolykp<>(SB), RODATA, $16 |
|
||||||
GLOBL r5kp<>(SB), RODATA, $8 |
|
||||||
|
|
||||||
// Based on http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf |
|
||||||
// len(p) must be at least 64, and must be a multiple of 16. |
|
||||||
|
|
||||||
// func ieeeCLMUL(crc uint32, p []byte) uint32 |
|
||||||
TEXT ·ieeeCLMUL(SB), NOSPLIT, $0 |
|
||||||
MOVL crc+0(FP), X0 // Initial CRC value |
|
||||||
MOVQ p+8(FP), SI // data pointer |
|
||||||
MOVQ p_len+16(FP), CX // len(p) |
|
||||||
|
|
||||||
MOVOU (SI), X1 |
|
||||||
MOVOU 16(SI), X2 |
|
||||||
MOVOU 32(SI), X3 |
|
||||||
MOVOU 48(SI), X4 |
|
||||||
PXOR X0, X1 |
|
||||||
ADDQ $64, SI // buf+=64 |
|
||||||
SUBQ $64, CX // len-=64 |
|
||||||
CMPQ CX, $64 // Less than 64 bytes left |
|
||||||
JB remain64 |
|
||||||
|
|
||||||
MOVOA r2r1kp<>+0(SB), X0 |
|
||||||
|
|
||||||
loopback64: |
|
||||||
MOVOA X1, X5 |
|
||||||
MOVOA X2, X6 |
|
||||||
MOVOA X3, X7 |
|
||||||
MOVOA X4, X8 |
|
||||||
|
|
||||||
PCLMULQDQ $0, X0, X1 |
|
||||||
PCLMULQDQ $0, X0, X2 |
|
||||||
PCLMULQDQ $0, X0, X3 |
|
||||||
PCLMULQDQ $0, X0, X4 |
|
||||||
|
|
||||||
// Load next early |
|
||||||
MOVOU (SI), X11 |
|
||||||
MOVOU 16(SI), X12 |
|
||||||
MOVOU 32(SI), X13 |
|
||||||
MOVOU 48(SI), X14 |
|
||||||
|
|
||||||
PCLMULQDQ $0x11, X0, X5 |
|
||||||
PCLMULQDQ $0x11, X0, X6 |
|
||||||
PCLMULQDQ $0x11, X0, X7 |
|
||||||
PCLMULQDQ $0x11, X0, X8 |
|
||||||
|
|
||||||
PXOR X5, X1 |
|
||||||
PXOR X6, X2 |
|
||||||
PXOR X7, X3 |
|
||||||
PXOR X8, X4 |
|
||||||
|
|
||||||
PXOR X11, X1 |
|
||||||
PXOR X12, X2 |
|
||||||
PXOR X13, X3 |
|
||||||
PXOR X14, X4 |
|
||||||
|
|
||||||
ADDQ $0x40, DI |
|
||||||
ADDQ $64, SI // buf+=64 |
|
||||||
SUBQ $64, CX // len-=64 |
|
||||||
CMPQ CX, $64 // Less than 64 bytes left? |
|
||||||
JGE loopback64 |
|
||||||
|
|
||||||
// Fold result into a single register (X1) |
|
||||||
remain64: |
|
||||||
MOVOA r4r3kp<>+0(SB), X0 |
|
||||||
|
|
||||||
MOVOA X1, X5 |
|
||||||
PCLMULQDQ $0, X0, X1 |
|
||||||
PCLMULQDQ $0x11, X0, X5 |
|
||||||
PXOR X5, X1 |
|
||||||
PXOR X2, X1 |
|
||||||
|
|
||||||
MOVOA X1, X5 |
|
||||||
PCLMULQDQ $0, X0, X1 |
|
||||||
PCLMULQDQ $0x11, X0, X5 |
|
||||||
PXOR X5, X1 |
|
||||||
PXOR X3, X1 |
|
||||||
|
|
||||||
MOVOA X1, X5 |
|
||||||
PCLMULQDQ $0, X0, X1 |
|
||||||
PCLMULQDQ $0x11, X0, X5 |
|
||||||
PXOR X5, X1 |
|
||||||
PXOR X4, X1 |
|
||||||
|
|
||||||
// If there is less than 16 bytes left we are done |
|
||||||
CMPQ CX, $16 |
|
||||||
JB finish |
|
||||||
|
|
||||||
// Encode 16 bytes |
|
||||||
remain16: |
|
||||||
MOVOU (SI), X10 |
|
||||||
MOVOA X1, X5 |
|
||||||
PCLMULQDQ $0, X0, X1 |
|
||||||
PCLMULQDQ $0x11, X0, X5 |
|
||||||
PXOR X5, X1 |
|
||||||
PXOR X10, X1 |
|
||||||
SUBQ $16, CX |
|
||||||
ADDQ $16, SI |
|
||||||
CMPQ CX, $16 |
|
||||||
JGE remain16 |
|
||||||
|
|
||||||
finish: |
|
||||||
// Fold final result into 32 bits and return it |
|
||||||
PCMPEQB X3, X3 |
|
||||||
PCLMULQDQ $1, X1, X0 |
|
||||||
PSRLDQ $8, X1 |
|
||||||
PXOR X0, X1 |
|
||||||
|
|
||||||
MOVOA X1, X2 |
|
||||||
MOVQ r5kp<>+0(SB), X0 |
|
||||||
|
|
||||||
// Creates 32 bit mask. Note that we don't care about upper half. |
|
||||||
PSRLQ $32, X3 |
|
||||||
|
|
||||||
PSRLDQ $4, X2 |
|
||||||
PAND X3, X1 |
|
||||||
PCLMULQDQ $0, X0, X1 |
|
||||||
PXOR X2, X1 |
|
||||||
|
|
||||||
MOVOA rupolykp<>+0(SB), X0 |
|
||||||
|
|
||||||
MOVOA X1, X2 |
|
||||||
PAND X3, X1 |
|
||||||
PCLMULQDQ $0x10, X0, X1 |
|
||||||
PAND X3, X1 |
|
||||||
PCLMULQDQ $0, X0, X1 |
|
||||||
PXOR X2, X1 |
|
||||||
|
|
||||||
// PEXTRD $1, X1, AX (SSE 4.1) |
|
||||||
BYTE $0x66; BYTE $0x0f; BYTE $0x3a
|
|
||||||
BYTE $0x16; BYTE $0xc8; BYTE $0x01
|
|
||||||
MOVL AX, ret+32(FP) |
|
||||||
|
|
||||||
RET |
|
||||||
@ -1,43 +0,0 @@ |
|||||||
// Copyright 2011 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.
|
|
||||||
|
|
||||||
// +build !appengine,!gccgo
|
|
||||||
|
|
||||||
package crc32 |
|
||||||
|
|
||||||
// This file contains the code to call the SSE 4.2 version of the Castagnoli
|
|
||||||
// CRC.
|
|
||||||
|
|
||||||
// haveSSE42 is defined in crc32_amd64p32.s and uses CPUID to test for SSE 4.2
|
|
||||||
// support.
|
|
||||||
func haveSSE42() bool |
|
||||||
|
|
||||||
// castagnoliSSE42 is defined in crc32_amd64p32.s and uses the SSE4.2 CRC32
|
|
||||||
// instruction.
|
|
||||||
//go:noescape
|
|
||||||
func castagnoliSSE42(crc uint32, p []byte) uint32 |
|
||||||
|
|
||||||
var sse42 = haveSSE42() |
|
||||||
|
|
||||||
func archAvailableCastagnoli() bool { |
|
||||||
return sse42 |
|
||||||
} |
|
||||||
|
|
||||||
func archInitCastagnoli() { |
|
||||||
if !sse42 { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
// No initialization necessary.
|
|
||||||
} |
|
||||||
|
|
||||||
func archUpdateCastagnoli(crc uint32, p []byte) uint32 { |
|
||||||
if !sse42 { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
return castagnoliSSE42(crc, p) |
|
||||||
} |
|
||||||
|
|
||||||
func archAvailableIEEE() bool { return false } |
|
||||||
func archInitIEEE() { panic("not available") } |
|
||||||
func archUpdateIEEE(crc uint32, p []byte) uint32 { panic("not available") } |
|
||||||
@ -1,67 +0,0 @@ |
|||||||
// Copyright 2011 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. |
|
||||||
|
|
||||||
// +build gc |
|
||||||
|
|
||||||
#define NOSPLIT 4 |
|
||||||
#define RODATA 8 |
|
||||||
|
|
||||||
// func castagnoliSSE42(crc uint32, p []byte) uint32 |
|
||||||
TEXT ·castagnoliSSE42(SB), NOSPLIT, $0 |
|
||||||
MOVL crc+0(FP), AX // CRC value |
|
||||||
MOVL p+4(FP), SI // data pointer |
|
||||||
MOVL p_len+8(FP), CX // len(p) |
|
||||||
|
|
||||||
NOTL AX |
|
||||||
|
|
||||||
// If there's less than 8 bytes to process, we do it byte-by-byte. |
|
||||||
CMPQ CX, $8 |
|
||||||
JL cleanup |
|
||||||
|
|
||||||
// Process individual bytes until the input is 8-byte aligned. |
|
||||||
startup: |
|
||||||
MOVQ SI, BX |
|
||||||
ANDQ $7, BX |
|
||||||
JZ aligned |
|
||||||
|
|
||||||
CRC32B (SI), AX |
|
||||||
DECQ CX |
|
||||||
INCQ SI |
|
||||||
JMP startup |
|
||||||
|
|
||||||
aligned: |
|
||||||
// The input is now 8-byte aligned and we can process 8-byte chunks. |
|
||||||
CMPQ CX, $8 |
|
||||||
JL cleanup |
|
||||||
|
|
||||||
CRC32Q (SI), AX |
|
||||||
ADDQ $8, SI |
|
||||||
SUBQ $8, CX |
|
||||||
JMP aligned |
|
||||||
|
|
||||||
cleanup: |
|
||||||
// We may have some bytes left over that we process one at a time. |
|
||||||
CMPQ CX, $0 |
|
||||||
JE done |
|
||||||
|
|
||||||
CRC32B (SI), AX |
|
||||||
INCQ SI |
|
||||||
DECQ CX |
|
||||||
JMP cleanup |
|
||||||
|
|
||||||
done: |
|
||||||
NOTL AX |
|
||||||
MOVL AX, ret+16(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
// func haveSSE42() bool |
|
||||||
TEXT ·haveSSE42(SB), NOSPLIT, $0 |
|
||||||
XORQ AX, AX |
|
||||||
INCL AX |
|
||||||
CPUID |
|
||||||
SHRQ $20, CX |
|
||||||
ANDQ $1, CX |
|
||||||
MOVB CX, ret+0(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
@ -1,89 +0,0 @@ |
|||||||
// Copyright 2011 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.
|
|
||||||
|
|
||||||
// This file contains CRC32 algorithms that are not specific to any architecture
|
|
||||||
// and don't use hardware acceleration.
|
|
||||||
//
|
|
||||||
// The simple (and slow) CRC32 implementation only uses a 256*4 bytes table.
|
|
||||||
//
|
|
||||||
// The slicing-by-8 algorithm is a faster implementation that uses a bigger
|
|
||||||
// table (8*256*4 bytes).
|
|
||||||
|
|
||||||
package crc32 |
|
||||||
|
|
||||||
// simpleMakeTable allocates and constructs a Table for the specified
|
|
||||||
// polynomial. The table is suitable for use with the simple algorithm
|
|
||||||
// (simpleUpdate).
|
|
||||||
func simpleMakeTable(poly uint32) *Table { |
|
||||||
t := new(Table) |
|
||||||
simplePopulateTable(poly, t) |
|
||||||
return t |
|
||||||
} |
|
||||||
|
|
||||||
// simplePopulateTable constructs a Table for the specified polynomial, suitable
|
|
||||||
// for use with simpleUpdate.
|
|
||||||
func simplePopulateTable(poly uint32, t *Table) { |
|
||||||
for i := 0; i < 256; i++ { |
|
||||||
crc := uint32(i) |
|
||||||
for j := 0; j < 8; j++ { |
|
||||||
if crc&1 == 1 { |
|
||||||
crc = (crc >> 1) ^ poly |
|
||||||
} else { |
|
||||||
crc >>= 1 |
|
||||||
} |
|
||||||
} |
|
||||||
t[i] = crc |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// simpleUpdate uses the simple algorithm to update the CRC, given a table that
|
|
||||||
// was previously computed using simpleMakeTable.
|
|
||||||
func simpleUpdate(crc uint32, tab *Table, p []byte) uint32 { |
|
||||||
crc = ^crc |
|
||||||
for _, v := range p { |
|
||||||
crc = tab[byte(crc)^v] ^ (crc >> 8) |
|
||||||
} |
|
||||||
return ^crc |
|
||||||
} |
|
||||||
|
|
||||||
// Use slicing-by-8 when payload >= this value.
|
|
||||||
const slicing8Cutoff = 16 |
|
||||||
|
|
||||||
// slicing8Table is array of 8 Tables, used by the slicing-by-8 algorithm.
|
|
||||||
type slicing8Table [8]Table |
|
||||||
|
|
||||||
// slicingMakeTable constructs a slicing8Table for the specified polynomial. The
|
|
||||||
// table is suitable for use with the slicing-by-8 algorithm (slicingUpdate).
|
|
||||||
func slicingMakeTable(poly uint32) *slicing8Table { |
|
||||||
t := new(slicing8Table) |
|
||||||
simplePopulateTable(poly, &t[0]) |
|
||||||
for i := 0; i < 256; i++ { |
|
||||||
crc := t[0][i] |
|
||||||
for j := 1; j < 8; j++ { |
|
||||||
crc = t[0][crc&0xFF] ^ (crc >> 8) |
|
||||||
t[j][i] = crc |
|
||||||
} |
|
||||||
} |
|
||||||
return t |
|
||||||
} |
|
||||||
|
|
||||||
// slicingUpdate uses the slicing-by-8 algorithm to update the CRC, given a
|
|
||||||
// table that was previously computed using slicingMakeTable.
|
|
||||||
func slicingUpdate(crc uint32, tab *slicing8Table, p []byte) uint32 { |
|
||||||
if len(p) >= slicing8Cutoff { |
|
||||||
crc = ^crc |
|
||||||
for len(p) > 8 { |
|
||||||
crc ^= uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24 |
|
||||||
crc = tab[0][p[7]] ^ tab[1][p[6]] ^ tab[2][p[5]] ^ tab[3][p[4]] ^ |
|
||||||
tab[4][crc>>24] ^ tab[5][(crc>>16)&0xFF] ^ |
|
||||||
tab[6][(crc>>8)&0xFF] ^ tab[7][crc&0xFF] |
|
||||||
p = p[8:] |
|
||||||
} |
|
||||||
crc = ^crc |
|
||||||
} |
|
||||||
if len(p) == 0 { |
|
||||||
return crc |
|
||||||
} |
|
||||||
return simpleUpdate(crc, &tab[0], p) |
|
||||||
} |
|
||||||
@ -1,15 +0,0 @@ |
|||||||
// Copyright 2011 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.
|
|
||||||
|
|
||||||
// +build !amd64,!amd64p32,!s390x
|
|
||||||
|
|
||||||
package crc32 |
|
||||||
|
|
||||||
func archAvailableIEEE() bool { return false } |
|
||||||
func archInitIEEE() { panic("not available") } |
|
||||||
func archUpdateIEEE(crc uint32, p []byte) uint32 { panic("not available") } |
|
||||||
|
|
||||||
func archAvailableCastagnoli() bool { return false } |
|
||||||
func archInitCastagnoli() { panic("not available") } |
|
||||||
func archUpdateCastagnoli(crc uint32, p []byte) uint32 { panic("not available") } |
|
||||||
@ -1,91 +0,0 @@ |
|||||||
// Copyright 2016 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.
|
|
||||||
|
|
||||||
// +build s390x
|
|
||||||
|
|
||||||
package crc32 |
|
||||||
|
|
||||||
const ( |
|
||||||
vxMinLen = 64 |
|
||||||
vxAlignMask = 15 // align to 16 bytes
|
|
||||||
) |
|
||||||
|
|
||||||
// hasVectorFacility reports whether the machine has the z/Architecture
|
|
||||||
// vector facility installed and enabled.
|
|
||||||
func hasVectorFacility() bool |
|
||||||
|
|
||||||
var hasVX = hasVectorFacility() |
|
||||||
|
|
||||||
// vectorizedCastagnoli implements CRC32 using vector instructions.
|
|
||||||
// It is defined in crc32_s390x.s.
|
|
||||||
//go:noescape
|
|
||||||
func vectorizedCastagnoli(crc uint32, p []byte) uint32 |
|
||||||
|
|
||||||
// vectorizedIEEE implements CRC32 using vector instructions.
|
|
||||||
// It is defined in crc32_s390x.s.
|
|
||||||
//go:noescape
|
|
||||||
func vectorizedIEEE(crc uint32, p []byte) uint32 |
|
||||||
|
|
||||||
func archAvailableCastagnoli() bool { |
|
||||||
return hasVX |
|
||||||
} |
|
||||||
|
|
||||||
var archCastagnoliTable8 *slicing8Table |
|
||||||
|
|
||||||
func archInitCastagnoli() { |
|
||||||
if !hasVX { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
// We still use slicing-by-8 for small buffers.
|
|
||||||
archCastagnoliTable8 = slicingMakeTable(Castagnoli) |
|
||||||
} |
|
||||||
|
|
||||||
// archUpdateCastagnoli calculates the checksum of p using
|
|
||||||
// vectorizedCastagnoli.
|
|
||||||
func archUpdateCastagnoli(crc uint32, p []byte) uint32 { |
|
||||||
if !hasVX { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
// Use vectorized function if data length is above threshold.
|
|
||||||
if len(p) >= vxMinLen { |
|
||||||
aligned := len(p) & ^vxAlignMask |
|
||||||
crc = vectorizedCastagnoli(crc, p[:aligned]) |
|
||||||
p = p[aligned:] |
|
||||||
} |
|
||||||
if len(p) == 0 { |
|
||||||
return crc |
|
||||||
} |
|
||||||
return slicingUpdate(crc, archCastagnoliTable8, p) |
|
||||||
} |
|
||||||
|
|
||||||
func archAvailableIEEE() bool { |
|
||||||
return hasVX |
|
||||||
} |
|
||||||
|
|
||||||
var archIeeeTable8 *slicing8Table |
|
||||||
|
|
||||||
func archInitIEEE() { |
|
||||||
if !hasVX { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
// We still use slicing-by-8 for small buffers.
|
|
||||||
archIeeeTable8 = slicingMakeTable(IEEE) |
|
||||||
} |
|
||||||
|
|
||||||
// archUpdateIEEE calculates the checksum of p using vectorizedIEEE.
|
|
||||||
func archUpdateIEEE(crc uint32, p []byte) uint32 { |
|
||||||
if !hasVX { |
|
||||||
panic("not available") |
|
||||||
} |
|
||||||
// Use vectorized function if data length is above threshold.
|
|
||||||
if len(p) >= vxMinLen { |
|
||||||
aligned := len(p) & ^vxAlignMask |
|
||||||
crc = vectorizedIEEE(crc, p[:aligned]) |
|
||||||
p = p[aligned:] |
|
||||||
} |
|
||||||
if len(p) == 0 { |
|
||||||
return crc |
|
||||||
} |
|
||||||
return slicingUpdate(crc, archIeeeTable8, p) |
|
||||||
} |
|
||||||
@ -1,249 +0,0 @@ |
|||||||
// Copyright 2016 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. |
|
||||||
|
|
||||||
// +build s390x |
|
||||||
|
|
||||||
#include "textflag.h" |
|
||||||
|
|
||||||
// Vector register range containing CRC-32 constants |
|
||||||
|
|
||||||
#define CONST_PERM_LE2BE V9 |
|
||||||
#define CONST_R2R1 V10 |
|
||||||
#define CONST_R4R3 V11 |
|
||||||
#define CONST_R5 V12 |
|
||||||
#define CONST_RU_POLY V13 |
|
||||||
#define CONST_CRC_POLY V14 |
|
||||||
|
|
||||||
// The CRC-32 constant block contains reduction constants to fold and |
|
||||||
// process particular chunks of the input data stream in parallel. |
|
||||||
// |
|
||||||
// Note that the constant definitions below are extended in order to compute |
|
||||||
// intermediate results with a single VECTOR GALOIS FIELD MULTIPLY instruction. |
|
||||||
// The rightmost doubleword can be 0 to prevent contribution to the result or |
|
||||||
// can be multiplied by 1 to perform an XOR without the need for a separate |
|
||||||
// VECTOR EXCLUSIVE OR instruction. |
|
||||||
// |
|
||||||
// The polynomials used are bit-reflected: |
|
||||||
// |
|
||||||
// IEEE: P'(x) = 0x0edb88320 |
|
||||||
// Castagnoli: P'(x) = 0x082f63b78 |
|
||||||
|
|
||||||
// IEEE polynomial constants |
|
||||||
DATA ·crcleconskp+0(SB)/8, $0x0F0E0D0C0B0A0908 // LE-to-BE mask |
|
||||||
DATA ·crcleconskp+8(SB)/8, $0x0706050403020100 |
|
||||||
DATA ·crcleconskp+16(SB)/8, $0x00000001c6e41596 // R2 |
|
||||||
DATA ·crcleconskp+24(SB)/8, $0x0000000154442bd4 // R1 |
|
||||||
DATA ·crcleconskp+32(SB)/8, $0x00000000ccaa009e // R4 |
|
||||||
DATA ·crcleconskp+40(SB)/8, $0x00000001751997d0 // R3 |
|
||||||
DATA ·crcleconskp+48(SB)/8, $0x0000000000000000 |
|
||||||
DATA ·crcleconskp+56(SB)/8, $0x0000000163cd6124 // R5 |
|
||||||
DATA ·crcleconskp+64(SB)/8, $0x0000000000000000 |
|
||||||
DATA ·crcleconskp+72(SB)/8, $0x00000001F7011641 // u' |
|
||||||
DATA ·crcleconskp+80(SB)/8, $0x0000000000000000 |
|
||||||
DATA ·crcleconskp+88(SB)/8, $0x00000001DB710641 // P'(x) << 1 |
|
||||||
|
|
||||||
GLOBL ·crcleconskp(SB), RODATA, $144 |
|
||||||
|
|
||||||
// Castagonli Polynomial constants |
|
||||||
DATA ·crccleconskp+0(SB)/8, $0x0F0E0D0C0B0A0908 // LE-to-BE mask |
|
||||||
DATA ·crccleconskp+8(SB)/8, $0x0706050403020100 |
|
||||||
DATA ·crccleconskp+16(SB)/8, $0x000000009e4addf8 // R2 |
|
||||||
DATA ·crccleconskp+24(SB)/8, $0x00000000740eef02 // R1 |
|
||||||
DATA ·crccleconskp+32(SB)/8, $0x000000014cd00bd6 // R4 |
|
||||||
DATA ·crccleconskp+40(SB)/8, $0x00000000f20c0dfe // R3 |
|
||||||
DATA ·crccleconskp+48(SB)/8, $0x0000000000000000 |
|
||||||
DATA ·crccleconskp+56(SB)/8, $0x00000000dd45aab8 // R5 |
|
||||||
DATA ·crccleconskp+64(SB)/8, $0x0000000000000000 |
|
||||||
DATA ·crccleconskp+72(SB)/8, $0x00000000dea713f1 // u' |
|
||||||
DATA ·crccleconskp+80(SB)/8, $0x0000000000000000 |
|
||||||
DATA ·crccleconskp+88(SB)/8, $0x0000000105ec76f0 // P'(x) << 1 |
|
||||||
|
|
||||||
GLOBL ·crccleconskp(SB), RODATA, $144 |
|
||||||
|
|
||||||
// func hasVectorFacility() bool |
|
||||||
TEXT ·hasVectorFacility(SB), NOSPLIT, $24-1 |
|
||||||
MOVD $x-24(SP), R1 |
|
||||||
XC $24, 0(R1), 0(R1) // clear the storage |
|
||||||
MOVD $2, R0 // R0 is the number of double words stored -1 |
|
||||||
WORD $0xB2B01000 // STFLE 0(R1) |
|
||||||
XOR R0, R0 // reset the value of R0 |
|
||||||
MOVBZ z-8(SP), R1 |
|
||||||
AND $0x40, R1 |
|
||||||
BEQ novector |
|
||||||
|
|
||||||
vectorinstalled: |
|
||||||
// check if the vector instruction has been enabled |
|
||||||
VLEIB $0, $0xF, V16 |
|
||||||
VLGVB $0, V16, R1 |
|
||||||
CMPBNE R1, $0xF, novector |
|
||||||
MOVB $1, ret+0(FP) // have vx |
|
||||||
RET |
|
||||||
|
|
||||||
novector: |
|
||||||
MOVB $0, ret+0(FP) // no vx |
|
||||||
RET |
|
||||||
|
|
||||||
// The CRC-32 function(s) use these calling conventions: |
|
||||||
// |
|
||||||
// Parameters: |
|
||||||
// |
|
||||||
// R2: Initial CRC value, typically ~0; and final CRC (return) value.
|
|
||||||
// R3: Input buffer pointer, performance might be improved if the |
|
||||||
// buffer is on a doubleword boundary. |
|
||||||
// R4: Length of the buffer, must be 64 bytes or greater. |
|
||||||
// |
|
||||||
// Register usage: |
|
||||||
// |
|
||||||
// R5: CRC-32 constant pool base pointer. |
|
||||||
// V0: Initial CRC value and intermediate constants and results. |
|
||||||
// V1..V4: Data for CRC computation. |
|
||||||
// V5..V8: Next data chunks that are fetched from the input buffer. |
|
||||||
// |
|
||||||
// V9..V14: CRC-32 constants. |
|
||||||
|
|
||||||
// func vectorizedIEEE(crc uint32, p []byte) uint32 |
|
||||||
TEXT ·vectorizedIEEE(SB), NOSPLIT, $0 |
|
||||||
MOVWZ crc+0(FP), R2 // R2 stores the CRC value |
|
||||||
MOVD p+8(FP), R3 // data pointer |
|
||||||
MOVD p_len+16(FP), R4 // len(p) |
|
||||||
|
|
||||||
MOVD $·crcleconskp(SB), R5 |
|
||||||
BR vectorizedBody<>(SB) |
|
||||||
|
|
||||||
// func vectorizedCastagnoli(crc uint32, p []byte) uint32 |
|
||||||
TEXT ·vectorizedCastagnoli(SB), NOSPLIT, $0 |
|
||||||
MOVWZ crc+0(FP), R2 // R2 stores the CRC value |
|
||||||
MOVD p+8(FP), R3 // data pointer |
|
||||||
MOVD p_len+16(FP), R4 // len(p) |
|
||||||
|
|
||||||
// R5: crc-32 constant pool base pointer, constant is used to reduce crc |
|
||||||
MOVD $·crccleconskp(SB), R5 |
|
||||||
BR vectorizedBody<>(SB) |
|
||||||
|
|
||||||
TEXT vectorizedBody<>(SB), NOSPLIT, $0 |
|
||||||
XOR $0xffffffff, R2 // NOTW R2 |
|
||||||
VLM 0(R5), CONST_PERM_LE2BE, CONST_CRC_POLY |
|
||||||
|
|
||||||
// Load the initial CRC value into the rightmost word of V0 |
|
||||||
VZERO V0 |
|
||||||
VLVGF $3, R2, V0 |
|
||||||
|
|
||||||
// Crash if the input size is less than 64-bytes. |
|
||||||
CMP R4, $64 |
|
||||||
BLT crash |
|
||||||
|
|
||||||
// Load a 64-byte data chunk and XOR with CRC |
|
||||||
VLM 0(R3), V1, V4 // 64-bytes into V1..V4 |
|
||||||
|
|
||||||
// Reflect the data if the CRC operation is in the bit-reflected domain |
|
||||||
VPERM V1, V1, CONST_PERM_LE2BE, V1 |
|
||||||
VPERM V2, V2, CONST_PERM_LE2BE, V2 |
|
||||||
VPERM V3, V3, CONST_PERM_LE2BE, V3 |
|
||||||
VPERM V4, V4, CONST_PERM_LE2BE, V4 |
|
||||||
|
|
||||||
VX V0, V1, V1 // V1 ^= CRC |
|
||||||
ADD $64, R3 // BUF = BUF + 64 |
|
||||||
ADD $(-64), R4 |
|
||||||
|
|
||||||
// Check remaining buffer size and jump to proper folding method |
|
||||||
CMP R4, $64 |
|
||||||
BLT less_than_64bytes |
|
||||||
|
|
||||||
fold_64bytes_loop: |
|
||||||
// Load the next 64-byte data chunk into V5 to V8 |
|
||||||
VLM 0(R3), V5, V8 |
|
||||||
VPERM V5, V5, CONST_PERM_LE2BE, V5 |
|
||||||
VPERM V6, V6, CONST_PERM_LE2BE, V6 |
|
||||||
VPERM V7, V7, CONST_PERM_LE2BE, V7 |
|
||||||
VPERM V8, V8, CONST_PERM_LE2BE, V8 |
|
||||||
|
|
||||||
// Perform a GF(2) multiplication of the doublewords in V1 with |
|
||||||
// the reduction constants in V0. The intermediate result is |
|
||||||
// then folded (accumulated) with the next data chunk in V5 and |
|
||||||
// stored in V1. Repeat this step for the register contents |
|
||||||
// in V2, V3, and V4 respectively. |
|
||||||
|
|
||||||
VGFMAG CONST_R2R1, V1, V5, V1 |
|
||||||
VGFMAG CONST_R2R1, V2, V6, V2 |
|
||||||
VGFMAG CONST_R2R1, V3, V7, V3 |
|
||||||
VGFMAG CONST_R2R1, V4, V8, V4 |
|
||||||
|
|
||||||
// Adjust buffer pointer and length for next loop |
|
||||||
ADD $64, R3 // BUF = BUF + 64 |
|
||||||
ADD $(-64), R4 // LEN = LEN - 64 |
|
||||||
|
|
||||||
CMP R4, $64 |
|
||||||
BGE fold_64bytes_loop |
|
||||||
|
|
||||||
less_than_64bytes: |
|
||||||
// Fold V1 to V4 into a single 128-bit value in V1 |
|
||||||
VGFMAG CONST_R4R3, V1, V2, V1 |
|
||||||
VGFMAG CONST_R4R3, V1, V3, V1 |
|
||||||
VGFMAG CONST_R4R3, V1, V4, V1 |
|
||||||
|
|
||||||
// Check whether to continue with 64-bit folding |
|
||||||
CMP R4, $16 |
|
||||||
BLT final_fold |
|
||||||
|
|
||||||
fold_16bytes_loop: |
|
||||||
VL 0(R3), V2 // Load next data chunk |
|
||||||
VPERM V2, V2, CONST_PERM_LE2BE, V2 |
|
||||||
|
|
||||||
VGFMAG CONST_R4R3, V1, V2, V1 // Fold next data chunk |
|
||||||
|
|
||||||
// Adjust buffer pointer and size for folding next data chunk |
|
||||||
ADD $16, R3 |
|
||||||
ADD $-16, R4 |
|
||||||
|
|
||||||
// Process remaining data chunks |
|
||||||
CMP R4, $16 |
|
||||||
BGE fold_16bytes_loop |
|
||||||
|
|
||||||
final_fold: |
|
||||||
VLEIB $7, $0x40, V9 |
|
||||||
VSRLB V9, CONST_R4R3, V0 |
|
||||||
VLEIG $0, $1, V0 |
|
||||||
|
|
||||||
VGFMG V0, V1, V1 |
|
||||||
|
|
||||||
VLEIB $7, $0x20, V9 // Shift by words |
|
||||||
VSRLB V9, V1, V2 // Store remaining bits in V2 |
|
||||||
VUPLLF V1, V1 // Split rightmost doubleword |
|
||||||
VGFMAG CONST_R5, V1, V2, V1 // V1 = (V1 * R5) XOR V2 |
|
||||||
|
|
||||||
// The input values to the Barret reduction are the degree-63 polynomial |
|
||||||
// in V1 (R(x)), degree-32 generator polynomial, and the reduction |
|
||||||
// constant u. The Barret reduction result is the CRC value of R(x) mod |
|
||||||
// P(x). |
|
||||||
// |
|
||||||
// The Barret reduction algorithm is defined as: |
|
||||||
// |
|
||||||
// 1. T1(x) = floor( R(x) / x^32 ) GF2MUL u |
|
||||||
// 2. T2(x) = floor( T1(x) / x^32 ) GF2MUL P(x) |
|
||||||
// 3. C(x) = R(x) XOR T2(x) mod x^32 |
|
||||||
// |
|
||||||
// Note: To compensate the division by x^32, use the vector unpack |
|
||||||
// instruction to move the leftmost word into the leftmost doubleword |
|
||||||
// of the vector register. The rightmost doubleword is multiplied |
|
||||||
// with zero to not contribute to the intermedate results. |
|
||||||
|
|
||||||
// T1(x) = floor( R(x) / x^32 ) GF2MUL u |
|
||||||
VUPLLF V1, V2 |
|
||||||
VGFMG CONST_RU_POLY, V2, V2 |
|
||||||
|
|
||||||
// Compute the GF(2) product of the CRC polynomial in VO with T1(x) in |
|
||||||
// V2 and XOR the intermediate result, T2(x), with the value in V1. |
|
||||||
// The final result is in the rightmost word of V2. |
|
||||||
|
|
||||||
VUPLLF V2, V2 |
|
||||||
VGFMAG CONST_CRC_POLY, V2, V1, V2 |
|
||||||
|
|
||||||
done: |
|
||||||
VLGVF $2, V2, R2 |
|
||||||
XOR $0xffffffff, R2 // NOTW R2 |
|
||||||
MOVWZ R2, ret + 32(FP) |
|
||||||
RET |
|
||||||
|
|
||||||
crash: |
|
||||||
MOVD $0, (R0) // input size is less than 64-bytes |
|
||||||
Loading…
Reference in new issue