From f9689503452d9f3ce3a506e0e613547ddf407d6c Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 4 Nov 2017 17:28:56 +1100 Subject: [PATCH] Read bits up front in decode_huffman_fast. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit name old speed new speed delta puffs_adler32_10k/clang 2.36GB/s ± 4% 2.38GB/s ± 2% ~ (p=1.000 n=5+5) puffs_adler32_100k/clang 2.39GB/s ± 4% 2.39GB/s ± 1% ~ (p=0.841 n=5+5) puffs_flate_decode_1k/clang 121MB/s ± 1% 129MB/s ± 2% +5.95% (p=0.008 n=5+5) puffs_flate_decode_10k/clang 138MB/s ± 3% 161MB/s ± 1% +16.52% (p=0.008 n=5+5) puffs_flate_decode_100k/clang 163MB/s ± 4% 187MB/s ± 3% +14.50% (p=0.008 n=5+5) puffs_zlib_decode_10k/clang 132MB/s ± 2% 150MB/s ± 1% +13.92% (p=0.008 n=5+5) puffs_zlib_decode_100k/clang 152MB/s ± 6% 174MB/s ± 1% +14.60% (p=0.008 n=5+5) puffs_adler32_10k/gcc 3.25GB/s ± 0% 3.12GB/s ± 3% -4.06% (p=0.008 n=5+5) puffs_adler32_100k/gcc 3.25GB/s ± 0% 3.12GB/s ± 3% -3.99% (p=0.008 n=5+5) puffs_flate_decode_1k/gcc 95.1MB/s ± 0% 127.7MB/s ± 3% +34.25% (p=0.008 n=5+5) puffs_flate_decode_10k/gcc 110MB/s ± 0% 172MB/s ± 4% +55.66% (p=0.008 n=5+5) puffs_flate_decode_100k/gcc 121MB/s ± 0% 196MB/s ± 2% +61.45% (p=0.008 n=5+5) puffs_zlib_decode_10k/gcc 112MB/s ± 0% 164MB/s ± 1% +46.14% (p=0.008 n=5+5) puffs_zlib_decode_100k/gcc 123MB/s ± 0% 186MB/s ± 0% +51.22% (p=0.016 n=5+4) --- gen/c/std/flate.c | 77 ++++++++++------ lang/check/bounds.go | 132 ++++++++++++++++++++++++++++ std/flate/decode_huffman_fast.puffs | 26 +++++- 3 files changed, 206 insertions(+), 29 deletions(-) diff --git a/gen/c/std/flate.c b/gen/c/std/flate.c index 7f71595f..6ceb380a 100644 --- a/gen/c/std/flate.c +++ b/gen/c/std/flate.c @@ -2037,14 +2037,7 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1); label_0_continue:; while (((uint64_t)(b_rend_src - b_rptr_src)) >= 6) { - while (true) { - v_table_entry = self->private_impl.f_huffs[0][v_bits & v_lmask]; - v_table_entry_n_bits = (v_table_entry & 15); - if (v_n_bits >= v_table_entry_n_bits) { - v_bits >>= v_table_entry_n_bits; - v_n_bits -= v_table_entry_n_bits; - goto label_1_break; - } + if (v_n_bits < 15) { { PUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); if (PUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { @@ -2054,10 +2047,38 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( v_bits |= (((uint32_t)(t_0)) << v_n_bits); } v_n_bits += 8; + { + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (PUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_1 = *b_rptr_src++; + v_bits |= (((uint32_t)(t_1)) << v_n_bits); + } + v_n_bits += 8; + } else { + } + while (true) { + v_table_entry = self->private_impl.f_huffs[0][v_bits & v_lmask]; + v_table_entry_n_bits = (v_table_entry & 15); + if (v_n_bits >= v_table_entry_n_bits) { + v_bits >>= v_table_entry_n_bits; + v_n_bits -= v_table_entry_n_bits; + goto label_1_break; + } + { + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (PUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { + goto short_read_src; + } + uint8_t t_2 = *b_rptr_src++; + v_bits |= (((uint32_t)(t_2)) << v_n_bits); + } + v_n_bits += 8; } label_1_break:; if ((v_table_entry >> 31) != 0) { - PUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); if (b_wptr_dst == b_wend_dst) { status = PUFFS_FLATE__SUSPENSION_SHORT_WRITE; goto suspend; @@ -2087,18 +2108,18 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( goto label_2_break; } { - PUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); if (PUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { goto short_read_src; } - uint8_t t_1 = *b_rptr_src++; - v_bits |= (((uint32_t)(t_1)) << v_n_bits); + uint8_t t_3 = *b_rptr_src++; + v_bits |= (((uint32_t)(t_3)) << v_n_bits); } v_n_bits += 8; } label_2_break:; if ((v_table_entry >> 31) != 0) { - PUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); if (b_wptr_dst == b_wend_dst) { status = PUFFS_FLATE__SUSPENSION_SHORT_WRITE; goto suspend; @@ -2133,12 +2154,12 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( v_table_entry_n_bits = ((v_table_entry >> 4) & 15); while (v_n_bits < v_table_entry_n_bits) { { - PUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); if (PUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { goto short_read_src; } - uint8_t t_2 = *b_rptr_src++; - v_bits |= (((uint32_t)(t_2)) << v_n_bits); + uint8_t t_4 = *b_rptr_src++; + v_bits |= (((uint32_t)(t_4)) << v_n_bits); } v_n_bits += 8; } @@ -2156,12 +2177,12 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( goto label_3_break; } { - PUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); if (PUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { goto short_read_src; } - uint8_t t_3 = *b_rptr_src++; - v_bits |= (((uint32_t)(t_3)) << v_n_bits); + uint8_t t_5 = *b_rptr_src++; + v_bits |= (((uint32_t)(t_5)) << v_n_bits); } v_n_bits += 8; } @@ -2185,12 +2206,12 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( goto label_4_break; } { - PUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); if (PUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { goto short_read_src; } - uint8_t t_4 = *b_rptr_src++; - v_bits |= (((uint32_t)(t_4)) << v_n_bits); + uint8_t t_6 = *b_rptr_src++; + v_bits |= (((uint32_t)(t_6)) << v_n_bits); } v_n_bits += 8; } @@ -2214,12 +2235,12 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( v_table_entry_n_bits = ((v_table_entry >> 4) & 15); while (v_n_bits < v_table_entry_n_bits) { { - PUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); if (PUFFS_BASE__UNLIKELY(b_rptr_src == b_rend_src)) { goto short_read_src; } - uint8_t t_5 = *b_rptr_src++; - v_bits |= (((uint32_t)(t_5)) << v_n_bits); + uint8_t t_7 = *b_rptr_src++; + v_bits |= (((uint32_t)(t_7)) << v_n_bits); } v_n_bits += 8; } @@ -2282,7 +2303,7 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( } } status = PUFFS_FLATE__SUSPENSION_SHORT_WRITE; - PUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11); } label_5_break:; if (v_hlen > 0) { @@ -2301,7 +2322,7 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( v_hlen -= v_n_copied; v_hdist = ((v_hdist + (v_n_copied & 32767)) & 32767); status = PUFFS_FLATE__SUSPENSION_SHORT_WRITE; - PUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(12); } label_6_break:; } @@ -2318,7 +2339,7 @@ static puffs_flate__status puffs_flate__flate_decoder__decode_huffman_fast( } v_length -= v_n_copied; status = PUFFS_FLATE__SUSPENSION_SHORT_WRITE; - PUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11); + PUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(13); } label_7_break:; } diff --git a/lang/check/bounds.go b/lang/check/bounds.go index 649c4d5a..c1e76ee1 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -39,6 +39,9 @@ var ( minusOne = big.NewInt(-1) zero = big.NewInt(+0) one = big.NewInt(+1) + two = big.NewInt(+2) + four = big.NewInt(+4) + eight = big.NewInt(+8) sixtyFour = big.NewInt(+64) ffff = big.NewInt(0xFFFF) @@ -229,6 +232,10 @@ func (q *checker) bcheckBlock(block []*a.Node) error { func (q *checker) bcheckStatement(n *a.Node) error { q.errFilename, q.errLine = n.Raw().FilenameLine() + // TODO: be principled about checking for provenNotToSuspend. Should we + // call bcheckIOMethods only for assignments, for var statements too, or + // for all statements generally? + switch n.Kind() { case a.KAssert: return q.bcheckAssert(n.Assert()) @@ -375,6 +382,20 @@ func (q *checker) bcheckAssignment(lhs *a.Expr, op t.ID, rhs *a.Expr) error { return err } } + + // TODO: be principled about checking for provenNotToSuspend, and for + // updating facts like "in.src.available() >= 6" after "in.src.read_u8?()". + // In general, we need to invalidate any "foo.bar()" facts after a call to + // an impure function like "foo.meth0!()" or "foo.meth1?()". + // + // What's here is somewhat ad hoc. Perhaps we need a call keyword and an + // explicit "foo = call bar?()" syntax. + if rhs.Suspendible() { + if err := q.bcheckIOMethods(rhs, 0); err != nil { + return err + } + } + return nil } @@ -1124,3 +1145,114 @@ func (q *checker) bcheckTypeExpr(n *a.TypeExpr) (*big.Int, *big.Int, error) { } return b[0], b[1], nil } + +func (q *checker) bcheckIOMethods(n *a.Expr, depth uint32) error { + if depth > a.MaxExprDepth { + return fmt.Errorf("check: expression recursion depth too large") + } + depth++ + + if !n.CallSuspendible() { + for _, o := range n.Node().Raw().SubNodes() { + if o != nil && o.Kind() == a.KExpr { + if err := q.bcheckIOMethods(o.Expr(), depth); err != nil { + return err + } + } + } + for _, o := range n.Args() { + if o != nil && o.Kind() == a.KExpr { + if err := q.bcheckIOMethods(o.Expr(), depth); err != nil { + return err + } + } + } + return nil + } + + if n.ID0().Key() != t.KeyOpenParen { + return nil + } + n = n.LHS().Expr() + if n.ID0().Key() != t.KeyDot { + return nil + } + advance := (*big.Int)(nil) + if key := n.ID1().Key(); key < t.Key(len(ioMethodAdvances)) { + advance = ioMethodAdvances[key] + } + if advance == nil { + return nil + } + n = n.LHS().Expr() + + // TODO: check that n's type is actually a reader1 or writer1. + + return q.facts.update(func(x *a.Expr) (*a.Expr, error) { + op := x.ID0().Key() + if op != t.KeyXBinaryGreaterEq && op != t.KeyXBinaryGreaterThan { + return x, nil + } + + rcv := x.RHS().Expr().ConstValue() + if rcv == nil { + return x, nil + } + + // Check that lhs is "n.available()". + lhs := x.LHS().Expr() + if lhs.ID0().Key() != t.KeyOpenParen || len(lhs.Args()) != 0 { + return x, nil + } + lhs = lhs.LHS().Expr() + if lhs.ID0().Key() != t.KeyDot || lhs.ID1().Key() != t.KeyAvailable { + return x, nil + } + lhs = lhs.LHS().Expr() + if !lhs.Eq(n) { + return x, nil + } + + // Check if the bytes available is >= the bytes needed. If so, update + // rcv to be the bytes remaining. If not, discard the fact x. + // + // TODO: mark the call as proven not to suspend. + if op == t.KeyXBinaryGreaterThan { + op = t.KeyXBinaryGreaterEq + rcv = big.NewInt(0).Add(rcv, one) + } + if rcv.Cmp(advance) < 0 { + return nil, nil + } + rcv = big.NewInt(0).Sub(rcv, advance) + + // Create a new a.Expr to hold the adjusted RHS constant value rcv. + id, err := q.tm.Insert(rcv.String()) + if err != nil { + return nil, err + } + o := a.NewExpr(a.FlagsTypeChecked, 0, id, nil, nil, nil, nil) + o.SetConstValue(rcv) + o.SetMType(typeExprIdeal) + + return a.NewExpr(x.Node().Raw().Flags(), t.IDXBinaryGreaterEq, 0, x.LHS(), nil, o.Node(), nil), nil + }) +} + +var ioMethodAdvances = [256]*big.Int{ + t.KeyReadU8: one, + t.KeyReadU16BE: two, + t.KeyReadU16LE: two, + t.KeyReadU32BE: four, + t.KeyReadU32LE: four, + t.KeyReadU64BE: eight, + t.KeyReadU64LE: eight, + + t.KeyWriteU8: one, + t.KeyWriteU16BE: two, + t.KeyWriteU16LE: two, + t.KeyWriteU32BE: four, + t.KeyWriteU32LE: four, + t.KeyWriteU64BE: eight, + t.KeyWriteU64LE: eight, +} diff --git a/std/flate/decode_huffman_fast.puffs b/std/flate/decode_huffman_fast.puffs index 4f877b1a..9eb6b60d 100644 --- a/std/flate/decode_huffman_fast.puffs +++ b/std/flate/decode_huffman_fast.puffs @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +// TODO: describe how the xxx_fast version differs from the xxx_slow one, the +// assumptions that xxx_fast makes, and how that makes it fast. pri func flate_decoder.decode_huffman_fast?(dst writer1, src reader1)() { // When editing this function, consider making the equivalent change to the // decode_huffman_slow function. Keep the diff between the two @@ -21,14 +23,34 @@ pri func flate_decoder.decode_huffman_fast?(dst writer1, src reader1)() { var bits u32 = this.bits var n_bits u32 = this.n_bits + // TODO: check that n_bits < 8? + var table_entry u32 var table_entry_n_bits u32[..15] var lmask u32[..511] = ((1 as u32) << this.n_huffs_bits[0]) - 1 var dmask u32[..511] = ((1 as u32) << this.n_huffs_bits[1]) - 1 while:loop in.src.available() >= 6 { + // Ensure that we have at least 15 bits of input. + if n_bits < 15 { + assert n_bits >= 0 // TODO: this shouldn't be necessary. + bits |= (in.src.read_u8?() as u32) << n_bits + n_bits += 8 + bits |= (in.src.read_u8?() as u32) << n_bits + n_bits += 8 + assert n_bits >= 15 + } else { + assert in.src.available() >= 4 + } + + // These assertions are redundant, but are listed explicitly for + // clarity. They must hold regardless of which branch was taken for the + // if statement above. + assert in.src.available() >= 4 + assert n_bits >= 15 + // Decode an lcode symbol from H-L. - while true { + while true { // TODO: drop the while. table_entry = this.huffs[0][bits & lmask] table_entry_n_bits = table_entry & 0x0F if n_bits >= table_entry_n_bits { @@ -248,6 +270,8 @@ pri func flate_decoder.decode_huffman_fast?(dst writer1, src reader1)() { } } + // TODO: unread some in.src bytes if n_bits >= 8? + this.bits = bits this.n_bits = n_bits }