snappy-ruby 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0d4b3c17111621f88734a4b6f1c86d9a48efeda84919f0023ae44a90d35e6dd
-  data.tar.gz: 2a64d86332ba69daaeb3bdda2e4177f3569693579c24977c59abe48700d15477
+  metadata.gz: 7fa950bf54b4cff60c331c99cd9344f00f3f866d1a742b6dd3b444a4eeea3ab7
+  data.tar.gz: 108576d2759e0a3c41e3371d09f8625a47e61f753c48e47e9d516f9a70d383ba
 SHA512:
-  metadata.gz: 4357498ff2a045b4988f3340121efa32b921fb592a387bd59e022d84df4c0b57c17350d82c76303857b770b503eee02891560d5f2f2fd501fde7224954f3b298
-  data.tar.gz: be36815e4e0d8f6d468574495ebfc675e291643c07c04ea19a04608d6f5ad08d2e70cf267f4381d6f8e53abe2af2d038cab35a6938c1a1ed3e098000ceb4c668
+  metadata.gz: 96087d06422cd609b2933643d6458cf655b207502d7a9489f7c14ba3ed0436ac3d9f64865bab9760ef5133a550ed23fab77e5792d22bf338895e3424362b7ffe
+  data.tar.gz: f6a9534da13ba8d4ea7203105fcaae82026dc68dea3c2c6ac6ab6dcba38a45a6831c2977c11e753d47db7c8849e4bc6065c18ff251bc837269463c04900772c9

data/CLAUDE.md

@@ -0,0 +1,117 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+snappy-ruby is a Ruby gem that provides bindings to Google's Snappy compression library. The gem bundles the Snappy C++ source code and provides a complete Ruby interface for all external functions defined in snappy.h.
+
+## Repository Structure
+
+- `ext/snappy/` - Native C extension code that wraps the Snappy library
+  - `snappy-src/` - Bundled Google Snappy C++ source code
+  - `extconf.rb` - Configuration script for building the native extension
+- `lib/snappy/` - Ruby code and version information
+- `test/` - Test suite using Minitest or RSpec
+- `snappy-ruby.gemspec` - Gem specification file
+
+## Development Commands
+
+### Building the Extension
+
+```bash
+# Build the native extension
+cd ext/snappy
+ruby extconf.rb
+make
+cd ../..
+
+# Or use rake to build
+rake compile
+```
+
+### Running Tests
+
+```bash
+# Run the full test suite
+rake test
+
+# Run a single test file
+ruby -Ilib:test test/test_snappy.rb
+
+# Run a specific test method
+ruby -Ilib:test test/test_snappy.rb -n test_compress
+```
+
+### Building the Gem
+
+```bash
+# Build the gem package
+gem build snappy-ruby.gemspec
+
+# Install the gem locally for testing
+gem install ./snappy-ruby-1.0.1.gem
+
+# Clean build artifacts
+rake clean
+rake clobber
+```
+
+### Git Operations
+
+Git is configured with:
+- User: John Greninger
+- Email: jgreninger@hotmail.com
+
+## Architecture
+
+### Native Extension Layer
+
+The C extension (`ext/snappy/snappy_ext.c`) provides Ruby method bindings for all Snappy operations:
+- Compression: `Snappy.compress(data)`
+- Decompression: `Snappy.uncompress(data)` / `Snappy.decompress(data)`
+- Raw compression: `Snappy.raw_compress(data)`
+- Raw decompression: `Snappy.raw_uncompress(data)`
+- Utilities: `Snappy.max_compressed_length(source_length)`, `Snappy.uncompressed_length(compressed)`
+- Validation: `Snappy.valid?(compressed_data)`
+
+All snappy.h external interfaces are mapped to corresponding Ruby methods.
+
+### Ruby Layer
+
+The Ruby layer (`lib/snappy.rb`) provides:
+- Module structure and organization
+- Version information
+- High-level convenience methods
+- Error handling and type validation
+
+### Bundled Source Code
+
+The Snappy C++ source code is bundled in `ext/snappy/snappy-src/`. During gem installation, the extension is compiled against this bundled source, ensuring the gem works without requiring system-level Snappy installation.
+
+## Testing Strategy
+
+Tests are organized to cover:
+1. Basic compression/decompression operations
+2. All snappy.h interface methods
+3. Edge cases (empty data, invalid data, large data)
+4. Error handling and validation
+5. Round-trip compression/decompression verification
+6. Raw compression API
+7. Utility functions (length calculations, validation)
+
+## Gem Publishing Configuration
+
+The gem is configured for RubyGems.org publication:
+- Version: 1.0.1
+- Name: snappy-ruby
+- Required Ruby version and dependencies specified in gemspec
+- Native extension properly configured for compilation during installation
+
+## Important Implementation Details
+
+- The native extension must properly handle memory management for C++ objects
+- Ruby strings need proper encoding handling (BINARY/ASCII-8BIT for compressed data)
+- Error handling must convert C++ exceptions to Ruby exceptions
+- Buffer size calculations must use Snappy's provided functions to avoid overflows
+- The gemspec must include all necessary files (lib, ext, bundled source) in the package

