@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/compress/flate/deflatefast.go

@@ -4,304 +4,198 @@
 
 package flate
 
-import "math"
-
-// This encoding algorithm, which prioritizes speed over output size, is
-// based on Snappy's LZ77-style encoder: github.com/golang/snappy
+import (
+	"math/bits"
+)
 
 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.
+	// tableBits is the number of bits used in the hash table.
+	tableBits = 15
 
-	// Reset the buffer offset when reaching this.
-	// Offsets are stored between blocks as int32 values.
-	// Since the offset we are checking against is at the beginning
-	// of the buffer, we need to subtract the current and input
-	// buffer to not risk overflowing the int32.
-	bufferReset = math.MaxInt32 - maxStoreBlockSize*2
-)
+	// tableSize is the size of the hash table.
+	tableSize = 1 << tableBits
 
-func load32(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
-}
+	// hashLongBytes is the number of bytes used for long table hashes.
+	hashLongBytes = 7
 
-func load64(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
-}
+	// baseMatchOffset is the smallest match offset.
+	baseMatchOffset = 1
 
-func hash(u uint32) uint32 {
-	return (u * 0x1e35a7bd) >> tableShift
-}
+	// baseMatchLength is the smallest match length per RFC section 3.2.5.
+	baseMatchLength = 3
 
-// These constants are defined by the Snappy implementation so that its
-// assembly implementation can fast-path some 16-bytes-at-a-time copies. They
-// aren't necessary in the pure Go implementation, as we don't use those same
-// optimizations, but using the same thresholds doesn't really hurt.
-const (
-	inputMargin            = 16 - 1
-	minNonLiteralBlockSize = 1 + 1 + inputMargin
-)
+	// maxMatchOffset is the largest match offset.
+	maxMatchOffset = 1 << 15
 
-type tableEntry struct {
-	val    uint32 // Value at destination
-	offset int32
-}
+	// allocHistory is the size to preallocate for history.
+	allocHistory = maxStoreBlockSize * 5
 
-// deflateFast maintains the table for matches,
-// and the previous byte block for cross block matching.
-type deflateFast struct {
-	table [tableSize]tableEntry
-	prev  []byte // Previous block, zero length if unknown.
-	cur   int32  // Current match offset.
-}
+	// bufferReset is the buffer offset at which the history is reset.
+	bufferReset = (1 << 31) - allocHistory - maxStoreBlockSize - 1
+)
 
-func newDeflateFast() *deflateFast {
-	return &deflateFast{cur: maxStoreBlockSize, prev: make([]byte, 0, maxStoreBlockSize)}
+// fastEncL1 to fastEncL6 provides specialized encoders for levels 1-6
+// that each provide a different speed/size/memory strategies.
+//
+// Level 1: Single small table, 5 byte hashes, sparse indexing.
+// Level 2: Single big table, 5 byte hashes, indexing ~ every 2 bytes.
+// Level 3: Single medium table, 5 byte hashes, 2 candidates per table entry.
+// Level 4: Two tables, 4/7 byte hashes, 1 candidate per table entry.
+// Level 5: Two tables, 4/7 byte hashes, 2 candidates per 7-byte table entry.
+// Level 6: Two tables, 4/7 byte hashes, full indexing, checks for repeats.
+//
+// Skipping on contiguous non-matches also decreases as levels go up.
+
+// fastEnc is the interface implemented by the level 1-6 fast encoders.
+type fastEnc interface {
+	// encode src into dst.
+	encode(dst *tokens, src []byte)
+	// reset the encoder so matches are not made with previous data.
+	reset()
 }
 
-// encode encodes a block given in src and appends tokens
-// to dst and returns the result.
-func (e *deflateFast) encode(dst []token, src []byte) []token {
-	// Ensure that e.cur doesn't wrap.
-	if e.cur >= bufferReset {
-		e.shiftOffsets()
+// newFastEnc returns a fastEnc encoder for the given compression level (1-6).
+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")
 	}
+}
 
-	// This check isn't in the Snappy implementation, but there, the caller
-	// instead of the callee handles this case.
-	if len(src) < minNonLiteralBlockSize {
-		e.cur += maxStoreBlockSize
-		e.prev = e.prev[:0]
-		return emitLiteral(dst, src)
-	}
-
-	// 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 := load32(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 := load32(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.
-		dst = 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 = append(dst, matchToken(uint32(l+4-baseMatchLength), uint32(s-t-baseMatchOffset)))
-			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 := load64(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)}
+// fastGen maintains the table for matches,
+// and the previous byte block for level 1 and up.
+// This is the generic implementation.
+type fastGen struct {
+	hist []byte
+	cur  int32
+}
 
-			offset := s - (candidate.offset - e.cur)
-			if offset > maxMatchOffset || uint32(x) != candidate.val {
-				cv = uint32(x >> 8)
-				nextHash = hash(cv)
-				s++
-				break
+// addBlock appends src to the history and returns the offset where src starts in e.hist.
+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:offset+maxMatchOffset])
+			e.cur += offset
+			e.hist = e.hist[:maxMatchOffset]
 		}
 	}
+	s := int32(len(e.hist))
+	e.hist = append(e.hist, src...)
+	return s
+}
 
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		dst = emitLiteral(dst, src[nextEmit:])
-	}
-	e.cur += int32(len(src))
-	e.prev = e.prev[:len(src)]
-	copy(e.prev, src)
-	return dst
+// matchLenLimited returns the match length between offsets s 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) matchLenLimited(s, t int, src []byte) int32 {
+	a := src[s:min(s+maxMatchLength-4, len(src))]
+	b := src[t:]
+	return int32(matchLen(a, b))
 }
 
