Move cgen's sub-structs to private_data

name                                             old speed      new speed      delta

wuffs_gif_decode_1k_bw/clang5                     243MB/s ± 1%   243MB/s ± 1%    ~     (p=0.101 n=47+48)
wuffs_gif_decode_1k_color/clang5                  142MB/s ± 1%   142MB/s ± 1%  +0.36%  (p=0.000 n=48+47)
wuffs_gif_decode_10k_bgra/clang5                  734MB/s ± 1%   728MB/s ± 1%  -0.78%  (p=0.000 n=46+50)
wuffs_gif_decode_10k_indexed/clang5               197MB/s ± 0%   196MB/s ± 1%  -0.52%  (p=0.000 n=47+46)
wuffs_gif_decode_20k/clang5                       250MB/s ± 1%   249MB/s ± 1%    ~     (p=0.189 n=49+46)
wuffs_gif_decode_100k_artificial/clang5           556MB/s ± 1%   555MB/s ± 1%  -0.23%  (p=0.000 n=46+44)
wuffs_gif_decode_100k_realistic/clang5            229MB/s ± 1%   229MB/s ± 0%    ~     (p=0.055 n=48+48)
wuffs_gif_decode_1000k/clang5                     233MB/s ± 1%   234MB/s ± 0%  +0.30%  (p=0.000 n=48+45)
wuffs_gif_decode_anim_screencap/clang5           1.11GB/s ± 1%  1.10GB/s ± 0%  -0.28%  (p=0.000 n=46+47)

wuffs_gif_decode_1k_bw/gcc7                       257MB/s ± 2%   263MB/s ± 1%  +2.67%  (p=0.000 n=49+47)
wuffs_gif_decode_1k_color/gcc7                    142MB/s ± 1%   146MB/s ± 1%  +3.25%  (p=0.000 n=50+49)
wuffs_gif_decode_10k_bgra/gcc7                    627MB/s ± 1%   625MB/s ± 1%  -0.35%  (p=0.000 n=48+49)
wuffs_gif_decode_10k_indexed/gcc7                 197MB/s ± 1%   196MB/s ± 1%  -0.21%  (p=0.000 n=48+43)
wuffs_gif_decode_20k/gcc7                         239MB/s ± 0%   239MB/s ± 1%  +0.21%  (p=0.000 n=50+47)
wuffs_gif_decode_100k_artificial/gcc7             511MB/s ± 0%   512MB/s ± 1%  +0.21%  (p=0.000 n=49+44)
wuffs_gif_decode_100k_realistic/gcc7              211MB/s ± 0%   212MB/s ± 1%  +0.39%  (p=0.000 n=45+44)
wuffs_gif_decode_1000k/gcc7                       215MB/s ± 0%   216MB/s ± 1%  +0.13%  (p=0.002 n=46+48)
wuffs_gif_decode_anim_screencap/gcc7             1.06GB/s ± 1%  1.06GB/s ± 1%  +0.12%  (p=0.007 n=45+48)

wuffs_lzw_decode_20k/clang5                       271MB/s ± 1%   270MB/s ± 1%  -0.34%  (p=0.000 n=49+49)
wuffs_lzw_decode_100k/clang5                      480MB/s ± 1%   478MB/s ± 1%  -0.31%  (p=0.001 n=48+50)

wuffs_lzw_decode_20k/gcc7                         263MB/s ± 1%   264MB/s ± 1%  +0.38%  (p=0.000 n=45+47)
wuffs_lzw_decode_100k/gcc7                        476MB/s ± 1%   482MB/s ± 2%  +1.30%  (p=0.000 n=47+50)
This commit is contained in:
Nigel Tao committed 2019-02-10 11:22:04 +11:00
1 parent 664c47fe3c
commit 0ab52c6204
6 files changed
+88 -38

No files matched your search

