diff --git a/mittest/mtlenv/storage/test_ls_tablet_service.cpp b/mittest/mtlenv/storage/test_ls_tablet_service.cpp
index a28f60ddde..42750630c9 100644
--- a/mittest/mtlenv/storage/test_ls_tablet_service.cpp
+++ b/mittest/mtlenv/storage/test_ls_tablet_service.cpp
@@ -185,15 +185,20 @@ void TestLSTabletService::construct_and_get_tablet_list(
   ObTabletHandle old_handle;
 
   ObTabletMapKey head_key(ls_id_, tablet_id);
+  ObUpdateTabletPointerParam param;
   ret = t3m->get_tablet(WashTabletPriority::WTP_LOW, head_key, old_handle);
   ASSERT_EQ(OB_SUCCESS, ret);
-  ret = t3m->compare_and_swap_tablet(head_key, old_handle, tablet_handle_head);
+  ret = tablet_handle_head.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ret = t3m->compare_and_swap_tablet(head_key, old_handle, tablet_handle_head, param);
   ASSERT_EQ(OB_SUCCESS, ret);
 
   ObTabletMapKey node_key(ls_id_, node_tablet_id);
   ret = t3m->get_tablet(WashTabletPriority::WTP_LOW, node_key, old_handle);
   ASSERT_EQ(OB_SUCCESS, ret);
-  ret = t3m->compare_and_swap_tablet(node_key, old_handle, tablet_handle_tail);
+  ret = tablet_handle_tail.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ret = t3m->compare_and_swap_tablet(node_key, old_handle, tablet_handle_tail, param);
   ASSERT_EQ(OB_SUCCESS, ret);
 }
 
@@ -1104,8 +1109,11 @@ TEST_F(TestLSTabletService, update_tablet_ddl_commit_scn)
   ASSERT_EQ(OB_NOT_SUPPORTED, ls_handle.get_ls()->get_tablet_svr()->update_tablet_ddl_commit_scn(data_tablet_id, ddl_commit_scn));
 
   ObTabletHandle new_tablet_hdl;
+  ObUpdateTabletPointerParam param;
   ASSERT_EQ(OB_SUCCESS, ObTabletPersister::persist_and_transform_tablet(*tablet_handle.get_obj(), new_tablet_hdl));
-  ASSERT_EQ(OB_SUCCESS, MTL(ObTenantMetaMemMgr *)->compare_and_swap_tablet(key, tablet_handle, new_tablet_hdl));
+  ret = new_tablet_hdl.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ASSERT_EQ(OB_SUCCESS, MTL(ObTenantMetaMemMgr *)->compare_and_swap_tablet(key, tablet_handle, new_tablet_hdl, param));
 
   ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet_svr()->update_tablet_ddl_commit_scn(data_tablet_id, ddl_commit_scn));
   ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet_svr()->get_tablet(data_tablet_id, tablet_handle));
diff --git a/mittest/mtlenv/storage/test_meta_snapshot.cpp b/mittest/mtlenv/storage/test_meta_snapshot.cpp
index 6dd424d330..d3477cbaa8 100644
--- a/mittest/mtlenv/storage/test_meta_snapshot.cpp
+++ b/mittest/mtlenv/storage/test_meta_snapshot.cpp
@@ -83,6 +83,7 @@ int TestMetaSnapshot::persist_tablet(ObTabletHandle &new_tablet_handle)
   ObTabletHandle tablet_handle;
   ObLSService *ls_svr = MTL(ObLSService*);
   ObMacroBlockHandle macro_handle;
+  ObUpdateTabletPointerParam param;
 
   if (OB_FAIL(ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD))) {
     LOG_WARN("fail to get ls", K(ret), K(ls_id));
@@ -92,8 +93,10 @@ int TestMetaSnapshot::persist_tablet(ObTabletHandle &new_tablet_handle)
     LOG_WARN("fail to switch shared meta block", K(ret));
   } else if (OB_FAIL(ObTabletPersister::persist_and_transform_tablet(*(tablet_handle.get_obj()), new_tablet_handle))) {
     LOG_WARN("fail to persist and transform tablet", K(ret), K(tablet_handle));
-  } else if (OB_FAIL(MTL(ObTenantMetaMemMgr*)->compare_and_swap_tablet(ObTabletMapKey(ls_id, tablet_id), tablet_handle, new_tablet_handle))) {
-    LOG_WARN("fail to cas tablet", K(ret), K(ls_id), K(tablet_id), K(tablet_handle), K(new_tablet_handle));
+  } else if (OB_FAIL(new_tablet_handle.get_obj()->get_updating_tablet_pointer_param(param))) {
+    LOG_WARN("fail to get updating tablet pointer parameters", K(ret));
+  } else if (OB_FAIL(MTL(ObTenantMetaMemMgr*)->compare_and_swap_tablet(ObTabletMapKey(ls_id, tablet_id), tablet_handle, new_tablet_handle, param))) {
+    LOG_WARN("fail to cas tablet", K(ret), K(ls_id), K(tablet_id), K(tablet_handle), K(new_tablet_handle), K(param));
   } else if (OB_FAIL(MTL(ObTenantCheckpointSlogHandler*)->get_shared_block_reader_writer().switch_block(macro_handle))) {
     LOG_WARN("fail to switch shared meta block", K(ret));
   }
@@ -294,4 +297,4 @@ int main(int argc, char **argv)
   oceanbase::common::ObClusterVersion::get_instance().init(CLUSTER_VERSION_4_2_0_0);
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
-}
\ No newline at end of file
+}
diff --git a/mittest/mtlenv/storage/test_tablet_status.cpp b/mittest/mtlenv/storage/test_tablet_status.cpp
index 96c3f8c775..ca5fdeacd0 100644
--- a/mittest/mtlenv/storage/test_tablet_status.cpp
+++ b/mittest/mtlenv/storage/test_tablet_status.cpp
@@ -189,7 +189,10 @@ TEST_F(TestTabletStatus, misc)
       share::SCN::base_scn(), snapshot_version, table_schema, compat_mode, store_flag, nullptr, freezer);
   ASSERT_EQ(OB_SUCCESS, ret);
 
-  ret = t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle);
+  ObUpdateTabletPointerParam param;
+  ret = tablet_handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(OB_SUCCESS, ret);
+  ret = t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle, param);
   ASSERT_EQ(OB_SUCCESS, ret);
 
   // set tx data
diff --git a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
index cef35a0b64..9f214b88bd 100644
--- a/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
+++ b/mittest/mtlenv/storage/test_tenant_meta_mem_mgr.cpp
@@ -370,7 +370,10 @@ void TestConcurrentT3M::run1()
 
     handle.get_obj()->is_inited_ = true; // to pass test
     handle.get_obj()->table_store_addr_.addr_.set_none_addr();
-    ret = t3m_.compare_and_swap_tablet(key, handle, handle);
+    ObUpdateTabletPointerParam param;
+    ret = handle.get_obj()->get_updating_tablet_pointer_param(param);
+    ASSERT_EQ(common::OB_SUCCESS, ret);
+    ret = t3m_.compare_and_swap_tablet(key, handle, handle, param);
     ASSERT_EQ(common::OB_SUCCESS, ret);
 
     ObTabletPointerHandle ptr_hdl(t3m_.tablet_map_);
