snappy 0.0.17 → 0.4.0

data/vendor/snappy/snappy-stubs-public.h.in

@@ -1,5 +1,4 @@
 // Copyright 2011 Google Inc. All Rights Reserved.
-// Author: sesse@google.com (Steinar H. Gunderson)
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -36,64 +35,28 @@
 #ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
 #define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
 
-#if @ac_cv_have_stdint_h@
-#include <stdint.h>
-#endif
+#include <cstddef>
 
-#if @ac_cv_have_stddef_h@
-#include <stddef.h>
-#endif
-
-#if @ac_cv_have_sys_uio_h@
+#if ${HAVE_SYS_UIO_H_01}  // HAVE_SYS_UIO_H
 #include <sys/uio.h>
-#endif
+#endif  // HAVE_SYS_UIO_H
 
-#define SNAPPY_MAJOR @SNAPPY_MAJOR@
-#define SNAPPY_MINOR @SNAPPY_MINOR@
-#define SNAPPY_PATCHLEVEL @SNAPPY_PATCHLEVEL@
+#define SNAPPY_MAJOR ${PROJECT_VERSION_MAJOR}
+#define SNAPPY_MINOR ${PROJECT_VERSION_MINOR}
+#define SNAPPY_PATCHLEVEL ${PROJECT_VERSION_PATCH}
 #define SNAPPY_VERSION \
     ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL)
 
-#include <string>
-
 namespace snappy {
 
-#if @ac_cv_have_stdint_h@
-typedef int8_t int8;
-typedef uint8_t uint8;
-typedef int16_t int16;
-typedef uint16_t uint16;
-typedef int32_t int32;
-typedef uint32_t uint32;
-typedef int64_t int64;
-typedef uint64_t uint64;
-#else
-typedef signed char int8;
-typedef unsigned char uint8;
-typedef short int16;
-typedef unsigned short uint16;
-typedef int int32;
-typedef unsigned int uint32;
-typedef long long int64;
-typedef unsigned long long uint64;
-#endif
-
-typedef std::string string;
-
-#ifndef DISALLOW_COPY_AND_ASSIGN
-#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
-  TypeName(const TypeName&);               \
-  void operator=(const TypeName&)
-#endif
-
-#if !@ac_cv_have_sys_uio_h@
+#if !${HAVE_SYS_UIO_H_01}  // !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 {
-	void* iov_base;
-	size_t iov_len;
+  void* iov_base;
+  size_t iov_len;
 };
-#endif
+#endif  // !HAVE_SYS_UIO_H
 
 }  // namespace snappy
 

data/vendor/snappy/snappy-test.cc

@@ -28,236 +28,130 @@
 //
 // Various stubs for the unit tests for the open-source version of Snappy.
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef HAVE_WINDOWS_H
-#include <windows.h>
-#endif
-
 #include "snappy-test.h"
 
 #include <algorithm>
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <string>
 
