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

[FEAT MERGE] Big Txn Execution Optimization

Browse Source
This commit is contained in:
Handora
2023-01-06 09:12:22 +00:00
committed by ob-robot
parent 4dfd67d8fb
commit 561432c689
141 changed files with 7806 additions and 2574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
unittest/storage/memtable/test_memtable_basic.cpp
View File

@ -95,6 +95,22 @@ int ObMvccRow::check_double_insert_(const share::SCN ,
{
return OB_SUCCESS;
}
}
namespace concurrent_control
{
int check_sequence_set_violation(const concurrent_control::ObWriteFlag ,
const int64_t ,
const ObTransID ,
const blocksstable::ObDmlFlag ,
const int64_t ,
const ObTransID ,
const blocksstable::ObDmlFlag ,
const int64_t )
{
return OB_SUCCESS;
}
} // end memtable
class TestMemtable : public testing::Test
@ -210,6 +226,7 @@ public:
ObStoreCtx store_ctx;
ObTxSnapshot snapshot;
ObTxTableGuard tx_table_guard;
concurrent_control::ObWriteFlag write_flag;
tx_table_guard.init((ObTxTable*)0x100);
snapshot.version_.convert_for_gts(snapshot_version);
store_ctx.mvcc_acc_ctx_.init_write(trans_ctx_,
@ -220,7 +237,8 @@ public:
tx_table_guard,
snapshot,
INT64_MAX,
INT64_MAX);
INT64_MAX,
write_flag);
ObTableStoreIterator table_iter;
store_ctx.table_iter_ = &table_iter;
ObStoreRow write_row;

6
unittest/storage/test_compaction_policy.cpp
View File

