Add std/adler32 hasher.up_arm_neon

On a Raspberry Pi 4 (32-bit armv7l) with -march=native and -mfpu=neon
("native" means "armv8-a+crc+simd"):

wuffs_adler32_10k/clang9                                  1.21GB/s ± 0%   6.58GB/s ± 1%  +442.43%  (p=0.008 n=5+5)
wuffs_adler32_100k/clang9                                 1.20GB/s ± 0%   6.58GB/s ± 0%  +449.37%  (p=0.008 n=5+5)

wuffs_adler32_10k/gcc8                                    1.24GB/s ± 0%   4.31GB/s ± 0%  +248.87%  (p=0.008 n=5+5)
wuffs_adler32_100k/gcc8                                   1.22GB/s ± 0%   4.29GB/s ± 0%  +251.09%  (p=0.008 n=5+5)

mimic_adler32_10k                                         1.40GB/s ± 0%   1.40GB/s ± 0%    -0.04%  (p=0.008 n=5+5)
mimic_adler32_100k                                        1.35GB/s ± 0%   1.38GB/s ± 0%    +2.77%  (p=0.008 n=5+5)

wuffs_zlib_decode_10k/clang9                              85.3MB/s ± 0%   91.1MB/s ± 0%    +6.83%  (p=0.008 n=5+5)
wuffs_zlib_decode_100k/clang9                              107MB/s ± 0%    113MB/s ± 0%    +5.20%  (p=0.008 n=5+5)

wuffs_zlib_decode_10k/gcc8                                86.1MB/s ± 0%   91.0MB/s ± 0%    +5.69%  (p=0.008 n=5+5)
wuffs_zlib_decode_100k/gcc8                                104MB/s ± 0%    111MB/s ± 0%    +7.08%  (p=0.016 n=5+4)

mimic_zlib_decode_10k                                      108MB/s ± 0%    108MB/s ± 0%      ~     (p=0.548 n=5+5)
mimic_zlib_decode_100k                                     142MB/s ± 0%    141MB/s ± 1%      ~     (p=0.310 n=5+5)

wuffs_png_decode_image_19k_8bpp/clang9                    69.9MB/s ± 0%   74.3MB/s ± 0%    +6.37%  (p=0.016 n=5+4)
wuffs_png_decode_image_40k_24bpp/clang9                   99.4MB/s ± 0%  104.3MB/s ± 0%    +4.92%  (p=0.008 n=5+5)
wuffs_png_decode_image_77k_8bpp/clang9                     266MB/s ± 0%    280MB/s ± 0%    +5.21%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/clang9   165MB/s ± 0%    169MB/s ± 0%    +2.45%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_verify_checksum/clang9   146MB/s ± 0%    163MB/s ± 0%   +11.86%  (p=0.008 n=5+5)
wuffs_png_decode_image_4002k_24bpp/clang9                 93.2MB/s ± 0%   97.7MB/s ± 0%    +4.78%  (p=0.008 n=5+5)

wuffs_png_decode_image_19k_8bpp/gcc8                      70.3MB/s ± 0%   74.3MB/s ± 0%    +5.70%  (p=0.008 n=5+5)
wuffs_png_decode_image_40k_24bpp/gcc8                      101MB/s ± 0%    107MB/s ± 0%    +5.67%  (p=0.008 n=5+5)
wuffs_png_decode_image_77k_8bpp/gcc8                       247MB/s ± 0%    259MB/s ± 0%    +4.71%  (p=0.008 n=5+5)
wuffs_png_decode_image_552k_32bpp_ignore_checksum/gcc8     162MB/s ± 0%    162MB/s ± 0%    +0.09%  (p=0.032 n=5+4)
wuffs_png_decode_image_552k_32bpp_verify_checksum/gcc8     140MB/s ± 0%    155MB/s ± 0%   +10.67%  (p=0.008 n=5+5)
wuffs_png_decode_image_4002k_24bpp/gcc8                   94.1MB/s ± 0%   99.4MB/s ± 0%    +5.57%  (p=0.008 n=5+5)

