From c5fe3df3abda4409cd6e605efc266355e138d8c6 Mon Sep 17 00:00:00 2001 From: obdev Date: Sat, 28 Jan 2023 19:05:34 +0800 Subject: [PATCH] [BugFix] Fix sanity core of __all_virtual_minor_freeze_info --- .../simple_server/test_ob_minor_freeze.cpp | 21 ++ .../ob_all_virtual_minor_freeze_info.cpp | 23 +- src/storage/ls/ob_freezer.cpp | 244 ++++++++++++++---- src/storage/ls/ob_freezer.h | 29 ++- 4 files changed, 250 insertions(+), 67 deletions(-) diff --git a/mittest/simple_server/test_ob_minor_freeze.cpp b/mittest/simple_server/test_ob_minor_freeze.cpp index 8f1c96dc14..0ad3779cbc 100644 --- a/mittest/simple_server/test_ob_minor_freeze.cpp +++ b/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"); diff --git a/src/observer/virtual_table/ob_all_virtual_minor_freeze_info.cpp b/src/observer/virtual_table/ob_all_virtual_minor_freeze_info.cpp index b41d5c99ee..eb6b5ed37b 100644 --- a/src/observer/virtual_table/ob_all_virtual_minor_freeze_info.cpp +++ b/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()) { - ObFreezerStat& freeze_stat = freezer->get_stat(); + } else if (!(freezer->get_stat().is_valid())) { + } 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; diff --git a/src/storage/ls/ob_freezer.cpp b/src/storage/ls/ob_freezer.cpp index ffb67eb1ee..1eff762100 100644 --- a/src/storage/ls/ob_freezer.cpp +++ b/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_(), - diagnose_info_lock_() + lock_() {} ObFreezerStat::~ObFreezerStat() @@ -116,21 +117,22 @@ ObFreezerStat::~ObFreezerStat() void ObFreezerStat::reset() { - ObSpinLockGuard memtables_info_guard(memtables_info_lock_); - ObSpinLockGuard diagnose_info_guard(diagnose_info_lock_); + ObSpinLockGuard guard(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 &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 &me return ret; } -void ObFreezerStat::add_diagnose_info(const ObString &str) +int ObFreezerStat::set_memtables_info(const common::ObSArray &memtables_info) { - ObSpinLockGuard guard(diagnose_info_lock_); - diagnose_info_.assign(str); + int ret = OB_SUCCESS; + + 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 *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(); - stat_.start_time_ = ObTimeUtility::current_time(); - stat_.state_ = ObFreezeState::NOT_SET_FREEZE_FLAG; + int64_t start_time = ObTimeUtility::current_time(); ObLSFreezeGuard guard(*this); if (IS_NOT_INIT) { @@ -341,7 +475,11 @@ int ObFreezer::logstream_freeze(ObFuture *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_.end_time_ = ObTimeUtility::current_time(); - stat_.ret_code_ = ret; + stat_.set_state(ObFreezeState::FINISH); + stat_.set_end_time(ObTimeUtility::current_time()); + stat_.set_ret_code(ret); unset_freeze_(); @@ -457,10 +595,7 @@ int ObFreezer::freeze_normal_tablet_(const ObTabletID &tablet_id, ObFuture ObTableHandleV2 frozen_memtable_handle; SCN freeze_snapshot_version; FLOG_INFO("[Freezer] tablet_freeze start", K(ret), K(ls_id), K(tablet_id)); - stat_.reset(); - stat_.start_time_ = ObTimeUtility::current_time(); - stat_.state_ = ObFreezeState::NOT_SET_FREEZE_FLAG; - stat_.tablet_id_ = tablet_id; + int64_t start_time = ObTimeUtility::current_time(); ObTabletFreezeGuard guard(*this, true /* try guard */); if (IS_NOT_INIT) { @@ -475,7 +610,6 @@ int ObFreezer::freeze_normal_tablet_(const ObTabletID &tablet_id, ObFuture } 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 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 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_.end_time_ = ObTimeUtility::current_time(); - stat_.ret_code_ = ret; + stat_.set_state(ObFreezeState::FINISH); + stat_.set_end_time(ObTimeUtility::current_time()); + 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(); - stat_.start_time_ = ObTimeUtility::current_time(); - stat_.state_ = ObFreezeState::NOT_SET_FREEZE_FLAG; - stat_.tablet_id_ = tablet_id; - stat_.is_force_ = true; + int64_t start_time = ObTimeUtility::current_time(); 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_.end_time_ = ObTimeUtility::current_time(); - stat_.ret_code_ = ret; + stat_.set_state(ObFreezeState::FINISH); + stat_.set_end_time(ObTimeUtility::current_time()); + 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_.end_time_ = ObTimeUtility::current_time(); - stat_.ret_code_ = ret; + stat_.set_state(ObFreezeState::FINISH); + stat_.set_end_time(ObTimeUtility::current_time()); + 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(); - stat_.start_time_ = ObTimeUtility::current_time(); - stat_.state_ = ObFreezeState::NOT_SET_FREEZE_FLAG; - stat_.tablet_id_ = tablet_id; + int64_t start_time = ObTimeUtility::current_time(); 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_.end_time_ = ObTimeUtility::current_time(); - stat_.ret_code_ = ret; + stat_.set_state(ObFreezeState::FINISH); + stat_.set_end_time(ObTimeUtility::current_time()); + 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_.end_time_ = ObTimeUtility::current_time(); - stat_.ret_code_ = ret; + stat_.set_state(ObFreezeState::FINISH); + stat_.set_end_time(ObTimeUtility::current_time()); + 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; } diff --git a/src/storage/ls/ob_freezer.h b/src/storage/ls/ob_freezer.h index ea4e6e16ae..59ffedbcbb 100644 --- a/src/storage/ls/ob_freezer.h +++ b/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 &memtables_info); - void add_diagnose_info(const ObString &str); + int set_memtables_info(const common::ObSArray &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 memtables_info_; - ObSpinLock memtables_info_lock_; - ObSpinLock diagnose_info_lock_; + ObSpinLock lock_; }; class ObFreezer