...
Run Format

Source file src/compress/flate/deflatefast.go

Documentation: compress/flate

     1  // Copyright 2016 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package flate
     6  
     7  // This encoding algorithm, which prioritizes speed over output size, is
     8  // based on Snappy's LZ77-style encoder: github.com/golang/snappy
     9  
    10  const (
    11  	tableBits  = 14             // Bits used in the table.
    12  	tableSize  = 1 << tableBits // Size of the table.
    13  	tableMask  = tableSize - 1  // Mask for table indices. Redundant, but can eliminate bounds checks.
    14  	tableShift = 32 - tableBits // Right-shift to get the tableBits most significant bits of a uint32.
    15  )
    16  
    17  func load32(b []byte, i int32) uint32 {
    18  	b = b[i : i+4 : len(b)] // Help the compiler eliminate bounds checks on the next line.
    19  	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
    20  }
    21  
    22  func load64(b []byte, i int32) uint64 {
    23  	b = b[i : i+8 : len(b)] // Help the compiler eliminate bounds checks on the next line.
    24  	return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
    25  		uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
    26  }
    27  
    28  func hash(u uint32) uint32 {
    29  	return (u * 0x1e35a7bd) >> tableShift
    30  }
    31  
    32  // These constants are defined by the Snappy implementation so that its
    33  // assembly implementation can fast-path some 16-bytes-at-a-time copies. They
    34  // aren't necessary in the pure Go implementation, as we don't use those same
    35  // optimizations, but using the same thresholds doesn't really hurt.
    36  const (
    37  	inputMargin            = 16 - 1
    38  	minNonLiteralBlockSize = 1 + 1 + inputMargin
    39  )
    40  
    41  type tableEntry struct {
    42  	val    uint32 // Value at destination
    43  	offset int32
    44  }
    45  
    46  // deflateFast maintains the table for matches,
    47  // and the previous byte block for cross block matching.
    48  type deflateFast struct {
    49  	table [tableSize]tableEntry
    50  	prev  []byte // Previous block, zero length if unknown.
    51  	cur   int32  // Current match offset.
    52  }
    53  
    54  func newDeflateFast() *deflateFast {
    55  	return &deflateFast{cur: maxStoreBlockSize, prev: make([]byte, 0, maxStoreBlockSize)}
    56  }
    57  
    58  // encode encodes a block given in src and appends tokens
    59  // to dst and returns the result.
    60  func (e *deflateFast) encode(dst []token, src []byte) []token {
    61  	// Ensure that e.cur doesn't wrap.
    62  	if e.cur > 1<<30 {
    63  		e.resetAll()
    64  	}
    65  
    66  	// This check isn't in the Snappy implementation, but there, the caller
    67  	// instead of the callee handles this case.
    68  	if len(src) < minNonLiteralBlockSize {
    69  		e.cur += maxStoreBlockSize
    70  		e.prev = e.prev[:0]
    71  		return emitLiteral(dst, src)
    72  	}
    73  
    74  	// sLimit is when to stop looking for offset/length copies. The inputMargin
    75  	// lets us use a fast path for emitLiteral in the main loop, while we are
    76  	// looking for copies.
    77  	sLimit := int32(len(src) - inputMargin)
    78  
    79  	// nextEmit is where in src the next emitLiteral should start from.
    80  	nextEmit := int32(0)
    81  	s := int32(0)
    82  	cv := load32(src, s)
    83  	nextHash := hash(cv)
    84  
    85  	for {
    86  		// Copied from the C++ snappy implementation:
    87  		//
    88  		// Heuristic match skipping: If 32 bytes are scanned with no matches
    89  		// found, start looking only at every other byte. If 32 more bytes are
    90  		// scanned (or skipped), look at every third byte, etc.. When a match
    91  		// is found, immediately go back to looking at every byte. This is a
    92  		// small loss (~5% performance, ~0.1% density) for compressible data
    93  		// due to more bookkeeping, but for non-compressible data (such as
    94  		// JPEG) it's a huge win since the compressor quickly "realizes" the
    95  		// data is incompressible and doesn't bother looking for matches
    96  		// everywhere.
    97  		//
    98  		// The "skip" variable keeps track of how many bytes there are since
    99  		// the last match; dividing it by 32 (ie. right-shifting by five) gives
   100  		// the number of bytes to move ahead for each iteration.
   101  		skip := int32(32)
   102  
   103  		nextS := s
   104  		var candidate tableEntry
   105  		for {
   106  			s = nextS
   107  			bytesBetweenHashLookups := skip >> 5
   108  			nextS = s + bytesBetweenHashLookups
   109  			skip += bytesBetweenHashLookups
   110  			if nextS > sLimit {
   111  				goto emitRemainder
   112  			}
   113  			candidate = e.table[nextHash&tableMask]
   114  			now := load32(src, nextS)
   115  			e.table[nextHash&tableMask] = tableEntry{offset: s + e.cur, val: cv}
   116  			nextHash = hash(now)
   117  
   118  			offset := s - (candidate.offset - e.cur)
   119  			if offset > maxMatchOffset || cv != candidate.val {
   120  				// Out of range or not matched.
   121  				cv = now
   122  				continue
   123  			}
   124  			break
   125  		}
   126  
   127  		// A 4-byte match has been found. We'll later see if more than 4 bytes
   128  		// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
   129  		// them as literal bytes.
   130  		dst = emitLiteral(dst, src[nextEmit:s])
   131  
   132  		// Call emitCopy, and then see if another emitCopy could be our next
   133  		// move. Repeat until we find no match for the input immediately after
   134  		// what was consumed by the last emitCopy call.
   135  		//
   136  		// If we exit this loop normally then we need to call emitLiteral next,
   137  		// though we don't yet know how big the literal will be. We handle that
   138  		// by proceeding to the next iteration of the main loop. We also can
   139  		// exit this loop via goto if we get close to exhausting the input.
   140  		for {
   141  			// Invariant: we have a 4-byte match at s, and no need to emit any
   142  			// literal bytes prior to s.
   143  
   144  			// Extend the 4-byte match as long as possible.
   145  			//
   146  			s += 4
   147  			t := candidate.offset - e.cur + 4
   148  			l := e.matchLen(s, t, src)
   149  
   150  			// matchToken is flate's equivalent of Snappy's emitCopy. (length,offset)
   151  			dst = append(dst, matchToken(uint32(l+4-baseMatchLength), uint32(s-t-baseMatchOffset)))
   152  			s += l
   153  			nextEmit = s
   154  			if s >= sLimit {
   155  				goto emitRemainder
   156  			}
   157  
   158  			// We could immediately start working at s now, but to improve
   159  			// compression we first update the hash table at s-1 and at s. If
   160  			// another emitCopy is not our next move, also calculate nextHash
   161  			// at s+1. At least on GOARCH=amd64, these three hash calculations
   162  			// are faster as one load64 call (with some shifts) instead of
   163  			// three load32 calls.
   164  			x := load64(src, s-1)
   165  			prevHash := hash(uint32(x))
   166  			e.table[prevHash&tableMask] = tableEntry{offset: e.cur + s - 1, val: uint32(x)}
   167  			x >>= 8
   168  			currHash := hash(uint32(x))
   169  			candidate = e.table[currHash&tableMask]
   170  			e.table[currHash&tableMask] = tableEntry{offset: e.cur + s, val: uint32(x)}
   171  
   172  			offset := s - (candidate.offset - e.cur)
   173  			if offset > maxMatchOffset || uint32(x) != candidate.val {
   174  				cv = uint32(x >> 8)
   175  				nextHash = hash(cv)
   176  				s++
   177  				break
   178  			}
   179  		}
   180  	}
   181  
   182  emitRemainder:
   183  	if int(nextEmit) < len(src) {
   184  		dst = emitLiteral(dst, src[nextEmit:])
   185  	}
   186  	e.cur += int32(len(src))
   187  	e.prev = e.prev[:len(src)]
   188  	copy(e.prev, src)
   189  	return dst
   190  }
   191  
   192  func emitLiteral(dst []token, lit []byte) []token {
   193  	for _, v := range lit {
   194  		dst = append(dst, literalToken(uint32(v)))
   195  	}
   196  	return dst
   197  }
   198  
   199  // matchLen returns the match length between src[s:] and src[t:].
   200  // t can be negative to indicate the match is starting in e.prev.
   201  // We assume that src[s-4:s] and src[t-4:t] already match.
   202  func (e *deflateFast) matchLen(s, t int32, src []byte) int32 {
   203  	s1 := int(s) + maxMatchLength - 4
   204  	if s1 > len(src) {
   205  		s1 = len(src)
   206  	}
   207  
   208  	// If we are inside the current block
   209  	if t >= 0 {
   210  		b := src[t:]
   211  		a := src[s:s1]
   212  		b = b[:len(a)]
   213  		// Extend the match to be as long as possible.
   214  		for i := range a {
   215  			if a[i] != b[i] {
   216  				return int32(i)
   217  			}
   218  		}
   219  		return int32(len(a))
   220  	}
   221  
   222  	// We found a match in the previous block.
   223  	tp := int32(len(e.prev)) + t
   224  	if tp < 0 {
   225  		return 0
   226  	}
   227  
   228  	// Extend the match to be as long as possible.
   229  	a := src[s:s1]
   230  	b := e.prev[tp:]
   231  	if len(b) > len(a) {
   232  		b = b[:len(a)]
   233  	}
   234  	a = a[:len(b)]
   235  	for i := range b {
   236  		if a[i] != b[i] {
   237  			return int32(i)
   238  		}
   239  	}
   240  
   241  	// If we reached our limit, we matched everything we are
   242  	// allowed to in the previous block and we return.
   243  	n := int32(len(b))
   244  	if int(s+n) == s1 {
   245  		return n
   246  	}
   247  
   248  	// Continue looking for more matches in the current block.
   249  	a = src[s+n : s1]
   250  	b = src[:len(a)]
   251  	for i := range a {
   252  		if a[i] != b[i] {
   253  			return int32(i) + n
   254  		}
   255  	}
   256  	return int32(len(a)) + n
   257  }
   258  
   259  // Reset resets the encoding history.
   260  // This ensures that no matches are made to the previous block.
   261  func (e *deflateFast) reset() {
   262  	e.prev = e.prev[:0]
   263  	// Bump the offset, so all matches will fail distance check.
   264  	e.cur += maxMatchOffset
   265  
   266  	// Protect against e.cur wraparound.
   267  	if e.cur > 1<<30 {
   268  		e.resetAll()
   269  	}
   270  }
   271  
   272  // resetAll resets the deflateFast struct and is only called in rare
   273  // situations to prevent integer overflow. It manually resets each field
   274  // to avoid causing large stack growth.
   275  //
   276  // See https://golang.org/issue/18636.
   277  func (e *deflateFast) resetAll() {
   278  	// This is equivalent to:
   279  	//	*e = deflateFast{cur: maxStoreBlockSize, prev: e.prev[:0]}
   280  	e.cur = maxStoreBlockSize
   281  	e.prev = e.prev[:0]
   282  	for i := range e.table {
   283  		e.table[i] = tableEntry{}
   284  	}
   285  }
   286  

View as plain text