init push

2021-05-31 22:56:52 +08:00
commit cea7de1475
7020 changed files with 5689869 additions and 0 deletions
--- a/unittest/clog/test_seg_array.cpp
+++ b/unittest/clog/test_seg_array.cpp
@ -0,0 +1,431 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include <gtest/gtest.h>
+#include "lib/container/ob_seg_array.h"
+#include "clog/ob_file_id_cache.h"
+using namespace oceanbase::common;
+using namespace oceanbase::clog;
+
+ObSmallAllocator small_allocator;
+
+void init_env()
+{
+  const int64_t seg_size = ObSegArray<Log2File, ObFileIdList::SEG_STEP, ObFileIdList::SEG_COUNT>::get_seg_size();
+  small_allocator.init(seg_size,
+      ObModIds::OB_CSR_FILE_ID_CACHE_FILE_ITEM,
+      OB_SERVER_TENANT_ID,
+      OB_MALLOC_BIG_BLOCK_SIZE,
+      128,
+      4L * 1024L * 1024L * 1024L);
+}
+
+class TestSegArray : public ::testing::Test {
+  public:
+  TestSegArray()
+  {}
+  virtual ~TestSegArray()
+  {}
+
+  private:
+  DISALLOW_COPY_AND_ASSIGN(TestSegArray);
+};
+
+struct Item {
+  int x;
+  int y;
+
+  Item() : x(0), y(0)
+  {}
+  bool operator<=(const Item& that) const
+  {
+    return x <= that.x;
+  }
+  TO_STRING_KV(K(x), K(y));
+};
+
+struct ItemLEFunctor {
+  bool operator()(const Item& a, const Item& b) const
+  {
+    return a <= b;
+  }
+};
+
+struct ReverseForEachFunctor {
+  int64_t cnt_;
+  int operator()(const Item& item)
+  {
+    int ret = OB_SUCCESS;
+    LIB_LOG(INFO, "print", K(item), K(cnt_));
+    cnt_++;
+    return ret;
+  }
+};
+
+TEST(TestSegArray, test_fix_rq)
+{
+  ObFixedRingDeque<Item, 20> q;
+  for (int i = 0; i < 10; i++) {
+    Item item;
+    item.x = i * 10;
+    item.y = i * 10;
+    ASSERT_EQ(OB_SUCCESS, q.push_back(item));
+  }
+
+  q.debug_print();
+
+  Item target;
+  target.x = -5;
+  target.y = -5;
+  Item prev;
+  Item next;
+  ItemLEFunctor le_functor;
+  ASSERT_EQ(OB_ERR_OUT_OF_LOWER_BOUND, q.search_boundary(target, prev, next, le_functor));
+  EXPECT_EQ(0, next.x);
+  EXPECT_EQ(0, next.y);
+
+  for (int i = 0; i < 10; i++) {
+    Item target;
+    target.x = i * 10 + 5;
+    target.y = i * 10 + 5;
+    Item prev;
+    Item next;
+    int expect_err = i < 9 ? OB_SUCCESS : OB_ERR_OUT_OF_UPPER_BOUND;
+    int search_err = q.search_boundary(target, prev, next, le_functor);
+    ASSERT_EQ(expect_err, search_err);
+    ASSERT_TRUE(prev.x == target.x - 5);
+    if (i < 9) {
+      ASSERT_TRUE(next.x == target.x + 5);
+    }
+    LIB_LOG(INFO, "search", K(target), K(prev), K(next), K(search_err));
+  }
+
+  for (int i = 0; i < 10; i++) {
+    Item item;
+    ASSERT_EQ(OB_SUCCESS, q.top_front(item));
+    ASSERT_EQ(item.x, i * 10);
+    LIB_LOG(INFO, "top_front", K(item));
+    ASSERT_EQ(OB_SUCCESS, q.pop_front(item));
+    ASSERT_EQ(item.x, i * 10);
+    LIB_LOG(INFO, "pop_front", K(item));
+  }
+
+  do {
+    Item item;
+    ASSERT_EQ(OB_ENTRY_NOT_EXIST, q.top_front(item));
+    ASSERT_EQ(OB_ENTRY_NOT_EXIST, q.pop_front(item));
+  } while (0);
+
+  for (int i = 0; i < 10; i++) {
+    Item item;
+    item.x = (9 - i) * 10;
+    item.y = (9 - i) * 10;
+    ASSERT_EQ(OB_SUCCESS, q.push_front(item));
+  }
+
+  for (int i = 0; i < 10; i++) {
+    Item target;
+    target.x = i * 10 + 5;
+    target.y = i * 10 + 5;
+    Item prev;
+    Item next;
+    int expect_err = i < 9 ? OB_SUCCESS : OB_ERR_OUT_OF_UPPER_BOUND;
+    int search_err = q.search_boundary(target, prev, next, le_functor);
+    ASSERT_EQ(expect_err, search_err);
+    ASSERT_TRUE(prev.x == target.x - 5);
+    if (i < 9) {
+      ASSERT_TRUE(next.x == target.x + 5);
+    }
+    LIB_LOG(INFO, "search", K(target), K(prev), K(next), K(search_err));
+  }
+
+  for (int i = 0; i < 10; i++) {
+    Item item;
+    ASSERT_EQ(OB_SUCCESS, q.top_back(item));
+    ASSERT_EQ(item.x, (9 - i) * 10);
+    LIB_LOG(INFO, "top_back", K(item));
+    ASSERT_EQ(OB_SUCCESS, q.pop_back(item));
+    ASSERT_EQ(item.x, (9 - i) * 10);
+    LIB_LOG(INFO, "pop_back", K(item));
+  }
+
+  do {
+    Item item;
+    ASSERT_EQ(OB_ENTRY_NOT_EXIST, q.top_front(item));
+    ASSERT_EQ(OB_ENTRY_NOT_EXIST, q.pop_front(item));
+  } while (0);
+}
+
+TEST(TestSegArray, test_fix_rq_wrapped)
+{
+  int ret = OB_SUCCESS;
+  ObFixedRingDeque<Item, 21> q;
+  for (int i = 0; i < 15; i++) {
+    Item item;
+    item.x = i * 2;
+    item.y = i * 2;
+    ASSERT_EQ(OB_SUCCESS, q.push_back(item));
+  }
+  q.debug_print();
+
+  for (int i = 0; i < 10; i++) {
+    Item item;
+    item.x = -1;
+    item.y = -1;
+    ASSERT_EQ(OB_SUCCESS, q.pop_front(item));
+    LIB_LOG(INFO, "poped item", K(item));
+  }
+  q.debug_print();
+
+  for (int i = 15; i < 20; i++) {
+    Item item;
+    item.x = i * 2;
+    item.y = i * 2;
+    ASSERT_EQ(OB_SUCCESS, q.push_back(item));
+  }
+  q.debug_print();
+
+  for (int i = 20; i < 25; i++) {
+    Item item;
+    item.x = i * 2;
+    item.y = i * 2;
+    ASSERT_EQ(OB_SUCCESS, q.push_back(item));
+  }
+  q.debug_print();
+
+  Item target;
+  target.x = 10;
+  target.y = 10;
+  Item prev;
+  Item next;
+  ItemLEFunctor le_functor;
+  ASSERT_EQ(OB_ERR_OUT_OF_LOWER_BOUND, q.search_boundary(target, prev, next, le_functor));
+  EXPECT_EQ(20, next.x);
+  EXPECT_EQ(20, next.y);
+
+  for (int i = 20; i < 50; i++) {
+    Item target;
+    target.x = i;
+    target.y = i;
+    Item prev;
+    Item next;
+    int expect_err = i < 48 ? OB_SUCCESS : OB_ERR_OUT_OF_UPPER_BOUND;
+    ret = q.search_boundary(target, prev, next, le_functor);
+    ASSERT_EQ(expect_err, ret);
+    EXPECT_EQ((i / 2) * 2, prev.x);
+    if (i < 48) {
+      EXPECT_EQ((i / 2 + 1) * 2, next.x);
+    }
+
+    LIB_LOG(INFO, "search", K(ret), K(i), K(target), K(prev), K(next));
+  }
+}
+
+TEST(TestSegArray, test_seg_arr)
+{
+  int ret = OB_SUCCESS;
+  ObSegArray<Item, 10, 8> seg_array;
+  ASSERT_EQ(OB_SUCCESS, seg_array.init(&small_allocator));
+
+  const int count = 65;
+  for (int i = 0; i < count; i++) {
+    Item item;
+    item.x = i * 10;
+    item.y = i * 10;
+    ASSERT_EQ(OB_SUCCESS, seg_array.push_back(item));
+    LIB_LOG(INFO, "push_back success", K(item));
+  }
+  LIB_LOG(INFO, "print seg_array");
+  seg_array.debug_print();
+
+  for (int i = 5; i < 650; i = i + 10) {
+    Item target;
+    target.x = i;
+    target.y = i;
+    Item prev;
+    Item next;
+    int expect_err = i < 640 ? OB_SUCCESS : OB_ERR_OUT_OF_UPPER_BOUND;
+    ret = seg_array.search_boundary(target, prev, next);
+    LIB_LOG(INFO, "seg_array search_boundary: ", K(ret), K(target), K(prev), K(next));
+    EXPECT_EQ(expect_err, ret);
+    EXPECT_EQ((i / 10) * 10, prev.x);
+    if (i < 640) {
+      EXPECT_EQ((i / 10 + 1) * 10, next.x);
+    }
+    ASSERT_TRUE(prev.x + 5 == target.x);
+  }
+
+  Item target;
+  target.x = -100;
+  target.y = -100;
+  Item prev;
+  Item next;
+  ret = seg_array.search_boundary(target, prev, next);
+  LIB_LOG(INFO, "search_boundary: ", K(ret), K(target), K(prev), K(next));
+  ASSERT_TRUE(OB_ERR_OUT_OF_LOWER_BOUND == ret);
+  EXPECT_EQ(0, next.x);
+
+  LIB_LOG(INFO, "seg_array test pop_front and top_front");
+  for (int i = 0; i < count; i++) {
+    Item item;
+    ASSERT_EQ(OB_SUCCESS, seg_array.top_front(item));
+    ASSERT_EQ(item.x, i * 10);
+    LIB_LOG(INFO, "seg_array top_front", K(item), K(i));
+    ASSERT_EQ(OB_SUCCESS, seg_array.pop_front(item));
+    ASSERT_EQ(item.x, i * 10);
+    LIB_LOG(INFO, "seg_array pop_front", K(item), K(i));
+  }
+
+  seg_array.debug_print();
+
+  LIB_LOG(INFO, "test push_front");
+  for (int i = 0; i < count; i++) {
+    Item item;
+    item.x = (count - 1 - i) * 10;
+    item.y = (count - 1 - i) * 10;
+    ASSERT_EQ(OB_SUCCESS, seg_array.push_front(item));
+    LIB_LOG(INFO, "push_front", K(item));
+  }
+
+  seg_array.debug_print();
+
+  for (int i = 5; i < 650; i = i + 10) {
+    Item target;
+    target.x = i;
+    target.y = i;
+    Item prev;
+    Item next;
+    int expect_err = i < 640 ? OB_SUCCESS : OB_ERR_OUT_OF_UPPER_BOUND;
+    ret = seg_array.search_boundary(target, prev, next);
+    LIB_LOG(INFO, "seg_array search_boundary: ", K(ret), K(target), K(prev), K(next));
+    EXPECT_EQ(expect_err, ret);
+    EXPECT_EQ((i / 10) * 10, prev.x);
+    if (i < 640) {
+      EXPECT_EQ((i / 10 + 1) * 10, next.x);
+    }
+    ASSERT_TRUE(prev.x + 5 == target.x);
+  }
+
+  seg_array.debug_print();
+
+  for (int i = 0; i < count; i++) {
+    Item item;
+    ASSERT_EQ(OB_SUCCESS, seg_array.top_back(item));
+    LIB_LOG(INFO, "top_back", K(item), K(i));
+    ASSERT_EQ(item.x, (count - 1 - i) * 10);
+    ASSERT_EQ(OB_SUCCESS, seg_array.pop_back(item));
+    LIB_LOG(INFO, "pop_back", K(item), K(i));
+    ASSERT_EQ(item.x, (count - 1 - i) * 10);
+  }
+}
+
+TEST(TestSegArray, test_seg_arr_pop)
+{
+  ObSegArray<Item, 5, 10> seg_array;
+  ASSERT_EQ(OB_SUCCESS, seg_array.init(&small_allocator));
+  for (int i = 0; i < 45; i++) {
+    Item item;
+    item.x = i * 2;
+    item.y = i * 2;
+    ASSERT_EQ(OB_SUCCESS, seg_array.push_back(item));
+  }
+  seg_array.debug_print();
+
+  for (int i = 0; i < 45; i++) {
+    Item poped;
+    ASSERT_EQ(OB_SUCCESS, seg_array.pop_front(poped));
+  }
+  seg_array.debug_print();
+
+  for (int i = 0; i < 45; i++) {
+    Item item;
+    item.x = i * 2;
+    item.y = i * 2;
+    ASSERT_EQ(OB_SUCCESS, seg_array.push_back(item));
+  }
+  seg_array.debug_print();
+
+  for (int i = 0; i < 45; i++) {
+    Item poped;
+    ASSERT_EQ(OB_SUCCESS, seg_array.pop_front(poped));
+  }
+  seg_array.debug_print();
+}
+
+TEST(TestSegArray, test_seg_arr_tail_size)
+{
+  ObSegArray<Item, 10, 8> seg_array;
+  ASSERT_EQ(OB_SUCCESS, seg_array.init(&small_allocator));
+
+  int count = 5;
+  for (int i = 0; i < count; i++) {
+    Item item;
+    item.x = i * 2;
+    item.y = i * 2;
+    ASSERT_EQ(OB_SUCCESS, seg_array.push_back(item));
+  }
+  LIB_LOG(INFO, "print seg_array");
+  seg_array.debug_print();
+}
+
+TEST(TestSegArray, test_seg_arr_destroy)
+{
+  ObSegArray<Item, 10, 8> seg_array;
+  ASSERT_EQ(OB_SUCCESS, seg_array.init(&small_allocator));
+
+  int count = 5;
+  for (int i = 0; i < count; i++) {
+    Item item;
+    item.x = i * 2;
+    item.y = i * 2;
+    ASSERT_EQ(OB_SUCCESS, seg_array.push_back(item));
+  }
+  LIB_LOG(INFO, "print seg_array");
+  seg_array.debug_print();
+  seg_array.destroy();
+}
+
+TEST(TestSegArray, test_reverse_for_each)
+{
+  ObSegArray<Item, 10, 8> seg_array;
+  ASSERT_EQ(OB_SUCCESS, seg_array.init(&small_allocator));
+
+  int count = 50;
+  for (int i = 0; i < count; i++) {
+    Item item;
+    item.x = i;
+    item.y = i;
+    ASSERT_EQ(OB_SUCCESS, seg_array.push_back(item));
+  }
+  ReverseForEachFunctor fn;
+  fn.cnt_ = 0;
+  ASSERT_EQ(OB_SUCCESS, seg_array.reverse_for_each(fn));
+  ASSERT_EQ(50, fn.cnt_);
+
+  count = 15;
+  fn.cnt_ = 0;
+  for (int i = 0; i < count; i++) {
+    Item item;
+    ASSERT_EQ(OB_SUCCESS, seg_array.pop_front(item));
+  }
+  ASSERT_EQ(OB_SUCCESS, seg_array.reverse_for_each(fn));
+  ASSERT_EQ(35, fn.cnt_);
+}
+
+int main(int argc, char** argv)
+{
+  OB_LOGGER.set_log_level("INFO");
+  OB_LOGGER.set_file_name("test_seg_array.log", true, true);
+  init_env();
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}