Mime sniffer: reduce table from 256 bytes to 4

net/base/mime_sniffer_perftest.cc

Index: net/base/mime_sniffer_perftest.cc
diff --git a/net/base/mime_sniffer_perftest.cc b/net/base/mime_sniffer_perftest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c8a1f656ca64ca446f5fa3ae1b04e5e7584e6c12
--- /dev/null
+++ b/net/base/mime_sniffer_perftest.cc
@@ -0,0 +1,34 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/base/mime_sniffer.h"
+
+#include <vector>
+
+#include "base/test/perf_time_logger.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace {
+
+TEST(MimeSnifferTest, FastPathPerfTest) {

[asanka, 2015/04/29 23:17:44]

Not very keen on this type of perftest that measures a very focused bit of code
that's not performance critical.

It might be interesting to have one that measures how efficient our overall MIME
sniffing logic is since it's doing a bunch of pattern matches. If anything there
takes too long I'd like to know, but I don't think the
does-this-look-like-binary logic is a big factor.

[Adam Rice, 2015/05/07 16:52:50]

I don't expect micro-benchmarks to be representative of real-world performance.
I just added them as a sanity check that I wasn't introducing a major
performance regression.

I have replaced the two very synthetic benchmarks with a slightly more realistic
"PlainTextPerfTest". This exposes something that was not apparent from the
previous benchmarks: the Xeon CPU branch predictor really hates the <0x20
branch. Although SlowPathPerfTest was supposed to account for this, it seems it
was not unpredictable enough.

I got the tests to run on Android by hacking net.gypi to add the file to the
net_unittests target (net_perftests lacks the magic needed to build and run on
Android) and ran the tests on my 2013 Nexus 7.

Results:

Xeon Workstation:

New implementation: 1125ns
Old implementation: 670ns
Old implementation with <0x20 check: 1158ns


Nexus 7:

New implementation: 3437ns
Old implementation: 3442ns
Old implementation with <0x20 check: 3479ns


All the Android results are within the margin of error of each other.

What I plan to do next is add benchmarks for the two hottest paths through this
code, which based on histogram data appear to be

1. Mime type is not considered sniffable, and
2. Mime type is "" and is sniffed as JPEG.

[asanka, 2015/05/12 19:20:41]

Interesting. Thanks for running the tests. I also didn't expect the <0x20 branch
to be this expensive.

+  std::vector<char> plaintext(1 << 28, ' ');
+  base::PerfTimeLogger timer("MimeSnifferFastPathPerf_256MB");
+  ContainsControlCodes(&plaintext[0], plaintext.size());
+}
+
+TEST(MimeSnifferTest, SlowPathPerfTest) {
+  const size_t target_size = 1 << 28;
+  // The control characters force the code to do an array lookup. The "a" is
+  // there to make branch prediction harder.
+  std::string plaintext = "\ta\r\n";
+  plaintext.reserve(target_size);
+  while (plaintext.size() < target_size)
+    plaintext += plaintext;
+  base::PerfTimeLogger timer("MimeSnifferSlowPathPerf_256MB");
+  ContainsControlCodes(&plaintext[0], plaintext.size());
+}
+
+}  // namespace net
+}  // namespace