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

remove tenant io manager hash in io manager

Browse Source
This commit is contained in:
nroskill
2024-02-09 08:52:00 +00:00
committed by ob-robot
parent 24f5ebe970
commit 4c24ed8d60
33 changed files with 250 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
unittest/storage/backup/test_backup_ctx.cpp
View File

@ -119,10 +119,14 @@ void TestBackupCtx::SetUp()
CHUNK_MGR.set_limit(8L * 1024L * 1024L * 1024L);
ret = ObTmpFileManager::get_instance().init();
EXPECT_EQ(OB_SUCCESS, ret);
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
inner_init_();
}

6
unittest/storage/backup/test_backup_index_merger.cpp
View File

@ -327,10 +327,14 @@ void TestBackupIndexMerger::SetUp()
} else {
ASSERT_EQ(OB_SUCCESS, ret);
}
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
inner_init_();
}

8
unittest/storage/backup/test_backup_iterator.cpp
View File

@ -116,10 +116,14 @@ void TestBackupIndexIterator::SetUp()
} else {
ASSERT_EQ(OB_SUCCESS, ret);
}
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
ASSERT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
inner_init_();
}

6
unittest/storage/backup/test_backup_tmp_file.cpp
View File

@ -68,10 +68,14 @@ void TestBackupTmpFile::SetUp()
CHUNK_MGR.set_limit(8L * 1024L * 1024L * 1024L);
ret = ObTmpFileManager::get_instance().init();
ASSERT_EQ(OB_SUCCESS, ret);
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
}
void TestBackupTmpFile::TearDown()

4
unittest/storage/backup/test_backup_utils.cpp
View File

@ -316,7 +316,11 @@ void TestBackupExternalSort::SetUp()
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
}
void TestBackupExternalSort::TearDown()

2
unittest/storage/blocksstable/ob_data_file_prepare.h
View File

@ -294,8 +294,6 @@ int TestDataFilePrepareUtil::open()
STORAGE_LOG(WARN, "Fail to init OB_STORE_CACHE, ", K(ret), K(storage_env_.data_dir_));
} else if (OB_FAIL(ObIOManager::get_instance().start())) {
STORAGE_LOG(WARN, "Fail to star io mgr", K(ret));
} else if (OB_FAIL(ObIOManager::get_instance().add_tenant_io_manager(OB_SERVER_TENANT_ID, io_config))) {
STORAGE_LOG(WARN, "add tenant io config failed", K(ret));
} else if (OB_FAIL(OB_SERVER_BLOCK_MGR.start(0/*reserver_size*/))) {
STORAGE_LOG(WARN, "Fail to start server block mgr", K(ret));
} else if (OB_FAIL(OB_SERVER_BLOCK_MGR.first_mark_device())) {

3
unittest/storage/blocksstable/ob_multi_version_sstable_test.h
View File

@ -237,9 +237,6 @@ void ObMultiVersionSSTableTest::SetUpTestCase()
ObServerCheckpointSlogHandler::get_instance().is_started_ = true;
//OK(init_io_device("multi_version_test"));
ObIOManager::get_instance().add_tenant_io_manager(
tenant_id_, ObTenantIOConfig::default_instance());
// create ls
ObLSHandle ls_handle;
ret = TestDmlCommon::create_ls(tenant_id_, ObLSID(ls_id_), ls_handle);

6
unittest/storage/blocksstable/test_bloom_filter_data.cpp
View File

@ -83,10 +83,14 @@ void TestBloomFilterDataReaderWriter::SetUp()
ret = row_generate_.init(table_schema_);
ASSERT_EQ(OB_SUCCESS, ret);
ASSERT_EQ(OB_SUCCESS, row_.init(allocator_, TEST_COLUMN_CNT));
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
}
void TestBloomFilterDataReaderWriter::TearDown()

6
unittest/storage/blocksstable/test_tmp_file.cpp
View File

