libgo: update to go1.7rc3

    
    Reviewed-on: https://go-review.googlesource.com/25150

From-SVN: r238662

9 files changed, 306 insertions, 83 deletions

diff --git a/libgo/go/hash/adler32/adler32.go b/libgo/go/hash/adler32/adler32.go
index 0c733f7..21d6a2e 100644
--- a/libgo/go/hash/adler32/adler32.go
+++ b/libgo/go/hash/adler32/adler32.go
@@ -42,7 +42,7 @@ func New() hash.Hash32 {
 
 func (d *digest) Size() int { return Size }
 
-func (d *digest) BlockSize() int { return 1 }
+func (d *digest) BlockSize() int { return 4 }
 
 // Add p to the running checksum d.
 func update(d digest, p []byte) digest {
@@ -52,6 +52,17 @@ func update(d digest, p []byte) digest {
 		if len(p) > nmax {
 			p, q = p[:nmax], p[nmax:]
 		}
+		for len(p) >= 4 {
+			s1 += uint32(p[0])
+			s2 += s1
+			s1 += uint32(p[1])
+			s2 += s1
+			s1 += uint32(p[2])
+			s2 += s1
+			s1 += uint32(p[3])
+			s2 += s1
+			p = p[4:]
+		}
 		for _, x := range p {
 			s1 += uint32(x)
 			s2 += s1
diff --git a/libgo/go/hash/crc32/crc32.go b/libgo/go/hash/crc32/crc32.go
index dc59948..c3ac7b8 100644
--- a/libgo/go/hash/crc32/crc32.go
+++ b/libgo/go/hash/crc32/crc32.go
@@ -20,6 +20,9 @@ import (
 // The size of a CRC-32 checksum in bytes.
 const Size = 4
 
+// Use "slice by 8" when payload >= this value.
+const sliceBy8Cutoff = 16
+
 // Predefined polynomials.
 const (
 	// IEEE is by far and away the most common CRC-32 polynomial.
@@ -45,10 +48,12 @@ type Table [256]uint32
 // Castagnoli table so we can compare against it to find when the caller is
 // using this polynomial.
 var castagnoliTable *Table
+var castagnoliTable8 *slicing8Table
 var castagnoliOnce sync.Once
 
 func castagnoliInit() {
 	castagnoliTable = makeTable(Castagnoli)
+	castagnoliTable8 = makeTable8(Castagnoli)
 }
 
 // IEEETable is the table for the IEEE polynomial.
@@ -146,6 +151,9 @@ func updateSlicingBy8(crc uint32, tab *slicing8Table, p []byte) uint32 {
 		p = p[8:]
 	}
 	crc = ^crc
+	if len(p) == 0 {
+		return crc
+	}
 	return update(crc, &tab[0], p)
 }
 
@@ -178,4 +186,4 @@ 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 { return Update(0, IEEETable, data) }
+func ChecksumIEEE(data []byte) uint32 { return updateIEEE(0, data) }
diff --git a/libgo/go/hash/crc32/crc32_amd64.go b/libgo/go/hash/crc32/crc32_amd64.go
index ab4e2b8..a0180a1 100644
--- a/libgo/go/hash/crc32/crc32_amd64.go
+++ b/libgo/go/hash/crc32/crc32_amd64.go
@@ -30,6 +30,10 @@ func updateCastagnoli(crc uint32, p []byte) uint32 {
 	if sse42 {
 		return castagnoliSSE42(crc, p)
 	}
+	// Use slicing-by-8 on larger inputs.
+	if len(p) >= sliceBy8Cutoff {
+		return updateSlicingBy8(crc, castagnoliTable8, p)
+	}
 	return update(crc, castagnoliTable, p)
 }
 
@@ -44,8 +48,8 @@ func updateIEEE(crc uint32, p []byte) uint32 {
 		return crc
 	}
 
-	// only use slicing-by-8 when input is >= 4KB
-	if len(p) >= 4096 {
+	// Use slicing-by-8 on larger inputs.
+	if len(p) >= sliceBy8Cutoff {
 		ieeeTable8Once.Do(func() {
 			ieeeTable8 = makeTable8(IEEE)
 		})
diff --git a/libgo/go/hash/crc32/crc32_amd64p32.go b/libgo/go/hash/crc32/crc32_amd64p32.go
index 067fbb1..1f6cd34 100644
--- a/libgo/go/hash/crc32/crc32_amd64p32.go
+++ b/libgo/go/hash/crc32/crc32_amd64p32.go
@@ -22,12 +22,16 @@ func updateCastagnoli(crc uint32, p []byte) uint32 {
 	if sse42 {
 		return castagnoliSSE42(crc, p)
 	}
+	// Use slicing-by-8 on larger inputs.
+	if len(p) >= sliceBy8Cutoff {
+		return updateSlicingBy8(crc, castagnoliTable8, p)
+	}
 	return update(crc, castagnoliTable, p)
 }
 
 func updateIEEE(crc uint32, p []byte) uint32 {
-	// only use slicing-by-8 when input is >= 4KB
-	if len(p) >= 4096 {
+	// Use slicing-by-8 on larger inputs.
+	if len(p) >= sliceBy8Cutoff {
 		ieeeTable8Once.Do(func() {
 			ieeeTable8 = makeTable8(IEEE)
 		})
diff --git a/libgo/go/hash/crc32/crc32_generic.go b/libgo/go/hash/crc32/crc32_generic.go
index 8fc11a7..10a6367 100644
--- a/libgo/go/hash/crc32/crc32_generic.go
+++ b/libgo/go/hash/crc32/crc32_generic.go
@@ -2,20 +2,24 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build 386 arm arm64 mips64 mips64le ppc64 ppc64le
+// +build !amd64,!amd64p32,!s390x
 
 package crc32
 
-// The file contains the generic version of updateCastagnoli which just calls
-// the software implementation.
+// This file contains the generic version of updateCastagnoli which does
+// slicing-by-8, or uses the fallback for very small sizes.
 
 func updateCastagnoli(crc uint32, p []byte) uint32 {
+	// Use slicing-by-8 on larger inputs.
+	if len(p) >= sliceBy8Cutoff {
+		return updateSlicingBy8(crc, castagnoliTable8, p)
+	}
 	return update(crc, castagnoliTable, p)
 }
 
 func updateIEEE(crc uint32, p []byte) uint32 {
-	// only use slicing-by-8 when input is >= 4KB
-	if len(p) >= 4096 {
+	// Use slicing-by-8 on larger inputs.
+	if len(p) >= sliceBy8Cutoff {
 		ieeeTable8Once.Do(func() {
 			ieeeTable8 = makeTable8(IEEE)
 		})
diff --git a/libgo/go/hash/crc32/crc32_s390x.go b/libgo/go/hash/crc32/crc32_s390x.go
new file mode 100644
index 0000000..2f20690
--- /dev/null
+++ b/libgo/go/hash/crc32/crc32_s390x.go
@@ -0,0 +1,101 @@
+// 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.
+
+package crc32
+
+import (
+	"unsafe"
+)
+
+const (
+	vxMinLen    = 64
+	vxAlignment = 16
+	vxAlignMask = vxAlignment - 1
+)
+
+// 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 genericCastagnoli(crc uint32, p []byte) uint32 {
+	// Use slicing-by-8 on larger inputs.
+	if len(p) >= sliceBy8Cutoff {
+		return updateSlicingBy8(crc, castagnoliTable8, p)
+	}
+	return update(crc, castagnoliTable, p)
+}
+
+func genericIEEE(crc uint32, p []byte) uint32 {
+	// Use slicing-by-8 on larger inputs.
+	if len(p) >= sliceBy8Cutoff {
+		ieeeTable8Once.Do(func() {
+			ieeeTable8 = makeTable8(IEEE)
+		})
+		return updateSlicingBy8(crc, ieeeTable8, p)
+	}
+	return update(crc, IEEETable, p)
+}
+
+// updateCastagnoli calculates the checksum of p using genericCastagnoli to
+// align the data appropriately for vectorCastagnoli. It avoids using
+// vectorCastagnoli entirely if the length of p is less than or equal to
+// vxMinLen.
+func updateCastagnoli(crc uint32, p []byte) uint32 {
+	// Use vectorized function if vector facility is available and
+	// data length is above threshold.
+	if hasVX && len(p) > vxMinLen {
+		pAddr := uintptr(unsafe.Pointer(&p[0]))
+		if pAddr&vxAlignMask != 0 {
+			prealign := vxAlignment - int(pAddr&vxAlignMask)
+			crc = genericCastagnoli(crc, p[:prealign])
+			p = p[prealign:]
+		}
+		aligned := len(p) & ^vxAlignMask
+		crc = vectorizedCastagnoli(crc, p[:aligned])
+		p = p[aligned:]
+		// process remaining data
+		if len(p) > 0 {
+			crc = genericCastagnoli(crc, p)
+		}
+		return crc
+	}
+	return genericCastagnoli(crc, p)
+}
+
+// updateIEEE calculates the checksum of p using genericIEEE to align the data
+// appropriately for vectorIEEE. It avoids using vectorIEEE entirely if the length
+// of p is less than or equal to vxMinLen.
+func updateIEEE(crc uint32, p []byte) uint32 {
+	// Use vectorized function if vector facility is available and
+	// data length is above threshold.
+	if hasVX && len(p) > vxMinLen {
+		pAddr := uintptr(unsafe.Pointer(&p[0]))
+		if pAddr&vxAlignMask != 0 {
+			prealign := vxAlignment - int(pAddr&vxAlignMask)
+			crc = genericIEEE(crc, p[:prealign])
+			p = p[prealign:]
+		}
+		aligned := len(p) & ^vxAlignMask
+		crc = vectorizedIEEE(crc, p[:aligned])
+		p = p[aligned:]
+		// process remaining data
+		if len(p) > 0 {
+			crc = genericIEEE(crc, p)
+		}
+		return crc
+	}
+	return genericIEEE(crc, p)
+}
diff --git a/libgo/go/hash/crc32/crc32_test.go b/libgo/go/hash/crc32/crc32_test.go
index 1ca3ac2..e2b3557 100644
--- a/libgo/go/hash/crc32/crc32_test.go
+++ b/libgo/go/hash/crc32/crc32_test.go
@@ -5,6 +5,7 @@
 package crc32
 
 import (
+	"hash"
 	"io"
 	"testing"
 )
@@ -81,49 +82,51 @@ func TestGolden(t *testing.T) {
 	}
 }
 
-func BenchmarkIEEECrc1KB(b *testing.B) {
-	b.SetBytes(1024)
-	data := make([]byte, 1024)
-	for i := range data {
-		data[i] = byte(i)
-	}
-	h := NewIEEE()
-	in := make([]byte, 0, h.Size())
+func BenchmarkIEEECrc40B(b *testing.B) {
+	benchmark(b, NewIEEE(), 40)
+}
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		h.Reset()
-		h.Write(data)
-		h.Sum(in)
-	}
+func BenchmarkIEEECrc1KB(b *testing.B) {
+	benchmark(b, NewIEEE(), 1<<10)
 }
 
 func BenchmarkIEEECrc4KB(b *testing.B) {
-	b.SetBytes(4096)
-	data := make([]byte, 4096)
-	for i := range data {
-		data[i] = byte(i)
-	}
-	h := NewIEEE()
-	in := make([]byte, 0, h.Size())
+	benchmark(b, NewIEEE(), 4<<10)
+}
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		h.Reset()
-		h.Write(data)
-		h.Sum(in)
-	}
+func BenchmarkIEEECrc32KB(b *testing.B) {
+	benchmark(b, NewIEEE(), 32<<10)
+}
+
+func BenchmarkCastagnoliCrc40B(b *testing.B) {
+	benchmark(b, New(MakeTable(Castagnoli)), 40)
 }
 
 func BenchmarkCastagnoliCrc1KB(b *testing.B) {
-	b.SetBytes(1024)
-	data := make([]byte, 1024)
+	benchmark(b, New(MakeTable(Castagnoli)), 1<<10)
+}
+
+func BenchmarkCastagnoliCrc4KB(b *testing.B) {
+	benchmark(b, New(MakeTable(Castagnoli)), 4<<10)
+}
+
+func BenchmarkCastagnoliCrc32KB(b *testing.B) {
+	benchmark(b, New(MakeTable(Castagnoli)), 32<<10)
+}
+
+func benchmark(b *testing.B, h hash.Hash32, n int64) {
+	b.SetBytes(n)
+	data := make([]byte, n)
 	for i := range data {
 		data[i] = byte(i)
 	}
-	h := New(MakeTable(Castagnoli))
 	in := make([]byte, 0, h.Size())
 
+	// Warm up
+	h.Reset()
+	h.Write(data)
+	h.Sum(in)
+
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		h.Reset()
diff --git a/libgo/go/hash/crc64/crc64.go b/libgo/go/hash/crc64/crc64.go
index 54cc560..e939c2a 100644
--- a/libgo/go/hash/crc64/crc64.go
+++ b/libgo/go/hash/crc64/crc64.go
@@ -24,9 +24,25 @@ const (
 // Table is a 256-word table representing the polynomial for efficient processing.
 type Table [256]uint64
 
+var (
+	slicing8TableISO  = makeSlicingBy8Table(makeTable(ISO))
+	slicing8TableECMA = makeSlicingBy8Table(makeTable(ECMA))
+)
+
 // MakeTable returns a Table constructed from the specified polynomial.
 // The contents of this Table must not be modified.
 func MakeTable(poly uint64) *Table {
+	switch poly {
+	case ISO:
+		return &slicing8TableISO[0]
+	case ECMA:
+		return &slicing8TableECMA[0]
+	default:
+		return makeTable(poly)
+	}
+}
+
+func makeTable(poly uint64) *Table {
 	t := new(Table)
 	for i := 0; i < 256; i++ {
 		crc := uint64(i)
@@ -42,6 +58,19 @@ func MakeTable(poly uint64) *Table {
 	return t
 }
 
+func makeSlicingBy8Table(t *Table) *[8]Table {
+	var helperTable [8]Table
+	helperTable[0] = *t
+	for i := 0; i < 256; i++ {
+		crc := t[i]
+		for j := 1; j < 8; j++ {
+			crc = t[crc&0xff] ^ (crc >> 8)
+			helperTable[j][i] = crc
+		}
+	}
+	return &helperTable
+}
+
 // digest represents the partial evaluation of a checksum.
 type digest struct {
 	crc uint64
@@ -61,6 +90,35 @@ func (d *digest) Reset() { d.crc = 0 }
 
 func update(crc uint64, tab *Table, p []byte) uint64 {
 	crc = ^crc
+	// Table comparison is somewhat expensive, so avoid it for small sizes
+	for len(p) >= 64 {
+		var helperTable *[8]Table
+		if *tab == slicing8TableECMA[0] {
+			helperTable = slicing8TableECMA
+		} else if *tab == slicing8TableISO[0] {
+			helperTable = slicing8TableISO
+			// For smaller sizes creating extended table takes too much time
+		} else if len(p) > 16384 {
+			helperTable = makeSlicingBy8Table(tab)
+		} else {
+			break
+		}
+		// Update using slicing-by-8
+		for len(p) > 8 {
+			crc ^= uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 |
+				uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
+			crc = helperTable[7][crc&0xff] ^
+				helperTable[6][(crc>>8)&0xff] ^
+				helperTable[5][(crc>>16)&0xff] ^
+				helperTable[4][(crc>>24)&0xff] ^
+				helperTable[3][(crc>>32)&0xff] ^
+				helperTable[2][(crc>>40)&0xff] ^
+				helperTable[1][(crc>>48)&0xff] ^
+				helperTable[0][crc>>56]
+			p = p[8:]
+		}
+	}
+	// For reminders or small sizes
 	for _, v := range p {
 		crc = tab[byte(crc)^v] ^ (crc >> 8)
 	}
diff --git a/libgo/go/hash/crc64/crc64_test.go b/libgo/go/hash/crc64/crc64_test.go
index 81a87b5..480b150 100644
--- a/libgo/go/hash/crc64/crc64_test.go
+++ b/libgo/go/hash/crc64/crc64_test.go
@@ -10,66 +10,75 @@ import (
 )
 
 type test struct {
-	out uint64
-	in  string
+	outISO  uint64
+	outECMA uint64
+	in      string
 }
 
 var golden = []test{
-	{0x0, ""},
-	{0x3420000000000000, "a"},
-	{0x36c4200000000000, "ab"},
-	{0x3776c42000000000, "abc"},
-	{0x336776c420000000, "abcd"},
-	{0x32d36776c4200000, "abcde"},
-	{0x3002d36776c42000, "abcdef"},
-	{0x31b002d36776c420, "abcdefg"},
-	{0xe21b002d36776c4, "abcdefgh"},
-	{0x8b6e21b002d36776, "abcdefghi"},
-	{0x7f5b6e21b002d367, "abcdefghij"},
-	{0x8ec0e7c835bf9cdf, "Discard medicine more than two years old."},
-	{0xc7db1759e2be5ab4, "He who has a shady past knows that nice guys finish last."},
-	{0xfbf9d9603a6fa020, "I wouldn't marry him with a ten foot pole."},
-	{0xeafc4211a6daa0ef, "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave"},
-	{0x3e05b21c7a4dc4da, "The days of the digital watch are numbered.  -Tom Stoppard"},
-	{0x5255866ad6ef28a6, "Nepal premier won't resign."},
-	{0x8a79895be1e9c361, "For every action there is an equal and opposite government program."},
-	{0x8878963a649d4916, "His money is twice tainted: 'taint yours and 'taint mine."},
-	{0xa7b9d53ea87eb82f, "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977"},
-	{0xdb6805c0966a2f9c, "It's a tiny change to the code and not completely disgusting. - Bob Manchek"},
-	{0xf3553c65dacdadd2, "size:  a.out:  bad magic"},
-	{0x9d5e034087a676b9, "The major problem is with sendmail.  -Mark Horton"},
-	{0xa6db2d7f8da96417, "Give me a rock, paper and scissors and I will move the world.  CCFestoon"},
-	{0x325e00cd2fe819f9, "If the enemy is within range, then so are you."},
-	{0x88c6600ce58ae4c6, "It's well we cannot hear the screams/That we create in others' dreams."},
-	{0x28c4a3f3b769e078, "You remind me of a TV show, but that's all right: I watch it anyway."},
-	{0xa698a34c9d9f1dca, "C is as portable as Stonehedge!!"},
-	{0xf6c1e2a8c26c5cfc, "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley"},
-	{0xd402559dfe9b70c, "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction.  Lewis-Randall Rule"},
-	{0xdb6efff26aa94946, "How can you write a big system without C++?  -Paul Glick"},
+	{0x0, 0x0, ""},
+	{0x3420000000000000, 0x330284772e652b05, "a"},
+	{0x36c4200000000000, 0xbc6573200e84b046, "ab"},
+	{0x3776c42000000000, 0x2cd8094a1a277627, "abc"},
+	{0x336776c420000000, 0x3c9d28596e5960ba, "abcd"},
+	{0x32d36776c4200000, 0x40bdf58fb0895f2, "abcde"},
+	{0x3002d36776c42000, 0xd08e9f8545a700f4, "abcdef"},
+	{0x31b002d36776c420, 0xec20a3a8cc710e66, "abcdefg"},
+	{0xe21b002d36776c4, 0x67b4f30a647a0c59, "abcdefgh"},
+	{0x8b6e21b002d36776, 0x9966f6c89d56ef8e, "abcdefghi"},
+	{0x7f5b6e21b002d367, 0x32093a2ecd5773f4, "abcdefghij"},
+	{0x8ec0e7c835bf9cdf, 0x8a0825223ea6d221, "Discard medicine more than two years old."},
+	{0xc7db1759e2be5ab4, 0x8562c0ac2ab9a00d, "He who has a shady past knows that nice guys finish last."},
+	{0xfbf9d9603a6fa020, 0x3ee2a39c083f38b4, "I wouldn't marry him with a ten foot pole."},
+	{0xeafc4211a6daa0ef, 0x1f603830353e518a, "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave"},
+	{0x3e05b21c7a4dc4da, 0x2fd681d7b2421fd, "The days of the digital watch are numbered.  -Tom Stoppard"},
+	{0x5255866ad6ef28a6, 0x790ef2b16a745a41, "Nepal premier won't resign."},
+	{0x8a79895be1e9c361, 0x3ef8f06daccdcddf, "For every action there is an equal and opposite government program."},
+	{0x8878963a649d4916, 0x49e41b2660b106d, "His money is twice tainted: 'taint yours and 'taint mine."},
+	{0xa7b9d53ea87eb82f, 0x561cc0cfa235ac68, "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977"},
+	{0xdb6805c0966a2f9c, 0xd4fe9ef082e69f59, "It's a tiny change to the code and not completely disgusting. - Bob Manchek"},
+	{0xf3553c65dacdadd2, 0xe3b5e46cd8d63a4d, "size:  a.out:  bad magic"},
+	{0x9d5e034087a676b9, 0x865aaf6b94f2a051, "The major problem is with sendmail.  -Mark Horton"},
+	{0xa6db2d7f8da96417, 0x7eca10d2f8136eb4, "Give me a rock, paper and scissors and I will move the world.  CCFestoon"},
+	{0x325e00cd2fe819f9, 0xd7dd118c98e98727, "If the enemy is within range, then so are you."},
+	{0x88c6600ce58ae4c6, 0x70fb33c119c29318, "It's well we cannot hear the screams/That we create in others' dreams."},
+	{0x28c4a3f3b769e078, 0x57c891e39a97d9b7, "You remind me of a TV show, but that's all right: I watch it anyway."},
+	{0xa698a34c9d9f1dca, 0xa1f46ba20ad06eb7, "C is as portable as Stonehedge!!"},
+	{0xf6c1e2a8c26c5cfc, 0x7ad25fafa1710407, "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley"},
+	{0xd402559dfe9b70c, 0x73cef1666185c13f, "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction.  Lewis-Randall Rule"},
+	{0xdb6efff26aa94946, 0xb41858f73c389602, "How can you write a big system without C++?  -Paul Glick"},
+	{0xe7fcf1006b503b61, 0x27db187fc15bbc72, "This is a test of the emergency broadcast system."},
 }
 
-var tab = MakeTable(ISO)
-
 func TestGolden(t *testing.T) {
+	tabISO := MakeTable(ISO)
+	tabECMA := MakeTable(ECMA)
 	for i := 0; i < len(golden); i++ {
 		g := golden[i]
-		c := New(tab)
+		c := New(tabISO)
 		io.WriteString(c, g.in)
 		s := c.Sum64()
-		if s != g.out {
-			t.Errorf("crc64(%s) = 0x%x want 0x%x", g.in, s, g.out)
+		if s != g.outISO {
+			t.Errorf("ISO crc64(%s) = 0x%x want 0x%x", g.in, s, g.outISO)
+			t.FailNow()
+		}
+		c = New(tabECMA)
+		io.WriteString(c, g.in)
+		s = c.Sum64()
+		if s != g.outECMA {
+			t.Errorf("ECMA crc64(%s) = 0x%x want 0x%x", g.in, s, g.outECMA)
 			t.FailNow()
 		}
 	}
 }
 
-func BenchmarkCrc64KB(b *testing.B) {
-	b.SetBytes(1024)
-	data := make([]byte, 1024)
+func bench(b *testing.B, poly uint64, size int64) {
+	b.SetBytes(size)
+	data := make([]byte, size)
 	for i := range data {
 		data[i] = byte(i)
 	}
-	h := New(tab)
+	h := New(MakeTable(poly))
 	in := make([]byte, 0, h.Size())
 
 	b.ResetTimer()
@@ -79,3 +88,24 @@ func BenchmarkCrc64KB(b *testing.B) {
 		h.Sum(in)
 	}
 }
+
+func BenchmarkCrc64(b *testing.B) {
+	b.Run("ISO64KB", func(b *testing.B) {
+		bench(b, ISO, 64<<10)
+	})
+	b.Run("ISO4KB", func(b *testing.B) {
+		bench(b, ISO, 4<<10)
+	})
+	b.Run("ISO1KB", func(b *testing.B) {
+		bench(b, ISO, 1<<10)
+	})
+	b.Run("ECMA64KB", func(b *testing.B) {
+		bench(b, ECMA, 64<<10)
+	})
+	b.Run("Random64KB", func(b *testing.B) {
+		bench(b, 0x777, 64<<10)
+	})
+	b.Run("Random16KB", func(b *testing.B) {
+		bench(b, 0x777, 16<<10)
+	})
+}