data/ext/snappy/extconf.rb

@@ -1,83 +1,33 @@
-require "mkmf"
+require 'mkmf'
 
-# Configuration for bundled Snappy library
-SNAPPY_DIR = File.expand_path("snappy-src", __dir__)
-
-unless File.directory?(SNAPPY_DIR)
-  abort <<-ERROR
-
-  ERROR: Snappy source directory not found at #{SNAPPY_DIR}
-
-  The Snappy library source should be bundled with this gem.
-  Please ensure the gem was installed correctly.
-
-  ERROR
-end
+# Set C++ compiler
+CONFIG['CC'] = 'g++'
+CONFIG['CXX'] = 'g++'
+CONFIG['LDSHARED'] = 'g++ -shared'
 
 # Add Snappy source directory to include path
-$INCFLAGS << " -I#{SNAPPY_DIR}"
-
-# Add C++11 support (required by Snappy)
-$CXXFLAGS << " -std=c++11 -fno-exceptions -fno-rtti"
-
-# Link against C++ standard library
-$LIBS << " -lstdc++"
-
-# Define HAVE_CONFIG_H to use our config.h
-$CPPFLAGS << " -DHAVE_CONFIG_H"
+$INCFLAGS << " -I$(srcdir)/snappy-src"
 
-# Disable some warnings for cleaner output
-$CXXFLAGS << " -Wno-sign-compare"
+# Add C++11 standard flag
+$CXXFLAGS << " -std=c++11"
 
-# Create a symlink for snappy.cc with a different name to avoid conflict with snappy.c
-# The Ruby binding (snappy.c) will compile to snappy.o
-# The Snappy library (snappy-lib.cc) will compile to snappy-lib.o
-snappy_lib_link = File.join(SNAPPY_DIR, "snappy-lib.cc")
-snappy_lib_src = File.join(SNAPPY_DIR, "snappy.cc")
+# Add optimization flags
+$CXXFLAGS << " -O2"
 
-# Remove old symlink if it exists, then create new one
-File.delete(snappy_lib_link) if File.exist?(snappy_lib_link) || File.symlink?(snappy_lib_link)
-File.symlink("snappy.cc", snappy_lib_link)
+# Add VPATH for source files
+$VPATH << "$(srcdir)/snappy-src"
 
-# List of Snappy source files to compile
+# Source files to compile (without path prefix, since we're using VPATH)
 snappy_sources = %w[
-  snappy-lib.cc
-  snappy-c.cc
+  snappy.cc
   snappy-sinksource.cc
   snappy-stubs-internal.cc
+  snappy-c.cc
 ]
 
