[FEAT MERGE] merge transfer

Co-authored-by: wxhwang <wxhwang@126.com> Co-authored-by: godyangfight <godyangfight@gmail.com> Co-authored-by: Tyshawn <tuyunshan@gmail.com>
2023-06-21 11:42:26 +00:00
parent d06678002e
commit 9dae112952
1280 changed files with 149724 additions and 48813 deletions
--- a/unittest/storage/test_dag_warning_history.cpp
+++ b/unittest/storage/test_dag_warning_history.cpp
@ -17,201 +17,466 @@

 #include "share/scheduler/ob_dag_warning_history_mgr.h"
 #include "share/scheduler/ob_dag_scheduler.h"
+#include "storage/ob_sstable_struct.h"
+#include "observer/omt/ob_tenant_node_balancer.h"

 namespace oceanbase
 {
 using namespace common;
 using namespace storage;
 using namespace share;
+using namespace lib;

 namespace unittest
 {
+static const int64_t INFO_PAGE_SIZE = (1 << 11); // 2KB
 class TestDagWarningHistory : public ::testing::Test
 {
 public:
-  TestDagWarningHistory() {}
-  virtual ~TestDagWarningHistory() {}
+  TestDagWarningHistory()
+    : tenant_id_(1),
+      dag_history_mgr_(nullptr),
+      tenant_base_(tenant_id_)
+  { }
+  ~TestDagWarningHistory() {}
+  void SetUp()
+  {
+    ObUnitInfoGetter::ObTenantConfig unit_config;
+    unit_config.mode_ = lib::Worker::CompatMode::MYSQL;
+    unit_config.tenant_id_ = tenant_id_;
+    TenantUnits units;
+    ASSERT_EQ(OB_SUCCESS, units.push_back(unit_config));
+
+    dag_history_mgr_ = OB_NEW(ObDagWarningHistoryManager, ObModIds::TEST);
+    tenant_base_.set(dag_history_mgr_);
+
+    ObTenantEnv::set_tenant(&tenant_base_);
+    ASSERT_EQ(OB_SUCCESS, tenant_base_.init());
+
+    ObMallocAllocator *ma = ObMallocAllocator::get_instance();
+    ASSERT_EQ(OB_SUCCESS, ma->create_and_add_tenant_allocator(tenant_id_));
+    ASSERT_EQ(OB_SUCCESS, ma->set_tenant_limit(tenant_id_, 1LL << 30));
+  }
+  void TearDown()
+  {
+    dag_history_mgr_->~ObDagWarningHistoryManager();
+    dag_history_mgr_ = nullptr;
+    tenant_base_.destroy();
+    ObTenantEnv::set_tenant(nullptr);
+  }
+private:
+  const uint64_t tenant_id_;
+  ObDagWarningHistoryManager *dag_history_mgr_;
+  ObTenantBase tenant_base_;
+  DISALLOW_COPY_AND_ASSIGN(TestDagWarningHistory);
 };

-TEST_F(TestDagWarningHistory, init)
+class ObBasicDag : public ObIDag
 {
-  ASSERT_EQ(OB_SUCCESS, ObDagWarningHistoryManager::get_instance().init());
-}
+public:
+  ObBasicDag() :
+    ObIDag(ObDagType::DAG_TYPE_MINI_MERGE)
+  {}
+  void init() { is_inited_ = true; }
+  virtual int64_t hash() const {
+    return KEY_START;
+  }
+  virtual bool operator == (const ObIDag &other) const
+  {
+    bool bret = false;
+    if (get_type() == other.get_type()) {
+      const ObBasicDag &dag = static_cast<const ObBasicDag &>(other);
+      bret = dag.id_ == id_;
+    }
+    return bret;
+  }
+  virtual int fill_info_param(compaction::ObIBasicInfoParam *&out_param,
+      ObIAllocator &allocator) const override
+  {
+    int ret = OB_SUCCESS;
+    if (!is_inited_) {
+      ret = OB_NOT_INIT;
+    } else if (OB_FAIL(ADD_DAG_WARN_INFO_PARAM(out_param, allocator, get_type(), 1, 2, "table_id", 10))) {
+      COMMON_LOG(WARN, "fail to add dag warning info param", K(ret));
+    }
+    return ret;
+  }
+  virtual int fill_dag_key(char *buf,const int64_t size) const override { UNUSEDx(buf, size); return OB_SUCCESS; }
+  virtual lib::Worker::CompatMode get_compat_mode() const override
+  { return lib::Worker::CompatMode::MYSQL; }
+  virtual uint64_t get_consumer_group_id() const override
+  { return consumer_group_id_; }
+  INHERIT_TO_STRING_KV("ObIDag", ObIDag, K_(is_inited), K_(type), K(task_list_.get_size()), K_(dag_ret));
+
+private:
+  DISALLOW_COPY_AND_ASSIGN(ObBasicDag);
+
+public:
+  static const int64_t KEY_START = 8888;
+  static const int DAG_RET_START = -4016;
+};
+
+class ObSeqDag : public ObBasicDag
+{
+public:
+  ObSeqDag() :
+    ObBasicDag()
+  {}
+  virtual int64_t hash() const {
+    static int64_t key = KEY_START;
+    return key++;
+  }
+};
+
+class ObComplexDag : public ObBasicDag
+{
+public:
+  ObComplexDag(int64_t hash) :
+    ObBasicDag()
+  {
+    hash_ = hash;
+  }
+  virtual int64_t hash() const {
+    return hash_;
+  }
+  int64_t hash_;
+};

 TEST_F(TestDagWarningHistory, simple_add)
 {
  int ret = OB_SUCCESS;
-  ObDagWarningHistoryManager& manager = ObDagWarningHistoryManager::get_instance();
+  ObDagWarningHistoryManager* manager = MTL(ObDagWarningHistoryManager *);
+  ASSERT_TRUE(nullptr != manager);

-  ObDagWarningInfo *info = NULL;
-  const int64_t key = 8888;
-  ret = manager.alloc_and_add_with_no_lock(key, info);
+  ObBasicDag dag;
+  dag.init();
+  dag.set_dag_ret(ObBasicDag::DAG_RET_START);
+  dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+
+  //not init
+  ret = MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag);
+  ASSERT_NE(OB_SUCCESS, ret);
+  ret = MTL(ObDagWarningHistoryManager *)->init(true, MTL_ID(), "DagWarnHis", INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ret = MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag);
  ASSERT_EQ(OB_SUCCESS, ret);

-  info->dag_ret_ = -4016;
-  info->dag_status_ = ObDagWarningInfo::ODS_WARNING;
-  info->dag_type_ = share::ObDagType::DAG_TYPE_MERGE_EXECUTE;
-  strcpy(info->warning_info_, "table_id=1101710651081571, partition_id=66, mini merge error");
-
-  ObDagWarningInfo *ret_info = NULL;
-  ret = manager.get(key + 1, ret_info);
+  compaction::ObInfoParamBuffer allocator;
+  ObDagWarningInfo ret_info;
+  ret = MTL(ObDagWarningHistoryManager *)->get_with_param(ObBasicDag::KEY_START+1, &ret_info, allocator);
  ASSERT_EQ(OB_HASH_NOT_EXIST, ret);
-  ASSERT_EQ(NULL, ret_info);

-  ret = manager.get(key, ret_info);
+  allocator.reuse();
+  ret = MTL(ObDagWarningHistoryManager *)->get_with_param(ObBasicDag::KEY_START, &ret_info, allocator);
  ASSERT_EQ(OB_SUCCESS, ret);
-  ASSERT_EQ (TRUE, *ret_info == *info);
-  STORAGE_LOG(INFO, "ret", KPC(ret_info));
+  ASSERT_EQ(TRUE, ret_info.dag_ret_ == ObBasicDag::DAG_RET_START);
+  STORAGE_LOG(DEBUG, "", K(ret_info));
+  ASSERT_EQ(TRUE, ret_info.tenant_id_ == tenant_id_);

-  // duplicated key
-  ret = manager.alloc_and_add_with_no_lock(key, info);
-  ASSERT_EQ(OB_HASH_EXIST, ret);
+  char comment[common::OB_DAG_WARNING_INFO_LENGTH];
+  memset(comment, '\0', sizeof(comment));
+  allocator.reuse();
+  ret = MTL(ObDagWarningHistoryManager *)->get_with_param(ObBasicDag::KEY_START, &ret_info, allocator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ (TRUE, ret_info.dag_ret_ == ObBasicDag::DAG_RET_START);
+  memset(comment, '\0', sizeof(comment));
+  ASSERT_EQ(OB_SUCCESS, ret_info.info_param_->fill_comment(comment, sizeof(comment)));
+  STORAGE_LOG(DEBUG, "comment", K(comment));
 }

-TEST_F(TestDagWarningHistory, simple_del_with_no_lock)
+TEST_F(TestDagWarningHistory, simple_del)
 {
  int ret = OB_SUCCESS;
-  ObDagWarningHistoryManager& manager = ObDagWarningHistoryManager::get_instance();
-  manager.clear();

-  ObDagWarningInfo *info = NULL;
-  const int64_t key = 8888;
-  ASSERT_EQ(OB_SUCCESS, manager.alloc_and_add_with_no_lock(key, info));
-  info->dag_ret_ = -4016;
-  info->dag_status_ = ObDagWarningInfo::ODS_WARNING;
-  info->dag_type_ = share::ObDagType::DAG_TYPE_MERGE_EXECUTE;
-  strcpy(info->warning_info_, "table_id=1101710651081571, partition_id=66, mini merge error");
+  ObDagWarningHistoryManager* manager = MTL(ObDagWarningHistoryManager *);
+  ASSERT_TRUE(nullptr != manager);
+  ret = MTL(ObDagWarningHistoryManager *)->init(true, MTL_ID(), "DagWarnHis", INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);

-  ASSERT_EQ(OB_HASH_NOT_EXIST, manager.del_with_no_lock(key + 1));
+  ObBasicDag dag;
+  dag.init();
+  dag.set_dag_ret(ObBasicDag::DAG_RET_START);
+  dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+  ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
+  ASSERT_EQ(OB_HASH_NOT_EXIST, MTL(ObDagWarningHistoryManager *)->delete_info(ObBasicDag::KEY_START + 1));
+  ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->delete_info(ObBasicDag::KEY_START));
+  ASSERT_EQ(1, MTL(ObDagWarningHistoryManager *)->size());

-  ASSERT_EQ(OB_SUCCESS, manager.del_with_no_lock(key));
+  compaction::ObInfoParamBuffer allocator;
+  ObDagWarningInfo ret_info;
+  ret = MTL(ObDagWarningHistoryManager *)->get_with_param(ObBasicDag::KEY_START, &ret_info, allocator);
+  ASSERT_EQ(OB_HASH_NOT_EXIST, ret);

-  ObDagWarningInfo *ret_info = NULL;
-  ret = manager.get(key, ret_info);
+  ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
+  compaction::ObIDiagnoseInfoMgr::Iterator iterator;
+  ret = MTL(ObDagWarningHistoryManager *)->open_iter(iterator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->delete_info(ObBasicDag::KEY_START));
+  // delete_info only delete info from map, there is still 2 info in list
+  ASSERT_EQ(2, MTL(ObDagWarningHistoryManager *)->size());
+  ASSERT_EQ(OB_ITER_END, iterator.get_next(&ret_info, nullptr, 0));
+
+  allocator.reuse();
+  ret = MTL(ObDagWarningHistoryManager *)->get_with_param(ObBasicDag::KEY_START, &ret_info, allocator);
  ASSERT_EQ(OB_HASH_NOT_EXIST, ret);
 }

 TEST_F(TestDagWarningHistory, simple_loop_get)
 {
  int ret = OB_SUCCESS;
-  ObDagWarningHistoryManager& manager = ObDagWarningHistoryManager::get_instance();
-  manager.clear();
-  const int64_t tenant_id = 100;

-  ObDagWarningInfo basic_info;
-  basic_info.tenant_id_ = tenant_id;
-  basic_info.dag_ret_ = -4016;
-  basic_info.dag_status_ = ObDagWarningInfo::ODS_WARNING;
-  basic_info.dag_type_ = share::ObDagType::DAG_TYPE_MERGE_EXECUTE;
-  strcpy(basic_info.warning_info_, "table_id=1101710651081571, partition_id=66, mini merge error");
+  ObDagWarningHistoryManager* manager = MTL(ObDagWarningHistoryManager *);
+  ASSERT_TRUE(nullptr != manager);
+  ret = MTL(ObDagWarningHistoryManager *)->init(true, MTL_ID(), "DagWarnHis", INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);

-  const int64_t max_cnt = 20;
-  ObDagWarningInfo *info = NULL;
-  int64_t key = 0;
+  const int64_t max_cnt = 4000;
  for (int i = 0; i < max_cnt; ++i) {
-    key = 8888 + i;
-    ASSERT_EQ(OB_SUCCESS, manager.alloc_and_add_with_no_lock(key, info));
-    info->tenant_id_ = tenant_id;
-    info->dag_ret_ = -4016 + i;
-    info->dag_status_ = ObDagWarningInfo::ODS_WARNING;
-    info->dag_type_ = share::ObDagType::DAG_TYPE_MERGE_EXECUTE;
-    strcpy(info->warning_info_, "table_id=1101710651081571, partition_id=66, mini merge error");
+    ObSeqDag dag;
+    dag.init();
+    dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+    dag.set_dag_ret(ObBasicDag::DAG_RET_START + i);
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
  }
-  ObDagWarningInfoIterator iterator;
-  iterator.open(tenant_id);
+
+  ASSERT_EQ(max_cnt, MTL(ObDagWarningHistoryManager *)->size());
+
+  compaction::ObIDiagnoseInfoMgr::Iterator iterator;
+  ret = MTL(ObDagWarningHistoryManager *)->open_iter(iterator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
  ObDagWarningInfo read_info;
+  char comment[common::OB_DAG_WARNING_INFO_LENGTH];
  int i = 0;
  while (OB_SUCC(ret)) {
-    if (OB_FAIL(iterator.get_next_info(read_info))) {
+    if (OB_FAIL(iterator.get_next(&read_info, comment, sizeof(comment)))) {
      ASSERT_EQ(OB_ITER_END, ret);
    } else {
-      basic_info.dag_ret_ = -4016 + i;
-      STORAGE_LOG(DEBUG, "print info", K(ret), K(read_info), K(basic_info));
-      ASSERT_EQ(TRUE, read_info == basic_info);
+      ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i));
      ++i;
    }
  }

-  for (int i = 0; i < max_cnt; i += 2) {
-    key = 8888 + i;
-    ASSERT_EQ(OB_SUCCESS, manager.del_with_no_lock(key));
+  int64_t key = 0;
+  const int64_t del_cnt = 3000;
+  for (int i = 0; i < del_cnt; i += 1) {
+    key = ObBasicDag::KEY_START + i;
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->delete_info(key));
  }

  iterator.reset();
-  iterator.open(tenant_id);
-  i = 0;
+  ret = MTL(ObDagWarningHistoryManager *)->open_iter(iterator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  i = del_cnt;
  while (OB_SUCC(ret)) {
-    if (OB_SUCC(iterator.get_next_info(read_info))) {
-      basic_info.dag_ret_ = -4016 + i;
-      ASSERT_EQ(TRUE, read_info == basic_info);
-      STORAGE_LOG(DEBUG, "print info", K(ret), K(read_info), KPC(info));
-      i += 2;
+    if (OB_SUCC(iterator.get_next(&read_info, nullptr, 0))) {
+      ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i));
+      i += 1;
    }
  }

-  manager.clear();
-  ASSERT_EQ(0, manager.size());
+  MTL(ObDagWarningHistoryManager *)->clear();
+  ASSERT_EQ(0, MTL(ObDagWarningHistoryManager *)->size());
 }

