@nxtedition/rocksdb 7.1.30 → 7.1.32

package/deps/rocksdb/rocksdb/memtable/skiplistrep.cc

@@ -21,74 +21,76 @@ class SkipListRep : public MemTableRep {
   const size_t lookahead_;
 
   friend class LookaheadIterator;
-public:
- explicit SkipListRep(const MemTableRep::KeyComparator& compare,
-                      Allocator* allocator, const SliceTransform* transform,
-                      const size_t lookahead)
-     : MemTableRep(allocator),
-       skip_list_(compare, allocator),
-       cmp_(compare),
-       transform_(transform),
-       lookahead_(lookahead) {}
-
- KeyHandle Allocate(const size_t len, char** buf) override {
-   *buf = skip_list_.AllocateKey(len);
-   return static_cast<KeyHandle>(*buf);
- }
+
+ public:
+  explicit SkipListRep(const MemTableRep::KeyComparator& compare,
+                       Allocator* allocator, const SliceTransform* transform,
+                       const size_t lookahead)
+      : MemTableRep(allocator),
+        skip_list_(compare, allocator),
+        cmp_(compare),
+        transform_(transform),
+        lookahead_(lookahead) {}
+
+  KeyHandle Allocate(const size_t len, char** buf) override {
+    *buf = skip_list_.AllocateKey(len);
+    return static_cast<KeyHandle>(*buf);
+  }
 
   // Insert key into the list.
   // REQUIRES: nothing that compares equal to key is currently in the list.
- void Insert(KeyHandle handle) override {
-   skip_list_.Insert(static_cast<char*>(handle));
- }
+  void Insert(KeyHandle handle) override {
+    skip_list_.Insert(static_cast<char*>(handle));
+  }
 
- bool InsertKey(KeyHandle handle) override {
-   return skip_list_.Insert(static_cast<char*>(handle));
- }
+  bool InsertKey(KeyHandle handle) override {
+    return skip_list_.Insert(static_cast<char*>(handle));
+  }
 
- void InsertWithHint(KeyHandle handle, void** hint) override {
-   skip_list_.InsertWithHint(static_cast<char*>(handle), hint);
- }
+  void InsertWithHint(KeyHandle handle, void** hint) override {
+    skip_list_.InsertWithHint(static_cast<char*>(handle), hint);
+  }
 
- bool InsertKeyWithHint(KeyHandle handle, void** hint) override {
-   return skip_list_.InsertWithHint(static_cast<char*>(handle), hint);
- }
+  bool InsertKeyWithHint(KeyHandle handle, void** hint) override {
+    return skip_list_.InsertWithHint(static_cast<char*>(handle), hint);
+  }
 
- void InsertWithHintConcurrently(KeyHandle handle, void** hint) override {
-   skip_list_.InsertWithHintConcurrently(static_cast<char*>(handle), hint);
- }
+  void InsertWithHintConcurrently(KeyHandle handle, void** hint) override {
+    skip_list_.InsertWithHintConcurrently(static_cast<char*>(handle), hint);
+  }
 
- bool InsertKeyWithHintConcurrently(KeyHandle handle, void** hint) override {
-   return skip_list_.InsertWithHintConcurrently(static_cast<char*>(handle),
-                                                hint);
- }
+  bool InsertKeyWithHintConcurrently(KeyHandle handle, void** hint) override {
+    return skip_list_.InsertWithHintConcurrently(static_cast<char*>(handle),
+                                                 hint);
+  }
 
- void InsertConcurrently(KeyHandle handle) override {
-   skip_list_.InsertConcurrently(static_cast<char*>(handle));
- }
+  void InsertConcurrently(KeyHandle handle) override {
+    skip_list_.InsertConcurrently(static_cast<char*>(handle));
+  }
 
- bool InsertKeyConcurrently(KeyHandle handle) override {
-   return skip_list_.InsertConcurrently(static_cast<char*>(handle));
- }
+  bool InsertKeyConcurrently(KeyHandle handle) override {
+    return skip_list_.InsertConcurrently(static_cast<char*>(handle));
+  }
 
   // Returns true iff an entry that compares equal to key is in the list.
- bool Contains(const char* key) const override {
-   return skip_list_.Contains(key);
- }
-
- size_t ApproximateMemoryUsage() override {
-   // All memory is allocated through allocator; nothing to report here
-   return 0;
- }
-
- void Get(const LookupKey& k, void* callback_args,
-          bool (*callback_func)(void* arg, const char* entry)) override {
-   SkipListRep::Iterator iter(&skip_list_);
-   Slice dummy_slice;
-   for (iter.Seek(dummy_slice, k.memtable_key().data());
-        iter.Valid() && callback_func(callback_args, iter.key()); iter.Next()) {
-   }
- }
+  bool Contains(const char* key) const override {
+    return skip_list_.Contains(key);
+  }
+
+  size_t ApproximateMemoryUsage() override {
+    // All memory is allocated through allocator; nothing to report here
+    return 0;
+  }
+
+  void Get(const LookupKey& k, void* callback_args,
+           bool (*callback_func)(void* arg, const char* entry)) override {
+    SkipListRep::Iterator iter(&skip_list_);
+    Slice dummy_slice;
+    for (iter.Seek(dummy_slice, k.memtable_key().data());
+         iter.Valid() && callback_func(callback_args, iter.key());
+         iter.Next()) {
+    }
+  }
 
   uint64_t ApproximateNumEntries(const Slice& start_ikey,
                                  const Slice& end_ikey) override {
@@ -218,7 +220,7 @@ public:
     void SeekToLast() override { iter_.SeekToLast(); }
 
    protected:
-    std::string tmp_;       // For passing to EncodeKey
+    std::string tmp_;  // For passing to EncodeKey
   };
 
   // Iterator over the contents of a skip list which also keeps track of the
@@ -227,8 +229,8 @@ public:
   // the target key hasn't been found.
   class LookaheadIterator : public MemTableRep::Iterator {
    public:
-    explicit LookaheadIterator(const SkipListRep& rep) :
-        rep_(rep), iter_(&rep_.skip_list_), prev_(iter_) {}
+    explicit LookaheadIterator(const SkipListRep& rep)
+        : rep_(rep), iter_(&rep_.skip_list_), prev_(iter_) {}
 
     ~LookaheadIterator() override {}
 
@@ -271,9 +273,9 @@ public:
     }
 
     void Seek(const Slice& internal_key, const char* memtable_key) override {
-      const char *encoded_key =
-        (memtable_key != nullptr) ?
-            memtable_key : EncodeKey(&tmp_, internal_key);
+      const char* encoded_key = (memtable_key != nullptr)
+                                    ? memtable_key
+                                    : EncodeKey(&tmp_, internal_key);
 
       if (prev_.Valid() && rep_.cmp_(encoded_key, prev_.key()) >= 0) {
         // prev_.key() is smaller or equal to our target key; do a quick
@@ -313,7 +315,7 @@ public:
     }
 
    protected:
-    std::string tmp_;       // For passing to EncodeKey
+    std::string tmp_;  // For passing to EncodeKey
 
    private:
     const SkipListRep& rep_;
@@ -323,19 +325,20 @@ public:
 
   MemTableRep::Iterator* GetIterator(Arena* arena = nullptr) override {
     if (lookahead_ > 0) {
-      void *mem =
-        arena ? arena->AllocateAligned(sizeof(SkipListRep::LookaheadIterator))
-              : operator new(sizeof(SkipListRep::LookaheadIterator));
+      void* mem =
+          arena ? arena->AllocateAligned(sizeof(SkipListRep::LookaheadIterator))
+                :
+                operator new(sizeof(SkipListRep::LookaheadIterator));
       return new (mem) SkipListRep::LookaheadIterator(*this);
     } else {
-      void *mem =
-        arena ? arena->AllocateAligned(sizeof(SkipListRep::Iterator))
-              : operator new(sizeof(SkipListRep::Iterator));
+      void* mem = arena ? arena->AllocateAligned(sizeof(SkipListRep::Iterator))
+                        :
+                        operator new(sizeof(SkipListRep::Iterator));
       return new (mem) SkipListRep::Iterator(&skip_list_);
     }
   }
 };
-}
+}  // namespace
 
 static std::unordered_map<std::string, OptionTypeInfo> skiplist_factory_info = {
 #ifndef ROCKSDB_LITE

package/deps/rocksdb/rocksdb/memtable/stl_wrappers.h

@@ -29,5 +29,5 @@ struct Compare : private Base {
   }
 };
 
