[BugFix] Fix sanity core of __all_virtual_minor_freeze_info

mittest/simple_server/test_ob_minor_freeze.cpp

@@ -70,6 +70,7 @@ public:
   void tablet_freeze_for_replace_tablet_meta();
   void insert_and_freeze();
   void empty_memtable_flush();
+  void all_virtual_minor_freeze_info();
 private:
   int insert_thread_num_ = 3;
   int insert_num_ = 200000;
@@ -141,6 +142,26 @@ void ObMinorFreezeTest::get_tablet_id_and_ls_id()
   ASSERT_EQ(true, ls_id_.is_valid());
 }
 
+void ObMinorFreezeTest::all_virtual_minor_freeze_info()
+{
+  int ret = OB_SUCCESS;
+  common::ObMySQLProxy &sql_proxy = get_curr_simple_server().get_sql_proxy();
+  const int64_t start_time = ObTimeUtility::current_time();
+
+  OB_LOG(INFO, "test __all_virtual_minor_freeze_info");
+  while (ObTimeUtility::current_time() - start_time <= freeze_duration_) {
+    ObSqlString sql;
+    ASSERT_EQ(OB_SUCCESS, sql.assign_fmt("select * from oceanbase.__all_virtual_minor_freeze_info where ls_id = %ld", ls_id_.id()));
+    SMART_VAR(ObMySQLProxy::MySQLResult, res) {
+      ASSERT_EQ(OB_SUCCESS, sql_proxy.read(res, sql.ptr()));
+      sqlclient::ObMySQLResult *result = res.get_result();
+      ASSERT_NE(nullptr, result);
+      ASSERT_EQ(OB_SUCCESS, result->next());
+    }
+  }
+
+}
+
 void ObMinorFreezeTest::get_ls()
 {
   OB_LOG(INFO, "get_ls");

src/observer/virtual_table/ob_all_virtual_minor_freeze_info.cpp

@@ -108,6 +108,7 @@ int ObAllVirtualMinorFreezeInfo::process_curr_tenant(ObNewRow *&row)
   int ret = OB_SUCCESS;
   ObLS *ls = nullptr;
   ObFreezer *freezer = nullptr;
+  ObFreezerStat freeze_stat;
   if (NULL == allocator_) {
     ret = OB_NOT_INIT;
     SERVER_LOG(WARN, "allocator_ shouldn't be NULL", K(allocator_), K(ret));
@@ -122,8 +123,10 @@ int ObAllVirtualMinorFreezeInfo::process_curr_tenant(ObNewRow *&row)
     ret = OB_ERR_UNEXPECTED;
     SERVER_LOG(WARN, "ls shouldn't NULL here", K(ret));
   } else if (FALSE_IT(freezer = ls->get_freezer())) {
-  } else if (freezer->get_stat().is_valid()) {
+  } else if (!(freezer->get_stat().is_valid())) {
-    ObFreezerStat& freeze_stat = freezer->get_stat();
+  } else if (OB_FAIL(freezer->get_stat().deep_copy_to(freeze_stat))) {
+    SERVER_LOG(WARN, "fail to deep copy", K(ret));
+  } else {
     int64_t freeze_clock = 0;
     const int64_t col_count = output_column_ids_.count();
     for (int64_t i = 0; OB_SUCC(ret) && i < col_count; ++i) {
@@ -153,37 +156,37 @@ int ObAllVirtualMinorFreezeInfo::process_curr_tenant(ObNewRow *&row)
           break;
         case OB_APP_MIN_COLUMN_ID + 4:
           // tablet_id
-          cur_row_.cells_[i].set_int(freeze_stat.tablet_id_.id());
+          cur_row_.cells_[i].set_int(freeze_stat.get_tablet_id().id());
           break;
         case OB_APP_MIN_COLUMN_ID + 5:
           // is_force
-          cur_row_.cells_[i].set_varchar(freeze_stat.is_force_ ? "YES" : "NO");
+          cur_row_.cells_[i].set_varchar(freeze_stat.get_is_force() ? "YES" : "NO");
           cur_row_.cells_[i].set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
           break;
         case OB_APP_MIN_COLUMN_ID + 6:
           // freeze_clock
-          freeze_clock = freezer->get_freeze_clock();
+          freeze_clock = freeze_stat.get_freeze_clock();
           cur_row_.cells_[i].set_int(freeze_clock);
           break;
         case OB_APP_MIN_COLUMN_ID + 7:
           // freeze_snapshot_version
-          cur_row_.cells_[i].set_int(freezer->get_freeze_snapshot_version().get_val_for_inner_table_field());
+          cur_row_.cells_[i].set_int(freeze_stat.get_freeze_snapshot_version().get_val_for_inner_table_field());
           break;
         case OB_APP_MIN_COLUMN_ID + 8:
           // start_time
-          cur_row_.cells_[i].set_timestamp(freeze_stat.start_time_);
+          cur_row_.cells_[i].set_timestamp(freeze_stat.get_start_time());
           break;
         case OB_APP_MIN_COLUMN_ID + 9:
           // end_time
-          cur_row_.cells_[i].set_timestamp(freeze_stat.end_time_);
+          cur_row_.cells_[i].set_timestamp(freeze_stat.get_end_time());
           break;
         case OB_APP_MIN_COLUMN_ID + 10:
           // ret_code
-          cur_row_.cells_[i].set_int(freeze_stat.ret_code_);
+          cur_row_.cells_[i].set_int(freeze_stat.get_ret_code());
           break;
         case OB_APP_MIN_COLUMN_ID + 11:
           // state
-          switch (freeze_stat.state_) {
+          switch (freeze_stat.get_state()) {
             case ObFreezeState::INVALID:
               cur_row_.cells_[i].set_varchar("INVALID");
               break;

src/storage/ls/ob_freezer.cpp

@@ -100,13 +100,14 @@ ObFreezerStat::ObFreezerStat()
   : tablet_id_(),
     is_force_(false),
     state_(ObFreezeState::INVALID),
+    freeze_clock_(0),
     start_time_(0),
     end_time_(INT64_MAX),
     ret_code_(-1),
+    freeze_snapshot_version_(),
     diagnose_info_(),
     memtables_info_(),
-    memtables_info_lock_(),
+    lock_()
-    diagnose_info_lock_()
 {}
 
 ObFreezerStat::~ObFreezerStat()
@@ -116,21 +117,22 @@ ObFreezerStat::~ObFreezerStat()
 
 void ObFreezerStat::reset()
 {
-  ObSpinLockGuard memtables_info_guard(memtables_info_lock_);
+  ObSpinLockGuard guard(lock_);
-  ObSpinLockGuard diagnose_info_guard(diagnose_info_lock_);
   tablet_id_.reset();
   is_force_ = false;
   state_ = ObFreezeState::INVALID;
+  freeze_clock_ = 0;
   start_time_ = 0;
   end_time_ = INT64_MAX;
   ret_code_ = -1;
+  freeze_snapshot_version_.reset();
   diagnose_info_.reset();
   memtables_info_.reset();
 }
 
 bool ObFreezerStat::is_valid()
 {
-  return start_time_ > 0 && state_ > ObFreezeState::INVALID;
+  return get_start_time() > 0 && get_state() > ObFreezeState::INVALID;
 }
 
 int ObFreezerStat::add_memtable_info(const ObTabletID &tablet_id,
@@ -143,7 +145,7 @@ int ObFreezerStat::add_memtable_info(const ObTabletID &tablet_id,
 {
   int ret = OB_SUCCESS;
 
-  ObSpinLockGuard guard(memtables_info_lock_);
+  ObSpinLockGuard guard(lock_);
   if (memtables_info_.count() < FROZEN_MEMTABLE_INFO_CNT) {
     ObFrozenMemtableInfo memtable_info(tablet_id,
                                        start_scn,
@@ -164,7 +166,7 @@ int ObFreezerStat::remove_memtable_info(const ObTabletID &tablet_id)
 {
   int ret = OB_SUCCESS;
 
-  ObSpinLockGuard guard(memtables_info_lock_);
+  ObSpinLockGuard guard(lock_);
   for (int i = 0; i < memtables_info_.count(); ++i) {
     if (tablet_id == memtables_info_[i].tablet_id_ && OB_FAIL(memtables_info_.remove(i))) {
       TRANS_LOG(WARN, "fail to remove from memtable_info", K(ret), K(tablet_id));
@@ -179,7 +181,7 @@ int ObFreezerStat::get_memtables_info(common::ObSArray<ObFrozenMemtableInfo> &me
 {
   int ret = OB_SUCCESS;
 
-  ObSpinLockGuard guard(memtables_info_lock_);
+  ObSpinLockGuard guard(lock_);
   if (OB_FAIL(memtables_info.assign(memtables_info_))) {
     TRANS_LOG(WARN, "fail to assign", K(ret));
   }
@@ -187,17 +189,35 @@ int ObFreezerStat::get_memtables_info(common::ObSArray<ObFrozenMemtableInfo> &me
   return ret;
 }
 
-void ObFreezerStat::add_diagnose_info(const ObString &str)
+int ObFreezerStat::set_memtables_info(const common::ObSArray<ObFrozenMemtableInfo> &memtables_info)
 {
-  ObSpinLockGuard guard(diagnose_info_lock_);
+  int ret = OB_SUCCESS;
-  diagnose_info_.assign(str);
+
+  ObSpinLockGuard guard(lock_);
+  if (OB_FAIL(memtables_info_.assign(memtables_info))) {
+    TRANS_LOG(WARN, "fail to assign", K(ret));
+  }
+
+  return ret;
+}
+
+int ObFreezerStat::add_diagnose_info(const ObString &str)
+{
+  int ret = OB_SUCCESS;
+
+  ObSpinLockGuard guard(lock_);
+  if (OB_FAIL(diagnose_info_.assign(str))) {
+    TRANS_LOG(WARN, "fail to add diagnose_info");
+  }
+
+  return ret;
 }
 
 int ObFreezerStat::get_diagnose_info(ObStringHolder &diagnose_info)
 {
   int ret = OB_SUCCESS;
 
-  ObSpinLockGuard guard(diagnose_info_lock_);
+  ObSpinLockGuard guard(lock_);
   if (OB_FAIL(diagnose_info.assign(diagnose_info_))) {
     TRANS_LOG(WARN, "fail to assign diagnose_info", K(ret));
   }
@@ -205,6 +225,122 @@ int ObFreezerStat::get_diagnose_info(ObStringHolder &diagnose_info)
   return ret;
 }
 
+void ObFreezerStat::set_freeze_clock(const int64_t freeze_clock)
+{
+  ObSpinLockGuard guard(lock_);
+  freeze_clock_ = freeze_clock;
+}
+
+int64_t ObFreezerStat::get_freeze_clock()
+{
+  ObSpinLockGuard guard(lock_);
+  return freeze_clock_;
+}
+
+void ObFreezerStat::set_tablet_id(const ObTabletID &tablet_id)
+{
+  ObSpinLockGuard guard(lock_);
+  tablet_id_ = tablet_id;
+}
+
+ObTabletID ObFreezerStat::get_tablet_id()
+{
+  ObSpinLockGuard guard(lock_);
+  return tablet_id_;
+}
+
+void ObFreezerStat::set_is_force(bool is_force)
+{
+  ObSpinLockGuard guard(lock_);
+  is_force_ = is_force;
+}
+
+bool ObFreezerStat::get_is_force()
+{
+  ObSpinLockGuard guard(lock_);
+  return is_force_;
+}
+
+void ObFreezerStat::set_state(int state)
+{
+  ObSpinLockGuard guard(lock_);
+  state_ = state;
+}
+
+int ObFreezerStat::get_state()
+{
+  ObSpinLockGuard guard(lock_);
+  return state_;
+}
+
+void ObFreezerStat::set_start_time(int64_t start_time)
+{
+  ObSpinLockGuard guard(lock_);
+  start_time_ = start_time;
+}
+
+int64_t ObFreezerStat::get_start_time()
+{
+  ObSpinLockGuard guard(lock_);
+  return start_time_;
+}
+
+void ObFreezerStat::set_end_time(int64_t end_time)
+{
+  ObSpinLockGuard guard(lock_);
+  end_time_ = end_time;
+}
+
+int64_t ObFreezerStat::get_end_time()
+{
+  ObSpinLockGuard guard(lock_);
+  return end_time_;
+}
+
+void ObFreezerStat::set_ret_code(int ret_code)
+{
+  ObSpinLockGuard guard(lock_);
+  ret_code_ = ret_code;
+}
+
+int ObFreezerStat::get_ret_code()
+{
+  ObSpinLockGuard guard(lock_);
+  return ret_code_;
+}
+
+void ObFreezerStat::set_freeze_snapshot_version(const share::SCN &freeze_snapshot_version)
+{
+  ObSpinLockGuard guard(lock_);
+  freeze_snapshot_version_ = freeze_snapshot_version;
+}
+
+share::SCN ObFreezerStat::get_freeze_snapshot_version()
+{
+  ObSpinLockGuard guard(lock_);
+  return freeze_snapshot_version_;
+}
+
+int ObFreezerStat::deep_copy_to(ObFreezerStat &other)
+{
+  int ret = OB_SUCCESS;
+  ObSpinLockGuard guard(lock_);
+  other.set_tablet_id(tablet_id_);
+  other.set_is_force(is_force_);
+  other.set_state(state_);
+  other.set_freeze_clock(freeze_clock_);
+  other.set_start_time(start_time_);
+  other.set_end_time(end_time_);
+  other.set_ret_code(ret_code_);
+  other.set_freeze_snapshot_version(freeze_snapshot_version_);
+  if (OB_FAIL(other.add_diagnose_info(diagnose_info_.get_ob_string()))) {
+    TRANS_LOG(WARN, "fail to add diagnose_info", K(ret));
+  } else if (OB_FAIL(other.set_memtables_info(memtables_info_))) {
+    TRANS_LOG(WARN, "fail to set memtables_info", K(ret));
+  }
+  return ret;
+}
+
 ObFreezer::ObFreezer()
   : freeze_flag_(0),
     freeze_snapshot_version_(),
@@ -317,9 +453,7 @@ int ObFreezer::logstream_freeze(ObFuture<int> *result)
   SCN max_decided_scn;
   share::ObLSID ls_id = get_ls_id();
   FLOG_INFO("[Freezer] logstream_freeze start", K(ret), K(ls_id));
-  stat_.reset();
+  int64_t start_time = ObTimeUtility::current_time();
-  stat_.start_time_ = ObTimeUtility::current_time();
-  stat_.state_ = ObFreezeState::NOT_SET_FREEZE_FLAG;
 
   ObLSFreezeGuard guard(*this);
   if (IS_NOT_INIT) {
@@ -341,7 +475,11 @@ int ObFreezer::logstream_freeze(ObFuture<int> *result)
   } else if (FALSE_IT(max_decided_scn_ = max_decided_scn)) {
   } else if (FALSE_IT(freeze_snapshot_version_ = freeze_snapshot_version)) {
   } else if (FALSE_IT(set_need_resubmit_log(false))) {
-  } else if (FALSE_IT(stat_.state_ = ObFreezeState::NOT_SUBMIT_LOG)) {
+  } else if (FALSE_IT(stat_.reset())) {
+  } else if (FALSE_IT(stat_.set_freeze_clock(get_freeze_clock()))) {
+  } else if (FALSE_IT(stat_.set_start_time(start_time))) {
+  } else if (FALSE_IT(stat_.set_state(ObFreezeState::NOT_SUBMIT_LOG))) {
+  } else if (FALSE_IT(stat_.set_freeze_snapshot_version(freeze_snapshot_version))) {
   } else if (OB_FAIL(inner_logstream_freeze(result))) {
     TRANS_LOG(WARN, "[Freezer] logstream_freeze failure", K(ret), K(ls_id));
     undo_freeze_();
@@ -407,9 +545,9 @@ int ObFreezer::ls_freeze_task()
   stat_.add_diagnose_info("logstream_freeze success");
   FLOG_INFO("[Freezer] logstream_freeze success", K(ls_id), K(freeze_clock));
 
-  stat_.state_ = ObFreezeState::FINISH;
+  stat_.set_state(ObFreezeState::FINISH);
-  stat_.end_time_ = ObTimeUtility::current_time();
+  stat_.set_end_time(ObTimeUtility::current_time());
-  stat_.ret_code_ = ret;
+  stat_.set_ret_code(ret);
 
   unset_freeze_();
 
@@ -457,10 +595,7 @@ int ObFreezer::freeze_normal_tablet_(const ObTabletID &tablet_id, ObFuture<int>
   ObTableHandleV2 frozen_memtable_handle;
   SCN freeze_snapshot_version;
   FLOG_INFO("[Freezer] tablet_freeze start", K(ret), K(ls_id), K(tablet_id));
-  stat_.reset();
+  int64_t start_time = ObTimeUtility::current_time();
-  stat_.start_time_ = ObTimeUtility::current_time();
-  stat_.state_ = ObFreezeState::NOT_SET_FREEZE_FLAG;
-  stat_.tablet_id_ = tablet_id;
 
   ObTabletFreezeGuard guard(*this, true /* try guard */);
   if (IS_NOT_INIT) {
@@ -475,7 +610,6 @@ int ObFreezer::freeze_normal_tablet_(const ObTabletID &tablet_id, ObFuture<int>
   } else if (OB_FAIL(set_freeze_flag_without_inc_freeze_clock())) {
     ret = OB_SUCCESS;
     FLOG_INFO("[Freezer] freeze is running", K(ret), K(ls_id), K(tablet_id));
-  } else if (FALSE_IT(stat_.state_ = ObFreezeState::NOT_SUBMIT_LOG)) {
   } else {
     // succeed to set freeze flag
     if (OB_FAIL(get_ls_weak_read_scn(freeze_snapshot_version))) {
@@ -486,6 +620,12 @@ int ObFreezer::freeze_normal_tablet_(const ObTabletID &tablet_id, ObFuture<int>
       LOG_WARN("[Freezer] weak read service not inited", K(ret), K(ls_id));
     } else if (FALSE_IT(freeze_snapshot_version_ = freeze_snapshot_version)) {
     } else if (FALSE_IT(set_need_resubmit_log(false))) {
+    } else if (FALSE_IT(stat_.reset())) {
+    } else if (FALSE_IT(stat_.set_freeze_clock(get_freeze_clock()))) {
+    } else if (FALSE_IT(stat_.set_freeze_snapshot_version(freeze_snapshot_version))) {
+    } else if (FALSE_IT(stat_.set_start_time(start_time))) {
+    } else if (FALSE_IT(stat_.set_state(ObFreezeState::NOT_SUBMIT_LOG))) {
+    } else if (FALSE_IT(stat_.set_tablet_id(tablet_id))) {
     } else if (OB_FAIL(get_ls_tablet_svr()->get_tablet(tablet_id,
                                                        handle,
                                                        ObTabletCommon::NO_CHECK_GET_TABLET_TIMEOUT_US))) {
@@ -512,9 +652,9 @@ int ObFreezer::freeze_normal_tablet_(const ObTabletID &tablet_id, ObFuture<int>
       TRANS_LOG(INFO, "[Freezer] succeed to start tablet_freeze_task", K(ret), K(ls_id), K(tablet_id));
     }
     if (OB_FAIL(ret) || !frozen_memtable_handle.is_valid()) {
-      stat_.state_ = ObFreezeState::FINISH;
+      stat_.set_state(ObFreezeState::FINISH);
-      stat_.end_time_ = ObTimeUtility::current_time();
+      stat_.set_end_time(ObTimeUtility::current_time());
-      stat_.ret_code_ = ret;
+      stat_.set_ret_code(ret);
       print_freezer_statistics();
       unset_freeze_();
     }
@@ -545,11 +685,7 @@ int ObFreezer::force_tablet_freeze(const ObTabletID &tablet_id)
   ObTableHandleV2 frozen_memtable_handle;
   SCN freeze_snapshot_version;
   FLOG_INFO("[Freezer] force_tablet_freeze start", K(ret), K(ls_id), K(tablet_id));
-  stat_.reset();
+  int64_t start_time = ObTimeUtility::current_time();
-  stat_.start_time_ = ObTimeUtility::current_time();
-  stat_.state_ = ObFreezeState::NOT_SET_FREEZE_FLAG;
-  stat_.tablet_id_ = tablet_id;
-  stat_.is_force_ = true;
 
   ObTabletFreezeGuard guard(*this);
   if (IS_NOT_INIT) {
@@ -560,7 +696,6 @@ int ObFreezer::force_tablet_freeze(const ObTabletID &tablet_id)
     LOG_WARN("freezer is offline, can not freeze now", K(ret), K(ls_id));
   } else if (OB_FAIL(loop_set_freeze_flag())) {
     TRANS_LOG(WARN, "[Freezer] failed to set freeze_flag", K(ret), K(ls_id), K(tablet_id));
-  } else if (FALSE_IT(stat_.state_ = ObFreezeState::NOT_SUBMIT_LOG)) {
   } else {
     // succeed to set freeze flag
     if (OB_FAIL(get_ls_weak_read_scn(freeze_snapshot_version))) {
@@ -571,6 +706,12 @@ int ObFreezer::force_tablet_freeze(const ObTabletID &tablet_id)
       LOG_WARN("[Freezer] weak read service not inited", K(ret), K(ls_id));
     } else if (FALSE_IT(freeze_snapshot_version_ = freeze_snapshot_version)) {
     } else if (FALSE_IT(set_need_resubmit_log(false))) {
+    } else if (FALSE_IT(stat_.reset())) {
+    } else if (FALSE_IT(stat_.set_freeze_clock(get_freeze_clock()))) {
+    } else if (FALSE_IT(stat_.set_freeze_snapshot_version(freeze_snapshot_version))) {
+    } else if (FALSE_IT(stat_.set_state(ObFreezeState::NOT_SUBMIT_LOG))) {
+    } else if (FALSE_IT(stat_.set_tablet_id(tablet_id))) {
+    } else if (FALSE_IT(stat_.set_is_force(true))) {
     } else if (OB_FAIL(get_ls_tablet_svr()->get_tablet(tablet_id,
                                                        handle,
                                                        ObTabletCommon::NO_CHECK_GET_TABLET_TIMEOUT_US))) {
@@ -597,9 +738,9 @@ int ObFreezer::force_tablet_freeze(const ObTabletID &tablet_id)
       TRANS_LOG(INFO, "[Freezer] succeed to start force_tablet_freeze_task", K(ret), K(ls_id), K(tablet_id));
     }
     if (OB_FAIL(ret) || !frozen_memtable_handle.is_valid()) {
-      stat_.state_ = ObFreezeState::FINISH;
+      stat_.set_state(ObFreezeState::FINISH);
-      stat_.end_time_ = ObTimeUtility::current_time();
+      stat_.set_end_time(ObTimeUtility::current_time());
-      stat_.ret_code_ = ret;
+      stat_.set_ret_code(ret);
       print_freezer_statistics();
       unset_freeze_();
     }
@@ -639,9 +780,9 @@ int ObFreezer::tablet_freeze_task(ObTableHandleV2 handle)
         FLOG_INFO("[Freezer] tablet_freeze_task success", K(ret), K(ls_id), KPC(memtable));
       }
     }
-    stat_.state_ = ObFreezeState::FINISH;
+    stat_.set_state(ObFreezeState::FINISH);
-    stat_.end_time_ = ObTimeUtility::current_time();
+    stat_.set_end_time(ObTimeUtility::current_time());
-    stat_.ret_code_ = ret;
+    stat_.set_ret_code(ret);
     print_freezer_statistics();
     unset_freeze_();
   }
@@ -693,10 +834,7 @@ int ObFreezer::tablet_freeze_for_replace_tablet_meta(const ObTabletID &tablet_id
   ObTabletMemtableMgr *memtable_mgr = nullptr;
   SCN freeze_snapshot_version;
   FLOG_INFO("[Freezer] tablet_freeze_for_replace_tablet_meta start", K(ret), K(ls_id), K(tablet_id));
-  stat_.reset();
+  int64_t start_time = ObTimeUtility::current_time();
-  stat_.start_time_ = ObTimeUtility::current_time();
-  stat_.state_ = ObFreezeState::NOT_SET_FREEZE_FLAG;
-  stat_.tablet_id_ = tablet_id;
 
   ObTabletFreezeGuard guard(*this, true /* try guard */);
   if (IS_NOT_INIT) {
@@ -710,7 +848,6 @@ int ObFreezer::tablet_freeze_for_replace_tablet_meta(const ObTabletID &tablet_id
     FLOG_INFO("[Freezer] ls freeze is running, no need freeze again", K(ret), K(ls_id), K(tablet_id));
   } else if (OB_FAIL(loop_set_freeze_flag())) {
     FLOG_INFO("[Freezer] freeze is running", K(ret), K(ls_id), K(tablet_id));
-  } else if (FALSE_IT(stat_.state_ = ObFreezeState::NOT_SUBMIT_LOG)) {
   } else {
     // succeed to set freeze flag
     if (OB_FAIL(get_ls_weak_read_scn(freeze_snapshot_version))) {
@@ -721,6 +858,11 @@ int ObFreezer::tablet_freeze_for_replace_tablet_meta(const ObTabletID &tablet_id
       LOG_WARN("[Freezer] weak read service not inited", K(ret), K(ls_id));
     } else if (FALSE_IT(freeze_snapshot_version_ = freeze_snapshot_version)) {
     } else if (FALSE_IT(set_need_resubmit_log(false))) {
+    } else if (FALSE_IT(stat_.reset())) {
+    } else if (FALSE_IT(stat_.set_freeze_clock(get_freeze_clock()))) {
+    } else if (FALSE_IT(stat_.set_freeze_snapshot_version(freeze_snapshot_version))) {
+    } else if (FALSE_IT(stat_.set_state(ObFreezeState::NOT_SUBMIT_LOG))) {
+    } else if (FALSE_IT(stat_.set_tablet_id(tablet_id))) {
     } else if (OB_FAIL(get_ls_tablet_svr()->get_tablet(tablet_id,
                                                   handle,
                                                   ObTabletCommon::NO_CHECK_GET_TABLET_TIMEOUT_US))) {
@@ -741,9 +883,9 @@ int ObFreezer::tablet_freeze_for_replace_tablet_meta(const ObTabletID &tablet_id
       }
     }
     if (OB_FAIL(ret) || !frozen_memtable_handle.is_valid()) {
-      stat_.state_ = ObFreezeState::FINISH;
+      stat_.set_state(ObFreezeState::FINISH);
-      stat_.end_time_ = ObTimeUtility::current_time();
+      stat_.set_end_time(ObTimeUtility::current_time());
-      stat_.ret_code_ = ret;
+      stat_.set_ret_code(ret);
       print_freezer_statistics();
       unset_freeze_();
     }
@@ -772,9 +914,9 @@ int ObFreezer::handle_frozen_memtable_for_replace_tablet_meta(const ObTabletID &
       stat_.add_diagnose_info("tablet_freeze_for_replace_tablet_meta success");
       FLOG_INFO("[Freezer] tablet_freeze_for_replace_tablet_meta success", K(ret), K(ls_id), K(tablet_id));
     }
-    stat_.state_ = ObFreezeState::FINISH;
+    stat_.set_state(ObFreezeState::FINISH);
-    stat_.end_time_ = ObTimeUtility::current_time();
+    stat_.set_end_time(ObTimeUtility::current_time());
-    stat_.ret_code_ = ret;
+    stat_.set_ret_code(ret);
     print_freezer_statistics();
     unset_freeze_();
   }
@@ -845,7 +987,7 @@ int ObFreezer::submit_log_for_freeze()
     }
   }
 
-  stat_.state_ = ObFreezeState::WAIT_READY_FOR_FLUSH;
+  stat_.set_state(ObFreezeState::WAIT_READY_FOR_FLUSH);
 
   return ret;
 }

src/storage/ls/ob_freezer.h

@@ -161,22 +161,39 @@ public:
                         const int64_t current_right_boundary);
   int remove_memtable_info(const ObTabletID &tablet_id);
   int get_memtables_info(common::ObSArray<ObFrozenMemtableInfo> &memtables_info);
-  void add_diagnose_info(const ObString &str);
+  int set_memtables_info(const common::ObSArray<ObFrozenMemtableInfo> &memtables_info);
+  int add_diagnose_info(const ObString &str);
   int get_diagnose_info(ObStringHolder &diagnose_info);
+  void set_tablet_id(const ObTabletID &tablet_id);
+  ObTabletID get_tablet_id();
+  void set_is_force(bool is_force);
+  bool get_is_force();
+  void set_state(int state);
+  int get_state();
+  void set_freeze_clock(const int64_t freeze_clock);
+  int64_t get_freeze_clock();
+  void set_start_time(int64_t start_time);
+  int64_t get_start_time();
+  void set_end_time(int64_t end_time);
+  int64_t get_end_time();
+  void set_ret_code(int ret_code);
+  int get_ret_code();
+  void set_freeze_snapshot_version(const share::SCN &freeze_snapshot_version);
+  share::SCN get_freeze_snapshot_version();
+  int deep_copy_to(ObFreezerStat &other);
 
-public:
+private:
   ObTabletID tablet_id_;
   bool is_force_;
   int state_;
+  int64_t freeze_clock_;
   int64_t start_time_;
   int64_t end_time_;
   int ret_code_;
+  share::SCN freeze_snapshot_version_;
   ObStringHolder diagnose_info_;
-
-private:
   common::ObSArray<ObFrozenMemtableInfo> memtables_info_;
-  ObSpinLock memtables_info_lock_;
+  ObSpinLock lock_;
-  ObSpinLock diagnose_info_lock_;
 };
 
 class ObFreezer