-# Add VPATH to tell make where to find the source files
-$VPATH ||= []
-$VPATH << SNAPPY_DIR
-
-# Initialize $objs if it's not already initialized
-$objs ||= []
-
-# First, add the main Ruby binding (snappy.c -> snappy.o)
-# This file is in ext/snappy/, not in snappy-src/
-$objs << "snappy.o"
-
-# Add Snappy library source files
-snappy_sources.each do |src|
-  $objs << src.sub(/\.cc$/, ".o")
-end
-
-# Verify all required source files exist
-missing_files = snappy_sources.reject { |src| File.exist?(File.join(SNAPPY_DIR, src)) || File.symlink?(File.join(SNAPPY_DIR, src)) }
-unless missing_files.empty?
-  abort "ERROR: Missing Snappy source files:\n  #{missing_files.join("\n  ")}"
-end
-
-puts "=" * 70
-puts "Building snappy-ruby with bundled Snappy library"
-puts "=" * 70
-puts "Snappy source: #{SNAPPY_DIR}"
-puts "Include flags: #{$INCFLAGS}"
-puts "C++ flags: #{$CXXFLAGS}"
-puts "Main Ruby binding: snappy.c"
-puts "Compiling Snappy sources:"
-snappy_sources.each { |src| puts "  - #{src}" }
-puts "=" * 70
+# Set the object files list
+$objs = snappy_sources.map { |src| src.sub(/\.cc$/, '.o') }
+$objs << 'snappy_ext.o'
 
-create_makefile("snappy/snappy")
+# Create Makefile
+create_makefile('snappy/snappy')

data/ext/snappy/snappy-src/snappy-stubs-public.h

@@ -27,26 +27,29 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Various type stubs for the open-source version of Snappy.
-// Auto-generated from snappy-stubs-public.h.in for snappy-ruby gem
+//
+// This file cannot include config.h, as it is included from snappy.h,
+// which is a public header. Instead, snappy-stubs-public.h is generated by
+// from snappy-stubs-public.h.in at configure time.
 
 #ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
 #define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
 
 #include <cstddef>
 
-#if 1  // HAVE_SYS_UIO_H
+#ifndef _WIN32  // HAVE_SYS_UIO_H
 #include <sys/uio.h>
 #endif  // HAVE_SYS_UIO_H
 
 #define SNAPPY_MAJOR 1
 #define SNAPPY_MINOR 2