mimic_png_decode_image_19k_8bpp                           43.6MB/s ± 0%   43.3MB/s ± 1%      ~     (p=0.167 n=5+5)
mimic_png_decode_image_40k_24bpp                          54.6MB/s ± 0%   54.6MB/s ± 0%      ~     (p=1.000 n=5+5)
mimic_png_decode_image_77k_8bpp                            125MB/s ± 0%    123MB/s ± 0%    -1.03%  (p=0.016 n=5+4)
mimic_png_decode_image_552k_32bpp_ignore_checksum               skipped
mimic_png_decode_image_552k_32bpp_verify_checksum          102MB/s ± 0%    101MB/s ± 0%    -0.43%  (p=0.008 n=5+5)
mimic_png_decode_image_4002k_24bpp                        81.3MB/s ± 0%   81.8MB/s ± 0%    +0.62%  (p=0.008 n=5+5)
This commit is contained in:
Nigel Tao committed 2021-02-16 22:17:46 +11:00
1 parent d13039d96e
commit 010b34ed38
7 files changed
+629 -50

No files matched your search

+203 -13
View File
@@ -448,6 +448,9 @@ func (g *gen) writeBuiltinTokenWriter(b *buffer, recv *a.Expr, method t.ID, args
}
func (g *gen) writeBuiltinCPUArch(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, sideEffectsOnly bool, depth uint32) error {
armCRC32U32 := recv.MType().Eq(typeExprARMCRC32U32)
armNeon := recv.MType().Eq(typeExprARMNeon64) || recv.MType().Eq(typeExprARMNeon128)
switch method {
case t.IDLoadU32, t.IDLoadU64, t.IDLoadSlice128:
if !sideEffectsOnly {
@@ -521,16 +524,37 @@ func (g *gen) writeBuiltinCPUArch(b *buffer, recv *a.Expr, method t.ID, args []*
b.writes(")))")
}
return nil
}
armCRC32U32 := recv.MType().Eq(typeExprARMCRC32U32)
armNeon := recv.MType().Eq(typeExprARMNeon64) || recv.MType().Eq(typeExprARMNeon128)
case t.IDCreateSlice64, t.IDCreateSlice128:
if armNeon {
switch method {
case t.IDCreateSlice64:
b.writes("vld1_u8(")
case t.IDCreateSlice128:
b.writes("vld1q_u8(")
}
}
if err := g.writeExpr(b, args[0].AsArg().Value(), false, depth); err != nil {
return err
}
b.writes(".ptr)")
return nil
}
methodStr := method.Str(g.tm)
vreinterpretU8Uxx, vreinterpretUxxU8, vreinterpretClose := "", "", ""
if armNeon {
vreinterpretClose = ")"
switch {
case methodStr == "create_vdupq_n_u16":
vreinterpretU8Uxx = "vreinterpretq_u8_u16("
vreinterpretUxxU8 = "("
case methodStr == "create_vdupq_n_u32":
vreinterpretU8Uxx = "vreinterpretq_u8_u32("
vreinterpretUxxU8 = "("
case methodStr == "create_vdupq_n_u64":
vreinterpretU8Uxx = "vreinterpretq_u8_u64("
vreinterpretUxxU8 = "("
case methodStr == "vmovn_u16":
vreinterpretU8Uxx = "("
vreinterpretUxxU8 = "vreinterpretq_u16_u8("
@@ -563,13 +587,46 @@ func (g *gen) writeBuiltinCPUArch(b *buffer, recv *a.Expr, method t.ID, args []*
}
}
const create = "create"
const (
create = "create"
createLiteralU = "create_literal_u"
)
if methodStr == "value" {
return g.writeExpr(b, recv, false, depth)
} else if methodStr == create {
return g.writeExpr(b, args[0].AsArg().Value(), false, depth)
} else if strings.HasPrefix(methodStr, createLiteralU) {
methodStr = methodStr[len(createLiteralU):]
switch methodStr {
case "16x4":
b.writes("vreinterpret_u8_u16")
case "16x8":
b.writes("vreinterpretq_u8_u16")
case "32x2":
b.writes("vreinterpret_u8_u32")
case "32x4":
b.writes("vreinterpretq_u8_u32")
case "64x1":
b.writes("vreinterpret_u8_u64")
case "64x2":
b.writes("vreinterpretq_u8_u64")
}
b.writes("((uint")
b.writes(methodStr)
b.writes("_t){")
for i, o := range args {
if i > 0 {
b.writes(", ")
}
if err := g.writeExpr(b, o.AsArg().Value(), false, depth); err != nil {
return err
}
}
b.writes("})")
return nil
} else if strings.HasPrefix(methodStr, create) {
methodStr = methodStr[len(create):]
if armNeon && (methodStr != "") && (methodStr[0] == '_') {
@@ -602,9 +659,133 @@ func (g *gen) writeBuiltinCPUArch(b *buffer, recv *a.Expr, method t.ID, args []*
}
b.writes(after)
}
b.writes(")")
b.writes(vreinterpretClose)
return nil
} else {
}
switch methodStr {
case "vaddw_u8":
b.writes("vreinterpretq_u8_u16(")
b.writes(methodStr)
b.writes("(vreinterpretq_u16_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes("), ")
if err := g.writeExpr(b, args[0].AsArg().Value(), false, depth); err != nil {
return err
}
b.writes("))")
return nil
case "vget_low_u16", "vget_high_u16":
b.writes("vreinterpret_u8_u16(")
b.writes(methodStr)
b.writes("(vreinterpretq_u16_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes(")))")
return nil
case "vget_low_u32", "vget_high_u32":
b.writes("vreinterpret_u8_u32(")
b.writes(methodStr)
b.writes("(vreinterpretq_u32_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes(")))")
return nil
case "vget_low_u64", "vget_high_u64":
b.writes("vreinterpret_u8_u64(")
b.writes(methodStr)
b.writes("(vreinterpretq_u64_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes(")))")
return nil
case "vget_low_u8", "vget_high_u8":
b.writes(methodStr)
b.writes("(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes(")")
return nil
case "vmlal_u16":
b.writes("vreinterpretq_u8_u32(")
b.writes(methodStr)
b.writes("(vreinterpretq_u32_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes(")")
for i := range args {
b.writes(", vreinterpret_u16_u8(")
if err := g.writeExpr(b, args[i].AsArg().Value(), false, depth); err != nil {
return err
}
b.writes(")")
}
b.writes("))")
case "vshlq_n_u32":
b.writes("vreinterpretq_u8_u32(")
b.writes(methodStr)
b.writes("(vreinterpretq_u32_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes("), ")
if err := g.writeExpr(b, args[0].AsArg().Value(), false, depth); err != nil {
return err
}
b.writes("))")
case "vpadalq_u16":
b.writes("vreinterpretq_u8_u32(vpadalq_u16(vreinterpretq_u32_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes("), vreinterpretq_u16_u8(")
if err := g.writeExpr(b, args[0].AsArg().Value(), false, depth); err != nil {
return err
}
b.writes(")))")
return nil
case "vpadalq_u32":
b.writes("vreinterpretq_u8_u64(vpadalq_u32(vreinterpretq_u64_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes("), vreinterpretq_u32_u8(")
if err := g.writeExpr(b, args[0].AsArg().Value(), false, depth); err != nil {
return err
}
b.writes(")))")
return nil
case "vpadalq_u8":
b.writes("vreinterpretq_u8_u16(vpadalq_u8(vreinterpretq_u16_u8(")
if err := g.writeExpr(b, recv, false, depth); err != nil {
return err
}
b.writes("), ")
if err := g.writeExpr(b, args[0].AsArg().Value(), false, depth); err != nil {
return err
}
b.writes("))")
return nil
default:
postArgsAfter := ""
if armCRC32U32 {
b.writeb('_')
@@ -612,14 +793,24 @@ func (g *gen) writeBuiltinCPUArch(b *buffer, recv *a.Expr, method t.ID, args []*
// TODO: generate this table automatically?
postArgsAfter = ")"
switch methodStr {
case "vabdl_u16", "vaddl_u16",
"vabdq_u32", "vcleq_u32":
b.writes("vreinterpretq_u8_u32(")
case "vabdl_u32", "vaddl_u32":
b.writes("vreinterpretq_u8_u64(")
case "vpadd_u16":
b.writes("vreinterpret_u8_u16(")
case "vpadd_u32":
b.writes("vreinterpret_u8_u32(")
case "vabdl_u8", "vaddl_u8",
"vabdq_u16", "vcleq_u16":
"vabdq_u16", "vcleq_u16",
"vaddq_u16",
"vpaddlq_u8":
b.writes("vreinterpretq_u8_u16(")
case "vabdl_u16", "vaddl_u16",
"vabdq_u32", "vcleq_u32",
"vaddq_u32",
"vpaddlq_u16":
b.writes("vreinterpretq_u8_u32(")
case "vabdl_u32", "vaddl_u32",
"vaddq_u64",
"vpaddlq_u32":
b.writes("vreinterpretq_u8_u64(")
default:
postArgsAfter = ""
}
@@ -656,10 +847,9 @@ func (g *gen) writeBuiltinCPUArch(b *buffer, recv *a.Expr, method t.ID, args []*
}
b.writes(after)
}
b.writes(")")
b.writes(postArgsAfter)
}
b.writes(")")
return nil
}