Files
wuffs/internal/cgen/base/io-private.h
T
Nigel Tao 1dd7ad4413 Optimize std/deflate decoding for RLE sections
name                                                      old speed      new speed      delta

wuffs_deflate_decode_1k_full_init/clang9                   104MB/s ± 1%   104MB/s ± 1%     ~     (p=0.161 n=9+9)
wuffs_deflate_decode_1k_part_init/clang9                   121MB/s ± 1%   119MB/s ± 1%   -0.92%  (p=0.000 n=9+9)
wuffs_deflate_decode_10k_full_init/clang9                  223MB/s ± 1%   223MB/s ± 1%     ~     (p=0.796 n=9+9)
wuffs_deflate_decode_10k_part_init/clang9                  230MB/s ± 1%   228MB/s ± 2%     ~     (p=0.065 n=10+9)
wuffs_deflate_decode_100k_just_one_read/clang9             279MB/s ± 1%   292MB/s ± 0%   +4.78%  (p=0.000 n=9+8)
wuffs_deflate_decode_100k_many_big_reads/clang9            178MB/s ± 5%   189MB/s ± 2%   +6.41%  (p=0.000 n=10+10)

wuffs_deflate_decode_1k_full_init/gcc10                    103MB/s ± 1%   102MB/s ± 1%   -0.57%  (p=0.022 n=10+9)
wuffs_deflate_decode_1k_part_init/gcc10                    122MB/s ± 1%   121MB/s ± 3%   -1.46%  (p=0.000 n=10+9)
wuffs_deflate_decode_10k_full_init/gcc10                   235MB/s ± 1%   231MB/s ± 1%   -1.34%  (p=0.000 n=10+8)
wuffs_deflate_decode_10k_part_init/gcc10                   242MB/s ± 1%   239MB/s ± 0%   -1.40%  (p=0.001 n=9+8)
wuffs_deflate_decode_100k_just_one_read/gcc10              300MB/s ± 4%   297MB/s ± 2%     ~     (p=0.156 n=10+9)
wuffs_deflate_decode_100k_many_big_reads/gcc10             193MB/s ± 2%   197MB/s ± 1%   +2.29%  (p=0.000 n=10+9)

wuffs_gzip_decode_10k/clang9                               220MB/s ± 1%   219MB/s ± 1%     ~     (p=0.605 n=9+9)
wuffs_gzip_decode_100k/clang9                              269MB/s ± 2%   283MB/s ± 2%   +4.98%  (p=0.000 n=9+10)

wuffs_gzip_decode_10k/gcc10                                227MB/s ± 1%   224MB/s ± 1%   -1.42%  (p=0.000 n=10+9)
wuffs_gzip_decode_100k/gcc10                               283MB/s ± 1%   285MB/s ± 4%     ~     (p=0.182 n=9+10)

wuffs_zlib_decode_10k/clang9                               226MB/s ± 1%   220MB/s ± 4%   -2.66%  (p=0.000 n=9+10)
wuffs_zlib_decode_100k/clang9                              272MB/s ± 2%   285MB/s ± 1%   +4.77%  (p=0.000 n=10+8)

wuffs_zlib_decode_10k/gcc10                                227MB/s ± 1%   212MB/s ± 1%   -6.80%  (p=0.000 n=10+9)
wuffs_zlib_decode_100k/gcc10                               282MB/s ± 1%   273MB/s ± 0%   -3.32%  (p=0.000 n=9+8)