-func emitLiteral(dst []token, lit []byte) []token {
-	for _, v := range lit {
-		dst = append(dst, literalToken(uint32(v)))
-	}
-	return dst
+// matchLenLong returns the match length between offsets s and t in src.
+// It is assumed that s > t, that t >= 0 and s < len(src).
+func (e *fastGen) matchLenLong(s, t int, src []byte) int32 {
+	return int32(matchLen(src[s:], src[t:]))
 }
 
-// matchLen returns the match length between src[s:] and src[t:].
-// t can be negative to indicate the match is starting in e.prev.
-// We assume that src[s-4:s] and src[t-4:t] already match.
-func (e *deflateFast) matchLen(s, t int32, src []byte) int32 {
-	s1 := int(s) + maxMatchLength - 4
-	if s1 > len(src) {
-		s1 = len(src)
+// reset resets the encoding table to prepare for a new compression stream.
+func (e *fastGen) reset() {
+	if cap(e.hist) < allocHistory {
+		e.hist = make([]byte, 0, allocHistory)
 	}
-
-	// 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
+	// We offset current position so everything will be out of reach.
+	// If we are above the buffer reset it will be cleared anyway since len(hist) == 0.
+	if e.cur <= bufferReset {
+		e.cur += maxMatchOffset + int32(len(e.hist))
 	}
+	e.hist = e.hist[: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)
-		}
-	}
+func (f *fastGen) getFastGen() *fastGen { return f }
 
-	// If we reached our limit, we matched everything we are
-	// allowed to in the previous block and we return.
-	n := int32(len(b))
-	if int(s+n) == s1 {
-		return n
-	}
+// tableEntry stores the offset of a hash match in the input history.
+type tableEntry struct {
+	offset int32
+}
 
-	// Continue looking for more matches in the current block.
-	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
+// tableEntryPrev stores the current and previous offsets for a hash entry.
+type tableEntryPrev struct {
+	cur  tableEntry
+	prev tableEntry
 }
 
-// Reset resets the encoding history.
-// This ensures that no matches are made to the previous block.
-func (e *deflateFast) reset() {
-	e.prev = e.prev[:0]
-	// Bump the offset, so all matches will fail distance check.
-	// Nothing should be >= e.cur in the table.
-	e.cur += maxMatchOffset
+const (
+	prime3bytes = 506832829
+	prime4bytes = 2654435761
+	prime5bytes = 889523592379
+	prime6bytes = 227718039650203
+	prime7bytes = 58295818150454627
+	prime8bytes = 0xcf1bbcdcb7a56463
+)
 
-	// Protect against e.cur wraparound.
-	if e.cur >= bufferReset {
-		e.shiftOffsets()
+// hashLen returns a hash of the first n bytes of u, using b output bits.
+// It expects 3 <= n <= 8; other values are treated as n == 4.
+// The bit length b must be <= 32.
+// b and n should be constants in speed-critical use.
+func hashLen(u uint64, b, n uint8) uint32 {
+	switch n {
+	case 3:
+		return (uint32(u<<8) * prime3bytes) >> (32 - b)
+	case 5:
+		return uint32(((u << (64 - 40)) * prime5bytes) >> (64 - b))
+	case 6:
+		return uint32(((u << (64 - 48)) * prime6bytes) >> (64 - b))
+	case 7:
+		return uint32(((u << (64 - 56)) * prime7bytes) >> (64 - b))
+	case 8:
+		return uint32((u * prime8bytes) >> (64 - b))
+	default:
+		return (uint32(u) * prime4bytes) >> (32 - b)
 	}
 }
 
-// shiftOffsets will shift down all match offset.
-// This is only called in rare situations to prevent integer overflow.
-//
-// See https://golang.org/issue/18636 and https://github.com/golang/go/issues/34121.
-func (e *deflateFast) shiftOffsets() {
-	if len(e.prev) == 0 {
-		// We have no history; just clear the table.
-		clear(e.table[:])
-		e.cur = maxMatchOffset + 1
-		return
+// matchLen returns the maximum common prefix length of a and b.
+// a must be the shortest of the two.
+func matchLen(a, b []byte) (n int) {
+	left := len(a)
+	for left >= 8 {
+		diff := loadLE64(a, n) ^ loadLE64(b, n)
+		if diff != 0 {
+			return n + bits.TrailingZeros64(diff)>>3
+		}
+		n += 8
+		left -= 8
 	}
 
-	// Shift down everything in the table that isn't already too far away.
-	for i := range e.table[:] {
-		v := e.table[i].offset - e.cur + maxMatchOffset + 1
-		if v < 0 {
-			// We want to reset e.cur to maxMatchOffset + 1, so we need to shift
-			// all table entries down by (e.cur - (maxMatchOffset + 1)).
-			// Because we ignore matches > maxMatchOffset, we can cap
-			// any negative offsets at 0.
-			v = 0
+	a = a[n:]
+	b = b[n:]
+	b = b[:len(a)]
+	for i := range a {
+		if a[i] != b[i] {
+			break
 		}
-		e.table[i].offset = v
+		n++
 	}
-	e.cur = maxMatchOffset + 1
+	return n
 }

package/bin/go/src/compress/flate/dict_decoder.go

@@ -104,10 +104,7 @@ func (dd *dictDecoder) writeCopy(dist, length int) int {
 	dstBase := dd.wrPos
 	dstPos := dstBase
 	srcPos := dstPos - dist
-	endPos := dstPos + length
-	if endPos > len(dd.hist) {
-		endPos = len(dd.hist)
-	}
+	endPos := min(dstPos+length, len(dd.hist))
 
 	// Copy non-overlapping section after destination position.
 	//