-}
+}  // namespace stl_wrappers
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/memtable/vectorrep.cc

@@ -48,13 +48,14 @@ class VectorRep : public MemTableRep {
     std::shared_ptr<std::vector<const char*>> bucket_;
     std::vector<const char*>::const_iterator mutable cit_;
     const KeyComparator& compare_;
-    std::string tmp_;       // For passing to EncodeKey
+    std::string tmp_;  // For passing to EncodeKey
     bool mutable sorted_;
     void DoSort() const;
+
    public:
     explicit Iterator(class VectorRep* vrep,
-      std::shared_ptr<std::vector<const char*>> bucket,
-      const KeyComparator& compare);
+                      std::shared_ptr<std::vector<const char*>> bucket,
+                      const KeyComparator& compare);
 
     // Initialize an iterator over the specified collection.
     // The returned iterator is not valid.
@@ -123,12 +124,10 @@ void VectorRep::MarkReadOnly() {
 }
 
 size_t VectorRep::ApproximateMemoryUsage() {
-  return
-    sizeof(bucket_) + sizeof(*bucket_) +
-    bucket_->size() *
-    sizeof(
-      std::remove_reference<decltype(*bucket_)>::type::value_type
-    );
+  return sizeof(bucket_) + sizeof(*bucket_) +
+         bucket_->size() *
+             sizeof(
+                 std::remove_reference<decltype(*bucket_)>::type::value_type);
 }
 
 VectorRep::VectorRep(const KeyComparator& compare, Allocator* allocator,
@@ -142,13 +141,13 @@ VectorRep::VectorRep(const KeyComparator& compare, Allocator* allocator,
 }
 
 VectorRep::Iterator::Iterator(class VectorRep* vrep,
-                   std::shared_ptr<std::vector<const char*>> bucket,
-                   const KeyComparator& compare)
-: vrep_(vrep),
-  bucket_(bucket),
-  cit_(bucket_->end()),
-  compare_(compare),
-  sorted_(false) { }
+                              std::shared_ptr<std::vector<const char*>> bucket,
+                              const KeyComparator& compare)
+    : vrep_(vrep),
+      bucket_(bucket),
+      cit_(bucket_->end()),
+      compare_(compare),
+      sorted_(false) {}
 
 void VectorRep::Iterator::DoSort() const {
   // vrep is non-null means that we are working on an immutable memtable
@@ -216,12 +215,11 @@ void VectorRep::Iterator::Seek(const Slice& user_key,
   // Do binary search to find first value not less than the target
   const char* encoded_key =
       (memtable_key != nullptr) ? memtable_key : EncodeKey(&tmp_, user_key);
-  cit_ = std::equal_range(bucket_->begin(),
-                          bucket_->end(),
-                          encoded_key,
-                          [this] (const char* a, const char* b) {
+  cit_ = std::equal_range(bucket_->begin(), bucket_->end(), encoded_key,
+                          [this](const char* a, const char* b) {
                             return compare_(a, b) < 0;
-                          }).first;
+                          })
+             .first;
 }
 
 // Advance to the first entry with a key <= target
@@ -282,7 +280,7 @@ MemTableRep::Iterator* VectorRep::GetIterator(Arena* arena) {
     }
   } else {
     std::shared_ptr<Bucket> tmp;
-    tmp.reset(new Bucket(*bucket_)); // make a copy
+    tmp.reset(new Bucket(*bucket_));  // make a copy
     if (arena == nullptr) {
       return new Iterator(nullptr, tmp, compare_);
     } else {
@@ -290,7 +288,7 @@ MemTableRep::Iterator* VectorRep::GetIterator(Arena* arena) {
     }
   }
 }
