Files
wuffs/script/puffs-flate-decoder-decode-huffman.c
T
Nigel Tao cf6b1be5b5 Re-organize flate Huffman decoder table bits.
Benchmarks are mixed, but it seems conceptually cleaner to arrange the
bits in the order that they're examined.

name                           old speed     new speed     delta
puffs_flate_decode_1k/clang    125MB/s ± 0%  123MB/s ± 1%  -1.91%  (p=0.008 n=5+5)
puffs_flate_decode_10k/clang   163MB/s ± 1%  157MB/s ± 0%  -3.55%  (p=0.008 n=5+5)
puffs_flate_decode_100k/clang  175MB/s ± 0%  173MB/s ± 0%  -0.75%  (p=0.016 n=4+5)
puffs_flate_decode_1k/gcc      127MB/s ± 0%  130MB/s ± 0%  +2.14%  (p=0.008 n=5+5)
puffs_flate_decode_10k/gcc     142MB/s ± 1%  149MB/s ± 0%  +4.99%  (p=0.016 n=5+4)
puffs_flate_decode_100k/gcc    162MB/s ± 2%  168MB/s ± 0%  +3.66%  (p=0.016 n=5+4)
2017-10-06 13:07:49 +11:00

288 lines
8.6 KiB
C

// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file.
// This file contains a hand-written C implementation of gen/c/std/flate.c's
// generated puffs_flate_decoder_decode_huffman function.
//
// It is not intended to be used in production settings, on untrusted data. Its
// purpose is to give a rough upper bound on how fast Puffs' generated C code
// can be, with a sufficiently smart Puffs compiler.
//
// To repeat, substituting in this C implementation is NOT SAFE, and may result
// in buffer overflows. This code exists only to aid optimization of the (safe)
// std/flate/*.puffs code and the Puffs compiler's code generation.
//
// ----------------
//
// Having said that, to generate the benchmark numbers with this hand-written C
// implementation, edit gen/c/std/flate.c and find the line that says
//
// C HEADER ENDS HERE.
//
// After that, add this line:
//
// #include "../../../script/puffs-flate-decoder-decode-huffman.c"
//
// Then find the call to puffs_flate_decoder_decode_huffman. It should be
// inside the puffs_flate_decoder_decode function body, and the line of code
// should look something like
//
// status = puffs_flate_decoder_decode_huffman(self, a_dst, a_src);
//
// Change the "puffs" to "c_puffs", i.e. add a "c_" prefix. The net result
// should look something like:
//
// ----------------
//
// $ git diff
// diff --git a/gen/c/std/flate.c b/gen/c/std/flate.c
// index 0fac466..87166fc 100644
// --- a/gen/c/std/flate.c
// +++ b/gen/c/std/flate.c
// @@ -252,6 +252,8 @@ puffs_flate_status
// puffs_flate_decoder_decode(puffs_flate_decoder* self,
//
// // C HEADER ENDS HERE.
//
// +#include "../../../script/puffs-flate-decoder-decode-huffman.c"
// +
// #ifndef PUFFS_BASE_IMPL_H
// #define PUFFS_BASE_IMPL_H
//
// @@ -580,7 +582,7 @@ puffs_flate_status
// puffs_flate_decoder_decode(puffs_flate_decoder* self,
// }
// }
// }
// - status = puffs_flate_decoder_decode_huffman(self, a_dst, a_src);
// + status = c_puffs_flate_decoder_decode_huffman(self, a_dst, a_src);
// if (a_src.buf) {
// b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
// size_t len = a_src.buf->wi - a_src.buf->ri;
//
// ----------------
//
// That concludes the two edits to gen/c/std/flate.c. Run the C test and
// benchmark programs directly, instead of running "puffs test" or "puffs
// bench", since the "puffs" tool will re-generate the C code and override your
// gen/c/std/flate.c edit.
//
// cd test/c/std
// gcc -O3 flate.c && ./a.out && ./a.out -bench; rm -f ./a.out
#include <stddef.h>
#include <stdio.h> // For manual printf debugging.
#ifdef __x86_64__
#define PUFFS_FLATE_HAVE_64_BIT_UNALIGNED_LITTLE_ENDIAN_LOADS
#endif
puffs_flate_status c_puffs_flate_decoder_decode_huffman(
puffs_flate_decoder* self,
puffs_base_writer1 a_dst,
puffs_base_reader1 a_src) {
if (!a_dst.buf || !a_src.buf) {
return PUFFS_FLATE_ERROR_BAD_ARGUMENT;
}
puffs_flate_status status = PUFFS_FLATE_STATUS_OK;
// Load contextual state.
uint8_t* pdst = a_dst.buf->ptr + a_dst.buf->wi;
uint8_t* psrc = a_src.buf->ptr + a_src.buf->ri;
#ifdef PUFFS_FLATE_HAVE_64_BIT_UNALIGNED_LITTLE_ENDIAN_LOADS
uint64_t bits = self->private_impl.f_bits;
#else
uint32_t bits = self->private_impl.f_bits;
#endif
uint32_t n_bits = self->private_impl.f_n_bits;
// Initialize other local variables.
uint8_t* pdst0 = pdst;
uint32_t lmask =
((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
uint32_t dmask =
((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
// NOTE: a reminder that this loop is NOT SAFE, as it does not check that
// pdst and psrc remain within a_dst's and a_src's bounds.
outer_loop:
while (true) {
// Ensure that we have at least 15 bits of input.
if (n_bits < 15) {
#ifdef PUFFS_FLATE_HAVE_64_BIT_UNALIGNED_LITTLE_ENDIAN_LOADS
bits |= *((uint64_t*)psrc) << n_bits;
psrc += 6;
n_bits += 48;
#else
bits |= ((uint32_t)(*psrc++)) << n_bits;
n_bits += 8;
bits |= ((uint32_t)(*psrc++)) << n_bits;
n_bits += 8;
#endif
}
// Decode an lcode symbol from H-L.
uint32_t table_entry = self->private_impl.f_huffs[0][bits & lmask];
while (true) {
uint32_t n = table_entry & 0x0F;
bits >>= n;
n_bits -= n;
if ((table_entry >> 31) != 0) {
// Literal.
*pdst++ = (uint8_t)(table_entry >> 8);
goto outer_loop;
}
if ((table_entry >> 30) != 0) {
// Back-reference; length = base number + extra bits.
break;
}
if ((table_entry >> 29) != 0) {
// End of block.
goto end;
}
if ((table_entry >> 24) != 0x10) {
status =
PUFFS_FLATE_ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE;
goto end;
}
uint32_t top = (table_entry >> 8) & 0xFFFF;
uint32_t mask = ((((uint32_t)(1)) << ((table_entry >> 4) & 0x0F)) - 1);
table_entry = self->private_impl.f_huffs[0][top + (bits & mask)];
}
// length = base number + extra bits.
uint32_t length = (table_entry >> 8) & 0xFFFF;
{
uint32_t n = (table_entry >> 4) & 0x0F;
if (n) {
if (n_bits < n) {
#ifdef PUFFS_FLATE_HAVE_64_BIT_UNALIGNED_LITTLE_ENDIAN_LOADS
bits |= *((uint64_t*)psrc) << n_bits;
psrc += 6;
n_bits += 48;
#else
bits |= ((uint32_t)(*psrc++)) << n_bits;
n_bits += 8;
#endif
}
length += bits & ((((uint32_t)(1)) << n) - 1);
bits >>= n;
n_bits -= n;
}
}
// Ensure that we have at least 15 bits of input.
if (n_bits < 15) {
#ifdef PUFFS_FLATE_HAVE_64_BIT_UNALIGNED_LITTLE_ENDIAN_LOADS
bits |= *((uint64_t*)psrc) << n_bits;
psrc += 6;
n_bits += 48;
#else
bits |= ((uint32_t)(*psrc++)) << n_bits;
n_bits += 8;
bits |= ((uint32_t)(*psrc++)) << n_bits;
n_bits += 8;
#endif
}
// Decode a dcode symbol from H-D.
table_entry = self->private_impl.f_huffs[1][bits & dmask];
while (true) {
uint32_t n = table_entry & 0x0F;
bits >>= n;
n_bits -= n;
if ((table_entry >> 30) != 0) {
// Back-reference; distance = base number + extra bits.
break;
}
if ((table_entry >> 24) != 0x10) {
status =
PUFFS_FLATE_ERROR_INTERNAL_ERROR_INCONSISTENT_HUFFMAN_DECODER_STATE;
goto end;
}
uint32_t top = (table_entry >> 8) & 0xFFFF;
uint32_t mask = ((((uint32_t)(1)) << ((table_entry >> 4) & 0x0F)) - 1);
table_entry = self->private_impl.f_huffs[1][top + (bits & mask)];
}
// distance = base number + extra bits.
uint32_t distance = (table_entry >> 8) & 0xFFFF;
{
uint32_t n = (table_entry >> 4) & 0x0F;
if (n) {
if (n_bits < 15) {
#ifdef PUFFS_FLATE_HAVE_64_BIT_UNALIGNED_LITTLE_ENDIAN_LOADS
bits |= *((uint64_t*)psrc) << n_bits;
psrc += 6;
n_bits += 48;
#else
bits |= ((uint32_t)(*psrc++)) << n_bits;
n_bits += 8;
bits |= ((uint32_t)(*psrc++)) << n_bits;
n_bits += 8;
#endif
}
distance += bits & ((((uint32_t)(1)) << n) - 1);
bits >>= n;
n_bits -= n;
}
}
// TODO: look at a sliding window, not just output written so far to dst.
if ((ptrdiff_t)(distance) > (pdst - pdst0)) {
status = PUFFS_FLATE_ERROR_BAD_ARGUMENT;
goto end;
}
uint8_t* pback = pdst - distance;
#ifdef PUFFS_FLATE_HAVE_64_BIT_UNALIGNED_LITTLE_ENDIAN_LOADS
// Back-copy fast path, copying 8 instead of 1 bytes at a time.
//
// This always copies 8*N bytes (where N is the smallest integer such that
// 8*N >= length, i.e. we round length up to a multiple of 8), instead of
// only length bytes, but that's OK, as subsequent iterations will fix up
// the overrun.
if (distance >= 8) {
while (1) {
*((uint64_t*)(pdst)) = *((uint64_t*)(pback));
if (length <= 8) {
pdst += length;
break;
}
pdst += 8;
pback += 8;
length -= 8;
}
continue;
}
#endif
// Back-copy slow path.
for (; length >= 3; length -= 3) {
*pdst++ = *pback++;
*pdst++ = *pback++;
*pdst++ = *pback++;
}
for (; length; length--) {
*pdst++ = *pback++;
}
}
end:
// Return unused input bytes.
for (; n_bits >= 8; n_bits -= 8) {
psrc--;
}
bits &= (((uint32_t)(1)) << n_bits) - 1;
// Save contextual state.
a_dst.buf->wi = pdst - a_dst.buf->ptr;
a_src.buf->ri = psrc - a_src.buf->ptr;
self->private_impl.f_bits = bits;
self->private_impl.f_n_bits = n_bits;
return status;
}