patch 4.0

unittest/storage/blocksstable/encoding/test_bitset.cpp

@@ -0,0 +1,141 @@
+/**
+ * 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 "storage/blocksstable/encoding/ob_encoding_bitset.h"
+#include "lib/time/ob_time_utility.h"
+#include <vector>
+
+namespace oceanbase
+{
+namespace blocksstable
+{
+
+using namespace common;
+
+TEST(BitSet, set_get)
+{
+  const int64_t sset_cnt = 50;
+  const int64_t lset_cnt = 400;
+
+  uint64_t s[1];
+  uint64_t l[8];
+
+  std::vector<int64_t> s_pos;
+  std::vector<int64_t> l_pos;
+
+  BitSet sset;
+  ASSERT_EQ(OB_SUCCESS, sset.init(s, sset_cnt));
+  BitSet lset;
+  ASSERT_EQ(OB_SUCCESS, lset.init(l, lset_cnt));
+
+  for (int64_t tn = 0; tn < 1000; ++tn) {
+    sset.reset();
+    lset.reset();
+    s_pos.clear();
+    l_pos.clear();
+
+    int64_t i = 0;
+    while(i < sset_cnt) {
+      sset.set(i);
+      s_pos.push_back(i);
+      i += random() % 5 + 1;
+    }
+
+    for(i = 0; i < sset_cnt; ++i) {
+      std::vector<int64_t>::iterator iter = std::find(s_pos.begin(), s_pos.end(), i);
+      if (s_pos.end() != iter) {
+        ASSERT_TRUE(sset.get(i))
+          << "i: " << i << std::endl;
+        ASSERT_EQ(iter - s_pos.begin(), sset.get_ref(i))
+          << "i: " << i << std::endl;
+      } else {
+        ASSERT_FALSE(sset.get(i))
+          << "i: " << i << std::endl;
+      }
+    }
+
+    i = 0;
+    while(i < lset_cnt) {
+      lset.set(i);
+      l_pos.push_back(i);
+      i += random() % 5 + 1;
+    }
+
+    for(i = 0; i < lset_cnt; ++i) {
+      std::vector<int64_t>::iterator iter = std::find(l_pos.begin(), l_pos.end(), i);
+      if (l_pos.end() != iter) {
+        ASSERT_TRUE(lset.get(i))
+          << "i: " << i << std::endl;
+        ASSERT_EQ(iter - l_pos.begin(), lset.get_ref(i))
+          << "i: " << i << std::endl;
+      } else {
+        ASSERT_FALSE(lset.get(i))
+          << "i: " << i << std::endl;
+      }
+    }
+  }
+}
+
+TEST(BitSet, perf)
+{
+  const int64_t lset_cnt = 400;
+  const int64_t pct = 10;
+  const int64_t loops_cnt = 10000;
+
+  uint64_t l[8];
+  std::vector<int64_t> l_pos;
+  BitSet lset;
+  ASSERT_EQ(OB_SUCCESS, lset.init(l, lset_cnt));
+  uint64_t bitset_time_used = 0;
+  uint64_t bins_time_used = 0;
+  uint64_t begin_time = 0;
+  uint64_t end_time = 0;
+
+  for (int64_t j = 0; j < loops_cnt; ++j) {
+    lset.reset();
+    l_pos.clear();
+    int64_t i = 0;
+    while(i < lset_cnt) {
+      lset.set(i);
+      l_pos.push_back(i);
+      i += random() % pct + 1;
+    }
+    // get ref
+    begin_time = ::oceanbase::common::ObTimeUtility::current_time();
+    for (i = 0; i < l_pos.size(); ++i) {
+      lset.get_ref(l_pos.at(i));
+    }
+    end_time = ::oceanbase::common::ObTimeUtility::current_time();
+    bitset_time_used += end_time - begin_time;
+
+    // binary search
+    begin_time = ::oceanbase::common::ObTimeUtility::current_time();
+    for (i = 0; i < l_pos.size(); ++i) {
+      std::lower_bound(l_pos.begin(), l_pos.end(), l_pos.at(i));
+    }
+    end_time = ::oceanbase::common::ObTimeUtility::current_time();
+    bins_time_used += end_time - begin_time;
+  }
+  printf("bitset time: %ld us\n", bitset_time_used);
+  printf("binary search time: %ld us\n", bins_time_used);
+
+}
+
+} // end namespace blocksstable
+} // end namespace oceanbase
+
+int main(int argc, char **argv)
+{
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}