-} // anon namespace
+}  // namespace
 
 static std::unordered_map<std::string, OptionTypeInfo> vector_rep_table_info = {
     {"count",

package/deps/rocksdb/rocksdb/memtable/write_buffer_manager_test.cc

@@ -8,6 +8,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "rocksdb/write_buffer_manager.h"
+
 #include "test_util/testharness.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/monitoring/histogram.cc

@@ -52,11 +52,10 @@ size_t HistogramBucketMapper::IndexForValue(const uint64_t value) const {
 }
 
 namespace {
-  const HistogramBucketMapper bucketMapper;
+const HistogramBucketMapper bucketMapper;
 }
 
-HistogramStat::HistogramStat()
-  : num_buckets_(bucketMapper.BucketCount()) {
+HistogramStat::HistogramStat() : num_buckets_(bucketMapper.BucketCount()) {
   assert(num_buckets_ == sizeof(buckets_) / sizeof(*buckets_));
   Clear();
 }
@@ -109,12 +108,14 @@ void HistogramStat::Merge(const HistogramStat& other) {
   uint64_t old_min = min();
   uint64_t other_min = other.min();
   while (other_min < old_min &&
-         !min_.compare_exchange_weak(old_min, other_min)) {}
+         !min_.compare_exchange_weak(old_min, other_min)) {
+  }
 
   uint64_t old_max = max();
   uint64_t other_max = other.max();
   while (other_max > old_max &&
-         !max_.compare_exchange_weak(old_max, other_max)) {}
+         !max_.compare_exchange_weak(old_max, other_max)) {
+  }
 
   num_.fetch_add(other.num(), std::memory_order_relaxed);
   sum_.fetch_add(other.sum(), std::memory_order_relaxed);
@@ -124,9 +125,7 @@ void HistogramStat::Merge(const HistogramStat& other) {
   }
 }
 
-double HistogramStat::Median() const {
-  return Percentile(50.0);
-}
+double HistogramStat::Median() const { return Percentile(50.0); }
 
 double HistogramStat::Percentile(double p) const {
   double threshold = num() * (p / 100.0);
@@ -136,14 +135,14 @@ double HistogramStat::Percentile(double p) const {
     cumulative_sum += bucket_value;
     if (cumulative_sum >= threshold) {
       // Scale linearly within this bucket
-      uint64_t left_point = (b == 0) ? 0 : bucketMapper.BucketLimit(b-1);
+      uint64_t left_point = (b == 0) ? 0 : bucketMapper.BucketLimit(b - 1);
       uint64_t right_point = bucketMapper.BucketLimit(b);
       uint64_t left_sum = cumulative_sum - bucket_value;
       uint64_t right_sum = cumulative_sum;
       double pos = 0;
       uint64_t right_left_diff = right_sum - left_sum;
       if (right_left_diff != 0) {
-       pos = (threshold - left_sum) / right_left_diff;
+        pos = (threshold - left_sum) / right_left_diff;
       }
       double r = left_point + (right_point - left_point) * pos;
       uint64_t cur_min = min();
@@ -180,8 +179,7 @@ std::string HistogramStat::ToString() const {
   uint64_t cur_num = num();
   std::string r;
   char buf[1650];
-  snprintf(buf, sizeof(buf),
-           "Count: %" PRIu64 " Average: %.4f  StdDev: %.2f\n",
+  snprintf(buf, sizeof(buf), "Count: %" PRIu64 " Average: %.4f  StdDev: %.2f\n",
            cur_num, Average(), StandardDeviation());
   r.append(buf);
   snprintf(buf, sizeof(buf),
@@ -195,7 +193,7 @@ std::string HistogramStat::ToString() const {
            Percentile(99.99));
   r.append(buf);
   r.append("------------------------------------------------------\n");
-  if (cur_num == 0) return r;   // all buckets are empty
+  if (cur_num == 0) return r;  // all buckets are empty
   const double mult = 100.0 / cur_num;
   uint64_t cumulative_sum = 0;
   for (unsigned int b = 0; b < num_buckets_; b++) {
@@ -205,11 +203,11 @@ std::string HistogramStat::ToString() const {
     snprintf(buf, sizeof(buf),
              "%c %7" PRIu64 ", %7" PRIu64 " ] %8" PRIu64 " %7.3f%% %7.3f%% ",
              (b == 0) ? '[' : '(',
-             (b == 0) ? 0 : bucketMapper.BucketLimit(b-1),  // left
-              bucketMapper.BucketLimit(b),  // right
-              bucket_value,                   // count
-             (mult * bucket_value),           // percentage
-             (mult * cumulative_sum));       // cumulative percentage
+             (b == 0) ? 0 : bucketMapper.BucketLimit(b - 1),  // left
+             bucketMapper.BucketLimit(b),                     // right
+             bucket_value,                                    // count
+             (mult * bucket_value),                           // percentage
+             (mult * cumulative_sum));  // cumulative percentage
     r.append(buf);
 
     // Add hash marks based on percentage; 20 marks for 100%.
@@ -220,7 +218,7 @@ std::string HistogramStat::ToString() const {
   return r;
 }
 
-void HistogramStat::Data(HistogramData * const data) const {
+void HistogramStat::Data(HistogramData* const data) const {
   assert(data);
   data->median = Median();
   data->percentile95 = Percentile(95);
@@ -238,13 +236,9 @@ void HistogramImpl::Clear() {
   stats_.Clear();
 }
 
-bool HistogramImpl::Empty() const {
-  return stats_.Empty();
-}
+bool HistogramImpl::Empty() const { return stats_.Empty(); }
 
-void HistogramImpl::Add(uint64_t value) {
-  stats_.Add(value);
-}
+void HistogramImpl::Add(uint64_t value) { stats_.Add(value); }
 
 void HistogramImpl::Merge(const Histogram& other) {
   if (strcmp(Name(), other.Name()) == 0) {
@@ -257,28 +251,20 @@ void HistogramImpl::Merge(const HistogramImpl& other) {
   stats_.Merge(other.stats_);
 }
 
-double HistogramImpl::Median() const {
-  return stats_.Median();
-}
+double HistogramImpl::Median() const { return stats_.Median(); }
 
 double HistogramImpl::Percentile(double p) const {
   return stats_.Percentile(p);
 }
 
-double HistogramImpl::Average() const {
-  return stats_.Average();
-}
+double HistogramImpl::Average() const { return stats_.Average(); }
 
 double HistogramImpl::StandardDeviation() const {
- return stats_.StandardDeviation();
+  return stats_.StandardDeviation();
 }
 
-std::string HistogramImpl::ToString() const {
-  return stats_.ToString();
-}
+std::string HistogramImpl::ToString() const { return stats_.ToString(); }
 
-void HistogramImpl::Data(HistogramData * const data) const {
-  stats_.Data(data);
-}
+void HistogramImpl::Data(HistogramData* const data) const { stats_.Data(data); }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/monitoring/histogram.h

@@ -8,36 +8,29 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #pragma once
-#include "rocksdb/statistics.h"
-
 #include <cassert>
-#include <string>
-#include <vector>
 #include <map>
 #include <mutex>
+#include <string>
+#include <vector>
+
+#include "rocksdb/statistics.h"
 
 namespace ROCKSDB_NAMESPACE {
 
 class HistogramBucketMapper {
  public:
-
   HistogramBucketMapper();
 
   // converts a value to the bucket index.
   size_t IndexForValue(uint64_t value) const;
   // number of buckets required.
 
-  size_t BucketCount() const {
-    return bucketValues_.size();
-  }
+  size_t BucketCount() const { return bucketValues_.size(); }
 
-  uint64_t LastValue() const {
-    return maxBucketValue_;
-  }
+  uint64_t LastValue() const { return maxBucketValue_; }
 
-  uint64_t FirstValue() const {
-    return minBucketValue_;
-  }
+  uint64_t FirstValue() const { return minBucketValue_; }
 
   uint64_t BucketLimit(const size_t bucketNumber) const {
     assert(bucketNumber < BucketCount());
@@ -88,14 +81,14 @@ struct HistogramStat {
   std::atomic_uint_fast64_t num_;
   std::atomic_uint_fast64_t sum_;
   std::atomic_uint_fast64_t sum_squares_;
-  std::atomic_uint_fast64_t buckets_[109]; // 109==BucketMapper::BucketCount()
+  std::atomic_uint_fast64_t buckets_[109];  // 109==BucketMapper::BucketCount()
   const uint64_t num_buckets_;
 };
 
 class Histogram {
-public:
+ public:
   Histogram() {}
-  virtual ~Histogram() {};
+  virtual ~Histogram(){};
 
   virtual void Clear() = 0;
   virtual bool Empty() const = 0;

package/deps/rocksdb/rocksdb/monitoring/histogram_test.cc

@@ -18,14 +18,14 @@ namespace ROCKSDB_NAMESPACE {
 class HistogramTest : public testing::Test {};
 
 namespace {
-  const double kIota = 0.1;
-  const HistogramBucketMapper bucketMapper;
-  std::shared_ptr<MockSystemClock> clock =
-      std::make_shared<MockSystemClock>(SystemClock::Default());
-}
-
-void PopulateHistogram(Histogram& histogram,
-             uint64_t low, uint64_t high, uint64_t loop = 1) {
+const double kIota = 0.1;
+const HistogramBucketMapper bucketMapper;
+std::shared_ptr<MockSystemClock> clock =
+    std::make_shared<MockSystemClock>(SystemClock::Default());
+}  // namespace
+
+void PopulateHistogram(Histogram& histogram, uint64_t low, uint64_t high,
+                       uint64_t loop = 1) {
   Random rnd(test::RandomSeed());
   for (; loop > 0; loop--) {
     for (uint64_t i = low; i <= high; i++) {
@@ -39,7 +39,7 @@ void PopulateHistogram(Histogram& histogram,
 }
 
 void BasicOperation(Histogram& histogram) {
-  PopulateHistogram(histogram, 1, 110, 10); // fill up to bucket [70, 110)
+  PopulateHistogram(histogram, 1, 110, 10);  // fill up to bucket [70, 110)
 
   HistogramData data;
   histogram.Data(&data);
@@ -47,8 +47,8 @@ void BasicOperation(Histogram& histogram) {
   ASSERT_LE(fabs(histogram.Percentile(100.0) - 110.0), kIota);
   ASSERT_LE(fabs(data.percentile99 - 108.9), kIota);  // 99 * 110 / 100
   ASSERT_LE(fabs(data.percentile95 - 104.5), kIota);  // 95 * 110 / 100
-  ASSERT_LE(fabs(data.median - 55.0), kIota);  // 50 * 110 / 100
-  ASSERT_EQ(data.average, 55.5);  // (1 + 110) / 2
+  ASSERT_LE(fabs(data.median - 55.0), kIota);         // 50 * 110 / 100
+  ASSERT_EQ(data.average, 55.5);                      // (1 + 110) / 2
 }
 
 void MergeHistogram(Histogram& histogram, Histogram& other) {
@@ -62,8 +62,8 @@ void MergeHistogram(Histogram& histogram, Histogram& other) {
   ASSERT_LE(fabs(histogram.Percentile(100.0) - 250.0), kIota);
   ASSERT_LE(fabs(data.percentile99 - 247.5), kIota);  // 99 * 250 / 100
   ASSERT_LE(fabs(data.percentile95 - 237.5), kIota);  // 95 * 250 / 100
-  ASSERT_LE(fabs(data.median - 125.0), kIota);  // 50 * 250 / 100
-  ASSERT_EQ(data.average, 125.5);  // (1 + 250) / 2
+  ASSERT_LE(fabs(data.median - 125.0), kIota);        // 50 * 250 / 100
+  ASSERT_EQ(data.average, 125.5);                     // (1 + 250) / 2
 }
 
 void EmptyHistogram(Histogram& histogram) {
@@ -139,8 +139,8 @@ TEST_F(HistogramTest, HistogramWindowingExpire) {
   int micros_per_window = 1000000;
   uint64_t min_num_per_window = 0;
 
-  HistogramWindowingImpl
-      histogramWindowing(num_windows, micros_per_window, min_num_per_window);
+  HistogramWindowingImpl histogramWindowing(num_windows, micros_per_window,
+                                            min_num_per_window);
   histogramWindowing.TEST_UpdateClock(clock);
   PopulateHistogram(histogramWindowing, 1, 1, 100);
   clock->SleepForMicroseconds(micros_per_window);
@@ -190,10 +190,10 @@ TEST_F(HistogramTest, HistogramWindowingMerge) {
   int micros_per_window = 1000000;
   uint64_t min_num_per_window = 0;
 
-  HistogramWindowingImpl
-      histogramWindowing(num_windows, micros_per_window, min_num_per_window);
-  HistogramWindowingImpl
-      otherWindowing(num_windows, micros_per_window, min_num_per_window);
+  HistogramWindowingImpl histogramWindowing(num_windows, micros_per_window,
+                                            min_num_per_window);
+  HistogramWindowingImpl otherWindowing(num_windows, micros_per_window,
+                                        min_num_per_window);
   histogramWindowing.TEST_UpdateClock(clock);
   otherWindowing.TEST_UpdateClock(clock);