-
-TEST_F(TestDagWarningHistory, test_rebuild)
+TEST_F(TestDagWarningHistory, resize)
 {
  int ret = OB_SUCCESS;
-  ObDagWarningHistoryManager& manager = ObDagWarningHistoryManager::get_instance();
-  manager.clear();

-  const int64_t tenant_id = 100;
+  ObDagWarningHistoryManager* manager = MTL(ObDagWarningHistoryManager *);
+  ASSERT_TRUE(nullptr != manager);
+  ret = MTL(ObDagWarningHistoryManager *)->init(true, MTL_ID(), "DagWarnHis", INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
  const int64_t max_cnt = 20;
-  ObDagWarningInfo basic_info;
-  basic_info.tenant_id_ = tenant_id;
-  basic_info.dag_ret_ = -4016;
-  basic_info.dag_status_ = ObDagWarningInfo::ODS_WARNING;
-  basic_info.dag_type_ = share::ObDagType::DAG_TYPE_MERGE_EXECUTE;
-  strcpy(basic_info.warning_info_, "table_id=1101710651081571, partition_id=66, mini merge error");
-
-  ObDagWarningInfo *info = NULL;
-  int64_t key = 0;
  for (int i = 0; i < max_cnt; ++i) {
-    key = 8888 + i;
-    ASSERT_EQ(OB_SUCCESS, manager.alloc_and_add_with_no_lock(key, info));
-    info->tenant_id_ = tenant_id;
-    info->dag_ret_ = -4016 + i;
-    info->dag_status_ = ObDagWarningInfo::ODS_WARNING;
-    info->dag_type_ = share::ObDagType::DAG_TYPE_MERGE_EXECUTE;
-    strcpy(info->warning_info_, "table_id=1101710651081571, partition_id=66, mini merge error");
-    STORAGE_LOG(DEBUG, "print info", K(ret), K(i), K(key), KPC(info));
+    ObSeqDag dag;
+    dag.init();
+    dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+    dag.set_dag_ret(ObBasicDag::DAG_RET_START + i);
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
  }

-  ASSERT_EQ(max_cnt, manager.size());
+  ASSERT_EQ(max_cnt, MTL(ObDagWarningHistoryManager *)->size());

-  for (int i = 0; i < max_cnt; i += 2) {
-    key = 8888 + i;
-    ASSERT_EQ(OB_SUCCESS, manager.del_with_no_lock(key));
-  }
+  // every info is 240 bytes, each page contains 7 info
+  // 20 infos are in 3 pages (7 7 6), set_max will left 6 info (6 * 240 < 4096 * 0.4), means 1 page (6)
+  ret = MTL(ObDagWarningHistoryManager *)->set_max(2 * INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(6, MTL(ObDagWarningHistoryManager *)->size());

-  ASSERT_EQ(max_cnt / 2, manager.size());
+  ret = MTL(ObDagWarningHistoryManager *)->set_max(3 * INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(6, MTL(ObDagWarningHistoryManager *)->size());
+
+  compaction::ObIDiagnoseInfoMgr::Iterator iterator;
+  ret = MTL(ObDagWarningHistoryManager *)->open_iter(iterator);
+  ASSERT_EQ(OB_SUCCESS, ret);

-  ObDagWarningInfoIterator iterator;
-  iterator.open(tenant_id);
  ObDagWarningInfo read_info;
-  int i = 1;
+  char comment[common::OB_DAG_WARNING_INFO_LENGTH];
+  int i = 14;
  while (OB_SUCC(ret)) {
-    if (OB_SUCC(iterator.get_next_info(read_info))) {
-      basic_info.dag_ret_ = -4016 + i;
-      STORAGE_LOG(DEBUG, "print info", K(ret), K(read_info), K(basic_info));
-      ASSERT_EQ(TRUE, read_info == basic_info);
-      i += 2;
+    if (OB_FAIL(iterator.get_next(&read_info, comment, sizeof(comment)))) {
+      ASSERT_EQ(OB_ITER_END, ret);
+    } else {
+      ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i));
+      ++i;
+    }
+  }
+}
+
+TEST_F(TestDagWarningHistory, gc_info)
+{
+  int ret = OB_SUCCESS;
+
+  ObDagWarningHistoryManager* manager = MTL(ObDagWarningHistoryManager *);
+  ASSERT_TRUE(nullptr != manager);
+  ret = MTL(ObDagWarningHistoryManager *)->init(true, MTL_ID(), "DagWarnHis", INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ret = MTL(ObDagWarningHistoryManager *)->set_max(10 * INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  int64_t hash_value = ObBasicDag::KEY_START;
+  const int64_t max_cnt = 69;
+  for (int i = 0; i < max_cnt; ++i) {
+    ObComplexDag dag(hash_value++);
+    dag.init();
+    dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+    dag.set_dag_ret(ObBasicDag::DAG_RET_START + i);
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
+  }
+  // 9 page full, 1 page contain 6 info (7 7 7 7 7 7 7 7 7 6)
+  ASSERT_EQ(max_cnt, MTL(ObDagWarningHistoryManager *)->size());
+
+  for (int i = 0; i < 30; ++i) {
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->delete_info(ObBasicDag::KEY_START+i));
+  }
+
+  // every info is 240 bytes, each page contains 7 info
+  // 69 * 240 > 20480 * 0.8 // after gc, left 34 info (34 * 240 < 20480 * 0.4), means 1 page (7 7 7 7 6)
+  ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->gc_info());
+  ASSERT_EQ(34, MTL(ObDagWarningHistoryManager *)->size());
+}
+
+TEST_F(TestDagWarningHistory, complex_test)
+{
+  int ret = OB_SUCCESS;
+
+  ObDagWarningHistoryManager* manager = MTL(ObDagWarningHistoryManager *);
+  ASSERT_TRUE(nullptr != manager);
+  ret = MTL(ObDagWarningHistoryManager *)->init(true, MTL_ID(), "DagWarnHis", INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ret = MTL(ObDagWarningHistoryManager *)->set_max(2 * INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  int64_t hash_value = ObBasicDag::KEY_START;
+  const int64_t max_cnt = 20;
+  for (int i = 0; i < max_cnt; ++i) {
+    ObComplexDag dag(hash_value++);
+    dag.init();
+    dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+    dag.set_dag_ret(ObBasicDag::DAG_RET_START + i);
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
+  }
+  // every info is 240 bytes, each page contains 7 info
+  // 10 info will be purged , left 2 page (4 6)
+  ASSERT_EQ(10, MTL(ObDagWarningHistoryManager *)->size());
+
+  compaction::ObIDiagnoseInfoMgr::Iterator iterator;
+  ret = MTL(ObDagWarningHistoryManager *)->open_iter(iterator);
+  ASSERT_EQ(OB_SUCCESS, ret);
+
+  ObDagWarningInfo read_info;
+  char comment[common::OB_DAG_WARNING_INFO_LENGTH];
+  // the first 10 info have been purged
+  int i = 10;
+  while (OB_SUCC(ret)) {
+    if (OB_FAIL(iterator.get_next(&read_info, comment, sizeof(comment)))) {
+      ASSERT_EQ(OB_ITER_END, ret);
+    } else {
+      ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i));
+      ++i;
    }
  }

-  manager.clear();
-  ASSERT_EQ(0, manager.size());
-}
+  // test when two iter is accessing info pool
+  compaction::ObIDiagnoseInfoMgr::Iterator iterator1;
+  compaction::ObIDiagnoseInfoMgr::Iterator iterator2;
+  ret = MTL(ObDagWarningHistoryManager *)->open_iter(iterator1);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ret = MTL(ObDagWarningHistoryManager *)->open_iter(iterator2);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  i = 10;
+  ASSERT_EQ(OB_SUCCESS, iterator1.get_next(&read_info, comment, sizeof(comment)));
+  ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i++));
+  ASSERT_EQ(OB_SUCCESS, iterator1.get_next(&read_info, comment, sizeof(comment)));
+  ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i++));

