mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 00:38:14 +01:00
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)
377 lines
11 KiB
C
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
|