@@ -549,6 +552,7 @@ TEST_F(TestTenantMetaMemMgr, test_tablet)
   int ret = OB_SUCCESS;
   const ObTabletID tablet_id(10000001);
   const ObTabletMapKey key(ls_id_, tablet_id);
+  ObUpdateTabletPointerParam param;
   ObTablet *tablet = nullptr;
   ObLSHandle ls_handle;
   ObTabletHandle handle;
@@ -597,7 +601,9 @@ TEST_F(TestTenantMetaMemMgr, test_tablet)
   handle.get_obj()->is_inited_ = true; // to pass test
   handle.get_obj()->table_store_addr_.addr_.set_none_addr();
 
-  ret = t3m_.compare_and_swap_tablet(key, handle, handle);
+  ret = handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, handle, handle, param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
@@ -720,7 +726,10 @@ TEST_F(TestTenantMetaMemMgr, test_wash_tablet)
   ASSERT_EQ(common::OB_SUCCESS, persister.persist_aggregated_meta(tablet_macro_info, new_handle, space_usage));
 
   ObMetaDiskAddr addr = new_handle.get_obj()->get_tablet_addr();
-  ret = t3m_.compare_and_swap_tablet(key, new_handle, new_handle);
+  ObUpdateTabletPointerParam param;
+  ret = new_handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, new_handle, new_handle, param);
   tablet = new_handle.get_obj();
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
@@ -817,7 +826,10 @@ TEST_F(TestTenantMetaMemMgr, test_wash_inner_tablet)
 
   ObMetaDiskAddr addr = new_handle.get_obj()->get_tablet_addr();
 
-  ret = t3m_.compare_and_swap_tablet(key, new_handle, new_handle);
+  ObUpdateTabletPointerParam param;
+  ret = new_handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, new_handle, new_handle, param);
   tablet = new_handle.get_obj();
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
@@ -922,7 +934,10 @@ TEST_F(TestTenantMetaMemMgr, test_wash_no_sstable_tablet)
       *tablet, linked_writer, total_write_ctxs, new_handle, space_usage, tablet_macro_info, shared_meta_id_arr));
   ASSERT_EQ(common::OB_SUCCESS, persister.persist_aggregated_meta(tablet_macro_info, new_handle, space_usage));
 
-  ret = t3m_.compare_and_swap_tablet(key, new_handle, new_handle);
+  ObUpdateTabletPointerParam param;
+  ret = new_handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, new_handle, new_handle, param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   tablet = new_handle.get_obj();
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
@@ -1016,7 +1031,10 @@ TEST_F(TestTenantMetaMemMgr, test_get_tablet_with_allocator)
       *tablet, linked_writer, total_write_ctxs, new_handle, space_usage, tablet_macro_info, shared_meta_id_arr));
   ASSERT_EQ(common::OB_SUCCESS, persister.persist_aggregated_meta(tablet_macro_info, new_handle, space_usage));
 
-  ret = t3m_.compare_and_swap_tablet(key, new_handle, new_handle);
+  ObUpdateTabletPointerParam update_pointer_param;
+  ret = new_handle.get_obj()->get_updating_tablet_pointer_param(update_pointer_param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, new_handle, new_handle, update_pointer_param);
   tablet = new_handle.get_obj();
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
@@ -1139,7 +1157,10 @@ TEST_F(TestTenantMetaMemMgr, test_wash_mem_tablet)
   addr.type_ = ObMetaDiskAddr::DiskType::MEM;
   handle.get_obj()->set_tablet_addr(addr);
 
-  ret = t3m_.compare_and_swap_tablet(key, handle, handle);
+  ObUpdateTabletPointerParam update_pointer_param;
+  ret = handle.get_obj()->get_updating_tablet_pointer_param(update_pointer_param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, handle, handle, update_pointer_param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
@@ -1215,7 +1236,10 @@ TEST_F(TestTenantMetaMemMgr, test_replace_tablet)
   handle.get_obj()->is_inited_ = true; // to pass test
   handle.get_obj()->table_store_addr_.addr_.set_none_addr();
 
-  ret = t3m_.compare_and_swap_tablet(key, handle, handle);
+  ObUpdateTabletPointerParam param;
+  ret = handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, handle, handle, param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
   ASSERT_EQ(0, t3m_.tablet_buffer_pool_.inner_used_num_);
@@ -1240,7 +1264,9 @@ TEST_F(TestTenantMetaMemMgr, test_replace_tablet)
   addr.size_ = 4096;
   addr.type_ = ObMetaDiskAddr::DiskType::BLOCK;
   handle.get_obj()->set_tablet_addr(addr);
-  ret = t3m_.compare_and_swap_tablet(key, handle, handle);
+  ret = handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, handle, handle, param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
   ASSERT_EQ(0, t3m_.tablet_buffer_pool_.inner_used_num_);
@@ -1289,7 +1315,9 @@ TEST_F(TestTenantMetaMemMgr, test_replace_tablet)
   tablet->is_inited_ = true; // to pass test
   tablet->table_store_addr_.addr_.set_none_addr();
 
-  ret = t3m_.compare_and_swap_tablet(key, old_handle, handle);
+  ret = handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  ret = t3m_.compare_and_swap_tablet(key, old_handle, handle, param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, t3m_.tablet_map_.map_.size());
   ASSERT_EQ(1, t3m_.tablet_buffer_pool_.inner_used_num_);
diff --git a/src/storage/ls/ob_ls_tablet_service.cpp b/src/storage/ls/ob_ls_tablet_service.cpp
index fe6c5477be..f11da7d0e8 100644
--- a/src/storage/ls/ob_ls_tablet_service.cpp
+++ b/src/storage/ls/ob_ls_tablet_service.cpp
@@ -695,6 +695,7 @@ int ObLSTabletService::table_rescan(ObTabletHandle &tablet_handle, ObTableScanPa
 int ObLSTabletService::refresh_tablet_addr(
     const share::ObLSID &ls_id,
     const common::ObTabletID &tablet_id,
+    const ObUpdateTabletPointerParam &param,
     ObTabletHandle &tablet_handle)
 {
   int ret = OB_SUCCESS;
@@ -717,8 +718,8 @@ int ObLSTabletService::refresh_tablet_addr(
   }
 
   if (OB_FAIL(ret)) {
-  } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle))) {
-    LOG_WARN("failed to add tablet to meta mem mgr", K(ret), K(key), K(tablet_handle));
+  } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle, param))) {
+    LOG_WARN("failed to add tablet to meta mem mgr", K(ret), K(key), K(tablet_handle), K(param));
   }
 
   return ret;
