Nigel Tao 83a72f3d77 Performance mystery: unused pixel swizzler code
A recent commit (c392a632de, "Swizzler let
src_pixfmt = INDEXED__BGRA_NONPREMUL") introduced new pixel swizzler
functions. These code paths weren't taken by the std/gif codec, but for
some mysterious reason, they dramatically impact the std/gif benchmarks.

To record that quantitatively in the git log, this commit touches the
INDEXED__BGRA_NONPREMUL code (editing wuffs-unsupported-snapshot.c
directly), making it incorrect but affecting the std/gif benchmarks (for
gcc10 but not for clang9). To repeat, the new code is not exercised by
the std/gif code. Even though test_wuffs_pixel_swizzler_swizzle now
fails, the std/gif tests still pass with this incorrect commit.

It is a mystery why this happens. This small, self-contained commit
will be immediately followed by a roll back, but it is committed anyway
so that we can refer to these numbers in the git log. To reproduce:

----
$ git clone https://github.com/google/wuffs.git
$ cd wuffs
$ gcc --version | head -n 1
gcc (Debian 10.2.1-3) 10.2.1 20201224

$ # Check out this commit.
$ git checkout --quiet THE_HASH_OF_THIS_COMMIT
$ gcc -O3 -Wall -std=c99 test/c/std/gif.c -DWUFFS_MIMIC -lgif
$ ./a.out -bench -focus=wuffs_gif_decode_1000k_full_init | grep MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 8242690 ns/op	     121.408 MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 8233370 ns/op	     121.546 MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 8228690 ns/op	     121.615 MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 8236640 ns/op	     121.497 MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 8239820 ns/op	     121.451 MB/s

$ # Check out the parent commit.
$ git checkout --quiet THE_HASH_OF_THIS_COMMIT^
$ gcc -O3 -Wall -std=c99 test/c/std/gif.c -DWUFFS_MIMIC -lgif
$ ./a.out -bench -focus=wuffs_gif_decode_1000k_full_init | grep MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 9614630 ns/op	     104.084 MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 9556300 ns/op	     104.719 MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 9522440 ns/op	     105.092 MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 9438460 ns/op	     106.027 MB/s
Benchmarkwuffs_gif_decode_1000k_full_init/gcc10	     100	 9477400 ns/op	     105.591 MB/s
----

On a mid-range x86_64 laptop:

wuffs_gif_decode_1k_bw/clang9                367MB/s ± 0%    347MB/s ± 0%   -5.37%  (p=0.016 n=4+5)
wuffs_gif_decode_1k_color_full_init/clang9  89.8MB/s ± 0%   90.6MB/s ± 0%   +0.83%  (p=0.008 n=5+5)
wuffs_gif_decode_1k_color_part_init/clang9   107MB/s ± 0%    107MB/s ± 0%     ~     (p=0.413 n=4+5)
wuffs_gif_decode_10k_bgra/clang9             421MB/s ± 0%    420MB/s ± 0%     ~     (p=0.548 n=5+5)
wuffs_gif_decode_10k_indexed/clang9          111MB/s ± 0%    112MB/s ± 0%     ~     (p=0.056 n=5+5)
wuffs_gif_decode_20k/clang9                  134MB/s ± 0%    134MB/s ± 0%   -0.33%  (p=0.016 n=5+5)
wuffs_gif_decode_100k_artificial/clang9      301MB/s ± 0%    301MB/s ± 0%     ~     (p=0.151 n=5+5)
wuffs_gif_decode_100k_realistic/clang9       115MB/s ± 0%    115MB/s ± 0%     ~     (p=0.151 n=5+5)
wuffs_gif_decode_1000k_full_init/clang9      117MB/s ± 0%    117MB/s ± 0%   -0.17%  (p=0.016 n=5+5)
wuffs_gif_decode_1000k_part_init/clang9      117MB/s ± 1%    117MB/s ± 0%     ~     (p=0.690 n=5+5)
wuffs_gif_decode_anim_screencap/clang9       675MB/s ± 0%    674MB/s ± 0%   -0.20%  (p=0.016 n=4+5)

wuffs_gif_decode_1k_bw/gcc10                 309MB/s ± 0%    313MB/s ± 0%   +1.18%  (p=0.008 n=5+5)
wuffs_gif_decode_1k_color_full_init/gcc10   85.4MB/s ± 0%  104.1MB/s ± 0%  +21.81%  (p=0.008 n=5+5)
wuffs_gif_decode_1k_color_part_init/gcc10   97.9MB/s ± 0%  123.3MB/s ± 0%  +25.92%  (p=0.008 n=5+5)
wuffs_gif_decode_10k_bgra/gcc10              372MB/s ± 0%    447MB/s ± 0%  +19.92%  (p=0.008 n=5+5)
wuffs_gif_decode_10k_indexed/gcc10          97.9MB/s ± 0%  119.0MB/s ± 0%  +21.54%  (p=0.008 n=5+5)
wuffs_gif_decode_20k/gcc10                   123MB/s ± 0%    139MB/s ± 0%  +12.98%  (p=0.008 n=5+5)
wuffs_gif_decode_100k_artificial/gcc10       271MB/s ± 0%    293MB/s ± 0%   +8.16%  (p=0.008 n=5+5)
wuffs_gif_decode_100k_realistic/gcc10        104MB/s ± 0%    119MB/s ± 0%  +13.90%  (p=0.008 n=5+5)
wuffs_gif_decode_1000k_full_init/gcc10       106MB/s ± 0%    121MB/s ± 0%  +14.06%  (p=0.008 n=5+5)
wuffs_gif_decode_1000k_part_init/gcc10       106MB/s ± 0%    121MB/s ± 0%  +14.24%  (p=0.008 n=5+5)
wuffs_gif_decode_anim_screencap/gcc10        633MB/s ± 0%    653MB/s ± 0%   +3.24%  (p=0.008 n=5+5)

mimic_gif_decode_1k_bw                      84.3MB/s ± 0%   84.1MB/s ± 0%     ~     (p=0.151 n=5+5)
mimic_gif_decode_1k_color                   45.1MB/s ± 0%   45.0MB/s ± 1%     ~     (p=0.421 n=5+5)
mimic_gif_decode_10k_indexed                52.4MB/s ± 0%   52.4MB/s ± 0%     ~     (p=0.841 n=5+5)
mimic_gif_decode_20k                        52.6MB/s ± 0%   52.6MB/s ± 0%     ~     (p=0.310 n=5+5)
mimic_gif_decode_100k_artificial            82.9MB/s ± 0%   82.7MB/s ± 1%     ~     (p=0.460 n=5+5)
mimic_gif_decode_100k_realistic             51.1MB/s ± 0%   51.0MB/s ± 0%   -0.12%  (p=0.016 n=5+5)
mimic_gif_decode_1000k                      52.5MB/s ± 0%   52.4MB/s ± 0%     ~     (p=0.548 n=5+5)
mimic_gif_decode_anim_screencap             98.2MB/s ± 0%   98.1MB/s ± 0%   -0.11%  (p=0.032 n=5+5)
2021-02-02 11:32:04 +11:00
2020-03-18 10:08:10 -07:00
2021-01-28 21:54:06 +11:00
2021-01-23 19:50:47 +11:00
2020-04-12 21:13:42 +10:00
2021-01-28 21:54:06 +11:00
2019-12-19 21:46:05 +11:00
2020-08-06 09:20:16 +10:00
2021-01-23 19:50:47 +11:00
2020-08-06 09:20:16 +10:00
2020-02-08 17:20:32 +11:00
2020-01-24 10:01:43 +11:00
2017-10-12 11:17:41 +11:00
2020-10-26 15:28:37 +11:00

WUFFS Logo

Wuffs (Wrangling Untrusted File Formats Safely) is formerly known as Puffs (Parsing Untrusted File Formats Safely).

Wuffs is a memory-safe programming language (and a standard library written in that language) for wrangling untrusted file formats safely. Wrangling includes parsing, decoding and encoding. Example file formats include images, audio, video, fonts and compressed archives.

It is also fast. On many of its GIF decoding benchmarks, Wuffs measures 2x faster than "giflib" (C), 3x faster than "image/gif" (Go) and 7x faster than "gif" (Rust).

Goals and Non-Goals

Wuffs' goal is to produce software libraries that are as safe as Go or Rust, roughly speaking, but as fast as C, and that can be used anywhere C libraries are used. This includes very large C/C++ projects, such as popular web browsers and operating systems (using that term to include desktop and mobile user interfaces, not just the kernel).

Wuffs the Library is available as transpiled C code. Other C/C++ projects can use that library without requiring the Wuffs the Language toolchain. Those projects can use Wuffs the Library like using any other third party C library. It's just not hand-written C.

However, unlike hand-written C, Wuffs the Language is safe with respect to buffer overflows, integer arithmetic overflows and null pointer dereferences. A key difference between Wuffs and other memory-safe languages is that all such checks are done at compile time, not at run time. If it compiles, it is safe, with respect to those three bug classes.

The trade-off in aiming for both safety and speed is that Wuffs programs take longer for a programmer to write, as they have to explicitly annotate their programs with proofs of safety. A statement like x += 1 unsurprisingly means to increment the variable x by 1. However, in Wuffs, such a statement is a compile time error unless the compiler can also prove that x is not the maximal value of x's type (e.g. x is not 255 if x is a base.u8), as the increment would otherwise overflow. Similarly, an integer arithmetic expression like x / y is a compile time error unless the compiler can also prove that y is not zero.

Wuffs is not a general purpose programming language. It is for writing libraries, not programs. The idea isn't to write your whole program in Wuffs, only the parts that are both performance-conscious and security-conscious. For example, while technically possible, it is unlikely that a Wuffs compiler would be worth writing entirely in Wuffs.

What Does Wuffs Code Look Like?

The /std/lzw/decode_lzw.wuffs file is a good example. The Wuffs the Language document has more information on how it differs from other languages in the C family.

What Does Compile Time Checking Look Like?

For example, making this one-line edit to the LZW codec leads to a compile time error. wuffs gen fails to generate the C code, i.e. fails to compile (transpile) the Wuffs code to C code:

diff --git a/std/lzw/decode_lzw.wuffs b/std/lzw/decode_lzw.wuffs
index f878c5e..f10dcee 100644
--- a/std/lzw/decode_lzw.wuffs
+++ b/std/lzw/decode_lzw.wuffs
@@ -98,7 +98,7 @@ pub func lzw_decoder.decode?(dst ptr buf1, src ptr buf1, src_final bool)() {
                        in.dst.write?(x:s)

                        if use_save_code {
-                               this.suffixes[save_code] = c as u8
+                               this.suffixes[save_code] = (c + 1) as u8
                                this.prefixes[save_code] = prev_code as u16
                        }
$ wuffs gen std/gif
check: expression "(c + 1) as u8" bounds [1 ..= 256] is not within bounds [0 ..= 255] at
/home/n/go/src/github.com/google/wuffs/std/lzw/decode_lzw.wuffs:101. Facts:
    n_bits < 8
    c < 256
    this.stack[s] == (c as u8)
    use_save_code

In comparison, this two-line edit will compile (but the "does it decode GIF correctly" tests then fail):

diff --git a/std/lzw/decode_lzw.wuffs b/std/lzw/decode_lzw.wuffs
index f878c5e..b43443d 100644
--- a/std/lzw/decode_lzw.wuffs
+++ b/std/lzw/decode_lzw.wuffs
@@ -97,8 +97,8 @@ pub func lzw_decoder.decode?(dst ptr buf1, src ptr buf1, src_final bool)() {
                        // type checking, bounds checking and code generation for it).
                        in.dst.write?(x:s)

-                       if use_save_code {
-                               this.suffixes[save_code] = c as u8
+                       if use_save_code and (c < 200) {
+                               this.suffixes[save_code] = (c + 1) as u8
                                this.prefixes[save_code] = prev_code as u16
                        }
$ wuffs gen std/gif
gen wrote:      /home/n/go/src/github.com/google/wuffs/gen/c/gif.c
gen unchanged:  /home/n/go/src/github.com/google/wuffs/gen/h/gif.h
$ wuffs test std/gif
gen unchanged:  /home/n/go/src/github.com/google/wuffs/gen/c/gif.c
gen unchanged:  /home/n/go/src/github.com/google/wuffs/gen/h/gif.h
test:           /home/n/go/src/github.com/google/wuffs/test/c/gif
gif/basic.c     clang   PASS (8 tests run)
gif/basic.c     gcc     PASS (8 tests run)
gif/gif.c       clang   FAIL test_lzw_decode: bufs1_equal: wi: got 19311, want 19200.
contents differ at byte 3 (in hex: 0x000003):
  000000: dcdc dc00 00d9 f5f9 f6df dc5f 393a 3a3a  ..........._9:::
  000010: 3a3b 618e c8e4 e4e4 e5e4 e600 00e4 bbbb  :;a.............
  000020: eded 8f91 9191 9090 9090 9190 9192 9192  ................
  000030: 9191 9292 9191 9293 93f0 f0f0 f1f1 f2f2  ................
excerpts of got (above) versus want (below):
  000000: dcdc dcdc dcd9 f5f9 f6df dc5f 393a 3a3a  ..........._9:::
  000010: 3a3a 618e c8e4 e4e4 e5e4 e6e4 e4e4 bbbb  ::a.............
  000020: eded 8f91 9191 9090 9090 9090 9191 9191  ................
  000030: 9191 9191 9191 9193 93f0 f0f0 f1f1 f2f2  ................

gif/gif.c       gcc     FAIL test_lzw_decode: bufs1_equal: wi: got 19311, want 19200.
contents differ at byte 3 (in hex: 0x000003):
  000000: dcdc dc00 00d9 f5f9 f6df dc5f 393a 3a3a  ..........._9:::
  000010: 3a3b 618e c8e4 e4e4 e5e4 e600 00e4 bbbb  :;a.............
  000020: eded 8f91 9191 9090 9090 9190 9192 9192  ................
  000030: 9191 9292 9191 9293 93f0 f0f0 f1f1 f2f2  ................
excerpts of got (above) versus want (below):
  000000: dcdc dcdc dcd9 f5f9 f6df dc5f 393a 3a3a  ..........._9:::
  000010: 3a3a 618e c8e4 e4e4 e5e4 e6e4 e4e4 bbbb  ::a.............
  000020: eded 8f91 9191 9090 9090 9090 9191 9191  ................
  000030: 9191 9191 9191 9193 93f0 f0f0 f1f1 f2f2  ................

wuffs-test-c: some tests failed
wuffs test: some tests failed

Directory Layout

  • lang holds the Go libraries that implement Wuffs the Language: tokenizer, AST, parser, renderer, etc. The Wuffs tools are written in Go, but as mentioned above, Wuffs transpiles to C code, and Go is not necessarily involved if all you want is to use the C edition of Wuffs.
  • lib holds other Go libraries, not specific to Wuffs the Language per se.
  • internal holds internal implementation details, as per Go's internal packages convention.
  • cmd holds Wuffs the Language' command line tools, also written in Go.
  • std holds Wuffs the Library's code.
  • release holds the releases (e.g. in their C form) of Wuffs the Library.
  • test holds the regular tests for Wuffs the Library.
  • fuzz holds the fuzz tests for Wuffs the Library.
  • script holds miscellaneous utility programs.
  • doc holds documentation.
  • example holds example programs for Wuffs the Library.
  • hello-wuffs-c holds an example program for Wuffs the Language.

Documentation

The Note directory also contains various short articles.

Status

Version 0.2. The API and ABI aren't stabilized yet. The compiler undoubtedly has bugs. Assertion checking needs more rigor, especially around side effects and aliasing, and being sufficiently well specified to allow alternative implementations. Lots of detail needs work, but the broad brushstrokes are there.

Discussion

The mailing list is at https://groups.google.com/forum/#!forum/wuffs.

Contributing

The CONTRIBUTING.md file contains instructions on how to file the Contributor License Agreement before sending any pull requests (PRs). Of course, if you're new to the project, it's usually best to discuss any proposals and reach consensus before sending your first PR.

Source code is auto-formatted.

License

Apache 2. See the LICENSE file for details.

Disclaimer

This is not an official Google product, it is just code that happens to be owned by Google.


Updated on December 2019.

S
Description
No description provided
Readme MIT
45 MiB
0 Stars 1 Watchers 0 Forks
Languages
C 88%
Go 9.6%
C++ 2%
Shell 0.2%
Rust 0.2%