snappy 0.5.1-java → 0.5.2-java

data/vendor/snappy/snappy.cc

@@ -74,7 +74,7 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
-#include <functional>
+#include <limits>
 #include <memory>
 #include <string>
 #include <utility>
@@ -195,6 +195,12 @@ inline uint16_t* TableEntry8ByteMatch(uint16_t* table, uint64_t bytes,
 }  // namespace
 
 size_t MaxCompressedLength(size_t source_bytes) {
+  // Avoid integer overflow that could cause undersized buffer allocations.
+  // Return std::numeric_limits<size_t>::max() to force a controlled allocation
+  // failure.
+  if (source_bytes > (std::numeric_limits<size_t>::max() - 32) / 7 * 6) {
+    return std::numeric_limits<size_t>::max();
+  }
   // Compressed data can be defined as:
   //    compressed := item* literal*
   //    item       := literal* copy
@@ -281,6 +287,8 @@ inline char* IncrementalCopySlow(const char* src, char* op,
 // 4, 5, 0, 1, 2, 3, 4, 5, 0, 1}. These byte index sequences are generated by
 // calling MakePatternMaskBytes(0, 6, index_sequence<16>()) and
 // MakePatternMaskBytes(16, 6, index_sequence<16>()) respectively.
+
+
 template <size_t... indexes>
 inline constexpr std::array<char, sizeof...(indexes)> MakePatternMaskBytes(
     int index_offset, int pattern_size, index_sequence<indexes...>) {
@@ -298,7 +306,6 @@ MakePatternMaskBytesTable(int index_offset,
       MakePatternMaskBytes(index_offset, pattern_sizes_minus_one + 1,
                            make_index_sequence</*indexes=*/sizeof(V128)>())...};
 }
-
 // This is an array of shuffle control masks that can be used as the source
 // operand for PSHUFB to permute the contents of the destination XMM register
 // into a repeating byte pattern.
@@ -494,7 +501,6 @@ inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
           LoadPatternAndReshuffleMask(src, pattern_size);
       V128 pattern = pattern_and_reshuffle_mask.first;
       V128 reshuffle_mask = pattern_and_reshuffle_mask.second;
-
       // There is at least one, and at most four 16-byte blocks. Writing four
       // conditionals instead of a loop allows FDO to layout the code with
       // respect to the actual probabilities of each length.
@@ -521,7 +527,6 @@ inline char* IncrementalCopy(const char* src, char* op, char* const op_limit,
           LoadPatternAndReshuffleMask(src, pattern_size);
       V128 pattern = pattern_and_reshuffle_mask.first;
       V128 reshuffle_mask = pattern_and_reshuffle_mask.second;
-
       // This code path is relatively cold however so we save code size
       // by avoiding unrolling and vectorizing.
       //
@@ -752,19 +757,36 @@ uint32_t CalculateTableSize(uint32_t input_size) {
 }  // namespace
 
 namespace internal {
-WorkingMemory::WorkingMemory(size_t input_size) {
+size_t WorkingMemory::RequiredSize(size_t input_size) {
   const size_t max_fragment_size = std::min(input_size, kBlockSize);
   const size_t table_size = CalculateTableSize(max_fragment_size);
-  size_ = table_size * sizeof(*table_) + max_fragment_size +
-          MaxCompressedLength(max_fragment_size);
-  mem_ = std::allocator<char>().allocate(size_);
+  return table_size * sizeof(uint16_t) + max_fragment_size +
+         MaxCompressedLength(max_fragment_size);
+}
+
+WorkingMemory::WorkingMemory(size_t input_size)
+    : WorkingMemory(input_size,
+                    std::allocator<char>().allocate(RequiredSize(input_size))) {
+  owns_mem_ = true;
+}
+
+WorkingMemory::WorkingMemory(size_t input_size, char* buffer) {
+  assert(buffer != nullptr);
+  assert(reinterpret_cast<uintptr_t>(buffer) % alignof(uint16_t) == 0);
+  const size_t max_fragment_size = std::min(input_size, kBlockSize);
+  const size_t table_size = CalculateTableSize(max_fragment_size);
+  mem_ = buffer;
+  size_ = RequiredSize(input_size);
+  owns_mem_ = false;
   table_ = reinterpret_cast<uint16_t*>(mem_);
   input_ = mem_ + table_size * sizeof(*table_);
   output_ = input_ + max_fragment_size;
 }
 
 WorkingMemory::~WorkingMemory() {
-  std::allocator<char>().deallocate(mem_, size_);
+  if (owns_mem_) {
+    std::allocator<char>().deallocate(mem_, size_);
+  }
 }
 
 uint16_t* WorkingMemory::GetHashTable(size_t fragment_size,
@@ -1227,7 +1249,7 @@ inline bool Copy64BytesWithPatternExtension(ptrdiff_t dst, size_t offset) {
 void MemCopy64(char* dst, const void* src, size_t size) {
   // Always copy this many bytes.  If that's below size then copy the full 64.
   constexpr int kShortMemCopy = 32;
-
+  (void)kShortMemCopy;
   assert(size <= 64);
   assert(std::less_equal<const void*>()(static_cast<const char*>(src) + size,
                                         dst) ||
@@ -1246,6 +1268,27 @@ void MemCopy64(char* dst, const void* src, size_t size) {
     data = _mm256_lddqu_si256(static_cast<const __m256i *>(src) + 1);
     _mm256_storeu_si256(reinterpret_cast<__m256i *>(dst) + 1, data);
   }
+  // RVV acceleration available on RISC-V when compiled with -march=rv64gcv
+#elif defined(__riscv) && SNAPPY_HAVE_RVV
+  // Cast pointers to the type we will operate on.
+  unsigned char* dst_ptr = reinterpret_cast<unsigned char*>(dst);
+  const unsigned char* src_ptr = reinterpret_cast<const unsigned char*>(src);
+  size_t remaining_bytes = size;
+  // Loop as long as there are bytes remaining to be copied.
+  while (remaining_bytes > 0) {
+    // Set vector configuration: e8 (8-bit elements), m2 (LMUL=2).
+    // Use e8m2 configuration to maximize throughput.
+    size_t vl = VSETVL_E8M2(remaining_bytes);
+    // Load data from the current source pointer.
+    vuint8m2_t vec = VLE8_V_U8M2(src_ptr, vl);
+    // Store data to the current destination pointer.
+    VSE8_V_U8M2(dst_ptr, vec, vl);
+    // Update pointers and the remaining count.
+    src_ptr += vl;
+    dst_ptr += vl;
+    remaining_bytes -= vl;
+  }
+
 #else
   std::memmove(dst, src, kShortMemCopy);
   // Profiling shows that nearly all copies are short.
@@ -1345,19 +1388,51 @@ inline size_t AdvanceToNextTagX86Optimized(const uint8_t** ip_p, size_t* tag) {
   return tag_type;
 }
 
+SNAPPY_ATTRIBUTE_ALWAYS_INLINE
+inline size_t AdvanceToNextTagRVOptimized(const uint8_t** ip_p, size_t* tag) {
+  const uint8_t*& ip = *ip_p;
+  // This section is crucial for the throughput of the decompression loop.
+  // The latency of an iteration is fundamentally constrained by the data chain on ip:
+  // ip -> c = *tag -> literal_len = c >> 2, tag_type = c & 3
+  //      -> literal_advance = literal_len + 2, copy_advance = tag_type + 1
+  //      -> next_ip = ip + literal_advance  OR  ip + copy_advance (literal vs copy)
+  //      -> *tag = byte at (next_ip - 1); ip = next_ip
+  //
+  // Base RISC-V has no x86-style cmov and no AArch64 csinc on the same shape; this
+  // computes both candidate advances and both load offsets, then selects with
+  // (is_literal ? ... : ...). With the Zicond extension (czero.eqz / czero.nez), those
+  // selections typically lower to branchless conditional-zero ops instead of a
+  // hard-to-predict literal/copy branch, which is why this form tends to win there.
+  const size_t literal_len = *tag >> 2;
+  const size_t tag_type = *tag & 3;
+  const bool is_literal = (tag_type == 0);
+  const size_t copy_advance = tag_type + 1;
+  const size_t literal_advance = literal_len + 2;
+  const uint8_t* next_ip = is_literal ? (ip + literal_advance) : (ip + copy_advance);
+  *tag = is_literal ? ip[literal_advance - 1] : ip[copy_advance - 1];
+  ip = next_ip;
+  return tag_type;
+}
+
 // Extract the offset for copy-1 and copy-2 returns 0 for literals or copy-4.
 inline uint32_t ExtractOffset(uint32_t val, size_t tag_type) {
-  // For x86 non-static storage works better. For ARM static storage is better.
+  // For Arm non-static storage works better. For x86 static storage is better.
   // TODO: Once the array is recognized as a register, improve the
   // readability for x86.
 #if defined(__x86_64__)
-  constexpr uint64_t kExtractMasksCombined = 0x0000FFFF00FF0000ull;
+  static constexpr uint64_t kExtractMasksCombined = 0x0000FFFF00FF0000ull;
   uint16_t result;
   memcpy(&result,
          reinterpret_cast<const char*>(&kExtractMasksCombined) + 2 * tag_type,
          sizeof(result));
   return val & result;
-#elif defined(__aarch64__)
+  // For AArch64 and RISC-V, use a bit-twiddling trick to extract the mask from a
+  // single combined constant instead of a lookup table. The constant packs multiple
+  // 16-bit masks based on tag_type (see implementation below). The code calculates
+  // the shift amount from tag_type, right-shifts the constant to move the desired
+  // mask to the LSB position, then extracts it with & 0xFFFF. This branchless
+  // approach is often more performant on modern CPUs.
+#elif defined(__aarch64__) || (defined(__riscv) && (__riscv_xlen == 64))
   constexpr uint64_t kExtractMasksCombined = 0x0000FFFF00FF0000ull;
   return val & static_cast<uint32_t>(
       (kExtractMasksCombined >> (tag_type * 16)) & 0xFFFF);
@@ -1421,6 +1496,11 @@ std::pair<const uint8_t*, ptrdiff_t> DecompressBranchless(
         // We never need more than 16 bits. Doing a Load16 allows the compiler
         // to elide the masking operation in ExtractOffset.
         next = LittleEndian::Load16(old_ip);
+#elif defined(__riscv)
+        size_t tag_type = AdvanceToNextTagRVOptimized(&ip, &tag);
+        // We never need more than 16 bits. Doing a Load16 allows the compiler
+        // to elide the masking operation in ExtractOffset.
+        next = LittleEndian::Load16(old_ip);
 #else
         size_t tag_type = AdvanceToNextTagX86Optimized(&ip, &tag);
         next = LittleEndian::Load32(old_ip);
@@ -1624,9 +1704,13 @@ class SnappyDecompressor {
         if (SNAPPY_PREDICT_FALSE(literal_length >= 61)) {
           // Long literal.
           const size_t literal_length_length = literal_length - 60;
+          // NOTE: literal_length might be equal 2^32 (i.e. ExtractLowBytes
+          // returns 0xFFFFFFFF); this is implicitly invalid stream (since
+          // uncompressed length is capped with 0xFFFFFFFF); for performance we
+          // do not check for this case here.
           literal_length =
               ExtractLowBytes(LittleEndian::Load32(ip), literal_length_length) +
-              1;
+              size_t{1};
           ip += literal_length_length;
         }
 
@@ -1779,13 +1863,13 @@ static bool InternalUncompressAllTags(SnappyDecompressor* decompressor,
                                       Writer* writer, uint32_t compressed_len,
                                       uint32_t uncompressed_len) {
     int token = 0;
-  Report(token, "snappy_uncompress", compressed_len, uncompressed_len);
 
   writer->SetExpectedLength(uncompressed_len);
 
   // Process the entire input
   decompressor->DecompressAllTags(writer);
   writer->Flush();
+  Report(token, "snappy_uncompress", compressed_len, uncompressed_len);
   return (decompressor->eof() && writer->CheckLength());
 }
 
@@ -1798,20 +1882,21 @@ size_t Compress(Source* reader, Sink* writer) {
   return Compress(reader, writer, CompressionOptions{});
 }
 
-size_t Compress(Source* reader, Sink* writer, CompressionOptions options) {
+static size_t InternalCompress(Source* reader, Sink* writer,
+                               CompressionOptions options,
+                               internal::WorkingMemory* wmem) {
   assert(options.level == 1 || options.level == 2);
-  int token = 0;
   size_t written = 0;
   size_t N = reader->Available();
-  assert(N <= 0xFFFFFFFFu);
-  const size_t uncompressed_size = N;
+  // The uncompressed length is a 32-bit varint in the stream format.
+  if (static_cast<uint64_t>(N) > std::numeric_limits<uint32_t>::max()) {
+    return 0;
+  }
   char ulength[Varint::kMax32];
   char* p = Varint::Encode32(ulength, N);
   writer->Append(ulength, p - ulength);
   written += (p - ulength);
 
-  internal::WorkingMemory wmem(N);
-
   while (N > 0) {
     // Get next block to compress (without copying if possible)
     size_t fragment_size;
@@ -1826,7 +1911,7 @@ size_t Compress(Source* reader, Sink* writer, CompressionOptions options) {
       pending_advance = num_to_read;
       fragment_size = num_to_read;
     } else {
-      char* scratch = wmem.GetScratchInput();
+      char* scratch = wmem->GetScratchInput();
       std::memcpy(scratch, fragment, bytes_read);
       reader->Skip(bytes_read);
 
@@ -1845,7 +1930,7 @@ size_t Compress(Source* reader, Sink* writer, CompressionOptions options) {
 
     // Get encoding table for compression
     int table_size;
-    uint16_t* table = wmem.GetHashTable(num_to_read, &table_size);
+    uint16_t* table = wmem->GetHashTable(num_to_read, &table_size);
 
     // Compress input_fragment and append to dest
     int max_output = MaxCompressedLength(num_to_read);
@@ -1855,27 +1940,89 @@ size_t Compress(Source* reader, Sink* writer, CompressionOptions options) {
     // scratch_output[] region is big enough for this iteration.
     // Need a scratch buffer for the output, in case the byte sink doesn't
     // have room for us directly.
-    char* dest = writer->GetAppendBuffer(max_output, wmem.GetScratchOutput());
+    char* dest = writer->GetAppendBuffer(max_output, wmem->GetScratchOutput());
     char* end = nullptr;
-    if (options.level == 1) {
-      end = internal::CompressFragment(fragment, fragment_size, dest, table,
-                                       table_size);
-    } else if (options.level == 2) {
-      end = internal::CompressFragmentDoubleHash(
-          fragment, fragment_size, dest, table, table_size >> 1,
-          table + (table_size >> 1), table_size >> 1);
-    }
+      if (options.level == 1) {
+        end = internal::CompressFragment(fragment, fragment_size, dest, table,
+                                         table_size);
+      } else if (options.level == 2) {
+        end = internal::CompressFragmentDoubleHash(
+            fragment, fragment_size, dest, table, table_size >> 1,
+            table + (table_size >> 1), table_size >> 1);
+      }
+
     writer->Append(dest, end - dest);
     written += (end - dest);
 
     N -= num_to_read;
     reader->Skip(pending_advance);
   }
-
-  Report(token, "snappy_compress", written, uncompressed_size);
   return written;
 }
 
+size_t Compress(Source* reader, Sink* writer, CompressionOptions options) {
+  internal::WorkingMemory wmem(reader->Available());
+  return InternalCompress(reader, writer, options, &wmem);
+}
+
+size_t Compress(Source* reader, Sink* writer, CompressionOptions options,
+                CompressionContext* ctx) {
+  assert(ctx != nullptr);
+  assert(ctx->working_memory_ != nullptr);
+  return InternalCompress(reader, writer, options, ctx->working_memory_);
+}
+
+CompressionContext::CompressionContext()
+    : working_memory_(new internal::WorkingMemory(kBlockSize)),
+      owns_working_memory_(true) {}
+
+size_t CompressionContext::WorkspaceSize() {
+  return sizeof(internal::WorkingMemory) +
+         internal::WorkingMemory::RequiredSize(kBlockSize);
+}
+
+CompressionContext::CompressionContext(void* workspace, size_t workspace_size)
+    : owns_working_memory_(false) {
+  assert(workspace != nullptr);
+  assert(workspace_size >= WorkspaceSize());
+  assert(reinterpret_cast<uintptr_t>(workspace) %
+             alignof(internal::WorkingMemory) ==
+         0);
+  (void)workspace_size;
+  char* base = static_cast<char*>(workspace);
+  working_memory_ = new (base) internal::WorkingMemory(
+      kBlockSize, base + sizeof(internal::WorkingMemory));
+}
+
+void CompressionContext::Reset() {
+  if (working_memory_ == nullptr) return;
+  if (owns_working_memory_) {
+    delete working_memory_;
+  } else {
+    working_memory_->~WorkingMemory();
+  }
+  working_memory_ = nullptr;
+}
+
+CompressionContext::~CompressionContext() { Reset(); }
+
+CompressionContext::CompressionContext(CompressionContext&& other) noexcept
+    : working_memory_(other.working_memory_),
+      owns_working_memory_(other.owns_working_memory_) {
+  other.working_memory_ = nullptr;
+}
+
+CompressionContext& CompressionContext::operator=(
+    CompressionContext&& other) noexcept {
+  if (this != &other) {
+    Reset();
+    working_memory_ = other.working_memory_;
+    owns_working_memory_ = other.owns_working_memory_;
+    other.working_memory_ = nullptr;
+  }
+  return *this;
+}
+
 // -----------------------------------------------------------------------
 // IOVec interfaces
 // -----------------------------------------------------------------------
@@ -2338,6 +2485,17 @@ void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
   *compressed_length = writer.CurrentDestination() - compressed;
 }
 
+void RawCompress(const char* input, size_t input_length, char* compressed,
+                 size_t* compressed_length, CompressionOptions options,
+                 CompressionContext* ctx) {
+  ByteArraySource reader(input, input_length);
+  UncheckedByteArraySink writer(compressed);
+  Compress(&reader, &writer, options, ctx);
+
+  // Compute how many bytes were added
+  *compressed_length = (writer.CurrentDestination() - compressed);
+}
+
 size_t Compress(const char* input, size_t input_length,
                 std::string* compressed) {
   return Compress(input, input_length, compressed, CompressionOptions{});

data/vendor/snappy/snappy.h

@@ -50,6 +50,10 @@ namespace snappy {
   class Source;
   class Sink;
 
+namespace internal {
+class WorkingMemory;
+}  // end namespace internal
+
   struct CompressionOptions {
     // Compression level.
     // Level 1 is the fastest
@@ -64,25 +68,78 @@ namespace snappy {
     // faster decompression speeds than snappy:1 and zstd:-3.
     int level = DefaultCompressionLevel();
 
-    constexpr CompressionOptions() = default;
-    constexpr CompressionOptions(int compression_level)
-        : level(compression_level) {}
+      constexpr CompressionOptions() = default;
+      constexpr explicit CompressionOptions(int compression_level)
+          : level(compression_level) {}
+
     static constexpr int MinCompressionLevel() { return 1; }
     static constexpr int MaxCompressionLevel() { return 2; }
     static constexpr int DefaultCompressionLevel() { return 1; }
   };
 
+  // Scratch memory for compression, reusable across compressions. Callers that
+  // compress frequently, or that need to avoid large heap allocations can
+  // allocate a CompressionContext once and pass it to Compress()/RawCompress()
+  // to reuse the working memory across calls.
+  //
+  // The context is sized for the largest block and works for inputs of any
+  // size. A context may be used by any number of sequential compressions, but
+  // must not be used from multiple threads concurrently. A moved-from context
+  // may only be destroyed or assigned to.
+  class CompressionContext {
+   public:
+    // Allocates the working memory on the heap.
+    CompressionContext();
+
+    // Constructs a context whose working memory is placed in the
+    // caller-provided "workspace" instead of being heap-allocated; the
+    // library performs no allocation at all.
+    //
+    // REQUIRES: "workspace" points to at least "workspace_size" bytes with
+    // "workspace_size >= WorkspaceSize()", is suitably aligned for any
+    // object type (as if returned by malloc), and outlives "*this".
+    CompressionContext(void* workspace, size_t workspace_size);
+
+    ~CompressionContext();
+
+    CompressionContext(CompressionContext&& other) noexcept;
+    CompressionContext& operator=(CompressionContext&& other) noexcept;
+
+    CompressionContext(const CompressionContext&) = delete;
+    CompressionContext& operator=(const CompressionContext&) = delete;
+
+    // The workspace size required by the non-allocating constructor above.
+    static size_t WorkspaceSize();
+
+   private:
+    friend size_t Compress(Source* reader, Sink* writer,
+                           CompressionOptions options, CompressionContext* ctx);
+
+    // Destroys the working memory as appropriate for how it was created
+    // (delete if heap-allocated, in-place destruction if placement-constructed
+    // in a caller-provided workspace).
+    void Reset();
+
+    internal::WorkingMemory* working_memory_;
+    bool owns_working_memory_;
+  };
+
   // ------------------------------------------------------------------------
   // Generic compression/decompression routines.
   // ------------------------------------------------------------------------
 
   // Compress the bytes read from "*reader" and append to "*writer". Return the
-  // number of bytes written.
+  // number of bytes written, or zero if "*reader" has 2^32 or more bytes.
   // First version is to preserve ABI.
   size_t Compress(Source* reader, Sink* writer);
   size_t Compress(Source* reader, Sink* writer,
                   CompressionOptions options);
 
+  // Same as the above, but uses the working memory of "*ctx" instead of
+  // allocating it internally. See CompressionContext.
+  size_t Compress(Source* reader, Sink* writer, CompressionOptions options,
+                  CompressionContext* ctx);
+
   // Find the uncompressed length of the given stream, as given by the header.
   // Note that the true length could deviate from this; the stream could e.g.
   // be truncated.
@@ -97,7 +154,8 @@ namespace snappy {
   // ------------------------------------------------------------------------
 
   // Sets "*compressed" to the compressed version of "input[0..input_length-1]".
-  // Original contents of *compressed are lost.
+  // Original contents of *compressed are lost. Returns zero and writes nothing
+  // if "input_length" is 2^32 or more.
   //
   // REQUIRES: "input[]" is not an alias of "*compressed".
   // First version is to preserve ABI.
@@ -109,7 +167,8 @@ namespace snappy {
   // Same as `Compress` above but taking an `iovec` array as input. Note that
   // this function preprocesses the inputs to compute the sum of
   // `iov[0..iov_cnt-1].iov_len` before reading. To avoid this, use
-  // `RawCompressFromIOVec` below.
+  // `RawCompressFromIOVec` below. Returns zero and writes nothing if that sum
+  // is 2^32 or more.
   // First version is to preserve ABI.
   size_t CompressFromIOVec(const struct iovec* iov, size_t iov_cnt,
                            std::string* compressed);
@@ -150,6 +209,9 @@ namespace snappy {
   // Takes the data stored in "input[0..input_length]" and stores
   // it in the array pointed to by "compressed".
   //
+  // "*compressed_length" is set to the length of the compressed output, or to
+  // zero, with nothing written, if "input_length" is 2^32 or more.
+  //
   // "*compressed_length" is set to the length of the compressed output.
   //
   // Example:
@@ -158,14 +220,23 @@ namespace snappy {
   //    RawCompress(input, input_length, output, &output_length);
   //    ... Process(output, output_length) ...
   //    delete [] output;
+  // First version is to preserve ABI.
   void RawCompress(const char* input, size_t input_length, char* compressed,
                    size_t* compressed_length);
   void RawCompress(const char* input, size_t input_length, char* compressed,
                    size_t* compressed_length, CompressionOptions options);
+  // Same as the above, but uses the working memory of "*ctx" instead of
+  // allocating it internally. See CompressionContext.
+  void RawCompress(const char* input, size_t input_length, char* compressed,
+                   size_t* compressed_length, CompressionOptions options,
+                   CompressionContext* ctx);
 
   // Same as `RawCompress` above but taking an `iovec` array as input. Note that
   // `uncompressed_length` is the total number of bytes to be read from the
-  // elements of `iov` (_not_ the number of elements in `iov`).
+  // elements of `iov` (_not_ the number of elements in `iov`). Sets
+  // "*compressed_length" to zero and writes nothing if `uncompressed_length`
+  // is 2^32 or more.
+  // First version is to preserve ABI.
   void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
                             char* compressed, size_t* compressed_length);
   void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,

data/vendor/snappy/snappy_benchmark.cc

@@ -31,10 +31,12 @@
 #include <string>
 #include <vector>
 
+#include "snappy-test.h"
+
 #include "benchmark/benchmark.h"
+
 #include "snappy-internal.h"
 #include "snappy-sinksource.h"
-#include "snappy-test.h"
 #include "snappy.h"
 #include "snappy_test_data.h"
 
@@ -192,8 +194,9 @@ void BM_UIOVecSource(benchmark::State& state) {
   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});
+    snappy::RawCompressFromIOVec(
+        iov, contents.size(), dst, &zsize,
+        snappy::CompressionOptions{/*level=*/static_cast<int>(level)});
     benchmark::DoNotOptimize(iov);
   }
   state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
@@ -226,7 +229,7 @@ void BM_UIOVecSink(benchmark::State& state) {
   // Uncompress into an iovec containing ten entries.
   const int kNumEntries = 10;
   struct iovec iov[kNumEntries];
-  char* dst = new char[contents.size()];
+  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;
@@ -304,8 +307,9 @@ void BM_ZFlat(benchmark::State& state) {
 
   size_t zsize = 0;
   for (auto s : state) {
-    snappy::RawCompress(contents.data(), contents.size(), dst, &zsize,
-                        snappy::CompressionOptions{/*level=*/level});
+    snappy::RawCompress(
+        contents.data(), contents.size(), dst, &zsize,
+        snappy::CompressionOptions{/*level=*/static_cast<int>(level)});
     benchmark::DoNotOptimize(dst);
   }
   state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
@@ -340,8 +344,9 @@ void BM_ZFlatAll(benchmark::State& state) {
   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});
+      snappy::RawCompress(
+          contents[i].data(), contents[i].size(), dst[i], &zsize,
+          snappy::CompressionOptions{/*level=*/static_cast<int>(level)});
       benchmark::DoNotOptimize(dst);
     }
   }
@@ -377,8 +382,9 @@ void BM_ZFlatIncreasingTableSize(benchmark::State& state) {
   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});
+      snappy::RawCompress(
+          contents[i].data(), contents[i].size(), dst[i], &zsize,
+          snappy::CompressionOptions{/*level=*/static_cast<int>(level)});
       benchmark::DoNotOptimize(dst);
     }
   }