@@ -988,14 +989,17 @@ int ObLSTabletService::update_tablet_checkpoint(
       }
       LOG_WARN("fail to get old tablet addr", K(ret), K(key));
     } else if (!is_replay_old) {
+      ObUpdateTabletPointerParam param;
       if (OB_FAIL(t3m->get_tablet(WashTabletPriority::WTP_LOW, key, tablet_handle))) {
         LOG_WARN("fail to get tablet", K(ret), K(key));
       } else if (FALSE_IT(time_guard.click("GetOld"))) {
       } else if (OB_FAIL(refresh_memtable_for_ckpt(old_addr, addr, new_handle))) {
         LOG_WARN("fail to update tablet", K(ret), K(old_addr), K(addr), K(new_handle));
       } else if (FALSE_IT(time_guard.click("UpdateTablet"))) {
-      } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, new_handle))) {
-        LOG_WARN("fail to compare and swap tablet", K(ret), K(tablet_handle), K(new_handle));
+      } else if (OB_FAIL(new_handle.get_obj()->get_updating_tablet_pointer_param(param))) {
+        LOG_WARN("fail to get updating tablet pointer param", K(ret), KPC(new_handle.get_obj()));
+      } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, new_handle, param))) {
+        LOG_WARN("fail to compare and swap tablet", K(ret), K(tablet_handle), K(new_handle), K(param));
       }
     } else {
       time_guard.click("GetOld");
@@ -1396,13 +1400,17 @@ int ObLSTabletService::update_tablet_release_memtable_for_offline(
     if (is_from_buf_pool) {
       ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
       ObTabletHandle new_tablet_handle;
+      ObUpdateTabletPointerParam param;
       if (OB_FAIL(ObTabletPersister::copy_from_old_tablet(*tablet, new_tablet_handle))) {
         LOG_WARN("fail to copy from old tablet", K(ret), KPC(tablet));
       } else if (FALSE_IT(time_guard.click("CpTablet"))) {
       } else if (OB_FAIL(new_tablet_handle.get_obj()->rebuild_memtables(scn))) {
         LOG_WARN("fail to rebuild memtables", K(ret), K(scn), K(new_tablet_handle));
-      } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, new_tablet_handle))) {
-        LOG_ERROR("failed to compare and swap tablet", K(ret), K(key), K(tablet_handle), K(new_tablet_handle));
+      } else if (OB_FAIL(new_tablet_handle.get_obj()->get_updating_tablet_pointer_param(param,
+              false/*update tablet attr*/))) {
+        LOG_WARN("fail to get updating tablet pointer parameters", K(ret));
+      } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, new_tablet_handle, param))) {
+        LOG_ERROR("failed to compare and swap tablet", K(ret), K(key), K(tablet_handle), K(new_tablet_handle), K(param));
       } else {
         time_guard.click("CASwap");
         LOG_INFO("succeeded to copy tablet to release memtable", K(ret), K(key), K(tablet_handle), K(new_tablet_handle));
@@ -1423,7 +1431,7 @@ int ObLSTabletService::update_tablet_release_memtable_for_offline(
     } else if (OB_FAIL(tablet_handle.get_obj()->wait_release_memtables())) {
       LOG_ERROR("failed to release memtables", K(ret), K(tablet_id));
     } else if (OB_FAIL(inner_remove_tablet(ls_id, tablet_id))) {
-     LOG_ERROR("failed to do remove tablet", K(ret), K(ls_id), K(tablet_id));
+      LOG_ERROR("failed to do remove tablet", K(ret), K(ls_id), K(tablet_id));
     } else {
       time_guard.click("RmTablet");
     }
@@ -1454,21 +1462,16 @@ int ObLSTabletService::update_tablet_ddl_commit_scn(
     ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
     ObMetaDiskAddr disk_addr;
     ObUpdateDDLCommitSCN modifier(ddl_commit_scn);
+    ObUpdateTabletPointerParam param;
     ObTabletHandle new_handle;
     const ObTablet &old_tablet = *old_handle.get_obj();
     if (OB_FAIL(ObTabletPersister::persist_and_transform_only_tablet_meta(old_tablet, modifier, new_handle))) {
       LOG_WARN("fail to persist and transform only tablet meta", K(ret), K(old_tablet), K(ddl_commit_scn));
     } else if (FALSE_IT(time_guard.click("Persist"))) {
     } else if (FALSE_IT(disk_addr = new_handle.get_obj()->tablet_addr_)) {
-    } else if (OB_FAIL(ObTabletSlogHelper::write_update_tablet_slog(key.ls_id_, tablet_id, disk_addr))) {
-      LOG_WARN("failed to write update tablet slog", K(ret), K(key), K(disk_addr));
-    } else if (FALSE_IT(time_guard.click("WrSlog"))) {
-    } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, old_handle, new_handle))) {
-      LOG_ERROR("failed to compare and swap tablet", K(ret), K(key), K(old_handle), K(new_handle));
-      ob_usleep(1000 * 1000);
-      ob_abort();
+    } else if (OB_FAIL(safe_update_cas_tablet(key, disk_addr, old_handle, new_handle, time_guard))) {
+      LOG_WARN("fail to safe compare and swap tablet", K(ret), K(disk_addr), K(old_handle), K(new_handle));
     } else {
-      time_guard.click("CASwap");
       LOG_INFO("succeeded to update tablet ddl commit scn", K(ret), K(key), K(disk_addr), K(old_handle),
           K(new_handle), K(ddl_commit_scn), K(time_guard));
     }