wuffs_png_decode_image_19k_8bpp/clang9                     148MB/s ± 1%   138MB/s ± 2%   -6.79%  (p=0.000 n=9+10)
wuffs_png_decode_image_40k_24bpp/clang9                    170MB/s ± 1%   171MB/s ± 2%     ~     (p=0.133 n=9+10)
wuffs_png_decode_image_77k_8bpp/clang9                     525MB/s ± 1%   495MB/s ± 4%   -5.81%  (p=0.000 n=8+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9   400MB/s ± 2%   457MB/s ± 4%  +14.16%  (p=0.000 n=9+9)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9   388MB/s ± 1%   435MB/s ± 5%  +12.17%  (p=0.000 n=9+10)
wuffs_png_decode_image_4002k_24bpp/clang9                  175MB/s ± 1%   172MB/s ± 2%   -1.78%  (p=0.005 n=10+10)

wuffs_png_decode_image_19k_8bpp/gcc10                      154MB/s ± 3%   157MB/s ± 1%   +1.72%  (p=0.001 n=9+9)
wuffs_png_decode_image_40k_24bpp/gcc10                     182MB/s ± 1%   187MB/s ± 1%   +2.56%  (p=0.000 n=9+10)
wuffs_png_decode_image_77k_8bpp/gcc10                      552MB/s ± 3%   554MB/s ± 1%     ~     (p=0.863 n=9+9)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc10    426MB/s ± 2%   502MB/s ± 1%  +17.85%  (p=0.000 n=10+10)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc10    410MB/s ± 2%   481MB/s ± 1%  +17.17%  (p=0.000 n=9+8)
wuffs_png_decode_image_4002k_24bpp/gcc10                   186MB/s ± 1%   189MB/s ± 2%   +1.33%  (p=0.001 n=9+10)
2021-04-09 14:31:52 +10:00

377 lines
11 KiB
C

// After editing this file, run "go generate" in the ../data directory.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ---------------- I/O
static inline uint64_t //
wuffs_base__io__count_since(uint64_t mark, uint64_t index) {
if (index >= mark) {
return index - mark;
}
return 0;
}
// TODO: drop the "const" in "const uint8_t* ptr". Some though required about
// the base.io_reader.since method returning a mutable "slice base.u8".
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
#endif
static inline wuffs_base__slice_u8 //
wuffs_base__io__since(uint64_t mark, uint64_t index, const uint8_t* ptr) {
if (index >= mark) {
return wuffs_base__make_slice_u8(((uint8_t*)ptr) + mark,
((size_t)(index - mark)));
}
return wuffs_base__make_slice_u8(NULL, 0);
}
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
// --------
static inline void //
wuffs_base__io_reader__limit(const uint8_t** ptr_io2_r,
const uint8_t* iop_r,
uint64_t limit) {
if (((uint64_t)(*ptr_io2_r - iop_r)) > limit) {
*ptr_io2_r = iop_r + limit;
}
}
static inline uint32_t //
wuffs_base__io_reader__limited_copy_u32_to_slice(const uint8_t** ptr_iop_r,
const uint8_t* io2_r,
uint32_t length,
wuffs_base__slice_u8 dst) {
const uint8_t* iop_r = *ptr_iop_r;
size_t n = dst.len;
if (n > length) {
n = length;
}
if (n > ((size_t)(io2_r - iop_r))) {
n = (size_t)(io2_r - iop_r);
}
if (n > 0) {
memmove(dst.ptr, iop_r, n);
*ptr_iop_r += n;
}
return (uint32_t)(n);
}
// wuffs_base__io_reader__match7 returns whether the io_reader's upcoming bytes
// start with the given prefix (up to 7 bytes long). It is peek-like, not
// read-like, in that there are no side-effects.
//
// The low 3 bits of a hold the prefix length, n.
//
// The high 56 bits of a hold the prefix itself, in little-endian order. The
// first prefix byte is in bits 8..=15, the second prefix byte is in bits
// 16..=23, etc. The high (8 * (7 - n)) bits are ignored.
//
// There are three possible return values:
// - 0 means success.
// - 1 means inconclusive, equivalent to "$short read".
// - 2 means failure.
static inline uint32_t //
wuffs_base__io_reader__match7(const uint8_t* iop_r,
const uint8_t* io2_r,
wuffs_base__io_buffer* r,
uint64_t a) {
uint32_t n = a & 7;
a >>= 8;
if ((io2_r - iop_r) >= 8) {
uint64_t x = wuffs_base__peek_u64le__no_bounds_check(iop_r);
uint32_t shift = 8 * (8 - n);
return ((a << shift) == (x << shift)) ? 0 : 2;
}
for (; n > 0; n--) {
if (iop_r >= io2_r) {
return (r && r->meta.closed) ? 2 : 1;
} else if (*iop_r != ((uint8_t)(a))) {
return 2;
}
iop_r++;
a >>= 8;
}
return 0;
}
static inline wuffs_base__io_buffer* //
wuffs_base__io_reader__set(wuffs_base__io_buffer* b,
const uint8_t** ptr_iop_r,
const uint8_t** ptr_io0_r,
const uint8_t** ptr_io1_r,
const uint8_t** ptr_io2_r,
wuffs_base__slice_u8 data) {
b->data = data;
b->meta.wi = data.len;
b->meta.ri = 0;
b->meta.pos = 0;
b->meta.closed = false;
*ptr_iop_r = data.ptr;
*ptr_io0_r = data.ptr;
*ptr_io1_r = data.ptr;
*ptr_io2_r = data.ptr + data.len;
return b;
}
// --------
static inline uint64_t //
wuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w,
uint8_t* io2_w,
wuffs_base__slice_u8 src) {
uint8_t* iop_w = *ptr_iop_w;
size_t n = src.len;
if (n > ((size_t)(io2_w - iop_w))) {
n = (size_t)(io2_w - iop_w);
}
if (n > 0) {
memmove(iop_w, src.ptr, n);
*ptr_iop_w += n;
}
return (uint64_t)(n);
}
static inline void //
wuffs_base__io_writer__limit(uint8_t** ptr_io2_w,
uint8_t* iop_w,
uint64_t limit) {
if (((uint64_t)(*ptr_io2_w - iop_w)) > limit) {
*ptr_io2_w = iop_w + limit;
}
}
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
uint8_t* io1_w,
uint8_t* io2_w,
uint32_t length,
uint32_t distance) {
if (!distance) {
return 0;
}
uint8_t* p = *ptr_iop_w;
if ((size_t)(p - io1_w) < (size_t)(distance)) {
return 0;
}
uint8_t* q = p - distance;
size_t n = (size_t)(io2_w - p);
if ((size_t)(length) > n) {
length = (uint32_t)(n);
} else {
n = (size_t)(length);
}
// TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that
// is mostly because 3 is the minimum length for the deflate format. This
// function implementation shouldn't overfit to that one format. Perhaps the
// limited_copy_u32_from_history Wuffs method should also take an unroll hint
// argument, and the cgen can look if that argument is the constant
// expression '3'.
//
// See also wuffs_base__io_writer__limited_copy_u32_from_history_fast below.
for (; n >= 3; n -= 3) {
*p++ = *q++;
*p++ = *q++;
*p++ = *q++;
}
for (; n; n--) {
*p++ = *q++;
}
*ptr_iop_w = p;
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_fast is like the
// wuffs_base__io_writer__limited_copy_u32_from_history function above, but has
// stronger pre-conditions.
//
// The caller needs to prove that:
// - length <= (io2_w - *ptr_iop_w)
// - distance >= 1
// - distance <= (*ptr_iop_w - io1_w)
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
uint8_t* io1_w,
uint8_t* io2_w,
uint32_t length,
uint32_t distance) {
uint8_t* p = *ptr_iop_w;
uint8_t* q = p - distance;
uint32_t n = length;
for (; n >= 3; n -= 3) {
*p++ = *q++;
*p++ = *q++;
*p++ = *q++;
}
for (; n; n--) {
*p++ = *q++;
}
*ptr_iop_w = p;
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast
// copies the previous byte (the one immediately before *ptr_iop_w), copying 8
// byte chunks at a time. Each chunk contains 8 repetitions of the same byte.
//
// In terms of number of bytes copied, length is rounded up to a multiple of 8.
// As a special case, a zero length rounds up to 8 (even though 0 is already a
// multiple of 8), since there is always at least one 8 byte chunk copied.
//
// In terms of advancing *ptr_iop_w, length is not rounded up.
//
// The caller needs to prove that:
// - (length + 8) <= (io2_w - *ptr_iop_w)
// - distance == 1
// - distance <= (*ptr_iop_w - io1_w)
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
uint8_t** ptr_iop_w,
uint8_t* io1_w,
uint8_t* io2_w,
uint32_t length,
uint32_t distance) {
uint8_t* p = *ptr_iop_w;
uint64_t x = p[-1];
x |= x << 8;
x |= x << 16;
x |= x << 32;
uint32_t n = length;
while (1) {
wuffs_base__poke_u64le__no_bounds_check(p, x);
if (n <= 8) {
p += n;
break;
}
p += 8;
n -= 8;
}
*ptr_iop_w = p;
return length;
}
// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast is
// like the wuffs_base__io_writer__limited_copy_u32_from_history_fast function
// above, but copies 8 byte chunks at a time.
//
// In terms of number of bytes copied, length is rounded up to a multiple of 8.
// As a special case, a zero length rounds up to 8 (even though 0 is already a
// multiple of 8), since there is always at least one 8 byte chunk copied.
//
// In terms of advancing *ptr_iop_w, length is not rounded up.
//
// The caller needs to prove that:
// - (length + 8) <= (io2_w - *ptr_iop_w)
// - distance >= 8
// - distance <= (*ptr_iop_w - io1_w)
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(
uint8_t** ptr_iop_w,
uint8_t* io1_w,
uint8_t* io2_w,
uint32_t length,
uint32_t distance) {
uint8_t* p = *ptr_iop_w;
uint8_t* q = p - distance;
uint32_t n = length;
while (1) {
memcpy(p, q, 8);
if (n <= 8) {
p += n;
break;
}
p += 8;
q += 8;
n -= 8;
}
*ptr_iop_w = p;
return length;
}
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_reader(uint8_t** ptr_iop_w,
uint8_t* io2_w,
uint32_t length,
const uint8_t** ptr_iop_r,
const uint8_t* io2_r) {
uint8_t* iop_w = *ptr_iop_w;
size_t n = length;
if (n > ((size_t)(io2_w - iop_w))) {
n = (size_t)(io2_w - iop_w);
}
const uint8_t* iop_r = *ptr_iop_r;
if (n > ((size_t)(io2_r - iop_r))) {
n = (size_t)(io2_r - iop_r);
}
if (n > 0) {
memmove(iop_w, iop_r, n);
*ptr_iop_w += n;
*ptr_iop_r += n;
}
return (uint32_t)(n);
}
static inline uint32_t //
wuffs_base__io_writer__limited_copy_u32_from_slice(uint8_t** ptr_iop_w,
uint8_t* io2_w,
uint32_t length,
wuffs_base__slice_u8 src) {
uint8_t* iop_w = *ptr_iop_w;
size_t n = src.len;
if (n > length) {
n = length;
}
if (n > ((size_t)(io2_w - iop_w))) {
n = (size_t)(io2_w - iop_w);
}
if (n > 0) {
memmove(iop_w, src.ptr, n);
*ptr_iop_w += n;
}
return (uint32_t)(n);
}
static inline wuffs_base__io_buffer* //
wuffs_base__io_writer__set(wuffs_base__io_buffer* b,
uint8_t** ptr_iop_w,
uint8_t** ptr_io0_w,
uint8_t** ptr_io1_w,
uint8_t** ptr_io2_w,
wuffs_base__slice_u8 data) {
b->data = data;
b->meta.wi = 0;
b->meta.ri = 0;
b->meta.pos = 0;
b->meta.closed = false;
*ptr_iop_w = data.ptr;
*ptr_io0_w = data.ptr;
*ptr_io1_w = data.ptr;
*ptr_io2_w = data.ptr + data.len;
return b;
}
// ---------------- I/O (Utility)
#define wuffs_base__utility__empty_io_reader wuffs_base__empty_io_reader
#define wuffs_base__utility__empty_io_writer wuffs_base__empty_io_writer