Have std/bzip2 read 4 (not 1) bytes per inner loop

name                             old speed      new speed      delta

wuffs_bzip2_decode_10k/clang11   42.9MB/s ± 0%  46.5MB/s ± 0%   +8.38%  (p=0.008 n=5+5)
wuffs_bzip2_decode_100k/clang11  36.9MB/s ± 0%  39.4MB/s ± 1%   +6.75%  (p=0.008 n=5+5)

wuffs_bzip2_decode_10k/gcc10     36.5MB/s ± 0%  43.8MB/s ± 0%  +19.73%  (p=0.008 n=5+5)
wuffs_bzip2_decode_100k/gcc10    30.8MB/s ± 0%  35.9MB/s ± 0%  +16.37%  (p=0.008 n=5+5)
This commit is contained in:
Nigel Tao committed 2022-05-23 15:22:31 +10:00
1 parent 94a2c704d4
commit fdad12d59f
4 files changed
+395 -132

No files matched your search

+120
View File
@@ -0,0 +1,120 @@
// Copyright 2022 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.
pri func decoder.decode_block_fast!(src: base.io_reader) base.status {
var bits : base.u32
var n_bits : base.u32[..= 31]
var block_size : base.u32[..= 900000]
var which : base.u8[..= 5]
var ticks : base.u32[..= 50]
var section : base.u32
var run_shift : base.u32[..= 23]
var child : base.u16
var child_ff : base.u32[..= 255]
var i : base.u32
var j : base.u32
var output : base.u32[..= 255]
var run : base.u32[..= 16_777216] // 16_777216 = (2 << 23)
var mtft0 : base.u32[..= 255]
bits = this.bits
n_bits = this.n_bits
block_size = this.block_size
which = this.decode_block_which
ticks = this.decode_block_ticks
section = this.decode_block_section
run_shift = this.decode_block_run_shift
// Apply the Huffman trees.
while.outer args.src.length() >= 4 {
if ticks > 0 {
ticks -= 1
} else {
ticks = 49
section ~mod+= 1
which = CLAMP_TO_5[this.huffman_selectors[section & 32767] & 7]
}
bits |= args.src.peek_u32be() >> n_bits
args.src.skip_u32_fast!(actual: (31 - n_bits) >> 3, worst_case: 4)
n_bits |= 24
child = 0
while child < 1024 {
child = this.huffman_trees[which][child][bits >> 31]
bits ~mod<<= 1
if n_bits <= 0 {
return "#internal error: inconsistent Huffman decoder state"
}
n_bits -= 1
} endwhile
if child < 1280 { // mNN symbol.
// Move to front.
child_ff = (child & 0xFF) as base.u32
output = this.mtft[child_ff] as base.u32
this.mtft[1 .. 1 + child_ff].copy_from_slice!(
s: this.mtft[.. child_ff])
this.mtft[0] = output as base.u8
this.letter_counts[output] ~mod+= 1
this.bwt[block_size] = output
if block_size >= this.max_incl_block_size {
return "#bad block length"
}
assert block_size < 900000 via "a < b: a < c; c <= b"(c: this.max_incl_block_size)
block_size += 1
run_shift = 0
continue.outer
} else if child > 1281 { // EOB symbol.
this.decode_block_finished = true
break.outer
}
// RUNA or RUNB symbol.
if run_shift >= 23 {
return "#bad block length"
}
run = ((child - 1279) as base.u32) << run_shift
run_shift += 1
i = block_size
j = run + block_size
if j > this.max_incl_block_size {
return "#bad block length"
}
assert j <= 900000 via "a <= b: a <= c; c <= b"(c: this.max_incl_block_size)
block_size = j
mtft0 = this.mtft[0] as base.u32
this.letter_counts[mtft0] ~mod+= run
while i < j,
pre j <= 900000,
{
assert i < 900000 via "a < b: a < c; c <= b"(c: j)
this.bwt[i] = mtft0
i += 1
} endwhile
} endwhile.outer
this.bits = bits
this.n_bits = n_bits
this.block_size = block_size
this.decode_block_which = which
this.decode_block_ticks = ticks
this.decode_block_section = section
this.decode_block_run_shift = run_shift
return ok
}
+26 -56
View File
@@ -13,50 +13,25 @@
// limitations under the License.
pri func decoder.decode_block_slow?(src: base.io_reader) {
var which : base.u8[..= 5]
var c : base.u8
var child : base.u16
var child_ff : base.u32[..= 255]
var i : base.u32
var j : base.u32
var ticks : base.u32[..= 50]
var section : base.u32
var bs : base.u32[..= 1_048575] // 1_048575 = ((1 << 20) - 1)
var output : base.u32[..= 255]
var node_index : base.u32[..= 1023]
var run_shift : base.u32[..= 23]
var run : base.u32[..= 16_777216] // 16_777216 = (2 << 23)
var mtft0 : base.u32[..= 255]
which = CLAMP_TO_5[this.huffman_selectors[0] & 7]
section = 1
// Initialize the MTFT state.
i = 0
j = 0
while i < 256 {
if this.presence[i] <> 0 {
this.mtft[j & 0xFF] = i as base.u8
j ~mod+= 1
}
i += 1
} endwhile
i = 0
while i < 256 {
this.letter_counts[i] = 0
i += 1
} endwhile
var child : base.u16
var child_ff : base.u32[..= 255]
var i : base.u32
var j : base.u32
var output : base.u32[..= 255]
var run : base.u32[..= 16_777216] // 16_777216 = (2 << 23)
var mtft0 : base.u32[..= 255]
// Apply the Huffman trees.
ticks = 50
while.outer true {
if ticks > 0 {
ticks -= 1
while.outer not coroutine_resumed {
if this.decode_block_ticks > 0 {
this.decode_block_ticks -= 1
} else {
ticks = 49
which = CLAMP_TO_5[this.huffman_selectors[section & 32767] & 7]
section ~mod+= 1
this.decode_block_ticks = 49
this.decode_block_section ~mod+= 1
this.decode_block_which = CLAMP_TO_5[this.huffman_selectors[this.decode_block_section & 32767] & 7]
}
node_index = 0
@@ -67,7 +42,7 @@ pri func decoder.decode_block_slow?(src: base.io_reader) {
this.n_bits = 8
assert this.n_bits > 0
}
child = this.huffman_trees[which][node_index][this.bits >> 31]
child = this.huffman_trees[this.decode_block_which][node_index][this.bits >> 31]
this.bits ~mod<<= 1
this.n_bits -= 1
@@ -84,32 +59,33 @@ pri func decoder.decode_block_slow?(src: base.io_reader) {
this.mtft[0] = output as base.u8
this.letter_counts[output] ~mod+= 1
this.bwt[bs] = output
if bs >= this.max_incl_block_size {
this.bwt[this.block_size] = output
if this.block_size >= this.max_incl_block_size {
return "#bad block length"
}
assert bs < 900000 via "a < b: a < c; c <= b"(c: this.max_incl_block_size)
bs += 1
run_shift = 0
assert this.block_size < 900000 via "a < b: a < c; c <= b"(c: this.max_incl_block_size)
this.block_size += 1
this.decode_block_run_shift = 0
break
} else if child > 1281 { // EOB symbol.
this.decode_block_finished = true
break.outer
}
// RUNA or RUNB symbol.
if run_shift >= 23 {
if this.decode_block_run_shift >= 23 {
return "#bad block length"
}
run = ((child - 1279) as base.u32) << run_shift
run_shift += 1
i = bs
j = run + bs
run = ((child - 1279) as base.u32) << this.decode_block_run_shift
this.decode_block_run_shift += 1
i = this.block_size
j = run + this.block_size
if j > this.max_incl_block_size {
return "#bad block length"
}
assert j <= 900000 via "a <= b: a <= c; c <= b"(c: this.max_incl_block_size)
bs = j
this.block_size = j
mtft0 = this.mtft[0] as base.u32
this.letter_counts[mtft0] ~mod+= run
@@ -123,10 +99,4 @@ pri func decoder.decode_block_slow?(src: base.io_reader) {
break
} endwhile
} endwhile.outer
if bs > this.max_incl_block_size {
return "#bad block length"
}
assert bs <= 900000 via "a <= b: a <= c; c <= b"(c: this.max_incl_block_size)
this.block_size = bs
}
+48 -5
View File
@@ -12,8 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
// TODO: optimize.
pub status "#bad Huffman code (over-subscribed)"
pub status "#bad Huffman code (under-subscribed)"
pub status "#bad block header"
@@ -25,6 +23,8 @@ pub status "#bad number of sections"
pub status "#unsupported Huffman code"
pub status "#unsupported block randomization"
pri status "#internal error: inconsistent Huffman decoder state"
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0
pri const CLAMP_TO_5 : array[8] base.u8[..= 5] = [0, 1, 2, 3, 4, 5, 5, 5]
@@ -34,9 +34,15 @@ pub struct decoder? implements base.io_transformer(
n_bits : base.u32[..= 31],
// Block size is measured prior to the RLE1 step.
block_size : base.u32[..= 900000],
max_incl_block_size : base.u32[..= 900000],
block_size : base.u32[..= 900000],
decode_block_finished : base.bool,
decode_block_which : base.u8[..= 5],
decode_block_ticks : base.u32[..= 50],
decode_block_section : base.u32,
decode_block_run_shift : base.u32[..= 23],
final_checksum_have : base.u32,
block_checksum_want : base.u32,
original_pointer : base.u32,
@@ -92,6 +98,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
var c : base.u8
var i : base.u32
var tag : base.u64
var status : base.status
var final_checksum_want : base.u32
// Read the header.
@@ -138,7 +145,23 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
}
this.prepare_block?(src: args.src)
this.decode_block_slow?(src: args.src)
this.block_size = 0
this.decode_block_finished = false
this.decode_block_which = CLAMP_TO_5[this.huffman_selectors[0] & 7]
this.decode_block_ticks = 50
this.decode_block_section = 0
this.decode_block_run_shift = 0
while not this.decode_block_finished {
status = this.decode_block_fast!(src: args.src)
if status.is_error() {
return status
} else if this.decode_block_finished {
break
}
this.decode_block_slow?(src: args.src)
} endwhile
this.invert_bwt!()
this.flush_block?(dst: args.dst)
} endwhile
@@ -167,6 +190,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
pri func decoder.prepare_block?(src: base.io_reader) {
var c : base.u8
var i : base.u32
var j : base.u32
var selector : base.u32
var sel_ff : base.u32
var movee : base.u8
@@ -378,6 +402,24 @@ pri func decoder.prepare_block?(src: base.io_reader) {
}
i += 1
} endwhile
// Initialize the MTFT state.
i = 0
j = 0
while i < 256 {
if this.presence[i] <> 0 {
this.mtft[j & 0xFF] = i as base.u8
j ~mod+= 1
}
i += 1
} endwhile
// Initialize the letter counts.
i = 0
while i < 256 {
this.letter_counts[i] = 0
i += 1
} endwhile
}
pri func decoder.read_code_lengths?(src: base.io_reader) {
@@ -592,7 +634,8 @@ pri func decoder.build_huffman_tree!(which: base.u32[..= 5]) base.status {
// invert_bwt performs "two passes over the data, and one pass over the
// alphabet", per the BWT technical report, except that the first data pass
// (accumulating this.letter_counts) is integrated into execute_block.
// (accumulating this.letter_counts) is integrated into the decode_block_etc
// methods.
pri func decoder.invert_bwt!() {
var i : base.u32
var letter : base.u32[..= 255]