tools/android: Benchmark tool for in-memory compression.

Adds a tool that:
- Reads a file from disk
- Compresses and decompresses it using {zlib,snappy}

Example output (Android Go, Gobo):

Gzip
Size = 4096
Compression
  Compression ratio = 2.46154
  Throughput = 4.97989MB/s
  Latency (size = 4096) = 822.508us
Decompression
  Throughput = 41.4281MB/s
  Latency (size = 4096) = 98.87us
Size = 8192
Compression
  Compression ratio = 3.3166
  Throughput = 7.32629MB/s
  Latency (size = 8192) = 1118.16us
Decompression
  Throughput = 63.3125MB/s
  Latency (size = 8192) = 129.39us
Size = 16384
Compression
  Compression ratio = 4.73937
  Throughput = 13.3032MB/s
  Latency (size = 16384) = 1231.58us
Decompression
  Throughput = 80.3413MB/s
  Latency (size = 16384) = 203.93us
Size = 32768
Compression
  Compression ratio = 5.51279
  Throughput = 10.4441MB/s
  Latency (size = 32768) = 3137.45us
Decompression
  Throughput = 108.485MB/s
  Latency (size = 32768) = 302.05us
Size = 65536
Compression
  Compression ratio = 5.36828
  Throughput = 15.3562MB/s
  Latency (size = 65536) = 4267.71us
Decompression
  Throughput = 113.76MB/s
  Latency (size = 65536) = 576.09us
Size = 131072
Compression
  Compression ratio = 5.42517
  Throughput = 10.1509MB/s
  Latency (size = 131072) = 12912.4us
Decompression
  Throughput = 114.958MB/s
  Latency (size = 131072) = 1140.17us

[...]

Snappy
Size = 4096
Compression
  Compression ratio = 1.78787
  Throughput = 53.2261MB/s
  Latency (size = 4096) = 76.9547us
Decompression
  Throughput = 161.323MB/s
  Latency (size = 4096) = 25.39us
Size = 8192
Compression
  Compression ratio = 2.44246
  Throughput = 63.8232MB/s
  Latency (size = 8192) = 128.355us
Decompression
  Throughput = 130.052MB/s
  Latency (size = 8192) = 62.99us
Size = 16384
Compression
  Compression ratio = 3.49339
  Throughput = 70.1383MB/s
  Latency (size = 16384) = 233.596us
Decompression
  Throughput = 173.762MB/s
  Latency (size = 16384) = 94.29us
Size = 32768
Compression
  Compression ratio = 4.24566
  Throughput = 88.4845MB/s
  Latency (size = 32768) = 370.325us
Decompression
  Throughput = 194.561MB/s
  Latency (size = 32768) = 168.42us
Size = 65536
Compression
  Compression ratio = 4.16339
  Throughput = 91.1387MB/s
  Latency (size = 65536) = 719.08us
Decompression
  Throughput = 183.827MB/s
  Latency (size = 65536) = 356.51us
Size = 131072
Compression
  Compression ratio = 4.16009
  Throughput = 87.5235MB/s
  Latency (size = 131072) = 1497.56us
Decompression
  Throughput = 171.56MB/s
  Latency (size = 131072) = 764us

Bug: 860693, 837659
Change-Id: I9887dd4b470ab1acf6d56b717fb73d33439ad453
Reviewed-on: https://chromium-review.googlesource.com/1127991
Commit-Queue: Benoit L <lizeb@chromium.org>
Reviewed-by: Egor Pasko (futex_wait(&amp;secret))) <pasko@chromium.org>
Reviewed-by: Adam Langley <agl@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#579743}

tools/android/io_benchmark/BUILD.gn

@@ -12,3 +12,16 @@ executable("io_benchmark") {
   ]
   testonly = true
 }
+
+executable("compression_benchmark") {
+  sources = [
+    "compression_benchmark.cc",
+  ]
+  deps = [
+    "//base",
+    "//base/test:test_support",
+    "//third_party/snappy",
+    "//third_party/zlib/google:compression_utils",
+  ]
+  testonly = true
+}