-#define SNAPPY_PATCHLEVEL 1
+#define SNAPPY_PATCHLEVEL 2
 #define SNAPPY_VERSION \
     ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL)
 
 namespace snappy {
 
-#if !1  // !HAVE_SYS_UIO_H
+#ifdef _WIN32  // !HAVE_SYS_UIO_H
 // Windows does not have an iovec type, yet the concept is universally useful.
 // It is simple to define it ourselves, so we put it inside our own namespace.
 struct iovec {

data/ext/snappy/snappy-src/snappy_benchmark.cc

@@ -0,0 +1,398 @@
+// Copyright 2020 Google Inc. All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+#include "snappy-internal.h"
+#include "snappy-sinksource.h"
+#include "snappy-test.h"
+#include "snappy.h"
+#include "snappy_test_data.h"
+
+namespace snappy {
+
+namespace {
+
+void FilesAndLevels(benchmark::internal::Benchmark* benchmark) {
+  for (int i = 0; i < ARRAYSIZE(kTestDataFiles); ++i) {
+    for (int level = snappy::CompressionOptions::MinCompressionLevel();
+         level <= snappy::CompressionOptions::MaxCompressionLevel(); ++level) {
+      benchmark->ArgPair(i, level);
+    }
+  }
+}
+
+void BM_UFlat(benchmark::State& state) {
+  // Pick file to process based on state.range(0).
+  int file_index = state.range(0);
+
+  CHECK_GE(file_index, 0);
+  CHECK_LT(file_index, ARRAYSIZE(kTestDataFiles));
+  std::string contents =
+      ReadTestDataFile(kTestDataFiles[file_index].filename,
+                       kTestDataFiles[file_index].size_limit);
+
+  std::string zcontents;
+  snappy::Compress(
+      contents.data(), contents.size(), &zcontents,
+      snappy::CompressionOptions{/*level=*/static_cast<int>(state.range(1))});
+  char* dst = new char[contents.size()];
+
+  for (auto s : state) {
+    CHECK(snappy::RawUncompress(zcontents.data(), zcontents.size(), dst));
+    benchmark::DoNotOptimize(dst);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          static_cast<int64_t>(contents.size()));
+  state.SetLabel(kTestDataFiles[file_index].label);
+
+  delete[] dst;
+}
+BENCHMARK(BM_UFlat)->Apply(FilesAndLevels);
+
+struct SourceFiles {
+  SourceFiles() {
+    for (int i = 0; i < kFiles; i++) {
+      std::string contents = ReadTestDataFile(kTestDataFiles[i].filename,
+                                              kTestDataFiles[i].size_limit);
+      max_size = std::max(max_size, contents.size());
+      sizes[i] = contents.size();
+      snappy::Compress(contents.data(), contents.size(), &zcontents[i]);
+    }
+  }
+  static constexpr int kFiles = ARRAYSIZE(kTestDataFiles);
+  std::string zcontents[kFiles];
+  size_t sizes[kFiles];
+  size_t max_size = 0;
+};
+
+void BM_UFlatMedley(benchmark::State& state) {
+  static const SourceFiles* const source = new SourceFiles();
+
+  std::vector<char> dst(source->max_size);
+
+  for (auto s : state) {
+    for (int i = 0; i < SourceFiles::kFiles; i++) {
+      CHECK(snappy::RawUncompress(source->zcontents[i].data(),
+                                  source->zcontents[i].size(), dst.data()));
+      benchmark::DoNotOptimize(dst);
+    }
+  }
+
+  int64_t source_sizes = 0;
+  for (int i = 0; i < SourceFiles::kFiles; i++) {
+    source_sizes += static_cast<int64_t>(source->sizes[i]);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          source_sizes);
+}
+BENCHMARK(BM_UFlatMedley);
+
+void BM_UValidate(benchmark::State& state) {
+  // Pick file to process based on state.range(0).
+  int file_index = state.range(0);
+
+  CHECK_GE(file_index, 0);
+  CHECK_LT(file_index, ARRAYSIZE(kTestDataFiles));
+  std::string contents =
+      ReadTestDataFile(kTestDataFiles[file_index].filename,
+                       kTestDataFiles[file_index].size_limit);
+
+  std::string zcontents;
+  snappy::Compress(
+      contents.data(), contents.size(), &zcontents,
+      snappy::CompressionOptions{/*level=*/static_cast<int>(state.range(1))});
+
+  for (auto s : state) {
+    CHECK(snappy::IsValidCompressedBuffer(zcontents.data(), zcontents.size()));
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          static_cast<int64_t>(contents.size()));
+  state.SetLabel(kTestDataFiles[file_index].label);
+}
+BENCHMARK(BM_UValidate)->Apply(FilesAndLevels);
+
+void BM_UValidateMedley(benchmark::State& state) {
+  static const SourceFiles* const source = new SourceFiles();
+
+  for (auto s : state) {
+    for (int i = 0; i < SourceFiles::kFiles; i++) {
+      CHECK(snappy::IsValidCompressedBuffer(source->zcontents[i].data(),
+                                            source->zcontents[i].size()));
+    }
+  }
+
+  int64_t source_sizes = 0;
+  for (int i = 0; i < SourceFiles::kFiles; i++) {
+    source_sizes += static_cast<int64_t>(source->sizes[i]);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          source_sizes);
+}
+BENCHMARK(BM_UValidateMedley);
+
+void BM_UIOVecSource(benchmark::State& state) {
+  // Pick file to process based on state.range(0).
+  int file_index = state.range(0);
+  int level = state.range(1);
+
+  CHECK_GE(file_index, 0);
+  CHECK_LT(file_index, ARRAYSIZE(kTestDataFiles));
+  std::string contents =
+      ReadTestDataFile(kTestDataFiles[file_index].filename,
+                       kTestDataFiles[file_index].size_limit);
+
+  // Create `iovec`s of the `contents`.
+  const int kNumEntries = 10;
+  struct iovec iov[kNumEntries];
+  size_t used_so_far = 0;
+  for (int i = 0; i < kNumEntries; ++i) {
+    iov[i].iov_base = const_cast<char*>(contents.data()) + used_so_far;
+    if (used_so_far == contents.size()) {
+      iov[i].iov_len = 0;
+      continue;
+    }
+    if (i == kNumEntries - 1) {
+      iov[i].iov_len = contents.size() - used_so_far;
+    } else {
+      iov[i].iov_len = contents.size() / kNumEntries;
+    }
+    used_so_far += iov[i].iov_len;
+  }
+
+  char* dst = new char[snappy::MaxCompressedLength(contents.size())];
+  size_t zsize = 0;
+  for (auto s : state) {
+    snappy::RawCompressFromIOVec(iov, contents.size(), dst, &zsize,
+                                 snappy::CompressionOptions{/*level=*/level});
+    benchmark::DoNotOptimize(iov);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          static_cast<int64_t>(contents.size()));
+  const double compression_ratio =
+      static_cast<double>(zsize) / std::max<size_t>(1, contents.size());
+  state.SetLabel(StrFormat("%s (%.2f %%)", kTestDataFiles[file_index].label,
+                           100.0 * compression_ratio));
+  VLOG(0) << StrFormat("compression for %s: %d -> %d bytes",
+                       kTestDataFiles[file_index].label, contents.size(),
+                       zsize);
+
+  delete[] dst;
+}
+BENCHMARK(BM_UIOVecSource)->Apply(FilesAndLevels);
+
+void BM_UIOVecSink(benchmark::State& state) {
+  // Pick file to process based on state.range(0).
+  int file_index = state.range(0);
+
+  CHECK_GE(file_index, 0);
+  CHECK_LT(file_index, ARRAYSIZE(kTestDataFiles));
+  std::string contents =
+      ReadTestDataFile(kTestDataFiles[file_index].filename,
+                       kTestDataFiles[file_index].size_limit);
+
+  std::string zcontents;
+  snappy::Compress(contents.data(), contents.size(), &zcontents);
+
+  // Uncompress into an iovec containing ten entries.
+  const int kNumEntries = 10;
+  struct iovec iov[kNumEntries];
+  char* dst = new char[contents.size()];
+  size_t used_so_far = 0;
+  for (int i = 0; i < kNumEntries; ++i) {
+    iov[i].iov_base = dst + used_so_far;
+    if (used_so_far == contents.size()) {
+      iov[i].iov_len = 0;
+      continue;
+    }
+
+    if (i == kNumEntries - 1) {
+      iov[i].iov_len = contents.size() - used_so_far;
+    } else {
+      iov[i].iov_len = contents.size() / kNumEntries;
+    }
+    used_so_far += iov[i].iov_len;
+  }
+
+  for (auto s : state) {
+    CHECK(snappy::RawUncompressToIOVec(zcontents.data(), zcontents.size(), iov,
+                                       kNumEntries));
+    benchmark::DoNotOptimize(iov);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          static_cast<int64_t>(contents.size()));
+  state.SetLabel(kTestDataFiles[file_index].label);
+
+  delete[] dst;
+}
+BENCHMARK(BM_UIOVecSink)->DenseRange(0, 4);
+
+void BM_UFlatSink(benchmark::State& state) {
+  // Pick file to process based on state.range(0).
+  int file_index = state.range(0);
+
+  CHECK_GE(file_index, 0);
+  CHECK_LT(file_index, ARRAYSIZE(kTestDataFiles));
+  std::string contents =
+      ReadTestDataFile(kTestDataFiles[file_index].filename,
+                       kTestDataFiles[file_index].size_limit);
+
+  std::string zcontents;
+  snappy::Compress(
+      contents.data(), contents.size(), &zcontents,
+      snappy::CompressionOptions{/*level=*/static_cast<int>(state.range(1))});
+  char* dst = new char[contents.size()];
+
+  for (auto s : state) {
+    snappy::ByteArraySource source(zcontents.data(), zcontents.size());
+    snappy::UncheckedByteArraySink sink(dst);
+    CHECK(snappy::Uncompress(&source, &sink));
+    benchmark::DoNotOptimize(sink);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          static_cast<int64_t>(contents.size()));
+  state.SetLabel(kTestDataFiles[file_index].label);
+
+  std::string s(dst, contents.size());
+  CHECK_EQ(contents, s);
+
+  delete[] dst;
+}
+
+BENCHMARK(BM_UFlatSink)->Apply(FilesAndLevels);
+
+void BM_ZFlat(benchmark::State& state) {
+  // Pick file to process based on state.range(0).
+  int file_index = state.range(0);
+  int level = state.range(1);
+
+  CHECK_GE(file_index, 0);
+  CHECK_LT(file_index, ARRAYSIZE(kTestDataFiles));
+  std::string contents =
+      ReadTestDataFile(kTestDataFiles[file_index].filename,
+                       kTestDataFiles[file_index].size_limit);
+  char* dst = new char[snappy::MaxCompressedLength(contents.size())];
+
+  size_t zsize = 0;
+  for (auto s : state) {
+    snappy::RawCompress(contents.data(), contents.size(), dst, &zsize,
+                        snappy::CompressionOptions{/*level=*/level});
+    benchmark::DoNotOptimize(dst);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          static_cast<int64_t>(contents.size()));
+  const double compression_ratio =
+      static_cast<double>(zsize) / std::max<size_t>(1, contents.size());
+  state.SetLabel(StrFormat("%s (%.2f %%)", kTestDataFiles[file_index].label,
+                           100.0 * compression_ratio));
+  VLOG(0) << StrFormat("compression for %s: %d -> %d bytes",
+                       kTestDataFiles[file_index].label, contents.size(),
+                       zsize);
+  delete[] dst;
+}
+
+BENCHMARK(BM_ZFlat)->Apply(FilesAndLevels);
+
+void BM_ZFlatAll(benchmark::State& state) {
+  const int num_files = ARRAYSIZE(kTestDataFiles);
+  int level = state.range(0);
+
+  std::vector<std::string> contents(num_files);
+  std::vector<char*> dst(num_files);
+
+  int64_t total_contents_size = 0;
+  for (int i = 0; i < num_files; ++i) {
+    contents[i] = ReadTestDataFile(kTestDataFiles[i].filename,
+                                   kTestDataFiles[i].size_limit);
+    dst[i] = new char[snappy::MaxCompressedLength(contents[i].size())];
+    total_contents_size += contents[i].size();
+  }
+
+  size_t zsize = 0;
+  for (auto s : state) {
+    for (int i = 0; i < num_files; ++i) {
+      snappy::RawCompress(contents[i].data(), contents[i].size(), dst[i],
+                          &zsize, snappy::CompressionOptions{/*level=*/level});
+      benchmark::DoNotOptimize(dst);
+    }
+  }
+
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          total_contents_size);
+
+  for (char* dst_item : dst) {
+    delete[] dst_item;
+  }
+  state.SetLabel(StrFormat("%d kTestDataFiles", num_files));
+}
+BENCHMARK(BM_ZFlatAll)->DenseRange(1, 2);
+
+void BM_ZFlatIncreasingTableSize(benchmark::State& state) {
+  CHECK_GT(ARRAYSIZE(kTestDataFiles), 0);
+  int level = state.range(0);
+  const std::string base_content = ReadTestDataFile(
+      kTestDataFiles[0].filename, kTestDataFiles[0].size_limit);
+
+  std::vector<std::string> contents;
+  std::vector<char*> dst;
+  int64_t total_contents_size = 0;
+  for (int table_bits = kMinHashTableBits; table_bits <= kMaxHashTableBits;
+       ++table_bits) {
+    std::string content = base_content;
+    content.resize(1 << table_bits);
+    dst.push_back(new char[snappy::MaxCompressedLength(content.size())]);
+    total_contents_size += content.size();
+    contents.push_back(std::move(content));
+  }
+
+  size_t zsize = 0;
+  for (auto s : state) {
+    for (size_t i = 0; i < contents.size(); ++i) {
+      snappy::RawCompress(contents[i].data(), contents[i].size(), dst[i],
+                          &zsize, snappy::CompressionOptions{/*level=*/level});
+      benchmark::DoNotOptimize(dst);
+    }
+  }
+
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
+                          total_contents_size);
+
+  for (char* dst_item : dst) {
+    delete[] dst_item;
+  }
+  state.SetLabel(StrFormat("%d tables", contents.size()));
+}
+BENCHMARK(BM_ZFlatIncreasingTableSize)->DenseRange(1, 2);
+
+}  // namespace
+
+}  // namespace snappy