hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

replace ts related to ddl with scn.

Browse Source
This commit is contained in:
obdev
2022-11-28 02:21:13 +00:00
committed by ob-robot
parent bbec6aff49
commit 8a4d14122f
539 changed files with 17685 additions and 173434 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
src/storage/tablet/ob_tablet_memtable_mgr.cpp
View File

@ -36,6 +36,9 @@ ObTabletMemtableMgr::ObTabletMemtableMgr()
: ls_(NULL),
schema_recorder_()
{
#if defined(__x86_64__)
static_assert(sizeof(ObTabletMemtableMgr) <= 352, "The size of ObTabletMemtableMgr will affect the meta memory manager, and the necessity of adding new fields needs to be considered.");
#endif
}
ObTabletMemtableMgr::~ObTabletMemtableMgr()
@ -45,26 +48,24 @@ ObTabletMemtableMgr::~ObTabletMemtableMgr()
void ObTabletMemtableMgr::destroy()
{
TCWLockGuard lock_guard(lock_);
SpinWLockGuard lock_guard(lock_);
// release memtable
memtable::ObIMemtable *imemtable = nullptr;
int ret = OB_SUCCESS;
for (int64_t pos = memtable_head_; pos < memtable_tail_; ++pos) {
if (OB_FAIL(memtables_[get_memtable_idx_(pos)].get_memtable(imemtable))) {
LOG_WARN("get_memtable failed in ObTabletMemtableMgr destroy", K(ret));
imemtable = tables_[get_memtable_idx(pos)];
if (OB_ISNULL(imemtable)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "memtable is nullptr", K(ret), KP(imemtable), K(pos));
} else if (imemtable->is_data_memtable()) {
memtable::ObMemtable *memtable = static_cast<memtable::ObMemtable *>(imemtable);
memtable->remove_from_data_checkpoint(true);
}
memtables_[get_memtable_idx_(pos)].reset();
}
memtable_head_ = 0;
memtable_tail_ = 0;
reset_tables();
tablet_id_ = 0;
ls_ = NULL;
t3m_ = nullptr;
freezer_ = nullptr;
ddl_kv_mgr_ = nullptr;
schema_recorder_.reset();
is_inited_ = false;
}
@ -72,8 +73,7 @@ void ObTabletMemtableMgr::destroy()
int ObTabletMemtableMgr::init(const common::ObTabletID &tablet_id,
const ObLSID &ls_id,
ObFreezer *freezer,
ObTenantMetaMemMgr *t3m,
ObTabletDDLKvMgr *ddl_kv_mgr)
ObTenantMetaMemMgr *t3m)
{
int ret = OB_SUCCESS;
ObLSService *ls_service = MTL(storage::ObLSService *);
@ -84,10 +84,9 @@ int ObTabletMemtableMgr::init(const common::ObTabletID &tablet_id,
LOG_WARN("this has been initialized, not init again", K(ret), K_(is_inited));
} else if (OB_UNLIKELY(!tablet_id.is_valid())
|| OB_ISNULL(t3m)
|| OB_ISNULL(freezer)
|| OB_ISNULL(ddl_kv_mgr)) {
|| OB_ISNULL(freezer)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(ret), K(tablet_id), KP(freezer), KP(t3m), KP(ddl_kv_mgr));
LOG_WARN("invalid arguments", K(ret), K(tablet_id), KP(freezer), KP(t3m));
} else if (OB_ISNULL(ls_service)) {
ret = OB_ERR_UNEXPECTED;
TRANS_LOG(WARN, "ls service should not be NULL", K(ret), KP(ls_service));
@ -101,8 +100,8 @@ int ObTabletMemtableMgr::init(const common::ObTabletID &tablet_id,
} else {
tablet_id_ = tablet_id;
t3m_ = t3m;
table_type_ = ObITable::TableType::DATA_MEMTABLE;
freezer_ = freezer;
ddl_kv_mgr_ = ddl_kv_mgr;
is_inited_ = true;
TRANS_LOG(DEBUG, "succeeded to init tablet memtable mgr", K(ret), K(ls_id), K(tablet_id));
}
@ -126,6 +125,15 @@ int ObTabletMemtableMgr::init_storage_schema_recorder(
return ret;
}
int ObTabletMemtableMgr::destroy_storage_schema_recorder()
{
int ret = OB_SUCCESS;
if (schema_recorder_.is_inited()) {
schema_recorder_.reset();
}
return ret;
}
// There are two cases:
// 1. create the first memtable for tablet
// 2. create the new memtable after freezing the old memtable
@ -135,7 +143,7 @@ int ObTabletMemtableMgr::create_memtable(const palf::SCN clog_checkpoint_scn,
{
ObTimeGuard time_guard("ObTabletMemtableMgr::create_memtable", 1 * 1000 * 1000);
// Write lock
TCWLockGuard lock_guard(lock_);
SpinWLockGuard lock_guard(lock_);
time_guard.click("lock");
int ret = OB_SUCCESS;
@ -161,7 +169,7 @@ int ObTabletMemtableMgr::create_memtable(const palf::SCN clog_checkpoint_scn,
ObTableHandleV2 first_frozen_memtable;
get_first_frozen_memtable_(first_frozen_memtable);
LOG_WARN("cannot create more memtable", K(ret), K(ls_id), K(tablet_id_), K(MAX_MEMSTORE_CNT),
K(memtable_head_), K(memtable_tail_), K(get_memtable_count_()),
K(get_memtable_count_()),
KPC(first_frozen_memtable.get_table()));
}
} else {
@ -257,7 +265,7 @@ bool ObTabletMemtableMgr::has_active_memtable()
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret), K_(is_inited));
} else {
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
if (NULL != get_active_memtable_()) {
bool_ret = true;
}
@ -267,22 +275,23 @@ bool ObTabletMemtableMgr::has_active_memtable()
int64_t ObTabletMemtableMgr::get_memtable_count() const
{
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
return get_memtable_count_();
}
int ObTabletMemtableMgr::get_boundary_memtable(ObTableHandleV2 &handle)
{
int ret = OB_SUCCESS;
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
memtable::ObIMemtable *memtable = nullptr;
handle.reset();
if (OB_UNLIKELY(get_memtable_count_() == 0)) {
ret = OB_ENTRY_NOT_EXIST;
} else if (memtable_tail_ > memtable_head_) {
handle = memtables_[get_memtable_idx_(memtable_tail_ - 1)];
if (OB_FAIL(handle.get_memtable(memtable))) {
if (OB_FAIL(get_ith_memtable(memtable_tail_ - 1, handle))) {
STORAGE_LOG(WARN, "fail to get ith memtable", K(ret), K(memtable_tail_));
} else if (OB_FAIL(handle.get_memtable(memtable))) {
handle.reset();
LOG_WARN("there is no boundary memtable", K(ret));
}
@ -294,7 +303,7 @@ int ObTabletMemtableMgr::get_boundary_memtable(ObTableHandleV2 &handle)
int ObTabletMemtableMgr::get_active_memtable(ObTableHandleV2 &handle) const
{
int ret = OB_SUCCESS;
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
handle.reset();
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
@ -316,8 +325,9 @@ int ObTabletMemtableMgr::get_active_memtable_(ObTableHandleV2 &handle) const
LOG_DEBUG("no memtable exists", K(ret));
} else if (memtable_tail_ > memtable_head_) {
memtable::ObMemtable *memtable = nullptr;
handle = memtables_[get_memtable_idx_(memtable_tail_ - 1)];
if (OB_FAIL(handle.get_data_memtable(memtable))) {
if (OB_FAIL(get_ith_memtable(memtable_tail_ - 1, handle))) {
STORAGE_LOG(WARN, "fail to get ith memtable", K(ret), K(memtable_tail_));
} else if (OB_FAIL(handle.get_data_memtable(memtable))) {
LOG_WARN("fail to get memtable", K(ret));
} else if (!memtable->is_active_memtable()) {
handle.reset();
@ -330,7 +340,7 @@ int ObTabletMemtableMgr::get_active_memtable_(ObTableHandleV2 &handle) const
ObMemtable *ObTabletMemtableMgr::get_last_frozen_memtable() const
{
int ret = OB_SUCCESS;
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
memtable::ObMemtable *memtable = nullptr;
if (OB_UNLIKELY(!is_inited_)) {
@ -462,11 +472,12 @@ int ObTabletMemtableMgr::get_memtable_for_replay(palf::SCN replay_scn,
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret), K_(is_inited));
} else {
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
int64_t i = 0;
for (i = memtable_tail_ - 1; OB_SUCC(ret) && i >= memtable_head_; --i) {
handle = memtables_[get_memtable_idx_(i)];
if (OB_FAIL(handle.get_data_memtable(memtable))) {
if (OB_FAIL(get_ith_memtable(i, handle))) {
STORAGE_LOG(WARN, "fail to get ith memtable", K(ret), K(i));
} else if (OB_FAIL(handle.get_data_memtable(memtable))) {
handle.reset();
LOG_WARN("fail to get data memtable", K(ret));
} else {
@ -507,7 +518,7 @@ int ObTabletMemtableMgr::get_memtables(
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret), K_(is_inited));
} else {
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
if (reset_handle) {
handle.reset();
}
@ -535,7 +546,7 @@ int ObTabletMemtableMgr::get_memtables_nolock(ObTableHdlArray &handle)
int ObTabletMemtableMgr::get_all_memtables(ObTableHdlArray &handle)
{
int ret = OB_SUCCESS;
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret), K_(is_inited));
@ -555,9 +566,10 @@ int ObTabletMemtableMgr::release_head_empty_memtable(memtable::ObIMemtable *flus
ret = OB_NOT_INIT;
TRANS_LOG(WARN, "not inited", K(ret));
} else {
memtable::ObIMemtable *imemtable = nullptr;
if (OB_FAIL(memtables_[get_memtable_idx_(memtable_head_)].get_memtable(imemtable))) {
STORAGE_LOG(WARN, "fail to get memtable", K(ret));
memtable::ObIMemtable *imemtable = tables_[get_memtable_idx(memtable_head_)];
if (OB_ISNULL(imemtable)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "memtable is nullptr", K(ret), KP(imemtable), K(memtable_head_));
} else if (flush_memtable == imemtable) {
memtable::ObMemtable *memtable = static_cast<memtable::ObMemtable *>(imemtable);
if (memtable->is_empty()) {
@ -574,7 +586,7 @@ int ObTabletMemtableMgr::release_head_empty_memtable(memtable::ObIMemtable *flus
}
}
}
lock_.wrunlock();
lock_.unlock();
} else {
ret = OB_EAGAIN;
}
@ -593,8 +605,8 @@ int ObTabletMemtableMgr::release_head_memtable_(memtable::ObIMemtable *imemtable
if (OB_UNLIKELY(get_memtable_count_() <= 0)) {
ret = OB_ERR_UNEXPECTED;
} else {
const int64_t idx = get_memtable_idx_(memtable_head_);
if (memtables_[idx].is_valid() && memtable == memtables_[idx].get_table()) {
const int64_t idx = get_memtable_idx(memtable_head_);
if (nullptr != tables_[idx] && memtable == tables_[idx]) {
LOG_INFO("release head memtable", K(ret), K(ls_id), KPC(memtable));
memtable::ObMtStat& mt_stat = memtable->get_mt_stat();
if (0 == mt_stat.release_time_) {
@ -610,8 +622,7 @@ int ObTabletMemtableMgr::release_head_memtable_(memtable::ObIMemtable *imemtable
memtable->remove_from_data_checkpoint(true);
memtable->set_is_flushed();
memtable->set_freeze_state(ObMemtableFreezeState::RELEASED);
memtables_[idx].reset();
++memtable_head_;
release_head_memtable();
FLOG_INFO("succeed to release head data memtable", K(ret), K(ls_id), K(tablet_id_));
}
}
@ -623,7 +634,7 @@ int ObTabletMemtableMgr::get_first_frozen_memtable(ObTableHandleV2 &handle) cons
{
int ret = OB_SUCCESS;
memtable::ObMemtable *memtable = NULL;
TCRLockGuard guard(lock_);
SpinRLockGuard guard(lock_);
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
@ -639,11 +650,12 @@ memtable::ObMemtable *ObTabletMemtableMgr::get_active_memtable_()
{
int ret = OB_SUCCESS;
memtable::ObMemtable *memtable = nullptr;
if (memtable_tail_ > memtable_head_) {
if (OB_FAIL(memtables_[get_memtable_idx_(memtable_tail_ - 1)].get_data_memtable(memtable))) {
LOG_WARN("fail to get memtable", K(ret));
} else if (OB_NOT_NULL(memtable) && !memtable->is_active_memtable()) {
memtable = static_cast<memtable::ObMemtable *>(tables_[get_memtable_idx(memtable_tail_ - 1)]);
if (OB_ISNULL(memtable)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "memtable is nullptr", K(ret), KP(memtable), K(memtable_tail_));
} else if (!memtable->is_active_memtable()) {
memtable = NULL;
}
}
@ -654,9 +666,16 @@ memtable::ObMemtable *ObTabletMemtableMgr::get_active_memtable_()
memtable::ObMemtable *ObTabletMemtableMgr::get_memtable_(const int64_t pos) const
{
int ret = OB_SUCCESS;
const memtable::ObMemtable *memtable = nullptr;
if (OB_FAIL(memtables_[get_memtable_idx_(pos)].get_data_memtable(memtable))) {
LOG_WARN("fail to get memtable", K(ret));
memtable::ObMemtable *memtable = nullptr;
memtable::ObMemtable *table = static_cast<memtable::ObMemtable *>(tables_[get_memtable_idx(pos)]);
if (OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("table is nullptr", K(ret), KP(table), K(pos));
} else if (!table->is_data_memtable()) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("not data memtable", K(ret), K(pos), K(table->get_key()));
} else {
memtable = table;
}
return const_cast<memtable::ObMemtable *>(memtable);
}
@ -679,14 +698,9 @@ int64_t ObTabletMemtableMgr::get_unmerged_memtable_count_() const
void ObTabletMemtableMgr::clean_tail_memtable_()
{
if (memtable_tail_ > memtable_head_) {
const int64_t idx = get_memtable_idx_(memtable_tail_ - 1);
memtables_[idx].reset();
--memtable_tail_;
}
ObIMemtableMgr::release_tail_memtable();
}
int ObTabletMemtableMgr::get_memtables_(ObTableHdlArray &handle, const int64_t start_point,
const bool include_active_memtable)
{
@ -713,8 +727,10 @@ int ObTabletMemtableMgr::add_tables_(
if (OB_LIKELY(start_pos > -1)) {
const int64_t last_pos = memtable_tail_ - 1;
for (int64_t pos = start_pos; OB_SUCC(ret) && pos < last_pos; ++pos) {
const ObTableHandleV2 &memtable_handle = memtables_[get_memtable_idx_(pos)];
if (OB_UNLIKELY(!memtable_handle.is_valid())) {
ObTableHandleV2 memtable_handle;
if (OB_FAIL(get_ith_memtable(pos, memtable_handle))) {
STORAGE_LOG(WARN, "fail to get ith memtable", K(ret), K(pos));
} else if (OB_UNLIKELY(!memtable_handle.is_valid())) {
ret = OB_ERR_SYS;
LOG_ERROR("invalid memtable handle", K(ret), K(memtable_handle));
} else if (OB_FAIL(handle.push_back(memtable_handle))) {
@ -722,8 +738,10 @@ int ObTabletMemtableMgr::add_tables_(
}
}
if (OB_SUCC(ret) && memtable_tail_ > memtable_head_) {
const ObTableHandleV2 &last_memtable_handle =memtables_[get_memtable_idx_(last_pos)];
if (OB_UNLIKELY(!last_memtable_handle.is_valid())) {
ObTableHandleV2 last_memtable_handle;
if (OB_FAIL(get_ith_memtable(last_pos, last_memtable_handle))) {
STORAGE_LOG(WARN, "fail to get ith memtable", K(ret), K(last_pos));
} else if (OB_UNLIKELY(!last_memtable_handle.is_valid())) {
ret = OB_ERR_SYS;
LOG_ERROR("invalid memtable handle", K(ret), K(last_memtable_handle));
} else if (include_active_memtable || last_memtable_handle.get_table()->is_frozen_memtable()) {
@ -768,7 +786,7 @@ int64_t ObTabletMemtableMgr::to_string(char *buf, const int64_t buf_len) const
J_COLON();
pos += ObIMemtableMgr::to_string(buf + pos, buf_len - pos);
J_COMMA();
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
J_OBJ_START();
J_ARRAY_START();
for (int64_t i = memtable_head_; i < memtable_tail_; ++i) {
@ -827,7 +845,7 @@ int ObTabletMemtableMgr::get_memtables_v2(
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret), K_(is_inited));
} else {
TCRLockGuard guard(lock_);
SpinRLockGuard guard(lock_);
if (reset_handle) {
handle.reset();
}
@ -849,9 +867,11 @@ int ObTabletMemtableMgr::get_first_frozen_memtable_(ObTableHandleV2 &handle) con
{
int ret = OB_SUCCESS;
for (int64_t i = memtable_head_; OB_SUCC(ret) && i < memtable_tail_; i++) {
const ObTableHandleV2 &m_handle = memtables_[get_memtable_idx_(i)];
ObTableHandleV2 m_handle;
const ObMemtable *memtable = nullptr;
if (OB_UNLIKELY(!m_handle.is_valid())) {
if (OB_FAIL(get_ith_memtable(i, m_handle))) {
STORAGE_LOG(WARN, "fail to get ith memtable", K(ret), K(i));
} else if (OB_UNLIKELY(!m_handle.is_valid())) {
ret = OB_ERR_SYS;
LOG_ERROR("memtable handle is invalid", K(ret), K(m_handle));
} else if (OB_FAIL(m_handle.get_data_memtable(memtable))) {
@ -872,7 +892,6 @@ int ObTabletMemtableMgr::get_multi_source_data_unit(
ObIAllocator *allocator/*= nullptr*/) const
{
int ret = OB_SUCCESS;
ObTableHandleV2 handle;
memtable::ObMemtable *memtable = nullptr;
multi_source_data_unit->reset();
@ -883,15 +902,14 @@ int ObTabletMemtableMgr::get_multi_source_data_unit(
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), KP(multi_source_data_unit));
} else {
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
if (!has_memtable_()) {
ret = OB_ENTRY_NOT_EXIST;
LOG_DEBUG("memtable does not exist", K(ret), K(memtable_head_), K(memtable_tail_));
} else {
for (int64_t i = memtable_tail_ - 1; (OB_ENTRY_NOT_EXIST == ret || OB_SUCC(ret)) && i >= memtable_head_; --i) {
handle = memtables_[get_memtable_idx_(i)];
memtable = static_cast<ObMemtable*>(handle.get_table());
memtable = static_cast<ObMemtable*>(get_memtable_(i));
if (OB_FAIL(memtable->get_multi_source_data_unit(multi_source_data_unit, allocator))) {
if (OB_ENTRY_NOT_EXIST == ret) {
} else {
@ -927,15 +945,14 @@ int ObTabletMemtableMgr::get_memtable_for_multi_source_data_unit(
ret = OB_NOT_INIT;
LOG_WARN("not inited", K(ret), K_(is_inited));
} else {
TCRLockGuard lock_guard(lock_);
SpinRLockGuard lock_guard(lock_);
if (!has_memtable_()) {
ret = OB_ENTRY_NOT_EXIST;
LOG_DEBUG("memtable does not exist", K(ret), K(memtable_head_), K(memtable_tail_));
} else {
for (int64_t i = memtable_tail_ - 1; OB_SUCC(ret) && i >= memtable_head_; --i) {
handle = memtables_[get_memtable_idx_(i)];
memtable = static_cast<ObMemtable*>(handle.get_table());
memtable = static_cast<ObMemtable*>(tables_[get_memtable_idx(i)]);
if (memtable->has_multi_source_data_unit(type)) {
break;
} else {
@ -949,7 +966,7 @@ int ObTabletMemtableMgr::get_memtable_for_multi_source_data_unit(
memtable = nullptr;
} else if (OB_ISNULL(memtable)) {
ret = OB_ENTRY_NOT_EXIST;
LOG_WARN("failed to get memtable", K(ret));
LOG_WARN("failed to get memtable", K(ret), K(type));
}
return ret;