Add circular_queue and time_based_counter classes. (istio#51)

* Add circular_queue and time_based_counter classes.

* Fix format

Author: qiwzhang

mixerclient/BUILD

@@ -37,9 +37,12 @@ cc_library(
         "src/signature.h",
         "src/stream_transport.h",
         "src/transport.h",
+        "utils/circular_queue.h",
         "utils/md5.cc",
         "utils/md5.h",
         "utils/status_test_util.h",
+        "utils/time_based_counter.cc",
+        "utils/time_based_counter.h",
     ],
     hdrs = [
         "include/attribute.h",
@@ -125,6 +128,28 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "circular_queue_test",
+    size = "small",
+    srcs = ["utils/circular_queue_test.cc"],
+    linkstatic = 1,
+    deps = [
+        ":mixer_client_lib",
+        "//external:googletest_main",
+    ],
+)
+
+cc_test(
+    name = "time_based_counter_test",
+    size = "small",
+    srcs = ["utils/time_based_counter_test.cc"],
+    linkstatic = 1,
+    deps = [
+        ":mixer_client_lib",
+        "//external:googletest_main",
+    ],
+)
+
 cc_test(
     name = "cache_key_set_test",
     size = "small",

mixerclient/utils/circular_queue.h

@@ -0,0 +1,97 @@
+/* Copyright 2017 Istio Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MIXER_CLIENT_UTILS_CIRCULAR_QUEUE_H_
+#define MIXER_CLIENT_UTILS_CIRCULAR_QUEUE_H_
+
+#include <functional>
+#include <vector>
+
+namespace istio {
+namespace mixer_client {
+
+// Define a circular FIFO queue
+// Supported classes should support copy operator.
+template <class T>
+class CircularQueue {
+ public:
+  explicit CircularQueue(int size);
+
+  // Push an item to the tail
+  void Push(const T& v);
+
+  // Pop up an item from the head
+  void Pop();
+
+  // Allow modifying the head item.
+  T* Mutable_Head();
+
+  // Calls the fn function for each element from head to tail.
+  void Iterate(std::function<bool(const T&)> fn) const;
+
+ private:
+  std::vector<T> nodes_;
+  int head_;
+  int tail_;
+  int count_;
+};
+
+template <class T>
+CircularQueue<T>::CircularQueue(int size)
+    : nodes_(size), head_(0), tail_(0), count_(0) {}
+
+template <class T>
+void CircularQueue<T>::Push(const T& v) {
+  if (head_ == tail_ && count_ > 0) {
+    size_t size = nodes_.size();
+    nodes_.resize(size * 2);
+    for (int i = 0; i <= head_; i++) {
+      // Use the copy operator of class T
+      nodes_[size + i] = nodes_[i];
+    }
+    tail_ += size;
+  }
+  nodes_[tail_] = v;
+  tail_ = (tail_ + 1) % nodes_.size();
+  count_++;
+}
+
+template <class T>
+void CircularQueue<T>::Pop() {
+  if (count_ == 0) return;
+  head_ = (head_ + 1) % nodes_.size();
+  count_--;
+}
+
+template <class T>
+T* CircularQueue<T>::Mutable_Head() {
+  if (count_ == 0) return nullptr;
+  return &nodes_[head_];
+}
+
+template <class T>
+void CircularQueue<T>::Iterate(std::function<bool(const T&)> fn) const {
+  if (count_ == 0) return;
+  int i = head_;
+  while (i != tail_) {
+    if (!fn(nodes_[i])) return;
+    i = (i + 1) % nodes_.size();
+  }
+}
+
+}  // namespace mixer_client
+}  // namespace istio
+
+#endif  // MIXER_CLIENT_CLIENT_UTILS_CIRCULAR_QUEUE_H_

mixerclient/utils/circular_queue_test.cc

@@ -0,0 +1,74 @@
+/* Copyright 2017 Istio Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "circular_queue.h"
+#include "gtest/gtest.h"
+
+namespace istio {
+namespace mixer_client {
+namespace {
+
+void ASSERT_RESULT(const CircularQueue<int>& q,
+                   const std::vector<int>& expected) {
+  std::vector<int> v;
+  q.Iterate([&](const int& i) -> bool {
+    v.push_back(i);
+    return true;
+  });
+  ASSERT_EQ(v, expected);
+}
+
+TEST(CircularQueueTest, TestNotResize) {
+  CircularQueue<int> q(5);
+  q.Push(1);
+  q.Push(2);
+  q.Push(3);
+  ASSERT_RESULT(q, {1, 2, 3});
+
+  q.Pop();
+  q.Pop();
+  q.Push(4);
+  q.Push(5);
+  q.Push(6);
+  ASSERT_RESULT(q, {3, 4, 5, 6});
+}
+
+TEST(CircularQueueTest, TestResize1) {
+  CircularQueue<int> q(3);
+  for (int i = 1; i < 6; i++) {
+    q.Push(i);
+  }
+  ASSERT_RESULT(q, {1, 2, 3, 4, 5});
+}
+
+TEST(CircularQueueTest, TestResize2) {
+  CircularQueue<int> q(3);
+
+  // move head and tail
+  q.Push(1);
+  q.Push(2);
+  q.Push(3);
+  q.Pop();
+  q.Pop();
+
+  for (int i = 4; i < 10; i++) {
+    q.Push(i);
+  }
+  ASSERT_RESULT(q, {3, 4, 5, 6, 7, 8, 9});
+}
+
+}  // namespace
+}  // namespace mixer_client
+}  // namespace istio

mixerclient/utils/time_based_counter.cc

@@ -0,0 +1,65 @@
+/* Copyright 2017 Istio Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "time_based_counter.h"
+
+namespace istio {
+namespace mixer_client {
+
+TimeBasedCounter::TimeBasedCounter(int window_size,
+                                   std::chrono::nanoseconds duration, Tick t)
+    : slots_(window_size),
+      slot_duration_(duration / window_size),
+      count_(0),
+      tail_(0),
+      last_time_(t) {}
+
+void TimeBasedCounter::Clear(Tick t) {
+  last_time_ = t;
+  for (size_t i = 0; i < slots_.size(); i++) {
+    slots_[i] = 0;
+  }
+  tail_ = count_ = 0;
+}
+
+void TimeBasedCounter::Roll(Tick t) {
+  std::chrono::nanoseconds d = t - last_time_;
+  uint32_t n = uint32_t(d / slot_duration_);
+  if (n >= slots_.size()) {
+    Clear(t);
+    return;
+  }
+
+  for (uint32_t i = 0; i < n; i++) {
+    tail_ = (tail_ + 1) % slots_.size();
+    count_ -= slots_[tail_];
+    slots_[tail_] = 0;
+    last_time_ += slot_duration_;
+  }
+}
+
+void TimeBasedCounter::Inc(Tick t) {
+  Roll(t);
+  slots_[tail_]++;
+  count_++;
+}
+
+int TimeBasedCounter::Count(Tick t) {
+  Roll(t);
+  return count_;
+}
+
+}  // namespace mixer_client
+}  // namespace istio

mixerclient/utils/time_based_counter.h

@@ -0,0 +1,61 @@
+/* Copyright 2017 Istio Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MIXER_CLIENT_UTILS_TIME_BASED_COUNTER_H_
+#define MIXER_CLIENT_UTILS_TIME_BASED_COUNTER_H_
+
+#include <chrono>
+#include <vector>
+
+namespace istio {
+namespace mixer_client {
+
+// Define a counter for the count in a time based window.
+// Each count is associated with a time stamp. The count outside
+// of the window will not be counted.
+class TimeBasedCounter {
+ public:
+  // Define a time type
+  typedef std::chrono::time_point<std::chrono::system_clock> Tick;
+
+  TimeBasedCounter(int window_size, std::chrono::nanoseconds duration, Tick t);
+
+  // Ideally, Now() timestamp should be inside the functions.
+  // But for easy unit_test, pass the time in.
+  // The input time should be always increasing.
+
+  // Add a count
+  void Inc(Tick t);
+
+  // Get the count.
+  int Count(Tick t);
+
+ private:
+  // Clear the whole window
+  void Clear(Tick t);
+  // Roll the window
+  void Roll(Tick t);
+
+  std::vector<int> slots_;
+  std::chrono::nanoseconds slot_duration_;
+  int count_;
+  int tail_;
+  Tick last_time_;
+};
+
+}  // namespace mixer_client
+}  // namespace istio
+
+#endif  // MIXER_CLIENT_CLIENT_UTILS_TIME_BASED_COUNTER_H_

mixerclient/utils/time_based_counter_test.cc

@@ -0,0 +1,40 @@
+/* Copyright 2017 Istio Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "time_based_counter.h"
+#include "gtest/gtest.h"
+
+namespace istio {
+namespace mixer_client {
+namespace {
+
+std::chrono::time_point<std::chrono::system_clock> FakeTime(int t) {
+  return std::chrono::time_point<std::chrono::system_clock>(
+      std::chrono::nanoseconds(t));
+}
+
+TEST(TimeBasedCounterTest, Test1) {
+  TimeBasedCounter c(3, std::chrono::nanoseconds(3), FakeTime(0));
+  c.Inc(FakeTime(4));
+  c.Inc(FakeTime(5));
+  c.Inc(FakeTime(7));
+
+  // Current slots are 6, 7, 8. and 4 and 5 are out.
+  ASSERT_EQ(c.Count(FakeTime(8)), 1);
+}
+
+}  // namespace
+}  // namespace mixer_client
+}  // namespace istio