tools/android/io_benchmark/DEPS

+include_rules = [
+  "+third_party/snappy",
+  "+third_party/zlib",
+]

tools/android/io_benchmark/compression_benchmark.cc

+// Copyright 2018 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.
+
+// Benchmarks in-memory compression and decompression of an input file,
+// comparing zlib and snappy.
+
+#include <memory>
+#include <string>
+
+#include "base/files/file.h"
+#include "base/files/file_util.h"
+#include "base/logging.h"
+#include "base/time/time.h"
+#include "third_party/snappy/src/snappy.h"
+#include "third_party/zlib/google/compression_utils.h"
+
+namespace {
+
+void LogThroughputAndLatency(size_t size,
+                             int repeats,
+                             base::TimeTicks tick,
+                             base::TimeTicks tock) {
+  size_t total_size = size * repeats;
+  double elapsed_us = (tock - tick).InMicrosecondsF();
+  double throughput = total_size / elapsed_us;
+  double latency_us = elapsed_us / repeats;
+  LOG(INFO) << "  Throughput = " << throughput << "MB/s";
+  LOG(INFO) << "  Latency (size = " << size << ") = " << latency_us << "us";
+  LOG(INFO) << size << "," << throughput << "," << latency_us;
+}
+
+void BenchmarkDecompression(const std::string& contents,
+                            int repeats,
+                            bool snappy) {
+  std::string compressed;
+  if (snappy) {
+    snappy::Compress(contents.c_str(), contents.size(), &compressed);
+  } else {
+    CHECK(compression::GzipCompress(contents, &compressed));
+  }
+
+  auto tick = base::TimeTicks::Now();
+  for (int i = 0; i < repeats; ++i) {
+    std::string uncompressed;
+    if (snappy) {
+      snappy::Uncompress(compressed.c_str(), compressed.size(), &uncompressed);
+    } else {
+      CHECK(compression::GzipUncompress(compressed, &uncompressed));
+    }
+  }
+  auto tock = base::TimeTicks::Now();
+
+  LogThroughputAndLatency(contents.size(), repeats, tick, tock);
+}
+
+void BenchmarkCompression(const std::string& contents,
+                          int repeats,
+                          bool snappy) {
+  size_t compressed_size = 0;
+  auto tick = base::TimeTicks::Now();
+  for (int i = 0; i < repeats; ++i) {
+    std::string compressed;
+    if (snappy) {
+      compressed_size =
+          snappy::Compress(contents.c_str(), contents.size(), &compressed);
+    } else {
+      CHECK(compression::GzipCompress(contents, &compressed));
+      compressed_size = compressed.size();
+    }
+  }
+  auto tock = base::TimeTicks::Now();
+
+  double ratio = contents.size() / static_cast<double>(compressed_size);
+  LOG(INFO) << "  Compression ratio = " << ratio;
+  LogThroughputAndLatency(contents.size(), repeats, tick, tock);
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  if (argc != 2) {
+    LOG(FATAL) << "Usage: " << argv[0] << " <filename>\n\n"
+               << "Where the file contains data to compress";
+    return 1;
+  }
+
+  LOG(INFO) << "Reading the input file";
+  auto path = base::FilePath(std::string(argv[1]));
+  std::string contents;
+  CHECK(base::ReadFileToString(path, &contents));
+
+  constexpr size_t kPageSize = 1 << 12;
+  for (bool use_snappy : {false, true}) {
+    LOG(INFO) << "\n\n\n\n" << (use_snappy ? "Snappy" : "Gzip");
+    for (size_t size = kPageSize; size < contents.size() * 2; size *= 2) {
+      size_t actual_size = std::min(contents.size(), size);
+      std::string data = contents.substr(0, actual_size);
+      LOG(INFO) << "Size = " << actual_size;
+      LOG(INFO) << "Compression";
+      BenchmarkCompression(data, (10 * 1024 * kPageSize) / actual_size,
+                           use_snappy);  // 40MiB.
+      LOG(INFO) << "Decompression";
+      BenchmarkDecompression(data, 100, use_snappy);
+    }
+  }
+  return 0;
+}