diff --git a/src/logservice/palf/log_engine.cpp b/src/logservice/palf/log_engine.cpp index e83ecf6b0559ce518c2519d8b41974695c33c7b8..f53ab7bcd915adfacebf1e57a526916299877717 100644 --- a/src/logservice/palf/log_engine.cpp +++ b/src/logservice/palf/log_engine.cpp @@ -38,7 +38,7 @@ namespace palf // ===================== LogEngine start ======================= LogEngine::LogEngine() : - min_block_ts_ns_(OB_INVALID_TIMESTAMP), + min_block_max_ts_ns_(OB_INVALID_TIMESTAMP), min_block_id_(LOG_INVALID_BLOCK_ID), base_lsn_for_block_gc_(PALF_INITIAL_LSN_VAL), log_meta_lock_(), @@ -158,7 +158,7 @@ void LogEngine::destroy() log_storage_.destroy(); base_lsn_for_block_gc_.reset(); min_block_id_ = LOG_INVALID_BLOCK_ID; - min_block_ts_ns_ = OB_INVALID_TIMESTAMP; + min_block_max_ts_ns_ = OB_INVALID_TIMESTAMP; } } @@ -537,8 +537,7 @@ int LogEngine::truncate_prefix_blocks(const LSN &lsn) } else if (OB_FAIL(log_storage_.truncate_prefix_blocks(lsn))) { PALF_LOG(WARN, "truncate_prefix_blocks failed", K(ret), K_(palf_id), K_(is_inited), K(lsn)); } else { - PALF_LOG(INFO, "truncate_prefix_blocks success", K(ret), K_(palf_id), K_(is_inited), K(lsn)); - } + PALF_LOG(INFO, "truncate_prefix_blocks success", K(ret), K_(palf_id), K_(is_inited), K(lsn)); } return ret; } @@ -551,7 +550,7 @@ int LogEngine::delete_block(const block_id_t &block_id) { int ret = OB_SUCCESS; block_id_t next_block_id = block_id + 1; - int64_t next_block_min_ts_ns = OB_INVALID_TIMESTAMP; + int64_t next_block_max_ts_ns = OB_INVALID_TIMESTAMP; if (IS_NOT_INIT) { ret = OB_NOT_INIT; PALF_LOG(ERROR, "LogEngine not inited!!!", K(ret), K_(palf_id), K_(is_inited)); @@ -566,12 +565,12 @@ int LogEngine::delete_block(const block_id_t &block_id) } else { PALF_LOG(INFO, "delete success", K(block_id), K_(palf_id), K_(is_inited)); } - - if (OB_SUCC(ret) && OB_FAIL(get_block_min_ts_ns(next_block_id , next_block_min_ts_ns))) { - PALF_LOG(WARN, "get the min ts of next block failed", K(ret), K(next_block_id)); + int tmp_ret = OB_SUCCESS; + if (OB_SUCC(ret) && OB_SUCCESS != (tmp_ret = get_block_min_ts_ns(next_block_id+1, next_block_max_ts_ns))) { + PALF_LOG(WARN, "get the max ts of next block failed", K(tmp_ret), K(next_block_id)); } // If 'delete_block' or 'get_block_min_ts_ns' failed, need reset 'min_block_ts_ns_' to be invalid. - reset_min_block_info_guarded_by_lock_(next_block_id, next_block_min_ts_ns); + reset_min_block_info_guarded_by_lock_(next_block_id, next_block_max_ts_ns); return ret; } @@ -587,30 +586,50 @@ int LogEngine::get_block_id_range(block_id_t &min_block_id, block_id_t &max_bloc return log_storage_.get_block_id_range(min_block_id, max_block_id); } -int LogEngine::get_min_block_id_and_min_ts_ns(block_id_t &block_id, int64_t &ts_ns) const +int LogEngine::get_min_block_info_for_gc(block_id_t &block_id, int64_t &max_ts_ns) const { int ret = OB_SUCCESS; block_id_t max_block_id = LOG_INVALID_BLOCK_ID; block_id_t min_block_id = LOG_INVALID_BLOCK_ID; - int64_t min_block_ts_ns = OB_INVALID_TIMESTAMP; + int64_t min_block_max_ts_ns = OB_INVALID_TIMESTAMP; do { ObSpinLockGuard guard(block_gc_lock_); min_block_id = min_block_id_; - min_block_ts_ns = min_block_ts_ns_; + min_block_max_ts_ns = min_block_max_ts_ns_; } while (0); - if (OB_INVALID_TIMESTAMP != min_block_ts_ns) { + if (IS_NOT_INIT) { + ret = OB_NOT_INIT; + PALF_LOG(WARN, "LogEngine is not inited", K(ret), KPC(this)); + } else if (OB_INVALID_TIMESTAMP != min_block_max_ts_ns) { block_id = min_block_id; - ts_ns = min_block_ts_ns; + max_ts_ns = min_block_max_ts_ns; } else if (OB_FAIL(get_block_id_range(min_block_id, max_block_id))) { PALF_LOG(WARN, "get_block_id_range failed", K(ret)); - } else if (OB_FAIL(get_block_min_ts_ns(min_block_id, min_block_ts_ns))) { + // NB: used next block min_block_ts as the max_ts_ns of current block + } else if (OB_FAIL(get_block_min_ts_ns(min_block_id+1, min_block_max_ts_ns))) { PALF_LOG(WARN, "get_block_min_ts_ns failed", K(ret)); } else { - reset_min_block_info_guarded_by_lock_(min_block_id, min_block_ts_ns); + reset_min_block_info_guarded_by_lock_(min_block_id, min_block_max_ts_ns); block_id = min_block_id; - ts_ns = min_block_ts_ns; + max_ts_ns = min_block_max_ts_ns; + } + return ret; +} + +int LogEngine::get_min_block_info(block_id_t &min_block_id, int64_t &min_block_ts_ns) const +{ + int ret = OB_SUCCESS; + block_id_t max_block_id; + if (IS_NOT_INIT) { + ret = OB_NOT_INIT; + PALF_LOG(WARN, "LogEngine is not inited", K(ret), KPC(this)); + } else if (OB_FAIL(get_block_id_range(min_block_id, max_block_id))) { + PALF_LOG(WARN, "get_block_id_range failed", K(ret), KPC(this)); + } else if (OB_FAIL(get_block_min_ts_ns(min_block_id, min_block_ts_ns))) { + PALF_LOG(WARN, "get_block_min_ts_ns failed", K(ret), KPC(this)); + } else { } return ret; } @@ -1255,11 +1274,11 @@ bool LogEngine::check_last_block_whether_is_integrity_(const block_id_t expected || expected_next_block_id < max_block_id; } -void LogEngine::reset_min_block_info_guarded_by_lock_(const block_id_t min_block_id, const int64_t min_block_ts_ns) const +void LogEngine::reset_min_block_info_guarded_by_lock_(const block_id_t min_block_id, const int64_t min_block_max_ts_ns) const { ObSpinLockGuard guard(block_gc_lock_); min_block_id_ = min_block_id; - min_block_ts_ns_ = min_block_ts_ns; + min_block_max_ts_ns_ = min_block_max_ts_ns; } } // end namespace palf } // end namespace oceanbase diff --git a/src/logservice/palf/log_engine.h b/src/logservice/palf/log_engine.h index 3d24bcb0eaed9abf41a0e99b01a6971eca1447dd..02d4daa9adaed82b41275cf8b22258863e40b077 100644 --- a/src/logservice/palf/log_engine.h +++ b/src/logservice/palf/log_engine.h @@ -362,14 +362,15 @@ public: LogMeta get_log_meta() const; const LSN &get_base_lsn_used_for_block_gc() const; // not thread safe - int get_min_block_id_and_min_ts_ns(block_id_t &block_id, int64_t &ts_ns) const; + int get_min_block_info_for_gc(block_id_t &block_id, int64_t &max_ts_ns) const; + int get_min_block_info(block_id_t &block_id, int64_t &min_log_ts) const; // // ===================== NetService end ======================== LogStorage *get_log_storage() { return &log_storage_; } LogStorage *get_log_meta_storage() { return &log_meta_storage_; } int get_total_used_disk_space(int64_t &total_used_size_byte) const; virtual int64_t get_palf_epoch() const { return palf_epoch_; } - TO_STRING_KV(K_(palf_id), K_(is_inited), K_(min_block_ts_ns), K_(min_block_id), K_(base_lsn_for_block_gc), + TO_STRING_KV(K_(palf_id), K_(is_inited), K_(min_block_max_ts_ns), K_(min_block_id), K_(base_lsn_for_block_gc), K_(log_meta), K_(log_meta_storage), K_(log_storage), K_(palf_epoch), KP(this)); private: int submit_flush_meta_task_(const FlushMetaCbCtx &flush_meta_cb_ctx, const LogMeta &log_meta); @@ -405,7 +406,8 @@ private: int serialize_log_meta_(const LogMeta &log_meta, char *buf, int64_t buf_len); - void reset_min_block_info_guarded_by_lock_(const block_id_t block_id, const int64_t min_ts_ns) const; + void reset_min_block_info_guarded_by_lock_(const block_id_t min_block_id, + const int64_t min_block_max_ts_ns) const; private: DISALLOW_COPY_AND_ASSIGN(LogEngine); @@ -413,7 +415,7 @@ private: private: // used for GC mutable ObSpinLock block_gc_lock_; - mutable int64_t min_block_ts_ns_; + mutable int64_t min_block_max_ts_ns_; mutable block_id_t min_block_id_; LSN base_lsn_for_block_gc_; diff --git a/src/logservice/palf/palf_env_impl.cpp b/src/logservice/palf/palf_env_impl.cpp index 4fed985e72b2ce3912edfcba55b58cf198b975b0..5103f2956d6e1f7e583dd8ef977e797147bd2d03 100644 --- a/src/logservice/palf/palf_env_impl.cpp +++ b/src/logservice/palf/palf_env_impl.cpp @@ -591,7 +591,7 @@ int PalfEnvImpl::try_freeze_log_for_all() PalfEnvImpl::LogGetRecycableFileCandidate::LogGetRecycableFileCandidate() : id_(-1), min_block_id_(LOG_INVALID_BLOCK_ID), - min_block_id_ts_(OB_INVALID_TIMESTAMP), + min_block_max_ts_(OB_INVALID_TIMESTAMP), min_using_block_id_(LOG_INVALID_BLOCK_ID), oldest_palf_id_(INVALID_PALF_ID), oldest_block_ts_(OB_INVALID_TIMESTAMP), @@ -602,7 +602,7 @@ PalfEnvImpl::LogGetRecycableFileCandidate::~LogGetRecycableFileCandidate() { ret_code_ = OB_SUCCESS; min_using_block_id_ = LOG_INVALID_BLOCK_ID; - min_block_id_ts_ = OB_INVALID_TIMESTAMP; + min_block_max_ts_ = OB_INVALID_TIMESTAMP; min_block_id_ = LOG_INVALID_BLOCK_ID; oldest_palf_id_ = INVALID_PALF_ID; oldest_block_ts_ = OB_INVALID_TIMESTAMP; @@ -620,13 +620,13 @@ bool PalfEnvImpl::LogGetRecycableFileCandidate::operator()(const LSKey &palf_id, const LSN base_lsn = palf_handle_impl->get_base_lsn_used_for_block_gc(); const block_id_t min_using_block_id = lsn_2_block(base_lsn, PALF_BLOCK_SIZE); block_id_t min_block_id = LOG_INVALID_BLOCK_ID; - int64_t min_block_id_ts = OB_INVALID_TIMESTAMP; + int64_t min_block_max_ts = OB_INVALID_TIMESTAMP; if (false == base_lsn.is_valid()) { PALF_LOG(WARN, "base_lsn is invalid", K(base_lsn), KPC(palf_handle_impl)); // OB_ENTRY_EXIST means there is not any block; // OB_NO_SUCH_FILE_OR_DIRECTORY means there is concurrently with rebuild. - } else if (OB_FAIL(palf_handle_impl->get_min_block_id_min_ts_ns(min_block_id, min_block_id_ts)) + } else if (OB_FAIL(palf_handle_impl->get_min_block_info_for_gc(min_block_id, min_block_max_ts)) && OB_ENTRY_NOT_EXIST != ret && OB_NO_SUCH_FILE_OR_DIRECTORY != ret) { ret_code_ = ret; @@ -644,20 +644,20 @@ bool PalfEnvImpl::LogGetRecycableFileCandidate::operator()(const LSKey &palf_id, PALF_LOG(TRACE, "can not recycle blocks, need keep at least two blocks or has been concurrently" " with rebuild, skip it", K(ret), KPC(palf_handle_impl), K(min_block_id), K(min_using_block_id)); - } else if (OB_INVALID_TIMESTAMP != min_block_id_ts_ && min_block_id_ts_ < min_block_id_ts) { - PALF_LOG(TRACE, "current palf_handle_impl is not older than previous, skip it", K(min_block_id_ts), - K(min_block_id_ts_), KPC(palf_handle_impl), K(min_block_id)); + } else if (OB_INVALID_TIMESTAMP != min_block_max_ts_ && min_block_max_ts_ < min_block_max_ts) { + PALF_LOG(TRACE, "current palf_handle_impl is not older than previous, skip it", K(min_block_max_ts), + K(min_block_max_ts_), KPC(palf_handle_impl), K(min_block_id)); } else { id_ = palf_id.id_; min_block_id_ = min_block_id; - min_block_id_ts_ = min_block_id_ts; + min_block_max_ts_ = min_block_max_ts; min_using_block_id_ = min_using_block_id; PALF_LOG(TRACE, "can be recycable palf_handle_impl", K(id_), K(min_block_id_), K(min_using_block_id_), - K(min_block_id_ts_), K(base_lsn)); + K(min_block_max_ts_), K(base_lsn)); } - if (OB_INVALID_TIMESTAMP != min_block_id_ts - && (OB_INVALID_TIMESTAMP == oldest_block_ts_ || oldest_block_ts_ > min_block_id_ts)) { - oldest_block_ts_ = min_block_id_ts; + if (OB_INVALID_TIMESTAMP != min_block_max_ts + && (OB_INVALID_TIMESTAMP == oldest_block_ts_ || oldest_block_ts_ > min_block_max_ts)) { + oldest_block_ts_ = min_block_max_ts; oldest_palf_id_ = palf_id.id_; } } diff --git a/src/logservice/palf/palf_env_impl.h b/src/logservice/palf/palf_env_impl.h index 32adeac5b5258da0939450eb6a1d0dacb71049a9..e2cdd1195b792c50d0814d8c723dc874be7e64e7 100644 --- a/src/logservice/palf/palf_env_impl.h +++ b/src/logservice/palf/palf_env_impl.h @@ -252,12 +252,12 @@ private: bool operator() (const LSKey &palf_id, PalfHandleImpl *palf_handle_impl); int64_t id_; block_id_t min_block_id_; - int64_t min_block_id_ts_; + int64_t min_block_max_ts_; block_id_t min_using_block_id_; int64_t oldest_palf_id_; int64_t oldest_block_ts_; int ret_code_; - TO_STRING_KV(K_(id), K_(min_block_id_ts), K_(min_block_id), K_(min_using_block_id), K_(oldest_palf_id), K_(oldest_block_ts), K_(ret_code)); + TO_STRING_KV(K_(id), K_(min_block_max_ts), K_(min_block_id), K_(min_using_block_id), K_(oldest_palf_id), K_(oldest_block_ts), K_(ret_code)); }; struct GetTotalUsedDiskSpace { diff --git a/src/logservice/palf/palf_handle_impl.cpp b/src/logservice/palf/palf_handle_impl.cpp index 996d2ded609ea00240592b947e15bee0630188fb..26ab03e06b7cd4a102c406079ed131e5ca87121c 100644 --- a/src/logservice/palf/palf_handle_impl.cpp +++ b/src/logservice/palf/palf_handle_impl.cpp @@ -301,8 +301,8 @@ int PalfHandleImpl::get_begin_ts_ns(int64_t &ts) const if (IS_NOT_INIT) { ret = OB_NOT_INIT; PALF_LOG(WARN, "PalfHandleImpl not init", K(ret), KPC(this)); - } else if (OB_FAIL(log_engine_.get_min_block_id_and_min_ts_ns(unused_block_id, ts))) { - PALF_LOG(WARN, "LogEngine get_min_block_id_and_min_ts_ns failed", K(ret), KPC(this)); + } else if (OB_FAIL(log_engine_.get_min_block_info(unused_block_id, ts))) { + PALF_LOG(WARN, "LogEngine get_min_block_info failed", K(ret), KPC(this)); } return ret; } @@ -1595,16 +1595,16 @@ int PalfHandleImpl::locate_by_lsn_coarsely(const LSN &lsn, int64_t &result_ts_ns return ret; } -int PalfHandleImpl::get_min_block_id_min_ts_ns(block_id_t &block_id, int64_t &ts_ns) +int PalfHandleImpl::get_min_block_info_for_gc(block_id_t &min_block_id, int64_t &max_ts_ns) { int ret = OB_SUCCESS; // if (false == end_lsn.is_valid()) { // ret = OB_ENTRY_NOT_EXIST; // } - if (OB_FAIL(log_engine_.get_min_block_id_and_min_ts_ns(block_id, ts_ns))) { - PALF_LOG(WARN, "get_min_block_id_and_min_ts_ns failed", K(ret), KPC(this)); + if (OB_FAIL(log_engine_.get_min_block_info_for_gc(min_block_id, max_ts_ns))) { + PALF_LOG(WARN, "get_min_block_info_for_gc failed", K(ret), KPC(this)); } else { - PALF_LOG(TRACE, "get_min_block_id_and_min_ts_ns success", K(ret), KPC(this), K(block_id), K(ts_ns)); + PALF_LOG(TRACE, "get_min_block_info_for_gc success", K(ret), KPC(this), K(min_block_id), K(max_ts_ns)); } return ret; } @@ -3485,7 +3485,7 @@ int PalfHandleImpl::stat(PalfStat &palf_stat) palf_stat.allow_vote_ = state_mgr_.is_allow_vote(); palf_stat.replica_type_ = state_mgr_.get_replica_type(); palf_stat.base_lsn_ = log_engine_.get_log_meta().get_log_snapshot_meta().base_lsn_; - (void)log_engine_.get_min_block_id_and_min_ts_ns(min_block_id, min_block_min_ts); + (void)log_engine_.get_min_block_info(min_block_id, min_block_min_ts); palf_stat.begin_lsn_ = LSN(min_block_id * PALF_BLOCK_SIZE); palf_stat.begin_ts_ns_ = min_block_min_ts; palf_stat.end_lsn_ = get_end_lsn(); diff --git a/src/logservice/palf/palf_handle_impl.h b/src/logservice/palf/palf_handle_impl.h index 5535404329adf345104c89cf20d0541ddb4de689..a072be52f249df7c243bfce3c2c24ff000dbbca2 100644 --- a/src/logservice/palf/palf_handle_impl.h +++ b/src/logservice/palf/palf_handle_impl.h @@ -423,7 +423,7 @@ public: virtual int get_begin_ts_ns(int64_t &ts) const = 0; virtual int get_base_info(const LSN &base_lsn, PalfBaseInfo &base_info) = 0; - virtual int get_min_block_id_min_ts_ns(block_id_t &block_id, int64_t &ts_ns) = 0; + virtual int get_min_block_info_for_gc(block_id_t &min_block_id, int64_t &max_ts_ns) = 0; //begin lsn base lsn end lsn // │ │ │ // │ │ │ @@ -716,7 +716,7 @@ public: int get_begin_lsn(LSN &lsn) const; int get_begin_ts_ns(int64_t &ts) const; int get_base_info(const LSN &base_lsn, PalfBaseInfo &base_info); - int get_min_block_id_min_ts_ns(block_id_t &block_id, int64_t &ts_ns) override final; + int get_min_block_info_for_gc(block_id_t &min_block_id, int64_t &max_ts_ns) override final; // return the block length which the previous data was committed const LSN get_end_lsn() const override final { diff --git a/unittest/logservice/mock_logservice_container/mock_log_engine.h b/unittest/logservice/mock_logservice_container/mock_log_engine.h index 9cfec36ad27b9a8934dba997410a2f14519510f5..9ee936312bff80077be53e3c930cb212f3d5b6ee 100644 --- a/unittest/logservice/mock_logservice_container/mock_log_engine.h +++ b/unittest/logservice/mock_logservice_container/mock_log_engine.h @@ -538,7 +538,7 @@ public: { return base_lsn_for_block_gc_; } - int get_min_block_id_and_min_ts_ns(block_id_t &block_id, int64_t &ts_ns) + int get_min_block_info_for_gc(block_id_t &block_id, int64_t &ts_ns) { int ret = OB_SUCCESS; UNUSED(block_id);