Introduce std/bzip2 decoder.flush_fast method

Compared to the recent commit 623290ef "Cache std/bzip2 Huffman tree
lookup":

name                             old speed      new speed      delta

wuffs_bzip2_decode_10k/clang11   60.5MB/s ± 0%  60.5MB/s ± 0%    ~     (p=1.000 n=5+5)
wuffs_bzip2_decode_100k/clang11  46.7MB/s ± 1%  45.7MB/s ± 1%  -2.05%  (p=0.008 n=5+5)

wuffs_bzip2_decode_10k/gcc10     58.7MB/s ± 0%  58.5MB/s ± 0%    ~     (p=0.222 n=5+5)
wuffs_bzip2_decode_100k/gcc10    46.9MB/s ± 0%  46.3MB/s ± 0%  -1.46%  (p=0.008 n=5+5)
This commit is contained in:
Nigel Tao committed 2022-05-24 11:50:48 +10:00
1 parent 29eec43287
commit 66f194f7e0
4 files changed
+309 -106

No files matched your search

+170 -68
View File
@@ -6941,7 +6941,11 @@ struct wuffs_bzip2__decoder__struct {
uint32_t f_decode_huffman_ticks;
uint32_t f_decode_huffman_section;
uint32_t f_decode_huffman_run_shift;
uint32_t f_flush_pointer;
uint32_t f_flush_repeat_count;
uint8_t f_flush_prev;
uint32_t f_final_checksum_have;
uint32_t f_block_checksum_have;
uint32_t f_block_checksum_want;
uint32_t f_original_pointer;
uint32_t f_num_symbols;
@@ -6952,7 +6956,7 @@ struct wuffs_bzip2__decoder__struct {
uint32_t p_transform_io[1];
uint32_t p_prepare_block[1];
uint32_t p_read_code_lengths[1];
uint32_t p_flush_block[1];
uint32_t p_flush_slow[1];
uint32_t p_decode_huffman_slow[1];
} private_impl;
@@ -6980,14 +6984,14 @@ struct wuffs_bzip2__decoder__struct {
uint32_t v_code_length;
} s_read_code_lengths[1];
struct {
uint32_t v_i;
uint32_t v_n;
uint32_t v_repeat_count;
uint32_t v_flush_pointer;
uint32_t v_flush_repeat_count;
uint8_t v_flush_prev;
uint32_t v_block_checksum_have;
uint8_t v_prev;
uint32_t v_block_size;
uint8_t v_curr;
uint64_t scratch;
} s_flush_block[1];
} s_flush_slow[1];
struct {
uint32_t v_node_index;
} s_decode_huffman_slow[1];
@@ -24938,8 +24942,13 @@ static wuffs_base__empty_struct
wuffs_bzip2__decoder__invert_bwt(
wuffs_bzip2__decoder* self);
static wuffs_base__empty_struct
wuffs_bzip2__decoder__flush_fast(
wuffs_bzip2__decoder* self,
wuffs_base__io_buffer* a_dst);
static wuffs_base__status
wuffs_bzip2__decoder__flush_block(
wuffs_bzip2__decoder__flush_slow(
wuffs_bzip2__decoder* self,
wuffs_base__io_buffer* a_dst);
@@ -25246,11 +25255,32 @@ wuffs_bzip2__decoder__transform_io(
}
label__1__break:;
wuffs_bzip2__decoder__invert_bwt(self);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
status = wuffs_bzip2__decoder__flush_block(self, a_dst);
if (status.repr) {
goto suspend;
self->private_impl.f_block_checksum_have = 4294967295;
if (self->private_impl.f_original_pointer >= self->private_impl.f_block_size) {
status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
goto exit;
}
self->private_impl.f_flush_pointer = (self->private_data.f_bwt[self->private_impl.f_original_pointer] >> 12);
self->private_impl.f_flush_repeat_count = 0;
self->private_impl.f_flush_prev = 0;
while (self->private_impl.f_block_size > 0) {
wuffs_bzip2__decoder__flush_fast(self, a_dst);
if (self->private_impl.f_block_size <= 0) {
goto label__2__break;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
status = wuffs_bzip2__decoder__flush_slow(self, a_dst);
if (status.repr) {
goto suspend;
}
}
label__2__break:;
self->private_impl.f_block_checksum_have ^= 4294967295;
if (self->private_impl.f_block_checksum_have != self->private_impl.f_block_checksum_want) {
status = wuffs_base__make_status(wuffs_bzip2__error__bad_checksum);
goto exit;
}
self->private_impl.f_final_checksum_have = (self->private_impl.f_block_checksum_have ^ ((self->private_impl.f_final_checksum_have >> 31) | ((uint32_t)(self->private_impl.f_final_checksum_have << 1))));
}
label__0__break:;
v_final_checksum_want = 0;
@@ -25903,20 +25933,18 @@ wuffs_bzip2__decoder__invert_bwt(
return wuffs_base__make_empty_struct();
}
// -------- func bzip2.decoder.flush_block
// -------- func bzip2.decoder.flush_fast
static wuffs_base__status
wuffs_bzip2__decoder__flush_block(
static wuffs_base__empty_struct
wuffs_bzip2__decoder__flush_fast(
wuffs_bzip2__decoder* self,
wuffs_base__io_buffer* a_dst) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_i = 0;
uint32_t v_n = 0;
uint32_t v_entry = 0;
uint32_t v_repeat_count = 0;
uint32_t v_flush_pointer = 0;
uint32_t v_flush_repeat_count = 0;
uint8_t v_flush_prev = 0;
uint32_t v_block_checksum_have = 0;
uint8_t v_prev = 0;
uint32_t v_block_size = 0;
uint32_t v_entry = 0;
uint8_t v_curr = 0;
uint8_t* iop_a_dst = NULL;
@@ -25933,89 +25961,163 @@ wuffs_bzip2__decoder__flush_block(
}
}
uint32_t coro_susp_point = self->private_impl.p_flush_block[0];
v_flush_pointer = self->private_impl.f_flush_pointer;
v_flush_repeat_count = self->private_impl.f_flush_repeat_count;
v_flush_prev = self->private_impl.f_flush_prev;
v_block_checksum_have = self->private_impl.f_block_checksum_have;
v_block_size = self->private_impl.f_block_size;
while ((v_block_size > 0) && (((uint64_t)(io2_a_dst - iop_a_dst)) > 255)) {
v_entry = self->private_data.f_bwt[v_flush_pointer];
v_curr = ((uint8_t)((v_entry & 255)));
v_flush_pointer = (v_entry >> 12);
if (v_flush_repeat_count >= 4) {
v_flush_repeat_count = ((uint32_t)(v_curr));
while (v_flush_repeat_count > 0) {
v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_flush_prev)] ^ ((uint32_t)(v_block_checksum_have << 8)));
if (((uint64_t)(io2_a_dst - iop_a_dst)) > 0) {
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_flush_prev), iop_a_dst += 1);
}
v_flush_repeat_count -= 1;
}
v_flush_repeat_count = 0;
} else if (v_curr != v_flush_prev) {
v_flush_repeat_count = 1;
v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_curr)] ^ ((uint32_t)(v_block_checksum_have << 8)));
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_curr), iop_a_dst += 1);
} else {
v_flush_repeat_count += 1;
v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_curr)] ^ ((uint32_t)(v_block_checksum_have << 8)));
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_curr), iop_a_dst += 1);
}
v_flush_prev = v_curr;
v_block_size -= 1;
}
self->private_impl.f_flush_pointer = v_flush_pointer;
self->private_impl.f_flush_repeat_count = v_flush_repeat_count;
self->private_impl.f_flush_prev = v_flush_prev;
self->private_impl.f_block_checksum_have = v_block_checksum_have;
if (v_block_size <= 900000) {
self->private_impl.f_block_size = v_block_size;
}
if (a_dst) {
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
}
return wuffs_base__make_empty_struct();
}
// -------- func bzip2.decoder.flush_slow
static wuffs_base__status
wuffs_bzip2__decoder__flush_slow(
wuffs_bzip2__decoder* self,
wuffs_base__io_buffer* a_dst) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t v_flush_pointer = 0;
uint32_t v_flush_repeat_count = 0;
uint8_t v_flush_prev = 0;
uint32_t v_block_checksum_have = 0;
uint32_t v_block_size = 0;
uint32_t v_entry = 0;
uint8_t v_curr = 0;
uint8_t* iop_a_dst = NULL;
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_dst) {
io0_a_dst = a_dst->data.ptr;
io1_a_dst = io0_a_dst + a_dst->meta.wi;
iop_a_dst = io1_a_dst;
io2_a_dst = io0_a_dst + a_dst->data.len;
if (a_dst->meta.closed) {
io2_a_dst = iop_a_dst;
}
}
uint32_t coro_susp_point = self->private_impl.p_flush_slow[0];
if (coro_susp_point) {
v_i = self->private_data.s_flush_block[0].v_i;
v_n = self->private_data.s_flush_block[0].v_n;
v_repeat_count = self->private_data.s_flush_block[0].v_repeat_count;
v_block_checksum_have = self->private_data.s_flush_block[0].v_block_checksum_have;
v_prev = self->private_data.s_flush_block[0].v_prev;
v_curr = self->private_data.s_flush_block[0].v_curr;
v_flush_pointer = self->private_data.s_flush_slow[0].v_flush_pointer;
v_flush_repeat_count = self->private_data.s_flush_slow[0].v_flush_repeat_count;
v_flush_prev = self->private_data.s_flush_slow[0].v_flush_prev;
v_block_checksum_have = self->private_data.s_flush_slow[0].v_block_checksum_have;
v_block_size = self->private_data.s_flush_slow[0].v_block_size;
v_curr = self->private_data.s_flush_slow[0].v_curr;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_original_pointer >= self->private_impl.f_block_size) {
status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
goto exit;
}
v_i = (self->private_data.f_bwt[self->private_impl.f_original_pointer] >> 12);
v_block_checksum_have = 4294967295;
v_n = 0;
while (v_n < self->private_impl.f_block_size) {
v_entry = self->private_data.f_bwt[v_i];
v_flush_pointer = self->private_impl.f_flush_pointer;
v_flush_repeat_count = self->private_impl.f_flush_repeat_count;
v_flush_prev = self->private_impl.f_flush_prev;
v_block_checksum_have = self->private_impl.f_block_checksum_have;
v_block_size = self->private_impl.f_block_size;
while ((v_block_size > 0) && ! (self->private_impl.p_flush_slow[0] != 0)) {
v_entry = self->private_data.f_bwt[v_flush_pointer];
v_curr = ((uint8_t)((v_entry & 255)));
v_i = (v_entry >> 12);
if (v_repeat_count >= 4) {
v_repeat_count = ((uint32_t)(v_curr));
while (v_repeat_count > 0) {
v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_prev)] ^ ((uint32_t)(v_block_checksum_have << 8)));
self->private_data.s_flush_block[0].scratch = v_prev;
v_flush_pointer = (v_entry >> 12);
if (v_flush_repeat_count >= 4) {
v_flush_repeat_count = ((uint32_t)(v_curr));
while (v_flush_repeat_count > 0) {
v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_flush_prev)] ^ ((uint32_t)(v_block_checksum_have << 8)));
self->private_data.s_flush_slow[0].scratch = v_flush_prev;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (iop_a_dst == io2_a_dst) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_block[0].scratch));
v_repeat_count -= 1;
*iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_slow[0].scratch));
v_flush_repeat_count -= 1;
}
v_repeat_count = 0;
} else if (v_curr != v_prev) {
v_repeat_count = 1;
v_flush_repeat_count = 0;
} else if (v_curr != v_flush_prev) {
v_flush_repeat_count = 1;
v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_curr)] ^ ((uint32_t)(v_block_checksum_have << 8)));
self->private_data.s_flush_block[0].scratch = v_curr;
self->private_data.s_flush_slow[0].scratch = v_curr;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
if (iop_a_dst == io2_a_dst) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_block[0].scratch));
*iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_slow[0].scratch));
} else {
v_repeat_count += 1;
v_flush_repeat_count += 1;
v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_curr)] ^ ((uint32_t)(v_block_checksum_have << 8)));
self->private_data.s_flush_block[0].scratch = v_curr;
self->private_data.s_flush_slow[0].scratch = v_curr;
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
if (iop_a_dst == io2_a_dst) {
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
goto suspend;
}
*iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_block[0].scratch));
*iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_slow[0].scratch));
}
v_prev = v_curr;
v_n += 1;
v_flush_prev = v_curr;
v_block_size -= 1;
}
v_block_checksum_have ^= 4294967295;
if (v_block_checksum_have != self->private_impl.f_block_checksum_want) {
status = wuffs_base__make_status(wuffs_bzip2__error__bad_checksum);
goto exit;
self->private_impl.f_flush_pointer = v_flush_pointer;
self->private_impl.f_flush_repeat_count = v_flush_repeat_count;
self->private_impl.f_flush_prev = v_flush_prev;
self->private_impl.f_block_checksum_have = v_block_checksum_have;
if (v_block_size <= 900000) {
self->private_impl.f_block_size = v_block_size;
}
self->private_impl.f_final_checksum_have = (v_block_checksum_have ^ ((self->private_impl.f_final_checksum_have >> 31) | ((uint32_t)(self->private_impl.f_final_checksum_have << 1))));
goto ok;
ok:
self->private_impl.p_flush_block[0] = 0;
self->private_impl.p_flush_slow[0] = 0;
goto exit;
}
goto suspend;
suspend:
self->private_impl.p_flush_block[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_flush_block[0].v_i = v_i;
self->private_data.s_flush_block[0].v_n = v_n;
self->private_data.s_flush_block[0].v_repeat_count = v_repeat_count;
self->private_data.s_flush_block[0].v_block_checksum_have = v_block_checksum_have;
self->private_data.s_flush_block[0].v_prev = v_prev;
self->private_data.s_flush_block[0].v_curr = v_curr;
self->private_impl.p_flush_slow[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
self->private_data.s_flush_slow[0].v_flush_pointer = v_flush_pointer;
self->private_data.s_flush_slow[0].v_flush_repeat_count = v_flush_repeat_count;
self->private_data.s_flush_slow[0].v_flush_prev = v_flush_prev;
self->private_data.s_flush_slow[0].v_block_checksum_have = v_block_checksum_have;
self->private_data.s_flush_slow[0].v_block_size = v_block_size;
self->private_data.s_flush_slow[0].v_curr = v_curr;
goto exit;
exit:
+30 -1
View File
@@ -43,7 +43,12 @@ pub struct decoder? implements base.io_transformer(
decode_huffman_section : base.u32,
decode_huffman_run_shift : base.u32[..= 23],
flush_pointer : base.u32[..= 1_048575],
flush_repeat_count : base.u32[..= 255],
flush_prev : base.u8,
final_checksum_have : base.u32,
block_checksum_have : base.u32,
block_checksum_want : base.u32,
original_pointer : base.u32,
num_symbols : base.u32[..= 258],
@@ -174,7 +179,31 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
} endwhile
this.invert_bwt!()
this.flush_block?(dst: args.dst)
this.block_checksum_have = 0xFFFF_FFFF
if this.original_pointer >= this.block_size {
return "#bad block length"
}
assert this.original_pointer < 900000 via "a < b: a < c; c <= b"(c: this.block_size)
this.flush_pointer = this.bwt[this.original_pointer] >> 12
this.flush_repeat_count = 0
this.flush_prev = 0
while this.block_size > 0 {
this.flush_fast!(dst: args.dst)
if this.block_size <= 0 {
break
}
this.flush_slow?(dst: args.dst)
} endwhile
this.block_checksum_have ^= 0xFFFF_FFFF
if this.block_checksum_have <> this.block_checksum_want {
return "#bad checksum"
}
this.final_checksum_have = this.block_checksum_have ^ (
(this.final_checksum_have >> 31) |
(this.final_checksum_have ~mod<< 1))
} endwhile
// Read the 32-bit final checksum.
+75
View File
@@ -0,0 +1,75 @@
// 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.flush_fast!(dst: base.io_writer) {
var flush_pointer : base.u32[..= 1_048575]
var flush_repeat_count : base.u32[..= 255]
var flush_prev : base.u8
var block_checksum_have : base.u32
var block_size : base.u32
var entry : base.u32
var curr : base.u8
flush_pointer = this.flush_pointer
flush_repeat_count = this.flush_repeat_count
flush_prev = this.flush_prev
block_checksum_have = this.block_checksum_have
block_size = this.block_size
while (block_size > 0) and (args.dst.length() > 255) {
entry = this.bwt[flush_pointer]
curr = (entry & 0xFF) as base.u8
flush_pointer = entry >> 12
if flush_repeat_count >= 4 {
flush_repeat_count = curr as base.u32
while flush_repeat_count > 0,
inv block_size > 0,
{
block_checksum_have =
REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ flush_prev] ^
(block_checksum_have ~mod<< 8)
if args.dst.length() > 0 {
args.dst.write_u8_fast!(a: flush_prev)
}
flush_repeat_count -= 1
} endwhile
flush_repeat_count = 0
} else if curr <> flush_prev {
flush_repeat_count = 1
block_checksum_have =
REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ curr] ^
(block_checksum_have ~mod<< 8)
args.dst.write_u8_fast!(a: curr)
} else {
flush_repeat_count += 1
block_checksum_have =
REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ curr] ^
(block_checksum_have ~mod<< 8)
args.dst.write_u8_fast!(a: curr)
}
flush_prev = curr
block_size -= 1
} endwhile
this.flush_pointer = flush_pointer
this.flush_repeat_count = flush_repeat_count
this.flush_prev = flush_prev
this.block_checksum_have = block_checksum_have
if block_size <= 900000 {
this.block_size = block_size
}
}
+34 -37
View File
@@ -12,65 +12,62 @@
// See the License for the specific language governing permissions and
// limitations under the License.
pri func decoder.flush_block?(dst: base.io_writer) {
var i : base.u32[..= 1_048575]
var n : base.u32
var entry : base.u32
var repeat_count : base.u32[..= 255]
pri func decoder.flush_slow?(dst: base.io_writer) {
var flush_pointer : base.u32[..= 1_048575]
var flush_repeat_count : base.u32[..= 255]
var flush_prev : base.u8
var block_checksum_have : base.u32
var prev : base.u8
var curr : base.u8
var block_size : base.u32
if this.original_pointer >= this.block_size {
return "#bad block length"
}
assert this.original_pointer < 900000 via "a < b: a < c; c <= b"(c: this.block_size)
i = this.bwt[this.original_pointer] >> 12
var entry : base.u32
var curr : base.u8
block_checksum_have = 0xFFFF_FFFF
flush_pointer = this.flush_pointer
flush_repeat_count = this.flush_repeat_count
flush_prev = this.flush_prev
block_checksum_have = this.block_checksum_have
block_size = this.block_size
n = 0
while n < this.block_size {
assert n < 900000 via "a < b: a < c; c <= b"(c: this.block_size)
entry = this.bwt[i]
while (block_size > 0) and (not coroutine_resumed) {
entry = this.bwt[flush_pointer]
curr = (entry & 0xFF) as base.u8
i = entry >> 12
flush_pointer = entry >> 12
if repeat_count >= 4 {
repeat_count = curr as base.u32
while repeat_count > 0,
inv n < 900000,
if flush_repeat_count >= 4 {
flush_repeat_count = curr as base.u32
while flush_repeat_count > 0,
inv block_size > 0,
{
block_checksum_have =
REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ prev] ^
REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ flush_prev] ^
(block_checksum_have ~mod<< 8)
args.dst.write_u8?(a: prev)
repeat_count -= 1
args.dst.write_u8?(a: flush_prev)
flush_repeat_count -= 1
} endwhile
repeat_count = 0
} else if curr <> prev {
repeat_count = 1
flush_repeat_count = 0
} else if curr <> flush_prev {
flush_repeat_count = 1
block_checksum_have =
REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ curr] ^
(block_checksum_have ~mod<< 8)
args.dst.write_u8?(a: curr)
} else {
repeat_count += 1
flush_repeat_count += 1
block_checksum_have =
REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ curr] ^
(block_checksum_have ~mod<< 8)
args.dst.write_u8?(a: curr)
}
prev = curr
n += 1
flush_prev = curr
block_size -= 1
} endwhile
block_checksum_have ^= 0xFFFF_FFFF
if block_checksum_have <> this.block_checksum_want {
return "#bad checksum"
this.flush_pointer = flush_pointer
this.flush_repeat_count = flush_repeat_count
this.flush_prev = flush_prev
this.block_checksum_have = block_checksum_have
if block_size <= 900000 {
this.block_size = block_size
}
this.final_checksum_have = block_checksum_have ^ (
(this.final_checksum_have >> 31) |
(this.final_checksum_have ~mod<< 1))
}