@@ -2011,6 +2014,7 @@ int ObLSTabletService::create_tablet(
   if (OB_FAIL(ObTabletCreateDeleteHelper::prepare_create_msd_tablet())) {
     LOG_WARN("fail to prepare create msd tablet", K(ret));
   } else {
+    ObUpdateTabletPointerParam param;
     ObBucketHashWLockGuard lock_guard(bucket_lock_, key.tablet_id_.hash());
     if (OB_FAIL(ObTabletCreateDeleteHelper::create_msd_tablet(key, tablet_handle))) {
       LOG_WARN("failed to create msd tablet", K(ret), K(key));
@@ -2022,8 +2026,10 @@ int ObLSTabletService::create_tablet(
         create_scn, snapshot_version, create_tablet_schema, freezer))) {
       LOG_WARN("failed to init tablet", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
           K(create_scn), K(snapshot_version), K(create_tablet_schema));
-    } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle))) {
-      LOG_WARN("failed to compare and swap tablet", K(ret), K(key), K(tablet_handle));
+    } else if (OB_FAIL(tablet->get_updating_tablet_pointer_param(param))) {
+      LOG_WARN("fail to get updating tablet pointer parameters", K(ret), KPC(tablet));
+    } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle, param))) {
+      LOG_WARN("failed to compare and swap tablet", K(ret), K(key), K(tablet_handle), K(param));
     } else if (OB_FAIL(tablet_id_set_.set(tablet_id))) {
       LOG_WARN("fail to insert tablet id", K(ret), K(ls_id), K(tablet_id));
     } else {
@@ -2126,6 +2132,7 @@ int ObLSTabletService::create_transfer_in_tablet(
   if (FAILEDx(ObTabletCreateDeleteHelper::prepare_create_msd_tablet())) {
     LOG_WARN("failed to prepare create msd tablet", K(ret));
   } else {
+    ObUpdateTabletPointerParam param;
     ObBucketHashWLockGuard lock_guard(bucket_lock_, tablet_meta.tablet_id_.hash());
     time_guard.click("Lock");
     if (FAILEDx(ObTabletCreateDeleteHelper::create_msd_tablet(key, tablet_handle))) {
@@ -2136,8 +2143,10 @@ int ObLSTabletService::create_transfer_in_tablet(
       LOG_ERROR("new tablet is null", K(ret), KP(tablet), KP(allocator), K(tablet_handle));
     } else if (OB_FAIL(tablet->init_with_migrate_param(*allocator, tablet_meta, false/*is_update*/, freezer))) {
       LOG_WARN("failed to init tablet", K(ret), K(ls_id), K(tablet_meta));
-    } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle))) {
-      LOG_WARN("failed to compare and swap tablet", K(ret), K(key), K(tablet_handle));
+    } else if (OB_FAIL(tablet->get_updating_tablet_pointer_param(param))) {
+      LOG_WARN("fail to get updating tablet pointer parameters", K(ret), KPC(tablet));
+    } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle, param))) {
+      LOG_WARN("failed to compare and swap tablet", K(ret), K(key), K(tablet_handle), K(param));
     } else if (OB_FAIL(tablet_id_set_.set(tablet_meta.tablet_id_))) {
       LOG_WARN("fail to insert tablet id", K(ret), K(ls_id), K(tablet_meta));
     } else {
@@ -2268,6 +2277,7 @@ int ObLSTabletService::create_memtable(
     } else {
       time_guard.click("get tablet");
       ObTabletCreateDeleteMdsUserData user_data;
+      ObUpdateTabletPointerParam param;
       bool is_committed = false;
       ObTablet &old_tablet = *(old_tablet_handle.get_obj());
       // forbid create new memtable when transfer
@@ -2283,8 +2293,10 @@ int ObLSTabletService::create_memtable(
           LOG_WARN("fail to create memtable", K(ret), K(new_tablet_handle), K(schema_version), K(tablet_id));
         }
       } else if (FALSE_IT(time_guard.click("create memtable"))) {
-      } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, old_tablet_handle, old_tablet_handle))) {
-        LOG_WARN("fail to compare and swap tablet", K(ret), K(key), K(old_tablet_handle));
+      } else if (OB_FAIL(old_tablet.get_updating_tablet_pointer_param(param, false/*update tablet attr*/))) {
+        LOG_WARN("fail to get updating tablet pointer parameters", K(ret), K(old_tablet));
+      } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, old_tablet_handle, old_tablet_handle, param))) {
+        LOG_WARN("fail to compare and swap tablet", K(ret), K(key), K(old_tablet_handle), K(param));
       }
     }
   }
