snappy_test_tool.cc - third_party/snappy - Git at Google

 // 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 <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <cstdlib>
 #include <random>
 #include <string>
 #include <utility>
 #include <vector>

 #include "snappy-test.h"

 #include "snappy-internal.h"
 #include "snappy-sinksource.h"
 #include "snappy.h"
 #include "snappy_test_data.h"

 SNAPPY_FLAG(int32_t, start_len, -1,
             "Starting prefix size for testing (-1: just full file contents)");
 SNAPPY_FLAG(int32_t, end_len, -1,
             "Starting prefix size for testing (-1: just full file contents)");
 SNAPPY_FLAG(int32_t, bytes, 10485760,
             "How many bytes to compress/uncompress per file for timing");

 SNAPPY_FLAG(bool, zlib, true,
             "Run zlib compression (http://www.zlib.net)");
 SNAPPY_FLAG(bool, lzo, true,
             "Run LZO compression (http://www.oberhumer.com/opensource/lzo/)");
 SNAPPY_FLAG(bool, lz4, true,
             "Run LZ4 compression (https://github.com/lz4/lz4)");
 SNAPPY_FLAG(bool, snappy, true, "Run snappy compression");

 SNAPPY_FLAG(bool, write_compressed, false,
             "Write compressed versions of each file to <file>.comp");
 SNAPPY_FLAG(bool, write_uncompressed, false,
             "Write uncompressed versions of each file to <file>.uncomp");

 namespace snappy {

 namespace {

 #if defined(HAVE_FUNC_MMAP) && defined(HAVE_FUNC_SYSCONF)

 // To test against code that reads beyond its input, this class copies a
 // string to a newly allocated group of pages, the last of which
 // is made unreadable via mprotect. Note that we need to allocate the
 // memory with mmap(), as POSIX allows mprotect() only on memory allocated
 // with mmap(), and some malloc/posix_memalign implementations expect to
 // be able to read previously allocated memory while doing heap allocations.
 class DataEndingAtUnreadablePage {
  public:
   explicit DataEndingAtUnreadablePage(const std::string& s) {
     const size_t page_size = sysconf(_SC_PAGESIZE);
     const size_t size = s.size();
     // Round up space for string to a multiple of page_size.
     size_t space_for_string = (size + page_size - 1) & ~(page_size - 1);
     alloc_size_ = space_for_string + page_size;
     mem_ = mmap(NULL, alloc_size_,
                 PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
     CHECK_NE(MAP_FAILED, mem_);
     protected_page_ = reinterpret_cast<char*>(mem_) + space_for_string;
     char* dst = protected_page_ - size;
     std::memcpy(dst, s.data(), size);
     data_ = dst;
     size_ = size;
     // Make guard page unreadable.
     CHECK_EQ(0, mprotect(protected_page_, page_size, PROT_NONE));
   }

   ~DataEndingAtUnreadablePage() {
     const size_t page_size = sysconf(_SC_PAGESIZE);
     // Undo the mprotect.
     CHECK_EQ(0, mprotect(protected_page_, page_size, PROT_READ|PROT_WRITE));
     CHECK_EQ(0, munmap(mem_, alloc_size_));
   }

   const char* data() const { return data_; }
   size_t size() const { return size_; }

  private:
   size_t alloc_size_;
   void* mem_;
   char* protected_page_;
   const char* data_;
   size_t size_;
 };

 #else  // defined(HAVE_FUNC_MMAP) && defined(HAVE_FUNC_SYSCONF)

 // Fallback for systems without mmap.
 using DataEndingAtUnreadablePage = std::string;

 #endif

 enum CompressorType { ZLIB, LZO, LZ4, SNAPPY };

 const char* names[] = {"ZLIB", "LZO", "LZ4", "SNAPPY"};

 size_t MinimumRequiredOutputSpace(size_t input_size, CompressorType comp) {
   switch (comp) {
 #ifdef ZLIB_VERSION
     case ZLIB:
       return ZLib::MinCompressbufSize(input_size);
 #endif  // ZLIB_VERSION

 #ifdef LZO_VERSION
     case LZO:
       return input_size + input_size/64 + 16 + 3;
 #endif  // LZO_VERSION

 #ifdef LZ4_VERSION_NUMBER
     case LZ4:
       return LZ4_compressBound(input_size);
 #endif  // LZ4_VERSION_NUMBER

     case SNAPPY:
       return snappy::MaxCompressedLength(input_size);

     default:
       LOG(FATAL) << "Unknown compression type number " << comp;
       return 0;
   }
 }

 // Returns true if we successfully compressed, false otherwise.
 //
 // If compressed_is_preallocated is set, do not resize the compressed buffer.
 // This is typically what you want for a benchmark, in order to not spend
 // time in the memory allocator. If you do set this flag, however,
 // "compressed" must be preinitialized to at least MinCompressbufSize(comp)
 // number of bytes, and may contain junk bytes at the end after return.
 bool Compress(const char* input, size_t input_size, CompressorType comp,
               std::string* compressed, bool compressed_is_preallocated) {
   if (!compressed_is_preallocated) {
     compressed->resize(MinimumRequiredOutputSpace(input_size, comp));
   }

   switch (comp) {
 #ifdef ZLIB_VERSION
     case ZLIB: {
       ZLib zlib;
       uLongf destlen = compressed->size();
       int ret = zlib.Compress(
           reinterpret_cast<Bytef*>(string_as_array(compressed)),
           &destlen,
           reinterpret_cast<const Bytef*>(input),
           input_size);
       CHECK_EQ(Z_OK, ret);
       if (!compressed_is_preallocated) {
         compressed->resize(destlen);
       }
       return true;
     }
 #endif  // ZLIB_VERSION

 #ifdef LZO_VERSION
     case LZO: {
       unsigned char* mem = new unsigned char[LZO1X_1_15_MEM_COMPRESS];
       lzo_uint destlen;
       int ret = lzo1x_1_15_compress(
           reinterpret_cast<const uint8_t*>(input),
           input_size,
           reinterpret_cast<uint8_t*>(string_as_array(compressed)),
           &destlen,
           mem);
       CHECK_EQ(LZO_E_OK, ret);
       delete[] mem;
       if (!compressed_is_preallocated) {
         compressed->resize(destlen);
       }
       break;
     }
 #endif  // LZO_VERSION

 #ifdef LZ4_VERSION_NUMBER
     case LZ4: {
       int destlen = compressed->size();
       destlen = LZ4_compress_default(input, string_as_array(compressed),
                                      input_size, destlen);
       CHECK(destlen != 0);
       if (!compressed_is_preallocated) {
         compressed->resize(destlen);
       }
       break;
     }
 #endif  // LZ4_VERSION_NUMBER

     case SNAPPY: {
       size_t destlen;
       snappy::RawCompress(input, input_size,
                           string_as_array(compressed),
                           &destlen);
       CHECK_LE(destlen, snappy::MaxCompressedLength(input_size));
       if (!compressed_is_preallocated) {
         compressed->resize(destlen);
       }
       break;
     }

     default: {
       return false;     // the asked-for library wasn't compiled in
     }
   }
   return true;
 }

 bool Uncompress(const std::string& compressed, CompressorType comp, int size,
                 std::string* output) {
   switch (comp) {
 #ifdef ZLIB_VERSION
     case ZLIB: {
       output->resize(size);
       ZLib zlib;
       uLongf destlen = output->size();
       int ret = zlib.Uncompress(
           reinterpret_cast<Bytef*>(string_as_array(output)),
           &destlen,
           reinterpret_cast<const Bytef*>(compressed.data()),
           compressed.size());
       CHECK_EQ(Z_OK, ret);
       CHECK_EQ(static_cast<uLongf>(size), destlen);
       break;
     }
 #endif  // ZLIB_VERSION

 #ifdef LZO_VERSION
     case LZO: {
       output->resize(size);
       lzo_uint destlen;
       int ret = lzo1x_decompress(
           reinterpret_cast<const uint8_t*>(compressed.data()),
           compressed.size(),
           reinterpret_cast<uint8_t*>(string_as_array(output)),
           &destlen,
           NULL);
       CHECK_EQ(LZO_E_OK, ret);
       CHECK_EQ(static_cast<lzo_uint>(size), destlen);
       break;
     }
 #endif  // LZO_VERSION

 #ifdef LZ4_VERSION_NUMBER
     case LZ4: {
       output->resize(size);
       int destlen = output->size();
       destlen = LZ4_decompress_safe(compressed.data(), string_as_array(output),
                                     compressed.size(), destlen);
       CHECK(destlen != 0);
       CHECK_EQ(size, destlen);
       break;
     }
 #endif  // LZ4_VERSION_NUMBER
     case SNAPPY: {
       snappy::RawUncompress(compressed.data(), compressed.size(),
                             string_as_array(output));
       break;
     }

     default: {
       return false;     // the asked-for library wasn't compiled in
     }
   }
   return true;
 }

 void Measure(const char* data, size_t length, CompressorType comp, int repeats,
              int block_size) {
   // Run tests a few time and pick median running times
   static const int kRuns = 5;
   double ctime[kRuns];
   double utime[kRuns];
   int compressed_size = 0;

   {
     // Chop the input into blocks
     int num_blocks = (length + block_size - 1) / block_size;
     std::vector<const char*> input(num_blocks);
     std::vector<size_t> input_length(num_blocks);
     std::vector<std::string> compressed(num_blocks);
     std::vector<std::string> output(num_blocks);
     for (int b = 0; b < num_blocks; ++b) {
       int input_start = b * block_size;
       int input_limit = std::min<int>((b+1)*block_size, length);
       input[b] = data+input_start;
       input_length[b] = input_limit-input_start;
     }

     // Pre-grow the output buffers so we don't measure string append time.
     for (std::string& compressed_block : compressed) {
       compressed_block.resize(MinimumRequiredOutputSpace(block_size, comp));
     }

     // First, try one trial compression to make sure the code is compiled in
     if (!Compress(input[0], input_length[0], comp, &compressed[0], true)) {
       LOG(WARNING) << "Skipping " << names[comp] << ": "
                    << "library not compiled in";
       return;
     }

     for (int run = 0; run < kRuns; ++run) {
       CycleTimer ctimer, utimer;

       // Pre-grow the output buffers so we don't measure string append time.
       for (std::string& compressed_block : compressed) {
         compressed_block.resize(MinimumRequiredOutputSpace(block_size, comp));
       }

       ctimer.Start();
       for (int b = 0; b < num_blocks; ++b) {
         for (int i = 0; i < repeats; ++i)
           Compress(input[b], input_length[b], comp, &compressed[b], true);
       }
       ctimer.Stop();

       // Compress once more, with resizing, so we don't leave junk
       // at the end that will confuse the decompressor.
       for (int b = 0; b < num_blocks; ++b) {
         Compress(input[b], input_length[b], comp, &compressed[b], false);
       }

       for (int b = 0; b < num_blocks; ++b) {
         output[b].resize(input_length[b]);
       }

       utimer.Start();
       for (int i = 0; i < repeats; ++i) {
         for (int b = 0; b < num_blocks; ++b)
           Uncompress(compressed[b], comp, input_length[b], &output[b]);
       }
       utimer.Stop();

       ctime[run] = ctimer.Get();
       utime[run] = utimer.Get();
     }

     compressed_size = 0;
     for (const std::string& compressed_item : compressed) {
       compressed_size += compressed_item.size();
     }
   }

   std::sort(ctime, ctime + kRuns);
   std::sort(utime, utime + kRuns);
   const int med = kRuns/2;

   float comp_rate = (length / ctime[med]) * repeats / 1048576.0;
   float uncomp_rate = (length / utime[med]) * repeats / 1048576.0;
   std::string x = names[comp];
   x += ":";
   std::string urate = (uncomp_rate >= 0) ? StrFormat("%.1f", uncomp_rate)
                                          : std::string("?");
   std::printf("%-7s [b %dM] bytes %6d -> %6d %4.1f%%  "
               "comp %5.1f MB/s  uncomp %5s MB/s\n",
               x.c_str(),
               block_size/(1<<20),
               static_cast<int>(length), static_cast<uint32_t>(compressed_size),
               (compressed_size * 100.0) / std::max<int>(1, length),
               comp_rate,
               urate.c_str());
 }

 void CompressFile(const char* fname) {
   std::string fullinput;
   CHECK_OK(file::GetContents(fname, &fullinput, file::Defaults()));

   std::string compressed;
   Compress(fullinput.data(), fullinput.size(), SNAPPY, &compressed, false);

   CHECK_OK(file::SetContents(std::string(fname).append(".comp"), compressed,
                              file::Defaults()));
 }

 void UncompressFile(const char* fname) {
   std::string fullinput;
   CHECK_OK(file::GetContents(fname, &fullinput, file::Defaults()));

   size_t uncompLength;
   CHECK(snappy::GetUncompressedLength(fullinput.data(), fullinput.size(),
                                       &uncompLength));

   std::string uncompressed;
   uncompressed.resize(uncompLength);
   CHECK(snappy::Uncompress(fullinput.data(), fullinput.size(), &uncompressed));

   CHECK_OK(file::SetContents(std::string(fname).append(".uncomp"), uncompressed,
                              file::Defaults()));
 }

 void MeasureFile(const char* fname) {
   std::string fullinput;
   CHECK_OK(file::GetContents(fname, &fullinput, file::Defaults()));
   std::printf("%-40s :\n", fname);

   int start_len = (snappy::GetFlag(FLAGS_start_len) < 0)
                       ? fullinput.size()
                       : snappy::GetFlag(FLAGS_start_len);
   int end_len = fullinput.size();
   if (snappy::GetFlag(FLAGS_end_len) >= 0) {
     end_len = std::min<int>(fullinput.size(), snappy::GetFlag(FLAGS_end_len));
   }
   for (int len = start_len; len <= end_len; ++len) {
     const char* const input = fullinput.data();
     int repeats = (snappy::GetFlag(FLAGS_bytes) + len) / (len + 1);
     if (snappy::GetFlag(FLAGS_zlib))
       Measure(input, len, ZLIB, repeats, 1024 << 10);
     if (snappy::GetFlag(FLAGS_lzo))
       Measure(input, len, LZO, repeats, 1024 << 10);
     if (snappy::GetFlag(FLAGS_lz4))
       Measure(input, len, LZ4, repeats, 1024 << 10);
     if (snappy::GetFlag(FLAGS_snappy))
       Measure(input, len, SNAPPY, repeats, 4096 << 10);

     // For block-size based measurements
     if (0 && snappy::GetFlag(FLAGS_snappy)) {
       Measure(input, len, SNAPPY, repeats, 8<<10);
       Measure(input, len, SNAPPY, repeats, 16<<10);
       Measure(input, len, SNAPPY, repeats, 32<<10);
       Measure(input, len, SNAPPY, repeats, 64<<10);
       Measure(input, len, SNAPPY, repeats, 256<<10);
       Measure(input, len, SNAPPY, repeats, 1024<<10);
     }
   }
 }

 }  // namespace

 }  // namespace snappy

 int main(int argc, char** argv) {
   InitGoogle(argv[0], &argc, &argv, true);

   for (int arg = 1; arg < argc; ++arg) {
     if (snappy::GetFlag(FLAGS_write_compressed)) {
       snappy::CompressFile(argv[arg]);
     } else if (snappy::GetFlag(FLAGS_write_uncompressed)) {
       snappy::UncompressFile(argv[arg]);
     } else {
       snappy::MeasureFile(argv[arg]);
     }
   }
   return 0;
 }
	// 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 <algorithm>
	#include <cmath>
	#include <cstdint>
	#include <cstdlib>
	#include <random>
	#include <string>
	#include <utility>
	#include <vector>

	#include "snappy-test.h"

	#include "snappy-internal.h"
	#include "snappy-sinksource.h"
	#include "snappy.h"
	#include "snappy_test_data.h"

	SNAPPY_FLAG(int32_t, start_len, -1,
	"Starting prefix size for testing (-1: just full file contents)");
	SNAPPY_FLAG(int32_t, end_len, -1,
	"Starting prefix size for testing (-1: just full file contents)");
	SNAPPY_FLAG(int32_t, bytes, 10485760,
	"How many bytes to compress/uncompress per file for timing");

	SNAPPY_FLAG(bool, zlib, true,
	"Run zlib compression (http://www.zlib.net)");
	SNAPPY_FLAG(bool, lzo, true,
	"Run LZO compression (http://www.oberhumer.com/opensource/lzo/)");
	SNAPPY_FLAG(bool, lz4, true,
	"Run LZ4 compression (https://github.com/lz4/lz4)");
	SNAPPY_FLAG(bool, snappy, true, "Run snappy compression");

	SNAPPY_FLAG(bool, write_compressed, false,
	"Write compressed versions of each file to <file>.comp");
	SNAPPY_FLAG(bool, write_uncompressed, false,
	"Write uncompressed versions of each file to <file>.uncomp");

	namespace snappy {

	namespace {

	#if defined(HAVE_FUNC_MMAP) && defined(HAVE_FUNC_SYSCONF)

	// To test against code that reads beyond its input, this class copies a
	// string to a newly allocated group of pages, the last of which
	// is made unreadable via mprotect. Note that we need to allocate the
	// memory with mmap(), as POSIX allows mprotect() only on memory allocated
	// with mmap(), and some malloc/posix_memalign implementations expect to
	// be able to read previously allocated memory while doing heap allocations.
	class DataEndingAtUnreadablePage {
	public:
	explicit DataEndingAtUnreadablePage(const std::string& s) {
	const size_t page_size = sysconf(_SC_PAGESIZE);
	const size_t size = s.size();
	// Round up space for string to a multiple of page_size.
	size_t space_for_string = (size + page_size - 1) & ~(page_size - 1);
	alloc_size_ = space_for_string + page_size;
	mem_ = mmap(NULL, alloc_size_,
	PROT_READ\|PROT_WRITE, MAP_PRIVATE\|MAP_ANONYMOUS, -1, 0);
	CHECK_NE(MAP_FAILED, mem_);
	protected_page_ = reinterpret_cast<char*>(mem_) + space_for_string;
	char* dst = protected_page_ - size;
	std::memcpy(dst, s.data(), size);
	data_ = dst;
	size_ = size;
	// Make guard page unreadable.
	CHECK_EQ(0, mprotect(protected_page_, page_size, PROT_NONE));
	}

	~DataEndingAtUnreadablePage() {
	const size_t page_size = sysconf(_SC_PAGESIZE);
	// Undo the mprotect.
	CHECK_EQ(0, mprotect(protected_page_, page_size, PROT_READ\|PROT_WRITE));
	CHECK_EQ(0, munmap(mem_, alloc_size_));
	}

	const char* data() const { return data_; }
	size_t size() const { return size_; }

	private:
	size_t alloc_size_;
	void* mem_;
	char* protected_page_;
	const char* data_;
	size_t size_;
	};

	#else // defined(HAVE_FUNC_MMAP) && defined(HAVE_FUNC_SYSCONF)

	// Fallback for systems without mmap.
	using DataEndingAtUnreadablePage = std::string;

	#endif

	enum CompressorType { ZLIB, LZO, LZ4, SNAPPY };

	const char* names[] = {"ZLIB", "LZO", "LZ4", "SNAPPY"};

	size_t MinimumRequiredOutputSpace(size_t input_size, CompressorType comp) {
	switch (comp) {
	#ifdef ZLIB_VERSION
	case ZLIB:
	return ZLib::MinCompressbufSize(input_size);
	#endif // ZLIB_VERSION

	#ifdef LZO_VERSION
	case LZO:
	return input_size + input_size/64 + 16 + 3;
	#endif // LZO_VERSION

	#ifdef LZ4_VERSION_NUMBER
	case LZ4:
	return LZ4_compressBound(input_size);
	#endif // LZ4_VERSION_NUMBER

	case SNAPPY:
	return snappy::MaxCompressedLength(input_size);

	default:
	LOG(FATAL) << "Unknown compression type number " << comp;
	return 0;
	}
	}

	// Returns true if we successfully compressed, false otherwise.
	//
	// If compressed_is_preallocated is set, do not resize the compressed buffer.
	// This is typically what you want for a benchmark, in order to not spend
	// time in the memory allocator. If you do set this flag, however,
	// "compressed" must be preinitialized to at least MinCompressbufSize(comp)
	// number of bytes, and may contain junk bytes at the end after return.
	bool Compress(const char* input, size_t input_size, CompressorType comp,
	std::string* compressed, bool compressed_is_preallocated) {
	if (!compressed_is_preallocated) {
	compressed->resize(MinimumRequiredOutputSpace(input_size, comp));
	}

	switch (comp) {
	#ifdef ZLIB_VERSION
	case ZLIB: {
	ZLib zlib;
	uLongf destlen = compressed->size();
	int ret = zlib.Compress(
	reinterpret_cast<Bytef*>(string_as_array(compressed)),
	&destlen,
	reinterpret_cast<const Bytef*>(input),
	input_size);
	CHECK_EQ(Z_OK, ret);
	if (!compressed_is_preallocated) {
	compressed->resize(destlen);
	}
	return true;
	}
	#endif // ZLIB_VERSION

	#ifdef LZO_VERSION
	case LZO: {
	unsigned char* mem = new unsigned char[LZO1X_1_15_MEM_COMPRESS];
	lzo_uint destlen;
	int ret = lzo1x_1_15_compress(
	reinterpret_cast<const uint8_t*>(input),
	input_size,
	reinterpret_cast<uint8_t*>(string_as_array(compressed)),
	&destlen,
	mem);
	CHECK_EQ(LZO_E_OK, ret);
	delete[] mem;
	if (!compressed_is_preallocated) {
	compressed->resize(destlen);
	}
	break;
	}
	#endif // LZO_VERSION

	#ifdef LZ4_VERSION_NUMBER
	case LZ4: {
	int destlen = compressed->size();
	destlen = LZ4_compress_default(input, string_as_array(compressed),
	input_size, destlen);
	CHECK(destlen != 0);
	if (!compressed_is_preallocated) {
	compressed->resize(destlen);
	}
	break;
	}
	#endif // LZ4_VERSION_NUMBER

	case SNAPPY: {
	size_t destlen;
	snappy::RawCompress(input, input_size,
	string_as_array(compressed),
	&destlen);
	CHECK_LE(destlen, snappy::MaxCompressedLength(input_size));
	if (!compressed_is_preallocated) {
	compressed->resize(destlen);
	}
	break;
	}

	default: {
	return false; // the asked-for library wasn't compiled in
	}
	}
	return true;
	}

	bool Uncompress(const std::string& compressed, CompressorType comp, int size,
	std::string* output) {
	switch (comp) {
	#ifdef ZLIB_VERSION
	case ZLIB: {
	output->resize(size);
	ZLib zlib;
	uLongf destlen = output->size();
	int ret = zlib.Uncompress(
	reinterpret_cast<Bytef*>(string_as_array(output)),
	&destlen,
	reinterpret_cast<const Bytef*>(compressed.data()),
	compressed.size());
	CHECK_EQ(Z_OK, ret);
	CHECK_EQ(static_cast<uLongf>(size), destlen);
	break;
	}
	#endif // ZLIB_VERSION

	#ifdef LZO_VERSION
	case LZO: {
	output->resize(size);
	lzo_uint destlen;
	int ret = lzo1x_decompress(
	reinterpret_cast<const uint8_t*>(compressed.data()),
	compressed.size(),
	reinterpret_cast<uint8_t*>(string_as_array(output)),
	&destlen,
	NULL);
	CHECK_EQ(LZO_E_OK, ret);
	CHECK_EQ(static_cast<lzo_uint>(size), destlen);
	break;
	}
	#endif // LZO_VERSION

	#ifdef LZ4_VERSION_NUMBER
	case LZ4: {
	output->resize(size);
	int destlen = output->size();
	destlen = LZ4_decompress_safe(compressed.data(), string_as_array(output),
	compressed.size(), destlen);
	CHECK(destlen != 0);
	CHECK_EQ(size, destlen);
	break;
	}
	#endif // LZ4_VERSION_NUMBER
	case SNAPPY: {
	snappy::RawUncompress(compressed.data(), compressed.size(),
	string_as_array(output));
	break;
	}

	default: {
	return false; // the asked-for library wasn't compiled in
	}
	}
	return true;
	}

	void Measure(const char* data, size_t length, CompressorType comp, int repeats,
	int block_size) {
	// Run tests a few time and pick median running times
	static const int kRuns = 5;
	double ctime[kRuns];
	double utime[kRuns];
	int compressed_size = 0;

	{
	// Chop the input into blocks
	int num_blocks = (length + block_size - 1) / block_size;
	std::vector<const char*> input(num_blocks);
	std::vector<size_t> input_length(num_blocks);
	std::vector<std::string> compressed(num_blocks);
	std::vector<std::string> output(num_blocks);
	for (int b = 0; b < num_blocks; ++b) {
	int input_start = b * block_size;
	int input_limit = std::min<int>((b+1)*block_size, length);
	input[b] = data+input_start;
	input_length[b] = input_limit-input_start;
	}

	// Pre-grow the output buffers so we don't measure string append time.
	for (std::string& compressed_block : compressed) {
	compressed_block.resize(MinimumRequiredOutputSpace(block_size, comp));
	}

	// First, try one trial compression to make sure the code is compiled in
	if (!Compress(input[0], input_length[0], comp, &compressed[0], true)) {
	LOG(WARNING) << "Skipping " << names[comp] << ": "
	<< "library not compiled in";
	return;
	}

	for (int run = 0; run < kRuns; ++run) {
	CycleTimer ctimer, utimer;

	// Pre-grow the output buffers so we don't measure string append time.
	for (std::string& compressed_block : compressed) {
	compressed_block.resize(MinimumRequiredOutputSpace(block_size, comp));
	}

	ctimer.Start();
	for (int b = 0; b < num_blocks; ++b) {
	for (int i = 0; i < repeats; ++i)
	Compress(input[b], input_length[b], comp, &compressed[b], true);
	}
	ctimer.Stop();

	// Compress once more, with resizing, so we don't leave junk
	// at the end that will confuse the decompressor.
	for (int b = 0; b < num_blocks; ++b) {
	Compress(input[b], input_length[b], comp, &compressed[b], false);
	}

	for (int b = 0; b < num_blocks; ++b) {
	output[b].resize(input_length[b]);
	}

	utimer.Start();
	for (int i = 0; i < repeats; ++i) {
	for (int b = 0; b < num_blocks; ++b)
	Uncompress(compressed[b], comp, input_length[b], &output[b]);
	}
	utimer.Stop();

	ctime[run] = ctimer.Get();
	utime[run] = utimer.Get();
	}

	compressed_size = 0;
	for (const std::string& compressed_item : compressed) {
	compressed_size += compressed_item.size();
	}
	}

	std::sort(ctime, ctime + kRuns);
	std::sort(utime, utime + kRuns);
	const int med = kRuns/2;

	float comp_rate = (length / ctime[med]) * repeats / 1048576.0;
	float uncomp_rate = (length / utime[med]) * repeats / 1048576.0;
	std::string x = names[comp];
	x += ":";
	std::string urate = (uncomp_rate >= 0) ? StrFormat("%.1f", uncomp_rate)
	: std::string("?");
	std::printf("%-7s [b %dM] bytes %6d -> %6d %4.1f%% "
	"comp %5.1f MB/s uncomp %5s MB/s\n",
	x.c_str(),
	block_size/(1<<20),
	static_cast<int>(length), static_cast<uint32_t>(compressed_size),
	(compressed_size * 100.0) / std::max<int>(1, length),
	comp_rate,
	urate.c_str());
	}

	void CompressFile(const char* fname) {
	std::string fullinput;
	CHECK_OK(file::GetContents(fname, &fullinput, file::Defaults()));

	std::string compressed;
	Compress(fullinput.data(), fullinput.size(), SNAPPY, &compressed, false);

	CHECK_OK(file::SetContents(std::string(fname).append(".comp"), compressed,
	file::Defaults()));
	}

	void UncompressFile(const char* fname) {
	std::string fullinput;
	CHECK_OK(file::GetContents(fname, &fullinput, file::Defaults()));

	size_t uncompLength;
	CHECK(snappy::GetUncompressedLength(fullinput.data(), fullinput.size(),
	&uncompLength));

	std::string uncompressed;
	uncompressed.resize(uncompLength);
	CHECK(snappy::Uncompress(fullinput.data(), fullinput.size(), &uncompressed));

	CHECK_OK(file::SetContents(std::string(fname).append(".uncomp"), uncompressed,
	file::Defaults()));
	}

	void MeasureFile(const char* fname) {
	std::string fullinput;
	CHECK_OK(file::GetContents(fname, &fullinput, file::Defaults()));
	std::printf("%-40s :\n", fname);

	int start_len = (snappy::GetFlag(FLAGS_start_len) < 0)
	? fullinput.size()
	: snappy::GetFlag(FLAGS_start_len);
	int end_len = fullinput.size();
	if (snappy::GetFlag(FLAGS_end_len) >= 0) {
	end_len = std::min<int>(fullinput.size(), snappy::GetFlag(FLAGS_end_len));
	}
	for (int len = start_len; len <= end_len; ++len) {
	const char* const input = fullinput.data();
	int repeats = (snappy::GetFlag(FLAGS_bytes) + len) / (len + 1);
	if (snappy::GetFlag(FLAGS_zlib))
	Measure(input, len, ZLIB, repeats, 1024 << 10);
	if (snappy::GetFlag(FLAGS_lzo))
	Measure(input, len, LZO, repeats, 1024 << 10);
	if (snappy::GetFlag(FLAGS_lz4))
	Measure(input, len, LZ4, repeats, 1024 << 10);
	if (snappy::GetFlag(FLAGS_snappy))
	Measure(input, len, SNAPPY, repeats, 4096 << 10);

	// For block-size based measurements
	if (0 && snappy::GetFlag(FLAGS_snappy)) {
	Measure(input, len, SNAPPY, repeats, 8<<10);
	Measure(input, len, SNAPPY, repeats, 16<<10);
	Measure(input, len, SNAPPY, repeats, 32<<10);
	Measure(input, len, SNAPPY, repeats, 64<<10);
	Measure(input, len, SNAPPY, repeats, 256<<10);
	Measure(input, len, SNAPPY, repeats, 1024<<10);
	}
	}
	}

	} // namespace

	} // namespace snappy

	int main(int argc, char** argv) {
	InitGoogle(argv[0], &argc, &argv, true);

	for (int arg = 1; arg < argc; ++arg) {
	if (snappy::GetFlag(FLAGS_write_compressed)) {
	snappy::CompressFile(argv[arg]);
	} else if (snappy::GetFlag(FLAGS_write_uncompressed)) {
	snappy::UncompressFile(argv[arg]);
	} else {
	snappy::MeasureFile(argv[arg]);
	}
	}
	return 0;
	}