Improve spatial locality by handling the huffman code as a struct of slices instead of a slice of structs.

Author: teivah

src/compress/flate/huffman_bit_writer.go

@@ -209,12 +209,12 @@ func (w *huffmanBitWriter) generateCodegen(numLiterals int, numOffsets int, litE
 	// Copy the concatenated code sizes to codegen. Put a marker at the end.
 	cgnl := codegen[:numLiterals]
 	for i := range cgnl {
-		cgnl[i] = uint8(litEnc.codes[i].len)
+		cgnl[i] = uint8(litEnc.codes.len[i])
 	}
 
 	cgnl = codegen[numLiterals : numLiterals+numOffsets]
 	for i := range cgnl {
-		cgnl[i] = uint8(offEnc.codes[i].len)
+		cgnl[i] = uint8(offEnc.codes.len[i])
 	}
 	codegen[numLiterals+numOffsets] = badCode
 
@@ -324,12 +324,12 @@ func (w *huffmanBitWriter) storedSize(in []byte) (int, bool) {
 	return 0, false
 }
 
-func (w *huffmanBitWriter) writeCode(c hcode) {
+func (w *huffmanBitWriter) writeCode(codes, lens []uint16, index uint32) {
 	if w.err != nil {
 		return
 	}
-	w.bits |= uint64(c.code) << w.nbits
-	w.nbits += uint(c.len)
+	w.bits |= uint64(codes[index]) << w.nbits
+	w.nbits += uint(lens[index])
 	if w.nbits >= 48 {
 		bits := w.bits
 		w.bits >>= 48
@@ -370,7 +370,7 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n
 	w.writeBits(int32(numCodegens-4), 4)
 
 	for i := 0; i < numCodegens; i++ {
-		value := uint(w.codegenEncoding.codes[codegenOrder[i]].len)
+		value := uint(w.codegenEncoding.codes.len[codegenOrder[i]])
 		w.writeBits(int32(value), 3)
 	}
 
@@ -381,7 +381,7 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n
 		if codeWord == badCode {
 			break
 		}
-		w.writeCode(w.codegenEncoding.codes[uint32(codeWord)])
+		w.writeCode(w.codegenEncoding.codes.code, w.codegenEncoding.codes.len, uint32(codeWord))
 
 		switch codeWord {
 		case 16:
@@ -574,19 +574,19 @@ func (w *huffmanBitWriter) indexTokens(tokens []token) (numLiterals, numOffsets
 
 // writeTokens writes a slice of tokens to the output.
 // codes for literal and offset encoding must be supplied.
-func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes []hcode) {
+func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes hcode) {
 	if w.err != nil {
 		return
 	}
 	for _, t := range tokens {
 		if t < matchType {
-			w.writeCode(leCodes[t.literal()])
+			w.writeCode(leCodes.code, leCodes.len, t.literal())
 			continue
 		}
 		// Write the length
 		length := t.length()
 		lengthCode := lengthCode(length)
-		w.writeCode(leCodes[lengthCode+lengthCodesStart])
+		w.writeCode(leCodes.code, leCodes.len, lengthCode+lengthCodesStart)
 		extraLengthBits := uint(lengthExtraBits[lengthCode])
 		if extraLengthBits > 0 {
 			extraLength := int32(length - lengthBase[lengthCode])
@@ -595,7 +595,7 @@ func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes []hcode)
 		// Write the offset
 		offset := t.offset()
 		offsetCode := offsetCode(offset)
-		w.writeCode(oeCodes[offsetCode])
+		w.writeCode(oeCodes.code, oeCodes.len, offsetCode)
 		extraOffsetBits := uint(offsetExtraBits[offsetCode])
 		if extraOffsetBits > 0 {
 			extraOffset := int32(offset - offsetBase[offsetCode])
@@ -658,13 +658,13 @@ func (w *huffmanBitWriter) writeBlockHuff(eof bool, input []byte) {
 
 	// Huffman.
 	w.writeDynamicHeader(numLiterals, numOffsets, numCodegens, eof)
-	encoding := w.literalEncoding.codes[:257]
+	encodingCode := w.literalEncoding.codes.code[:257]
+	encodingLen := w.literalEncoding.codes.len[:257]
 	n := w.nbytes
 	for _, t := range input {
 		// Bitwriting inlined, ~30% speedup
-		c := encoding[t]
-		w.bits |= uint64(c.code) << w.nbits
-		w.nbits += uint(c.len)
+		w.bits |= uint64(encodingCode[t]) << w.nbits
+		w.nbits += uint(encodingLen[t])
 		if w.nbits < 48 {
 			continue
 		}
@@ -690,7 +690,7 @@ func (w *huffmanBitWriter) writeBlockHuff(eof bool, input []byte) {
 		n = 0
 	}
 	w.nbytes = n
-	w.writeCode(encoding[endBlockMarker])
+	w.writeCode(encodingCode, encodingLen, endBlockMarker)
 }
 
 // histogram accumulates a histogram of b in h.

src/compress/flate/huffman_code.go

@@ -12,11 +12,12 @@ import (
 
 // hcode is a huffman code with a bit code and bit length.
 type hcode struct {
-	code, len uint16
+	code []uint16
+	len  []uint16
 }
 
 type huffmanEncoder struct {
-	codes     []hcode
+	codes     hcode
 	freqcache []literalNode
 	bitCount  [17]int32
 	lns       byLiteral // stored to avoid repeated allocation in generate
@@ -48,16 +49,13 @@ type levelInfo struct {
 	needed int32
 }
 
-// set sets the code and length of an hcode.
-func (h *hcode) set(code uint16, length uint16) {
-	h.len = length
-	h.code = code
-}
-
 func maxNode() literalNode { return literalNode{math.MaxUint16, math.MaxInt32} }
 
 func newHuffmanEncoder(size int) *huffmanEncoder {
-	return &huffmanEncoder{codes: make([]hcode, size)}
+	return &huffmanEncoder{codes: hcode{
+		code: make([]uint16, size),
+		len:  make([]uint16, size),
+	}}
 }
 
 // Generates a HuffmanCode corresponding to the fixed literal table
@@ -89,16 +87,18 @@ func generateFixedLiteralEncoding() *huffmanEncoder {
 			bits = ch + 192 - 280
 			size = 8
 		}
-		codes[ch] = hcode{code: reverseBits(bits, byte(size)), len: size}
+		codes.code[ch] = reverseBits(bits, byte(size))
+		codes.len[ch] = size
 	}
 	return h
 }
 
 func generateFixedOffsetEncoding() *huffmanEncoder {
 	h := newHuffmanEncoder(30)
 	codes := h.codes
-	for ch := range codes {
-		codes[ch] = hcode{code: reverseBits(uint16(ch), 5), len: 5}
+	for i := 0; i < len(codes.code); i++ {
+		codes.code[i] = reverseBits(uint16(i), 5)
+		codes.len[i] = 5
 	}
 	return h
 }
@@ -110,7 +110,7 @@ func (h *huffmanEncoder) bitLength(freq []int32) int {
 	var total int
 	for i, f := range freq {
 		if f != 0 {
-			total += int(f) * int(h.codes[i].len)
+			total += int(f) * int(h.codes.len[i])
 		}
 	}
 	return total
@@ -260,7 +260,8 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
 
 		h.lns.sort(chunk)
 		for _, node := range chunk {
-			h.codes[node.literal] = hcode{code: reverseBits(code, uint8(n)), len: uint16(n)}
+			h.codes.code[node.literal] = reverseBits(code, uint8(n))
+			h.codes.len[node.literal] = uint16(n)
 			code++
 		}
 		list = list[0 : len(list)-int(bits)]
@@ -288,7 +289,7 @@ func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
 			count++
 		} else {
 			list[count] = literalNode{}
-			h.codes[i].len = 0
+			h.codes.len[i] = 0
 		}
 	}
 	list[len(freq)] = literalNode{}
@@ -299,7 +300,8 @@ func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
 		// two or fewer literals, everything has bit length 1.
 		for i, node := range list {
 			// "list" is in order of increasing literal value.
-			h.codes[node.literal].set(uint16(i), 1)
+			h.codes.code[node.literal] = uint16(i)
+			h.codes.len[node.literal] = 1
 		}
 		return
 	}