-TEST_F(TestDagWarningHistory, simple_destory)
-{
-  ObDagWarningHistoryManager& manager = ObDagWarningHistoryManager::get_instance();
-  manager.destroy();
+  i = 10;
+  ASSERT_EQ(OB_SUCCESS, iterator2.get_next(&read_info, comment, sizeof(comment)));
+  ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i++));
+  ASSERT_EQ(OB_SUCCESS, iterator2.get_next(&read_info, comment, sizeof(comment)));
+  ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i++));
+  ASSERT_EQ(OB_SUCCESS, iterator2.get_next(&read_info, comment, sizeof(comment)));
+  ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + i++));
+
+  i = max_cnt;
+  {
+    ObComplexDag dag(hash_value++);
+    dag.init();
+    dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+    dag.set_dag_ret(ObBasicDag::DAG_RET_START + i++);
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
+    ASSERT_EQ(11, MTL(ObDagWarningHistoryManager *)->size());
+  }
+  {
+    ObComplexDag dag(hash_value++);
+    dag.init();
+    dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+    dag.set_dag_ret(ObBasicDag::DAG_RET_START + i++);
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
+    ASSERT_EQ(2, MTL(ObDagWarningHistoryManager *)->size());
+  }
+
+  // let the iterator1 in iter_end
+  int j = 20;
+  while (OB_SUCC(ret)) {
+    if (OB_FAIL(iterator1.get_next(&read_info, comment, sizeof(comment)))) {
+      ASSERT_EQ(OB_ITER_END, ret);
+    } else {
+      ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + j));
+      ++j;
+    }
+  }
+
+  // before set_max (1 1), after set_max (1)
+  ret = MTL(ObDagWarningHistoryManager *)->set_max(INFO_PAGE_SIZE);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(1, MTL(ObDagWarningHistoryManager *)->size());
+
+  {
+    ObComplexDag dag(hash_value++);
+    dag.init();
+    dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+    dag.set_dag_ret(ObBasicDag::DAG_RET_START + i++);
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
+    ASSERT_EQ(2, MTL(ObDagWarningHistoryManager *)->size());
+  }
+
+  ASSERT_EQ(OB_ITER_END, iterator1.get_next(&read_info, comment, sizeof(comment)));
+  ASSERT_EQ(OB_SUCCESS, iterator2.get_next(&read_info, comment, sizeof(comment)));
+  ASSERT_EQ(TRUE, read_info.dag_ret_ == (ObBasicDag::DAG_RET_START + 21));
+
+  // test purge cuz add when there are some deleted info on list
+  ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->delete_info(hash_value-1));
+  for (int i = 0; i < max_cnt; ++i) {
+    ObComplexDag dag(hash_value++);
+    dag.init();
+    dag.set_dag_status(ObBasicDag::ObDagStatus::DAG_STATUS_ABORT);
+    dag.set_dag_ret(ObBasicDag::DAG_RET_START + i);
+    ASSERT_EQ(OB_SUCCESS, MTL(ObDagWarningHistoryManager *)->add_dag_warning_info(&dag));
+  }
 }

 }  // end namespace unittest