@@ -3474,12 +3486,15 @@ int ObLSTabletService::safe_update_cas_tablet(
     ObTimeGuard &time_guard)
 {
   int ret = OB_SUCCESS;
+  ObUpdateTabletPointerParam param;
   SLOG_CKPT_READ_GUARD
-  if (OB_FAIL(ObTabletSlogHelper::write_update_tablet_slog(key.ls_id_, key.tablet_id_, addr))) {
+  if (OB_FAIL(new_handle.get_obj()->get_updating_tablet_pointer_param(param))) {
+    LOG_WARN("fail to get updating tablet pointer parameters", K(ret), K(new_handle));
+  } else if (OB_FAIL(ObTabletSlogHelper::write_update_tablet_slog(key.ls_id_, key.tablet_id_, addr))) {
     LOG_WARN("fail to write update tablet slog", K(ret), K(key), K(addr));
   } else if (FALSE_IT(time_guard.click("WrSlog"))) {
-  } else if (OB_FAIL(MTL(ObTenantMetaMemMgr*)->compare_and_swap_tablet(key, old_handle, new_handle))) {
-    LOG_ERROR("failed to compare and swap tablet", K(ret), K(key), K(addr));
+  } else if (OB_FAIL(MTL(ObTenantMetaMemMgr*)->compare_and_swap_tablet(key, old_handle, new_handle, param))) {
+    LOG_ERROR("failed to compare and swap tablet", K(ret), K(key), K(addr), K(param));
     ob_usleep(1000 * 1000);
     ob_abort();
   } else {
@@ -3496,14 +3511,18 @@ int ObLSTabletService::safe_update_cas_empty_shell(
 {
   int ret = OB_SUCCESS;
   ObMetaDiskAddr addr;
+  ObUpdateTabletPointerParam param;
   ObTablet *tablet = new_handle.get_obj();
   SLOG_CKPT_READ_GUARD
-  if (OB_FAIL(ObTabletSlogHelper::write_empty_shell_tablet_slog(tablet, addr))) {
+  if (OB_FAIL(new_handle.get_obj()->get_updating_tablet_pointer_param(param))) {
+    LOG_WARN("fail to get updating tablet pointer parameters", K(ret), K(new_handle));
+  } else if (OB_FAIL(ObTabletSlogHelper::write_empty_shell_tablet_slog(tablet, addr))) {
     LOG_WARN("fail to write emtpy shell tablet slog", K(ret), K(key), K(new_handle));
   } else if (FALSE_IT(tablet->tablet_addr_ = addr)) {
+  } else if (FALSE_IT(param.tablet_addr_ = addr)) {
   } else if (FALSE_IT(time_guard.click("WrSlog"))) {
-  } else if (OB_FAIL(MTL(ObTenantMetaMemMgr*)->compare_and_swap_tablet(key, old_handle, new_handle))) {
-    LOG_ERROR("failed to compare and swap tablet", K(ret), K(key), K(old_handle), K(new_handle));
+  } else if (OB_FAIL(MTL(ObTenantMetaMemMgr*)->compare_and_swap_tablet(key, old_handle, new_handle, param))) {
+    LOG_ERROR("failed to compare and swap tablet", K(ret), K(key), K(old_handle), K(new_handle), K(param));
     ob_usleep(1000 * 1000);
     ob_abort();
   } else {
@@ -3520,12 +3539,15 @@ int ObLSTabletService::safe_create_cas_tablet(
     ObTimeGuard &time_guard)
 {
   int ret = OB_SUCCESS;
+  ObUpdateTabletPointerParam param;
   SLOG_CKPT_READ_GUARD
-  if (OB_FAIL(ObTabletSlogHelper::write_update_tablet_slog(ls_id, tablet_id, addr))) {
+  if (OB_FAIL(tablet_handle.get_obj()->get_updating_tablet_pointer_param(param))) {
+    LOG_WARN("fail to get updating tablet pointer parameters", K(ret), K(tablet_handle));
+  } else if (OB_FAIL(ObTabletSlogHelper::write_update_tablet_slog(ls_id, tablet_id, addr))) {
     LOG_WARN("fail to write update tablet slog", K(ret), K(ls_id), K(tablet_id), K(addr));
   } else if (FALSE_IT(time_guard.click("WrSlog"))) {
-  } else if (OB_FAIL(refresh_tablet_addr(ls_id, tablet_id, tablet_handle))) {
-    LOG_WARN("failed to refresh tablet addr", K(ret), K(ls_id), K(tablet_id), K(lbt()));
+  } else if (OB_FAIL(refresh_tablet_addr(ls_id, tablet_id, param, tablet_handle))) {
+    LOG_WARN("failed to refresh tablet addr", K(ret), K(ls_id), K(tablet_id), K(param), K(lbt()));
     ob_usleep(1000 * 1000);
     ob_abort();
   } else {
@@ -3542,14 +3564,18 @@ int ObLSTabletService::safe_create_cas_empty_shell(
 {
   int ret = OB_SUCCESS;
   ObTablet *tablet = tablet_handle.get_obj();
+  ObUpdateTabletPointerParam param;
   ObMetaDiskAddr addr;
   SLOG_CKPT_READ_GUARD
-  if (OB_FAIL(ObTabletSlogHelper::write_empty_shell_tablet_slog(tablet, addr))) {
+  if (OB_FAIL(tablet_handle.get_obj()->get_updating_tablet_pointer_param(param))) {
+    LOG_WARN("fail to get updating tablet pointer parameters", K(ret), K(tablet_handle));
+  } else if (OB_FAIL(ObTabletSlogHelper::write_empty_shell_tablet_slog(tablet, addr))) {
     LOG_WARN("fail to write emtpy shell tablet slog", K(ret), K(tablet_id), K(addr));
   } else if (FALSE_IT(tablet->tablet_addr_ = addr)) {
+  } else if (FALSE_IT(param.tablet_addr_ = addr)) {
   } else if (FALSE_IT(time_guard.click("WrSlog"))) {
-  } else if (OB_FAIL(refresh_tablet_addr(ls_id, tablet_id, tablet_handle))) {
-    LOG_WARN("failed to refresh tablet addr", K(ret), K(ls_id), K(tablet_id), K(lbt()));
+  } else if (OB_FAIL(refresh_tablet_addr(ls_id, tablet_id, param, tablet_handle))) {
+    LOG_WARN("failed to refresh tablet addr", K(ret), K(ls_id), K(tablet_id), K(param), K(lbt()));
     ob_usleep(1000 * 1000);
     ob_abort();
   } else {
diff --git a/src/storage/ls/ob_ls_tablet_service.h b/src/storage/ls/ob_ls_tablet_service.h
index 6405571668..f869eaea6c 100644
--- a/src/storage/ls/ob_ls_tablet_service.h
+++ b/src/storage/ls/ob_ls_tablet_service.h
@@ -545,6 +545,7 @@ private:
   int refresh_tablet_addr(
       const share::ObLSID &ls_id,
       const common::ObTabletID &tablet_id,
+      const ObUpdateTabletPointerParam &param,
       ObTabletHandle &tablet_handle);
   int inner_remove_tablet(
       const share::ObLSID &ls_id,
diff --git a/src/storage/meta_mem/ob_tablet_pointer.cpp b/src/storage/meta_mem/ob_tablet_pointer.cpp
index 7c1189eafd..f5244d1160 100644
--- a/src/storage/meta_mem/ob_tablet_pointer.cpp
+++ b/src/storage/meta_mem/ob_tablet_pointer.cpp
@@ -155,7 +155,7 @@ int ObTabletPointer::read_from_disk(
   return ret;
 }
 
-int ObTabletPointer::hook_obj(ObTablet *&t,  ObMetaObjGuard<ObTablet> &guard)
+int ObTabletPointer::hook_obj(const ObTabletAttr &attr, ObTablet *&t,  ObMetaObjGuard<ObTablet> &guard)
 {
   int ret = OB_SUCCESS;
   guard.reset();
@@ -175,7 +175,7 @@ int ObTabletPointer::hook_obj(ObTablet *&t,  ObMetaObjGuard<ObTablet> &guard)
     obj_.ptr_ = t;
     guard.set_obj(obj_);
     ObMetaObjBufferHelper::set_in_map(reinterpret_cast<char *>(t), true/*in_map*/);
-    if (!is_attr_valid() && OB_FAIL(set_tablet_attr(*t))) { // only set tablet attr when first hook obj
+    if (!is_attr_valid() && OB_FAIL(set_tablet_attr(attr))) { // only set tablet attr when first hook obj
       STORAGE_LOG(WARN, "failed to update tablet attr", K(ret), K(guard));
     }
   }
@@ -657,16 +657,14 @@ int ObTabletPointer::release_obj(ObTablet *&t)
   return ret;
 }
 
-int ObTabletPointer::set_tablet_attr(ObTablet &tablet)
+int ObTabletPointer::set_tablet_attr(const ObTabletAttr &attr)
 {
   int ret = OB_SUCCESS;
-  attr_.reset();
-  if (OB_FAIL(tablet.calc_tablet_attr(attr_))) {
-    if (OB_ALLOCATE_MEMORY_FAILED == ret) {
-      ret = OB_SUCCESS; // the invalid attr is allowed
-    } else {
-      STORAGE_LOG(WARN, "failed to update tablet attr", K(ret), K(tablet));
-    }
+  if (OB_UNLIKELY(!attr.is_valid())) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid arguments", K(ret), K(attr));
+  } else {
+    attr_ = attr;
   }
   return ret;
 }
diff --git a/src/storage/meta_mem/ob_tablet_pointer.h b/src/storage/meta_mem/ob_tablet_pointer.h
index da13ad7164..793765c10b 100644
--- a/src/storage/meta_mem/ob_tablet_pointer.h
+++ b/src/storage/meta_mem/ob_tablet_pointer.h
@@ -98,7 +98,7 @@ public:
       const char *buf,
       const int64_t buf_len,
       ObTablet *t);
-  int hook_obj(ObTablet *&t, ObMetaObjGuard<ObTablet> &guard);
+  int hook_obj(const ObTabletAttr &attr, ObTablet *&t, ObMetaObjGuard<ObTablet> &guard);
   int release_obj(ObTablet *&t);
   int dump_meta_obj(ObMetaObjGuard<ObTablet> &guard, void *&free_obj);
 
@@ -123,7 +123,7 @@ public:
   int get_min_mds_ckpt_scn(share::SCN &scn);
   ObLS *get_ls() const;
   // the RW operations of tablet_attr are protected by lock guard of tablet_map_
-  int set_tablet_attr(ObTablet &tablet);
+  int set_tablet_attr(const ObTabletAttr &attr);
   bool is_attr_valid() const { return attr_.is_valid(); }
 private:
   int wash_obj();
@@ -144,7 +144,9 @@ private:
   DISALLOW_COPY_AND_ASSIGN(ObTabletPointer); // 288B
 };
 
-struct ObTabletResidentInfo final {
+struct ObTabletResidentInfo final
+{
+public:
   ObTabletResidentInfo(ObTabletAttr &attr, ObTabletID &tablet_id, share::ObLSID &ls_id)
   : attr_(attr), tablet_addr_(), tablet_id_(tablet_id), ls_id_(ls_id)
     {}
@@ -158,10 +160,10 @@ struct ObTabletResidentInfo final {
   bool has_nested_table() const { return attr_.has_nested_table_; }
   TO_STRING_KV(K_(ls_id), K_(tablet_id), K_(tablet_addr), K_(attr));
 public:
-	ObTabletAttr &attr_;
+  ObTabletAttr &attr_;
   ObMetaDiskAddr tablet_addr_; // used to identify one tablet
-	ObTabletID tablet_id_;
-	share::ObLSID ls_id_;
+  ObTabletID tablet_id_;
+  share::ObLSID ls_id_;
 };
 
 class ObITabletFilterOp
diff --git a/src/storage/meta_mem/ob_tablet_pointer_map.cpp b/src/storage/meta_mem/ob_tablet_pointer_map.cpp
index c056860ab4..0600cd6e29 100644
--- a/src/storage/meta_mem/ob_tablet_pointer_map.cpp
+++ b/src/storage/meta_mem/ob_tablet_pointer_map.cpp
@@ -323,14 +323,14 @@ int ObTabletPointerMap::load_and_hook_meta_obj(
 {
   int ret = OB_SUCCESS;
   uint64_t hash_val = 0;
-  ObMetaDiskAddr disk_addr;
+  ObUpdateTabletPointerParam update_pointer_param;
   ObTabletPointer *meta_pointer = ptr_hdl.get_resource_ptr();
   do {
     bool need_free_obj = false;
     ObTablet *t = nullptr;
     // Move load obj from disk out of the bucket lock, because
     // wash obj may acquire the bucket lock again, which cause dead lock.
-    if (OB_FAIL(load_meta_obj(key, meta_pointer, disk_addr, t))) {
+    if (OB_FAIL(load_meta_obj(key, meta_pointer, update_pointer_param, t))) {
       STORAGE_LOG(WARN, "load obj from disk fail", K(ret), K(key), KPC(meta_pointer), K(lbt()));
     } else if (OB_FAIL(ResourceMap::hash_func_(key, hash_val))) {
       STORAGE_LOG(WARN, "fail to calc hash", K(ret), K(key));
@@ -348,18 +348,18 @@ int ObTabletPointerMap::load_and_hook_meta_obj(
           if (OB_FAIL(meta_pointer->get_in_memory_obj(guard))) {
             STORAGE_LOG(WARN, "fail to get meta object", K(ret), KP(meta_pointer));
           }
-        } else if (OB_UNLIKELY(disk_addr != meta_pointer->get_addr()
+        } else if (OB_UNLIKELY(update_pointer_param.tablet_addr_ != meta_pointer->get_addr()
             || meta_pointer != tmp_ptr_hdl.get_resource_ptr()
             || meta_pointer->get_addr() != tmp_ptr_hdl.get_resource_ptr()->get_addr())) {
           ret = OB_ITEM_NOT_MATCH;
           need_free_obj = true;
           if (REACH_TIME_INTERVAL(1000000)) {
-            STORAGE_LOG(WARN, "disk address or pointer change", K(ret), K(disk_addr), KPC(meta_pointer),
+            STORAGE_LOG(WARN, "disk address or pointer change", K(ret), K(update_pointer_param), KPC(meta_pointer),
                 KPC(tmp_ptr_hdl.get_resource_ptr()));
           }
         } else {
-          if (OB_FAIL(meta_pointer->hook_obj(t, guard))) {
-            STORAGE_LOG(WARN, "fail to hook object", K(ret), KP(meta_pointer));
+          if (OB_FAIL(meta_pointer->hook_obj(update_pointer_param.tablet_attr_, t, guard))) {
+            STORAGE_LOG(WARN, "fail to hook object", K(ret), K(update_pointer_param), KP(meta_pointer));
           }
         }
       } // write lock end
@@ -428,7 +428,7 @@ int ObTabletPointerMap::load_meta_obj(
 int ObTabletPointerMap::load_meta_obj(
     const ObTabletMapKey &key,
     ObTabletPointer *meta_pointer,
-    ObMetaDiskAddr &load_addr,
+    ObUpdateTabletPointerParam &update_pointer_param,
     ObTablet *&t)
 {
   int ret = common::OB_SUCCESS;
@@ -447,6 +447,7 @@ int ObTabletPointerMap::load_meta_obj(
     {
       common::ObBucketHashRLockGuard lock_guard(ResourceMap::bucket_lock_, hash_val);
       ObTabletPointerHandle tmp_ptr_hdl(*this);
+      ObMetaDiskAddr load_addr;
       // check whether the tablet has been deleted
       if (OB_FAIL(ResourceMap::get_without_lock(key, tmp_ptr_hdl))) {
         if (common::OB_ENTRY_NOT_EXIST != ret) {
@@ -462,6 +463,8 @@ int ObTabletPointerMap::load_meta_obj(
         t->tablet_addr_ = load_addr;
         if (OB_FAIL(meta_pointer->deserialize(buf, buf_len, t))) {
           STORAGE_LOG(WARN, "fail to deserialize object", K(ret), K(key), KPC(meta_pointer));
+        } else if (OB_FAIL(t->get_updating_tablet_pointer_param(update_pointer_param))) {
+          STORAGE_LOG(WARN, "fail to get updating tablet pointer parameters", K(ret), KPC(t));
         }
       }
     }
@@ -650,14 +653,15 @@ int ObTabletPointerMap::get_attr_for_obj(const ObTabletMapKey &key, ObMetaObjGua
 
 int ObTabletPointerMap::compare_and_swap_addr_and_object(
     const ObTabletMapKey &key,
-    const ObMetaDiskAddr &new_addr,
     const ObMetaObjGuard<ObTablet> &old_guard,
-    ObMetaObjGuard<ObTablet> &new_guard)
+    const ObMetaObjGuard<ObTablet> &new_guard,
+    const ObUpdateTabletPointerParam &update_pointer_param)
 {
   int ret = common::OB_SUCCESS;
   ObTabletPointerHandle ptr_hdl(*this);
   ObTabletPointer *t_ptr = nullptr;
   ObMetaObjGuard<ObTablet> ptr_guard;
+  const ObMetaDiskAddr &new_addr = update_pointer_param.tablet_addr_;
   uint64_t hash_val = 0;
 
   if (OB_FAIL(ResourceMap::hash_func_(key, hash_val))) {
@@ -696,8 +700,8 @@ int ObTabletPointerMap::compare_and_swap_addr_and_object(
       if (t_ptr->get_addr().is_equal_for_persistence(new_addr)) {
         // no need to update tablet attr, including creating memtables or updating the same tablets
         STORAGE_LOG(DEBUG, "no need to update tablet attr", K(ret), K(new_addr), K(t_ptr->get_addr()), K(new_guard), K(old_guard));
-      } else if (OB_FAIL(t_ptr->set_tablet_attr(*new_guard.get_obj()))) {
-        STORAGE_LOG(WARN, "failed to update tablet attr", K(ret), K(key), K(new_addr), K(new_guard));
+      } else if (OB_FAIL(t_ptr->set_tablet_attr(update_pointer_param.tablet_attr_))) {
+        STORAGE_LOG(WARN, "failed to update tablet attr", K(ret), K(key), KPC(t_ptr), K(update_pointer_param));
       }
 
       if (OB_SUCC(ret)) {
diff --git a/src/storage/meta_mem/ob_tablet_pointer_map.h b/src/storage/meta_mem/ob_tablet_pointer_map.h
index e559aac22d..256e6ed126 100644
--- a/src/storage/meta_mem/ob_tablet_pointer_map.h
+++ b/src/storage/meta_mem/ob_tablet_pointer_map.h
@@ -26,6 +26,18 @@ namespace oceanbase
 namespace storage
 {
 
+struct ObUpdateTabletPointerParam final
+{
+public:
+  ObUpdateTabletPointerParam() = default;
+  ~ObUpdateTabletPointerParam() = default;
+  bool is_valid() const { return tablet_addr_.is_valid(); }
+  TO_STRING_KV(K_(tablet_addr), K_(tablet_attr));
+public:
+  ObMetaDiskAddr tablet_addr_;
+  ObTabletAttr tablet_attr_;
+};
+
 class ObTabletPointerMap : public ObResourceMap<ObTabletMapKey, ObTabletPointer>
 {
 public:
@@ -50,9 +62,9 @@ public:
   int get_attr_for_obj(const ObTabletMapKey &key, ObMetaObjGuard<ObTablet> &guard);
   int compare_and_swap_addr_and_object(
       const ObTabletMapKey &key,
-      const ObMetaDiskAddr &new_addr,
       const ObMetaObjGuard<ObTablet> &old_guard,
-      ObMetaObjGuard<ObTablet> &new_guard);
+      const ObMetaObjGuard<ObTablet> &new_guard,
+      const ObUpdateTabletPointerParam &update_pointer_param);
   // TIPS:
   //  - only compare and swap pure address, but no reset object.
   // only used for replay and compat, others mustn't call this func
@@ -78,7 +90,7 @@ private:
   int load_meta_obj(
       const ObTabletMapKey &key,
       ObTabletPointer *meta_pointer,
-      ObMetaDiskAddr &load_addr,
+      ObUpdateTabletPointerParam &updata_pointer_param,
       ObTablet *&t);
   int load_and_hook_meta_obj(const ObTabletMapKey &key, ObTabletPointerHandle &ptr_hdl, ObMetaObjGuard<ObTablet> &guard);
   int try_get_in_memory_meta_obj(
diff --git a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp
index 29a8f50448..c0d859be81 100644
--- a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp
+++ b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.cpp
@@ -725,7 +725,9 @@ int ObTenantMetaMemMgr::gc_tablet(ObTablet *tablet)
   if (OB_SUCC(ret) && OB_FAIL(push_tablet_into_gc_queue(tablet))) {
     LOG_WARN("fail to push tablet into gc queue", K(ret), KPC(tablet));
   }
-  FLOG_INFO("gc tablet", K(ret), KP(tablet), K(common::lbt()));
+#ifdef OB_BUILD_RPM
+  FLOG_INFO("push tablet into gc queue", K(ret), KP(tablet), K(common::lbt()));
+#endif
   return ret;
 }
 
@@ -1885,7 +1887,8 @@ int ObTenantMetaMemMgr::del_tablet(const ObTabletMapKey &key)
 int ObTenantMetaMemMgr::compare_and_swap_tablet(
     const ObTabletMapKey &key,
     const ObTabletHandle &old_handle,
-    ObTabletHandle &new_handle)
+    const ObTabletHandle &new_handle,
+    const ObUpdateTabletPointerParam &update_pointer_param)
 {
   TIMEGUARD_INIT(STORAGE, 10_ms);
   int ret = OB_SUCCESS;
@@ -1905,15 +1908,14 @@ int ObTenantMetaMemMgr::compare_and_swap_tablet(
                       || !new_handle.is_valid()
                       || !old_handle.is_valid()
                       || new_handle.is_tmp_tablet()
-                      // TODO jingzhu : uncomment following code
-                      // || !(new_addr.is_memory() || new_addr.is_block())
+                      || !update_pointer_param.is_valid()
                       )) {
     ret = OB_INVALID_ARGUMENT;
-    LOG_WARN("invalid argument", K(ret), K(key), K(new_addr), K(old_handle), K(new_handle));
+    LOG_WARN("invalid argument", K(ret), K(key), K(new_addr), K(old_handle), K(new_handle), K(update_pointer_param));
   } else {
     ObBucketHashWLockGuard lock_guard(bucket_lock_, key.hash());
-    if (CLICK_FAIL(tablet_map_.compare_and_swap_addr_and_object(key, new_addr, old_handle, new_handle))) {
-      LOG_WARN("fail to compare and swap tablet", K(ret), K(key), K(new_addr), K(old_handle), K(new_handle));
+    if (CLICK_FAIL(tablet_map_.compare_and_swap_addr_and_object(key, old_handle, new_handle, update_pointer_param))) {
+      LOG_WARN("fail to compare and swap tablet", K(ret), K(key), K(old_handle), K(new_handle), K(update_pointer_param));
     } else if (CLICK_FAIL(update_tablet_buffer_header(old_handle.get_obj(), new_handle.get_obj()))) {
       LOG_WARN("fail to update tablet buffer header", K(ret), K(old_handle), K(new_handle));
     } else if (old_handle.get_obj() != new_handle.get_obj()) { // skip first init, old_handle == new_handle
diff --git a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h
index 5d5c9f2f2d..9c19567ae4 100644
--- a/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h
+++ b/src/storage/meta_mem/ob_tenant_meta_mem_mgr.h
@@ -272,7 +272,8 @@ public:
   int compare_and_swap_tablet(
       const ObTabletMapKey &key,
       const ObTabletHandle &old_handle,
-      ObTabletHandle &new_handle);
+      const ObTabletHandle &new_handle,
+      const ObUpdateTabletPointerParam &update_tablet_pointer_param);
   int update_tablet_buffer_header(ObTablet *old_obj, ObTablet *new_obj);
   int try_wash_tablet(const std::type_info &type_info, void *&obj);
   int get_meta_mem_status(common::ObIArray<ObTenantMetaMemStatus> &info) const;
diff --git a/src/storage/tablet/ob_tablet.cpp b/src/storage/tablet/ob_tablet.cpp
index 3060dd6ecd..df07c0177a 100644
--- a/src/storage/tablet/ob_tablet.cpp
+++ b/src/storage/tablet/ob_tablet.cpp
@@ -5629,7 +5629,23 @@ int ObTablet::get_storage_schema_for_transfer_in(
   return ret;
 }
 
-int ObTablet::calc_tablet_attr(ObTabletAttr &attr)
+int ObTablet::get_updating_tablet_pointer_param(
+    ObUpdateTabletPointerParam &param,
+    const bool need_tablet_attr /*= true*/) const
+{
+  int ret = OB_SUCCESS;
+  if (IS_NOT_INIT) {
+    ret = OB_NOT_INIT;
+    LOG_WARN("this tablet hasn't be initialized", K(ret), KPC(this));
+  } else if (need_tablet_attr && OB_FAIL(calc_tablet_attr(param.tablet_attr_))) {
+    LOG_WARN("fail to calculate tablet attributes", K(ret));
+  } else {
+    param.tablet_addr_ = tablet_addr_;
+  }
+  return ret;
+}
+
+int ObTablet::calc_tablet_attr(ObTabletAttr &attr) const
 {
   int ret = OB_SUCCESS;
   attr.reset();
diff --git a/src/storage/tablet/ob_tablet.h b/src/storage/tablet/ob_tablet.h
index f15af731d8..592bc4338f 100644
--- a/src/storage/tablet/ob_tablet.h
+++ b/src/storage/tablet/ob_tablet.h
@@ -103,6 +103,7 @@ class ObDDLKVHandle;
 class ObStorageSchema;
 class ObTabletTableIterator;
 class ObMetaDiskAddr;
+class ObUpdateTabletPointerParam;
 class ObTabletCreateDeleteMdsUserData;
 class ObTabletBindingMdsUserData;
 class ObMemtableArray;
@@ -821,7 +822,12 @@ private:
   int mark_mds_table_switched_to_empty_shell_();
   int fetch_autoinc_seq(ObTabletMemberWrapper<share::ObTabletAutoincSeq> &wrapper) const;
   int handle_transfer_replace_(const ObBatchUpdateTableStoreParam &param);
-  int calc_tablet_attr(ObTabletAttr &attr);
+  // NOTICE:
+  // - Because the `calc_tablet_attr()` may has I/O operations, you can bypass it if wantn't to update it.
+  int get_updating_tablet_pointer_param(
+      ObUpdateTabletPointerParam &param,
+      const bool need_tablet_attr = true) const;
+  int calc_tablet_attr(ObTabletAttr &attr) const;
 private:
   // ObTabletDDLKvMgr::MAX_DDL_KV_CNT_IN_STORAGE
   // Array size is too large, need to shrink it if possible
diff --git a/unittest/storage/test_tablet_helper.h b/unittest/storage/test_tablet_helper.h
index 97fae43bcf..a759ab2046 100644
--- a/unittest/storage/test_tablet_helper.h
+++ b/unittest/storage/test_tablet_helper.h
@@ -158,8 +158,11 @@ inline int TestTabletHelper::create_tablet(
       }
     }
 
-    if (FAILEDx(t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle))) {
-      STORAGE_LOG(WARN, "failed to compare and swap tablet", K(ret), K(ls_id), K(tablet_id));
+    ObUpdateTabletPointerParam param;
+    if (FAILEDx(tablet_handle.get_obj()->get_updating_tablet_pointer_param(param))) {
+      STORAGE_LOG(WARN, "fail to get updating tablet pointer parameters", K(ret), K(tablet_handle));
+    } else if (OB_FAIL(t3m->compare_and_swap_tablet(key, tablet_handle, tablet_handle, param))) {
+      STORAGE_LOG(WARN, "failed to compare and swap tablet", K(ret), K(ls_id), K(tablet_id), K(param));
     } else if (OB_FAIL(ls_tablet_svr->tablet_id_set_.set(tablet_id))){
       STORAGE_LOG(WARN, "set tablet id failed", K(ret), K(tablet_id));
     } else {
@@ -207,9 +210,12 @@ inline int TestTabletHelper::remove_tablet(const ObLSHandle &ls_handle, const Ob
   } else {
     tablet_handle.get_obj()->mds_data_.tablet_status_.committed_kv_.get_ptr()->v_.user_data_.assign(buf, data_serialize_size);
     ObMetaDiskAddr disk_addr;
+    ObUpdateTabletPointerParam param;
     disk_addr.set_mem_addr(0, sizeof(ObTablet));
-    if(OB_FAIL(t3m->compare_and_swap_tablet(
-            ObTabletMapKey(ls_id, tablet_id), tablet_handle, tablet_handle))) {
+    if (OB_FAIL(tablet_handle.get_obj()->get_updating_tablet_pointer_param(param))) {
+      STORAGE_LOG(WARN, "fail to get updating tablet pointer parameters", K(ret), K(tablet_handle));
+    } else if(OB_FAIL(t3m->compare_and_swap_tablet(
+            ObTabletMapKey(ls_id, tablet_id), tablet_handle, tablet_handle, param))) {
       STORAGE_LOG(WARN, "failed to compare and swap tablet", K(ret), K(ls_id), K(tablet_id), K(disk_addr));
     }
   }
diff --git a/unittest/storage/test_tablet_pointer_map.cpp b/unittest/storage/test_tablet_pointer_map.cpp
index c02bbd6992..f5b00e1cc4 100644
--- a/unittest/storage/test_tablet_pointer_map.cpp
+++ b/unittest/storage/test_tablet_pointer_map.cpp
@@ -264,7 +264,11 @@ TEST_F(TestMetaPointerMap, test_meta_pointer_map)
 
   old_tablet->is_inited_ = true;
   old_tablet->table_store_addr_.addr_.set_none_addr(); // mock empty_shell to pass test
-  ret = tablet_map_.compare_and_swap_addr_and_object(key, phy_addr, handle, handle);
+  ObUpdateTabletPointerParam param;
+  ret = handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  param.tablet_addr_ = phy_addr;
+  ret = tablet_map_.compare_and_swap_addr_and_object(key, handle, handle, param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
 
   ObTablet *tablet = new ObTablet();
@@ -277,7 +281,10 @@ TEST_F(TestMetaPointerMap, test_meta_pointer_map)
 
   tablet->is_inited_ = true;
   tablet->table_store_addr_.addr_.set_none_addr(); // mock empty_shell to pass test
-  ret = tablet_map_.compare_and_swap_addr_and_object(key, phy_addr, handle, tablet_handle);
+  ret = handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  param.tablet_addr_ = phy_addr;
+  ret = tablet_map_.compare_and_swap_addr_and_object(key, handle, tablet_handle, param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
   ASSERT_EQ(1, tablet_map_.map_.size());
 
@@ -354,7 +361,11 @@ TEST_F(TestMetaPointerMap, test_erase_and_load_concurrency)
   old_tablet->is_inited_ = true;
   old_tablet->table_store_addr_.addr_.set_none_addr(); // mock empty_shell to pass test
 
-  ret = tablet_map_.compare_and_swap_addr_and_object(key, phy_addr, handle, handle);
+  ObUpdateTabletPointerParam param;
+  ret = handle.get_obj()->get_updating_tablet_pointer_param(param);
+  ASSERT_EQ(common::OB_SUCCESS, ret);
+  param.tablet_addr_ = phy_addr;
+  ret = tablet_map_.compare_and_swap_addr_and_object(key, handle, handle, param);
   ASSERT_EQ(common::OB_SUCCESS, ret);
 
   ObTabletPointerHandle ptr_hdl(tablet_map_);