From 3056a843934241c79b4e09209d8443f8e1eaa9f2 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 3 Feb 2019 15:25:53 +1100 Subject: [PATCH] Roll back 3 recent lzw.decoder.suffixes commits MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Specifically: 49627b4 Flatten the lzw.decoder.suffixes array f877fb2 Use the workbuf instead of lzw.decoder.suffixes 85be5b9 Delete the obsolete lzw.decoder.suffixes array name old speed new speed delta wuffs_lzw_decode_20k/clang5 247MB/s ± 0% 265MB/s ± 0% +7.31% (p=0.008 n=5+5) wuffs_lzw_decode_100k/clang5 407MB/s ± 0% 452MB/s ± 1% +11.21% (p=0.008 n=5+5) wuffs_lzw_decode_20k/gcc7 238MB/s ± 1% 263MB/s ± 1% +10.81% (p=0.008 n=5+5) wuffs_lzw_decode_100k/gcc7 384MB/s ± 0% 482MB/s ± 2% +25.54% (p=0.008 n=5+5) wuffs_gif_decode_1k_bw/clang5 318MB/s ± 0% 241MB/s ± 1% -24.15% (p=0.008 n=5+5) wuffs_gif_decode_1k_color/clang5 154MB/s ± 0% 141MB/s ± 1% -8.58% (p=0.008 n=5+5) wuffs_gif_decode_10k_bgra/clang5 697MB/s ± 1% 721MB/s ± 0% +3.53% (p=0.008 n=5+5) wuffs_gif_decode_10k_indexed/clang5 186MB/s ± 0% 194MB/s ± 1% +4.20% (p=0.008 n=5+5) wuffs_gif_decode_20k/clang5 226MB/s ± 1% 246MB/s ± 1% +8.85% (p=0.008 n=5+5) wuffs_gif_decode_100k_artificial/clang5 508MB/s ± 1% 551MB/s ± 0% +8.33% (p=0.008 n=5+5) wuffs_gif_decode_100k_realistic/clang5 203MB/s ± 0% 227MB/s ± 0% +11.88% (p=0.008 n=5+5) wuffs_gif_decode_1000k/clang5 206MB/s ± 0% 231MB/s ± 0% +12.46% (p=0.008 n=5+5) wuffs_gif_decode_anim_screencap/clang5 1.03GB/s ± 0% 1.10GB/s ± 0% +5.85% (p=0.008 n=5+5) wuffs_gif_decode_1k_bw/gcc7 398MB/s ± 0% 265MB/s ± 1% -33.35% (p=0.008 n=5+5) wuffs_gif_decode_1k_color/gcc7 161MB/s ± 0% 145MB/s ± 1% -9.74% (p=0.008 n=5+5) wuffs_gif_decode_10k_bgra/gcc7 604MB/s ± 1% 622MB/s ± 1% +2.94% (p=0.008 n=5+5) wuffs_gif_decode_10k_indexed/gcc7 187MB/s ± 1% 194MB/s ± 0% +3.83% (p=0.008 n=5+5) wuffs_gif_decode_20k/gcc7 227MB/s ± 0% 234MB/s ± 1% +3.09% (p=0.008 n=5+5) wuffs_gif_decode_100k_artificial/gcc7 492MB/s ± 0% 506MB/s ± 1% +2.91% (p=0.008 n=5+5) wuffs_gif_decode_100k_realistic/gcc7 201MB/s ± 0% 210MB/s ± 1% +4.42% (p=0.008 n=5+5) wuffs_gif_decode_1000k/gcc7 203MB/s ± 0% 213MB/s ± 0% +4.97% (p=0.008 n=5+5) wuffs_gif_decode_anim_screencap/gcc7 1.04GB/s ± 0% 1.06GB/s ± 0% +2.61% (p=0.008 n=5+5) --- release/c/wuffs-unsupported-snapshot.c | 66 +++++++++++--------------- std/gif/decode_gif.wuffs | 14 +++--- std/lzw/decode_lzw.wuffs | 59 +++++++---------------- test/c/std/gif.c | 4 +- 4 files changed, 56 insertions(+), 87 deletions(-) diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index df20a6f6..f93fd9ab 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -2820,11 +2820,11 @@ extern const char* wuffs_lzw__error__bad_code; // ---------------- Public Consts -#define WUFFS_LZW__DECODER_WORKBUF_LEN_MAX_INCL 32768 +#define WUFFS_LZW__DECODER_WORKBUF_LEN_MAX_INCL 0 static const uint64_t // wuffs_lzw__decoder_workbuf_len_max_incl // - WUFFS_BASE__POTENTIALLY_UNUSED = 32768; + WUFFS_BASE__POTENTIALLY_UNUSED = 0; // ---------------- Struct Declarations @@ -2896,6 +2896,7 @@ struct wuffs_lzw__decoder__struct { uint32_t f_output_ri; uint32_t f_output_wi; uint32_t f_read_from_return_value; + uint8_t f_suffixes[4096][8]; uint16_t f_prefixes[4096]; uint16_t f_lm1s[4096]; uint8_t f_output[8199]; @@ -2993,11 +2994,11 @@ extern const char* wuffs_gif__error__too_much_pixel_data; // ---------------- Public Consts -#define WUFFS_GIF__DECODER_WORKBUF_LEN_MAX_INCL 98303 +#define WUFFS_GIF__DECODER_WORKBUF_LEN_MAX_INCL 65535 static const uint64_t // wuffs_gif__decoder_workbuf_len_max_incl // - WUFFS_BASE__POTENTIALLY_UNUSED = 98303; + WUFFS_BASE__POTENTIALLY_UNUSED = 65535; // ---------------- Struct Declarations @@ -7737,8 +7738,7 @@ const char* wuffs_lzw__error__internal_error_inconsistent_i_o = static wuffs_base__empty_struct // wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, - wuffs_base__io_reader a_src, - wuffs_base__slice_u8 a_workbuf); + wuffs_base__io_reader a_src); static wuffs_base__status // wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self, @@ -7853,23 +7853,15 @@ wuffs_lzw__decoder__decode_io_writer(wuffs_lzw__decoder* self, self->private_impl.f_n_bits = 0; self->private_impl.f_output_ri = 0; self->private_impl.f_output_wi = 0; - if (((uint64_t)(a_workbuf.len)) < 32768) { - status = wuffs_base__error__bad_workbuf_length; - goto exit; - } v_i = 0; while (v_i < self->private_impl.f_clear_code) { self->private_impl.f_lm1s[v_i] = 0; - a_workbuf.ptr[((uint64_t)(((8 * v_i) + 0)))] = ((uint8_t)(v_i)); + self->private_impl.f_suffixes[v_i][0] = ((uint8_t)(v_i)); v_i += 1; } label_0_continue:; while (true) { - if (((uint64_t)(a_workbuf.len)) < 32768) { - status = wuffs_base__error__bad_workbuf_length; - goto exit; - } - wuffs_lzw__decoder__read_from(self, a_src, a_workbuf); + wuffs_lzw__decoder__read_from(self, a_src); if (self->private_impl.f_output_wi > 0) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); status = wuffs_lzw__decoder__write_to(self, a_dst); @@ -7917,8 +7909,7 @@ exit: static wuffs_base__empty_struct // wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, - wuffs_base__io_reader a_src, - wuffs_base__slice_u8 a_workbuf) { + wuffs_base__io_reader a_src) { uint32_t v_clear_code = 0; uint32_t v_end_code = 0; uint32_t v_save_code = 0; @@ -7950,9 +7941,6 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, io1_a_src = a_src.private_impl.limit; } - if (((uint64_t)(a_workbuf.len)) < 32768) { - return ((wuffs_base__empty_struct){}); - } v_clear_code = self->private_impl.f_clear_code; v_end_code = self->private_impl.f_end_code; v_save_code = self->private_impl.f_save_code; @@ -8003,14 +7991,15 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, if ((v_lm1_a % 8) != 0) { self->private_impl.f_prefixes[v_save_code] = self->private_impl.f_prefixes[v_prev_code]; - memcpy((a_workbuf.ptr) + ((8 * v_save_code)), - (a_workbuf.ptr) + ((8 * v_prev_code)), 8); - a_workbuf.ptr[((8 * v_save_code) + ((uint32_t)((v_lm1_a % 8))))] = + memcpy(self->private_impl.f_suffixes[v_save_code], + self->private_impl.f_suffixes[v_prev_code], + sizeof(self->private_impl.f_suffixes[v_save_code])); + self->private_impl.f_suffixes[v_save_code][(v_lm1_a % 8)] = ((uint8_t)(v_code)); } else { self->private_impl.f_prefixes[v_save_code] = ((uint16_t)(v_prev_code)); - a_workbuf.ptr[((8 * v_save_code) + 0)] = ((uint8_t)(v_code)); + self->private_impl.f_suffixes[v_save_code][0] = ((uint8_t)(v_code)); } v_save_code += 1; if (v_width < 12) { @@ -8040,7 +8029,7 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, v_steps = (((uint32_t)(self->private_impl.f_lm1s[v_c])) >> 3); while (true) { memcpy((self->private_impl.f_output) + (v_o), - (a_workbuf.ptr) + ((8 * v_c)), 8); + (self->private_impl.f_suffixes[v_c]), 8); if (v_steps <= 0) { goto label_1_break; } @@ -8049,7 +8038,7 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, v_c = ((uint32_t)(self->private_impl.f_prefixes[v_c])); } label_1_break:; - v_first_byte = a_workbuf.ptr[((8 * v_c) + 0)]; + v_first_byte = self->private_impl.f_suffixes[v_c][0]; if (v_code == v_save_code) { self->private_impl.f_output[v_output_wi] = v_first_byte; v_output_wi = ((v_output_wi + 1) & 8191); @@ -8060,14 +8049,16 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, if ((v_lm1_b % 8) != 0) { self->private_impl.f_prefixes[v_save_code] = self->private_impl.f_prefixes[v_prev_code]; - memcpy((a_workbuf.ptr) + ((8 * v_save_code)), - (a_workbuf.ptr) + ((8 * v_prev_code)), 8); - a_workbuf.ptr[((8 * v_save_code) + ((uint32_t)((v_lm1_b % 8))))] = + memcpy(self->private_impl.f_suffixes[v_save_code], + self->private_impl.f_suffixes[v_prev_code], + sizeof(self->private_impl.f_suffixes[v_save_code])); + self->private_impl.f_suffixes[v_save_code][(v_lm1_b % 8)] = v_first_byte; } else { self->private_impl.f_prefixes[v_save_code] = ((uint16_t)(v_prev_code)); - a_workbuf.ptr[((8 * v_save_code) + 0)] = ((uint8_t)(v_first_byte)); + self->private_impl.f_suffixes[v_save_code][0] = + ((uint8_t)(v_first_byte)); } v_save_code += 1; if (v_width < 12) { @@ -8517,8 +8508,8 @@ wuffs_gif__decoder__workbuf_len(const wuffs_gif__decoder* self) { } return wuffs_base__utility__make_range_ii_u64( - (32768 + ((uint64_t)(self->private_impl.f_width))), - (32768 + ((uint64_t)(self->private_impl.f_width)))); + ((uint64_t)(self->private_impl.f_width)), + ((uint64_t)(self->private_impl.f_width))); } // -------- func gif.decoder.restart_frame @@ -10223,11 +10214,11 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self, (iop_a_src += 1, wuffs_base__return_empty_struct()); } label_1_break:; - if ((32768 + ((uint64_t)(self->private_impl.f_width))) < + if (((uint64_t)(self->private_impl.f_width)) < ((uint64_t)(a_workbuf.len))) { a_workbuf = wuffs_base__slice_u8__subslice_j( - a_workbuf, (32768 + ((uint64_t)(self->private_impl.f_width)))); - } else if ((32768 + ((uint64_t)(self->private_impl.f_width))) > + a_workbuf, ((uint64_t)(self->private_impl.f_width))); + } else if (((uint64_t)(self->private_impl.f_width)) > ((uint64_t)(a_workbuf.len))) { status = wuffs_base__error__bad_workbuf_length; goto exit; @@ -10257,7 +10248,8 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self, u_r.meta.ri = iop_v_r - u_r.data.ptr; wuffs_base__status t_1 = wuffs_lzw__decoder__decode_io_writer( &self->private_impl.f_lzw, - wuffs_base__utility__null_io_writer(), v_r, a_workbuf); + wuffs_base__utility__null_io_writer(), v_r, + wuffs_base__utility__null_slice_u8()); iop_v_r = u_r.data.ptr + u_r.meta.ri; v_lzw_status = t_1; } diff --git a/std/gif/decode_gif.wuffs b/std/gif/decode_gif.wuffs index 53d697f6..b0e4327d 100644 --- a/std/gif/decode_gif.wuffs +++ b/std/gif/decode_gif.wuffs @@ -25,7 +25,7 @@ pub status "?too much pixel data" pri status "?internal error: inconsistent ri/wi" // TODO: reference lzw.decoder_workbuf_len_max_incl. -pub const decoder_workbuf_len_max_incl base.u64 = 32768 + 0xFFFF +pub const decoder_workbuf_len_max_incl base.u64 = 0xFFFF // See the spec appendix E "Interlaced Images" on page 29. The first element // represents either that the frame was non-interlaced, or that all interlace @@ -184,8 +184,8 @@ pub func decoder.frame_dirty_rect() base.rect_ie_u32 { pub func decoder.workbuf_len() base.range_ii_u64 { return this.util.make_range_ii_u64( - min_incl:32768 + (this.width as base.u64), - max_incl:32768 + (this.width as base.u64)) + min_incl:this.width as base.u64, + max_incl:this.width as base.u64) } pub func decoder.restart_frame!(index base.u64, io_position base.u64) base.status { @@ -707,9 +707,9 @@ pri func decoder.decode_id_part2?(dst ptr base.pixel_buffer, src base.io_reader, args.src.skip_fast!(actual:1, worst_case:1) } - if (32768 + (this.width as base.u64)) < args.workbuf.length() { - args.workbuf = args.workbuf[:32768 + (this.width as base.u64)] - } else if (32768 + (this.width as base.u64)) > args.workbuf.length() { + if (this.width as base.u64) < args.workbuf.length() { + args.workbuf = args.workbuf[:this.width as base.u64] + } else if (this.width as base.u64) > args.workbuf.length() { return base."?bad workbuf length" } @@ -719,7 +719,7 @@ pri func decoder.decode_id_part2?(dst ptr base.pixel_buffer, src base.io_reader, } io_bind (io:r, data:this.compressed[this.compressed_ri:this.compressed_wi]) { lzw_status =? this.lzw.decode_io_writer?( - dst:this.util.null_io_writer(), src:r, workbuf:args.workbuf) + dst:this.util.null_io_writer(), src:r, workbuf:this.util.null_slice_u8()) this.compressed_ri ~sat+= r.since_mark().length() } diff --git a/std/lzw/decode_lzw.wuffs b/std/lzw/decode_lzw.wuffs index b449b2c9..f7ec8986 100644 --- a/std/lzw/decode_lzw.wuffs +++ b/std/lzw/decode_lzw.wuffs @@ -16,8 +16,9 @@ pub status "?bad code" pri status "?internal error: inconsistent I/O" -// The suffixes table is 8 bytes per code, so 4096 * 8 = 32768 bytes. -pub const decoder_workbuf_len_max_incl base.u64 = 32768 +// TODO: move bulk data buffers like decoder.suffixes or decoder.output into +// the workbuf? +pub const decoder_workbuf_len_max_incl base.u64 = 0 pub struct decoder?( // The value passed to set_literal_width. This lw field is copied to the @@ -46,6 +47,7 @@ pub struct decoder?( read_from_return_value base.u32, // read_from per-code state. + suffixes array[4096] array[8] base.u8, prefixes array[4096] base.u16[..4095], // lm1s is the "length minus 1"s of the values for the implicit key-value // table in this decoder. See std/lzw/README.md for more detail. @@ -83,25 +85,16 @@ pub func decoder.decode_io_writer?(dst base.io_writer, src base.io_reader, workb this.n_bits = 0 this.output_ri = 0 this.output_wi = 0 - - if args.workbuf.length() < 32768 { - return base."?bad workbuf length" - } i = 0 - while i < this.clear_code, - inv args.workbuf.length() >= 32768, - { + while i < this.clear_code { assert i < 256 via "a < b: a < c; c <= b"(c:this.clear_code) this.lm1s[i] = 0 - args.workbuf[((8 * i) + 0) as base.u64] = i as base.u8 + this.suffixes[i][0] = i as base.u8 i += 1 } while true { - if args.workbuf.length() < 32768 { - return base."?bad workbuf length" - } - this.read_from!(src:args.src, workbuf:args.workbuf) + this.read_from!(src:args.src) if this.output_wi > 0 { this.write_to?(dst:args.dst) @@ -121,7 +114,7 @@ pub func decoder.decode_io_writer?(dst base.io_writer, src base.io_reader, workb } } -pri func decoder.read_from!(src base.io_reader, workbuf slice base.u8) { +pri func decoder.read_from!(src base.io_reader) { var clear_code base.u32[..256] var end_code base.u32[..257] @@ -140,10 +133,6 @@ pri func decoder.read_from!(src base.io_reader, workbuf slice base.u8) { var lm1_b base.u16[..4095] var lm1_a base.u16[..4095] - if args.workbuf.length() < 32768 { - return nothing - } - clear_code = this.clear_code end_code = this.end_code @@ -154,9 +143,7 @@ pri func decoder.read_from!(src base.io_reader, workbuf slice base.u8) { n_bits = this.n_bits output_wi = this.output_wi - while true, - inv args.workbuf.length() >= 32768, - { + while true { if n_bits < width { assert n_bits < 12 via "a < b: a < c; c <= b"(c:width) if args.src.available() >= 4 { @@ -209,15 +196,12 @@ pri func decoder.read_from!(src base.io_reader, workbuf slice base.u8) { this.lm1s[save_code] = lm1_a if (lm1_a % 8) != 0 { - assert (8 * save_code) <= ((8 * save_code) + 8) via "a <= (a + b): 0 <= b"(b:8) - assert (8 * prev_code) <= ((8 * prev_code) + 8) via "a <= (a + b): 0 <= b"(b:8) this.prefixes[save_code] = this.prefixes[prev_code] - args.workbuf[(8 * save_code):(8 * save_code) + 8].copy_from_slice!( - s:args.workbuf[(8 * prev_code):(8 * prev_code) + 8]) - args.workbuf[(8 * save_code) + ((lm1_a % 8) as base.u32)] = code as base.u8 + this.suffixes[save_code] = this.suffixes[prev_code] + this.suffixes[save_code][lm1_a % 8] = code as base.u8 } else { this.prefixes[save_code] = prev_code as base.u16 - args.workbuf[(8 * save_code) + 0] = code as base.u8 + this.suffixes[save_code][0] = code as base.u8 } save_code += 1 @@ -255,17 +239,13 @@ pri func decoder.read_from!(src base.io_reader, workbuf slice base.u8) { output_wi = (output_wi + 1 + (this.lm1s[c] as base.u32)) & 8191 steps = (this.lm1s[c] as base.u32) >> 3 - while true, - inv args.workbuf.length() >= 32768, - { + while true { assert o <= (o + 8) via "a <= (a + b): 0 <= b"(b:8) - assert (8 * c) <= ((8 * c) + 8) via "a <= (a + b): 0 <= b"(b:8) - assert ((8 * c) + 8) <= 32768 // The final "8" is redundant semantically, but helps the // wuffs-c code generator recognize that both slices have the // same constant length, and hence produce efficient C code. - this.output[o:o + 8].copy_from_slice!(s:args.workbuf[(8 * c):(8 * c) + 8]) + this.output[o:o + 8].copy_from_slice!(s:this.suffixes[c][:8]) if steps <= 0 { break @@ -277,7 +257,7 @@ pri func decoder.read_from!(src base.io_reader, workbuf slice base.u8) { o = (o ~mod- 8) & 8191 c = this.prefixes[c] as base.u32 } - first_byte = args.workbuf[(8 * c) + 0] + first_byte = this.suffixes[c][0] if code == save_code { this.output[output_wi] = first_byte @@ -289,15 +269,12 @@ pri func decoder.read_from!(src base.io_reader, workbuf slice base.u8) { this.lm1s[save_code] = lm1_b if (lm1_b % 8) != 0 { - assert (8 * save_code) <= ((8 * save_code) + 8) via "a <= (a + b): 0 <= b"(b:8) - assert (8 * prev_code) <= ((8 * prev_code) + 8) via "a <= (a + b): 0 <= b"(b:8) this.prefixes[save_code] = this.prefixes[prev_code] - args.workbuf[(8 * save_code):(8 * save_code) + 8].copy_from_slice!( - s:args.workbuf[(8 * prev_code):(8 * prev_code) + 8]) - args.workbuf[(8 * save_code) + ((lm1_b % 8) as base.u32)] = first_byte + this.suffixes[save_code] = this.suffixes[prev_code] + this.suffixes[save_code][lm1_b % 8] = first_byte } else { this.prefixes[save_code] = prev_code as base.u16 - args.workbuf[(8 * save_code) + 0] = first_byte as base.u8 + this.suffixes[save_code][0] = first_byte as base.u8 } save_code += 1 diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 94fca683..27d26991 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -311,8 +311,8 @@ const char* do_test_wuffs_gif_decode(const char* filename, } } - if (wuffs_gif__decoder__workbuf_len(&dec).min_incl != 32768 + 160) { - RETURN_FAIL("workbuf_len: got %" PRIu64 ", want 32768 + 160", + if (wuffs_gif__decoder__workbuf_len(&dec).min_incl != 160) { + RETURN_FAIL("workbuf_len: got %" PRIu64 ", want 160", wuffs_gif__decoder__workbuf_len(&dec).min_incl); }