+31 -8
View File
@@ -321,11 +321,12 @@ type gen struct {
// generated C code (due to line numbers changing) when editing Wuffs code.
genlinenum bool
scalarConstsMap map[t.QID]*a.Const
statusList []status
statusMap map[t.QID]status
structList []*a.Struct
structMap map[t.QID]*a.Struct
privateDataFields map[t.QQID]struct{}
scalarConstsMap map[t.QID]*a.Const
statusList []status
statusMap map[t.QID]status
structList []*a.Struct
structMap map[t.QID]*a.Struct
currFunk funk
funks map[t.QQID]funk
@@ -374,8 +375,16 @@ func (g *gen) generate() ([]byte, error) {
return nil, fmt.Errorf("cyclical struct definitions")
}
g.structMap = map[t.QID]*a.Struct{}
g.privateDataFields = map[t.QQID]struct{}{}
for _, n := range g.structList {
g.structMap[n.QID()] = n
qid := n.QID()
g.structMap[qid] = n
for _, f := range n.Fields() {
f := f.AsField()
if f.PrivateData() {
g.privateDataFields[t.QQID{qid[0], qid[1], f.Name()}] = struct{}{}
}
}
}
g.funks = map[t.QQID]funk{}
@@ -745,7 +754,7 @@ func (g *gen) writeStructPrivateImpl(b *buffer, n *a.Struct) error {
for _, o := range n.Fields() {
o := o.AsField()
if o.XType().Eq(typeExprUtility) {
if o.PrivateData() || o.XType().Eq(typeExprUtility) {
continue
}
if err := g.writeCTypeName(b, o.XType(), fPrefix, o.Name().Str(g.tm)); err != nil {
@@ -782,6 +791,20 @@ func (g *gen) writeStructPrivateImpl(b *buffer, n *a.Struct) error {
b.writes("struct {\n")
oldOuterLenB1 := len(*b)
for _, o := range n.Fields() {
o := o.AsField()
if !o.PrivateData() || o.XType().Eq(typeExprUtility) {
continue
}
if err := g.writeCTypeName(b, o.XType(), fPrefix, o.Name().Str(g.tm)); err != nil {
return err
}
b.writes(";\n")
}
if oldOuterLenB1 != len(*b) {
b.writeb('\n')
}
for _, file := range g.files {
for _, tld := range file.TopLevelDecls() {
if tld.Kind() != a.KFunc {
@@ -1011,7 +1034,7 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error {
b.printf("{\n")
b.printf("wuffs_base__status z = %s%s__initialize("+
"&self->private_impl.%s%s, sizeof(self->private_impl.%s%s), WUFFS_VERSION, initialize_flags);\n",
"&self->private_data.%s%s, sizeof(self->private_data.%s%s), WUFFS_VERSION, initialize_flags);\n",
prefix, qid[1].Str(g.tm), fPrefix, f.Name().Str(g.tm), fPrefix, f.Name().Str(g.tm))
b.printf("if (z) { return z; }\n")
b.printf("}\n")
+17 -1
View File
@@ -217,13 +217,29 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, depth uint32) error {
} else {
b.writes(".")
}
b.writes("private_impl." + fPrefix)
b.writes(g.privateImplData(lhs.MType(), n.Ident()))
b.writeb('.')
b.writes(fPrefix)
b.writes(n.Ident().Str(g.tm))
return nil
}
return fmt.Errorf("unrecognized token (0x%X) for writeExprOther", n.Operator())
}
func (g *gen) privateImplData(typ *a.TypeExpr, fieldName t.ID) string {
if p := typ.Decorator(); p == t.IDNptr || p == t.IDPtr {
typ = typ.Inner()
}
if s := g.structMap[typ.QID()]; s != nil {
qid := s.QID()
if _, ok := g.privateDataFields[t.QQID{qid[0], qid[1], fieldName}]; ok {
return "private_data"
}
}
return "private_impl"
}
func (g *gen) writeExprUnaryOp(b *buffer, n *a.Expr, depth uint32) error {
op := n.Operator()
opName := cOpName(op)
+11 -7
View File
@@ -102,6 +102,7 @@ const (
FlagsClassy = Flags(0x00001000)
FlagsSubExprHasEffect = Flags(0x00002000)
FlagsRetsError = Flags(0x00004000)
FlagsPrivateData = Flags(0x00008000)
)
func (f Flags) AsEffect() Effect { return Effect(f) }
@@ -453,19 +454,22 @@ func NewVar(name t.ID, xType *TypeExpr) *Var {
}
// Field is a "name type" struct field:
// - FlagsPrivateData is the initializer need not explicitly memset to zero.
// - ID2: name
// - LHS: <TypeExpr>
type Field Node
func (n *Field) AsNode() *Node { return (*Node)(n) }
func (n *Field) Name() t.ID { return n.id2 }
func (n *Field) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
func (n *Field) AsNode() *Node { return (*Node)(n) }
func (n *Field) PrivateData() bool { return n.flags&FlagsPrivateData != 0 }
func (n *Field) Name() t.ID { return n.id2 }
func (n *Field) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
func NewField(name t.ID, xType *TypeExpr) *Field {
func NewField(flags Flags, name t.ID, xType *TypeExpr) *Field {
return &Field{
kind: KField,
id2: name,
lhs: xType.AsNode(),
kind: KField,
flags: flags,
id2: name,
lhs: xType.AsNode(),
}
}
+5 -1
View File
@@ -339,7 +339,11 @@ func (p *parser) parseFieldNode() (*a.Node, error) {
if err != nil {
return nil, err
}
return a.NewField(name, typ).AsNode(), nil
flags := a.Flags(0)
if pkg := typ.Innermost().QID()[0]; (pkg != 0) && (pkg != t.IDBase) {
flags |= a.FlagsPrivateData
}
return a.NewField(flags, name, typ).AsNode(), nil
}
func (p *parser) parseTypeExpr() (*a.TypeExpr, error) {
+22 -19
View File
@@ -3297,7 +3297,6 @@ struct wuffs_gif__decoder__struct {
uint64_t f_compressed_ri;
uint64_t f_compressed_wi;
wuffs_base__pixel_swizzler f_swizzler;
wuffs_lzw__decoder f_lzw;
uint8_t f_compressed[4096];
uint8_t f_palettes[2][1024];
uint8_t f_dst_palette[1024];
@@ -3319,6 +3318,8 @@ struct wuffs_gif__decoder__struct {
} private_impl;
struct {
wuffs_lzw__decoder f_lzw;
struct {
uint64_t scratch;
} s_skip_frame[1];
@@ -3551,13 +3552,14 @@ struct wuffs_gzip__decoder__struct {
uint32_t active_coroutine;
bool f_ignore_checksum;
wuffs_crc32__ieee_hasher f_checksum;
wuffs_deflate__decoder f_flate;
uint32_t p_decode_io_writer[1];
} private_impl;
struct {
wuffs_crc32__ieee_hasher f_checksum;
wuffs_deflate__decoder f_flate;
struct {
uint8_t v_flags;
uint32_t v_checksum_got;
@@ -3725,13 +3727,14 @@ struct wuffs_zlib__decoder__struct {
uint32_t active_coroutine;
bool f_ignore_checksum;
wuffs_adler32__hasher f_checksum;
wuffs_deflate__decoder f_flate;
uint32_t p_decode_io_writer[1];
} private_impl;
struct {
wuffs_adler32__hasher f_checksum;
wuffs_deflate__decoder f_flate;
struct {
uint32_t v_checksum_got;
uint64_t scratch;
@@ -8605,7 +8608,7 @@ wuffs_gif__decoder__initialize(wuffs_gif__decoder* self,
}
{
wuffs_base__status z = wuffs_lzw__decoder__initialize(
&self->private_impl.f_lzw, sizeof(self->private_impl.f_lzw),
&self->private_data.f_lzw, sizeof(self->private_data.f_lzw),
WUFFS_VERSION, initialize_flags);
if (z) {
return z;
@@ -10338,9 +10341,9 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
.len = 1024,
}));
if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
(memset(&self->private_impl.f_lzw, 0, sizeof((wuffs_lzw__decoder){})),
(memset(&self->private_data.f_lzw, 0, sizeof((wuffs_lzw__decoder){})),
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(
&self->private_impl.f_lzw, sizeof((wuffs_lzw__decoder){}),
&self->private_data.f_lzw, sizeof((wuffs_lzw__decoder){}),
WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED)),
wuffs_base__return_empty_struct());
}
@@ -10357,7 +10360,7 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
status = wuffs_gif__error__bad_literal_width;
goto exit;
}
wuffs_lzw__decoder__set_literal_width(&self->private_impl.f_lzw,
wuffs_lzw__decoder__set_literal_width(&self->private_data.f_lzw,
((uint32_t)(v_lw)));
self->private_impl.f_previous_lzw_decode_ended_abruptly = true;
@@ -10520,7 +10523,7 @@ 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,
&self->private_data.f_lzw,
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;
@@ -10533,7 +10536,7 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self,
iop_v_r = o_0_iop_v_r;
io1_v_r = o_0_io1_v_r;
}
v_uncompressed = wuffs_lzw__decoder__flush(&self->private_impl.f_lzw);
v_uncompressed = wuffs_lzw__decoder__flush(&self->private_data.f_lzw);
if (((uint64_t)(v_uncompressed.len)) > 0) {
v_copy_status = wuffs_gif__decoder__copy_to_image_buffer(
self, a_dst, v_uncompressed);
@@ -10765,7 +10768,7 @@ wuffs_gzip__decoder__initialize(wuffs_gzip__decoder* self,
}
{
wuffs_base__status z = wuffs_crc32__ieee_hasher__initialize(
&self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum),
&self->private_data.f_checksum, sizeof(self->private_data.f_checksum),
WUFFS_VERSION, initialize_flags);
if (z) {
return z;
@@ -10773,7 +10776,7 @@ wuffs_gzip__decoder__initialize(wuffs_gzip__decoder* self,
}
{
wuffs_base__status z = wuffs_deflate__decoder__initialize(
&self->private_impl.f_flate, sizeof(self->private_impl.f_flate),
&self->private_data.f_flate, sizeof(self->private_data.f_flate),
WUFFS_VERSION, initialize_flags);
if (z) {
return z;
@@ -11066,7 +11069,7 @@ wuffs_gzip__decoder__decode_io_writer(wuffs_gzip__decoder* self,
iop_a_src - a_src.private_impl.buf->data.ptr;
}
wuffs_base__status t_7 = wuffs_deflate__decoder__decode_io_writer(
&self->private_impl.f_flate, a_dst, a_src, a_workbuf);
&self->private_data.f_flate, a_dst, a_src, a_workbuf);
if (a_dst.private_impl.buf) {
iop_a_dst = a_dst.private_impl.buf->data.ptr +
a_dst.private_impl.buf->meta.wi;
@@ -11079,7 +11082,7 @@ wuffs_gzip__decoder__decode_io_writer(wuffs_gzip__decoder* self,
}
if (!self->private_impl.f_ignore_checksum) {
v_checksum_got = wuffs_crc32__ieee_hasher__update(
&self->private_impl.f_checksum,
&self->private_data.f_checksum,
((wuffs_base__slice_u8){
.ptr = a_dst.private_impl.mark,
.len = (size_t)(iop_a_dst - a_dst.private_impl.mark),
@@ -11238,7 +11241,7 @@ wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self,
}
{
wuffs_base__status z = wuffs_adler32__hasher__initialize(
&self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum),
&self->private_data.f_checksum, sizeof(self->private_data.f_checksum),
WUFFS_VERSION, initialize_flags);
if (z) {
return z;
@@ -11246,7 +11249,7 @@ wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self,
}
{
wuffs_base__status z = wuffs_deflate__decoder__initialize(
&self->private_impl.f_flate, sizeof(self->private_impl.f_flate),
&self->private_data.f_flate, sizeof(self->private_data.f_flate),
WUFFS_VERSION, initialize_flags);
if (z) {
return z;
@@ -11424,7 +11427,7 @@ wuffs_zlib__decoder__decode_io_writer(wuffs_zlib__decoder* self,
iop_a_src - a_src.private_impl.buf->data.ptr;
}
wuffs_base__status t_1 = wuffs_deflate__decoder__decode_io_writer(
&self->private_impl.f_flate, a_dst, a_src, a_workbuf);
&self->private_data.f_flate, a_dst, a_src, a_workbuf);
if (a_dst.private_impl.buf) {
iop_a_dst = a_dst.private_impl.buf->data.ptr +
a_dst.private_impl.buf->meta.wi;
@@ -11437,7 +11440,7 @@ wuffs_zlib__decoder__decode_io_writer(wuffs_zlib__decoder* self,
}
if (!self->private_impl.f_ignore_checksum) {
v_checksum_got = wuffs_adler32__hasher__update(
&self->private_impl.f_checksum,
&self->private_data.f_checksum,
((wuffs_base__slice_u8){
.ptr = a_dst.private_impl.mark,
.len = (size_t)(iop_a_dst - a_dst.private_impl.mark),
+2 -2
View File
@@ -180,9 +180,9 @@ const char* test_basic_sub_struct_initializer() {
RETURN_FAIL("outer magic: got %" PRIu32 ", want %" PRIu32 "",
dec.private_impl.magic, WUFFS_BASE__MAGIC);
}
if (dec.private_impl.f_lzw.private_impl.magic != WUFFS_BASE__MAGIC) {
if (dec.private_data.f_lzw.private_impl.magic != WUFFS_BASE__MAGIC) {
RETURN_FAIL("inner magic: got %" PRIu32 ", want %" PRIu32,
dec.private_impl.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC);
dec.private_data.f_lzw.private_impl.magic, WUFFS_BASE__MAGIC);
}
return NULL;
}