@ -627,10 +627,14 @@ void TestTmpFile::SetUp()
CHUNK_MGR.set_limit(8L * 1024L * 1024L * 1024L);
ret = ObTmpFileManager::get_instance().init();
ASSERT_EQ(OB_SUCCESS, ret);
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
}
void TestTmpFile::TearDown()

6
unittest/storage/ddl/test_chunk_compact_store.cpp
View File

@ -186,10 +186,14 @@ void TestCompactChunk::SetUp()
CHUNK_MGR.set_limit(8L * 1024L * 1024L * 1024L);
ret = ObTmpFileManager::get_instance().init();
ASSERT_EQ(OB_SUCCESS, ret);
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
}
void TestCompactChunk::TearDown()

6
unittest/storage/direct_load/test_direct_load_data_block_writer.cpp
View File

@ -169,10 +169,14 @@ void TestDataBlockWriter::SetUp()
ret = ObTmpFileManager::get_instance().init();
ASSERT_EQ(OB_SUCCESS, ret);
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
}
void TestDataBlockWriter::TearDown()

6
unittest/storage/direct_load/test_direct_load_index_block_writer.cpp
View File

@ -136,10 +136,14 @@ void TestIndexBlockWriter::SetUp()
CHUNK_MGR.set_limit(8L * 1024L * 1024L * 1024L);
ret = ObTmpFileManager::get_instance().init();
ASSERT_EQ(OB_SUCCESS, ret);
static ObTenantBase tenant_ctx(1);
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
}
void TestIndexBlockWriter::TearDown()

6
unittest/storage/slog/test_storage_log_read_write.cpp
View File

@ -57,7 +57,7 @@ class TestStorageLogRW : public TestDataFilePrepare
public:
TestStorageLogRW()
: TestDataFilePrepare(&getter, "TestStorageLogRW"),
tenant_base1_(1),
tenant_base1_(OB_SERVER_TENANT_ID),
slogger_(nullptr)
{
}
@ -100,14 +100,12 @@ void TestStorageLogRW::SetUp()
SLOGGERMGR.init(dir_, MAX_FILE_SIZE, log_file_spec_);
ObStorageLogger *tmp_slogger = OB_NEW(ObStorageLogger, ObModIds::TEST);
ASSERT_EQ(OB_SUCCESS, tmp_slogger->init(SLOGGERMGR, 1));
ASSERT_EQ(OB_SUCCESS, tmp_slogger->init(SLOGGERMGR, OB_SERVER_TENANT_ID));
ASSERT_EQ(OB_SUCCESS, tmp_slogger->start());
tenant_base1_.set(tmp_slogger);
ObTenantEnv::set_tenant(&tenant_base1_);
ASSERT_EQ(OB_SUCCESS, tenant_base1_.init());
EXPECT_EQ(OB_SUCCESS, ObIOManager::get_instance().add_tenant_io_manager(
tenant_base1_.id(), ObTenantIOConfig::default_instance()));
slogger_ = MTL(ObStorageLogger*);
slogger_->start_log(start_cursor_);

4
unittest/storage/slog/test_storage_log_replay.cpp
View File

@ -73,10 +73,6 @@ void TestStorageLogReplay::SetUp()
TestDataFilePrepare::SetUp();
FileDirectoryUtils::create_full_path("./test_storage_log_replay");
SLOGGERMGR.init(dir_, MAX_FILE_SIZE, log_file_spec_);
static ObTenantBase tenant_ctx(10);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
}
void TestStorageLogReplay::TearDown()

124
unittest/storage/test_io_manager.cpp
View File