@ -626,7 +626,11 @@ int TestCompactionPolicy::prepare_freeze_info(
if (OB_ISNULL(mgr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("mgr is unexpected null", K(ret));
} else if (OB_FAIL(mgr->update_info(snapshot_gc_ts, freeze_infos, snapshots, min_major_snapshot, changed))) {
} else if (OB_FAIL(mgr->update_info(snapshot_gc_ts,
freeze_infos,
snapshots,
min_major_snapshot,
changed))) {
LOG_WARN("failed to update info", K(ret));
}
return ret;

15
unittest/storage/tx/it/test_tx.cpp
View File

@ -27,6 +27,21 @@ using namespace ::testing;
using namespace transaction;
using namespace share;
namespace concurrent_control
{
int check_sequence_set_violation(const concurrent_control::ObWriteFlag ,
const int64_t ,
const ObTransID ,
const blocksstable::ObDmlFlag ,
const int64_t ,
const ObTransID ,
const blocksstable::ObDmlFlag ,
const int64_t )
{
return OB_SUCCESS;
}
}
namespace common
{
void* ObGMemstoreAllocator::alloc(AllocHandle& handle, int64_t size)

4
unittest/storage/tx/it/tx_node.cpp
View File

@ -484,8 +484,10 @@ int ObTxNode::write(ObTxDesc &tx,
write_store_ctx.ls_ = &mock_ls_;
write_store_ctx.ls_id_ = ls_id_;
write_store_ctx.table_iter_ = iter;
concurrent_control::ObWriteFlag write_flag;
OZ(txs_.get_write_store_ctx(tx,
snapshot,
write_flag,
write_store_ctx));
write_store_ctx.mvcc_acc_ctx_.tx_table_guard_.init(&fake_tx_table_);
ObArenaAllocator allocator;
@ -517,8 +519,10 @@ int ObTxNode::write_begin(ObTxDesc &tx,
iter->add_tables(&mtb, 1);
write_store_ctx.ls_id_ = ls_id_;
write_store_ctx.table_iter_ = iter;
concurrent_control::ObWriteFlag write_flag;
OZ(txs_.get_write_store_ctx(tx,
snapshot,
write_flag,
write_store_ctx));
return ret;
}

71
unittest/storage/tx/mock_utils/basic_fake_define.h
View File

@ -13,6 +13,9 @@
#ifndef OCEANBASE_TRANSACTION_TEST_BASIC_FAKE_DEFINE_
#define OCEANBASE_TRANSACTION_TEST_BASIC_FAKE_DEFINE_
#define protected public
#define private public
#include "storage/tx/ob_trans_define.h"
#include "storage/tx_table/ob_tx_table.h"
#include "lib/utility/ob_defer.h"
@ -27,74 +30,92 @@
namespace oceanbase {
using namespace share;
using namespace memtable;
namespace transaction {
class ObFakeTxDataTable : public ObTxDataTable {
public:
ObFakeTxDataTable() : map_() { IGNORE_RETURN map_.init(); }
ObFakeTxDataTable() : map_(1 << 20 /*2097152*/)
{
IGNORE_RETURN map_.init();
ObMemAttr mem_attr;
mem_attr.label_ = "TX_DATA_TABLE";
mem_attr.tenant_id_ = 1;
mem_attr.ctx_id_ = ObCtxIds::DEFAULT_CTX_ID;
ObMemtableMgrHandle memtable_mgr_handle;
OB_ASSERT(OB_SUCCESS == slice_allocator_.init(
sizeof(ObTxData), OB_MALLOC_NORMAL_BLOCK_SIZE, common::default_blk_alloc, mem_attr));
slice_allocator_.set_nway(ObTxDataTable::TX_DATA_MAX_CONCURRENCY);
is_inited_ = true;
}
virtual int init(ObLS *ls, ObTxCtxTable *tx_ctx_table) override
{ return OB_SUCCESS; }
{
return OB_SUCCESS;
}
virtual int start() override { return OB_SUCCESS; }
virtual void stop() override {}
virtual void reset() override {}
virtual void destroy() override {}
virtual int alloc_tx_data(ObTxData *&tx_data) override
virtual int alloc_tx_data(ObTxDataGuard &tx_data_guard) override
{
return map_.alloc_value(tx_data);
void *ptr = slice_allocator_.alloc();
ObTxData *tx_data = new (ptr) ObTxData();
tx_data->ref_cnt_ = 100;
tx_data->slice_allocator_ = &slice_allocator_;
tx_data->flag_ = 269381;
tx_data_guard.init(tx_data);
return OB_ISNULL(tx_data) ? OB_ALLOCATE_MEMORY_FAILED : OB_SUCCESS;
}
virtual int deep_copy_tx_data(ObTxData *from, ObTxData *&to) override
virtual int deep_copy_tx_data(const ObTxDataGuard &from_guard, ObTxDataGuard &to_guard) override
{
int ret = OB_SUCCESS;
OZ (map_.alloc_value(to));
void *ptr = slice_allocator_.alloc();
ObTxData *to = new (ptr) ObTxData();
ObTxData *from = (ObTxData*)from_guard.tx_data();
to->ref_cnt_ = 100;
to->slice_allocator_ = &slice_allocator_;
to->flag_ = 269381;
to_guard.init(to);
OX (*to = *from);
OZ (deep_copy_undo_status_list_(from->undo_status_list_, to->undo_status_list_));
return ret;
}
virtual void free_tx_data(ObTxData *tx_data) override
virtual void free_tx_data(ObTxData *tx_data)
{
map_.free_value(tx_data);
}
virtual int alloc_undo_status_node(ObUndoStatusNode *&undo_status_node) override
{
undo_status_node = new ObUndoStatusNode();
void *ptr = ob_malloc(TX_DATA_SLICE_SIZE);
undo_status_node = new (ptr) ObUndoStatusNode();
return OB_SUCCESS;
}
virtual int free_undo_status_node(ObUndoStatusNode *&undo_status_node) override
{
delete undo_status_node;
return OB_SUCCESS;
}
virtual int insert(ObTxData *&tx_data) override
{
int ret = OB_SUCCESS;
ObTxData *old = NULL;
if (OB_SUCC(map_.get(tx_data->tx_id_, old))) {
OX (map_.revert(old));
OZ (map_.del(tx_data->tx_id_));
} else if (OB_ENTRY_NOT_EXIST == ret) {
ret = OB_SUCCESS;
}
OZ (map_.insert_and_get(tx_data->tx_id_, tx_data));
OX (map_.revert(tx_data));
OZ (map_.insert(tx_data->tx_id_, tx_data));
return ret;
}
virtual int check_with_tx_data(const ObTransID tx_id, ObITxDataCheckFunctor &fn) override
{
int ret = OB_SUCCESS;
ObTxData *tx_data = NULL;
OZ (map_.get(tx_id, tx_data));
OZ (fn(*tx_data));
if (OB_NOT_NULL(tx_data)) { map_.revert(tx_data); }
ObTxDataGuard tx_data_guard;
OZ (map_.get(tx_id, tx_data_guard));
OZ (fn(*tx_data_guard.tx_data()));
if (OB_ENTRY_NOT_EXIST == ret) { ret = OB_TRANS_CTX_NOT_EXIST; }
return ret;
}
common::ObLinkHashMap<ObTransID, ObTxData> map_;
ObTxDataHashMap map_;
};
class ObFakeTxTable : public ObTxTable {
public:
ObFakeTxTable() : ObTxTable(tx_data_table_) {}
private:
public:
ObFakeTxDataTable tx_data_table_;
};

1
unittest/storage/tx/ob_mock_tx_ctx.cpp
View File

@ -430,4 +430,5 @@ void MockObTxCtx::set_exiting_()
}
} // end namespace transaction
} // end namespace oceanbase

2
unittest/storage/tx/test_simple_tx_ctx.cpp
View File

@ -14,6 +14,8 @@
#include <vector>
#define private public
#define protected public
#define UNITTEST
#include "storage/tx/ob_mock_tx_ctx.h"
namespace oceanbase

3
unittest/storage/tx_table/test_tx_ctx_table.cpp
View File

@ -14,6 +14,7 @@
#define protected public
#define private public
#define UNITTEST
#include <vector>
#include "storage/meta_mem/ob_tenant_meta_mem_mgr.h"
@ -259,7 +260,7 @@ TEST_F(TestTxCtxTable, test_tx_ctx_memtable_mgr)
ObSliceAlloc slice_allocator;
ObMemAttr attr;
attr.tenant_id_ = MTL_ID();
slice_allocator.init(TX_DATA_SLICE_SIZE, OB_MALLOC_NORMAL_BLOCK_SIZE, common::default_blk_alloc, attr);
slice_allocator.init(sizeof(ObTxData), OB_MALLOC_NORMAL_BLOCK_SIZE, common::default_blk_alloc, attr);
ObTxPalfParam palf_param((logservice::ObLogHandler *)(0x01));