diff --git a/util/benchmark.cc b/util/benchmark.cc
index d3e1b40..8ef6b1e 100644
--- a/util/benchmark.cc
+++ b/util/benchmark.cc
@@ -10,7 +10,6 @@
 
 #include "util/benchmark.h"
 #include "util/flags.h"
-#include "util/util.h"
 #include "re2/re2.h"
 
 DEFINE_string(test_tmpdir, "/var/tmp", "temp directory");
@@ -60,7 +59,7 @@
 
 void SetBenchmarkBytesProcessed(int64_t b) { bytes = b; }
 
-void SetBenchmarkItemsProcessed(int i) { items = i; }
+void SetBenchmarkItemsProcessed(int64_t i) { items = i; }
 
 int NumCPUs() {
   // Pretend to support multi-threaded benchmarking.
@@ -109,7 +108,7 @@
   if (ns > 0 && bytes > 0)
     snprintf(mb, sizeof mb, "\t%7.2f MB/s",
              ((double)bytes / 1e6) / ((double)ns / 1e9));
-  if (b->arg()) {
+  if (b->has_arg()) {
     if (arg >= (1 << 20)) {
       snprintf(suf, sizeof suf, "/%dM", arg / (1 << 20));
     } else if (arg >= (1 << 10)) {
diff --git a/util/benchmark.h b/util/benchmark.h
index 8dd36e5..1e7ad8b 100644
--- a/util/benchmark.h
+++ b/util/benchmark.h
@@ -9,25 +9,140 @@
 #include <functional>
 #include <thread>
 
+#include "util/logging.h"
+#include "util/util.h"
+
+// Globals for the old benchmark API.
+void BenchmarkMemoryUsage();
+void StartBenchmarkTiming();
+void StopBenchmarkTiming();
+void SetBenchmarkBytesProcessed(int64_t b);
+void SetBenchmarkItemsProcessed(int64_t i);
+
+int NumCPUs();
+
+namespace benchmark {
+
+// The new benchmark API implemented as a layer over the old benchmark API.
+// (Please refer to https://github.com/google/benchmark for documentation.)
+class State {
+ private:
+  class Iterator {
+   public:
+    // Benchmark code looks like this:
+    //
+    //   for (auto _ : state) {
+    //     // ...
+    //   }
+    //
+    // We try to avoid compiler warnings about such variables being unused.
+    struct ATTRIBUTE_UNUSED Value {};
+
+    explicit Iterator(int64_t iters) : iters_(iters) {}
+
+    bool operator!=(const Iterator& that) const {
+      if (iters_ != that.iters_) {
+        return true;
+      } else {
+        // We are about to stop the loop, so stop timing.
+        StopBenchmarkTiming();
+        return false;
+      }
+    }
+
+    Value operator*() const {
+      return Value();
+    }
+
+    Iterator& operator++() {
+      --iters_;
+      return *this;
+    }
+
+   private:
+    int64_t iters_;
+  };
+
+ public:
+  explicit State(int64_t iters)
+      : iters_(iters), arg_(0), has_arg_(false) {}
+
+  State(int64_t iters, int64_t arg)
+      : iters_(iters), arg_(arg), has_arg_(true) {}
+
+  Iterator begin() {
+    // We are about to start the loop, so start timing.
+    StartBenchmarkTiming();
+    return Iterator(iters_);
+  }
+
+  Iterator end() {
+    return Iterator(0);
+  }
+
+  void SetBytesProcessed(int64_t b) { SetBenchmarkBytesProcessed(b); }
+  void SetItemsProcessed(int64_t i) { SetBenchmarkItemsProcessed(i); }
+  int64_t iterations() const { return iters_; }
+  int64_t range() const { CHECK(has_arg_); return arg_; }
+
+ private:
+  int64_t iters_;
+  int64_t arg_;
+  bool has_arg_;
+
+  State(const State&) = delete;
+  State& operator=(const State&) = delete;
+};
+
+}  // namespace benchmark
+
 namespace testing {
 
 class Benchmark {
  public:
   Benchmark(const char* name, void (*func)(int))
       : name_(name),
-        func_([func](int iters, int arg) { func(iters); }),
+        func_([func](int iters, int arg) {
+          func(iters);
+        }),
         lo_(0),
         hi_(0),
-        arg_(false) {
+        has_arg_(false) {
     Register();
   }
 
   Benchmark(const char* name, void (*func)(int, int), int lo, int hi)
       : name_(name),
-        func_([func](int iters, int arg) { func(iters, arg); }),
+        func_([func](int iters, int arg) {
+          func(iters, arg);
+        }),
         lo_(lo),
         hi_(hi),
-        arg_(true) {
+        has_arg_(true) {
+    Register();
+  }
+
+  Benchmark(const char* name, void (*func)(benchmark::State&))
+      : name_(name),
+        func_([func](int iters, int arg) {
+          benchmark::State state(iters);
+          func(state);
+        }),
+        lo_(0),
+        hi_(0),
+        has_arg_(false) {
+    Register();
+  }
+
+  Benchmark(const char* name, void (*func)(benchmark::State&), int lo, int hi)
+      : name_(name),
+        func_([func](int iters, int arg) {
+          benchmark::State state(iters, arg);
+          func(state);
+        }),
+        lo_(lo),
+        hi_(hi),
+        has_arg_(true) {
     Register();
   }
 
@@ -40,7 +155,7 @@
   const std::function<void(int, int)>& func() const { return func_; }
   int lo() const { return lo_; }
   int hi() const { return hi_; }
-  bool arg() const { return arg_; }
+  bool has_arg() const { return has_arg_; }
 
  private:
   void Register();
@@ -49,7 +164,7 @@
   std::function<void(int, int)> func_;
   int lo_;
   int hi_;
-  bool arg_;
+  bool has_arg_;
 
   Benchmark(const Benchmark&) = delete;
   Benchmark& operator=(const Benchmark&) = delete;
@@ -57,14 +172,6 @@
 
 }  // namespace testing
 
-void BenchmarkMemoryUsage();
-void StartBenchmarkTiming();
-void StopBenchmarkTiming();
-void SetBenchmarkBytesProcessed(int64_t b);
-void SetBenchmarkItemsProcessed(int i);
-
-int NumCPUs();
-
 #define BENCHMARK(f)                     \
   ::testing::Benchmark* _benchmark_##f = \
       (new ::testing::Benchmark(#f, f))
diff --git a/util/util.h b/util/util.h
index 8f3e0d0..56e46c1 100644
--- a/util/util.h
+++ b/util/util.h
@@ -17,6 +17,14 @@
 #endif
 #endif
 
+#ifndef ATTRIBUTE_UNUSED
+#if defined(__GNUC__)
+#define ATTRIBUTE_UNUSED __attribute__((unused))
+#else
+#define ATTRIBUTE_UNUSED
+#endif
+#endif
+
 #ifndef FALLTHROUGH_INTENDED
 #if defined(__clang__)
 #define FALLTHROUGH_INTENDED [[clang::fallthrough]]