From 2f18dc61d0d461a943edb85dbd377f6400164c98 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 4 Jun 2023 21:21:36 +1000 Subject: [PATCH] std/jpeg: call slice.bulk_memset --- internal/cgen/base/fundamental-private.h | 8 +++ internal/cgen/builtin.go | 63 ++++++++++++++++++++++++ lang/ast/ast.go | 31 ++++++++++++ lang/builtin/builtin.go | 5 ++ lang/check/type.go | 12 ++++- lang/token/list.go | 18 +++---- release/c/wuffs-unsupported-snapshot.c | 60 ++++++++-------------- std/jpeg/decode_jpeg.wuffs | 54 +++++--------------- 8 files changed, 160 insertions(+), 91 deletions(-) diff --git a/internal/cgen/base/fundamental-private.h b/internal/cgen/base/fundamental-private.h index 316720f6..d2f827b6 100644 --- a/internal/cgen/base/fundamental-private.h +++ b/internal/cgen/base/fundamental-private.h @@ -214,6 +214,14 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst, return len; } +static inline wuffs_base__empty_struct // +wuffs_base__bulk_memset(void* ptr, size_t len, uint8_t byte_value) { + if (len) { + memset(ptr, byte_value, len); + } + return wuffs_base__make_empty_struct(); +} + // -------- static inline wuffs_base__slice_u8 // diff --git a/internal/cgen/builtin.go b/internal/cgen/builtin.go index 66d98db7..5e265dfa 100644 --- a/internal/cgen/builtin.go +++ b/internal/cgen/builtin.go @@ -872,6 +872,69 @@ func (g *gen) writeBuiltinNumType(b *buffer, recv *a.Expr, method t.ID, args []* func (g *gen) writeBuiltinSlice(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, sideEffectsOnly bool, depth uint32) error { switch method { + case t.IDBulkMemset: + if arrayOrSlice, lo, hi, ok := recv.IsSlice(); !ok { + return fmt.Errorf("TODO: bulk_memset for general expressions") + + } else if hi == nil { + return fmt.Errorf("TODO: bulk_memset for general expressions") + + } else if arrayOrSlice.MType().IsBulkNumType() { + b.writes("wuffs_base__bulk_memset(&") + if err := g.writeExpr(b, arrayOrSlice, false, depth); err != nil { + return err + } + if lo == nil { + b.writes("[0], ") + if err := g.writeExpr(b, hi, false, depth); err != nil { + return err + } + } else { + b.writes("[") + if err := g.writeExpr(b, lo, false, depth); err != nil { + return err + } + b.writes("], (") + if err := g.writeExpr(b, hi, false, depth); err != nil { + return err + } + b.writes(" - ") + if err := g.writeExpr(b, lo, false, depth); err != nil { + return err + } + b.writes(")") + } + if bs := arrayOrSlice.MType().Inner().BulkSize(); (bs != nil) && (bs.Cmp(one) != 0) { + b.writes(" * (size_t)") + b.writes(bs.String()) + b.writes("u") + } + b.writes(", ") + + return g.writeArgs(b, args, depth) + + } else if arrayOrSlice.MType().IsContainerOfSpecificNumType(t.IDSlice, t.IDU8) { + b.writes("wuffs_base__bulk_memset(") + if err := g.writeExpr(b, recv, false, depth); err != nil { + return err + } + b.writes(".ptr, ") + if err := g.writeExpr(b, recv, false, depth); err != nil { + return err + } + b.writes(".len") + if bs := arrayOrSlice.MType().Inner().BulkSize(); (bs != nil) && (bs.Cmp(one) != 0) { + b.writes(" * (size_t)") + b.writes(bs.String()) + b.writes("u") + } + b.writes(", ") + return g.writeArgs(b, args, depth) + + } else { + return fmt.Errorf("TODO: bulk_memset for general expressions") + } + case t.IDCopyFromSlice: if err := g.writeBuiltinSliceCopyFromSlice8(b, recv, method, args, depth); err != errOptimizationNotApplicable { return err diff --git a/lang/ast/ast.go b/lang/ast/ast.go index f100c3e2..1f3b8c31 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -838,6 +838,33 @@ func (n *TypeExpr) Pointee() *TypeExpr { return n } +func (n *TypeExpr) BulkSize() *big.Int { + if !n.IsBulkNumType() { + return nil + } + ret := big.NewInt(1) + for ; n.id0 == t.IDArray; n = n.rhs.AsTypeExpr() { + ret = ret.Mul(ret, n.ArrayLength().ConstValue()) + } + switch n.id2 { + case t.IDU8: + return ret + case t.IDU16: + return ret.Lsh(ret, 1) + case t.IDU32: + return ret.Lsh(ret, 2) + case t.IDU64: + return ret.Lsh(ret, 3) + } + return nil +} + +func (n *TypeExpr) IsBulkNumType() bool { + for ; n.id0 == t.IDArray; n = n.rhs.AsTypeExpr() { + } + return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsNumType() +} + func (n *TypeExpr) IsBool() bool { return n.id0 == 0 && n.id1 == t.IDBase && n.id2 == t.IDBool } @@ -914,6 +941,10 @@ func (n *TypeExpr) IsReadOnly() bool { return (n.id0 == t.IDRoarray) || (n.id0 == t.IDRoslice) || (n.id0 == t.IDRotable) } +func (n *TypeExpr) IsContainerOfSpecificNumType(container t.ID, numType t.ID) bool { + return (n.id0 == container) && n.Inner().IsNumType() && (n.Inner().id2 == numType) +} + func (n *TypeExpr) IsUnsignedInteger() bool { return n.id0 == 0 && n.id1 == t.IDBase && (n.id2 == t.IDU8 || n.id2 == t.IDU16 || n.id2 == t.IDU32 || n.id2 == t.IDU64) diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index fceef8a1..1860d1cf 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -964,6 +964,11 @@ var SliceFuncs = []string{ "GENERIC T1.prefix(up_to: u64) T1", "GENERIC T1.uintptr_low_12_bits() u32[..= 4095]", "GENERIC T1.suffix(up_to: u64) T1", + + // The bulk_etc methods are further restricted to those slices whose + // elements are bulk-numeric types: numerics (e.g. base.u32), arrays of + // numerics, arrays of arrays of numerics, etc. + "GENERIC T1.bulk_memset!(byte_value: u8)", } var SliceU8Funcs = []string{ diff --git a/lang/check/type.go b/lang/check/type.go index 07eb7a3d..15b15961 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -730,8 +730,16 @@ func (q *checker) tcheckDot(n *a.Expr, depth uint32) error { qqid[0] = t.IDBase qqid[1] = t.IDDagger1 if q.c.isBuiltInSliceFunc(qqid, lTyp) { - n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.AsNode(), nil, nil)) - return nil + bulky := false + switch qqid[2] { + case t.IDBulkMemset: + bulky = true + } + + if !bulky || lTyp.Inner().IsBulkNumType() { + n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.AsNode(), nil, nil)) + return nil + } } return fmt.Errorf("check: no %s method %q", lTyp.Decorator().Str(q.tm), n.Ident().Str(q.tm)) diff --git a/lang/token/list.go b/lang/token/list.go index dc45b727..d38a8697 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -668,14 +668,14 @@ const ( IDIsOK = ID(0x231) IDIsSuspension = ID(0x232) - IDData = ID(0x240) - IDHeight = ID(0x241) - IDIO = ID(0x242) - IDLimit = ID(0x243) - IDPrefix = ID(0x244) - IDRowU32 = ID(0x245) - IDStride = ID(0x246) - IDSubslice = ID(0x247) + IDBulkMemset = ID(0x240) + IDData = ID(0x241) + IDHeight = ID(0x242) + IDIO = ID(0x243) + IDLimit = ID(0x244) + IDPrefix = ID(0x245) + IDRowU32 = ID(0x246) + IDStride = ID(0x247) IDSubtable = ID(0x248) IDSuffix = ID(0x249) IDUintptrLow12Bits = ID(0x24A) @@ -1100,6 +1100,7 @@ var builtInsByID = [nBuiltInIDs]string{ IDIsOK: "is_ok", IDIsSuspension: "is_suspension", + IDBulkMemset: "bulk_memset", IDData: "data", IDHeight: "height", IDIO: "io", @@ -1107,7 +1108,6 @@ var builtInsByID = [nBuiltInIDs]string{ IDPrefix: "prefix", IDRowU32: "row_u32", IDStride: "stride", - IDSubslice: "subslice", IDSubtable: "subtable", IDSuffix: "suffix", IDUintptrLow12Bits: "uintptr_low_12_bits", diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index e751bf56..bba91aca 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -12277,6 +12277,14 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst, return len; } +static inline wuffs_base__empty_struct // +wuffs_base__bulk_memset(void* ptr, size_t len, uint8_t byte_value) { + if (len) { + memset(ptr, byte_value, len); + } + return wuffs_base__make_empty_struct(); +} + // -------- static inline wuffs_base__slice_u8 // @@ -36853,10 +36861,6 @@ wuffs_jpeg__decoder__fill_bitstream( wuffs_jpeg__decoder* self, wuffs_base__io_buffer* a_src); -static wuffs_base__empty_struct -wuffs_jpeg__decoder__clear_mcu_blocks( - wuffs_jpeg__decoder* self); - static wuffs_base__empty_struct wuffs_jpeg__decoder__load_mcu_blocks( wuffs_jpeg__decoder* self, @@ -38937,8 +38941,6 @@ wuffs_jpeg__decoder__do_decode_frame( uint32_t v_pixfmt = 0; wuffs_base__status v_status = wuffs_base__make_status(NULL); - uint64_t v_i = 0; - uint64_t v_i_end = 0; uint8_t v_c = 0; uint8_t v_marker = 0; @@ -38997,15 +38999,15 @@ wuffs_jpeg__decoder__do_decode_frame( } goto ok; } - v_i = self->private_impl.f_components_workbuf_offsets[4]; - v_i_end = self->private_impl.f_components_workbuf_offsets[8]; - if (v_i_end > ((uint64_t)(a_workbuf.len))) { + if (self->private_impl.f_components_workbuf_offsets[8] > ((uint64_t)(a_workbuf.len))) { status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); goto exit; - } - while (v_i < v_i_end) { - a_workbuf.ptr[v_i] = 0; - v_i += 1; + } else if (self->private_impl.f_components_workbuf_offsets[4] < self->private_impl.f_components_workbuf_offsets[8]) { + wuffs_base__bulk_memset(wuffs_base__slice_u8__subslice_ij(a_workbuf, + self->private_impl.f_components_workbuf_offsets[4], + self->private_impl.f_components_workbuf_offsets[8]).ptr, wuffs_base__slice_u8__subslice_ij(a_workbuf, + self->private_impl.f_components_workbuf_offsets[4], + self->private_impl.f_components_workbuf_offsets[8]).len, 0); } label__0__continue:; while (true) { @@ -39516,7 +39518,7 @@ wuffs_jpeg__decoder__decode_sos( if (self->private_impl.f_sof_marker >= 194) { wuffs_jpeg__decoder__load_mcu_blocks(self, v_mx, v_my, a_workbuf); } else { - wuffs_jpeg__decoder__clear_mcu_blocks(self); + wuffs_base__bulk_memset(&self->private_data.f_mcu_blocks[0], self->private_impl.f_mcu_num_blocks * (size_t)128u, 0); } while (true) { v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self); @@ -39916,7 +39918,7 @@ wuffs_jpeg__decoder__fill_bitstream( wuffs_base__io_buffer* a_src) { uint32_t v_wi = 0; uint8_t v_c = 0; - uint32_t v_n = 0; + uint32_t v_new_wi = 0; const uint8_t* iop_a_src = NULL; const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; @@ -39961,11 +39963,11 @@ wuffs_jpeg__decoder__fill_bitstream( label__0__break:; if (((uint64_t)(io2_a_src - iop_a_src)) > 1) { if ((wuffs_base__peek_u8be__no_bounds_check(iop_a_src) >= 255) && ((wuffs_base__peek_u16le__no_bounds_check(iop_a_src) >> 8) > 0)) { - v_n = (wuffs_base__u32__min(v_wi, 2016) + 32); - while (v_wi < v_n) { - self->private_data.f_bitstream_buffer[v_wi] = 0; - v_wi += 1; + v_new_wi = (wuffs_base__u32__min(v_wi, 2016) + 32); + if (v_wi < v_new_wi) { + wuffs_base__bulk_memset(&self->private_data.f_bitstream_buffer[v_wi], (v_new_wi - v_wi), 0); } + v_wi = v_new_wi; } } self->private_impl.f_bitstream_wi = v_wi; @@ -39976,26 +39978,6 @@ wuffs_jpeg__decoder__fill_bitstream( return wuffs_base__make_empty_struct(); } -// -------- func jpeg.decoder.clear_mcu_blocks - -static wuffs_base__empty_struct -wuffs_jpeg__decoder__clear_mcu_blocks( - wuffs_jpeg__decoder* self) { - uint32_t v_b = 0; - uint32_t v_i = 0; - - v_b = 0; - while (v_b < self->private_impl.f_mcu_num_blocks) { - v_i = 0; - while (v_i < 64) { - self->private_data.f_mcu_blocks[v_b][v_i] = 0; - v_i += 1; - } - v_b += 1; - } - return wuffs_base__make_empty_struct(); -} - // -------- func jpeg.decoder.load_mcu_blocks static wuffs_base__empty_struct diff --git a/std/jpeg/decode_jpeg.wuffs b/std/jpeg/decode_jpeg.wuffs index ad7e04a8..10805693 100644 --- a/std/jpeg/decode_jpeg.wuffs +++ b/std/jpeg/decode_jpeg.wuffs @@ -789,8 +789,6 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) { var pixfmt : base.u32 var status : base.status - var i : base.u64 - var i_end : base.u64 var c : base.u8 var marker : base.u8 @@ -819,19 +817,11 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade // For progressive JPEGs, zero-initialize the saved pre-IDCT blocks. For // sequential JPEGs, this is a no-op, other than checking that args.workbuf // is long enough. - i = this.components_workbuf_offsets[4] - i_end = this.components_workbuf_offsets[8] - if i_end > args.workbuf.length() { + if this.components_workbuf_offsets[8] > args.workbuf.length() { return base."#bad workbuf length" + } else if this.components_workbuf_offsets[4] < this.components_workbuf_offsets[8] { + args.workbuf[this.components_workbuf_offsets[4] .. this.components_workbuf_offsets[8]].bulk_memset!(byte_value: 0) } - while i < i_end, - inv i_end <= args.workbuf.length(), - { - assert i < 0xFFFF_FFFF_FFFF_FFFF via "a < b: a < c; c <= b"(c: i_end) - assert i < args.workbuf.length() via "a < b: a < c; c <= b"(c: i_end) - args.workbuf[i] = 0 - i += 1 - } endwhile // Process chunks (markers and their payloads). while true { @@ -1182,7 +1172,8 @@ pri func decoder.decode_sos?(dst: ptr base.pixel_buffer, src: base.io_reader, wo if this.sof_marker >= 0xC2 { this.load_mcu_blocks!(mx: mx, my: my, workbuf: args.workbuf) } else { - this.clear_mcu_blocks!() + // Clear this.mcu_blocks. + this.mcu_blocks[.. this.mcu_num_blocks].bulk_memset!(byte_value: 0) } while.decode_mcu true, @@ -1489,9 +1480,9 @@ pri func decoder.calculate_single_component_scan_fields!() { } pri func decoder.fill_bitstream!(src: base.io_reader) { - var wi : base.u32[..= 0x800] - var c : base.u8 - var n : base.u32[..= 0x800] + var wi : base.u32[..= 0x800] + var c : base.u8 + var new_wi : base.u32[..= 0x800] // Compact unread bytes to the start of the buffer. if this.bitstream_ri <= 0 { @@ -1533,36 +1524,17 @@ pri func decoder.fill_bitstream!(src: base.io_reader) { // this method can insert even more. if args.src.length() > 1 { if (args.src.peek_u8() >= 0xFF) and ((args.src.peek_u16le() >> 8) > 0) { - n = wi.min(no_more_than: 0x800 - 32) + 32 - while wi < n { - assert wi < 0x800 via "a < b: a < c; c <= b"(c: n) - this.bitstream_buffer[wi] = 0x00 - wi += 1 - } endwhile + new_wi = wi.min(no_more_than: 0x800 - 32) + 32 + if wi < new_wi { + this.bitstream_buffer[wi .. new_wi].bulk_memset!(byte_value: 0) + } + wi = new_wi } } this.bitstream_wi = wi } -pri func decoder.clear_mcu_blocks!() { - var b : base.u32 - var i : base.u32 - - b = 0 - while b < this.mcu_num_blocks { - assert b < 10 via "a < b: a < c; c <= b"(c: this.mcu_num_blocks) - i = 0 - while i < 64, - inv b < 10, - { - this.mcu_blocks[b][i] = 0 - i += 1 - } endwhile - b += 1 - } endwhile -} - pri func decoder.load_mcu_blocks!(mx: base.u32[..= 0x2000], my: base.u32[..= 0x2000], workbuf: slice base.u8) { var b : base.u32 var csel : base.u8[..= 3]