Function encodeBlockBetterSnappyGo64K

s2/encode_better.go:733–892

encodeBlockBetterSnappyGo encodes a non-empty src to a guaranteed-large-enough dst. It assumes that the varint-encoded length of the decompressed bytes has already been written. It also assumes that: len(dst) >= MaxEncodedLen(len(src)) && minNonLiteralBlockSize <= len(src) && len(src) <= maxBloc

(dst, src []byte)

//	len(dst) >= MaxEncodedLen(len(src)) &&
//	minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
func encodeBlockBetterSnappyGo64K(dst, src []byte) (d int) {
	// 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
	if len(src) < minNonLiteralBlockSize {
		return 0
	}

	// Initialize the hash tables.
	// Use smaller tables for smaller blocks
	const (
		// Long hash matches.
		lTableBits    = 15
		maxLTableSize = 1 << lTableBits

		// Short hash matches.
		sTableBits    = 13
		maxSTableSize = 1 << sTableBits
	)

	var lTable [maxLTableSize]uint16
	var sTable [maxSTableSize]uint16

	// Bail if we can't compress to at least this.
	dstLimit := len(src) - len(src)>>5 - 6

	// 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
	cv := load64(src, s)

	const maxSkip = 100

	for {
		candidateL := 0
		nextS := 0
		for {
			// Next src position to check
			nextS = min(s+(s-nextEmit)>>6+1, s+maxSkip)

			if nextS > sLimit {
				goto emitRemainder
			}
			hashL := hash7(cv, lTableBits)
			hashS := hash4(cv, sTableBits)
			candidateL = int(lTable[hashL])
			candidateS := int(sTable[hashS])
			lTable[hashL] = uint16(s)
			sTable[hashS] = uint16(s)

			if uint32(cv) == load32(src, candidateL) {
				break
			}