-DEFINE_bool(run_microbenchmarks, true,
-            "Run microbenchmarks before doing anything else.");
+namespace file {
 
-namespace snappy {
+OptionsStub::OptionsStub() = default;
+OptionsStub::~OptionsStub() = default;
 
-string ReadTestDataFile(const string& base, size_t size_limit) {
-  string contents;
-  const char* srcdir = getenv("srcdir");  // This is set by Automake.
-  string prefix;
-  if (srcdir) {
-    prefix = string(srcdir) + "/";
-  }
-  file::GetContents(prefix + "testdata/" + base, &contents, file::Defaults()
-      ).CheckSuccess();
-  if (size_limit > 0) {
-    contents = contents.substr(0, size_limit);
-  }
-  return contents;
-}
-
-string ReadTestDataFile(const string& base) {
-  return ReadTestDataFile(base, 0);
+const OptionsStub &Defaults() {
+  static OptionsStub defaults;
+  return defaults;
 }
 
-string StringPrintf(const char* format, ...) {
-  char buf[4096];
-  va_list ap;
-  va_start(ap, format);
-  vsnprintf(buf, sizeof(buf), format, ap);
-  va_end(ap);
-  return buf;
-}
+StatusStub::StatusStub() = default;
+StatusStub::StatusStub(const StatusStub &) = default;
+StatusStub &StatusStub::operator=(const StatusStub &) = default;
+StatusStub::~StatusStub() = default;
 
-bool benchmark_running = false;
-int64 benchmark_real_time_us = 0;
-int64 benchmark_cpu_time_us = 0;
-string *benchmark_label = NULL;
-int64 benchmark_bytes_processed = 0;
+bool StatusStub::ok() { return true; }
 
-void ResetBenchmarkTiming() {
-  benchmark_real_time_us = 0;
-  benchmark_cpu_time_us = 0;
-}
+StatusStub GetContents(const std::string &filename, std::string *output,
+                       const OptionsStub & /* options */) {
+  std::FILE *fp = std::fopen(filename.c_str(), "rb");
+  if (fp == nullptr) {
+    std::perror(filename.c_str());
+    std::exit(1);
+  }
 
-#ifdef WIN32
-LARGE_INTEGER benchmark_start_real;
-FILETIME benchmark_start_cpu;
-#else  // WIN32
-struct timeval benchmark_start_real;
-struct rusage benchmark_start_cpu;
-#endif  // WIN32
-
-void StartBenchmarkTiming() {
-#ifdef WIN32
-  QueryPerformanceCounter(&benchmark_start_real);
-  FILETIME dummy;
-  CHECK(GetProcessTimes(
-      GetCurrentProcess(), &dummy, &dummy, &dummy, &benchmark_start_cpu));
-#else
-  gettimeofday(&benchmark_start_real, NULL);
-  if (getrusage(RUSAGE_SELF, &benchmark_start_cpu) == -1) {
-    perror("getrusage(RUSAGE_SELF)");
-    exit(1);
+  output->clear();
+  while (!std::feof(fp)) {
+    char buffer[4096];
+    size_t bytes_read = std::fread(buffer, 1, sizeof(buffer), fp);
+    if (bytes_read == 0 && std::ferror(fp)) {
+      std::perror("fread");
+      std::exit(1);
+    }
+    output->append(buffer, bytes_read);
   }
-#endif
-  benchmark_running = true;
+
+  std::fclose(fp);
+  return StatusStub();
 }
 
-void StopBenchmarkTiming() {
-  if (!benchmark_running) {
-    return;
+StatusStub SetContents(const std::string &file_name, const std::string &content,
+                       const OptionsStub & /* options */) {
+  std::FILE *fp = std::fopen(file_name.c_str(), "wb");
+  if (fp == nullptr) {
+    std::perror(file_name.c_str());
+    std::exit(1);
   }
 
-#ifdef WIN32
-  LARGE_INTEGER benchmark_stop_real;
-  LARGE_INTEGER benchmark_frequency;
-  QueryPerformanceCounter(&benchmark_stop_real);
-  QueryPerformanceFrequency(&benchmark_frequency);
-
-  double elapsed_real = static_cast<double>(
-      benchmark_stop_real.QuadPart - benchmark_start_real.QuadPart) /
-      benchmark_frequency.QuadPart;
-  benchmark_real_time_us += elapsed_real * 1e6 + 0.5;
-
-  FILETIME benchmark_stop_cpu, dummy;
-  CHECK(GetProcessTimes(
-      GetCurrentProcess(), &dummy, &dummy, &dummy, &benchmark_stop_cpu));
-
-  ULARGE_INTEGER start_ulargeint;
-  start_ulargeint.LowPart = benchmark_start_cpu.dwLowDateTime;
-  start_ulargeint.HighPart = benchmark_start_cpu.dwHighDateTime;
-
-  ULARGE_INTEGER stop_ulargeint;
-  stop_ulargeint.LowPart = benchmark_stop_cpu.dwLowDateTime;
-  stop_ulargeint.HighPart = benchmark_stop_cpu.dwHighDateTime;
-
-  benchmark_cpu_time_us +=
-      (stop_ulargeint.QuadPart - start_ulargeint.QuadPart + 5) / 10;
-#else  // WIN32
-  struct timeval benchmark_stop_real;
-  gettimeofday(&benchmark_stop_real, NULL);
-  benchmark_real_time_us +=
-      1000000 * (benchmark_stop_real.tv_sec - benchmark_start_real.tv_sec);
-  benchmark_real_time_us +=
-      (benchmark_stop_real.tv_usec - benchmark_start_real.tv_usec);
-
-  struct rusage benchmark_stop_cpu;
-  if (getrusage(RUSAGE_SELF, &benchmark_stop_cpu) == -1) {
-    perror("getrusage(RUSAGE_SELF)");
-    exit(1);
+  size_t bytes_written = std::fwrite(content.data(), 1, content.size(), fp);
+  if (bytes_written != content.size()) {
+    std::perror("fwrite");
+    std::exit(1);
   }
-  benchmark_cpu_time_us += 1000000 * (benchmark_stop_cpu.ru_utime.tv_sec -
-                                      benchmark_start_cpu.ru_utime.tv_sec);
-  benchmark_cpu_time_us += (benchmark_stop_cpu.ru_utime.tv_usec -
-                            benchmark_start_cpu.ru_utime.tv_usec);
-#endif  // WIN32
 
-  benchmark_running = false;
+  std::fclose(fp);
+  return StatusStub();
 }
 
-void SetBenchmarkLabel(const string& str) {
-  if (benchmark_label) {
-    delete benchmark_label;
+}  // namespace file
+
+namespace snappy {
+
+std::string ReadTestDataFile(const std::string& base, size_t size_limit) {
+  std::string contents;
+  const char* srcdir = getenv("srcdir");  // This is set by Automake.
+  std::string prefix;
+  if (srcdir) {
+    prefix = std::string(srcdir) + "/";
   }
-  benchmark_label = new string(str);
+  file::GetContents(prefix + "testdata/" + base, &contents, file::Defaults()
+      ).ok();
+  if (size_limit > 0) {
+    contents = contents.substr(0, size_limit);
+  }
+  return contents;
 }
 
-void SetBenchmarkBytesProcessed(int64 bytes) {
-  benchmark_bytes_processed = bytes;
+std::string StrFormat(const char* format, ...) {
+  char buffer[4096];
+  std::va_list ap;
+  va_start(ap, format);
+  std::vsnprintf(buffer, sizeof(buffer), format, ap);
+  va_end(ap);
+  return buffer;
 }
 
-struct BenchmarkRun {
-  int64 real_time_us;
-  int64 cpu_time_us;
-};
+LogMessage::~LogMessage() { std::cerr << std::endl; }
 
-struct BenchmarkCompareCPUTime {
-  bool operator() (const BenchmarkRun& a, const BenchmarkRun& b) const {
-    return a.cpu_time_us < b.cpu_time_us;
-  }
-};
-
-void Benchmark::Run() {
-  for (int test_case_num = start_; test_case_num <= stop_; ++test_case_num) {
-    // Run a few iterations first to find out approximately how fast
-    // the benchmark is.
-    const int kCalibrateIterations = 100;
-    ResetBenchmarkTiming();
-    StartBenchmarkTiming();
-    (*function_)(kCalibrateIterations, test_case_num);
-    StopBenchmarkTiming();
-
-    // Let each test case run for about 200ms, but at least as many
-    // as we used to calibrate.
-    // Run five times and pick the median.
-    const int kNumRuns = 5;
-    const int kMedianPos = kNumRuns / 2;
-    int num_iterations = 0;
-    if (benchmark_real_time_us > 0) {
-      num_iterations = 200000 * kCalibrateIterations / benchmark_real_time_us;
-    }
-    num_iterations = max(num_iterations, kCalibrateIterations);
-    BenchmarkRun benchmark_runs[kNumRuns];
+LogMessage &LogMessage::operator<<(const std::string &message) {
+  std::cerr << message;
+  return *this;
+}
 
-    for (int run = 0; run < kNumRuns; ++run) {
-      ResetBenchmarkTiming();
-      StartBenchmarkTiming();
-      (*function_)(num_iterations, test_case_num);
-      StopBenchmarkTiming();
+LogMessage &LogMessage::operator<<(int number) {
+  std::cerr << number;
+  return *this;
+}
 
-      benchmark_runs[run].real_time_us = benchmark_real_time_us;
-      benchmark_runs[run].cpu_time_us = benchmark_cpu_time_us;
-    }
+#ifdef _MSC_VER
+// ~LogMessageCrash calls std::abort() and therefore never exits. This is by
+// design, so temporarily disable warning C4722.
+#pragma warning(push)
+#pragma warning(disable : 4722)
+#endif
 
-    string heading = StringPrintf("%s/%d", name_.c_str(), test_case_num);
-    string human_readable_speed;
-
-    nth_element(benchmark_runs,
-                benchmark_runs + kMedianPos,
-                benchmark_runs + kNumRuns,
-                BenchmarkCompareCPUTime());
-    int64 real_time_us = benchmark_runs[kMedianPos].real_time_us;
-    int64 cpu_time_us = benchmark_runs[kMedianPos].cpu_time_us;
-    if (cpu_time_us <= 0) {
-      human_readable_speed = "?";
-    } else {
-      int64 bytes_per_second =
-          benchmark_bytes_processed * 1000000 / cpu_time_us;
-      if (bytes_per_second < 1024) {
-        human_readable_speed = StringPrintf("%dB/s", bytes_per_second);
-      } else if (bytes_per_second < 1024 * 1024) {
-        human_readable_speed = StringPrintf(
-            "%.1fkB/s", bytes_per_second / 1024.0f);
-      } else if (bytes_per_second < 1024 * 1024 * 1024) {
-        human_readable_speed = StringPrintf(
-            "%.1fMB/s", bytes_per_second / (1024.0f * 1024.0f));
-      } else {
-        human_readable_speed = StringPrintf(
-            "%.1fGB/s", bytes_per_second / (1024.0f * 1024.0f * 1024.0f));
-      }
-    }
+LogMessageCrash::~LogMessageCrash() {
+  std::cerr << std::endl;
+  std::abort();
+}
 
-    fprintf(stderr,
-#ifdef WIN32
-            "%-18s %10I64d %10I64d %10d %s  %s\n",
-#else
-            "%-18s %10lld %10lld %10d %s  %s\n",
+#ifdef _MSC_VER
+#pragma warning(pop)
 #endif
-            heading.c_str(),
-            static_cast<long long>(real_time_us * 1000 / num_iterations),
-            static_cast<long long>(cpu_time_us * 1000 / num_iterations),
-            num_iterations,
-            human_readable_speed.c_str(),
-            benchmark_label->c_str());
-  }
-}
 
-#ifdef HAVE_LIBZ
+#if HAVE_LIBZ
 
 ZLib::ZLib()
     : comp_init_(false),
@@ -523,8 +417,8 @@ int ZLib::UncompressAtMostOrAll(Bytef *dest, uLongf *destLen,
     LOG(WARNING)
       << "UncompressChunkOrAll: Received some extra data, bytes total: "
       << uncomp_stream_.avail_in << " bytes: "
-      << string(reinterpret_cast<const char *>(uncomp_stream_.next_in),
-                min(int(uncomp_stream_.avail_in), 20));
+      << std::string(reinterpret_cast<const char *>(uncomp_stream_.next_in),
+                     std::min(int(uncomp_stream_.avail_in), 20));
     UncompressErrorInit();
     return Z_DATA_ERROR;       // what's the extra data for?
   } else if (err != Z_OK && err != Z_STREAM_END && err != Z_BUF_ERROR) {