@ -20,6 +20,7 @@
#include "share/io/ob_io_calibration.h"
#include "share/io/io_schedule/ob_io_mclock.h"
#include "share/resource_manager/ob_cgroup_ctrl.h"
#include "mittest/mtlenv/mock_tenant_module_env.h"
#undef private
#include "share/ob_local_device.h"
#include "lib/thread/thread_pool.h"
@ -38,13 +39,12 @@ using namespace oceanbase::common;
using namespace oceanbase::share;
using namespace oceanbase::blocksstable;
#define TEST_ROOT_DIR "io_test"
#define TEST_ROOT_DIR "./"
#define TEST_DATA_DIR TEST_ROOT_DIR "/data_dir"
#define TEST_SSTABLE_DIR TEST_DATA_DIR "/sstable"
static const int64_t IO_MEMORY_LIMIT = 10L * 1024L * 1024L * 1024L;
static const uint64_t TEST_TENANT_ID = 1001;
static const uint64_t TEST_TENANT_ID = 1;
int init_device(const int64_t media_id, ObLocalDevice &device)
{
@ -54,8 +54,8 @@ int init_device(const int64_t media_id, ObLocalDevice &device)
const int64_t data_disk_size = 1024L * 1024L * 1024L; // 1GB
const int64_t data_disk_percentage = 50L;
ObIODOpt io_opts[IO_OPT_COUNT];
io_opts[0].key_ = "data_dir"; io_opts[0].value_.value_str = TEST_DATA_DIR;
io_opts[1].key_ = "sstable_dir"; io_opts[1].value_.value_str = TEST_SSTABLE_DIR;
io_opts[0].key_ = "data_dir"; io_opts[0].value_.value_str = oceanbase::MockTenantModuleEnv::get_instance().storage_env_.data_dir_;
io_opts[1].key_ = "sstable_dir"; io_opts[1].value_.value_str = oceanbase::MockTenantModuleEnv::get_instance().storage_env_.sstable_dir_;
io_opts[2].key_ = "block_size"; io_opts[2].value_.value_int64 = block_size;
io_opts[3].key_ = "datafile_disk_percentage"; io_opts[3].value_.value_int64 = data_disk_percentage;
io_opts[4].key_ = "datafile_size"; io_opts[4].value_.value_int64 = data_disk_size;
@ -80,7 +80,6 @@ int init_device(const int64_t media_id, ObLocalDevice &device)
return ret;
}
class TestIOStruct : public ::testing::Test
{
public:
@ -90,17 +89,14 @@ static void SetUpTestCase()
system("mkdir -p " TEST_DATA_DIR);
system("mkdir -p " TEST_SSTABLE_DIR);
ASSERT_SUCC(oceanbase::MockTenantModuleEnv::get_instance().init());
ObMallocAllocator::get_instance()->create_and_add_tenant_allocator(1001);
ObMallocAllocator::get_instance()->create_and_add_tenant_allocator(1002);
// init io device
static oceanbase::share::ObLocalDevice local_device;
ASSERT_SUCC(init_device(0, local_device));
THE_IO_DEVICE = &local_device;
ObMallocAllocator::get_instance()->get_tenant_ctx_allocator(OB_SERVER_TENANT_ID, 0)->set_limit(IO_MEMORY_LIMIT);
}
static void TearDownTestCase()
{
THE_IO_DEVICE->destroy();
ObMallocAllocator::get_instance()->recycle_tenant_allocator(1001);
ObMallocAllocator::get_instance()->recycle_tenant_allocator(1002);
}
@ -302,10 +298,9 @@ TEST_F(TestIOStruct, IOAllocator)
TEST_F(TestIOStruct, IORequest)
{
ObTenantIOManager tenant_io_mgr;
tenant_io_mgr.inc_ref();
ASSERT_SUCC(tenant_io_mgr.io_allocator_.init(TEST_TENANT_ID, IO_MEMORY_LIMIT));
ObRefHolder<ObTenantIOManager> holder(&tenant_io_mgr);
ObRefHolder<ObTenantIOManager> holder;
OB_IO_MANAGER.get_tenant_io_manager(OB_SERVER_TENANT_ID, holder);
ObTenantIOManager &tenant_io_mgr = *(holder.get_ptr());
ObIOFd fd;
fd.first_id_ = 0;
fd.second_id_ = 1;
@ -544,10 +539,7 @@ TEST_F(TestIOStruct, IOScheduler)
ObIOAllocator io_allocator;
ASSERT_SUCC(io_allocator.init(TEST_TENANT_ID, IO_MEMORY_LIMIT));
ASSERT_TRUE(io_config.is_valid());
ObIOScheduler scheduler(io_config, io_allocator);
ASSERT_FALSE(scheduler.is_inited_);
ASSERT_SUCC(scheduler.init(2));
ASSERT_TRUE(scheduler.is_inited_);
ObIOScheduler &scheduler = *(OB_IO_MANAGER.get_scheduler());
// test schedule
ObIOResult result;
@ -654,17 +646,15 @@ TEST_F(TestIOStruct, Test_Size)
TEST_F(TestIOStruct, IOResult)
{
ObTenantIOManager tenant_io_mgr;
tenant_io_mgr.inc_ref();
ASSERT_SUCC(tenant_io_mgr.io_allocator_.init(TEST_TENANT_ID, IO_MEMORY_LIMIT));
ObRefHolder<ObTenantIOManager> holder(&tenant_io_mgr);
ObRefHolder<ObTenantIOManager> holder;
ASSERT_SUCC(OB_IO_MANAGER.get_tenant_io_manager(TEST_TENANT_ID, holder));
ObIOFd fd;
fd.first_id_ = 0;
fd.second_id_ = 1;
void *result_buf = tenant_io_mgr.io_allocator_.alloc(sizeof(ObIOResult));
void *result_buf = holder.get_ptr()->io_allocator_.alloc(sizeof(ObIOResult));
ObIOResult *result = new (result_buf) ObIOResult;
void *req_buf = tenant_io_mgr.io_allocator_.alloc(sizeof(ObIORequest));
void *req_buf = holder.get_ptr()->io_allocator_.alloc(sizeof(ObIORequest));
ObIORequest *req = new (req_buf) ObIORequest;
@ -677,8 +667,8 @@ TEST_F(TestIOStruct, IOResult)
// prepare test read request
req->destroy();
result->destroy();
req->tenant_io_mgr_.hold(&tenant_io_mgr);
result->tenant_io_mgr_.hold(&tenant_io_mgr);
req->tenant_io_mgr_.hold(holder.get_ptr());
result->tenant_io_mgr_.hold(holder.get_ptr());
result->inc_ref();
req->inc_ref();
@ -763,12 +753,8 @@ TEST_F(TestIOStruct, IOCallbackManager)
TEST_F(TestIOStruct, IOFaultDetector)
{
// test init
ObIOConfig io_config = ObIOConfig::default_config();
ObIOFaultDetector detector(io_config);
ASSERT_FALSE(detector.is_inited_);
ASSERT_SUCC(detector.init());
ASSERT_TRUE(detector.is_inited_);
ObIOFaultDetector &detector = OB_IO_MANAGER.get_device_health_detector();
ObIOConfig &io_config = (ObIOConfig &)detector.io_config_;
// test get device health
ObDeviceHealthStatus dhs = DEVICE_HEALTH_NORMAL;
@ -777,10 +763,6 @@ TEST_F(TestIOStruct, IOFaultDetector)
ASSERT_TRUE(DEVICE_HEALTH_NORMAL == dhs);
ASSERT_TRUE(0 == disk_abnormal_time);
// test start
ASSERT_SUCC(detector.start());
ObIOManager::get_instance().is_working_ = true;
// test read failure detection
ObIOInfo io_info = get_random_io_info();
ObIOResult result;
@ -827,35 +809,27 @@ TEST_F(TestIOStruct, IOFaultDetector)
ASSERT_SUCC(detector.get_device_health_status(dhs, disk_abnormal_time));
ASSERT_TRUE(DEVICE_HEALTH_ERROR == dhs);
ASSERT_TRUE(disk_abnormal_time > 0);
// test destroy
detector.destroy();
ASSERT_FALSE(detector.is_inited_);
}
TEST_F(TestIOStruct, IOManager)
{
ObIOManager io_mgr;
ASSERT_FALSE(io_mgr.is_inited_);
ASSERT_SUCC(io_mgr.init());
ASSERT_TRUE(io_mgr.is_inited_);
ASSERT_SUCC(io_mgr.start());
io_mgr.stop();
io_mgr.destroy();
ASSERT_FALSE(io_mgr.is_inited_);
}
class TestIOManager : public TestIOStruct
{
// basic use resource manager
public:
static void SetUpTestCase()
{
}
static void TearDownTestCase()
{
oceanbase::MockTenantModuleEnv::get_instance().destroy();
}
virtual void SetUp()
{
ObIOManager::get_instance().destroy();
OB_IO_MANAGER.destroy();
const int64_t memory_limit = 10L * 1024L * 1024L * 1024L; // 10GB
ASSERT_SUCC(ObIOManager::get_instance().init(memory_limit));
ASSERT_SUCC(ObIOManager::get_instance().start());
ASSERT_SUCC(OB_IO_MANAGER.init(memory_limit));
ASSERT_SUCC(OB_IO_MANAGER.start());
// add io device
ASSERT_SUCC(OB_IO_MANAGER.add_device_channel(THE_IO_DEVICE, 16, 2, 1024));
@ -871,20 +845,18 @@ public:
io_config.other_group_config_.min_percent_ = 100;
io_config.other_group_config_.max_percent_ = 100;
io_config.other_group_config_.weight_percent_ = 100;
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(tenant_id, io_config));
}
virtual void TearDown()
{
ObIOManager::get_instance().stop();
ObIOManager::get_instance().destroy();
OB_IO_MANAGER.stop();
OB_IO_MANAGER.destroy();
}
};
TEST_F(TestIOManager, memory_pool)
{
ObIOManager &io_mgr = ObIOManager::get_instance();
ObRefHolder<ObTenantIOManager> tenant_holder;
ASSERT_SUCC(io_mgr.get_tenant_io_manager(500, tenant_holder));
ASSERT_SUCC(OB_IO_MANAGER.get_tenant_io_manager(500, tenant_holder));
ASSERT_NE(nullptr, tenant_holder.get_ptr());
ObIORequest *io_request = nullptr;
@ -893,6 +865,7 @@ TEST_F(TestIOManager, memory_pool)
io_request->tenant_io_mgr_.hold(tenant_holder.get_ptr());
ASSERT_TRUE(tenant_holder.get_ptr()->io_request_pool_.contain(io_request));
ASSERT_SUCC(tenant_holder.get_ptr()->io_request_pool_.recycle(io_request));
io_request->tenant_io_mgr_.reset();
ObIOResult *io_result = nullptr;
ASSERT_SUCC(tenant_holder.get_ptr()->io_result_pool_.alloc(io_result));
@ -900,12 +873,14 @@ TEST_F(TestIOManager, memory_pool)
io_result->tenant_io_mgr_.hold(tenant_holder.get_ptr());
ASSERT_TRUE(tenant_holder.get_ptr()->io_result_pool_.contain(io_result));
ASSERT_SUCC(tenant_holder.get_ptr()->io_result_pool_.recycle(io_result));
io_result->tenant_io_mgr_.reset();
void *result_buf = tenant_holder.get_ptr()->io_allocator_.alloc(sizeof(ObIOResult));
ObIOResult *result1 = new (result_buf) ObIOResult;
result1->tenant_io_mgr_.hold(tenant_holder.get_ptr());
ASSERT_FALSE(tenant_holder.get_ptr()->io_result_pool_.contain(result1));
ASSERT_FAIL(tenant_holder.get_ptr()->io_result_pool_.recycle(result1));
result1->~ObIOResult();
tenant_holder.get_ptr()->io_allocator_.free(result1);
void *req_buf = tenant_holder.get_ptr()->io_allocator_.alloc(sizeof(ObIORequest));
@ -913,6 +888,7 @@ TEST_F(TestIOManager, memory_pool)
req1->tenant_io_mgr_.hold(tenant_holder.get_ptr());
ASSERT_FALSE(tenant_holder.get_ptr()->io_request_pool_.contain(req1));
ASSERT_FAIL(tenant_holder.get_ptr()->io_request_pool_.recycle(req1));
req1->~ObIORequest();
tenant_holder.get_ptr()->io_allocator_.free(req1);
}
@ -1277,8 +1253,6 @@ TEST_F(TestIOManager, tenant)
{
ObTenantIOConfig default_config = ObTenantIOConfig::default_instance();
default_config.unit_config_.max_iops_ = 20000L;
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(1001, default_config));
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(1002, default_config));
int64_t current_ts = ObTimeUtility::fast_current_time();
IOPerfLoad load;
load.group_id_ = 0;
@ -1303,8 +1277,6 @@ TEST_F(TestIOManager, tenant)
IOPerfRunner runner;
ASSERT_SUCC(runner.init(current_ts, load));
usleep(2L * 1000L * 1000L); // 2s
ASSERT_SUCC(OB_IO_MANAGER.remove_tenant_io_manager(1002));
ASSERT_SUCC(OB_IO_MANAGER.remove_tenant_io_manager(1001));
runner.wait();
runner.destroy();
}
@ -1348,7 +1320,6 @@ TEST_F(TestIOManager, perf)
for (int64_t i = 0; i < perf_tenants.count(); ++i) {
IOPerfTenant &curr_config = perf_tenants.at(i);
LOG_INFO("wenqu: tenant config", K(curr_config), K(i));
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(curr_config.tenant_id_, curr_config.config_));
ObRefHolder<ObTenantIOManager> tenant_holder;
ASSERT_SUCC(OB_IO_MANAGER.get_tenant_io_manager(curr_config.tenant_id_, tenant_holder));
ASSERT_SUCC(tenant_holder.get_ptr()->refresh_group_io_config());
@ -1422,7 +1393,6 @@ TEST_F(TestIOManager, alloc_memory)
for (int64_t i = 0; i < perf_tenants.count(); ++i) {
IOPerfTenant &curr_config = perf_tenants.at(i);
curr_config.config_.memory_limit_ = 16L* 1024L * 1024L; //16MB
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(curr_config.tenant_id_, curr_config.config_));
ObRefHolder<ObTenantIOManager> tenant_holder;
ASSERT_SUCC(OB_IO_MANAGER.get_tenant_io_manager(curr_config.tenant_id_, tenant_holder));
ASSERT_SUCC(tenant_holder.get_ptr()->refresh_group_io_config());
@ -1493,7 +1463,6 @@ TEST_F(TestIOManager, IOTracer)
for (int64_t i = 0; i < perf_tenants.count(); ++i) {
IOPerfTenant &curr_config = perf_tenants.at(i);
LOG_INFO("wenqu: tenant config", K(curr_config), K(i));
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(curr_config.tenant_id_, curr_config.config_));
ObRefHolder<ObTenantIOManager> tenant_holder;
ASSERT_SUCC(OB_IO_MANAGER.get_tenant_io_manager(curr_config.tenant_id_, tenant_holder));
ASSERT_SUCC(tenant_holder.get_ptr()->refresh_group_io_config());
@ -1580,7 +1549,6 @@ TEST_F(TestIOManager, ModifyIOPS)
for (int64_t i = 0; i < perf_tenants.count(); ++i) {
IOPerfTenant &curr_config = perf_tenants.at(i);
LOG_INFO("wenqu: tenant config", K(curr_config), K(i));
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(curr_config.tenant_id_, curr_config.config_));
ObRefHolder<ObTenantIOManager> tenant_holder;
ASSERT_SUCC(OB_IO_MANAGER.get_tenant_io_manager(curr_config.tenant_id_, tenant_holder));
ASSERT_SUCC(tenant_holder.get_ptr()->refresh_group_io_config());
@ -1667,7 +1635,6 @@ TEST_F(TestIOManager, ModifyCallbackThread)
for (int64_t i = 0; i < perf_tenants.count(); ++i) {
IOPerfTenant &curr_config = perf_tenants.at(i);
LOG_INFO("wenqu: tenant config", K(curr_config), K(i));
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(curr_config.tenant_id_, curr_config.config_));
ObRefHolder<ObTenantIOManager> tenant_holder;
ASSERT_SUCC(OB_IO_MANAGER.get_tenant_io_manager(curr_config.tenant_id_, tenant_holder));
ASSERT_SUCC(tenant_holder.get_ptr()->refresh_group_io_config());
@ -1752,7 +1719,6 @@ TEST_F(TestIOManager, ModifyGroupIO)
IOPerfTenant &curr_config = perf_tenants.at(i);
if (curr_config.tenant_id_ == 1002) {
LOG_INFO("qilu: tenant config", K(curr_config), K(i));
ASSERT_SUCC(OB_IO_MANAGER.add_tenant_io_manager(curr_config.tenant_id_, curr_config.config_));
ObRefHolder<ObTenantIOManager> tenant_holder;
ASSERT_SUCC(OB_IO_MANAGER.get_tenant_io_manager(curr_config.tenant_id_, tenant_holder));
ASSERT_SUCC(tenant_holder.get_ptr()->refresh_group_io_config());
@ -1892,15 +1858,15 @@ void write_group_perf_config()
"1 0 8 1 64 1 ./perf_test\n"
"\n"
"tenant_id min_iops max_iops weight group\n"
"1001 5000 100000 700 10001: testgroup1: 80, 100, 60; 10002: testgroup2: 10, 60, 30; 0: OTHER_GROUPS: 10, 100, 10;\n"
"1002 1000 50000 1000 12345: testgroup1: 50, 50, 50; 0: OTHER_GROUPS: 50, 50, 50;\n"
"1 5000 100000 700 10001: testgroup1: 80, 100, 60; 10002: testgroup2: 10, 60, 30; 0: OTHER_GROUPS: 10, 100, 10;\n"
"500 1000 50000 1000 12345: testgroup1: 50, 50, 50; 0: OTHER_GROUPS: 50, 50, 50;\n"
"\n"
"tenant_id device_id group io_mode io_size_byte io_depth perf_mode target_iops thread_count is_sequence start_s stop_s\n"
"1001 1 0 r 16384 10 rolling 0 16 0 0 8\n"
"1001 1 10001 r 16384 10 rolling 0 16 0 2 7\n"
"1001 1 10002 r 16384 10 rolling 0 16 0 0 6\n"
"1002 1 0 r 16384 100 rolling 0 16 0 0 10\n"
"1002 1 12345 r 16384 100 rolling 0 16 0 0 10\n"
"1 1 0 r 16384 10 rolling 0 16 0 0 8\n"
"1 1 10001 r 16384 10 rolling 0 16 0 2 7\n"
"1 1 10002 r 16384 10 rolling 0 16 0 0 6\n"
"500 1 0 r 16384 100 rolling 0 16 0 0 10\n"
"500 1 12345 r 16384 100 rolling 0 16 0 0 10\n"
;
const int64_t file_len = strlen(file_buf);
int write_ret = ::write(fd, file_buf, file_len);

4
unittest/storage/test_parallel_external_sort.cpp
View File

@ -190,7 +190,11 @@ void TestParallelExternalSort::SetUp()
static ObTenantBase tenant_ctx(OB_SYS_TENANT_ID);
ObTenantEnv::set_tenant(&tenant_ctx);
ObTenantIOManager *io_service = nullptr;
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_new(io_service));
EXPECT_EQ(OB_SUCCESS, ObTenantIOManager::mtl_init(io_service));
EXPECT_EQ(OB_SUCCESS, io_service->start());
tenant_ctx.set(io_service);
ObTenantEnv::set_tenant(&tenant_ctx);
}
void TestParallelExternalSort::TearDown()