refactor ObCompactionTimeGuard to process failed event

unittest/share/CMakeLists.txt

@@ -103,3 +103,4 @@ add_subdirectory(location_cache)
 add_subdirectory(detect)
 add_subdirectory(vector)
 add_subdirectory(index_usage)
+add_subdirectory(compaction)

unittest/share/compaction/CMakeLists.txt

@@ -0,0 +1 @@
+storage_unittest(test_compaction_time_guard)

unittest/share/compaction/test_compaction_time_guard.cpp

@@ -0,0 +1,160 @@
+/**
+ * Copyright (c) 2024 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>
+#define USING_LOG_PREFIX STORAGE
+#define private public
+#define protected public
+
+#include "share/compaction/ob_compaction_time_guard.h"
+
+namespace oceanbase
+{
+namespace unittest
+{
+
+using namespace compaction;
+
+class TestCompactionTimeGuard : public ::testing::Test
+{
+public:
+  TestCompactionTimeGuard() {}
+  virtual ~TestCompactionTimeGuard() {}
+};
+
+TEST_F(TestCompactionTimeGuard, basic_time_guard)
+{
+  const uint16_t CAPACITY = ObCompactionTimeGuard::CAPACITY;
+  const uint64_t current_time = common::ObTimeUtility::current_time();
+  ObCompactionTimeGuard time_guard;
+  // construction
+  ASSERT_EQ(CAPACITY, time_guard.capacity_);
+  ASSERT_EQ(0, time_guard.size_);
+  ASSERT_TRUE(time_guard.is_empty());
+  time_guard.set_last_click_ts(current_time);
+  ASSERT_EQ(current_time, time_guard.add_time_);
+  ASSERT_EQ(current_time, time_guard.last_click_ts_);
+
+  // click
+  ASSERT_TRUE(time_guard.click(CAPACITY));
+  ASSERT_TRUE(time_guard.is_empty());
+  for (uint16_t i = 0; i < CAPACITY; ++i) {
+    ASSERT_TRUE(time_guard.click(i));
+    ASSERT_EQ(time_guard.size_, i + 1);
+    ASSERT_EQ(time_guard.event_times_[i], time_guard.get_specified_cost_time(i));
+  }
+  ASSERT_TRUE(time_guard.click(CAPACITY + 1));
+  ASSERT_EQ(CAPACITY, time_guard.size_);
+
+  // add and assignment
+  ObCompactionTimeGuard other_guard;
+  ASSERT_EQ(CAPACITY, other_guard.capacity_);
+  ASSERT_TRUE(other_guard.is_empty());
+  for (uint16_t i = 0; i < CAPACITY; ++i) {
+    ASSERT_EQ(0, other_guard.event_times_[i]);
+  }
+  other_guard = time_guard;
+  ASSERT_EQ(time_guard.guard_type_, other_guard.guard_type_);
+  ASSERT_EQ(time_guard.warn_threshold_, other_guard.warn_threshold_);
+  ASSERT_EQ(time_guard.capacity_, other_guard.capacity_);
+  ASSERT_EQ(time_guard.size_, other_guard.size_);
+  ASSERT_EQ(time_guard.last_click_ts_, other_guard.last_click_ts_);
+  ASSERT_EQ(time_guard.add_time_, other_guard.add_time_);
+  for (uint16_t i = 0; i < CAPACITY; ++i) {
+    ASSERT_EQ(time_guard.event_times_[i], other_guard.event_times_[i]);
+  }
+
+  // add time guard
+  ObCompactionTimeGuard summary_guard;
+  for (uint16_t i = 0; i < 2 * CAPACITY; i++) {
+    summary_guard.add_time_guard(time_guard);
+    summary_guard.add_time_guard(other_guard);
+  }
+  for (uint16_t i = 0; i < CAPACITY; ++i) {
+    ASSERT_EQ(summary_guard.event_times_[i], time_guard.event_times_[i] * 4 * CAPACITY);
+    ASSERT_EQ(summary_guard.event_times_[i], other_guard.event_times_[i] *  4 * CAPACITY);
+  }
+
+  // reuse
+  ObCompactionTimeGuard* guards[3] = {&time_guard, &other_guard, &summary_guard};
+  for (int i = 0; i < 3; i++) {
+    guards[i]->reuse();
+    ASSERT_TRUE(guards[i]->is_empty());
+    ASSERT_EQ(CAPACITY, guards[i]->capacity_);
+    ASSERT_EQ(0, guards[i]->size_);
+    for (uint16_t j = 0; j < CAPACITY; ++j) {
+      ASSERT_EQ(0, guards[i]->event_times_[j]);
+    }
+  }
+  // out of order click and add time guard with diffrent size_
+  time_guard.click(0);
+  ASSERT_EQ(1, time_guard.size_);
+  time_guard.click(2);
+  ASSERT_EQ(3, time_guard.size_);
+  time_guard.click(1);
+  ASSERT_EQ(3, time_guard.size_);
+  time_guard.click(10);
+  ASSERT_EQ(11, time_guard.size_);
+  other_guard.click(6);
+  ASSERT_EQ(7, other_guard.size_);
+  summary_guard.add_time_guard(other_guard);
+  ASSERT_EQ(summary_guard.size_, other_guard.size_);
+  summary_guard.add_time_guard(time_guard);
+  ASSERT_EQ(summary_guard.size_, time_guard.size_);
+}
+
+TEST_F(TestCompactionTimeGuard, time_guard_to_string)
+{
+  ObStorageCompactionTimeGuard storage_guard;
+  for (uint16_t i = 0; i < ObStorageCompactionTimeGuard::COMPACTION_EVENT_MAX; i++) {
+    storage_guard.click(i);
+    storage_guard.event_times_[i] += ObStorageCompactionTimeGuard::COMPACTION_SHOW_TIME_THRESHOLD;
+    ASSERT_EQ(i + 1, storage_guard.size_);
+  }
+  ASSERT_EQ(ObStorageCompactionTimeGuard::COMPACTION_EVENT_MAX, storage_guard.size_);
+  storage_guard.event_times_[ObStorageCompactionTimeGuard::DAG_WAIT_TO_SCHEDULE] += 2 * ObStorageCompactionTimeGuard::COMPACTION_SHOW_TIME_THRESHOLD;
+  storage_guard.event_times_[ObStorageCompactionTimeGuard::DAG_FINISH] += 2 * ObCompactionTimeGuard::WARN_THRESHOLD;
+  STORAGE_LOG(INFO, "storage guard is", K(storage_guard));
+
+  ObRSCompactionTimeGuard rs_guard;
+  for (uint16_t i = 0; i < ObRSCompactionTimeGuard::COMPACTION_EVENT_MAX; i++) {
+    rs_guard.click(i);
+    rs_guard.event_times_[i] += 10 * i;
+    ASSERT_EQ(i + 1, rs_guard.size_);
+  }
+  ASSERT_EQ(ObRSCompactionTimeGuard::COMPACTION_EVENT_MAX, rs_guard.size_);
+  rs_guard.event_times_[ObRSCompactionTimeGuard::CKM_VERIFICATION] += 2 * ObCompactionTimeGuard::WARN_THRESHOLD;
+  STORAGE_LOG(INFO, "rs guard is", K(rs_guard));
+
+  ObCompactionScheduleTimeGuard schedule_guard;
+  for (uint16_t i = 0; i < ObCompactionScheduleTimeGuard::COMPACTION_EVENT_MAX; i++) {
+    schedule_guard.click(i);
+    schedule_guard.event_times_[i] += 10 * i;
+    ASSERT_EQ(i + 1, schedule_guard.size_);
+  }
+  ASSERT_EQ(ObCompactionScheduleTimeGuard::COMPACTION_EVENT_MAX, schedule_guard.size_);
+  schedule_guard.event_times_[ObCompactionScheduleTimeGuard::SCHEDULER_NEXT_ROUND] += 2 * ObCompactionTimeGuard::WARN_THRESHOLD;
+  STORAGE_LOG(INFO, "schedule guard is", K(schedule_guard));
+}
+
+} // namespace unittest
+} // namespace oceanbase
+
+int main(int argc, char **argv)
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  system("rm -f test_compaction_time_guard.log*");
+  OB_LOGGER.set_file_name("test_compaction_time_guard.log");
+  OB_LOGGER.set_log_level("INFO");
+  OB_LOGGER.set_max_file_size(256*1024*1024);
+  return RUN_ALL_TESTS();
+}